Canonical mode is enabled by setting the ICANON flag in c_lflag. When active, here is what happens between you pressing a key and the program receiving it:

A “line” in canonical mode ends when one of five possible delimiters is received. Understanding each is important because they behave slightly differently:

/* Demonstrating EOF behavior in canonical mode */
#include <stdio.h>
#include <unistd.h>

int main(void)
{
    char buf[100];
    ssize_t n;

    while ((n = read(STDIN_FILENO, buf, sizeof(buf))) > 0) {
        printf("Read %zd bytes: ", n);
        write(STDOUT_FILENO, buf, n);
    }

    if (n == 0)
        printf("EOF received (Ctrl+D on empty line)\n");

    return 0;
}
/* Run: ./prog
   Type: hello<Enter>   → Read 6 bytes: hello\n
   Type: <Ctrl+D>       → EOF received
*/

One of the most useful features of canonical mode is that the user can edit the current line before pressing Enter. The terminal driver handles these editing operations, so your program never sees the deleted or corrected characters — it only gets the final, edited line.

These editing characters are stored in the c_cc[] array and are enabled by the ICANON flag (with some also requiring IEXTEN):

/* Customize the ERASE character to Delete key (0x7F) 
   and KILL character to Ctrl+X (0x18) */
#include <termios.h>
#include <unistd.h>

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

tp.c_cc[VERASE] = 0x7F;   /* Delete key */
tp.c_cc[VKILL]  = 0x18;   /* Ctrl+X */

tcsetattr(STDIN_FILENO, TCSAFLUSH, &tp);

In canonical mode, a read() call on a terminal blocks until a complete line is available in the line buffer. Once a line delimiter is received, the line becomes available and read() returns.

There are three ways a canonical-mode read() can return:

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

int main(void)
{
    char buf[20];  /* Deliberately small to show partial reads */
    ssize_t n;

    /* Read up to 5 bytes at a time */
    while ((n = read(STDIN_FILENO, buf, 5)) > 0) {
        printf("read() returned %zd bytes: [", n);
        for (ssize_t i = 0; i < n; i++) {
            if (buf[i] == '\n')
                printf("\\n");
            else
                printf("%c", buf[i]);
        }
        printf("]\n");
    }

    return 0;
}
/* Example:
   Type: "hello world" then Enter
   Output:
     read() returned 5 bytes: [hello]
     read() returned 5 bytes: [ worl]
     read() returned 2 bytes: [d\n]
   The 12-byte line was split across three 5-byte read() calls.
*/

Some key combinations in canonical mode generate signals. The terminal driver also flushes queues when these signals are generated — unless NOFLSH is set (covered in Part 1).

/* Demonstrate: even with SIGINT ignored, Ctrl+C flushes queues
   unless NOFLSH is set */

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

int main(void)
{
    struct termios tp;

    /* Ignore SIGINT */
    signal(SIGINT, SIG_IGN);

    /* Without NOFLSH: Ctrl+C still flushes queues (default) */
    tcgetattr(STDIN_FILENO, &tp);

    /* Option A: allow flush (default - don't set NOFLSH) */

    /* Option B: prevent flush */
    tp.c_lflag |= NOFLSH;
    tcsetattr(STDIN_FILENO, TCSANOW, &tp);

    printf("Type something, then Ctrl+C, then Enter:\n");
    char buf[100];
    if (fgets(buf, sizeof(buf), stdin))
        printf("Got: %s\n", buf);  /* With NOFLSH: pre-Ctrl+C text survives */

    return 0;
}

This example reads lines from the terminal in canonical mode, counts them, and shows how partial reads accumulate into complete lines:

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

#define MAX_LINE 1024

/* Reads exactly one full line from terminal in canonical mode.
   Returns number of bytes read (including \n), or -1 on error/EOF. */
int read_canonical_line(int fd, char *buf, int maxlen)
{
    int total = 0;
    ssize_t n;

    /*
     * In canonical mode, once a line is available, read() will return
     * the complete line (or up to maxlen-1 bytes of it).
     * We read in a loop to handle partial reads (when maxlen is small).
     */
    while (total < maxlen - 1) {
        n = read(fd, buf + total, 1);   /* Read one byte at a time */
        if (n <= 0) {
            if (total == 0) return -1;  /* EOF or error before any data */
            break;
        }
        total += n;
        if (buf[total - 1] == '\n')     /* Got newline = end of canonical line */
            break;
    }

    buf[total] = '\0';
    return total;
}

int main(void)
{
    char line[MAX_LINE];
    int linenum = 0;
    int n;

    printf("Type lines (Ctrl+D to stop):\n");

    while ((n = read_canonical_line(STDIN_FILENO, line, MAX_LINE)) > 0) {
        linenum++;

        /* Strip trailing newline for display */
        int len = strlen(line);
        if (len > 0 && line[len-1] == '\n')
            line[len-1] = '\0';

        printf("Line %d (%d chars): \"%s\"\n", linenum, len - 1, line);
    }

    printf("Total lines read: %d\n", linenum);
    return 0;
}

You may see two terms used for the same thing — here is how they relate: