]> andersk Git - moira.git/blame - server/qrtn.dc
andersk / moira.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Further changes to prevent INGRES error 40100.
[moira.git] / server / qrtn.dc
CommitLineData
1a41acb7 1/*
2 * $Source$
3 * $Author$
4 * $Header$
b070f8a1 5 *
1a41acb7 6 * Copyright (C) 1987, 1988 by the Massachusetts Institute of Technology
7 * For copying and distribution information, please see the file
8 * <mit-copyright.h>.
9 *
b070f8a1 10 */
11
12#ifndef lint
048b1b94 13static char *rcsid_qrtn_dc = "$Header$";
b070f8a1 14#endif lint
15
16#include <mit-copyright.h>
cc0088db 17#include <string.h>
b070f8a1 18#include "query.h"
19#include "mr_server.h"
048b1b94 20EXEC SQL INCLUDE sqlca; /* SQL Communications Area */
21EXEC SQL INCLUDE sqlda; /* SQL Descriptor Area */
22#include "qrtn.h"
23
c9a214e4 24MR_SQLDA_T *SQLDA;
048b1b94 25EXEC SQL BEGIN DECLARE SECTION;
1741dca0 26int mr_sig_length;
048b1b94 27int idummy;
28char cdummy[MR_CDUMMY_LEN];
29char stmt_buf[MR_STMTBUF_LEN];
30EXEC SQL END DECLARE SECTION;
b070f8a1 31
32char *Argv[16];
33
34int ingres_errno = 0;
35int mr_errcode = 0;
048b1b94 36EXEC SQL BEGIN DECLARE SECTION;
37int query_timeout = 30;
38EXEC SQL END DECLARE SECTION;
b070f8a1 39extern char *whoami;
40extern FILE *journal;
41
1741dca0 42#define INGRES_BAD_DATE1 40206
43#define INGRES_BAD_DATE2 40207
44#define INGRES_DEADLOCK 49900
1b247a36 45#define INGRES_TIMEOUT 39100
45bf7573 46#define INGRES_BAD_COLUMN 30110
47#define INGRES_ASGN_ERR 40204
48#define INGRES_NO_CURSOR 30120
49#define INGRES_NO_STMT 30130
50
048b1b94 51/*
1741dca0 52 * ingerr: Called when Ingres indicates an error.
b070f8a1 53 */
54
c9a214e4 55void ingerr()
b070f8a1 56{
45bf7573 57 EXEC SQL BEGIN DECLARE SECTION;
58 char err_msg[256];
59 EXEC SQL END DECLARE SECTION;
048b1b94 60 ingres_errno = -sqlca.sqlcode;
b070f8a1 61
048b1b94 62 switch (ingres_errno) {
1741dca0 63 case INGRES_BAD_DATE1:
64 case INGRES_BAD_DATE2:
b070f8a1 65 mr_errcode = MR_DATE;
66 break;
1741dca0 67 case INGRES_DEADLOCK:
b070f8a1 68 mr_errcode = MR_DEADLOCK;
69 com_err(whoami, 0, "INGRES deadlock detected");
70 break;
1b247a36 71 case INGRES_TIMEOUT:
72/* May be something other than timeout! #39100 is "Unknown error"
73 * Really should parse the error message enough to decide if it's a timeout */
74 mr_errcode = MR_BUSY;
75 com_err(whoami, 0, "timed out getting lock");
76 break;
77/* These should never come up unless someone breaks the query table */
78 case INGRES_NO_CURSOR:
45bf7573 79 mr_errcode = MR_INTERNAL;
80 com_err(whoami, 0, "Cursor not opened");
81 break;
1b247a36 82 case INGRES_NO_STMT:
45bf7573 83 mr_errcode = MR_INTERNAL;
84 com_err(whoami, 0, "Statement not declared");
85 break;
1b247a36 86 case INGRES_BAD_COLUMN:
1741dca0 87 mr_errcode = MR_INTERNAL;
88 com_err(whoami, 0, "Bad column name in query table");
89 break;
1b247a36 90 case INGRES_ASGN_ERR:
1741dca0 91 mr_errcode = MR_INTERNAL;
92 com_err(whoami, 0, "Error in SQL assignment statement");
93 break;
1b247a36 94/* Others ??? */
95 default:
b070f8a1 96 mr_errcode = MR_INGRES_ERR;
45bf7573 97 com_err(whoami, MR_INGRES_ERR, " code %d\n", ingres_errno);
98 EXEC SQL INQUIRE_SQL(:err_msg = errortext);
99 com_err(whoami, 0, "SQL error text = %s", err_msg);
c9a214e4 100 critical_alert("MOIRA", "Moira server encountered INGRES ERROR %d", ingres_errno);
b070f8a1 101 }
b070f8a1 102}
103
45bf7573 104/* This is declarative, not executed. Applies from here on, in this file. */
048b1b94 105EXEC SQL WHENEVER SQLERROR CALL ingerr;
106
b070f8a1 107int mr_open_database()
108{
109 register int i;
110 char *malloc();
c9a214e4 111 MR_SQLDA_T *mr_alloc_SQLDA();
b070f8a1 112 static first_open = 1;
113
114 if (first_open) {
115 first_open = 0;
116
117 /* initialize local argv */
118 for (i = 0; i < 16; i++)
119 Argv[i] = malloc(ARGLEN);
120
c9a214e4 121 SQLDA = mr_alloc_SQLDA();
122
b070f8a1 123 incremental_init();
124 flush_cache();
125 }
126
127 ingres_errno = 0;
128 mr_errcode = 0;
129
130 /* open the database */
048b1b94 131#ifsql INGRES
132 EXEC SQL CONNECT moira;
1741dca0 133 if(ingres_errno)
134 return (ingres_errno);
048b1b94 135 EXEC SQL set lockmode session where level = table, timeout = :query_timeout;
136 EXEC SQL set lockmode on capacls where readlock = shared;
137 EXEC SQL set lockmode on alias where readlock = shared;
138#endsql
139#ifsql INFORMIX
140 EXEC SQL DATABASE moira
141#endsql
1741dca0 142
143 if(ingres_errno)
144 return(mr_errcode);
145
146 EXEC SQL SELECT SIZE(signature) INTO :mr_sig_length FROM users WHERE users_id=0; /* Harmless on second open */
3e6ff9e4 147 EXEC SQL COMMIT WORK;
1741dca0 148 if(ingres_errno)
149 return(mr_errcode);
150
151 return(MR_SUCCESS);
b070f8a1 152}
153
154int mr_close_database()
155{
156 flush_cache();
048b1b94 157#ifsql INGRES
158 EXEC SQL DISCONNECT;
159#endsql
b070f8a1 160}
161
162mr_check_access(cl, name, argc, argv_ro)
163 client *cl;
164 char *name;
165 int argc;
166 char *argv_ro[];
167{
168 struct query *q;
169 struct query *get_query_by_name();
170
171 ingres_errno = 0;
172 mr_errcode = 0;
173
174 q = get_query_by_name(name, cl->args->mr_version_no);
175 if (q == (struct query *)0)
176 return(MR_NO_HANDLE);
177
048b1b94 178 return(mr_verify_query(cl, q, argc, argv_ro));
b070f8a1 179}
180
181mr_process_query(cl, name, argc, argv_ro, action, actarg)
182 client *cl;
183 char *name;
184 int argc;
185 char *argv_ro[];
186 int (*action)();
187 char *actarg;
188{
189 register struct query *q;
190 register int status;
191 register struct validate *v;
192 char qual[256];
193 char sort[32];
194 char *pqual;
195 char *psort;
048b1b94 196 EXEC SQL BEGIN DECLARE SECTION;
197 char *table_name;
198 EXEC SQL END DECLARE SECTION;
b070f8a1 199 struct save_queue *sq;
200 struct query *get_query_by_name();
201 int sq_save_args();
202 struct save_queue *sq_create();
203 char *build_sort();
204
205 ingres_errno = 0;
206 mr_errcode = 0;
207
208 /* list queries command */
209 if (!strcmp(name, "_list_queries")) {
210 list_queries(cl->args->mr_version_no, action, actarg);
211 return(MR_SUCCESS);
212 }
213
214 /* help query command */
215 if (!strcmp(name, "_help")) {
216 if (argc < 1)
217 return(MR_ARGS);
218 q = get_query_by_name(argv_ro[0], cl->args->mr_version_no);
219 if (q == (struct query *)0) return(MR_NO_HANDLE);
220 help_query(q, action, actarg);
221 return(MR_SUCCESS);
222 }
223
224 /* get query structure, return error if named query does not exist */
225 q = get_query_by_name(name, cl->args->mr_version_no);
226 if (q == (struct query *)0) return(MR_NO_HANDLE);
227 v = q->validate;
228
229 /* setup argument vector, verify access and arguments */
230 if ((status = mr_verify_query(cl, q, argc, argv_ro)) != MR_SUCCESS)
231 goto out;
232
233 /* perform any special query pre-processing */
234 if (v && v->pre_rtn) {
235 status = (*v->pre_rtn)(q, Argv, cl, 0);
236 if (status != MR_SUCCESS)
237 goto out;
238 }
239
240 switch (q->type) {
241 case RETRIEVE:
242 /* for queries that do not permit wildcarding, check if row
243 uniquely exists */
244 if (v && v->field) {
048b1b94 245 status = validate_row(q, Argv, v);
b070f8a1 246 if (status != MR_EXISTS) break;
247 }
248
249 /* build "where" clause if needed */
250 if (q->qual) {
048b1b94 251 build_qual(q->qual, q->argc, Argv, qual);
b070f8a1 252 pqual = qual;
253 } else {
254 pqual = 0;
255 }
256
257 /* build "sort" clause if needed */
258 if (v && v->valobj) {
259 psort = build_sort(v, sort);
260 } else {
261 psort = 0;
262 }
263
264 /* if there is a followup routine, then we must save the results */
265 /* of the first query for use by the followup routine */
266 /* if q->rvar = NULL, perform post_rtn only */
267 if (q->rvar) {
268 if (v && v->post_rtn) {
269 sq = sq_create();
270 status = do_retrieve(q, pqual, psort, sq_save_args, sq);
271 if (status != MR_SUCCESS) {
272 sq_destroy(sq);
273 break;
274 }
275 status = (*v->post_rtn)(q, sq, v, action, actarg, cl);
276 } else {
277 /* normal retrieve */
278 status = do_retrieve(q, pqual, psort, action, actarg);
279 }
280 if (status != MR_SUCCESS) break;
281 } else {
282 status = (*v->post_rtn)(q, Argv, cl, action, actarg);
283 }
284
285 break;
286
287 case UPDATE:
288 /* see if row already exists */
289 if (v->field) {
290 status = validate_row(q, Argv, v);
291 if (status != MR_EXISTS) break;
292 }
293
294 /* build "where" clause and perform update */
295 /* if q->rvar = NULL, perform post_rtn only */
296 if (q->rvar) {
297 build_qual(q->qual, q->argc, Argv, qual);
298 incremental_before(q->rtable, qual, argv_ro);
299 status = do_update(q, &Argv[q->argc], qual, action, actarg);
300 incremental_after(q->rtable, qual, argv_ro);
301 if (status != MR_SUCCESS) break;
302 flush_name(argv_ro[0], q->rtable);
048b1b94 303 table_name = q->rtable;
b070f8a1 304 if (strcmp(q->shortname, "sshi") && strcmp(q->shortname, "ssif")) {
048b1b94 305 EXEC SQL UPDATE tblstats
306 SET updates = updates + 1, modtime = 'now'
307 WHERE table_name = :table_name;
b070f8a1 308 }
309 }
310
311 /* execute followup routine (if any) */
312 if (v->post_rtn) status = (*v->post_rtn)(q, Argv, cl);
313
314 break;
315
316 case APPEND:
317 /* see if row already exists */
318 if (v->field) {
319 status = validate_row(q, Argv, v);
320 if (status != MR_NO_MATCH) break;
321 }
322
b070f8a1 323 /* build "where" clause if needed */
324 if (q->qual) {
325 build_qual(q->qual, q->argc, Argv, qual);
326 pqual = qual;
327 } else {
328 pqual = 0;
329 }
330
331 /* perform the append */
332 /* if q->rvar = NULL, perform post_rtn only */
333 if (q->rvar) {
334 incremental_clear_before();
335 status = do_append(q, &Argv[q->argc], pqual, action, actarg);
336 if (status != MR_SUCCESS) break;
337 if (v && v->object_id) {
1b247a36 338 sprintf(qual, "%s.%s = %s",q->rvar, v->object_id,
45bf7573 339 Argv[q->argc+q->vcnt]);
b070f8a1 340 incremental_after(q->rtable, qual, argv_ro);
341 } else
342 incremental_after(q->rtable, pqual, argv_ro);
343
048b1b94 344 table_name = q->rtable;
345 EXEC SQL UPDATE tblstats
346 SET appends = appends + 1, modtime = 'now'
347 WHERE table_name = :table_name;
b070f8a1 348 }
349
350 /* execute followup routine */
351 if (v->post_rtn) status = (*v->post_rtn)(q, Argv, cl);
352 break;
353
354 case DELETE:
355 /* see if row already exists */
356 if (v->field) {
357 status = validate_row(q, Argv, v);
358 if (status != MR_EXISTS) break;
359 }
360
361 /* build "where" clause and perform delete */
362 /* if q->rvar = NULL, perform post_rtn only */
363 if (q->rvar) {
364 build_qual(q->qual, q->argc, Argv, qual);
048b1b94 365 table_name = q->rtable;
366 incremental_before(q->rtable, qual, argv_ro);
b070f8a1 367 status = do_delete(q, qual, action, actarg);
368 incremental_clear_after();
369 if (status != MR_SUCCESS) break;
370 flush_name(argv_ro[0], q->rtable);
048b1b94 371 EXEC SQL UPDATE tblstats
372 SET deletes = deletes + 1, modtime = 'now'
373 WHERE table_name = :table_name;
b070f8a1 374 }
375
376 /* execute followup routine */
377 if (v->post_rtn) status = (*v->post_rtn)(q, Argv, cl);
378 break;
379
380 }
381
382out:
383 if (status == MR_SUCCESS && ingres_errno != 0) {
384 com_err(whoami, MR_INTERNAL, "Server didn't notice INGRES ERROR %d",
385 ingres_errno);
386 status = mr_errcode;
387 }
388
048b1b94 389 if (q->type == RETRIEVE) {
048b1b94 390 EXEC SQL COMMIT WORK;
048b1b94 391 } else {
b070f8a1 392 if (status == MR_SUCCESS) {
048b1b94 393 EXEC SQL COMMIT WORK;
b070f8a1 394 if (journal) {
395 char buf[1024], *bp;
396 int i;
397 extern time_t now;
398
399 fprintf(journal, "%% %s %s %s",
400 cl->clname, cl->entity, ctime(&now));
401 fprintf(journal, "%s[%d] ", q->name, cl->args->mr_version_no);
402 for (i = 0; i < argc; i++) {
403 if (i != 0) {
404 putc(' ', journal);
405 }
406 requote(buf, argv_ro[i], sizeof(buf));
407 fputs(buf, journal);
408 }
409 putc('\n', journal);
410 fflush(journal);
411 }
412 incremental_update();
413 } else {
1a41acb7 414 cache_abort();
b070f8a1 415 if (ingres_errno != INGRES_DEADLOCK) {
048b1b94 416 EXEC SQL ROLLBACK WORK;
b070f8a1 417 }
418 incremental_flush();
419 }
420 }
1a41acb7 421 cache_commit(); /* commit following abort is safe */
b070f8a1 422
423 if (status != MR_SUCCESS && log_flags & LOG_RES)
424 com_err(whoami, status, " (Query failed)");
425 return(status);
426}
427
428build_qual(fmt, argc, argv, qual)
429 char *fmt;
430 int argc;
431 char *argv[];
432 char *qual;
433{
434 register char *c;
435 register int i;
436 char *args[4];
437 char *index();
438
439 c = fmt;
440 for (i = 0; i < argc; i++) {
441 c = index(c, '%');
442 if (c++ == (char *)0) return(MR_ARGS);
443 if (*c == 's')
444 args[i] = argv[i];
445 else if (*c == 'd')
446 *(int *)&args[i] = *(int *)argv[i]; /* sigh */
447 else
448 return(MR_INGRES_ERR);
449 }
1a41acb7 450 if (c = index(c, '%')) {
451 args[i] = args[i - 1];
452 }
b070f8a1 453
454 switch (argc) {
455 case 0:
456 strcpy(qual, fmt);
457 break;
458
459 case 1:
460 sprintf(qual, fmt, args[0]);
461 break;
462
463 case 2:
464 sprintf(qual, fmt, args[0], args[1]);
465 break;
466
467 case 3:
468 sprintf(qual, fmt, args[0], args[1], args[2]);
469 break;
470
471 case 4:
472 sprintf(qual, fmt, args[0], args[1], args[2], args[3]);
473 break;
1a41acb7 474
475 default:
476 com_err(whoami, MR_INTERNAL,
477 "Internal arg count error processing query");
478 return(MR_INTERNAL);
b070f8a1 479 }
480 return(MR_SUCCESS);
481}
482
483char *
484build_sort(v, sort)
485 register struct validate *v;
486 char *sort;
487{
488 register struct valobj *vo;
489 register int n;
490 char elem[16];
491
492 n = v->objcnt;
493 vo = v->valobj;
494 *sort = 0;
495
496 while (--n >= 0) {
497 if (vo->type == V_SORT) {
048b1b94 498 sprintf(elem, "%d", vo->index + 1); /* Result column number */
b070f8a1 499 if (*sort) strcat(sort, ", ");
500 strcat(sort, elem);
501 }
502 vo++;
503 }
504
505 return ((*sort) ? sort : 0);
506}
507
508
509/* Build arguement vector, verify query and arguments */
510
511mr_verify_query(cl, q, argc, argv_ro)
512 client *cl;
513 struct query *q;
514 int argc;
515 char *argv_ro[];
516{
517 register int argreq;
518 register int status;
519 register struct validate *v = q->validate;
520 register int i;
521 register int privileged = 0;
99e09b48 522 register char *to,*fr,*stop;
b070f8a1 523
524 /* copy the arguments into a local argv that we can modify */
525 if (argc >= QMAXARGS)
526 return(MR_ARGS);
527 for (i = 0; i < argc; i++) {
99e09b48 528 /* Single quotes must be doubled for SQL */
529 for (to=Argv[i], fr=argv_ro[i], stop=to+ARGLEN; (*fr) && (to<stop);) {
530 if(*fr=='\'')
531 *to++ = *fr;
532 *to++ = *fr++;
533 }
534 if (*fr)
535 return(MR_ARG_TOO_LONG);
536 *to='\0';
537
538 if (*--to == '\\')
b070f8a1 539 return(MR_BAD_CHAR);
540 }
541
542 /* check initial query access */
543 status = check_query_access(q, Argv, cl);
544 if (status != MR_SUCCESS && status != MR_PERM)
545 return(status);
546 if (status == MR_SUCCESS)
547 privileged++;
548
549 /* check argument count */
550 argreq = q->argc;
551 if (q->type == UPDATE || q->type == APPEND) argreq += q->vcnt;
552 if (argc != argreq) return(MR_ARGS);
553
554 /* validate arguments */
555 if (v && v->valobj) {
556 status = validate_fields(q, Argv, v->valobj, v->objcnt);
557 if (status != MR_SUCCESS) return(status);
558 }
559
560 /* perform special query access check */
561 if (!privileged && v && v->acs_rtn) {
562 status = (*v->acs_rtn)(q, Argv, cl);
563 if (status != MR_SUCCESS && status != MR_PERM)
564 return(status);
565 if (status == MR_SUCCESS)
566 privileged++;
567 }
568
569 return(privileged ? MR_SUCCESS : MR_PERM);
570}
571
572
573/* This routine caches info from the database. Each query acl is stored
574 * in the query structure, and whether that acl contains everybody.
575 */
576
577check_query_access(q, argv, cl)
578 struct query *q;
579 char *argv[];
580 client *cl;
048b1b94 581{
582 EXEC SQL BEGIN DECLARE SECTION;
583 char *name;
584 int acl_id;
585 int rowcount;
586 int errorno;
587 static int def_uid;
588 EXEC SQL END DECLARE SECTION;
b070f8a1 589 int status;
590 int client_id;
591 char *client_type;
592
593 /* initialize default uid */
594 if (def_uid == 0) {
048b1b94 595 EXEC SQL SELECT users_id INTO :def_uid FROM users WHERE login='default';
b070f8a1 596 }
597
598 /* get query access control list */
599 if (q->acl != 0)
600 acl_id = q->acl;
601 else {
602 name = q->shortname;
048b1b94 603 EXEC SQL SELECT list_id INTO :acl_id FROM capacls WHERE tag = :name;
604 if (sqlca.sqlcode < 0) return(MR_INGRES_ERR);
605 if (sqlca.sqlcode == 100) return(MR_PERM);
b070f8a1 606 q->acl = acl_id;
607
608 /* check for default access */
048b1b94 609 EXEC SQL SELECT member_id INTO :acl_id FROM imembers
610 WHERE list_id = :acl_id AND member_type = 'USER'
611 AND member_id = :def_uid;
612 if (sqlca.sqlerrd[2] == 0)
613 q->everybody = 0;
614 else
615 q->everybody = 1;
b070f8a1 616 }
617
618 if (q->everybody)
619 return(MR_SUCCESS);
620
621 if (get_client(cl, &client_type, &client_id) != MR_SUCCESS)
622 return(MR_PERM);
623 if (find_member("LIST", acl_id, client_type, client_id, 0))
624 return(MR_SUCCESS);
625 else
626 return(MR_PERM);
048b1b94 627}
b070f8a1 628
629
630get_client(cl, client_type, client_id)
631 client *cl;
632 char **client_type;
633 int *client_id;
634{
635 if (cl->users_id > 0) {
636 *client_id = cl->users_id;
637 *client_type = "USER";
638 return(MR_SUCCESS);
639 }
640
641 if (cl->client_id < 0) {
642 *client_id = -cl->users_id;
643 *client_type = "KERBEROS";
644 return(MR_SUCCESS);
645 }
646
647 return(MR_PERM);
648}
649
048b1b94 650find_member(list_type, list_id, member_type, member_id)
1a41acb7 651 char *list_type;
048b1b94 652 EXEC SQL BEGIN DECLARE SECTION;
653 int list_id;
654 char *member_type;
655 int member_id;
656 EXEC SQL END DECLARE SECTION;
657{
658 EXEC SQL BEGIN DECLARE SECTION;
659 int flag, errorno;
660 EXEC SQL END DECLARE SECTION;
b070f8a1 661
662 if (!strcmp(strtrim(list_type), strtrim(member_type)) &&
663 list_id == member_id)
664 return(1);
665
666 /* see if client is a direct member of list */
048b1b94 667 flag = 0;
668 EXEC SQL SELECT member_id INTO :flag FROM imembers
669 WHERE list_id = :list_id AND member_type = :member_type
670 AND member_id = :member_id;
671 if(flag!=0) flag=1; /** Not strictly necessary */
672 if (sqlca.sqlcode == 0)
673 return(flag);
674 return(0);
675}
b070f8a1 676
677
048b1b94 678do_retrieve(q, pqual, psort, action, actarg)
b070f8a1 679 register struct query *q;
048b1b94 680EXEC SQL BEGIN DECLARE SECTION;
b070f8a1 681 char *pqual;
682 char *psort;
048b1b94 683EXEC SQL END DECLARE SECTION;
b070f8a1 684 int (*action)();
685 char *actarg;
048b1b94 686{
b070f8a1 687 static char **vaddrs = (char **)NULL;
c9a214e4 688 int j, rowcount;
b070f8a1 689
690 if (!vaddrs) {
691 register int i;
692
693 if ((vaddrs = (char **)malloc(sizeof(char *) * QMAXARGS)) == NULL) {
694 com_err(whoami, MR_NO_MEM, "setting up static argv");
695 exit(1);
696 }
45bf7573 697 for (i = 0; i < QMAXARGS; i++) {
c9a214e4 698 vaddrs[i]=SQLDA->sqlvar[i].sqldata;
b070f8a1 699 }
700 }
701
c9a214e4 702 build_sql_stmt(stmt_buf,"SELECT",q->tlist,vaddrs,pqual);
048b1b94 703 if(psort) { strcat(stmt_buf," ORDER BY "); strcat(stmt_buf,psort); }
c9a214e4 704 EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
99e09b48 705 if(sqlca.sqlcode)
706 return(MR_INTERNAL);
048b1b94 707 EXEC SQL DECLARE csr001 CURSOR FOR stmt;
708 EXEC SQL OPEN csr001;
c9a214e4 709 rowcount = 0;
048b1b94 710 while(1) {
711 EXEC SQL FETCH csr001 USING DESCRIPTOR :SQLDA;
712 if(sqlca.sqlcode != 0) break;
713 (*action)(q->vcnt, vaddrs, actarg);
c9a214e4 714 rowcount++;
b070f8a1 715 }
048b1b94 716 EXEC SQL CLOSE csr001;
b070f8a1 717
718 if (mr_errcode) return(mr_errcode);
c9a214e4 719 return ((rowcount == 0) ? MR_NO_MATCH : MR_SUCCESS);
048b1b94 720}
721
cc0088db 722char *sqlstrstr(str,pat)
723 char *str;
724 char *pat;
725{
726 register char *p=pat;
727
728 do {
729 if(*str=='\'') { /* Skip over single-quote delimited substrings */
730 while(*++str && (*str!='\''))
731 ;
732 continue;
733 }
734 if(*str==*p) {
735 register char *s;
736 s=str;
737 while(*++p && (*++s==*p))
738 ;
739 if(*p) p=pat; /* failed */
740 }
741 } while(*p && *++str);
742
743 if(!*str) str=NULL;
744 return(str);
745}
746
747void optimize_sql_stmt(buf)
748char *buf;
749{
750 char *point=buf, *pat, *eopat, *esc1, *esc2, *csr;
751
752 for(point=buf; point=sqlstrstr(point,"LIKE"); point++) {
753 /* Now pointing to string "LIKE" */
754
755 /* Look at next word */
756 for(pat=point+4; *pat==' '; pat++) ;
757
758 /* Is it a single-quote delimited string? */
759 if(*pat!='\'') continue;
760
761 /* look for "escape" clause - save escape character */
762 /* 1. Find end of pattern */
763 for(eopat=pat+1; 1; eopat++) {
764 if(*eopat=='\'') {
765 if(eopat[1]=='\'') /* single-quote is self-escaping */
766 eopat++;
767 else
768 break;
769 }
770 }
771
772 /* 2. Look at next word */
773 for(esc1=eopat; *++esc1==' ';) ;
774
775 /* 3. esc1=0 if not "ESCAPE '?'", where the ? may be any character. */
776 if(strncmp(esc1,"ESCAPE",6)) esc1=NULL;
777
778 if(esc1) {
779 for(esc2=esc1+6; *esc2==' '; esc2++) ;
780
781 if(*esc2++!='\'') continue; /* Bad SQL syntax. Skip. */
782 /* esc2 now points at the escape character itself */
783 if(esc2[1]!='\'') continue; /* Weird escape string. Skip. */
784 } else {
785 esc2="\\";
786 }
787
788 /* Is pattern free from special characters? */
789 for(csr=pat; csr<eopat; csr++)
790 if((*csr=='%') || (*csr=='_') || (*csr==*esc2)) break;
791 if(csr!=eopat) continue; /* Uses pattern matching. Skip. */
792
793 /* Optimize the query statement */
794 /* 1. Change "LIKE" to " = " */
795 memcpy(point," = ",4);
796
797 /* 2. Change "ESCAPE" to " " */
798 if(esc1) {
799 memset(esc1,' ',6);
800 /* 3. Change "'*'" to " " */
801 /* (Changes '''' to " ") */
802 if(esc2) memset(esc2-1,' ',(*esc2=='\'')?4:3);
803 }
804 }
805}
806
048b1b94 807build_sql_stmt(result_buf,cmd,targetlist,argv,qual)
808 char *result_buf;
809 char *cmd;
810 char *targetlist;
811 char *argv[];
c9a214e4 812 char *qual;
048b1b94 813{
814 char fmt_buf[MR_STMTBUF_LEN];
99e09b48 815 register char *res, *fmt;
816
817 if(qual)
818 sprintf(fmt_buf,"%s %s WHERE %s",cmd,targetlist,qual);
819 else
820 sprintf(fmt_buf,"%s %s",cmd,targetlist);
821
822 for(res=result_buf, fmt=fmt_buf; *fmt; fmt++) {
823 if(*fmt=='%') {
824 if(*++fmt) {
825 switch(*fmt) {
826 case '%': /* %% -> % */
827 *res++ = *fmt;
828 break;
829 case 's':
830 if(*argv[0]) {
831 *res='\0';
832 strcat(res,*argv);
833 while(*++res) ;
834 }
835 argv++;
836 break;
837 case 'd':
838 sprintf(res,"%d",*(int *)*argv++); /* print to result buffer */
839 while(*++res) ;
840 break;
841 default: /* Swallow other %? pairs */
842 break;
843 }
844 } else break;
845 } else *res++ = *fmt; /* text -> result buffer */
048b1b94 846 }
847 *res='\0';
cc0088db 848
849 optimize_sql_stmt(result_buf);
048b1b94 850}
b070f8a1 851
852do_update(q, argv, qual, action, actarg)
853 register struct query *q;
854 char *argv[];
855 char *qual;
856 int (*action)();
857 char *actarg;
048b1b94 858{
859 build_sql_stmt(stmt_buf,"UPDATE",q->tlist,argv,qual);
c9a214e4 860 EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
b070f8a1 861 if (mr_errcode) return(mr_errcode);
862 return(MR_SUCCESS);
048b1b94 863}
b070f8a1 864
865do_append(q, argv, pqual, action, actarg)
866 register struct query *q;
867 char *argv[];
868 char *pqual;
869 int (*action)();
870 char *actarg;
048b1b94 871{
872 build_sql_stmt(stmt_buf,"INSERT",q->tlist,argv,pqual);
c9a214e4 873 EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
b070f8a1 874 if (mr_errcode) return(mr_errcode);
875 return(MR_SUCCESS);
048b1b94 876}
b070f8a1 877
878do_delete(q, qual, action, actarg)
879 register struct query *q;
880 char *qual;
881 int (*action)();
882 char *actarg;
048b1b94 883{
884 sprintf(stmt_buf,"DELETE FROM %s WHERE %s",q->rtable,qual);
885 EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
b070f8a1 886 if (mr_errcode) return(mr_errcode);
887 return(MR_SUCCESS);
048b1b94 888}
b070f8a1 889
890
891/**
892 ** set_next_object_id - set next object id in values table
893 **
894 ** Inputs: object - object name in values table and in objects
895 ** table - name of table objects are found in
1a41acb7 896 ** limit - should the ID be range limited
b070f8a1 897 **
898 ** - called before an APPEND operation to set the next object id to
899 ** be used for the new record to the next free value
900 **
901 **/
902
048b1b94 903set_next_object_id(object, table_name, limit)
904 EXEC SQL BEGIN DECLARE SECTION;
1a41acb7 905 char *object;
048b1b94 906 char *table_name;
1a41acb7 907 int limit;
048b1b94 908 EXEC SQL END DECLARE SECTION;
909{
910 EXEC SQL BEGIN DECLARE SECTION;
c9a214e4 911 int value;
048b1b94 912 EXEC SQL END DECLARE SECTION;
45bf7573 913 int starting_value;
914
048b1b94 915 EXEC SQL SELECT value INTO :value FROM numvalues WHERE name = :object;
916 if (sqlca.sqlerrd[2] != 1)
1a41acb7 917 return(MR_NO_ID);
918
45bf7573 919 starting_value=value;
c9a214e4 920 while (1) {
45bf7573 921 if (limit && value > MAX_ID_VALUE)
922 value = MIN_ID_VALUE;
923
924 sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s=%d",object,table_name,object,value);
925 EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
99e09b48 926 if(sqlca.sqlcode)
927 return(MR_INTERNAL);
45bf7573 928 EXEC SQL DECLARE csr002 CURSOR FOR stmt;
c9a214e4 929 EXEC SQL OPEN csr002;
45bf7573 930 EXEC SQL FETCH csr002 USING DESCRIPTOR :SQLDA;
931 if (sqlca.sqlcode < 0) return(mr_errcode);
932 if (sqlca.sqlcode == 100) break;
933
c9a214e4 934 EXEC SQL CLOSE csr002;
45bf7573 935 value++;
936 if (limit && value == starting_value) {
937 com_err(whoami,0,"All id values have been used");
938 return(MR_NO_ID);
939 }
b070f8a1 940 }
c9a214e4 941 EXEC SQL CLOSE csr002;
b070f8a1 942
943 if (LOG_RES)
c9a214e4 944 com_err(whoami, 0, "setting ID %s to %d", object, value);
048b1b94 945 EXEC SQL UPDATE numvalues SET value = :value WHERE name = :object;
b070f8a1 946 return(MR_SUCCESS);
048b1b94 947}
b070f8a1 948
949
950/* Turn a kerberos name into the user's ID of the account that principal
951 * owns. Sets the kerberos ID and user ID.
952 */
953
954int set_krb_mapping(name, login, ok, kid, uid)
955char *name;
956char *login;
957int ok;
958int *kid;
959int *uid;
048b1b94 960{
961 EXEC SQL BEGIN DECLARE SECTION;
962 int u_id, k_id;
963 char *krbname;
964 EXEC SQL END DECLARE SECTION;
b070f8a1 965
966 krbname = name;
967 *kid = 0;
968 *uid = 0;
969
fbeb0263 970 EXEC SQL SELECT km.users_id, km.string_id INTO :u_id, :k_id
971 FROM krbmap km, strings str
972 WHERE km.string_id = str.string_id AND str.string = :krbname;
3e6ff9e4 973 EXEC SQL COMMIT WORK;
048b1b94 974
b070f8a1 975 if (ingres_errno) return(mr_errcode);
976
048b1b94 977 if (sqlca.sqlerrd[2] == 1) { /* rowcount */
b070f8a1 978 *kid = -k_id;
979 *uid = u_id;
980 return(MR_SUCCESS);
981 }
982
983 if (name_to_id(name, "STRINGS", &k_id) == MR_SUCCESS)
984 *kid = -k_id;
985
048b1b94 986 if (!ok) {
b070f8a1 987 *uid = *kid;
988 return(MR_SUCCESS);
989 }
990
991 if (name_to_id(login, "USERS", uid) != MR_SUCCESS)
992 *uid = 0;
993
994 if (*kid == 0)
995 *kid = *uid;
996 if (ingres_errno) return(mr_errcode);
997 return(MR_SUCCESS);
048b1b94 998}
b070f8a1 999
1000
1001/* For now this just checks the argc's. It should also see that there
1002 * are no duplicate names.
1003 */
1004
1005sanity_check_queries()
1006{
1007 register int i;
1008 int maxv = 0, maxa = 0;
1009#ifdef MULTIPROTOCOLS
1010 extern int QueryCount1, QueryCount2;
1011 extern struct query Queries1[], Queries2[];
1012#else
1013 extern int QueryCount2;
1014 extern struct query Queries2[];
1015#endif MULTIPROTOCOLS
1016
1017#define MAX(x,y) ((x) > (y) ? (x) : (y))
1018
1019#ifdef MULTIPROTOCOLS
1020 for (i = 0; i < QueryCount1; i++) {
1021 maxv = MAX(maxv, Queries1[i].vcnt);
1022 maxa = MAX(maxa, Queries1[i].argc);
1023 }
1024#endif MULTIPROTOCOLS
1025 for (i = 0; i < QueryCount2; i++) {
1026 maxv = MAX(maxv, Queries2[i].vcnt);
1027 maxa = MAX(maxa, Queries2[i].argc);
1028 }
1029 if (MAX(maxv, maxa) > QMAXARGS) {
1030 com_err(whoami, 0, "A query has more args than QMAXARGS");
1031 exit(1);
1032 }
1033}
048b1b94 1034
1035/* eof:qrtn.dc */
Moira, the Athena Service Management system
This page took 0.472161 seconds and 5 git commands to generate.