NAME

tty − general terminal interface

USAGE

#include <sgtty.h>

DESCRIPTION

This section describes both a particular special file /dev/tty and the terminal drivers used for conversational computing. 

Line disciplines. 

The system provides different line disciplines for controlling communications lines.  In this version of the system there are three disciplines available:

oldThe old (standard) terminal driver.  This is used when using the standard shell sh(1) and for compatibility with other standard version 7 UNIX systems. 

newA newer terminal driver, with features for job control; this must be used when using csh(1). 

Line discipline switching is accomplished with the TIOCSETD ioctl:

int ldisc = LDISC; ioctl(filedes, TIOCSETD, &ldisc);

where LDISC is OTTYDISC for the standard tty driver and NTTYDISC for the new driver.  The standard (currently old) tty driver is discipline 0 by convention.  The current line discipline can be obtained with the TIOCGETD ioctl.  Pending input is discarded when the line discipline is changed. 

All of the low-speed asynchronous communications ports can use any of the available line disciplines, no matter what hardware is involved.  The remainder of this section discusses the “old” and “new” disciplines. 

The control terminal. 

When a terminal file is opened, it causes the process to wait until a connection is established.  In practice, user programs seldom open these files; they are opened by the Display Manager and become a user’s standard input and output file. 

If a process which has no control terminal opens a terminal file, then that terminal file becomes the control terminal for that process.  The control terminal is thereafter inherited by a child process during a fork(2), even if the control terminal is closed. 

The file /dev/tty is, in each process, a synonym for a control terminal associated with that process.  It is useful for programs that wish to be sure of writing messages on the terminal no matter how output has been redirected.  It can also be used for programs that demand a file name for output, when typed output is desired and it is tiresome to find out which terminal is currently in use. 

Process groups. 

Command processors such as csh(1) can arbitrate the terminal between different jobs by placing related jobs in a single process group and associating this process group with the terminal.  A terminal’s associated process group may be set using the TIOCSPGRP ioctl(2):

ioctl(fildes, TIOCSPGRP, &pgrp)

or examined using TIOCGPGRP rather than TIOCSPGRP, returning the current process group in pgrp.  The new terminal driver aids in this arbitration by restricting access to the terminal by processes which are not in the current process group; see Job access control below. 

Modes. 

The terminal drivers have three major modes, characterized by the amount of processing on the input and output characters:

COOKEDThe normal mode.  In this mode lines of input are collected and input editing is done.  The edited line is made available when it is completed by a newline or when an EOT (control-D, hereafter ^D) is entered.  A carriage return is usually made synonymous with newline in this mode, and replaced with a newline whenever it is typed.  All driver functions (input editing, interrupt generation, output processing such as delay generation and tab expansion, etc.)  are available in this mode. 

CBREAKThis mode eliminates the character, word, and line editing input facilities, making the input character available to the user program as it is typed.  Flow control, literal-next and interrupt processing are still done in this mode.  Output processing is done. 

RAWThis mode eliminates all input processing and makes all input characters available as they are typed; no output processing is done either. 

The style of input processing can also be very different when the terminal is put in non-blocking I/O mode; see fcntl(2).  In this case a read(2) from the control terminal will never block, but rather return an error indication (EWOULDBLOCK) if there is no input available. 

Input editing. 

A terminal ordinarily operates in full-duplex mode.  Characters may be typed at any time, even while output is occurring, and are only lost when the system’s character input buffers become completely choked, which is rare, or when the user has accumulated the maximum allowed number of input characters that have not yet been read by some program.  Currently this limit is 256 characters.  In the old terminal driver all the saved characters are thrown away when the limit is reached, without notice; the new driver simply refuses to accept any further input, and rings the terminal bell. 

Input characters are normally accepted in either even or odd parity with the parity bit being stripped off before the character is given to the program.  By clearing either the EVEN or ODD bit in the flags word it is possible to have input characters with that parity discarded (see the Summary below.) 

Input characters are normally echoed by putting them in an output queue as they arrive.  This may be disabled by clearing the ECHO bit in the flags word using the stty(3) call or the TIOCSETN or TIOCSETP ioctls (see the Summary below). 

In cooked mode, terminal input is processed in units of lines.  A program attempting to read will normally be suspended until an entire line has been received (but see the description of SIGTTIN in Modes above and FIONREAD in Summary below.)  No matter how many characters are requested in the read call, at most one line will be returned.  It is not, however, necessary to read a whole line at once; any number of characters may be requested in a read, even one, without losing information. 

