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