/* * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights * Reserved. This file contains Original Code and/or Modifications of * Original Code as defined in and that are subject to the Apple Public * Source License Version 1.0 (the 'License'). You may not use this file * except in compliance with the License. Please obtain a copy of the * License at http://www.apple.com/publicsource and read it before using * this file. * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the * License for the specific language governing rights and limitations * under the License." * * @APPLE_LICENSE_HEADER_END@ */ /* * Copyright (c) 1983, 1990, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * rlogin - remote login */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __STDC__ #include #else #include #endif #ifdef KERBEROS #include #include #include "krb.h" CREDENTIALS cred; Key_schedule schedule; int use_kerberos = 1, doencrypt; char dst_realm_buf[REALM_SZ], *dest_realm = NULL; #endif #ifndef TIOCPKT_WINDOW #define TIOCPKT_WINDOW 0x80 #endif /* concession to Sun */ #ifndef SIGUSR1 #define SIGUSR1 30 #endif int eight, litout, rem; int noescape; u_char escapechar = '~'; #ifdef OLDSUN struct winsize { unsigned short ws_row, ws_col; unsigned short ws_xpixel, ws_ypixel; }; #else #define get_window_size(fd, wp) ioctl(fd, TIOCGWINSZ, wp) #endif struct winsize winsize; void catch_child __P((int)); void copytochild __P((int)); __dead void doit __P((sigset_t *)); __dead void done __P((int)); void echo __P((char)); u_int getescape __P((char *)); static void do_exit __P((int)); void lostpeer __P((int)); void mode __P((int)); void msg __P((char *)); void oob __P((int)); int reader __P((sigset_t *)); void sendwindow __P((void)); void setsignal __P((int)); int speed __P((int)); void sigwinch __P((int)); void stop __P((char)); __dead void usage __P((void)); void writer __P((void)); void writeroob __P((int)); #ifdef KERBEROS void warning __P((const char *, ...)); #endif #ifdef OLDSUN int get_window_size __P((int, struct winsize *)); #endif int main(argc, argv) int argc; char *argv[]; { struct passwd *pw; struct servent *sp; sigset_t smask; uid_t uid; int argoff, ch, dflag, one; char *host, *p, *user, term[1024]; struct sigaction sa; argoff = dflag = 0; one = 1; host = user = NULL; if (p = strrchr(argv[0], '/')) ++p; else p = argv[0]; if (strcmp(p, "rlogin") != 0) host = p; /* handle "rlogin host flags" */ if (!host && argc > 2 && argv[1][0] != '-') { host = argv[1]; argoff = 1; } #ifdef KERBEROS #define OPTIONS "8EKLde:k:l:x" #else #define OPTIONS "8EKLde:l:" #endif while ((ch = getopt(argc - argoff, argv + argoff, OPTIONS)) != EOF) switch(ch) { case '8': eight = 1; break; case 'E': noescape = 1; break; case 'K': #ifdef KERBEROS use_kerberos = 0; #endif break; case 'L': litout = 1; break; case 'd': dflag = 1; break; case 'e': noescape = 0; escapechar = getescape(optarg); break; #ifdef KERBEROS case 'k': dest_realm = dst_realm_buf; (void)strncpy(dest_realm, optarg, REALM_SZ); break; #endif case 'l': user = optarg; break; #ifdef CRYPT #ifdef KERBEROS case 'x': doencrypt = 1; des_set_key(cred.session, schedule); break; #endif #endif case '?': default: usage(); } optind += argoff; argc -= optind; argv += optind; /* if haven't gotten a host yet, do so */ if (!host && !(host = *argv++)) usage(); if (*argv) usage(); if (!(pw = getpwuid(uid = getuid()))) errx(1, "unknown user id."); /* Accept user1@host format, though "-l user2" overrides user1 */ p = strchr(host, '@'); if (p) { *p = '\0'; if (!user && p > host) user = host; host = p + 1; if (*host == '\0') usage(); } if (!user) user = pw->pw_name; sp = NULL; #ifdef KERBEROS if (use_kerberos) { sp = getservbyname((doencrypt ? "eklogin" : "klogin"), "tcp"); if (sp == NULL) { use_kerberos = 0; warning("can't get entry for %s/tcp service", doencrypt ? "eklogin" : "klogin"); } } #endif if (sp == NULL) sp = getservbyname("login", "tcp"); if (sp == NULL) errx(1, "login/tcp: unknown service."); (void)snprintf(term, sizeof(term), "%s/%d", ((p = getenv("TERM")) ? p : "network"), speed(0)); (void)get_window_size(0, &winsize); sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART; sa.sa_handler = lostpeer; (void)sigaction(SIGPIPE, &sa, (struct sigaction *) 0); /* will use SIGUSR1 for window size hack, so hold it off */ sigemptyset(&smask); sigaddset(&smask, SIGURG); sigaddset(&smask, SIGUSR1); (void)sigprocmask(SIG_SETMASK, &smask, &smask); /* * We set SIGURG and SIGUSR1 below so that an * incoming signal will be held pending rather than being * discarded. Note that these routines will be ready to get * a signal by the time that they are unblocked below. */ sa.sa_handler = copytochild; (void)sigaction(SIGURG, &sa, (struct sigaction *) 0); sa.sa_handler = writeroob; (void)sigaction(SIGUSR1, &sa, (struct sigaction *) 0); #ifdef KERBEROS try_connect: if (use_kerberos) { struct hostent *hp; /* Fully qualify hostname (needed for krb_realmofhost). */ hp = gethostbyname(host); if (hp != NULL && !(host = strdup(hp->h_name))) errx(1, "%s", strerror(ENOMEM)); rem = KSUCCESS; errno = 0; if (dest_realm == NULL) dest_realm = krb_realmofhost(host); #ifdef CRYPT if (doencrypt) rem = krcmd_mutual(&host, sp->s_port, user, term, 0, dest_realm, &cred, schedule); else #endif /* CRYPT */ rem = krcmd(&host, sp->s_port, user, term, 0, dest_realm); if (rem < 0) { use_kerberos = 0; sp = getservbyname("login", "tcp"); if (sp == NULL) errx(1, "unknown service login/tcp."); if (errno == ECONNREFUSED) warning("remote host doesn't support Kerberos"); if (errno == ENOENT) warning("can't provide Kerberos auth data"); goto try_connect; } } else { #ifdef CRYPT if (doencrypt) errx(1, "the -x flag requires Kerberos authentication."); #endif /* CRYPT */ rem = rcmd(&host, sp->s_port, pw->pw_name, user, term, 0); } #else rem = rcmd(&host, sp->s_port, pw->pw_name, user, term, 0); #endif /* KERBEROS */ if (rem < 0) exit(1); if (dflag && setsockopt(rem, SOL_SOCKET, SO_DEBUG, &one, sizeof(one)) < 0) warn("setsockopt DEBUG (ignored)"); one = IPTOS_LOWDELAY; if (setsockopt(rem, IPPROTO_IP, IP_TOS, (char *)&one, sizeof(int)) < 0) warn("setsockopt TOS (ignored)"); (void)setuid(uid); doit(&smask); /*NOTREACHED*/ } #if BSD >= 198810 int speed(fd) int fd; { struct termios tt; (void)tcgetattr(fd, &tt); return ((int) cfgetispeed(&tt)); } #else int speeds[] = { /* for older systems, B0 .. EXTB */ 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19200, 38400 }; int speed(fd) int fd; { struct termios tt; (void)tcgetattr(fd, &tt); return (speeds[(int)cfgetispeed(&tt)]); } #endif pid_t child; struct termios deftt; struct termios nott; void doit(smask) sigset_t *smask; { int i; struct sigaction sa; for (i = 0; i < NCCS; i++) nott.c_cc[i] = _POSIX_VDISABLE; tcgetattr(0, &deftt); nott.c_cc[VSTART] = deftt.c_cc[VSTART]; nott.c_cc[VSTOP] = deftt.c_cc[VSTOP]; sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART; sa.sa_handler = SIG_IGN; (void)sigaction(SIGINT, &sa, (struct sigaction *) 0); setsignal(SIGHUP); setsignal(SIGQUIT); child = fork(); if (child == -1) { warn("fork"); done(1); } if (child == 0) { mode(1); if (reader(smask) == 0) { msg("connection closed."); exit(0); } sleep(1); msg("\007connection closed."); exit(1); } /* * We may still own the socket, and may have a pending SIGURG (or might * receive one soon) that we really want to send to the reader. When * one of these comes in, the trap copytochild simply copies such * signals to the child. We can now unblock SIGURG and SIGUSR1 * that were set above. */ (void)sigprocmask(SIG_SETMASK, smask, (sigset_t *) 0); sa.sa_handler = catch_child; (void)sigaction(SIGCHLD, &sa, (struct sigaction *) 0); writer(); msg("closed connection."); done(0); } /* trap a signal, unless it is being ignored. */ void setsignal(sig) int sig; { struct sigaction sa; sigset_t sigs; sigemptyset(&sigs); sigaddset(&sigs, sig); sigprocmask(SIG_BLOCK, &sigs, &sigs); sigemptyset(&sa.sa_mask); sa.sa_handler = do_exit; sa.sa_flags = SA_RESTART; (void)sigaction(sig, &sa, &sa); if (sa.sa_handler == SIG_IGN) (void)sigaction(sig, &sa, (struct sigaction *) 0); (void)sigprocmask(SIG_SETMASK, &sigs, (sigset_t *) 0); } __dead void done(status) int status; { pid_t w; int wstatus; struct sigaction sa; mode(0); if (child > 0) { /* make sure catch_child does not snap it up */ sigemptyset(&sa.sa_mask); sa.sa_handler = SIG_DFL; sa.sa_flags = 0; (void)sigaction(SIGCHLD, &sa, (struct sigaction *) 0); if (kill(child, SIGKILL) >= 0) while ((w = wait(&wstatus)) > 0 && w != child) continue; } exit(status); } int dosigwinch; /* * This is called when the reader process gets the out-of-band (urgent) * request to turn on the window-changing protocol. */ void writeroob(signo) int signo; { struct sigaction sa; if (dosigwinch == 0) { sendwindow(); sigemptyset(&sa.sa_mask); sa.sa_handler = sigwinch; sa.sa_flags = SA_RESTART; (void)sigaction(SIGWINCH, &sa, (struct sigaction *) 0); } dosigwinch = 1; } void catch_child(signo) int signo; { int status; pid_t pid; for (;;) { pid = waitpid(-1, &status, WNOHANG|WUNTRACED); if (pid == 0) return; /* if the child (reader) dies, just quit */ if (pid < 0 || (pid == child && !WIFSTOPPED(status))) done(WEXITSTATUS(status) | WTERMSIG(status)); } /* NOTREACHED */ } /* * writer: write to remote: 0 -> line. * ~. terminate * ~^Z suspend rlogin process. * ~ suspend rlogin process, but leave reader alone. */ void writer() { register int bol, local, n; char c; bol = 1; /* beginning of line */ local = 0; for (;;) { n = read(STDIN_FILENO, &c, 1); if (n <= 0) { if (n < 0 && errno == EINTR) continue; break; } /* * If we're at the beginning of the line and recognize a * command character, then we echo locally. Otherwise, * characters are echo'd remotely. If the command character * is doubled, this acts as a force and local echo is * suppressed. */ if (bol) { bol = 0; if (!noescape && c == escapechar) { local = 1; continue; } } else if (local) { local = 0; if (c == '.' || c == deftt.c_cc[VEOF]) { echo(c); break; } if (c == deftt.c_cc[VSUSP] || c == deftt.c_cc[VDSUSP]) { bol = 1; echo(c); stop(c); continue; } if (c != escapechar) #ifdef CRYPT #ifdef KERBEROS if (doencrypt) (void)des_write(rem, (char *)&escapechar, 1); else #endif #endif (void)write(rem, &escapechar, 1); } #ifdef CRYPT #ifdef KERBEROS if (doencrypt) { if (des_write(rem, &c, 1) == 0) { msg("line gone"); break; } } else #endif #endif if (write(rem, &c, 1) == 0) { msg("line gone"); break; } bol = c == deftt.c_cc[VKILL] || c == deftt.c_cc[VEOF] || c == deftt.c_cc[VINTR] || c == deftt.c_cc[VSUSP] || c == '\r' || c == '\n'; } } void #if __STDC__ echo(register char c) #else echo(c) register char c; #endif { register char *p; char buf[8]; p = buf; c &= 0177; *p++ = escapechar; if (c < ' ') { *p++ = '^'; *p++ = c + '@'; } else if (c == 0177) { *p++ = '^'; *p++ = '?'; } else *p++ = c; *p++ = '\r'; *p++ = '\n'; (void)write(STDOUT_FILENO, buf, p - buf); } void #if __STDC__ stop(char cmdc) #else stop(cmdc) char cmdc; #endif { struct sigaction sa; mode(0); sigemptyset(&sa.sa_mask); sa.sa_handler = SIG_IGN; sa.sa_flags = SA_RESTART; (void)sigaction(SIGCHLD, &sa, (struct sigaction *) 0); (void)kill(cmdc == deftt.c_cc[VSUSP] ? 0 : getpid(), SIGTSTP); sa.sa_handler = catch_child; (void)sigaction(SIGCHLD, &sa, (struct sigaction *) 0); mode(1); sigwinch(0); /* check for size changes */ } void sigwinch(signo) int signo; { struct winsize ws; if (dosigwinch && get_window_size(0, &ws) == 0 && memcmp(&ws, &winsize, sizeof(ws))) { winsize = ws; sendwindow(); } } /* * Send the window size to the server via the magic escape */ void sendwindow() { struct winsize *wp; char obuf[4 + sizeof (struct winsize)]; wp = (struct winsize *)(obuf+4); obuf[0] = 0377; obuf[1] = 0377; obuf[2] = 's'; obuf[3] = 's'; wp->ws_row = htons(winsize.ws_row); wp->ws_col = htons(winsize.ws_col); wp->ws_xpixel = htons(winsize.ws_xpixel); wp->ws_ypixel = htons(winsize.ws_ypixel); #ifdef CRYPT #ifdef KERBEROS if(doencrypt) (void)des_write(rem, obuf, sizeof(obuf)); else #endif #endif (void)write(rem, obuf, sizeof(obuf)); } /* * reader: read from remote: line -> 1 */ #define READING 1 #define WRITING 2 jmp_buf rcvtop; pid_t ppid; int rcvcnt, rcvstate; char rcvbuf[8 * 1024]; void oob(signo) int signo; { struct termios tt; int atmark, n, out, rcvd; char waste[BUFSIZ], mark; out = O_RDWR; rcvd = 0; while (recv(rem, &mark, 1, MSG_OOB) < 0) { switch (errno) { case EWOULDBLOCK: /* * Urgent data not here yet. It may not be possible * to send it yet if we are blocked for output and * our input buffer is full. */ if (rcvcnt < sizeof(rcvbuf)) { n = read(rem, rcvbuf + rcvcnt, sizeof(rcvbuf) - rcvcnt); if (n <= 0) return; rcvd += n; } else { n = read(rem, waste, sizeof(waste)); if (n <= 0) return; } continue; default: return; } } if (mark & TIOCPKT_WINDOW) { /* Let server know about window size changes */ (void)kill(ppid, SIGUSR1); } if (!eight && (mark & TIOCPKT_NOSTOP)) { tcgetattr(0, &tt); tt.c_iflag &= ~(IXON | IXOFF); tt.c_cc[VSTOP] = _POSIX_VDISABLE; tt.c_cc[VSTART] = _POSIX_VDISABLE; tcsetattr(0, TCSANOW, &tt); } if (!eight && (mark & TIOCPKT_DOSTOP)) { tcgetattr(0, &tt); tt.c_iflag |= (IXON|IXOFF); tt.c_cc[VSTOP] = deftt.c_cc[VSTOP]; tt.c_cc[VSTART] = deftt.c_cc[VSTART]; tcsetattr(0, TCSANOW, &tt); } if (mark & TIOCPKT_FLUSHWRITE) { (void)ioctl(1, TIOCFLUSH, (char *)&out); for (;;) { if (ioctl(rem, SIOCATMARK, &atmark) < 0) { warn("ioctl SIOCATMARK (ignored)"); break; } if (atmark) break; n = read(rem, waste, sizeof (waste)); if (n <= 0) break; } /* * Don't want any pending data to be output, so clear the recv * buffer. If we were hanging on a write when interrupted, * don't want it to restart. If we were reading, restart * anyway. */ rcvcnt = 0; longjmp(rcvtop, 1); } /* oob does not do FLUSHREAD (alas!) */ /* * If we filled the receive buffer while a read was pending, longjmp * to the top to restart appropriately. Don't abort a pending write, * however, or we won't know how much was written. */ if (rcvd && rcvstate == READING) longjmp(rcvtop, 1); } /* reader: read from remote: line -> 1 */ int reader(smask) sigset_t *smask; { pid_t pid; int n, remaining; char *bufp; struct sigaction sa; #if BSD >= 43 || defined(SUNOS4) pid = getpid(); /* modern systems use positives for pid */ #else pid = -getpid(); /* old broken systems use negatives */ #endif sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART; sa.sa_handler = SIG_IGN; (void)sigaction(SIGTTOU, &sa, (struct sigaction *) 0); sa.sa_handler = oob; (void)sigaction(SIGURG, &sa, (struct sigaction *) 0); ppid = getppid(); (void)fcntl(rem, F_SETOWN, pid); (void)setjmp(rcvtop); (void)sigprocmask(SIG_SETMASK, smask, (sigset_t *) 0); bufp = rcvbuf; for (;;) { while ((remaining = rcvcnt - (bufp - rcvbuf)) > 0) { rcvstate = WRITING; n = write(STDOUT_FILENO, bufp, remaining); if (n < 0) { if (errno != EINTR) return (-1); continue; } bufp += n; } bufp = rcvbuf; rcvcnt = 0; rcvstate = READING; #ifdef CRYPT #ifdef KERBEROS if (doencrypt) rcvcnt = des_read(rem, rcvbuf, sizeof(rcvbuf)); else #endif #endif rcvcnt = read(rem, rcvbuf, sizeof (rcvbuf)); if (rcvcnt == 0) return (0); if (rcvcnt < 0) { if (errno == EINTR) continue; warn("read"); return (-1); } } } void mode(f) int f; { struct termios tt; switch (f) { case 0: tcsetattr(0, TCSADRAIN, &deftt); break; case 1: tt = deftt; tt.c_oflag &= ~(OPOST); tt.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); tt.c_iflag &= ~(ICRNL); tt.c_cc[VMIN] = 1; tt.c_cc[VTIME] = 0; if (eight) { tt.c_iflag &= ~(IXON | IXOFF | ISTRIP); tt.c_cc[VSTOP] = _POSIX_VDISABLE; tt.c_cc[VSTART] = _POSIX_VDISABLE; } /*if (litout) lflags |= LLITOUT;*/ tcsetattr(0, TCSADRAIN, &tt); break; default: return; } } void lostpeer(signo) int signo; { struct sigaction sa; sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART; sa.sa_handler = SIG_IGN; (void)sigaction(SIGPIPE, &sa, (struct sigaction *) 0); msg("\007connection closed."); done(1); } /* copy SIGURGs to the child process. */ void copytochild(signo) int signo; { (void)kill(child, SIGURG); } static void do_exit(int signo) { exit(signo); } void msg(str) char *str; { (void)fprintf(stderr, "rlogin: %s\r\n", str); } #ifdef KERBEROS /* VARARGS */ void #if __STDC__ warning(const char *fmt, ...) #else warning(fmt, va_alist) char *fmt; va_dcl #endif { va_list ap; (void)fprintf(stderr, "rlogin: warning, using standard rlogin: "); #ifdef __STDC__ va_start(ap, fmt); #else va_start(ap); #endif vfprintf(stderr, fmt, ap); va_end(ap); (void)fprintf(stderr, ".\n"); } #endif __dead void usage() { (void)fprintf(stderr, "usage: rlogin [ -%s]%s[-e char] [ -l username ] [username@]host\n", #ifdef KERBEROS #ifdef CRYPT "8EKLx", " [-k realm] "); #else "8EKL", " [-k realm] "); #endif #else "8EL", " "); #endif exit(1); } /* * The following routine provides compatibility (such as it is) between older * Suns and others. Suns have only a `ttysize', so we convert it to a winsize. */ #ifdef OLDSUN int get_window_size(fd, wp) int fd; struct winsize *wp; { struct ttysize ts; int error; if ((error = ioctl(0, TIOCGSIZE, &ts)) != 0) return (error); wp->ws_row = ts.ts_lines; wp->ws_col = ts.ts_cols; wp->ws_xpixel = 0; wp->ws_ypixel = 0; return (0); } #endif u_int getescape(p) register char *p; { long val; int len; if ((len = strlen(p)) == 1) /* use any single char, including '\' */ return ((u_int)*p); /* otherwise, \nnn */ if (*p == '\\' && len >= 2 && len <= 4) { val = strtol(++p, NULL, 8); for (;;) { if (!*++p) return ((u_int)val); if (*p < '0' || *p > '8') break; } } msg("illegal option value -- e"); usage(); /* NOTREACHED */ }