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