All terminal settings live in a struct termios. Here is what it looks like:

#include <termios.h>

struct termios {
    tcflag_t  c_iflag;   /* Input flags    - control how input arrives */
    tcflag_t  c_oflag;   /* Output flags   - control how output goes out */
    tcflag_t  c_cflag;   /* Control flags  - baud rate, parity bits etc */
    tcflag_t  c_lflag;   /* Local flags    - echo, canonical mode etc */
    cc_t      c_cc[NCCS];/* Special characters - EOF, INTR, ERASE ... */
};

In this part, most flags we discuss are c_lflag (local flags), but we also touch c_oflag (OPOST) and c_iflag (parity-related flags).

Think of it this way. Imagine you are chatting with someone through a window that has a mail slot. With ICANON set, the window only opens once you have written an entire sentence and pressed Enter — the program gets the whole line. With ICANON clear, every single letter you write slips through the slot instantly — the program sees it right away.

When ICANON is set, the following special characters also become active: EOF, EOL, EOL2, ERASE, LNEXT, KILL, REPRINT, WERASE. These let you delete words, kill the whole line, reprint it etc.

/* Turning ICANON off programmatically */
#include <termios.h>
#include <unistd.h>

struct termios t;
tcgetattr(STDIN_FILENO, &t);

t.c_lflag &= ~ICANON;   /* Clear ICANON bit - go noncanonical */
t.c_cc[VMIN]  = 1;      /* Read at least 1 byte at a time */
t.c_cc[VTIME] = 0;      /* No timeout */

tcsetattr(STDIN_FILENO, TCSANOW, &t);

IEXTEN is like an “extras” switch. Some special characters only work when both ICANON and IEXTEN are turned on together. If IEXTEN is off, these characters lose their special meaning.

/* Check if IEXTEN is set */
struct termios t;
tcgetattr(STDIN_FILENO, &t);

if (t.c_lflag & IEXTEN)
    printf("IEXTEN is ON - extended processing active\n");
else
    printf("IEXTEN is OFF\n");

The input queue is a small buffer where keystrokes wait to be read by your program. If you type very fast and the program is slow to read, this buffer fills up. On Linux, IMAXBEL has no actual effect — the bell always rings in this situation regardless of the flag’s value.

UTF-8 characters like “é”, “ñ”, “中” are stored as 2–4 bytes. Without IUTF8, pressing Backspace might delete only one byte of a multi-byte character, leaving broken bytes in the input buffer. With IUTF8, the terminal driver understands that one character may be multiple bytes, so Backspace deletes the whole character.

/* Enable IUTF8 for correct multi-byte character handling */
struct termios t;
tcgetattr(STDIN_FILENO, &t);

t.c_lflag |= IUTF8;  /* Set IUTF8 bit */

tcsetattr(STDIN_FILENO, TCSANOW, &t);

Think of the input queue as a pipe. When a signal like SIGINT arrives (you pressed Ctrl+C), Linux normally empties the pipe — throwing away any data already typed but not yet read. This makes sense for interactive shells but may cause data loss in certain applications. NOFLSH tells Linux: “Do not throw away queued data when a signal arrives.”

Signals that trigger this flush: INTR (Ctrl+C → SIGINT), QUIT (Ctrl+\ → SIGQUIT), SUSP (Ctrl+Z → SIGTSTP). This flush happens even if the application has set the signal to be ignored.

/* Prevent queue flush on signals */
struct termios t;
tcgetattr(STDIN_FILENO, &t);

t.c_lflag |= NOFLSH;  /* Set NOFLSH - queues survive signals */

tcsetattr(STDIN_FILENO, TCSANOW, &t);

/* Now even if user presses Ctrl+C, buffered input is not lost */

Output postprocessing means the terminal driver can automatically transform your output. The most common example: when your program writes \n (newline), the terminal driver translates it to \r\n (carriage return + newline) because that is what hardware terminals need to move to the start of the next line.

/* Disable output postprocessing - raw output */
struct termios t;
tcgetattr(STDOUT_FILENO, &t);

t.c_oflag &= ~OPOST;  /* Turn off ALL output processing */

tcsetattr(STDOUT_FILENO, TCSANOW, &t);

/* Now you must write \r\n manually for proper line movement */
write(STDOUT_FILENO, "Hello\r\n", 7);

Parity is an error-detection mechanism used in serial communication. A “parity bit” is added to each character to help detect transmission errors. These five flags control whether parity is generated, how it is checked, and what happens when a parity error is detected.

/* Example: Enable even parity on a serial port */
#include <termios.h>
#include <fcntl.h>
#include <unistd.h>

int fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY);

struct termios t;
tcgetattr(fd, &t);

/* Enable parity generation + checking */
t.c_cflag |= PARENB;   /* Enable parity */
t.c_cflag &= ~PARODD;  /* Even parity (PARODD cleared) */

/* Enable input parity checking */
t.c_iflag |= INPCK;

/* If parity error: mark with 0377+0 prefix */
t.c_iflag |= PARMRK;
t.c_iflag &= ~IGNPAR;  /* Do not ignore - we want to detect errors */

tcsetattr(fd, TCSANOW, &t);