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