server/qrtn.pc

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