ECHO — The Master Echo Switch

When ECHO is ON, every character you type is immediately sent back to the terminal screen. This is what makes your typing visible. Without it, you’d be typing blind.

Turning off ECHO is exactly how password input works — the terminal driver stops echoing characters while getpass() or similar functions are running. The characters still reach the program; they just aren’t shown on screen.

ECHOCTL — Making Control Characters Readable

Control characters (ASCII codes < 32, plus DEL = 127) are normally invisible or cause side effects if echoed literally. ECHOCTL causes them to be displayed as ^X notation:

ECHOE — Visual Erase (Backspace)

In canonical mode, when you press Backspace (the ERASE character), two things can happen:

• If ECHOE is ON: the driver sends backspace-space-backspace to the terminal. This visually erases the character by moving back, writing a space over it, then moving back again.
• If ECHOE is OFF: the ERASE character is still functional (deletes from buffer) but visually it shows something like ^? instead of actually erasing the character on screen.

ECHOK / ECHOKE — Kill Line (Ctrl+U)

When you press Ctrl+U (the KILL character) in canonical mode, the entire current line is discarded. The flags ECHOK and ECHOKE control how this is shown:

ECHOPRT — For Hardcopy (Paper) Terminals

This was designed for teletype and paper-based terminals where you couldn’t erase what was already printed. When ECHOPRT is ON and you press Backspace, the deleted character appears between \ and /:

/* Typing "hello" then pressing Backspace twice with ECHOPRT ON: */
hello\o/
/* The \o/ shows "o" was deleted, then pressing another backspace: */
hello\o\l//
/* Each deleted character is shown in this notation */

This is essentially useless on modern screen terminals.

When ISIG is ON (default), pressing certain key combinations causes the terminal driver to send a signal to the foreground process group rather than passing the character to the program:

When ISIG is OFF, these key combinations are treated as regular characters and passed to the program’s read(). This is needed when implementing interactive programs like text editors (vi, emacs) or terminal emulators that want to handle Ctrl+C themselves.

A BREAK condition is a special serial-line event — not a regular character. It is generated when the serial line is held in a “spacing” state (logical 0) for longer than the time it takes to send one full byte. Typically 0.25 to 0.5 seconds.

On old physical terminals, there was a physical BREAK key. On virtual consoles, you can generate a BREAK by pressing Ctrl+Break.

On historical multi-speed serial systems, the BREAK key told the remote host to try a different baud rate. The user would press BREAK repeatedly until a valid login prompt appeared at a baud rate the terminal could handle.

This is one of the most important flags. It controls how input is delivered to your program:

When TOSTOP is ON and a background process tries to write to the terminal, the terminal driver sends SIGTTOU to that process, which stops it. The user must then bring the process to the foreground (fg) for it to write.

This is part of the job control system. By default TOSTOP is OFF, meaning background processes can freely write to the terminal — which can cause jumbled output if a background process outputs text while you’re typing.

This is the most common real-world use of c_lflag manipulation — disabling echo to read a password securely.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

#define MAX_PASS 128

/*
 * read_password: reads from stdin with echo disabled.
 * buf: caller-supplied buffer
 * len: size of buffer
 * Returns: number of characters read (excluding NUL)
 */
int read_password(char *buf, size_t len)
{
    struct termios orig, noecho;

    /* Save original settings */
    if (tcgetattr(STDIN_FILENO, &orig) != 0) {
        perror("tcgetattr");
        return -1;
    }

    /* Copy and disable ECHO */
    noecho = orig;
    noecho.c_lflag &= ~ECHO;       /* Turn off echo */
    noecho.c_lflag &= ~ECHONL;     /* Don't echo newline either */

    /* Apply no-echo settings */
    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &noecho) != 0) {
        perror("tcsetattr");
        return -1;
    }

    printf("Enter password: ");
    fflush(stdout);

    /* Read the password (user presses Enter, canonical mode still active) */
    if (fgets(buf, len, stdin) == NULL) {
        /* Restore before returning on error */
        tcsetattr(STDIN_FILENO, TCSANOW, &orig);
        return -1;
    }

    /* Remove trailing newline */
    int n = strlen(buf);
    if (n > 0 && buf[n - 1] == '\n') {
        buf[--n] = '\0';
    }

    /* Print newline since we didn't echo it */
    printf("\n");

    /* Restore original echo settings */
    if (tcsetattr(STDIN_FILENO, TCSANOW, &orig) != 0) {
        perror("tcsetattr restore");
    }

    return n;
}

int main(void)
{
    char password[MAX_PASS];

    int n = read_password(password, sizeof(password));
    if (n < 0) {
        fprintf(stderr, "Failed to read password\n");
        return 1;
    }

    /* In real code, you would verify the password here, not print it! */
    printf("Password length: %d characters\n", n);

    /* Securely clear the password from memory when done */
    memset(password, 0, sizeof(password));

    return 0;
}

Raw mode is used by terminal applications like vim, less, and games. In raw mode, every keypress is immediately available to the program without waiting for Enter.

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

struct termios saved_termios;

void enable_raw_mode(void)
{
    struct termios raw;

    /* Save current settings for restoration later */
    if (tcgetattr(STDIN_FILENO, &saved_termios) != 0) {
        perror("tcgetattr");
        exit(1);
    }

    raw = saved_termios;

    /* c_lflag: disable canonical mode, echo, signal generation */
    raw.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ISIG | IEXTEN);

    /* c_iflag: disable CR/NL translation, flow control */
    raw.c_iflag &= ~(ICRNL | IXON | IXOFF | INLCR);

    /* c_oflag: disable output post-processing */
    raw.c_oflag &= ~OPOST;

    /* Noncanonical read: return after each single character */
    raw.c_cc[VMIN]  = 1;    /* Read returns as soon as 1 byte is available */
    raw.c_cc[VTIME] = 0;    /* No timeout */

    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) != 0) {
        perror("tcsetattr");
        exit(1);
    }
}

void disable_raw_mode(void)
{
    /* Restore saved settings */
    if (tcsetattr(STDIN_FILENO, TCSANOW, &saved_termios) != 0) {
        perror("tcsetattr restore");
    }
}

int main(void)
{
    enable_raw_mode();

    printf("Raw mode ON. Type characters (press 'q' to quit):\r\n");

    char c;
    while (1) {
        /* Each read() returns immediately after 1 character (VMIN=1, VTIME=0) */
        if (read(STDIN_FILENO, &c, 1) <= 0)
            break;

        /* Print hex value of each character pressed */
        printf("Key: 0x%02X  (%c)\r\n", (unsigned char)c,
               (c >= 32 && c < 127) ? c : '.');

        if (c == 'q')
            break;
    }

    disable_raw_mode();
    printf("\nRaw mode OFF. Back to normal.\n");
    return 0;
}