tim::popen Namespace Reference

Classes
struct	group_info
struct	TIMEMORY_PIPE

Typedefs
using	string_t = std::string
using	strvec_t = std::vector< string_t >

Functions
group_info &	get_group_info ()
void	drop_privileges (int permanent)
void	restore_privileges ()
int	open_devnull (int fd)
void	sanitize_files ()
pid_t	fork ()
TIMEMORY_PIPE *	popen (const char *path, char **argv, char **envp)
int	pclose (TIMEMORY_PIPE *p)
strvec_t	read_fork (TIMEMORY_PIPE *proc, int max_counter)
std::ostream &	flush_output (std::ostream &os, TIMEMORY_PIPE *proc, int max_counter)
	TIMEMORY_UTILITY_LINKAGE (TIMEMORY_PIPE *) popen(const char *path
	TIMEMORY_UTILITY_LINKAGE (int) pclose(TIMEMORY_PIPE *p)
	TIMEMORY_UTILITY_LINKAGE (pid_t) fork()
	TIMEMORY_UTILITY_LINKAGE (void) sanitize_files()
	TIMEMORY_UTILITY_LINKAGE (strvec_t) read_fork(TIMEMORY_PIPE *proc

Variables
char **	argv = nullptr
char char **	envp = nullptr)
int	max_counter = 50)

---

Class Documentation

tim::popen::group_info

struct tim::popen::group_info

Definition at line 55 of file popen.cpp.

Collaboration diagram for tim::popen::group_info:

Class Members
gid_t	group_id
gid_t	groups[16]
int	ngroups
uid_t	user_id

tim::popen::TIMEMORY_PIPE

struct tim::popen::TIMEMORY_PIPE

Definition at line 60 of file popen.hpp.

Collaboration diagram for tim::popen::TIMEMORY_PIPE:

Class Members
pid_t	child_pid
int	child_status
FILE *	read_fd
FILE *	write_fd

Typedef Documentation

string_t

using tim::popen::string_t = typedef std::string

Definition at line 57 of file popen.hpp.

strvec_t

using tim::popen::strvec_t = typedef std::vector<string_t>

Definition at line 58 of file popen.hpp.

Function Documentation

drop_privileges()

void tim::popen::drop_privileges

(

int

permanent

)

Definition at line 75 of file popen.cpp.

{
    gid_t newgid = getgid();
    gid_t oldgid = getegid();
    uid_t newuid = getuid();
    uid_t olduid = geteuid();
 
    if(permanent == 0)
    {
        // Save information about the privileges that are being dropped so that they
        // can be restored later.
        //
        get_group_info().group_id = oldgid;
        get_group_info().user_id  = olduid;
        get_group_info().ngroups  = getgroups(NGROUPS_MAX, get_group_info().groups);
    }
 
    // If root privileges are to be dropped, be sure to pare down the ancillary
    // groups for the process before doing anything else because the setgroups(  )
    // system call requires root privileges.  Drop ancillary groups regardless of
    // whether privileges are being dropped temporarily or permanently.
    //
    if(olduid == 0)
        setgroups(1, &newgid);
 
    if(newgid != oldgid)
    {
#    if !defined(TIMEMORY_LINUX)
        auto ret = setegid(newgid);
        if(ret != 0)
            abort();
        if(permanent != 0 && setgid(newgid) == -1)
            abort();
#    else
        if(setregid(((permanent != 0) ? newgid : oldgid), newgid) == -1)
            abort();
#    endif
    }
 
    if(newuid != olduid)
    {
#    if !defined(TIMEMORY_LINUX)
        auto ret = seteuid(newuid);
        if(ret != 0)
            abort();
        if(permanent != 0 && setuid(newuid) == -1)
            abort();
#    else
        if(setreuid(((permanent != 0) ? newuid : olduid), newuid) == -1)
            abort();
#    endif
    }
 
    // verify that the changes were successful
    if(permanent != 0)
    {
        if(newgid != oldgid && (setegid(oldgid) != -1 || getegid() != newgid))
            abort();
        if(newuid != olduid && (seteuid(olduid) != -1 || geteuid() != newuid))
            abort();
    }
    else
    {
        if(newgid != oldgid && getegid() != newgid)
            abort();
        if(newuid != olduid && geteuid() != newuid)
            abort();
    }
}

References get_group_info(), tim::popen::group_info::group_id, tim::popen::group_info::ngroups, NGROUPS_MAX, and tim::popen::group_info::user_id.

Referenced by fork().

flush_output()

std::ostream & tim::popen::flush_output	(	std::ostream &	os,
		TIMEMORY_PIPE *	proc,
		int	max_counter
	)

Definition at line 426 of file popen.cpp.

{
    int counter = 0;
    while(proc)
    {
        char  buffer[4096];
        auto* ret = fgets(buffer, 4096, proc->read_fd);
        if(ret == nullptr || strlen(buffer) == 0)
        {
            if(max_counter == 0)
            {
                pid_t cpid = waitpid(proc->child_pid, &proc->child_status, WNOHANG);
                if(cpid == 0)
                    continue;
                else
                    break;
            }
            if(counter++ > max_counter)
                break;
            continue;
        }
        os << string_t{ buffer } << std::flush;
    }
 
    return os;
}

