Added range checking.

[moira.git] / server / mr_scall.c

diff --git a/server/mr_scall.c b/server/mr_scall.c
index b9419900ae2e606a58d810fe562a51d7c2f17c1d..1589426bc960075e4678c0fc91114b59377b22cf 100644 (file)
--- a/server/mr_scall.c
+++ b/server/mr_scall.c
@@ -6,9 +6,19 @@
  *     Copyright (C) 1987 by the Massachusetts Institute of Technology
  *
  *     $Log$
- *     Revision 1.3  1987-06-04 01:35:01  wesommer
- *     Added a working query request handler.
+ *     Revision 1.6  1987-06-30 20:04:43  wesommer
+ *     Free returned tuples when possible.
  *
+ * Revision 1.5  87/06/26  10:55:53  wesommer
+ * Added sms_access, now paiys attention to return code from 
+ * sms_process_query, sms_check_access.
+ * 
+ * Revision 1.4  87/06/21  16:42:00  wesommer
+ * Performance work, rearrangement of include files.
+ * 
+ * Revision 1.3  87/06/04  01:35:01  wesommer
+ * Added a working query request handler.
+ * 
  * Revision 1.2  87/06/03  16:07:50  wesommer
  * Fixes for lint.
  * 
@@ -23,7 +33,6 @@ static char *rcsid_sms_scall_c = "$Header$";
 
 #include <krb.h>
 #include <errno.h>
-#include "sms_private.h"
 #include "sms_server.h"
 extern char buf1[];
 extern int nclients;
@@ -39,6 +48,7 @@ void
 do_client(cp)
        client *cp;
 {
+       free_rtn_tuples(cp);
        if (OP_STATUS(cp->pending_op) == OP_CANCELLED) {
                (void) sprintf(buf1, "Closed connection (now %d client%s)",
                               nclients-1,
@@ -103,6 +113,7 @@ do_call(cl)
                cl->reply.sms_status = 0;
                com_err(whoami, 0, "noop");
                return;
+
        case SMS_AUTH:
                do_auth(cl);
                return;
@@ -111,37 +122,78 @@ do_call(cl)
                do_retr(cl);
                return;
 
+       case SMS_ACCESS:
+               do_access(cl);
+               return;
+               
        case SMS_SHUTDOWN:
                do_shutdown(cl);
                return;
        }
 }
 
+free_rtn_tuples(cp)
+       client *cp;
+{
+       register returned_tuples *temp;
+       for (temp=cp->first; temp && OP_DONE(temp->op); ) {
+               register returned_tuples *t1=temp;
+               temp = t1->next;
+               if (t1 == cp->last) cp->last = NULL;
+#ifdef notdef
+               sms_destroy_reply(t1->retval);
+#endif notdef
+               if (t1->retval) {
+                       register sms_params *p = t1->retval;
+                       if (p->sms_flattened)
+                               free(p->sms_flattened);
+                       if (p->sms_argl)
+                               free(p->sms_argl);
+                       free(p);
+               }
+               delete_operation(t1->op);
+               free(t1);
+       }
+       cp->first = temp;
+}      
+
 retr_callback(argc, argv, p_cp)
        int argc;
        char **argv;
        char *p_cp;
 {
        register client *cp = (client *)p_cp;
-       /* XXX MEM when are these freed?? */
        /*
         * This takes too much advantage of the fact that
         * serialization of the data happens during the queue operation.
         */
        sms_params *arg_tmp = (sms_params *)db_alloc(sizeof(sms_params));
-       OPERATION op_tmp = create_operation();
+       returned_tuples *tp = (returned_tuples *)
+               db_alloc(sizeof(returned_tuples));
        
+       OPERATION op_tmp = create_operation();
 
 #ifdef notdef                  /* We really don't want this logged */
        com_err(whoami, 0, "Returning next data:");
        log_args(argc, argv);
 #endif notdef
+       tp->op = op_tmp;
+       tp->retval = arg_tmp;
+       tp->next = NULL;
        
        arg_tmp->sms_status = SMS_MORE_DATA;
        arg_tmp->sms_argc = argc;
        arg_tmp->sms_argv = argv;
        arg_tmp->sms_flattened = (char *)NULL;
        arg_tmp->sms_argl = (int *)NULL;
+
+       if (cp->last) {
+               cp->last->next = tp;
+               cp->last = tp;
+       } else {
+               cp->last = cp->first = tp;
+       }
+       
        reset_operation(op_tmp);
        initialize_operation(op_tmp, sms_start_send, (char *)arg_tmp,
                             (int (*)())NULL);
@@ -154,21 +206,47 @@ do_retr(cl)
 {
        cl->reply.sms_argc = 0;
        cl->reply.sms_status = 0;
-
+#ifdef notdef
        if (!cl->clname) {
                com_err(whoami, 0, "Unauthenticated query rejected");
                cl->reply.sms_status = EACCES;
                return;
        }
+#endif notdef
        com_err(whoami, 0, "Processing query: ");
        log_args(cl->args->sms_argc, cl->args->sms_argv);
        
-       sms_process_query(cl->args->sms_argv[0],
-                         cl->args->sms_argc-1,
-                         cl->args->sms_argv+1,
-                         retr_callback,
-                         (char *)cl);
+       cl->reply.sms_status = 
+         sms_process_query(cl,
+                           cl->args->sms_argv[0],
+                           cl->args->sms_argc-1,
+                           cl->args->sms_argv+1,
+                           retr_callback,
+                           (char *)cl);
 
        com_err(whoami, 0, "Query complete.");
 }
 
+do_access(cl)
+       client *cl;
+{
+       cl->reply.sms_argc = 0;
+       cl->reply.sms_status = 0;
+#ifdef notdef
+       if (!cl->clname) {
+               com_err(whoami, 0, "Unauthenticated query rejected");
+               cl->reply.sms_status = EACCES;
+               return;
+       }
+#endif notdef
+       com_err(whoami, 0, "Checking access: ");
+       log_args(cl->args->sms_argc, cl->args->sms_argv);
+       
+       cl->reply.sms_status = 
+         sms_check_access(cl,
+                          cl->args->sms_argv[0],
+                          cl->args->sms_argc-1,
+                          cl->args->sms_argv+1);
+       
+       com_err(whoami, 0, "Access check complete.");
+}