server/qsupport.pc

   1 /* $Id$
   2  *
   3  * Special query routines
   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 #include "qrtn.h"
  14
  15 #include <ctype.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 EXEC SQL INCLUDE sqlca;
  20
  21 RCSID("$Header$");
  22
  23 extern char *whoami, *table_name[];
  24 extern int dbms_errno, mr_errcode;
  25
  26 EXEC SQL BEGIN DECLARE SECTION;
  27 extern char stmt_buf[];
  28 EXEC SQL END DECLARE SECTION;
  29
  30 EXEC SQL WHENEVER SQLERROR DO dbmserr();
  31
  32 int get_ace_internal(char *atypex, int aid,
  33                      int (*action)(int, char *[], void *), void *actarg);
  34 int qualified_get(struct query *q, char *argv[],
  35                   int (*action)(int, char *[], void *), void *actarg,
  36                   char *start, char *range, char *field, char *flags[]);
  37
  38
  39 /* set_pobox - this does all of the real work.
  40  *       argv = user_id, type, box
  41  * if type is POP, then box should be a machine, and its ID should be put in
  42  * pop_id.  If type is IMAP, then box should be a filesys, and its ID should
  43  * be put in pop_id.  If type is SMTP, then box should be a string and its
  44  * ID should be put in box_id.  If type is EXCHANGE, then box should be a
  45  * machine, and its ID should be put in exchange_id.  If type is NONE, then
  46  * box doesn't matter.
  47  */
  48
  49 int set_pobox(struct query *q, char **argv, client *cl)
  50 {
  51   EXEC SQL BEGIN DECLARE SECTION;
  52   int user, id;
  53   char *box, potype[USERS_POTYPE_SIZE];
  54   EXEC SQL END DECLARE SECTION;
  55   int status;
  56   char buffer[256];
  57
  58   box = argv[2];
  59   user = *(int *)argv[0];
  60
  61   EXEC SQL SELECT pop_id, potype INTO :id, :potype FROM users
  62     WHERE users_id = :user;
  63   if (dbms_errno)
  64     return mr_errcode;
  65   if (!strcmp(strtrim(potype), "POP") ||
  66       (!strcmp(strtrim(potype), "SPLIT") && id))
  67     set_pop_usage(id, -1);
  68
  69   sprintf(buffer, "u.users_id = %d", user);
  70   incremental_before(USERS_TABLE, buffer, 0);
  71
  72   if (!strcmp(argv[1], "POP"))
  73     {
  74       status = name_to_id(box, MACHINE_TABLE, &id);
  75       if (status == MR_NO_MATCH)
  76         return MR_MACHINE;
  77       else if (status)
  78         return status;
  79       EXEC SQL UPDATE users SET potype = 'POP', pop_id = :id, imap_id = 0,
  80         exchange_id = 0 WHERE users_id = :user;
  81       set_pop_usage(id, 1);
  82     }
  83   else if (!strcmp(argv[1], "EXCHANGE"))
  84     {
  85       status = name_to_id(box, MACHINE_TABLE, &id);
  86       if (status == MR_NO_MATCH)
  87         return MR_MACHINE;
  88       else if (status)
  89         return status;
  90       EXEC SQL UPDATE users SET POTYPE = 'EXCHANGE', exchange_id = :id,
  91         pop_id = 0, imap_id = 0 WHERE users_id = :user;
  92     }
  93   else if (!strcmp(argv[1], "SMTP") || !strcmp(argv[1], "SPLIT"))
  94     {
  95       if (strchr(box, '/') || strchr(box, '|'))
  96         return MR_BAD_CHAR;
  97       status = name_to_id(box, STRINGS_TABLE, &id);
  98       if (status == MR_NO_MATCH)
  99         id = add_string(box);
 100       else if (status)
 101         return status;
 102
 103       /* If going from SMTP or NONE to SPLIT, make sure we have a valid
 104        * POP or IMAP box.
 105        */
 106       if ((!strcmp(potype, "SMTP") || !strcmp(potype, "NONE")) &&
 107            !strcmp(argv[1], "SPLIT"))
 108         {
 109           status = set_pobox_pop(q, argv, cl);
 110           if (status)
 111             return status;
 112         }
 113       strlcpy(potype, argv[1], sizeof(potype));
 114       EXEC SQL UPDATE users SET potype = :potype, box_id = :id
 115         WHERE users_id = :user;
 116     }
 117   else if (!strcmp(argv[1], "IMAP"))
 118     {
 119       EXEC SQL SELECT filsys_id INTO :id FROM filesys
 120         WHERE label = :box AND type = 'IMAP';
 121       if (sqlca.sqlcode)
 122         return MR_FILESYS;
 123       EXEC SQL UPDATE users SET potype = 'IMAP', imap_id = :id, pop_id = 0,
 124         exchange_id = 0 WHERE users_id = :user;
 125     }
 126   else /* argv[1] == "NONE" */
 127     {
 128       EXEC SQL UPDATE users SET potype = 'NONE'
 129         WHERE users_id = :user;
 130     }
 131
 132   incremental_after(USERS_TABLE, buffer, 0);
 133
 134   set_pobox_modtime(q, argv, cl);
 135   EXEC SQL UPDATE tblstats SET updates = updates + 1, modtime = SYSDATE
 136     WHERE table_name = 'users';
 137   if (dbms_errno)
 138     return mr_errcode;
 139   return MR_SUCCESS;
 140 }
 141
 142 /* set_pobox_pop: Revert to existing POP, IMAP, or EXCHANGE pobox.
 143  * Also take care of keeping track of the post office usage.
 144  */
 145 int set_pobox_pop(struct query *q, char **argv, client *cl)
 146 {
 147   EXEC SQL BEGIN DECLARE SECTION;
 148   int id, pid, iid, mid, eid;
 149   char type[USERS_POTYPE_SIZE];
 150   EXEC SQL END DECLARE SECTION;
 151   char buffer[256];
 152
 153   id = *(int *)argv[0];
 154   EXEC SQL SELECT potype, pop_id, imap_id, exchange_id
 155     INTO :type, :pid, :iid, :eid
 156     FROM users WHERE users_id = :id;
 157   if (sqlca.sqlerrd[2] == 0 || (pid == 0 && iid == 0 && eid == 0))
 158     return MR_MACHINE;
 159
 160   sprintf(buffer, "u.users_id = %d", id);
 161   incremental_before(USERS_TABLE, buffer, 0);
 162
 163   if (pid)
 164     {
 165       EXEC SQL SELECT mach_id INTO :mid FROM machine
 166         WHERE mach_id = :pid;
 167       if (sqlca.sqlerrd[2] == 0)
 168         return MR_MACHINE;
 169       EXEC SQL UPDATE users SET potype = 'POP' WHERE users_id = :id;
 170       if (!strcmp(strtrim(type), "POP"))
 171         set_pop_usage(mid, 1);
 172     }
 173   else if (iid)
 174     {
 175       EXEC SQL SELECT filsys_id INTO :mid FROM filesys
 176         WHERE filsys_id = :iid;
 177       if (sqlca.sqlerrd[2] == 0)
 178         return MR_MACHINE;
 179       EXEC SQL UPDATE users SET potype = 'IMAP' WHERE users_id = :id;
 180     }
 181   else if (eid)
 182     {
 183       EXEC SQL SELECT mach_id INTO :mid FROM machine
 184         WHERE mach_id = :eid;
 185       if (sqlca.sqlerrd[2] == 0)
 186         return MR_MACHINE;
 187       EXEC SQL UPDATE users SET potype = 'EXCHANGE' WHERE users_id = :id;
 188     }
 189
 190   incremental_after(USERS_TABLE, buffer, 0);
 191
 192   set_pobox_modtime(q, argv, cl);
 193   EXEC SQL UPDATE tblstats SET updates = updates + 1, modtime = SYSDATE
 194     WHERE table_name = 'users';
 195   if (dbms_errno)
 196     return mr_errcode;
 197   return MR_SUCCESS;
 198 }
 199
 200
 201 /* Add_member_to_list: do list flattening as we go!  MAXLISTDEPTH is
 202  * how many different ancestors a member is allowed to have.
 203  */
 204
 205 #define MAXLISTDEPTH    3072
 206
 207 int add_member_to_list(struct query *q, char **argv, client *cl)
 208 {
 209   EXEC SQL BEGIN DECLARE SECTION;
 210   int id, lid, mid, tag, error, who, ref, rowcnt;
 211   char *mtype, dtype[IMEMBERS_MEMBER_TYPE_SIZE], *entity;
 212   EXEC SQL END DECLARE SECTION;
 213   int ancestors[MAXLISTDEPTH], aref[MAXLISTDEPTH], acount, a;
 214   int descendants[MAXLISTDEPTH], dref[MAXLISTDEPTH], dcount, d;
 215   int status;
 216   char *dtypes[MAXLISTDEPTH];
 217   char *iargv[3], *buf;
 218
 219   lid = *(int *)argv[0];
 220   mtype = argv[1];
 221   mid = *(int *)argv[2];
 222   tag = !strcmp(q->shortname, "atml") ? *(int *)argv[3] : 0;
 223
 224   if (acl_access_check(lid, cl))
 225     return MR_PERM;
 226
 227   /* if the member is already a direct member of the list, punt */
 228   EXEC SQL SELECT COUNT(list_id) INTO :rowcnt FROM imembers
 229     WHERE list_id = :lid AND member_id = :mid
 230     AND member_type = :mtype AND direct = 1;
 231   if (rowcnt > 0)
 232     return MR_EXISTS;
 233   if (!strcasecmp(mtype, "STRING"))
 234     {
 235       buf = malloc(0);
 236       status = id_to_name(mid, STRINGS_TABLE, &buf);
 237       if (status)
 238         return status;
 239       if (strchr(buf, '/') || strchr(buf, '|') || strchr(buf, ','))
 240         {
 241           free(buf);
 242           return MR_BAD_CHAR;
 243         }
 244       free(buf);
 245     }
 246
 247   ancestors[0] = lid;
 248   aref[0] = 1;
 249   acount = 1;
 250   EXEC SQL DECLARE csr103 CURSOR FOR
 251     SELECT list_id, ref_count   FROM imembers
 252     WHERE member_id = :lid AND member_type = 'LIST';
 253   if (dbms_errno)
 254     return mr_errcode;
 255   EXEC SQL OPEN csr103;
 256   if (dbms_errno)
 257     return mr_errcode;
 258   while (1)
 259     {
 260       EXEC SQL FETCH csr103 INTO :id, :ref;
 261       if (sqlca.sqlcode)
 262         break;
 263       aref[acount] = ref;
 264       ancestors[acount++] = id;
 265       if (acount >= MAXLISTDEPTH)
 266         break;
 267     }
 268   EXEC SQL CLOSE csr103;
 269   if (dbms_errno)
 270     return mr_errcode;
 271   if (acount >= MAXLISTDEPTH)
 272     return MR_INTERNAL;
 273   descendants[0] = mid;
 274   dtypes[0] = mtype;
 275   dref[0] = 1;
 276   dcount = 1;
 277   error = 0;
 278   if (!strcmp(mtype, "LIST"))
 279     {
 280       EXEC SQL DECLARE csr104 CURSOR FOR
 281         SELECT member_id, member_type, ref_count
 282         FROM imembers
 283         WHERE list_id = :mid;
 284       if (dbms_errno)
 285         return mr_errcode;
 286       EXEC SQL OPEN csr104;
 287       if (dbms_errno)
 288         return mr_errcode;
 289       while (1)
 290         {
 291           EXEC SQL FETCH csr104 INTO :id, :dtype, :ref;
 292           if (sqlca.sqlcode)
 293             break;
 294           switch (dtype[0])
 295             {
 296             case 'L':
 297               dtypes[dcount] = "LIST";
 298               break;
 299             case 'U':
 300               dtypes[dcount] = "USER";
 301               break;
 302             case 'S':
 303               dtypes[dcount] = "STRING";
 304               break;
 305             case 'K':
 306               dtypes[dcount] = "KERBEROS";
 307               break;
 308             case 'M':
 309               dtypes[dcount] = "MACHINE";
 310               break;
 311             default:
 312               error++;
 313               break;
 314             }
 315           dref[dcount] = ref;
 316           descendants[dcount++] = id;
 317           if (dcount >= MAXLISTDEPTH)
 318             {
 319               error++;
 320               break;
 321             }
 322         }
 323       EXEC SQL CLOSE csr104;
 324       if (dbms_errno)
 325         return mr_errcode;
 326       if (error)
 327         return MR_INTERNAL;
 328     }
 329   for (a = 0; a < acount; a++)
 330     {
 331       lid = ancestors[a];
 332       for (d = 0; d < dcount; d++)
 333         {
 334           mid = descendants[d];
 335           mtype = dtypes[d];
 336           if (mid == lid && !strcmp(mtype, "LIST"))
 337             return MR_LISTLOOP;
 338           EXEC SQL SELECT COUNT(ref_count) INTO :rowcnt
 339             FROM imembers
 340             WHERE list_id = :lid AND member_id = :mid
 341             AND member_type = :mtype;
 342           ref = aref[a] * dref[d];
 343           if (rowcnt > 0)
 344             {
 345               if (a == 0 && d == 0)
 346                 {
 347                   EXEC SQL UPDATE imembers
 348                     SET ref_count = ref_count + :ref, direct = 1, tag = :tag
 349                     WHERE list_id = :lid AND member_id = :mid
 350                     AND member_type = :mtype;
 351                 }
 352               else
 353                 {
 354                   EXEC SQL UPDATE imembers
 355                     SET ref_count = ref_count + :ref
 356                     WHERE list_id = :lid AND member_id = :mid
 357                     AND member_type = :mtype;
 358                 }
 359             }
 360           else
 361             {
 362               incremental_clear_before();
 363               if (a == 0 && d == 0)
 364                 {
 365                   EXEC SQL INSERT INTO imembers
 366                     (list_id, member_type, member_id, tag, direct, ref_count)
 367                     VALUES (:lid, :mtype, :mid, :tag, 1, :ref);
 368                 }
 369               else
 370                 {
 371                   EXEC SQL INSERT INTO imembers
 372                     (list_id, member_type, member_id, tag, direct, ref_count)
 373                     VALUES (:lid, :mtype, :mid, :tag, 0, :ref);
 374                 }
 375               iargv[0] = (char *)lid;
 376               iargv[1] = mtype;
 377               iargv[2] = (char *)mid;
 378               incremental_after(IMEMBERS_TABLE, 0, iargv);
 379             }
 380         }
 381     }
 382   lid = *(int *)argv[0];
 383   entity = cl->entity;
 384   who = cl->client_id;
 385   EXEC SQL UPDATE list
 386     SET modtime = SYSDATE, modby = :who, modwith = :entity
 387     WHERE list_id = :lid;
 388   if (dbms_errno)
 389     return mr_errcode;
 390   return MR_SUCCESS;
 391 }
 392
 393
 394 /* Delete_member_from_list: do list flattening as we go!
 395  */
 396
 397 int delete_member_from_list(struct query *q, char **argv, client *cl)
 398 {
 399   EXEC SQL BEGIN DECLARE SECTION;
 400   int id, lid, mid, cnt, error, who, ref;
 401   char *mtype, dtype[IMEMBERS_MEMBER_TYPE_SIZE], *entity;
 402   EXEC SQL END DECLARE SECTION;
 403   int ancestors[MAXLISTDEPTH], aref[MAXLISTDEPTH], acount, a;
 404   int descendants[MAXLISTDEPTH], dref[MAXLISTDEPTH], dcount, d;
 405   char *dtypes[MAXLISTDEPTH];
 406   char *iargv[3];
 407
 408   lid = *(int *)argv[0];
 409   mtype = argv[1];
 410   mid = *(int *)argv[2];
 411
 412   if (acl_access_check(lid, cl))
 413     return MR_PERM;
 414
 415   /* if the member is not a direct member of the list, punt */
 416   EXEC SQL SELECT COUNT(list_id) INTO :cnt FROM imembers
 417     WHERE list_id = :lid AND member_id = :mid
 418     AND member_type = :mtype AND direct = 1;
 419   if (dbms_errno)
 420     return mr_errcode;
 421   if (cnt == 0)
 422     return MR_NO_MATCH;
 423   ancestors[0] = lid;
 424   aref[0] = 1;
 425   acount = 1;
 426   EXEC SQL DECLARE csr105 CURSOR FOR
 427     SELECT list_id, ref_count FROM imembers
 428     WHERE member_id = :lid AND member_type = 'LIST';
 429   if (dbms_errno)
 430     return mr_errcode;
 431   EXEC SQL OPEN csr105;
 432   if (dbms_errno)
 433     return mr_errcode;
 434   while (1)
 435     {
 436       EXEC SQL FETCH csr105 INTO :id, :ref;
 437       if (sqlca.sqlcode)
 438         break;
 439       aref[acount] = ref;
 440       ancestors[acount++] = id;
 441       if (acount >= MAXLISTDEPTH)
 442         break;
 443     }
 444   EXEC SQL CLOSE csr105;
 445   if (dbms_errno)
 446     return mr_errcode;
 447   if (acount >= MAXLISTDEPTH)
 448     return MR_INTERNAL;
 449   descendants[0] = mid;
 450   dtypes[0] = mtype;
 451   dref[0] = 1;
 452   dcount = 1;
 453   error = 0;
 454   if (!strcmp(mtype, "LIST"))
 455     {
 456       EXEC SQL DECLARE csr106 CURSOR FOR
 457         SELECT member_id, member_type, ref_count FROM imembers
 458         WHERE list_id = :mid;
 459       if (dbms_errno)
 460         return mr_errcode;
 461       EXEC SQL OPEN csr106;
 462       if (dbms_errno)
 463         return mr_errcode;
 464       while (1)
 465         {
 466           EXEC SQL FETCH csr106 INTO :id, :dtype, :ref;
 467           if (sqlca.sqlcode)
 468             break;
 469           switch (dtype[0])
 470             {
 471             case 'L':
 472               dtypes[dcount] = "LIST";
 473               break;
 474             case 'U':
 475               dtypes[dcount] = "USER";
 476               break;
 477             case 'S':
 478               dtypes[dcount] = "STRING";
 479               break;
 480             case 'K':
 481               dtypes[dcount] = "KERBEROS";
 482               break;
 483             case 'M':
 484               dtypes[dcount] = "MACHINE";
 485               break;
 486             default:
 487               error++;
 488               break;
 489             }
 490           dref[dcount] = ref;
 491           descendants[dcount++] = id;
 492           if (dcount >= MAXLISTDEPTH)
 493             break;
 494         }
 495       EXEC SQL CLOSE csr106;
 496       if (dbms_errno)
 497         return mr_errcode;
 498       if (error)
 499         return MR_INTERNAL;
 500     }
 501   for (a = 0; a < acount; a++)
 502     {
 503       lid = ancestors[a];
 504       for (d = 0; d < dcount; d++)
 505         {
 506           mid = descendants[d];
 507           mtype = dtypes[d];
 508           if (mid == lid && !strcmp(mtype, "LIST"))
 509             return MR_LISTLOOP;
 510           EXEC SQL SELECT ref_count INTO :cnt FROM imembers
 511             WHERE list_id = :lid AND member_id = :mid AND member_type = :mtype;
 512           ref = aref[a] * dref[d];
 513           if (cnt <= ref)
 514             {
 515               iargv[0] = (char *)lid;
 516               iargv[1] = mtype;
 517               iargv[2] = (char *)mid;
 518               incremental_before(IMEMBERS_TABLE, 0, iargv);
 519               EXEC SQL DELETE FROM imembers
 520                 WHERE list_id = :lid AND member_id = :mid
 521                 AND member_type= :mtype;
 522               incremental_clear_after();
 523             }
 524           else if (a == 0 && d == 0)
 525             {
 526               EXEC SQL UPDATE imembers
 527                 SET ref_count = ref_count - :ref, direct = 0
 528                 WHERE list_id = :lid AND member_id = :mid
 529                 AND member_type = :mtype;
 530             }
 531           else
 532             {
 533               EXEC SQL UPDATE imembers
 534                 SET ref_count = ref_count - :ref
 535                 WHERE list_id = :lid AND member_id = :mid
 536                 AND member_type = :mtype;
 537             }
 538         }
 539     }
 540   lid = *(int *)argv[0];
 541   entity = cl->entity;
 542   who = cl->client_id;
 543   EXEC SQL UPDATE list SET modtime = SYSDATE, modby = :who, modwith = :entity
 544     WHERE list_id = :lid;
 545   if (dbms_errno)
 546     return mr_errcode;
 547   return MR_SUCCESS;
 548 }
 549
 550 int tag_member_of_list(struct query *q, char **argv, client *cl)
 551 {
 552   EXEC SQL BEGIN DECLARE SECTION;
 553   int lid, mid, cnt, tag;
 554   char *mtype;
 555   EXEC SQL END DECLARE SECTION;
 556   char *iargv[3];
 557
 558   lid = *(int *)argv[0];
 559   mtype = argv[1];
 560   mid = *(int *)argv[2];
 561   tag = *(int *)argv[3];
 562
 563   EXEC SQL SELECT COUNT(member_id) INTO :cnt FROM imembers
 564     WHERE member_id = :mid AND member_type = :mtype AND
 565     list_id = :lid;
 566   if (dbms_errno)
 567     return mr_errcode;
 568   if (cnt == 0)
 569     return MR_NO_MATCH;
 570
 571   incremental_clear_before();
 572   EXEC SQL UPDATE imembers SET tag = :tag WHERE list_id = :lid
 573     AND member_type = :mtype AND member_id = :mid;
 574   if (dbms_errno)
 575     return mr_errcode;
 576
 577   iargv[0] = (char *)lid;
 578   iargv[1] = mtype;
 579   iargv[2] = (char *)mid;
 580   incremental_after(IMEMBERS_TABLE, 0, iargv);
 581
 582   return MR_SUCCESS;
 583 }
 584
 585 /* Don't allow someone to add someone to a list which is the acl of a
 586  * query unless they're on the list acl, even if they're on the amtl
 587  * query acl! Also, don't allow someone proxying to add someone to a
 588  * capacl.
 589  */
 590 int acl_access_check(int list_id, client *cl)
 591 {
 592   EXEC SQL BEGIN DECLARE SECTION;
 593   int c1, c2, lid = list_id, acl_id, memacl_id;
 594   char acl_type[LIST_ACL_TYPE_SIZE], memacl_type[LIST_ACL_TYPE_SIZE];
 595   EXEC SQL END DECLARE SECTION;
 596
 597   /* Check if the list is directly a capacl */
 598   EXEC SQL SELECT COUNT(list_id) INTO :c1 FROM capacls WHERE list_id=:lid;
 599
 600   /* Check if the list is a member (direct or indirect) of a list that
 601      is a capacl */
 602   EXEC SQL SELECT COUNT(l1.list_id) INTO :c2 FROM list l1, list l2,
 603     imembers im, capacls c WHERE c.list_id = l2.list_id AND
 604     im.list_id = l2.list_id AND im.member_type = 'LIST' AND
 605     im.member_id = l1.list_id AND l1.list_id = :lid;
 606
 607   if (c1 == 0 && c2 == 0)
 608     return 0;
 609
 610   if (cl->proxy_id)
 611     return 1;
 612
 613   EXEC SQL SELECT acl_type, acl_id, memacl_type, memacl_id
 614     INTO :acl_type, :acl_id, :memacl_type, :memacl_id
 615     FROM list WHERE list_id=:lid;
 616
 617   if (!find_member(acl_type, acl_id, cl))
 618     {
 619       if (!find_member(memacl_type, memacl_id, cl))
 620         return 1;
 621     }
 622
 623   return 0;
 624 }
 625
 626
 627 /* get_ace_use - given a type and a name, return a type and a name.
 628  * The ace_type is one of "LIST", "USER", "RLIST", or "RUSER" in argv[0],
 629  * and argv[1] will contain the ID of the entity in question.  The R*
 630  * types mean to recursively look at every containing list, not just
 631  * when the object in question is a direct member.  On return, the
 632  * usage type will be one of LIST, SERVICE, FILESYS, QUOTA, QUERY, or ZEPHYR.
 633  */
 634
 635 int get_ace_use(struct query *q, char *argv[], client *cl,
 636                 int (*action)(int, char *[], void *), void *actarg)
 637 {
 638   int found = 0;
 639   EXEC SQL BEGIN DECLARE SECTION;
 640   char *atype;
 641   int aid, listid, id;
 642   EXEC SQL END DECLARE SECTION;
 643   struct save_queue *sq;
 644
 645   atype = argv[0];
 646   aid = *(int *)argv[1];
 647   if (!strcmp(atype, "LIST") || !strcmp(atype, "USER") ||
 648       !strcmp(atype, "KERBEROS"))
 649     return get_ace_internal(atype, aid, action, actarg);
 650
 651   sq = sq_create();
 652   if (!strcmp(atype, "RLIST"))
 653     {
 654       sq_save_data(sq, (void *)aid);
 655       /* get all the list_id's of containing lists */
 656       EXEC SQL DECLARE csr107 CURSOR FOR
 657         SELECT list_id FROM imembers
 658         WHERE member_type = 'LIST' AND member_id = :aid;
 659       if (dbms_errno)
 660         return mr_errcode;
 661       EXEC SQL OPEN csr107;
 662       if (dbms_errno)
 663         return mr_errcode;
 664       while (1)
 665         {
 666           EXEC SQL FETCH csr107 INTO :listid;
 667           if (sqlca.sqlcode)
 668             break;
 669           sq_save_unique_data(sq, (void *)listid);
 670         }
 671       EXEC SQL CLOSE csr107;
 672       /* now process each one */
 673       while (sq_get_data(sq, &id))
 674         {
 675           if (get_ace_internal("LIST", id, action, actarg) == MR_SUCCESS)
 676             found++;
 677         }
 678     }
 679
 680   if (!strcmp(atype, "RUSER"))
 681     {
 682       EXEC SQL DECLARE csr108 CURSOR FOR
 683         SELECT list_id FROM imembers
 684         WHERE member_type = 'USER' AND member_id = :aid;
 685       if (dbms_errno)
 686         return mr_errcode;
 687       EXEC SQL OPEN csr108;
 688       if (dbms_errno)
 689         return mr_errcode;
 690       while (1)
 691         {
 692           EXEC SQL FETCH csr108 INTO :listid;
 693           if (sqlca.sqlcode)
 694             break;
 695           sq_save_data(sq, (void *)listid);
 696         }
 697       EXEC SQL CLOSE csr108;
 698       /* now process each one */
 699       while (sq_get_data(sq, &id))
 700         {
 701           if (get_ace_internal("LIST", id, action, actarg) == MR_SUCCESS)
 702             found++;
 703         }
 704       if (get_ace_internal("USER", aid, action, actarg) == MR_SUCCESS)
 705         found++;
 706     }
 707
 708   if (!strcmp(atype, "RKERBEROS"))
 709     {
 710       EXEC SQL DECLARE csr109 CURSOR FOR
 711         SELECT list_id FROM imembers
 712         WHERE member_type = 'KERBEROS' AND member_id = :aid;
 713       if (dbms_errno)
 714         return mr_errcode;
 715       EXEC SQL OPEN csr109;
 716       if (dbms_errno)
 717         return mr_errcode;
 718       while (1)
 719         {
 720           EXEC SQL FETCH csr109 INTO :listid;
 721           if (sqlca.sqlcode)
 722             break;
 723           sq_save_data(sq, (void *)listid);
 724         }
 725       EXEC SQL CLOSE csr109;
 726       /* now process each one */
 727       while (sq_get_data(sq, &id))
 728         {
 729           if (get_ace_internal("LIST", id, action, actarg) == MR_SUCCESS)
 730             found++;
 731         }
 732       if (get_ace_internal("KERBEROS", aid, action, actarg) == MR_SUCCESS)
 733         found++;
 734     }
 735
 736   sq_destroy(sq);
 737   if (dbms_errno)
 738     return mr_errcode;
 739   if (!found)
 740     return MR_NO_MATCH;
 741   return MR_SUCCESS;
 742 }
 743
 744
 745 /* This looks up a single list or user for ace use.  atype must be "USER"
 746  * or "LIST", and aid is the ID of the corresponding object.  This is used
 747  * by get_ace_use above.
 748  */
 749
 750 int get_ace_internal(char *atype, int aid,
 751                      int (*action)(int, char *[], void *), void *actarg)
 752 {
 753   char *rargv[2];
 754   int found = 0;
 755   EXEC SQL BEGIN DECLARE SECTION;
 756   char name[MAX_FIELD_WIDTH], *type = atype;
 757   int id = aid;
 758   EXEC SQL END DECLARE SECTION;
 759
 760   rargv[1] = name;
 761   if (!strcmp(atype, "LIST"))
 762     {
 763       rargv[0] = "FILESYS";
 764       EXEC SQL DECLARE csr110 CURSOR FOR
 765         SELECT label FROM filesys
 766         WHERE owners = :id;
 767       if (dbms_errno)
 768         return mr_errcode;
 769       EXEC SQL OPEN csr110;
 770       if (dbms_errno)
 771         return mr_errcode;
 772       while (1)
 773         {
 774           EXEC SQL FETCH csr110 INTO :name;
 775           if (sqlca.sqlcode)
 776             break;
 777           (*action)(2, rargv, actarg);
 778           found++;
 779         }
 780       EXEC SQL CLOSE csr110;
 781
 782       rargv[0] = "QUERY";
 783       EXEC SQL DECLARE csr111 CURSOR FOR
 784         SELECT capability FROM capacls
 785         WHERE list_id = :id;
 786       if (dbms_errno)
 787         return mr_errcode;
 788       EXEC SQL OPEN csr111;
 789       if (dbms_errno)
 790         return mr_errcode;
 791       while (1)
 792         {
 793           EXEC SQL FETCH csr111 INTO :name;
 794           if (sqlca.sqlcode)
 795             break;
 796           (*action)(2, rargv, actarg);
 797           found++;
 798         }
 799       EXEC SQL CLOSE csr111;
 800     }
 801   else if (!strcmp(atype, "USER"))
 802     {
 803       rargv[0] = "FILESYS";
 804       EXEC SQL DECLARE csr112 CURSOR FOR
 805         SELECT label FROM filesys
 806         WHERE owner = :id;
 807       if (dbms_errno)
 808         return mr_errcode;
 809       EXEC SQL OPEN csr112;
 810       if (dbms_errno)
 811         return mr_errcode;
 812       while (1)
 813         {
 814           EXEC SQL FETCH csr112 INTO :name;
 815           if (sqlca.sqlcode)
 816             break;
 817           (*action)(2, rargv, actarg);
 818           found++;
 819         }
 820       EXEC SQL CLOSE csr112;
 821     }
 822
 823   rargv[0] = "LIST";
 824   EXEC SQL DECLARE csr113 CURSOR FOR
 825     SELECT name FROM list
 826     WHERE (acl_type = :type AND acl_id = :id)
 827     OR (memacl_type = :type AND memacl_id = :id);
 828   if (dbms_errno)
 829     return mr_errcode;
 830   EXEC SQL OPEN csr113;
 831   if (dbms_errno)
 832     return mr_errcode;
 833   while (1)
 834     {
 835       EXEC SQL FETCH csr113 INTO :name;
 836       if (sqlca.sqlcode)
 837         break;
 838       (*action)(2, rargv, actarg);
 839       found++;
 840     }
 841   EXEC SQL CLOSE csr113;
 842
 843   rargv[0] = "SERVICE";
 844   EXEC SQL DECLARE csr114 CURSOR FOR
 845     SELECT name FROM servers
 846     WHERE acl_type = :type AND acl_id = :id;
 847   if (dbms_errno)
 848     return mr_errcode;
 849   EXEC SQL OPEN csr114;
 850   if (dbms_errno)
 851     return mr_errcode;
 852   while (1)
 853     {
 854       EXEC SQL FETCH csr114 INTO :name;
 855       if (sqlca.sqlcode)
 856         break;
 857       (*action)(2, rargv, actarg);
 858       found++;
 859     }
 860   EXEC SQL CLOSE csr114;
 861
 862   rargv[0] = "HOSTACCESS";
 863   EXEC SQL DECLARE csr115 CURSOR FOR
 864     SELECT name FROM machine m, hostaccess ha
 865     WHERE m.mach_id = ha.mach_id AND ha.acl_type = :type
 866     AND ha.acl_id = :id;
 867   if (dbms_errno)
 868     return mr_errcode;
 869   EXEC SQL OPEN csr115;
 870   if (dbms_errno)
 871     return mr_errcode;
 872   while (1)
 873     {
 874       EXEC SQL FETCH csr115 INTO :name;
 875       if (sqlca.sqlcode)
 876         break;
 877       (*action)(2, rargv, actarg);
 878       found++;
 879     }
 880   EXEC SQL CLOSE csr115;
 881
 882   rargv[0] = "MACHINE";
 883   EXEC SQL DECLARE csr115a CURSOR FOR
 884     SELECT name FROM machine m
 885     WHERE m.owner_type = :type
 886     AND m.owner_id = :id;
 887   if (dbms_errno)
 888     return mr_errcode;
 889   EXEC SQL OPEN csr115a;
 890   if (dbms_errno)
 891     return mr_errcode;
 892   while (1)
 893     {
 894       EXEC SQL FETCH csr115a INTO :name;
 895       if (sqlca.sqlcode)
 896         break;
 897       (*action)(2, rargv, actarg);
 898       found++;
 899     }
 900   EXEC SQL CLOSE csr115a;
 901
 902   rargv[0] = "ZEPHYR";
 903   EXEC SQL DECLARE csr116 CURSOR FOR
 904     SELECT class FROM zephyr z
 905     WHERE z.xmt_type = :type AND z.xmt_id = :id
 906     OR z.sub_type = :type AND z.sub_id = :id
 907     OR z.iws_type = :type AND z.iws_id = :id
 908     OR z.iui_type = :type AND z.iui_id = :id
 909     OR z.owner_type = :type AND z.owner_id = :id;
 910   if (dbms_errno)
 911     return mr_errcode;
 912   EXEC SQL OPEN csr116;
 913   if (dbms_errno)
 914     return mr_errcode;
 915   while (1)
 916     {
 917       EXEC SQL FETCH csr116 INTO :name;
 918       if (sqlca.sqlcode)
 919         break;
 920       (*action)(2, rargv, actarg);
 921       found++;
 922     }
 923   EXEC SQL CLOSE csr116;
 924
 925   rargv[0] = "CONTAINER";
 926   EXEC SQL DECLARE csr117c CURSOR FOR
 927     SELECT name FROM containers c
 928     WHERE c.acl_type = :type AND c.acl_id = :id;
 929   if (dbms_errno)
 930     return mr_errcode;
 931   EXEC SQL OPEN csr117c;
 932   while (1)
 933     {
 934       EXEC SQL FETCH csr117c INTO :name;
 935       if (sqlca.sqlcode)
 936         break;
 937       (*action)(2, rargv, actarg);
 938       found++;
 939     }
 940   EXEC SQL CLOSE csr117c;
 941
 942   rargv[0] = "CONTAINER-MEMACL";
 943   EXEC SQL DECLARE csr117d CURSOR FOR
 944     SELECT name FROM containers c
 945     WHERE c.memacl_type = :type AND c.memacl_id = :id;
 946   if (dbms_errno)
 947     return mr_errcode;
 948   EXEC SQL OPEN csr117d;
 949   while (1)
 950     {
 951       EXEC SQL FETCH csr117d INTO :name;
 952       if (sqlca.sqlcode)
 953         break;
 954       (*action)(2, rargv, actarg);
 955       found++;
 956     }
 957   EXEC SQL CLOSE csr117d;
 958
 959   if (!found)
 960     return MR_NO_MATCH;
 961   return MR_SUCCESS;
 962 }
 963
 964 /* ghbo_internal */
 965 int ghbo_internal(char *atype, int aid,
 966                   int (*action)(int, char *[], void *), void *actarg)
 967 {
 968   char *rargv[1];
 969   int found = 0;
 970   EXEC SQL BEGIN DECLARE SECTION;
 971   char name[MACHINE_NAME_SIZE], *type = atype;
 972   int id = aid;
 973   EXEC SQL END DECLARE SECTION;
 974
 975   rargv[0] = name;
 976   EXEC SQL DECLARE csr115b CURSOR FOR
 977     SELECT name FROM machine m
 978     WHERE m.owner_type = :type
 979     AND m.owner_id = :id;
 980   if (dbms_errno)
 981     return mr_errcode;
 982   EXEC SQL OPEN csr115b;
 983   if (dbms_errno)
 984     return mr_errcode;
 985   while (1)
 986     {
 987       EXEC SQL FETCH csr115b INTO :name;
 988       if (sqlca.sqlcode)
 989         break;
 990       (*action)(1, rargv, actarg);
 991       found++;
 992     }
 993   EXEC SQL CLOSE csr115b;
 994
 995   if (!found)
 996     return MR_NO_MATCH;
 997   return MR_SUCCESS;
 998 }
 999
