server/mr_scall.c

   1 /*
   2  *      $Source$
   3  *      $Author$
   4  *      $Header$
   5  *
   6  *      Copyright (C) 1987 by the Massachusetts Institute of Technology
   7  *
   8  *      $Log$
   9  *      Revision 1.6  1987-06-30 20:04:43  wesommer
  10  *      Free returned tuples when possible.
  11  *
  12  * Revision 1.5  87/06/26  10:55:53  wesommer
  13  * Added sms_access, now paiys attention to return code from
  14  * sms_process_query, sms_check_access.
  15  *
  16  * Revision 1.4  87/06/21  16:42:00  wesommer
  17  * Performance work, rearrangement of include files.
  18  *
  19  * Revision 1.3  87/06/04  01:35:01  wesommer
  20  * Added a working query request handler.
  21  *
  22  * Revision 1.2  87/06/03  16:07:50  wesommer
  23  * Fixes for lint.
  24  *
  25  * Revision 1.1  87/06/02  20:07:10  wesommer
  26  * Initial revision
  27  *
  28  */
  29
  30 #ifndef lint
  31 static char *rcsid_sms_scall_c = "$Header$";
  32 #endif lint
  33
  34 #include <krb.h>
  35 #include <errno.h>
  36 #include "sms_server.h"
  37 extern char buf1[];
  38 extern int nclients;
  39 extern char *whoami;
  40
  41 extern void clist_delete(), do_auth(), do_shutdown();
  42 void do_call();
  43
  44 /*
  45  * Welcome to the (finite state) machine (highest level).
  46  */
  47 void
  48 do_client(cp)
  49         client *cp;
  50 {
  51         free_rtn_tuples(cp);
  52         if (OP_STATUS(cp->pending_op) == OP_CANCELLED) {
  53                 (void) sprintf(buf1, "Closed connection (now %d client%s)",
  54                                nclients-1,
  55                                nclients!=2?"s":"");
  56                 com_err(whoami, 0, buf1);
  57                 clist_delete(cp);
  58                 return;
  59         }
  60         switch (cp->action) {
  61         case CL_ACCEPT:
  62         case CL_SEND:
  63                 /* Start recieving next request */
  64                 initialize_operation(cp->pending_op, sms_start_recv,
  65                                      (char *)&cp->args, (int (*)())NULL);
  66                 queue_operation(cp->con, CON_INPUT, cp->pending_op);
  67                 cp->action = CL_RECEIVE;
  68                 break;
  69         case CL_RECEIVE:
  70                 /* Data is here. Process it & start it heading back */
  71                 do_call(cp); /* This may block for a while. */
  72                 initialize_operation(cp->pending_op, sms_start_send,
  73                                      (char *)&cp->reply, (int (*)())NULL);
  74                 queue_operation(cp->con, CON_OUTPUT, cp->pending_op);
  75                 cp->action = CL_SEND;
  76                 break;
  77         }
  78 }
  79
  80 #ifdef notdef
  81 char *procnames[] = {
  82          "noop",
  83          "auth",
  84          "shutdown",
  85          "query",
  86          };
  87 #endif notdef
  88
  89 void
  90 do_call(cl)
  91         client *cl;
  92 {
  93         int pn;
  94         cl->reply.sms_argc = 0;
  95         cl->reply.sms_status = 0;
  96         if (((pn = cl->args->sms_procno) < 0) ||
  97             (pn > SMS_MAX_PROC)) {
  98                 com_err(whoami, 0, "procno out of range");
  99                 cl->reply.sms_status = SMS_UNKNOWN_PROC;
 100                 return;
 101         }
 102 #ifdef SMS_DBG
 103         fprintf(stderr, "[#%d] %s(", cl->id, procnames[pn]);
 104         for (i=0; i < cl->args->sms_argc; i++) {
 105                 if (i) fputc(',', stderr);
 106                 frequote(stderr,cl->args->sms_argv[i]);
 107         }
 108         fprintf(stderr, ")\n");
 109 #endif SMS_DBG
 110
 111         switch(pn) {
 112         case SMS_NOOP:
 113                 cl->reply.sms_status = 0;
 114                 com_err(whoami, 0, "noop");
 115                 return;
 116
 117         case SMS_AUTH:
 118                 do_auth(cl);
 119                 return;
 120
 121         case SMS_QUERY:
 122                 do_retr(cl);
 123                 return;
 124
 125         case SMS_ACCESS:
 126                 do_access(cl);
 127                 return;
 128
 129         case SMS_SHUTDOWN:
 130                 do_shutdown(cl);
 131                 return;
 132         }
 133 }
 134
 135 free_rtn_tuples(cp)
 136         client *cp;
 137 {
 138         register returned_tuples *temp;
 139         for (temp=cp->first; temp && OP_DONE(temp->op); ) {
 140                 register returned_tuples *t1=temp;
 141                 temp = t1->next;
 142                 if (t1 == cp->last) cp->last = NULL;
 143 #ifdef notdef
 144                 sms_destroy_reply(t1->retval);
 145 #endif notdef
 146                 if (t1->retval) {
 147                         register sms_params *p = t1->retval;
 148                         if (p->sms_flattened)
 149                                 free(p->sms_flattened);
 150                         if (p->sms_argl)
 151                                 free(p->sms_argl);
 152                         free(p);
 153                 }
 154                 delete_operation(t1->op);
 155                 free(t1);
 156         }
 157         cp->first = temp;
 158 }
 159
 160 retr_callback(argc, argv, p_cp)
 161         int argc;
 162         char **argv;
 163         char *p_cp;
 164 {
 165         register client *cp = (client *)p_cp;
 166         /*
 167          * This takes too much advantage of the fact that
 168          * serialization of the data happens during the queue operation.
 169          */
 170         sms_params *arg_tmp = (sms_params *)db_alloc(sizeof(sms_params));
 171         returned_tuples *tp = (returned_tuples *)
 172                 db_alloc(sizeof(returned_tuples));
 173
 174         OPERATION op_tmp = create_operation();
 175
 176 #ifdef notdef                   /* We really don't want this logged */
 177         com_err(whoami, 0, "Returning next data:");
 178         log_args(argc, argv);
 179 #endif notdef
 180         tp->op = op_tmp;
 181         tp->retval = arg_tmp;
 182         tp->next = NULL;
 183
 184         arg_tmp->sms_status = SMS_MORE_DATA;
 185         arg_tmp->sms_argc = argc;
 186         arg_tmp->sms_argv = argv;
 187         arg_tmp->sms_flattened = (char *)NULL;
 188         arg_tmp->sms_argl = (int *)NULL;
 189
 190         if (cp->last) {
 191                 cp->last->next = tp;
 192                 cp->last = tp;
 193         } else {
 194                 cp->last = cp->first = tp;
 195         }
 196
 197         reset_operation(op_tmp);
 198         initialize_operation(op_tmp, sms_start_send, (char *)arg_tmp,
 199                              (int (*)())NULL);
 200         queue_operation(cp->con, CON_OUTPUT, op_tmp);
 201 }
 202
 203
 204 do_retr(cl)
 205         client *cl;
 206 {
 207         cl->reply.sms_argc = 0;
 208         cl->reply.sms_status = 0;
 209 #ifdef notdef
 210         if (!cl->clname) {
 211                 com_err(whoami, 0, "Unauthenticated query rejected");
 212                 cl->reply.sms_status = EACCES;
 213                 return;
 214         }
 215 #endif notdef
 216         com_err(whoami, 0, "Processing query: ");
 217         log_args(cl->args->sms_argc, cl->args->sms_argv);
 218
 219         cl->reply.sms_status =
 220           sms_process_query(cl,
 221                             cl->args->sms_argv[0],
 222                             cl->args->sms_argc-1,
 223                             cl->args->sms_argv+1,
 224                             retr_callback,
 225                             (char *)cl);
 226
 227         com_err(whoami, 0, "Query complete.");
 228 }
 229
 230 do_access(cl)
 231         client *cl;
 232 {
 233         cl->reply.sms_argc = 0;
 234         cl->reply.sms_status = 0;
 235 #ifdef notdef
 236         if (!cl->clname) {
 237                 com_err(whoami, 0, "Unauthenticated query rejected");
 238                 cl->reply.sms_status = EACCES;
 239                 return;
 240         }
 241 #endif notdef
 242         com_err(whoami, 0, "Checking access: ");
 243         log_args(cl->args->sms_argc, cl->args->sms_argv);
 244
 245         cl->reply.sms_status =
 246           sms_check_access(cl,
 247                            cl->args->sms_argv[0],
 248                            cl->args->sms_argc-1,
 249                            cl->args->sms_argv+1);
 250
 251         com_err(whoami, 0, "Access check complete.");
 252 }