[unix-history] / usr / src / libexec / telnetd / telnetd.c

#ifndef lint
static char sccsid[] = "@(#)telnetd.c	4.9 82/10/10";
#endif

/*
 * Stripped-down telnet server.
 */
#include <stdio.h>
#include <signal.h>
#include <errno.h>
#include <sgtty.h>
#include <wait.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <net/in.h>
#include <netdb.h>
#include "telnet.h"

#define	INFINITY	10000000
#define	BELL		'\07'

char	hisopts[256];
char	myopts[256];

char	doopt[] = { IAC, DO, '%', 'c', 0 };
char	dont[] = { IAC, DONT, '%', 'c', 0 };
char	will[] = { IAC, WILL, '%', 'c', 0 };
char	wont[] = { IAC, WONT, '%', 'c', 0 };

/*
 * I/O data buffers, pointers, and counters.
 */
char	ptyibuf[BUFSIZ], *ptyip = ptyibuf;
char	ptyobuf[BUFSIZ], *pfrontp = ptyobuf, *pbackp = ptyobuf;
char	netibuf[BUFSIZ], *netip = netibuf;
char	netobuf[BUFSIZ], *nfrontp = netobuf, *nbackp = netobuf;
int	pcc, ncc;

int	pty, net;
int	inter;
extern	int errno;
char	line[] = "/dev/ptyp0";

struct	sockaddr_in sin = { AF_INET };
int	options = SO_ACCEPTCONN|SO_KEEPALIVE;

main(argc, argv)
	char *argv[];
{
	int s, pid;
	union wait status;
	struct servent *sp;

	sp = getservbyname("telnet", "tcp");
	if (sp == 0) {
		fprintf(stderr, "telnetd: tcp/telnet: unknown service\n");
		exit(1);
	}
	sin.sin_port = sp->s_port;
	argc--, argv++;
	if (argc > 0 && !strcmp(argv[0], "-d"))
		options |= SO_DEBUG, argc--, argv++;
	if (argc > 0) {
		sin.sin_port = atoi(*argv);
		if (sin.sin_port <= 0) {
			fprintf(stderr, "telnetd: %s: bad port #\n", *argv);
			exit(1);
		}
	}
	sin.sin_port = htons(sin.sin_port);
#ifndef DEBUG
	if (fork())
		exit(0);
	for (s = 0; s < 10; s++)
		(void) close(s);
	(void) open("/", 0);
	(void) dup2(0, 1);
	(void) dup2(0, 2);
	{ int tt = open("/dev/tty", 2);
	  if (tt > 0) {
		ioctl(tt, TIOCNOTTY, 0);
		close(tt);
	  }
	}
#endif
	for (;;) {
		errno = 0;
		if ((s = socket(SOCK_STREAM, 0, &sin, options)) < 0) {
			perror("socket");
			sleep(5);
			continue;
		}
		if (accept(s, 0) < 0) {
			perror("accept");
			close(s);
			sleep(1);
			continue;
		}
		if ((pid = fork()) < 0)
			printf("Out of processes\n");
		else if (pid == 0)
			doit(s);
		close(s);
		while (wait3(status, WNOHANG, 0) > 0)
			continue;
	}
	/*NOTREACHED*/
}

int	cleanup();

/*
 * Get a pty, scan input lines.
 */
doit(f)
{
	char *cp = line;
	int i, p, cc, t;
	struct sgttyb b;

	for (i = 0; i < 16; i++) {
		cp[strlen("/dev/ptyp")] = "0123456789abcdef"[i];
		p = open(cp, 2);
		if (p > 0)
			goto gotpty;
	}
	dup2(f, 1);
	printf("All network ports in use.\n");
	exit(1);
gotpty:
	dup2(f, 0);
	cp[strlen("/dev/")] = 't';
	t = open("/dev/tty", 2);
	if (t >= 0) {
		ioctl(t, TIOCNOTTY, 0);
		close(t);
	}
	t = open(cp, 2);
	if (t < 0) {
		dup2(f, 2);
		perror(cp);
		exit(1);
	}
	ioctl(t, TIOCGETP, &b);
	b.sg_flags = CRMOD|XTABS|ANYP;
	ioctl(t, TIOCSETP, &b);
	ioctl(p, TIOCGETP, &b);
	b.sg_flags &= ~ECHO;
	ioctl(p, TIOCSETP, &b);
	if ((i = fork()) < 0) {
		dup2(f, 2);
		perror("fork");
		exit(1);
	}
	if (i)
		telnet(f, p);
	close(f);
	close(p);
	dup2(t, 0);
	dup2(t, 1);
	dup2(t, 2);
	close(t);
	execl("/bin/login", "telnet-login", 0);
	perror("/bin/login");
	exit(1);
}

