The c_cc array in struct termios maps symbolic index names to the actual byte values that trigger special terminal behaviors. Think of it as a lookup table: “what character value causes ERASE to happen?” → c_cc[VERASE].

You can completely disable a special character by setting its c_cc entry to the VDISABLE value. This is a special byte value (usually 0xFF = 255) that means “this character is disabled — don’t treat any byte as this special character.”

The portable way to get the VDISABLE value for the current system is to call:

long vdisable = fpathconf(fd, _PC_VDISABLE);

fpathconf() queries file-system or terminal configuration values. The constant _PC_VDISABLE asks “what byte value disables a special character on this terminal?”

This is a program from TLPI (The Linux Programming Interface) that demonstrates how to change the INTR special character at runtime. Let’s walk through it step by step:

/* new_intr.c — Change or disable the INTR (interrupt) character
 *
 * Usage:
 *   ./new_intr          -- disable INTR completely
 *   ./new_intr 65       -- set INTR to decimal 65 ('A') — Ctrl+A = SIGINT
 *   ./new_intr 0x41     -- set INTR to hex 0x41 (also 'A')
 *   ./new_intr A        -- set INTR to the literal character 'A'
 */

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

int main(int argc, char *argv[])
{
    struct termios tp;
    int intrChar;

    /* ---- Step 1: Determine the new INTR character ---- */

    if (argc == 1) {
        /*
         * No argument: disable INTR completely.
         * fpathconf with _PC_VDISABLE returns the "disable" byte value.
         * On Linux this is typically 0 or 0xFF.
         */
        intrChar = fpathconf(STDIN_FILENO, _PC_VDISABLE);
        if (intrChar == -1) {
            perror("fpathconf: Couldn't determine VDISABLE");
            exit(EXIT_FAILURE);
        }

    } else if (isdigit((unsigned char) argv[1][0])) {
        /*
         * Argument starts with a digit: treat it as a number.
         * strtoul with base 0 auto-detects: 0x prefix = hex, 0 prefix = octal,
         * no prefix = decimal.
         * Example: "65" -> 65, "0x41" -> 65, "0101" -> 65 (all = 'A')
         */
        intrChar = strtoul(argv[1], NULL, 0);

    } else {
        /*
         * Argument is a literal character: use its ASCII value.
         * Example: "./new_intr A" -> intrChar = 65
         * Example: "./new_intr ^" -> intrChar = 94
         */
        intrChar = argv[1][0];
    }

    /* ---- Step 2: Read current terminal attributes ---- */
    if (tcgetattr(STDIN_FILENO, &tp) == -1) {
        perror("tcgetattr");
        exit(EXIT_FAILURE);
    }

    /* ---- Step 3: Change the VINTR entry in c_cc ---- */
    /*
     * c_cc[VINTR] holds the byte value that causes SIGINT.
     * Setting it to intrChar changes (or disables) the INTR character.
     */
    tp.c_cc[VINTR] = intrChar;

    /* ---- Step 4: Push the modified settings back ---- */
    /*
     * TCSAFLUSH: wait for pending output to be written, discard unread input,
     * then apply new settings. Best choice for input-related changes.
     */
    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &tp) == -1) {
        perror("tcsetattr");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}

Compile and test:

gcc -o new_intr new_intr.c

# Disable INTR (Ctrl+C won't send SIGINT anymore)
./new_intr

# Change INTR to Ctrl+A (ASCII 1)
./new_intr 1

# Change INTR to the letter 'A' (ASCII 65 = 0x41)
./new_intr A
./new_intr 65
./new_intr 0x41

# Verify: check current INTR character using stty
stty -a | grep intr

stty intr ^C

The new_intr.c program uses strtoul(argv[1], NULL, 0). The base = 0 is important — it lets the function auto-detect the number format:

This makes the program flexible — users can specify the INTR character value in whatever numeric format they prefer.

In noncanonical mode (ICANON OFF), the special c_cc entries VMIN and VTIME control when read() returns:

/* Example: noncanonical with 0.5 second timeout */
struct termios tp;
tcgetattr(fd, &tp);

tp.c_lflag &= ~ICANON;
tp.c_cc[VMIN]  = 0;   /* Return even if no bytes */
tp.c_cc[VTIME] = 5;   /* 5 * 0.1 = 0.5 seconds timeout */

tcsetattr(fd, TCSAFLUSH, &tp);

char c;
int n = read(fd, &c, 1);
if (n == 0) {
    printf("Timeout: no input in 0.5 seconds\n");
} else if (n == 1) {
    printf("Got char: 0x%02X\n", (unsigned char)c);
}

The stty command is the command-line tool for viewing and modifying termios settings. It is essential for debugging and for disabling flags before testing programs that manipulate them.

# Show all current terminal settings in detail
stty -a

# Show raw termios values (numeric)
stty -g

# Disable ECHO (hide typed characters)
stty -echo

# Re-enable ECHO
stty echo

# Disable canonical mode (raw character input)
stty -icanon

# Restore canonical mode
stty icanon

# Change INTR character to Ctrl+A (^A)
stty intr ^A

# Restore INTR to default Ctrl+C
stty intr ^C

# Disable Ctrl+S / Ctrl+Q (IXON)
stty -ixon

# Save current settings and restore later
saved=$(stty -g)
stty raw -echo
# ... do your raw terminal work ...
stty $saved