server/queries2.c

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