Here is how data flows between your keyboard, the terminal driver, and your program:

The c_cflag handles serial-line level things (baud rate, parity), and c_lflag sits above all of them managing line discipline behavior (echo, canonical mode, etc.).

These flags control what happens to characters after they arrive at the terminal driver from the keyboard but before they reach your program. Think of it as pre-processing for input.

ICRNL — CR to NL Mapping

When you press Enter on a keyboard, the terminal physically sends a Carriage Return (CR, ASCII 13, \r). But Unix programs expect a Newline (NL, ASCII 10, \n) to mark end-of-line. When ICRNL is ON (default), the terminal driver silently converts every incoming CR into NL. This is why Unix programs work normally even though the keyboard hardware sends CR.

IXON — Output Flow Control (Ctrl+S / Ctrl+Q)

When IXON is set (default ON), the terminal supports software flow control for output. If output is scrolling too fast:

• Press Ctrl+S → sends STOP character → terminal pauses output
• Press Ctrl+Q → sends START character → terminal resumes output

This is a pure software mechanism. The characters are not passed to the program — the driver handles them internally.

ISTRIP — Strip 8th Bit

Old 7-bit terminals could not send or receive 8-bit characters. When ISTRIP is ON, the driver sets the 8th bit of every input character to 0 (strips it). Modern terminals are 8-bit, so this is usually OFF.

INPCK / IGNPAR / PARMRK — Parity Handling

Parity is an error-detection mechanism used in serial communications. These three flags work together:

Below is a complete C example showing how to read current terminal input flags, disable CR-to-NL mapping (ICRNL), and restore original settings on exit.

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

int main(void)
{
    struct termios orig, modified;

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

    /* Step 2: Copy original and modify c_iflag */
    modified = orig;

    /*
     * Disable ICRNL: stop the driver from mapping CR (\r) to NL (\n).
     * After this, pressing Enter sends \r to the program, not \n.
     */
    modified.c_iflag &= ~ICRNL;

    /*
     * Also disable IXON: stop Ctrl+S / Ctrl+Q from working.
     * Now those keystrokes will be passed to the program.
     */
    modified.c_iflag &= ~IXON;

    /* Step 3: Apply the modified settings (take effect after output flushed) */
    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &modified) == -1) {
        perror("tcsetattr");
        exit(EXIT_FAILURE);
    }

    printf("ICRNL disabled. Enter sends CR (\\r) now.\n");
    printf("Press any key (Ctrl+C to test if IXON is really off):\n");

    char buf[10];
    ssize_t n = read(STDIN_FILENO, buf, sizeof(buf));
    if (n > 0) {
        printf("Read %zd bytes. First byte = 0x%02X\n", n, (unsigned char)buf[0]);
        /* 0x0D = CR (\r), 0x0A = NL (\n) */
    }

    /* Step 4: Always restore original settings before exit */
    if (tcsetattr(STDIN_FILENO, TCSANOW, &orig) == -1) {
        perror("tcsetattr restore");
    }

    return 0;
}

Compile and run:

gcc -o iflag_demo iflag_demo.c
./iflag_demo

The second argument to tcsetattr() controls when the new settings take effect: