| //===-- PseudoTerminal.cpp --------------------------------------*- C++ -*-===// | |
| // | |
| // The LLVM Compiler Infrastructure | |
| // | |
| // This file is distributed under the University of Illinois Open Source | |
| // License. See LICENSE.TXT for details. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // 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_master_fd(invalid_fd), | |
| m_slave_fd(invalid_fd) | |
| { | |
| } | |
| //---------------------------------------------------------------------- | |
| // Destructor | |
| // The master and slave file descriptors will get closed if they are | |
| // valid. Call the ReleaseMasterFD()/ReleaseSlaveFD() member functions | |
| // to release any file descriptors that are needed beyond the lifespan | |
| // of this object. | |
| //---------------------------------------------------------------------- | |
| PseudoTerminal::~PseudoTerminal() | |
| { | |
| CloseMaster(); | |
| CloseSlave(); | |
| } | |
| //---------------------------------------------------------------------- | |
| // Close the master file descriptor if it is valid. | |
| //---------------------------------------------------------------------- | |
| void | |
| PseudoTerminal::CloseMaster() | |
| { | |
| if (m_master_fd > 0) | |
| { | |
| ::close (m_master_fd); | |
| m_master_fd = invalid_fd; | |
| } | |
| } | |
| //---------------------------------------------------------------------- | |
| // Close the slave file descriptor if it is valid. | |
| //---------------------------------------------------------------------- | |
| void | |
| PseudoTerminal::CloseSlave() | |
| { | |
| if (m_slave_fd > 0) | |
| { | |
| ::close (m_slave_fd); | |
| m_slave_fd = invalid_fd; | |
| } | |
| } | |
| //---------------------------------------------------------------------- | |
| // Open the first available pseudo terminal with OFLAG as the | |
| // permissions. The file descriptor is store in the m_master_fd member | |
| // variable and can be accessed via the MasterFD() or ReleaseMasterFD() | |
| // accessors. | |
| // | |
| // Suggested value for oflag is O_RDWR|O_NOCTTY | |
| // | |
| // RETURNS: | |
| // Zero when successful, non-zero indicating an error occurred. | |
| //---------------------------------------------------------------------- | |
| PseudoTerminal::Error | |
| PseudoTerminal::OpenFirstAvailableMaster(int oflag) | |
| { | |
| // Open the master side of a pseudo terminal | |
| m_master_fd = ::posix_openpt (oflag); | |
| if (m_master_fd < 0) | |
| { | |
| return err_posix_openpt_failed; | |
| } | |
| // Grant access to the slave pseudo terminal | |
| if (::grantpt (m_master_fd) < 0) | |
| { | |
| CloseMaster(); | |
| return err_grantpt_failed; | |
| } | |
| // Clear the lock flag on the slave pseudo terminal | |
| if (::unlockpt (m_master_fd) < 0) | |
| { | |
| CloseMaster(); | |
| return err_unlockpt_failed; | |
| } | |
| return success; | |
| } | |
| //---------------------------------------------------------------------- | |
| // Open the slave pseudo terminal for the current master pseudo | |
| // terminal. A master pseudo terminal should already be valid prior to | |
| // calling this function (see PseudoTerminal::OpenFirstAvailableMaster()). | |
| // The file descriptor is stored in the m_slave_fd member variable and | |
| // can be accessed via the SlaveFD() or ReleaseSlaveFD() accessors. | |
| // | |
| // RETURNS: | |
| // Zero when successful, non-zero indicating an error occurred. | |
| //---------------------------------------------------------------------- | |
| PseudoTerminal::Error | |
| PseudoTerminal::OpenSlave(int oflag) | |
| { | |
| CloseSlave(); | |
| // Open the master side of a pseudo terminal | |
| const char *slave_name = SlaveName(); | |
| if (slave_name == NULL) | |
| return err_ptsname_failed; | |
| m_slave_fd = ::open (slave_name, oflag); | |
| if (m_slave_fd < 0) | |
| return err_open_slave_failed; | |
| return success; | |
| } | |
| //---------------------------------------------------------------------- | |
| // Get the name of the slave pseudo terminal. A master pseudo terminal | |
| // should already be valid prior to calling this function (see | |
| // PseudoTerminal::OpenFirstAvailableMaster()). | |
| // | |
| // RETURNS: | |
| // NULL if no valid master pseudo terminal or if ptsname() fails. | |
| // The name of the slave 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::SlaveName() const | |
| { | |
| if (m_master_fd < 0) | |
| return NULL; | |
| return ::ptsname (m_master_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 master 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 slave pseudo terminal and the master file descriptor will be | |
| // closed as it is no longer needed by the child process. | |
| // | |
| // This class will close the file descriptors for the master/slave | |
| // when the destructor is called, so be sure to call ReleaseMasterFD() | |
| // or ReleaseSlaveFD() 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::Error& error) | |
| { | |
| pid_t pid = invalid_pid; | |
| error = OpenFirstAvailableMaster (O_RDWR|O_NOCTTY); | |
| if (error == 0) | |
| { | |
| // Successfully opened our master pseudo terminal | |
| pid = ::fork (); | |
| if (pid < 0) | |
| { | |
| // Fork failed | |
| error = err_fork_failed; | |
| } | |
| else if (pid == 0) | |
| { | |
| // Child Process | |
| ::setsid(); | |
| error = OpenSlave (O_RDWR); | |
| if (error == 0) | |
| { | |
| // Successfully opened slave | |
| // We are done with the master in the child process so lets close it | |
| CloseMaster (); | |
| #if defined (TIOCSCTTY) | |
| // Acquire the controlling terminal | |
| if (::ioctl (m_slave_fd, TIOCSCTTY, (char *)0) < 0) | |
| error = err_failed_to_acquire_controlling_terminal; | |
| #endif | |
| // Duplicate all stdio file descriptors to the slave pseudo terminal | |
| if (::dup2 (m_slave_fd, STDIN_FILENO) != STDIN_FILENO) | |
| error = error ? error : err_dup2_failed_on_stdin; | |
| if (::dup2 (m_slave_fd, STDOUT_FILENO) != STDOUT_FILENO) | |
| error = error ? error : err_dup2_failed_on_stdout; | |
| if (::dup2 (m_slave_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; | |
| } |