With the old Seventh Edition / BSD terminal driver, switching to Cbreak or Raw mode was a single bit flip. The modern POSIX termios interface replaced those single bits with a full structure of flags, and there is no single “set raw mode” system call. Every application that wants raw or cbreak mode must clear/set the correct combination of flags in struct termios.

Wrapping this in reusable functions achieves three things:

• Correctness — the exact flags needed are documented and applied once.
• Portability — differences between Linux, macOS, and embedded RTOS can be isolated inside the functions.
• Safety — the functions return the previous settings so the caller can restore them.

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

/*
 * ttySetCbreak - place terminal 'fd' into Cbreak mode.
 *
 * Cbreak = noncanonical, echo off, but signals (Ctrl-C/Z/\) still work.
 *
 * fd          : file descriptor of terminal (typically STDIN_FILENO)
 * prevTermios : if non-NULL, the ORIGINAL settings are saved here so
 *               the caller can restore the terminal later.
 *
 * Returns 0 on success, -1 on error (errno set).
 */
int ttySetCbreak(int fd, struct termios *prevTermios)
{
    struct termios t;

    /* Step 1: read current terminal settings into 't' */
    if (tcgetattr(fd, &t) == -1)
        return -1;

    /* Step 2: if caller wants old settings, copy them out now,
               BEFORE we modify 't' */
    if (prevTermios != NULL)
        *prevTermios = t;

    /* Step 3: turn OFF line-by-line input and character echo */
    t.c_lflag &= ~(ICANON | ECHO);

    /* Step 4: keep signal-generating characters ACTIVE
               (Ctrl-C → SIGINT, Ctrl-Z → SIGTSTP, Ctrl-\ → SIGQUIT) */
    t.c_lflag |= ISIG;

    /* Step 5: stop mapping CR (0x0D) to NL (0x0A) on input.
               Without this, pressing Enter sends 0x0A not 0x0D,
               which confuses programs that watch for raw carriage returns. */
    t.c_iflag &= ~ICRNL;

    /* Step 6: VMIN=1 means read() returns after at least 1 byte is available.
               VTIME=0 means no timeout — block indefinitely until a byte arrives. */
    t.c_cc[VMIN]  = 1;
    t.c_cc[VTIME] = 0;

    /* Step 7: apply the new settings.
               TCSAFLUSH: wait for all output to be sent, then discard
               any unread input before applying the change. */
    if (tcsetattr(fd, TCSAFLUSH, &t) == -1)
        return -1;

    return 0;
}

/*
 * ttySetRaw - place terminal 'fd' into Raw mode.
 *
 * Raw = noncanonical, no signals, no echo, no input/output processing.
 * Every byte typed reaches the program unmodified.
 *
 * fd          : file descriptor of terminal
 * prevTermios : if non-NULL, original settings saved here for later restore
 *
 * Returns 0 on success, -1 on error.
 */
int ttySetRaw(int fd, struct termios *prevTermios)
{
    struct termios t;

    if (tcgetattr(fd, &t) == -1)
        return -1;

    if (prevTermios != NULL)
        *prevTermios = t;

    /* ---- c_lflag (local / line discipline flags) ---- */
    t.c_lflag &= ~(ICANON   /* no line-by-line buffering        */
                 | ISIG     /* no signals from Ctrl-C/Z/\       */
                 | IEXTEN   /* no extended processing (Ctrl-V)  */
                 | ECHO);   /* no automatic echo                */

    /* ---- c_iflag (input flags) ---- */
    t.c_iflag &= ~(BRKINT   /* BREAK does not send SIGINT       */
                 | ICRNL    /* no CR→NL mapping                 */
                 | IGNBRK   /* do not ignore BREAK              */
                 | IGNCR    /* do not drop CR characters        */
                 | INLCR    /* no NL→CR mapping                 */
                 | INPCK    /* no parity checking               */
                 | ISTRIP   /* do not strip 8th bit             */
                 | IXON     /* no START/STOP output control     */
                 | PARMRK); /* no parity-error marking          */

    /* ---- c_oflag (output flags) ---- */
    t.c_oflag &= ~OPOST;   /* disable ALL output processing    */

    /* ---- noncanonical read parameters ---- */
    t.c_cc[VMIN]  = 1;     /* read() returns when 1 byte ready */
    t.c_cc[VTIME] = 0;     /* no timeout: block until byte     */

    if (tcsetattr(fd, TCSAFLUSH, &t) == -1)
        return -1;

    return 0;
}

Key differences between ttySetCbreak and ttySetRaw:

#ifndef TTY_FUNCTIONS_H
#define TTY_FUNCTIONS_H

#include <termios.h>

/*
 * Set terminal 'fd' to Cbreak mode.
 * Saves previous settings into *prevTermios if non-NULL.
 * Returns 0 on success, -1 on error.
 */
int ttySetCbreak(int fd, struct termios *prevTermios);

/*
 * Set terminal 'fd' to Raw mode.
 * Saves previous settings into *prevTermios if non-NULL.
 * Returns 0 on success, -1 on error.
 */
int ttySetRaw(int fd, struct termios *prevTermios);

#endif /* TTY_FUNCTIONS_H */

Always pair each ttySetCbreak() or ttySetRaw() call with a tcsetattr(fd, TCSANOW, &saved) on exit. The next section shows how to do this correctly in the presence of signals.

Once your program puts the terminal into Cbreak or Raw mode, the terminal driver no longer echoes input or interprets Backspace. If your program exits abnormally — killed by a signal, segfault, or uncaught exception — and never runs the restore code, the user’s shell session is left in an unusable state:

• Nothing typed appears on screen.
• In Cbreak mode, Ctrl-C still sends SIGINT to the shell, but in Raw mode even that breaks.
• The user must type reset blindly, or close the terminal.

The SIGTSTP case is the trickiest. When the user presses Ctrl-Z, the process must:

1. Save the program’s current terminal settings (ourTermios).
2. Restore the user’s original settings (userTermios) so the shell prompt works normally.
3. Re-raise SIGTSTP (with the default handler active) to actually suspend the process.
4. When fg is typed, the process receives SIGCONT and resumes.
5. On SIGCONT: save the current (possibly user-modified) terminal state as userTermios, then reapply ourTermios.

The following program demonstrates all the concepts. It places the terminal in Cbreak or Raw mode (depending on a command-line argument), reads characters, echoes them transformed (lowercase letters as-is, control chars as ^X notation, others as *), and handles all signals correctly.

/*
 * demo_tty_modes.c
 *
 * Usage:
 *   ./demo_tty_modes         -- uses Cbreak mode
 *   ./demo_tty_modes raw     -- uses Raw mode
 *
 * Press 'q' to quit. Watch Ctrl-C behavior differ between modes.
 *
 * Compile:
 *   gcc -Wall -o demo_tty_modes demo_tty_modes.c tty_functions.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <termios.h>
#include "tty_functions.h"

/*
 * Two terminal state snapshots kept in global scope so signal handlers
 * can access them without extra arguments.
 *
 * userTermios : terminal state as the USER left it (what we restore to)
 * ourTermios  : terminal state our program set (used after SIGCONT)
 */
static struct termios userTermios;
static struct termios ourTermios;

/* ------------------------------------------------------------------ */
/* Handler for SIGINT, SIGQUIT, SIGTERM                               */
/* ------------------------------------------------------------------ */
static void restoreAndExit(int sig)
{
    /*
     * Restore the terminal to the state the user had BEFORE our program ran.
     * TCSANOW: apply immediately (don't wait for output drain — we are exiting).
     */
    tcsetattr(STDIN_FILENO, TCSANOW, &userTermios);

    /* Print a newline so the next shell prompt appears on a fresh line */
    write(STDOUT_FILENO, "\n", 1);

    /*
     * Re-raise the signal with the default handler so the process exits
     * with the right status/core-dump behavior (SIGQUIT generates a core).
     */
    signal(sig, SIG_DFL);
    raise(sig);
}

/* ------------------------------------------------------------------ */
/* Handler for SIGTSTP (Ctrl-Z / job control suspend)                 */
/* ------------------------------------------------------------------ */
static void tstpHandler(int sig)
{
    /* Step 1: Save our program's terminal settings for later resumption */
    tcgetattr(STDIN_FILENO, &ourTermios);

    /*
     * Step 2: Restore the terminal to what the user had.
     *         This makes the shell prompt work normally while we are stopped.
     */
    tcsetattr(STDIN_FILENO, TCSANOW, &userTermios);

    write(STDOUT_FILENO, "\n", 1);   /* cosmetic newline */

    /*
     * Step 3: Re-raise SIGTSTP with the DEFAULT handler so the kernel
     *         actually stops this process.
     *         The process is now suspended here until SIGCONT arrives.
     */
    signal(SIGTSTP, SIG_DFL);
    raise(SIGTSTP);

    /*
     * ---- execution resumes here after 'fg' sends SIGCONT ----
     *
     * Step 4: Re-install our custom SIGTSTP handler (it was reset to SIG_DFL above).
     */
    signal(SIGTSTP, tstpHandler);

    /*
     * Step 5: The user may have changed terminal settings while we were stopped
     *         (e.g. via 'stty'). Save whatever state they left it in.
     */
    tcgetattr(STDIN_FILENO, &userTermios);

    /*
     * Step 6: Reapply our program's terminal mode (cbreak or raw).
     */
    tcsetattr(STDIN_FILENO, TCSANOW, &ourTermios);
}

