Terminals, TTYs & Pseudo-Terminals

// shelf-pick.c: ask "Return Dune? [y/n]" and read one key without Enter.
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>

static struct termios saved;
static int have_saved = 0;

static void restore(void) {
    if (have_saved) {
        tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved);
        have_saved = 0;
    }
}

static void on_fatal(int sig) {
    restore();                   /* tcsetattr is async-signal-safe */
    signal(sig, SIG_DFL);        /* then die with the original signal */
    raise(sig);
}

static int enter_cbreak(void) {
    if (!isatty(STDIN_FILENO)) {
        errno = ENOTTY;
        return -1;
    }
    if (tcgetattr(STDIN_FILENO, &saved) == -1) return -1;
    have_saved = 1;
    atexit(restore);

    struct sigaction sa = { .sa_handler = on_fatal };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);

    struct termios t = saved;
    t.c_lflag &= ~(ICANON | ECHO);   /* cbreak: keep ISIG so Ctrl-C still works */
    t.c_cc[VMIN] = 1;                /* block until one byte ... */
    t.c_cc[VTIME] = 0;               /* ... with no timeout */
    return tcsetattr(STDIN_FILENO, TCSAFLUSH, &t);
}

int main(void) {
    if (enter_cbreak() == -1) {
        perror("shelf: stdin is not a terminal");
        return 1;
    }
    fputs("Return \"Dune\"? [y/n] ", stdout);
    fflush(stdout);
    unsigned char c;
    if (read(STDIN_FILENO, &c, 1) != 1) return 1;
    printf("%c\n", c);
    return c == 'y' ? 0 : 2;
}

$ echo y | ./shelf-pick
shelf: stdin is not a terminal: Inappropriate ioctl for device
$ echo $?
1

// shelf-pty.c: run a command on a new pseudo-terminal, print what it writes,
// then resize the window. Usage: shelf-pty command [args...]
#define _XOPEN_SOURCE 700
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <termios.h>
#include <unistd.h>

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "usage: %s command [args...]\n", argv[0]);
        return 64;
    }

    int master = posix_openpt(O_RDWR | O_NOCTTY);          /* 1. master side */
    if (master == -1 || grantpt(master) == -1 || unlockpt(master) == -1) {
        perror("posix_openpt");
        return 1;
    }
    const char *slave_name = ptsname(master);              /* 2. slave path */
    if (slave_name == NULL) {
        perror("ptsname");
        return 1;
    }

    struct winsize ws = { .ws_row = 24, .ws_col = 80 };    /* initial size */

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }
    if (pid == 0) {
        close(master);
        setsid();                                          /* new session, no controlling terminal */
        int slave = open(slave_name, O_RDWR);              /* a session leader's first open may
                                                              already make it the controlling tty */
#ifdef TIOCSCTTY
        ioctl(slave, TIOCSCTTY, 0);                        /* BSD and macOS make it explicit; harmless
                                                              if the open already did it */
#endif
        ioctl(slave, TIOCSWINSZ, &ws);                     /* macOS refuses this on the master
                                                              until the slave has been opened */
        dup2(slave, STDIN_FILENO);
        dup2(slave, STDOUT_FILENO);
        dup2(slave, STDERR_FILENO);
        if (slave > STDERR_FILENO) close(slave);
        execvp(argv[1], &argv[1]);
        perror("execvp");
        _exit(127);
    }

    char buf[256];
    ssize_t n;
    int resized = 0;
    while ((n = read(master, buf, sizeof buf)) > 0) {      /* EIO when the child exits (Linux) */
        fwrite(buf, 1, (size_t)n, stdout);
        if (!resized) {                                    /* after the first output */
            resized = 1;
            ws.ws_row = 40;
            ws.ws_col = 120;
            ioctl(master, TIOCSWINSZ, &ws);                /* kernel sends SIGWINCH */
        }
    }
    int status = 0;
    waitpid(pid, &status, 0);
    return WIFEXITED(status) ? WEXITSTATUS(status) : 128 + WTERMSIG(status);
}

$ ./shelf-pty ./shelf-size
shelf tui: 24 rows x 80 columns
shelf tui: 40 rows x 120 columns
$ ./shelf-pty sh -c 'tty; stty -a | head -1'
/dev/ttys013
speed 9600 baud; 40 rows; 120 columns;

