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