What happens: read() checks if any data is available right now. If data is there, it returns immediately with however many bytes are available (up to the count requested). If no data is available at all, read() returns 0 immediately — it does not wait.

Similar to O_NONBLOCK? Both avoid blocking when no data is available. Key difference: with O_NONBLOCK, read() returns -1 (EAGAIN) when no data. With MIN=0/TIME=0, read() returns 0. They behave differently on end-of-file too.

Typical use: Checking if input is available without blocking — useful in event loops that also monitor other file descriptors.

/* Case 1: Polling read - check for input without blocking */
tp.c_lflag &= ~ICANON;
tp.c_cc[VMIN]  = 0;
tp.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSAFLUSH, &tp);

char ch;
ssize_t n = read(STDIN_FILENO, &ch, 1);
if (n > 0)
    printf("Got char: %c\n", ch);
else if (n == 0)
    printf("No input available right now\n");
/* Unlike O_NONBLOCK: n == 0 means "no data", not EAGAIN */

What happens: read() blocks until at least MIN bytes are available. It then returns the lesser of MIN bytes or the number of bytes requested. It can block indefinitely — there is no timeout.

Typical use: Applications like less, simple terminal games, and any program that needs single-keypress responses. Setting MIN=1, TIME=0 is the most common noncanonical configuration — it gives you exactly one character per read(), blocking until a key is pressed.

/* Case 2: Blocking read, single key at a time (like 'less') */
tp.c_lflag &= ~(ICANON | ECHO);
tp.c_cc[VMIN]  = 1;   /* Need at least 1 byte */
tp.c_cc[VTIME] = 0;   /* No timeout - wait forever if needed */
tcsetattr(STDIN_FILENO, TCSAFLUSH, &tp);

char ch;
printf("Press any key (q to quit):\n");
while (1) {
    read(STDIN_FILENO, &ch, 1);  /* Blocks until a key is pressed */
    printf("Key: 0x%02X ('%c')\n", (unsigned char)ch,
           (ch >= 32 && ch < 127) ? ch : '.');
    if (ch == 'q') break;
    /* No CPU wasted here - process sleeps until keystroke */
}

What happens: A timer starts as soon as read() is called. read() returns as soon as the first byte arrives, OR when the timer expires (whichever comes first). If the timer expires with no data, read() returns 0. At least 1 byte is returned if data arrives before timeout.

Typical use: Talking to serial devices (modems, microcontrollers). Program sends a command to the device, then calls read() with a timeout. If the device responds, great. If it doesn’t within TIME tenths of a second, read() returns 0 and you can handle the timeout gracefully instead of hanging forever.

/* Case 3: Read with timeout - useful for serial device communication */
#include <termios.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>

int read_with_timeout(int fd, char *buf, int maxlen, int timeout_tenths)
{
    struct termios tp, save;
    tcgetattr(fd, &tp);
    save = tp;

    tp.c_lflag &= ~ICANON;
    tp.c_cc[VMIN]  = 0;                 /* MIN=0: return on first byte OR timeout */
    tp.c_cc[VTIME] = timeout_tenths;    /* TIME in tenths of second */
    tcsetattr(fd, TCSAFLUSH, &tp);

    /* Send command to device (example) */
    write(fd, "AT\r\n", 4);

    /* Wait for response */
    ssize_t n = read(fd, buf, maxlen);

    tcsetattr(fd, TCSANOW, &save);

    if (n == 0) {
        printf("Timeout: device did not respond within %.1f seconds\n",
               timeout_tenths / 10.0);
        return -1;
    }
    return (int)n;
}

int main(void)
{
    char buf[256];
    int fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY);
    if (fd < 0) { perror("open"); return 1; }

    /* 2 second timeout (20 tenths) */
    int n = read_with_timeout(fd, buf, sizeof(buf), 20);
    if (n > 0) {
        buf[n] = '\0';
        printf("Device responded: %s\n", buf);
    }
    return 0;
}

What happens: The timer does NOT start when read() is called. It starts only after the first byte arrives. After each subsequent byte, the timer is reset. read() returns when either MIN bytes have been read, or when TIME tenths of a second pass between successive bytes. At least 1 byte is always returned (since the timer starts only after the first byte). read() can block indefinitely waiting for the first byte.

Typical use: Handling terminal escape sequences. When you press the left-arrow key on most terminals, it sends a 3-byte sequence: ESC (0x1B), then ‘[‘, then ‘D’. These three bytes arrive nearly simultaneously. Case 4 lets you read them together as one unit by waiting for a brief inter-byte gap rather than dealing with one byte at a time.

/* Case 4: Interbyte timeout - reading escape sequences from terminal */
#include <termios.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

void setup_interbyte_timeout(int fd)
{
    struct termios tp;
    tcgetattr(fd, &tp);

    tp.c_lflag &= ~(ICANON | ECHO);
    tp.c_cc[VMIN]  = 1;   /* Need at least 1 byte to start */
    tp.c_cc[VTIME] = 1;   /* 0.1s interbyte gap triggers return */
    tcsetattr(fd, TCSAFLUSH, &tp);
}

int main(void)
{
    struct termios save;
    tcgetattr(STDIN_FILENO, &save);

    setup_interbyte_timeout(STDIN_FILENO);

    printf("Press keys (Ctrl+C to quit):\n");

    unsigned char buf[16];
    ssize_t n;

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

        for (ssize_t i = 0; i < n; i++)
            printf("0x%02X ", buf[i]);

        /* Identify common escape sequences */
        if (n == 3 && buf[0] == 0x1B && buf[1] == '[') {
            switch (buf[2]) {
                case 'A': printf(" [UP arrow]");    break;
                case 'B': printf(" [DOWN arrow]");  break;
                case 'C': printf(" [RIGHT arrow]"); break;
                case 'D': printf(" [LEFT arrow]");  break;
            }
        } else if (n == 1 && buf[0] == 0x1B) {
            printf(" [ESC key]");
        } else if (n == 1) {
            printf(" ['%c']", (buf[0] >= 32 && buf[0] < 127) ? buf[0] : '?');
        }
        printf("\n");

        if (n == 1 && buf[0] == 3)  /* Ctrl+C = 0x03 */
            break;
    }

    tcsetattr(STDIN_FILENO, TCSANOW, &save);
    return 0;
}
/* Output example:
   Press LEFT arrow: Read 3 bytes: 0x1B 0x5B 0x44 [LEFT arrow]
   Press 'a':        Read 1 bytes: 0x61 ['a']
   Press ESC:        Read 1 bytes: 0x1B [ESC key]
*/