/* ------------------------------------------------------------------ */
/* main                                                                */
/* ------------------------------------------------------------------ */
int main(int argc, char *argv[])
{
    int useRaw;
    char ch;
    ssize_t numRead;

    /* Decide mode based on presence of any command-line argument */
    useRaw = (argc > 1);

    /* Install signal handlers BEFORE switching terminal mode */
    signal(SIGINT,  restoreAndExit);
    signal(SIGQUIT, restoreAndExit);
    signal(SIGTERM, restoreAndExit);
    signal(SIGTSTP, tstpHandler);

    /*
     * Switch to the chosen mode.
     * Pass &userTermios so the ORIGINAL settings are saved there.
     * Signal handlers will use userTermios to restore the terminal.
     */
    if (useRaw) {
        if (ttySetRaw(STDIN_FILENO, &userTermios) == -1) {
            perror("ttySetRaw");
            exit(EXIT_FAILURE);
        }
        write(STDOUT_FILENO, "[Raw mode]\r\n", 12);
    } else {
        if (ttySetCbreak(STDIN_FILENO, &userTermios) == -1) {
            perror("ttySetCbreak");
            exit(EXIT_FAILURE);
        }
        write(STDOUT_FILENO, "[Cbreak mode]\r\n", 15);
    }

    /* Save our terminal settings for the SIGTSTP handler */
    tcgetattr(STDIN_FILENO, &ourTermios);

    /* ---- Main character read loop ---- */
    while (1) {

        numRead = read(STDIN_FILENO, &ch, 1);

        if (numRead <= 0)
            break;

        if (ch == 'q')        /* 'q' quits the loop */
            break;

        /*
         * Echo transformation rules:
         *   lowercase letters   → output as-is
         *   \n and \r           → output unchanged
         *   other control chars → display as ^X  (e.g. Ctrl-A → ^A)
         *   everything else     → display as *
         */
        if (ch >= 'a' && ch <= 'z') {
            write(STDOUT_FILENO, &ch, 1);

        } else if (ch == '\n' || ch == '\r') {
            write(STDOUT_FILENO, &ch, 1);

        } else if (ch < 0x20 || ch == 0x7f) {
            /* Control character: print as ^X */
            char ctrl[3];
            ctrl[0] = '^';
            ctrl[1] = (ch == 0x7f) ? '?' : (ch + '@');
            ctrl[2] = '\0';
            write(STDOUT_FILENO, ctrl, 2);

        } else {
            write(STDOUT_FILENO, "*", 1);
        }
    }

    /* ---- Normal exit: restore terminal ---- */
    tcsetattr(STDIN_FILENO, TCSANOW, &userTermios);
    write(STDOUT_FILENO, "\r\n[Terminal restored]\r\n", 23);

    return EXIT_SUCCESS;
}

The second argument to tcsetattr(fd, when, &t) controls when the change takes effect:

Our ttySetCbreak() and ttySetRaw() use TCSAFLUSH for mode entry. Signal handlers use TCSANOW for restoration because we need it to take effect before the next shell prompt appears.

# Compile (all three .c files together)
gcc -Wall -Wextra -o demo_tty_modes demo_tty_modes.c tty_functions.c

# Run in Cbreak mode (Ctrl-C still sends SIGINT)
./demo_tty_modes

# Run in Raw mode (Ctrl-C passes as byte ^C to the program)
./demo_tty_modes raw

# Expected output (Cbreak mode, typing 'hello', Ctrl-A, then 'q'):
[Cbreak mode]
hello^Aq
[Terminal restored]

Experiment ideas:

• Run in Cbreak mode, press Ctrl-C — the program exits via SIGINT handler.
• Run in Raw mode, press Ctrl-C — you see ^C echoed as output; the program does NOT exit.
• Run in Cbreak mode, press Ctrl-Z, then type fg — the program resumes in its mode correctly.
• Send SIGTERM from another terminal: kill <pid> — terminal is restored cleanly.