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