During input, line editing is normally done, with the character ‘#’ logically erasing the last character typed and the character ‘@’ logically erasing the entire current input line.  These are often reset on CRT’s, with ^H replacing #, and ^U replacing @.  These characters never erase beyond the beginning of the current input line or an ^D.  These characters may be entered literally by preceding them with ‘\’; in the old teletype driver both the ‘\’ and the character entered literally will appear on the screen; in the new driver the ‘\’ will normally disappear.

The drivers normally treat either a carriage return or a newline character as terminating an input line, replacing the return with a newline and echoing a return and a line feed.  If the CRMOD bit is cleared in the local mode word then the processing for carriage return is disabled, and it is simply echoed as a return, and does not terminate cooked mode input. 

In the new driver there is a literal-next character ^V which can be typed in both cooked and CBREAK mode preceding any character to prevent its special meaning.  This is to be preferred to the use of ‘\’ escaping erase and kill characters, but ‘\’ is (at least temporarily) retained with its old function in the new driver for historical reasons.

The new terminal driver also provides two other editing characters in normal mode.  The word-erase character, normally ^W, erases the preceding word, but not any spaces before it.  For the purposes of ^W, a word is defined as a sequence of non-blank characters, with tabs counted as blanks.  Finally, the reprint character, normally ^R, retypes the pending input beginning on a new line.  Retyping occurs automatically in cooked mode if characters which would normally be erased from the screen are fouled by program output. 

Input echoing and redisplay

In the old terminal driver, nothing special occurs when an erase character is typed; the erase character is simply echoed.  When a kill character is typed it is echoed followed by a new-line (even if the character is not killing the line, because it was preceded by a ‘\’!.)

The new terminal driver has several modes for handling the echoing of terminal input, controlled by bits in a local mode word. 

Hardcopy terminals.  When a hardcopy terminal is in use, the LPRTERA bit is normally set in the local mode word.  Characters which are logically erased are then printed out backwards preceded by ‘\’ and followed by ‘/’ in this mode.

CRT terminals.  When a CRT terminal is in use, the LCRTBS bit is normally set in the local mode word.  The terminal driver then echoes the proper number of erase characters when input is erased; in the normal case where the erase character is a ^H this causes the cursor of the terminal to back up to where it was before the logically erased character was typed.  If the input has become fouled due to interspersed asynchronous output, the input is automatically retyped. 

Erasing characters from a CRT.  When a CRT terminal is in use, the LCRTERA bit may be set to cause input to be erased from the screen with a “backspace-space-backspace” sequence when character or word deleting sequences are used.  A LCRTKIL bit may be set as well, causing the input to be erased in this manner on line kill sequences as well. 

Echoing of control characters.  If the LCTLECH bit is set in the local state word, then non-printing (control) characters are normally echoed as ^X (for some X) rather than being echoed unmodified; delete is echoed as ^?. 

The normal modes for using the new terminal driver on CRT terminals are speed-dependent.  At speeds less than 1200 baud, the LCRTERA and LCRTKILL processing is painfully slow, so stty(1) normally just sets LCRTBS and LCTLECH; at speeds of 1200 baud or greater all of these bits are normally set.  Stty(1) summarizes these option settings and the use of the new terminal driver as “newcrt.”

Output processing. 

When one or more characters are written, they are actually transmitted to the terminal as soon as previously-written characters have finished typing.  (As noted above, input characters are normally echoed by putting them in the output queue as they arrive.)  When a process produces characters more rapidly than they can be typed, it will be suspended when its output queue exceeds some limit.  When the queue has drained down to some threshold the program is resumed.  Even parity is normally generated on output.  The EOT character is not transmitted in cooked mode to prevent terminals that respond to it from hanging up; programs using raw or cbreak mode should be careful. 

The terminal drivers provide necessary processing for cooked and CBREAK mode output including delay generation for certain special characters and parity generation.   Delays are available after backspaces (^H), form feeds (^L), carriage returns (^M), tabs (^I) and newlines (^J).  The driver will also optionally expand tabs into spaces, where the tab stops are assumed to be set every eight columns.  These functions are controlled by bits in the tty flags word; see Summary below. 

Flow control. 

There are two characters (the stop character, normally ^S, and the start character, normally ^Q) which cause output to be suspended and resumed respectively.  Extra stop characters typed when output is already stopped have no effect, unless the start and stop characters are made the same, in which case output resumes. 

