• History:
  • UNIX systems were accessed using a piece of hardware called a terminal (often over an RS-232 serial cable)
  • Each specific device had its own device driver
• Today:
  • UNIX systems are accessed using a terminal emulator (e.g., xterm)
  • Terminal emulators use a device driver called a pseudoterminal
  • As with other devices, a terminal is modeled as a file

• Where are the files?
  • Usually in /dev or /dev/pts
• An example that might surprise you:
  1. Open two terminals
  2. Enter tty in each to get its name
  3. In one terminal, enter ls (you should know what will happen)
  4. In the same terminal, enter ls > other where other is the name of the other terminal (e.g., /dev/pts/1)
  5. Figure out what happened and why
• Another example:
  • Do the same thing but with man man (so that the output requires more than one "screen" and you need to provide input to move between "screens")
  • Figure out what happened and why

• Queue Management:
  • Input from the terminal to the reading process(es)
  • Output from process(es) to the terminal
• Special Character Handling:
  • Interrupt (normally Ctrl+C)
  • End-Of-File (normally Ctrl+D)

• Canonical:
  • Line-by-line (with line editing) which means that read() only returns when a line-feed character is encountered
• Noncanonical:
  • Not line-by-line

  struct termios {
    tcflag_t   c_iflag;     // Input flags
    tcflag_t   c_oflag;     // Output flags
    tcflag_t   c_cflag;     // Control flags
    tcflag_t   c_lflag;     // Local modes
    cc_t       c_line;      // Do not use
    cc_t       c_cc[NCCS};  // Special characters
    speed_t    c_ispeed;    // Do not use
    speed_t    c_ospeed;    // Do not use
  }
  

• Polling:
  • VMIN is 0, VTIME is 0
• Blocking:
  • VMIN is > 0, VTIME is 0
• Timeout:
  • VMIN is 0, VTIME is > 0
• Interbyte Timeout:
  • VMIN is > 0, VTIME is > 0

unixexamples/terminal/line.c

        #include <stdio.h>
#include <unistd.h>
#define  LENGTH 40

int
main(void)
{
  char  line[LENGTH+1];
  int   n;

  printf("%s\n", "Enter a short or long line...");

  // Note: The line-feed character is not disgarded
  n = read(STDIN_FILENO, line, LENGTH);

  // Make it a null-terminated string
  line[n] = '\0';

  printf("Line Length:   |%d|\n", n);
  printf("Line Contents: |%s|\n", line);
}
        

unixexamples/terminal/yesno.c

        #include <termios.h>
#include <unistd.h>

int
main(void)
{
  char             key; 
  struct termios   newterm, oldterm;

  tcgetattr(STDIN_FILENO, &oldterm);  // Remember the current mode

  newterm = oldterm;
  newterm.c_lflag &= ~ICANON;         // Not canonical
  newterm.c_lflag |= ECHO;            // Echo
  newterm.c_lflag |= ISIG;            // Enable QUIT, INTR, SUSP 
  newterm.c_lflag &= ~ICRNL;          // Don't map CR to LF/NL 
  newterm.c_cc[VMIN]  = 1;            // Character-at-a-time
  newterm.c_cc[VTIME] = 0;            // Do not blocking

  tcsetattr(STDIN_FILENO, TCSANOW, &newterm);

  write(STDOUT_FILENO, "Continue (Y/N)? ", 16);
  read(STDIN_FILENO, &key, 1);

  if (key == 'Y')
    {
      write(STDOUT_FILENO, "\nContinuing\n", 12);
    }
  else
    {
      write(STDOUT_FILENO, "\nStopping  \n", 12);
    }

  tcsetattr(STDIN_FILENO, TCSANOW, &oldterm);
}
        

#include <unistd.h>

This function is equivalent to the tty command.