// shelf-forkpty.c: forkpty does openpty + fork + login_tty in one call.
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <unistd.h>
#if defined(__APPLE__) || defined(__OpenBSD__)
#  include <util.h>
#elif defined(__FreeBSD__)
#  include <libutil.h>
#else
#  include <pty.h>         /* Linux: link with -lutil on older glibc */
#endif

int main(void) {
    int master;
    struct winsize ws = { .ws_row = 24, .ws_col = 80 };
    pid_t pid = forkpty(&master, NULL, NULL, &ws);   /* NULL name, NULL termios: inherit defaults */
    if (pid == -1) {
        perror("forkpty");
        return 1;
    }
    if (pid == 0) {                                  /* child: stdin/out/err are the slave */
        execlp("tty", "tty", (char *)NULL);
        _exit(127);
    }
    char buf[128];
    ssize_t n = read(master, buf, sizeof buf - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("child says: %s", buf);
    }
    int status;
    waitpid(pid, &status, 0);
    return 0;
}

// shelf-login.c: read an API token from /dev/tty without echoing it.
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

/* True when this process may read the terminal without being stopped by SIGTTIN. */
static int in_foreground(int fd) {
    pid_t fg = tcgetpgrp(fd);
    return fg != -1 && fg == getpgrp();
}

int main(void) {
    int tty = open("/dev/tty", O_RDWR | O_NOCTTY);   /* the controlling terminal, even if stdin is a pipe */
    if (tty == -1) {
        perror("shelf login: no controlling terminal; use --token-file");
        return 1;
    }
    if (!in_foreground(tty)) {
        fputs("shelf login: running in the background, cannot prompt\n", stderr);
        return 1;
    }

    struct termios saved, quiet;
    if (tcgetattr(tty, &saved) == -1) {
        perror("tcgetattr");
        return 1;
    }
    quiet = saved;
    quiet.c_lflag &= ~(tcflag_t)ECHO;                /* keep ICANON: the line editor still works */
    quiet.c_lflag |= ECHONL;                         /* but echo the newline the user types */

    dprintf(tty, "shelfd token: ");
    if (tcsetattr(tty, TCSAFLUSH, &quiet) == -1) {
        perror("tcsetattr");
        return 1;
    }
    char token[256];
    ssize_t n = read(tty, token, sizeof token - 1);
    tcsetattr(tty, TCSAFLUSH, &saved);               /* restore before doing anything else */
    if (n <= 0) return 1;
    token[n] = '\0';
    token[strcspn(token, "\n")] = '\0';
    printf("read %zu characters\n", strlen(token));
    return 0;
}

// shelf-suspend.c: a raw-mode program that cooperates with Ctrl-Z.
#include <signal.h>
#include <stdio.h>
#include <termios.h>
#include <unistd.h>

static struct termios cooked, raw;
static volatile sig_atomic_t redraw_needed = 1;

static void on_tstp(int sig) {
    (void)sig;
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &cooked);   /* give the shell a sane terminal */
    signal(SIGTSTP, SIG_DFL);                      /* next SIGTSTP stops us for real */
    raise(SIGTSTP);                                /* delivered when the handler returns ... */
}                                                  /* ... because SIGTSTP is blocked inside it */

static void on_cont(int sig) {
    (void)sig;
    signal(SIGTSTP, on_tstp);                      /* re-arm */
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);      /* back to raw mode */
    redraw_needed = 1;                             /* the screen may have been overwritten */
}

int main(void) {
    if (tcgetattr(STDIN_FILENO, &cooked) == -1) return 1;
    raw = cooked;
    raw.c_lflag &= (tcflag_t)~(ICANON | ECHO);     /* keep ISIG: Ctrl-Z must still generate SIGTSTP */
    raw.c_cc[VMIN] = 1;
    raw.c_cc[VTIME] = 0;

    struct sigaction sa = { .sa_handler = on_tstp };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGTSTP, &sa, NULL);
    sa.sa_handler = on_cont;
    sigaction(SIGCONT, &sa, NULL);

    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
    unsigned char c;
    for (;;) {
        if (redraw_needed) {
            redraw_needed = 0;
            dprintf(STDOUT_FILENO, "[redraw] press q to quit\n");
        }
        ssize_t n = read(STDIN_FILENO, &c, 1);
        if (n == -1) continue;                     /* EINTR after a signal */
        if (n == 0 || c == 'q') break;
    }
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &cooked);
    return 0;
}

