server/qrtn.qc

   1 /*
   2  *      $Source$
   3  *      $Author$
   4  *      $Header$
   5  *
   6  *      Copyright (C) 1987 by the Massachusetts Institute of Technology
   7  *
   8  *      $Log$
   9  *      Revision 1.5  1987-06-21 16:37:58  wesommer
  10  *      Changed include files, reindented things.
  11  *
  12  *
  13  * Revision 1.4  87/06/08  05:03:27  wesommer
  14  * Reindented; added header and trailer.
  15  *
  16  */
  17
  18 #ifndef lint
  19 static char *rcsid_qrtn_qc = "$Header$";
  20 #endif lint
  21
  22 #include "query.h"
  23 #include "sms_server.h"
  24
  25 char *Argv[16];
  26
  27 static int ingres_errno = 0;
  28
  29 /*
  30  * ingerr: (supposedly) called when Ingres indicates an error.
  31  * I have not yet been able to get this to work to intercept a
  32  * database open error.
  33  */
  34
  35 static int ingerr(num)
  36     int *num;
  37 {
  38     ingres_errno = SMS_INGRES_ERR;
  39     return *num;
  40 }
  41
  42 int sms_open_database()
  43 {
  44     register int i;
  45
  46     /* initialize local argv */
  47     for (i = 0; i < 16; i++)
  48         Argv[i] = (char *)malloc(128);
  49
  50     IIseterr(ingerr);
  51
  52     ingres_errno = 0;
  53
  54     /* open the database */
  55 ##  ingres sms
  56     return ingres_errno;
  57 }
  58
  59 int sms_close_database()
  60 {
  61 ##  exit
  62
  63 }
  64
  65 sms_process_query(name, argc, argv_ro, action, actarg)
  66     char *name;
  67     int argc;
  68     char *argv_ro[];
  69     int (*action)();
  70     char *actarg;
  71 {
  72     register struct query *q;
  73     register int i;
  74     struct query *get_query_by_name();
  75     char qual[128];
  76
  77     /* copy the arguments into a local argv that we can modify */
  78     for (i = 0; i < argc; i++)
  79         strcpy(Argv[i], argv_ro[i]);
  80
  81     q = get_query_by_name(name);
  82
  83     switch (q->type) {
  84     case RETRIEVE:
  85         if (q->qual) {
  86             build_qual(q->qual, q->argc, Argv, qual);
  87             do_retrieve_with_qual(q, qual, action, actarg);
  88         } else
  89             do_retrieve(q, action, actarg);
  90         break;
  91
  92     case UPDATE:
  93         if (q->support_rtn) {
  94             if ((*q->support_rtn)(Argv, action, actarg) == -1)
  95                 break;
  96         }
  97         build_qual(q->qual, q->argc, &Argv[q->sargc], qual);
  98         do_update(q, &Argv[q->sargc + q->argc], qual, action, actarg);
  99         break;
 100
 101     case APPEND:
 102         if (q->support_rtn) {
 103             if ((*q->support_rtn)(Argv, action, actarg) == -1)
 104                 break;
 105         }
 106         do_append(q, &Argv[q->sargc + q->argc], action, actarg);
 107         break;
 108
 109     case DELETE:
 110         if (q->support_rtn) {
 111             if ((*q->support_rtn)(Argv, action, actarg) == -1)
 112                 break;
 113         }
 114         build_qual(q->qual, q->argc, &Argv[q->sargc], qual);
 115         do_delete(q, qual, action, actarg);
 116         break;
 117     }
 118 }
 119
 120 build_qual(fmt, argc, argv, qual)
 121         char *fmt;
 122         int argc;
 123         char *argv[];
 124         char *qual;
 125 {
 126     switch (argc) {
 127     case 0:
 128         strcpy(qual, fmt);
 129         break;
 130
 131     case 1:
 132         sprintf(qual, fmt, argv[0]);
 133         break;
 134
 135     case 2:
 136         sprintf(qual, fmt, argv[0], argv[1]);
 137         break;
 138
 139     case 3:
 140         sprintf(qual, fmt, argv[0], argv[1], argv[2]);
 141         break;
 142
 143     case 4:
 144         sprintf(qual, fmt, argv[0], argv[1], argv[2], argv[3]);
 145         break;
 146     }
 147 }
 148
 149 do_retrieve(q, action, actarg)
 150     register struct query *q;
 151     int (*action)();
 152     char *actarg;
 153 ##{
 154 ##  char *rvar;
 155 ##  char *rtable;
 156 ##  int rowcount;
 157
 158     if (q->rvar) {
 159         rvar = q->rvar;
 160         rtable = q->rtable;
 161 ##      range of rvar is rtable
 162     }
 163
 164 ##  retrieve (param (q->tlist, q->vaddr)) {
 165         if (q->support_rtn)
 166             /* save result */
 167             (*q->support_rtn)(q->vcnt, q->vaddr, 0, 0);
 168         else
 169             (*action)(q->vcnt, q->vaddr, actarg);
 170 ##  }
 171
 172 ##  inquire_equel (rowcount = "rowcount")
 173
 174     if (q->support_rtn) {
 175         /* process and send saved results */
 176         (*q->support_rtn)(0, 0, &q->vnames[q->argc], action, actarg);
 177     }
 178
 179 ##}
 180
 181 do_retrieve_with_qual(q, qual, action, actarg)
 182     register struct query *q;
 183     char *qual;
 184     int (*action)();
 185     char *actarg;
 186 ##{
 187 ##  char *rvar;
 188 ##  char *rtable;
 189 ##  char *cqual;
 190 ##  int rowcount;
 191
 192     if (q->rvar) {
 193         rvar = q->rvar;
 194         rtable = q->rtable;
 195 ##      range of rvar is rtable
 196     }
 197
 198     cqual = qual;
 199 ##  retrieve (param (q->tlist, q->vaddr))
 200 ##  where cqual {
 201         if (q->support_rtn)
 202             (*q->support_rtn)(q->vcnt, q->vaddr, 0, 0);
 203         else
 204             (*action)(q->vcnt, q->vaddr, actarg);
 205 ##  }
 206
 207 ##  inquire_equel (rowcount = "rowcount")
 208
 209     if (q->support_rtn) {
 210         (*q->support_rtn)(0, 0, &q->vnames[q->argc], action, actarg);
 211     }
 212
 213 ##}
 214
 215 do_update(q, argv, qual, action, actarg)
 216     register struct query *q;
 217     char *argv[];
 218     char *qual;
 219     int (*action)();
 220     char *actarg;
 221 ##{
 222 ##  char *rvar;
 223 ##  char *rtable;
 224 ##  char *cqual;
 225 ##  int rowcount;
 226
 227     rvar = q->rvar;
 228     rtable = q->rtable;
 229 ##  range of rvar is rtable
 230
 231     cqual = qual;
 232 ##  replace rvar (param (q->tlist, argv))
 233 ##  where cqual
 234
 235 ##}
 236
 237 do_append(q, argv, action, actarg)
 238     register struct query *q;
 239     char *argv[];
 240     int (*action)();
 241     char *actarg;
 242 ##{
 243 ##  char *rvar;
 244 ##  char *rtable;
 245
 246     rvar = q->rvar;
 247     rtable = q->rtable;
 248 ##  range of rvar is rtable
 249
 250 ##  append to rtable (param (q->tlist, argv))
 251
 252 ##}
 253
 254 do_delete(q, qual, action, actarg)
 255     register struct query *q;
 256     char *qual;
 257     int (*action)();
 258     char *actarg;
 259 ##{
 260 ##  char *rvar;
 261 ##  char *rtable;
 262 ##  char *cqual;
 263
 264     rvar = q->rvar;
 265     rtable = q->rtable;
 266 ##  range of rvar is rtable
 267
 268     cqual = qual;
 269 ##  delete rvar where cqual
 270
 271 ##}
 272
 273 /* Support Queries */
 274
 275 support_alis(argv, action, actarg)
 276     char *argv[];
 277     int (*action)();
 278     char *actarg;
 279 ##{
 280 ##  static int list_id;
 281
 282 ##  range of tbi is tbinfo
 283
 284 ##  repeat retrieve (list_id = tbi.value1) where tbi.table = "list"
 285     list_id++;
 286 ##  repeat replace tbi (value1 = @list_id) where tbi.table = "list"
 287
 288     argv[0] = (char *)&list_id;
 289 ##}
 290
 291 /**
 292  ** support_member():
 293  **
 294  ** support for ADD_MEMBER_TO_LIST
 295  ** support for DELETE_MEMBER_FROM_LIST
 296  ** support for UPDATE_MEMBER_STATUS
 297  **
 298  **           Input                     Output
 299  ** argv[0]   List Type       argv[4]   List ID
 300  ** argv[1]   List Name       argv[5]   Member ID
 301  ** argv[2]   Member Type     argv[6]   Member Type
 302  ** argv[3]   Member Name
 303  **/
 304
 305 support_member(argv, action, actarg)
 306         char *argv[];
 307         int (*action)();
 308         char *actarg;
 309 ##{
 310 ##  char *list_name;
 311 ##  char *list_type;
 312 ##  char *member_name;
 313 ##  char *member_type;
 314 ##  int list_id;
 315 ##  int value;
 316 ##  int rowcount;
 317     char errmsg[64];
 318     char *p_errmsg = errmsg;
 319
 320     list_type = argv[0];
 321     list_name = argv[1];
 322     member_type = argv[2];
 323     member_name = argv[3];
 324
 325 ##  range of l is list
 326 ##  repeat retrieve (list_id = l.id)
 327 ##      where l.name = @list_name and l.type = @list_type
 328     sprintf(argv[4], "%d", list_id);
 329
 330     if (!strcmp(member_type, "acl") || !strcmp(member_type, "group") ||
 331         !strcmp(member_type, "mail")) {
 332 ##      repeat retrieve (value = l.id)
 333 ##          where l.name = @member_name and l.type = @member_type
 334 ##      inquire_equel (rowcount = "rowcount")
 335         if (rowcount == 0) {
 336             sprintf(errmsg, "(No such list: %s)", member_name);
 337             (*action)(1, p_errmsg, actarg);
 338             return(-1);
 339         }
 340     } else if (!strcmp(member_type, "user")) {
 341 ##      range of u is users
 342 ##      repeat retrieve (value = u.id) where u.login = @member_name
 343 ##      inquire_equel (rowcount = "rowcount")
 344         if (rowcount == 0) {
 345             sprintf(errmsg, "(No such user: %s)", member_name);
 346             (*action)(1, p_errmsg, actarg);
 347             return(-1);
 348         }
 349     } else if (!strcmp(member_type, "string")) {
 350 ##      range of s is strings
 351 ##      repeat retrieve (value = s.id) where s.string = @member_name
 352 ##      inquire_equel (rowcount = "rowcount")
 353         if (rowcount == 0) {
 354 ##          range of tbi is tbinfo
 355 ##          retrieve (value = tbi.value1) where tbi.table = "strings"
 356             value++;
 357 ##          replace tbi (value1 = value) where tbi.table = "strings"
 358 ##          append to strings (id = value, string = member_name)
 359         }
 360     } else {
 361         sprintf(errmsg, "(Unknown member type: %s)", member_type);
 362         (*action)(1, p_errmsg, actarg);
 363         return(-1);
 364     }
 365
 366     sprintf(argv[5], "%d", value);
 367     strcpy(argv[6], member_type);
 368     return(0);
 369 ##}
 370
 371 /**
 372  ** support for GET_LIST_MEMBERS
 373  **
 374  **           Input           Output
 375  ** argv[0]   Member Type     Member Type
 376  ** argv[1]   Member Id       Member Name (ACL, Group, Maillist, User, String)
 377  ** argv[2]   Member Status   Member Status
 378  **
 379  ** This routine performs two functions:
 380  **   When called with argc > 0, it copies and saves argv in a queue
 381  **   When called with argc = 0, it does post-processing on the saved
 382  **     data, and sends the data to the client using the supplied action
 383  **     routine.
 384  **/
 385
 386 support_gmol(argc, argv, vnames, action, actarg)
 387     int argc;
 388     char *argv[];
 389     char *vnames[];
 390     int (*action)();
 391     char *actarg;
 392 ##{
 393 ##  char *member_type;
 394 ##  int member_id;
 395 ##  char member_name[33];
 396     char **sargv;
 397     char *nargv[3];
 398     register int n;
 399     static struct save_queue *sq = (struct save_queue *)0;
 400     struct save_queue *sq_create();
 401
 402     if (argc > 0) {
 403         if (sq == (struct save_queue *)0) {
 404             sq = sq_create();
 405         }
 406         sargv = (char **)malloc(3 * sizeof (char *));
 407         /* copy member_type */
 408         n = strlen(argv[0]) + 1;
 409         sargv[0] = (char *)malloc(n);
 410         bcopy(argv[0], sargv[0], n);
 411         /* copy member_id */
 412         sargv[1] = (char *)malloc(sizeof (int));
 413         *(int *)sargv[1] = *(int *)argv[1];
 414         /* copy member_status */
 415         n = strlen(argv[2]) + 1;
 416         sargv[2] = (char *)malloc(n);
 417         bcopy(argv[2], sargv[2], n);
 418         /* store data */
 419         sq_save_data(sq, sargv);
 420         return;
 421     }
 422
 423     while (sq_get_data(sq, &sargv)) {
 424         member_type = sargv[0];
 425         member_id = *(int *)sargv[1];
 426
 427         nargv[0] = member_type;
 428         nargv[1] = member_name;
 429         nargv[2] = sargv[2];
 430
 431         if (!strcmp(member_type, "acl") ||
 432             !strcmp(member_type, "group") ||
 433             !strcmp(member_type, "mail")) {
 434 ##          range of l is list
 435 ##          repeat retrieve (member_name = l.name)
 436 ##              where l.id = @member_id
 437         } else if (!strcmp(member_type, "user")) {
 438 ##          range of u is users
 439 ##          repeat retrieve (member_name = u.login)
 440 ##              where u.id = @member_id
 441         } else if (!strcmp(member_type, "string")) {
 442 ##          range of s is strings
 443 ##          repeat retrieve (member_name = s.string)
 444 ##              where s.id = @member_id
 445         } else {
 446             sprintf(member_name, "%d", member_id);
 447         }
 448
 449         (*action)(3, nargv, vnames, actarg);
 450         free(sargv[0]);
 451         free(sargv[1]);
 452         free(sargv[2]);
 453     }
 454
 455     sq_destroy(sq);
 456     sq = (struct save_queue *)0;
 457 ##}
 458
 459 /*
 460  * Local Variables:
 461  * mode: c
 462  * c-indent-level: 4
 463  * c-continued-statement-offset: 4
 464  * c-brace-offset: -4
 465  * c-argdecl-indent: 4
 466  * c-label-offset: -4
 467  * End:
 468  */
 469