/*
 * Main loop.  Select from pty and network, and
 * hand data to telnet receiver finite state machine.
 */
telnet(f, p)
{
	int on = 1;

	net = f, pty = p;
	ioctl(f, FIONBIO, &on);
	ioctl(p, FIONBIO, &on);
	signal(SIGTSTP, SIG_IGN);
	sigset(SIGCHLD, cleanup);

	/*
	 * Request to do remote echo.
	 */
	dooption(TELOPT_ECHO);
	myopts[TELOPT_ECHO] = 1;
	for (;;) {
		int ibits = 0, obits = 0;
		register int c;

		/*
		 * Never look for input if there's still
		 * stuff in the corresponding output buffer
		 */
		if (nfrontp - nbackp)
			obits |= (1 << f);
		else
			ibits |= (1 << p);
		if (pfrontp - pbackp)
			obits |= (1 << p);
		else
			ibits |= (1 << f);
		if (ncc < 0 && pcc < 0)
			break;
		select(32, &ibits, &obits, INFINITY);
		if (ibits == 0 && obits == 0) {
			sleep(5);
			continue;
		}

		/*
		 * Something to read from the network...
		 */
		if (ibits & (1 << f)) {
			ncc = read(f, netibuf, BUFSIZ);
			if (ncc < 0 && errno == EWOULDBLOCK)
				ncc = 0;
			else {
				if (ncc <= 0)
					break;
				netip = netibuf;
			}
		}

		/*
		 * Something to read from the pty...
		 */
		if (ibits & (1 << p)) {
			pcc = read(p, ptyibuf, BUFSIZ);
			if (pcc < 0 && errno == EWOULDBLOCK)
				pcc = 0;
			else {
				if (pcc <= 0)
					break;
				ptyip = ptyibuf;
			}
		}

		while (pcc > 0) {
			if ((&netobuf[BUFSIZ] - nfrontp) < 2)
				break;
			c = *ptyip++ & 0377, pcc--;
			if (c == IAC)
				*nfrontp++ = c;
			*nfrontp++ = c;
		}
		if ((obits & (1 << f)) && (nfrontp - nbackp) > 0)
			netflush();
		if (ncc > 0)
			telrcv();
		if ((obits & (1 << p)) && (pfrontp - pbackp) > 0)
			ptyflush();
	}
	cleanup();
}
	
/*
 * State for recv fsm
 */
#define	TS_DATA		0	/* base state */
#define	TS_IAC		1	/* look for double IAC's */
#define	TS_CR		2	/* CR-LF ->'s CR */
#define	TS_BEGINNEG	3	/* throw away begin's... */
#define	TS_ENDNEG	4	/* ...end's (suboption negotiation) */
#define	TS_WILL		5	/* will option negotiation */
#define	TS_WONT		6	/* wont " */
#define	TS_DO		7	/* do " */
#define	TS_DONT		8	/* dont " */