References tim::popen::TIMEMORY_PIPE::child_pid, tim::popen::TIMEMORY_PIPE::child_status, max_counter, tim::os, and tim::popen::TIMEMORY_PIPE::read_fd.

Referenced by tim::if().

fork()

pid_t tim::popen::fork

(

)

Definition at line 208 of file popen.cpp.

{
    pid_t childpid;
 
    if((childpid = ::fork()) == -1)
        return -1;
 
    // If this is the parent process, there's nothing more to do
    if(childpid != 0)
        return childpid;
 
    // This is the child process
    popen::sanitize_files();    // Close all open files.
    popen::drop_privileges(1);  // Permanently drop privileges.
 
    return 0;
}

References drop_privileges(), fork(), and sanitize_files().

Referenced by fork(), and popen().

get_group_info()

group_info & tim::popen::get_group_info ( )

inline

Definition at line 66 of file popen.cpp.

{
    static group_info _instance;
    return _instance;
}

Referenced by drop_privileges(), and restore_privileges().

open_devnull()

int tim::popen::open_devnull

(

int

fd

)

Definition at line 165 of file popen.cpp.

{
    FILE* f = nullptr;
    switch(fd)
    {
        case 0: f = freopen("/dev/null", "rb", stdin); break;
        case 1: f = freopen("/dev/null", "wb", stdout); break;
        case 2: f = freopen("/dev/null", "wb", stderr); break;
        default: break;
    }
    return (f != nullptr && fileno(f) == fd) ? 1 : 0;
}

Referenced by sanitize_files().

pclose()

int tim::popen::pclose

(

TIMEMORY_PIPE *

p

)

Definition at line 327 of file popen.cpp.

{
    int   status = p->child_status;
    pid_t pid    = -1;
 
    // clean up memory
    auto _clean = [&]() {
        if(p->read_fd)
            fclose(p->read_fd);
        if(p->write_fd)
            fclose(p->write_fd);
        delete p;
    };
 
    if(status != std::numeric_limits<int>::max())
    {
        _clean();
        if(WIFEXITED(status))
        {
            // printf("process %i exited, status=%d\n", p->child_pid,
            // WEXITSTATUS(status));
            return EXIT_SUCCESS;
        }
        else if(WIFSIGNALED(status))
        {
            printf("process %i killed by signal %d\n", p->child_pid, WTERMSIG(status));
            return EXIT_FAILURE;
        }
        else if(WIFSTOPPED(status))
        {
            printf("process %i stopped by signal %d\n", p->child_pid, WSTOPSIG(status));
            // return EXIT_FAILURE;
        }
        else if(WIFCONTINUED(status))
        {
            printf("process %i continued\n", p->child_pid);
            // return EXIT_FAILURE;
        }
    }
    else
    {
        if(p->child_pid != -1)
        {
            do
            {
                pid = waitpid(p->child_pid, &status, 0);
            } while(pid == -1 && errno == EINTR);
        }
    }
    _clean();
    if(pid != -1 && WIFEXITED(status))
        return WEXITSTATUS(status);
    return (pid == -1 ? -1 : 0);
}

References tim::popen::TIMEMORY_PIPE::child_pid, tim::popen::TIMEMORY_PIPE::child_status, std::max(), tim::popen::TIMEMORY_PIPE::read_fd, and tim::popen::TIMEMORY_PIPE::write_fd.

popen()

TIMEMORY_PIPE * tim::popen::popen	(	const char *	path,
		char **	argv,
		char **	envp
	)

Definition at line 229 of file popen.cpp.

{
    int            stdin_pipe[2]  = { 0, 0 };
    int            stdout_pipe[2] = { 0, 0 };
    TIMEMORY_PIPE* p              = nullptr;
 
    static char** _argv = []() {
        static auto* _tmp = new char*[1];
        _tmp[0]           = nullptr;
        return _tmp;
    }();
 
    if(envp == nullptr)
        envp = environ;
    if(argv == nullptr)
        argv = _argv;
 
    p = new TIMEMORY_PIPE;
 
    if(!p)
        return nullptr;
 
    p->read_fd   = nullptr;
    p->write_fd  = nullptr;
    p->child_pid = -1;
 
    if(pipe(stdin_pipe) == -1)
    {
        delete p;
        return nullptr;
    }
 
    if(pipe(stdout_pipe) == -1)
    {
        close(stdin_pipe[1]);
        close(stdin_pipe[0]);
        delete p;
        return nullptr;
    }
 
    if(!(p->read_fd = fdopen(stdout_pipe[0], "r")))
    {
        close(stdout_pipe[1]);
        close(stdout_pipe[0]);
        close(stdin_pipe[1]);
        close(stdin_pipe[0]);
        delete p;
        return nullptr;
    }
 
    if(!(p->write_fd = fdopen(stdin_pipe[1], "w")))
    {
        fclose(p->read_fd);
        close(stdout_pipe[1]);
        close(stdin_pipe[1]);
        close(stdin_pipe[0]);
        delete p;
        return nullptr;
    }
 
    if((p->child_pid = popen::fork()) == -1)
    {
        fclose(p->write_fd);
        fclose(p->read_fd);
        close(stdout_pipe[1]);
        close(stdin_pipe[0]);
        delete p;
        return nullptr;
    }
 
    if(p->child_pid == 0)
    {
        // this is the child process
        close(stdout_pipe[0]);
        close(stdin_pipe[1]);
        if(stdin_pipe[0] != 0)
        {
            dup2(stdin_pipe[0], 0);
            close(stdin_pipe[0]);
        }
        if(stdout_pipe[1] != 1)
        {
            dup2(stdout_pipe[1], 1);
            close(stdout_pipe[1]);
        }
        execve(path, argv, envp);
        exit(127);
    }
 
    close(stdout_pipe[1]);
    close(stdin_pipe[0]);
 
    return p;
}

References argv, tim::popen::TIMEMORY_PIPE::child_pid, tim::plotting::close(), environ, envp, fork(), tim::popen::TIMEMORY_PIPE::read_fd, and tim::popen::TIMEMORY_PIPE::write_fd.

Referenced by tim::if().

read_fork()

strvec_t tim::popen::read_fork	(	TIMEMORY_PIPE *	proc,
		int	max_counter
	)

Definition at line 385 of file popen.cpp.

{
    int      counter = 0;
    strvec_t linked_libraries;
 
    while(proc)
    {
        char  buffer[4096];
        auto* ret = fgets(buffer, 4096, proc->read_fd);
        if(ret == nullptr || strlen(buffer) == 0)
        {
            if(max_counter == 0)
            {
                pid_t cpid = waitpid(proc->child_pid, &proc->child_status, WNOHANG);
                if(cpid == 0)
                    continue;
                else
                    break;
            }
            if(counter++ > max_counter)
                break;
            continue;
        }
        auto line = string_t(buffer);
        auto loc  = string_t::npos;
        while((loc = line.find_first_of("\n\t")) != string_t::npos)
            line.erase(loc, 1);
        auto delim = delimit(line, " \n\t=>");
        for(const auto& itr : delim)
        {
            if(itr.find('/') == 0)
                linked_libraries.push_back(itr);
        }
    }
 
    return linked_libraries;
}

References tim::popen::TIMEMORY_PIPE::child_pid, tim::popen::TIMEMORY_PIPE::child_status, tim::delimit(), max_counter, and tim::popen::TIMEMORY_PIPE::read_fd.

restore_privileges()

void tim::popen::restore_privileges

(

)

Definition at line 148 of file popen.cpp.

{
    if(geteuid() != get_group_info().user_id)
        if(seteuid(get_group_info().user_id) == -1 ||
           geteuid() != get_group_info().user_id)
            abort();
    if(getegid() != get_group_info().group_id)
        if(setegid(get_group_info().group_id) == -1 ||
           getegid() != get_group_info().group_id)
            abort();
    if(get_group_info().user_id == 0U)
        setgroups(get_group_info().ngroups, get_group_info().groups);
}

References get_group_info().

sanitize_files()

void tim::popen::sanitize_files

(

)

Definition at line 181 of file popen.cpp.

{
    // int         fds;
    struct stat st;
 
    // Make sure all open descriptors other than the standard ones are closed
    // if((fds = getdtablesize()) == -1)
    //    fds = OPEN_MAX;
 
    // closing these files results in the inability to read the pipe from the parent
    // for(int fd = 3; fd < fds; ++fd)
    //    close(fd);
 
    // Verify that the standard descriptors are open.  If they're not, attempt to
    // open them using /dev/null.  If any are unsuccessful, abort.
    for(int fd = 0; fd < 3; ++fd)
    {
        if(fstat(fd, &st) == -1 && (errno != EBADF || open_devnull(fd) == 0))
        {
            abort();
        }
    }
}

References open_devnull().

Referenced by fork().

TIMEMORY_UTILITY_LINKAGE() [1/5]

tim::popen::TIMEMORY_UTILITY_LINKAGE

(

int

)

TIMEMORY_UTILITY_LINKAGE() [2/5]

tim::popen::TIMEMORY_UTILITY_LINKAGE

(

pid_t

)

TIMEMORY_UTILITY_LINKAGE() [3/5]

tim::popen::TIMEMORY_UTILITY_LINKAGE

(

strvec_t

)

TIMEMORY_UTILITY_LINKAGE() [4/5]

tim::popen::TIMEMORY_UTILITY_LINKAGE

(

TIMEMORY_PIPE *

)

const

TIMEMORY_UTILITY_LINKAGE() [5/5]

tim::popen::TIMEMORY_UTILITY_LINKAGE

(

void

)

Variable Documentation

argv

char** tim::popen::argv = nullptr

Definition at line 69 of file popen.hpp.

Referenced by popen().

envp

char char** tim::popen::envp = nullptr)

Definition at line 69 of file popen.hpp.

Referenced by popen().

max_counter

int tim::popen::max_counter = 50)

Definition at line 90 of file popen.hpp.

Referenced by flush_output(), and read_fork().