server/queries2.c

   1 /* This file defines the query dispatch table for version 2 of the protocol
   2  *
   3  * $Header$
   4  *
   5  * Copyright 1987, 1988 by the Massachusetts Institute of Technology.
   6  * For copying and distribution information, please see the file
   7  * <mit-copyright.h>.
   8  */
   9
  10 #include <mit-copyright.h>
  11 #include "mr_server.h"
  12 #undef ACE_TYPE
  13 #undef ACE_NAME
  14 #undef NAME
  15 #include "query.h"
  16 #include "mr_et.h"
  17
  18 /* Specialized Support Query Routines */
  19
  20 /* Special Access Check Routines */
  21 int access_user();
  22 int access_login();
  23 int access_list();
  24 int access_visible_list();
  25 int access_vis_list_by_name();
  26 int access_member();
  27 int access_qgli();
  28 int access_service();
  29 int access_filesys();
  30 int access_host();
  31 int access_ahal();
  32 int access_snt();
  33
  34 /* Query Setup Routines */
  35 int prefetch_value();
  36 int prefetch_filesys();
  37 int setup_ausr();
  38 int setup_dusr();
  39 int setup_spop();
  40 int setup_dpob();
  41 int setup_dmac();
  42 int setup_dsnet();
  43 int setup_dclu();
  44 int setup_alis();
  45 int setup_dlis();
  46 int setup_dsin();
  47 int setup_dshi();
  48 int setup_afil();
  49 int setup_ufil();
  50 int setup_dfil();
  51 int setup_aftg();
  52 int setup_dnfp();
  53 int setup_dqot();
  54 int setup_akum();
  55 int setup_dsnt();
  56 int setup_ahst();
  57 int setup_ahal();
  58
  59 /* Query Followup Routines */
  60 int followup_fix_modby();
  61 int followup_ausr();
  62 int followup_gpob();
  63 int followup_glin();
  64 int followup_aqot();
  65 int followup_dqot();
  66 int followup_gzcl();
  67 int followup_gsha();
  68 int followup_gqot();
  69 int followup_gpce();
  70 int followup_guax();
  71 int followup_uuac();
  72 int followup_gsnt();
  73 int followup_ghst();
  74
  75 int set_modtime();
  76 int set_modtime_by_id();
  77 int set_finger_modtime();
  78 int set_pobox_modtime();
  79 int set_uppercase_modtime();
  80 int set_mach_modtime_by_id();
  81 int set_cluster_modtime_by_id();
  82 int set_serverhost_modtime();
  83 int set_nfsphys_modtime();
  84 int set_filesys_modtime();
  85 int set_zephyr_modtime();
  86
  87 /* Special Queries */
  88 int set_pobox();
  89 int get_list_info();
  90 int add_member_to_list();
  91 int delete_member_from_list();
  92 int get_ace_use();
  93 int qualified_get_lists();
  94 int get_members_of_list();
  95 int get_end_members_of_list();
  96 int qualified_get_server();
  97 int qualified_get_serverhost();
  98 int trigger_dcm();
  99 int count_members_of_list();
 100 int get_lists_of_member();
 101 int register_user();
 102 int _sdl_followup();
 103
 104
 105 \f
 106 /* String compression
 107  * These are commonly used strings in the table, defined here so that
 108  * they can be shared.
 109  */
 110
 111 static char ACE_NAME[] = "ace_name";
 112 static char ACE_TYPE[] = "ace_type";
 113 static char ADDRESS[] = "address";
 114 static char ALIAS[] = "alias";
 115 static char CLASS[] = "class";
 116 static char CLU_ID[] = "clu_id";
 117 static char CLUSTER[] = "clusters";
 118 static char COMMENTS[] = "comments";
 119 static char DESC[] = "description";
 120 static char DEVICE[] = "device";
 121 static char DIR[] = "dir";
 122 static char FILESYS[] = "filesys";
 123 static char FILSYS_ID[] = "filsys_id";
 124 static char FIRST[] = "first";
 125 static char HOSTACCESS[] = "hostaccess";
 126 static char LABEL[] = "label";
 127 static char LAST[] = "last";
 128 static char LIST[] = "list";
 129 static char LIST_ID[] = "list_id";
 130 static char LOCATION[] = "location";
 131 static char LOGIN[] = "login";
 132 static char MACH_ID[] = "mach_id";
 133 static char MACHINE[] = "machine";
 134 static char MIDDLE[] = "middle";
 135 static char MIT_ID[] = "clearid";
 136 static char MOD1[] = "modtime";
 137 static char MOD2[] = "modby";
 138 static char MOD3[] = "modwith";
 139 static char NAME[] = "name";
 140 static char PRINTCAP[] = "printcap";
 141 static char QUOTA[] = "quota";
 142 static char QUOTA_TYPE[] = "quota_type";
 143 static char SECURE[] = "secure";
 144 static char SERVICE[] = "service";
 145 static char SERVERS[] = "servers";
 146 static char SHELL[] = "shell";
 147 static char SIGNATURE[] = "signature";
 148 static char SNET_ID[] = "snet_id";
 149 static char SUBNET[] = "subnet";
 150 static char STATUS[] = "status";
 151 static char TYPE[] = "type";
 152 static char USERS[] = "users";
 153 static char USERS_ID[] = "users_id";
 154 static char UID[] = "unix_uid";
 155 static char ZEPH[] = "zephyr";
 156 static char ZEPH_ID[] = "xmt_id";
 157
 158 /* Table Names */
 159 char *table_name[] = {
 160   "none", USERS, "krbmap", MACHINE, "hostalias", SUBNET, CLUSTER,
 161   "mcmap", "svc", LIST, "imembers", SERVERS, "serverhosts", FILESYS,
 162   "fsgroup", "nfsphys", "quota", ZEPH, HOSTACCESS, "strings", "services",
 163   PRINTCAP, "palladium", "capacls", "alias", "numvalues", "tblstats",
 164   "incremental"};
 165 int num_tables = 27;
 166
 167
 168 /* VALOBJS
 169  * These are commonly used validation objects, defined here so that they
 170  * can be shared.
 171  */
 172
 173 /*
 174  * A word about validation objects and locking:  The validation object
 175  * for a query should also request locks on behalf of the pre-processing
 176  * and post-processing routines.  This helps to ensure that tables are
 177  * accessed and locked in the proper order and thus avoids deadlock
 178  * situations
 179  */
 180
 181 static struct valobj VOsort0[] = {
 182   {V_SORT, 0},
 183 };
 184
 185 static struct valobj VOwild0[] = {
 186   {V_WILD, 0},
 187 };
 188
 189 static struct valobj VOupwild0[] = {
 190   {V_UPWILD, 0},
 191 };
 192
 193 static struct valobj VOwild0sort[] = {
 194   {V_WILD, 0},
 195   {V_SORT, 0},
 196 };
 197
 198 static struct valobj VOupwild0sort[] = {
 199   {V_UPWILD, 0},
 200   {V_SORT, 0},
 201 };
 202
 203 static struct valobj VOwild01sort0[] = {
 204   {V_WILD, 0},
 205   {V_WILD, 1},
 206   {V_SORT, 0},
 207 };
 208
 209 static struct valobj VOwild01sort01[] = {
 210   {V_WILD, 0},
 211   {V_WILD, 1},
 212   {V_SORT, 0},
 213   {V_SORT, 1},
 214 };
 215
 216 static struct valobj VOwild012sort0[] = {  /* get_alias */
 217   {V_WILD, 0},
 218   {V_WILD, 1},
 219   {V_WILD, 2},
 220   {V_SORT, 0},
 221 };
 222
 223
 224 static struct valobj VOuser0[] = {
 225   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 226 };
 227
 228
 229 static struct valobj VOuser0lock[] = {
 230   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 231   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 232 };
 233
 234 static struct valobj VOmach0[] = {
 235   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
 236 };
 237
 238 static struct valobj VOclu0[] = {
 239   {V_ID, 0, CLUSTER_TABLE, NAME, CLU_ID, MR_CLUSTER},
 240 };
 241
 242 static struct valobj VOlist0[] = {
 243   {V_ID, 0, LIST_TABLE, NAME, LIST_ID, MR_LIST},
 244 };
 245
 246
 247 static struct valobj VOchar0[] = {
 248   {V_CHAR, 0},
 249 };
 250
 251
 252
 253 static struct valobj VOfilsys0user1[] = {
 254   {V_LOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
 255   {V_ID, 0, FILESYS_TABLE, LABEL, FILSYS_ID, MR_FILESYS},
 256   {V_ID, 1, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 257 };
 258
 259
 260 /* Validations
 261  * Commonly used validation records defined here so that they may
 262  * be shared.
 263  */
 264
 265 static struct validate VDmach = { VOmach0, 1 };
 266 static struct validate VDwild0= { VOwild0, 1 };
 267 static struct validate VDupwild0= { VOupwild0, 1 };
 268 static struct validate VDwild2sort2 = { VOwild01sort01,4 };
 269 static struct validate VDwild3sort1 = { VOwild012sort0,4 };
 270 static struct validate VDsortf = {
 271   VOsort0,
 272   1,
 273   0,
 274   0,
 275   0,
 276   0,
 277   0,
 278   0,
 279   followup_fix_modby,
 280 };
 281
 282 static struct validate VDwildsortf = {
 283   VOwild0sort,
 284   2,
 285   0,
 286   0,
 287   0,
 288   0,
 289   0,
 290   0,
 291   followup_fix_modby,
 292 };
 293 static struct validate VDsort0= { VOsort0, 1 };
 294
 295
 296 static struct validate VDupwildsortf = {
 297   VOupwild0sort,
 298   2,
 299   0,
 300   0,
 301   0,
 302   0,
 303   0,
 304   0,
 305   followup_fix_modby,
 306 };
 307 /* Query data */
 308
 309 static char *galo_fields[] = {
 310   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE,
 311 };
 312
 313 static char *gual_fields[] = {
 314   LOGIN,
 315   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 316   MIT_ID, CLASS, COMMENTS, SIGNATURE, SECURE, MOD1, MOD2, MOD3,
 317 };
 318
 319 static char *gubl_fields[] = {
 320   LOGIN,
 321   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 322   MIT_ID, CLASS, MOD1, MOD2, MOD3,
 323 };
 324
 325 static struct validate gubl_validate =
 326 {
 327   VOwild0sort,
 328   2,
 329   0,
 330   0,
 331   0,
 332   0,
 333   access_login,
 334   0,
 335   followup_guax,
 336 };
 337
 338 static char *guau_fields[] = {
 339   UID,
 340   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 341   MIT_ID, CLASS, COMMENTS, SIGNATURE, SECURE, MOD1, MOD2, MOD3,
 342 };
 343
 344 static char *guan_fields[] = {
 345   FIRST, LAST,
 346   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 347   MIT_ID, CLASS, COMMENTS, SIGNATURE, SECURE, MOD1, MOD2, MOD3,
 348 };
 349
 350 static struct validate guan_validate =
 351 {
 352   VOwild01sort01,
 353   4,
 354   0,
 355   0,
 356   0,
 357   0,
 358   0,
 359   0,
 360   followup_guax,
 361 };
 362
 363 static char *guac_fields[] = {
 364   CLASS,
 365   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 366   MIT_ID, CLASS, COMMENTS, SIGNATURE, SECURE, MOD1, MOD2, MOD3,
 367 };
 368
 369 static char *guam_fields[] = {
 370   MIT_ID,
 371   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 372   MIT_ID, CLASS, COMMENTS, SIGNATURE, SECURE, MOD1, MOD2, MOD3,
 373 };
 374
 375 static char *gubu_fields[] = {
 376   UID,
 377   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 378   MIT_ID, CLASS, MOD1, MOD2, MOD3,
 379 };
 380
 381 static struct validate gubu_validate =
 382 {
 383   VOsort0,
 384   1,
 385   0,
 386   0,
 387   0,
 388   0,
 389   access_login,
 390   0,
 391   followup_fix_modby,
 392 };
 393
 394 static char *gubn_fields[] = {
 395   FIRST, LAST,
 396   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 397   MIT_ID, CLASS, MOD1, MOD2, MOD3,
 398 };
 399
 400 static struct validate gubn_validate =
 401 {
 402   VOwild01sort0,
 403   3,
 404   0,
 405   0,
 406   0,
 407   0,
 408   0,
 409   0,
 410   followup_fix_modby,
 411 };
 412
 413 static char *gubc_fields[] = {
 414   CLASS,
 415   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 416   MIT_ID, CLASS, MOD1, MOD2, MOD3,
 417 };
 418
 419 static char *gubm_fields[] = {
 420   MIT_ID,
 421   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 422   MIT_ID, CLASS, MOD1, MOD2, MOD3,
 423 };
 424
 425 static char *auac_fields[] = {
 426   LOGIN, UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 427   MIT_ID, CLASS, COMMENTS, SIGNATURE, SECURE,
 428 };
 429
 430 static struct valobj auac_valobj[] = {
 431   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 432   {V_CHAR, 0, USERS_TABLE, LOGIN},
 433   {V_CHAR, 2, USERS_TABLE, SHELL},
 434   {V_CHAR, 3, USERS_TABLE, LAST},
 435   {V_CHAR, 4, USERS_TABLE, FIRST},
 436   {V_CHAR, 5, USERS_TABLE, MIDDLE},
 437   {V_CHAR, 7, USERS_TABLE, MIT_ID},
 438   {V_TYPE, 8, 0, CLASS, 0, MR_BAD_CLASS},
 439   {V_ID, 9, STRINGS_TABLE, "string", "string_id", MR_NO_MATCH},
 440 };
 441
 442 static struct validate auac_validate = {
 443   auac_valobj,
 444   9,
 445   LOGIN,
 446   "login = '%s'",
 447   1,
 448   USERS_ID,
 449   0,
 450   setup_ausr,
 451   followup_ausr,
 452 };
 453
 454 static struct validate ausr_validate = {
 455   auac_valobj,
 456   8,
 457   LOGIN,
 458   "login = '%s'",
 459   1,
 460   USERS_ID,
 461   0,
 462   setup_ausr,
 463   followup_ausr,
 464 };
 465
 466 static char *rusr_fields[] = {
 467   UID, LOGIN, "fs_type"
 468 };
 469
 470 static struct valobj rusr_valobj[] = {
 471   {V_LOCK, 0, IMEMBERS_TABLE, 0, LIST_ID, MR_DEADLOCK},
 472   {V_LOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
 473   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 474   {V_RLOCK, 0, MACHINE_TABLE, 0,MACH_ID, MR_DEADLOCK},
 475   {V_LOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
 476   {V_LOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
 477   {V_LOCK, 0, QUOTA_TABLE,0, FILSYS_ID, MR_DEADLOCK},
 478   {V_RLOCK,0, SERVERHOSTS_TABLE,0, MACH_ID, MR_DEADLOCK},
 479 };
 480
 481 static struct validate rusr_validate = {
 482   rusr_valobj,
 483   8,
 484   0,
 485   0,
 486   0,
 487   0,
 488   0,
 489   register_user,
 490   0,
 491 };
 492
 493 static char *uuac_fields[] = {
 494   LOGIN,
 495   "newlogin", UID, SHELL, LAST, FIRST, MIDDLE, STATUS,
 496   MIT_ID, CLASS, COMMENTS, SIGNATURE, SECURE,
 497 };
 498
 499 static struct valobj uuac_valobj[] = {
 500   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 501   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 502   {V_RENAME, 1, USERS_TABLE, LOGIN, USERS_ID, MR_NOT_UNIQUE},
 503   {V_CHAR, 3, USERS_TABLE, SHELL},
 504   {V_CHAR, 4, USERS_TABLE, FIRST},
 505   {V_CHAR, 5, USERS_TABLE, LAST},
 506   {V_CHAR, 6, USERS_TABLE, MIDDLE},
 507   {V_CHAR, 8, USERS_TABLE, MIT_ID},
 508   {V_TYPE, 9, 0, CLASS, 0, MR_BAD_CLASS},
 509   {V_ID, 10, STRINGS_TABLE, "string", "string_id", MR_NO_MATCH},
 510 };
 511
 512 static struct validate uuac_validate = {
 513   uuac_valobj,
 514   10,
 515   0,
 516   0,
 517   0,
 518   USERS_ID,
 519   0,
 520   setup_ausr,
 521   followup_uuac,
 522 };
 523
 524 static struct validate uusr_validate = {
 525   uuac_valobj,
 526   10,
 527   0,
 528   0,
 529   0,
 530   USERS_ID,
 531   0,
 532   setup_ausr,
 533   set_modtime_by_id,
 534 };
 535
 536 static char *uush_fields[] = {
 537   LOGIN,
 538   SHELL,
 539 };
 540
 541 static struct valobj uush_valobj[] = {
 542   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 543   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 544   {V_CHAR, 1, USERS_TABLE, SHELL},
 545 };
 546
 547 static struct validate uush_validate = {
 548   uush_valobj,
 549   3,
 550   0,
 551   0,
 552   0,
 553   USERS_ID,
 554   access_user,
 555   0,
 556   set_modtime_by_id,
 557 };
 558
 559 static char *uust_fields[] = {
 560   LOGIN,
 561   STATUS,
 562 };
 563
 564 static char *uuss_fields[] = {
 565   LOGIN,
 566   SECURE,
 567 };
 568
 569 static struct validate uust_validate = {
 570   VOuser0lock,
 571   2,
 572   0,
 573   0,
 574   0,
 575   USERS_ID,
 576   0,
 577   0,
 578   set_modtime_by_id,
 579 };
 580
 581 static char *dusr_fields[] = {
 582   LOGIN,
 583 };
 584
 585 struct valobj dusr_valobj[]= {
 586   {V_LOCK, 0, IMEMBERS_TABLE, 0, LIST_ID, MR_DEADLOCK},
 587   {V_LOCK, 0, FILESYS_TABLE, 0,  FILSYS_ID, MR_DEADLOCK},
 588   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 589   {V_LOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
 590   {V_LOCK, 0, QUOTA_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
 591   {V_LOCK, 0, HOSTACCESS_TABLE, 0, MACH_ID, MR_DEADLOCK},
 592   {V_LOCK, 0, KRBMAP_TABLE, 0, "users_id", MR_DEADLOCK},
 593   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 594 };
 595
 596 static struct validate dusr_validate = {
 597   dusr_valobj,
 598   8,
 599   0,
 600   0,
 601   0,
 602   0,
 603   0,
 604   setup_dusr,
 605   0,
 606 };
 607
 608 static char *dubu_fields[] = {
 609   UID,
 610 };
 611
 612 static struct valobj dubu_valobj[] = {
 613   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 614   {V_ID, 0, USERS_TABLE, UID, USERS_ID, MR_USER}
 615 };
 616
 617 static struct validate dubu_validate = {
 618   dubu_valobj,
 619   2,
 620   0,
 621   0,
 622   0,
 623   0,
 624   0,
 625   setup_dusr,
 626   0,
 627 };
 628
 629 static char *gkum_fields[] = { LOGIN, "kerberos",
 630                                    LOGIN, "kerberos" };
 631
 632 static char *akum_fields[] = { LOGIN, "kerberos" };
 633
 634 static struct valobj akum_valobj[] =
 635 {
 636   {V_LOCK, 0, KRBMAP_TABLE, 0, "users_id", MR_DEADLOCK},
 637   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 638   {V_ID, 1, STRINGS_TABLE, "string", "string_id", MR_NO_MATCH},
 639
 640 };
 641
 642 static struct validate akum_validate =
 643 {
 644   akum_valobj,
 645   3,
 646   USERS_ID,
 647   "users_id = %d or string_id = %d",
 648   2,
 649   USERS_ID,
 650   access_user,
 651   setup_akum,
 652   0,
 653 };
 654
 655 static struct validate dkum_validate =
 656 {
 657   akum_valobj,
 658   3,
 659   USERS_ID,
 660   "users_id = %d and string_id = %d",
 661   2,
 662   USERS_ID,
 663   access_user,
 664   0,
 665   0,
 666 };
 667
 668 static char *gfbl_fields[] = {
 669   LOGIN,
 670   LOGIN, "fullname", "nickname", "home_addr",
 671   "home_phone", "office_addr", "office_phone", "department",
 672   "affiliation", MOD1, MOD2, MOD3,
 673 };
 674
 675 static struct validate gfbl_validate = {
 676   VOuser0,
 677   1,
 678   0,
 679   0,
 680   0,
 681   0,
 682   access_user,
 683   0,
 684   followup_fix_modby,
 685 };
 686
 687 static char *ufbl_fields[] = {
 688   LOGIN,
 689   "fullname", "nickname", "home_addr",
 690   "home_phone", "office_addr", "office_phone", "department",
 691   "affiliation",
 692 };
 693
 694 static struct valobj ufbl_valobj[] = {
 695   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 696   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 697   {V_LEN, 1, USERS_TABLE, "fullname"},
 698   {V_LEN, 2, USERS_TABLE, "nickname"},
 699   {V_LEN, 3, USERS_TABLE, "home_addr"},
 700   {V_LEN, 4, USERS_TABLE, "home_phone"},
 701   {V_LEN, 5, USERS_TABLE, "office_addr"},
 702   {V_LEN, 6, USERS_TABLE, "office_phone"},
 703   {V_LEN, 7, USERS_TABLE, "department"},
 704   {V_LEN, 8, USERS_TABLE, "affiliation"},
 705 };
 706
 707 static struct validate ufbl_validate = {
 708   ufbl_valobj,
 709   10,
 710   0,
 711   0,
 712   0,
 713   0,
 714   access_user,
 715   0,
 716   set_finger_modtime,
 717 };
 718
 719 static char *gpob_fields[] = {
 720   LOGIN,
 721   LOGIN, TYPE, "box", MOD1, MOD2, MOD3,
 722 };
 723
 724 static struct validate gpob_validate = {
 725   VOuser0,
 726   1,
 727   "potype",
 728   "potype != 'NONE' and users_id=%d",
 729   1,
 730   0,
 731   access_user,
 732   0,
 733   followup_gpob,
 734 };
 735
 736 static char *gpox_fields[] = {
 737   LOGIN, TYPE, "box",
 738 };
 739
 740 struct valobj gpox_valobj[]={
 741   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 742   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK}
 743 };
 744
 745 static struct validate gpox_validate = {
 746   gpox_valobj,
 747   2,
 748   0,
 749   0,
 750   0,
 751   0,
 752   0,
 753   0,
 754   followup_gpob,
 755 };
 756
 757 static char *spob_fields[] = {
 758   LOGIN, TYPE, "box",
 759 };
 760
 761 static struct valobj spob_valobj[] = {
 762   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 763   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
 764   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 765   {V_TYPE, 1, 0, "pobox", 0, MR_TYPE},
 766 };
 767
 768 static struct validate spob_validate =  /* SET_POBOX */
 769 {
 770   spob_valobj,
 771   4,
 772   0,
 773   0,
 774   0,
 775   0,
 776   access_user,
 777   0,
 778   set_pobox,
 779 };
 780
 781 struct valobj spop_valobj[] = {
 782   {V_LOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 783   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
 784   {V_ID, 0, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
 785 };
 786
 787 static struct validate spop_validate =  /* SET_POBOX_POP */
 788 {
 789   spop_valobj,
 790   3,
 791   0,
 792   0,
 793   0,
 794   0,
 795   access_user,
 796   setup_spop,
 797   set_pobox_modtime,
 798 };
 799
 800 static struct validate dpob_validate =  /* DELETE_POBOX */
 801 {
 802   spop_valobj,
 803   3,
 804   0,
 805   0,
 806   0,
 807   0,
 808   access_user,
 809   setup_dpob,
 810   set_pobox_modtime,
 811 };
 812
 813 static char *gmac_fields[] = {
 814   NAME,
 815   NAME, TYPE, MOD1, MOD2, MOD3,
 816 };
 817
 818 static char *ghst_fields[] = {
 819   NAME, ADDRESS, "location", "network",
 820   NAME, "vendor", "model", "os", "location", "contact", "use", "status", "status_change", "network", ADDRESS, ACE_TYPE, ACE_NAME, "admin_comment", "ops_comment", "created", "creator", "inuse", MOD1, MOD2, MOD3,
 821 };
 822
 823 static struct valobj ghst_valobj[] = {
 824   {V_UPWILD, 0},
 825   {V_UPWILD, 1},
 826   {V_UPWILD, 2},
 827   {V_UPWILD, 3},
 828   {V_SORT, 0},
 829 };
 830
 831 static struct validate ghst_validate = {
 832   ghst_valobj,
 833   5,
 834   0,
 835   0,
 836   0,
 837   0,
 838   access_host,
 839   0,
 840   followup_ghst,
 841 };
 842
 843 static char *ahst_fields[] = {
 844   NAME, "vendor", "model", "os", "location", "contact", "use", "status", SUBNET, ADDRESS, ACE_TYPE, ACE_NAME, "admin_comment", "ops_comment",
 845 };
 846
 847 static struct valobj ahst_valobj[] = {
 848   {V_CHAR, 0, MACHINE_TABLE, NAME},
 849   {V_CHAR, 1, MACHINE_TABLE, "vendor"},
 850   {V_CHAR, 2, MACHINE_TABLE, "model"},
 851   {V_CHAR, 3, MACHINE_TABLE, "os"},
 852   {V_CHAR, 4, MACHINE_TABLE, "location"},
 853   {V_CHAR, 5, MACHINE_TABLE, "contact"},
 854   {V_RLOCK,0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 855   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
 856   {V_RLOCK, 0, SUBNET_TABLE, 0, SNET_ID, MR_DEADLOCK},
 857   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
 858   {V_RLOCK, 0, HOSTALIAS_TABLE, 0, MACH_ID, MR_DEADLOCK},
 859   {V_ID, 8, SUBNET_TABLE, NAME, SNET_ID, MR_SUBNET},
 860   {V_TYPE, 10, 0, ACE_TYPE, 0, MR_ACE},
 861   {V_TYPEDATA, 11, 0, 0, 0, MR_ACE},
 862   {V_ID, 12, STRINGS_TABLE, "string", "string_id", MR_NO_MATCH},
 863   {V_ID, 13, STRINGS_TABLE, "string", "string_id", MR_NO_MATCH},
 864 };
 865
 866 static struct validate ahst_validate = {
 867   ahst_valobj,
 868   16,
 869   NAME,
 870   "name = UPPER('%s')",
 871   1,
 872   MACH_ID,
 873   access_host,
 874   setup_ahst,
 875   set_uppercase_modtime,
 876 };
 877
 878 static char *uhst_fields[] = {
 879   NAME,
 880   "newname", "vendor", "model", "os", "location", "contact", "use", "status", SUBNET, ADDRESS, ACE_TYPE, ACE_NAME, "admin_comment", "ops_comment",
 881 };
 882
 883 static struct valobj uhst_valobj[] = {
 884   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 885   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
 886   {V_RLOCK, 0, SUBNET_TABLE, 0, SNET_ID, MR_DEADLOCK},
 887   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
 888   {V_CHAR, 0, MACHINE_TABLE, "name"},
 889   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
 890   {V_RENAME, 1, MACHINE_TABLE, NAME, MACH_ID, MR_NOT_UNIQUE},
 891   {V_CHAR, 2, MACHINE_TABLE, "vendor"},
 892   {V_CHAR, 3, MACHINE_TABLE, "model"},
 893   {V_CHAR, 4, MACHINE_TABLE, "os"},
 894   {V_CHAR, 5, MACHINE_TABLE, "location"},
 895   {V_ID, 9, SUBNET_TABLE, NAME, SNET_ID, MR_SUBNET},
 896   {V_TYPE, 11, 0, ACE_TYPE, 0, MR_ACE},
 897   {V_TYPEDATA, 12, 0, 0, 0, MR_ACE},
 898   {V_ID, 13, STRINGS_TABLE, "string", "string_id", MR_NO_MATCH},
 899   {V_ID, 14, STRINGS_TABLE, "string", "string_id", MR_NO_MATCH},
 900 };
 901
 902 static struct validate uhst_validate = {
 903   uhst_valobj,
 904   16,
 905   0,
 906   0,
 907   0,
 908   MACH_ID,
 909   access_host,
 910   setup_ahst,
 911   set_modtime_by_id,
 912 };
 913
 914 static char *dhst_fields[] = {
 915   NAME,
 916 };
 917
 918 static struct valobj dhst_valobj[] = {
 919   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
 920   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
 921   {V_RLOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
 922   {V_RLOCK, 0, SERVERHOSTS_TABLE, 0, MACH_ID, MR_DEADLOCK},
 923   {V_RLOCK, 0, HOSTACCESS_TABLE, 0, MACH_ID, MR_DEADLOCK},
 924   {V_RLOCK, 0, HOSTALIAS_TABLE, 0, MACH_ID, MR_DEADLOCK},
 925   {V_LOCK, 0, MCMAP_TABLE, 0, MACH_ID, MR_DEADLOCK},
 926   {V_RLOCK, 0, PRINTCAP_TABLE, 0, MACH_ID, MR_DEADLOCK},
 927   {V_RLOCK, 0, PALLADIUM_TABLE, 0, MACH_ID, MR_DEADLOCK},
 928   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
 929 };
 930
 931 static struct validate dhst_validate = {
 932   dhst_valobj,
 933   10,
 934   0,
 935   0,
 936   0,
 937   0,
 938   0,
 939   setup_dmac,
 940   0,
 941 };
 942
 943 static char *ghal_fields[] = {
 944     ALIAS, "canonical_hostname",
 945     ALIAS, "canonical_hostname"
 946 };
 947
 948 static struct valobj ghal_valobj[] = {
 949   {V_UPWILD, 0},
 950   {V_UPWILD, 1},
 951   {V_SORT, 0},
 952 };
 953
 954 static struct validate ghal_validate = {
 955   ghal_valobj,
 956   3,
 957   0,
 958   0,
 959   0,
 960   0,
 961   access_ahal,
 962   0,
 963   0,
 964 };
 965
 966 static struct valobj ahal_valobj[] = {
 967   {V_CHAR, 0, HOSTALIAS_TABLE, NAME},
 968   {V_UPWILD, 0},
 969   {V_ID, 1, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
 970 };
 971
 972 static struct validate ahal_validate = {
 973   ahal_valobj,
 974   3,
 975   NAME,
 976   "name = '%s'",
 977   1,
 978   MACH_ID,
 979   access_ahal,
 980   setup_ahal,
 981   0,
 982 };
 983
 984 static struct valobj dhal_valobj[] = {
 985   {V_UPWILD, 0},
 986   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
 987   {V_ID, 1, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
 988 };
 989
 990 static struct validate dhal_validate = {
 991   dhal_valobj,
 992   3,
 993   NAME,
 994   "name = '%s' AND mach_id = %d",
 995   2,
 996   MACH_ID,
 997   access_ahal,
 998   0,
 999   0,
1000 };
1001
1002 static char *gsnt_fields[] = {
1003     NAME,
1004     NAME, DESC, ADDRESS, "mask", "low", "high", "prefix", ACE_TYPE, ACE_NAME,
1005     MOD1, MOD2, MOD3
1006 };
1007
1008 static struct valobj gsnt_valobj[] = {
1009   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1010   {V_RLOCK, 0, SUBNET_TABLE, 0, SNET_ID, MR_DEADLOCK},
1011   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1012   {V_UPWILD, 0},
1013   {V_SORT, 0},
1014 };
1015
1016 static struct validate gsnt_validate = {
1017   gsnt_valobj,
1018   5,
1019   0,
1020   0,
1021   0,
1022   0,
1023   access_snt,
1024   0,
1025   followup_gsnt,
1026 };
1027
1028 static char *asnt_fields[] = {
1029     NAME, DESC, ADDRESS, "mask", "low", "high", "prefix", ACE_TYPE, ACE_NAME,
1030 };
1031
1032 static struct valobj asnt_valobj[] = {
1033   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1034   {V_LOCK, 0, SUBNET_TABLE, 0, SNET_ID, MR_DEADLOCK},
1035   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1036   {V_CHAR, 0, SUBNET_TABLE, NAME},
1037   {V_LEN, 1, SUBNET_TABLE, DESC},
1038   {V_LEN, 6, SUBNET_TABLE, "prefix"},
1039   {V_TYPE, 7, 0, ACE_TYPE, 0, MR_ACE},
1040   {V_TYPEDATA, 8, 0, 0, 0, MR_ACE},
1041 };
1042
1043 static struct validate asnt_validate =
1044 {
1045     asnt_valobj,
1046     8,
1047     NAME,
1048     "name = UPPER('%s')",
1049     1,
1050     SNET_ID,
1051     0,
1052     prefetch_value,
1053     set_uppercase_modtime,
1054 };
1055
1056 static char *usnt_fields[] = {
1057     NAME,
1058     "newname", DESC, ADDRESS, "mask", "low", "high", "prefix", ACE_TYPE, ACE_NAME,
1059 };
1060
1061 static struct valobj usnt_valobj[] = {
1062   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1063   {V_LOCK, 0, SUBNET_TABLE, 0, SNET_ID, MR_DEADLOCK},
1064   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1065   {V_ID, 0, SUBNET_TABLE, NAME, SNET_ID, MR_NO_MATCH},
1066   {V_RENAME, 1, SUBNET_TABLE, NAME, SNET_ID, MR_NOT_UNIQUE},
1067   {V_LEN, 2, SUBNET_TABLE, DESC},
1068   {V_LEN, 7, SUBNET_TABLE, "prefix"},
1069   {V_TYPE, 8, 0, ACE_TYPE, 0, MR_ACE},
1070   {V_TYPEDATA, 9, 0, 0, 0, MR_ACE},
1071 };
1072
1073 static struct validate usnt_validate =
1074 {
1075     usnt_valobj,
1076     9,
1077     NAME,
1078     "snet_id = %d",
1079     1,
1080     SNET_ID,
1081     0,
1082     0,
1083     set_modtime_by_id,
1084 };
1085
1086 static char *dsnt_fields[] = {
1087   NAME,
1088 };
1089
1090 static struct valobj dsnt_valobj[] = {
1091   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
1092   {V_LOCK, 0, SUBNET_TABLE, 0, SNET_ID, MR_DEADLOCK},
1093   {V_ID, 0, SUBNET_TABLE, NAME, SNET_ID, MR_SUBNET},
1094 };
1095
1096 static struct validate dsnt_validate = {
1097   dsnt_valobj,
1098   3,
1099   0,
1100   0,
1101   0,
1102   0,
1103   0,
1104   setup_dsnt,
1105   0,
1106 };
1107
1108 static char *gclu_fields[] = {
1109   NAME,
1110   NAME, DESC, LOCATION, MOD1, MOD2, MOD3,
1111 };
1112
1113 static char *aclu_fields[] = {
1114   NAME, DESC, LOCATION,
1115 };
1116
1117 static struct valobj aclu_valobj[] = {
1118   {V_LOCK, 0, CLUSTER_TABLE, 0, CLU_ID, MR_DEADLOCK},
1119   {V_CHAR, 0, CLUSTER_TABLE, NAME},
1120   {V_LEN, 1, CLUSTER_TABLE, DESC},
1121   {V_LEN, 2, CLUSTER_TABLE, LOCATION},
1122 };
1123
1124 static struct validate aclu_validate =
1125 {
1126   aclu_valobj,
1127   4,
1128   NAME,
1129   "name = '%s'",
1130   1,
1131   CLU_ID,
1132   0,
1133   prefetch_value,
1134   set_modtime,
1135 };
1136
1137 static char *uclu_fields[] = {
1138   NAME,
1139   "newname", DESC, LOCATION,
1140 };
1141
1142 static struct valobj uclu_valobj[] = {
1143   {V_LOCK, 0, CLUSTER_TABLE, 0, CLU_ID, MR_DEADLOCK},
1144   {V_ID, 0, CLUSTER_TABLE, NAME, CLU_ID, MR_CLUSTER},
1145   {V_RENAME, 1, CLUSTER_TABLE, NAME, CLU_ID, MR_NOT_UNIQUE},
1146   {V_LEN, 2, CLUSTER_TABLE, DESC},
1147   {V_LEN, 3, CLUSTER_TABLE, LOCATION},
1148 };
1149
1150 static struct validate uclu_validate = {
1151   uclu_valobj,
1152   5,
1153   0,
1154   0,
1155   0,
1156   CLU_ID,
1157   0,
1158   0,
1159   set_modtime_by_id,
1160 };
1161
1162 static char *dclu_fields[] = {
1163   NAME,
1164 };
1165
1166 static struct validate dclu_validate = {
1167   VOclu0,
1168   1,
1169   0,
1170   0,
1171   0,
1172   0,
1173   0,
1174   setup_dclu,
1175   0,
1176 };
1177
1178 static char *gmcm_fields[] = {
1179   MACHINE, CLUSTER,
1180   MACHINE, CLUSTER,
1181 };
1182
1183 static struct valobj gmcm_valobj[] =
1184 {
1185   {V_UPWILD, 0},
1186   {V_WILD, 1},
1187   {V_SORT, 0},
1188   {V_SORT, 1},
1189 };
1190
1191 static struct validate gmcm_validate = { gmcm_valobj, 4 };
1192
1193 static struct valobj amtc_valobj[] =    /* ADD_MACHINE_TO_CLUSTER */
1194 {                                       /* DELETE_MACHINE_FROM_CLUSTER */
1195   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
1196   {V_ID, 1, CLUSTER_TABLE, NAME, CLU_ID, MR_CLUSTER},
1197 };
1198
1199 static struct validate amtc_validate = /* for amtc and dmfc */
1200 {
1201   amtc_valobj,
1202   2,
1203   MACH_ID,
1204   "mach_id = %d and clu_id = %d",
1205   2,
1206   0,
1207   0,
1208   0,
1209   set_mach_modtime_by_id,
1210 };
1211
1212 static char *gcld_fields[] = {
1213   CLUSTER, "serv_label",
1214   CLUSTER, "serv_label", "serv_cluster",
1215 };
1216
1217 static char *acld_fields[] = {
1218   CLUSTER, "serv_label", "serv_cluster",
1219 };
1220
1221 static struct valobj acld_valobj[] =
1222 {
1223   {V_ID, 0, CLUSTER_TABLE, NAME, CLU_ID, MR_CLUSTER},
1224   {V_CHAR, 1, SVC_TABLE, "serv_label"},
1225   {V_CHAR, 2, SVC_TABLE, "serv_cluster"}
1226 };
1227
1228 static struct validate acld_validate =
1229 {
1230   acld_valobj,
1231   3,
1232   CLU_ID,
1233   "clu_id = %d AND serv_label = '%s' AND serv_cluster = '%s'",
1234   3,
1235   0,
1236   0,
1237   0,
1238   set_cluster_modtime_by_id,
1239 };
1240
1241 static struct valobj dcld_valobj[] =
1242 {
1243   {V_ID, 0, CLUSTER_TABLE, NAME, CLU_ID, MR_CLUSTER},
1244 };
1245
1246 static struct validate dcld_validate =
1247 {
1248   dcld_valobj,
1249   1,
1250   CLU_ID,
1251   "clu_id = %d AND serv_label = '%s' AND serv_cluster = '%s'",
1252   3,
1253   0,
1254   0,
1255   0,
1256   set_cluster_modtime_by_id,
1257 };
1258
1259 static char *glin_fields[] = {
1260   NAME,
1261   NAME, "active", "publicflg", "hidden", "maillist", "grouplist", "gid",
1262   ACE_TYPE, ACE_NAME, DESC, MOD1, MOD2, MOD3,
1263 };
1264
1265 static struct validate glin_validate = {
1266   0,
1267   0,
1268   0,
1269   0,
1270   0,
1271   0,
1272   access_vis_list_by_name,
1273   0,
1274   get_list_info,
1275 };
1276
1277 static char *alis_fields[] = {
1278   NAME, "active", "publicflg", "hidden", "maillist", "grouplist", "gid",
1279   ACE_TYPE, ACE_NAME, DESC,
1280 };
1281
1282 static struct valobj alis_valobj[] = {
1283   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1284   {V_LOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1285   {V_CHAR, 0, LIST_TABLE, NAME},
1286   {V_TYPE, 7, 0, ACE_TYPE, 0, MR_ACE},
1287   {V_TYPEDATA, 8, 0, 0, LIST_ID, MR_ACE},
1288   {V_LEN, 9, LIST_TABLE, DESC},
1289 };
1290
1291 static struct validate alis_validate = {
1292   alis_valobj,
1293   6,
1294   NAME,
1295   "name = '%s'",
1296   1,
1297   LIST_ID,
1298   0,
1299   setup_alis,
1300   set_modtime,
1301 };
1302
1303 static char *ulis_fields[] = {
1304   NAME,
1305   "newname", "active", "publicflg", "hidden", "maillist", "grouplist", "gid",
1306   ACE_TYPE, ACE_NAME, DESC,
1307 };
1308
1309 static struct valobj ulis_valobj[] = {
1310   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1311   {V_LOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1312   {V_ID, 0, LIST_TABLE, NAME, LIST_ID, MR_LIST},
1313   {V_RENAME, 1, LIST_TABLE, NAME, LIST_ID, MR_NOT_UNIQUE},
1314   {V_TYPEDATA, 9, 0, 0, LIST_ID, MR_ACE},
1315   {V_CHAR, 1, LIST_TABLE, NAME},
1316   {V_LEN, 10, LIST_TABLE, DESC},
1317 };
1318
1319 static struct validate ulis_validate = {
1320   ulis_valobj,
1321   7,
1322   NAME,
1323   "list_id = %d",
1324   1,
1325   LIST_ID,
1326   access_list,
1327   setup_alis,
1328   set_modtime_by_id,
1329 };
1330
1331 static char *dlis_fields[] = {
1332   NAME,
1333 };
1334
1335 static struct valobj dlis_valobj[] ={
1336   {V_RLOCK, 0, CAPACLS_TABLE, 0, LIST_ID, MR_DEADLOCK},
1337   {V_RLOCK, 0, IMEMBERS_TABLE, 0, LIST_ID, MR_DEADLOCK},
1338   {V_RLOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1339   {V_LOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1340   {V_RLOCK, 0, QUOTA_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1341   {V_RLOCK, 0, ZEPHYR_TABLE, 0, ZEPH_ID, MR_DEADLOCK},
1342   {V_RLOCK, 0, HOSTACCESS_TABLE, 0, MACH_ID, MR_DEADLOCK},
1343   {V_ID, 0, LIST_TABLE, NAME, LIST_ID, MR_LIST}
1344 };
1345
1346 static struct validate dlis_validate = {
1347   dlis_valobj,
1348   8,
1349   NAME,
1350   "list_id = %d",
1351   1,
1352   0,
1353   access_list,
1354   setup_dlis,
1355   0,
1356 };
1357
1358 static char *amtl_fields[] = {
1359   "list_name", "member_type", "member_name",
1360 };
1361
1362 static struct valobj amtl_valobj[] = {
1363   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1364   {V_LOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1365   {V_ID, 0, LIST_TABLE, NAME, LIST_ID, MR_LIST},
1366   {V_TYPE, 1, 0, "member", 0, MR_TYPE},
1367   {V_TYPEDATA, 2, 0, 0, 0, MR_NO_MATCH},
1368 };
1369
1370 static struct validate amtl_validate =
1371 {
1372   amtl_valobj,
1373   5,
1374   0,
1375   0,
1376   0,
1377   0,
1378   access_list,
1379   0,
1380   add_member_to_list,
1381 };
1382
1383 static struct validate dmfl_validate =
1384 {
1385   amtl_valobj,
1386   5,
1387   0,
1388   0,
1389   0,
1390   0,
1391   access_list,
1392   0,
1393   delete_member_from_list,
1394 };
1395
1396 static char *gaus_fields[] = {
1397   ACE_TYPE, ACE_NAME,
1398   "use_type", "use_name",
1399 };
1400
1401 static struct valobj gaus_valobj[] = {
1402   {V_RLOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1403   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1404   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1405   {V_RLOCK, 0, ZEPHYR_TABLE, 0, ZEPH_ID, MR_DEADLOCK},
1406   {V_RLOCK, 0, HOSTACCESS_TABLE, 0, MACH_ID, MR_DEADLOCK},
1407   {V_TYPE, 0, 0, "gaus", 0, MR_TYPE},
1408   {V_TYPEDATA, 1, 0, 0, 0, MR_NO_MATCH},
1409 };
1410
1411 static struct validate gaus_validate = {
1412   gaus_valobj,
1413   7,
1414   0,
1415   0,
1416   0,
1417   0,
1418   access_member,
1419   0,
1420   get_ace_use,
1421 };
1422
1423 static char *qgli_fields[] = {
1424   "active", "publicflg", "hidden", "maillist", "grouplist",
1425   "list",
1426 };
1427
1428 static struct valobj qgli_valobj[] = {
1429   {V_TYPE, 0, 0, "boolean", 0, MR_TYPE},
1430   {V_TYPE, 1, 0, "boolean", 0, MR_TYPE},
1431   {V_TYPE, 2, 0, "boolean", 0, MR_TYPE},
1432   {V_TYPE, 3, 0, "boolean", 0, MR_TYPE},
1433   {V_TYPE, 4, 0, "boolean", 0, MR_TYPE},
1434 };
1435
1436 static struct validate qgli_validate = {
1437   qgli_valobj,
1438   5,
1439   0,
1440   0,
1441   0,
1442   0,
1443   access_qgli,
1444   0,
1445   qualified_get_lists,
1446 };
1447
1448 static char *gmol_fields[] = {
1449   "list_name",
1450   "member_type", "member_name",
1451 };
1452
1453 static struct valobj gmol_valobj[]={
1454   {V_LOCK, 0, IMEMBERS_TABLE, 0, LIST_ID, MR_DEADLOCK},
1455   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1456   {V_ID, 0, LIST_TABLE, NAME, LIST_ID, MR_LIST},
1457
1458 };
1459 static struct validate gmol_validate = {
1460  gmol_valobj,
1461   3,
1462   0,
1463   0,
1464   0,
1465   0,
1466   access_visible_list,
1467   0,
1468   get_members_of_list,
1469 };
1470
1471 static struct validate geml_validate = {
1472   gmol_valobj,
1473   3,
1474   0,
1475   0,
1476   0,
1477   0,
1478   access_visible_list,
1479   0,
1480   get_end_members_of_list,
1481 };
1482
1483 static char *glom_fields[] = {
1484   "member_type", "member_name",
1485   "list_name", "active", "publicflg", "hidden", "maillist", "grouplist",
1486 };
1487
1488 static struct valobj glom_valobj[] = {
1489    {V_LOCK, 0, IMEMBERS_TABLE, 0, LIST_ID, MR_DEADLOCK},
1490    {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1491    {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1492    {V_TYPE, 0, 0, "rmember", 0, MR_TYPE},
1493    {V_TYPEDATA, 1, 0, 0, 0, MR_NO_MATCH},
1494    {V_SORT, 0},
1495 };
1496
1497 static struct validate glom_validate = {
1498   glom_valobj,
1499   6,
1500   0,
1501   0,
1502   0,
1503   0,
1504   access_member,
1505   0,
1506   get_lists_of_member,
1507 };
1508
1509 static char *cmol_fields[] = {
1510   "list_name",
1511   "count",
1512 };
1513
1514 static struct validate cmol_validate = {
1515   VOlist0,
1516   1,
1517   0,
1518   0,
1519   0,
1520   0,
1521   access_visible_list,
1522   0,
1523   count_members_of_list,
1524 };
1525
1526 static char *gsin_fields[] = {
1527   SERVICE,
1528   SERVICE, "update_int", "target_file", "script", "dfgen", "dfcheck",
1529   TYPE, "enable", "inprogress", "harderror", "errmsg",
1530   ACE_TYPE, ACE_NAME, MOD1, MOD2, MOD3,
1531 };
1532
1533 static struct valobj gsin_valobj[] =
1534 {
1535   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1536   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1537   {V_UPWILD, 0 },
1538 };
1539
1540 static struct validate gsin_validate =
1541 {
1542   gsin_valobj,
1543   3,
1544   0,
1545   0,
1546   0,
1547   0,
1548   access_service,
1549   0,
1550   followup_glin,
1551 };
1552
1553 static char *qgsv_fields[] = {
1554   "enable", "inprogress", "harderror",
1555   "service",
1556 };
1557
1558 static struct valobj qgsv_valobj[] = {
1559   {V_TYPE, 0, 0, "boolean", 0, MR_TYPE},
1560   {V_TYPE, 1, 0, "boolean", 0, MR_TYPE},
1561   {V_TYPE, 2, 0, "boolean", 0, MR_TYPE},
1562 };
1563
1564 static struct validate qgsv_validate = {
1565   qgsv_valobj,
1566   3,
1567   0,
1568   0,
1569   0,
1570   0,
1571   0,
1572   0,
1573   qualified_get_server,
1574 };
1575
1576 static char *asin_fields[] = {
1577   SERVICE, "update_int", "target_file", "script", TYPE, "enable",
1578   ACE_TYPE, ACE_NAME,
1579 };
1580
1581 static struct valobj asin_valobj[] = {
1582   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1583   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
1584   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1585   {V_CHAR, 0, SERVERS_TABLE, SERVICE},
1586   {V_LEN, 2, SERVERS_TABLE, "target_file"},
1587   {V_LEN, 3, SERVERS_TABLE, "script"},
1588   {V_TYPE, 4, 0, "service", 0, MR_TYPE},
1589   {V_TYPE, 6, 0, ACE_TYPE, 0, MR_ACE},
1590   {V_TYPEDATA, 7, 0, 0, 0, MR_ACE},
1591 };
1592
1593 static struct validate asin_validate =  /* for asin, usin */
1594 {
1595   asin_valobj,
1596   9,
1597   NAME,
1598   "name = UPPER('%s')",
1599   1,
1600   0,
1601   0,
1602   0,
1603   set_uppercase_modtime,
1604 };
1605
1606 static struct validate rsve_validate = {
1607   asin_valobj,
1608   3,
1609   NAME,
1610   "name = UPPER('%s')",
1611   1,
1612   0,
1613   access_service,
1614   0,
1615   set_uppercase_modtime,
1616 };
1617
1618 static char *ssif_fields[] = {
1619   SERVICE, "dfgen", "dfcheck", "inprogress", "harderror", "errmsg",
1620 };
1621
1622 static struct valobj ssif_valobj[] = {
1623   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1624   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
1625   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1626   {V_LEN, 5, SERVERS_TABLE, "errmsg"},
1627 };
1628
1629 static struct validate ssif_validate = {
1630   ssif_valobj,
1631   4,
1632   NAME,
1633   "name = UPPER('%s')",
1634   1,
1635   0,
1636   0,
1637   0,
1638   0,
1639 };
1640
1641 static char *dsin_fields[] = {
1642   SERVICE,
1643 };
1644
1645 static struct validate dsin_validate = {
1646   asin_valobj,
1647   3,
1648   NAME,
1649   "name = UPPER('%s')",
1650   1,
1651   0,
1652   0,
1653   setup_dsin,
1654   0,
1655 };
1656
1657 static char *gshi_fields[] = {
1658   SERVICE, MACHINE,
1659   SERVICE, MACHINE, "enable", "override", "success", "inprogress",
1660   "hosterror", "hosterrormsg", "ltt", "lts", "value1", "value2",
1661   "value3", MOD1, MOD2, MOD3,
1662 };
1663
1664 static struct valobj gshi_valobj[] = {
1665   { V_UPWILD, 0 },
1666   { V_UPWILD, 1 },
1667 };
1668
1669 static struct validate gshi_validate = {
1670   gshi_valobj,
1671   2,
1672   0,
1673   0,
1674   0,
1675   0,
1676   access_service,
1677   0,
1678   followup_fix_modby,
1679 };
1680
1681 static char *qgsh_fields[] = {
1682   "service", "enable", "override", "success", "inprogress", "hosterror",
1683   "service", MACHINE,
1684 };
1685
1686 static struct valobj qgsh_valobj[] = {
1687   {V_TYPE, 1, 0, "boolean", 0, MR_TYPE},
1688   {V_TYPE, 2, 0, "boolean", 0, MR_TYPE},
1689   {V_TYPE, 3, 0, "boolean", 0, MR_TYPE},
1690   {V_TYPE, 4, 0, "boolean", 0, MR_TYPE},
1691   {V_TYPE, 5, 0, "boolean", 0, MR_TYPE},
1692 };
1693
1694 static struct validate qgsh_validate = {
1695   qgsh_valobj,
1696   5,
1697   0,
1698   0,
1699   0,
1700   0,
1701   0,
1702   0,
1703   qualified_get_serverhost,
1704 };
1705
1706 static char *ashi_fields[] = {
1707   SERVICE, MACHINE, "enable", "value1", "value2", "value3",
1708 };
1709
1710 static struct valobj ashi_valobj[] = {
1711   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
1712   {V_NAME, 0, SERVERS_TABLE, NAME, 0, MR_SERVICE},
1713   {V_LOCK, 0, SERVERHOSTS_TABLE,0, MACH_ID, MR_DEADLOCK},
1714   {V_ID, 1, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
1715   {V_CHAR, 0, SERVERHOSTS_TABLE, NAME},
1716   {V_LEN, 5, SERVERHOSTS_TABLE, "value3"},
1717 };
1718
1719 static struct validate ashi_validate = /* ashi & ushi */
1720 {
1721   ashi_valobj,
1722   6,
1723   SERVICE,
1724   "service = UPPER('%s') AND mach_id = %d",
1725   2,
1726   0,
1727   access_service,
1728   0,
1729   set_serverhost_modtime,
1730 };
1731
1732 static struct validate rshe_validate =
1733 {
1734   ashi_valobj,
1735   4,
1736   SERVICE,
1737   "service = UPPER('%s') AND mach_id = %d",
1738   2,
1739   0,
1740   access_service,
1741   0,
1742   set_serverhost_modtime,
1743 };
1744
1745 static struct validate ssho_validate =
1746 {
1747   ashi_valobj,
1748   4,
1749   SERVICE,
1750   "service = UPPER('%s') AND mach_id = %d",
1751   2,
1752   0,
1753   access_service,
1754   0,
1755   trigger_dcm,
1756 };
1757
1758 static char *sshi_fields[] = {
1759   "service", MACHINE, "override", "success", "inprogress",
1760   "hosterror", "errmsg", "ltt", "lts",
1761 };
1762
1763 static struct valobj sshi_valobj[] = {
1764   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
1765   {V_NAME, 0, SERVERS_TABLE, NAME, 0, MR_SERVICE},
1766   {V_ID, 1, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},  /** Was this ok to add? */
1767   {V_LEN, 5, SERVERS_TABLE, "errmsg"},
1768 };
1769
1770 static struct validate sshi_validate =
1771 {
1772   sshi_valobj,
1773   4,
1774   0,
1775   0,
1776   0,
1777   0,
1778   0,
1779   0,
1780   0,
1781 };
1782
1783 static char *dshi_fields[] = {
1784   SERVICE, MACHINE,
1785 };
1786
1787 static struct validate dshi_validate =
1788 {
1789   ashi_valobj,
1790   4,
1791   SERVICE,
1792   "service = UPPER('%s') AND mach_id = %d",
1793   2,
1794   0,
1795   access_service,
1796   setup_dshi,
1797   0,
1798 };
1799
1800 static char *gslo_fields[] = {
1801   "server",
1802   "server", MACHINE,
1803 };
1804
1805 static char *gfsl_fields[] = {
1806   LABEL,
1807   LABEL, TYPE, MACHINE, NAME, "mount", "access", COMMENTS, "owner", "owners",
1808   "create", "lockertype", MOD1, MOD2, MOD3,
1809 };
1810
1811 static char *gfsm_fields[] = {
1812   MACHINE,
1813   LABEL, TYPE, MACHINE, NAME, "mount", "access", COMMENTS, "owner", "owners",
1814   "create", "lockertype", MOD1, MOD2, MOD3,
1815 };
1816
1817 static struct valobj gfsm_valobj[] = {
1818   {V_RLOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1819   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
1820 };
1821
1822 static struct validate gfsm_validate = {
1823   gfsm_valobj,
1824   2,
1825   0,
1826   0,
1827   0,
1828   0,
1829   0,
1830   0,
1831   followup_fix_modby,
1832 };
1833
1834 static char *gfsn_fields[] = {
1835   MACHINE, "parition",
1836   LABEL, TYPE, MACHINE, NAME, "mount", "access", COMMENTS, "owner", "owners",
1837   "create", "lockertype", MOD1, MOD2, MOD3,
1838 };
1839
1840 static struct valobj gfsn_valobj[] =
1841 {
1842   {V_RLOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1843   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
1844   {V_WILD, 1},
1845 };
1846
1847 static struct validate gfsn_validate = {
1848   gfsn_valobj,
1849   3,
1850   0,
1851   0,
1852   0,
1853   0,
1854   0,
1855   0,
1856   followup_fix_modby,
1857 };
1858
1859 static char *gfsp_fields[] = {
1860   "path",
1861   LABEL, TYPE, MACHINE, NAME, "mount", "access", COMMENTS, "owner", "owners",
1862   "create", "lockertype", MOD1, MOD2, MOD3,
1863 };
1864
1865 static char *gfsg_fields[] = {
1866   LIST,
1867   LABEL, TYPE, MACHINE, NAME, "mount", "access", COMMENTS, "owner", "owners",
1868   "create", "lockertype", MOD1, MOD2, MOD3,
1869 };
1870
1871 static struct valobj gfsg_valobj[] = {
1872   {V_RLOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1873   {V_ID, 0, LIST_TABLE, NAME, LIST_ID, MR_LIST}
1874 };
1875
1876 static struct validate gfsg_validate = {
1877   gfsg_valobj,
1878   2,
1879   0,
1880   0,
1881   0,
1882   0,
1883   access_list,
1884   0,
1885   followup_fix_modby,
1886 };
1887
1888 static char *afil_fields[] = {
1889   LABEL, TYPE, MACHINE, NAME, "mount", "access", COMMENTS, "owner", "owners",
1890   "create", "lockertype",
1891 };
1892
1893 static struct valobj afil_valobj[] = {
1894   {V_LOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1895   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1896   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
1897   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1898   {V_CHAR, 0, FILESYS_TABLE, LABEL},
1899   {V_TYPE, 1, 0, "filesys", 0, MR_FSTYPE},
1900   {V_ID, 2, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
1901   {V_CHAR, 3, FILESYS_TABLE, NAME},
1902   {V_LEN, 4, FILESYS_TABLE, "mount"},
1903   {V_LEN, 6, FILESYS_TABLE, COMMENTS},
1904   {V_ID, 7, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
1905   {V_ID, 8, LIST_TABLE, NAME, LIST_ID, MR_LIST},
1906   {V_TYPE, 10, 0, "lockertype", 0, MR_TYPE},
1907 };
1908
1909 static struct validate afil_validate = {
1910   afil_valobj,
1911   13,
1912   LABEL,
1913   "label = '%s'",
1914   1,
1915   FILSYS_ID,
1916   0,
1917   setup_afil,
1918   set_filesys_modtime,
1919 };
1920
1921 static char *ufil_fields[] = {
1922   LABEL, "newlabel", TYPE, MACHINE, NAME, "mount", "access", COMMENTS,
1923   "owner", "owners", "create", "lockertype",
1924 };
1925
1926 static struct valobj ufil_valobj[] = {
1927   {V_LOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1928   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
1929   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
1930   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
1931   {V_LOCK, 0, QUOTA_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1932   {V_ID, 0, FILESYS_TABLE, LABEL, FILSYS_ID, MR_FILESYS},
1933   {V_RENAME, 1, FILESYS_TABLE, LABEL, FILSYS_ID, MR_NOT_UNIQUE},
1934   {V_TYPE, 2, 0, "filesys", 0, MR_FSTYPE},
1935   {V_ID, 3, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
1936   {V_CHAR, 4, FILESYS_TABLE, NAME},
1937   {V_LEN, 5, FILESYS_TABLE, "mount"},
1938   {V_LEN, 7, FILESYS_TABLE, COMMENTS},
1939   {V_ID, 8, USERS_TABLE, LOGIN, USERS_ID, MR_USER},
1940   {V_ID, 9, LIST_TABLE, NAME, LIST_ID, MR_LIST},
1941   {V_TYPE, 11, 0, "lockertype", 0, MR_TYPE},
1942 };
1943
1944 static struct validate ufil_validate = {
1945   ufil_valobj,
1946   15,
1947   LABEL,
1948   "filsys_id = %d",
1949   1,
1950   FILSYS_ID,
1951   0,
1952   setup_ufil,
1953   set_filesys_modtime,
1954 };
1955
1956 static char *dfil_fields[] = {
1957   LABEL,
1958 };
1959
1960 static struct valobj dfil_valobj[] = {
1961   {V_LOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1962   {V_LOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
1963   {V_LOCK, 0, QUOTA_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
1964   {V_LOCK, 0, FSGROUP_TABLE, 0, "filsys_id", MR_DEADLOCK},
1965   {V_ID, 0, FILESYS_TABLE, LABEL, FILSYS_ID, MR_FILESYS},
1966 };
1967
1968 static struct validate dfil_validate = {
1969   dfil_valobj,
1970   5,
1971   "label",
1972   "filsys_id = %d",
1973   1,
1974   0,
1975   0,
1976   setup_dfil,
1977   0,
1978 };
1979
1980 static char *gfgm_fields[] = {
1981   "fsgroup", FILESYS, "sortkey"
1982     };
1983
1984 static struct valobj gfgm_valobj[] = {
1985   {V_ID, 0, FILESYS_TABLE, LABEL, FILSYS_ID, MR_FILESYS},
1986   {V_SORT, 1},
1987   {V_SORT, 0},
1988 };
1989
1990 static struct validate gfgm_validate = {
1991   gfgm_valobj,
1992   3,
1993   0,
1994   0,
1995   0,
1996   0,
1997   0,
1998   0,
1999   0,
2000 };
2001
2002 static struct valobj aftg_valobj[] = {
2003   {V_LOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
2004   {V_LOCK, 0, FSGROUP_TABLE, 0, "filsys_id", MR_DEADLOCK},
2005   {V_ID, 0, FILESYS_TABLE, LABEL, FILSYS_ID, MR_FILESYS},
2006   {V_ID, 1, FILESYS_TABLE, LABEL, FILSYS_ID, MR_FILESYS},
2007 };
2008
2009 static struct validate aftg_validate = {
2010   aftg_valobj,
2011   4,
2012   "group_id",
2013   "group_id = %d and filsys_id = %d",
2014   2,
2015   0,
2016   0,
2017   0,
2018   0,
2019 };
2020
2021 static char *ganf_fields[] = {
2022   MACHINE, DIR, DEVICE, STATUS, "allocated", "size", MOD1, MOD2, MOD3,
2023 };
2024
2025 static char *gnfp_fields[] = {
2026   MACHINE, DIR,
2027   MACHINE, DIR, DEVICE, STATUS, "allocated", "size", MOD1, MOD2, MOD3,
2028 };
2029
2030 static struct valobj gnfp_valobj[] = {
2031   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2032   {V_RLOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
2033   {V_WILD, 1},
2034 };
2035
2036 static struct validate gnfp_validate = {
2037   gnfp_valobj,
2038   3,
2039   0,
2040   0,
2041   0,
2042   0,
2043   0,
2044   0,
2045   followup_fix_modby,
2046 };
2047
2048 static struct valobj anfp_valobj[] = {
2049   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
2050   {V_LOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
2051   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2052   {V_CHAR, 1, NFSPHYS_TABLE, "dir"},
2053   {V_LEN, 2, NFSPHYS_TABLE, "device"},
2054 };
2055
2056 static struct validate anfp_validate = {
2057   anfp_valobj,
2058   5,
2059   DIR,
2060   "mach_id = %d and dir = '%s'",
2061   2,
2062   "nfsphys_id",
2063   0,
2064   prefetch_value,
2065   set_nfsphys_modtime,
2066 };
2067
2068 static struct validate unfp_validate = {
2069   anfp_valobj,
2070   5,
2071   DIR,
2072   "mach_id = %d and dir = '%s'",
2073   2,
2074   "nfsphys_id",
2075   0,
2076   0,
2077   set_nfsphys_modtime,
2078 };
2079
2080 static char *ajnf_fields[] = {
2081   MACHINE, DIR, "adjustment",
2082 };
2083
2084 static char *dnfp_fields[] = {
2085   MACHINE, DIR,
2086 };
2087
2088 static struct valobj dnfp_valobj[] = {
2089   {V_RLOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
2090   {V_LOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
2091   {V_LOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
2092   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2093
2094 };
2095
2096 static struct validate dnfp_validate = {
2097   dnfp_valobj,
2098   4,
2099   DIR,
2100   "mach_id = %d and dir = '%s'",
2101   2,
2102   "nfsphys_id",
2103   0,
2104   setup_dnfp,
2105   set_nfsphys_modtime,
2106 };
2107
2108 static char *gqot_fields[] = {
2109   FILESYS, TYPE, NAME,
2110   FILESYS, TYPE, NAME, QUOTA, DIR, MACHINE, MOD1, MOD2, MOD3,
2111 };
2112
2113 static struct valobj gqot_valobj[] = {
2114   {V_RLOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
2115   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
2116   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
2117   {V_RLOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
2118   {V_RLOCK, 0, QUOTA_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
2119   {V_WILD, 0},
2120   {V_TYPE, 1, 0, QUOTA_TYPE, 0, MR_TYPE},
2121   {V_TYPEDATA, 2, 0, 0, 0, MR_ACE},
2122   {V_SORT, 0, 0, 0, 0, 0},
2123 };
2124
2125 static struct validate gqot_validate = {
2126   gqot_valobj,
2127   9,
2128   0,
2129   0,
2130   0,
2131   0,
2132   0,
2133   0,
2134   followup_gqot,
2135 };
2136
2137 static char *gqbf_fields[] = {
2138   FILESYS,
2139   FILESYS, TYPE, NAME, QUOTA, DIR, MACHINE, MOD1, MOD2, MOD3,
2140 };
2141
2142 static struct validate gqbf_validate = {
2143   VOwild0sort,
2144   2,
2145   0,
2146   0,
2147   0,
2148   0,
2149   access_filesys,
2150   0,
2151   followup_gqot,
2152 };
2153
2154 static char *aqot_fields[] = {
2155   FILESYS, TYPE, NAME, QUOTA,
2156 };
2157
2158 static struct valobj aqot_valobj[] = {
2159   {V_LOCK, 0, FILESYS_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
2160   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
2161   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
2162   {V_LOCK, 0, NFSPHYS_TABLE, 0, "nfsphys_id", MR_DEADLOCK},
2163   {V_LOCK, 0, QUOTA_TABLE, 0, FILSYS_ID, MR_DEADLOCK},
2164   {V_ID, 0, FILESYS_TABLE, LABEL, FILSYS_ID, MR_FILESYS},
2165   {V_TYPE, 1, 0, QUOTA_TYPE, 0, MR_TYPE},
2166   {V_TYPEDATA, 2, 0, 0, 0, MR_ACE},
2167 };
2168
2169 static struct validate aqot_validate = {
2170   aqot_valobj,
2171   8,
2172   FILSYS_ID,
2173   "filsys_id = %d and type = '%s' and entity_id = %d",
2174   3,
2175   0,
2176   0,
2177   prefetch_filesys,
2178   followup_aqot,
2179 };
2180
2181 static struct validate uqot_validate = {
2182   aqot_valobj,
2183   8,
2184   FILSYS_ID,
2185   "filsys_id = %d AND type = '%s' AND entity_id = %d",
2186   3,
2187   0,
2188   0,
2189   setup_dqot,
2190   followup_aqot,
2191 };
2192
2193 static struct validate dqot_validate = {
2194   aqot_valobj,
2195   8,
2196   FILSYS_ID,
2197   "filsys_id = %d AND type = '%s' AND entity_id = %d",
2198   3,
2199   0,
2200   0,
2201   setup_dqot,
2202   followup_dqot,
2203 };
2204
2205 static char *gnfq_fields[] = {
2206   FILESYS, LOGIN,
2207   FILESYS, LOGIN, QUOTA, DIR, MACHINE, MOD1, MOD2, MOD3,
2208 };
2209
2210 static struct validate gnfq_validate = {
2211   VOwild0sort,
2212   2,
2213   0,
2214   0,
2215   0,
2216   0,
2217   access_filesys,
2218   0,
2219   followup_gqot,
2220 };
2221
2222 static char *gnqp_fields[] = {
2223   MACHINE, DIR,
2224   FILESYS, LOGIN, QUOTA, DIR, MACHINE, MOD1, MOD2, MOD3,
2225 };
2226
2227 static struct valobj gnqp_valobj[] = {
2228   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2229   {V_WILD, 1},
2230 };
2231
2232 static struct validate gnqp_validate = { gnqp_valobj, 2, };
2233
2234 static char *anfq_fields[] = {
2235   FILESYS, LOGIN, QUOTA,
2236 };
2237
2238 static struct validate anfq_validate = {
2239   VOfilsys0user1,
2240   3,
2241   FILSYS_ID,
2242   "filsys_id = %d AND type = 'USER' AND entity_id = %d",
2243   2,
2244   0, /* object ? */
2245   0,
2246   prefetch_filesys,
2247   followup_aqot,
2248 };
2249
2250 static struct validate unfq_validate = {
2251   VOfilsys0user1,
2252   3,
2253   FILSYS_ID,
2254   "filsys_id = %d AND type = 'USER' AND entity_id = %d",
2255   2,
2256   0,
2257   0,
2258   setup_dqot,
2259   followup_aqot,
2260 };
2261
2262 static struct validate dnfq_validate = {
2263   VOfilsys0user1,
2264   3,
2265   FILSYS_ID,
2266   "filsys_id = %d AND entity_id = %d",
2267   2,
2268   0,
2269   0,
2270   setup_dqot,
2271   followup_dqot,
2272 };
2273
2274 static char *gzcl_fields[] = {
2275   CLASS,
2276   CLASS, "xmt_type", "xmt_name", "sub_type", "sub_name",
2277   "iws_type", "iws_name", "iui_type", "iui_name", MOD1, MOD2, MOD3,
2278 };
2279
2280 static struct valobj gzcl_valobj[] = {
2281   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
2282   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
2283   {V_RLOCK, 0, ZEPHYR_TABLE, 0, ZEPH_ID, MR_DEADLOCK},
2284   {V_WILD, 0},
2285   {V_SORT, 0},
2286 };
2287 static struct validate gzcl_validate = {
2288   gzcl_valobj,
2289   5,
2290   0,
2291   0,
2292   0,
2293   0,
2294   0,
2295   0,
2296   followup_gzcl,
2297 };
2298
2299 static char *azcl_fields[] = {
2300   CLASS, "xmt_type", "xmt_name", "sub_type", "sub_name",
2301   "iws_type", "iws_name", "iui_type", "iui_name",
2302 };
2303
2304 static struct valobj azcl_valobj[] = {
2305   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
2306   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
2307   {V_LOCK, 0, ZEPHYR_TABLE, 0, ZEPH_ID, MR_DEADLOCK},
2308   {V_CHAR, 0, ZEPHYR_TABLE, CLASS},
2309   {V_TYPE, 1, 0, ACE_TYPE, 0, MR_ACE},
2310   {V_TYPEDATA, 2, 0, 0, LIST_ID, MR_ACE},
2311   {V_TYPE, 3, 0, ACE_TYPE, 0, MR_ACE},
2312   {V_TYPEDATA, 4, 0, 0, LIST_ID, MR_ACE},
2313   {V_TYPE, 5, 0, ACE_TYPE, 0, MR_ACE},
2314   {V_TYPEDATA, 6, 0, 0, LIST_ID, MR_ACE},
2315   {V_TYPE, 7, 0, ACE_TYPE, 0, MR_ACE},
2316   {V_TYPEDATA, 8, 0, 0, LIST_ID, MR_ACE},
2317 };
2318
2319 static struct validate azcl_validate = {
2320   azcl_valobj,
2321   12,
2322   CLASS,
2323   "class = '%s'",
2324   1,
2325   0,
2326   0,
2327   0,
2328   set_zephyr_modtime,
2329 };
2330
2331 static char *uzcl_fields[] = {
2332   CLASS, "newclass", "xmt_type", "xmt_name", "sub_type", "sub_name",
2333   "iws_type", "iws_name", "iui_type", "iui_name",
2334 };
2335
2336 static struct valobj uzcl_valobj[] = {
2337   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
2338   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
2339   {V_LOCK, 0, ZEPHYR_TABLE, 0, ZEPH_ID, MR_DEADLOCK},
2340   {V_RENAME, 1, ZEPHYR_TABLE, CLASS, 0, MR_NOT_UNIQUE},
2341   {V_TYPE, 2, 0, ACE_TYPE, 0, MR_ACE},
2342   {V_TYPEDATA, 3, 0, 0, LIST_ID, MR_ACE},
2343   {V_TYPE, 4, 0, ACE_TYPE, 0, MR_ACE},
2344   {V_TYPEDATA, 5, 0, 0, LIST_ID, MR_ACE},
2345   {V_TYPE, 6, 0, ACE_TYPE, 0, MR_ACE},
2346   {V_TYPEDATA, 7, 0, 0, LIST_ID, MR_ACE},
2347   {V_TYPE, 8, 0, ACE_TYPE, 0, MR_ACE},
2348   {V_TYPEDATA, 9, 0, 0, LIST_ID, MR_ACE},
2349 };
2350
2351 static struct validate uzcl_validate = {
2352   uzcl_valobj,
2353   12,
2354   CLASS,
2355   "class = '%s'",
2356   1,
2357   0,
2358   0,
2359   0,
2360   set_zephyr_modtime,
2361 };
2362
2363 static struct validate dzcl_validate = {
2364   0,
2365   0,
2366   CLASS,
2367   "class = '%s'",
2368   1,
2369   0,
2370   0,
2371   0,
2372   0,
2373 };
2374
2375 static char *gsha_fields[] = {
2376   MACHINE,
2377   MACHINE, ACE_TYPE, ACE_NAME, MOD1, MOD2, MOD3,
2378 };
2379
2380 static struct validate gsha_validate =
2381 {
2382   VOupwild0,
2383   1,
2384   0,
2385   0,
2386   0,
2387   0,
2388   0,
2389   0,
2390   followup_gsha,
2391 };
2392
2393 static char *asha_fields[] = {
2394   MACHINE, ACE_TYPE, ACE_NAME,
2395 };
2396
2397 static struct valobj asha_valobj[] = {
2398   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
2399   {V_ID, 0, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2400   {V_RLOCK, 0, LIST_TABLE, 0, LIST_ID, MR_DEADLOCK},
2401   {V_TYPE, 1, 0, ACE_TYPE, 0, MR_ACE},
2402   {V_TYPEDATA, 2, 0, 0, 0, MR_ACE},
2403 };
2404
2405 static struct validate asha_validate =
2406 {
2407   asha_valobj,
2408   5,
2409   MACH_ID,
2410   "mach_id = %d",
2411   1,
2412   MACH_ID,
2413   0,
2414   0,
2415   set_modtime_by_id,
2416 };
2417
2418 static char *gsvc_fields[] = {
2419   SERVICE,
2420   SERVICE, "protocol", "port", DESC, MOD1, MOD2, MOD3,
2421 };
2422
2423 static char *asvc_fields[] = {
2424   SERVICE, "protocol", "port", DESC,
2425 };
2426
2427 static struct valobj asvc_valobj[] = {
2428   {V_CHAR, 0, SERVICES_TABLE, NAME},
2429   {V_CHAR, 1, SERVICES_TABLE, "protocol"},
2430   {V_CHAR, 3, SERVICES_TABLE, DESC},
2431 };
2432
2433 static struct validate asvc_validate = {
2434   asvc_valobj,
2435   3,
2436   NAME,
2437   "name = '%s'",
2438   1,
2439   0,
2440   0,
2441   0,
2442   set_modtime,
2443 };
2444
2445 static char *gpce_fields[] = {
2446   "printer",
2447   "printer", "spooling_host", "spool_directory", "rprinter",
2448   "quotaserver", "authenticate", "price", COMMENTS,
2449   MOD1, MOD2, MOD3,
2450 };
2451
2452 static struct valobj gpce_valobj[]={
2453   {V_RLOCK, 0, USERS_TABLE, 0, USERS_ID, MR_DEADLOCK},
2454   {V_RLOCK, 0, MACHINE_TABLE, 0, MACH_ID, MR_DEADLOCK},
2455   {V_RLOCK, 0, PRINTCAP_TABLE, 0, MACH_ID, MR_DEADLOCK},
2456   {V_WILD, 0},
2457   {V_SORT, 0},
2458 };
2459
2460 static struct validate gpce_validate = {
2461   gpce_valobj,
2462   5,
2463   0,
2464   0,
2465   0,
2466   0,
2467   0,
2468   0,
2469   followup_gpce,
2470 };
2471
2472 static char *apce_fields[] = {
2473   "printer", "spooling_host", "spool_directory", "rprinter",
2474   "quotaserver", "authenticate", "price", COMMENTS,
2475   MOD1, MOD2, MOD3,
2476 };
2477
2478 static struct valobj apce_valobj[] = {
2479   {V_CHAR, 0, PRINTCAP_TABLE, NAME},
2480   {V_ID, 1, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2481   {V_LEN, 2, PRINTCAP_TABLE, "dir"},
2482   {V_LEN, 3, PRINTCAP_TABLE, "rp"},
2483   {V_ID, 4, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2484   {V_CHAR, 7, PRINTCAP_TABLE, "comments"},
2485 };
2486
2487 static struct validate apce_validate = {
2488   apce_valobj,
2489   6,
2490   NAME,
2491   "name = '%s'",
2492   1,
2493   0,
2494   0,
2495   0,
2496   set_modtime,
2497 };
2498
2499 static struct validate dpce_validate = {
2500   0,
2501   0,
2502   NAME,
2503   "name = '%s'",
2504   1,
2505   0,
2506   0,
2507   0,
2508   0,
2509 };
2510
2511 static char *gpcp_fields[] = {
2512   "printer",
2513   "printer", "spooling_host", "spool_directory", "rprinter", COMMENTS,
2514   MOD1, MOD2, MOD3,
2515 };
2516
2517 static char *gpdm_fields[] = {
2518   NAME,
2519   NAME, "rpcnum", "host", MOD1, MOD2, MOD3,
2520 };
2521
2522 static char *apdm_fields[] = {
2523   NAME, "rpcnum", "host"
2524 };
2525
2526 static struct valobj apdm_valobj[] = {
2527   {V_CHAR, 0, PALLADIUM_TABLE, NAME},
2528   {V_ID, 2, MACHINE_TABLE, NAME, MACH_ID, MR_MACHINE},
2529 };
2530
2531 static struct validate apdm_validate = {
2532   apdm_valobj,
2533   2,
2534   NAME,
2535   "name = '%s'",
2536   1,
2537   0,
2538   0,
2539   0,
2540   set_modtime,
2541 };
2542
2543 static struct validate dpdm_validate = {
2544   0,
2545   0,
2546   NAME,
2547   "name = '%s'",
2548   1,
2549   0,
2550   0,
2551   0,
2552   0,
2553 };
2554
2555 static char *gali_fields[] = {
2556   NAME, TYPE, "trans",
2557   NAME, TYPE, "trans",
2558 };
2559
2560 static char *aali_fields[] = {
2561   NAME, TYPE, "trans",
2562 };
2563
2564 static struct valobj aali_valobj[] = {
2565   {V_CHAR, 0, ALIAS_TABLE, NAME},
2566   {V_TYPE, 1, 0, ALIAS, 0, MR_TYPE},
2567   {V_CHAR, 2, ALIAS_TABLE, "trans"},
2568 };
2569
2570 static struct validate aali_validate = {
2571   aali_valobj,
2572   3,
2573   "trans",
2574   "name = '%s' and type = '%s' and trans = '%s'",
2575   3,
2576   0,
2577   0,
2578   0,
2579   0,
2580 };
2581
2582 static struct validate dali_validate =  /* DELETE_ALIAS */
2583 {
2584   0,
2585   0,
2586   "trans",
2587   "name = '%s' and type = '%s' and trans = '%s'",
2588   3,
2589   0,
2590   0,
2591   0,
2592   0,
2593 };
2594
2595 static char *gval_fields[] = {
2596   NAME, "value",
2597 };
2598
2599 static struct valobj gval_valobj[] = {
2600   {V_NAME, 0, NUMVALUES_TABLE, NAME, 0, MR_NO_MATCH},
2601 };
2602
2603 static struct validate gval_validate = {
2604   gval_valobj,
2605   1,
2606   0,
2607   0,
2608   0,
2609   0,
2610   0,
2611   0,
2612   0,
2613 };
2614
2615 static char *aval_fields[] = {
2616   NAME, "value",
2617 };
2618
2619 static struct valobj aval_valobj[] = {
2620   {V_CHAR, 0, NUMVALUES_TABLE, NAME},
2621 };
2622
2623 static struct validate aval_validate =  /* for aval, uval, and dval */
2624 {
2625   aval_valobj,
2626   1,
2627   NAME,
2628   "name = '%s'",
2629   1,
2630   0,
2631   0,
2632   0,
2633   0,
2634 };
2635
2636 static char *dval_fields[] = {
2637   NAME,
2638 };
2639
2640 static char *gats_fields[] = {
2641   "table_name", "appends", "updates", "deletes", MOD1, MOD2, MOD3,
2642 };
2643
2644 static char *_sdl_fields[] = {
2645     "level",
2646 };
2647
2648 static struct validate _sdl_validate =
2649 {
2650     0,
2651     0,
2652     (char *)0,
2653     (char *)0,
2654     0,
2655     0,
2656     0,
2657     0,
2658     _sdl_followup,
2659 };
2660
2661
2662 \f
2663 /* Generalized Query Definitions */
2664
2665 /* Note: For any query which uses prefetch_value, the vcnt should be
2666  * one less than the number of %-format specifiers in the tlist.
2667  */
2668
2669 struct query Queries2[] = {
2670   {
2671     /* Q_GALO - GET_ALL_LOGINS */
2672     "get_all_logins",
2673     "galo",
2674     RETRIEVE,
2675     "u",
2676     USERS_TABLE,
2677     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle FROM users u",
2678     galo_fields,
2679     6,
2680     "u.users_id != 0",
2681     0,
2682     &VDsort0,
2683   },
2684
2685   {
2686     /* Q_GAAL - GET_ALL_ACTIVE_LOGINS */
2687     "get_all_active_logins",
2688     "gaal",
2689     RETRIEVE,
2690     "u",
2691     USERS_TABLE,
2692     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle FROM users u",
2693     galo_fields,
2694     6,
2695     "u.status = 1",
2696     0,
2697     &VDsort0,
2698   },
2699
2700   {
2701     /* Q_GUAL - GET_USER_ACCOUNT_BY_LOGIN */
2702     "get_user_account_by_login",
2703     "gual",
2704     RETRIEVE,
2705     "u",
2706     USERS_TABLE,
2707     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, str.string, u.signature, u.secure, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u, strings str",
2708     gual_fields,
2709     15,
2710     "u.login LIKE '%s' ESCAPE '*' AND u.users_id != 0 AND u.comments = str.string_id",
2711     1,
2712     &gubl_validate,
2713   },
2714
2715   {
2716     /* Q_GUAU - GET_USER_ACCOUNT_BY_UID */
2717     "get_user_account_by_uid",
2718     "guau",
2719     RETRIEVE,
2720     "u",
2721     USERS_TABLE,
2722     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, str.string, u.signature, u.secure, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u, strings str",
2723     guau_fields,
2724     15,
2725     "u.unix_uid = %s AND u.users_id != 0 AND u.comments = str.string_id",
2726     1,
2727     &gubu_validate,
2728   },
2729
2730   {
2731     /* Q_GUAN - GET_USER_ACCOUNT_BY_NAME */
2732     "get_user_account_by_name",
2733     "guan",
2734     RETRIEVE,
2735     "u",
2736     USERS_TABLE,
2737     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, str.string, u.signature, u.secure, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u, strings str",
2738     guan_fields,
2739     15,
2740     "u.first LIKE '%s' ESCAPE '*' AND u.last LIKE '%s' ESCAPE '*' AND u.users_id != 0 and u.comments = str.string_id",
2741     2,
2742     &guan_validate,
2743   },
2744
2745   {
2746     /* Q_GUAC - GET_USER_ACCOUNT_BY_CLASS */
2747     "get_user_account_by_class",
2748     "guac",
2749     RETRIEVE,
2750     "u",
2751     USERS_TABLE,
2752     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, str.string, u.signature, u.secure, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u, strings str",
2753     guac_fields,
2754     15,
2755     "u.type = UPPER('%s') AND u.users_id != 0 AND u.comments = str.string_id",
2756     1,
2757     &VDsortf,
2758   },
2759
2760   {
2761     /* Q_GUAM - GET_USER_ACCOUNT_BY_MITID */
2762     "get_user_account_by_id",
2763     "guai",
2764     RETRIEVE,
2765     "u",
2766     USERS_TABLE,
2767     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, str.string, u.signature, u.secure, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u, strings str",
2768     guam_fields,
2769     15,
2770     "u.clearid LIKE '%s' ESCAPE '*' AND u.users_id != 0 AND u.comments = str.string_id",
2771     1,
2772     &VDwildsortf,
2773   },
2774
2775   {
2776     /* Q_GUBL - GET_USER_BY_LOGIN */
2777     "get_user_by_login",
2778     "gubl",
2779     RETRIEVE,
2780     "u",
2781     USERS_TABLE,
2782     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u",
2783     gubl_fields,
2784     12,
2785     "u.login LIKE '%s' ESCAPE '*' AND u.users_id != 0",
2786     1,
2787     &gubl_validate,
2788   },
2789
2790   {
2791     /* Q_GUBU - GET_USER_BY_UID */
2792     "get_user_by_uid",
2793     "gubu",
2794     RETRIEVE,
2795     "u",
2796     USERS_TABLE,
2797     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u",
2798     gubu_fields,
2799     12,
2800     "u.unix_uid = %s AND u.users_id != 0",
2801     1,
2802     &gubu_validate,
2803   },
2804
2805   {
2806     /* Q_GUBN - GET_USER_BY_NAME */
2807     "get_user_by_name",
2808     "gubn",
2809     RETRIEVE,
2810     "u",
2811     USERS_TABLE,
2812     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u",
2813     gubn_fields,
2814     12,
2815     "u.first LIKE '%s' ESCAPE '*' AND u.last LIKE '%s' ESCAPE '*' AND u.users_id != 0",
2816     2,
2817     &gubn_validate,
2818   },
2819
2820   {
2821     /* Q_GUBC - GET_USER_BY_CLASS */
2822     "get_user_by_class",
2823     "gubc",
2824     RETRIEVE,
2825     "u",
2826     USERS_TABLE,
2827     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u",
2828     gubc_fields,
2829     12,
2830     "u.type = UPPER('%s') AND u.users_id != 0",
2831     1,
2832     &VDsortf,
2833   },
2834
2835   {
2836     /* Q_GUBM - GET_USER_BY_MITID */
2837     "get_user_by_mitid",
2838     "gubm",
2839     RETRIEVE,
2840     "u",
2841     USERS_TABLE,
2842     "u.login, u.unix_uid, u.shell, u.last, u.first, u.middle, u.status, u.clearid, u.type, TO_CHAR(u.modtime, 'DD-mon-YYYY HH24:MI:SS'), u.modby, u.modwith FROM users u",
2843     gubm_fields,
2844     12,
2845     "u.clearid LIKE '%s' ESCAPE '*' AND u.users_id != 0",
2846     1,
2847     &VDwildsortf,
2848   },
2849
2850   {
2851     /* Q_AUAC - ADD_USER_ACCOUNT */  /* uses prefetch_value() for users_id */
2852     "add_user_account",
2853     "auac",
2854     APPEND,
2855     "u",
2856     USERS_TABLE,
2857     "INTO users (login, unix_uid, shell, last, first, middle, status, clearid, type, comments, signature, secure, users_id) VALUES ('%s', %s, '%s', NVL('%s',CHR(0)), NVL('%s',CHR(0)), NVL('%s',CHR(0)), %s, NVL('%s',CHR(0)), '%s', %d, LENGTH(NVL('%s',CHR(0))), %s, %s)", /* followup_ausr fixes signature field */
2858     auac_fields,
2859     12,
2860     (char *)0,
2861     0,
2862     &auac_validate,
2863   },
2864
2865   {
2866     /* Q_AUSR - ADD_USER */  /* uses prefetch_value() for users_id */
2867     "add_user",
2868     "ausr",
2869     APPEND,
2870     "u",
2871     USERS_TABLE,
2872     "INTO users (login, unix_uid, shell, last, first, middle, status, clearid, type, comments, signature, secure, users_id) VALUES ('%s', %s, '%s', NVL('%s',CHR(0)), NVL('%s',CHR(0)), NVL('%s',CHR(0)), %s, NVL('%s',CHR(0)), '%s', 0, CHR(0), 0, %s)",
2873     auac_fields,
2874     9,
2875     0,
2876     0,
2877     &ausr_validate,
2878   },
2879
2880   {
2881     /* Q_RUSR - REGISTER_USER */
2882     "register_user",
2883     "rusr",
2884     APPEND,
2885     0,
2886     0,
2887     0,
2888     rusr_fields,
2889     3,
2890     0,
2891     0,
2892     &rusr_validate,
2893   },
2894
2895   {
2896     /* Q_UUAC - UPDATE_USER_ACCOUNT */
2897     "update_user_account",
2898     "uuac",
2899     UPDATE,
2900     "u",
2901     USERS_TABLE,
2902     "users SET login = '%s', unix_uid = %s, shell = '%s', last = NVL('%s',CHR(0)), first = NVL('%s',CHR(0)), middle = NVL('%s',CHR(0)), status = %s, clearid = NVL('%s',CHR(0)), type = '%s', comments = %d, signature = LENGTH(NVL('%s',CHR(0))), secure = %s", /* followup_uuac fixes signature */
2903     uuac_fields,
2904     12,
2905     "users_id = %d",
2906     1,
2907     &uuac_validate,
2908   },
2909
2910   {
2911     /* Q_UUSR - UPDATE_USER */
2912     "update_user",
2913     "uusr",
2914     UPDATE,
2915     "u",
2916     USERS_TABLE,
2917     "users SET login = '%s', unix_uid = %s, shell = '%s', last = NVL('%s',CHR(0)), first = NVL('%s',CHR(0)), middle = NVL('%s',CHR(0)), status = %s, clearid = NVL('%s',CHR(0)),  type = '%s'",
2918     uuac_fields,
2919     9,
2920     "users_id = %d",
2921     1,
2922     &uusr_validate,
2923   },
2924
2925   {
2926     /* Q_UUSH - UPDATE_USER_SHELL */
2927     "update_user_shell",
2928     "uush",
2929     UPDATE,
2930     "u",
2931     USERS_TABLE,
2932     "users SET shell = '%s'",
2933     uush_fields,
2934     1,
2935     "users_id = %d",
2936     1,
2937     &uush_validate,
2938   },
2939
2940   {
2941     /* Q_UUST - UPDATE_USER_STATUS */
2942     "update_user_status",
2943     "uust",
2944     UPDATE,
2945     "u",
2946     USERS_TABLE,
2947     "users SET status = %s",
2948     uust_fields,
2949     1,
2950     "users_id = %d",
2951     1,
2952     &uust_validate,
2953   },
2954
2955   {
2956     /* Q_UUSS - UPDATE_USER_SECURITY_STATUS */
2957     "update_user_security_status",
2958     "uuss",
2959     UPDATE,
2960     "u",
2961     USERS_TABLE,
2962     "users SET secure = %s",
2963     uuss_fields,
2964     1,
2965     "users_id = %d",
2966     1,
2967     &uust_validate,
2968   },
2969
2970   {
2971     /* Q_DUSR - DELETE_USER */
2972     "delete_user",
2973     "dusr",
2974     DELETE,
2975     "u",
2976     USERS_TABLE,
2977     (char *)0,
2978     dusr_fields,
2979     0,
2980     "users_id = %d",
2981     1,
2982     &dusr_validate,
2983   },
2984
2985   {
2986     /* Q_DUBU - DELETE_USER_BY_UID */
2987     "delete_user_by_uid",
2988     "dubu",
2989     DELETE,
2990     "u",
2991     USERS_TABLE,
2992     (char *)0,
2993     dubu_fields,
2994     0,
2995     "users_id = %d",
2996     1,
2997     &dubu_validate,
2998   },
2999
3000   {
3001     /* Q_GKUM - GET_KERBEROS_USER_MAP */
3002     "get_kerberos_user_map",
3003     "gkum",
3004     RETRIEVE,
3005     "k",
3006     KRBMAP_TABLE,
3007     "u.login, str.string FROM krbmap km, users u, strings str",
3008     gkum_fields,
3009     2,
3010     "u.login LIKE '%s' ESCAPE '*' AND str.string LIKE '%s' ESCAPE '*' AND km.users_id = u.users_id AND km.string_id = str.string_id",
3011     2,
3012     &VDwild2sort2,
3013   },
3014
3015   {
3016     /* Q_AKUM - ADD_KERBEROS_USER_MAP */
3017     "add_kerberos_user_map",
3018     "akum",
3019     APPEND,
3020     "k",
3021     KRBMAP_TABLE,
3022     "INTO krbmap (users_id, string_id) VALUES (%d, %d)",
3023     akum_fields,
3024     2,
3025     0,
3026     0,
3027     &akum_validate,
3028   },
3029
3030   {
3031     /* Q_DKUM - DELETE_KERBEROS_USER_MAP */
3032     "delete_kerberos_user_map",
3033     "dkum",
3034     DELETE,
3035     "k",
3036     KRBMAP_TABLE,
3037     0,
3038     akum_fields,
3039     0,
3040     "users_id = %d AND string_id = %d",
3041     2,
3042     &dkum_validate,
3043   },
3044
3045   {
3046     /* Q_GFBL - GET_FINGER_BY_LOGIN */
3047     "get_finger_by_login",
3048     "gfbl",
3049     RETRIEVE,
3050     "u",
3051     USERS_TABLE,
3052     "login, fullname, nickname, home_addr, home_phone, office_addr, office_phone, department, affiliation, TO_CHAR(fmodtime, 'DD-mon-YYYY HH24:MI:SS'), fmodby, fmodwith FROM users",
3053     gfbl_fields,
3054     12,
3055     "users_id = %d",
3056     1,
3057     &gfbl_validate,
3058   },
3059
3060   {
3061     /* Q_UFBL - UPDATE_FINGER_BY_LOGIN */
3062     "update_finger_by_login",
3063     "ufbl",
3064     UPDATE,
3065     "u",
3066     USERS_TABLE,
3067     "users SET fullname= NVL('%s',CHR(0)),nickname= NVL('%s',CHR(0)),home_addr= NVL('%s',CHR(0)),home_phone= NVL('%s',CHR(0)),office_addr= NVL('%s',CHR(0)),office_phone= NVL('%s',CHR(0)),department= NVL('%s',CHR(0)),affiliation= NVL('%s',CHR(0))",
3068     ufbl_fields,
3069     8,
3070     "users_id = %d",
3071     1,
3072     &ufbl_validate,
3073   },
3074
3075   {
3076     /* Q_GPOB - GET_POBOX */
3077     "get_pobox",
3078     "gpob",
3079     RETRIEVE,
3080     "u",
3081     USERS_TABLE,
3082     "login, potype, pop_id || ':' || box_id, TO_CHAR(pmodtime, 'DD-mon-YYYY HH24:MI:SS'), pmodby, pmodwith FROM users",
3083     gpob_fields,
3084     6,
3085     "users_id = %d",
3086     1,
3087     &gpob_validate,
3088   },
3089
3090   {
3091     /* Q_GAPO - GET_ALL_POBOXES */
3092     "get_all_poboxes",
3093     "gapo",
3094     RETRIEVE,
3095     "u",
3096     USERS_TABLE,
3097     "login, potype, pop_id || ':' || box_id FROM users",
3098     gpox_fields,
3099     3,
3100     "potype != 'NONE'",
3101     0,
3102     &gpox_validate,
3103   },
3104
3105   {
3106     /* Q_GPOP - GET_POBOXES_POP */
3107     "get_poboxes_pop",
3108     "gpop",
3109     RETRIEVE,
3110     "u",
3111     USERS_TABLE,
3112     "login, potype, pop_id || ':' || box_id FROM users",
3113     gpox_fields,
3114     3,
3115     "potype = 'POP'",
3116     0,
3117     &gpox_validate
3118   },
3119
3120   {
3121     /* Q_GPOF - GET_POBOXES_SMTP */
3122     "get_poboxes_smtp",
3123     "gpos",
3124     RETRIEVE,
3125     "u",
3126     USERS_TABLE,
3127     "login, potype, pop_id || ':' || box_id FROM users",
3128     gpox_fields,
3129     3,
3130     "potype = 'SMTP'",
3131     0,
3132     &gpox_validate
3133   },
3134
3135   {
3136     /* Q_SPOB - SET_POBOX */
3137     "set_pobox",
3138     "spob",
3139     UPDATE,
3140     0,
3141     USERS_TABLE,
3142     0,
3143     spob_fields,
3144     3,
3145     (char *)0,
3146     0,
3147     &spob_validate,
3148   },
3149
3150   {
3151     /* Q_SPOP - SET_POBOX_POP */
3152     "set_pobox_pop",
3153     "spop",
3154     UPDATE,
3155     "u",
3156     USERS_TABLE,
3157     "users SET potype = 'POP'",
3158     spob_fields,
3159     0,
3160     "users_id = %d",
3161     1,
3162     &spop_validate,
3163   },
3164
3165   {
3166     /* Q_DPOB - DELETE_POBOX */
3167     "delete_pobox",
3168     "dpob",
3169     UPDATE,
3170     "u",
3171     USERS_TABLE,
3172     "users SET potype = 'NONE'",
3173     spob_fields,
3174     0,
3175     "users_id = %d",
3176     1,
3177     &dpob_validate,
3178   },
3179
3180   {
3181     /* Q_GHST - GET_HOST */
3182     "get_host",
3183     "ghst",
3184     RETRIEVE,
3185     "m",
3186     MACHINE_TABLE,
3187     "m.name, m.vendor, m.model, m.os, m.location, m.contact, m.use, m.status, TO_CHAR(m.statuschange, 'DD-mon-YYYY HH24:MI:SS'), s.name, m.address, m.owner_type, m.owner_id, m.acomment, m.ocomment, TO_CHAR(m.created, 'DD-mon-YYYY HH24:MI:SS'), m.creator, TO_CHAR(m.inuse, 'DD-mon-YYYY HH24:MI:SS'), TO_CHAR(m.modtime, 'DD-mon-YYYY HH24:MI:SS'), m.modby, m.modwith FROM machine m, subnet s",
3188     ghst_fields,
3189     21,
3190     "m.name LIKE '%s' ESCAPE '*' AND m.address LIKE '%s' ESCAPE '*' AND m.location LIKE '%s' ESCAPE '*' AND s.name LIKE '%s' ESCAPE '*' AND m.mach_id != 0 AND s.snet_id = m.snet_id",
3191     4,
3192     &ghst_validate,
3193   },
3194
3195   {
3196     /* Q_AHST - ADD_HOST */ /* uses prefetch_value() for mach_id */
3197     "add_host",
3198     "ahst",
3199     APPEND,
3200     "m",
3201     MACHINE_TABLE,
3202     "INTO machine (name, vendor, model, os, location, contact, use, status, statuschange, snet_id, address, owner_type, owner_id, acomment, ocomment, created, inuse, mach_id, creator) VALUES (UPPER('%s'),NVL(UPPER('%s'),CHR(0)),NVL(UPPER('%s'),CHR(0)),NVL(UPPER('%s'),CHR(0)),NVL(UPPER('%s'),CHR(0)),NVL('%s',CHR(0)),%s,%s,SYSDATE,%d,'%s','%s',%d,%d,%d,SYSDATE,SYSDATE,%s,%s)",
3203     ahst_fields,
3204     14,
3205     0,
3206     0,
3207     &ahst_validate,
3208   },
3209
3210   {
3211     /* Q_UHST - UPDATE_HOST */
3212     "update_host",
3213     "uhst",
3214     UPDATE,
3215     "m",
3216     MACHINE_TABLE,
3217     "machine SET name=NVL(UPPER('%s'),CHR(0)),vendor=NVL(UPPER('%s'),CHR(0)),model=NVL(UPPER('%s'),CHR(0)),os=NVL(UPPER('%s'),CHR(0)),location=NVL(UPPER('%s'),CHR(0)),contact=NVL('%s',CHR(0)),use=%s,status=%s,snet_id=%d,address='%s',owner_type='%s',owner_id=%d,acomment=%d,ocomment=%d",
3218     uhst_fields,
3219     14,
3220     "mach_id = %d",
3221     1,
3222     &uhst_validate,
3223   },
3224
3225   {
3226     /* Q_DHST - DELETE_HOST */
3227     "delete_host",
3228     "dhst",
3229     DELETE,
3230     "m",
3231     MACHINE_TABLE,
3232     (char *)0,
3233     dhst_fields,
3234     0,
3235     "mach_id = %d",
3236     1,
3237     &dhst_validate,
3238   },
3239
3240   {
3241     /* Q_GMAC - GET_MACHINE */
3242     "get_machine",
3243     "gmac",
3244     RETRIEVE,
3245     "m",
3246     MACHINE_TABLE,
3247     "name, vendor, TO_CHAR(modtime, 'DD-mon-YYYY HH24:MI:SS'), modby, modwith FROM machine",
3248     gmac_fields,
3249     5,
3250     "name LIKE '%s' ESCAPE '*' AND mach_id != 0",
3251     1,
3252     &VDupwildsortf,
3253   },
3254
3255   {
3256     /* Q_GHAL - GET_HOSTALIAS */
3257     "get_hostalias",
3258     "ghal",
3259     RETRIEVE,
3260     "a",
3261     HOSTALIAS_TABLE,
3262     "a.name, m.name FROM hostalias a, machine m",
3263     ghal_fields,
3264     2,
3265     "m.mach_id = a.mach_id and a.name LIKE '%s' ESCAPE '*' AND m.name LIKE '%s' ESCAPE '*'",
3266     2,
3267     &ghal_validate,
3268   },
3269
3270   {
3271     /* Q_AHAL - ADD_HOSTALIAS */
3272     "add_hostalias",
3273     "ahal",
3274     APPEND,
3275     "a",
3276     HOSTALIAS_TABLE,
3277     "INTO hostalias (name, mach_id) VALUES (UPPER('%s'),%d)",
3278     ghal_fields,
3279     2,
3280     0,
3281     0,
3282     &ahal_validate,
3283   },
3284
3285   {
3286     /* Q_DHAL - DELETE_HOSTALIAS */
3287     "delete_hostalias",
3288     "dhal",
3289     DELETE,
3290     "a",
3291     HOSTALIAS_TABLE,
3292     (char *)0,
3293     ghal_fields,
3294     0,
3295     "name = UPPER('%s') AND mach_id = %d",
3296     2,
3297     &dhal_validate,
3298   },
3299
3300   {
3301     /* Q_GSNT - GET_SUBNET */
3302     "get_subnet",
3303     "gsnt",
3304     RETRIEVE,
3305     "s",
3306     SUBNET_TABLE,
3307     "name, description, saddr, mask, low, high, prefix, owner_type, owner_id, TO_CHAR(modtime, 'DD-mon-YYYY HH24:MI:SS'), modby, modwith FROM subnet",
3308     gsnt_fields,
3309     12,
3310     "name LIKE '%s' ESCAPE '*' and snet_id != 0",
3311     1,
3312     &gsnt_validate,
3313   },
3314
3315   {
3316     /* Q_ASNT - ADD_SUBNET */
3317     "add_subnet",
3318     "asnt",
3319     APPEND,
3320     "s",
3321     SUBNET_TABLE,
3322     "INTO subnet (name, description, saddr, mask, low, high, prefix, owner_type, owner_id, snet_id) VALUES (UPPER('%s'), NVL('%s',CHR(0)), %s, %s, %s, %s, NVL('%s',CHR(0)), '%s', %d, %s)",
3323     asnt_fields,
3324     9,
3325     0,
3326     0,
3327     &asnt_validate,
3328   },
3329
3330   {
3331     /* Q_USNT - UPDATE_SUBNET */
3332     "update_subnet",
3333     "usnt",
3334     UPDATE,
3335     "s",
3336     SUBNET_TABLE,
3337     "subnet SET name=UPPER('%s'), description=NVL('%s',CHR(0)), saddr=%s, mask=%s, low=%s, high=%s, prefix=NVL('%s',CHR(0)), owner_type='%s', owner_id=%d",
3338     usnt_fields,
3339     9,
3340     "snet_id = %d",
3341     1,
3342     &usnt_validate,
3343   },
3344
3345   {
3346     /* Q_DSNT - DELETE_SUBNET */
3347     "delete_subnet",
3348     "dsnt",
3349     DELETE,
3350     "s",
3351     SUBNET_TABLE,
3352     (char *)0,
3353     dsnt_fields,
3354     0,
3355     "snet_id = %d",
3356     1,
3357     &dsnt_validate,
3358   },
3359
3360   {
3361     /* Q_GCLU - GET_CLUSTER */
3362     "get_cluster",
3363     "gclu",
3364     RETRIEVE,
3365     "c",
3366     CLUSTER_TABLE,
3367     "name, description, location, TO_CHAR(modtime, 'DD-mon-YYYY HH24:MI:SS'), modby, modwith FROM clusters",
3368     gclu_fields,
3369     6,
3370     "name LIKE '%s' ESCAPE '*' AND clu_id != 0",
3371     1,
3372     &VDwildsortf,
3373   },
3374
3375   {
3376     /* Q_ACLU - ADD_CLUSTER */ /* uses prefetch_value() for clu_id */
3377     "add_cluster",
3378     "aclu",
3379     APPEND,
3380     "c",
3381     CLUSTER_TABLE,
3382     "INTO clusters (name, description, location, clu_id) VALUES ('%s',NVL('%s',CHR(0)),NVL('%s',CHR(0)),%s)",
3383     aclu_fields,
3384     3,
3385     0,
3386     0,
3387     &aclu_validate,
3388   },
3389
3390   {
3391     /* Q_UCLU - UPDATE_CLUSTER */
3392     "update_cluster",
3393     "uclu",
3394     UPDATE,
3395     "c",
3396     CLUSTER_TABLE,
3397     "clusters SET name = '%s', description = NVL('%s',CHR(0)), location = NVL('%s',CHR(0))",
3398     uclu_fields,
3399     3,
3400     "clu_id = %d",
3401     1,
3402     &uclu_validate,
3403   },
3404
3405   {
3406     /* Q_DCLU - DELETE_CLUSTER */
3407     "delete_cluster",
3408     "dclu",
3409     DELETE,
3410     "c",
3411     CLUSTER_TABLE,
3412     (char *)0,
3413     dclu_fields,
3414     0,
3415     "clu_id = %d",
3416     1,
3417     &dclu_validate,
3418   },
3419
3420   {
3421     /* Q_GMCM - GET_MACHINE_TO_CLUSTER_MAP */
3422     "get_machine_to_cluster_map",
3423     "gmcm",
3424     RETRIEVE,
3425     "mcm",
3426     MCMAP_TABLE,
3427     "m.name, c.name FROM machine m, clusters c, mcmap mcm",
3428     gmcm_fields,
3429     2,
3430     "m.name LIKE '%s' ESCAPE '*' AND c.name LIKE '%s' ESCAPE '*' AND mcm.clu_id = c.clu_id AND mcm.mach_id = m.mach_id",
3431     2,
3432     &gmcm_validate,
3433   },
3434
3435   {
3436     /* Q_AMTC - ADD_MACHINE_TO_CLUSTER */
3437     "add_machine_to_cluster",
3438     "amtc",
3439     APPEND,
3440     "mcm",
3441     MCMAP_TABLE,
3442     "INTO mcmap (mach_id, clu_id) VALUES (%d, %d)",
3443     gmcm_fields,
3444     2,
3445     0,
3446     0,
3447     &amtc_validate,
3448   },
3449
3450   {
3451     /* Q_DMFC - DELETE_MACHINE_FROM_CLUSTER */
3452     "delete_machine_from_cluster",
3453     "dmfc",
3454     DELETE,
3455     "mcm",
3456     MCMAP_TABLE,
3457     0,
3458     gmcm_fields,
3459     0,
3460     "mach_id = %d AND clu_id = %d",
3461     2,
3462     &amtc_validate,
3463   },
3464
3465   {
3466     /* Q_GCLD - GET_CLUSTER_DATA */
3467     "get_cluster_data",
3468     "gcld",
3469     RETRIEVE,
3470     "svc",
3471     SVC_TABLE,
3472     "c.name, svc.serv_label, svc.serv_cluster FROM svc svc, clusters c",
3473     gcld_fields,
3474     3,
3475     "c.clu_id = svc.clu_id AND c.name LIKE '%s' ESCAPE '*' AND svc.serv_label LIKE '%s' ESCAPE '*'",
3476     2,
3477     &VDwild2sort2,
3478   },
3479
3480   {
3481     /* Q_ACLD - ADD_CLUSTER_DATA */
3482     "add_cluster_data",
3483     "acld",
3484     APPEND,
3485     "svc",
3486     SVC_TABLE,
3487     "INTO svc (clu_id, serv_label, serv_cluster) VALUES (%d,'%s','%s')",
3488     acld_fields,
3489     3,
3490     (char *)0,
3491     0,
3492     &acld_validate,
3493   },
3494
3495   {
3496     /* Q_DCLD - DELETE_CLUSTER_DATA */
3497     "delete_cluster_data",
3498     "dcld",
3499     DELETE,
3500     "svc",
3501     SVC_TABLE,
3502     (char *)0,
3503     acld_fields,
3504     0,
3505     "clu_id = %d AND serv_label = '%s' AND serv_cluster = '%s'",
3506     3,
3507     &dcld_validate,
3508   },
3509
3510   {
3511     /* Q_GLIN - GET_LIST_INFO */
3512     "get_list_info",
3513     "glin",
3514     RETRIEVE,
3515     0,
3516     LIST_TABLE,
3517     0,
3518     glin_fields,
3519     13,
3520     0,
3521     1,
3522     &glin_validate,
3523   },
3524
3525   {
3526     /* Q_EXLN - EXPAND_LIST_NAMES */
3527     "expand_list_names",
3528     "exln",
3529     RETRIEVE,
3530     "l",
3531     LIST_TABLE,
3532     "name FROM list",
3533     glin_fields,
3534     1,
3535     "name LIKE '%s' ESCAPE '*' AND list_id != 0",
3536     1,
3537     &VDwild0,
3538   },
3539
3540   {
3541     /* Q_ALIS - ADD_LIST */ /* uses prefetch_value() for list_id */
3542     "add_list",
3543     "alis",
3544     APPEND,
3545     "l",
3546     LIST_TABLE,
3547     "INTO list (name, active, publicflg, hidden, maillist, grouplist, gid, acl_type, acl_id, description, list_id) VALUES ('%s',%s,%s,%s,%s,%s,%s,'%s',%d,NVL('%s',CHR(0)),%s)",
3548     alis_fields,
3549     10,
3550     0,
3551     0,
3552     &alis_validate,
3553   },
3554
3555   {
3556     /* Q_ULIS - UPDATE_LIST */
3557     "update_list",
3558     "ulis",
3559     UPDATE,
3560     "l",
3561     LIST_TABLE,
3562     "list SET name='%s', active=%s, publicflg=%s, hidden=%s, maillist=%s, grouplist=%s, gid=%s, acl_type='%s', acl_id=%d, description=NVL('%s',CHR(0))",
3563     ulis_fields,
3564     10,
3565     "list_id = %d",
3566     1,
3567     &ulis_validate,
3568   },
3569
3570   {
3571     /* Q_DLIS - DELETE_LIST */
3572     "delete_list",
3573     "dlis",
3574     DELETE,
3575     "l",
3576     LIST_TABLE,
3577     (char *)0,
3578     dlis_fields,
3579     0,
3580     "list_id = %d",
3581     1,
3582     &dlis_validate,
3583   },
3584
3585   {
3586     /* Q_AMTL - ADD_MEMBER_TO_LIST */
3587     "add_member_to_list",
3588     "amtl",
3589     APPEND,
3590     0,
3591     IMEMBERS_TABLE,
3592     0,
3593     amtl_fields,
3594     3,
3595     (char *)0,
3596     0,
3597     &amtl_validate,
3598   },
3599
3600   {
3601     /* Q_DMFL - DELETE_MEMBER_FROM_LIST */
3602     "delete_member_from_list",
3603     "dmfl",
3604     DELETE,
3605     0,
3606     IMEMBERS_TABLE,
3607     (char *)0,
3608     amtl_fields,
3609     0,
3610     0,
3611     3,
3612     &dmfl_validate,
3613   },
3614
3615   {
3616     /* Q_GAUS - GET_ACE_USE */
3617     "get_ace_use",
3618     "gaus",
3619     RETRIEVE,
3620     0,
3621     0,
3622     0,
3623     gaus_fields,
3624     2,
3625     0,
3626     2,
3627     &gaus_validate,
3628   },
3629
3630   {
3631     /* Q_QGLI - QUALIFIED_GET_LISTS */
3632     "qualified_get_lists",
3633     "qgli",
3634     RETRIEVE,
3635     0,
3636     LIST_TABLE,
3637     0,
3638     qgli_fields,
3639     1,
3640     0,
3641     5,
3642     &qgli_validate,
3643   },
3644
3645   {
3646     /* Q_GMOL - GET_MEMBERS_OF_LIST */
3647     "get_members_of_list",
3648     "gmol",
3649     RETRIEVE,
3650     (char *)0,
3651     IMEMBERS_TABLE,
3652     (char *)0,
3653     gmol_fields,
3654     2,
3655     (char *)0,
3656     1,
3657     &gmol_validate,
3658   },
3659
3660   {
3661     /* Q_GEML - GET_END_MEMBERS_OF_LIST */
3662     "get_end_members_of_list",
3663     "geml",
3664     RETRIEVE,
3665     (char *)0,
3666     IMEMBERS_TABLE,
3667     (char *)0,
3668     gmol_fields,
3669     0,
3670     (char *)0,
3671     1,
3672     &geml_validate,
3673   },
3674
3675   {
3676     /* Q_GLOM - GET_LISTS_OF_MEMBER */
3677     "get_lists_of_member",
3678     "glom",
3679     RETRIEVE,
3680     0,
3681     IMEMBERS_TABLE,
3682     0,
3683     glom_fields,
3684     6,
3685     0,
3686     2,
3687     &glom_validate,
3688   },
3689
3690   {
3691     /* Q_CMOL - COUNT_MEMBERS_OF_LIST */
3692     "count_members_of_list",
3693     "cmol",
3694     RETRIEVE,
3695     0,
3696     IMEMBERS_TABLE,
3697     0,
3698     cmol_fields,
3699     1,
3700     0,
3701     1,
3702     &cmol_validate,
3703   },
3704
3705   {
3706     /* Q_GSIN - GET_SERVER_INFO */
3707     "get_server_info",
3708     "gsin",
3709     RETRIEVE,
3710     "s",
3711     SERVERS_TABLE,
3712     "name, update_int, target_file, script, dfgen, dfcheck, type, enable, inprogress, harderror, errmsg, acl_type, acl_id, TO_CHAR(modtime, 'DD-mon-YYYY HH24:MI:SS'), modby, modwith FROM servers",
3713     gsin_fields,
3714     16,
3715     "name LIKE '%s' ESCAPE '*'",
3716     1,
3717     &gsin_validate,
3718   },
3719
3720   {
3721     /* Q_QGSV - QUALIFIED_GET_SERVER */
3722     "qualified_get_server",
3723     "qgsv",
3724     RETRIEVE,
3725     0,
3726     SERVERS_TABLE,
3727     0,
3728     qgsv_fields,
3729     1,
3730     0,
3731     3,
3732     &qgsv_validate,
3733   },
3734
3735   {
3736     /* Q_ASIN - ADD_SERVER_INFO */
3737     "add_server_info",
3738     "asin",
3739     APPEND,
3740     "s",
3741     SERVERS_TABLE,
3742     "INTO servers (name, update_int, target_file, script, type, enable, acl_type, acl_id) VALUES (UPPER('%s'),%s,'%s','%s','%s',%s,'%s',%d)",
3743     asin_fields,
3744     8,
3745     (char *)0,
3746     0,
3747     &asin_validate,
3748   },
3749
3750   {
3751     /* Q_USIN - UPDATE_SERVER_INFO */
3752     "update_server_info",
3753     "usin",
3754     UPDATE,
3755     "s",
3756     SERVERS_TABLE,
3757     "servers SET update_int = %s, target_file = '%s', script = '%s', type = '%s', enable = %s, acl_type = '%s', acl_id = %d",
3758     asin_fields,
3759     7,
3760     "name = UPPER('%s')",
3761     1,
3762     &asin_validate,
3763   },
3764
3765   {
3766     /* Q_RSVE - RESET_SERVER_ERROR */
3767     "reset_server_error",
3768     "rsve",
3769     UPDATE,
3770     "s",
3771     SERVERS_TABLE,
3772     "servers SET harderror = 0, dfcheck = dfgen",
3773     dsin_fields,
3774     0,
3775     "name = UPPER('%s')",
3776     1,
3777     &rsve_validate,
3778   },
3779
3780   {
3781     /* Q_SSIF - SET_SERVER_INTERNAL_FLAGS */
3782     "set_server_internal_flags",
3783     "ssif",
3784     UPDATE,
3785     "s",
3786     SERVERS_TABLE,
3787     "servers SET dfgen = %s, dfcheck = %s, inprogress = %s, harderror = %s, errmsg = NVL('%s',CHR(0))",
3788     ssif_fields,
3789     5,
3790     "name = UPPER('%s')",
3791     1,
3792     &ssif_validate,
3793   },
3794
3795   {
3796     /* Q_DSIN - DELETE_SERVER_INFO */
3797     "delete_server_info",
3798     "dsin",
3799     DELETE,
3800     "s",
3801     SERVERS_TABLE,
3802     (char *)0,
3803     dsin_fields,
3804     0,
3805     "name = UPPER('%s')",
3806     1,
3807     &dsin_validate,
3808   },
3809
3810   {
3811     /* Q_GSHI - GET_SERVER_HOST_INFO */
3812     "get_server_host_info",
3813     "gshi",
3814     RETRIEVE,
3815     "sh",
3816     SERVERHOSTS_TABLE,
3817     "sh.service, m.name, sh.enable, sh.override, sh.success, sh.inprogress, sh.hosterror, sh.hosterrmsg, sh.ltt, sh.lts, sh.value1, sh.value2, sh.value3, TO_CHAR(sh.modtime, 'DD-mon-YYYY HH24:MI:SS'), sh.modby, sh.modwith FROM serverhosts sh, machine m",
3818     gshi_fields,
3819     16,
3820     "sh.service LIKE '%s' ESCAPE '*' AND m.name LIKE '%s' ESCAPE '*' AND m.mach_id = sh.mach_id",
3821     2,
3822     &gshi_validate,
3823   },
3824
3825   {
3826     /* Q_QGSH - QUALIFIED_GET_SERVER_HOST */
3827     "qualified_get_server_host",
3828     "qgsh",
3829     RETRIEVE,
3830     0,
3831     SERVERHOSTS_TABLE,
3832     0,
3833     qgsh_fields,
3834     2,
3835     0,
3836     6,
3837     &qgsh_validate,
3838   },
3839
3840   {
3841     /* Q_ASHI - ADD_SERVER_HOST_INFO */
3842     "add_server_host_info",
3843     "ashi",
3844     APPEND,
3845     "sh",
3846     SERVERHOSTS_TABLE,
3847     "INTO serverhosts (service, mach_id, enable, value1, value2, value3) VALUES (UPPER('%s'), %d, %s, %s, %s, NVL('%s',CHR(0)))",
3848     ashi_fields,
3849     6,
3850     (char *)0,
3851     0,
3852     &ashi_validate,
3853   },
3854
3855   {
3856     /* Q_USHI - UPDATE_SERVER_HOST_INFO */
3857     "update_server_host_info",
3858     "ushi",
3859     UPDATE,
3860     "sh",
3861     SERVERHOSTS_TABLE,
3862     "serverhosts SET enable = %s, value1 = %s, value2 = %s, value3 = NVL('%s',CHR(0))",
3863     ashi_fields,
3864     4,
3865     "service = UPPER('%s') AND mach_id = %d",
3866     2,
3867     &ashi_validate,
3868   },
3869
3870   {
3871     /* Q_RSHE - RESET_SERVER_HOST_ERROR */
3872     "reset_server_host_error",
3873     "rshe",
3874     UPDATE,
3875     "sh",
3876     SERVERHOSTS_TABLE,
3877     "serverhosts SET hosterror = 0",
3878     dshi_fields,
3879     0,
3880     "service = UPPER('%s') AND mach_id = %d",
3881     2,
3882     &rshe_validate,
3883   },
3884
3885   {
3886     /* Q_SSHO - SET_SERVER_HOST_OVERRIDE */
3887     "set_server_host_override",
3888     "ssho",
3889     UPDATE,
3890     "sh",
3891     SERVERHOSTS_TABLE,
3892     "serverhosts SET override = 1",
3893     dshi_fields,
3894     0,
3895     "service = UPPER('%s') AND mach_id = %d",
3896     2,
3897     &ssho_validate,
3898   },
3899
3900   {
3901     /* Q_SSHI - SET_SERVER_HOST_INTERNAL */
3902     "set_server_host_internal",
3903     "sshi",
3904     UPDATE,
3905     "s",
3906     SERVERHOSTS_TABLE,
3907     "serverhosts SET override = %s, success = %s, inprogress = %s, hosterror = %s, hosterrmsg = NVL('%s',CHR(0)), ltt = %s, lts = %s",
3908     sshi_fields,
3909     7,
3910     "service = UPPER('%s') AND mach_id = %d",
3911     2,
3912     &sshi_validate,
3913   },
3914
3915   {
3916     /* Q_DSHI - DELETE_SERVER_HOST_INFO */
3917     "delete_server_host_info",
3918     "dshi",
3919     DELETE,
3920     "sh",
3921     SERVERHOSTS_TABLE,
3922     (char *)0,
3923     dshi_fields,
3924     0,
3925     "service = UPPER('%s') AND mach_id = %d",
3926     2,
3927     &dshi_validate,
3928   },
3929
3930   {
3931     /* Q_GSLO - GET_SERVER_LOCATIONS */
3932     "get_server_locations",
3933     "gslo",
3934     RETRIEVE,
3935     "sh",
3936     SERVERHOSTS_TABLE,
3937     "sh.service, m.name FROM serverhosts sh, machine m",
3938     gslo_fields,
3939     2,
3940     "sh.service LIKE '%s' ESCAPE '*' AND sh.mach_id = m.mach_id",
3941     1,
3942     &VDupwild0,
3943   },
3944
3945   {
3946     /* Q_GFSL - GET_FILESYS_BY_LABEL */
3947     "get_filesys_by_label",
3948     "gfsl",
3949     RETRIEVE,
3950     "fs",
3951     FILESYS_TABLE,
3952     "fs.label, fs.type, m.name, fs.name, fs.mount, fs.rwaccess, fs.comments, u.login, l.name, fs.createflg, fs.lockertype, TO_CHAR(fs.modtime, 'DD-mon-YYYY HH24:MI:SS'), fs.modby, fs.modwith FROM filesys fs, machine m, users u, list l",
3953     gfsl_fields,
3954     14,
3955     "fs.label LIKE '%s' ESCAPE '*' AND fs.mach_id = m.mach_id AND fs.owner = u.users_id AND fs.owners = l.list_id",
3956     1,
3957     &VDwildsortf,
3958   },
3959
3960   {
3961     /* Q_GFSM - GET_FILESYS_BY_MACHINE */
3962     "get_filesys_by_machine",
3963     "gfsm",
3964     RETRIEVE,
3965     "fs",
3966     FILESYS_TABLE,
3967     "fs.label, fs.type, m.name, fs.name, fs.mount, fs.rwaccess, fs.comments, u.login, l.name, fs.createflg, fs.lockertype, TO_CHAR(fs.modtime, 'DD-mon-YYYY HH24:MI:SS'), fs.modby, fs.modwith FROM filesys fs, machine m, users u, list l",
3968     gfsm_fields,
3969     14,
3970     "fs.mach_id = %d AND m.mach_id = fs.mach_id AND fs.owner = u.users_id AND fs.owners = l.list_id",
3971     1,
3972     &gfsm_validate,
3973   },
3974
3975   {
3976     /* Q_GFSN - GET_FILESYS_BY_NFSPHYS */
3977     "get_filesys_by_nfsphys",
3978     "gfsn",
3979     RETRIEVE,
3980     "fs",
3981     FILESYS_TABLE,
3982     "fs.label, fs.type, m.name, fs.name, fs.mount, fs.rwaccess, fs.comments, u.login, l.name, fs.createflg, fs.lockertype, TO_CHAR(fs.modtime, 'DD-mon-YYYY HH24:MI:SS'), fs.modby, fs.modwith FROM filesys fs, machine m, users u, list l, nfsphys np",
3983     gfsn_fields,
3984     14,
3985     "fs.mach_id = %d AND m.mach_id = fs.mach_id AND fs.owner = u.users_id AND fs.owners = l.list_id AND np.nfsphys_id = fs.phys_id AND np.dir LIKE '%s' ESCAPE '*' AND fs.type = 'NFS'",
3986     2,
3987     &gfsn_validate,
3988   },
3989
3990   {
3991     /* Q_GFSG - GET_FILESYS_BY_GROUP */
3992     "get_filesys_by_group",
3993     "gfsg",
3994     RETRIEVE,
3995     "fs",
3996     FILESYS_TABLE,
3997     "fs.label, fs.type, m.name, fs.name, fs.mount, fs.rwaccess, fs.comments, u.login, l.name, fs.createflg, fs.lockertype, TO_CHAR(fs.modtime, 'DD-mon-YYYY HH24:MI:SS'), fs.modby, fs.modwith FROM filesys fs, machine m, users u, list l",
3998     gfsg_fields,
3999     14,
4000     "fs.owners = %d AND m.mach_id = fs.mach_id AND fs.owner = u.users_id AND fs.owners = l.list_id",
4001     1,
4002     &gfsg_validate,
4003   },
4004
4005   {
4006     /* Q_GFSP - GET_FILESYS_BY_PATH */
4007     "get_filesys_by_path",
4008     "gfsp",
4009     RETRIEVE,
4010     "fs",
4011     FILESYS_TABLE,
4012     "fs.label, fs.type, m.name, fs.name, fs.mount, fs.rwaccess, fs.comments, u.login, l.name, fs.createflg, fs.lockertype, TO_CHAR(fs.modtime, 'DD-mon-YYYY HH24:MI:SS'), fs.modby, fs.modwith FROM filesys fs, machine m, users u, list l",
4013     gfsp_fields,
4014     14,
4015     "fs.name LIKE '%s' ESCAPE '*' AND m.mach_id = fs.mach_id AND fs.owner = u.users_id AND fs.owners = list_id",
4016     1,
4017     &VDwildsortf,
4018   },
4019
4020   {
4021     /* Q_AFIL - ADD_FILESYS */ /* uses prefetch_value() for filsys_id */
4022     "add_filesys",
4023     "afil",
4024     APPEND,
4025     "fs",
4026     FILESYS_TABLE,
4027     "INTO filesys (label, type, mach_id, name, mount, rwaccess, comments, owner, owners, createflg, lockertype, filsys_id) VALUES ('%s','%s',%d,NVL('%s',CHR(0)),'%s','%s',NVL('%s',CHR(0)),%d,%d,%s,'%s',%s)",
4028     afil_fields,
4029     11,
4030     0,
4031     0,
4032     &afil_validate,
4033   },
4034
4035   {
4036     /* Q_UFIL - UPDATE_FILESYS */
4037     "update_filesys",
4038     "ufil",
4039     UPDATE,
4040     "fs",
4041     FILESYS_TABLE,
4042     "filesys SET label = '%s', type = '%s', mach_id = %d, name = NVL('%s',CHR(0)), mount = '%s', rwaccess = '%s', comments = NVL('%s',CHR(0)), owner = %d, owners = %d, createflg = %s, lockertype = '%s'",
4043     ufil_fields,
4044     11,
4045     "filsys_id = %d",
4046     1,
4047     &ufil_validate,
4048   },
4049
4050   {
4051     /* Q_DFIL - DELETE_FILESYS */
4052     "delete_filesys",
4053     "dfil",
4054     DELETE,
4055     "fs",
4056     FILESYS_TABLE,
4057     (char *)0,
4058     dfil_fields,
4059     0,
4060     "filsys_id = %d",
4061     1,
4062     &dfil_validate,
4063   },
4064
4065   {
4066     /* Q_GFGM - GET_FSGROUP_MEMBERS */
4067     "get_fsgroup_members",
4068     "gfgm",
4069     RETRIEVE,
4070     "fg",
4071     FSGROUP_TABLE,
4072     "fs.label, fg.key FROM fsgroup fg, filesys fs",
4073     gfgm_fields,
4074     2,
4075     "fg.group_id = %d AND fs.filsys_id = fg.filsys_id",
4076     1,
4077     &gfgm_validate,
4078   },
4079
4080   {
4081     /* Q_AFTG - ADD_FILESYS_TO_FSGROUP */
4082     "add_filesys_to_fsgroup",
4083     "aftg",
4084     APPEND,
4085     "fg",
4086     FSGROUP_TABLE,
4087     "INTO fsgroup (group_id,filsys_id,key) VALUES (%d, %d, '%s')",
4088     gfgm_fields,
4089     3,
4090     (char *)0,
4091     0,
4092     &aftg_validate,
4093   },
4094
4095   {
4096     /* Q_RFFG - REMOVE_FILESYS_FROM_FSGROUP */
4097     "remove_filesys_from_fsgroup",
4098     "rffg",
4099     DELETE,
4100     "fg",
4101     FSGROUP_TABLE,
4102     (char *)0,
4103     gfgm_fields,
4104     0,
4105     "group_id = %d AND filsys_id = %d",
4106     2,
4107     &aftg_validate,
4108   },
4109
4110   {
4111     /* Q_GANF - GET_ALL_NFSPHYS */
4112     "get_all_nfsphys",
4113     "ganf",
4114     RETRIEVE,
4115     "np",
4116     NFSPHYS_TABLE,
4117     "m.name, np.dir, np.device, np.status, np.allocated, np.partsize, TO_CHAR(np.modtime, 'DD-mon-YYYY HH24:MI:SS'), np.modby, np.modwith FROM nfsphys np, machine m",
4118     ganf_fields,
4119     9,
4120     "m.mach_id = np.mach_id",
4121     0,
4122     &VDsortf,
4123   },
4124
4125   {
4126     /* Q_GNFP - GET_NFSPHYS */
4127     "get_nfsphys",
4128     "gnfp",
4129     RETRIEVE,
4130     "np",
4131     NFSPHYS_TABLE,
4132     "m.name, np.dir, np.device, np.status, np.allocated, np.partsize, TO_CHAR(np.modtime, 'DD-mon-YYYY HH24:MI:SS'), np.modby, np.modwith FROM nfsphys np, machine m",
4133     gnfp_fields,
4134     9,
4135     "np.mach_id = %d AND np.dir LIKE '%s' ESCAPE '*' AND m.mach_id = np.mach_id",
4136     2,
4137     &gnfp_validate,
4138   },
4139
4140   {
4141     /* Q_ANFP - ADD_NFSPHYS */ /* uses prefetch_value() for nfsphys_id */
4142     "add_nfsphys",
4143     "anfp",
4144     APPEND,
4145     "np",
4146     NFSPHYS_TABLE,
4147     "INTO nfsphys (mach_id, dir, device, status, allocated, partsize, nfsphys_id) VALUES (%d, '%s', NVL('%s',CHR(0)), %s, %s, %s, %s)",
4148     ganf_fields,
4149     6,
4150     0,
4151     0,
4152     &anfp_validate,
4153   },
4154
4155   {
4156     /* Q_UNFP - UPDATE_NFSPHYS */
4157     "update_nfsphys",
4158     "unfp",
4159     UPDATE,
4160     "np",
4161     NFSPHYS_TABLE,
4162     "nfsphys SET device = NVL('%s',CHR(0)), status = %s, allocated = %s, partsize = %s",
4163     ganf_fields,
4164     4,
4165     "mach_id = %d AND dir = '%s'",
4166     2,
4167     &unfp_validate,
4168   },
4169
4170   {
4171     /* Q_AJNF - ADJUST_NFSPHYS_ALLOCATION */
4172     "adjust_nfsphys_allocation",
4173     "ajnf",
4174     UPDATE,
4175     "np",
4176     NFSPHYS_TABLE,
4177     "nfsphys SET allocated = allocated + %s",
4178     ajnf_fields,
4179     1,
4180     "mach_id = %d AND dir = '%s'",
4181     2,
4182     &unfp_validate,
4183   },
4184
4185   {
4186     /* Q_DNFP - DELETE_NFSPHYS */
4187     "delete_nfsphys",
4188     "dnfp",
4189     DELETE,
4190     "np",
4191     NFSPHYS_TABLE,
4192     (char *)0,
4193     dnfp_fields,
4194     0,
4195     "mach_id = %d AND dir = '%s'",
4196     2,
4197     &dnfp_validate,
4198   },
4199
4200   {
4201     /* Q_GQOT - GET_QUOTA */
4202     "get_quota",
4203     "gqot",
4204     RETRIEVE,
4205     "q",
4206     QUOTA_TABLE,
4207     "fs.label, q.type, q.entity_id, q.quota, q.phys_id, m.name, TO_CHAR(q.modtime, 'DD-mon-YYYY HH24:MI:SS'), q.modby, q.modwith FROM quota q, filesys fs, machine m",
4208     gqot_fields,
4209     9,
4210     "fs.label LIKE '%s' ESCAPE '*' AND q.type = '%s' AND q.entity_id = %d AND fs.filsys_id = q.filsys_id AND m.mach_id = fs.mach_id",
4211     3,
4212     &gqot_validate,
4213   },
4214
4215   {
4216     /* Q_GQBF - GET_QUOTA_BY_FILESYS */
4217     "get_quota_by_filesys",
4218     "gqbf",
4219     RETRIEVE,
4220     "q",
4221     QUOTA_TABLE,
4222     "fs.label, q.type, q.entity_id, q.quota, q.phys_id, m.name, TO_CHAR(q.modtime, 'DD-mon-YYYY HH24:MI:SS'), q.modby, q.modwith FROM quota q, filesys fs, machine m",
4223     gqbf_fields,
4224     9,
4225     "fs.label LIKE '%s' ESCAPE '*' AND fs.filsys_id = q.filsys_id AND m.mach_id = fs.mach_id",
4226     1,
4227     &gqbf_validate,
4228   },
4229
4230   {
4231     /* Q_AQOT - ADD_QUOTA */ /* prefetch_filsys() gets last 1 value */
4232     "add_quota",
4233     "aqot",
4234     APPEND,
4235     0,
4236     QUOTA_TABLE,
4237     "INTO quota (filsys_id, type, entity_id, quota, phys_id) VALUES ('%s', %d, %d, %s, %s)",
4238     aqot_fields,
4239     4,
4240     (char *)0,
4241     0,
4242     &aqot_validate,
4243   },
4244
4245   {
4246     /* Q_UQOT - UPDATE_QUOTA */
4247     "update_quota",
4248     "uqot",
4249     UPDATE,
4250     0,
4251     QUOTA_TABLE,
4252     "quota SET quota = %s",
4253     aqot_fields,
4254     1,
4255     0,
4256     3,
4257     &uqot_validate,
4258   },
4259
4260   {
4261     /* Q_DQOT - DELETE_QUOTA */
4262     "delete_quota",
4263     "dqot",
4264     DELETE,
4265     0,
4266     QUOTA_TABLE,
4267     (char *)0,
4268     aqot_fields,
4269     0,
4270     0,
4271     3,
4272     &dqot_validate,
4273   },
4274
4275   {
4276     /* Q_GNFQ - GET_NFS_QUOTAS */
4277     "get_nfs_quota",
4278     "gnfq",
4279     RETRIEVE,
4280     "q",
4281     QUOTA_TABLE,
4282     "fs.label, u.login, q.quota, q.phys_id, m.name, TO_CHAR(q.modtime, 'DD-mon-YYYY HH24:MI:SS'), q.modby, q.modwith FROM quota q, filesys fs, users u, machine m",
4283     gnfq_fields,
4284     8,
4285     "fs.label LIKE '%s' ESCAPE '*' AND q.type = 'USER' AND q.entity_id = u.users_id AND fs.filsys_id = q.filsys_id AND m.mach_id = fs.mach_id AND u.login = '%s'",
4286     2,
4287     &gnfq_validate,
4288   },
4289
4290   {
4291     /* Q_GNQP - GET_NFS_QUOTAS_BY_PARTITION */
4292     "get_nfs_quotas_by_partition",
4293     "gnqp",
4294     RETRIEVE,
4295     "q",
4296     QUOTA_TABLE,
4297     "fs.label, u.login, q.quota, np.dir, m.name FROM quota q, filesys fs, users u, nfsphys np, machine m",
4298     gnqp_fields,
4299     5,
4300     "np.mach_id = %d AND np.dir LIKE '%s' ESCAPE '*' AND q.phys_id = np.nfsphys_id AND fs.filsys_id = q.filsys_id AND q.type = 'USER' AND u.users_id = q.entity_id AND m.mach_id = np.mach_id",
4301     2,
4302     &gnqp_validate,
4303   },
4304
4305   {
4306     /* Q_ANFQ - ADD_NFS_QUOTA */ /* prefetch_filsys() gets last 1 value */
4307     "add_nfs_quota",
4308     "anfq",
4309     APPEND,
4310     0,
4311     QUOTA_TABLE,
4312     "INTO quota (type, filsys_id, entity_id, quota, phys_id ) VALUES ('USER', %d, %d, %s, %s)",
4313     anfq_fields,
4314     3,
4315     (char *)0,
4316     0,
4317     &anfq_validate,
4318   },
4319
4320   {
4321     /* Q_UNFQ - UPDATE_NFS_QUOTA */
4322     "update_nfs_quota",
4323     "unfq",
4324     UPDATE,
4325     0,
4326     QUOTA_TABLE,
4327     "quota SET quota = %s",
4328     anfq_fields,
4329     1,
4330     0,
4331     2,
4332     &unfq_validate,
4333   },
4334
4335   {
4336     /* Q_DNFQ - DELETE_NFS_QUOTA */
4337     "delete_nfs_quota",
4338     "dnfq",
4339     DELETE,
4340     0,
4341     QUOTA_TABLE,
4342     (char *)0,
4343     anfq_fields,
4344     0,
4345     0,
4346     2,
4347     &dnfq_validate,
4348   },
4349
4350   {
4351     /* Q_GZCL - GET_ZEPHYR_CLASS */
4352     "get_zephyr_class",
4353     "gzcl",
4354     RETRIEVE,
4355     "z",
4356     ZEPHYR_TABLE,
4357     "class, xmt_type, xmt_id, sub_type, sub_id, iws_type, iws_id, iui_type, iui_id, TO_CHAR(modtime, 'DD-mon-YYYY HH24:MI:SS'), modby, modwith FROM zephyr",
4358     gzcl_fields,
4359     12,
4360     "class LIKE '%s' ESCAPE '*'",
4361     1,
4362     &gzcl_validate,
4363   },
4364
4365   {
4366     /* Q_AZCL - ADD_ZEPHYR_CLASS */
4367     "add_zephyr_class",
4368     "azcl",
4369     APPEND,
4370     "z",
4371     ZEPHYR_TABLE,
4372     "INTO zephyr (class, xmt_type, xmt_id, sub_type, sub_id, iws_type, iws_id, iui_type, iui_id) VALUES ('%s','%s',%d,'%s',%d,'%s',%d,'%s',%d)",
4373     azcl_fields,
4374     9,
4375     0,
4376     0,
4377     &azcl_validate,
4378   },
4379
4380   {
4381     /* Q_UZCL - UPDATE_ZEPHYR_CLASS */
4382     "update_zephyr_class",
4383     "uzcl",
4384     UPDATE,
4385     "z",
4386     ZEPHYR_TABLE,
4387     "zephyr SET class = '%s', xmt_type = '%s', xmt_id = %d, sub_type = '%s', sub_id = %d, iws_type = '%s', iws_id = %d, iui_type = '%s', iui_id = %d",
4388     uzcl_fields,
4389     9,
4390     "class = '%s'",
4391     1,
4392     &uzcl_validate,
4393   },
4394
4395   {
4396     /* Q_DZCL - DELETE_ZEPHYR_CLASS */
4397     "delete_zephyr_class",
4398     "dzcl",
4399     DELETE,
4400     "z",
4401     ZEPHYR_TABLE,
4402     0,
4403     uzcl_fields,
4404     0,
4405     "class = '%s'",
4406     1,
4407     &dzcl_validate,
4408   },
4409
4410   {
4411     /* Q_GSHA - GET_SERVER_HOST_ACCESS */
4412     "get_server_host_access",
4413     "gsha",
4414     RETRIEVE,
4415     "ha",
4416     HOSTACCESS_TABLE,
4417     "m.name, ha.acl_type, ha.acl_id, TO_CHAR(ha.modtime, 'DD-mon-YYYY HH24:MI:SS'), ha.modby, ha.modwith FROM hostaccess ha, machine m",
4418     gsha_fields,
4419     6,
4420     "m.name LIKE '%s' ESCAPE '*' AND ha.mach_id = m.mach_id",
4421     1,
4422     &gsha_validate,
4423   },
4424
4425   {
4426     /* Q_ASHA - ADD_SERVER_HOST_ACCESS */
4427     "add_server_host_access",
4428     "asha",
4429     APPEND,
4430     "ha",
4431     HOSTACCESS_TABLE,
4432     "INTO hostaccess (mach_id, acl_type, acl_id) VALUES (%d,'%s',%d)",
4433     asha_fields,
4434     3,
4435     0,
4436     0,
4437     &asha_validate,
4438   },
4439
4440   {
4441     /* Q_USHA - UPDATE_SERVER_HOST_ACCESS */
4442     "update_server_host_access",
4443     "usha",
4444     UPDATE,
4445     "ha",
4446     HOSTACCESS_TABLE,
4447     "hostaccess SET acl_type = '%s', acl_id = %d",
4448     asha_fields,
4449     2,
4450     "mach_id = %d",
4451     1,
4452     &asha_validate,
4453   },
4454
4455   {
4456     /* Q_DSHA - DELETE_SERVER_HOST_ACCESS */
4457     "delete_server_host_access",
4458     "dsha",
4459     DELETE,
4460     "ha",
4461     HOSTACCESS_TABLE,
4462     0,
4463     asha_fields,
4464     0,
4465     "mach_id = %d",
4466     1,
4467     &VDmach,
4468   },
4469
4470   {
4471     /* Q_GSVC - GET_SERVICE */
4472     "get_service",
4473     "gsvc",
4474     RETRIEVE,
4475     "ss",
4476     SERVICES_TABLE,
4477     "name, protocol, port, description, TO_CHAR(modtime, 'DD-mon-YYYY HH24:MI:SS'), modby, modwith FROM services",
4478     gsvc_fields,
4479     7,
4480     "name LIKE '%s' ESCAPE '*'",
4481     1,
4482     &VDwildsortf,
4483   },
4484
4485   {
4486     /* Q_ASVC - ADD_SERVICE */
4487     "add_service",
4488     "asvc",
4489     APPEND,
4490     "ss",
4491     SERVICES_TABLE,
4492     "INTO services (name, protocol, port, description) VALUES ('%s','%s',%s,NVL('%s',CHR(0)))",
4493     asvc_fields,
4494     4,
4495     (char *)0,
4496     0,
4497     &asvc_validate,
4498   },
4499
4500   {
4501     /* Q_DSVC - DELETE_SERVICE */
4502     "delete_service",
4503     "dsvc",
4504     DELETE,
4505     "ss",
4506     SERVICES_TABLE,
4507     0,
4508     asvc_fields,
4509     0,
4510     "name = '%s'",
4511     1,
4512     &asvc_validate,
4513   },
4514
4515   {
4516     /* Q_GPCE - GET_PRINTCAP_ENTRY */
4517     "get_printcap_entry",
4518     "gpce",
4519     RETRIEVE,
4520     "pc",
4521     PRINTCAP_TABLE,
4522     "pc.name, m.name, pc.dir, pc.rp, pc.quotaserver, pc.auth, pc.price, pc.comments, TO_CHAR(pc.modtime, 'DD-mon-YYYY HH24:MI:SS'), pc.modby, pc.modwith FROM printcap pc, machine m",
4523     gpce_fields,
4524     11,
4525     "pc.name LIKE '%s' ESCAPE '*' AND m.mach_id = pc.mach_id",
4526     1,
4527     &gpce_validate,
4528   },
4529
4530   {
4531     /* Q_APCE - ADD_PRINTCAP_ENTRY */
4532     "add_printcap_entry",
4533     "apce",
4534     APPEND,
4535     "pc",
4536     PRINTCAP_TABLE,
4537     "INTO printcap (name, mach_id, dir, rp, quotaserver, auth, price, comments) VALUES ('%s',%d,'%s','%s',%d,%s,%s,NVL('%s',CHR(0)))",
4538     apce_fields,
4539     8,
4540     0,
4541     0,
4542     &apce_validate,
4543   },
4544
4545   {
4546     /* Q_DPCE - DELETE_PRINTCAP_ENTRY */
4547     "delete_printcap_entry",
4548     "dpce",
4549     DELETE,
4550     "pc",
4551     PRINTCAP_TABLE,
4552     0,
4553     apce_fields,
4554     0,
4555     "name = '%s'",
4556     1,
4557     &dpce_validate,
4558   },
4559
4560   {
4561     /* Q_GPCP - GET_PRINTCAP */
4562     "get_printcap",
4563     "gpcp",
4564     RETRIEVE,
4565     "pc",
4566     PRINTCAP_TABLE,
4567     "pc.name, m.name, pc.dir, pc.rp, pc.comments, TO_CHAR(pc.modtime, 'DD-mon-YYYY HH24:MI:SS'), pc.modby, pc.modwith FROM printcap pc, machine m",
4568     gpcp_fields,
4569     8,
4570     "pc.name LIKE '%s' ESCAPE '*' AND m.mach_id = pc.mach_id",
4571     1,
4572     &VDwildsortf,
4573   },
4574
4575   {
4576     /* Q_DPCP - DELETE_PRINTCAP */
4577     "delete_printcap",
4578     "dpcp",
4579     DELETE,
4580     "pc",
4581     PRINTCAP_TABLE,
4582     0,
4583     apce_fields,
4584     0,
4585     "name = '%s'",
4586     1,
4587     &dpce_validate,
4588   },
4589
4590   {
4591     /* Q_GPDM - GET_PALLADIUM */
4592     "get_palladium",
4593     "gpdm",
4594     RETRIEVE,
4595     "pal",
4596     PALLADIUM_TABLE,
4597     "pal.name, pal.identifier, m.name, TO_CHAR(pal.modtime, 'DD-mon-YYYY HH24:MI:SS'), pal.modby, pal.modwith FROM palladium pal, machine m",
4598     gpdm_fields,
4599     6,
4600     "pal.name LIKE '%s' ESCAPE '*' AND m.mach_id = pal.mach_id",
4601     1,
4602     &VDwildsortf,
4603   },
4604
4605   {
4606     /* Q_APDM - ADD_PALLADIUM */
4607     "add_palladium",
4608     "apdm",
4609     APPEND,
4610     "pal",
4611     PALLADIUM_TABLE,
4612     "INTO palladium (name, identifier, mach_id) VALUES ('%s',%s,%d)",
4613     apdm_fields,
4614     3,
4615     0,
4616     0,
4617     &apdm_validate,
4618   },
4619
4620   {
4621     /* Q_DPDM - DELETE_PALLADIUM */
4622     "delete_palladium",
4623     "dpdm",
4624     DELETE,
4625     "pal",
4626     PALLADIUM_TABLE,
4627     0,
4628     apdm_fields,
4629     0,
4630     "name = '%s'",
4631     1,
4632     &dpdm_validate,
4633   },
4634
4635   {
4636     /* Q_GALI - GET_ALIAS */
4637     "get_alias",
4638     "gali",
4639     RETRIEVE,
4640     "a",
4641     ALIAS_TABLE,
4642     "name, type, trans FROM alias",
4643     gali_fields,
4644     3,
4645     "name LIKE '%s' ESCAPE '*' AND type LIKE '%s' ESCAPE '*' AND trans LIKE '%s' ESCAPE '*'",
4646     3,
4647     &VDwild3sort1,
4648   },
4649
4650   {
4651     /* Q_AALI - ADD_ALIAS */
4652     "add_alias",
4653     "aali",
4654     APPEND,
4655     "a",
4656     ALIAS_TABLE,
4657     "INTO alias (name, type, trans) VALUES ('%s', '%s', '%s')",
4658     aali_fields,
4659     3,
4660     (char *)0,
4661     0,
4662     &aali_validate,
4663   },
4664
4665   {
4666     /* Q_DALI - DELETE_ALIAS */
4667     "delete_alias",
4668     "dali",
4669     DELETE,
4670     "a",
4671     ALIAS_TABLE,
4672     (char *)0,
4673     aali_fields,
4674     0,
4675     "name = '%s' AND type = '%s' AND  trans = '%s'",
4676     3,
4677     &dali_validate,
4678   },
4679
4680   {
4681     /* Q_GVAL - GET_VALUE */
4682     "get_value",
4683     "gval",
4684     RETRIEVE,
4685     "val",
4686     NUMVALUES_TABLE,
4687     "value FROM numvalues",
4688     gval_fields,
4689     1,
4690     "name = '%s'",
4691     1,
4692     &gval_validate,
4693   },
4694
4695   {
4696     /* Q_AVAL - ADD_VALUE */
4697     "add_value",
4698     "aval",
4699     APPEND,
4700     "val",
4701     NUMVALUES_TABLE,
4702     "INTO numvalues (name, value) VALUES ('%s', %s)",
4703     aval_fields,
4704     2,
4705     (char *)0,
4706     0,
4707     &aval_validate,
4708   },
4709
4710   {
4711     /* Q_UVAL - UPDATE_VALUE */
4712     "update_value",
4713     "uval",
4714     UPDATE,
4715     "val",
4716     NUMVALUES_TABLE,
4717     "numvalues SET value = %s",
4718     aval_fields,
4719     1,
4720     "name = '%s'",
4721     1,
4722     &aval_validate,
4723   },
4724
4725   {
4726     /* Q_DVAL - DELETE_VALUE */
4727     "delete_value",
4728     "dval",
4729     DELETE,
4730     "val",
4731     NUMVALUES_TABLE,
4732     (char *)0,
4733     dval_fields,
4734     0,
4735     "name = '%s'",
4736     1,
4737     &aval_validate,
4738   },
4739
4740   {
4741     /* Q_GATS - GET_ALL_TABLE_STATS */
4742     "get_all_table_stats",
4743     "gats",
4744     RETRIEVE,
4745     "tbs",
4746     TBLSTATS_TABLE,
4747     "table_name, appends, updates, deletes, TO_CHAR(modtime, 'DD-mon-YYYY HH24:MI:SS') FROM tblstats",
4748     gats_fields,
4749     5,
4750     (char *)0,
4751     0,
4752     0,
4753   },
4754
4755   {
4756     /* Q__SDL - _SET_DEBUG_LEVEL */
4757     "_set_debug_level",
4758     "_sdl",
4759     UPDATE,
4760     (char *)0,
4761     0,
4762     (char *)0,
4763     _sdl_fields,
4764     1,
4765     (char *)0,
4766     0,
4767     &_sdl_validate,
4768   },
4769
4770 };
4771
4772 int QueryCount2 = (sizeof Queries2 / sizeof (struct query));