]> andersk Git - moira.git/blob - server/qfollow.pc
Modify queries that effect the services table (asvc, dsvc, gvc).
[moira.git] / server / qfollow.pc
1 /* $Id$
2  *
3  * Query followup routines
4  *
5  * Copyright (C) 1987-1998 by the Massachusetts Institute of Technology
6  * For copying and distribution information, please see the file
7  * <mit-copyright.h>.
8  *
9  */
10
11 #include <mit-copyright.h>
12 #include "mr_server.h"
13 #include "query.h"
14 #include "qrtn.h"
15
16 #include <errno.h>
17 #include <ctype.h>
18 #include <stdlib.h>
19 #include <string.h>
20
21 EXEC SQL INCLUDE sqlca;
22
23 RCSID("$Header$");
24
25 extern char *whoami, *table_name[];
26 extern int dbms_errno, mr_errcode;
27
28 EXEC SQL BEGIN DECLARE SECTION;
29 extern char stmt_buf[];
30 EXEC SQL END DECLARE SECTION;
31
32 EXEC SQL WHENEVER SQLERROR DO dbmserr();
33
34
35 /* FOLLOWUP ROUTINES */
36
37 /* generic set_modtime routine.  This takes the table id from the query,
38  * and will update the modtime, modby, and modwho fields in the entry in
39  * the table whose name field matches argv[0].
40  */
41
42 int set_modtime(struct query *q, char *argv[], client *cl)
43 {
44   char *name, *entity, *table;
45   int who;
46
47   entity = cl->entity;
48   who = cl->client_id;
49   table = table_name[q->rtable];
50   name = argv[0];
51
52   sprintf(stmt_buf, "UPDATE %s SET modtime = SYSDATE, modby = %d, "
53           "modwith = '%s' WHERE name = '%s'", table, who, entity, name);
54   EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
55
56   return MR_SUCCESS;
57 }
58
59 /* generic set_modtime_by_id routine.  This takes the table id from
60  * the query, and the id name from the validate record,
61  * and will update the modtime, modby, and modwho fields in the entry in
62  * the table whose id matches argv[0].
63  */
64
65 int set_modtime_by_id(struct query *q, char *argv[], client *cl)
66 {
67   char *entity, *table, *id_name;
68   int who, id;
69
70   entity = cl->entity;
71   who = cl->client_id;
72   table = table_name[q->rtable];
73   id_name = q->validate->object_id;
74
75   id = *(int *)argv[0];
76   sprintf(stmt_buf, "UPDATE %s SET modtime = SYSDATE, modby = %d, "
77           "modwith = '%s' WHERE %s = %d", table, who, entity, id_name, id);
78   EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
79   return MR_SUCCESS;
80 }
81
82
83 /* Sets the finger modtime on a user record.  The users_id will be in argv[0].
84  */
85
86 int set_finger_modtime(struct query *q, char *argv[], client *cl)
87 {
88   EXEC SQL BEGIN DECLARE SECTION;
89   int users_id, who;
90   char *entity;
91   EXEC SQL END DECLARE SECTION;
92
93   entity = cl->entity;
94   who = cl->client_id;
95   users_id = *(int *)argv[0];
96
97   EXEC SQL UPDATE users SET fmodtime = SYSDATE, fmodby = :who,
98     fmodwith = :entity WHERE users_id = :users_id;
99
100   return MR_SUCCESS;
101 }
102
103
104 /* Sets the pobox modtime on a user record.  The users_id will be in argv[0].
105  */
106
107 int set_pobox_modtime(struct query *q, char *argv[], client *cl)
108 {
109   EXEC SQL BEGIN DECLARE SECTION;
110   int users_id, who;
111   char *entity;
112   EXEC SQL END DECLARE SECTION;
113
114   entity = cl->entity;
115   who = cl->client_id;
116   users_id = *(int *)argv[0];
117
118   EXEC SQL UPDATE users SET pmodtime = SYSDATE, pmodby = :who,
119     pmodwith = :entity WHERE users_id = :users_id;
120
121   return MR_SUCCESS;
122 }
123
124
125 /* Like set_modtime, but uppercases the name first.
126  */
127
128 int set_uppercase_modtime(struct query *q, char *argv[], client *cl)
129 {
130   char *name, *entity, *table;
131   int who;
132
133   entity = cl->entity;
134   who = cl->client_id;
135   table = table_name[q->rtable];
136   name = argv[0];
137
138   sprintf(stmt_buf, "UPDATE %s SET modtime = SYSDATE, modby = %d, "
139           "modwith = '%s' WHERE name = UPPER('%s')", table, who, entity, name);
140   EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
141
142   return MR_SUCCESS;
143 }
144
145
146 /* Sets the modtime on the machine whose mach_id is in argv[0].  This routine
147  * is necessary for add_machine_to_cluster becuase the table that query
148  * operates on is "mcm", not "machine".
149  */
150
151 int set_mach_modtime_by_id(struct query *q, char *argv[], client *cl)
152 {
153   EXEC SQL BEGIN DECLARE SECTION;
154   char *entity;
155   int who, id;
156   EXEC SQL END DECLARE SECTION;
157
158   entity = cl->entity;
159   who = cl->client_id;
160   id = *(int *)argv[0];
161   EXEC SQL UPDATE machine SET modtime = SYSDATE, modby = :who,
162     modwith = :entity WHERE mach_id = :id;
163
164   return MR_SUCCESS;
165 }
166
167
168 /* Sets the modtime on the cluster whose mach_id is in argv[0].  This routine
169  * is necessary for add_cluster_data and delete_cluster_data becuase the
170  * table that query operates on is "svc", not "cluster".
171  */
172
173 int set_cluster_modtime_by_id(struct query *q, char *argv[], client *cl)
174 {
175   EXEC SQL BEGIN DECLARE SECTION;
176   char *entity;
177   int who, id;
178   EXEC SQL END DECLARE SECTION;
179
180   entity = cl->entity;
181   who = cl->client_id;
182
183   id = *(int *)argv[0];
184   EXEC SQL UPDATE clusters SET modtime = SYSDATE, modby = :who,
185     modwith = :entity WHERE clu_id = :id;
186   return MR_SUCCESS;
187 }
188
189
190 /* sets the modtime on the serverhost where the service name is in argv[0]
191  * and the mach_id is in argv[1].
192  */
193
194 int set_serverhost_modtime(struct query *q, char *argv[], client *cl)
195 {
196   EXEC SQL BEGIN DECLARE SECTION;
197   char *entity, *serv;
198   int who, id;
199   EXEC SQL END DECLARE SECTION;
200
201   entity = cl->entity;
202   who = cl->client_id;
203
204   serv = argv[0];
205   id = *(int *)argv[1];
206   EXEC SQL UPDATE serverhosts
207     SET modtime = SYSDATE, modby = :who, modwith = :entity
208     WHERE service = :serv AND mach_id = :id;
209   return MR_SUCCESS;
210 }
211
212
213 /* sets the modtime on the nfsphys where the mach_id is in argv[0] and the
214  * directory name is in argv[1].
215  */
216
217 int set_nfsphys_modtime(struct query *q, char *argv[], client *cl)
218 {
219   EXEC SQL BEGIN DECLARE SECTION;
220   char *entity, *dir;
221   int who, id;
222   EXEC SQL END DECLARE SECTION;
223
224   entity = cl->entity;
225   who = cl->client_id;
226
227   id = *(int *)argv[0];
228   dir = argv[1];
229   EXEC SQL UPDATE nfsphys SET modtime = SYSDATE, modby = :who,
230     modwith = :entity WHERE dir = :dir AND mach_id = :id;
231   return MR_SUCCESS;
232 }
233
234
235 /* sets the modtime on a filesystem, where argv[0] contains the filesys
236  * label.
237  */
238
239 int set_filesys_modtime(struct query *q, char *argv[], client *cl)
240 {
241   EXEC SQL BEGIN DECLARE SECTION;
242   char *label, *entity;
243   int who;
244   extern int _var_phys_id;
245   EXEC SQL END DECLARE SECTION;
246
247   entity = cl->entity;
248   who = cl->client_id;
249
250   label = argv[0];
251   if (!strcmp(q->shortname, "ufil"))
252     label = argv[1];
253
254   EXEC SQL UPDATE filesys SET modtime = SYSDATE, modby = :who,
255     modwith = :entity, phys_id = :_var_phys_id
256     WHERE label = :label;
257   return MR_SUCCESS;
258 }
259
260
261 /* sets the modtime on a zephyr class, where argv[0] contains the class
262  * name.
263  */
264
265 int set_zephyr_modtime(struct query *q, char *argv[], client *cl)
266 {
267   EXEC SQL BEGIN DECLARE SECTION;
268   char *class, *entity;
269   int who;
270   EXEC SQL END DECLARE SECTION;
271
272   entity = cl->entity;
273   who = cl->client_id;
274
275   class = argv[0];
276
277   EXEC SQL UPDATE zephyr SET modtime = SYSDATE, modby = :who,
278     modwith = :entity WHERE class = :class;
279
280   return MR_SUCCESS;
281 }
282
283 /* sets the modtime on an entry in services table, where argv[0] contains
284  * the service name.
285  */
286
287 int set_service_modtime(struct query *q, char *argv[], client *cl)
288 {
289   EXEC SQL BEGIN DECLARE SECTION;
290   char *service, *protocol, *entity;
291   int who;
292   EXEC SQL END DECLARE SECTION;
293
294   entity = cl->entity;
295   who = cl->client_id; 
296
297   service = argv[0];
298   protocol = argv[1];
299
300   EXEC SQL UPDATE services SET modtime = SYSDATE, modby = :who,
301     modwith = :entity WHERE name = :service AND protocol = :protocol;
302
303   return MR_SUCCESS;
304 }
305
306 /* fixes the modby field.  This will be the second to last thing in the
307  * argv, the argv length is determined from the query structure.  It is
308  * passed as a pointer to an integer.  This will either turn it into a
309  * username, or # + the users_id.
310  */
311 int followup_fix_modby(struct query *q, struct save_queue *sq,
312                        struct validate *v, int (*action)(int, char *[], void *),
313                        void *actarg, client *cl)
314 {
315   int i, j;
316   char **argv;
317   int id, status;
318
319   i = q->vcnt - 2;
320   while (sq_get_data(sq, &argv))
321     {
322       id = atoi(argv[i]);
323       if (id > 0)
324         status = id_to_name(id, USERS_TABLE, &argv[i]);
325       else
326         status = id_to_name(-id, STRINGS_TABLE, &argv[i]);
327       if (status && status != MR_NO_MATCH)
328         return status;
329       (*action)(q->vcnt, argv, actarg);
330       for (j = 0; j < q->vcnt; j++)
331         free(argv[j]);
332       free(argv);
333     }
334   sq_destroy(sq);
335   return MR_SUCCESS;
336 }
337
338 /**
339  ** followup_ausr - add finger and pobox entries, set_user_modtime
340  **
341  ** Inputs:
342  **     argv[0] - login (add_user)
343  **     argv[U_LAST] - last name
344  **     argv[U_FIRST] - first name
345  **     argv[U_MIDDLE] - middle name
346  **
347  **/
348
349 int followup_ausr(struct query *q, char *argv[], client *cl)
350 {
351   EXEC SQL BEGIN DECLARE SECTION;
352   int who, status;
353   char *login, *entity, *name;
354   char fullname[USERS_FIRST_SIZE + USERS_MIDDLE_SIZE + USERS_LAST_SIZE];
355   EXEC SQL END DECLARE SECTION;
356
357   /* build fullname */
358   if (strlen(argv[U_FIRST]) && strlen(argv[U_MIDDLE]))
359     sprintf(fullname, "%s %s %s", argv[U_FIRST], argv[U_MIDDLE], 
360             argv[U_LAST]);
361   else if (strlen(argv[U_FIRST]))
362     sprintf(fullname, "%s %s", argv[U_FIRST], argv[U_LAST]);
363   else
364     sprintf(fullname, "%s", argv[U_LAST]);
365
366   login = argv[0];
367   who = cl->client_id;
368   entity = cl->entity;
369
370   /* create finger entry, pobox & set modtime on user */
371   EXEC SQL UPDATE users
372     SET modtime = SYSDATE, modby = :who, modwith = :entity,
373     fullname = NVL(:fullname, CHR(0)), affiliation = type,
374     fmodtime = SYSDATE, fmodby = :who, fmodwith = :entity,
375     potype = 'NONE', pmodtime = SYSDATE, pmodby = :who, pmodwith = :entity
376     WHERE login = :login;
377
378   return MR_SUCCESS;
379 }
380
381 /* followup_gpob: fixes argv[2] and argv[3] based on the pobox type.
382  * Then completes the upcall to the user.
383  *
384  * argv[2] is the users_id on input and should be converted to the
385  * pobox name on output. argv[3] is empty on input and should be
386  * converted to an email address on output.
387  */
388
389 int followup_gpob(struct query *q, struct save_queue *sq, struct validate *v,
390                   int (*action)(int, char *[], void *), void *actarg,
391                   client *cl)
392 {
393   char **argv;
394   char *ptype, *p;
395   int mid, sid, status, i;
396   EXEC SQL BEGIN DECLARE SECTION;
397   int users_id, pid, iid, bid;
398   char mach[MACHINE_NAME_SIZE], fs[FILESYS_LABEL_SIZE];
399   char str[STRINGS_STRING_SIZE];
400   EXEC SQL END DECLARE SECTION;
401
402   /* for each row */
403   while (sq_get_data(sq, &argv))
404     {
405       mr_trim_args(4, argv);
406       ptype = argv[1];
407       users_id = atoi(argv[2]);
408
409       EXEC SQL SELECT pop_id, imap_id, box_id INTO :pid, :iid, :bid
410         FROM users WHERE users_id = :users_id;
411       if (sqlca.sqlcode)
412         return MR_USER;
413
414       if (ptype[0] == 'S')
415         {
416           /* SMTP or SPLIT */
417           EXEC SQL SELECT string INTO :str FROM strings
418             WHERE string_id = :bid;
419           if (sqlca.sqlcode)
420             return MR_STRING;
421
422           /* If SMTP, don't bother fetching IMAP and POP boxes. */
423           if (ptype[1] == 'M')
424             pid = iid = 0;
425         }
426       if (iid)
427         {
428           /* IMAP, or SPLIT with IMAP */
429           EXEC SQL SELECT f.label, m.name INTO :fs, :mach
430             FROM filesys f, machine m
431             WHERE f.filsys_id = :iid AND f.mach_id = m.mach_id;
432           if (sqlca.sqlcode)
433             return MR_FILESYS;
434         }
435       if (pid)
436         {
437           /* POP, or SPLIT with POP */
438           EXEC SQL SELECT m.name INTO :mach FROM machine m, users u
439             WHERE u.users_id = :users_id AND u.pop_id = m.mach_id;
440           if (sqlca.sqlcode)
441             return MR_MACHINE;
442         }
443
444       free(argv[2]);
445       free(argv[3]);
446
447       /* Now assemble the right answer. */
448       if (!strcmp(ptype, "POP"))
449         {
450           argv[2] = xstrdup(strtrim(mach));
451           argv[3] = xmalloc(strlen(argv[0]) + strlen(argv[2]) + 2);
452           sprintf(argv[3], "%s@%s", argv[0], argv[2]);
453         }
454       else if (!strcmp(ptype, "SMTP"))
455         {
456           argv[2] = xstrdup(strtrim(str));
457           argv[3] = xstrdup(str);
458         }
459       else if (!strcmp(ptype, "IMAP"))
460         {
461           argv[2] = xstrdup(strtrim(fs));
462           argv[3] = xmalloc(strlen(argv[0]) + strlen(strtrim(mach)) + 2);
463           sprintf(argv[3], "%s@%s", argv[0], mach);
464         }
465       else if (!strcmp(ptype, "SPLIT"))
466         {
467           argv[2] = xstrdup(strtrim(str));
468           argv[3] = xmalloc(strlen(argv[0]) + strlen(strtrim(mach)) +
469                             strlen(str) + 4);
470           sprintf(argv[3], "%s@%s, %s", argv[0], mach, str);
471         }
472       else /* ptype == "NONE" */
473         goto skip;
474
475       if (!strcmp(q->shortname, "gpob"))
476         {
477           sid = atoi(argv[5]);
478           if (sid > 0)
479             status = id_to_name(sid, USERS_TABLE, &argv[5]);
480           else
481             status = id_to_name(-sid, STRINGS_TABLE, &argv[5]);
482           if (status && status != MR_NO_MATCH)
483             return status;
484         }
485
486       (*action)(q->vcnt, argv, actarg);
487     skip:
488       /* free saved data */
489       for (i = 0; i < q->vcnt; i++)
490         free(argv[i]);
491       free(argv);
492     }
493
494   sq_destroy(sq);
495   return MR_SUCCESS;
496 }
497
498 /* Fix an ace_name, based on its type. */
499
500 static int fix_ace(char *type, char **name)
501 {
502   int id = atoi(*name);
503
504   if (!strcmp(type, "LIST"))
505     return id_to_name(id, LIST_TABLE, name);
506   else if (!strcmp(type, "USER"))
507     return id_to_name(id, USERS_TABLE, name);
508   else if (!strcmp(type, "KERBEROS"))
509     return id_to_name(id, STRINGS_TABLE, name);
510   else
511     {
512       free(*name);
513       if (!strcmp(type, "NONE"))
514         *name = xstrdup("NONE");
515       else
516         *name = xstrdup("???");
517       return MR_SUCCESS;
518     }
519 }
520
521
522 /* followup_gsnt: fix the ace_name and modby */
523
524 int followup_gsnt(struct query *q, struct save_queue *sq, struct validate *v,
525                   int (*action)(int, char *[], void *), void *actarg,
526                   client *cl)
527 {
528   char **argv;
529   int status;
530
531   while (sq_get_data(sq, &argv))
532     {
533       mr_trim_args(q->vcnt, argv);
534
535       status = fix_ace(argv[7], &argv[8]);
536       if (status && status != MR_NO_MATCH)
537         return status;
538     }
539
540   return followup_fix_modby(q, sq, v, action, actarg, cl);
541 }
542
543
544 /* followup_ghst: fix the ace_name, strings and modby */
545
546 int followup_ghst(struct query *q, struct save_queue *sq, struct validate *v,
547                   int (*action)(int, char *[], void *), void *actarg,
548                   client *cl)
549 {
550   char **argv;
551   int id, status;
552
553   while (sq_get_data(sq, &argv))
554     {
555       mr_trim_args(q->vcnt, argv);
556
557       id = atoi(argv[13]);
558       status = id_to_name(id, STRINGS_TABLE, &argv[13]);
559       if (status)
560         return status;
561       id = atoi(argv[14]);
562       status = id_to_name(id, STRINGS_TABLE, &argv[14]);
563       if (status)
564         return status;
565       id = atoi(argv[16]);
566       if (id < 0)
567         status = id_to_name(-id, STRINGS_TABLE, &argv[16]);
568       else
569         status = id_to_name(id, USERS_TABLE, &argv[16]);
570       if (status && status != MR_NO_MATCH)
571         return status;
572
573       status = fix_ace(argv[11], &argv[12]);
574       if (status && status != MR_NO_MATCH)
575         return status;
576     }
577
578   return followup_fix_modby(q, sq, v, action, actarg, cl);
579 }
580
581
582 /* followup_glin: fix the ace_name, modace_name, expiration, and modby */
583
584 int followup_glin(struct query *q, struct save_queue *sq, struct validate *v,
585                   int (*action)(int, char *[], void *), void *actarg,
586                   client *cl)
587 {
588   char **argv;
589   int id, i, idx, status;
590
591   idx = 7;
592   if (!strcmp(q->shortname, "glin")  && q->version > 2)
593     idx = 8;
594   if (!strcmp(q->shortname, "gsin"))
595     idx = 11;
596
597   while (sq_get_data(sq, &argv))
598     {
599       mr_trim_args(q->vcnt, argv);
600
601       status = fix_ace(argv[idx], &argv[idx + 1]);
602       if (status && status != MR_NO_MATCH)
603         return status;
604
605       if (!strcmp(q->shortname, "glin") && atoi(argv[6]) == -1)
606         {
607           argv[6] = xrealloc(argv[6], strlen(UNIQUE_GID) + 1);
608           strcpy(argv[6], UNIQUE_GID);
609         }
610     }
611
612   return followup_fix_modby(q, sq, v, action, actarg, cl);
613 }
614
615 int followup_gpsv(struct query *q, struct save_queue *sq, struct validate *v,
616                   int (*action)(int, char *[], void *), void *actarg,
617                   client *cl)
618 {
619   char **argv;
620   int status;
621
622   while (sq_get_data(sq, &argv))
623     {
624       mr_trim_args(q->vcnt, argv);
625
626       status = fix_ace(argv[PRINTSERVER_OWNER_TYPE],
627                        &argv[PRINTSERVER_OWNER_NAME]);
628       if (status && status != MR_NO_MATCH)
629         return status;
630     }
631
632   return followup_fix_modby(q, sq, v, action, actarg, cl);
633 }
634   
635
636 /* followup_gqot: Fix the entity name, directory name & modby fields
637  *   argv[0] = filsys_id
638  *   argv[1] = type
639  *   argv[2] = entity_id
640  *   argv[3] = ascii(quota)
641  */
642
643 int followup_gqot(struct query *q, struct save_queue *sq, struct validate *v,
644                   int (*action)(int, char *[], void *), void *actarg,
645                   client *cl)
646 {
647   int j;
648   char **argv;
649   EXEC SQL BEGIN DECLARE SECTION;
650   int id;
651   char *name, *label;
652   EXEC SQL END DECLARE SECTION;
653   int status, idx;
654
655   if (!strcmp(q->name, "get_quota") ||
656       !strcmp(q->name, "get_quota_by_filesys"))
657     idx = 4;
658   else
659     idx = 3;
660
661   while (sq_get_data(sq, &argv))
662     {
663       if (idx == 4)
664         {
665           switch (argv[1][0])
666             {
667             case 'U':
668               status = id_to_name(atoi(argv[2]), USERS_TABLE, &argv[2]);
669               break;
670             case 'G':
671             case 'L':
672               status = id_to_name(atoi(argv[2]), LIST_TABLE, &argv[2]);
673               break;
674             case 'A':
675               free(argv[2]);
676               argv[2] = xstrdup("system:anyuser");
677               break;
678             default:
679               id = atoi(argv[2]);
680               argv[2] = xmalloc(8);
681               sprintf(argv[2], "%d", id);
682             }
683         }
684       id = atoi(argv[idx]);
685       free(argv[idx]);
686       argv[idx] = xmalloc(id ? NFSPHYS_DIR_SIZE : FILESYS_NAME_SIZE);
687       name = argv[idx];
688       name[0] = '\0';
689       if (id == 0)
690         {
691           label = argv[0];
692           EXEC SQL SELECT name INTO :name FROM filesys
693             WHERE label = :label;
694         }
695       else
696         {
697           EXEC SQL SELECT dir INTO :name FROM nfsphys
698             WHERE nfsphys_id = :id;
699         }
700       if (sqlca.sqlerrd[2] != 1)
701         sprintf(argv[idx], "#%d", id);
702
703       id = atoi(argv[idx + 3]);
704       if (id > 0)
705         status = id_to_name(id, USERS_TABLE, &argv[idx + 3]);
706       else
707         status = id_to_name(-id, STRINGS_TABLE, &argv[idx + 3]);
708       if (status && status != MR_NO_MATCH)
709         return status;
710       (*action)(q->vcnt, argv, actarg);
711       for (j = 0; j < q->vcnt; j++)
712         free(argv[j]);
713       free(argv);
714     }
715   sq_destroy(sq);
716   return MR_SUCCESS;
717 }
718
719
720 /* followup_aqot: Add allocation to nfsphys after creating quota.
721  *   argv[0] = filsys_id
722  *   argv[1] = type if "add_quota" or "update_quota"
723  *   argv[2 or 1] = id
724  *   argv[3 or 2] = ascii(quota)
725  */
726
727 int followup_aqot(struct query *q, char *argv[], client *cl)
728 {
729   EXEC SQL BEGIN DECLARE SECTION;
730   int quota, id, fs, who, physid, table;
731   char *entity, *qtype, *tname;
732   EXEC SQL END DECLARE SECTION;
733   char incr_qual[60];
734   char *incr_argv[2];
735   int status;
736
737   table = q->rtable;
738   tname = table_name[table];
739   fs = *(int *)argv[0];
740   EXEC SQL SELECT phys_id INTO :physid FROM filesys
741     WHERE filsys_id = :fs;
742   if (dbms_errno)
743     return mr_errcode;
744
745   if (!strcmp(q->shortname, "aqot") || !strcmp(q->shortname, "uqot"))
746     {
747       qtype = argv[1];
748       id = *(int *)argv[2];
749       quota = atoi(argv[3]);
750       sprintf(incr_qual, "q.filsys_id = %d", fs);
751     }
752   else
753     {
754       qtype = "USER";
755       id = *(int *)argv[1];
756       quota = atoi(argv[2]);
757       sprintf(incr_qual, "q.filsys_id = %d AND q.type = '%s' AND "
758               "q.entity_id = %d", fs, qtype, id);
759     }
760
761   /* quota case of incremental_{before|after} only looks at slot 1 */
762   incr_argv[1] = qtype;
763
764   /* Follows one of many possible gross hacks to fix these particular
765    * conflicts between what is possible in the query table and what
766    * is possible in SQL.
767    */
768   if (q->type == APPEND)
769     {
770       incremental_clear_before();
771       EXEC SQL INSERT INTO quota
772         (filsys_id, type, entity_id, quota, phys_id)
773         VALUES (:fs, NVL(:qtype, CHR(0)), :id, :quota, :physid);
774       incremental_after(table, incr_qual, incr_argv);
775     }
776   else
777     {
778       incremental_before(table, incr_qual, incr_argv);
779       EXEC SQL UPDATE quota SET quota = :quota
780         WHERE filsys_id = :fs AND type = :qtype AND entity_id = :id;
781       status = mr_errcode;
782       incremental_after(table, incr_qual, incr_argv);
783     }
784
785   if (dbms_errno)
786     return mr_errcode;
787   flush_name(argv[0], table);
788   if (q->type == APPEND)
789     {
790       EXEC SQL UPDATE tblstats SET appends = appends + 1, modtime = SYSDATE
791         WHERE table_name = :tname;
792     }
793   else
794     {
795       EXEC SQL UPDATE tblstats SET updates = updates + 1, modtime = SYSDATE
796         WHERE table_name = :tname;
797     }
798
799   /* Proceed with original followup */
800   who = cl->client_id;
801   entity = cl->entity;
802
803   EXEC SQL UPDATE quota
804     SET modtime = SYSDATE, modby = :who, modwith = :entity
805     WHERE filsys_id = :fs and type = :qtype and entity_id = :id;
806   EXEC SQL UPDATE nfsphys SET allocated = allocated + :quota
807     WHERE nfsphys_id = :physid;
808   if (dbms_errno)
809     return mr_errcode;
810   return MR_SUCCESS;
811 }
812
813
814 /* Necessitated by the requirement of a correlation name by the incremental
815  * routines, since query table deletes don't provide one.
816  */
817 int followup_dqot(struct query *q, char **argv, client *cl)
818 {
819   char *qtype;
820   int id, fs, table;
821   char *incr_argv[2];
822   EXEC SQL BEGIN DECLARE SECTION;
823   char incr_qual[80], *tname;
824   EXEC SQL END DECLARE SECTION;
825
826   table = q->rtable;
827   tname = table_name[table];
828   fs = *(int *)argv[0];
829   if (!strcmp(q->shortname, "dqot"))
830     {
831       qtype = argv[1];
832       id = *(int *)argv[2];
833     }
834   else
835     {
836       qtype = "USER";
837       id = *(int *)argv[1];
838     }
839   sprintf(incr_qual, "q.filsys_id = %d AND q.type = '%s' AND q.entity_id = %d",
840           fs, qtype, id);
841
842   /* quota case of incremental_{before|after} only looks at slot 1 */
843   incr_argv[1] = qtype;
844
845   incremental_before(table, incr_qual, incr_argv);
846   EXEC SQL DELETE FROM quota q WHERE q.filsys_id = :fs AND q.type = :qtype
847     AND q.entity_id = :id;
848   incremental_clear_after();
849
850   if (dbms_errno)
851     return mr_errcode;
852   flush_name(argv[0], table);
853
854   EXEC SQL UPDATE tblstats SET deletes = deletes + 1, modtime = SYSDATE
855     WHERE table_name = :tname;
856   return MR_SUCCESS;
857 }
858
859 /* followup_gzcl:
860  */
861
862 int followup_gzcl(struct query *q, struct save_queue *sq, struct validate *v,
863                   int (*action)(int, char *[], void *), void *actarg,
864                   client *cl)
865 {
866   int i, status;
867   char **argv;
868
869   while (sq_get_data(sq, &argv))
870     {
871       mr_trim_args(q->vcnt, argv);
872
873       for (i = 1; i < 8; i += 2)
874         {
875           status = fix_ace(argv[i], &argv[i + 1]);
876           if (status && status != MR_NO_MATCH)
877             return status;
878         }
879     }
880
881   return followup_fix_modby(q, sq, v, action, actarg, cl);
882 }
883
884
885 /* followup_gsha:
886  */
887
888 int followup_gsha(struct query *q, struct save_queue *sq, struct validate *v,
889                   int (*action)(int, char *[], void *), void *actarg,
890                   client *cl)
891 {
892   char **argv;
893   int status;
894
895   while (sq_get_data(sq, &argv))
896     {
897       mr_trim_args(q->vcnt, argv);
898
899       status = fix_ace(argv[1], &argv[2]);
900       if (status && status != MR_NO_MATCH)
901         return status;
902     }
903
904   return followup_fix_modby(q, sq, v, action, actarg, cl);
905 }
906
907
908 int _sdl_followup(struct query *q, char *argv[], client *cl)
909 {
910   if (atoi(argv[0]))
911     EXEC SQL ALTER SESSION SET SQL_TRACE TRUE;
912   else
913     EXEC SQL ALTER SESSION SET SQL_TRACE FALSE;
914
915   return MR_SUCCESS;
916 }
917
918
919 int trigger_dcm(struct query *q, char *argv[], client *cl)
920 {
921   pid_t pid;
922   char prog[MAXPATHLEN];
923
924   sprintf(prog, "%s/startdcm", BIN_DIR);
925   pid = vfork();
926   switch (pid)
927     {
928     case 0:
929       execl(prog, "startdcm", 0);
930       exit(1);
931
932     case -1:
933       return errno;
934
935     default:
936       return MR_SUCCESS;
937     }
938 }
This page took 0.116022 seconds and 5 git commands to generate.