clients/userreg/reg_stubs.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.1  1987-08-22 18:39:29  wesommer
  10  *      Initial revision
  11  *
  12  */
  13
  14 #ifndef lint
  15 static char *rcsid_reg_stubs_c = "$Header$";
  16 #endif lint
  17 #include <stdio.h>
  18 #include <sys/types.h>
  19 #include <sys/time.h>
  20 #include <sys/socket.h>
  21 #include <netinet/in.h>
  22 #include <netdb.h>
  23 #include <des.h>
  24 #include <errno.h>
  25 #include "ureg_err.h"
  26 #include "ureg_proto.h"
  27 #include <strings.h>
  28
  29 static int reg_sock = -1;
  30 extern errno;
  31 #define UNKNOWN_HOST -1
  32 #define UNKNOWN_SERVICE -2
  33
  34 ureg_init()
  35 {
  36     struct servent *sp;
  37     struct hostent *hp;
  38     struct sockaddr_in sin;
  39
  40     init_ureg_err_tbl();
  41     init_sms_err_tbl();
  42
  43     hp = gethostbyname("sms.mit.edu");
  44     if (hp == NULL) return UNKNOWN_HOST;
  45
  46     sp = getservbyname("sms_ureg", "udp");
  47
  48     if (sp == NULL) return UNKNOWN_SERVICE;
  49
  50     (void) close(reg_sock);
  51     reg_sock = socket(AF_INET, SOCK_DGRAM, 0);
  52     if (reg_sock < 0) return errno;
  53
  54     bzero((char *)&sin, sizeof(sin));
  55     sin.sin_port = sp->s_port;
  56     bcopy(hp->h_addr, (char *)&sin.sin_addr, sizeof(struct in_addr));
  57     sin.sin_family = AF_INET;
  58
  59     if (connect(reg_sock, &sin, sizeof(sin)) < 0)
  60         return errno;
  61     return 0;
  62 }
  63
  64 static int seq_no = 0;
  65
  66 int
  67 verify_user(first, last, idnumber, hashidnumber, login)
  68     char *first, *last, *idnumber, *hashidnumber, *login;
  69 {
  70     char buf[1024];
  71     int version = ntohl((u_long)1);
  72     int call = ntohl((u_long)UREG_VERIFY_USER);
  73     C_Block key;
  74     Key_schedule ks;
  75     register char *bp = buf;
  76     register int len;
  77     char crypt_src[1024];
  78
  79     bcopy((char *)&version, bp, sizeof(int));
  80     bp += sizeof(int);
  81     seq_no++;
  82     bcopy((char *)&seq_no, bp, sizeof(int));
  83
  84     bp += sizeof(int);
  85
  86     bcopy((char *)&call, bp, sizeof(int));
  87
  88     bp += sizeof(int);
  89
  90     (void) strcpy(bp, first);
  91     bp += strlen(bp)+1;
  92
  93     (void) strcpy(bp, last);
  94     bp += strlen(bp)+1;
  95
  96     len = strlen(idnumber) + 1;
  97     bcopy(idnumber, crypt_src, len);
  98
  99     bcopy(hashidnumber, crypt_src+len, 13);
 100
 101     string_to_key(hashidnumber, key);
 102     key_sched(key, ks);
 103     pcbc_encrypt(crypt_src, bp, len+14, ks, key, 1);
 104     bp += len+14+8;
 105     len = bp - buf;
 106     return do_call(buf, len, seq_no, login);
 107 }
 108
 109 grab_login(first, last, idnumber, hashidnumber, login)
 110     char *first, *last, *idnumber, *hashidnumber, *login;
 111 {
 112     char buf[1024];
 113     int version = ntohl((u_long)1);
 114     int call = ntohl((u_long)UREG_RESERVE_LOGIN);
 115     C_Block key;
 116     Key_schedule ks;
 117     register char *bp = buf;
 118     register int len;
 119     int i;
 120
 121     char crypt_src[1024];
 122     char *cbp;
 123
 124     bcopy((char *)&version, bp, sizeof(int));
 125     bp += sizeof(int);
 126     seq_no++;
 127     bcopy((char *)&seq_no, bp, sizeof(int));
 128
 129     bp += sizeof(int);
 130
 131     bcopy((char *)&call, bp, sizeof(int));
 132
 133     bp += sizeof(int);
 134
 135     (void) strcpy(bp, first);
 136     bp += strlen(bp)+1;
 137
 138     (void) strcpy(bp, last);
 139     bp += strlen(bp)+1;
 140
 141     len = strlen(idnumber) + 1;
 142     cbp = crypt_src;
 143
 144     bcopy(idnumber, crypt_src, len);
 145     cbp += len;
 146
 147     bcopy(hashidnumber, cbp, 14);
 148     cbp += 14;
 149
 150     len = strlen(login) + 1;
 151     bcopy(login, cbp, len);
 152     cbp += len;
 153
 154     len = cbp - crypt_src;
 155     string_to_key(hashidnumber, key);
 156     key_sched(key, ks);
 157     pcbc_encrypt(crypt_src, bp, len, ks, key, 1);
 158 #ifdef notdef
 159     for (i = 0; i < len; i++) {
 160         printf("%02.2x ", (unsigned char)bp[i]);
 161     }
 162     printf("\n");
 163 #endif notdef
 164     len = ((len + 7) >> 3) << 3;
 165     bp += len;
 166
 167     len = bp - buf;
 168     return do_call(buf, len, seq_no, 0);
 169
 170 }
 171
 172 set_password(first, last, idnumber, hashidnumber, password)
 173     char *first, *last, *idnumber, *hashidnumber, *password;
 174 {
 175     char buf[1024];
 176     int version = ntohl((u_long)1);
 177     int call = ntohl((u_long)UREG_SET_PASSWORD);
 178     C_Block key;
 179     Key_schedule ks;
 180     register char *bp = buf;
 181     register int len;
 182     int i;
 183
 184     char crypt_src[1024];
 185     char *cbp;
 186
 187     bcopy((char *)&version, bp, sizeof(int));
 188     bp += sizeof(int);
 189     seq_no++;
 190     bcopy((char *)&seq_no, bp, sizeof(int));
 191
 192     bp += sizeof(int);
 193
 194     bcopy((char *)&call, bp, sizeof(int));
 195
 196     bp += sizeof(int);
 197
 198     (void) strcpy(bp, first);
 199     bp += strlen(bp)+1;
 200
 201     (void) strcpy(bp, last);
 202     bp += strlen(bp)+1;
 203
 204     len = strlen(idnumber) + 1;
 205     cbp = crypt_src;
 206
 207     bcopy(idnumber, crypt_src, len);
 208     cbp += len;
 209
 210     bcopy(hashidnumber, cbp, 14);
 211     cbp += 14;
 212
 213     len = strlen(password) + 1;
 214     bcopy(password, cbp, len);
 215     cbp += len;
 216
 217     len = cbp - crypt_src;
 218     string_to_key(hashidnumber, key);
 219     key_sched(key, ks);
 220     pcbc_encrypt(crypt_src, bp, len, ks, key, 1);
 221 #ifdef notdef
 222     for (i = 0; i < len; i++) {
 223         printf("%02.2x ", (unsigned char)bp[i]);
 224     }
 225     printf("\n");
 226 #endif notdef
 227     len = ((len + 7) >> 3) << 3;
 228     bp += len;
 229
 230     len = bp - buf;
 231     return do_call(buf, len, seq_no, 0);
 232
 233 }
 234
 235 static do_call(buf, len, seq_no, login)
 236     char *buf;
 237     char *login;
 238     int seq_no;
 239     int len;
 240 {
 241     struct timeval timeout;
 242     char ibuf[1024];
 243     fd_set set;
 244
 245     int retry = 0;
 246
 247     do {
 248         if (write(reg_sock, buf, len) != len) return errno;
 249
 250         FD_ZERO(&set);
 251         FD_SET(reg_sock, &set);
 252         timeout.tv_sec = 10;
 253         timeout.tv_usec = 0;
 254         do {
 255             int rtn;
 256             struct sockaddr_in sin;
 257             int addrlen = sizeof(sin);
 258             int vno;
 259             int sno;
 260             int stat;
 261
 262             rtn = select(reg_sock+1, &set, (fd_set *)0, (fd_set *)0, &timeout);
 263             if (rtn == 0)
 264                 break;
 265             else if (rtn < 0) return errno;
 266
 267             len = recvfrom(reg_sock, ibuf, BUFSIZ, 0, &sin, &addrlen);
 268             if (len < 0) return errno;
 269             if (len < 12) return UREG_BROKEN_PACKET;
 270             bcopy(ibuf, (char *)&vno, sizeof(long));
 271             vno = ntohl((u_long)vno);
 272             if (vno != 1) continue;
 273             bcopy(ibuf + 4, (char *)&sno, sizeof(long));
 274
 275             if (sno != seq_no) continue;
 276
 277             bcopy(ibuf + 8, (char *)&stat, sizeof(long));
 278             stat = ntohl((u_long)stat);
 279             if (login) {
 280                 bcopy(ibuf+12, login, len-12);
 281                 login[len-12] = '\0';
 282             }
 283             return stat;
 284         } while (1);
 285     } while (++retry < 6);
 286     return ETIMEDOUT;
 287 }
 288
 289 /*
 290  * Local Variables:
 291  * mode: c
 292  * c-indent-level: 4
 293  * c-continued-statement-offset: 4
 294  * c-brace-offset: -4
 295  * c-argdecl-indent: 4
 296  * c-label-offset: -4
 297  * End:
 298  */