| //===-- PseudoTerminal.cpp --------------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Created by Greg Clayton on 1/8/08. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "PseudoTerminal.h" |
| #include <stdlib.h> |
| #include <sys/ioctl.h> |
| #include <unistd.h> |
| |
| // PseudoTerminal constructor |
| PseudoTerminal::PseudoTerminal() |
| : m_primary_fd(invalid_fd), m_secondary_fd(invalid_fd) {} |
| |
| // Destructor |
| // The primary and secondary file descriptors will get closed if they are |
| // valid. Call the ReleasePrimaryFD()/ReleaseSecondaryFD() member functions |
| // to release any file descriptors that are needed beyond the lifespan |
| // of this object. |
| PseudoTerminal::~PseudoTerminal() { |
| ClosePrimary(); |
| CloseSecondary(); |
| } |
| |
| // Close the primary file descriptor if it is valid. |
| void PseudoTerminal::ClosePrimary() { |
| if (m_primary_fd > 0) { |
| ::close(m_primary_fd); |
| m_primary_fd = invalid_fd; |
| } |
| } |
| |
| // Close the secondary file descriptor if it is valid. |
| void PseudoTerminal::CloseSecondary() { |
| if (m_secondary_fd > 0) { |
| ::close(m_secondary_fd); |
| m_secondary_fd = invalid_fd; |
| } |
| } |
| |
| // Open the first available pseudo terminal with OFLAG as the |
| // permissions. The file descriptor is store in the m_primary_fd member |
| // variable and can be accessed via the PrimaryFD() or ReleasePrimaryFD() |
| // accessors. |
| // |
| // Suggested value for oflag is O_RDWR|O_NOCTTY |
| // |
| // RETURNS: |
| // Zero when successful, non-zero indicating an error occurred. |
| PseudoTerminal::Status PseudoTerminal::OpenFirstAvailablePrimary(int oflag) { |
| // Open the primary side of a pseudo terminal |
| m_primary_fd = ::posix_openpt(oflag); |
| if (m_primary_fd < 0) { |
| return err_posix_openpt_failed; |
| } |
| |
| // Grant access to the secondary pseudo terminal |
| if (::grantpt(m_primary_fd) < 0) { |
| ClosePrimary(); |
| return err_grantpt_failed; |
| } |
| |
| // Clear the lock flag on the secondary pseudo terminal |
| if (::unlockpt(m_primary_fd) < 0) { |
| ClosePrimary(); |
| return err_unlockpt_failed; |
| } |
| |
| return success; |
| } |
| |
| // Open the secondary pseudo terminal for the current primary pseudo |
| // terminal. A primary pseudo terminal should already be valid prior to |
| // calling this function (see PseudoTerminal::OpenFirstAvailablePrimary()). |
| // The file descriptor is stored in the m_secondary_fd member variable and |
| // can be accessed via the SecondaryFD() or ReleaseSecondaryFD() accessors. |
| // |
| // RETURNS: |
| // Zero when successful, non-zero indicating an error occurred. |
| PseudoTerminal::Status PseudoTerminal::OpenSecondary(int oflag) { |
| CloseSecondary(); |
| |
| // Open the primary side of a pseudo terminal |
| const char *secondary_name = SecondaryName(); |
| |
| if (secondary_name == NULL) |
| return err_ptsname_failed; |
| |
| m_secondary_fd = ::open(secondary_name, oflag); |
| |
| if (m_secondary_fd < 0) |
| return err_open_secondary_failed; |
| |
| return success; |
| } |
| |
| // Get the name of the secondary pseudo terminal. A primary pseudo terminal |
| // should already be valid prior to calling this function (see |
| // PseudoTerminal::OpenFirstAvailablePrimary()). |
| // |
| // RETURNS: |
| // NULL if no valid primary pseudo terminal or if ptsname() fails. |
| // The name of the secondary pseudo terminal as a NULL terminated C string |
| // that comes from static memory, so a copy of the string should be |
| // made as subsequent calls can change this value. |
| const char *PseudoTerminal::SecondaryName() const { |
| if (m_primary_fd < 0) |
| return NULL; |
| return ::ptsname(m_primary_fd); |
| } |
| |
| // Fork a child process that and have its stdio routed to a pseudo |
| // terminal. |
| // |
| // In the parent process when a valid pid is returned, the primary file |
| // descriptor can be used as a read/write access to stdio of the |
| // child process. |
| // |
| // In the child process the stdin/stdout/stderr will already be routed |
| // to the secondary pseudo terminal and the primary file descriptor will be |
| // closed as it is no longer needed by the child process. |
| // |
| // This class will close the file descriptors for the primary/secondary |
| // when the destructor is called, so be sure to call ReleasePrimaryFD() |
| // or ReleaseSecondaryFD() if any file descriptors are going to be used |
| // past the lifespan of this object. |
| // |
| // RETURNS: |
| // in the parent process: the pid of the child, or -1 if fork fails |
| // in the child process: zero |
| |
| pid_t PseudoTerminal::Fork(PseudoTerminal::Status &error) { |
| pid_t pid = invalid_pid; |
| error = OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY); |
| |
| if (error == 0) { |
| // Successfully opened our primary pseudo terminal |
| |
| pid = ::fork(); |
| if (pid < 0) { |
| // Fork failed |
| error = err_fork_failed; |
| } else if (pid == 0) { |
| // Child Process |
| ::setsid(); |
| |
| error = OpenSecondary(O_RDWR); |
| if (error == 0) { |
| // Successfully opened secondary |
| // We are done with the primary in the child process so lets close it |
| ClosePrimary(); |
| |
| #if defined(TIOCSCTTY) |
| // Acquire the controlling terminal |
| if (::ioctl(m_secondary_fd, TIOCSCTTY, (char *)0) < 0) |
| error = err_failed_to_acquire_controlling_terminal; |
| #endif |
| // Duplicate all stdio file descriptors to the secondary pseudo terminal |
| if (::dup2(m_secondary_fd, STDIN_FILENO) != STDIN_FILENO) |
| error = error ? error : err_dup2_failed_on_stdin; |
| if (::dup2(m_secondary_fd, STDOUT_FILENO) != STDOUT_FILENO) |
| error = error ? error : err_dup2_failed_on_stdout; |
| if (::dup2(m_secondary_fd, STDERR_FILENO) != STDERR_FILENO) |
| error = error ? error : err_dup2_failed_on_stderr; |
| } |
| } else { |
| // Parent Process |
| // Do nothing and let the pid get returned! |
| } |
| } |
| return pid; |
| } |