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