usr/src/bin/stty/stty.c

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)stty.c	5.5 (Berkeley) %G%";
#endif not lint

/*
 * set teletype modes
 */

#include <stdio.h>
#include <sys/ioctl.h>

struct
{
	char	*string;
	int	speed;
} speeds[] = {
	"0",	B0,
	"50",	B50,
	"75",	B75,
	"110",	B110,
	"134",	B134,
	"134.5",B134,
	"150",	B150,
	"200",	B200,
	"300",	B300,
	"600",	B600,
	"1200",	B1200,
	"1800",	B1800,
	"2400",	B2400,
	"4800",	B4800,
	"9600",	B9600,
	"exta",	EXTA,
	"19200", EXTA,
	"extb",	EXTB,
	"38400", EXTB,
	0,
};
struct
{
	char	*string;
	int	set;
	int	reset;
	int	lset;
	int	lreset;
} modes[] = {
	"even",		EVENP, 0, 0, 0,
	"-even",	0, EVENP, 0, 0,
	"odd",		ODDP, 0, 0, 0,
	"-odd",		0, ODDP, 0, 0,
	"raw",		RAW, 0, 0, 0,
	"-raw",		0, RAW, 0, 0,
	"cooked",	0, RAW, 0, 0,
	"-nl",		CRMOD, 0, 0, 0,
	"nl",		0, CRMOD, 0, 0,
	"echo",		ECHO, 0, 0, 0,
	"-echo",	0, ECHO, 0, 0,
	"LCASE",	LCASE, 0, 0, 0,
	"lcase",	LCASE, 0, 0, 0,
	"-LCASE",	0, LCASE, 0, 0,
	"-lcase",	0, LCASE, 0, 0,
	"-tabs",	XTABS, 0, 0, 0,
	"tabs",		0, XTABS, 0, 0,
	"tandem",	TANDEM, 0, 0, 0,
	"-tandem",	0, TANDEM, 0, 0,
	"cbreak",	CBREAK, 0, 0, 0,
	"-cbreak",	0, CBREAK, 0, 0,
	"cr0",		CR0, CR3, 0, 0,
	"cr1",		CR1, CR3, 0, 0,
	"cr2",		CR2, CR3, 0, 0,
	"cr3",		CR3, CR3, 0, 0,
	"tab0",		TAB0, XTABS, 0, 0,
	"tab1",		TAB1, XTABS, 0, 0,
	"tab2",		TAB2, XTABS, 0, 0,
	"nl0",		NL0, NL3, 0, 0,
	"nl1",		NL1, NL3, 0, 0,
	"nl2",		NL2, NL3, 0, 0,
	"nl3",		NL3, NL3, 0, 0,
	"ff0",		FF0, FF1, 0, 0,
	"ff1",		FF1, FF1, 0, 0,
	"bs0",		BS0, BS1, 0, 0,
	"bs1",		BS1, BS1, 0, 0,
	"33",		CR1, ALLDELAY, 0, 0,
	"tty33",	CR1, ALLDELAY, 0, 0,
	"37",		FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
	"tty37",	FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
	"05",		NL2, ALLDELAY, 0, 0,
	"vt05",		NL2, ALLDELAY, 0, 0,
	"tn",		CR1, ALLDELAY, 0, 0,
	"tn300",	CR1, ALLDELAY, 0, 0,
	"ti",		CR2, ALLDELAY, 0, 0,
	"ti700",	CR2, ALLDELAY, 0, 0,
	"tek",		FF1, ALLDELAY, 0, 0,
	"crtbs",	0, 0, LCRTBS, LPRTERA,
	"-crtbs",	0, 0, 0, LCRTBS,
	"prterase",	0, 0, LPRTERA, LCRTBS+LCRTKIL+LCRTERA,
	"-prterase",	0, 0, 0, LPRTERA,
	"crterase",	0, 0, LCRTERA, LPRTERA,
	"-crterase",	0, 0, 0, LCRTERA,
	"crtkill",	0, 0, LCRTKIL, LPRTERA,
	"-crtkill",	0, 0, 0, LCRTKIL,
	"tilde",	0, 0, LTILDE, 0,
	"-tilde",	0, 0, 0, LTILDE,
	"mdmbuf",	0, 0, LMDMBUF, 0,
	"-mdmbuf",	0, 0, 0, LMDMBUF,
	"litout",	0, 0, LLITOUT, 0,
	"-litout",	0, 0, 0, LLITOUT,
	"pass8",	0, 0, LPASS8, 0,
	"-pass8",	0, 0, 0, LPASS8,
	"tostop",	0, 0, LTOSTOP, 0,
	"-tostop",	0, 0, 0, LTOSTOP,
	"flusho",	0, 0, LFLUSHO, 0,
	"-flusho",	0, 0, 0, LFLUSHO,
	"nohang",	0, 0, LNOHANG, 0,
	"-nohang",	0, 0, 0, LNOHANG,
#ifdef notdef
	"etxack",	0, 0, LETXACK, 0,
	"-etxack",	0, 0, 0, LETXACK,
#endif
	"ctlecho",	0, 0, LCTLECH, 0,
	"-ctlecho",	0, 0, 0, LCTLECH,
	"pendin",	0, 0, LPENDIN, 0,
	"-pendin",	0, 0, 0, LPENDIN,
	"decctlq",	0, 0, LDECCTQ, 0,
	"-decctlq",	0, 0, 0, LDECCTQ,
	"noflsh",	0, 0, LNOFLSH, 0,
	"-noflsh",	0, 0, 0, LNOFLSH,
	0,
};

