server/queries2.c

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