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