// shelf-rawmode.c (Windows): switch the console to VT in and out, restore on exit.
#include <windows.h>
#include <stdio.h>

static DWORD saved_in, saved_out;
static HANDLE h_in, h_out;

static void restore_console(void) {
    SetConsoleMode(h_in, saved_in);
    SetConsoleMode(h_out, saved_out);
}

static BOOL WINAPI on_ctrl(DWORD type) {
    if (type == CTRL_C_EVENT || type == CTRL_CLOSE_EVENT) restore_console();
    return FALSE;                                   /* let the default handler end the process */
}

int wmain(void) {
    h_in  = GetStdHandle(STD_INPUT_HANDLE);
    h_out = GetStdHandle(STD_OUTPUT_HANDLE);
    if (!GetConsoleMode(h_in, &saved_in) || !GetConsoleMode(h_out, &saved_out)) {
        fputs("shelf: not a console\n", stderr);   /* redirected: treat like a non-TTY on POSIX */
        return 1;
    }
    SetConsoleCtrlHandler(on_ctrl, TRUE);
    atexit(restore_console);

    DWORD in  = saved_in;
    in &= ~(DWORD)(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);   /* like clearing ICANON and ECHO */
    in |= ENABLE_VIRTUAL_TERMINAL_INPUT | ENABLE_WINDOW_INPUT;
    DWORD out = saved_out | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    if (!SetConsoleMode(h_in, in) || !SetConsoleMode(h_out, out)) {
        fputs("shelf: this console does not support virtual terminal mode\n", stderr);
        return 1;
    }

    CONSOLE_SCREEN_BUFFER_INFO info;
    GetConsoleScreenBufferInfo(h_out, &info);
    int cols = info.srWindow.Right  - info.srWindow.Left + 1;
    int rows = info.srWindow.Bottom - info.srWindow.Top  + 1;
    printf("shelf tui: %d rows x %d columns\n", rows, cols);
    return 0;
}

// shelf-conpty.c (Windows 10 1809+): run "shelf.exe list" on a pseudoconsole and print its output.
#include <windows.h>
#include <stdio.h>

static HPCON pty;
static HANDLE child;

/* Waits for the child, then closes the pseudoconsole from a thread that does not read the output. */
static DWORD WINAPI close_when_done(LPVOID unused) {
    (void)unused;
    WaitForSingleObject(child, INFINITE);
    ClosePseudoConsole(pty);
    return 0;
}

int wmain(void) {
    HANDLE in_read, in_write, out_read, out_write;
    CreatePipe(&in_read, &in_write, NULL, 0);        /* input channel: we write, ConPTY reads */
    CreatePipe(&out_read, &out_write, NULL, 0);      /* output channel: ConPTY writes, we read */

    COORD size = { 120, 30 };                        /* columns, rows */
    HRESULT hr = CreatePseudoConsole(size, in_read, out_write, 0, &pty);
    if (FAILED(hr)) {
        fprintf(stderr, "CreatePseudoConsole failed: 0x%08lx\n", (unsigned long)hr);
        return 1;
    }

    STARTUPINFOEXW si = { 0 };
    si.StartupInfo.cb = sizeof si;
    SIZE_T bytes = 0;
    InitializeProcThreadAttributeList(NULL, 1, 0, &bytes);          /* first call: how much memory */
    si.lpAttributeList = HeapAlloc(GetProcessHeap(), 0, bytes);
    InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &bytes);
    UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
                              pty, sizeof pty, NULL, NULL);

    wchar_t cmd[] = L"shelf.exe list";
    PROCESS_INFORMATION pi;
    if (!CreateProcessW(NULL, cmd, NULL, NULL, FALSE, EXTENDED_STARTUPINFO_PRESENT,
                        NULL, NULL, &si.StartupInfo, &pi)) {
        fprintf(stderr, "CreateProcess failed: %lu\n", GetLastError());
        return 1;
    }
    child = pi.hProcess;
    CloseHandle(in_read);                            /* free our copies so a broken pipe is detected */
    CloseHandle(out_write);
    CreateThread(NULL, 0, close_when_done, NULL, 0, NULL);

    char buf[4096];
    DWORD n;
    while (ReadFile(out_read, buf, sizeof buf, &n, NULL) && n > 0)
        fwrite(buf, 1, n, stdout);                   /* virtual-terminal text, escape sequences included */
    CloseHandle(pi.hThread);
    return 0;
}