tty(4) Kernel Interfaces Manual tty(4)
Name
tty - general terminal interface
Description
Terminal Subsystem
The terminal subsystem is the part of the operating system that allows users to read and write characters over asynchronous terminal lines.
An important aspect of this subsystem is to provide a means for the user to set and receive terminal attributes. Terminal attributes
involve such things as line speed (baud rate), character length, parity, flow control, modem control, as well as numerous character-pro-
cessing capabilities.
The ULTRIX terminal interface allows the user to specify terminal attributes in different ways. Several different terminal interfaces
exist to provide standard compliant terminal control.
Terminal Interface Definitions
The reference page describes the standard Berkeley terminal interface. This interface is backward compatible with earlier versions of the
ULTRIX operating system.
The reference page describes the terminal interface as defined by the System V Interface Definition.
The reference page describes the termios termio interface as defined by the IEEE P1003 POSIX specification.
Functionally, the three terminal interfaces are quite similar. Major differences lie in how terminal attributes are specified. This
includes the use of different data structures to represent terminal attributes, as well as the means of setting and receiving attributes.
It is possible to use combinations of the three terminal interface definitions. Under these circumstances, the attributes of one interface
are mapped into the corresponding attributes of the other interfaces. Combining aspects of different interfaces is discouraged, because it
prevents the development of portable programs. For example, a program intended for use with the System V termio terminal interface fails
to be a standard compliant program if it sets terminal attributes that are specific to either of the other two terminal interfaces.
Combinations of the different terminal interfaces should be used with extreme caution to avoid unwanted side-effects. For example, a pro-
gram may have initially set up its terminal environment using the System V termio interface, Suppose that the initial line settings are
seven bits even parity with input and output processing performed. If this same program were to set the line to RAW mode as specified in
the line would be set to eight bits no parity, with no input or output processing. These settings would be reflected in the parameters as
specified in This simple example is meant to illustrate the subtle side effects that can result from the use of combinations of terminal
interfaces.
Using combinations of terminal interfaces can also cause problems if attributes that are not common to all interfaces are used. For exam-
ple, the Berkeley terminal interface allows the user to set the value of the start and stop characters. The System V termio interface
defines that the start and stop characters shall be Control-Q and Control-S. As a result, if a terminal changes the start and stop charac-
ters using the Berkeley terminal interface, those characters are reset if the terminal parameters are set using the System V termio inter-
face.
Terminal Interface Usage
The three interfaces have been developed to provide standard compliant terminal behavior. The interface type should be specified at the
time of program compilation. As described in to compile a System V-compliant program, the -Y option (or setting PROG_ENV equal to SYS-
TEM_FIVE) should be used. Similarly, the -YPOSIX option should be used to compile a POSIX-compliant program. Without the -Y or -YPOSIX
compile option, the program intends to use the Berkeley terminal interface. Refer to for specific details on compatibility modes.
Berkeley Terminal Interface
Line Disciplines.
The system provides different line disciplines for controlling communications lines. In this version of the system, there are several dis-
ciplines available:
old The old (Version 7) terminal driver. This is sometimes used when using the standard shell and for compatibility with other stan-
dard Version 7 UNIX systems.
new The standard terminal driver, with features for job control. This must be used when using
net A line discipline used for networking and loading data into the system over communications lines. It allows high speed input at
low overhead and is described in
termio This line discipline is intended for use by System V programs that use the termio interface, as described in The termio line disci-
pline is also used by programs that require a POSIX IEEE P1003 termios interface as described in
Line discipline switching is accomplished with the TIOCSETD
int ldisc = LDISC; ioctl(filedes, TIOCSETD, &ldisc);
LDISC is OTTYDISC for the standard tty driver, NTTYDISC for the new driver, NETLDISC for the networking discipline, and TERMIODISC for Sys-
tem V termio and POSIX termios. The standard tty driver is discipline 0 by convention. Other disciplines may exist for special purposes.
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 or and become a user's standard input and output file.
If a process that 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 even if the control terminal is closed.
The file is, in each process, a synonym for a control terminal associated with that process. It is useful for programs that want 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.
A process can remove the association it has with its controlling terminal by opening the file and issuing:
ioctl(fildes, TIOCNOTTY, 0)
This is often desirable in server processes.
Process Groups
Command processors such as can arbitrate the terminal between different jobs by placing related jobs in a single process group and associ-
ating this process group with the terminal. A terminal's associated process group may be set using the TIOCSPGRP
ioctl(fildes, TIOCSPGRP, &pgrp)
The process group can be examined using using TIOCGPGRP, rather than TIOCSPGRP, returning the current process group in pgrp. The new ter-
minal driver aids in this arbitration by restricting access to the terminal by processes that are not in the current process group; see Job
Access Control.
Modes
The terminal drivers have three major modes, characterized by the amount of processing on the input and output characters:
cooked The 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 the t_brkc character (normally undefined) or t_eofc character (normally an EOT, CTRL/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,
and so forth) are available in this mode.
CBREAK This 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.
RAW This 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 different when the terminal is put in nonblocking I/O mode. For further information, see the
FNDELAY flag described in In this case, a from the control terminal never blocks. Rather, it returns an error indication (EWOULDBLOCK), if
there is no input available.
A process may also request a SIGIO signal be sent it whenever input is present and also whenever output queues fall below the low-water
mark. To enable this mode, the FASYNC flag should be set using
Input Editing
An ULTRIX 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. This limit is 256 characters. In RAW mode, the terminal
driver throws away all input and output without notice when the limit is reached. In CBREAK mode or cooked mode, it refuses to accept any
further input and, if in the new line discipline, 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 dis-
carded (see the Summary).
In all of the line disciplines, it is possible to simulate terminal input using the TIOCSTI ioctl, which takes, as its third argument, the
address of a character. The system pretends that this character was typed on the argument terminal, which must be the control terminal,
except for the superuser. (This call is not in standard Version 7 UNIX.)
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 call or the TIOCSETN or TIOCSETP ioctl (see the Summary).
In cooked mode, terminal input is processed in units of lines. A program attempting to read is normally suspended until an entire line has
been received (but, see the description of SIGTTIN in Job Access Control and FIONREAD in Summary of modes.) No matter how many characters
are requested in the read call, at most one line is returned. It is not, however, necessary to read a whole line at once; any number of
characters can be requested in a read, even one, without losing information.
During input, line editing is normally done, with the erase character sg_erase (by default, the number sign (#)) logically erasing the last
character typed and the sg_kill character (by default, the at sign (@)) logically erasing the entire current input line. These are often
reset on CRTs, with CTRL/H replacing the number sign (#), and CTRL/U replacing the at sign (@). These characters never erase beyond the
beginning of the current input line or an EOF. These characters may be entered literally, by preceding them with a backslash (). In the
old Teletype driver, both the backslash () and the character entered literally appear on the screen; in the new driver, the () normally
disappears.
The drivers normally treat either a carriage return or a newline character as terminating an input line, replacing the return with a new-
line 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 (normally CTRL/V), which can be typed in both cooked and CBREAK mode preceding any
character to prevent its special meaning to the terminal handler. This is to be preferred to the use of the backslash () escaping erase
and kill characters, but the backslash () is 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 CTRL/W, erases the
preceding word, but not any spaces before it. For the purposes of CTRL/W, a word is defined as a sequence of nonblank characters, with
tabs counted as blanks. Finally, the reprint character, normally CTRL/R, retypes the pending input beginning on a new line. Retyping
occurs automatically in cooked mode, if characters that would normally be erased from the screen are fouled by program output.
Input Echoing and Redisplay
In the old terminal driver, the erase character is simply echoed. When a kill character is typed, it is echoed, followed by a newline
(even if the character is not killing the line, because it was preceded by a backslash ().)
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 that are logi-
cally erased are then printed out backwards, preceded by a backslash () and followed by a slash (/) 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 echoes the proper
number of erase characters when input is erased. In the normal case, where the erase character is a CTRL/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 can 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. LCRTERA must be used with LCRTBS for this func-
tionality. A LCRTKIL bit can 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 nonprinting (control) characters are normally echoed
as ^x (where x is the character used in combination with the CTRL key), 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 slow, so normally just sets LCRTBS and LCTLECH; at speeds of 1200 baud or greater, all of these bits are normally
set. The command 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 fin-
ished 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 is 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 charac-
ters and parity generation. Delays are available after backspaces (CTRL/H), form feeds (CTRL/L), carriage returns (CTRL/M), tabs
(CTRL/I), and newlines (CTRL/J). The driver also optionally expands 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.)
The terminal drivers provide for mapping between uppercase and lowercase on terminals lacking lowercase, and for other special processing
on deficient terminals.
Finally, in the new terminal driver, there is an output flush character, normally CTRL/O, which sets the LFLUSHO bit in the local mode
word, causing subsequent output to be flushed until it is cleared by a program or more input is typed. This character has effect in both
cooked and CBREAK modes and causes pending input to be retyped if there is any pending input. An ioctl to flush the characters in the
input and output queues, TIOCFLUSH, is also available.
Uppercase Terminals and Hazeltines
If the LCASE bit is set in the tty flags, then all uppercase letters are mapped into the corresponding lowercase letter. The uppercase
letter may be generated by preceding it by a backslash (). If the new terminal driver is being used, then uppercase letters are preceded
by a a backslash () when output. In addition, the following escape sequences can be generated on output and accepted on input:
for ` | ~ { }
use ' ! ^ ( )
To deal with Hazeltine terminals, which do not recognize the tilde (~) as an ASCII character, the LTILDE bit may be set in the local mode
word when using the new terminal driver; in this case, the tilde (~) will be replaced with the grave accent (`) on output.
Flow Control
There are two characters (the stop character, normally CTRL/S, and the start character, normally CTRL/Q), that 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
CTRL/S) when the input queue is in danger of overflowing, and a start character (default CTRL/Q) when the input has drained sufficiently.
This mode is useful when the terminal is actually another machine that obeys the conventions.
A bit in the local mode word may be set to put the terminal into AUTOFLOW mode. In this mode, flow control characters are responded to at
the hardware level. Upon receipt of a stop character, the hardware suspends output. This allows for quick response to the stop character,
which prevents buffer overflow (in printers for example). AUTOFLOW functionality is only provided if the start character is CTRL/Q and the
stop character is CTRL/S. The AUTOFLOW bit is cleared if the start or stop characters are not standard values, or if the RAW bit is not
set.
Line Control and Breaks
There are several calls available to control the state of the terminal line. The TIOCSBRK ioctl sets the break bit in the hardware inter-
face, causing a break condition to exist. This can be cleared by TIOCCBRK, usually after a delay with 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 clears the data ter-
minal ready condition. It can be set again by TIOCSDTR.
When the carrier signal from the dataset drops (usually because the user has hung up his 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 set-
ting 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 fail, and programs that read a terminal and test for end-of-file on their input 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 system call were done, except that these characters also
flush pending input and output when typed at a terminal (for example, TIOCFLUSH). The characters shown here are the defaults. The field
names in the structures 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 that 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.
^Z t_suspc (EM) generates a SIGTSTP signal that is used to suspend the current process group.
^Y t_dsuspc (SUB) generates a SIGTSTP signal as CTRL/Z does, but the signal is sent when a program attempts to read the CTRL/Y, rather
than when it is typed.
Job Access Control
When using the new terminal driver, if a process that 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 it
is returned an end-of-file instead. (An orphan process is a process whose parent has exited and that has been inherited by the process.)
Under older UNIX systems these processes would typically have had their input files reset to 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 termi-
nal, if it is not in the distinguished process group for that terminal. Processes that are holding or ignoring SIGTTOU signals, that are
orphans, or that are in the middle of a are excepted and allowed to produce output.
Modem Control
Ioctls have been added to provide more flexible modem control on tty lines. The new commands are summarized below.
TIOCMODEM Indicate to the system that this tty line has a modem attached to it and should not ignore modem signals. The argument to
this ioctl is the address of a word that contains either zero or a nonzero value. Zero indicates that the effect of the
ioctl is temporary, and the line is reset to its condition prior to the ioctl, when the tty line is closed. Nonzero indi-
cates that the effect of the ioctl should be permanent. Root privilege is required to effect a permanent change.
TIOCNMODEM Indicate to the system that modem transmissions should be ignored on this line. This is useful for connections that do not
implement the full RS-232 standard (most direct connections to terminals). The argument to this ioctl is the address of a
word that contains either zero or a nonzero value. Zero indicates that the effect of ioctl is temporary, and the line is
reset to its condition prior to the ioctl, when the tty line is closed. Nonzero indicates that the effect of the ioctl
should be permanent. Root privilege is required to effect a permanent change.
TIOCNCAR Ignore soft carrier when doing reads or writes. If carrier is not present on a modem line, then reads or writes normally
fail. This ioctl allows reads and writes to succeed, regardless of the state of this line. This is useful for dealing with
automatic call units that send status messages before carrier is present on the line. The alternative would be to use the
TIOCNMODEM ioctl and ignore all modem signals and force soft carrier to be present. The latter alternative is not desir-
able, if full modem control is required.
TIOCCAR The opposite effect of TIOCNCAR. If carrier is not present on modem lines, then reads and writes fail.
TIOCWONLINE This ioctl blocks the process until carrier is detected.
The following example demonstrates how one might deal with a modem:
/* open the line and don't wait for carrier */
fd = open(dcname, O_RDWR|O_NDELAY);
/* we are attached to a modem so don't ignore modem signals */
ioctl(fd, TIOCMODEM, &temp);
ioctl(fd, TIOCNCAR); /* ignore soft carr while dialing number */
/*
* dial phone number and negotiate with auto call unit.
*/
ioctl(fd, TIOCCAR); /* don't ignore carrier anymore */
alarm(40);
ioctl(fd, TIOCWONLINE); /* wait for carrier */
alarm(0);
Shared tty Lines
The following ioctls are used by and to implement shared terminal lines: TIOCSINUSE/FIOSINUSE, TIOCCINUSE/FIOCINUSE. Shared terminal
lines can be used for both incoming and outgoing connections. For further information, see the Guide to System Environment Setup. These
ioctls can be used by any user process on any file type, but they do not work on a socket.
TIOCSINUSE TIOCSINUSE is defined to FIOSINUSE. This command checks to see if the file is marked ``in use''. If the file is not ``in
use'', it is marked ``in use'' by the current process and the ioctl succeeds. If the file is already ``in use'' by some
other process, the ioctl fails and errno is set to EALREADY. For further information, see
TIOCCINUSE TIOCCINUSE is defined to FIOCINUSE. This command clears the ``in use'' flag on a file, if the current process was the one
that set the ``in use'' flag. Any process that is blocked and waiting for the ``in use'' flag to clear will be resumed.
For further information, see
Summary of Modes
Unfortunately, due to the evolution of the terminal driver, there are four different structures that 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.
Basic modes: sgtty - There are two versions of the sgttyb structure: one for BSD (default) and one for SYSTEM_FIVE. The basic ioctls use
the structure defined in
You get this version of sgttyb if you include into your .c source, and then compile with `cc -YBSD ....' or `setenv PROG_ENV BSD' or by
default to BSD if PROG_ENV is not defined, or `-Y' is not specified.
struct sgttyb {
char sg_ispeed;
char sg_ospeed;
char sg_erase;
char sg_kill;
short sg_flags;
};
You get this version of sgttyb if you include in your .c source, and then compile using the `-Y' or `-YSYSTEM_FIVE' option of or set
PROG_ENV environment to `SYSTEM_FIVE'.
struct sgttyb {
char sg_ispeed;
char sg_ospeed;
char sg_erase;
char sg_kill;
int sg_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 speeds offered on most Digital terminal multiplexers. If other hardware is used, impossible speed changes are ignored. Symbolic
values in the table are as defined in
B0 0 (hang up dataphone)
B50 1 50 baud
B75 2 75 baud
B110 3 110 baud
B134 4 134.5 baud
B150 5 150 baud
B200 6 200 baud
B300 7 300 baud
B600 8 600 baud
B1200 9 1200 baud
B1800 10 1800 baud
B2400 11 2400 baud
B4800 12 4800 baud
B9600 13 9600 baud
EXTA 14 External A (19200 baud)
EXTB 15 External B (38400 baud)
Code conversion and line control required for IBM 2741s (134.5 baud) must be implemented by the user's program. The half-duplex line dis-
cipline 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 the number
sign (#) and the at sign (@).)
The sg_flags field of the argument structure contains several bits that determine the system's treatment of the terminal:
ALLDELAY 0177400 Delay algorithm selection
BSDELAY 0100000 Select backspace delays (not implemented):
BS0 0
BS1 0100000
VTDELAY 0040000 Select form-feed and vertical-tab delays:
FF0 0
FF1 0100000
CRDELAY 0030000 Select carriage-return delays:
CR0 0
CR1 0010000
CR2 0020000
CR3 0030000
TBDELAY 0006000 Select tab delays:
TAB0 0
TAB1 0002000
TAB2 0004000
XTABS 0006000
NLDELAY 0001400 Select new-line delays:
NL0 0
NL1 0000400
NL2 0001000
NL3 0001400
EVENP 0000200 Even parity allowed on input (most terminals)
ODDP 0000100 Odd parity allowed on input
RAW 0000040 Raw mode: wake up on all characters, 8-bit interface
CRMOD 0000020 Map CR into LF; echo LF or CR as CR-LF
ECHO 0000010 Echo (full duplex)
LCASE 0000004 Map uppercase to lowercase on input
CBREAK 0000002 Return each character as soon as typed
TANDEM 0000001 Automatic flow control
The delay bits specify how long transmission stops to allow for mechanical or other movement, when certain characters are sent to the ter-
minal. In all cases, a value of 0 indicates no delay.
Backspace delays are ignored but might be used for Terminet 300s.
If a form-feed/vertical tab delay is specified, it lasts for about two 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 nine characters at 9600
baud.
New-line 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 is 0 and is unimplemented.
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.
The flags for even and odd parity control parity checking on input and generation on output in cooked and CBREAK mode. Even parity is gen-
erated on output unless ODDP is set and EVENP is clear, in which case odd parity is generated. For no parity, set both ODDP and EVENP
flags. Input characters with the wrong parity, as determined by EVENP and ODDP, are ignored in cooked and CBREAK mode.
RAW disables all processing save output flushing with LFLUSHO; full eight bits of input are given as soon as it is available; all eight
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 process-
ing is done, except the input editing: character and word erase and line kill, input reprint, and the special treatment of the backslash
() or EOT are disabled.
TANDEM mode causes the system to produce a stop character (default, CTRL/S), whenever the input queue is in danger of overflowing, and a
start character (default CTRL/Q), when the input queue has drained sufficiently. It is useful for flow control when the ``terminal'' is
really another computer that understands the conventions.
Basic ioctls - In addition to the TIOCSETD and TIOCGETD disciplines discussed in Line disciplines, a large number of other calls apply to
terminals and have the general form:
#include <sgtty.h>
ioctl(fildes, code, arg)
struct sgttyb *arg;
The applicable codes are:
TIOCGETP Fetch the basic parameters associated with the terminal and store in the pointed-to sgttyb structure.
TIOCSETP Set the parameters according to the pointed-to sgttyb structure. The interface delays until output is quiescent, and then
throws away any unread characters, before changing the modes.
TIOCSETN Set 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.
TIOCEXCL Set "exclusive-use" mode: all open calls to this line have been closed. This setting does not prevent superuser opens of the
terminal line.
TIOCNXCL Turn off "exclusive-use" mode.
TIOCHPCL When 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.
Setting the pointed-to integer parameter to the following values determines how TIOCFLUSH functions.
TIOCFLUSH FREAD flushes input queues. FWRITE flushes output queues. Zero(0) flushes both. FREAD and FWRITE are defined in
In cases where arguments are required, they are described; arg should otherwise be given as zero(0).
TIOCSTI The argument is the address of a character that the system pretends was typed on the terminal.
TIOCSBRK The break bit is set in the terminal.
TIOCCBRK The break bit is cleared.
TIOCSDTR Data terminal ready is set.
TIOCCDTR Data terminal ready is cleared.
TIOCSTOP Output is stopped, as if the ``stop'' character had been typed.
TIOCSTART Output is restarted, as if the ``start'' character had been typed.
TIOCGPGRP arg is the address of a word into which is placed the process group number of the control terminal.
TIOCSPGRP arg is a word (typically a process ID) that becomes the process group for the control terminal.
FIONREAD Returns in the long integer whose address is arg, the number of immediately readable characters from the argument unit.
Tchars - The second structure associated with each terminal specifies characters that are special in both the old and new terminal inter-
faces. The following structure is defined in which is automatically included in
struct tchars {
char t_intrc; /* interrupt */
char t_quitc; /* quit */
char t_startc; /* start output */
char t_stopc; /* stop output */
char t_eofc; /* end-of-file */
char t_brkc; /* input delimiter (like nl) */
};
The default values for these characters are CTRL/?, CTRL/, CTRL/Q, CTRL/S, CTRL/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:
TIOCGETC Get the special characters and put them in the specified structure.
TIOCSETC Set the special characters to those given in the structure.
Local mode - The third structure associated with each terminal is a local mode word. The bits of the local mode word are:
LCRTBS 0x0001 Backspace on erase, rather than echoing erase
LPRTERA 0x0002 Printing terminal erase mode
LCRTERA 0x0004 Erase character echoes as backspace-space-backspace
LTILDE 0x0008 Convert ~ to ` on output (for Hazeltine terminals)
LLITOUT 0x0020 Suppress output translations
LTOSTOP 0x0040 Send SIGTTOU for background output
LFLUSHO 0x0080 Output is being flushed
LNOHANG 0x0100 Do not send hangup when carrier drops
LAUTOFLOW 0x0200 Hardware responds to flow control characters. (See Flow control.)
LCRTKIL 0x0400 BS-space-BS erase entire line on line kill
LPASS8 0x0800 Allow 8-bit characters in input and output
LCTLECH 0x1000 Echo input control chars as ^X, delete as ^?
LPENDIN 0x2000 Retype pending input at next read or input character
LDECCTQ 0x4000 Only CTRL/Q restarts output after CTRL/S
LNOFLSH 0x8000 Do not flush output on receipt of suspend or interrupt character
The applicable functions are:
TIOCLBIS arg is the address of a mask of bits to be set in the local mode word.
TIOCLBIC arg is the address of a mask of bits to be cleared in the local mode word.
TIOCLSET arg is the address of a mask to be placed in the local mode word.
TIOCLGET arg is the address of a word into which the current mask is placed.
Window Size - The fourth structure associated with terminals is the structure that defines the size of the terminal window. The structure
is defined as follows:
struct winsize {
unsigned short ws_row, ws_col;
unsigned short ws_xpixel, ws_ypixel;
};
The ws_row and ws_col elements define the window size in terms of the number of characters per row and column respectively. The ws_xpixel
and ws_ypixel define the window size in terms of pixels. The default value is to initialize each of the elements to zero.
The applicable functions are:
TIOCSWINSZ arg is the address of a structure, which defines the new window sizes. This will send a SIGWINCH signal to notify all mem-
bers of process group that the window size has changed.
TIOCGWINSZ arg is the address of a structure into which is placed the current window size settings.
Local special characters - The final structure associated with each terminal is the structure that defines interrupt characters for the new
terminal driver. Its structure is:
struct ltchars {
char t_suspc; /* stop process signal */
char t_dsuspc; /* delayed stop process signal */
char t_rprntc; /* reprint line */
char t_flushc; /* flush output (toggles) */
char t_werasc; /* word erase */
char t_lnextc; /* literal next character */
};
The default values for these characters are CTRL/Z, CTRL/Y, CTRL/R, CTRL/O, CTRL/W, and CTRL/V. A value of -1 disables the character.
The applicable ioctl functions are:
TIOCSLTC args is the address of an structure, which defines the new local special characters.
TIOCGLTC args is the address of an structure, into which is placed the current set of local special characters.
Restrictions
Half-duplex terminals are not supported.
Files
See Also
csh(1), stty(1), tset(1), ioctl(2), sigvec(2), stty(3), termio(4), termios(4), getty(8), MAKEDEV(8)
tty(4)