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