A bit in the flags word may be set to put the terminal into TANDEM mode.  In this mode the system produces a stop character (default ^S) when the input queue is in danger of overflowing, and a start character (default ^Q) when the input has drained sufficiently.  This mode is useful when the terminal is actually another machine that obeys the conventions. 

Line control and breaks. 

There are several ioctl calls available to control the state of the terminal line.  The TIOCSBRK ioctl will set the break bit in the hardware interface causing a break condition to exist; this can be cleared (usually after a delay with sleep(3)) by TIOCCBRK.  Break conditions in the input are reflected as a null character in RAW mode or as the interrupt character in cooked or CBREAK mode.  The TIOCCDTR ioctl will clear the data terminal ready condition; it can be set again by TIOCSDTR. 

When the carrier signal from the dataset drops (usually because the user has hung up a terminal) a SIGHUP hangup signal is sent to the processes in the distinguished process group of the terminal; this usually causes them to terminate (the SIGHUP can be suppressed by setting the LNOHANG bit in the local state word of the driver.)  Access to the terminal by other processes is then normally revoked, so any further reads will fail, and programs that read a terminal and test for end-of-file on their input will terminate appropriately. 

When using an ACU it is possible to ask that the phone line be hung up on the last close with the TIOCHPCL ioctl; this is normally done on the outgoing line. 

Interrupt characters. 

There are several characters that generate interrupts in cooked and CBREAK mode; all are sent the processes in the control group of the terminal, as if a TIOCGPGRP ioctl were done to get the process group and then a killpg(2) system call were done, except that these characters also flush pending input and output when typed at a terminal (as with TIOCFLUSH).  The characters shown here are the defaults; the field names in the structures (given below) are also shown.  The characters may be changed, although this is not often done. 

^?t_intrc (Delete) generates a SIGINT signal.  This is the normal way to stop a process which is no longer interesting, or to regain control in an interactive program. 

^\t_quitc (FS) generates a SIGQUIT signal.  This is used to cause a program to terminate and produce a core image, if possible, in the file core in the current directory. 

^Zt_suspc (EM) generates a SIGTSTP signal, which is used to suspend the current process group. 

^Yt_dsuspc (SUB) generates a SIGTSTP signal as ^Z does, but the signal is sent when a program attempts to read the ^Y, rather than when it is typed. 

Job access control. 

When using the new terminal driver, if a process which is not in the distinguished process group of its control terminal attempts to read from that terminal its process group is sent a SIGTTIN signal.  This signal normally causes the members of that process group to stop.  If, however, the process is ignoring SIGTTIN, has SIGTTIN blocked, is an orphan process, or is in the middle of process creation using vfork(2)), it is instead returned an end-of-file.  (An orphan process is a process whose parent has exited and has been inherited by the init(8) process.)  Under older UNIX systems these processes would typically have had their input files reset to /dev/null, so this is a compatible change. 

When using the new terminal driver with the LTOSTOP bit set in the local modes, a process is prohibited from writing on its control terminal if it is not in the distinguished process group for that terminal.  Processes that are holding or ignoring SIGTTOU signals, are orphans, or are in the middle of a vfork(2), are excepted and allowed to produce output. 

Summary of modes. 

Unfortunately, due to the evolution of the terminal driver, there are four different structures which contain various portions of the driver data.  The first of these (sgttyb) contains that part of the information largely common between version 6 and version 7 UNIX systems.  The second contains additional control characters added in version 7.  The third is a word of local state peculiar to the new terminal driver, and the fourth is another structure of special characters added for the new driver.  In the future a single structure may be made available to programs which need to access all this information; most programs need not concern themselves with all this state. 

The basic ioctls use the structure defined in <sgtty.h>:

struct sgttyb {
charsg_ispeed;
charsg_ospeed;
charsg_erase;
charsg_kill;
shortsg_flags;
};

The sg_ispeed and sg_ospeed fields describe the input and output speeds of the device according to the following table, which corresponds to the DEC DH-11 interface.  If other hardware is used, impossible speed changes are ignored.  Symbolic values in the table are as defined in <sgtty.h>.

B00(hang up dataphone)
B50150 baud
B75275 baud
B1103110 baud
B1344134.5 baud
B1505150 baud
B2006200 baud
B3007300 baud
B6008600 baud
B120091200 baud
B1800101800 baud
B2400112400 baud
B4800124800 baud
B9600139600 baud
EXTA14 External A
EXTB15 External B