telrcv()
{
	register int c;
	static int state = TS_DATA;
	struct sgttyb b;

	while (ncc > 0) {
		if ((&ptyobuf[BUFSIZ] - pfrontp) < 2)
			return;
		c = *netip++ & 0377, ncc--;
		switch (state) {

		case TS_DATA:
			if (c == IAC) {
				state = TS_IAC;
				break;
			}
			if (inter > 0)
				break;
			*pfrontp++ = c;
			if (!myopts[TELOPT_BINARY] && c == '\r')
				state = TS_CR;
			break;

		case TS_CR:
			if (c && c != '\n')
				*pfrontp++ = c;
			state = TS_DATA;
			break;

		case TS_IAC:
			switch (c) {

			/*
			 * Send the process on the pty side an
			 * interrupt.  Do this with a NULL or
			 * interrupt char; depending on the tty mode.
			 */
			case BREAK:
			case IP:
				interrupt();
				break;

			/*
			 * Are You There?
			 */
			case AYT:
				*pfrontp++ = BELL;
				break;

			/*
			 * Erase Character and
			 * Erase Line
			 */
			case EC:
			case EL:
				ptyflush();	/* half-hearted */
				ioctl(pty, TIOCGETP, &b);
				*pfrontp++ = (c == EC) ?
					b.sg_erase : b.sg_kill;
				break;

			/*
			 * Check for urgent data...
			 */
			case DM:
				break;

			/*
			 * Begin option subnegotiation...
			 */
			case SB:
				state = TS_BEGINNEG;
				continue;

			case WILL:
			case WONT:
			case DO:
			case DONT:
				state = TS_WILL + (c - WILL);
				continue;

			case IAC:
				*pfrontp++ = c;
				break;
			}
			state = TS_DATA;
			break;

		case TS_BEGINNEG:
			if (c == IAC)
				state = TS_ENDNEG;
			break;

		case TS_ENDNEG:
			state = c == SE ? TS_DATA : TS_BEGINNEG;
			break;

		case TS_WILL:
			if (!hisopts[c])
				willoption(c);
			state = TS_DATA;
			continue;

		case TS_WONT:
			if (hisopts[c])
				wontoption(c);
			state = TS_DATA;
			continue;

		case TS_DO:
			if (!myopts[c])
				dooption(c);
			state = TS_DATA;
			continue;

		case TS_DONT:
			if (myopts[c]) {
				myopts[c] = 0;
				sprintf(nfrontp, wont, c);
				nfrontp += sizeof (wont) - 2;
			}
			state = TS_DATA;
			continue;

		default:
			printf("netser: panic state=%d\n", state);
			exit(1);
		}
	}
}

willoption(option)
	int option;
{
	char *fmt;

	switch (option) {

	case TELOPT_BINARY:
		mode(RAW, 0);
		goto common;

	case TELOPT_ECHO:
		mode(0, ECHO|CRMOD);
		/*FALL THRU*/

	case TELOPT_SGA:
	common:
		hisopts[option] = 1;
		fmt = doopt;
		break;

	case TELOPT_TM:
		fmt = dont;
		break;

	default:
		fmt = dont;
		break;
	}
	sprintf(nfrontp, fmt, option);
	nfrontp += sizeof (dont) - 2;
}

wontoption(option)
	int option;
{
	char *fmt;

	switch (option) {

	case TELOPT_ECHO:
		mode(ECHO|CRMOD, 0);
		goto common;

	case TELOPT_BINARY:
		mode(0, RAW);
		/*FALL THRU*/

	case TELOPT_SGA:
	common:
		hisopts[option] = 0;
		fmt = dont;
		break;

	default:
		fmt = dont;
	}
	sprintf(nfrontp, fmt, option);
	nfrontp += sizeof (doopt) - 2;
}

dooption(option)
	int option;
{
	char *fmt;

	switch (option) {

	case TELOPT_TM:
		fmt = wont;
		break;

	case TELOPT_ECHO:
		mode(ECHO|CRMOD, 0);
		goto common;

	case TELOPT_BINARY:
		mode(RAW, 0);
		/*FALL THRU*/

	case TELOPT_SGA:
	common:
		fmt = will;
		break;

	default:
		fmt = wont;
		break;
	}
	sprintf(nfrontp, fmt, option);
	nfrontp += sizeof (doopt) - 2;
}

mode(on, off)
	int on, off;
{
	struct sgttyb b;

	ptyflush();
	ioctl(pty, TIOCGETP, &b);
	b.sg_flags |= on;
	b.sg_flags &= ~off;
	ioctl(pty, TIOCSETP, &b);
}

/*
 * Send interrupt to process on other side of pty.
 * If it is in raw mode, just write NULL;
 * otherwise, write intr char.
 */
interrupt()
{
	struct sgttyb b;
	struct tchars tchars;

	ptyflush();	/* half-hearted */
	ioctl(pty, TIOCGETP, &b);
	if (b.sg_flags & RAW) {
		*pfrontp++ = '\0';
		return;
	}
	*pfrontp++ = ioctl(pty, TIOCGETC, &tchars) < 0 ?
		'\177' : tchars.t_intrc;
}

