Home /Modules/impl/sleela_terminal.c

sleela_terminal.c

impl/core/sleela_terminal.c · 438 line(s) · c

#ifndef _WIN32
#define _XOPEN_SOURCE 600
/* On macOS, _XOPEN_SOURCE alone hides BSD/Darwin symbols; _DARWIN_C_SOURCE
 * re-exposes posix_openpt/grantpt/unlockpt/ptsname and TIOCSCTTY. */
#if defined(__APPLE__)
#define _DARWIN_C_SOURCE 1
#endif
#endif
#ifdef _WIN32
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#endif
#endif

#include "sleela_terminal.h"

#include <errno.h>
#include <stdlib.h>
#include <string.h>

#ifdef _WIN32
#include <windows.h>
#include <processthreadsapi.h>

typedef struct {
    HPCON console;
    HANDLE input_write;
    HANDLE output_read;
    HANDLE process;
} SLWinTerminal;

static SLWinTerminal* as_terminal(SLTerminalHandle h) {
    return (SLWinTerminal*)(intptr_t)h;
}

SLTerminalPlatform slterminal_platform(void) { return SL_TERMINAL_WINDOWS; }
const char* slterminal_platform_name(void) { return "windows-conpty"; }
int slterminal_platform_is_available(SLTerminalPlatform platform) {
    return platform == SL_TERMINAL_AUTO || platform == SL_TERMINAL_WINDOWS;
}

static wchar_t* utf8_to_wide(const char* text) {
    int n;
    wchar_t* out;
    if (!text) return NULL;
    n = MultiByteToWideChar(CP_UTF8, 0, text, -1, NULL, 0);
    if (n <= 0) return NULL;
    out = (wchar_t*)calloc((size_t)n, sizeof(*out));
    if (!out) return NULL;
    if (!MultiByteToWideChar(CP_UTF8, 0, text, -1, out, n)) {
        free(out);
        return NULL;
    }
    return out;
}

int slterminal_spawn(SLTerminalHandle* terminal, const char* command,
                     unsigned cols, unsigned rows) {
    HANDLE child_in = NULL, parent_in = NULL;
    HANDLE parent_out = NULL, child_out = NULL;
    SECURITY_ATTRIBUTES sa;
    COORD size;
    HPCON hpc = NULL;
    STARTUPINFOEXW si;
    PROCESS_INFORMATION pi;
    SIZE_T attr_size = 0;
    wchar_t* cmd = NULL;
    SLWinTerminal* t = NULL;
    HRESULT hr;
    DWORD error_code;

    if (!terminal || cols == 0 || rows == 0) return EINVAL;
    *terminal = (SLTerminalHandle)0;
    memset(&sa, 0, sizeof(sa));
    sa.nLength = sizeof(sa);
    sa.bInheritHandle = TRUE;

    if (!CreatePipe(&child_in, &parent_in, &sa, 0) ||
        !CreatePipe(&parent_out, &child_out, &sa, 0)) {
        error_code = GetLastError();
        if (child_in) CloseHandle(child_in);
        if (parent_in) CloseHandle(parent_in);
        if (parent_out) CloseHandle(parent_out);
        if (child_out) CloseHandle(child_out);
        return (int)error_code;
    }
    if (!SetHandleInformation(parent_in, HANDLE_FLAG_INHERIT, 0) ||
        !SetHandleInformation(parent_out, HANDLE_FLAG_INHERIT, 0)) {
        error_code = GetLastError();
        CloseHandle(child_in); CloseHandle(parent_in);
        CloseHandle(parent_out); CloseHandle(child_out);
        return (int)error_code;
    }

    size.X = (SHORT)(cols > 32767 ? 32767 : cols);
    size.Y = (SHORT)(rows > 32767 ? 32767 : rows);
    hr = CreatePseudoConsole(size, child_in, child_out, 0, &hpc);
    if (FAILED(hr)) {
        CloseHandle(child_in);
        CloseHandle(child_out);
        CloseHandle(parent_in); CloseHandle(parent_out);
        return (int)hr;
    }

    memset(&si, 0, sizeof(si));
    si.StartupInfo.cb = sizeof(si);
    InitializeProcThreadAttributeList(NULL, 1, 0, &attr_size);
    si.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(
        GetProcessHeap(), 0, attr_size);
    if (!si.lpAttributeList ||
        !InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &attr_size) ||
        !UpdateProcThreadAttribute(si.lpAttributeList, 0,
            PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE, hpc, sizeof(hpc), NULL, NULL)) {
        error_code = GetLastError();
        if (si.lpAttributeList) HeapFree(GetProcessHeap(), 0, si.lpAttributeList);
        CloseHandle(child_in); CloseHandle(child_out);
        CloseHandle(parent_in); CloseHandle(parent_out); ClosePseudoConsole(hpc);
        return (int)error_code;
    }

    cmd = utf8_to_wide(command ? command : "cmd.exe");
    if (!cmd) {
        DeleteProcThreadAttributeList(si.lpAttributeList);
        HeapFree(GetProcessHeap(), 0, si.lpAttributeList);
        CloseHandle(child_in); CloseHandle(child_out);
        CloseHandle(parent_in); CloseHandle(parent_out); ClosePseudoConsole(hpc);
        return ERROR_OUTOFMEMORY;
    }
    memset(&pi, 0, sizeof(pi));
    if (!CreateProcessW(NULL, cmd, NULL, NULL, FALSE,
                        EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT,
                        NULL, NULL, &si.StartupInfo, &pi)) {
        error_code = GetLastError();
        free(cmd);
        DeleteProcThreadAttributeList(si.lpAttributeList);
        HeapFree(GetProcessHeap(), 0, si.lpAttributeList);
        CloseHandle(child_in); CloseHandle(child_out);
        CloseHandle(parent_in); CloseHandle(parent_out); ClosePseudoConsole(hpc);
        return (int)error_code;
    }
    /* Keep the pipe endpoints supplied to CreatePseudoConsole alive until
     * CreateProcess has attached the child, as required by the ConPTY setup
     * sequence. Only then release this process's copies. */
    CloseHandle(child_in);
    CloseHandle(child_out);
    CloseHandle(pi.hThread);
    free(cmd);
    DeleteProcThreadAttributeList(si.lpAttributeList);
    HeapFree(GetProcessHeap(), 0, si.lpAttributeList);

    t = (SLWinTerminal*)calloc(1, sizeof(*t));
    if (!t) {
        TerminateProcess(pi.hProcess, 1);
        CloseHandle(pi.hProcess);
        CloseHandle(parent_in); CloseHandle(parent_out); ClosePseudoConsole(hpc);
        return ERROR_OUTOFMEMORY;
    }
    t->console = hpc;
    t->input_write = parent_in;
    t->output_read = parent_out;
    t->process = pi.hProcess;
    *terminal = (SLTerminalHandle)(intptr_t)t;
    return 0;
}

SLTerminalCount slterminal_read(SLTerminalHandle terminal, void* buffer, size_t size) {
    SLWinTerminal* t = as_terminal(terminal);
    DWORD got = 0;
    if (!t || !buffer || size == 0 || size > 0xffffffffu) return -1;
    if (!ReadFile(t->output_read, buffer, (DWORD)size, &got, NULL)) return -1;
    return (SLTerminalCount)got;
}

SLTerminalCount slterminal_write(SLTerminalHandle terminal, const void* buffer, size_t size) {
    SLWinTerminal* t = as_terminal(terminal);
    DWORD sent = 0;
    if (!t || !buffer || size == 0 || size > 0xffffffffu) return -1;
    if (!WriteFile(t->input_write, buffer, (DWORD)size, &sent, NULL)) return -1;
    return (SLTerminalCount)sent;
}

int slterminal_resize(SLTerminalHandle terminal, unsigned cols, unsigned rows) {
    SLWinTerminal* t = as_terminal(terminal);
    COORD size;
    HRESULT hr;
    if (!t || cols == 0 || rows == 0) return EINVAL;
    size.X = (SHORT)(cols > 32767 ? 32767 : cols);
    size.Y = (SHORT)(rows > 32767 ? 32767 : rows);
    hr = ResizePseudoConsole(t->console, size);
    return SUCCEEDED(hr) ? 0 : (int)hr;
}

/* Drain ConPTY output on a dedicated thread while ClosePseudoConsole runs.
 * Windows 10/11 releases before 24H2 may emit a final frame during shutdown and
 * wait indefinitely for the output pipe to be drained. Closing the reader
 * before ClosePseudoConsole is documented as an alternative, but is not
 * reliable for every hosted-runner process tree. A concurrent drain follows
 * Microsoft's recommended multi-threaded pipe servicing model. */
static DWORD WINAPI drain_conpty_output(LPVOID context) {
    HANDLE output = (HANDLE)context;
    char buffer[4096];
    DWORD received = 0;
    while (ReadFile(output, buffer, (DWORD)sizeof(buffer), &received, NULL) &&
           received != 0) {
        /* Discard terminal frames during teardown. */
    }
    return 0;
}

int slterminal_close(SLTerminalHandle terminal) {
    SLWinTerminal* t = as_terminal(terminal);
    DWORD wait_result;
    HANDLE drain_thread = NULL;
    int rc = 0;
    if (!t) return EINVAL;

    if (t->input_write && !CloseHandle(t->input_write)) rc = (int)GetLastError();
    t->input_write = NULL;

    /* Reap the direct child first. A timeout is bounded and escalates to
     * termination; descendants are then disconnected by ClosePseudoConsole. */
    wait_result = WaitForSingleObject(t->process, 3000);
    if (wait_result == WAIT_TIMEOUT) {
        if (!TerminateProcess(t->process, ERROR_PROCESS_ABORTED)) {
            DWORD error_code = GetLastError();
            if (error_code != ERROR_ACCESS_DENIED && rc == 0) rc = (int)error_code;
        }
        wait_result = WaitForSingleObject(t->process, 2000);
    }
    if (wait_result != WAIT_OBJECT_0 && rc == 0) {
        rc = wait_result == WAIT_FAILED ? (int)GetLastError() : ERROR_TIMEOUT;
    }

    if (t->output_read && t->console) {
        drain_thread = CreateThread(NULL, 0, drain_conpty_output,
                                    t->output_read, 0, NULL);
        if (!drain_thread) {
            DWORD error_code = GetLastError();
            if (rc == 0) rc = (int)error_code;
            /* Documented fallback for resource exhaustion: close the output
             * reader before ClosePseudoConsole so legacy Windows can finish. */
            if (!CloseHandle(t->output_read) && rc == 0)
                rc = (int)GetLastError();
            t->output_read = NULL;
        }
    }

    if (t->console) {
        /* Keep output_read open until the drain thread observes the broken pipe.
         * This allows ClosePseudoConsole to emit and flush its final frame. */
        ClosePseudoConsole(t->console);
    }
    t->console = NULL;

    if (drain_thread) {
        DWORD drain_wait = WaitForSingleObject(drain_thread, 5000);
        if (drain_wait == WAIT_TIMEOUT) {
            (void)CancelSynchronousIo(drain_thread);
            drain_wait = WaitForSingleObject(drain_thread, 1000);
            if (rc == 0) rc = ERROR_TIMEOUT;
        }
        if (drain_wait == WAIT_FAILED && rc == 0) rc = (int)GetLastError();
        CloseHandle(drain_thread);
    }

    if (t->output_read && !CloseHandle(t->output_read) && rc == 0)
        rc = (int)GetLastError();
    t->output_read = NULL;

    if (t->process && !CloseHandle(t->process) && rc == 0)
        rc = (int)GetLastError();
    t->process = NULL;
    free(t);
    return rc;
}

int slterminal_valid(SLTerminalHandle terminal) { return as_terminal(terminal) != NULL; }
int slterminal_last_error(void) { return (int)GetLastError(); }

#else

#include <fcntl.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#ifndef TIOCSWINSZ
#error "A POSIX PTY implementation requires TIOCSWINSZ"
#endif

typedef struct {
    int master;
    pid_t child;
    char slave_name[256];
} SLLinuxTerminal;

static SLLinuxTerminal* as_terminal(SLTerminalHandle h) {
    return (SLLinuxTerminal*)(intptr_t)h;
}

SLTerminalPlatform slterminal_platform(void) {
#if defined(__APPLE__)
    return SL_TERMINAL_MACOS;
#else
    return SL_TERMINAL_LINUX;
#endif
}
const char* slterminal_platform_name(void) {
#if defined(__APPLE__)
    return "macos-pty";
#else
    return "linux-pty";
#endif
}
int slterminal_platform_is_available(SLTerminalPlatform platform) {
    return platform == SL_TERMINAL_AUTO || platform == slterminal_platform();
}

int slterminal_spawn(SLTerminalHandle* terminal, const char* command,
                     unsigned cols, unsigned rows) {
    int master;
    pid_t child;
    struct winsize ws;
    SLLinuxTerminal* t;
    char slave_path[256];
    char* slave_name;
    if (!terminal || cols == 0 || rows == 0) return EINVAL;
    *terminal = (SLTerminalHandle)0;
    master = posix_openpt(O_RDWR | O_NOCTTY);
    if (master < 0) return errno;
    if (grantpt(master) < 0 || unlockpt(master) < 0) {
        int e = errno; close(master); return e;
    }
    slave_name = ptsname(master);
    if (!slave_name) { int e = errno; close(master); return e; }
    if (strlen(slave_name) >= sizeof(slave_path)) { close(master); return ENAMETOOLONG; }
    strcpy(slave_path, slave_name);
    memset(&ws, 0, sizeof(ws));
    ws.ws_col = (unsigned short)(cols > 65535 ? 65535 : cols);
    ws.ws_row = (unsigned short)(rows > 65535 ? 65535 : rows);
#if defined(__APPLE__)
    /* Darwin PTYs can reject TIOCSWINSZ on the master before the slave has
     * been opened. Set the initial dimensions through the slave descriptor. */
    {
        int size_fd = open(slave_path, O_RDWR | O_NOCTTY);
        if (size_fd < 0) { int e = errno; close(master); return e; }
        if (ioctl(size_fd, TIOCSWINSZ, &ws) < 0) {
            int e = errno; close(size_fd); close(master); return e;
        }
        close(size_fd);
    }
#else
    if (ioctl(master, TIOCSWINSZ, &ws) < 0) {
        int e = errno; close(master); return e;
    }
#endif
    child = fork();
    if (child < 0) { int e = errno; close(master); return e; }
    if (child == 0) {
        int slave;
        setsid();
        slave = open(slave_path, O_RDWR | O_NOCTTY);
        if (slave < 0) _exit(127);
        ioctl(slave, TIOCSCTTY, 0);
        dup2(slave, STDIN_FILENO);
        dup2(slave, STDOUT_FILENO);
        dup2(slave, STDERR_FILENO);
        if (slave > STDERR_FILENO) close(slave);
        if (command) execl("/bin/sh", "sh", "-c", command, (char*)NULL);
        else execl("/bin/sh", "sh", (char*)NULL);
        _exit(127);
    }
    t = (SLLinuxTerminal*)calloc(1, sizeof(*t));
    if (!t) { kill(child, SIGTERM); close(master); waitpid(child, NULL, 0); return ENOMEM; }
    t->master = master;
    t->child = child;
    strcpy(t->slave_name, slave_path);
    *terminal = (SLTerminalHandle)(intptr_t)t;
    return 0;
}

SLTerminalCount slterminal_read(SLTerminalHandle terminal, void* buffer, size_t size) {
    SLLinuxTerminal* t = as_terminal(terminal);
    ssize_t n;
    if (!t || !buffer || size == 0) return -1;
    n = read(t->master, buffer, size);
    return (SLTerminalCount)n;
}

SLTerminalCount slterminal_write(SLTerminalHandle terminal, const void* buffer, size_t size) {
    SLLinuxTerminal* t = as_terminal(terminal);
    ssize_t n;
    if (!t || !buffer || size == 0) return -1;
    n = write(t->master, buffer, size);
    return (SLTerminalCount)n;
}

int slterminal_resize(SLTerminalHandle terminal, unsigned cols, unsigned rows) {
    SLLinuxTerminal* t = as_terminal(terminal);
    struct winsize ws;
    if (!t || cols == 0 || rows == 0) return EINVAL;
    memset(&ws, 0, sizeof(ws));
    ws.ws_col = (unsigned short)(cols > 65535 ? 65535 : cols);
    ws.ws_row = (unsigned short)(rows > 65535 ? 65535 : rows);
#if defined(__APPLE__)
    {
        int size_fd = open(t->slave_name, O_RDWR | O_NOCTTY);
        int rc, e;
        if (size_fd < 0) return errno;
        rc = ioctl(size_fd, TIOCSWINSZ, &ws);
        e = errno;
        close(size_fd);
        return rc == 0 ? 0 : e;
    }
#else
    return ioctl(t->master, TIOCSWINSZ, &ws) == 0 ? 0 : errno;
#endif
}

int slterminal_close(SLTerminalHandle terminal) {
    SLLinuxTerminal* t = as_terminal(terminal);
    int status;
    if (!t) return EINVAL;
    close(t->master);
    if (waitpid(t->child, &status, 0) < 0) {
        int e = errno; free(t); return e;
    }
    free(t);
    return 0;
}

int slterminal_valid(SLTerminalHandle terminal) { return as_terminal(terminal) != NULL; }
int slterminal_last_error(void) { return errno; }

#endif