OpenSolaris_b135/ucbcmd/tset/tset.c
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
/*
* TSET -- set terminal modes
*
* This program does sophisticated terminal initialization.
* I recommend that you include it in your .profile or .login
* file to initialize whatever terminal you are on.
*
* There are several features:
*
* A special file or sequence (as controlled by the termcap file)
* is sent to the terminal.
*
* Mode bits are set on a per-terminal_type basis (much better
* than UNIX itself). This allows special delays, automatic
* tabs, etc.
*
* Erase and Kill characters can be set to whatever you want.
* Default is to change erase to control-H on a terminal which
* can overstrike, and leave it alone on anything else. Kill
* is always left alone unless specifically requested. These
* characters can be represented as "^X" meaning control-X;
* X is any character.
*
* Terminals which are dialups or plugboard types can be aliased
* to whatever type you may have in your home or office. Thus,
* if you know that when you dial up you will always be on a
* TI 733, you can specify that fact to tset. You can represent
* a type as "?type". This will ask you what type you want it
* to be -- if you reply with just a newline, it will default
* to the type given.
*
* The current terminal type can be queried.
*
* Usage:
* tset [-] [-EC] [-eC] [-kC] [-iC] [-s] [-h] [-u] [-r]
* [-m [ident] [test baudrate] :type]
* [-Q] [-I] [-S] [type]
*
* In systems with environments, use:
* eval `tset -s ...`
* Actually, this doesn't work in old csh's.
* Instead, use:
* tset -s ... > tset.tmp
* source tset.tmp
* rm tset.tmp
* or:
* set noglob
* set term=(`tset -S ....`)
* setenv TERM $term[1]
* setenv TERMCAP "$term[2]"
* unset term
* unset noglob
*
* Positional Parameters:
* type -- the terminal type to force. If this is
* specified, initialization is for this
* terminal type.
*
* Flags:
* - -- report terminal type. Whatever type is
* decided on is reported. If no other flags
* are stated, the only affect is to write
* the terminal type on the standard output.
* -r -- report to user in addition to other flags.
* -EC -- set the erase character to C on all terminals
* except those which cannot backspace (e.g.,
* a TTY 33). C defaults to control-H.
* -eC -- set the erase character to C on all terminals.
* C defaults to control-H. If not specified,
* the erase character is untouched; however, if
* not specified and the erase character is NULL
* (zero byte), the erase character is set to CERASE.
* -kC -- set the kill character to C on all terminals.
* Default for C is control-U. If not specified,
* the kill character is untouched; however, if
* not specified and the kill character is NULL
* (zero byte), the kill character is set to CKILL.
* -iC -- set the interrupt character to C on all terminals.
* Default for C is control-C. If not specified, the
* interrupt character is untouched; however, if
* not specified and the interrupt character is NULL
* (zero byte), the interrupt character is set to
* control-C.
* -qC -- reserved for setable quit character.
* -m -- map the system identified type to some user
* specified type. The mapping can be baud rate
* dependent. This replaces the old -d, -p flags.
* (-d type -> -m dialup:type)
* (-p type -> -m plug:type)
* Syntax: -m identifier [test baudrate] :type
* where: ``identifier'' is terminal type found in
* /etc/ttys for this port, (abscence of an identifier
* matches any identifier); ``test'' may be any combination
* of > = < ! @; ``baudrate'' is as with stty(1);
* ``type'' is the actual terminal type to use if the
* mapping condition is met. Multiple maps are scanned
* in order and the first match prevails.
* -n -- If the new tty driver from UCB is available, this flag
* will activate the new options for erase and kill
* processing. This will be different for printers
* and crt's. For crts, if the baud rate is < 1200 then
* erase and kill don't remove characters from the screen.
* -h -- don't read htmp file. Normally the terminal type
* is determined by reading the htmp file or the
* environment (unless some mapping is specified).
* This forces a read of the ttytype file -- useful
* when htmp is somehow wrong. (V6 only)
* -u -- don't update htmp. It seemed like this should
* be put in. Note that htmp is never actually
* written if there are no changes, so don't bother
* bother using this for efficiency reasons alone.
* -s -- output setenv commands for TERM. This can be
* used with
* `tset -s ...`
* and is to be prefered to:
* setenv TERM `tset - ...`
* because -s sets the TERMCAP variable also.
* -S -- Similar to -s but outputs 2 strings suitable for
* use in csh .login files as follows:
* set noglob
* set term=(`tset -S .....`)
* setenv TERM $term[1]
* setenv TERMCAP "$term[2]"
* unset term
* unset noglob
* -Q -- be quiet. don't output 'Erase set to' etc.
* -I -- don't do terminal initialization (is & if
* strings).
* -v -- On virtual terminal systems, don't set up a
* virtual terminal. Otherwise tset will tell
* the operating system what kind of terminal you
* are on (if it is a known terminal) and fix up
* the output of -s to use virtual terminal sequences.
*
* Files:
* /etc/ttys
* contains a terminal id -> terminal type
* mapping; used when any user mapping is specified,
* or the environment doesn't have TERM set.
* /etc/termcap
* a terminal_type -> terminal_capabilities
* mapping.
*
* Return Codes:
* -1 -- couldn't open termcap.
* 1 -- bad terminal type, or standard output not tty.
* 0 -- ok.
*
* Defined Constants:
* DIALUP -- the type code for a dialup port.
* PLUGBOARD -- the type code for a plugboard port.
* ARPANET -- the type code for an arpanet port.
* BACKSPACE -- control-H, the default for -e.
* CNTL('U') -- control-U, the default for -k.
* OLDERASE -- the ancient default erase character.
* FILEDES -- the file descriptor to do the operation
* on, nominally 1 or 2.
* STDOUT -- the standard output file descriptor.
* UIDMASK -- the bit pattern to mask with the getuid()
* call to get just the user id.
* GTTYN -- defines file containing generalized ttynames
* and compiles code to look there.
*
* Requires:
* Routines to handle htmp, ttys, and termcap.
*
* Compilation Flags:
* OLDFLAGS -- must be defined to compile code for any of
* the -d, -p, or -a flags.
* OLDDIALUP -- accept the -d flag.
* OLDPLUGBOARD -- accept the -p flag.
* OLDARPANET -- accept the -a flag.
* V6 -- if clear, use environments, not htmp.
* also use TIOCSETN rather than stty to avoid flushing
* GTTYN -- if set, compiles code to look at /etc/ttys.
*
* Trace Flags:
* none
*
* Diagnostics:
* Bad flag
* An incorrect option was specified.
* Too few args
* more command line arguments are required.
* Unexpected arg
* wrong type of argument was encountered.
* Cannot open ...
* The specified file could not be openned.
* Type ... unknown
* An unknown terminal type was specified.
* Cannot update htmp
* Cannot update htmp file when the standard
* output is not a terminal.
* Erase set to ...
* Telling that the erase character has been
* set to the specified character.
* Kill set to ...
* Ditto for kill
* Erase is ... Kill is ...
* Tells that the erase/kill characters were
* wierd before, but they are being left as-is.
* Not a terminal
* Set if FILEDES is not a terminal.
*
* Compilation Instructions:
* cc -n -O tset.c -ltermlib
* mv a.out tset
* chown bin tset
* chmod 4755 tset
*
* where 'bin' should be whoever owns the 'htmp' file.
* If 'htmp' is 666, then tset need not be setuid.
*
* For version 6 the compile command should be:
* cc -n -O -I/usr/include/retrofit tset.c -ltermlib -lretro -lS
*
*
* History:
* 1/81 -- Added alias checking for mapping identifiers.
* 7/80 -- '-S' added. '-m' mapping added. TERMCAP string
* cleaned up.
* 3/80 -- Changed to use tputs. Prc & flush added.
* 10/79 -- '-s' option extended to handle TERMCAP
* variable, set noglob, quote the entry,
* and know about the Bourne shell. Terminal
* initialization moved to before any information
* output so screen clears would not screw you.
* '-Q' option added.
* 8/79 -- '-' option alone changed to only output
* type. '-s' option added. 'VERSION7'
* changed to 'V6' for compatibility.
* 12/78 -- modified for eventual migration to VAX/UNIX,
* so the '-' option is changed to output only
* the terminal type to STDOUT instead of
* FILEDES.
* 9/78 -- '-' and '-p' options added (now fully
* compatible with ttytype!), and spaces are
* permitted between the -d and the type.
* 8/78 -- The sense of -h and -u were reversed, and the
* -f flag is dropped -- same effect is available
* by just stating the terminal type.
* 10/77 -- Written.
*/
#define index strchr
#define rindex strrchr
#define curerase modes.c_cc[VERASE]
#define curkill modes.c_cc[VKILL]
#define curintr modes.c_cc[VINTR]
#define olderase oldmodes.c_cc[VERASE]
#define oldkill oldmodes.c_cc[VKILL]
#define oldintr oldmodes.c_cc[VINTR]
#include <stdio.h>
#include <termio.h>
#include <signal.h>
#define YES 1
#define NO 0
#undef CNTL
#define CNTL(c) ((c)&037)
#define BACKSPACE (CNTL('H'))
#define isdigit(c) (c >= '0' && c <= '9')
#define isalnum(c) (c > ' ' && (index("<@=>!:|\177", c) == NULL))
#define OLDERASE '#'
/* default special characters */
#ifndef CERASE
#define CERASE '\177'
#endif
#ifndef CKILL
#define CKILL CNTL('U')
#endif
#ifndef CINTR
#define CINTR CNTL('C')
#endif
#ifndef CDSUSP
#define CQUIT 034 /* FS, ^\ */
#define CSTART CNTL('Q')
#define CSTOP CNTL('S')
#define CEOF CNTL('D')
#define CEOT CEOF
#define CBRK 0377
#define CSUSP CNTL('Z')
#define CDSUSP CNTL('Y')
#define CRPRNT CNTL('R')
#define CFLUSH CNTL('O')
#define CWERASE CNTL('W')
#define CLNEXT CNTL('V')
#endif
#define FILEDES 2 /* do gtty/stty on this descriptor */
#define STDOUT 1 /* output of -s/-S to this descriptor */
#define UIDMASK -1
#define USAGE "usage: tset [-] [-rsIQS] [-eC] [-kC] " \
"[-iC] [-m [ident][test speed]:type] [type]\n"
#define OLDFLAGS
#define DIALUP "dialup"
#define OLDDIALUP "sd"
#define PLUGBOARD "plugboard"
#define OLDPLUGBOARD "sp"
#define DEFTYPE "unknown"
#define NOTTY 'x'
/*
* Baud Rate Conditionals
*/
#define ANY 0
#define GT 1
#define EQ 2
#define LT 4
#define GE (GT|EQ)
#define LE (LT|EQ)
#define NE (GT|LT)
#define ALL (GT|EQ|LT)
#define NMAP 10
struct map {
char *Ident;
char Test;
char Speed;
char *Type;
} map[NMAP];
struct map *Map = map;
/* This should be available in an include file */
struct
{
char *string;
int speed;
int baudrate;
} speeds[] = {
"0", B0, 0,
"50", B50, 50,
"75", B75, 75,
"110", B110, 110,
"134", B134, 134,
"134.5", B134, 134,
"150", B150, 150,
"200", B200, 200,
"300", B300, 300,
"600", B600, 600,
"1200", B1200, 1200,
"1800", B1800, 1800,
"2400", B2400, 2400,
"4800", B4800, 4800,
"9600", B9600, 9600,
"19200", EXTA, 19200,
"exta", EXTA, 19200,
"extb", EXTB, 38400,
"57600", B57600, 57600,
"76800", B76800, 76800,
"115200", B115200, 115200,
"153600", B153600, 153600,
"230400", B230400, 230400,
"307200", B307200, 307200,
"460800", B460800, 460800,
"921600", B921600, 921600,
0,
};
signed char Erase_char; /* new erase character */
char Kill_char; /* new kill character */
char Intr_char; /* new interrupt character */
char Specialerase; /* set => Erase_char only on terminals with backspace */
char Ttyid = NOTTY; /* terminal identifier */
char *TtyType; /* type of terminal */
char *DefType; /* default type if none other computed */
char *NewType; /* mapping identifier based on old flags */
int Mapped; /* mapping has been specified */
int Dash_u; /* don't update htmp */
int Dash_h; /* don't read htmp */
int DoSetenv; /* output setenv commands */
int BeQuiet; /* be quiet */
int NoInit; /* don't output initialization string */
int IsReset; /* invoked as reset */
int Report; /* report current type */
int Ureport; /* report to user */
int RepOnly; /* report only */
int CmndLine; /* output full command lines (-s option) */
int Ask; /* ask user for termtype */
int DoVirtTerm = YES; /* Set up a virtual terminal */
int PadBaud; /* Min rate of padding needed */
#define CAPBUFSIZ 1024
char Capbuf[CAPBUFSIZ]; /* line from /etc/termcap for this TtyType */
char *Ttycap; /* termcap line from termcap or environ */
char Aliasbuf[128];
char *Alias[16];
extern char *strcpy();
extern char *index();
struct delay
{
int d_delay;
int d_bits;
};
#include "tset.delays.h"
struct termio mode;
struct termio oldmode;
struct termios modes;
struct termios oldmodes;
int istermios;
void reportek(char *, char, char, char);
void setdelay(char *, struct delay [], tcflag_t, tcflag_t *);
void prs(char *);
void prc(char);
void flush(void);
void cat(char *);
void bmove(char *, char *, int);
void makealias(char *);
void wrtermcap(char *);
void fatal(char *, char *);
char reset(); /* Routine for checking&resetting chars */
int
main(int argc, char *argv[])
{
char buf[CAPBUFSIZ];
char termbuf[32];
auto char *bufp;
char *p;
char *command;
int i;
int Break;
int Not;
char *nextarg();
char *mapped();
extern char *rindex();
struct winsize win;
extern char *getenv();
extern char *tgetstr();
char bs_char;
int csh;
int settle = NO;
void setmode();
extern char PC;
extern short ospeed;
if ((istermios = ioctl(FILEDES, TCGETS, (char *)&modes)) < 0) {
if (ioctl(FILEDES, TCGETA, (char *)&mode) < 0) {
prs("Not a terminal\n");
exit(1);
}
bmove((char *)&mode, (char *)&oldmode, sizeof (mode));
modes.c_lflag = oldmodes.c_lflag = mode.c_lflag;
modes.c_oflag = oldmodes.c_oflag = mode.c_oflag;
modes.c_iflag = oldmodes.c_iflag = mode.c_iflag;
modes.c_cflag = oldmodes.c_cflag = mode.c_cflag;
for (i = 0; i < NCC; i++)
modes.c_cc[i] = oldmodes.c_cc[i] = mode.c_cc[i];
} else
bmove((char *)&modes, (char *)&oldmodes, sizeof (modes));
ospeed = cfgetospeed(&modes);
(void) signal(SIGINT, setmode);
(void) signal(SIGQUIT, setmode);
(void) signal(SIGTERM, setmode);
if (command = rindex(argv[0], '/'))
command++;
else
command = argv[0];
if (sequal(command, "reset")) {
/*
* Reset the teletype mode bits to a sensible state.
* Copied from the program by Kurt Shoens & Mark Horton.
* Very useful after crapping out in raw.
*/
if ((istermios = ioctl(FILEDES, TCGETS, (char *)&modes)) < 0) {
(void) ioctl(FILEDES, TCGETA, (char *)&mode);
modes.c_lflag = mode.c_lflag;
modes.c_oflag = mode.c_oflag;
modes.c_iflag = mode.c_iflag;
modes.c_cflag = mode.c_cflag;
for (i = 0; i < NCC; i++)
modes.c_cc[i] = mode.c_cc[i];
}
curerase = reset(curerase, CERASE);
curkill = reset(curkill, CKILL);
curintr = reset(curintr, CINTR);
modes.c_cc[VQUIT] = reset(modes.c_cc[VQUIT], CQUIT);
modes.c_cc[VEOF] = reset(modes.c_cc[VEOF], CEOF);
modes.c_iflag |= (BRKINT|ISTRIP|ICRNL|IXON);
modes.c_iflag &= ~(IGNBRK|PARMRK|INPCK|INLCR|IGNCR|IUCLC|IXOFF);
modes.c_oflag |= (OPOST|ONLCR);
modes.c_oflag &= ~(OLCUC|OCRNL|ONOCR|ONLRET|OFILL|OFDEL|
NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
modes.c_cflag |= (CS7|CREAD);
modes.c_cflag &= ~(PARODD|CLOCAL);
modes.c_lflag |= (ISIG|ICANON|ECHO|ECHOK);
modes.c_lflag &= ~(XCASE|ECHONL|NOFLSH);
if (istermios < 0) {
mode.c_lflag = modes.c_lflag;
mode.c_oflag = modes.c_oflag;
mode.c_iflag = modes.c_iflag;
mode.c_cflag = modes.c_cflag;
for (i = 0; i < NCC; i++)
mode.c_cc[i] = modes.c_cc[i];
(void) ioctl(FILEDES, TCSETAW, (char *)&mode);
} else
(void) ioctl(FILEDES, TCSETSW, (char *)&modes);
Dash_u = YES;
BeQuiet = YES;
IsReset = YES;
} else if (argc == 2 && sequal(argv[1], "-")) {
RepOnly = YES;
Dash_u = YES;
}
argc--;
/* scan argument list and collect flags */
while (--argc >= 0) {
p = *++argv;
if (*p == '-') {
if (*++p == NULL)
Report = YES; /* report current terminal type */
else
while (*p)
switch (*p++) {
case 'r': /* report to user */
Ureport = YES;
continue;
case 'E':
/* special erase: operate on all but TTY33 */
Specialerase = YES;
/* explicit fall-through to -e case */
case 'e': /* erase character */
if (*p == NULL)
Erase_char = -1;
else {
if (*p == '^' && p[1] != NULL)
if (*++p == '?')
Erase_char = '\177';
else
Erase_char = CNTL(*p);
else
Erase_char = *p;
p++;
}
continue;
case 'i': /* interrupt character */
if (*p == NULL)
Intr_char = CNTL('C');
else {
if (*p == '^' && p[1] != NULL)
if (*++p == '?')
Intr_char = '\177';
else
Intr_char = CNTL(*p);
else
Intr_char = *p;
p++;
}
continue;
case 'k': /* kill character */
if (*p == NULL)
Kill_char = CNTL('U');
else {
if (*p == '^' && p[1] != NULL)
if (*++p == '?')
Kill_char = '\177';
else
Kill_char = CNTL(*p);
else
Kill_char = *p;
p++;
}
continue;
#ifdef OLDFLAGS
#ifdef OLDDIALUP
case 'd': /* dialup type */
NewType = DIALUP;
goto mapold;
#endif
#ifdef OLDPLUGBOARD
case 'p': /* plugboard type */
NewType = PLUGBOARD;
goto mapold;
#endif
#ifdef OLDARPANET
case 'a': /* arpanet type */
Newtype = ARPANET;
goto mapold;
#endif
mapold: Map->Ident = NewType;
Map->Test = ALL;
if (*p == NULL) {
p = nextarg(argc--, argv++);
}
Map->Type = p;
Map++;
Mapped = YES;
p = "";
continue;
#endif
case 'm': /* map identifier to type */
/*
* This code is very loose. Almost no
* syntax checking is done!! However,
* illegal syntax will only produce
* weird results.
*/
if (*p == NULL) {
p = nextarg(argc--, argv++);
}
if (isalnum(*p)) {
Map->Ident = p; /* identifier */
while (isalnum(*p)) p++;
}
else
Map->Ident = "";
Break = NO;
Not = NO;
while (!Break)
switch (*p) {
case NULL:
p = nextarg(argc--, argv++);
continue;
case ':': /* mapped type */
*p++ = NULL;
Break = YES;
continue;
case '>': /* conditional */
Map->Test |= GT;
*p++ = NULL;
continue;
case '<': /* conditional */
Map->Test |= LT;
*p++ = NULL;
continue;
case '=': /* conditional */
case '@':
Map->Test |= EQ;
*p++ = NULL;
continue;
case '!': /* invert conditions */
Not = ~Not;
*p++ = NULL;
continue;
case 'B': /* Baud rate */
p++;
/* intentional fallthru */
default:
if (isdigit(*p) || *p == 'e') {
Map->Speed =
baudrate(p);
while (isalnum(*p) ||
*p == '.')
p++;
} else
Break = YES;
continue;
}
if (Not) { /* invert sense of test */
Map->Test = (~(Map->Test))&ALL;
}
if (*p == NULL) {
p = nextarg(argc--, argv++);
}
Map->Type = p;
p = "";
Map++;
Mapped = YES;
continue;
case 'h': /* don't get type from htmp or env */
Dash_h = YES;
continue;
case 'u': /* don't update htmp */
Dash_u = YES;
continue;
case 's': /* output setenv commands */
DoSetenv = YES;
CmndLine = YES;
continue;
case 'S': /* output setenv strings */
DoSetenv = YES;
CmndLine = NO;
continue;
case 'Q': /* be quiet */
BeQuiet = YES;
continue;
case 'I': /* no initialization */
NoInit = YES;
continue;
case 'A': /* Ask user */
Ask = YES;
continue;
case 'v': /* no virtual terminal */
DoVirtTerm = NO;
continue;
default:
*p-- = NULL;
fatal("Bad flag -", p);
}
} else {
/* terminal type */
DefType = p;
}
}
if (DefType) {
if (Mapped) {
Map->Ident = ""; /* means "map any type" */
Map->Test = ALL; /* at all baud rates */
Map->Type = DefType; /* to the default type */
} else
TtyType = DefType;
}
/*
* Get rid of $TERMCAP, if it's there, so we get a real
* entry from /etc/termcap. This prevents us from being
* fooled by out of date stuff in the environment, and
* makes tabs work right on CB/Unix.
*/
bufp = getenv("TERMCAP");
if (bufp && *bufp != '/')
(void) strcpy(bufp-8, "NOTHING"); /* overwrite only "TERMCAP" */
/* get current idea of terminal type from environment */
if (!Dash_h && TtyType == 0)
TtyType = getenv("TERM");
if (!RepOnly && Ttyid == NOTTY && (TtyType == 0 || !Dash_h))
Ttyid = ttyname(FILEDES);
/* If still undefined, use DEFTYPE */
if (TtyType == 0) {
TtyType = DEFTYPE;
}
/* check for dialup or other mapping */
if (Mapped) {
if (!(Alias[0] && isalias(TtyType)))
if (tgetent(Capbuf, TtyType) > 0)
makealias(Capbuf);
TtyType = mapped(TtyType);
}
/* TtyType now contains a pointer to the type of the terminal */
/* If the first character is '?', ask the user */
if (TtyType[0] == '?') {
Ask = YES;
TtyType++;
if (TtyType[0] == '\0')
TtyType = DEFTYPE;
}
if (Ask) {
ask:
prs("TERM = (");
prs(TtyType);
prs(") ");
flush();
/* read the terminal. If not empty, set type */
i = read(2, termbuf, sizeof (termbuf) - 1);
if (i > 0) {
if (termbuf[i - 1] == '\n')
i--;
termbuf[i] = '\0';
if (termbuf[0] != '\0')
TtyType = termbuf;
}
}
/* get terminal capabilities */
if (!(Alias[0] && isalias(TtyType))) {
switch (tgetent(Capbuf, TtyType)) {
case -1:
prs("Cannot find termcap\n");
flush();
exit(-1);
case 0:
prs("Type ");
prs(TtyType);
prs(" unknown\n");
flush();
if (DoSetenv) {
TtyType = DEFTYPE;
Alias[0] = '\0';
goto ask;
} else
exit(1);
}
}
Ttycap = Capbuf;
if (!RepOnly) {
/* determine erase and kill characters */
if (Specialerase && !tgetflag("bs"))
Erase_char = 0;
bufp = buf;
p = tgetstr("kb", &bufp);
if (p == NULL || p[1] != '\0')
p = tgetstr("bc", &bufp);
if (p != NULL && p[1] == '\0')
bs_char = p[0];
else if (tgetflag("bs"))
bs_char = BACKSPACE;
else
bs_char = 0;
/*
* The next statement can't be fixed, because now users
* depend on keeping their erase character as DEL if the
* system set it there. People who want backspace have
* to say tset -e.
*/
if (Erase_char == 0 && !tgetflag("os") &&
curerase == OLDERASE) {
if (tgetflag("bs") || bs_char != 0)
Erase_char = -1;
}
if (Erase_char < 0)
Erase_char = (bs_char != 0) ? bs_char : BACKSPACE;
if (curerase == 0)
curerase = CERASE;
if (Erase_char != 0)
curerase = Erase_char;
if (curintr == 0)
curintr = CINTR;
if (Intr_char != 0)
curintr = Intr_char;
if (curkill == 0)
curkill = CKILL;
if (Kill_char != 0)
curkill = Kill_char;
/* set modes */
PadBaud = tgetnum("pb"); /* OK if fails */
for (i = 0; speeds[i].string; i++)
if (speeds[i].baudrate == PadBaud) {
PadBaud = speeds[i].speed;
break;
}
setdelay("dC", CRdelay, CRbits, &modes.c_oflag);
setdelay("dN", NLdelay, NLbits, &modes.c_oflag);
setdelay("dB", BSdelay, BSbits, &modes.c_oflag);
setdelay("dF", FFdelay, FFbits, &modes.c_oflag);
setdelay("dT", TBdelay, TBbits, &modes.c_oflag);
setdelay("dV", VTdelay, VTbits, &modes.c_oflag);
if (tgetflag("UC") || (command[0] & 0140) == 0100) {
modes.c_iflag |= IUCLC;
modes.c_oflag |= OLCUC;
modes.c_cflag |= XCASE;
} else if (tgetflag("LC")) {
modes.c_iflag &= ~IUCLC;
modes.c_oflag &= ~OLCUC;
modes.c_cflag &= ~XCASE;
}
modes.c_iflag &= ~(PARMRK|INPCK);
modes.c_lflag |= ICANON;
if (tgetflag("EP")) {
modes.c_iflag |= INPCK;
modes.c_cflag |= PARENB;
modes.c_cflag &= ~PARODD;
}
if (tgetflag("OP")) {
modes.c_iflag |= INPCK;
modes.c_cflag |= PARENB;
modes.c_cflag |= PARODD;
}
modes.c_oflag |= ONLCR;
modes.c_iflag |= ICRNL;
modes.c_lflag |= ECHO;
modes.c_oflag |= TAB3;
if (tgetflag("NL")) { /* new line, not line feed */
modes.c_oflag &= ~ONLCR;
modes.c_iflag &= ~ICRNL;
}
if (tgetflag("HD")) /* half duplex */
modes.c_lflag &= ~ECHO;
if (tgetflag("pt")) /* print tabs */
modes.c_oflag &= ~TAB3;
modes.c_lflag |= (ECHOE|ECHOK);
if (tgetflag("hc")) { /* set printer modes */
modes.c_lflag &= ~ECHOE;
}
/* get pad character */
bufp = buf;
if (tgetstr("pc", &bufp) != 0)
PC = buf[0];
/* output startup string */
if (!NoInit) {
if (oldmodes.c_oflag&(TAB3|ONLCR|OCRNL|ONLRET)) {
oldmodes.c_oflag &= (TAB3|ONLCR|OCRNL|ONLRET);
setmode(-1);
}
if (settabs()) {
settle = YES;
flush();
}
bufp = buf;
if (IsReset && tgetstr("rs", &bufp) != 0 ||
tgetstr("is", &bufp) != 0) {
tputs(buf, 0, prc);
settle = YES;
flush();
}
bufp = buf;
if (IsReset && tgetstr("rf", &bufp) != 0 ||
tgetstr("if", &bufp) != 0) {
cat(buf);
settle = YES;
}
if (settle) {
prc('\r');
if (IsReset)
prc('\n'); /* newline too */
flush();
sleep(1); /* let terminal settle down */
}
}
setmode(0); /* set new modes, if they've changed */
/* set up environment for the shell we are using */
/* (this code is rather heuristic, checking for $SHELL */
/* ending in the 3 characters "csh") */
csh = NO;
if (DoSetenv) {
char *sh;
if ((sh = getenv("SHELL")) && (i = strlen(sh)) >= 3) {
if ((csh = sequal(&sh[i-3], "csh")) && CmndLine)
(void) write(STDOUT,
"set noglob;\n", 12);
}
if (!csh) { /* running Bourne shell */
(void) write(STDOUT,
"export TERMCAP TERM;\n", 21);
}
}
}
/* report type if appropriate */
if (DoSetenv || Report || Ureport) {
/* if type is the short name, find first alias (if any) */
makealias(Ttycap);
if (sequal(TtyType, Alias[0]) && Alias[1]) {
TtyType = Alias[1];
}
if (DoSetenv) {
if (csh) {
if (CmndLine)
(void) write(STDOUT,
"setenv TERM ", 12);
(void) write(STDOUT, TtyType, strlen(TtyType));
(void) write(STDOUT, " ", 1);
if (CmndLine)
(void) write(STDOUT, ";\n", 2);
} else {
(void) write(STDOUT, "TERM=", 5);
(void) write(STDOUT, TtyType, strlen(TtyType));
(void) write(STDOUT, ";\n", 2);
}
} else if (Report) {
(void) write(STDOUT, TtyType, strlen(TtyType));
(void) write(STDOUT, "\n", 1);
}
if (Ureport) {
prs("Terminal type is ");
prs(TtyType);
prs("\n");
flush();
}
if (DoSetenv) {
if (csh) {
if (CmndLine)
(void) write(STDOUT,
"setenv TERMCAP '", 16);
} else
(void) write(STDOUT, "TERMCAP='", 9);
wrtermcap(Ttycap);
if (csh) {
if (CmndLine) {
(void) write(STDOUT, "';\n", 3);
(void) write(STDOUT,
"unset noglob;\n", 14);
}
} else
(void) write(STDOUT, "';\n", 3);
}
}
if (RepOnly)
exit(0);
/* tell about changing erase, kill and interrupt characters */
reportek("Erase", curerase, olderase, CERASE);
reportek("Kill", curkill, oldkill, CKILL);
reportek("Interrupt", curintr, oldintr, CINTR);
return (0);
}
/*
* Set the hardware tabs on the terminal, using the ct (clear all tabs),
* st (set one tab) and ch (horizontal cursor addressing) capabilities.
* This is done before if and is, so they can patch in case we blow this.
*/
int
settabs(void)
{
char caps[100];
char *capsp = caps;
char *clear_tabs, *set_tab, *set_column, *set_pos;
char *tg_out, *tgoto();
int c;
extern char *tgetstr();
int lines, columns;
clear_tabs = tgetstr("ct", &capsp);
set_tab = tgetstr("st", &capsp);
set_column = tgetstr("ch", &capsp);
if (set_column == 0)
set_pos = tgetstr("cm", &capsp);
if (clear_tabs && set_tab) {
prc('\r'); /* force to be at left margin */
tputs(clear_tabs, 0, prc);
}
if (set_tab) {
columns = tgetnum("co");
lines = tgetnum("li");
for (c = 0; c < columns; c += 8) {
/* get to that column. */
tg_out = "OOPS"; /* also returned by tgoto */
if (set_column)
tg_out = tgoto(set_column, 0, c);
if (*tg_out == 'O' && set_pos)
tg_out = tgoto(set_pos, c, lines-1);
if (*tg_out != 'O')
tputs(tg_out, 1, prc);
else if (c != 0) {
prc(' '); prc(' '); prc(' '); prc(' ');
prc(' '); prc(' '); prc(' '); prc(' ');
}
/* set the tab */
tputs(set_tab, 0, prc);
}
prc('\r');
return (1);
}
return (0);
}
/*
* flag serves several purposes:
* if called as the result of a signal, flag will be > 0.
* if called from terminal init, flag == -1 means reset "oldmode".
* called with flag == 0 at end of normal mode processing.
*/
void
setmode(int flag)
{
struct termio *ttymode;
struct termios *ttymodes;
int i;
ttymode = (struct termio *)0;
ttymodes = (struct termios *)0;
if (flag < 0) { /* unconditionally reset oldmode (called from init) */
if (istermios < 0) {
oldmode.c_lflag = oldmodes.c_lflag;
oldmode.c_oflag = oldmodes.c_oflag;
oldmode.c_iflag = oldmodes.c_iflag;
oldmode.c_cflag = oldmodes.c_cflag;
for (i = 0; i < NCC; i++)
oldmode.c_cc[i] = oldmodes.c_cc[i];
ttymode = &oldmode;
} else
ttymodes = &oldmodes;
} else {
if (istermios < 0) {
oldmode.c_lflag = oldmodes.c_lflag;
oldmode.c_oflag = oldmodes.c_oflag;
oldmode.c_iflag = oldmodes.c_iflag;
oldmode.c_cflag = oldmodes.c_cflag;
for (i = 0; i < NCC; i++)
oldmode.c_cc[i] = oldmodes.c_cc[i];
mode.c_lflag = modes.c_lflag;
mode.c_oflag = modes.c_oflag;
mode.c_iflag = modes.c_iflag;
mode.c_cflag = modes.c_cflag;
for (i = 0; i < NCC; i++)
mode.c_cc[i] = modes.c_cc[i];
if (!bequal((char *)&mode, (char *)&oldmode,
sizeof (mode)))
ttymode = &mode;
} else if (!bequal((char *)&modes, (char *)&oldmodes,
sizeof (modes)))
ttymodes = &modes;
}
if (ttymode) {
(void) ioctl(FILEDES, TCSETAW, (char *)ttymode);
} else if (ttymodes) {
(void) ioctl(FILEDES, TCSETSW, (char *)ttymodes);
}
if (flag > 0) /* trapped signal */
exit(1);
}
void
reportek(char *name, char new, char old, char def)
{
char o;
char n;
char *p;
char buf[32];
char *bufp;
extern char *tgetstr();
if (BeQuiet)
return;
o = old;
n = new;
if (o == n && n == def)
return;
prs(name);
if (o == n)
prs(" is ");
else
prs(" set to ");
bufp = buf;
if (tgetstr("kb", &bufp) > (char *)0 && n == buf[0] && buf[1] == NULL)
prs("Backspace\n");
else if (n == 0177)
prs("Delete\n");
else {
if (n < 040) {
prs("Ctrl-");
n ^= 0100;
}
p = "x\n";
p[0] = n;
prs(p);
}
flush();
}
void
setdelay(char *cap, struct delay dtab[], tcflag_t bits, tcflag_t *flags)
{
int i;
struct delay *p;
extern short ospeed;
/* see if this capability exists at all */
i = tgetnum(cap);
if (i < 0)
i = 0;
/* No padding at speeds below PadBaud */
if (PadBaud > ospeed)
i = 0;
/* clear out the bits, replace with new ones */
*flags &= ~bits;
/* scan dtab for first entry with adequate delay */
for (p = dtab; p->d_delay >= 0; p++) {
if (p->d_delay >= i) {
p++;
break;
}
}
/* use last entry if none will do */
*flags |= (tcflag_t)((--p)->d_bits);
}
void
prs(char *s)
{
while (*s != '\0')
prc(*s++);
}
char OutBuf[256];
int OutPtr;
void
prc(char c)
{
OutBuf[OutPtr++] = c;
if (OutPtr >= sizeof (OutBuf))
flush();
}
void
flush(void)
{
if (OutPtr > 0)
(void) write(2, OutBuf, OutPtr);
OutPtr = 0;
}
void
cat(char *file)
{
int fd;
int i;
char buf[BUFSIZ];
fd = open(file, 0);
if (fd < 0) {
prs("Cannot open ");
prs(file);
prs("\n");
flush();
return;
}
while ((i = read(fd, buf, BUFSIZ)) > 0)
(void) write(FILEDES, buf, i);
(void) close(fd);
}
void
bmove(char *from, char *to, int length)
{
char *p, *q;
int i;
i = length;
p = from;
q = to;
while (i-- > 0)
*q++ = *p++;
}
int
bequal(char *a, char *b, int len) /* must be same thru len chars */
{
char *p, *q;
int i;
i = len;
p = a;
q = b;
while ((*p == *q) && --i > 0) {
p++; q++;
}
return ((*p == *q) && i >= 0);
}
int
sequal(char *a, char *b) /* must be same thru NULL */
{
char *p = a, *q = b;
while (*p && *q && (*p == *q)) {
p++; q++;
}
return (*p == *q);
}
void
makealias(char *buf)
{
int i;
char *a;
char *b;
Alias[0] = a = Aliasbuf;
b = buf;
i = 1;
while (*b && *b != ':') {
if (*b == '|') {
*a++ = NULL;
Alias[i++] = a;
b++;
} else
*a++ = *b++;
}
*a = NULL;
Alias[i] = NULL;
#ifdef DEB
for (i = 0; Alias[i]; printf("A:%s\n", Alias[i++]))
;
#endif
}
int
isalias(char *ident) /* is ident same as one of the aliases? */
{
char **a = Alias;
if (*a)
while (*a)
if (sequal(ident, *a))
return (YES);
else
a++;
return (NO);
}
/*
* routine to output the string for the environment TERMCAP variable
*/
#define WHITE(c) (c == ' ' || c == '\t')
char delcap[128][2];
int ncap = 0;
void
wrtermcap(char *bp)
{
char buf[CAPBUFSIZ];
char *p = buf;
char *tp;
char *putbuf();
int space, empty;
/* discard names with blanks */
/* May not be desireable ? */
while (*bp && *bp != ':') {
if (*bp == '|') {
tp = bp+1;
space = NO;
while (*tp && *tp != '|' && *tp != ':') {
space = (space || WHITE(*tp));
tp++;
}
if (space) {
bp = tp;
continue;
}
}
*p++ = *bp++;
}
/* */
while (*bp) {
switch (*bp) {
case ':': /* discard empty, cancelled or dupl fields */
tp = bp + 1;
empty = YES;
while (*tp && *tp != ':') {
empty = (empty && WHITE(*tp));
tp++;
}
if (empty || cancelled(bp+1)) {
bp = tp;
continue;
}
break;
case ' ': /* no spaces in output */
p = putbuf(p, "\\040");
bp++;
continue;
case '!': /* the shell thinks this is history */
p = putbuf(p, "\\041");
bp++;
continue;
case ',': /* the shell thinks this is history */
p = putbuf(p, "\\054");
bp++;
continue;
case '"': /* no quotes in output */
p = putbuf(p, "\\042");
bp++;
continue;
case '\'': /* no quotes in output */
p = putbuf(p, "\\047");
bp++;
continue;
case '`': /* no back quotes in output */
p = putbuf(p, "\\140");
bp++;
continue;
case '\\':
case '^': /* anything following is OK */
*p++ = *bp++;
}
*p++ = *bp++;
}
*p++ = ':'; /* we skipped the last : with the : lookahead hack */
(void) write(STDOUT, buf, p-buf);
}
int
cancelled(char *cap)
{
int i;
for (i = 0; i < ncap; i++) {
if (cap[0] == delcap[i][0] && cap[1] == delcap[i][1])
return (YES);
}
/* delete a second occurrance of the same capability */
delcap[ncap][0] = cap[0];
delcap[ncap][1] = cap[1];
ncap++;
return (cap[2] == '@');
}
char *
putbuf(ptr, str)
char *ptr;
char *str;
{
char buf[20];
while (*str) {
switch (*str) {
case '\033':
ptr = putbuf(ptr, "\\E");
str++;
break;
default:
if (*str <= ' ') {
(void) sprintf(buf, "\\%03o", *str);
ptr = putbuf(ptr, buf);
str++;
} else
*ptr++ = *str++;
}
}
return (ptr);
}
int
baudrate(char *p)
{
char buf[8];
int i = 0;
while (i < 7 && (isalnum(*p) || *p == '.'))
buf[i++] = *p++;
buf[i] = NULL;
for (i = 0; speeds[i].string; i++)
if (sequal(speeds[i].string, buf))
return (speeds[i].speed);
return (-1);
}
char *
mapped(type)
char *type;
{
extern short ospeed;
int match;
#ifdef DEB
printf("spd:%d\n", ospeed);
prmap();
#endif
Map = map;
while (Map->Ident) {
if (*(Map->Ident) == NULL ||
sequal(Map->Ident, type) || isalias(Map->Ident)) {
match = NO;
switch (Map->Test) {
case ANY: /* no test specified */
case ALL:
match = YES;
break;
case GT:
match = (ospeed > Map->Speed);
break;
case GE:
match = (ospeed >= Map->Speed);
break;
case EQ:
match = (ospeed == Map->Speed);
break;
case LE:
match = (ospeed <= Map->Speed);
break;
case LT:
match = (ospeed < Map->Speed);
break;
case NE:
match = (ospeed != Map->Speed);
break;
}
if (match)
return (Map->Type);
}
Map++;
}
/* no match found; return given type */
return (type);
}
#ifdef DEB
prmap()
{
Map = map;
while (Map->Ident) {
printf("%s t:%d s:%d %s\n",
Map->Ident, Map->Test, Map->Speed, Map->Type);
Map++;
}
}
#endif
char *
nextarg(argc, argv)
int argc;
char *argv[];
{
if (argc <= 0)
fatal("Too few args: ", *argv);
if (*(*++argv) == '-')
fatal("Unexpected arg: ", *argv);
return (*argv);
}
void
fatal(char *mesg, char *obj)
{
prs(mesg);
prs(obj);
prc('\n');
prs(USAGE);
flush();
exit(1);
}
/*
* Stolen from /usr/src/ucb/reset.c, which this mod obsoletes.
*/
char
reset(ch, def)
char ch;
int def;
{
if (ch == 0 || (ch&0377) == 0377)
return (def);
return (ch);
}