/* This file is part of dvi2bitmap; see README for copyrights and licence */
#include <config.h>
#include <PipeStream.h>
#include <Util.h>
#include <iostream>
#ifdef HAVE_CSTD_INCLUDE
# include <cstdio>
# include <cstdlib>
# include <cstring>
# include <cctype>
# include <cerrno>
#else
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <ctype.h>
# include <errno.h>
#endif
// the assert headers appear to be slightly less predictable...
#if HAVE_CASSERT
# include <cassert>
#elif HAVE_ASSERT_H
# include <assert.h>
#endif
#include <unistd.h> // this is standard according to single-unix,
// how POSIXy is that? How C++?
/*
* Include <signal.h>, and don't bother with <csignal>, which brings
* with it a number of problems related to declarations. Some of
* these are minor ones related to whether functions are or are not in
* std, but most are because only a subset of Unix/POSIX signal
* handling is part of the C++ standard, and we want to use more.
* This whole class is probably fairly Unix-specific, and this doesn't
* magically go away if we include <csignal>.
*
* If it's available, explicitly include sys/signal.h as well as
* <csignal> or <signal.h>. If we're compiling in a strict-ansi mode,
* the compiler may well have carefully avoided including these
* signals specific to Unix/POSIX, which are, of course, precisely the
* ones we're hoping to use.
*
* Include <sys/signal.h> first: if <signal.h> includes it for us,
* then it will probably define sentinels which will stop us including
* it a second time.
*/
#if HAVE_SYS_SIGNAL_H
# include <sys/signal.h>
#endif
#include <signal.h>
#ifdef HAVE_SYS_WAIT_H
# include <sys/wait.h>
#endif
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
#include <map>
using STD::ostream;
using STD::ends;
using STD::endl;
using STD::cerr;
#include <stringstream.h>
#ifndef WIN32
/**
* Takes care of the signal handling necessary for the functions in
* the {@link PipeStream} class. If your application for whatever
* reason has to catch <code>SIGCHLD</code>, then to avoid interference
* between these, you should do so using functions {@link
* #expectAnother} and {@link #got_status}. These two functions are the
* only `public' API in this namespace.
*/
namespace PipeStreamSignalHandling {
/* Handle SIGCHLDs by maintaining a set of pid/caught-status pairs. */
struct process_status {
sig_atomic_t pid;
sig_atomic_t status;
process_status() : pid(0), status(-1) { }
void clear() { pid=0; status=-1; }
};
struct process_status* procs = 0; // initial value triggers initialisation
sig_atomic_t nprocs; // max no of children we can wait for
sig_atomic_t nprocs_used; // number of slots used
bool got_status(pid_t pid, int* status);
void expectAnother() throw (InputByteStreamError);
extern "C" void childcatcher(int);
extern "C" void alarmcatcher(int);
}
#endif
/**
* Creates a stream which returns the output of a given command. The
* constructor open a pipe with the given command, and prepares for
* the results to be read by this class's accessor methods.
*
* <p>If the second argument is omitted, then a default list of
* environment variables, namely <code>PATH HOME LOGNAME SHELL TMPDIR</code>,
* are inherited from the current environment. If present, it should
* be a space-separated list of environment variables with optional
* values: if no equal sign is present, the variable's value is
* inherited from the current environment. For example, if this list
* is given as in the form <code>env1=val1 env2= env3</code>, then
* <code>env1</code> would receive the value <code>val1</code>,
* <code>env2</code> would receive a null value, and <code>env3</code>
* would be inherited.
*
* <p>If the command exits with a non-zero exit status, this is noted
* on <code>stderr</code>, but any output from the command is still returned.
*
* <p>If there's no way of doing this on a particular platform, throw
* <code>InputByteStreamError</code> always.
*
* @param cmd the command to be run
*
* @param envs if specified, this is a list of environment variables;
* if it is an empty string, <code>""</code> (the default), then a
* default list of variables is inherited
*
* @throws InputByteStreamError on any errors
*/
PipeStream::PipeStream (string cmd, string envs)
throw (InputByteStreamError)
: pipe_status_(-1), pid_(0), orig_command_(cmd)
{
#ifdef HAVE_PIPE
/*
* Can't use popen, because we want to control the environment
* more. Initialisation of kpathsea adds settings to the
* environment which confuse an invocation of mktexpk.
*
* Implementation here follows useful example in
* <http://www.erack.de/download/pipe-fork.c>
*/
PipeStreamSignalHandling::expectAnother();
int fd[2];
if (pipe(fd))
throw new DviError("PipeStream: failed to create pipe");
pid_ = fork();
if (pid_ < 0) {
throw new DviError("PipeStream: failed to fork");
} else if (pid_ == 0) {
// ...in child. We will write to the pipe, so immediately
// close the reading end
::close(fd[0]);
// And we want our stdout to go down the writing end
dup2(fd[1], STDOUT_FILENO);
::close(fd[1]);
char **argv = Util::string_list_to_array(Util::tokenise_string(cmd));
string defenvs = "PATH HOME LOGNAME SHELL TMPDIR";
string_list envlist;
if (envs == "") {
envs = "+"; // triggers processing below
}
STD::map<string,string> env;
for (string_list e = Util::tokenise_string(envs);
! e.empty();
e.pop_front()) {
if (e.front() == "+") {
e.pop_front(); // the "+"
string_list de = Util::tokenise_string(defenvs);
while (! de.empty()) {
e.push_front(de.front());
de.pop_front();
}
if (getVerbosity() > normal) {
cerr << "Added: now";
for (string_list::const_iterator ci = e.begin();
ci != e.end();
ci++) {
cerr << " " << *ci;
}
cerr << endl;
}
}
string& s = e.front();
size_t si = s.find('=');
if (si == string::npos) {
// no setting found
char *envval = getenv(s.c_str());
if (envval != 0) {
//cerr << "set [" << s << "]=" << envval << endl;
env[s] = envval;
}
} else {
// value found
env[s.substr(0,si)] = s.substr(si+1);
//cerr << "substr: [" << s.substr(0,si) << "]=" << s.substr(si+1) << endl;
}
}
for (STD::map<string,string>::const_iterator mi = env.begin();
mi != env.end();
mi++) {
string v = mi->first;
v.append("=");
v.append(mi->second);
envlist.push_back(v);
}
if (getVerbosity() > normal) {
cerr << "Final envlist:";
for (string_list::const_iterator si = envlist.begin();
si != envlist.end();
si++) {
cerr << " " << *si << endl;
}
}
char **envp = Util::string_list_to_array(envlist);
execve(argv[0], argv, envp);
// This is an error
if (getVerbosity() > normal)
cerr << "Error executing " << argv[0]
<< ": " << STD::strerror(errno) << endl;
// Children should exit with _exit rather than exit. See, eg.,
// <http://www.erlenstar.demon.co.uk/unix/faq_toc.html#TOC6>
_exit(EXIT_FAILURE);
} else {
// ... in parent. Close the writing end.
::close(fd[1]);
bindToFileDescriptor(fd[0]);
if (getVerbosity() > normal)
cerr << "PipeStream: pid=" << pid_ << endl;
}
#else /* HAVE_PIPE */
#ifdef WIN32
// On Windows (it seems) we _can_ use the popen function
if (getVerbosity() > normal)
cerr << "PipeStream: cmd = " << cmd << endl;
fp_ = popen(cmd.c_str(), "rb");
if (fp_ == NULL){
// This is an error
if (getVerbosity() > normal)
cerr << "Error executing " << cmd
<< ": " << strerror(errno) << endl;
throw new InputByteStreamError("popen failer");
}
int fd = _fileno(fp_);
bindToFileDescriptor(fd);
#else // WIN32
throw new InputByteStreamError("Have no pipe() function");
#endif // WIN32
#endif /* HAVE_PIPE */
}
PipeStream::~PipeStream()
{
close();
}
/**
* Closes the stream, and reaps the process status.
*
* <p>If the process has not already terminated, this method attempts
* to kill it, by sending first HUP then KILL. If
* there is some reason why we can't reap the status -- because it has
* not died or for, say, some permissions reason -- we set the
* returned status to -1. Any data not read from the pipe is discarded.
*/
void PipeStream::close(void)
{
InputByteStream::close();
#ifdef WIN32
pclose(fp_);
pipe_status_ = 0;
#else // WIN32
if (pid_ > 0) {
// make sure that SIGALRM and SIGCHLD aren't blocked
sigset_t alrm_and_chld, oldmask;
sigemptyset(&alrm_and_chld);
sigaddset(&alrm_and_chld, SIGALRM);
sigaddset(&alrm_and_chld, SIGCHLD);
sigprocmask(SIG_UNBLOCK, &alrm_and_chld, &oldmask);
int status = -1;
bool keep_waiting
= !PipeStreamSignalHandling::got_status(pid_, &status);
bool process_gone = false;
for (int i=0; keep_waiting; i++) {
int sigtosend;
if (process_gone) {
// We weren't able to signal to the process, but we still
// can't get its status. How has this happened? Give up.
keep_waiting = false;
} else {
switch (i) {
case 0:
sigtosend = 0; // check process (really, just wait)
break;
case 1:
sigtosend = SIGINT;
break;
case 2:
sigtosend = SIGKILL;
break;
default:
keep_waiting = false; // give up
break;
}
}
if (keep_waiting) {
// temporarily block SIGALRM and SIGCHLD, until we can set
// an alarm for ourself
sigprocmask(SIG_BLOCK, &alrm_and_chld, 0);
if (kill(pid_, sigtosend) == 0) {
sigset_t zeromask;
sigemptyset(&zeromask);
#if defined(HAVE_SETITIMER)
struct itimerval timer;
timer.it_value.tv_sec = 1;
timer.it_value.tv_usec = 0;
timer.it_interval.tv_sec = 0;
timer.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &timer, 0);
#elif defined(HAVE_ALARM)
alarm(1);
#else
#error "Have neither setitimer nor alarm. Can't proceed!"
#endif
sigsuspend(&zeromask); // unblock and pause
if (getVerbosity() > normal)
cerr << "PipeStream::close sent signal " << sigtosend
<< " and waited for child" << endl;
} else {
// process wasn't there
process_gone = true;
if (getVerbosity() > normal)
cerr << "PipeStream::close: can't send signal "
<< sigtosend << " to process " << pid_
<< " (" << STD::strerror(errno) << ")"
<< endl;
}
keep_waiting
= !PipeStreamSignalHandling::got_status(pid_, &status);
}
}
pipe_status_ = status;
pid_ = 0;
// restore original signals mask
sigprocmask(SIG_SETMASK, &oldmask, 0);
}
#endif // WIN32
}
/**
* Returns the exit status of the command at the end of the pipe. Since
* this is only available after the process has completed, this
* invokes {@link #close} on the stream first. Thus you should not
* invoke this method until after you have extracted all of the
* command's output that you want. If <code>close</code> is unable
* to terminate the process for some reason, this returns -1.
*
* <p>If the process exited normally, return the exit status of the command,
* as opposed to the raw exit status returned from the process, since this is
* more useful than the raw status with assorted other status information
* concerning anomalous exits. This status is non-negative. If the process
* did not exit normally, then return the negative of the raw status
* information, which we assert will be less than zero.
*
* <p>See waitpid(2) for details.
*
* @return the exit status of the process.
*/
int PipeStream::getTerminationStatus(void)
{
int retval;
close();
if (WIFEXITED(pipe_status_)) {
retval = WEXITSTATUS(pipe_status_);
assert(retval >= 0);
} else {
retval = -pipe_status_;
assert(retval < 0); // we are correct about this, aren't we?
}
return retval;
}
/**
* Returns the contents of the stream as a string. If some of the
* stream has already been read by other methods of this class or its
* parent, it cannot be re-read. Any trailing whitespace, including
* end-of-line characters, is stripped.
*
* It's possible that the returned string will be incomplete, if the
* process failed somehow; irrespective of whether this happened, this
* returns what it can, and if this condition matters to you, you
* should check the termination status with
* <code>getTerminationStatus</code>.
*
* @param allOfFile if true, then all of the file is read into the
* string; if false (the default), only the first line is returned,
* <em>not</em> including the newline or carriage-return which ends
* the line
*
* @param gobbleRest if true (the default) then gobble the rest of
* the file; has an effect only if <code>allOfFile</code> was false
*
* @return the stream contents (or some of it, depending on the
* parameter values) as a string
* @throws InputByteStreamError if there is some problem reading the stream
*/
string PipeStream::getResult(bool allOfFile, bool gobbleRest)
throw (InputByteStreamError)
{
SSTREAM resp;
if (getVerbosity() > normal)
cerr << "PipeStream::getResult(" << (allOfFile?"true":"false")
<< ',' << (gobbleRest?"true":"false") << ")" << endl;
if (allOfFile) {
for (Byte b=getByte(); !eof(); b=getByte())
resp << b;
} else {
for (Byte b=getByte(); !(eof() || b=='\n' || b=='\r'); b=getByte())
resp << b;
if (gobbleRest)
while (!eof())
getByte();
}
string response = SS_STRING(resp);
if (getVerbosity() > normal)
cerr << "PipeStream::getResult: returning <" << response
<< ">; eof=" << (eof() ? "true" : "false") << endl;
// string response;
// int status = getTerminationStatus();
// if (WIFEXITED(status)) {
// if (getVerbosity() > normal)
// cerr << "exit status=" << WEXITSTATUS(status) << endl;
// if (WEXITSTATUS(status) != 0 && getVerbosity() >= normal) {
// cerr << "Command <" << orig_command_
// << "> exited with non-zero status "
// << WEXITSTATUS(status) << endl;
// }
// response = SS_STRING(resp);
// } else if (WIFSIGNALED(status)) {
// // if the command fails we may come here
// if (getVerbosity() >= normal)
// cerr << "Signalled with signal number " << WTERMSIG(status)
// << (WCOREDUMP(status) ? " (coredump)" : " (no coredump)")
// << endl;
// response = "";
// } else if (WIFSTOPPED(status)) {
// if (getVerbosity() >= normal)
// cerr << "Stopped on signal " << WSTOPSIG(status) << endl;
// response = "";
// } else {
// char msg[100];
// sprintf(msg, "Impossible status %d from child %d", status, getPid());
// throw InputByteStreamError(msg);
// }
return response;
}
#ifndef WIN32
/*
* All this is a rather simple-minded version of the pattern described in
* <http://www.cs.wustl.edu/~schmidt/signal-patterns.html>
*/
/**
* Note that we expect to start another child. This function must
* be called before doing each <code>fork()</code>, as it does the
* initialisation of the structures used by this set of functions, and
* subsequently ensures that there is enough space in the list of
* statuses to hold another one.
*
* @throws InputByteStreamError if we can't do this for some reason
*/
void PipeStreamSignalHandling::expectAnother()
throw (InputByteStreamError)
{
sigset_t chld, oldmask;
sigemptyset(&chld);
sigaddset(&chld, SIGCHLD);
if (sigprocmask(SIG_BLOCK, &chld, &oldmask) < 0)
throw InputByteStreamError("Can't set signal mask");
if (procs == 0) {
// first time
nprocs = 8;
nprocs_used = 0;
procs = new struct process_status[nprocs];
struct sigaction sa_chld;
sa_chld.sa_handler = &PipeStreamSignalHandling::childcatcher;
sigemptyset(&sa_chld.sa_mask);
#ifdef SA_RESTART
sa_chld.sa_flags = SA_RESTART;
#else
sa_chld.sa_flags = 0;
#endif
if (sigaction(SIGCHLD, &sa_chld, 0) < 0)
throw new InputByteStreamError("Can't install CHLD handler");
struct sigaction sa_alrm;
sa_alrm.sa_handler = &PipeStreamSignalHandling::alarmcatcher;
sigemptyset(&sa_alrm.sa_mask);
#ifdef SA_INTERRUPT
sa_alrm.sa_flags = SA_INTERRUPT; // some SunOS
#else
sa_alrm.sa_flags = 0;
#endif
if (sigaction(SIGALRM, &sa_alrm, 0) < 0)
throw new InputByteStreamError("Can't install ALRM handler");
if (InputByteStream::getVerbosity() > normal) {
cerr << "expectAnother: initialised to " << nprocs << "; set now";
for (int i=0; i<nprocs; i++)
cerr << " " << procs[i].pid << '/' << procs[i].status;
cerr << endl;
}
} else if (nprocs_used >= nprocs-1) {
assert(nprocs > 0);
int newnprocs = nprocs * 2;
struct process_status* newprocs = new struct process_status[nprocs];
for (int i=0; i<nprocs; i++)
newprocs[i] = procs[i];
nprocs = newnprocs;
delete[] procs;
procs = newprocs;
if (InputByteStream::getVerbosity() > normal) {
cerr << "expectAnother: expanded to " << nprocs << "; set now";
for (int i=0; i<nprocs; i++)
cerr << " " << procs[i].pid << '/' << procs[i].status;
cerr << endl;
}
}
if (sigprocmask(SIG_SETMASK, &oldmask, 0) < 0)
throw InputByteStreamError("Can't reset set signal mask");
}
/**
* Checks to see if the given process has exited. If there's an entry
* for this PID in the list, then put the corresponding status in the
* <code>status</code> parameter, and return true. If not, return false;
* <code>*status</code> is then unchanged.
*
* @param pid the PID to check
* @param status a pointer to the status to be returned
* @return true if the status was in fact available, and is now in
* <code>*status</code>; false otherwise
*/
bool PipeStreamSignalHandling::got_status(pid_t pid, int* status)
{
assert(status != 0);
for (int i=0; i<nprocs; i++) {
if (procs[i].pid == pid) {
// found a slot with the required PID in it
*status = static_cast<int>(procs[i].status);
procs[i].clear();
nprocs_used--;
if (InputByteStream::getVerbosity() > normal)
cerr << "got_status: pid=" << pid << " status=" << *status
<< " ("
<< i << "/" << nprocs_used << "/" << nprocs
<< ")" << endl;
return true;
}
}
if (InputByteStream::getVerbosity() > normal)
cerr << "got_status: no status for pid " << pid << endl;
return false;
}
void PipeStreamSignalHandling::childcatcher(int signum)
{
assert(signum == SIGCHLD);
int i;
int status;
pid_t caughtpid = waitpid(0, &status, 0);
for (i=0; i<nprocs; i++) {
if (procs[i].pid == 0) { // free slot
procs[i].pid = static_cast<sig_atomic_t>(caughtpid);
procs[i].status = static_cast<sig_atomic_t>(status);
nprocs_used++;
break;
}
}
// If i=nprocs, then there's no space to store this signal.
// Nothing much we can do -- but at least it isn't a zombie.
return;
}
void PipeStreamSignalHandling::alarmcatcher(int signum)
{
assert(signum == SIGALRM);
return; // nothing to do
}
#endif // WIN32