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