ptyflush()
{
	int n;

	if ((n = pfrontp - pbackp) > 0)
		n = write(pty, pbackp, n);
	if (n < 0)
		return;
	pbackp += n;
	if (pbackp == pfrontp)
		pbackp = pfrontp = ptyobuf;
}

netflush()
{
	int n;

	if ((n = nfrontp - nbackp) > 0)
		n = write(net, nbackp, n);
	if (n < 0) {
		if (errno == EWOULDBLOCK)
			return;
		/* should blow this guy away... */
		return;
	}
	nbackp += n;
	if (nbackp == nfrontp)
		nbackp = nfrontp = netobuf;
}

cleanup()
{
	int how = 2;

	rmut();
	vhangup();
	ioctl(net, SIOCDONE, &how);
	kill(0, SIGKILL);
	exit(1);
}

#include <utmp.h>

struct	utmp wtmp;
char	wtmpf[]	= "/usr/adm/wtmp";
char	utmp[] = "/etc/utmp";
#define SCPYN(a, b)	strncpy(a, b, sizeof (a))
#define SCMPN(a, b)	strncmp(a, b, sizeof (a))

rmut()
{
	register f;
	int found = 0;

	f = open(utmp, 2);
	if (f >= 0) {
		while(read(f, (char *)&wtmp, sizeof (wtmp)) == sizeof (wtmp)) {
			if (SCMPN(wtmp.ut_line, line+5) || wtmp.ut_name[0]==0)
				continue;
			lseek(f, -(long)sizeof (wtmp), 1);
			SCPYN(wtmp.ut_name, "");
			time(&wtmp.ut_time);
			write(f, (char *)&wtmp, sizeof (wtmp));
			found++;
		}
		close(f);
	}
	if (found) {
		f = open(wtmpf, 1);
		if (f >= 0) {
			SCPYN(wtmp.ut_line, line+5);
			SCPYN(wtmp.ut_name, "");
			time(&wtmp.ut_time);
			lseek(f, (long)0, 2);
			write(f, (char *)&wtmp, sizeof (wtmp));
			close(f);
		}
	}
	chmod(line, 0666);
	chown(line, 0, 0);
	line[strlen("/dev/")] = 'p';
	chmod(line, 0666);
	chown(line, 0, 0);
}
Commit	Line	Data
ac6e6727	1	#ifndef lint
16f092bf	2	static char sccsid[] = "@(#)telnetd.c 4.9 82/10/10";
ac6e6727 BJ	3	#endif
ac6e6727 BJ	4
66b878f6 BJ	5	/*
	6	* Stripped-down telnet server.
	7	*/
	8	#include <stdio.h>
	9	#include <signal.h>
	10	#include <errno.h>
	11	#include <sgtty.h>
	12	#include <wait.h>
	13	#include <sys/types.h>
	14	#include <sys/socket.h>
	15	#include <net/in.h>
9f005877	16	#include <netdb.h>
66b878f6 BJ	17	#include "telnet.h"
	18
	19	#define INFINITY 10000000
	20	#define BELL '\07'
66b878f6 BJ	21
	22	char hisopts[256];
	23	char myopts[256];
	24
	25	char doopt[] = { IAC, DO, '%', 'c', 0 };
	26	char dont[] = { IAC, DONT, '%', 'c', 0 };
	27	char will[] = { IAC, WILL, '%', 'c', 0 };
	28	char wont[] = { IAC, WONT, '%', 'c', 0 };
	29
	30	/*
	31	* I/O data buffers, pointers, and counters.
	32	*/
	33	char ptyibuf[BUFSIZ], *ptyip = ptyibuf;
	34	char ptyobuf[BUFSIZ], pfrontp = ptyobuf, pbackp = ptyobuf;
	35	char netibuf[BUFSIZ], *netip = netibuf;
9ef3087d	36	char netobuf[BUFSIZ], nfrontp = netobuf, nbackp = netobuf;
66b878f6 BJ	37	int pcc, ncc;
	38
	39	int pty, net;
	40	int inter;
	41	extern int errno;
	42	char line[] = "/dev/ptyp0";
	43
