server/queries2.c

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