// SPDX-License-Identifier: GPL-3.0-or-later #include "DriveWireShell.h" #include "DriveWireTerminal.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace VCC::Mac { namespace { using Transport = Devices::DriveWireTransport; using State = Transport::State; using namespace std::chrono_literals; constexpr std::size_t queueLimit = 65536; struct Child { pid_t pid = -1; int master = -1; ~Child() { if (master >= 0) ::close(master); } }; // Spawn directly into a fresh session. The child gets only its three tty // descriptors and a small interactive environment. No login helper, command // string, or user-supplied executable path is involved. bool spawnShell(Child& child, DriveWireShell::StartupFiles startup) { passwd record{}, *user = nullptr; std::array account{}; if (::getpwuid_r(::getuid(), &record, account.data(), account.size(), &user) || !user) return false; std::string home = record.pw_dir, shell = record.pw_shell, name = record.pw_name; if (home.empty() || home.front() != '/' || shell.empty() || shell.front() != '/') return false; int slave = -1; winsize size{24, 80, 0, 0}; char tty[PATH_MAX]{}; if (::openpty(&child.master, &slave, tty, nullptr, &size) != 0) return false; if (::fcntl(child.master, F_SETFD, FD_CLOEXEC) < 0 || ::fcntl(slave, F_SETFD, FD_CLOEXEC) < 0 || ::fcntl(child.master, F_SETFL, O_NONBLOCK) < 0) { ::close(slave); return false; } termios modes{}; if (::tcgetattr(slave, &modes) == 0) { modes.c_cc[VERASE] = 8; // CoCo backspace ::tcsetattr(slave, TCSANOW, &modes); } std::string term = "TERM=vt100", path = "PATH=/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin"; std::string dir = "HOME=" + home, login = "LOGNAME=" + name, uid = "USER=" + name, sh = "SHELL=" + shell; std::string locale = "LANG=en_US.UTF-8", prompt = "PS1=$ ", history = "HISTFILE=/dev/null"; // Ordinary sessions use the account's interactive login shell. Only // the integration tests suppress personal startup scripts and history. auto base = shell.substr(shell.find_last_of('/') + 1); bool isolated = startup == DriveWireShell::StartupFiles::isolatedTest; if (isolated && base != "zsh" && base != "bash") { shell = "/bin/sh"; sh = "SHELL=" + shell; base = "sh"; } std::vector options{isolated ? base : "-" + base}; if (isolated && base == "zsh") options.insert(options.end(), {"-f", "-o", "no_zle"}); if (isolated && base == "bash") options.insert(options.end(), {"--noprofile", "--norc", "--noediting"}); options.emplace_back("-i"); std::vector args; for (auto& option : options) args.push_back(option.data()); args.push_back(nullptr); std::vector env{dir.data(), login.data(), uid.data(), sh.data(), term.data(), path.data(), locale.data()}; if (isolated) { env.push_back(prompt.data()); env.push_back(history.data()); } env.push_back(nullptr); // These pointers and limits are computed before fork. The child of the // multithreaded Mac app uses only descriptor/signal syscalls and execve. auto executable = shell.c_str(); auto directory = home.c_str(); auto arguments = args.data(); auto environment = env.data(); const int maxFD = static_cast(::sysconf(_SC_OPEN_MAX)); int handshake[2]{}; if (maxFD < 3 || ::pipe(handshake) < 0) { ::close(slave); return false; } if (::fcntl(handshake[0], F_SETFD, FD_CLOEXEC) < 0 || ::fcntl(handshake[1], F_SETFD, FD_CLOEXEC) < 0) { ::close(slave); ::close(handshake[0]); ::close(handshake[1]); return false; } sigset_t mask; sigemptyset(&mask); struct sigaction defaults{}; defaults.sa_handler = SIG_DFL; sigemptyset(&defaults.sa_mask); child.pid = ::fork(); if (child.pid == 0) { ::close(handshake[0]); bool ok = ::setsid() >= 0 && ::ioctl(slave, TIOCSCTTY, 0) == 0; for (int fd = 0; ok && fd < 3; ++fd) ok = ::dup2(slave, fd) >= 0 && ::fcntl(fd, F_SETFD, 0) == 0; for (int fd = 3; fd < maxFD; ++fd) if (fd != handshake[1]) ::close(fd); for (int signal = 1; signal < NSIG; ++signal) { if (signal != SIGKILL && signal != SIGSTOP) ::sigaction(signal, &defaults, nullptr); } ::sigprocmask(SIG_SETMASK, &mask, nullptr); if (ok && ::chdir(directory) == 0) ::execve(executable, arguments, environment); const char failed = 1; (void)::write(handshake[1], &failed, 1); _exit(127); } ::close(slave); ::close(handshake[1]); char failure; ssize_t result; do { result = ::read(handshake[0], &failure, 1); } while (result < 0 && errno == EINTR); ::close(handshake[0]); if (child.pid < 0) return false; if (result == 0) return true; while (::waitpid(child.pid, nullptr, 0) < 0 && errno == EINTR) {} return false; } void hangup(Child& child) { // Closing a controlling tty sends HUP to its foreground group. Also signal // the shell's own group when a foreground job has taken control. Keep its // pid unreaped until sending signals is finished to avoid pid reuse. pid_t foreground = ::tcgetpgrp(child.master); if (foreground > 0 && foreground != child.pid && ::getsid(foreground) == child.pid) { ::kill(-foreground, SIGHUP); ::kill(-foreground, SIGCONT); // Explicit revocation must also stop a foreground program that traps // terminal hangups. Limit the signal to the shell's own session. if (::getsid(foreground) == child.pid) ::kill(-foreground, SIGKILL); } ::kill(-child.pid, SIGHUP); ::kill(-child.pid, SIGCONT); ::close(child.master); child.master = -1; for (unsigned i = 0; i < 20; ++i) { int status = 0; pid_t done = ::waitpid(child.pid, &status, WNOHANG); if (done == child.pid || (done < 0 && errno == ECHILD)) return; std::this_thread::sleep_for(10ms); } ::kill(child.pid, SIGKILL); while (::waitpid(child.pid, nullptr, 0) < 0 && errno == EINTR) {} } // Option (the CoCo Alt key) distinguishes cursor keys from OS-9 editing // characters. The stock telnet client sends the corresponding high-bit codes. char cursorDirection(std::uint8_t key) { switch (key) { case 0x8c: return 'A'; // up case 0x8a: return 'B'; // down case 0x89: return 'C'; // right case 0x88: return 'D'; // left default: return 0; } } class Terminal { public: std::atomic state{State::connecting}; std::atomic stopped{false}; std::atomic launched{false}; const std::chrono::steady_clock::time_point expires = std::chrono::steady_clock::now() + 2min; bool waiting() const { return !launched && !stopped && state == State::connecting && std::chrono::steady_clock::now() < expires; } State transportState() const { if (!launched && !waiting()) return State::failed; return stopped ? State::closed : state.load(); } void cancel() { std::lock_guard lock(mutex); stopped = true; incoming.clear(); outgoing.clear(); } std::size_t read(std::uint8_t* bytes, std::size_t count) { std::lock_guard lock(mutex); if (stopped) return 0; count = std::min(count, incoming.size()); std::copy_n(incoming.begin(), count, bytes); incoming.erase(incoming.begin(), incoming.begin() + count); return count; } bool write(const std::uint8_t* bytes, std::size_t count) { std::lock_guard lock(mutex); if (stopped || state != State::connected || count > queueLimit - outgoing.size()) return false; // The stock OS-9 telnet client sends its abort byte for CoCo Break // (Mac Escape). Backspace and Tab also double as left/right on the // wire; keep their normal shell meanings. const auto arrows = std::count_if(bytes, bytes + count, cursorDirection); if (count + 2 * arrows > queueLimit - outgoing.size()) return false; for (std::size_t i = 0; i < count; ++i) { if (auto direction = cursorDirection(bytes[i])) { outgoing.push_back(0x1b); outgoing.push_back(applicationKeys ? 'O' : '['); outgoing.push_back(direction); } else { outgoing.push_back(bytes[i] == 0x05 ? 0x1b : bytes[i]); } } return true; } void run(DriveWireShell::StartupFiles startup) { Child child; if (stopped || !spawnShell(child, startup)) { state = State::failed; return; } state = State::connected; bool reaped = false; DriveWireTerminal terminal; std::vector display; std::size_t displayOffset = 0; while (!stopped) { std::array data{}; std::size_t room, pending; { std::lock_guard lock(mutex); // One PTY read can expand into a screen redraw. Drain that redraw // in order before consuming more output, even after shell exit. auto transfer = std::min(display.size() - displayOffset, queueLimit - incoming.size()); incoming.insert(incoming.end(), display.begin() + displayOffset, display.begin() + displayOffset + transfer); displayOffset += transfer; room = displayOffset == display.size() && incoming.size() < queueLimit ? data.size() : 0; pending = std::min(data.size(), outgoing.size()); } if (!reaped) { pid_t result = ::waitpid(child.pid, nullptr, WNOHANG); reaped = result == child.pid || (result < 0 && errno == ECHILD); } pollfd descriptor{child.master, short((room ? POLLIN : 0) | (pending ? POLLOUT : 0)), 0}; if (!room && !pending) { std::this_thread::sleep_for(10ms); continue; } int result = ::poll(&descriptor, 1, 10); if (result < 0 && errno == EINTR) continue; if (result < 0) break; if (pending && (descriptor.revents & POLLOUT)) { std::lock_guard lock(mutex); if (stopped) break; std::copy_n(outgoing.begin(), pending, data.begin()); auto sent = ::write(child.master, data.data(), pending); // non-blocking PTY if (sent > 0) outgoing.erase(outgoing.begin(), outgoing.begin() + sent); else if (sent < 0 && errno != EINTR && errno != EAGAIN) break; } if (room && (descriptor.revents & (POLLIN | POLLHUP | POLLERR))) { auto n = ::read(child.master, data.data(), room); if (n > 0) { display = terminal.consume(data.data(), static_cast(n)); displayOffset = 0; auto replies = terminal.takeReply(); std::lock_guard lock(mutex); applicationKeys = terminal.applicationCursor(); if (stopped || replies.size() > queueLimit - outgoing.size()) break; outgoing.insert(outgoing.end(), replies.begin(), replies.end()); continue; // collect any final output before reporting EOF } if (n < 0 && errno == EINTR) continue; if (n <= 0 && (n == 0 || errno != EAGAIN || reaped)) break; } if (reaped && room) break; } if (!reaped) hangup(child); state = State::closed; } private: std::mutex mutex; std::deque incoming, outgoing; bool applicationKeys = false; // guarded by mutex }; class ShellChannel final : public Transport { public: explicit ShellChannel(std::shared_ptr terminal) : terminal(std::move(terminal)) {} ~ShellChannel() override { terminal->cancel(); } State state() override { return terminal->transportState(); } std::size_t read(std::uint8_t* bytes, std::size_t count) override { return terminal->read(bytes, count); } bool write(const std::uint8_t* bytes, std::size_t count) override { return terminal->write(bytes, count); } private: std::shared_ptr terminal; }; } struct DriveWireShell::Impl { explicit Impl(StartupFiles startup) : startup(startup) {} StartupFiles startup; mutable std::mutex mutex; std::chrono::steady_clock::time_point readyUntil{}; std::weak_ptr active; std::uint64_t sequence = 0, pendingID = 0; void clear() { readyUntil = {}; pendingID = 0; if (auto current = active.lock()) current->cancel(); active.reset(); } void start(const std::shared_ptr& live) { live->launched = true; try { std::thread([live, files = startup]{ live->run(files); }).detach(); } catch (const std::system_error&) { live->state = State::failed; } } }; DriveWireShell::DriveWireShell(StartupFiles files) : impl(std::make_unique(files)) {} DriveWireShell::~DriveWireShell() { stop(); } void DriveWireShell::arm() { std::lock_guard lock(impl->mutex); impl->clear(); impl->readyUntil = std::chrono::steady_clock::now() + 2min; } void DriveWireShell::stop() { std::lock_guard lock(impl->mutex); impl->clear(); } std::string DriveWireShell::status() const { std::lock_guard lock(impl->mutex); if (std::chrono::steady_clock::now() < impl->readyUntil) return "ready"; if (auto live = impl->active.lock()) { if (live->waiting()) return "requested"; auto state = live->transportState(); if (state == State::connecting || state == State::connected) return "connected"; } return "idle"; } std::uint64_t DriveWireShell::requestID() const { std::lock_guard lock(impl->mutex); auto live = impl->active.lock(); return live && live->waiting() ? impl->pendingID : 0; } bool DriveWireShell::decide(std::uint64_t id, bool allow) { std::lock_guard lock(impl->mutex); auto live = impl->active.lock(); if (!id || id != impl->pendingID || !live || !live->waiting()) return false; impl->pendingID = 0; if (allow) impl->start(live); else live->state = State::failed; return true; } std::unique_ptr DriveWireShell::connect() { std::lock_guard lock(impl->mutex); if (auto live = impl->active.lock()) { auto state = live->transportState(); if (state == State::connecting || state == State::connected) return {}; } auto live = std::make_shared(); auto channel = std::make_unique(live); impl->active = live; if (std::chrono::steady_clock::now() < impl->readyUntil) { impl->readyUntil = {}; impl->pendingID = 0; impl->start(live); } else { if (!++impl->sequence) ++impl->sequence; impl->pendingID = impl->sequence; } return channel; } }