In the current configuration, only 110, 150, 300 and 1200 baud are really supported on dial-up lines.  Code conversion and line control required for IBM 2741s (134.5 baud) must be implemented by the user’s program.  The half-duplex line discipline required for the 202 dataset (1200 baud) is not supplied; full-duplex 212 datasets work fine. 

The sg_erase and sg_kill fields of the argument structure specify the erase and kill characters respectively.  (Defaults are # and @.) 

The sg_flags field of the argument structure contains several bits that determine the system’s treatment of the terminal:

ALLDELAY0177400Delay algorithm selection
BSDELAY0100000Select backspace delays (not implemented):
BS00
BS10100000
VTDELAY0040000Select form-feed and vertical-tab delays:
FF00
FF10100000
CRDELAY0030000Select carriage-return delays:
CR00
CR10010000
CR20020000
CR30030000
TBDELAY0006000Select tab delays:
TAB00
TAB10001000
TAB20004000
XTABS0006000
NLDELAY0001400Select newline delays:
NL00
NL10000400
NL20001000
NL30001400
EVENP0000200Even parity allowed on input (most terminals)
ODDP0000100Odd parity allowed on input
RAW0000040Raw mode: wake up on all characters, 8-bit interface
CRMOD0000020Map CR into LF; echo LF or CR as CR-LF
ECHO0000010Echo (full duplex)
LCASE0000004Map uppercase to lower- on input
CBREAK0000002Return each character as soon as typed
TANDEM0000001Automatic flow control

The delay bits specify how long transmission stops to allow for mechanical or other movement when certain characters are sent to the terminal.  In all cases, a value of zero indicates no delay. 

Backspace delays are currently ignored but might be used for Terminet 300s. 

If a form-feed/vertical tab delay is specified, it lasts for about 2 seconds. 

Carriage-return delay type 1 lasts about .08 seconds and is suitable for the Terminet 300.  Delay type 2 lasts about .16 seconds and is suitable for the VT05 and the TI 700.  Delay type 3 is suitable for the concept-100 and pads lines to be at least 9 characters at 9600 baud. 

Newline delay type 1 is dependent on the current column and is tuned for Teletype model 37s.  Type 2 is useful for the VT05 and is about .10 seconds.  Type 3 is unimplemented and is zero. 

Tab delay type 1 is dependent on the amount of movement and is tuned to the Teletype model 37.  Type 3, called XTABS, is not a delay at all but causes tabs to be replaced by the appropriate number of spaces on output. 

Input characters with the wrong parity, as determined by bits 200 and 100, are ignored in cooked and CBREAK mode. 

RAW disables all processing save output flushing with LFLUSHO; full 8 bits of input are given as soon as it is available; all 8 bits are passed on output.  A break condition in the input is reported as a null character.  If the input queue overflows in raw mode it is discarded; this applies to both new and old drivers. 

CRMOD causes input carriage returns to be turned into newlines; input of either CR or LF causes LF-CR both to be echoed (for terminals with a newline function). 

CBREAK is a sort of half-cooked mode.  Programs can read each character as soon as typed, instead of waiting for a full line; all processing is done except the input editing: character and word erase and line kill, input reprint, and the special treatment of \ or EOT are disabled. 

TANDEM mode causes the system to produce a stop character (default ^S) whenever the input queue is in danger of overflowing, and a start character (default ^Q) when the input queue has drained sufficiently.  It is useful for flow control when the ‘terminal’ is really another computer which understands the conventions. 

In addition to the TIOCSETD and TIOCGETD disciplines discussed in Line disciplines above, a large number of other ioctl(2) calls apply to terminals, and have the general form:

#include <sgtty.h>

ioctl(fildes, code, arg)
struct sgttyb *arg;

The applicable codes are:

TIOCGETPFetch the basic parameters associated with the terminal, and store in the pointed-to sgttyb structure. 

TIOCSETPSet the parameters according to the pointed-to sgttyb structure.  The interface delays until output is quiescent, then throws away any unread characters, before changing the modes. 

TIOCSETNSet the parameters like TIOCSETP but do not delay or flush input.  Input is not preserved, however, when changing to or from RAW. 

With the following codes, the arg is ignored. 

TIOCEXCLSet “exclusive-use” mode: no further opens are permitted until the file has been closed. 

TIOCNXCLTurn off “exclusive-use” mode. 

TIOCHPCLWhen the file is closed for the last time, hang up the terminal.  This is useful when the line is associated with an ACU used to place outgoing calls. 

TIOCFLUSHAll characters waiting in input or output queues are flushed. 

The remaining calls are not available in vanilla version 7 UNIX.  In cases where arguments are required, they are described; arg should otherwise be given as zero. 

TIOCSTIthe argument is the address of a character which the system pretends was typed on the terminal. 

TIOCSBRKthe break bit is set in the terminal. 

TIOCCBRKthe break bit is cleared. 

TIOCSDTRdata terminal ready is set. 

TIOCCDTRdata terminal ready is cleared. 

TIOCGPGRParg is the address of a word into which is placed the process group number of the control terminal. 

TIOCSPGRParg is a word (typically a process ID) which becomes the process group for the control terminal. 

FIONREADreturns in the long integer whose address is arg the number of immediately readable characters from the argument unit.  This works for files, pipes, and terminals, but not (yet) for multiplexed channels. 

The second structure associated with each terminal specifies characters that are special in both the old and new terminal interfaces: The following structure is defined in <sys/ioctl.h>, which is automatically included in <sgtty.h>:

struct tchars {
chart_intrc;/* interrupt */
chart_quitc;/* quit */
chart_startc;/* start output */
chart_stopc;/* stop output */
chart_eofc;/* end-of-file */
chart_brkc;/* input delimiter (like nl) */
};

The default values for these characters are ^?, ^\, ^Q, ^S, ^D, and −1. A character value of −1 eliminates the effect of that character. The t_brkc character, by default −1, acts like a newline in that it terminates a ‘line,’ is echoed, and is passed to the program.  The ‘stop’ and ‘start’ characters may be the same, to produce a toggle effect.  It is probably counterproductive to make other special characters (including erase and kill) identical.  The applicable ioctl calls are:

TIOCGETCGet the special characters and put them in the specified structure. 

TIOCSETCSet the special characters to those given in the structure. 

The third structure associated with each terminal is a local mode word; except for the LNOHANG bit, this word is interpreted only when the new driver is in use.  The bits of the local mode word are:

LCRTBS000001Backspace on erase rather than echoing erase
LPRTERA000002Printing terminal erase mode
LCRTERA000004Erase character echoes as backspace-space-backspace
LTILDE000010Convert ~ to ` on output (for Hazeltine terminals)
LMDMBUF000020Stop/start output when carrier drops
LLITOUT000040Suppress output translations
LTOSTOP000100Send SIGTTOU for background output
LFLUSHO000200Output is being flushed
LNOHANG000400Don’t send hangup when carrier drops
LETXACK001000Diablo style buffer hacking (unimplemented)
LCRTKIL002000BS-space-BS erase entire line on line kill
LINTRUP004000Generate interrupt SIGTINT when input ready to read
LCTLECH010000Echo input control chars as ^X, delete as ^?
LPENDIN020000Retype pending input at next read or input character
LDECCTQ040000Only ^Q restarts output after ^S, like DEC systems

The applicable ioctl functions are:

TIOCLBISarg is the address of a mask which is the bits to be set in the local mode word. 

TIOCLBICarg is the address of a mask of bits to be cleared in the local mode word. 

TIOCLSETarg is the address of a mask to be placed in the local mode word. 

TIOCLGETarg is the address of a word into which the current mask is placed. 

The final structure associated with each terminal is the ltchars structure which defines interrupt characters for the new terminal driver.  Its structure is:

struct ltchars {
chart_suspc;/* stop process signal */
chart_dsuspc;/* delayed stop process signal */
chart_rprntc;/* reprint line */
chart_flushc;/* flush output (toggles) */
chart_werasc;/* word erase */
chart_lnextc;/* literal next character */
};

The default values for these characters are ^Z, ^Y, ^R, ^O, ^W, and ^V. A value of −1 disables the character.

The applicable ioctl functions are:

TIOCSLTCargs is the address of a ltchars structure which defines the new local special characters. 

TIOCGLTCargs is the address of a ltchars structure into which is placed the current set of local special characters. 

NOTES

Half-duplex terminals are not supported. 

FILES

/dev/tty
/dev/tty*
/dev/console

RELATED COMMANDS

csh(1), stty(1), ioctl(2), sigvec(2), stty(3C)