]> andersk Git - moira.git/blame - server/qsupport.pc
andersk / moira.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Major update to container related code.
[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;
206 if (strchr(buf, '/') || strchr(buf, '|'))
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;
891
892 if (!found)
893 return MR_NO_MATCH;
894 return MR_SUCCESS;
895}
896
897/* ghbo_internal */
898int ghbo_internal(char *atype, int aid,
899 int (*action)(int, char *[], void *), void *actarg)
900{
901 char *rargv[1];
902 int found = 0;
903 EXEC SQL BEGIN DECLARE SECTION;
904 char name[MACHINE_NAME_SIZE], *type = atype;
905 int id = aid;
906 EXEC SQL END DECLARE SECTION;
907
908 rargv[0] = name;
909 EXEC SQL DECLARE csr115b CURSOR FOR
910 SELECT name FROM machine m
911 WHERE m.owner_type = :type
912 AND m.owner_id = :id;
913 if (dbms_errno)
914 return mr_errcode;
915 EXEC SQL OPEN csr115b;
916 if (dbms_errno)
917 return mr_errcode;
918 while (1)
919 {
920 EXEC SQL FETCH csr115b INTO :name;
921 if (sqlca.sqlcode)
922 break;
923 (*action)(1, rargv, actarg);
924 found++;
925 }
926 EXEC SQL CLOSE csr115b;
927
928 if (!found)
929 return MR_NO_MATCH;
930 return MR_SUCCESS;
931}
932
933/* get_host_by_owner - like gaus but limited to hosts */
934int get_host_by_owner(struct query *q, char *argv[], client *cl,
935 int (*action)(int, char *[], void *), void *actarg)
936{
937 int found = 0;
938 EXEC SQL BEGIN DECLARE SECTION;
939 char *atype;
940 int aid, listid, id;
941 EXEC SQL END DECLARE SECTION;
942 struct save_queue *sq;
943
944 atype = argv[0];
945 aid = *(int *)argv[1];
946 if (!strcmp(atype, "LIST") || !strcmp(atype, "USER") ||
947 !strcmp(atype, "KERBEROS"))
948 return ghbo_internal(atype, aid, action, actarg);
949
950 sq = sq_create();
951 if (!strcmp(atype, "RLIST"))
952 {
953 sq_save_data(sq, (void *)aid);
954 /* get all the list_id's of containing lists */
955 EXEC SQL DECLARE csr107q CURSOR FOR
956 SELECT list_id FROM imembers
957 WHERE member_type = 'LIST' AND member_id = :aid;
958 if (dbms_errno)
959 return mr_errcode;
960 EXEC SQL OPEN csr107q;
961 if (dbms_errno)
962 return mr_errcode;
963 while (1)
964 {
965 EXEC SQL FETCH csr107q INTO :listid;
966 if (sqlca.sqlcode)
967 break;
968 sq_save_unique_data(sq, (void *)listid);
969 }
970 EXEC SQL CLOSE csr107q;
971 /* now process each one */
972 while (sq_get_data(sq, &id))
973 {
974 if (ghbo_internal("LIST", id, action, actarg) == MR_SUCCESS)
975 found++;
976 }
977 }
978
979 if (!strcmp(atype, "RUSER"))
980 {
981 EXEC SQL DECLARE csr108q CURSOR FOR
982 SELECT list_id FROM imembers
983 WHERE member_type = 'USER' AND member_id = :aid;
984 if (dbms_errno)
5eaef520 985 return mr_errcode;
d3051625 986 EXEC SQL OPEN csr108q;
987 if (dbms_errno)
5eaef520 988 return mr_errcode;
d3051625 989 while (1)
990 {
991 EXEC SQL FETCH csr108q INTO :listid;
992 if (sqlca.sqlcode)
993 break;
994 sq_save_data(sq, (void *)listid);
995 }
996 EXEC SQL CLOSE csr108q;
997 /* now process each one */
998 while (sq_get_data(sq, &id))
999 {
1000 if (ghbo_internal("LIST", id, action, actarg) == MR_SUCCESS)
1001 found++;
1002 }
1003 if (ghbo_internal("USER", aid, action, actarg) == MR_SUCCESS)
0659551f 1004 found++;
d3051625 1005 }
1006
1007 if (!strcmp(atype, "RKERBEROS"))
1008 {
1009 EXEC SQL DECLARE csr109q CURSOR FOR
1010 SELECT list_id FROM imembers
1011 WHERE member_type = 'KERBEROS' AND member_id = :aid;
1012 if (dbms_errno)
1013 return mr_errcode;
1014 EXEC SQL OPEN csr109q;
1015 if (dbms_errno)
1016 return mr_errcode;
1017 while (1)
1018 {
1019 EXEC SQL FETCH csr109q INTO :listid;
1020 if (sqlca.sqlcode)
1021 break;
1022 sq_save_data(sq, (void *)listid);
1023 }
1024 EXEC SQL CLOSE csr109q;
1025 /* now process each one */
1026 while (sq_get_data(sq, &id))
1027 {
1028 if (ghbo_internal("LIST", id, action, actarg) == MR_SUCCESS)
1029 found++;
1030 }
1031 if (ghbo_internal("KERBEROS", aid, action, actarg) == MR_SUCCESS)
0659551f 1032 found++;
d3051625 1033 }
b070f8a1 1034
d3051625 1035 sq_destroy(sq);
1036 if (dbms_errno)
1037 return mr_errcode;
1038 if (!found)
1039 return MR_NO_MATCH;
1040 return MR_SUCCESS;
5d677c81 1041}
b070f8a1 1042
0659551f 1043/* get_lists_of_member - given a type and a name, return the name and flags
1044 * of all of the lists of the given member. The member_type is one of
5f7b0741 1045 * "LIST", "USER", "STRING", "KERBEROS", "MACHINE", "RLIST", "RUSER",
1046 * "RSTRING", "RKERBEROS", or "RMACHINE" in argv[0], and argv[1] will contain
1047 * the ID of the entity in question. The R* types mean to recursively look
1048 * at every containing list, not just when the object in question is a direct
1049 * member.
0659551f 1050 */
b070f8a1 1051
5eaef520 1052int get_lists_of_member(struct query *q, char *argv[], client *cl,
7ac48069 1053 int (*action)(int, char *[], void *), void *actarg)
0659551f 1054{
5eaef520 1055 int found = 0, direct = 1;
1056 char *rargv[6];
1057 EXEC SQL BEGIN DECLARE SECTION;
1058 char *atype;
1059 int aid;
e688520a 1060 char name[LIST_NAME_SIZE];
1061 char active[5], public[5], hidden[5], maillist[5], grouplist[5];
5eaef520 1062 EXEC SQL END DECLARE SECTION;
1063
1064 atype = argv[0];
1065 aid = *(int *)argv[1];
1066 if (!strcmp(atype, "RLIST"))
1067 {
1068 atype = "LIST";
1069 direct = 0;
0659551f 1070 }
5eaef520 1071 if (!strcmp(atype, "RUSER"))
1072 {
1073 atype = "USER";
1074 direct = 0;
0659551f 1075 }
5eaef520 1076 if (!strcmp(atype, "RSTRING"))
1077 {
1078 atype = "STRING";
1079 direct = 0;
0659551f 1080 }
5eaef520 1081 if (!strcmp(atype, "RKERBEROS"))
1082 {
1083 atype = "KERBEROS";
1084 direct = 0;
0659551f 1085 }
5f7b0741 1086 if (!strcmp(atype, "RMACHINE"))
1087 {
1088 atype = "MACHINE";
1089 direct = 0;
1090 }
b070f8a1 1091
5eaef520 1092 rargv[0] = name;
1093 rargv[1] = active;
1094 rargv[2] = public;
1095 rargv[3] = hidden;
1096 rargv[4] = maillist;
1097 rargv[5] = grouplist;
1098 if (direct)
1099 {
1100 EXEC SQL DECLARE csr117a CURSOR FOR
1101 SELECT l.name, l.active, l.publicflg, l.hidden, l.maillist, l.grouplist
1102 FROM list l, imembers im
1103 WHERE l.list_id = im.list_id AND im.direct = 1
1104 AND im.member_type = :atype AND im.member_id = :aid;
1105 if (dbms_errno)
1106 return mr_errcode;
1107 EXEC SQL OPEN csr117a;
1108 if (dbms_errno)
1109 return mr_errcode;
1110 while (1)
1111 {
1112 EXEC SQL FETCH csr117a
1113 INTO :name, :active, :public, :hidden, :maillist, :grouplist;
1114 if (sqlca.sqlcode)
1115 break;
1116 (*action)(6, rargv, actarg);
1117 found++;
0659551f 1118 }
5eaef520 1119 EXEC SQL CLOSE csr117a;
1120 }
1121 else
1122 {
1123 EXEC SQL DECLARE csr117b CURSOR FOR
1124 SELECT l.name, l.active, l.publicflg, l.hidden, l.maillist, l.grouplist
1125 FROM list l, imembers im
1126 WHERE l.list_id = im.list_id
1127 AND im.member_type = :atype AND im.member_id = :aid;
1128 if (dbms_errno)
1129 return mr_errcode;
1130 EXEC SQL OPEN csr117b;
1131 if (dbms_errno)
1132 return mr_errcode;
1133 while (1)
1134 {
1135 EXEC SQL FETCH csr117b
1136 INTO :name, :active, :public, :hidden, :maillist, :grouplist;
1137 if (sqlca.sqlcode)
1138 break;
1139 (*action)(6, rargv, actarg);
1140 found++;
0659551f 1141 }
5eaef520 1142 EXEC SQL CLOSE csr117b;
038fd8a4 1143 }
0659551f 1144
5eaef520 1145 if (dbms_errno)
1146 return mr_errcode;
1147 if (!found)
1148 return MR_NO_MATCH;
1149 return MR_SUCCESS;
038fd8a4 1150}
1151
b070f8a1 1152
0659551f 1153/* qualified_get_lists: passed "TRUE", "FALSE", or "DONTCARE" for each of
1154 * the five flags associated with each list. It will return the name of
1155 * each list that meets the quailifications. It does this by building a
1156 * where clause based on the arguments, then doing a retrieve.
1157 */
1158
1159static char *lflags[5] = { "active", "publicflg", "hidden", "maillist", "grouplist" };
b070f8a1 1160
5eaef520 1161int qualified_get_lists(struct query *q, char *argv[], client *cl,
7ac48069 1162 int (*action)(int, char *[], void *), void *actarg)
5d677c81 1163{
5eaef520 1164 return qualified_get(q, argv, action, actarg, "l.list_id != 0",
1165 "l", "name", lflags);
0659551f 1166}
0fc7ab46 1167
5d677c81 1168
5eaef520 1169int get_members_of_list(struct query *q, char *argv[], client *cl,
7ac48069 1170 int (*action)(int, char *[], void *), void *actarg)
0659551f 1171{
5eaef520 1172 EXEC SQL BEGIN DECLARE SECTION;
7ac48069 1173 int list_id, direct;
46b6f1f6 1174 char member_name[MAX_FIELD_WIDTH], tag[STRINGS_STRING_SIZE];
5eaef520 1175 EXEC SQL END DECLARE SECTION;
46b6f1f6 1176 char *targv[3];
1177 int targc;
5eaef520 1178
46b6f1f6 1179 /* For gmol or gtml, only get direct members. For geml, get all. */
1180 if (!strcmp(q->shortname, "geml"))
1181 direct = -1;
1182 else
5eaef520 1183 direct = 0;
46b6f1f6 1184
1185 /* For gmol or geml, only return type and name. For gtml, return tag too. */
1186 if (!strcmp(q->shortname, "gtml"))
1187 targc = 3;
5eaef520 1188 else
46b6f1f6 1189 targc = 2;
5eaef520 1190
1191 list_id = *(int *)argv[0];
1192
1193 targv[1] = member_name;
46b6f1f6 1194 targv[2] = tag;
1195
5eaef520 1196 targv[0] = "USER";
1197 EXEC SQL DECLARE csr119 CURSOR FOR
46b6f1f6 1198 SELECT u.login, s.string FROM users u, imembers im, strings s
5eaef520 1199 WHERE im.list_id = :list_id AND im.member_type = 'USER'
1200 AND im.member_id = u.users_id AND im.direct > :direct
46b6f1f6 1201 AND s.string_id = im.tag ORDER BY 1;
5eaef520 1202 if (dbms_errno)
1203 return mr_errcode;
1204 EXEC SQL OPEN csr119;
1205 if (dbms_errno)
1206 return mr_errcode;
1207 while (1)
1208 {
46b6f1f6 1209 EXEC SQL FETCH csr119 INTO :member_name, :tag;
5eaef520 1210 if (sqlca.sqlcode)
1211 break;
46b6f1f6 1212 (*action)(targc, targv, actarg);
b070f8a1 1213 }
5eaef520 1214 EXEC SQL CLOSE csr119;
1215 if (dbms_errno)
1216 return mr_errcode;
1217
1218 targv[0] = "LIST";
1219 EXEC SQL DECLARE csr120 CURSOR FOR
46b6f1f6 1220 SELECT l.name, s.string FROM list l, imembers im, strings s
5eaef520 1221 WHERE im.list_id = :list_id AND im.member_type = 'LIST'
1222 AND im.member_id = l.list_id AND im.direct > :direct
46b6f1f6 1223 AND s.string_id = im.tag ORDER BY 1;
5eaef520 1224 if (dbms_errno)
1225 return mr_errcode;
1226 EXEC SQL OPEN csr120;
1227 if (dbms_errno)
1228 return mr_errcode;
1229 while (1)
1230 {
46b6f1f6 1231 EXEC SQL FETCH csr120 INTO :member_name, :tag;
5eaef520 1232 if (sqlca.sqlcode)
1233 break;
46b6f1f6 1234 (*action)(targc, targv, actarg);
b070f8a1 1235 }
5eaef520 1236 EXEC SQL CLOSE csr120;
1237 if (dbms_errno)
1238 return mr_errcode;
1239
1240 targv[0] = "STRING";
1241 EXEC SQL DECLARE csr121 CURSOR FOR
46b6f1f6 1242 SELECT str.string, s.string FROM strings str, imembers im, strings s
5eaef520 1243 WHERE im.list_id = :list_id AND im.member_type = 'STRING'
1244 AND im.member_id = str.string_id AND im.direct > :direct
46b6f1f6 1245 AND s.string_id = im.tag ORDER BY 1;
5eaef520 1246 if (dbms_errno)
1247 return mr_errcode;
1248 EXEC SQL OPEN csr121;
1249 if (dbms_errno)
1250 return mr_errcode;
1251 while (1)
1252 {
46b6f1f6 1253 EXEC SQL FETCH csr121 INTO :member_name, :tag;
5eaef520 1254 if (sqlca.sqlcode)
1255 break;
46b6f1f6 1256 (*action)(targc, targv, actarg);
b070f8a1 1257 }
5eaef520 1258 EXEC SQL CLOSE csr121;
1259 if (dbms_errno)
1260 return mr_errcode;
1261
1262 targv[0] = "KERBEROS";
1263 EXEC SQL DECLARE csr122 CURSOR FOR
46b6f1f6 1264 SELECT str.string, s.string FROM strings str, imembers im, strings s
5eaef520 1265 WHERE im.list_id = :list_id AND im.member_type = 'KERBEROS'
46b6f1f6 1266 AND im.member_id = str.string_id AND im.direct > :direct
1267 AND s.string_id = im.tag ORDER BY 1;
5eaef520 1268 if (dbms_errno)
1269 return mr_errcode;
1270 EXEC SQL OPEN csr122;
1271 if (dbms_errno)
1272 return mr_errcode;
1273 while (1)
1274 {
46b6f1f6 1275 EXEC SQL FETCH csr122 INTO :member_name, :tag;
5eaef520 1276 if (sqlca.sqlcode)
1277 break;
46b6f1f6 1278 (*action)(targc, targv, actarg);
0659551f 1279 }
5eaef520 1280 EXEC SQL CLOSE csr122;
1281 if (dbms_errno)
1282 return mr_errcode;
b070f8a1 1283
5f7b0741 1284 targv[0] = "MACHINE";
1285 EXEC SQL DECLARE csr123 CURSOR FOR
1286 SELECT m.name, s.string FROM machine m, imembers im, strings s
1287 WHERE im.list_id = :list_id AND im.member_type = 'MACHINE'
1288 AND im.member_id = m.mach_id AND im.direct > :direct
1289 AND s.string_id = im.tag ORDER BY 1;
1290 if (dbms_errno)
1291 return mr_errcode;
1292 EXEC SQL OPEN csr123;
1293 if (dbms_errno)
1294 return mr_errcode;
1295 while (1)
1296 {
1297 EXEC SQL FETCH csr123 INTO :member_name, :tag;
1298 if (sqlca.sqlcode)
1299 break;
1300 (*action)(targc, targv, actarg);
1301 }
1302 EXEC SQL CLOSE csr123;
1303 if (dbms_errno)
1304 return mr_errcode;
1305
5eaef520 1306 return MR_SUCCESS;
5d677c81 1307}
b070f8a1 1308
1309
0659551f 1310/* count_members_of_list: this is a simple query, but it cannot be done
1311 * through the dispatch table.
1312 */
b070f8a1 1313
5eaef520 1314int count_members_of_list(struct query *q, char *argv[], client *cl,
7ac48069 1315 int (*action)(int, char *[], void *), void *actarg)
5d677c81 1316{
5eaef520 1317 EXEC SQL BEGIN DECLARE SECTION;
1318 int list, ct = 0;
1319 EXEC SQL END DECLARE SECTION;
1320 char *rargv[1], countbuf[5];
1321
1322 list = *(int *)argv[0];
1323 rargv[0] = countbuf;
1324 EXEC SQL SELECT count (*) INTO :ct FROM imembers
1325 WHERE list_id = :list AND direct = 1;
1326 if (dbms_errno)
1327 return mr_errcode;
1328 sprintf(countbuf, "%d", ct);
1329 (*action)(1, rargv, actarg);
1330 return MR_SUCCESS;
5d677c81 1331}
b070f8a1 1332
b070f8a1 1333
0659551f 1334/* qualified_get_server: passed "TRUE", "FALSE", or "DONTCARE" for each of
1335 * the three flags associated with each service. It will return the name of
1336 * each service that meets the quailifications. It does this by building a
1337 * where clause based on the arguments, then doing a retrieve.
1338 */
b070f8a1 1339
0659551f 1340static char *sflags[3] = { "enable", "inprogress", "harderror" };
b070f8a1 1341
5eaef520 1342int qualified_get_server(struct query *q, char *argv[], client *cl,
7ac48069 1343 int (*action)(int, char *[], void *), void *actarg)
5d677c81 1344{
5eaef520 1345 return qualified_get(q, argv, action, actarg, "s.name is not null",
1346 "s", "name", sflags);
1347 /* of course, name will never be null, but we need something there
1348 to make qualified_get happy */
5d677c81 1349}
b070f8a1 1350
1351
0659551f 1352/* generic qualified get routine, used by qualified_get_lists,
1353 * qualified_get_server, and qualified_get_serverhost.
1354 * Args:
1355 * start - a simple where clause, must not be empty
1356 * range - the name of the range variable
1357 * field - the field to return
1358 * flags - an array of strings, names of the flag variables
b070f8a1 1359 */
1360
7ac48069 1361int qualified_get(struct query *q, char *argv[],
1362 int (*action)(int, char *[], void *), void *actarg,
5eaef520 1363 char *start, char *range, char *field, char *flags[])
453b99fe 1364{
5eaef520 1365 char qual[256];
1366 int i;
1367 char buf[32];
1368
1369 strcpy(qual, start);
1370 for (i = 0; i < q->argc; i++)
1371 {
1372 if (!strcmp(argv[i], "TRUE"))
1373 {
1374 sprintf(buf, " AND %s.%s != 0", range, flags[i]);
1375 strcat(qual, buf);
1376 }
1377 else if (!strcmp(argv[i], "FALSE"))
1378 {
1379 sprintf(buf, " AND %s.%s = 0", range, flags[i]);
1380 strcat(qual, buf);
0659551f 1381 }
453b99fe 1382 }
1383
5eaef520 1384 sprintf(stmt_buf, "SELECT %s.%s FROM %s %s WHERE %s", range, field,
1385 table_name[q->rtable], range, qual);
1386 return do_for_all_rows(stmt_buf, 1, action, actarg);
453b99fe 1387}
1388
1389
0659551f 1390/* qualified_get_serverhost: passed "TRUE", "FALSE", or "DONTCARE" for each of
1391 * the five flags associated with each serverhost. It will return the name of
1392 * each service and host that meets the quailifications. It does this by
1393 * building a where clause based on the arguments, then doing a retrieve.
45bf7573 1394 */
45bf7573 1395
0659551f 1396static char *shflags[6] = { "service", "enable", "override", "success",
1397 "inprogress", "hosterror" };
45bf7573 1398
5eaef520 1399int qualified_get_serverhost(struct query *q, char *argv[], client *cl,
7ac48069 1400 int (*action)(int, char *[], void *),
1401 void *actarg)
45bf7573 1402{
5eaef520 1403 char qual[256], buf[32];
1404 int i;
1405
1406 sprintf(qual, "m.mach_id = sh.mach_id AND sh.service = UPPER('%s')",
1407 argv[0]);
1408 for (i = 1; i < q->argc; i++)
1409 {
1410 if (!strcmp(argv[i], "TRUE"))
1411 {
1412 sprintf(buf, " AND sh.%s != 0", shflags[i]);
1413 strcat(qual, buf);
1414 }
1415 else if (!strcmp(argv[i], "FALSE"))
1416 {
1417 sprintf(buf, " AND sh.%s = 0", shflags[i]);
1418 strcat(qual, buf);
0659551f 1419 }
1420 }
45bf7573 1421
5eaef520 1422 sprintf(stmt_buf, "SELECT sh.service, m.name FROM serverhosts sh, "
1423 "machine m WHERE %s", qual);
1424 return do_for_all_rows(stmt_buf, 2, action, actarg);
45bf7573 1425}
1426
0659551f 1427
1428/* register_user - change user's login name and allocate a pobox, group,
1429 * filesystem, and quota for them. The user's status must start out as 0,
b4bfb4d1 1430 * and is left as 2. Arguments are: user's UID, new login name, and
edf666a5 1431 * pobox type ("POP" = POP, "IMAP" or numeric = IMAP)
99e09b48 1432 */
0659551f 1433
5eaef520 1434int register_user(struct query *q, char **argv, client *cl)
99e09b48 1435{
5eaef520 1436 EXEC SQL BEGIN DECLARE SECTION;
e688520a 1437 char *login, *entity;
1438 char directory[FILESYS_NAME_SIZE], machname[MACHINE_NAME_SIZE];
b4bfb4d1 1439 char dir[NFSPHYS_DIR_SIZE], *potype;
1440 int who, rowcount, mid, uid, users_id;
1441 int ostatus, nstatus, fsidval, popid;
1442 int npid, tmp;
edf666a5 1443 int po_exists = 0;
b4bfb4d1 1444 static int m_id, def_quota, def_imap_quota, list_id;
5eaef520 1445 EXEC SQL END DECLARE SECTION;
1446 char buffer[256], *aargv[3];
1447
b4bfb4d1 1448 if (!m_id)
1449 {
1450 EXEC SQL SELECT list_id INTO :list_id FROM list
1451 WHERE name = 'wheel';
1452
1453 EXEC SQL SELECT mach_id INTO :m_id FROM machine
1454 WHERE name = 'ATHENA.MIT.EDU';
1455
1456 EXEC SQL SELECT value INTO :def_quota FROM numvalues
1457 WHERE name = 'def_quota';
1458 if (sqlca.sqlerrd[2] != 1)
1459 return MR_NO_QUOTA;
1460
1461 EXEC SQL SELECT value INTO :def_imap_quota FROM numvalues
1462 WHERE name = 'def_imap_quota';
1463 if (sqlca.sqlerrd[2] != 1)
1464 return MR_NO_QUOTA;
1465 }
1466
5eaef520 1467 entity = cl->entity;
1468 who = cl->client_id;
1469
1470 uid = atoi(argv[0]);
1471 login = argv[1];
b4bfb4d1 1472 potype = argv[2];
5eaef520 1473
1474 /* find user */
1475 EXEC SQL SELECT users_id, status INTO :users_id, :ostatus
1476 FROM users
7c95c11b 1477 WHERE unix_uid = :uid AND
1478 (status = 0 OR status = 5 OR status = 6 OR status = 9);
5eaef520 1479
1480 if (sqlca.sqlerrd[2] == 0)
1481 return MR_NO_MATCH;
1482 if (sqlca.sqlerrd[2] > 1)
1483 return MR_NOT_UNIQUE;
1484
1485 /* check new login name */
1486 EXEC SQL SELECT COUNT(login) INTO :rowcount FROM users
1487 WHERE login = :login AND users_id != :users_id;
1488 if (dbms_errno)
1489 return mr_errcode;
1490 if (rowcount > 0)
1491 return MR_IN_USE;
1492 EXEC SQL SELECT COUNT(name) INTO :rowcount FROM list
ec0b8003 1493 WHERE LOWER(name) = :login;
5eaef520 1494 if (dbms_errno)
1495 return mr_errcode;
1496 if (rowcount > 0)
1497 return MR_IN_USE;
1498 EXEC SQL SELECT COUNT(label) INTO :rowcount FROM filesys
edf666a5 1499 WHERE label = :login;
5eaef520 1500 if (dbms_errno)
1501 return mr_errcode;
1502 if (rowcount > 0)
1503 return MR_IN_USE;
edf666a5 1504 EXEC SQL SELECT COUNT(label) INTO :rowcount
1505 FROM filesys WHERE label = :login || '.po';
1506 if (dbms_errno)
1507 return mr_errcode;
1508 if (rowcount > 0)
1509 {
1510 EXEC SQL SELECT owner INTO :tmp FROM filesys
1511 WHERE label = :login || '.po';
1512 if (dbms_errno)
1513 return mr_errcode;
7c95c11b 1514 if ((ostatus == 0 || ostatus == 9) || (tmp != users_id))
edf666a5 1515 return MR_IN_USE;
69e2312e 1516 else
edf666a5 1517 po_exists = 1;
1518 }
5eaef520 1519 EXEC SQL SELECT COUNT(name) INTO :rowcount FROM alias
b4bfb4d1 1520 WHERE ( name = :login OR name = :login || '.po' )
1521 AND type = 'FILESYS';
5eaef520 1522 if (dbms_errno)
1523 return mr_errcode;
1524 if (rowcount > 0)
1525 return MR_IN_USE;
1526 com_err(whoami, 0, "login name OK");
1527
edf666a5 1528 EXEC SQL SELECT COUNT(potype) INTO :rowcount FROM users WHERE
1529 login = :login AND potype = 'POP';
1530 if (dbms_errno)
1531 return mr_errcode;
1532 if (rowcount > 0)
1533 po_exists = 1;
1534
b4bfb4d1 1535 /* choose type and location for pobox */
edf666a5 1536 if (!po_exists)
5eaef520 1537 {
edf666a5 1538 if (!strcmp(potype, "POP"))
b4bfb4d1 1539 {
edf666a5 1540
1541 EXEC SQL DECLARE csr130 CURSOR FOR
1542 SELECT sh.mach_id, m.name FROM serverhosts sh, machine m
1543 WHERE sh.service = 'POP' AND sh.mach_id = m.mach_id
1544 AND sh.value2 - sh.value1 =
1545 (SELECT MAX(value2 - value1) FROM serverhosts WHERE service = 'POP');
b4bfb4d1 1546 if (dbms_errno)
1547 return mr_errcode;
edf666a5 1548 EXEC SQL OPEN csr130;
1549 if (dbms_errno)
1550 return mr_errcode;
1551 EXEC SQL FETCH csr130 INTO :popid, :machname;
1552 if (sqlca.sqlerrd[2] == 0)
1553 {
1554 EXEC SQL CLOSE csr130;
1555 if (dbms_errno)
1556 return mr_errcode;
1557 return MR_NO_POBOX;
1558 }
1559 else
1560 {
1561 EXEC SQL CLOSE csr130;
1562 if (dbms_errno)
1563 return mr_errcode;
1564 }
1565
1566 EXEC SQL UPDATE users SET potype = 'POP', pop_id = :popid
1567 WHERE users_id = :users_id;
1568 com_err(whoami, 0, "pobox set to POP:%s", strtrim(machname));
1569 }
b4bfb4d1 1570 else
1571 {
edf666a5 1572 /* Select all IMAP nfsphys entries in order of increasing
1573 * (allocated - partsize). The partitions will almost always be
1574 * overallocated, but we choose the one that is the least
1575 * overallocated.
1576 */
1577 potype = "IMAP";
1578
1579 EXEC SQL DECLARE csr_rusr_imap CURSOR FOR
1580 SELECT np.allocated - np.partsize, np.nfsphys_id, np.mach_id,
1581 np.dir, m.name FROM serverhosts sh, nfsphys np, machine m
1582 WHERE sh.service = 'POSTOFFICE' AND sh.mach_id = np.mach_id
1583 AND m.mach_id = np.mach_id
1584 ORDER BY 1;
b4bfb4d1 1585 if (dbms_errno)
1586 return mr_errcode;
edf666a5 1587 EXEC SQL OPEN csr_rusr_imap;
1588 if (dbms_errno)
1589 return mr_errcode;
1590 EXEC SQL FETCH csr_rusr_imap INTO :tmp, :npid, :mid, :dir, :machname;
1591 if (sqlca.sqlerrd[2] == 0)
1592 {
1593 EXEC SQL CLOSE csr_rusr_imap;
1594 if (dbms_errno)
1595 return mr_errcode;
1596 return MR_NO_POBOX;
1597 }
1598 else
1599 {
1600 EXEC SQL CLOSE csr_rusr_imap;
1601 if (dbms_errno)
1602 return mr_errcode;
1603 }
b4bfb4d1 1604
edf666a5 1605 /* create filesystem */
1606 if (set_next_object_id("filsys_id", FILESYS_TABLE, 0))
1607 return MR_NO_ID;
1608 incremental_clear_before();
1609
1610 EXEC SQL SELECT value INTO :popid FROM numvalues
1611 WHERE numvalues.name = 'filsys_id';
1612 EXEC SQL INSERT INTO filesys
1613 (filsys_id, phys_id, label, type, mach_id, name,
1614 mount, rwaccess, comments, owner, owners, createflg,
1615 lockertype, modtime, modby, modwith)
1616 VALUES
1617 (:popid, :npid, :login || '.po', 'IMAP', :mid, :dir,
1618 CHR(0), 'w', 'IMAP box', :users_id, :list_id, 1,
9f3ee749 1619 'USER', SYSDATE, :who, :entity);
b4bfb4d1 1620
b4bfb4d1 1621 if (dbms_errno)
1622 return mr_errcode;
edf666a5 1623 if (sqlca.sqlerrd[2] != 1)
1624 return MR_INTERNAL;
1625 sprintf(buffer, "fs.filsys_id = %d", popid);
1626 incremental_after(FILESYS_TABLE, buffer, 0);
1627
1628 /* set quota */
1629 incremental_clear_before();
1630 EXEC SQL INSERT INTO quota
1631 (entity_id, filsys_id, type, quota, phys_id, modtime, modby, modwith)
1632 VALUES (:users_id, :popid, 'USER', :def_imap_quota, :npid,
1633 SYSDATE, :who, :entity);
1634 if (dbms_errno)
1635 return mr_errcode;
1636 if (sqlca.sqlerrd[2] != 1)
1637 return MR_INTERNAL;
1638 aargv[0] = login;
1639 aargv[1] = "USER";
1640 aargv[2] = login;
1641 sprintf(buffer, "q.entity_id = %d and q.filsys_id = %d and "
1642 "q.type = 'USER'", users_id, popid);
1643 incremental_after(QUOTA_TABLE, buffer, aargv);
b4bfb4d1 1644 if (dbms_errno)
1645 return mr_errcode;
99e09b48 1646
edf666a5 1647 EXEC SQL UPDATE nfsphys SET allocated = allocated + :def_imap_quota
1648 WHERE nfsphys_id = :npid;
1649
1650 EXEC SQL UPDATE users SET potype = 'IMAP', imap_id = :popid
1651 WHERE users_id = :users_id;
1652 com_err(whoami, 0, "pobox set to IMAP:%s:%s", strtrim(machname),
1653 strtrim(dir));
1654 }
b4bfb4d1 1655 }
1656
5eaef520 1657 /* change login name, set pobox */
1658 sprintf(buffer, "u.users_id = %d", users_id);
1659 incremental_before(USERS_TABLE, buffer, 0);
1660 nstatus = 2;
7c95c11b 1661 if (ostatus == 5 || ostatus == 6 || ostatus == 9)
5eaef520 1662 nstatus = 1;
1663 EXEC SQL UPDATE users SET login = :login, status = :nstatus,
b4bfb4d1 1664 modtime = SYSDATE, modby = :who, modwith = :entity,
3b634eb3 1665 pmodtime = SYSDATE, pmodby = :who, pmodwith = :entity,
1666 created = SYSDATE, creator = :who
5eaef520 1667 WHERE users_id = :users_id;
1668
1669 if (dbms_errno)
1670 return mr_errcode;
1671 if (sqlca.sqlerrd[2] != 1)
1672 return MR_INTERNAL;
edf666a5 1673
1674 /* Only update usage count if we created a POP pobox. */
1675 if (!strcmp(potype, "POP") && !po_exists)
1676 set_pop_usage(mid, 1);
1677
b4bfb4d1 1678 com_err(whoami, 0, "set login name to %s", login);
5eaef520 1679 incremental_after(USERS_TABLE, buffer, 0);
1680
5eaef520 1681 /* create filesystem */
1682 if (set_next_object_id("filsys_id", FILESYS_TABLE, 0))
1683 return MR_NO_ID;
1684 incremental_clear_before();
1685 if (islower(login[0]) && islower(login[1]))
1686 {
1687 sprintf(directory, "/afs/athena.mit.edu/user/%c/%c/%s",
1688 login[0], login[1], login);
0659551f 1689 }
5eaef520 1690 else
1691 sprintf(directory, "/afs/athena.mit.edu/user/other/%s", login);
1692
1693 EXEC SQL SELECT value INTO :fsidval FROM numvalues
1694 WHERE numvalues.name = 'filsys_id';
1695 EXEC SQL INSERT INTO filesys
1696 (filsys_id, phys_id, label, type, mach_id, name,
1697 mount, rwaccess, comments, owner, owners, createflg,
1698 lockertype, modtime, modby, modwith)
1699 VALUES
1700 (:fsidval, 0, :login, 'AFS', :m_id, :directory,
1701 '/mit/' || :login, 'w', 'User Locker', :users_id, :list_id, 1,
1702 'HOMEDIR', SYSDATE, :who, :entity);
1703
1704 if (dbms_errno)
1705 return mr_errcode;
1706 if (sqlca.sqlerrd[2] != 1)
1707 return MR_INTERNAL;
1708 sprintf(buffer, "fs.filsys_id = %d", fsidval);
1709 incremental_after(FILESYS_TABLE, buffer, 0);
1710
1711 /* set quota */
5eaef520 1712 incremental_clear_before();
1713 EXEC SQL INSERT INTO quota
1714 (entity_id, filsys_id, type, quota, phys_id, modtime, modby, modwith)
1715 VALUES (0, :fsidval, 'ANY', :def_quota, 0, SYSDATE, :who, :entity);
1716 if (dbms_errno)
1717 return mr_errcode;
1718 if (sqlca.sqlerrd[2] != 1)
1719 return MR_INTERNAL;
1720 aargv[0] = login;
1721 aargv[1] = "ANY";
1722 aargv[2] = login;
1723 sprintf(buffer, "q.entity_id = 0 and q.filsys_id = %d and q.type = 'ANY'",
1724 fsidval);
1725 incremental_after(QUOTA_TABLE, buffer, aargv);
1726 com_err(whoami, 0, "quota of %d assigned", def_quota);
1727 if (dbms_errno)
1728 return mr_errcode;
1729
5eaef520 1730 EXEC SQL UPDATE tblstats SET updates = updates + 1, modtime = SYSDATE
1731 WHERE table_name = 'users';
1732 EXEC SQL UPDATE tblstats SET appends = appends + 1, modtime = SYSDATE
1733 WHERE table_name = 'filesys' OR table_name = 'quota';
1734 if (dbms_errno)
1735 return mr_errcode;
1736 return MR_SUCCESS;
3afb5524 1737}
1738
0659551f 1739/** set_pop_usage - incr/decr usage count for pop server in serverhosts talbe
1740 **
1741 ** Inputs:
1742 ** id of machine
1743 ** delta (will be +/- 1)
1744 **
1745 ** Description:
1746 ** - incr/decr value field in serverhosts table for pop/mach_id
1747 **
1748 **/
1749
1750int set_pop_usage(id, cnt)
03c05291 1751 int id, cnt;
0659551f 1752{
5eaef520 1753 EXEC SQL BEGIN DECLARE SECTION;
1754 int iid = id, icnt = cnt;
1755 EXEC SQL END DECLARE SECTION;
03c05291 1756
5eaef520 1757 EXEC SQL UPDATE serverhosts SET value1 = value1 + :icnt
1758 WHERE serverhosts.service = 'POP' AND serverhosts.mach_id = :iid;
835aabee 1759
5eaef520 1760 if (dbms_errno)
1761 return mr_errcode;
1762 return MR_SUCCESS;
835aabee 1763}
1764
77eb4bdf 1765
1766int do_user_reservation(struct query *q, char *argv[], client *cl)
1767{
1768 EXEC SQL BEGIN DECLARE SECTION;
1769 char resv[USERS_RESERVATIONS_SIZE];
1770 char *trans, name[ALIAS_NAME_SIZE];
1771 int uid;
1772 EXEC SQL END DECLARE SECTION;
1773
1774 uid = *(int *)argv[0];
1775 trans = argv[1];
1776
1777 EXEC SQL SELECT UPPER(name) INTO :name FROM alias
1778 WHERE type = 'RESERVE' AND LOWER(trans) = LOWER(:trans);
1779 if (dbms_errno)
1780 return mr_errcode;
1781 if (sqlca.sqlerrd[2] != 1)
1782 return MR_STRING;
1783 name[1] = '\0';
1784
1785 EXEC SQL SELECT reservations INTO :resv FROM users
1786 WHERE users_id = :uid;
1787 if (dbms_errno)
1788 return mr_errcode;
1789 strtrim(resv);
1790
1791 if (!strcmp(q->shortname, "aurv"))
1792 {
1793 if (strchr(resv, *name))
1794 return MR_EXISTS;
1795 if (strlen(resv) == USERS_RESERVATIONS_SIZE - 1)
1796 return MR_ARG_TOO_LONG;
1797
1798 strcat(resv, name);
1799 }
1800 else
1801 {
1802 char *p = strchr(resv, *name);
1803 if (!p)
1804 return MR_NO_MATCH;
1805 memmove(p, p + 1, strlen(p));
1806 }
1807
1808 EXEC SQL UPDATE users SET reservations = NVL(:resv, CHR(0))
1809 WHERE users_id = :uid;
1810 if (dbms_errno)
1811 return mr_errcode;
1812
1813 EXEC SQL UPDATE tblstats SET updates = updates + 1, modtime = SYSDATE
1814 WHERE table_name = 'users';
1815 return set_modtime_by_id(q, argv, cl);
1816}
1817
1818int get_user_reservations(struct query *q, char **argv, client *cl,
1819 int (*action)(int, char *[], void *), void *actarg)
1820{
1821 EXEC SQL BEGIN DECLARE SECTION;
1822 char resv[USERS_RESERVATIONS_SIZE], *p;
1823 char trans[ALIAS_TRANS_SIZE], name[2] = { 0, 0 };
1824 int uid;
1825 EXEC SQL END DECLARE SECTION;
1826 char *targv[1];
1827
1828 uid = *(int *)argv[0];
1829
1830 EXEC SQL SELECT reservations INTO :resv FROM users
1831 WHERE users_id = :uid;
1832 if (dbms_errno)
1833 return mr_errcode;
1834
1835 targv[0] = trans;
1836 p = resv;
1837 while (*p && !isspace(*p))
1838 {
1839 name[0] = toupper(*p);
1840 EXEC SQL SELECT trans INTO :trans FROM alias
1841 WHERE type = 'RESERVE' AND UPPER(name) = :name;
1842 if (dbms_errno)
1843 return mr_errcode;
1844 if (sqlca.sqlerrd[2] != 1)
1845 sprintf(trans, "Unknown (%s)", name);
1846 (*action)(1, targv, actarg);
1847 p++;
1848 }
1849 return MR_SUCCESS;
1850}
1851
1852int get_user_by_reservation(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], login[USERS_LOGIN_SIZE];
1857 char *trans, name[ALIAS_NAME_SIZE];
1858 int uid;
1859 EXEC SQL END DECLARE SECTION;
1860 char *targv[1];
1861
1862 trans = argv[0];
1863
1864 EXEC SQL SELECT UPPER(name) INTO :name FROM alias
1865 WHERE type = 'RESERVE' AND LOWER(trans) = LOWER(:trans);
1866 if (dbms_errno)
1867 return mr_errcode;
1868 if (sqlca.sqlerrd[2] != 1)
1869 return MR_STRING;
1870 name[1] = '\0';
1871
1872 EXEC SQL DECLARE csr_gubr CURSOR FOR
1873 SELECT login FROM users WHERE reservations LIKE '%' || :name || '%';
1874 EXEC SQL OPEN csr_gubr;
1875 if (dbms_errno)
1876 return mr_errcode;
1877
1878 targv[0] = login;
1879 while (1)
1880 {
1881 EXEC SQL FETCH csr_gubr INTO :login;
1882 if (sqlca.sqlcode)
1883 break;
1884 (*action)(1, targv, actarg);
1885 }
1886 EXEC SQL CLOSE csr_gubr;
1887
1888 return MR_SUCCESS;
1889}
2fb668b0 1890
1891int update_container(struct query *q, char *argv[], client *cl)
1892{
1893 EXEC SQL BEGIN DECLARE SECTION;
73155abd 1894 int cnt_id, acl_id, memacl_id, who, flag;
2fb668b0 1895 char name[CONTAINERS_NAME_SIZE], newchildname[CONTAINERS_NAME_SIZE];
1896 char* newname, *entity, *description, *location, *contact, *acl_type, *memacl_type;
1897 EXEC SQL END DECLARE SECTION;
1898 char* tmpchar;
1899 int cnt, childid;
1900 char childname[CONTAINERS_NAME_SIZE];
bb5c9457 1901 char *qual;
73155abd 1902 int index = 0;
2fb668b0 1903
73155abd 1904 cnt_id = *(int *)argv[index++];
1905 newname = argv[index++];
1906
1907 if (q->version >= 9)
1908 flag = atoi(argv[index++]);
1909
1910 description = argv[index++];
1911 location = argv[index++];
1912 contact = argv[index++];
1913 acl_type = argv[index++];
1914 acl_id = *(int *)argv[index++];
1915 memacl_type = argv[index++];
1916 memacl_id = *(int *)argv[index++];
2fb668b0 1917 entity = cl->entity;
1918 who = cl->client_id;
1919
1920 EXEC SQL SELECT name INTO :name
1921 FROM containers
1922 WHERE cnt_id = :cnt_id;
1923
1924 /* trim off the trailing spaces */
1925 strcpy(name, strtrim(name));
1926
751f43da 1927 qual = xmalloc(MAX_FIELD_WIDTH);
1928 sprintf(qual, "name = '%s'", name);
1929 incremental_before(CONTAINERS_TABLE, qual, argv);
1930
2fb668b0 1931 /* if we are renaming the container */
1932 if (strcmp(name, newname))
1933 {
1934 /* make sure that only the name part of the name has been changed */
1935 tmpchar = strrchr(name, '/');
1936 /* not a top-level name */
1937 if (tmpchar)
1938 {
1939 cnt = tmpchar - name + 1;
1940 /* the parent part of the old and new name should be identical */
1941 if (strncmp(name, newname, cnt))
1942 return MR_NEW_CONTAINER_NAME;
1943 }
1944 /* top level name, new name should be a top level name too */
1945 else
1946 {
1947 if (strrchr(newname, '/'))
1948 return MR_NEW_CONTAINER_NAME;
1949 }
1950
1951 /* update the name for this container */
1952 EXEC SQL UPDATE containers
1953 SET name = :newname
1954 WHERE cnt_id = :cnt_id;
1955
1956 if (dbms_errno)
1957 return mr_errcode;
1958
1959 /* get names for its child containers */
1960 EXEC SQL DECLARE csr_ucon CURSOR FOR
1961 SELECT name, cnt_id FROM containers WHERE name LIKE :name || '/' || '%';
1962
1963 EXEC SQL OPEN csr_ucon;
1964 if (dbms_errno)
1965 return mr_errcode;
1966
1967 while (1)
1968 {
1969 EXEC SQL FETCH csr_ucon INTO :childname, :childid;
1970 if (sqlca.sqlcode)
1971 break;
d16a0628 1972
1973 strcpy(childname, strtrim(childname));
2fb668b0 1974 /* concatenate the new parent name with the existing sub-container name
1975 * we get the sub-containers new name */
1976 tmpchar = childname + strlen(name);
1977 strcpy(newchildname, newname);
1978 strcat(newchildname, tmpchar);
1979
1980 /* update the name */
1981 EXEC SQL UPDATE containers
1982 SET name = :newchildname, modtime = SYSDATE, modby = :who, modwith = :entity
1983 WHERE cnt_id = :childid;
1984
1985 if (sqlca.sqlcode)
1986 break;
1987 }
1988
1989 EXEC SQL CLOSE csr_ucon;
1990 if (dbms_errno)
1991 return mr_errcode;
1992 }
1993
1994 /* update the remaining fields */
73155abd 1995 if (q->version >= 9)
1996 {
1997 EXEC SQL UPDATE containers
1998 SET publicflg= :flag, description = NVL(:description, CHR(0)), location = NVL(:location, CHR(0)),
1999 contact = NVL(:contact, CHR(0)), acl_type = :acl_type, acl_id = :acl_id,
2000 memacl_type = :memacl_type, memacl_id = :memacl_id,
2001 modtime = SYSDATE, modby = :who, modwith = :entity
2002 WHERE cnt_id = :cnt_id;
2003 }
2004 else
2005 {
2006 EXEC SQL UPDATE containers
2007 SET publicflg= :flag, description = NVL(:description, CHR(0)), location = NVL(:location, CHR(0)),
2008 contact = NVL(:contact, CHR(0)), acl_type = :acl_type, acl_id = :acl_id,
2009 memacl_type = :memacl_type, memacl_id = :memacl_id,
2010 modtime = SYSDATE, modby = :who, modwith = :entity
2011 WHERE cnt_id = :cnt_id;
2012 }
2fb668b0 2013
2014 if (dbms_errno)
2015 return mr_errcode;
bb5c9457 2016
2017 sprintf(qual, "name = '%s'", newname);
2018 incremental_after(CONTAINERS_TABLE, qual, argv);
2fb668b0 2019
2020 return MR_SUCCESS;
2021}
2022
2023int get_machines_of_container(struct query *q, char *argv[], client *cl,
2024 int (*action)(int, char *[], void *), void *actarg)
2025{
2026 EXEC SQL BEGIN DECLARE SECTION;
2027 int cnt_id, isrecursive;
2028 char machinename[MACHINE_NAME_SIZE], containername[CONTAINERS_NAME_SIZE];
2029 char *qs;
2030 EXEC SQL END DECLARE SECTION;
2031
2032 char querystring[512], tmp [256];
2033 char *rargv[2];
2034 int found = 0;
2035
2036 rargv[0] = machinename;
2037 rargv[1] = containername;
2038
2039 cnt_id = *(int *)argv[0];
faf44ced 2040 isrecursive = atoi(argv[1]);
2fb668b0 2041
2042 /* get the container name */
2043
2044 EXEC SQL SELECT name INTO :containername
2045 FROM containers
2046 WHERE cnt_id = :cnt_id;
2047
2048 /* trim off the trailing spaces */
2049 strcpy(containername, strtrim(containername));
2050
2051 strcpy(querystring, "SELECT a.name, b.name FROM machine a, containers b, mcntmap c ");
2052 strcat(querystring, "WHERE a.mach_id = c.mach_id AND b.cnt_id = c.cnt_id ");
2053
2054 if (!isrecursive)
2055 sprintf(tmp, "AND b.cnt_id = %d ", cnt_id);
2056 else
73155abd 2057 sprintf(tmp, "AND (b.cnt_id = %d OR b.name LIKE LOWER('%s/%%')) ",
2058 cnt_id, containername);
2fb668b0 2059
2060 strcat(querystring, tmp);
2061 strcat(querystring, "ORDER BY b.name, a.name");
2062
2063 qs = querystring;
2064
2065 EXEC SQL PREPARE stmt FROM :qs;
2066 if (sqlca.sqlcode)
2067 return MR_INTERNAL;
2068 EXEC SQL DECLARE curs_gmnm CURSOR FOR stmt;
2069 EXEC SQL OPEN curs_gmnm;
2070
2071 while (1)
2072 {
2073 EXEC SQL FETCH curs_gmnm INTO :machinename, :containername;
2074 if (sqlca.sqlcode)
2075 break;
2076 (*action)(2, rargv, actarg);
2077 found++;
2078 }
2079
2080 EXEC SQL CLOSE curs_gmnm;
2081 if (!found)
2082 return MR_NO_MATCH;
2083 return MR_SUCCESS;
2084}
2085
2086int get_subcontainers_of_container(struct query *q, char *argv[], client *cl,
2087 int (*action)(int, char *[], void *), void *actarg)
2088{
2089 EXEC SQL BEGIN DECLARE SECTION;
2090 int cnt_id, isrecursive;
2091 char containername[CONTAINERS_NAME_SIZE], subcontainername[CONTAINERS_NAME_SIZE];
2092 char *qs;
2093 EXEC SQL END DECLARE SECTION;
2094
8d7d8af0 2095 char querystring[2048], tmp [1024];
2fb668b0 2096 char *rargv[1];
2097 int found = 0;
2098
2099 rargv[0] = subcontainername;
2100
2101 cnt_id = *(int *)argv[0];
faf44ced 2102 isrecursive = atoi(argv[1]);
2fb668b0 2103
2104 /* get the container name */
2105
2106 EXEC SQL SELECT name INTO :containername
2107 FROM containers
2108 WHERE cnt_id = :cnt_id;
2109
2110 /* trim off the trailing spaces */
2111 strcpy(containername, strtrim(containername));
2112
2113 strcpy(querystring, "SELECT name FROM containers ");
2114
2115 if (!isrecursive)
73155abd 2116 sprintf(tmp, "WHERE LOWER(name) LIKE '%s/%%' and name NOT LIKE LOWER('%s/%%/%%') ",
2117 containername, containername);
2fb668b0 2118 else
73155abd 2119 sprintf(tmp, "WHERE LOWER(name) LIKE LOWER('%s/%%') ", containername);
2fb668b0 2120
2121 strcat(querystring, tmp);
2122 strcat(querystring, "ORDER BY name");
2123
2124 qs = querystring;
2125
2126 EXEC SQL PREPARE stmt FROM :qs;
2127 if (sqlca.sqlcode)
2128 return MR_INTERNAL;
2129 EXEC SQL DECLARE curs_gsoc CURSOR FOR stmt;
2130 EXEC SQL OPEN curs_gsoc;
2131
2132 while (1)
2133 {
2134 EXEC SQL FETCH curs_gsoc INTO :subcontainername;
2135 if (sqlca.sqlcode)
2136 break;
2137 (*action)(1, rargv, actarg);
2138 found++;
2139 }
2140
2141 EXEC SQL CLOSE curs_gsoc;
2142 if (!found)
2143 return MR_NO_MATCH;
2144 return MR_SUCCESS;
2145}
73155abd 2146
2147int set_container_list(struct query *q, char *argv[], client *cl)
2148{
2149 EXEC SQL BEGIN DECLARE SECTION;
2150 int cnt_id, list_id;
2151 EXEC SQL END DECLARE SECTION;
2152
2153 cnt_id = *(int *)argv[0];
2154 list_id = *(int *)argv[1];
2155
2156 EXEC SQL UPDATE containers SET list_id = :list_id WHERE cnt_id = :cnt_id;
2157 if (dbms_errno)
2158 return mr_errcode;
2159
2160 return MR_SUCCESS;
2161}
Moira, the Athena Service Management system
This page took 0.471809 seconds and 5 git commands to generate.