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