c_oflag controls how characters are processed after your program calls write() but before they appear on the terminal screen. The master switch for all output processing is the OPOST flag.

This is one of the most important output flags to understand. On a physical terminal, a Newline (\n) only moves the cursor down one line — it does NOT move it back to column 0. A Carriage Return (\r) is what moves the cursor to column 0.

So to go to the start of the next line, a terminal needs to receive CR+NL (\r\n). When ONLCR is ON (the default), the terminal driver automatically converts every \n your program writes into \r\n going out to the screen.

If you turn off ONLCR, your output will look staircase-shaped because each \n only moves down, not back to column 0:

/* What you see with ONLCR OFF: */
Line one
         Line two
                  Line three
/* Each line starts where the previous ended (only moved down, not back to col 0) */

The TABDLY flag is a mask that can be set to TAB0, TAB1, TAB2, or TAB3. The only practically useful value on Linux is TAB3:

• TAB0 (default) — no processing, tab characters are sent as-is
• TAB3 — expand each tab character to the appropriate number of spaces (up to 8) based on the current column position

/* Enable tab expansion in output */
struct termios tp;
tcgetattr(STDOUT_FILENO, &tp);

/* Set TABDLY field to TAB3 (expand tabs to spaces) */
tp.c_oflag &= ~TABDLY;       /* Clear current TABDLY bits */
tp.c_oflag |= TAB3;          /* Set TAB3 */

tcsetattr(STDOUT_FILENO, TCSADRAIN, &tp);
/* Now every \t written will become spaces aligned to 8-column tab stops */

c_cflag controls the low-level serial hardware settings. On modern systems (virtual consoles, network terminals) most of these have no real effect, but they are critical for real serial port (UART) programming — common in embedded systems work.

In embedded systems, serial (UART) communication is very common. The c_cflag settings directly map to how the UART hardware frames each byte on the wire:

Flow Control: Software vs Hardware

Hardware flow control (CRTSCTS) is more reliable because it doesn’t occupy any data bandwidth. It is the standard choice in embedded serial communication between microcontrollers and Linux hosts.

This is a complete example of opening a serial port and setting it up for 8N1 at 115200 baud — the most common configuration for embedded Linux serial communication.

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

int open_serial_port(const char *device)
{
    int fd;
    struct termios tty;

    /* Open the serial port */
    fd = open(device, O_RDWR | O_NOCTTY | O_SYNC);
    if (fd < 0) {
        perror("open serial port");
        return -1;
    }

    /* Read current settings */
    if (tcgetattr(fd, &tty) != 0) {
        perror("tcgetattr");
        close(fd);
        return -1;
    }

    /* ---- c_cflag: Hardware settings ---- */

    /* Set baud rate to 115200 (input and output) */
    cfsetispeed(&tty, B115200);
    cfsetospeed(&tty, B115200);

    /* 8 data bits: clear CSIZE field, then set CS8 */
    tty.c_cflag &= ~CSIZE;
    tty.c_cflag |= CS8;

    /* No parity: clear PARENB */
    tty.c_cflag &= ~PARENB;

    /* 1 stop bit: clear CSTOPB */
    tty.c_cflag &= ~CSTOPB;

    /* Enable receiver, ignore modem control lines */
    tty.c_cflag |= (CREAD | CLOCAL);

    /* Disable hardware flow control */
    tty.c_cflag &= ~CRTSCTS;

    /* ---- c_iflag: Disable input processing ---- */
    /* Disable CR/NL mapping, parity check, strip — raw input */
    tty.c_iflag &= ~(ICRNL | INLCR | IGNCR);
    tty.c_iflag &= ~(IXON | IXOFF | IXANY);  /* No software flow control */
    tty.c_iflag &= ~(INPCK | ISTRIP);

    /* ---- c_oflag: Disable output processing ---- */
    tty.c_oflag &= ~OPOST;   /* Raw output — no CR/NL translation */

    /* ---- c_lflag: Disable line discipline processing ---- */
    tty.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);

    /* Non-blocking read: return immediately if no data */
    tty.c_cc[VMIN]  = 0;
    tty.c_cc[VTIME] = 10;   /* 1 second timeout (in 0.1s units) */

    /* Apply settings */
    if (tcsetattr(fd, TCSANOW, &tty) != 0) {
        perror("tcsetattr");
        close(fd);
        return -1;
    }

    return fd;
}

int main(void)
{
    int fd = open_serial_port("/dev/ttyS0");
    if (fd < 0)
        return 1;

    printf("Serial port opened and configured: 115200 8N1\n");

    /* Write a test message */
    const char *msg = "Hello from Linux UART!\r\n";
    write(fd, msg, strlen(msg));

    /* Read response */
    char buf[128];
    int n = read(fd, buf, sizeof(buf) - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("Received: %s\n", buf);
    }

    close(fd);
    return 0;
}

The correct way to read or write baud rate is through the helper functions cfgetispeed() and cfgetospeed() — not by reading c_cflag directly.

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

/* Helper: convert speed_t constant to human-readable string */
const char *baud_to_str(speed_t speed)
{
    switch (speed) {
        case B0:      return "0 (Hangup)";
        case B9600:   return "9600";
        case B19200:  return "19200";
        case B38400:  return "38400";
        case B57600:  return "57600";
        case B115200: return "115200";
        case B230400: return "230400";
        default:      return "unknown";
    }
}

int main(void)
{
    struct termios tty;

    if (tcgetattr(STDIN_FILENO, &tty) != 0) {
        perror("tcgetattr");
        return 1;
    }

    speed_t ispeed = cfgetispeed(&tty);
    speed_t ospeed = cfgetospeed(&tty);

    printf("Input baud rate:  %s\n", baud_to_str(ispeed));
    printf("Output baud rate: %s\n", baud_to_str(ospeed));

    return 0;
}

The various delay flags in c_oflag (NLDLY, CRDLY, BSDLY, FFDLY, VTDLY) were needed for old electromechanical terminals like teletypes and dot-matrix printers. These devices had printhead mechanisms that physically moved across the paper, and they needed a short pause after a carriage return or newline to allow the mechanism to complete its movement before the next character arrived.

Modern virtual terminals and pseudoterminals process characters at memory speed, so these delays are completely irrelevant. On Linux, most of these flags are recognized by the kernel but have no actual effect. The one exception is TAB3 (part of TABDLY), which still works and converts tab characters to spaces.

Similarly, the IUCLC / OLCUC / XCASE flags were for terminals that could only display uppercase. When a user logged in with an all-uppercase username, the login program would set these flags, causing all output to appear in uppercase and input to be interpreted with a backslash-escape convention for real uppercase characters. These are essentially obsolete today.