/* * Copyright (c) 1989 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms are permitted provided * that: (1) source distributions retain this entire copyright notice and * comment, and (2) distributions including binaries display the following * acknowledgement: ``This product includes software developed by the * University of California, Berkeley and its contributors'' in the * documentation or other materials provided with the distribution and in * all advertising materials mentioning features or use of this software. * 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 ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef lint static char sccsid[] = "@(#)sys_term.c 5.11 (Berkeley) 9/14/90"; #endif /* not lint */ #include "telnetd.h" #include "pathnames.h" #include struct utmp wtmp; #ifdef sgi #define BSD 43 #else char wtmpf[] = "/usr/adm/wtmp"; char utmpf[] = "/etc/utmp"; #endif #ifdef _IRIX4 #include static struct utmp entry; #else /* !_IRIX4 */ #include #include static struct utmpx entry; #endif /* _IRIX4 */ #if !(BSD > 43) #include #endif #define SCPYN(a, b) (void) strncpy(a, b, sizeof(a)) #define SCMPN(a, b) strncmp(a, b, sizeof(a)) #ifdef STREAMS #include #endif #ifdef sgi #include #include #include #include #else #include #endif #ifdef t_erase #undef t_erase #undef t_kill #undef t_intrc #undef t_quitc #undef t_startc #undef t_stopc #undef t_eofc #undef t_brkc #undef t_suspc #undef t_dsuspc #undef t_rprntc #undef t_flushc #undef t_werasc #undef t_lnextc #endif #ifndef USE_TERMIO struct termbuf { struct sgttyb sg; struct tchars tc; struct ltchars ltc; int state; int lflags; } termbuf, termbuf2; # define cfsetospeed(tp, val) (tp)->sg.sg_ospeed = (val) # define cfsetispeed(tp, val) (tp)->sg.sg_ispeed = (val) #else /* USE_TERMIO */ # ifdef SYSV_TERMIO # define termios termio # endif # ifndef TCSANOW # ifdef TCSETS # define TCSANOW TCSETS # define TCSADRAIN TCSETSW # define tcgetattr(f, t) iotcl(f, TCGETS, t) # else # ifdef TCSETA # define TCSANOW TCSETA # define TCSADRAIN TCSETAW # define tcgetattr(f, t) ioctl(f, TCGETA, t) # else # define TCSANOW TIOCSETA # define TCSADRAIN TIOCSETAW # define tcgetattr(f, t) iotcl(f, TIOCGETA, t) # endif # endif # define tcsetattr(f, a, t) ioctl(f, a, t) # define cfsetospeed(tp, val) (tp)->c_cflag &= ~CBAUD; \ (tp)->c_cflag |= (val) # ifdef CIBAUD # define cfsetispeed(tp, val) (tp)->c_cflag &= ~CIBAUD; \ (tp)->c_cflag |= ((val)<c_cflag &= ~CBAUD; \ (tp)->c_cflag |= (val) # endif # endif /* TCSANOW */ struct termios termbuf, termbuf2; /* pty control structure */ #endif /* USE_TERMIO */ /* * init_termbuf() * copy_termbuf(cp) * set_termbuf() * * These three routines are used to get and set the "termbuf" structure * to and from the kernel. init_termbuf() gets the current settings. * copy_termbuf() hands in a new "termbuf" to write to the kernel, and * set_termbuf() writes the structure into the kernel. */ init_termbuf() { #ifndef USE_TERMIO (void) ioctl(pty, TIOCGETP, (char *)&termbuf.sg); (void) ioctl(pty, TIOCGETC, (char *)&termbuf.tc); (void) ioctl(pty, TIOCGLTC, (char *)&termbuf.ltc); # ifdef TIOCGSTATE (void) ioctl(pty, TIOCGSTATE, (char *)&termbuf.state); # endif #else #ifdef sgi (void) tcgetattr(pty, &termbuf); #else (void) tcgetattr(pty, (char *)&termbuf); #endif #endif termbuf2 = termbuf; } #if defined(LINEMODE) && defined(TIOCPKT_IOCTL) copy_termbuf(cp, len) char *cp; int len; { if (len > sizeof(termbuf)) len = sizeof(termbuf); bcopy(cp, (char *)&termbuf, len); termbuf2 = termbuf; } #endif /* defined(LINEMODE) && defined(TIOCPKT_IOCTL) */ set_termbuf() { /* * Only make the necessary changes. */ #ifndef USE_TERMIO if (bcmp((char *)&termbuf.sg, (char *)&termbuf2.sg, sizeof(termbuf.sg))) (void) ioctl(pty, TIOCSETN, (char *)&termbuf.sg); if (bcmp((char *)&termbuf.tc, (char *)&termbuf2.tc, sizeof(termbuf.tc))) (void) ioctl(pty, TIOCSETC, (char *)&termbuf.tc); if (bcmp((char *)&termbuf.ltc, (char *)&termbuf2.ltc, sizeof(termbuf.ltc))) (void) ioctl(pty, TIOCSLTC, (char *)&termbuf.ltc); if (termbuf.lflags != termbuf2.lflags) (void) ioctl(pty, TIOCLSET, (char *)&termbuf.lflags); #else /* USE_TERMIO */ if (bcmp((char *)&termbuf, (char *)&termbuf2, sizeof(termbuf))) #ifdef sgi (void) tcsetattr(pty, TCSADRAIN, &termbuf); #else (void) tcsetattr(pty, TCSADRAIN, (char *)&termbuf); #endif #endif /* USE_TERMIO */ } /* * spcset(func, valp, valpp) * * This function takes various special characters (func), and * sets *valp to the current value of that character, and * *valpp to point to where in the "termbuf" structure that * value is kept. * * It returns the SLC_ level of support for this function. */ #ifndef USE_TERMIO spcset(func, valp, valpp) int func; cc_t *valp; cc_t **valpp; { switch(func) { case SLC_EOF: *valp = termbuf.tc.t_eofc; *valpp = (cc_t *)&termbuf.tc.t_eofc; return(SLC_VARIABLE); case SLC_EC: *valp = termbuf.sg.sg_erase; *valpp = (cc_t *)&termbuf.sg.sg_erase; return(SLC_VARIABLE); case SLC_EL: *valp = termbuf.sg.sg_kill; *valpp = (cc_t *)&termbuf.sg.sg_kill; return(SLC_VARIABLE); case SLC_IP: *valp = termbuf.tc.t_intrc; *valpp = (cc_t *)&termbuf.tc.t_intrc; return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT); case SLC_ABORT: *valp = termbuf.tc.t_quitc; *valpp = (cc_t *)&termbuf.tc.t_quitc; return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT); case SLC_XON: *valp = termbuf.tc.t_startc; *valpp = (cc_t *)&termbuf.tc.t_startc; return(SLC_VARIABLE); case SLC_XOFF: *valp = termbuf.tc.t_stopc; *valpp = (cc_t *)&termbuf.tc.t_stopc; return(SLC_VARIABLE); case SLC_AO: *valp = termbuf.ltc.t_flushc; *valpp = (cc_t *)&termbuf.ltc.t_flushc; return(SLC_VARIABLE); case SLC_SUSP: *valp = termbuf.ltc.t_suspc; *valpp = (cc_t *)&termbuf.ltc.t_suspc; return(SLC_VARIABLE); case SLC_EW: *valp = termbuf.ltc.t_werasc; *valpp = (cc_t *)&termbuf.ltc.t_werasc; return(SLC_VARIABLE); case SLC_RP: *valp = termbuf.ltc.t_rprntc; *valpp = (cc_t *)&termbuf.ltc.t_rprntc; return(SLC_VARIABLE); case SLC_LNEXT: *valp = termbuf.ltc.t_lnextc; *valpp = (cc_t *)&termbuf.ltc.t_lnextc; return(SLC_VARIABLE); case SLC_FORW1: *valp = termbuf.tc.t_brkc; *valpp = (cc_t *)&termbuf.ltc.t_lnextc; return(SLC_VARIABLE); case SLC_BRK: case SLC_SYNCH: case SLC_AYT: case SLC_EOR: *valp = (cc_t)0; *valpp = (cc_t *)0; return(SLC_DEFAULT); default: *valp = (cc_t)0; *valpp = (cc_t *)0; return(SLC_NOSUPPORT); } } #else /* USE_TERMIO */ spcset(func, valp, valpp) int func; cc_t *valp; cc_t **valpp; { #define setval(a, b) *valp = termbuf.c_cc[a]; \ *valpp = &termbuf.c_cc[a]; \ return(b); #define defval(a) *valp = ((cc_t)a); *valpp = (cc_t *)0; return(SLC_DEFAULT); switch(func) { case SLC_EOF: setval(VEOF, SLC_VARIABLE); case SLC_EC: setval(VERASE, SLC_VARIABLE); case SLC_EL: setval(VKILL, SLC_VARIABLE); case SLC_IP: setval(VINTR, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT); case SLC_ABORT: setval(VQUIT, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT); case SLC_XON: #ifdef VSTART setval(VSTART, SLC_VARIABLE); #else defval(0x13); #endif case SLC_XOFF: #ifdef VSTOP setval(VSTOP, SLC_VARIABLE); #else defval(0x11); #endif case SLC_EW: #ifdef VWERASE setval(VWERASE, SLC_VARIABLE); #else defval(0); #endif case SLC_RP: #ifdef VREPRINT setval(VREPRINT, SLC_VARIABLE); #else defval(0); #endif case SLC_LNEXT: #ifdef VLNEXT setval(VLNEXT, SLC_VARIABLE); #else defval(0); #endif case SLC_AO: #if !defined(VDISCARD) && defined(VFLUSHO) # define VDISCARD VFLUSHO #endif #ifdef VDISCARD setval(VDISCARD, SLC_VARIABLE|SLC_FLUSHOUT); #else defval(0); #endif case SLC_SUSP: #ifdef VSUSP setval(VSUSP, SLC_VARIABLE|SLC_FLUSHIN); #else defval(0); #endif #ifdef VEOL case SLC_FORW1: setval(VEOL, SLC_VARIABLE); #endif #ifdef VEOL2 case SLC_FORW2: setval(VEOL2, SLC_VARIABLE); #endif case SLC_AYT: #ifdef VSTATUS setval(VSTATUS, SLC_VARIABLE); #else defval(0); #endif case SLC_BRK: case SLC_SYNCH: case SLC_EOR: defval(0); default: *valp = 0; *valpp = 0; return(SLC_NOSUPPORT); } } #endif /* USE_TERMIO */ /* * getpty() * * Allocate a pty. As a side effect, the external character * array "line" contains the name of the slave side. * * Returns the file descriptor of the opened pty. */ #ifdef sgi extern char *_getpty(int*, int, mode_t, int); extern char *line; getpty() { int p; line = _getpty(&p, O_RDWR|O_NDELAY, 0600, 0); if (0 == line) return(-1); return p; } #else /* sgi */ #ifndef __GNUC__ char *line = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; #else static char Xline[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; char *line = Xline; #endif getpty() { register int p; register char c, *p1, *p2; register int i; (void) sprintf(line, "/dev/ptyXX"); p1 = &line[8]; p2 = &line[9]; for (c = 'p'; c <= 's'; c++) { struct stat stb; *p1 = c; *p2 = '0'; if (stat(line, &stb) < 0) break; for (i = 0; i < 16; i++) { *p2 = "0123456789abcdef"[i]; p = open(line, 2); if (p > 0) { line[5] = 't'; return(p); } } } return(-1); } #endif /* sgi */ #ifdef LINEMODE /* * tty_flowmode() Find out if flow control is enabled or disabled. * tty_linemode() Find out if linemode (external processing) is enabled. * tty_setlinemod(on) Turn on/off linemode. * tty_isecho() Find out if echoing is turned on. * tty_setecho(on) Enable/disable character echoing. * tty_israw() Find out if terminal is in RAW mode. * tty_binaryin(on) Turn on/off BINARY on input. * tty_binaryout(on) Turn on/off BINARY on output. * tty_isediting() Find out if line editing is enabled. * tty_istrapsig() Find out if signal trapping is enabled. * tty_setedit(on) Turn on/off line editing. * tty_setsig(on) Turn on/off signal trapping. * tty_issofttab() Find out if tab expansion is enabled. * tty_setsofttab(on) Turn on/off soft tab expansion. * tty_islitecho() Find out if typed control chars are echoed literally * tty_setlitecho() Turn on/off literal echo of control chars * tty_tspeed(val) Set transmit speed to val. * tty_rspeed(val) Set receive speed to val. */ tty_flowmode() { #ifndef USE_TERMIO return((termbuf.tc.t_startc) > 0 && (termbuf.tc.t_stopc) > 0); #else return(termbuf.c_iflag & IXON ? 1 : 0); #endif } tty_linemode() { #ifndef USE_TERMIO return(termbuf.state & TS_EXTPROC); #else return(termbuf.c_lflag & EXTPROC); #endif } tty_setlinemode(on) int on; { #ifdef TIOCEXT set_termbuf(); (void) ioctl(pty, TIOCEXT, (char *)&on); init_termbuf(); #else /* !TIOCEXT */ # ifdef EXTPROC if (on) termbuf.c_lflag |= EXTPROC; else termbuf.c_lflag &= ~EXTPROC; # endif #endif /* TIOCEXT */ } tty_isecho() { #ifndef USE_TERMIO return (termbuf.sg.sg_flags & ECHO); #else return (termbuf.c_lflag & ECHO); #endif } #endif /* LINEMODE */ tty_setecho(on) { #ifndef USE_TERMIO if (on) termbuf.sg.sg_flags |= ECHO|CRMOD; else termbuf.sg.sg_flags &= ~(ECHO|CRMOD); #else if (on) termbuf.c_lflag |= ECHO; else termbuf.c_lflag &= ~ECHO; #endif } #if defined(LINEMODE) && defined(KLUDGELINEMODE) tty_israw() { #ifndef USE_TERMIO return(termbuf.sg.sg_flags & RAW); #else return(!(termbuf.c_lflag & ICANON)); #endif } #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */ tty_binaryin(on) { #ifndef USE_TERMIO if (on) termbuf.lflags |= LPASS8; else termbuf.lflags &= ~LPASS8; #else if (on) { termbuf.c_lflag &= ~ISTRIP; } else { termbuf.c_lflag |= ISTRIP; } #endif } tty_binaryout(on) { #ifndef USE_TERMIO if (on) termbuf.lflags |= LLITOUT; else termbuf.lflags &= ~LLITOUT; #else if (on) { termbuf.c_cflag &= ~(CSIZE|PARENB); termbuf.c_cflag |= CS8; termbuf.c_oflag &= ~OPOST; } else { termbuf.c_cflag &= ~CSIZE; termbuf.c_cflag |= CS7|PARENB; termbuf.c_oflag |= OPOST; } #endif } tty_isbinaryin() { #ifndef USE_TERMIO return(termbuf.lflags & LPASS8); #else return(!(termbuf.c_iflag & ISTRIP)); #endif } tty_isbinaryout() { #ifndef USE_TERMIO return(termbuf.lflags & LLITOUT); #else return(!(termbuf.c_oflag&OPOST)); #endif } #ifdef LINEMODE tty_isediting() { #ifndef USE_TERMIO return(!(termbuf.sg.sg_flags & (CBREAK|RAW))); #else return(termbuf.c_lflag & ICANON); #endif } tty_istrapsig() { #ifndef USE_TERMIO return(!(termbuf.sg.sg_flags&RAW)); #else return(termbuf.c_lflag & ISIG); #endif } tty_setedit(on) int on; { #ifndef USE_TERMIO if (on) termbuf.sg.sg_flags &= ~CBREAK; else termbuf.sg.sg_flags |= CBREAK; #else if (on) termbuf.c_lflag |= ICANON; else termbuf.c_lflag &= ~ICANON; #endif } tty_setsig(on) int on; { #ifndef USE_TERMIO if (on) ; #else if (on) termbuf.c_lflag |= ISIG; else termbuf.c_lflag &= ~ISIG; #endif } #endif /* LINEMODE */ tty_issofttab() { #ifndef USE_TERMIO return (termbuf.sg.sg_flags & XTABS); #else # ifdef OXTABS return (termbuf.c_oflag & OXTABS); # endif # ifdef TABDLY return ((termbuf.c_oflag & TABDLY) == TAB3); # endif #endif } tty_setsofttab(on) int on; { #ifndef USE_TERMIO if (on) termbuf.sg.sg_flags |= XTABS; else termbuf.sg.sg_flags &= ~XTABS; #else if (on) { # ifdef OXTABS termbuf.c_oflag |= OXTABS; # endif # ifdef TABDLY termbuf.c_oflag &= ~TABDLY; termbuf.c_oflag |= TAB3; # endif } else { # ifdef OXTABS termbuf.c_oflag &= ~OXTABS; # endif # ifdef TABDLY termbuf.c_oflag &= ~TABDLY; termbuf.c_oflag |= TAB0; # endif } #endif } tty_islitecho() { #ifndef USE_TERMIO return (!(termbuf.sg.sg_flags & CTLECH)); #else # ifdef ECHOCTL return (!(termbuf.c_lflag & ECHOCTL)); # endif # ifdef TCTLECH return (!(termbuf.c_lflag & TCTLECH)); # endif #if !defined(ECHOCTL) && !defined(TCTLECH) return (0); /* assumes ctl chars are echoed '^x' */ # endif #endif } tty_setlitecho(on) int on; { #ifndef USE_TERMIO if (on) termbuf.sg.sg_flags &= ~CTLECH; else termbuf.sg.sg_flags |= CTLECH; #else # ifdef ECHOCTL if (on) termbuf.c_lflag &= ~ECHOCTL; else termbuf.c_lflag |= ECHOCTL; # endif # ifdef TCTLECH if (on) termbuf.c_lflag &= ~TCTLECH; else termbuf.c_lflag |= TCTLECH; # endif #endif } /* * A table of available terminal speeds */ struct termspeeds { int speed; int value; } termspeeds[] = { { 0, B0 }, { 50, B50 }, { 75, B75 }, { 110, B110 }, { 134, B134 }, { 150, B150 }, { 200, B200 }, { 300, B300 }, { 600, B600 }, { 1200, B1200 }, { 1800, B1800 }, { 2400, B2400 }, { 4800, B4800 }, { 9600, B9600 }, { 19200, B9600 }, { 38400, B9600 }, { -1, B9600 } }; tty_tspeed(val) { register struct termspeeds *tp; for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++) ; cfsetospeed(&termbuf, tp->value); } tty_rspeed(val) { register struct termspeeds *tp; for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++) ; cfsetispeed(&termbuf, tp->value); } /* * getptyslave() * * Open the slave side of the pty, and do any initialization * that is necessary. The return value is a file descriptor * for the slave side. */ getptyslave() { register int t = -1; # ifdef LINEMODE /* * Opening the slave side may cause initilization of the * kernel tty structure. We need remember whether or not * linemode was turned on, so that we can re-set it if we * need to. */ int waslm = tty_linemode(); # endif /* * Make sure that we don't have a controlling tty, and * that we are the session (process group) leader. */ # ifdef TIOCNOTTY t = open(_PATH_TTY, O_RDWR); if (t >= 0) { (void) ioctl(t, TIOCNOTTY, (char *)0); (void) close(t); } # endif t = cleanopen(line); if (t < 0) fatalperror(net, line); /* * set up the tty modes as we like them to be. */ init_termbuf(); # ifdef LINEMODE if (waslm) tty_setlinemode(); # endif /* LINEMODE */ /* * Settings for sgtty based systems */ # ifndef USE_TERMIO termbuf.sg.sg_flags |= CRMOD|ANYP|ECHO|XTABS; termbuf.sg.sg_ospeed = termbuf.sg.sg_ispeed = B9600; # endif /* USE_TERMIO */ /* * Settings for all other termios/termio based * systems, other than 4.4BSD. In 4.4BSD the * kernel does the initial terminal setup. */ #if defined(USE_TERMIO) && (BSD <= 43) # ifndef OXTABS # define OXTABS 0 # endif termbuf.c_lflag |= ECHO; termbuf.c_oflag |= ONLCR|OXTABS; termbuf.c_iflag |= ICRNL; termbuf.c_iflag &= ~IXOFF; cfsetospeed(&termbuf, B9600); cfsetispeed(&termbuf, B9600); # endif /* defined(USE_TERMIO) && !defined(CRAY) && (BSD <= 43) */ /* * Set the tty modes, and make this our controlling tty. */ set_termbuf(); if (login_tty(t) == -1) fatalperror(net, "login_tty"); if (net > 2) (void) close(net); if (pty > 2) (void) close(pty); } #ifndef O_NOCTTY #define O_NOCTTY 0 #endif /* * Open the specified slave side of the pty, * making sure that we have a clean tty. */ cleanopen(line) char *line; { register int t; cap_t ocap; cap_value_t cap_device_mgt = CAP_DEVICE_MGT; cap_value_t cap_fowner = CAP_FOWNER; cap_value_t cap_dac_override[] = {CAP_DAC_READ_SEARCH, CAP_DAC_WRITE}; /* * Make sure that other people can't open the * slave side of the connection. */ ocap = cap_acquire(1, &cap_fowner); (void) chown(line, 0, 0); cap_surrender(ocap); #ifdef sgi t = open(line, O_RDWR); if (t < 0 || fchmod(t, 0)) return(-1); /* * Hangup anybody else using this ttyp, then reopen it for * ourselves. */ (void) signal(SIGHUP, SIG_IGN); ocap = cap_acquire(1, &cap_device_mgt); vhangup(); cap_surrender(ocap); (void) signal(SIGHUP, SIG_DFL); setpgrp(); ocap = cap_acquire(2, cap_dac_override); t = open(line, O_RDWR); cap_surrender(ocap); if (t < 0) return(-1); /* * Make the pty world-writable so programs like write & talk work. * XXX should be protected, with "approved" setgid programs allowed * to write to ptys. */ if (fchmod(t, 0622)) return(-1); #else (void) chmod(line, 0600); #if (BSD > 43) (void) revoke(line); # endif t = open(line, O_RDWR|O_NOCTTY); if (t < 0) return(-1); /* * Hangup anybody else using this ttyp, then reopen it for * ourselves. */ #if (BSD <= 43) (void) signal(SIGHUP, SIG_IGN); vhangup(); (void) signal(SIGHUP, SIG_DFL); t = open(line, O_RDWR|O_NOCTTY); if (t < 0) return(-1); # endif #endif /* sgi */ return(t); } #if BSD <= 43 login_tty(t) int t; { #ifndef sgi # ifndef NO_SETSID if (setsid() < 0) fatalperror(net, "setsid()"); # else if (setpgrp(0,0) < 0) fatalperror(net, "setpgrp()"); # endif #endif # ifdef TIOCSCTTY if (ioctl(t, TIOCSCTTY, (char *)0) < 0) fatalperror(net, "ioctl(sctty)"); # else close(open(line, O_RDWR)); # endif (void) dup2(t, 0); (void) dup2(t, 1); (void) dup2(t, 2); #ifdef sgi adut(); closelog(); /* (so syslog() can work below) */ for (t = getdtablehi(); --t > 2; ) (void)close(t); return 0; #else close(t); #endif } #endif /* BSD <= 43 */ /* * startslave(host) * * Given a hostname, do whatever * is necessary to startup the login process on the slave side of the pty. */ /* ARGSUSED */ startslave(host) char *host; { register int i; #ifndef sgi long time(); #endif if ((i = fork()) < 0) fatalperror(net, "fork"); if (i) { } else { getptyslave(); start_login(host); /*NOTREACHED*/ } } char *envinit[3]; extern char **environ; init_env() { #ifdef sgi extern char *telnet_getenv(); #else extern char *getenv(); #endif char **envp; envp = envinit; #ifdef sgi if (*envp = telnet_getenv("TZ")) #else if (*envp = getenv("TZ")) #endif *envp++ -= 3; *envp = 0; environ = envinit; } /* * start_login(host) * * Assuming that we are now running as a child processes, this * function will turn us into the login process. */ start_login(host) char *host; { #ifndef sgi register char *cp; #endif register char **argv; char **addarg(); #ifdef sgi extern char *telnet_getenv(); #endif /* * -h : pass on name of host. * WARNING: -h is accepted by login if and only if * getuid() == 0. * -p : don't clobber the environment (so terminal type stays set). */ argv = addarg(0, "login"); argv = addarg(argv, "-h"); argv = addarg(argv, host); #ifndef NO_LOGIN_P argv = addarg(argv, "-p"); #endif #ifdef BFTPDAEMON /* * Are we working as the bftp daemon? If so, then ask login * to start bftp instead of shell. */ if (bftpd) { argv = addarg(argv, "-e"); argv = addarg(argv, BFTPPATH); } else #endif #ifdef sgi if (telnet_getenv("USER")) { argv = addarg(argv, telnet_getenv("USER")); #else if (getenv("USER")) { argv = addarg(argv, getenv("USER")); #endif } #ifndef _IRIX4 execv(_PATH_SCHEME, argv); syslog(LOG_ERR, "%s: %m\n", _PATH_SCHEME); #endif /* !_IRIX4 */ execv(_PATH_LOGIN, argv); syslog(LOG_ERR, "%s: %m\n", _PATH_LOGIN); fatalperror(net, _PATH_LOGIN); /*NOTREACHED*/ } char ** addarg(argv, val) register char **argv; register char *val; { register char **cpp; char *malloc(); if (argv == NULL) { /* * 10 entries, a leading length, and a null */ argv = (char **)malloc(sizeof(*argv) * 12); if (argv == NULL) return(NULL); *argv++ = (char *)10; *argv = (char *)0; } for (cpp = argv; *cpp; cpp++) ; if (cpp == &argv[(int)argv[-1]]) { --argv; *argv = (char *)((int)(*argv) + 10); argv = (char **)realloc(argv, (int)(*argv) + 2); if (argv == NULL) return(NULL); argv++; cpp = &argv[(int)argv[-1] - 10]; } *cpp++ = val; *cpp = 0; return(argv); } /* * cleanup() * * This is the routine to call when we are all through, to * clean up anything that needs to be cleaned up. */ void cleanup() { #ifdef sgi rmut(); #else #if (BSD > 43) char *p; p = line + sizeof("/dev/") - 1; if (logout(p)) logwtmp(p, "", ""); (void)chmod(line, 0666); (void)chown(line, 0, 0); *p = 'p'; (void)chmod(line, 0666); (void)chown(line, 0, 0); # else rmut(); vhangup(); /* XXX */ # endif #endif /* sgi */ (void) shutdown(net, 2); exit(1); } /* * rmut() * * This is the function called by cleanup() to * remove the utmp entry for this person. */ #if BSD <= 43 && !defined(sgi) rmut() { register f; int found = 0; struct utmp *u, *utmp; int nutmp; struct stat statbf; char *malloc(); long time(); off_t lseek(); f = open(utmpf, O_RDWR); if (f >= 0) { (void) fstat(f, &statbf); utmp = (struct utmp *)malloc((unsigned)statbf.st_size); if (!utmp) syslog(LOG_ERR, "utmp malloc failed"); if (statbf.st_size && utmp) { nutmp = read(f, (char *)utmp, (int)statbf.st_size); nutmp /= sizeof(struct utmp); for (u = utmp ; u < &utmp[nutmp] ; u++) { if (SCMPN(u->ut_line, line+5) || u->ut_name[0]==0) continue; (void) lseek(f, ((long)u)-((long)utmp), L_SET); SCPYN(u->ut_name, ""); SCPYN(u->ut_host, ""); (void) time(&u->ut_time); (void) write(f, (char *)u, sizeof(wtmp)); found++; } } (void) close(f); } if (found) { f = open(wtmpf, O_WRONLY|O_APPEND); if (f >= 0) { SCPYN(wtmp.ut_line, line+5); SCPYN(wtmp.ut_name, ""); SCPYN(wtmp.ut_host, ""); (void) time(&wtmp.ut_time); (void) write(f, (char *)&wtmp, sizeof(wtmp)); (void) close(f); } } (void) chmod(line, 0666); (void) chown(line, 0, 0); line[strlen("/dev/")] = 'p'; (void) chmod(line, 0666); (void) chown(line, 0, 0); } /* end of rmut */ #endif /* CRAY */ /* add ourself to utmp */ adut() { int f; cap_t ocap; cap_value_t cap_dac_write = CAP_DAC_WRITE; SCPYN(entry.ut_user, "telnet"); SCPYN(entry.ut_id, &line[(sizeof("/dev/tty") - 1)]); SCPYN(entry.ut_line, line+sizeof("/dev/")-1); entry.ut_pid = getpid(); entry.ut_type = LOGIN_PROCESS; #ifdef _IRIX4 entry.ut_time = time(0); setutent(); (void)pututline(&entry); endutent(); #ifdef _XUTMP_FILE _xsetutent(); /* login adds host */ _xutupdate(&entry, NULL, NULL, 0, NULL); _xendutent(); #endif f = open(WTMP_FILE, O_WRONLY|O_APPEND); if (f >= 0) { write(f, (char *)&entry, sizeof(entry)); close(f); } #else /* !_IRIX4 */ (void) time(&entry.ut_tv.tv_sec); setutxent(); ocap = cap_acquire(1, &cap_dac_write); pututxline(&entry); /* updates utmpx and utmp */ cap_surrender(ocap); endutxent(); ocap = cap_acquire(1, &cap_dac_write); updwtmpx(WTMPX_FILE, &entry); cap_surrender(ocap); #endif /* _IRIX4 */ } rmut() { int f; cap_t ocap; cap_value_t cap_dac_write = CAP_DAC_WRITE; cap_value_t cap_audit_write = CAP_AUDIT_WRITE; static char satid[5], satline[33]; SCPYN(entry.ut_user, "telnet"); SCPYN(entry.ut_id, &line[(sizeof("/dev/tty") - 1)]); SCPYN(entry.ut_line, line+sizeof("/dev/")-1); entry.ut_pid = getpid(); entry.ut_type = DEAD_PROCESS; #ifdef _IRIX4 entry.ut_time = time(0); setutent(); (void)pututline(&entry); endutent(); #ifdef _XUTMP_FILE _xsetutent(); _xutupdate(&entry, NULL, NULL, 1, NULL); _xendutent(); #endif f = open(WTMP_FILE, O_WRONLY|O_APPEND); if (f >= 0) { entry.ut_user[0] = '\0'; write(f, (char *)&entry, sizeof(entry)); close(f); } #else /* !_IRIX4 */ (void) time(&entry.ut_tv.tv_sec); setutxent(); ocap = cap_acquire(1, &cap_dac_write); pututxline(&entry); cap_surrender(ocap); endutxent(); ocap = cap_acquire(1, &cap_dac_write); updwtmpx(WTMPX_FILE, &entry); cap_surrender(ocap); #endif /* _IRIX4 */ strncpy(satid, entry.ut_id, sizeof(entry.ut_id)); strncpy(satline, line, strlen(line)); ocap = cap_acquire(1, &cap_audit_write); satvwrite(SAT_AE_IDENTITY, SAT_SUCCESS, "telnetd|+|?|Remote telnet logout id %s line %s", satid, satline); cap_surrender(ocap); }