In noncanonical mode the c_cc array has two important slots: c_cc[VMIN] (minimum bytes before read returns) and c_cc[VTIME] (timeout in tenths of a second). In canonical mode the same array holds c_cc[VEOF] (the EOF character, default Ctrl-D) and c_cc[VEOL] (additional line-delimiter character).

The problem: SUSv3 (the POSIX standard) allows VMIN and VEOF to share the same array index, and similarly VTIME and VEOL may share an index. On Linux these constants have distinct values, so there is no overlap. But on some older or embedded UNIX systems they are the same index.

Why does this matter in practice? Suppose your program:

1. Reads the original terminal settings with tcgetattr().
2. Switches to noncanonical mode and sets c_cc[VMIN] = 1.
3. Later tries to return to canonical mode by toggling the ICANON flag.

On a system where VMIN == VEOF (same constant value), step 2 silently overwrote the EOF character with the value 1 (ASCII SOH, not Ctrl-D). When canonical mode is restored in step 3, the user presses Ctrl-D and nothing happens — EOF is now value 1, which is nearly impossible to type.

The portable, correct solution:

/* Save BEFORE switching to noncanonical */
struct termios saved, t;
tcgetattr(STDIN_FILENO, &saved);   /* snapshot of canonical settings */

/* Switch to noncanonical */
tcgetattr(STDIN_FILENO, &t);
t.c_lflag &= ~(ICANON | ECHO);
t.c_cc[VMIN]  = 1;
t.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSAFLUSH, &t);

/* ... do work ... */

/* Restore using the SAVED structure, not by fiddling flags */
tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved);  /* safe on all UNIX */

The saved structure still has the original VEOF = 0x04 (Ctrl-D), so restoring it puts the terminal back exactly as it was.

Seventh Edition UNIX (1979) and the early BSD terminal driver defined three named modes. Although modern POSIX replaced the single-bit RAW/CBREAK switches with the full termios structure, the concepts remain central to terminal programming. Every interactive application — from vi to a BLE configuration shell — maps to one of these modes.

⚠ Cbreak echoing: typically disabled by the application (e.g. password input), but the mode itself does not mandate it.

Cooked mode is simply canonical mode with all the default special-character processing left enabled. This is what you get on a fresh terminal — the normal shell prompt experience.

What is active in Cooked mode:

• ICANON — input collected line by line; backspace erases.
• ECHO — typed characters echoed to screen.
• ISIG — Ctrl-C sends SIGINT, Ctrl-Z sends SIGTSTP, Ctrl-\ sends SIGQUIT.
• ICRNL — incoming CR (0x0D from Enter key) mapped to NL (0x0A).
• OPOST — output processing: NL expanded to CR+NL for display.
• Special chars — EOF (Ctrl-D), EOL all work normally.

When to use: Normal shell, simple line-input programs (scanf, fgets). The kernel does all the work for you.

Cbreak mode sits between Cooked and Raw. The application receives each keystroke immediately (no waiting for Enter), but signals (Ctrl-C, Ctrl-Z) and some I/O transformations still work.

What is ON in Cbreak:

• ISIG — signal-generating characters still active (Ctrl-C, Ctrl-Z, Ctrl-\).
• Input/output transformations (ICRNL, OPOST) can still be configured independently.

What is OFF in Cbreak:

• ICANON — no line buffering, no backspace editing.
• ECHO — usually disabled (application echoes manually if needed).
• Special chars beyond signal chars (VEOF, VEOL, VSTART, VSTOP, etc.) are ignored.

Classic use cases:

• less, more — page through output one key at a time, Ctrl-C still quits.
• vim command mode — immediate response to h/j/k/l, but Ctrl-Z suspends as expected.
• Any full-screen TUI app using ncurses: the library’s cbreak() function sets this mode.

Key flag to set: disable ICANON and ECHO, keep ISIG.

t.c_lflag &= ~(ICANON | ECHO);   /* OFF: line-by-line, echo */
t.c_lflag |=  ISIG;              /* ON:  Ctrl-C/Z/\ still work */
t.c_iflag &= ~ICRNL;            /* optional: stop CR→NL mapping */
t.c_cc[VMIN]  = 1;              /* return after 1 character */
t.c_cc[VTIME] = 0;              /* block indefinitely */

Raw mode is the opposite extreme of Cooked. The terminal driver becomes a transparent pipe: every byte typed reaches your program unchanged, and every byte your program writes goes to the terminal unchanged.

Everything that gets turned OFF in Raw mode:

Raw mode is used for:

• Serial line forwarding / pass-through (modem communication).
• Full-screen editors (vim itself uses raw for its internal I/O layer).
• Embedded firmware update tools — every byte matters, no transformations allowed.
• BLE HCI sniffer tools that read raw bytes from a UART-attached dongle.
• Binary protocol terminals (XMODEM, ZMODEM file transfer over serial).

Applications that use the ncurses library do not need to manipulate termios directly. ncurses provides wrapper functions that handle all the flag setting for you:

#include <ncurses.h>

int main(void)
{
    initscr();        /* initialise ncurses, opens terminal */
    cbreak();         /* equivalent to Cbreak mode: char-by-char, signals kept */
    /* OR */
    raw();            /* equivalent to Raw mode: all processing off */

    noecho();         /* turn off echo (ncurses manages display itself) */
    keypad(stdscr, TRUE);  /* enable F-keys, arrow keys */

    int ch = getch(); /* blocks until one character typed */
    endwin();         /* restore terminal */
    return 0;
}

Behind the scenes cbreak() calls tcsetattr() after clearing ICANON and ECHO while keeping ISIG, just like our manual implementation in Part 6B. raw() additionally clears ISIG and all input processing flags.