struct tchars tc;
struct ltchars ltc;
struct sgttyb mode;
struct winsize win;
int	lmode;
int	oldisc, ldisc;

struct	special {
	char	*name;
	char	*cp;
	char	def;
} special[] = {
	"erase",	&mode.sg_erase,		CERASE,
	"kill",		&mode.sg_kill,		CKILL,
	"intr",		&tc.t_intrc,		CINTR,
	"quit",		&tc.t_quitc,		CQUIT,
	"start",	&tc.t_startc,		CSTART,
	"stop",		&tc.t_stopc,		CSTOP,
	"eof",		&tc.t_eofc,		CEOF,
	"brk",		&tc.t_brkc,		CBRK,
	"susp",		&ltc.t_suspc,		CSUSP,
	"dsusp",	&ltc.t_dsuspc,		CDSUSP,
	"rprnt",	&ltc.t_rprntc,		CRPRNT,
	"flush",	&ltc.t_flushc,		CFLUSH,
	"werase",	&ltc.t_werasc,		CWERASE,
	"lnext",	&ltc.t_lnextc,		CLNEXT,
	0
};
char	*arg;

int	argc;
char	**argv;
main(iargc, iargv)
char	**iargv;
{
	int i;
	register struct special *sp;
	char obuf[BUFSIZ];

	setbuf(stderr, obuf);
	argc = iargc;
	argv = iargv;
	ioctl(1, TIOCGETP, &mode);
	ioctl(1, TIOCGETD, &ldisc);
	oldisc = ldisc;
	ioctl(1, TIOCGETC, &tc);
	ioctl(1, TIOCLGET, &lmode);
	ioctl(1, TIOCGLTC, &ltc);
	ioctl(1, TIOCGWINSZ, &win);
	if(argc == 1) {
		prmodes(0);
		exit(0);
	}
	if (argc == 2 && !strcmp(argv[1], "all")) {
		prmodes(1);
		exit(0);
	}
	if (argc == 2 && !strcmp(argv[1], "everything")) {
		prmodes(2);
		exit(0);
	}
/*
	if (argc == 2 && !strcmp(argv[1], "all")) {
		prmodes(2);
		exit(0);
	}
*/
	while(--argc > 0) {
		arg = *++argv;
		if (eq("ek")){
			mode.sg_erase = '#';
			mode.sg_kill = '@';
			continue;
		}
		if (eq("new")){
			ldisc = NTTYDISC;
			if (ioctl(1, TIOCSETD, &ldisc)<0)
				perror("ioctl");
			continue;
		}
		if (eq("newcrt")){
			ldisc = NTTYDISC;
			lmode &= ~LPRTERA;
			lmode |= LCRTBS|LCTLECH;
			if (mode.sg_ospeed >= B1200)
				lmode |= LCRTERA|LCRTKIL;
			if (ioctl(1, TIOCSETD, &ldisc)<0)
				perror("ioctl");
			continue;
		}
		if (eq("crt")){
			lmode &= ~LPRTERA;
			lmode |= LCRTBS|LCTLECH;
			if (mode.sg_ospeed >= B1200)
				lmode |= LCRTERA|LCRTKIL;
			continue;
		}
		if (eq("old")){
			ldisc = 0;
			if (ioctl(1, TIOCSETD, &ldisc)<0)
				perror("ioctl");
			continue;
		}
		if (eq("dec")){
			mode.sg_erase = 0177;
			mode.sg_kill = CKILL;
			tc.t_intrc = CINTR;
			ldisc = NTTYDISC;
			lmode &= ~LPRTERA;
			lmode |= LCRTBS|LCTLECH|LDECCTQ;
			if (mode.sg_ospeed >= B1200)
				lmode |= LCRTERA|LCRTKIL;
			if (ioctl(1, TIOCSETD, &ldisc)<0)
				perror("ioctl");
			continue;
		}
		for (sp = special; sp->name; sp++)
			if (eq(sp->name)) {
				if (--argc == 0)
					goto done;
				if (**++argv == 'u')
					*sp->cp = 0377;
				else if (**argv == '^')
					*sp->cp = ((*argv)[1] == '?') ?
					    0177 : (*argv)[1] & 037;
				else
					*sp->cp = **argv;
				goto cont;
			}
		if (eq("gspeed")) {
			mode.sg_ispeed = B300;
			mode.sg_ospeed = B9600;
			continue;
		}
		if (eq("hup")) {
			ioctl(1, TIOCHPCL, NULL);
			continue;
		}
		if (eq("rows")) {
			if (--argc == 0)
				goto done;
			win.ws_row = atoi(*++argv);
		}
		if (eq("cols") || eq("columns")) {
			if (--argc == 0)
				goto done;
			win.ws_col = atoi(*++argv);
		}
		if (eq("size")) {
			ioctl(open("/dev/tty", 0), TIOCGWINSZ, &win);
			printf("%d %d\n", win.ws_row, win.ws_col);
			exit(0);
		}
		for(i=0; speeds[i].string; i++)
			if(eq(speeds[i].string)) {
				mode.sg_ispeed = mode.sg_ospeed = speeds[i].speed;
				goto cont;
			}
		if (eq("speed")) {
			ioctl(open("/dev/tty", 0), TIOCGETP, &mode);
			for(i=0; speeds[i].string; i++)
				if (mode.sg_ospeed == speeds[i].speed) {
					printf("%s\n", speeds[i].string);
					exit(0);
				}
			printf("unknown\n");
			exit(1);
		}
		for(i=0; modes[i].string; i++)
			if(eq(modes[i].string)) {
				mode.sg_flags &= ~modes[i].reset;
				mode.sg_flags |= modes[i].set;
				lmode &= ~modes[i].lreset;
				lmode |= modes[i].lset;
			}
		if(arg)
			fprintf(stderr,"unknown mode: %s\n", arg);
cont:
		;
	}
done:
	ioctl(1, TIOCSETN, &mode);
	ioctl(1, TIOCSETC, &tc);
	ioctl(1, TIOCSLTC, &ltc);
	ioctl(1, TIOCLSET, &lmode);
	ioctl(1, TIOCSWINSZ, &win);
}

