server/queries2.c

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