9f005877	44	struct sockaddr_in sin = { AF_INET };
75a2ff26	45	int options = SO_ACCEPTCONN\|SO_KEEPALIVE;
66b878f6 BJ	46
	47	main(argc, argv)
	48	char *argv[];
	49	{
	50	int s, pid;
	51	union wait status;
9f005877	52	struct servent *sp;
66b878f6	53
9f005877 SL	54	sp = getservbyname("telnet", "tcp");
	55	if (sp == 0) {
	56	fprintf(stderr, "telnetd: tcp/telnet: unknown service\n");
	57	exit(1);
	58	}
	59	sin.sin_port = sp->s_port;
66b878f6 BJ	60	argc--, argv++;
66b878f6 BJ	61	if (argc > 0 && !strcmp(argv[0], "-d"))
9f005877 SL	62	options \|= SO_DEBUG, argc--, argv++;
	63	if (argc > 0) {
	64	sin.sin_port = atoi(*argv);
	65	if (sin.sin_port <= 0) {
	66	fprintf(stderr, "telnetd: %s: bad port #\n", *argv);
	67	exit(1);
	68	}
	69	}
ac6e6727	70	sin.sin_port = htons(sin.sin_port);
16f092bf SL	71	#ifndef DEBUG
	72	if (fork())
	73	exit(0);
	74	for (s = 0; s < 10; s++)
	75	(void) close(s);
	76	(void) open("/", 0);
	77	(void) dup2(0, 1);
	78	(void) dup2(0, 2);
	79	{ int tt = open("/dev/tty", 2);
	80	if (tt > 0) {
	81	ioctl(tt, TIOCNOTTY, 0);
	82	close(tt);
	83	}
	84	}
	85	#endif
66b878f6 BJ	86	for (;;) {
	87	errno = 0;
	88	if ((s = socket(SOCK_STREAM, 0, &sin, options)) < 0) {
	89	perror("socket");
	90	sleep(5);
	91	continue;
	92	}
	93	if (accept(s, 0) < 0) {
	94	perror("accept");
	95	close(s);
	96	sleep(1);
	97	continue;
	98	}
	99	if ((pid = fork()) < 0)
	100	printf("Out of processes\n");
	101	else if (pid == 0)
	102	doit(s);
	103	close(s);
	104	while (wait3(status, WNOHANG, 0) > 0)
	105	continue;
	106	}
	107	/NOTREACHED/
	108	}
	109
	110	int cleanup();
	111
	112	/*
	113	* Get a pty, scan input lines.
	114	*/
	115	doit(f)
	116	{
	117	char *cp = line;
	118	int i, p, cc, t;
	119	struct sgttyb b;
	120
	121	for (i = 0; i < 16; i++) {
	122	cp[strlen("/dev/ptyp")] = "0123456789abcdef"[i];
	123	p = open(cp, 2);
	124	if (p > 0)
	125	goto gotpty;
	126	}
	127	dup2(f, 1);
	128	printf("All network ports in use.\n");
	129	exit(1);
	130	gotpty:
	131	dup2(f, 0);
	132	cp[strlen("/dev/")] = 't';
	133	t = open("/dev/tty", 2);
	134	if (t >= 0) {
	135	ioctl(t, TIOCNOTTY, 0);
	136	close(t);
	137	}
	138	t = open(cp, 2);
	139	if (t < 0) {
	140	dup2(f, 2);
	141	perror(cp);
	142	exit(1);
	143	}
	144	ioctl(t, TIOCGETP, &b);
9ef3087d	145	b.sg_flags = CRMOD\|XTABS\|ANYP;
66b878f6	146	ioctl(t, TIOCSETP, &b);
9ef3087d	147	ioctl(p, TIOCGETP, &b);
da96b661	148	b.sg_flags &= ~ECHO;
9ef3087d	149	ioctl(p, TIOCSETP, &b);
66b878f6 BJ	150	if ((i = fork()) < 0) {
	151	dup2(f, 2);
	152	perror("fork");
	153	exit(1);
	154	}
	155	if (i)
	156	telnet(f, p);
	157	close(f);
	158	close(p);
	159	dup2(t, 0);
	160	dup2(t, 1);
	161	dup2(t, 2);
	162	close(t);
	163	execl("/bin/login", "telnet-login", 0);
	164	perror("/bin/login");
	165	exit(1);
	166	}
	167
	168	/*
	169	* Main loop. Select from pty and network, and
	170	* hand data to telnet receiver finite state machine.
	171	*/
	172	telnet(f, p)
	173	{
	174	int on = 1;
	175
	176	net = f, pty = p;
	177	ioctl(f, FIONBIO, &on);
	178	ioctl(p, FIONBIO, &on);
	179	signal(SIGTSTP, SIG_IGN);
	180	sigset(SIGCHLD, cleanup);
	181
da96b661 SL	182	/*
	183	* Request to do remote echo.
	184	*/
	185	dooption(TELOPT_ECHO);
	186	myopts[TELOPT_ECHO] = 1;
66b878f6 BJ	187	for (;;) {
	188	int ibits = 0, obits = 0;
	189	register int c;
	190
	191	/*
	192	* Never look for input if there's still
	193	* stuff in the corresponding output buffer
	194	*/
	195	if (nfrontp - nbackp)
	196	obits \|= (1 << f);
	197	else
	198	ibits \|= (1 << p);
	199	if (pfrontp - pbackp)
	200	obits \|= (1 << p);
	201	else
	202	ibits \|= (1 << f);
	203	if (ncc < 0 && pcc < 0)
	204	break;
	205	select(32, &ibits, &obits, INFINITY);
	206	if (ibits == 0 && obits == 0) {
	207	sleep(5);
	208	continue;
	209	}
	210
	211	/*
	212	* Something to read from the network...
	213	*/
	214	if (ibits & (1 << f)) {
	215	ncc = read(f, netibuf, BUFSIZ);
	216	if (ncc < 0 && errno == EWOULDBLOCK)
	217	ncc = 0;
	218	else {
	219	if (ncc <= 0)
	220	break;
	221	netip = netibuf;
	222	}
	223	}
	224
	225	/*
	226	* Something to read from the pty...
	227	*/
	228	if (ibits & (1 << p)) {
	229	pcc = read(p, ptyibuf, BUFSIZ);
	230	if (pcc < 0 && errno == EWOULDBLOCK)
	231	pcc = 0;
	232	else {
	233	if (pcc <= 0)
	234	break;
	235	ptyip = ptyibuf;
	236	}
	237	}
	238
	239	while (pcc > 0) {
	240	if ((&netobuf[BUFSIZ] - nfrontp) < 2)
	241	break;
	242	c = *ptyip++ & 0377, pcc--;
	243	if (c == IAC)
	244	*nfrontp++ = c;
	245	*nfrontp++ = c;
	246	}
	247	if ((obits & (1 << f)) && (nfrontp - nbackp) > 0)
	248	netflush();
	249	if (ncc > 0)
	250	telrcv();
251	if ((obits & (1 << p)) && (pfrontp - pbackp) > 0)
252	ptyflush();
253	}
254	cleanup();
255	}
256
257	/*
258	* State for recv fsm
259	*/
260	#define TS_DATA 0 /* base state */
261	#define TS_IAC 1 /* look for double IAC's */
262	#define TS_CR 2 /* CR-LF ->'s CR */
263	#define TS_BEGINNEG 3 /* throw away begin's... */
264	#define TS_ENDNEG 4 /* ...end's (suboption negotiation) */
265	#define TS_WILL 5 /* will option negotiation */
266	#define TS_WONT 6 /* wont " */
267	#define TS_DO 7 /* do " */
268	#define TS_DONT 8 /* dont " */
269
270	telrcv()
271	{
272	register int c;
273	static int state = TS_DATA;
274	struct sgttyb b;
275
276	while (ncc > 0) {
277	if ((&ptyobuf[BUFSIZ] - pfrontp) < 2)
278	return;
279	c = *netip++ & 0377, ncc--;
280	switch (state) {
281
282	case TS_DATA:
283	if (c == IAC) {
284	state = TS_IAC;
285	break;
286	}
287	if (inter > 0)
288	break;
289	*pfrontp++ = c;
290	if (!myopts[TELOPT_BINARY] && c == '\r')
291	state = TS_CR;
292	break;
293
294	case TS_CR:
295	if (c && c != '\n')
296	*pfrontp++ = c;
297	state = TS_DATA;
298	break;
299
300	case TS_IAC:
301	switch (c) {
302
303	/*
304	* Send the process on the pty side an
305	* interrupt. Do this with a NULL or
306	* interrupt char; depending on the tty mode.
307	*/
308	case BREAK:
309	case IP:
310	interrupt();
311	break;
312
313	/*
314	* Are You There?
315	*/
316	case AYT:
317	*pfrontp++ = BELL;
318	break;
319
320	/*
321	* Erase Character and
322	* Erase Line
323	*/
324	case EC:
325	case EL:
326	ptyflush(); /* half-hearted */
327	ioctl(pty, TIOCGETP, &b);
328	*pfrontp++ = (c == EC) ?
329	b.sg_erase : b.sg_kill;
330	break;
331
332	/*
333	* Check for urgent data...
334	*/
335	case DM:
336	break;
337
338	/*
339	* Begin option subnegotiation...
340	*/
341	case SB:
342	state = TS_BEGINNEG;
343	continue;
344
345	case WILL:
346	case WONT:
347	case DO:
348	case DONT:
349	state = TS_WILL + (c - WILL);
350	continue;
351
352	case IAC:
353	*pfrontp++ = c;
354	break;
355	}
356	state = TS_DATA;
357	break;
358
359	case TS_BEGINNEG:
360	if (c == IAC)
361	state = TS_ENDNEG;
362	break;
363
364	case TS_ENDNEG:
365	state = c == SE ? TS_DATA : TS_BEGINNEG;
366	break;
367
368	case TS_WILL:
369	if (!hisopts[c])
370	willoption(c);
371	state = TS_DATA;
372	continue;
373
374	case TS_WONT:
375	if (hisopts[c])
376	wontoption(c);
377	state = TS_DATA;
378	continue;
379
380	case TS_DO:
381	if (!myopts[c])
382	dooption(c);
383	state = TS_DATA;
384	continue;
385
386	case TS_DONT:
387	if (myopts[c]) {
388	myopts[c] = 0;
389	sprintf(nfrontp, wont, c);
da96b661	390	nfrontp += sizeof (wont) - 2;
66b878f6 BJ	391	}
	392	state = TS_DATA;
	393	continue;
	394
	395	default:
	396	printf("netser: panic state=%d\n", state);
	397	exit(1);
	398	}
	399	}
	400	}
	401
	402	willoption(option)
	403	int option;
	404	{
	405	char *fmt;
	406
	407	switch (option) {
	408
	409	case TELOPT_BINARY:
	410	mode(RAW, 0);
	411	goto common;
	412
	413	case TELOPT_ECHO:
	414	mode(0, ECHO\|CRMOD);
	415	/FALL THRU/
	416
	417	case TELOPT_SGA:
	418	common:
	419	hisopts[option] = 1;
	420	fmt = doopt;
	421	break;
	422
	423	case TELOPT_TM:
	424	fmt = dont;
	425	break;
	426
	427	default:
	428	fmt = dont;
	429	break;
	430	}
13646f15	431	sprintf(nfrontp, fmt, option);
da96b661	432	nfrontp += sizeof (dont) - 2;
66b878f6 BJ	433	}
	434
	435	wontoption(option)
	436	int option;
	437	{
	438	char *fmt;
	439
	440	switch (option) {
	441
	442	case TELOPT_ECHO:
	443	mode(ECHO\|CRMOD, 0);
	444	goto common;
	445
	446	case TELOPT_BINARY:
	447	mode(0, RAW);
	448	/FALL THRU/
	449
	450	case TELOPT_SGA:
	451	common:
	452	hisopts[option] = 0;
	453	fmt = dont;
	454	break;
	455
	456	default:
	457	fmt = dont;
	458	}
	459	sprintf(nfrontp, fmt, option);
da96b661	460	nfrontp += sizeof (doopt) - 2;
66b878f6 BJ	461	}
	462
	463	dooption(option)
	464	int option;
	465	{
	466	char *fmt;
	467
	468	switch (option) {
	469
	470	case TELOPT_TM:
	471	fmt = wont;
	472	break;
	473
	474	case TELOPT_ECHO:
	475	mode(ECHO\|CRMOD, 0);
	476	goto common;
	477
	478	case TELOPT_BINARY:
	479	mode(RAW, 0);
	480	/FALL THRU/
	481
	482	case TELOPT_SGA:
	483	common:
	484	fmt = will;
	485	break;
	486
	487	default:
	488	fmt = wont;
	489	break;
	490	}
	491	sprintf(nfrontp, fmt, option);
da96b661	492	nfrontp += sizeof (doopt) - 2;
66b878f6 BJ	493	}
	494
	495	mode(on, off)
	496	int on, off;
	497	{
	498	struct sgttyb b;
	499
	500	ptyflush();
	501	ioctl(pty, TIOCGETP, &b);
	502	b.sg_flags \|= on;
	503	b.sg_flags &= ~off;
	504	ioctl(pty, TIOCSETP, &b);
	505	}
	506
	507	/*
	508	* Send interrupt to process on other side of pty.
	509	* If it is in raw mode, just write NULL;
	510	* otherwise, write intr char.
	511	*/
	512	interrupt()
	513	{
	514	struct sgttyb b;
	515	struct tchars tchars;
	516
	517	ptyflush(); /* half-hearted */
	518	ioctl(pty, TIOCGETP, &b);
	519	if (b.sg_flags & RAW) {
	520	*pfrontp++ = '\0';
	521	return;
	522	}
	523	*pfrontp++ = ioctl(pty, TIOCGETC, &tchars) < 0 ?
	524	'\177' : tchars.t_intrc;
	525	}
	526
	527	ptyflush()
	528	{
	529	int n;
	530
	531	if ((n = pfrontp - pbackp) > 0)
	532	n = write(pty, pbackp, n);
9f005877 SL	533	if (n < 0)
9f005877 SL	534	return;
66b878f6 BJ	535	pbackp += n;
	536	if (pbackp == pfrontp)
	537	pbackp = pfrontp = ptyobuf;
	538	}
	539
	540	netflush()
	541	{
	542	int n;
	543
	544	if ((n = nfrontp - nbackp) > 0)
	545	n = write(net, nbackp, n);
9f005877 SL	546	if (n < 0) {
	547	if (errno == EWOULDBLOCK)
	548	return;
	549	/* should blow this guy away... */
	550	return;
	551	}
66b878f6 BJ	552	nbackp += n;
	553	if (nbackp == nfrontp)
	554	nbackp = nfrontp = netobuf;
	555	}
	556
	557	cleanup()
	558	{
	559	int how = 2;
	560
	561	rmut();
	562	vhangup();
	563	ioctl(net, SIOCDONE, &how);
	564	kill(0, SIGKILL);
	565	exit(1);
	566	}
	567
	568	#include <utmp.h>
	569
	570	struct utmp wtmp;
	571	char wtmpf[] = "/usr/adm/wtmp";
	572	char utmp[] = "/etc/utmp";
