server/queries2.c

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