eq(string)
char *string;
{
	int i;

	if(!arg)
		return(0);
	i = 0;
loop:
	if(arg[i] != string[i])
		return(0);
	if(arg[i++] != '\0')
		goto loop;
	arg = 0;
	return(1);
}

prmodes(all)
{
	register m;
	int any;

	if(ldisc==NETLDISC)
		fprintf(stderr, "net discipline, ");
	else if(ldisc==NTTYDISC)
		fprintf(stderr, "new tty, ");
	else if(all==2)
		fprintf(stderr, "old tty, ");
	if(mode.sg_ispeed != mode.sg_ospeed) {
		prspeed("input speed ", mode.sg_ispeed);
		prspeed("output speed ", mode.sg_ospeed);
	} else
		prspeed("speed ", mode.sg_ispeed);
	if (all)
		fprintf(stderr, ", %d rows, %d columns", win.ws_row, win.ws_col);
	fprintf(stderr, all==2 ? "\n" : "; ");
	m = mode.sg_flags;
	if(all==2 || (m&(EVENP|ODDP))!=(EVENP|ODDP)) {
		if(m & EVENP)	fprintf(stderr,"even ");
		if(m & ODDP)	fprintf(stderr,"odd ");
	}
	if(all==2 || m&RAW)
		fprintf(stderr,"-raw "+((m&RAW)!=0));
	if(all==2 || (m&CRMOD)==0)
		fprintf(stderr,"-nl "+((m&CRMOD)==0));
	if(all==2 || (m&ECHO)==0)
		fprintf(stderr,"-echo "+((m&ECHO)!=0));
	if(all==2 || (m&LCASE))
		fprintf(stderr,"-lcase "+((m&LCASE)!=0));
	if(all==2 || (m&TANDEM))
		fprintf(stderr,"-tandem "+((m&TANDEM)!=0));
	fprintf(stderr,"-tabs "+((m&XTABS)!=XTABS));
	if(all==2 || (m&CBREAK))
		fprintf(stderr,"-cbreak "+((m&CBREAK)!=0));
	if(all==2 || (m&NLDELAY))
		delay((m&NLDELAY)/NL1,	"nl");
	if ((m&TBDELAY)!=XTABS)
		delay((m&TBDELAY)/TAB1,	"tab");
	if(all==2 || (m&CRDELAY))
		delay((m&CRDELAY)/CR1,	"cr");
	if(all==2 || (m&VTDELAY))
		delay((m&VTDELAY)/FF1,	"ff");
	if(all==2 || (m&BSDELAY))
		delay((m&BSDELAY)/BS1,	"bs");
	if (all)
		fprintf(stderr,"\n");
#define	lpit(what,str) \
	if (all==2||(lmode&what)) { \
		fprintf(stderr,str+((lmode&what)!=0)); any++; \
	}
	if (ldisc == NTTYDISC) {
		int newcrt = (lmode&(LCTLECH|LCRTBS)) == (LCTLECH|LCRTBS) &&
		    (lmode&(LCRTERA|LCRTKIL)) ==
		      ((mode.sg_ospeed > B300) ? LCRTERA|LCRTKIL : 0);
		int nothing = 1;
		if (newcrt) {
			if (all==2)
				fprintf(stderr, "crt: (crtbs crterase crtkill ctlecho) ");
			else
				fprintf(stderr, "crt ");
			any++;
		} else {
			lpit(LCRTBS, "-crtbs ");
			lpit(LCRTERA, "-crterase ");
			lpit(LCRTKIL, "-crtkill ");
			lpit(LCTLECH, "-ctlecho ");
			lpit(LPRTERA, "-prterase ");
		}
		lpit(LTOSTOP, "-tostop ");
		if (all==2) {
			fprintf(stderr, "\n");
			any = 0;
			nothing = 0;
		}
		lpit(LTILDE, "-tilde ");
		lpit(LFLUSHO, "-flusho ");
		lpit(LMDMBUF, "-mdmbuf ");
		lpit(LLITOUT, "-litout ");
		lpit(LPASS8, "-pass8 ");
		lpit(LNOHANG, "-nohang ");
		if (any) {
			fprintf(stderr,"\n");
			any = 0;
			nothing = 0;
		}
#ifdef notdef
		lpit(LETXACK, "-etxack ");
#endif
		lpit(LPENDIN, "-pendin ");
		lpit(LDECCTQ, "-decctlq ");
		lpit(LNOFLSH, "-noflsh ");
		if (any || nothing)
			fprintf(stderr,"\n");
	} else if (!all)
		fprintf(stderr,"\n");
	if (all) {
		switch (ldisc) {

		case 0:
			fprintf(stderr,"\
erase  kill   intr   quit   stop   eof\
\n");
			pcol(mode.sg_erase, -1);
			pcol(mode.sg_kill, -1);
			pcol(tc.t_intrc, -1);
			pcol(tc.t_quitc, -1);
			pcol(tc.t_stopc, tc.t_startc);
			pcol(tc.t_eofc, tc.t_brkc);
			fprintf(stderr,"\n");
			break;

		case NTTYDISC:
			fprintf(stderr,"\
erase  kill   werase rprnt  flush  lnext  susp   intr   quit   stop   eof\
\n");
			pcol(mode.sg_erase, -1);
			pcol(mode.sg_kill, -1);
			pcol(ltc.t_werasc, -1);
			pcol(ltc.t_rprntc, -1);
			pcol(ltc.t_flushc, -1);
			pcol(ltc.t_lnextc, -1);
			pcol(ltc.t_suspc, ltc.t_dsuspc);
			pcol(tc.t_intrc, -1);
			pcol(tc.t_quitc, -1);
			pcol(tc.t_stopc, tc.t_startc);
			pcol(tc.t_eofc, tc.t_brkc);
			fprintf(stderr,"\n");
			break;
		}
	} else if (ldisc != NETLDISC) {
		register struct special *sp;
		int first = 1;

		for (sp = special; sp->name; sp++) {
			if ((*sp->cp&0377) != (sp->def&0377)) {
				pit(*sp->cp, sp->name, first ? "" : ", ");
				first = 0;
			};
			if (sp->cp == &tc.t_brkc && ldisc == 0)
				break;
		}
		if (!first)
			fprintf(stderr, "\n");
	}
}

