server/mr_scall.c

   1 /*
   2  *      $Source$
   3  *      $Author$
   4  *      $Header$
   5  *
   6  *      Copyright (C) 1987 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_sms_scall_c = "$Header$";
  14 #endif lint
  15
  16 #include <mit-copyright.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <sys/file.h>
  20 #include <fcntl.h>
  21 #include <string.h>
  22 #include <krb.h>
  23 #include <errno.h>
  24 #include "mr_server.h"
  25 #include "query.h"
  26 extern char buf1[];
  27 extern int nclients;
  28 extern char *whoami;
  29 extern int errno;
  30
  31 extern void clist_delete(), do_auth(), do_shutdown();
  32 void do_call();
  33 extern int dbms_errno, mr_errcode;
  34 static int row_count;
  35
  36 /* Put this in a variable so that we can patch it if necessary */
  37 int max_row_count = 2048;
  38
  39 /*
  40  * Welcome to the (finite state) machine (highest level).
  41  */
  42 void
  43 do_client(cp)
  44         client *cp;
  45 {
  46         struct stat stbuf;
  47
  48         free_rtn_tuples(cp);
  49         if (OP_STATUS(cp->pending_op) == OP_CANCELLED) {
  50                 com_err(whoami, 0, "Closed connection (now %d client%s, %d new queries, %d old)",
  51                         nclients-1,
  52                         nclients!=2?"s":"",
  53                         newqueries,
  54                         oldqueries);
  55                 clist_delete(cp);
  56                 /* if we no longer have any clients, and we're supposed to
  57                  * go down, then go down now.
  58                  */
  59                 if ((dormant == AWAKE) && (nclients == 0) &&
  60                     (stat(MOIRA_MOTD_FILE, &stbuf) == 0)) {
  61                     com_err(whoami, 0, "motd file exists, slumbertime");
  62                     dormant = SLEEPY;
  63                 }
  64                 return;
  65         }
  66         switch (cp->action) {
  67         case CL_ACCEPT:
  68         case CL_SEND:
  69                 /* Start recieving next request */
  70                 initialize_operation(cp->pending_op, mr_start_recv,
  71                                      (char *)&cp->args, (int (*)())NULL);
  72                 queue_operation(cp->con, CON_INPUT, cp->pending_op);
  73                 cp->action = CL_RECEIVE;
  74                 break;
  75         case CL_RECEIVE:
  76                 /* Data is here. Process it & start it heading back */
  77                 do_call(cp); /* This may block for a while. */
  78                 mr_destroy_reply(cp->args);
  79                 cp->args = NULL;
  80                 initialize_operation(cp->pending_op, mr_start_send,
  81                                      (char *)&cp->reply, (int (*)())NULL);
  82                 queue_operation(cp->con, CON_OUTPUT, cp->pending_op);
  83                 cp->action = CL_SEND;
  84                 break;
  85         }
  86 }
  87
  88 char *procnames[] = {
  89          "noop",
  90          "auth",
  91          "shutdown",
  92          "query",
  93          "access",
  94          "dcm",
  95          "motd",
  96 };
  97
  98
  99 void
 100 do_call(cl)
 101         client *cl;
 102 {
 103         int pn;
 104         cl->reply.mr_argc = 0;
 105         cl->reply.mr_status = 0;
 106         cl->reply.mr_version_no = cl->args->mr_version_no;
 107         if (((pn = cl->args->mr_procno) < 0) ||
 108             (pn > MR_MAX_PROC)) {
 109                 com_err(whoami, 0, "procno out of range");
 110                 cl->reply.mr_status = MR_UNKNOWN_PROC;
 111                 return;
 112         }
 113         if (log_flags & LOG_ARGS)
 114                 log_args(procnames[pn], cl->args->mr_version_no,
 115                          cl->args->mr_argc, cl->args->mr_argv);
 116         else if (log_flags & LOG_REQUESTS)
 117                 com_err(whoami, 0, "%s", procnames[pn]);
 118
 119         if ((dormant == ASLEEP || dormant == GROGGY) &&
 120             pn != MR_NOOP && pn != MR_MOTD) {
 121             cl->reply.mr_status = MR_DOWN;
 122             if (log_flags & LOG_RES)
 123               com_err(whoami, MR_DOWN, "(query refused)");
 124             return;
 125         }
 126
 127         /* make sure this gets cleared before every operation */
 128         dbms_errno = 0;
 129
 130         switch(pn) {
 131         case MR_NOOP:
 132                 cl->reply.mr_status = 0;
 133                 return;
 134
 135         case MR_AUTH:
 136                 do_auth(cl);
 137                 return;
 138
 139         case MR_QUERY:
 140                 do_retr(cl);
 141                 return;
 142
 143         case MR_ACCESS:
 144                 do_access(cl);
 145                 return;
 146
 147         case MR_SHUTDOWN:
 148                 do_shutdown(cl);
 149                 return;
 150
 151         case MR_DO_UPDATE:
 152                 trigger_dcm(0, 0, cl);
 153                 return;
 154
 155         case MR_MOTD:
 156                 get_motd(cl);
 157                 return;
 158         }
 159 }
 160
 161 free_rtn_tuples(cp)
 162         client *cp;
 163 {
 164         register returned_tuples *temp;
 165         for (temp=cp->first; temp && OP_DONE(temp->op); ) {
 166                 register returned_tuples *t1=temp;
 167                 temp = t1->next;
 168                 if (t1 == cp->last) cp->last = NULL;
 169
 170                 mr_destroy_reply(t1->retval);
 171                 delete_operation(t1->op);
 172                 free(t1);
 173         }
 174         cp->first = temp;
 175 }
 176
 177 retr_callback(argc, argv, p_cp)
 178         register int argc;
 179         register char **argv;
 180         char *p_cp;
 181 {
 182         register client *cp = (client *)p_cp;
 183         mr_params *arg_tmp;
 184         returned_tuples *tp;
 185         OPERATION op_tmp;
 186         register char **nargv;
 187         register int i;
 188
 189         if (row_count++ >= max_row_count) {
 190             dbms_errno = mr_errcode = MR_NO_MEM;
 191             return;
 192         }
 193
 194         /*
 195          * This takes too much advantage of the fact that
 196          * serialization of the data happens during the queue operation.
 197          */
 198         arg_tmp = (mr_params *)db_alloc(sizeof(mr_params));
 199         tp = (returned_tuples *)db_alloc(sizeof(returned_tuples));
 200         nargv = (char **)malloc(argc * sizeof(char *));
 201
 202         op_tmp = create_operation();
 203
 204         if (mr_trim_args(argc, argv) == MR_NO_MEM) {
 205             com_err(whoami, MR_NO_MEM, "while trimming args");
 206         }
 207         if (log_flags & LOG_RESP)
 208                 log_args("return: ", cp->args->mr_version_no, argc, argv);
 209
 210         tp->op = op_tmp;
 211         tp->retval = arg_tmp;
 212         tp->next = NULL;
 213
 214         arg_tmp->mr_status = MR_MORE_DATA;
 215         arg_tmp->mr_version_no = cp->args->mr_version_no;
 216         arg_tmp->mr_argc = argc;
 217         arg_tmp->mr_argv = nargv;
 218         for (i = 0; i < argc; i++) {
 219                 register int len = strlen(argv[i]) + 1;
 220                 nargv[i] = malloc(len);
 221                 memcpy(nargv[i], argv[i], len);
 222         }
 223         arg_tmp->mr_flattened = (char *)NULL;
 224         arg_tmp->mr_argl = (int *)NULL;
 225
 226         if (cp->last) {
 227                 cp->last->next = tp;
 228                 cp->last = tp;
 229         } else {
 230                 cp->last = cp->first = tp;
 231         }
 232
 233         reset_operation(op_tmp);
 234         initialize_operation(op_tmp, mr_start_send, (char *)arg_tmp,
 235                              (int (*)())NULL);
 236         queue_operation(cp->con, CON_OUTPUT, op_tmp);
 237 }
 238
 239 list_users(callbk, callarg)
 240         int (*callbk)();
 241         char *callarg;
 242 {
 243         char *argv[6];
 244         char buf[30];
 245         char buf1[30];
 246         int i;
 247         extern client **clients;
 248         extern char *inet_ntoa();
 249         char *cp;
 250         char *ctime();
 251
 252         for (i = 0; i < nclients; i++) {
 253                 register client *cl = clients[i];
 254                 if (cl->clname)
 255                         argv[0] = cl->clname;
 256                 else argv[0] = "unauthenticated";
 257
 258                 argv[1] = inet_ntoa(cl->haddr.sin_addr);
 259                 argv[2] = buf;
 260                 sprintf(buf, "port %d", ntohs(cl->haddr.sin_port));
 261                 argv[3] = ctime(&cl->last_time_used);
 262                 cp = strchr(argv[3], '\n');
 263                 if (cp) *cp = '\0';
 264                 argv[4] = buf1;
 265                 sprintf(buf1, "[#%d]", cl->id);
 266                 (*callbk)(5, argv, callarg);
 267         }
 268         return 0;
 269 }
 270
 271 do_retr(cl)
 272         register client *cl;
 273 {
 274         register char *queryname;
 275
 276         cl->reply.mr_argc = 0;
 277         cl->reply.mr_status = 0;
 278         row_count = 0;
 279
 280         if (cl->args->mr_argc < 1) {
 281             cl->reply.mr_status = MR_ARGS;
 282             com_err(whoami, MR_ARGS, "got nameless query");
 283             return;
 284         }
 285         queryname = cl->args->mr_argv[0];
 286
 287         if (cl->args->mr_version_no == MR_VERSION_2)
 288           newqueries++;
 289         else
 290           oldqueries++;
 291
 292         if (strcmp(queryname, "_list_users") == 0)
 293                 cl->reply.mr_status = list_users(retr_callback, (char *)cl);
 294         else {
 295                 cl->reply.mr_status =
 296                         mr_process_query(cl,
 297                                           queryname,
 298                                           cl->args->mr_argc-1,
 299                                           cl->args->mr_argv+1,
 300                                           retr_callback,
 301                                           (char *)cl);
 302         }
 303         if (row_count >= max_row_count) {
 304             critical_alert("moirad", "attempted query %s with %d rows\n",
 305                            queryname, row_count);
 306         }
 307
 308         if (log_flags & LOG_RES)
 309                 com_err(whoami, 0, "Query complete.");
 310 }
 311
 312 do_access(cl)
 313         client *cl;
 314 {
 315         if (cl->args->mr_argc < 1) {
 316             cl->reply.mr_status = MR_ARGS;
 317             com_err(whoami, MR_ARGS, "got nameless access");
 318             return;
 319         }
 320         cl->reply.mr_argc = 0;
 321
 322         cl->reply.mr_status =
 323           mr_check_access(cl,
 324                            cl->args->mr_argv[0],
 325                            cl->args->mr_argc-1,
 326                            cl->args->mr_argv+1);
 327
 328         com_err(whoami, 0, "Access check complete.");
 329 }
 330
 331
 332 /* trigger_dcm is also used as a followup routine to the
 333  * set_server_host_override query, hence the two dummy arguments.
 334  */
 335
 336 struct query pseudo_query = {
 337         "trigger_dcm",
 338         "tdcm",
 339 };
 340
 341 trigger_dcm(dummy0, dummy1, cl)
 342         int dummy0, dummy1;
 343         client *cl;
 344 {
 345         register int pid;
 346         char prog[128];
 347
 348         cl->reply.mr_argc = 0;
 349
 350         if (cl->reply.mr_status = check_query_access(&pseudo_query, 0, cl) )
 351                 return(cl->reply.mr_status);
 352
 353         sprintf(prog, "%s/startdcm", BIN_DIR);
 354         pid = vfork();
 355         switch (pid) {
 356         case 0:
 357                 execl(prog, "startdcm", 0);
 358                 exit(1);
 359
 360         case -1:
 361                 cl->reply.mr_status = errno;
 362                 return(0);
 363
 364         default:
 365                 return(0);
 366         }
 367 }
 368
 369
 370 get_motd(cl)
 371 client *cl;
 372 {
 373     int motd, len;
 374     char buffer[1024];
 375     char *arg[1];
 376
 377     arg[0] = buffer;
 378     cl->reply.mr_status = 0;
 379     motd = open(MOIRA_MOTD_FILE, 0, O_RDONLY);
 380     if (motd < 0) return;
 381     len = read(motd, buffer, sizeof(buffer) - 1);
 382     close(motd);
 383     buffer[len] = 0;
 384     row_count = 0;
 385     retr_callback(1, arg, cl);
 386     cl->reply.mr_status = 0;
 387 }