/*
 * pty_demo.c
 *
 * Opens a PTY pair, forks a child, runs /bin/sh on the PTY slave.
 * The parent relays data between the real terminal (your stdin/stdout)
 * and the PTY master using select().
 *
 * Compile: gcc -o pty_demo pty_demo.c
 * Run:     ./pty_demo
 */

#define _XOPEN_SOURCE 600   /* needed for posix_openpt, grantpt, unlockpt, ptsname */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/select.h>
#include <sys/wait.h>

#define BUF_SIZE 256

/*
 * put_terminal_raw():
 * Save old terminal settings, then switch terminal to raw mode.
 * In raw mode, characters are sent one at a time without line editing.
 * This is needed so keypresses go directly to the shell in the PTY.
 */
static void put_terminal_raw(struct termios *old_termios)
{
    struct termios new_termios;

    if (tcgetattr(STDIN_FILENO, old_termios) == -1) {
        perror("tcgetattr");
        exit(EXIT_FAILURE);
    }

    new_termios = *old_termios;

    /* cfmakeraw() sets all the flags needed for raw mode */
    cfmakeraw(&new_termios);

    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &new_termios) == -1) {
        perror("tcsetattr");
        exit(EXIT_FAILURE);
    }
}

/*
 * restore_terminal():
 * Restore the terminal to its saved settings when we exit.
 */
static void restore_terminal(struct termios *old_termios)
{
    tcsetattr(STDIN_FILENO, TCSAFLUSH, old_termios);
}

int main(void)
{
    int master_fd, slave_fd;
    char *slave_name;
    pid_t child_pid;
    struct termios saved_termios;
    char buf[BUF_SIZE];
    ssize_t nread;
    fd_set read_fds;

    /* ---- STEP 1: Open PTY master ---- */

    master_fd = posix_openpt(O_RDWR | O_NOCTTY);
    if (master_fd == -1) {
        perror("posix_openpt");
        exit(EXIT_FAILURE);
    }

    /* Set correct ownership (typically /dev/pts/N owned by calling user) */
    if (grantpt(master_fd) == -1) {
        perror("grantpt");
        exit(EXIT_FAILURE);
    }

    /* Unlock the slave side so we can open it */
    if (unlockpt(master_fd) == -1) {
        perror("unlockpt");
        exit(EXIT_FAILURE);
    }

    /* Get the slave device name, e.g. /dev/pts/3 */
    slave_name = ptsname(master_fd);
    if (slave_name == NULL) {
        perror("ptsname");
        exit(EXIT_FAILURE);
    }

    /* Make a copy since ptsname() returns a static buffer */
    slave_name = strdup(slave_name);
    printf("PTY slave device: %s\n", slave_name);
    fflush(stdout);

    /* ---- STEP 2: fork() ---- */

    child_pid = fork();
    if (child_pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (child_pid == 0) {
        /* ========================================
         * CHILD PROCESS: set up PTY slave side
         * ======================================== */

        /* STEP 2a: setsid() — become session leader in new session.
         * This detaches from any existing controlling terminal. */
        if (setsid() == -1) {
            perror("setsid");
            exit(EXIT_FAILURE);
        }

        /* STEP 2b: Open PTY slave.
         * Since we are now a session leader with no controlling terminal,
         * opening the slave device automatically makes it our controlling terminal. */
        slave_fd = open(slave_name, O_RDWR);
        if (slave_fd == -1) {
            perror("open slave");
            exit(EXIT_FAILURE);
        }

        /* STEP 2c: Redirect stdin, stdout, stderr to the slave */
        if (dup2(slave_fd, STDIN_FILENO)  == -1 ||
            dup2(slave_fd, STDOUT_FILENO) == -1 ||
            dup2(slave_fd, STDERR_FILENO) == -1) {
            perror("dup2");
            exit(EXIT_FAILURE);
        }

        /* Close original slave_fd (we have it as fd 0,1,2 now) */
        if (slave_fd > STDERR_FILENO)
            close(slave_fd);

        /* Child does not need the master */
        close(master_fd);

        free(slave_name);

        /* STEP 2d: exec the terminal-oriented program */
        execl("/bin/sh", "sh", NULL);

        /* If we reach here, exec failed */
        perror("execl");
        exit(EXIT_FAILURE);
    }

    /* ========================================
     * PARENT PROCESS: relay between stdin/stdout and PTY master
     * ======================================== */

    free(slave_name);

    /* Put our terminal in raw mode so keypresses go straight to the shell */
    put_terminal_raw(&saved_termios);

    /*
     * RELAY LOOP:
     * Use select() to watch both stdin (fd 0) and the PTY master.
     * - Data from stdin  → write to master  (user typing → goes to shell)
     * - Data from master → write to stdout  (shell output → shown to user)
     */
    while (1) {
        FD_ZERO(&read_fds);
        FD_SET(STDIN_FILENO, &read_fds);  /* watch keyboard input */
        FD_SET(master_fd,    &read_fds);  /* watch PTY master output */

        /* select() blocks until one or both become readable */
        if (select(master_fd + 1, &read_fds, NULL, NULL, NULL) == -1) {
            perror("select");
            break;
        }

        /* Keyboard input available? → send to PTY master (becomes shell stdin) */
        if (FD_ISSET(STDIN_FILENO, &read_fds)) {
            nread = read(STDIN_FILENO, buf, BUF_SIZE);
            if (nread <= 0)
                break;
            if (write(master_fd, buf, nread) != nread) {
                perror("write to master");
                break;
            }
        }

        /* PTY master has data? → write to our stdout (shell output to screen) */
        if (FD_ISSET(master_fd, &read_fds)) {
            nread = read(master_fd, buf, BUF_SIZE);
            if (nread <= 0)
                break;  /* shell exited */
            if (write(STDOUT_FILENO, buf, nread) != nread) {
                perror("write to stdout");
                break;
            }
        }
    }

    /* Restore terminal settings before we exit */
    restore_terminal(&saved_termios);

    close(master_fd);

    /* Wait for the child (shell) to exit */
    waitpid(child_pid, NULL, 0);

    printf("\nPTY demo ended.\n");
    return 0;
}

/* process_a.c: opens master, launches process_b with slave name as argument */
int main(void)
{
    int master_fd;
    char *slave_name;
    char slave_copy[64];

    master_fd = posix_openpt(O_RDWR | O_NOCTTY);
    grantpt(master_fd);
    unlockpt(master_fd);

    slave_name = ptsname(master_fd);
    strncpy(slave_copy, slave_name, sizeof(slave_copy) - 1);

    /* Tell process_b the slave device name via argv[1] */
    /* process_b will open it as its terminal */
    execlp("process_b", "process_b", slave_copy, NULL);

    /* process_a keeps master_fd and acts as relay */
    return 0;
}

/* process_b.c: receives slave name, opens it, becomes a terminal program */
int main(int argc, char *argv[])
{
    int slave_fd;

    if (argc < 2) {
        fprintf(stderr, "Usage: process_b /dev/pts/N\n");
        exit(1);
    }

    /* Create new session (must do this to make PTY slave controlling terminal) */
    setsid();

    /* Open the slave device given to us by process_a */
    slave_fd = open(argv[1], O_RDWR);

    dup2(slave_fd, STDIN_FILENO);
    dup2(slave_fd, STDOUT_FILENO);
    dup2(slave_fd, STDERR_FILENO);
    if (slave_fd > STDERR_FILENO) close(slave_fd);

    /* Now run any terminal-oriented program */
    execl("/bin/sh", "sh", NULL);
    return 0;
}

$ tty
/dev/pts/2

$ ls -la /dev/pts/
total 0
drwxr-xr-x  2 root   tty      0 Jun 18 10:00 .
drwxr-xr-x 22 root   root     0 Jun 18 09:58 ..
crw--w----  1 ravi   tty 136,0 Jun 18 10:05 0
crw--w----  1 ravi   tty 136,1 Jun 18 10:06 1
crw--w----  1 ravi   tty 136,2 Jun 18 10:07 2
c---------  1 root   root  5,2 Jun 18 09:58 ptmx

# Each number (0, 1, 2) is an active PTY slave = one open terminal window
# /dev/pts/ptmx is the per-directory clone of /dev/ptmx