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