//===-- 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;
}