![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rlogin.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / rlogin|
Return to rlogin.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / rlogin |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983, 1990 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted provided ! 6: * that: (1) source distributions retain this entire copyright notice and ! 7: * comment, and (2) distributions including binaries display the following ! 8: * acknowledgement: ``This product includes software developed by the ! 9: * University of California, Berkeley and its contributors'' in the ! 10: * documentation or other materials provided with the distribution and in ! 11: * all advertising materials mentioning features or use of this software. ! 12: * Neither the name of the University nor the names of its contributors may ! 13: * be used to endorse or promote products derived from this software without ! 14: * specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: char copyright[] = ! 22: "@(#) Copyright (c) 1983, 1990 The Regents of the University of California.\n\ ! 23: All rights reserved.\n"; ! 24: #endif /* not lint */ ! 25: ! 26: #ifndef lint ! 27: static char sccsid[] = "@(#)rlogin.c 5.29 (Berkeley) 6/27/90"; ! 28: #endif /* not lint */ ! 29: ! 30: /* ! 31: * $Source: mit/rlogin/RCS/rlogin.c,v $ ! 32: * $Header: mit/rlogin/RCS/rlogin.c,v 5.2 89/07/26 12:11:21 kfall ! 33: * Exp Locker: kfall $ ! 34: */ ! 35: ! 36: /* ! 37: * rlogin - remote login ! 38: */ ! 39: #include <sys/param.h> ! 40: #include <sys/file.h> ! 41: #include <sys/socket.h> ! 42: #include <sys/signal.h> ! 43: #include <sys/time.h> ! 44: #include <sys/resource.h> ! 45: #include <sys/wait.h> ! 46: ! 47: #include <netinet/in.h> ! 48: #include <netinet/in_systm.h> ! 49: #include <netinet/ip.h> ! 50: #include <netdb.h> ! 51: ! 52: #include <sgtty.h> ! 53: #include <setjmp.h> ! 54: #include <errno.h> ! 55: #include <varargs.h> ! 56: #include <pwd.h> ! 57: #include <stdio.h> ! 58: #include <unistd.h> ! 59: #include <string.h> ! 60: ! 61: #ifdef KERBEROS ! 62: #include <kerberosIV/des.h> ! 63: #include <kerberosIV/krb.h> ! 64: ! 65: CREDENTIALS cred; ! 66: Key_schedule schedule; ! 67: int use_kerberos = 1, encrypt; ! 68: char dst_realm_buf[REALM_SZ], *dest_realm = NULL; ! 69: extern char *krb_realmofhost(); ! 70: #endif ! 71: ! 72: #ifndef TIOCPKT_WINDOW ! 73: #define TIOCPKT_WINDOW 0x80 ! 74: #endif ! 75: ! 76: /* concession to Sun */ ! 77: #ifndef SIGUSR1 ! 78: #define SIGUSR1 30 ! 79: #endif ! 80: ! 81: extern int errno; ! 82: int eight, litout, rem; ! 83: char cmdchar; ! 84: char *speeds[] = { ! 85: "0", "50", "75", "110", "134", "150", "200", "300", "600", "1200", ! 86: "1800", "2400", "4800", "9600", "19200", "38400" ! 87: }; ! 88: ! 89: #ifdef sun ! 90: struct winsize { ! 91: unsigned short ws_row, ws_col; ! 92: unsigned short ws_xpixel, ws_ypixel; ! 93: }; ! 94: #endif ! 95: struct winsize winsize; ! 96: ! 97: #ifndef sun ! 98: #define get_window_size(fd, wp) ioctl(fd, TIOCGWINSZ, wp) ! 99: #endif ! 100: ! 101: void exit(); ! 102: ! 103: main(argc, argv) ! 104: int argc; ! 105: char **argv; ! 106: { ! 107: extern char *optarg; ! 108: extern int optind; ! 109: struct passwd *pw; ! 110: struct servent *sp; ! 111: struct sgttyb ttyb; ! 112: long omask; ! 113: int argoff, ch, dflag, one, uid; ! 114: char *host, *p, *user, term[1024]; ! 115: void lostpeer(); ! 116: char *getenv(); ! 117: ! 118: argoff = dflag = 0; ! 119: one = 1; ! 120: host = user = NULL; ! 121: cmdchar = '~'; ! 122: ! 123: if (p = rindex(argv[0], '/')) ! 124: ++p; ! 125: else ! 126: p = argv[0]; ! 127: ! 128: if (strcmp(p, "rlogin")) ! 129: host = p; ! 130: ! 131: /* handle "rlogin host flags" */ ! 132: if (!host && argc > 2 && argv[1][0] != '-') { ! 133: host = argv[1]; ! 134: argoff = 1; ! 135: } ! 136: ! 137: #ifdef KERBEROS ! 138: #define OPTIONS "8KLde:k:l:x" ! 139: #else ! 140: #define OPTIONS "8KLde:l:" ! 141: #endif ! 142: while ((ch = getopt(argc - argoff, argv + argoff, OPTIONS)) != EOF) ! 143: switch(ch) { ! 144: case '8': ! 145: eight = 1; ! 146: break; ! 147: case 'K': ! 148: #ifdef KERBEROS ! 149: use_kerberos = 0; ! 150: #endif ! 151: break; ! 152: case 'L': ! 153: litout = 1; ! 154: break; ! 155: case 'd': ! 156: dflag = 1; ! 157: break; ! 158: case 'e': ! 159: cmdchar = optarg[0]; ! 160: break; ! 161: #ifdef KERBEROS ! 162: case 'k': ! 163: dest_realm = dst_realm_buf; ! 164: (void)strncpy(dest_realm, optarg, REALM_SZ); ! 165: break; ! 166: #endif ! 167: case 'l': ! 168: user = optarg; ! 169: break; ! 170: #ifdef KERBEROS ! 171: case 'x': ! 172: encrypt = 1; ! 173: des_set_key(cred.session, schedule); ! 174: break; ! 175: #endif ! 176: case '?': ! 177: default: ! 178: usage(); ! 179: } ! 180: optind += argoff; ! 181: argc -= optind; ! 182: argv += optind; ! 183: ! 184: /* if haven't gotten a host yet, do so */ ! 185: if (!host && !(host = *argv++)) ! 186: usage(); ! 187: ! 188: if (*argv) ! 189: usage(); ! 190: ! 191: if (!(pw = getpwuid(uid = getuid()))) { ! 192: (void)fprintf(stderr, "rlogin: unknown user id.\n"); ! 193: exit(1); ! 194: } ! 195: if (!user) ! 196: user = pw->pw_name; ! 197: ! 198: sp = NULL; ! 199: #ifdef KERBEROS ! 200: if (use_kerberos) { ! 201: sp = getservbyname((encrypt ? "eklogin" : "klogin"), "tcp"); ! 202: if (sp == NULL) { ! 203: use_kerberos = 0; ! 204: warning("can't get entry for %s/tcp service", ! 205: encrypt ? "eklogin" : "klogin"); ! 206: } ! 207: } ! 208: #endif ! 209: if (sp == NULL) ! 210: sp = getservbyname("login", "tcp"); ! 211: if (sp == NULL) { ! 212: (void)fprintf(stderr, "rlogin: login/tcp: unknown service.\n"); ! 213: exit(1); ! 214: } ! 215: ! 216: (void)strcpy(term, (p = getenv("TERM")) ? p : "network"); ! 217: if (ioctl(0, TIOCGETP, &ttyb) == 0) { ! 218: (void)strcat(term, "/"); ! 219: (void)strcat(term, speeds[ttyb.sg_ospeed]); ! 220: } ! 221: ! 222: (void)get_window_size(0, &winsize); ! 223: ! 224: (void)signal(SIGPIPE, lostpeer); ! 225: /* will use SIGUSR1 for window size hack, so hold it off */ ! 226: omask = sigblock(sigmask(SIGURG) | sigmask(SIGUSR1)); ! 227: ! 228: #ifdef KERBEROS ! 229: try_connect: ! 230: if (use_kerberos) { ! 231: rem = KSUCCESS; ! 232: errno = 0; ! 233: if (dest_realm == NULL) ! 234: dest_realm = krb_realmofhost(host); ! 235: ! 236: if (encrypt) ! 237: rem = krcmd_mutual(&host, sp->s_port, user, term, 0, ! 238: dest_realm, &cred, schedule); ! 239: else ! 240: rem = krcmd(&host, sp->s_port, user, term, 0, ! 241: dest_realm); ! 242: if (rem < 0) { ! 243: use_kerberos = 0; ! 244: sp = getservbyname("login", "tcp"); ! 245: if (sp == NULL) { ! 246: (void)fprintf(stderr, ! 247: "rlogin: unknown service login/tcp.\n"); ! 248: exit(1); ! 249: } ! 250: if (errno == ECONNREFUSED) ! 251: warning("remote host doesn't support Kerberos"); ! 252: if (errno == ENOENT) ! 253: warning("can't provide Kerberos auth data"); ! 254: goto try_connect; ! 255: } ! 256: } else { ! 257: if (encrypt) { ! 258: (void)fprintf(stderr, ! 259: "rlogin: the -x flag requires Kerberos authentication.\n"); ! 260: exit(1); ! 261: } ! 262: rem = rcmd(&host, sp->s_port, pw->pw_name, user, term, 0); ! 263: } ! 264: #else ! 265: rem = rcmd(&host, sp->s_port, pw->pw_name, user, term, 0); ! 266: #endif ! 267: ! 268: if (rem < 0) ! 269: exit(1); ! 270: ! 271: if (dflag && ! 272: setsockopt(rem, SOL_SOCKET, SO_DEBUG, &one, sizeof(one)) < 0) ! 273: (void)fprintf(stderr, "rlogin: setsockopt: %s.\n", ! 274: strerror(errno)); ! 275: one = IPTOS_LOWDELAY; ! 276: if (setsockopt(rem, IPPROTO_IP, IP_TOS, (char *)&one, sizeof(int)) < 0) ! 277: perror("rlogin: setsockopt TOS (ignored)"); ! 278: ! 279: (void)setuid(uid); ! 280: doit(omask); ! 281: /*NOTREACHED*/ ! 282: } ! 283: ! 284: int child, defflags, deflflags, tabflag; ! 285: char deferase, defkill; ! 286: struct tchars deftc; ! 287: struct ltchars defltc; ! 288: struct tchars notc = { -1, -1, -1, -1, -1, -1 }; ! 289: struct ltchars noltc = { -1, -1, -1, -1, -1, -1 }; ! 290: ! 291: doit(omask) ! 292: long omask; ! 293: { ! 294: struct sgttyb sb; ! 295: void catch_child(), copytochild(), exit(), writeroob(); ! 296: ! 297: (void)ioctl(0, TIOCGETP, (char *)&sb); ! 298: defflags = sb.sg_flags; ! 299: tabflag = defflags & TBDELAY; ! 300: defflags &= ECHO | CRMOD; ! 301: deferase = sb.sg_erase; ! 302: defkill = sb.sg_kill; ! 303: (void)ioctl(0, TIOCLGET, (char *)&deflflags); ! 304: (void)ioctl(0, TIOCGETC, (char *)&deftc); ! 305: notc.t_startc = deftc.t_startc; ! 306: notc.t_stopc = deftc.t_stopc; ! 307: (void)ioctl(0, TIOCGLTC, (char *)&defltc); ! 308: (void)signal(SIGINT, SIG_IGN); ! 309: setsignal(SIGHUP, exit); ! 310: setsignal(SIGQUIT, exit); ! 311: child = fork(); ! 312: if (child == -1) { ! 313: (void)fprintf(stderr, "rlogin: fork: %s.\n", strerror(errno)); ! 314: done(1); ! 315: } ! 316: if (child == 0) { ! 317: mode(1); ! 318: if (reader(omask) == 0) { ! 319: msg("connection closed."); ! 320: exit(0); ! 321: } ! 322: sleep(1); ! 323: msg("\007connection closed."); ! 324: exit(1); ! 325: } ! 326: ! 327: /* ! 328: * We may still own the socket, and may have a pending SIGURG (or might ! 329: * receive one soon) that we really want to send to the reader. Set a ! 330: * trap that simply copies such signals to the child. ! 331: */ ! 332: (void)signal(SIGURG, copytochild); ! 333: (void)signal(SIGUSR1, writeroob); ! 334: (void)sigsetmask(omask); ! 335: (void)signal(SIGCHLD, catch_child); ! 336: writer(); ! 337: msg("closed connection."); ! 338: done(0); ! 339: } ! 340: ! 341: /* trap a signal, unless it is being ignored. */ ! 342: setsignal(sig, act) ! 343: int sig; ! 344: void (*act)(); ! 345: { ! 346: int omask = sigblock(sigmask(sig)); ! 347: ! 348: if (signal(sig, act) == SIG_IGN) ! 349: (void)signal(sig, SIG_IGN); ! 350: (void)sigsetmask(omask); ! 351: } ! 352: ! 353: done(status) ! 354: int status; ! 355: { ! 356: int w; ! 357: ! 358: mode(0); ! 359: if (child > 0) { ! 360: /* make sure catch_child does not snap it up */ ! 361: (void)signal(SIGCHLD, SIG_DFL); ! 362: if (kill(child, SIGKILL) >= 0) ! 363: while ((w = wait((union wait *)0)) > 0 && w != child); ! 364: } ! 365: exit(status); ! 366: } ! 367: ! 368: int dosigwinch; ! 369: ! 370: /* ! 371: * This is called when the reader process gets the out-of-band (urgent) ! 372: * request to turn on the window-changing protocol. ! 373: */ ! 374: void ! 375: writeroob() ! 376: { ! 377: void sigwinch(); ! 378: ! 379: if (dosigwinch == 0) { ! 380: sendwindow(); ! 381: (void)signal(SIGWINCH, sigwinch); ! 382: } ! 383: dosigwinch = 1; ! 384: } ! 385: ! 386: void ! 387: catch_child() ! 388: { ! 389: union wait status; ! 390: int pid; ! 391: ! 392: for (;;) { ! 393: pid = wait3(&status, WNOHANG|WUNTRACED, (struct rusage *)0); ! 394: if (pid == 0) ! 395: return; ! 396: /* if the child (reader) dies, just quit */ ! 397: if (pid < 0 || pid == child && !WIFSTOPPED(status)) ! 398: done((int)(status.w_termsig | status.w_retcode)); ! 399: } ! 400: /* NOTREACHED */ ! 401: } ! 402: ! 403: /* ! 404: * writer: write to remote: 0 -> line. ! 405: * ~. terminate ! 406: * ~^Z suspend rlogin process. ! 407: * ~^Y suspend rlogin process, but leave reader alone. ! 408: */ ! 409: writer() ! 410: { ! 411: char c; ! 412: register int bol, local, n; ! 413: ! 414: bol = 1; /* beginning of line */ ! 415: local = 0; ! 416: for (;;) { ! 417: n = read(STDIN_FILENO, &c, 1); ! 418: if (n <= 0) { ! 419: if (n < 0 && errno == EINTR) ! 420: continue; ! 421: break; ! 422: } ! 423: /* ! 424: * If we're at the beginning of the line and recognize a ! 425: * command character, then we echo locally. Otherwise, ! 426: * characters are echo'd remotely. If the command character ! 427: * is doubled, this acts as a force and local echo is ! 428: * suppressed. ! 429: */ ! 430: if (bol) { ! 431: bol = 0; ! 432: if (c == cmdchar) { ! 433: bol = 0; ! 434: local = 1; ! 435: continue; ! 436: } ! 437: } else if (local) { ! 438: local = 0; ! 439: if (c == '.' || c == deftc.t_eofc) { ! 440: echo(c); ! 441: break; ! 442: } ! 443: if (c == defltc.t_suspc || c == defltc.t_dsuspc) { ! 444: bol = 1; ! 445: echo(c); ! 446: stop(c); ! 447: continue; ! 448: } ! 449: if (c != cmdchar) { ! 450: #ifdef KERBEROS ! 451: if (encrypt) { ! 452: (void)des_write(rem, &cmdchar, 1); ! 453: } else ! 454: #endif ! 455: (void)write(rem, &cmdchar, 1); ! 456: } ! 457: } ! 458: ! 459: #ifdef KERBEROS ! 460: if (encrypt) { ! 461: if (des_write(rem, &c, 1) == 0) { ! 462: msg("line gone"); ! 463: break; ! 464: } ! 465: } else ! 466: #endif ! 467: if (write(rem, &c, 1) == 0) { ! 468: msg("line gone"); ! 469: break; ! 470: } ! 471: bol = c == defkill || c == deftc.t_eofc || ! 472: c == deftc.t_intrc || c == defltc.t_suspc || ! 473: c == '\r' || c == '\n'; ! 474: } ! 475: } ! 476: ! 477: echo(c) ! 478: register char c; ! 479: { ! 480: register char *p; ! 481: char buf[8]; ! 482: ! 483: p = buf; ! 484: c &= 0177; ! 485: *p++ = cmdchar; ! 486: if (c < ' ') { ! 487: *p++ = '^'; ! 488: *p++ = c + '@'; ! 489: } else if (c == 0177) { ! 490: *p++ = '^'; ! 491: *p++ = '?'; ! 492: } else ! 493: *p++ = c; ! 494: *p++ = '\r'; ! 495: *p++ = '\n'; ! 496: (void)write(1, buf, p - buf); ! 497: } ! 498: ! 499: stop(cmdc) ! 500: char cmdc; ! 501: { ! 502: mode(0); ! 503: (void)signal(SIGCHLD, SIG_IGN); ! 504: (void)kill(cmdc == defltc.t_suspc ? 0 : getpid(), SIGTSTP); ! 505: (void)signal(SIGCHLD, catch_child); ! 506: mode(1); ! 507: sigwinch(); /* check for size changes */ ! 508: } ! 509: ! 510: void ! 511: sigwinch() ! 512: { ! 513: struct winsize ws; ! 514: ! 515: if (dosigwinch && get_window_size(0, &ws) == 0 && ! 516: bcmp(&ws, &winsize, sizeof(ws))) { ! 517: winsize = ws; ! 518: sendwindow(); ! 519: } ! 520: } ! 521: ! 522: /* ! 523: * Send the window size to the server via the magic escape ! 524: */ ! 525: sendwindow() ! 526: { ! 527: struct winsize *wp; ! 528: char obuf[4 + sizeof (struct winsize)]; ! 529: ! 530: wp = (struct winsize *)(obuf+4); ! 531: obuf[0] = 0377; ! 532: obuf[1] = 0377; ! 533: obuf[2] = 's'; ! 534: obuf[3] = 's'; ! 535: wp->ws_row = htons(winsize.ws_row); ! 536: wp->ws_col = htons(winsize.ws_col); ! 537: wp->ws_xpixel = htons(winsize.ws_xpixel); ! 538: wp->ws_ypixel = htons(winsize.ws_ypixel); ! 539: ! 540: #ifdef KERBEROS ! 541: if(encrypt) ! 542: (void)des_write(rem, obuf, sizeof(obuf)); ! 543: else ! 544: #endif ! 545: (void)write(rem, obuf, sizeof(obuf)); ! 546: } ! 547: ! 548: /* ! 549: * reader: read from remote: line -> 1 ! 550: */ ! 551: #define READING 1 ! 552: #define WRITING 2 ! 553: ! 554: jmp_buf rcvtop; ! 555: int ppid, rcvcnt, rcvstate; ! 556: char rcvbuf[8 * 1024]; ! 557: ! 558: void ! 559: oob() ! 560: { ! 561: struct sgttyb sb; ! 562: int atmark, n, out, rcvd; ! 563: char waste[BUFSIZ], mark; ! 564: ! 565: out = O_RDWR; ! 566: rcvd = 0; ! 567: while (recv(rem, &mark, 1, MSG_OOB) < 0) ! 568: switch (errno) { ! 569: case EWOULDBLOCK: ! 570: /* ! 571: * Urgent data not here yet. It may not be possible ! 572: * to send it yet if we are blocked for output and ! 573: * our input buffer is full. ! 574: */ ! 575: if (rcvcnt < sizeof(rcvbuf)) { ! 576: n = read(rem, rcvbuf + rcvcnt, ! 577: sizeof(rcvbuf) - rcvcnt); ! 578: if (n <= 0) ! 579: return; ! 580: rcvd += n; ! 581: } else { ! 582: n = read(rem, waste, sizeof(waste)); ! 583: if (n <= 0) ! 584: return; ! 585: } ! 586: continue; ! 587: default: ! 588: return; ! 589: } ! 590: if (mark & TIOCPKT_WINDOW) { ! 591: /* Let server know about window size changes */ ! 592: (void)kill(ppid, SIGUSR1); ! 593: } ! 594: if (!eight && (mark & TIOCPKT_NOSTOP)) { ! 595: (void)ioctl(0, TIOCGETP, (char *)&sb); ! 596: sb.sg_flags &= ~CBREAK; ! 597: sb.sg_flags |= RAW; ! 598: (void)ioctl(0, TIOCSETN, (char *)&sb); ! 599: notc.t_stopc = -1; ! 600: notc.t_startc = -1; ! 601: (void)ioctl(0, TIOCSETC, (char *)¬c); ! 602: } ! 603: if (!eight && (mark & TIOCPKT_DOSTOP)) { ! 604: (void)ioctl(0, TIOCGETP, (char *)&sb); ! 605: sb.sg_flags &= ~RAW; ! 606: sb.sg_flags |= CBREAK; ! 607: (void)ioctl(0, TIOCSETN, (char *)&sb); ! 608: notc.t_stopc = deftc.t_stopc; ! 609: notc.t_startc = deftc.t_startc; ! 610: (void)ioctl(0, TIOCSETC, (char *)¬c); ! 611: } ! 612: if (mark & TIOCPKT_FLUSHWRITE) { ! 613: (void)ioctl(1, TIOCFLUSH, (char *)&out); ! 614: for (;;) { ! 615: if (ioctl(rem, SIOCATMARK, &atmark) < 0) { ! 616: (void)fprintf(stderr, "rlogin: ioctl: %s.\n", ! 617: strerror(errno)); ! 618: break; ! 619: } ! 620: if (atmark) ! 621: break; ! 622: n = read(rem, waste, sizeof (waste)); ! 623: if (n <= 0) ! 624: break; ! 625: } ! 626: /* ! 627: * Don't want any pending data to be output, so clear the recv ! 628: * buffer. If we were hanging on a write when interrupted, ! 629: * don't want it to restart. If we were reading, restart ! 630: * anyway. ! 631: */ ! 632: rcvcnt = 0; ! 633: longjmp(rcvtop, 1); ! 634: } ! 635: ! 636: /* oob does not do FLUSHREAD (alas!) */ ! 637: ! 638: /* ! 639: * If we filled the receive buffer while a read was pending, longjmp ! 640: * to the top to restart appropriately. Don't abort a pending write, ! 641: * however, or we won't know how much was written. ! 642: */ ! 643: if (rcvd && rcvstate == READING) ! 644: longjmp(rcvtop, 1); ! 645: } ! 646: ! 647: /* reader: read from remote: line -> 1 */ ! 648: reader(omask) ! 649: int omask; ! 650: { ! 651: void oob(); ! 652: ! 653: #if !defined(BSD) || BSD < 43 ! 654: int pid = -getpid(); ! 655: #else ! 656: int pid = getpid(); ! 657: #endif ! 658: int n, remaining; ! 659: char *bufp = rcvbuf; ! 660: ! 661: (void)signal(SIGTTOU, SIG_IGN); ! 662: (void)signal(SIGURG, oob); ! 663: ppid = getppid(); ! 664: (void)fcntl(rem, F_SETOWN, pid); ! 665: (void)setjmp(rcvtop); ! 666: (void)sigsetmask(omask); ! 667: for (;;) { ! 668: while ((remaining = rcvcnt - (bufp - rcvbuf)) > 0) { ! 669: rcvstate = WRITING; ! 670: n = write(1, bufp, remaining); ! 671: if (n < 0) { ! 672: if (errno != EINTR) ! 673: return(-1); ! 674: continue; ! 675: } ! 676: bufp += n; ! 677: } ! 678: bufp = rcvbuf; ! 679: rcvcnt = 0; ! 680: rcvstate = READING; ! 681: ! 682: #ifdef KERBEROS ! 683: if (encrypt) ! 684: rcvcnt = des_read(rem, rcvbuf, sizeof(rcvbuf)); ! 685: else ! 686: #endif ! 687: rcvcnt = read(rem, rcvbuf, sizeof (rcvbuf)); ! 688: if (rcvcnt == 0) ! 689: return (0); ! 690: if (rcvcnt < 0) { ! 691: if (errno == EINTR) ! 692: continue; ! 693: (void)fprintf(stderr, "rlogin: read: %s.\n", ! 694: strerror(errno)); ! 695: return(-1); ! 696: } ! 697: } ! 698: } ! 699: ! 700: mode(f) ! 701: { ! 702: struct ltchars *ltc; ! 703: struct sgttyb sb; ! 704: struct tchars *tc; ! 705: int lflags; ! 706: ! 707: (void)ioctl(0, TIOCGETP, (char *)&sb); ! 708: (void)ioctl(0, TIOCLGET, (char *)&lflags); ! 709: switch(f) { ! 710: case 0: ! 711: sb.sg_flags &= ~(CBREAK|RAW|TBDELAY); ! 712: sb.sg_flags |= defflags|tabflag; ! 713: tc = &deftc; ! 714: ltc = &defltc; ! 715: sb.sg_kill = defkill; ! 716: sb.sg_erase = deferase; ! 717: lflags = deflflags; ! 718: break; ! 719: case 1: ! 720: sb.sg_flags |= (eight ? RAW : CBREAK); ! 721: sb.sg_flags &= ~defflags; ! 722: /* preserve tab delays, but turn off XTABS */ ! 723: if ((sb.sg_flags & TBDELAY) == XTABS) ! 724: sb.sg_flags &= ~TBDELAY; ! 725: tc = ¬c; ! 726: ltc = &noltc; ! 727: sb.sg_kill = sb.sg_erase = -1; ! 728: if (litout) ! 729: lflags |= LLITOUT; ! 730: break; ! 731: default: ! 732: return; ! 733: } ! 734: (void)ioctl(0, TIOCSLTC, (char *)ltc); ! 735: (void)ioctl(0, TIOCSETC, (char *)tc); ! 736: (void)ioctl(0, TIOCSETN, (char *)&sb); ! 737: (void)ioctl(0, TIOCLSET, (char *)&lflags); ! 738: } ! 739: ! 740: void ! 741: lostpeer() ! 742: { ! 743: (void)signal(SIGPIPE, SIG_IGN); ! 744: msg("\007connection closed."); ! 745: done(1); ! 746: } ! 747: ! 748: /* copy SIGURGs to the child process. */ ! 749: void ! 750: copytochild() ! 751: { ! 752: (void)kill(child, SIGURG); ! 753: } ! 754: ! 755: msg(str) ! 756: char *str; ! 757: { ! 758: (void)fprintf(stderr, "rlogin: %s\r\n", str); ! 759: } ! 760: ! 761: #ifdef KERBEROS ! 762: /* VARARGS */ ! 763: warning(va_alist) ! 764: va_dcl ! 765: { ! 766: va_list ap; ! 767: char *fmt; ! 768: ! 769: (void)fprintf(stderr, "rlogin: warning, using standard rlogin: "); ! 770: va_start(ap); ! 771: fmt = va_arg(ap, char *); ! 772: vfprintf(stderr, fmt, ap); ! 773: va_end(ap); ! 774: (void)fprintf(stderr, ".\n"); ! 775: } ! 776: #endif ! 777: ! 778: usage() ! 779: { ! 780: (void)fprintf(stderr, ! 781: "usage: rlogin [ -%s]%s[-e char] [ -l username ] host\n", ! 782: #ifdef KERBEROS ! 783: "8Lx", " [-k realm] "); ! 784: #else ! 785: "8L", " "); ! 786: #endif ! 787: exit(1); ! 788: } ! 789: ! 790: /* ! 791: * The following routine provides compatibility (such as it is) between 4.2BSD ! 792: * Suns and others. Suns have only a `ttysize', so we convert it to a winsize. ! 793: */ ! 794: #ifdef sun ! 795: int ! 796: get_window_size(fd, wp) ! 797: int fd; ! 798: struct winsize *wp; ! 799: { ! 800: struct ttysize ts; ! 801: int error; ! 802: ! 803: if ((error = ioctl(0, TIOCGSIZE, &ts)) != 0) ! 804: return(error); ! 805: wp->ws_row = ts.ts_lines; ! 806: wp->ws_col = ts.ts_cols; ! 807: wp->ws_xpixel = 0; ! 808: wp->ws_ypixel = 0; ! 809: return(0); ! 810: } ! 811: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.