1000 /* get_host_by_owner - like gaus but limited to hosts */
1001 int get_host_by_owner(struct query *q, char *argv[], client *cl,
1002                       int (*action)(int, char *[], void *), void *actarg)
1003 {
1004   int found = 0;
1005   EXEC SQL BEGIN DECLARE SECTION;
1006   char *atype;
1007   int aid, listid, id;
1008   EXEC SQL END DECLARE SECTION;
1009   struct save_queue *sq;
1010
1011   atype = argv[0];
1012   aid = *(int *)argv[1];
1013   if (!strcmp(atype, "LIST") || !strcmp(atype, "USER") ||
1014       !strcmp(atype, "KERBEROS"))
1015     return ghbo_internal(atype, aid, action, actarg);
1016
1017   sq = sq_create();
1018   if (!strcmp(atype, "RLIST"))
1019     {
1020       sq_save_data(sq, (void *)aid);
1021       /* get all the list_id's of containing lists */
1022       EXEC SQL DECLARE csr107q CURSOR FOR
1023         SELECT list_id FROM imembers
1024         WHERE member_type = 'LIST' AND member_id = :aid;
1025       if (dbms_errno)
1026         return mr_errcode;
1027       EXEC SQL OPEN csr107q;
1028       if (dbms_errno)
1029         return mr_errcode;
1030       while (1)
1031         {
1032           EXEC SQL FETCH csr107q INTO :listid;
1033           if (sqlca.sqlcode)
1034             break;
1035           sq_save_unique_data(sq, (void *)listid);
1036         }
1037       EXEC SQL CLOSE csr107q;
1038       /* now process each one */
1039       while (sq_get_data(sq, &id))
1040         {
1041           if (ghbo_internal("LIST", id, action, actarg) == MR_SUCCESS)
1042             found++;
1043         }
1044     }
1045
1046   if (!strcmp(atype, "RUSER"))
1047     {
1048       EXEC SQL DECLARE csr108q CURSOR FOR
1049         SELECT list_id FROM imembers
1050         WHERE member_type = 'USER' AND member_id = :aid;
1051       if (dbms_errno)
1052         return mr_errcode;
1053       EXEC SQL OPEN csr108q;
1054       if (dbms_errno)
1055         return mr_errcode;
1056       while (1)
1057         {
1058           EXEC SQL FETCH csr108q INTO :listid;
1059           if (sqlca.sqlcode)
1060             break;
1061           sq_save_data(sq, (void *)listid);
1062         }
1063       EXEC SQL CLOSE csr108q;
1064       /* now process each one */
1065       while (sq_get_data(sq, &id))
1066         {
1067           if (ghbo_internal("LIST", id, action, actarg) == MR_SUCCESS)
1068             found++;
1069         }
1070       if (ghbo_internal("USER", aid, action, actarg) == MR_SUCCESS)
1071         found++;
1072     }
1073
1074   if (!strcmp(atype, "RKERBEROS"))
1075     {
1076       EXEC SQL DECLARE csr109q CURSOR FOR
1077         SELECT list_id FROM imembers
1078         WHERE member_type = 'KERBEROS' AND member_id = :aid;
1079       if (dbms_errno)
1080         return mr_errcode;
1081       EXEC SQL OPEN csr109q;
1082       if (dbms_errno)
1083         return mr_errcode;
1084       while (1)
1085         {
1086           EXEC SQL FETCH csr109q INTO :listid;
1087           if (sqlca.sqlcode)
1088             break;
1089           sq_save_data(sq, (void *)listid);
1090         }
1091       EXEC SQL CLOSE csr109q;
1092       /* now process each one */
1093       while (sq_get_data(sq, &id))
1094         {
1095           if (ghbo_internal("LIST", id, action, actarg) == MR_SUCCESS)
1096             found++;
1097         }
1098       if (ghbo_internal("KERBEROS", aid, action, actarg) == MR_SUCCESS)
1099         found++;
1100     }
1101
1102   sq_destroy(sq);
1103   if (dbms_errno)
1104     return mr_errcode;
1105   if (!found)
1106     return MR_NO_MATCH;
1107   return MR_SUCCESS;
1108 }
1109
1110 int guas_internal(char *atype, int aid,
1111                   int (*action)(int, char *[], void *), void *actarg)
1112 {
1113   char *rargv[1];
1114   int found = 0;
1115   EXEC SQL BEGIN DECLARE SECTION;
1116   char login[USERS_LOGIN_SIZE], *type = atype;
1117   int id = aid;
1118   EXEC SQL END DECLARE SECTION;
1119
1120   rargv[0] = login;
1121   EXEC SQL DECLARE csr115sp CURSOR FOR
1122     SELECT login FROM users u
1123     WHERE u.sponsor_type = :type
1124     AND u.sponsor_id = :id;
1125   if (dbms_errno)
1126     return mr_errcode;
1127   EXEC SQL OPEN csr115sp;
1128   if (dbms_errno)
1129     return mr_errcode;
1130   while (1)
1131     {
1132       EXEC SQL FETCH csr115sp INTO :login;
1133       if (sqlca.sqlcode)
1134         break;
1135       (*action)(1, rargv, actarg);
1136       found++;
1137     }
1138   EXEC SQL CLOSE csr115sp;
1139
1140   if (!found)
1141     return MR_NO_MATCH;
1142   return MR_SUCCESS;
1143 }
1144
1145 /* get_user_account_by_sponsor - like gaus but limited to user accounts */
1146 int get_user_account_by_sponsor(struct query *q, char *argv[], client *cl,
1147                                 int (*action)(int, char *[], void *),
1148                                 void *actarg)
1149 {
1150   int found = 0;
1151   EXEC SQL BEGIN DECLARE SECTION;
1152   char *atype;
1153   int aid, listid, id;
1154   EXEC SQL END DECLARE SECTION;
1155   struct save_queue *sq;
1156
1157   atype = argv[0];
1158   aid = *(int *)argv[1];
1159   if (!strcmp(atype, "LIST") || !strcmp(atype, "USER") ||
1160       !strcmp(atype, "KERBEROS"))
1161     return guas_internal(atype, aid, action, actarg);
1162
1163   sq = sq_create();
1164   if (!strcmp(atype, "RLIST"))
1165     {
1166       sq_save_data(sq, (void *)aid);
1167       /* get all the list_id's of containing lists */
1168       EXEC SQL DECLARE csr107sp CURSOR FOR
1169         SELECT list_id FROM imembers
1170         WHERE member_type = 'LIST' AND member_id = :aid;
1171       if (dbms_errno)
1172         return mr_errcode;
1173       EXEC SQL OPEN csr107sp;
1174       if (dbms_errno)
1175         return mr_errcode;
1176       while (1)
1177         {
1178           EXEC SQL FETCH csr107sp INTO :listid;
1179           if (sqlca.sqlcode)
1180             break;
1181           sq_save_unique_data(sq, (void *)listid);
1182         }
1183       EXEC SQL CLOSE csr107sp;
1184       /* now process each one */
1185       while (sq_get_data(sq, &id))
1186         {
1187           if (guas_internal("LIST", id, action, actarg) == MR_SUCCESS)
1188             found++;
1189         }
1190     }
1191
1192   if (!strcmp(atype, "RUSER"))
1193     {
1194       EXEC SQL DECLARE csr108sp CURSOR FOR
1195         SELECT list_id FROM imembers
1196         WHERE member_type = 'USER' AND member_id = :aid;
1197       if (dbms_errno)
1198         return mr_errcode;
1199       EXEC SQL OPEN csr108sp;
1200       if (dbms_errno)
1201         return mr_errcode;
1202       while (1)
1203         {
1204           EXEC SQL FETCH csr108sp INTO :listid;
1205           if (sqlca.sqlcode)
1206             break;
1207           sq_save_data(sq, (void *)listid);
1208         }
1209       EXEC SQL CLOSE csr108sp;
1210       /* now process each one */
1211       while (sq_get_data(sq, &id))
1212         {
1213           if (guas_internal("LIST", id, action, actarg) == MR_SUCCESS)
1214             found++;
1215         }
1216       if (guas_internal("USER", aid, action, actarg) == MR_SUCCESS)
1217         found++;
1218     }
1219
1220   if (!strcmp(atype, "RKERBEROS"))
1221     {
1222       EXEC SQL DECLARE csr109sp CURSOR FOR
1223         SELECT list_id FROM imembers
1224         WHERE member_type = 'KERBEROS' AND member_id = :aid;
1225       if (dbms_errno)
1226         return mr_errcode;
1227       EXEC SQL OPEN csr109sp;
1228       if (dbms_errno)
1229         return mr_errcode;
1230       while (1)
1231         {
1232           EXEC SQL FETCH csr109sp INTO :listid;
1233           if (sqlca.sqlcode)
1234             break;
1235           sq_save_data(sq, (void *)listid);
1236         }
1237       EXEC SQL CLOSE csr109sp;
1238       /* now process each one */
1239       while (sq_get_data(sq, &id))
1240         {
1241           if (guas_internal("LIST", id, action, actarg) == MR_SUCCESS)
1242             found++;
1243         }
1244       if (guas_internal("KERBEROS", aid, action, actarg) == MR_SUCCESS)
1245         found++;
1246     }
1247
1248   sq_destroy(sq);
1249   if (dbms_errno)
1250     return mr_errcode;
1251   if (!found)
1252     return MR_NO_MATCH;
1253   return MR_SUCCESS;
1254 }
1255
1256 /* get_lists_of_member - given a type and a name, return the name and flags
1257  * of all of the lists of the given member.  The member_type is one of
1258  * "LIST", "USER", "STRING", "KERBEROS", "MACHINE", "RLIST", "RUSER",
1259  * "RSTRING", "RKERBEROS", or "RMACHINE" in argv[0], and argv[1] will contain
1260  * the ID of the entity in question.  The R* types mean to recursively look
1261  * at every containing list, not just when the object in question is a direct
1262  * member.
1263  */
1264
1265 int get_lists_of_member(struct query *q, char *argv[], client *cl,
1266                         int (*action)(int, char *[], void *), void *actarg)
1267 {
1268   int found = 0, direct = 1;
1269   char *rargv[6];
1270   EXEC SQL BEGIN DECLARE SECTION;
1271   char *atype;
1272   int aid;
1273   char name[LIST_NAME_SIZE];
1274   char active[5], public[5], hidden[5], maillist[5], grouplist[5];
1275   EXEC SQL END DECLARE SECTION;
1276
1277   atype = argv[0];
1278   aid = *(int *)argv[1];
1279   if (!strcmp(atype, "RLIST"))
1280     {
1281       atype = "LIST";
1282       direct = 0;
1283     }
1284   if (!strcmp(atype, "RUSER"))
1285     {
1286       atype = "USER";
1287       direct = 0;
1288     }
1289   if (!strcmp(atype, "RSTRING"))
1290     {
1291       atype = "STRING";
1292       direct = 0;
1293     }
1294   if (!strcmp(atype, "RKERBEROS"))
1295     {
1296       atype = "KERBEROS";
1297       direct = 0;
1298     }
1299   if (!strcmp(atype, "RMACHINE"))
1300     {
1301       atype = "MACHINE";
1302       direct = 0;
1303     }
1304
1305   rargv[0] = name;
1306   rargv[1] = active;
1307   rargv[2] = public;
1308   rargv[3] = hidden;
1309   rargv[4] = maillist;
1310   rargv[5] = grouplist;
1311   if (direct)
1312     {
1313       EXEC SQL DECLARE csr117a CURSOR FOR
1314         SELECT l.name, l.active, l.publicflg, l.hidden, l.maillist, l.grouplist
1315         FROM list l, imembers im
1316         WHERE l.list_id = im.list_id AND im.direct = 1
1317         AND im.member_type = :atype AND im.member_id = :aid;
1318       if (dbms_errno)
1319         return mr_errcode;
1320       EXEC SQL OPEN csr117a;
1321       if (dbms_errno)
1322         return mr_errcode;
1323       while (1)
1324         {
1325           EXEC SQL FETCH csr117a
1326             INTO :name, :active, :public, :hidden, :maillist, :grouplist;
1327           if (sqlca.sqlcode)
1328             break;
1329           (*action)(6, rargv, actarg);
1330           found++;
1331         }
1332       EXEC SQL CLOSE csr117a;
1333     }
1334   else
1335     {
1336       EXEC SQL DECLARE csr117b CURSOR FOR
1337         SELECT l.name, l.active, l.publicflg, l.hidden, l.maillist, l.grouplist
1338         FROM list l, imembers im
1339         WHERE l.list_id = im.list_id
1340         AND im.member_type = :atype AND im.member_id = :aid;
1341       if (dbms_errno)
1342         return mr_errcode;
1343       EXEC SQL OPEN csr117b;
1344       if (dbms_errno)
1345         return mr_errcode;
1346       while (1)
1347         {
1348           EXEC SQL FETCH csr117b
1349             INTO :name, :active, :public, :hidden, :maillist, :grouplist;
1350           if (sqlca.sqlcode)
1351             break;
1352           (*action)(6, rargv, actarg);
1353           found++;
1354         }
1355       EXEC SQL CLOSE csr117b;
1356     }
1357
1358   if (dbms_errno)
1359     return mr_errcode;
1360   if (!found)
1361     return MR_NO_MATCH;
1362   return MR_SUCCESS;
1363 }
1364
1365
1366 /* qualified_get_lists: passed "TRUE", "FALSE", or "DONTCARE" for each of
1367  * the five flags associated with each list.  It will return the name of
1368  * each list that meets the quailifications.  It does this by building a
1369  * where clause based on the arguments, then doing a retrieve.
1370  */
1371
1372 static char *lflags[5] = { "active", "publicflg", "hidden", "maillist", "grouplist" };
1373
1374 int qualified_get_lists(struct query *q, char *argv[], client *cl,
1375                         int (*action)(int, char *[], void *), void *actarg)
1376 {
1377   return qualified_get(q, argv, action, actarg, "l.list_id != 0",
1378                        "l", "name", lflags);
1379 }
1380
1381
1382 int get_members_of_list(struct query *q, char *argv[], client *cl,
1383                         int (*action)(int, char *[], void *), void *actarg)
1384 {
1385   EXEC SQL BEGIN DECLARE SECTION;
1386   int list_id, direct;
1387   char member_name[MAX_FIELD_WIDTH], tag[STRINGS_STRING_SIZE];
1388   EXEC SQL END DECLARE SECTION;
1389   char *targv[3];
1390   int targc;
1391
1392   /* For gmol or gtml, only get direct members. For geml, get all. */
1393   if (!strcmp(q->shortname, "geml"))
1394     direct = -1;
1395   else
1396     direct = 0;
1397
1398   /* For gmol or geml, only return type and name. For gtml, return tag too. */
1399   if (!strcmp(q->shortname, "gtml"))
1400     targc = 3;
1401   else
1402     targc = 2;
1403
1404   list_id = *(int *)argv[0];
1405
1406   targv[1] = member_name;
1407   targv[2] = tag;
1408
1409   targv[0] = "USER";
1410   EXEC SQL DECLARE csr119 CURSOR FOR
1411     SELECT u.login, s.string FROM users u, imembers im, strings s
1412     WHERE im.list_id = :list_id AND im.member_type = 'USER'
1413     AND im.member_id = u.users_id AND im.direct > :direct
1414     AND s.string_id = im.tag ORDER BY 1;
1415   if (dbms_errno)
1416     return mr_errcode;
1417   EXEC SQL OPEN csr119;
1418   if (dbms_errno)
1419     return mr_errcode;
1420   while (1)
1421     {
1422       EXEC SQL FETCH csr119 INTO :member_name, :tag;
1423       if (sqlca.sqlcode)
1424         break;
1425       (*action)(targc, targv, actarg);
1426     }
1427   EXEC SQL CLOSE csr119;
1428   if (dbms_errno)
1429     return mr_errcode;
1430
1431   targv[0] = "LIST";
1432   EXEC SQL DECLARE csr120 CURSOR FOR
1433     SELECT l.name, s.string FROM list l, imembers im, strings s
1434     WHERE im.list_id = :list_id AND im.member_type = 'LIST'
1435     AND im.member_id = l.list_id AND im.direct > :direct
1436     AND s.string_id = im.tag ORDER BY 1;
1437   if (dbms_errno)
1438     return mr_errcode;
1439   EXEC SQL OPEN csr120;
1440   if (dbms_errno)
1441     return mr_errcode;
1442   while (1)
1443     {
1444       EXEC SQL FETCH csr120 INTO :member_name, :tag;
1445       if (sqlca.sqlcode)
1446         break;
1447       (*action)(targc, targv, actarg);
1448     }
1449   EXEC SQL CLOSE csr120;
1450   if (dbms_errno)
1451     return mr_errcode;
1452
1453   targv[0] = "STRING";
1454   EXEC SQL DECLARE csr121 CURSOR FOR
1455     SELECT str.string, s.string FROM strings str, imembers im, strings s
1456     WHERE im.list_id = :list_id AND im.member_type = 'STRING'
1457     AND im.member_id = str.string_id AND im.direct > :direct
1458     AND s.string_id = im.tag ORDER BY 1;
1459   if (dbms_errno)
1460     return mr_errcode;
1461   EXEC SQL OPEN csr121;
1462   if (dbms_errno)
1463     return mr_errcode;
1464   while (1)
1465     {
1466       EXEC SQL FETCH csr121 INTO :member_name, :tag;
1467       if (sqlca.sqlcode)
1468         break;
1469       (*action)(targc, targv, actarg);
1470     }
1471   EXEC SQL CLOSE csr121;
1472   if (dbms_errno)
1473     return mr_errcode;
1474
1475   targv[0] = "KERBEROS";
1476   EXEC SQL DECLARE csr122 CURSOR FOR
1477     SELECT str.string, s.string FROM strings str, imembers im, strings s
1478     WHERE im.list_id = :list_id AND im.member_type = 'KERBEROS'
1479     AND im.member_id = str.string_id AND im.direct > :direct
1480     AND s.string_id = im.tag ORDER BY 1;
1481   if (dbms_errno)
1482     return mr_errcode;
1483   EXEC SQL OPEN csr122;
1484   if (dbms_errno)
1485     return mr_errcode;
1486   while (1)
1487     {
1488       EXEC SQL FETCH csr122 INTO :member_name, :tag;
1489       if (sqlca.sqlcode)
1490         break;
1491       (*action)(targc, targv, actarg);
1492     }
1493   EXEC SQL CLOSE csr122;
1494   if (dbms_errno)
1495     return mr_errcode;
1496
1497   targv[0] = "MACHINE";
1498   EXEC SQL DECLARE csr123 CURSOR FOR
1499     SELECT m.name, s.string FROM machine m, imembers im, strings s
1500     WHERE im.list_id = :list_id AND im.member_type = 'MACHINE'
1501     AND im.member_id = m.mach_id AND im.direct > :direct
1502     AND s.string_id = im.tag ORDER BY 1;
1503   if (dbms_errno)
1504     return mr_errcode;
1505   EXEC SQL OPEN csr123;
1506   if (dbms_errno)
1507     return mr_errcode;
1508   while (1)
1509     {
1510       EXEC SQL FETCH csr123 INTO :member_name, :tag;
1511       if (sqlca.sqlcode)
1512         break;
1513       (*action)(targc, targv, actarg);
1514     }
1515   EXEC SQL CLOSE csr123;
1516   if (dbms_errno)
1517     return mr_errcode;
1518
1519   return MR_SUCCESS;
1520 }
1521
1522
1523 /* count_members_of_list: this is a simple query, but it cannot be done
1524  * through the dispatch table.
1525  */
1526
1527 int count_members_of_list(struct query *q, char *argv[], client *cl,
1528                           int (*action)(int, char *[], void *), void *actarg)
1529 {
1530   EXEC SQL BEGIN DECLARE SECTION;
1531   int  list, ct = 0;
1532   EXEC SQL END DECLARE SECTION;
1533   char *rargv[1], countbuf[5];
1534
1535   list = *(int *)argv[0];
1536   rargv[0] = countbuf;
1537   EXEC SQL SELECT count (*) INTO :ct FROM imembers
1538     WHERE list_id = :list AND direct = 1;
1539   if (dbms_errno)
1540     return mr_errcode;
1541   sprintf(countbuf, "%d", ct);
1542   (*action)(1, rargv, actarg);
1543   return MR_SUCCESS;
1544 }
1545
1546
1547 /* qualified_get_server: passed "TRUE", "FALSE", or "DONTCARE" for each of
1548  * the three flags associated with each service.  It will return the name of
1549  * each service that meets the quailifications.  It does this by building a
1550  * where clause based on the arguments, then doing a retrieve.
1551  */
1552
1553 static char *sflags[3] = { "enable", "inprogress", "harderror" };
1554
1555 int qualified_get_server(struct query *q, char *argv[], client *cl,
1556                          int (*action)(int, char *[], void *), void *actarg)
1557 {
1558   return qualified_get(q, argv, action, actarg, "s.name is not null",
1559                        "s", "name", sflags);
1560   /* of course, name will never be null, but we need something there
1561      to make qualified_get happy */
1562 }
1563
1564
1565 /* generic qualified get routine, used by qualified_get_lists,
1566  * qualified_get_server, and qualified_get_serverhost.
1567  *   Args:
1568  *      start - a simple where clause, must not be empty
1569  *      range - the name of the range variable
1570  *      field - the field to return
1571  *      flags - an array of strings, names of the flag variables
1572  */
1573
1574 int qualified_get(struct query *q, char *argv[],
1575                   int (*action)(int, char *[], void *), void *actarg,
1576                   char *start, char *range, char *field, char *flags[])
1577 {
1578   char qual[256];
1579   int i;
1580   char buf[32];
1581
1582   strcpy(qual, start);
1583   for (i = 0; i < q->argc; i++)
1584     {
1585       if (!strcmp(argv[i], "TRUE"))
1586         {
1587           sprintf(buf, " AND %s.%s != 0", range, flags[i]);
1588           strcat(qual, buf);
1589         }
1590       else if (!strcmp(argv[i], "FALSE"))
1591         {
1592           sprintf(buf, " AND %s.%s = 0", range, flags[i]);
1593           strcat(qual, buf);
1594         }
1595     }
1596
1597   sprintf(stmt_buf, "SELECT %s.%s FROM %s %s WHERE %s", range, field,
1598           table_name[q->rtable], range, qual);
1599   return do_for_all_rows(stmt_buf, 1, action, actarg);
1600 }
1601
1602
1603 /* qualified_get_serverhost: passed "TRUE", "FALSE", or "DONTCARE" for each of
1604  * the five flags associated with each serverhost.  It will return the name of
1605  * each service and host that meets the quailifications.  It does this by
1606  * building a where clause based on the arguments, then doing a retrieve.
1607  */
1608
1609 static char *shflags[6] = { "service", "enable", "override", "success",
1610                             "inprogress", "hosterror" };
1611
1612 int qualified_get_serverhost(struct query *q, char *argv[], client *cl,
1613                              int (*action)(int, char *[], void *),
1614                              void *actarg)
1615 {
1616   char qual[256], buf[32];
1617   int i;
1618
1619   sprintf(qual, "m.mach_id = sh.mach_id AND sh.service = UPPER('%s')",
1620           argv[0]);
1621   for (i = 1; i < q->argc; i++)
1622     {
1623       if (!strcmp(argv[i], "TRUE"))
1624         {
1625           sprintf(buf, " AND sh.%s != 0", shflags[i]);
1626           strcat(qual, buf);
1627         }
1628       else if (!strcmp(argv[i], "FALSE"))
1629         {
1630           sprintf(buf, " AND sh.%s = 0", shflags[i]);
1631           strcat(qual, buf);
1632         }
1633     }
1634
1635   sprintf(stmt_buf, "SELECT sh.service, m.name FROM serverhosts sh, "
1636           "machine m WHERE %s", qual);
1637   return do_for_all_rows(stmt_buf, 2, action, actarg);
1638 }
1639
1640
1641 /* register_user - change user's login name and allocate a pobox, group,
1642  * filesystem, and quota for them.  The user's status must start out as 0,
1643  * and is left as 2.  Arguments are: user's UID, new login name, and
1644  * pobox type ("POP" = POP, "IMAP" or numeric = IMAP, "EXCHANGE" = EXCHANGE)
1645  */
1646
1647 int register_user(struct query *q, char **argv, client *cl)
1648 {
1649   EXEC SQL BEGIN DECLARE SECTION;
1650   char *login, *entity;
1651   char directory[FILESYS_NAME_SIZE], machname[MACHINE_NAME_SIZE];
1652   char dir[NFSPHYS_DIR_SIZE], *potype;
1653   int who, rowcount, mid, uid, users_id;
1654   int ostatus, nstatus, fsidval, popid;
1655   int npid, tmp;
1656   int po_exists = 0;
1657   static int m_id, def_quota, def_imap_quota, list_id, exchange_id;
1658   EXEC SQL END DECLARE SECTION;
1659   char buffer[256], *aargv[3];
1660
1661   if (!m_id)
1662     {
1663       EXEC SQL SELECT list_id INTO :list_id FROM list
1664         WHERE name = 'wheel';
1665
1666       EXEC SQL SELECT mach_id INTO :m_id FROM machine
1667         WHERE name = 'ATHENA.MIT.EDU';
1668
1669       EXEC SQL SELECT mach_id INTO :exchange_id FROM machine
1670         WHERE name = 'EXCHANGE.MIT.EDU';
1671     }
1672
1673   EXEC SQL SELECT value INTO :def_quota FROM numvalues
1674     WHERE name = 'def_quota';
1675   if (sqlca.sqlerrd[2] != 1)
1676     return MR_NO_QUOTA;
1677
1678   EXEC SQL SELECT value INTO :def_imap_quota FROM numvalues
1679     WHERE name = 'def_imap_quota';
1680   if (sqlca.sqlerrd[2] != 1)
1681     return MR_NO_QUOTA;
1682
1683   entity = cl->entity;
1684   who = cl->client_id;
1685
1686   uid = atoi(argv[0]);
1687   login = argv[1];
1688   potype = argv[2];
1689
1690   /* find user */
1691   EXEC SQL SELECT users_id, status INTO :users_id, :ostatus
1692     FROM users
1693     WHERE unix_uid = :uid AND
1694     (status = 0 OR status = 5 OR status = 6 OR status = 9);
1695
1696   if (sqlca.sqlerrd[2] == 0)
1697     return MR_NO_MATCH;
1698   if (sqlca.sqlerrd[2] > 1)
1699     return MR_NOT_UNIQUE;
1700
1701   /* check new login name */
1702   EXEC SQL SELECT COUNT(login) INTO :rowcount FROM users
1703     WHERE login = :login AND users_id != :users_id;
1704   if (dbms_errno)
1705     return mr_errcode;
1706   if (rowcount > 0)
1707     return MR_IN_USE;
1708
1709   /* Remove this check when we're allowing username reuse again. */
1710   EXEC SQL SELECT COUNT(login) INTO :rowcount FROM userhistory
1711     WHERE login = :login;
1712   if (dbms_errno)
1713     return mr_errcode;
1714   if (rowcount > 0)
1715     return MR_IN_USE;
1716
1717   EXEC SQL SELECT COUNT(name) INTO :rowcount FROM list
1718     WHERE LOWER(name) = :login;
1719   if (dbms_errno)
1720     return mr_errcode;
1721   if (rowcount > 0)
1722     return MR_IN_USE;
1723   EXEC SQL SELECT COUNT(label) INTO :rowcount FROM filesys
1724     WHERE label = :login;
1725   if (dbms_errno)
1726     return mr_errcode;
1727   if (rowcount > 0)
1728     return MR_IN_USE;
1729   EXEC SQL SELECT COUNT(label) INTO :rowcount
1730     FROM filesys WHERE label = :login || '.po';
1731   if (dbms_errno)
1732     return mr_errcode;
1733   if (rowcount > 0)
1734     {
1735       EXEC SQL SELECT owner INTO :tmp FROM filesys
1736         WHERE label = :login || '.po';
1737       if (dbms_errno)
1738         return mr_errcode;
1739       if ((ostatus == 0 || ostatus == 9) || (tmp != users_id))
1740         return MR_IN_USE;
1741       else
1742         po_exists = 1;
1743     }
1744   EXEC SQL SELECT COUNT(name) INTO :rowcount FROM alias
1745     WHERE ( name = :login OR name = :login || '.po' )
1746     AND type = 'FILESYS';
1747   if (dbms_errno)
1748     return mr_errcode;
1749   if (rowcount > 0)
1750     return MR_IN_USE;
1751   com_err(whoami, 0, "login name OK");
1752
1753   EXEC SQL SELECT COUNT(potype) INTO :rowcount FROM users WHERE
1754     login = :login AND potype = 'POP';
1755   if (dbms_errno)
1756     return mr_errcode;
1757   if (rowcount > 0)
1758     po_exists = 1;
1759
1760   /* choose type and location for pobox */
1761   if (!po_exists)
1762     {
1763       if (!strcmp(potype, "POP"))
1764         {
1765
1766           EXEC SQL DECLARE csr130 CURSOR FOR
1767             SELECT sh.mach_id, m.name FROM serverhosts sh, machine m
1768             WHERE sh.service = 'POP' AND sh.mach_id = m.mach_id
1769             AND sh.value2 - sh.value1 =
1770             (SELECT MAX(value2 - value1) FROM serverhosts WHERE service = 'POP');
1771           if (dbms_errno)
1772             return mr_errcode;
1773           EXEC SQL OPEN csr130;
1774           if (dbms_errno)
1775             return mr_errcode;
1776           EXEC SQL FETCH csr130 INTO :popid, :machname;
1777           if (sqlca.sqlerrd[2] == 0)
1778             {
1779               EXEC SQL CLOSE csr130;
1780               if (dbms_errno)
1781                 return mr_errcode;
1782               return MR_NO_POBOX;
1783             }
1784           else
1785             {
1786               EXEC SQL CLOSE csr130;
1787               if (dbms_errno)
1788                 return mr_errcode;
1789             }
1790
1791           EXEC SQL UPDATE users SET potype = 'POP', pop_id = :popid
1792             WHERE users_id = :users_id;
1793           com_err(whoami, 0, "pobox set to POP:%s", strtrim(machname));
1794         }
1795       else if (!strcmp(potype, "EXCHANGE"))
1796         {
1797           EXEC SQL UPDATE users SET potype = 'EXCHANGE',
1798             exchange_id = :exchange_id
1799             WHERE users_id = :users_id;
1800           com_err(whoami, 0, "pobox set to EXCHANGE:EXCHANGE.MIT.EDU");
1801         }
1802       else
1803         {
1804       /* Select all IMAP nfsphys entries in order of increasing
1805        * (allocated - partsize).  The partitions will almost always be
1806        * overallocated, but we choose the one that is the least
1807        * overallocated.
1808        */
1809           potype = "IMAP";
1810
1811           EXEC SQL DECLARE csr_rusr_imap CURSOR FOR
1812             SELECT np.allocated - np.partsize, np.nfsphys_id, np.mach_id,
1813             np.dir, m.name FROM serverhosts sh, nfsphys np, machine m
1814             WHERE sh.service = 'POSTOFFICE' AND sh.mach_id = np.mach_id
1815             AND m.mach_id = np.mach_id
1816             ORDER BY 1;
1817           if (dbms_errno)
1818             return mr_errcode;
1819           EXEC SQL OPEN csr_rusr_imap;
1820           if (dbms_errno)
1821             return mr_errcode;
1822           EXEC SQL FETCH csr_rusr_imap INTO :tmp, :npid, :mid, :dir, :machname;
1823           if (sqlca.sqlerrd[2] == 0)
1824             {
1825               EXEC SQL CLOSE csr_rusr_imap;
1826               if (dbms_errno)
1827                 return mr_errcode;
1828               return MR_NO_POBOX;
1829             }
1830           else
1831             {
1832               EXEC SQL CLOSE csr_rusr_imap;
1833               if (dbms_errno)
1834                 return mr_errcode;
1835             }
1836
1837           /* create filesystem */
1838           if (set_next_object_id("filsys_id", FILESYS_TABLE, 0))
1839             return MR_NO_ID;
1840           incremental_clear_before();
1841
1842           EXEC SQL SELECT value INTO :popid FROM numvalues
1843             WHERE numvalues.name = 'filsys_id';
1844           EXEC SQL INSERT INTO filesys
1845             (filsys_id, phys_id, label, type, mach_id, name,
1846              mount, rwaccess, comments, owner, owners, createflg,
1847              lockertype, modtime, modby, modwith)
1848             VALUES
1849             (:popid, :npid, :login || '.po', 'IMAP', :mid, :dir,
1850              CHR(0), 'w', 'IMAP box', :users_id, :list_id, 1,
1851              'USER', SYSDATE, :who, :entity);
1852
1853           if (dbms_errno)
1854             return mr_errcode;
1855           if (sqlca.sqlerrd[2] != 1)
1856             return MR_INTERNAL;
1857           sprintf(buffer, "fs.filsys_id = %d", popid);
1858           incremental_after(FILESYS_TABLE, buffer, 0);
1859
1860           /* set quota */
1861           incremental_clear_before();
1862           EXEC SQL INSERT INTO quota
1863             (entity_id, filsys_id, type, quota, phys_id, modtime, modby, modwith)
1864             VALUES (:users_id, :popid, 'USER', :def_imap_quota, :npid,
1865                     SYSDATE, :who, :entity);
1866           if (dbms_errno)
1867             return mr_errcode;
1868           if (sqlca.sqlerrd[2] != 1)
1869             return MR_INTERNAL;
1870           aargv[0] = login;
1871           aargv[1] = "USER";
1872           aargv[2] = login;
1873           sprintf(buffer, "q.entity_id = %d and q.filsys_id = %d and "
1874                   "q.type = 'USER'", users_id, popid);
1875           incremental_after(QUOTA_TABLE, buffer, aargv);
1876           if (dbms_errno)
1877             return mr_errcode;
1878
1879           EXEC SQL UPDATE nfsphys SET allocated = allocated + :def_imap_quota
1880             WHERE nfsphys_id = :npid;
1881
1882           EXEC SQL UPDATE users SET potype = 'IMAP', imap_id = :popid
1883             WHERE users_id = :users_id;
1884           com_err(whoami, 0, "pobox set to IMAP:%s:%s", strtrim(machname),
1885                   strtrim(dir));
1886         }
1887     }
1888
1889   /* change login name, set pobox */
1890   sprintf(buffer, "u.users_id = %d", users_id);
1891   incremental_before(USERS_TABLE, buffer, 0);
1892   nstatus = 2;
1893   if (ostatus == 5 || ostatus == 6 || ostatus == 9)
1894     nstatus = 1;
1895   EXEC SQL UPDATE users SET login = :login, status = :nstatus,
1896     modtime = SYSDATE, modby = :who, modwith = :entity,
1897     pmodtime = SYSDATE, pmodby = :who, pmodwith = :entity,
1898     created = SYSDATE, creator = :who
1899     WHERE users_id = :users_id;
1900
1901   if (dbms_errno)
1902     return mr_errcode;
1903   if (sqlca.sqlerrd[2] != 1)
1904     return MR_INTERNAL;
1905
1906   /* Only update usage count if we created a POP pobox. */
1907   if (!strcmp(potype, "POP") && !po_exists)
1908     set_pop_usage(mid, 1);
1909
1910   com_err(whoami, 0, "set login name to %s", login);
1911   incremental_after(USERS_TABLE, buffer, 0);
1912
1913   /* create filesystem */
1914   if (set_next_object_id("filsys_id", FILESYS_TABLE, 0))
1915     return MR_NO_ID;
1916   incremental_clear_before();
1917   if (islower(login[0]) && islower(login[1]))
1918     {
1919       sprintf(directory, "/afs/athena.mit.edu/user/%c/%c/%s",
1920               login[0], login[1], login);
1921     }
1922   else
1923     sprintf(directory, "/afs/athena.mit.edu/user/other/%s", login);
1924
1925   EXEC SQL SELECT value INTO :fsidval FROM numvalues
1926     WHERE numvalues.name = 'filsys_id';
1927   EXEC SQL INSERT INTO filesys
1928     (filsys_id, phys_id, label, type, mach_id, name,
1929      mount, rwaccess, comments, owner, owners, createflg,
1930      lockertype, modtime, modby, modwith)
1931     VALUES
1932     (:fsidval, 0, :login, 'AFS', :m_id, :directory,
1933      '/mit/' || :login, 'w', 'User Locker', :users_id, :list_id, 1,
1934      'HOMEDIR', SYSDATE, :who, :entity);
1935
1936   if (dbms_errno)
1937     return mr_errcode;
1938   if (sqlca.sqlerrd[2] != 1)
1939     return MR_INTERNAL;
1940   sprintf(buffer, "fs.filsys_id = %d", fsidval);
1941   incremental_after(FILESYS_TABLE, buffer, 0);
1942
1943   /* set quota */
1944   incremental_clear_before();
1945   EXEC SQL INSERT INTO quota
1946     (entity_id, filsys_id, type, quota, phys_id, modtime, modby, modwith)
1947     VALUES (0, :fsidval, 'ANY', :def_quota, 0, SYSDATE, :who, :entity);
1948   if (dbms_errno)
1949     return mr_errcode;
1950   if (sqlca.sqlerrd[2] != 1)
1951     return MR_INTERNAL;
1952   aargv[0] = login;
1953   aargv[1] = "ANY";
1954   aargv[2] = login;
1955   sprintf(buffer, "q.entity_id = 0 and q.filsys_id = %d and q.type = 'ANY'",
1956           fsidval);
1957   incremental_after(QUOTA_TABLE, buffer, aargv);
1958   com_err(whoami, 0, "quota of %d assigned", def_quota);
1959   if (dbms_errno)
1960     return mr_errcode;
1961
1962   EXEC SQL UPDATE tblstats SET updates = updates + 1, modtime = SYSDATE
1963     WHERE table_name = 'users';
1964   EXEC SQL UPDATE tblstats SET appends = appends + 1, modtime = SYSDATE
1965     WHERE table_name = 'filesys' OR table_name = 'quota';
1966   if (dbms_errno)
1967     return mr_errcode;
1968   return MR_SUCCESS;
1969 }
1970
1971 /** set_pop_usage - incr/decr usage count for pop server in serverhosts talbe
1972  **
1973  ** Inputs:
1974  **   id of machine
1975  **   delta (will be +/- 1)
1976  **
1977  ** Description:
1978  **   - incr/decr value field in serverhosts table for pop/mach_id
1979  **
1980  **/
1981
1982 int set_pop_usage(id, cnt)
1983     int id, cnt;
1984 {
1985   EXEC SQL BEGIN DECLARE SECTION;
1986   int iid = id, icnt = cnt;
1987   EXEC SQL END DECLARE SECTION;
1988
1989   EXEC SQL UPDATE serverhosts SET value1 = value1 + :icnt
1990     WHERE serverhosts.service = 'POP' AND serverhosts.mach_id = :iid;
1991
1992   if (dbms_errno)
1993     return mr_errcode;
1994   return MR_SUCCESS;
1995 }
1996
1997
1998 int do_user_reservation(struct query *q, char *argv[], client *cl)
1999 {
2000   EXEC SQL BEGIN DECLARE SECTION;
2001   char resv[USERS_RESERVATIONS_SIZE];
2002   char *trans, name[ALIAS_NAME_SIZE];
2003   int uid;
2004   EXEC SQL END DECLARE SECTION;
2005
2006   uid = *(int *)argv[0];
2007   trans = argv[1];
2008
2009   EXEC SQL SELECT UPPER(name) INTO :name FROM alias
2010     WHERE type = 'RESERVE' AND LOWER(trans) = LOWER(:trans);
2011   if (dbms_errno)
2012     return mr_errcode;
2013   if (sqlca.sqlerrd[2] != 1)
2014     return MR_STRING;
2015   name[1] = '\0';
2016
2017   EXEC SQL SELECT reservations INTO :resv FROM users
2018     WHERE users_id = :uid;
2019   if (dbms_errno)
2020     return mr_errcode;
2021   strtrim(resv);
2022
2023   if (!strcmp(q->shortname, "aurv"))
2024     {
2025       if (strchr(resv, *name))
2026         return MR_EXISTS;
2027       if (strlen(resv) == USERS_RESERVATIONS_SIZE - 1)
2028         return MR_ARG_TOO_LONG;
2029
2030       strcat(resv, name);
2031     }
2032   else
2033     {
2034       char *p = strchr(resv, *name);
2035       if (!p)
2036         return MR_NO_MATCH;
2037       memmove(p, p + 1, strlen(p));
2038     }
2039
2040   EXEC SQL UPDATE users SET reservations = NVL(:resv, CHR(0))
2041     WHERE users_id = :uid;
2042   if (dbms_errno)
2043     return mr_errcode;
2044
2045   EXEC SQL UPDATE tblstats SET updates = updates + 1, modtime = SYSDATE
2046     WHERE table_name = 'users';
2047   return set_modtime_by_id(q, argv, cl);
2048 }
2049
2050 int get_user_reservations(struct query *q, char **argv, client *cl,
2051                           int (*action)(int, char *[], void *), void *actarg)
2052 {
2053   EXEC SQL BEGIN DECLARE SECTION;
2054   char resv[USERS_RESERVATIONS_SIZE], *p;
2055   char trans[ALIAS_TRANS_SIZE], name[2] = { 0, 0 };
2056   int uid;
2057   EXEC SQL END DECLARE SECTION;
2058   char *targv[1];
2059
2060   uid = *(int *)argv[0];
2061
2062   EXEC SQL SELECT reservations INTO :resv FROM users
2063     WHERE users_id = :uid;
2064   if (dbms_errno)
2065     return mr_errcode;
2066
2067   targv[0] = trans;
2068   p = resv;
2069   while (*p && !isspace(*p))
2070     {
2071       name[0] = toupper(*p);
2072       EXEC SQL SELECT trans INTO :trans FROM alias
2073         WHERE type = 'RESERVE' AND UPPER(name) = :name;
2074       if (dbms_errno)
2075         return mr_errcode;
2076       if (sqlca.sqlerrd[2] != 1)
2077         sprintf(trans, "Unknown (%s)", name);
2078       (*action)(1, targv, actarg);
2079       p++;
2080     }
2081   return MR_SUCCESS;
2082 }
2083
2084 int get_user_by_reservation(struct query *q, char **argv, client *cl,
2085                             int (*action)(int, char *[], void *), void *actarg)
2086 {
2087   EXEC SQL BEGIN DECLARE SECTION;
2088   char resv[USERS_RESERVATIONS_SIZE], login[USERS_LOGIN_SIZE];
2089   char *trans, name[ALIAS_NAME_SIZE];
2090   int uid;
2091   EXEC SQL END DECLARE SECTION;
2092   char *targv[1];
2093
2094   trans = argv[0];
2095
2096   EXEC SQL SELECT UPPER(name) INTO :name FROM alias
2097     WHERE type = 'RESERVE' AND LOWER(trans) = LOWER(:trans);
2098   if (dbms_errno)
2099     return mr_errcode;
2100   if (sqlca.sqlerrd[2] != 1)
2101     return MR_STRING;
2102   name[1] = '\0';
2103
2104   EXEC SQL DECLARE csr_gubr CURSOR FOR
2105     SELECT login FROM users WHERE reservations LIKE '%' || :name || '%';
2106   EXEC SQL OPEN csr_gubr;
2107   if (dbms_errno)
2108     return mr_errcode;
2109
2110   targv[0] = login;
2111   while (1)
2112     {
2113       EXEC SQL FETCH csr_gubr INTO :login;
2114       if (sqlca.sqlcode)
2115         break;
2116       (*action)(1, targv, actarg);
2117     }
2118   EXEC SQL CLOSE csr_gubr;
2119
2120   return MR_SUCCESS;
2121 }
2122
2123 int update_container(struct query *q, char *argv[], client *cl)
2124 {
2125   EXEC SQL BEGIN DECLARE SECTION;
2126   int cnt_id, acl_id, memacl_id, who, flag;
2127   char name[CONTAINERS_NAME_SIZE], newchildname[CONTAINERS_NAME_SIZE];
2128   char* newname, *entity, *description, *location, *contact, *acl_type, *memacl_type;
2129   EXEC SQL END DECLARE SECTION;
2130   char* tmpchar;
2131   int cnt, childid;
2132   char childname[CONTAINERS_NAME_SIZE];
2133   char *qual;
2134   int index = 0;
2135
2136   cnt_id = *(int *)argv[index++];
2137   newname = argv[index++];
2138
2139   if (q->version >= 9)
2140     flag = atoi(argv[index++]);
2141
2142   description = argv[index++];
2143   location = argv[index++];
2144   contact = argv[index++];
2145   acl_type = argv[index++];
2146   acl_id = *(int *)argv[index++];
2147   memacl_type = argv[index++];
2148   memacl_id = *(int *)argv[index++];
2149   entity = cl->entity;
2150   who = cl->client_id;
2151
2152   EXEC SQL SELECT name INTO :name
2153     FROM containers
2154     WHERE cnt_id = :cnt_id;
2155
2156   /* trim off the trailing spaces */
2157    strcpy(name, strtrim(name));
2158
2159    qual = xmalloc(MAX_FIELD_WIDTH);
2160    sprintf(qual, "name = '%s'", name);
2161    incremental_before(CONTAINERS_TABLE, qual, argv);
2162
2163   /* if we are renaming the container */
2164   if (strcmp(name, newname))
2165   {
2166     /* make sure that only the name part of the name has been changed */
2167     tmpchar = strrchr(name, '/');
2168     /* not a top-level name */
2169     if (tmpchar)
2170     {
2171       cnt = tmpchar - name + 1;
2172       /* the parent part of the old and new name should be identical */
2173       if (strncmp(name, newname, cnt))
2174         return MR_NEW_CONTAINER_NAME;
2175     }
2176     /* top level name, new name should be a top level name too */
2177     else
2178     {
2179       if (strrchr(newname, '/'))
2180         return MR_NEW_CONTAINER_NAME;
2181     }
2182
2183     /* update the name for this container */
2184     EXEC SQL UPDATE containers
2185       SET name = :newname
2186     WHERE cnt_id = :cnt_id;
2187
2188     if (dbms_errno)
2189       return mr_errcode;
2190
2191     /* get names for its child containers */
2192     EXEC SQL DECLARE csr_ucon CURSOR FOR
2193       SELECT name, cnt_id FROM containers WHERE name LIKE :name || '/' || '%';
2194
2195     EXEC SQL OPEN csr_ucon;
2196     if (dbms_errno)
2197       return mr_errcode;
2198
2199     while (1)
2200     {
2201       EXEC SQL FETCH csr_ucon INTO :childname, :childid;
2202       if (sqlca.sqlcode)
2203               break;
2204
2205       strcpy(childname, strtrim(childname));
2206       /* concatenate the new parent name with the existing sub-container name
2207        * we get the sub-containers new name */
2208       tmpchar = childname + strlen(name);
2209       strcpy(newchildname, newname);
2210       strcat(newchildname, tmpchar);
2211
2212       /* update the name */
2213       EXEC SQL UPDATE containers
2214         SET name = :newchildname, modtime = SYSDATE, modby = :who, modwith = :entity
2215       WHERE cnt_id = :childid;
2216
2217       if (sqlca.sqlcode)
2218         break;
2219     }
2220
2221     EXEC SQL CLOSE csr_ucon;
2222     if (dbms_errno)
2223       return mr_errcode;
2224   }
2225
2226   /* update the remaining fields */
2227   if (q->version >= 9)
2228   {
2229         EXEC SQL UPDATE containers
2230                 SET publicflg= :flag, description = NVL(:description, CHR(0)), location = NVL(:location, CHR(0)),
2231                         contact = NVL(:contact, CHR(0)), acl_type = :acl_type, acl_id = :acl_id,
2232                         memacl_type = :memacl_type, memacl_id = :memacl_id,
2233                         modtime = SYSDATE, modby = :who, modwith = :entity
2234                 WHERE cnt_id = :cnt_id;
2235   }
2236   else
2237   {
2238     EXEC SQL UPDATE containers
2239                 SET publicflg= :flag, description = NVL(:description, CHR(0)), location = NVL(:location, CHR(0)),
2240                         contact = NVL(:contact, CHR(0)), acl_type = :acl_type, acl_id = :acl_id,
2241                         memacl_type = :memacl_type, memacl_id = :memacl_id,
2242                         modtime = SYSDATE, modby = :who, modwith = :entity
2243                 WHERE cnt_id = :cnt_id;
2244   }
2245
2246   if (dbms_errno)
2247     return mr_errcode;
2248
2249   sprintf(qual, "name = '%s'", newname);
2250   incremental_after(CONTAINERS_TABLE, qual, argv);
2251
2252   return MR_SUCCESS;
2253 }
2254
2255 int get_machines_of_container(struct query *q, char *argv[], client *cl,
2256                         int (*action)(int, char *[], void *), void *actarg)
2257 {
2258   EXEC SQL BEGIN DECLARE SECTION;
2259   int cnt_id, isrecursive;
2260   char machinename[MACHINE_NAME_SIZE], containername[CONTAINERS_NAME_SIZE];
2261   char *qs;
2262   EXEC SQL END DECLARE SECTION;
2263
2264   char querystring[512], tmp [256];
2265   char *rargv[2];
2266   int found = 0;
2267
2268   rargv[0] = machinename;
2269   rargv[1] = containername;
2270
2271   cnt_id = *(int *)argv[0];
2272   isrecursive = atoi(argv[1]);
2273
2274   /* get the container name */
2275
2276   EXEC SQL SELECT name INTO :containername
2277     FROM containers
2278     WHERE cnt_id = :cnt_id;
2279
2280   /* trim off the trailing spaces */
2281   strcpy(containername, strtrim(containername));
2282
2283   strcpy(querystring, "SELECT a.name, b.name FROM machine a, containers b, mcntmap c ");
2284   strcat(querystring, "WHERE a.mach_id = c.mach_id AND b.cnt_id = c.cnt_id ");
2285
2286   if (!isrecursive)
2287     sprintf(tmp, "AND b.cnt_id = %d ", cnt_id);
2288   else
2289     sprintf(tmp, "AND (b.cnt_id = %d OR LOWER(b.name) LIKE LOWER('%s/%%')) ",
2290             cnt_id, containername);
2291
2292   strcat(querystring, tmp);
2293   strcat(querystring, "ORDER BY b.name, a.name");
2294
2295   qs = querystring;
2296
2297   EXEC SQL PREPARE stmt FROM :qs;
2298   if (sqlca.sqlcode)
2299     return MR_INTERNAL;
2300   EXEC SQL DECLARE curs_gmnm CURSOR FOR stmt;
2301   EXEC SQL OPEN curs_gmnm;
2302
2303    while (1)
2304         {
2305           EXEC SQL FETCH curs_gmnm INTO :machinename, :containername;
2306           if (sqlca.sqlcode)
2307             break;
2308           (*action)(2, rargv, actarg);
2309           found++;
2310         }
2311
2312   EXEC SQL CLOSE curs_gmnm;
2313   if (!found)
2314     return MR_NO_MATCH;
2315   return MR_SUCCESS;
2316 }
2317
2318 int get_subcontainers_of_container(struct query *q, char *argv[], client *cl,
2319                         int (*action)(int, char *[], void *), void *actarg)
2320 {
2321   EXEC SQL BEGIN DECLARE SECTION;
2322   int cnt_id, isrecursive;
2323   char containername[CONTAINERS_NAME_SIZE], subcontainername[CONTAINERS_NAME_SIZE];
2324   char *qs;
2325   EXEC SQL END DECLARE SECTION;
2326
2327   char querystring[2048], tmp [1024];
2328   char *rargv[1];
2329   int found = 0;
2330
2331   rargv[0] = subcontainername;
2332
2333   cnt_id = *(int *)argv[0];
2334   isrecursive = atoi(argv[1]);
2335
2336   /* get the container name */
2337
2338   EXEC SQL SELECT name INTO :containername
2339     FROM containers
2340     WHERE cnt_id = :cnt_id;
2341
2342   /* trim off the trailing spaces */
2343   strcpy(containername, strtrim(containername));
2344
2345   strcpy(querystring, "SELECT name FROM containers ");
2346
2347   if (!isrecursive)
2348     sprintf(tmp, "WHERE LOWER(name) LIKE LOWER('%s/%%') and LOWER(name) NOT LIKE LOWER('%s/%%/%%') ",
2349             containername, containername);
2350   else
2351     sprintf(tmp, "WHERE LOWER(name) LIKE LOWER('%s/%%') ", containername);
2352
2353   strcat(querystring, tmp);
2354   strcat(querystring, "ORDER BY name");
2355
2356   qs = querystring;
2357
2358   EXEC SQL PREPARE stmt FROM :qs;
2359   if (sqlca.sqlcode)
2360     return MR_INTERNAL;
2361   EXEC SQL DECLARE curs_gsoc CURSOR FOR stmt;
2362   EXEC SQL OPEN curs_gsoc;
2363
2364    while (1)
2365         {
2366           EXEC SQL FETCH curs_gsoc INTO :subcontainername;
2367           if (sqlca.sqlcode)
2368             break;
2369           (*action)(1, rargv, actarg);
2370           found++;
2371         }
2372
2373   EXEC SQL CLOSE curs_gsoc;
2374   if (!found)
2375     return MR_NO_MATCH;
2376   return MR_SUCCESS;
2377 }
2378
2379 int set_container_list(struct query *q, char *argv[], client *cl)
2380 {
2381   EXEC SQL BEGIN DECLARE SECTION;
2382   int cnt_id, list_id;
2383   EXEC SQL END DECLARE SECTION;
2384
2385   cnt_id = *(int *)argv[0];
2386   list_id = *(int *)argv[1];
2387
2388   EXEC SQL UPDATE containers SET list_id = :list_id WHERE cnt_id = :cnt_id;
2389   if (dbms_errno)
2390     return mr_errcode;
2391
2392   return MR_SUCCESS;
2393 }