server/queries2.c

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