da96b661 SL	573	#define SCPYN(a, b) strncpy(a, b, sizeof (a))
da96b661 SL	574	#define SCMPN(a, b) strncmp(a, b, sizeof (a))
66b878f6 BJ	575
	576	rmut()
	577	{
	578	register f;
	579	int found = 0;
	580
	581	f = open(utmp, 2);
	582	if (f >= 0) {
da96b661	583	while(read(f, (char *)&wtmp, sizeof (wtmp)) == sizeof (wtmp)) {
66b878f6 BJ	584	if (SCMPN(wtmp.ut_line, line+5) \|\| wtmp.ut_name[0]==0)
66b878f6 BJ	585	continue;
da96b661	586	lseek(f, -(long)sizeof (wtmp), 1);
66b878f6 BJ	587	SCPYN(wtmp.ut_name, "");
66b878f6 BJ	588	time(&wtmp.ut_time);
da96b661	589	write(f, (char *)&wtmp, sizeof (wtmp));
66b878f6 BJ	590	found++;
	591	}
	592	close(f);
	593	}
	594	if (found) {
	595	f = open(wtmpf, 1);
	596	if (f >= 0) {
	597	SCPYN(wtmp.ut_line, line+5);
	598	SCPYN(wtmp.ut_name, "");
	599	time(&wtmp.ut_time);
	600	lseek(f, (long)0, 2);
da96b661	601	write(f, (char *)&wtmp, sizeof (wtmp));
66b878f6 BJ	602	close(f);
	603	}
	604	}
	605	chmod(line, 0666);
	606	chown(line, 0, 0);
	607	line[strlen("/dev/")] = 'p';
	608	chmod(line, 0666);
	609	chown(line, 0, 0);
	610	}