server/qrtn.qc

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