pcol(ch1, ch2)
	int ch1, ch2;
{
	int nout = 0;

	ch1 &= 0377;
	ch2 &= 0377;
	if (ch1 == ch2)
		ch2 = 0377;
	for (; ch1 != 0377 || ch2 != 0377; ch1 = ch2, ch2 = 0377) {
		if (ch1 == 0377)
			continue;
		if (ch1 & 0200) {
			fprintf(stderr, "M-");
			nout += 2;
			ch1 &= ~ 0200;
		}
		if (ch1 == 0177) {
			fprintf(stderr, "^");
			nout++;
			ch1 = '?';
		} else if (ch1 < ' ') {
			fprintf(stderr, "^");
			nout++;
			ch1 += '@';
		}
		fprintf(stderr, "%c", ch1);
		nout++;
		if (ch2 != 0377) {
			fprintf(stderr, "/");
			nout++;
		}
	}
	while (nout < 7) {
		fprintf(stderr, " ");
		nout++;
	}
}

pit(what, itsname, sep)
	unsigned what;
	char *itsname, *sep;
{

	what &= 0377;
	fprintf(stderr, "%s%s", sep, itsname);
	if (what == 0377) {
		fprintf(stderr, " <undef>");
		return;
	}
	fprintf(stderr, " = ");
	if (what & 0200) {
		fprintf(stderr, "M-");
		what &= ~ 0200;
	}
	if (what == 0177) {
		fprintf(stderr, "^");
		what = '?';
	} else if (what < ' ') {
		fprintf(stderr, "^");
		what += '@';
	}
	fprintf(stderr, "%c", what);
}

delay(m, s)
char *s;
{

	if(m)
		fprintf(stderr,"%s%d ", s, m);
}

int	speed[] = {
	0,50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400
};

