server/queries2.c

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