6 * Copyright (C) 1989 by the Massachusetts Institute of Technology
7 * For copying and distribution information, please see the file
13 static char *rcsid_increment_dc = "$Header$";
17 #include <mit-copyright.h>
20 #include "mr_server.h"
21 EXEC SQL INCLUDE sqlca;
31 EXEC SQL WHENEVER SQLERROR CALL ingerr;
33 /* structures to save before args */
34 static char beforeb[MAXARGC][ARGLEN];
35 static char *before[MAXARGC];
36 EXEC SQL BEGIN DECLARE SECTION;
37 char *barg0, *barg1, *barg2, *barg3, *barg4;
38 char *barg5, *barg6, *barg7, *barg8, *barg9;
39 char *barg10, *barg11, *barg12, *barg13, *barg14;
40 EXEC SQL END DECLARE SECTION;
42 static char *beforetable;
44 /* structures to save after args */
45 static char afterb[MAXARGC][ARGLEN];
46 static char *after[MAXARGC];
47 EXEC SQL BEGIN DECLARE SECTION;
48 char *aarg0, *aarg1, *aarg2, *aarg3, *aarg4;
49 char *aarg5, *aarg6, *aarg7, *aarg8, *aarg9;
50 char *aarg10, *aarg11, *aarg12, *aarg13, *aarg14;
51 EXEC SQL END DECLARE SECTION;
54 /* structures to save entire sets of incremental changes */
55 struct save_queue *incremental_sq = NULL;
56 struct save_queue *incremental_exec = NULL;
71 for (i = 0; i < MAXARGC; i++) {
72 before[i] = &beforeb[i][0];
73 after[i] = &afterb[i][0];
105 if (incremental_sq == NULL)
106 incremental_sq = sq_create();
107 if (incremental_exec == NULL)
108 incremental_exec = sq_create();
112 incremental_before(table, qual, argv)
114 EXEC SQL BEGIN DECLARE SECTION;
116 EXEC SQL END DECLARE SECTION;
119 EXEC SQL BEGIN DECLARE SECTION;
121 EXEC SQL END DECLARE SECTION;
123 char buffer[512], *name;
127 if (!strcmp(table, "users")) {
128 EXEC SQL SELECT u.login, CHAR(u.uid), u.shell, u.last, u.first, u.middle,
129 CHAR(u.status), u.clearid, u.type
130 INTO :barg0, :barg1, :barg2, :barg3, :barg4, :barg5, :barg6,
132 FROM users u WHERE :qual;
134 } else if (!strcmp(table, "machine")) {
135 EXEC SQL SELECT m.name, m.vendor INTO :barg0, :barg1 FROM machine m
138 } else if (!strcmp(table, "cluster")) {
139 EXEC SQL SELECT c.name, c.description, c.location
140 INTO :barg0, :barg1, :barg2
141 FROM cluster c WHERE :qual;
143 } else if (!strcmp(table, "mcmap")) {
144 strcpy(barg0, argv[0]);
145 strcpy(barg1, argv[1]);
147 } else if (!strcmp(table, "svc")) {
148 strcpy(barg0, argv[0]);
149 strcpy(barg1, argv[1]);
150 strcpy(barg2, argv[2]);
152 } else if (!strcmp(table, "filesys")) {
153 EXEC SQL SELECT fs.label, fs.type, CHAR(fs.mach_id), fs.name,
154 fs.mount, fs.access, fs.comments, CHAR(fs.owner), CHAR(fs.owners),
155 CHAR(fs.createflg), fs.lockertype
156 INTO :barg0, :barg1, :barg2, :barg3, :barg4, :barg5, :barg6,
157 :barg7, :barg8, :barg9, :barg10
158 FROM filesys fs WHERE :qual;
161 id_to_name(id, "MACHINE", &name);
164 id_to_name(id, "USER", &name);
167 id_to_name(id, "LIST", &name);
171 } else if (!strcmp(table, "quota")) {
173 strcpy(barg1, argv[1]);
175 sprintf(buffer, "%s AND fs.filsys_id = q.filsys_id", qual);
177 EXEC SQL SELECT CHAR(q.quota), fs.name INTO :barg3, :barg4
178 FROM quota q, filesys fs WHERE :qual;
180 } else if (!strcmp(table, "list")) {
181 EXEC SQL SELECT l.name, CHAR(l.active), CHAR(l.publicflg),
182 CHAR(l.hidden), CHAR(l.maillist), CHAR(l.grouplist), CHAR(l.gid),
183 l.acl_type, CHAR(l.acl_id), l.description
184 INTO :barg0, :barg1, :barg2, :barg3, :barg4, :barg5, :barg6,
185 :barg7, :barg8, :barg9
186 FROM list l WHERE :qual;
188 } else if (!strcmp(table, "members")) {
190 EXEC SQL SELECT CHAR(active), CHAR(publicflg), CHAR(hidden),
191 CHAR(maillist), CHAR(grouplist), CHAR(gid)
192 INTO :barg3, :barg4, :barg5, :barg6, :barg7, :barg8
193 FROM list WHERE list_id = :id;
195 id_to_name(id, "LIST", &name);
197 strcpy(barg1, argv[1]);
200 if (!strcmp(barg1, "USER")) {
201 id_to_name(id, barg1, &name);
202 EXEC SQL SELECT CHAR(status) INTO :barg9 FROM users
205 } else if (!strcmp(barg1, "LIST")) {
206 id_to_name(id, barg1, &name);
207 } else if (!strcmp(barg1, "STRING")) {
208 id_to_name(id, barg1, &name);
209 } else if (!strcmp(barg1, "KERBEROS")) {
210 id_to_name(id, "STRING", &name);
215 com_err(whoami, 0, "unknown table in incremental_before"); */
219 incremental_clear_before()
224 incremental_clear_after()
226 incremental_after("clear", 0);
231 incremental_after(table, qual, argv)
233 EXEC SQL BEGIN DECLARE SECTION;
235 EXEC SQL END DECLARE SECTION;
238 char buffer[2048], *name;
239 EXEC SQL BEGIN DECLARE SECTION;
241 EXEC SQL END DECLARE SECTION;
245 if (!strcmp(table, "users")) {
246 EXEC SQL SELECT u.login, CHAR(u.uid), u.shell, u.last, u.first,
247 u.middle, CHAR(u.status), u.clearid, u.type
248 INTO :aarg0, :aarg1, :aarg2, :aarg3, :aarg4, :aarg5,
249 :aarg6, :aarg7, :aarg8
250 FROM users u WHERE :qual;
252 } else if (!strcmp(table, "machine")) {
253 EXEC SQL SELECT m.name, m.vendor INTO :aarg0, :aarg1
254 FROM machine m WHERE :qual;
256 } else if (!strcmp(table, "cluster")) {
257 EXEC SQL SELECT c.name, c.description, c.location
258 INTO :aarg0, :aarg1, :aarg2
259 FROM cluster c WHERE :qual;
261 } else if (!strcmp(table, "mcmap")) {
262 strcpy(aarg0, argv[0]);
263 strcpy(aarg1, argv[1]);
265 } else if (!strcmp(table, "svc")) {
266 strcpy(aarg0, argv[0]);
267 strcpy(aarg1, argv[1]);
268 strcpy(aarg2, argv[2]);
270 } else if (!strcmp(table, "filesys")) {
271 EXEC SQL SELECT CHAR(fs.label), fs.type, CHAR(fs.mach_id), fs.name,
272 fs.mount, fs.access, fs.comments, CHAR(fs.owner), CHAR(fs.owners),
273 CHAR(fs.createflg), fs.lockertype
274 INTO :aarg0, :aarg1, :aarg2, :aarg3, :aarg4, :aarg5, :aarg6,
275 :aarg7, :aarg8, :aarg9, :aarg10
276 FROM filesys fs WHERE :qual;
279 id_to_name(id, "MACHINE", &name);
282 id_to_name(id, "USER", &name);
285 id_to_name(id, "LIST", &name);
289 } else if (!strcmp(table, "quota")) {
291 strcpy(aarg1, argv[1]);
293 sprintf(buffer, "%s and fs.filsys_id = q.filsys_id and q.type = '%s'",
296 EXEC SQL SELECT CHAR(q.quota), fs.name INTO :aarg3, :aarg4
297 FROM quota q, filesys fs WHERE :qual;
299 } else if (!strcmp(table, "list")) {
300 EXEC SQL SELECT l.name, CHAR(l.active), CHAR(l.publicflg),
301 CHAR(l.hidden), CHAR(l.maillist), CHAR(l.grouplist), CHAR(l.gid),
302 l.acl_type, CHAR(l.acl_id), l.description
303 INTO :aarg0, :aarg1, :aarg2, :aarg3, :aarg4, :aarg5, :aarg6,
304 :aarg7, :aarg8, :aarg9
305 FROM list l WHERE :qual;
307 } else if (!strcmp(table, "members")) {
309 EXEC SQL SELECT CHAR(active), CHAR(publicflg), CHAR(hidden),
310 CHAR(maillist), CHAR(grouplist), CHAR(gid)
311 INTO :aarg3, :aarg4, :aarg5, :aarg6, :aarg7, :aarg8
312 FROM list WHERE list_id = :id;
314 id_to_name(id, "LIST", &name);
316 strcpy(aarg1, argv[1]);
319 if (!strcmp(aarg1, "USER")) {
320 id_to_name(id, aarg1, &name);
321 EXEC SQL SELECT CHAR(status) INTO :aarg9 FROM users
324 } else if (!strcmp(aarg1, "LIST")) {
325 id_to_name(id, aarg1, &name);
326 } else if (!strcmp(aarg1, "STRING")) {
327 id_to_name(id, aarg1, &name);
328 } else if (!strcmp(aarg1, "KERBEROS")) {
329 id_to_name(id, "STRING", &name);
333 } else if (!strcmp(table, "clear")) {
337 com_err(whoami, 0, "unknown table in incremental_after"); */
339 iu = (struct iupdate *) malloc(sizeof(struct iupdate));
340 iu->table = strsave(table);
341 iu->beforec = beforec;
342 iu->before = copy_argv(before, beforec);
344 iu->after = copy_argv(after, afterc);
345 sq_save_data(incremental_sq, iu);
348 sprintf(buffer, "INCREMENTAL(%s, [", table);
349 for (i = 0; i < beforec; i++) {
351 strcat(buffer, strtrim(before[0]));
353 strcat(buffer, ", ");
354 strcat(buffer, strtrim(before[i]));
357 strcat(buffer, "], [");
358 for (i = 0; i < afterc; i++) {
360 strcat(buffer, strtrim(after[0]));
362 strcat(buffer, ", ");
363 strcat(buffer, strtrim(after[i]));
366 strcat(buffer, "])");
367 com_err(whoami, 0, buffer);
372 /* Called when the current transaction is committed to start any queued
373 * incremental updates. This caches the update table the first time it
378 struct inc_cache *next;
386 static int inited = 0;
387 static struct inc_cache *cache;
389 EXEC SQL BEGIN DECLARE SECTION;
390 char tab[17], serv[17];
391 EXEC SQL END DECLARE SECTION;
397 EXEC SQL DECLARE inc CURSOR FOR SELECT tablename, service FROM incremental;
400 EXEC SQL FETCH inc INTO :tab, :serv;
401 if (sqlca.sqlcode != 0) break;
402 c = (struct inc_cache *)malloc(sizeof(struct inc_cache));
404 c->table = strsave(strtrim(tab));
405 c->service = strsave(strtrim(serv));
409 EXEC SQL COMMIT WORK;
412 while (sq_remove_data(incremental_sq, &iu)) {
413 for (c = cache; c; c = c->next) {
414 if (!strcmp(c->table, iu->table)) {
415 iu->service = c->service;
416 sq_save_data(incremental_exec, iu);
420 if (inc_running == 0)
428 char *argv[MAXARGC * 2 + 4], cafter[3], cbefore[3], prog[BUFSIZ];
431 if (incremental_exec == NULL)
434 if (sq_empty(incremental_exec) ||
435 (inc_running && now - inc_started < INC_TIMEOUT))
439 com_err(whoami, 0, "incremental timeout on pid %d", inc_pid);
441 sq_remove_data(incremental_exec, &iu);
443 sprintf(cbefore, "%d", iu->beforec);
445 sprintf(cafter, "%d", iu->afterc);
447 for (i = 0; i < iu->beforec; i++)
448 argv[4 + i] = iu->before[i];
449 for (i = 0; i < iu->afterc; i++)
450 argv[4 + iu->beforec + i] = iu->after[i];
452 sprintf(prog, "%s/%s.incr", BIN_DIR, iu->service);
454 com_err(whoami, 0, "forking %s", prog);
457 argv[4 + iu->beforec + iu->afterc] = 0;
464 com_err(whoami, 0, "Failed to start incremental update");
471 free_argv(iu->before, iu->beforec);
472 free_argv(iu->after, iu->afterc);
479 /* Called when the current transaction is aborted to throw away any queued
480 * incremental updates
487 while (sq_get_data(incremental_sq, &iu)) {
488 free_argv(iu->before, iu->beforec);
489 free_argv(iu->after, iu->afterc);
493 sq_destroy(incremental_sq);
494 incremental_sq = sq_create();
498 char **copy_argv(argv, argc)
502 char **ret = (char **)malloc(sizeof(char *) * argc);
504 ret[argc] = strsave(strtrim(argv[argc]));
508 free_argv(argv, argc)