server/mr_glue.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  *      Glue routines to allow the database stuff to be linked in to
  11  *      a program expecting a library level interface.
  12  */
  13
  14 #ifndef lint
  15 static char *rcsid_sms_glue_c = "$Header$";
  16 #endif lint
  17
  18 #include <mit-copyright.h>
  19 #include "sms_server.h"
  20 #include <krb.h>                /* XXX for error codes */
  21 #include <pwd.h>
  22 #include "query.h"
  23
  24 static int already_connected = 0;
  25
  26 #define CHECK_CONNECTED { if (!already_connected) return SMS_NOT_CONNECTED; }
  27
  28 static client pseudo_client;
  29 extern int krb_err_base, errno;
  30 extern char *malloc(), *whoami;
  31 extern time_t now;
  32
  33 sms_connect(server)
  34 char *server;
  35 {
  36     register int status;
  37
  38     if (already_connected) return SMS_ALREADY_CONNECTED;
  39
  40     init_sms_err_tbl();
  41     init_krb_err_tbl();
  42     bzero((char *)&pseudo_client, sizeof(pseudo_client)); /* XXX */
  43
  44     status =  sms_open_database();
  45     if (!status) already_connected = 1;
  46     return status;
  47 }
  48
  49 sms_disconnect()
  50 {
  51     CHECK_CONNECTED;
  52     sms_close_database();
  53     already_connected = 0;
  54     return 0;
  55 }
  56
  57 sms_noop()
  58 {
  59     CHECK_CONNECTED;
  60     return 0;
  61 }
  62 /*
  63  * This routine is rather bogus, as it only fills in who you claim to be.
  64  */
  65 sms_auth(prog)
  66 char *prog;
  67 {
  68     struct passwd *pw;
  69     extern char *krb_realm;
  70     char buf[1024], *strsave();
  71
  72     CHECK_CONNECTED;
  73     pw = getpwuid(getuid());
  74     if (!pw) return (KDC_PR_UNKNOWN + krb_err_base); /* XXX hack (we
  75                                                     * need an extended
  76                                                     * error code table)
  77                                                     */
  78     strcpy(pseudo_client.kname.name, pw->pw_name);
  79     get_krbrlm(pseudo_client.kname.realm, 1);
  80     krb_realm = pseudo_client.kname.realm;
  81
  82     strcpy(buf, pw->pw_name);
  83     strcat(buf, "@");
  84     strcat(buf, pseudo_client.kname.realm);
  85     pseudo_client.clname = malloc(strlen(buf)+1);
  86     strcpy(pseudo_client.clname, buf);
  87     pseudo_client.users_id = get_users_id(pseudo_client.kname.name);
  88     pseudo_client.entity = strsave(prog);
  89     pseudo_client.args = (sms_params *) malloc(sizeof(sms_params));
  90     pseudo_client.args->sms_version_no = SMS_VERSION_2;
  91     return 0;
  92 }
  93
  94 struct hint {
  95     int (*proc)();
  96     char *hint;
  97 };
  98
  99 callback(argc, argv, arg)
 100 int argc;
 101 char **argv;
 102 struct hint *arg;
 103 {
 104     if (sms_trim_args(argc, argv) == SMS_NO_MEM) {
 105         com_err(whoami, SMS_NO_MEM, "while trimmming args");
 106     }
 107     (*arg->proc)(argc, argv, arg->hint);
 108 }
 109
 110
 111 int sms_query(name, argc, argv, callproc, callarg)
 112     char *name;         /* Query name */
 113     int argc;           /* Arg count */
 114     char **argv;                /* Args */
 115     int (*callproc)();  /* Callback procedure */
 116     char *callarg;              /* Callback argument */
 117 {
 118     struct hint hints;
 119
 120     time(&now);
 121     hints.proc = callproc;
 122     hints.hint = callarg;
 123     return sms_process_query(&pseudo_client, name, argc, argv,
 124                              callback, &hints);
 125 }
 126
 127 int sms_access(name, argc, argv)
 128     char *name;                 /* Query name */
 129     int argc;                   /* Arg count */
 130     char **argv;                /* Args */
 131 {
 132     time(&now);
 133     return sms_check_access(&pseudo_client, name, argc, argv);
 134 }
 135
 136 int sms_query_internal(argc, argv, callproc, callarg)
 137     int argc;
 138     char **argv;
 139     int (*callproc)();
 140     char *callarg;
 141 {
 142     struct hint hints;
 143
 144     time(&now);
 145     hints.proc = callproc;
 146     hints.hint = callarg;
 147     return sms_process_query(&pseudo_client, argv[0], argc-1, argv+1,
 148                              callback, &hints);
 149 }
 150
 151 int sms_access_internal(argc, argv)
 152     int argc;
 153     char **argv;
 154 {
 155     time(&now);
 156     return sms_check_access(&pseudo_client, argv[0], argc-1, argv+1);
 157 }
 158
 159 sms_shutdown(why)
 160     char *why;
 161 {
 162     fprintf(stderr, "Sorry, not implemented\n");
 163 }
 164
 165
 166 /* trigger_dcm is also used as a followup routine to the
 167  * set_server_host_override query, hence the two dummy arguments.
 168  */
 169
 170 struct query pseudo_query = {
 171         "trigger_dcm",
 172         "tdcm",
 173 };
 174
 175 trigger_dcm(dummy0, dummy1, cl)
 176         int dummy0, dummy1;
 177         client *cl;
 178 {
 179         register int pid, status;
 180
 181         if (status = check_query_access(&pseudo_query, 0, cl))
 182             return(status);
 183
 184         pid = vfork();
 185         switch (pid) {
 186         case 0:
 187                 execl("/u1/sms/bin/startdcm", "startdcm", 0);
 188                 exit(1);
 189
 190         case -1:
 191                 return(errno);
 192
 193         default:
 194                 return(SMS_SUCCESS);
 195         }
 196 }