server/queries2.c

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