prspeed(c, s)
char *c;
{

	fprintf(stderr,"%s%d baud",  c, speed[s]);
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 1980 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) 1980 Regents of the University of California.\n\
	10	All rights reserved.\n";
	11	#endif not lint
	12
	13	#ifndef lint
	14	static char sccsid[] = "@(#)stty.c 5.5 (Berkeley) %G%";
	15	#endif not lint
	16
	17	/*
	18	* set teletype modes
	19	*/
	20
	21	#include <stdio.h>
	22	#include <sys/ioctl.h>
	23
	24	struct
	25	{
	26	char *string;
	27	int speed;
	28	} speeds[] = {
	29	"0", B0,
	30	"50", B50,
	31	"75", B75,
	32	"110", B110,
	33	"134", B134,
	34	"134.5",B134,
	35	"150", B150,
	36	"200", B200,
	37	"300", B300,
	38	"600", B600,
	39	"1200", B1200,
	40	"1800", B1800,
	41	"2400", B2400,
	42	"4800", B4800,
	43	"9600", B9600,
	44	"exta", EXTA,
	45	"19200", EXTA,
	46	"extb", EXTB,
	47	"38400", EXTB,
	48	0,
	49	};
	50	struct
	51	{
	52	char *string;
	53	int set;
	54	int reset;
	55	int lset;
	56	int lreset;
	57	} modes[] = {
	58	"even", EVENP, 0, 0, 0,
	59	"-even", 0, EVENP, 0, 0,
	60	"odd", ODDP, 0, 0, 0,
	61	"-odd", 0, ODDP, 0, 0,
	62	"raw", RAW, 0, 0, 0,
	63	"-raw", 0, RAW, 0, 0,
	64	"cooked", 0, RAW, 0, 0,
	65	"-nl", CRMOD, 0, 0, 0,
	66	"nl", 0, CRMOD, 0, 0,
	67	"echo", ECHO, 0, 0, 0,
	68	"-echo", 0, ECHO, 0, 0,
	69	"LCASE", LCASE, 0, 0, 0,
	70	"lcase", LCASE, 0, 0, 0,
	71	"-LCASE", 0, LCASE, 0, 0,
	72	"-lcase", 0, LCASE, 0, 0,
	73	"-tabs", XTABS, 0, 0, 0,
	74	"tabs", 0, XTABS, 0, 0,
	75	"tandem", TANDEM, 0, 0, 0,
	76	"-tandem", 0, TANDEM, 0, 0,
	77	"cbreak", CBREAK, 0, 0, 0,
	78	"-cbreak", 0, CBREAK, 0, 0,
	79	"cr0", CR0, CR3, 0, 0,
	80	"cr1", CR1, CR3, 0, 0,
	81	"cr2", CR2, CR3, 0, 0,
	82	"cr3", CR3, CR3, 0, 0,
	83	"tab0", TAB0, XTABS, 0, 0,
	84	"tab1", TAB1, XTABS, 0, 0,
	85	"tab2", TAB2, XTABS, 0, 0,
	86	"nl0", NL0, NL3, 0, 0,
	87	"nl1", NL1, NL3, 0, 0,
	88	"nl2", NL2, NL3, 0, 0,
	89	"nl3", NL3, NL3, 0, 0,
	90	"ff0", FF0, FF1, 0, 0,
	91	"ff1", FF1, FF1, 0, 0,
	92	"bs0", BS0, BS1, 0, 0,
	93	"bs1", BS1, BS1, 0, 0,
	94	"33", CR1, ALLDELAY, 0, 0,
	95	"tty33", CR1, ALLDELAY, 0, 0,
	96	"37", FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
	97	"tty37", FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
	98	"05", NL2, ALLDELAY, 0, 0,
	99	"vt05", NL2, ALLDELAY, 0, 0,
	100	"tn", CR1, ALLDELAY, 0, 0,
	101	"tn300", CR1, ALLDELAY, 0, 0,
	102	"ti", CR2, ALLDELAY, 0, 0,
	103	"ti700", CR2, ALLDELAY, 0, 0,
	104	"tek", FF1, ALLDELAY, 0, 0,
	105	"crtbs", 0, 0, LCRTBS, LPRTERA,
	106	"-crtbs", 0, 0, 0, LCRTBS,
	107	"prterase", 0, 0, LPRTERA, LCRTBS+LCRTKIL+LCRTERA,
	108	"-prterase", 0, 0, 0, LPRTERA,
	109	"crterase", 0, 0, LCRTERA, LPRTERA,
	110	"-crterase", 0, 0, 0, LCRTERA,
	111	"crtkill", 0, 0, LCRTKIL, LPRTERA,
	112	"-crtkill", 0, 0, 0, LCRTKIL,
	113	"tilde", 0, 0, LTILDE, 0,
	114	"-tilde", 0, 0, 0, LTILDE,
	115	"mdmbuf", 0, 0, LMDMBUF, 0,
	116	"-mdmbuf", 0, 0, 0, LMDMBUF,
	117	"litout", 0, 0, LLITOUT, 0,
	118	"-litout", 0, 0, 0, LLITOUT,
	119	"pass8", 0, 0, LPASS8, 0,
	120	"-pass8", 0, 0, 0, LPASS8,
	121	"tostop", 0, 0, LTOSTOP, 0,
	122	"-tostop", 0, 0, 0, LTOSTOP,
	123	"flusho", 0, 0, LFLUSHO, 0,
	124	"-flusho", 0, 0, 0, LFLUSHO,
	125	"nohang", 0, 0, LNOHANG, 0,
	126	"-nohang", 0, 0, 0, LNOHANG,
	127	#ifdef notdef
	128	"etxack", 0, 0, LETXACK, 0,
	129	"-etxack", 0, 0, 0, LETXACK,
	130	#endif
	131	"ctlecho", 0, 0, LCTLECH, 0,
	132	"-ctlecho", 0, 0, 0, LCTLECH,
	133	"pendin", 0, 0, LPENDIN, 0,
	134	"-pendin", 0, 0, 0, LPENDIN,
	135	"decctlq", 0, 0, LDECCTQ, 0,
	136	"-decctlq", 0, 0, 0, LDECCTQ,
	137	"noflsh", 0, 0, LNOFLSH, 0,
	138	"-noflsh", 0, 0, 0, LNOFLSH,
	139	0,
	140	};
	141
	142	struct tchars tc;
	143	struct ltchars ltc;
	144	struct sgttyb mode;
	145	struct winsize win;
	146	int lmode;
	147	int oldisc, ldisc;
	148
	149	struct special {
	150	char *name;
	151	char *cp;
	152	char def;
	153	} special[] = {
	154	"erase", &mode.sg_erase, CERASE,
	155	"kill", &mode.sg_kill, CKILL,
	156	"intr", &tc.t_intrc, CINTR,
	157	"quit", &tc.t_quitc, CQUIT,
	158	"start", &tc.t_startc, CSTART,
	159	"stop", &tc.t_stopc, CSTOP,
	160	"eof", &tc.t_eofc, CEOF,
	161	"brk", &tc.t_brkc, CBRK,
	162	"susp", &ltc.t_suspc, CSUSP,
	163	"dsusp", &ltc.t_dsuspc, CDSUSP,
	164	"rprnt", &ltc.t_rprntc, CRPRNT,
	165	"flush", &ltc.t_flushc, CFLUSH,
	166	"werase", &ltc.t_werasc, CWERASE,
	167	"lnext", &ltc.t_lnextc, CLNEXT,
	168	0
	169	};
	170	char *arg;
	171
	172	int argc;
	173	char **argv;
	174	main(iargc, iargv)
	175	char **iargv;
	176	{
	177	int i;
	178	register struct special *sp;
	179	char obuf[BUFSIZ];
	180
	181	setbuf(stderr, obuf);
	182	argc = iargc;
	183	argv = iargv;
	184	ioctl(1, TIOCGETP, &mode);
	185	ioctl(1, TIOCGETD, &ldisc);
	186	oldisc = ldisc;
	187	ioctl(1, TIOCGETC, &tc);
	188	ioctl(1, TIOCLGET, &lmode);
	189	ioctl(1, TIOCGLTC, &ltc);
	190	ioctl(1, TIOCGWINSZ, &win);
	191	if(argc == 1) {
	192	prmodes(0);
	193	exit(0);
	194	}
	195	if (argc == 2 && !strcmp(argv[1], "all")) {
	196	prmodes(1);
	197	exit(0);
	198	}
	199	if (argc == 2 && !strcmp(argv[1], "everything")) {
	200	prmodes(2);
	201	exit(0);
	202	}
	203	/*
	204	if (argc == 2 && !strcmp(argv[1], "all")) {
	205	prmodes(2);
	206	exit(0);
	207	}
	208	*/
	209	while(--argc > 0) {
	210	arg = *++argv;
	211	if (eq("ek")){
	212	mode.sg_erase = '#';
	213	mode.sg_kill = '@';
	214	continue;
	215	}
	216	if (eq("new")){
	217	ldisc = NTTYDISC;
	218	if (ioctl(1, TIOCSETD, &ldisc)<0)
	219	perror("ioctl");
	220	continue;
	221	}
	222	if (eq("newcrt")){
	223	ldisc = NTTYDISC;
	224	lmode &= ~LPRTERA;
	225	lmode \|= LCRTBS\|LCTLECH;
	226	if (mode.sg_ospeed >= B1200)
	227	lmode \|= LCRTERA\|LCRTKIL;
	228	if (ioctl(1, TIOCSETD, &ldisc)<0)
	229	perror("ioctl");
	230	continue;
	231	}
	232	if (eq("crt")){
	233	lmode &= ~LPRTERA;
	234	lmode \|= LCRTBS\|LCTLECH;
	235	if (mode.sg_ospeed >= B1200)
	236	lmode \|= LCRTERA\|LCRTKIL;
	237	continue;
	238	}
	239	if (eq("old")){
	240	ldisc = 0;
	241	if (ioctl(1, TIOCSETD, &ldisc)<0)
	242	perror("ioctl");
	243	continue;
	244	}
	245	if (eq("dec")){
	246	mode.sg_erase = 0177;
	247	mode.sg_kill = CKILL;
	248	tc.t_intrc = CINTR;
	249	ldisc = NTTYDISC;
	250	lmode &= ~LPRTERA;
	251	lmode \|= LCRTBS\|LCTLECH\|LDECCTQ;
	252	if (mode.sg_ospeed >= B1200)
	253	lmode \|= LCRTERA\|LCRTKIL;
	254	if (ioctl(1, TIOCSETD, &ldisc)<0)
	255	perror("ioctl");
	256	continue;
	257	}
	258	for (sp = special; sp->name; sp++)
	259	if (eq(sp->name)) {
	260	if (--argc == 0)
	261	goto done;
	262	if (**++argv == 'u')
	263	*sp->cp = 0377;
	264	else if (**argv == '^')
	265	sp->cp = ((argv)[1] == '?') ?
	266	0177 : (*argv)[1] & 037;
	267	else
	268	sp->cp = *argv;
	269	goto cont;
	270	}
	271	if (eq("gspeed")) {
	272	mode.sg_ispeed = B300;
	273	mode.sg_ospeed = B9600;
	274	continue;
	275	}
	276	if (eq("hup")) {
	277	ioctl(1, TIOCHPCL, NULL);
	278	continue;
	279	}
	280	if (eq("rows")) {
	281	if (--argc == 0)
	282	goto done;
	283	win.ws_row = atoi(*++argv);
	284	}
	285	if (eq("cols") \|\| eq("columns")) {
	286	if (--argc == 0)
	287	goto done;
	288	win.ws_col = atoi(*++argv);
	289	}
	290	if (eq("size")) {
	291	ioctl(open("/dev/tty", 0), TIOCGWINSZ, &win);
	292	printf("%d %d\n", win.ws_row, win.ws_col);
	293	exit(0);
	294	}
	295	for(i=0; speeds[i].string; i++)
	296	if(eq(speeds[i].string)) {
	297	mode.sg_ispeed = mode.sg_ospeed = speeds[i].speed;
	298	goto cont;
	299	}
	300	if (eq("speed")) {
	301	ioctl(open("/dev/tty", 0), TIOCGETP, &mode);
	302	for(i=0; speeds[i].string; i++)
	303	if (mode.sg_ospeed == speeds[i].speed) {
	304	printf("%s\n", speeds[i].string);
	305	exit(0);
	306	}
	307	printf("unknown\n");
	308	exit(1);
	309	}
	310	for(i=0; modes[i].string; i++)
	311	if(eq(modes[i].string)) {
	312	mode.sg_flags &= ~modes[i].reset;
	313	mode.sg_flags \|= modes[i].set;
	314	lmode &= ~modes[i].lreset;
	315	lmode \|= modes[i].lset;
	316	}
	317	if(arg)
	318	fprintf(stderr,"unknown mode: %s\n", arg);
	319	cont:
	320	;
	321	}
	322	done:
	323	ioctl(1, TIOCSETN, &mode);
	324	ioctl(1, TIOCSETC, &tc);
	325	ioctl(1, TIOCSLTC, &ltc);
	326	ioctl(1, TIOCLSET, &lmode);
	327	ioctl(1, TIOCSWINSZ, &win);
	328	}
	329
	330	eq(string)
	331	char *string;
	332	{
	333	int i;
	334
	335	if(!arg)
	336	return(0);
	337	i = 0;
	338	loop:
	339	if(arg[i] != string[i])
	340	return(0);
	341	if(arg[i++] != '\0')
	342	goto loop;
	343	arg = 0;
	344	return(1);
	345	}
	346
	347	prmodes(all)
	348	{
	349	register m;
	350	int any;
	351
	352	if(ldisc==NETLDISC)
	353	fprintf(stderr, "net discipline, ");
	354	else if(ldisc==NTTYDISC)
	355	fprintf(stderr, "new tty, ");
	356	else if(all==2)
	357	fprintf(stderr, "old tty, ");
	358	if(mode.sg_ispeed != mode.sg_ospeed) {
	359	prspeed("input speed ", mode.sg_ispeed);
	360	prspeed("output speed ", mode.sg_ospeed);
	361	} else
	362	prspeed("speed ", mode.sg_ispeed);
	363	if (all)
	364	fprintf(stderr, ", %d rows, %d columns", win.ws_row, win.ws_col);
	365	fprintf(stderr, all==2 ? "\n" : "; ");
	366	m = mode.sg_flags;
	367	if(all==2 \|\| (m&(EVENP\|ODDP))!=(EVENP\|ODDP)) {
	368	if(m & EVENP) fprintf(stderr,"even ");
	369	if(m & ODDP) fprintf(stderr,"odd ");
	370	}
	371	if(all==2 \|\| m&RAW)
	372	fprintf(stderr,"-raw "+((m&RAW)!=0));
	373	if(all==2 \|\| (m&CRMOD)==0)
	374	fprintf(stderr,"-nl "+((m&CRMOD)==0));
	375	if(all==2 \|\| (m&ECHO)==0)
	376	fprintf(stderr,"-echo "+((m&ECHO)!=0));
	377	if(all==2 \|\| (m&LCASE))
	378	fprintf(stderr,"-lcase "+((m&LCASE)!=0));
	379	if(all==2 \|\| (m&TANDEM))
	380	fprintf(stderr,"-tandem "+((m&TANDEM)!=0));
	381	fprintf(stderr,"-tabs "+((m&XTABS)!=XTABS));
	382	if(all==2 \|\| (m&CBREAK))
	383	fprintf(stderr,"-cbreak "+((m&CBREAK)!=0));
	384	if(all==2 \|\| (m&NLDELAY))
	385	delay((m&NLDELAY)/NL1, "nl");
	386	if ((m&TBDELAY)!=XTABS)
	387	delay((m&TBDELAY)/TAB1, "tab");
	388	if(all==2 \|\| (m&CRDELAY))
	389	delay((m&CRDELAY)/CR1, "cr");
	390	if(all==2 \|\| (m&VTDELAY))
	391	delay((m&VTDELAY)/FF1, "ff");
	392	if(all==2 \|\| (m&BSDELAY))
	393	delay((m&BSDELAY)/BS1, "bs");
	394	if (all)
	395	fprintf(stderr,"\n");
	396	#define lpit(what,str) \
	397	if (all==2\|\|(lmode&what)) { \
	398	fprintf(stderr,str+((lmode&what)!=0)); any++; \
	399	}
	400	if (ldisc == NTTYDISC) {
	401	int newcrt = (lmode&(LCTLECH\|LCRTBS)) == (LCTLECH\|LCRTBS) &&
	402	(lmode&(LCRTERA\|LCRTKIL)) ==
	403	((mode.sg_ospeed > B300) ? LCRTERA\|LCRTKIL : 0);
	404	int nothing = 1;
	405	if (newcrt) {
	406	if (all==2)
	407	fprintf(stderr, "crt: (crtbs crterase crtkill ctlecho) ");
	408	else
	409	fprintf(stderr, "crt ");
	410	any++;
	411	} else {
	412	lpit(LCRTBS, "-crtbs ");
	413	lpit(LCRTERA, "-crterase ");
	414	lpit(LCRTKIL, "-crtkill ");
	415	lpit(LCTLECH, "-ctlecho ");
	416	lpit(LPRTERA, "-prterase ");
	417	}
	418	lpit(LTOSTOP, "-tostop ");
	419	if (all==2) {
	420	fprintf(stderr, "\n");
	421	any = 0;
	422	nothing = 0;
	423	}
	424	lpit(LTILDE, "-tilde ");
	425	lpit(LFLUSHO, "-flusho ");
	426	lpit(LMDMBUF, "-mdmbuf ");
	427	lpit(LLITOUT, "-litout ");
	428	lpit(LPASS8, "-pass8 ");
	429	lpit(LNOHANG, "-nohang ");
	430	if (any) {
	431	fprintf(stderr,"\n");
	432	any = 0;
	433	nothing = 0;
	434	}
	435	#ifdef notdef
	436	lpit(LETXACK, "-etxack ");
	437	#endif
	438	lpit(LPENDIN, "-pendin ");
	439	lpit(LDECCTQ, "-decctlq ");
	440	lpit(LNOFLSH, "-noflsh ");
	441	if (any \|\| nothing)
	442	fprintf(stderr,"\n");
	443	} else if (!all)
	444	fprintf(stderr,"\n");
	445	if (all) {
	446	switch (ldisc) {
	447
	448	case 0:
	449	fprintf(stderr,"\
	450	erase kill intr quit stop eof\
	451	\n");
	452	pcol(mode.sg_erase, -1);
	453	pcol(mode.sg_kill, -1);
	454	pcol(tc.t_intrc, -1);
	455	pcol(tc.t_quitc, -1);
	456	pcol(tc.t_stopc, tc.t_startc);
	457	pcol(tc.t_eofc, tc.t_brkc);
	458	fprintf(stderr,"\n");
	459	break;
	460
	461	case NTTYDISC:
	462	fprintf(stderr,"\
	463	erase kill werase rprnt flush lnext susp intr quit stop eof\
	464	\n");
	465	pcol(mode.sg_erase, -1);
	466	pcol(mode.sg_kill, -1);
	467	pcol(ltc.t_werasc, -1);
	468	pcol(ltc.t_rprntc, -1);
	469	pcol(ltc.t_flushc, -1);
	470	pcol(ltc.t_lnextc, -1);
	471	pcol(ltc.t_suspc, ltc.t_dsuspc);
	472	pcol(tc.t_intrc, -1);
	473	pcol(tc.t_quitc, -1);
	474	pcol(tc.t_stopc, tc.t_startc);
	475	pcol(tc.t_eofc, tc.t_brkc);
	476	fprintf(stderr,"\n");
	477	break;
	478	}
	479	} else if (ldisc != NETLDISC) {
	480	register struct special *sp;
	481	int first = 1;
	482
	483	for (sp = special; sp->name; sp++) {
	484	if ((*sp->cp&0377) != (sp->def&0377)) {
	485	pit(*sp->cp, sp->name, first ? "" : ", ");
	486	first = 0;
	487	};
	488	if (sp->cp == &tc.t_brkc && ldisc == 0)
	489	break;
	490	}
	491	if (!first)
	492	fprintf(stderr, "\n");
	493	}
	494	}
	495
	496	pcol(ch1, ch2)
	497	int ch1, ch2;
	498	{
	499	int nout = 0;
	500
	501	ch1 &= 0377;
	502	ch2 &= 0377;
	503	if (ch1 == ch2)
	504	ch2 = 0377;
	505	for (; ch1 != 0377 \|\| ch2 != 0377; ch1 = ch2, ch2 = 0377) {
	506	if (ch1 == 0377)
	507	continue;
	508	if (ch1 & 0200) {
	509	fprintf(stderr, "M-");
	510	nout += 2;
	511	ch1 &= ~ 0200;
	512	}
	513	if (ch1 == 0177) {
	514	fprintf(stderr, "^");
	515	nout++;
	516	ch1 = '?';
	517	} else if (ch1 < ' ') {
	518	fprintf(stderr, "^");
	519	nout++;
	520	ch1 += '@';
	521	}
	522	fprintf(stderr, "%c", ch1);
	523	nout++;
	524	if (ch2 != 0377) {
	525	fprintf(stderr, "/");
	526	nout++;
	527	}
	528	}
	529	while (nout < 7) {
	530	fprintf(stderr, " ");
	531	nout++;
	532	}
	533	}
	534
	535	pit(what, itsname, sep)
	536	unsigned what;
	537	char itsname, sep;
	538	{
	539
	540	what &= 0377;
	541	fprintf(stderr, "%s%s", sep, itsname);
	542	if (what == 0377) {
	543	fprintf(stderr, " <undef>");
	544	return;
	545	}
	546	fprintf(stderr, " = ");
	547	if (what & 0200) {
	548	fprintf(stderr, "M-");
	549	what &= ~ 0200;
	550	}
	551	if (what == 0177) {
	552	fprintf(stderr, "^");
	553	what = '?';
	554	} else if (what < ' ') {
	555	fprintf(stderr, "^");
	556	what += '@';
	557	}
	558	fprintf(stderr, "%c", what);
	559	}
	560
	561	delay(m, s)
	562	char *s;
	563	{
	564
	565	if(m)
	566	fprintf(stderr,"%s%d ", s, m);
	567	}
	568
	569	int speed[] = {
	570	0,50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400
	571	};
	572
	573	prspeed(c, s)
	574	char *c;
	575	{
	576
	577	fprintf(stderr,"%s%d baud", c, speed[s]);
	578	}