4.3BSD - /usr/src/etc/rlogind.c

   1: /*
   2:  * Copyright (c) 1983 Regents of the University of California.
   3:  * All rights reserved.  The Berkeley software License Agreement
   4:  * specifies the terms and conditions for redistribution.
   5:  */
   6: 
   7: #ifndef lint
   8: char copyright[] =
   9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
  10:  All rights reserved.\n";
  11: #endif not lint
  12: 
  13: #ifndef lint
  14: static char sccsid[] = "@(#)rlogind.c	5.11 (Berkeley) 5/23/86";
  15: #endif not lint
  16: 
  17: /*
  18:  * remote login server:
  19:  *	remuser\0
  20:  *	locuser\0
  21:  *	terminal info\0
  22:  *	data
  23:  */
  24: 
  25: #include <stdio.h>
  26: #include <sys/types.h>
  27: #include <sys/stat.h>
  28: #include <sys/socket.h>
  29: #include <sys/wait.h>
  30: #include <sys/file.h>
  31: 
  32: #include <netinet/in.h>
  33: 
  34: #include <errno.h>
  35: #include <pwd.h>
  36: #include <signal.h>
  37: #include <sgtty.h>
  38: #include <stdio.h>
  39: #include <netdb.h>
  40: #include <syslog.h>
  41: #include <strings.h>
  42: 
  43: # ifndef TIOCPKT_WINDOW
  44: # define TIOCPKT_WINDOW 0x80
  45: # endif TIOCPKT_WINDOW
  46: 
  47: extern  errno;
  48: int reapchild();
  49: struct  passwd *getpwnam();
  50: char    *malloc();
  51: 
  52: main(argc, argv)
  53:     int argc;
  54:     char **argv;
  55: {
  56:     int on = 1, options = 0, fromlen;
  57:     struct sockaddr_in from;
  58: 
  59:     openlog("rlogind", LOG_PID | LOG_AUTH, LOG_AUTH);
  60:     fromlen = sizeof (from);
  61:     if (getpeername(0, &from, &fromlen) < 0) {
  62:         fprintf(stderr, "%s: ", argv[0]);
  63:         perror("getpeername");
  64:         _exit(1);
  65:     }
  66:     if (setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof (on)) < 0) {
  67:         syslog(LOG_WARNING, "setsockopt (SO_KEEPALIVE): %m");
  68:     }
  69:     doit(0, &from);
  70: }
  71: 
  72: int child;
  73: int cleanup();
  74: int netf;
  75: extern  errno;
  76: char    *line;
  77: extern  char    *inet_ntoa();
  78: 
  79: struct winsize win = { 0, 0, 0, 0 };
  80: 
  81: 
  82: doit(f, fromp)
  83:     int f;
  84:     struct sockaddr_in *fromp;
  85: {
  86:     int i, p, t, pid, on = 1;
  87:     register struct hostent *hp;
  88:     struct hostent hostent;
  89:     char c;
  90: 
  91:     alarm(60);
  92:     read(f, &c, 1);
  93:     if (c != 0)
  94:         exit(1);
  95:     alarm(0);
  96:     fromp->sin_port = ntohs((u_short)fromp->sin_port);
  97:     hp = gethostbyaddr(&fromp->sin_addr, sizeof (struct in_addr),
  98:         fromp->sin_family);
  99:     if (hp == 0) {
 100:         /*
 101: 		 * Only the name is used below.
 102: 		 */
 103:         hp = &hostent;
 104:         hp->h_name = inet_ntoa(fromp->sin_addr);
 105:     }
 106:     if (fromp->sin_family != AF_INET ||
 107:         fromp->sin_port >= IPPORT_RESERVED)
 108:         fatal(f, "Permission denied");
 109:     write(f, "", 1);
 110:     for (c = 'p'; c <= 's'; c++) {
 111:         struct stat stb;
 112:         line = "/dev/ptyXX";
 113:         line[strlen("/dev/pty")] = c;
 114:         line[strlen("/dev/ptyp")] = '0';
 115:         if (stat(line, &stb) < 0)
 116:             break;
 117:         for (i = 0; i < 16; i++) {
 118:             line[strlen("/dev/ptyp")] = "0123456789abcdef"[i];
 119:             p = open(line, 2);
 120:             if (p > 0)
 121:                 goto gotpty;
 122:         }
 123:     }
 124:     fatal(f, "Out of ptys");
 125:     /*NOTREACHED*/
 126: gotpty:
 127:     (void) ioctl(p, TIOCSWINSZ, &win);
 128:     netf = f;
 129:     line[strlen("/dev/")] = 't';
 130: #ifdef DEBUG
 131:     { int tt = open("/dev/tty", 2);
 132:       if (tt > 0) {
 133:         ioctl(tt, TIOCNOTTY, 0);
 134:         close(tt);
 135:       }
 136:     }
 137: #endif
 138:     t = open(line, 2);
 139:     if (t < 0)
 140:         fatalperror(f, line, errno);
 141:     { struct sgttyb b;
 142:       gtty(t, &b); b.sg_flags = RAW|ANYP; stty(t, &b);
 143:     }
 144:     pid = fork();
 145:     if (pid < 0)
 146:         fatalperror(f, "", errno);
 147:     if (pid == 0) {
 148:         close(f), close(p);
 149:         dup2(t, 0), dup2(t, 1), dup2(t, 2);
 150:         close(t);
 151:         execl("/bin/login", "login", "-r", hp->h_name, 0);
 152:         fatalperror(2, "/bin/login", errno);
 153:         /*NOTREACHED*/
 154:     }
 155:     close(t);
 156:     ioctl(f, FIONBIO, &on);
 157:     ioctl(p, FIONBIO, &on);
 158:     ioctl(p, TIOCPKT, &on);
 159:     signal(SIGTSTP, SIG_IGN);
 160:     signal(SIGCHLD, cleanup);
 161:     setpgrp(0, 0);
 162:     protocol(f, p);
 163:     cleanup();
 164: }
 165: 
 166: char    magic[2] = { 0377, 0377 };
 167: char    oobdata[] = {TIOCPKT_WINDOW};
 168: 
 169: /*
 170:  * Handle a "control" request (signaled by magic being present)
 171:  * in the data stream.  For now, we are only willing to handle
 172:  * window size changes.
 173:  */
 174: control(pty, cp, n)
 175:     int pty;
 176:     char *cp;
 177:     int n;
 178: {
 179:     struct winsize w;
 180: 
 181:     if (n < 4+sizeof (w) || cp[2] != 's' || cp[3] != 's')
 182:         return (0);
 183:     oobdata[0] &= ~TIOCPKT_WINDOW;  /* we know he heard */
 184:     bcopy(cp+4, (char *)&w, sizeof(w));
 185:     w.ws_row = ntohs(w.ws_row);
 186:     w.ws_col = ntohs(w.ws_col);
 187:     w.ws_xpixel = ntohs(w.ws_xpixel);
 188:     w.ws_ypixel = ntohs(w.ws_ypixel);
 189:     (void)ioctl(pty, TIOCSWINSZ, &w);
 190:     return (4+sizeof (w));
 191: }
 192: 
 193: /*
 194:  * rlogin "protocol" machine.
 195:  */
 196: protocol(f, p)
 197:     int f, p;
 198: {
 199:     char pibuf[1024], fibuf[1024], *pbp, *fbp;
 200:     register pcc = 0, fcc = 0;
 201:     int cc;
 202:     char cntl;
 203: 
 204:     /*
 205: 	 * Must ignore SIGTTOU, otherwise we'll stop
 206: 	 * when we try and set slave pty's window shape
 207: 	 * (our controlling tty is the master pty).
 208: 	 */
 209:     (void) signal(SIGTTOU, SIG_IGN);
 210:     send(f, oobdata, 1, MSG_OOB);   /* indicate new rlogin */
 211:     for (;;) {
 212:         int ibits, obits, ebits;
 213: 
 214:         ibits = 0;
 215:         obits = 0;
 216:         if (fcc)
 217:             obits |= (1<<p);
 218:         else
 219:             ibits |= (1<<f);
 220:         if (pcc >= 0)
 221:             if (pcc)
 222:                 obits |= (1<<f);
 223:             else
 224:                 ibits |= (1<<p);
 225:         ebits = (1<<p);
 226:         if (select(16, &ibits, &obits, &ebits, 0) < 0) {
 227:             if (errno == EINTR)
 228:                 continue;
 229:             fatalperror(f, "select", errno);
 230:         }
 231:         if (ibits == 0 && obits == 0 && ebits == 0) {
 232:             /* shouldn't happen... */
 233:             sleep(5);
 234:             continue;
 235:         }
 236: #define pkcontrol(c)    ((c)&(TIOCPKT_FLUSHWRITE|TIOCPKT_NOSTOP|TIOCPKT_DOSTOP))
 237:         if (ebits & (1<<p)) {
 238:             cc = read(p, &cntl, 1);
 239:             if (cc == 1 && pkcontrol(cntl)) {
 240:                 cntl |= oobdata[0];
 241:                 send(f, &cntl, 1, MSG_OOB);
 242:                 if (cntl & TIOCPKT_FLUSHWRITE) {
 243:                     pcc = 0;
 244:                     ibits &= ~(1<<p);
 245:                 }
 246:             }
 247:         }
 248:         if (ibits & (1<<f)) {
 249:             fcc = read(f, fibuf, sizeof (fibuf));
 250:             if (fcc < 0 && errno == EWOULDBLOCK)
 251:                 fcc = 0;
 252:             else {
 253:                 register char *cp;
 254:                 int left, n;
 255: 
 256:                 if (fcc <= 0)
 257:                     break;
 258:                 fbp = fibuf;
 259: 
 260:             top:
 261:                 for (cp = fibuf; cp < fibuf+fcc-1; cp++)
 262:                     if (cp[0] == magic[0] &&
 263:                         cp[1] == magic[1]) {
 264:                         left = fcc - (cp-fibuf);
 265:                         n = control(p, cp, left);
 266:                         if (n) {
 267:                             left -= n;
 268:                             if (left > 0)
 269:                                 bcopy(cp+n, cp, left);
 270:                             fcc -= n;
 271:                             goto top; /* n^2 */
 272:                         }
 273:                     }
 274:             }
 275:         }
 276: 
 277:         if ((obits & (1<<p)) && fcc > 0) {
 278:             cc = write(p, fbp, fcc);
 279:             if (cc > 0) {
 280:                 fcc -= cc;
 281:                 fbp += cc;
 282:             }
 283:         }
 284: 
 285:         if (ibits & (1<<p)) {
 286:             pcc = read(p, pibuf, sizeof (pibuf));
 287:             pbp = pibuf;
 288:             if (pcc < 0 && errno == EWOULDBLOCK)
 289:                 pcc = 0;
 290:             else if (pcc <= 0)
 291:                 break;
 292:             else if (pibuf[0] == 0)
 293:                 pbp++, pcc--;
 294:             else {
 295:                 if (pkcontrol(pibuf[0])) {
 296:                     pibuf[0] |= oobdata[0];
 297:                     send(f, &pibuf[0], 1, MSG_OOB);
 298:                 }
 299:                 pcc = 0;
 300:             }
 301:         }
 302:         if ((obits & (1<<f)) && pcc > 0) {
 303:             cc = write(f, pbp, pcc);
 304:             if (cc < 0 && errno == EWOULDBLOCK) {
 305:                 /* also shouldn't happen */
 306:                 sleep(5);
 307:                 continue;
 308:             }
 309:             if (cc > 0) {
 310:                 pcc -= cc;
 311:                 pbp += cc;
 312:             }
 313:         }
 314:     }
 315: }
 316: 
 317: cleanup()
 318: {
 319: 
 320:     rmut();
 321:     vhangup();      /* XXX */
 322:     shutdown(netf, 2);
 323:     exit(1);
 324: }
 325: 
 326: fatal(f, msg)
 327:     int f;
 328:     char *msg;
 329: {
 330:     char buf[BUFSIZ];
 331: 
 332:     buf[0] = '\01';     /* error indicator */
 333:     (void) sprintf(buf + 1, "rlogind: %s.\r\n", msg);
 334:     (void) write(f, buf, strlen(buf));
 335:     exit(1);
 336: }
 337: 
 338: fatalperror(f, msg, errno)
 339:     int f;
 340:     char *msg;
 341:     int errno;
 342: {
 343:     char buf[BUFSIZ];
 344:     extern int sys_nerr;
 345:     extern char *sys_errlist[];
 346: 
 347:     if ((unsigned)errno < sys_nerr)
 348:         (void) sprintf(buf, "%s: %s", msg, sys_errlist[errno]);
 349:     else
 350:         (void) sprintf(buf, "%s: Error %d", msg, errno);
 351:     fatal(f, buf);
 352: }
 353: 
 354: #include <utmp.h>
 355: 
 356: struct  utmp wtmp;
 357: char    wtmpf[] = "/usr/adm/wtmp";
 358: char    utmpf[] = "/etc/utmp";
 359: #define SCPYN(a, b) strncpy(a, b, sizeof(a))
 360: #define SCMPN(a, b) strncmp(a, b, sizeof(a))
 361: 
 362: rmut()
 363: {
 364:     register f;
 365:     int found = 0;
 366:     struct utmp *u, *utmp;
 367:     int nutmp;
 368:     struct stat statbf;
 369: 
 370:     f = open(utmpf, O_RDWR);
 371:     if (f >= 0) {
 372:         fstat(f, &statbf);
 373:         utmp = (struct utmp *)malloc(statbf.st_size);
 374:         if (!utmp)
 375:             syslog(LOG_ERR, "utmp malloc failed");
 376:         if (statbf.st_size && utmp) {
 377:             nutmp = read(f, utmp, statbf.st_size);
 378:             nutmp /= sizeof(struct utmp);
 379: 
 380:             for (u = utmp ; u < &utmp[nutmp] ; u++) {
 381:                 if (SCMPN(u->ut_line, line+5) ||
 382:                     u->ut_name[0]==0)
 383:                     continue;
 384:                 lseek(f, ((long)u)-((long)utmp), L_SET);
 385:                 SCPYN(u->ut_name, "");
 386:                 SCPYN(u->ut_host, "");
 387:                 time(&u->ut_time);
 388:                 write(f, (char *)u, sizeof(wtmp));
 389:                 found++;
 390:             }
 391:         }
 392:         close(f);
 393:     }
 394:     if (found) {
 395:         f = open(wtmpf, O_WRONLY|O_APPEND);
 396:         if (f >= 0) {
 397:             SCPYN(wtmp.ut_line, line+5);
 398:             SCPYN(wtmp.ut_name, "");
 399:             SCPYN(wtmp.ut_host, "");
 400:             time(&wtmp.ut_time);
 401:             write(f, (char *)&wtmp, sizeof(wtmp));
 402:             close(f);
 403:         }
 404:     }
 405:     chmod(line, 0666);
 406:     chown(line, 0, 0);
 407:     line[strlen("/dev/")] = 'p';
 408:     chmod(line, 0666);
 409:     chown(line, 0, 0);
 410: }

Defined functions

Defined variables

Defined macros