Before understanding what a PTY is, let us understand the problem it solves.

Imagine you want to run a text editor like vi on a remote server from your local laptop over a network. You have sockets and TCP/IP to transfer data. But there is a big problem: vi is a terminal-oriented program. It does not just read and write plain text. It expects to be connected to a real terminal device.

A terminal-oriented program needs three things from its environment:

None of these things work when stdin/stdout/stderr are connected to a raw socket. The pseudoterminal is the solution to all three problems at once.

A pseudoterminal (PTY) is a pair of virtual kernel devices that together act as a communication channel:

• PTY Master — the controlling side, opened by the driver/relay program
• PTY Slave — looks exactly like a real terminal, used by the terminal-oriented program

Think of it like a bidirectional pipe with terminal features:

The key rule to remember: whatever you write to the master appears as input on the slave, and whatever the slave program writes appears as output readable from the master. The kernel PTY driver in the middle applies the full terminal line discipline — all the special character processing (Ctrl+C sends SIGINT, Ctrl+D is EOF, etc.).

The PTY slave silently ignores operations that don’t make sense for a virtual device (like setting baud rate or parity). This allows real terminal programs to work without any modifications.

The term terminal-oriented program is broader than you might think. It covers almost every interactive program you use in a shell session:

These programs share common behaviors that require a real terminal:

If you try to run such a program with its stdin/stdout connected to a plain socket or pipe, these operations return errors like ENOTTY (“Not a typewriter”) and the program either crashes or behaves incorrectly.

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

int main(void)
{
    struct termios t;

    /* Try to get terminal attributes on stdin */
    if (tcgetattr(STDIN_FILENO, &t) == -1) {
        /* If stdin is a pipe or socket, this fails with ENOTTY */
        fprintf(stderr, "tcgetattr failed: %s\n", strerror(errno));
        /* errno will be ENOTTY = 25 = "Inappropriate ioctl for device" */
    } else {
        printf("stdin is a terminal - terminal programs work fine\n");
    }

    /* Check using isatty() before calling terminal functions */
    if (isatty(STDIN_FILENO)) {
        printf("stdin is a TTY\n");
    } else {
        printf("stdin is NOT a TTY - PTY slave would fix this\n");
    }

    return 0;
}

A pseudoterminal always comes as a matched pair: one master device and one slave device. You cannot use one without the other.

The kernel PTY line discipline sits between master and slave. It does all the same work as a real serial terminal driver: echoing characters, translating newlines, processing Ctrl+C into SIGINT, Ctrl+Z into SIGTSTP, and so on. This is why terminal-oriented programs work transparently on the PTY slave.

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

int main(void)
{
    int master_fd;
    char *slave_name;

    /*
     * posix_openpt() opens /dev/ptmx and returns a file descriptor
     * for a new PTY master device. This is the POSIX standard way.
     * Equivalent to: open("/dev/ptmx", O_RDWR)
     */
    master_fd = posix_openpt(O_RDWR | O_NOCTTY);
    if (master_fd == -1) {
        perror("posix_openpt");
        exit(EXIT_FAILURE);
    }

    /* grantpt(): sets ownership and permissions of the slave device */
    if (grantpt(master_fd) == -1) {
        perror("grantpt");
        exit(EXIT_FAILURE);
    }

    /* unlockpt(): unlocks the slave so it can be opened */
    if (unlockpt(master_fd) == -1) {
        perror("unlockpt");
        exit(EXIT_FAILURE);
    }

    /* ptsname(): returns the pathname of the slave device */
    slave_name = ptsname(master_fd);
    if (slave_name == NULL) {
        perror("ptsname");
        exit(EXIT_FAILURE);
    }

    printf("PTY master fd = %d\n", master_fd);
    printf("PTY slave device = %s\n", slave_name);
    /* slave_name will be something like: /dev/pts/3 */

    close(master_fd);
    return 0;
}

This is the most important concept in the entire chapter. The PTY slave device is indistinguishable from a real hardware terminal from the point of view of the terminal-oriented program running on it.

Some operations that don’t make sense for a virtual device (like setting baud rate or parity bits) are simply silently ignored by the PTY slave. The program gets a success return code and moves on, never knowing it’s not on real hardware.