processInterface.cpp

Go to the documentation of this file.

/** \file processInterface.cpp
 * \author Jared R. Males (jaredmales@gmail.com)
 * \brief Process interface facilities
 * \ingroup IPC
 *
 */
 
//***********************************************************************//
// Copyright 2021 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "ipc/processInterface.hpp"
#include "mxError.hpp"
 
#include <cstring>
#include <sstream>
#include <cstdio>
#include <iostream>
 
#include <unistd.h>
#include <sys/wait.h>
 
namespace mx
{
namespace ipc
{
 
int command_response( const char *cmd, char *resp, size_t respsz )
{
    FILE *cmd_ptr;
 
    if( ( cmd_ptr = popen( cmd, "r" ) ) != NULL )
    {
        size_t written = 0;
 
        char buf[MX_IPC_PI_BUFSZ];
 
        while( fgets( buf, MX_IPC_PI_BUFSZ, cmd_ptr ) != NULL && written + 1 < respsz )
        {
            strcat( resp, buf );
            written = strlen( resp );
        }
        pclose( cmd_ptr );
    }
    else
    {
        return -1;
    }
 
    return 0;
}
 
int runCommand(
    int &retVal, // [out] the return value of the process. Only meaningful if this returns 0.
    std::vector<std::string>
        &commandOutput, // [out] the output, line by line.  If an error, first entry contains the message.
    std::vector<std::string> &commandStderr,    // [out] the output of stderr.
    const std::vector<std::string> &commandList // [in] command to be run, with one entry per command line word
)
{
    int link[2];
    int errlink[2];
 
    pid_t pid;
 
    if( pipe( link ) == -1 )
    {
        mxPError( "mx::ipc::runCommand", errno, "piping stdout" );
        return -1;
    }
 
    if( pipe( errlink ) == -1 )
    {
        mxPError( "mx::ipc::runCommand", errno, "piping stderr" );
        return -1;
    }
 
    if( ( pid = fork() ) == -1 )
    {
        mxPError( "mx::ipc::runCommand", errno, "forking" );
        return -1;
    }
 
    if( pid == 0 )
    {
        if( dup2( link[1], STDOUT_FILENO ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "dup2" );
            return -1;
        }
 
        if( close( link[0] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        if( close( link[1] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        if( dup2( errlink[1], STDERR_FILENO ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "dup2" );
            return -1;
        }
 
        if( close( errlink[0] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        if( close( errlink[1] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        std::vector<const char *> charCommandList( commandList.size() + 1, NULL );
 
        for( int index = 0; index < (int)commandList.size(); ++index )
        {
            charCommandList[index] = commandList[index].c_str();
        }
        execvp( charCommandList[0], const_cast<char **>( charCommandList.data() ) );
 
        mxPError( "mx::ipc::runCommand", errno, "execvp returned" );
 
        return -1;
    }
    else
    {
        char commandOutput_c[4096];
 
        int status;
 
        pid_t rvid = waitpid( pid, &status, 0 );
 
        if( rvid < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "waitpid" );
            return -1;
        }
 
        if( WIFEXITED( status ) )
        {
            retVal = WEXITSTATUS( status );
        }
        else
        {
            mxError( "mx::ipc::runCommand", MXE_PROCERR, "child did not exit" );
            return -1;
        }
 
        if( close( link[1] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        if( close( errlink[1] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        int rd;
        if( ( rd = read( link[0], commandOutput_c, sizeof( commandOutput_c ) ) ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "read" );
 
            if( close( errlink[0] ) < 0 )
                mxPError( "mx::ipc::runCommand", errno, "close" );
            if( close( link[0] ) < 0 )
                mxPError( "mx::ipc::runCommand", errno, "close" );
 
            return -1;
        }
 
        if( close( link[0] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            if( close( errlink[0] ) < 0 )
                mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        std::string line;
 
        commandOutput_c[rd] = '\0';
        std::string commandOutputString( commandOutput_c );
 
        std::istringstream iss( commandOutputString );
 
        while( getline( iss, line ) )
        {
            commandOutput.push_back( line );
        }
 
        //----stderr
        if( ( rd = read( errlink[0], commandOutput_c, sizeof( commandOutput_c ) ) ) < 0 )
        {
            commandStderr.push_back( std::string( "Read error on stderr: " ) + strerror( errno ) );
            if( close( errlink[0] ) < 0 )
                mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        if( close( errlink[0] ) < 0 )
        {
            mxPError( "mx::ipc::runCommand", errno, "close" );
            return -1;
        }
 
        commandOutput_c[rd] = '\0';
        commandOutputString = commandOutput_c;
 
        std::istringstream iss2( commandOutputString );
 
        while( getline( iss2, line ) )
        {
            commandStderr.push_back( line );
        }
 
        return 0;
    }
}
 
} // namespace ipc
} // namespace mx