Fix line endlings

1 files changed, 1358 insertions, 1358 deletions

diff --git a/indra/llcommon/llprocess.cpp b/indra/llcommon/llprocess.cpp
index 80413bb841..912e596c3f 100644
--- a/indra/llcommon/llprocess.cpp
+++ b/indra/llcommon/llprocess.cpp
@@ -1,1358 +1,1358 @@
-/**

- * @file llprocess.cpp

- * @brief Utility class for launching, terminating, and tracking the state of processes.

- *

- * $LicenseInfo:firstyear=2008&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc.

- *

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- *

- * This library 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

- * Lesser General Public License for more details.

- *

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- *

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-#include "linden_common.h"

-#include "llprocess.h"

-#include "llsdutil.h"

-#include "llsdserialize.h"

-#include "llsingleton.h"

-#include "llstring.h"

-#include "stringize.h"

-#include "llapr.h"

-#include "apr_signal.h"

-#include "llevents.h"

-#include "llexception.h"

-

-#include <boost/bind.hpp>

-#include <boost/asio/streambuf.hpp>

-#include <boost/asio/buffers_iterator.hpp>

-#include <iostream>

-#include <stdexcept>

-#include <limits>

-#include <algorithm>

-#include <vector>

-#include <typeinfo>

-#include <utility>

-

-/*****************************************************************************

-*   Helpers

-*****************************************************************************/

-static const char* whichfile_[] = { "stdin", "stdout", "stderr" };

-static std::string empty;

-static LLProcess::Status interpret_status(int status);

-static std::string getDesc(const LLProcess::Params& params);

-

-static std::string whichfile(LLProcess::FILESLOT index)

-{

-    if (index < LL_ARRAY_SIZE(whichfile_))

-        return whichfile_[index];

-    return STRINGIZE("file slot " << index);

-}

-

-/**

- * Ref-counted "mainloop" listener. As long as there are still outstanding

- * LLProcess objects, keep listening on "mainloop" so we can keep polling APR

- * for process status.

- */

-class LLProcessListener

-{

-    LOG_CLASS(LLProcessListener);

-public:

-    LLProcessListener():

-        mCount(0)

-    {}

-

-    void addPoll(const LLProcess&)

-    {

-        // Unconditionally increment mCount. If it was zero before

-        // incrementing, listen on "mainloop".

-        if (mCount++ == 0)

-        {

-            LL_DEBUGS("LLProcess") << "listening on \"mainloop\"" << LL_ENDL;

-            mConnection = LLEventPumps::instance().obtain("mainloop")

-                .listen("LLProcessListener", boost::bind(&LLProcessListener::tick, this, _1));

-        }

-    }

-

-    void dropPoll(const LLProcess&)

-    {

-        // Unconditionally decrement mCount. If it's zero after decrementing,

-        // stop listening on "mainloop".

-        if (--mCount == 0)

-        {

-            LL_DEBUGS("LLProcess") << "disconnecting from \"mainloop\"" << LL_ENDL;

-            mConnection.disconnect();

-        }

-    }

-

-private:

-    /// called once per frame by the "mainloop" LLEventPump

-    bool tick(const LLSD&)

-    {

-        // Tell APR to sense whether each registered LLProcess is still

-        // running and call handle_status() appropriately. We should be able

-        // to get the same info from an apr_proc_wait(APR_NOWAIT) call; but at

-        // least in APR 1.4.2, testing suggests that even with APR_NOWAIT,

-        // apr_proc_wait() blocks the caller. We can't have that in the

-        // viewer. Hence the callback rigmarole. (Once we update APR, it's

-        // probably worth testing again.) Also -- although there's an

-        // apr_proc_other_child_refresh() call, i.e. get that information for

-        // one specific child, it accepts an 'apr_other_child_rec_t*' that's

-        // mentioned NOWHERE else in the documentation or header files! I

-        // would use the specific call in LLProcess::getStatus() if I knew

-        // how. As it is, each call to apr_proc_other_child_refresh_all() will

-        // call callbacks for ALL still-running child processes. That's why we

-        // centralize such calls, using "mainloop" to ensure it happens once

-        // per frame, and refcounting running LLProcess objects to remain

-        // registered only while needed.

-        LL_DEBUGS("LLProcess") << "calling apr_proc_other_child_refresh_all()" << LL_ENDL;

-        apr_proc_other_child_refresh_all(APR_OC_REASON_RUNNING);

-        return false;

-    }

-

-    /// If this object is destroyed before mCount goes to zero, stop

-    /// listening on "mainloop" anyway.

-    LLTempBoundListener mConnection;

-    unsigned mCount;

-};

-static LLProcessListener sProcessListener;

-

-/*****************************************************************************

-*   WritePipe and ReadPipe

-*****************************************************************************/

-LLProcess::BasePipe::~BasePipe() {}

-const LLProcess::BasePipe::size_type

-      // use funky syntax to call max() to avoid blighted max() macros

-      LLProcess::BasePipe::npos((std::numeric_limits<LLProcess::BasePipe::size_type>::max)());

-

-class WritePipeImpl: public LLProcess::WritePipe

-{

-    LOG_CLASS(WritePipeImpl);

-public:

-    WritePipeImpl(const std::string& desc, apr_file_t* pipe):

-        mDesc(desc),

-        mPipe(pipe),

-        // Essential to initialize our std::ostream with our special streambuf!

-        mStream(&mStreambuf)

-    {

-        mConnection = LLEventPumps::instance().obtain("mainloop")

-            .listen(LLEventPump::inventName("WritePipe"),

-                    boost::bind(&WritePipeImpl::tick, this, _1));

-

-#if ! LL_WINDOWS

-        // We can't count on every child process reading everything we try to

-        // write to it. And if the child terminates with WritePipe data still

-        // pending, unless we explicitly suppress it, Posix will hit us with

-        // SIGPIPE. That would terminate the viewer, boom. "Ignoring" it means

-        // APR gets the correct errno, passes it back to us, we log it, etc.

-        signal(SIGPIPE, SIG_IGN);

-#endif

-    }

-

-    virtual std::ostream& get_ostream() { return mStream; }

-    virtual size_type size() const { return mStreambuf.size(); }

-

-    bool tick(const LLSD&)

-    {

-        typedef boost::asio::streambuf::const_buffers_type const_buffer_sequence;

-        // If there's anything to send, try to send it.

-        std::size_t total(mStreambuf.size()), consumed(0);

-        if (total)

-        {

-            const_buffer_sequence bufs = mStreambuf.data();

-            // In general, our streambuf might contain a number of different

-            // physical buffers; iterate over those.

-            bool keepwriting = true;

-            for (const_buffer_sequence::const_iterator bufi(bufs.begin()), bufend(bufs.end());

-                 bufi != bufend && keepwriting; ++bufi)

-            {

-                // http://www.boost.org/doc/libs/1_49_0_beta1/doc/html/boost_asio/reference/buffer.html#boost_asio.reference.buffer.accessing_buffer_contents

-                // Although apr_file_write() accepts const void*, we

-                // manipulate const char* so we can increment the pointer.

-                const char* remainptr = boost::asio::buffer_cast<const char*>(*bufi);

-                std::size_t remainlen = boost::asio::buffer_size(*bufi);

-                while (remainlen)

-                {

-                    // Tackle the current buffer in discrete chunks. On

-                    // Windows, we've observed strange failures when trying to

-                    // write big lengths (~1 MB) in a single operation. Even a

-                    // 32K chunk seems too large. At some point along the way

-                    // apr_file_write() returns 11 (Resource temporarily

-                    // unavailable, i.e. EAGAIN) and says it wrote 0 bytes --

-                    // even though it did write the chunk! Our next write

-                    // attempt retries with the same chunk, resulting in the

-                    // chunk being duplicated at the child end. Using smaller

-                    // chunks is empirically more reliable.

-                    std::size_t towrite((std::min)(remainlen, std::size_t(4*1024)));

-                    apr_size_t written(towrite);

-                    apr_status_t err = apr_file_write(mPipe, remainptr, &written);

-                    // EAGAIN is exactly what we want from a nonblocking pipe.

-                    // Rather than waiting for data, it should return immediately.

-                    if (! (err == APR_SUCCESS || APR_STATUS_IS_EAGAIN(err)))

-                    {

-                        LL_WARNS("LLProcess") << "apr_file_write(" << towrite << ") on " << mDesc

-                                              << " got " << err << ":" << LL_ENDL;

-                        ll_apr_warn_status(err);

-                    }

-

-                    // 'written' is modified to reflect the number of bytes actually

-                    // written. Make sure we consume those later. (Don't consume them

-                    // now, that would invalidate the buffer iterator sequence!)

-                    consumed += written;

-                    // don't forget to advance to next chunk of current buffer

-                    remainptr += written;

-                    remainlen -= written;

-

-                    char msgbuf[512];

-                    LL_DEBUGS("LLProcess") << "wrote " << written << " of " << towrite

-                                           << " bytes to " << mDesc

-                                           << " (original " << total << "),"

-                                           << " code " << err << ": "

-                                           << apr_strerror(err, msgbuf, sizeof(msgbuf))

-                                           << LL_ENDL;

-

-                    // The parent end of this pipe is nonblocking. If we weren't able

-                    // to write everything we wanted, don't keep banging on it -- that

-                    // won't change until the child reads some. Wait for next tick().

-                    if (written < towrite)

-                    {

-                        keepwriting = false; // break outer loop over buffers too

-                        break;

-                    }

-                } // next chunk of current buffer

-            }     // next buffer

-            // In all, we managed to write 'consumed' bytes. Remove them from the

-            // streambuf so we don't keep trying to send them. This could be

-            // anywhere from 0 up to mStreambuf.size(); anything we haven't yet

-            // sent, we'll try again later.

-            mStreambuf.consume(consumed);

-        }

-

-        return false;

-    }

-

-private:

-    std::string mDesc;

-    apr_file_t* mPipe;

-    LLTempBoundListener mConnection;

-    boost::asio::streambuf mStreambuf;

-    std::ostream mStream;

-};

-

-class ReadPipeImpl: public LLProcess::ReadPipe

-{

-    LOG_CLASS(ReadPipeImpl);

-public:

-    ReadPipeImpl(const std::string& desc, apr_file_t* pipe, LLProcess::FILESLOT index):

-        mDesc(desc),

-        mPipe(pipe),

-        mIndex(index),

-        // Essential to initialize our std::istream with our special streambuf!

-        mStream(&mStreambuf),

-        mPump("ReadPipe", true),    // tweak name as needed to avoid collisions

-        mLimit(0),

-        mEOF(false)

-    {

-        mConnection = LLEventPumps::instance().obtain("mainloop")

-            .listen(LLEventPump::inventName("ReadPipe"),

-                    boost::bind(&ReadPipeImpl::tick, this, _1));

-    }

-

-    ~ReadPipeImpl()

-    {

-        if (mConnection.connected())

-        {

-            mConnection.disconnect();

-        }

-    }

-

-    // Much of the implementation is simply connecting the abstract virtual

-    // methods with implementation data concealed from the base class.

-    virtual std::istream& get_istream() { return mStream; }

-    virtual std::string getline() { return LLProcess::getline(mStream); }

-    virtual LLEventPump& getPump() { return mPump; }

-    virtual void setLimit(size_type limit) { mLimit = limit; }

-    virtual size_type getLimit() const { return mLimit; }

-    virtual size_type size() const { return mStreambuf.size(); }

-

-    virtual std::string read(size_type len)

-    {

-        // Read specified number of bytes into a buffer.

-        size_type readlen((std::min)(size(), len));

-        // Formally, &buffer[0] is invalid for a vector of size() 0. Exit

-        // early in that situation.

-        if (! readlen)

-            return "";

-        // Make a buffer big enough.

-        std::vector<char> buffer(readlen);

-        mStream.read(&buffer[0], readlen);

-        // Since we've already clamped 'readlen', we can think of no reason

-        // why mStream.read() should read fewer than 'readlen' bytes.

-        // Nonetheless, use the actual retrieved length.

-        return std::string(&buffer[0], mStream.gcount());

-    }

-

-    virtual std::string peek(size_type offset=0, size_type len=npos) const

-    {

-        // Constrain caller's offset and len to overlap actual buffer content.

-        std::size_t real_offset = (std::min)(mStreambuf.size(), std::size_t(offset));

-        size_type   want_end    = (len == npos)? npos : (real_offset + len);

-        std::size_t real_end    = (std::min)(mStreambuf.size(), std::size_t(want_end));

-        boost::asio::streambuf::const_buffers_type cbufs = mStreambuf.data();

-        return std::string(boost::asio::buffers_begin(cbufs) + real_offset,

-                           boost::asio::buffers_begin(cbufs) + real_end);

-    }

-

-    virtual size_type find(const std::string& seek, size_type offset=0) const

-    {

-        // If we're passing a string of length 1, use find(char), which can

-        // use an O(n) std::find() rather than the O(n^2) std::search().

-        if (seek.length() == 1)

-        {

-            return find(seek[0], offset);

-        }

-

-        // If offset is beyond the whole buffer, can't even construct a valid

-        // iterator range; can't possibly find the string we seek.

-        if (offset > mStreambuf.size())

-        {

-            return npos;

-        }

-

-        boost::asio::streambuf::const_buffers_type cbufs = mStreambuf.data();

-        boost::asio::buffers_iterator<boost::asio::streambuf::const_buffers_type>

-            begin(boost::asio::buffers_begin(cbufs)),

-            end  (boost::asio::buffers_end(cbufs)),

-            found(std::search(begin + offset, end, seek.begin(), seek.end()));

-        return (found == end)? npos : (found - begin);

-    }

-

-    virtual size_type find(char seek, size_type offset=0) const

-    {

-        // If offset is beyond the whole buffer, can't even construct a valid

-        // iterator range; can't possibly find the char we seek.

-        if (offset > mStreambuf.size())

-        {

-            return npos;

-        }

-

-        boost::asio::streambuf::const_buffers_type cbufs = mStreambuf.data();

-        boost::asio::buffers_iterator<boost::asio::streambuf::const_buffers_type>

-            begin(boost::asio::buffers_begin(cbufs)),

-            end  (boost::asio::buffers_end(cbufs)),

-            found(std::find(begin + offset, end, seek));

-        return (found == end)? npos : (found - begin);

-    }

-

-    bool tick(const LLSD&)

-    {

-        // Once we've hit EOF, skip all the rest of this.

-        if (mEOF)

-            return false;

-

-        typedef boost::asio::streambuf::mutable_buffers_type mutable_buffer_sequence;

-        // Try, every time, to read into our streambuf. In fact, we have no

-        // idea how much data the child might be trying to send: keep trying

-        // until we're convinced we've temporarily exhausted the pipe.

-        enum PipeState { RETRY, EXHAUSTED, CLOSED };

-        PipeState state = RETRY;

-        std::size_t committed(0);

-        do

-        {

-            // attempt to read an arbitrary size

-            mutable_buffer_sequence bufs = mStreambuf.prepare(4096);

-            // In general, the mutable_buffer_sequence returned by prepare() might

-            // contain a number of different physical buffers; iterate over those.

-            std::size_t tocommit(0);

-            for (mutable_buffer_sequence::const_iterator bufi(bufs.begin()), bufend(bufs.end());

-                 bufi != bufend; ++bufi)

-            {

-                // http://www.boost.org/doc/libs/1_49_0_beta1/doc/html/boost_asio/reference/buffer.html#boost_asio.reference.buffer.accessing_buffer_contents

-                std::size_t toread(boost::asio::buffer_size(*bufi));

-                apr_size_t gotten(toread);

-                apr_status_t err = apr_file_read(mPipe,

-                                                 boost::asio::buffer_cast<void*>(*bufi),

-                                                 &gotten);

-                // EAGAIN is exactly what we want from a nonblocking pipe.

-                // Rather than waiting for data, it should return immediately.

-                if (! (err == APR_SUCCESS || APR_STATUS_IS_EAGAIN(err)))

-                {

-                    // Handle EOF specially: it's part of normal-case processing.

-                    if (err == APR_EOF)

-                    {

-                        LL_DEBUGS("LLProcess") << "EOF on " << mDesc << LL_ENDL;

-                    }

-                    else

-                    {

-                        LL_WARNS("LLProcess") << "apr_file_read(" << toread << ") on " << mDesc

-                                              << " got " << err << ":" << LL_ENDL;

-                        ll_apr_warn_status(err);

-                    }

-                    // Either way, though, we won't need any more tick() calls.

-                    mConnection.disconnect();

-                    // Ignore any subsequent calls we might get anyway.

-                    mEOF = true;

-                    state = CLOSED; // also break outer retry loop

-                    break;

-                }

-

-                // 'gotten' was modified to reflect the number of bytes actually

-                // received. Make sure we commit those later. (Don't commit them

-                // now, that would invalidate the buffer iterator sequence!)

-                tocommit += gotten;

-                LL_DEBUGS("LLProcess") << "filled " << gotten << " of " << toread

-                                       << " bytes from " << mDesc << LL_ENDL;

-

-                // The parent end of this pipe is nonblocking. If we weren't even

-                // able to fill this buffer, don't loop to try to fill the next --

-                // that won't change until the child writes more. Wait for next

-                // tick().

-                if (gotten < toread)

-                {

-                    // break outer retry loop too

-                    state = EXHAUSTED;

-                    break;

-                }

-            }

-

-            // Don't forget to "commit" the data!

-            mStreambuf.commit(tocommit);

-            committed += tocommit;

-

-            // state is changed from RETRY when we can't fill any one buffer

-            // of the mutable_buffer_sequence established by the current

-            // prepare() call -- whether due to error or not enough bytes.

-            // That is, if state is still RETRY, we've filled every physical

-            // buffer in the mutable_buffer_sequence. In that case, for all we

-            // know, the child might have still more data pending -- go for it!

-        } while (state == RETRY);

-

-        // Once we recognize that the pipe is closed, make one more call to

-        // listener. The listener might be waiting for a particular substring

-        // to arrive, or a particular length of data or something. The event

-        // with "eof" == true announces that nothing further will arrive, so

-        // use it or lose it.

-        if (committed || state == CLOSED)

-        {

-            // If we actually received new data, publish it on our LLEventPump

-            // as advertised. Constrain it by mLimit. But show listener the

-            // actual accumulated buffer size, regardless of mLimit.

-            size_type datasize((std::min)(mLimit, size_type(mStreambuf.size())));

-            mPump.post(LLSDMap

-                       ("data", peek(0, datasize))

-                       ("len", LLSD::Integer(mStreambuf.size()))

-                       ("slot", LLSD::Integer(mIndex))

-                       ("name", whichfile(mIndex))

-                       ("desc", mDesc)

-                       ("eof", state == CLOSED));

-        }

-

-        return false;

-    }

-

-private:

-    std::string mDesc;

-    apr_file_t* mPipe;

-    LLProcess::FILESLOT mIndex;

-    LLTempBoundListener mConnection;

-    boost::asio::streambuf mStreambuf;

-    std::istream mStream;

-    LLEventStream mPump;

-    size_type mLimit;

-    bool mEOF;

-};

-

-/*****************************************************************************

-*   LLProcess itself

-*****************************************************************************/

-/// Need an exception to avoid constructing an invalid LLProcess object, but

-/// internal use only

-struct LLProcessError: public LLException

-{

-    LLProcessError(const std::string& msg): LLException(msg) {}

-};

-

-LLProcessPtr LLProcess::create(const LLSDOrParams& params)

-{

-    try

-    {

-        return LLProcessPtr(new LLProcess(params));

-    }

-    catch (const LLProcessError& e)

-    {

-        LL_WARNS("LLProcess") << e.what() << LL_ENDL;

-

-        // If caller is requesting an event on process termination, send one

-        // indicating bad launch. This may prevent someone waiting forever for

-        // a termination post that can't arrive because the child never

-        // started.

-        if (params.postend.isProvided())

-        {

-            LLEventPumps::instance().obtain(params.postend)

-                .post(LLSDMap

-                      // no "id"

-                      ("desc", getDesc(params))

-                      ("state", LLProcess::UNSTARTED)

-                      // no "data"

-                      ("string", e.what())

-                     );

-        }

-

-        return LLProcessPtr();

-    }

-}

-

-/// Call an apr function returning apr_status_t. On failure, log warning and

-/// throw LLProcessError mentioning the function call that produced that

-/// result.

-#define chkapr(func)                            \

-    if (ll_apr_warn_status(func))               \

-        throw LLProcessError(#func " failed")

-

-LLProcess::LLProcess(const LLSDOrParams& params):

-    mAutokill(params.autokill),

-    // Because 'autokill' originally meant both 'autokill' and 'attached', to

-    // preserve existing semantics, we promise that mAttached defaults to the

-    // same setting as mAutokill.

-    mAttached(params.attached.isProvided()? params.attached : params.autokill),

-    mPool(NULL),

-    mPipes(NSLOTS)

-{

-    // Hmm, when you construct a ptr_vector with a size, it merely reserves

-    // space, it doesn't actually make it that big. Explicitly make it bigger.

-    // Because of ptr_vector's odd semantics, have to push_back(0) the right

-    // number of times! resize() wants to default-construct new BasePipe

-    // instances, which fails because it's pure virtual. But because of the

-    // constructor call, these push_back() calls should require no new

-    // allocation.

-    for (size_t i = 0; i < mPipes.capacity(); ++i)

-        mPipes.push_back(0);

-

-    if (! params.validateBlock(true))

-    {

-        LLTHROW(LLProcessError(STRINGIZE("not launched: failed parameter validation\n"

-                                         << LLSDNotationStreamer(params))));

-    }

-

-    mPostend = params.postend;

-

-    apr_pool_create(&mPool, gAPRPoolp);

-    if (!mPool)

-    {

-        LLTHROW(LLProcessError(STRINGIZE("failed to create apr pool")));

-    }

-

-    apr_procattr_t *procattr = NULL;

-    chkapr(apr_procattr_create(&procattr, mPool));

-

-    // IQA-490, CHOP-900: On Windows, ask APR to jump through hoops to

-    // constrain the set of handles passed to the child process. Before we

-    // changed to APR, the Windows implementation of LLProcessLauncher called

-    // CreateProcess(bInheritHandles=false), meaning to pass NO open handles

-    // to the child process. Now that we support pipes, though, we must allow

-    // apr_proc_create() to pass bInheritHandles=true. But without taking

-    // special pains, that causes trouble in a number of ways, due to the fact

-    // that the viewer is constantly opening and closing files -- most of

-    // which CreateProcess() passes to every child process!

-#if ! defined(APR_HAS_PROCATTR_CONSTRAIN_HANDLE_SET)

-    // Our special preprocessor symbol isn't even defined -- wrong APR

-    LL_WARNS("LLProcess") << "This version of APR lacks Linden "

-                          << "apr_procattr_constrain_handle_set() extension" << LL_ENDL;

-#else

-    chkapr(apr_procattr_constrain_handle_set(procattr, 1));

-#endif

-

-    // For which of stdin, stdout, stderr should we create a pipe to the

-    // child? In the viewer, there are only a couple viable

-    // apr_procattr_io_set() alternatives: inherit the viewer's own stdxxx

-    // handle (APR_NO_PIPE, e.g. for stdout, stderr), or create a pipe that's

-    // blocking on the child end but nonblocking at the viewer end

-    // (APR_CHILD_BLOCK).

-    // Other major options could include explicitly creating a single APR pipe

-    // and passing it as both stdout and stderr (apr_procattr_child_out_set(),

-    // apr_procattr_child_err_set()), or accepting a filename, opening it and

-    // passing that apr_file_t (simple <, >, 2> redirect emulation).

-    std::vector<apr_int32_t> select;

-    for (const FileParam& fparam : params.files)

-    {

-        // Every iteration, we're going to append an item to 'select'. At the

-        // top of the loop, its size() is, in effect, an index. Use that to

-        // pick a string description for messages.

-        std::string which(whichfile(FILESLOT(select.size())));

-        if (fparam.type().empty())  // inherit our file descriptor

-        {

-            select.push_back(APR_NO_PIPE);

-        }

-        else if (fparam.type() == "pipe") // anonymous pipe

-        {

-            if (! fparam.name().empty())

-            {

-                LL_WARNS("LLProcess") << "For " << params.executable()

-                                      << ": internal names for reusing pipes ('"

-                                      << fparam.name() << "' for " << which

-                                      << ") are not yet supported -- creating distinct pipe"

-                                      << LL_ENDL;

-            }

-            // The viewer can't block for anything: the parent end MUST be

-            // nonblocking. As the APR documentation itself points out, it

-            // makes very little sense to set nonblocking I/O for the child

-            // end of a pipe: only a specially-written child could deal with

-            // that.

-            select.push_back(APR_CHILD_BLOCK);

-        }

-        else

-        {

-            LLTHROW(LLProcessError(STRINGIZE("For " << params.executable()

-                                             << ": unsupported FileParam for " << which

-                                             << ": type='" << fparam.type()

-                                             << "', name='" << fparam.name() << "'")));

-        }

-    }

-    // By default, pass APR_NO_PIPE for unspecified slots.

-    while (select.size() < NSLOTS)

-    {

-        select.push_back(APR_NO_PIPE);

-    }

-    chkapr(apr_procattr_io_set(procattr, select[STDIN], select[STDOUT], select[STDERR]));

-

-    // Thumbs down on implicitly invoking the shell to invoke the child. From

-    // our point of view, the other major alternative to APR_PROGRAM_PATH

-    // would be APR_PROGRAM_ENV: still copy environment, but require full

-    // executable pathname. I don't see a downside to searching the PATH,

-    // though: if our caller wants (e.g.) a specific Python interpreter, s/he

-    // can still pass the full pathname.

-    chkapr(apr_procattr_cmdtype_set(procattr, APR_PROGRAM_PATH));

-    // YES, do extra work if necessary to report child exec() failures back to

-    // parent process.

-    chkapr(apr_procattr_error_check_set(procattr, 1));

-    // Do not start a non-autokill child in detached state. On Posix

-    // platforms, this setting attempts to daemonize the new child, closing

-    // std handles and the like, and that's a bit more detachment than we

-    // want. autokill=false just means not to implicitly kill the child when

-    // the parent terminates!

-//  chkapr(apr_procattr_detach_set(procattr, mAutokill? 0 : 1));

-

-    if (mAutokill)

-    {

-#if ! defined(APR_HAS_PROCATTR_AUTOKILL_SET)

-        // Our special preprocessor symbol isn't even defined -- wrong APR

-        LL_WARNS("LLProcess") << "This version of APR lacks Linden apr_procattr_autokill_set() extension" << LL_ENDL;

-#elif ! APR_HAS_PROCATTR_AUTOKILL_SET

-        // Symbol is defined, but to 0: expect apr_procattr_autokill_set() to

-        // return APR_ENOTIMPL.

-#else   // APR_HAS_PROCATTR_AUTOKILL_SET nonzero

-        ll_apr_warn_status(apr_procattr_autokill_set(procattr, 1));

-#endif

-    }

-

-    // In preparation for calling apr_proc_create(), we collect a number of

-    // const char* pointers obtained from std::string::c_str(). Turns out

-    // LLInitParam::Block's helpers Optional, Mandatory, Multiple et al.

-    // guarantee that converting to the wrapped type (std::string in our

-    // case), e.g. by calling operator(), returns a reference to *the same

-    // instance* of the wrapped type that's stored in our Block subclass.

-    // That's important! We know 'params' persists throughout this method

-    // call; but without that guarantee, we'd have to assume that converting

-    // one of its members to std::string might return a different (temp)

-    // instance. Capturing the c_str() from a temporary std::string is Bad Bad

-    // Bad. But armed with this knowledge, when you see params.cwd().c_str(),

-    // grit your teeth and smile and carry on.

-

-    if (params.cwd.isProvided())

-    {

-        chkapr(apr_procattr_dir_set(procattr, params.cwd().c_str()));

-    }

-

-    // create an argv vector for the child process

-    std::vector<const char*> argv;

-

-    // Add the executable path. See above remarks about c_str().

-    argv.push_back(params.executable().c_str());

-

-    // Add arguments. See above remarks about c_str().

-    for (const std::string& arg : params.args)

-    {

-        argv.push_back(arg.c_str());

-    }

-

-    // terminate with a null pointer

-    argv.push_back(NULL);

-

-    // Launch! The NULL would be the environment block, if we were passing

-    // one. Hand-expand chkapr() macro so we can fill in the actual command

-    // string instead of the variable names.

-    if (ll_apr_warn_status(apr_proc_create(&mProcess, argv[0], &argv[0], NULL, procattr,

-                                           mPool)))

-    {

-        LLTHROW(LLProcessError(STRINGIZE(params << " failed")));

-    }

-

-    // arrange to call status_callback()

-    apr_proc_other_child_register(&mProcess, &LLProcess::status_callback, this, mProcess.in,

-                                  mPool);

-    // and make sure we poll it once per "mainloop" tick

-    sProcessListener.addPoll(*this);

-    mStatus.mState = RUNNING;

-

-    mDesc = STRINGIZE(getDesc(params) << " (" << mProcess.pid << ')');

-    LL_INFOS("LLProcess") << mDesc << ": launched " << params << LL_ENDL;

-

-    // Unless caller explicitly turned off autokill (child should persist),

-    // take steps to terminate the child. This is all suspenders-and-belt: in

-    // theory our destructor should kill an autokill child, but in practice

-    // that doesn't always work (e.g. VWR-21538).

-    if (mAutokill)

-    {

-/*==========================================================================*|

-        // NO: There may be an APR bug, not sure -- but at least on Mac, when

-        // gAPRPoolp is destroyed, OUR process receives SIGTERM! Apparently

-        // either our own PID is getting into the list of processes to kill()

-        // (unlikely), or somehow one of those PIDs is getting zeroed first,

-        // so that kill() sends SIGTERM to the whole process group -- this

-        // process included. I'd have to build and link with a debug version

-        // of APR to know for sure. It's too bad: this mechanism would be just

-        // right for dealing with static autokill LLProcessPtr variables,

-        // which aren't destroyed until after APR is no longer available.

-

-        // Tie the lifespan of this child process to the lifespan of our APR

-        // pool: on destruction of the pool, forcibly kill the process. Tell

-        // APR to try SIGTERM and suspend 3 seconds. If that didn't work, use

-        // SIGKILL.

-        apr_pool_note_subprocess(gAPRPoolp, &mProcess, APR_KILL_AFTER_TIMEOUT);

-|*==========================================================================*/

-

-        // On Windows, associate the new child process with our Job Object.

-        autokill();

-    }

-

-    // Instantiate the proper pipe I/O machinery

-    // want to be able to point to apr_proc_t::in, out, err by index

-    typedef apr_file_t* apr_proc_t::*apr_proc_file_ptr;

-    static apr_proc_file_ptr members[] =

-        { &apr_proc_t::in, &apr_proc_t::out, &apr_proc_t::err };

-    for (size_t i = 0; i < NSLOTS; ++i)

-    {

-        if (select[i] != APR_CHILD_BLOCK)

-            continue;

-        std::string desc(STRINGIZE(mDesc << ' ' << whichfile(FILESLOT(i))));

-        apr_file_t* pipe(mProcess.*(members[i]));

-        if (i == STDIN)

-        {

-            mPipes.replace(i, new WritePipeImpl(desc, pipe));

-        }

-        else

-        {

-            mPipes.replace(i, new ReadPipeImpl(desc, pipe, FILESLOT(i)));

-        }

-        // Removed temporaily for Xcode 7 build tests: error was:

-        // "error: expression with side effects will be evaluated despite

-        // being used as an operand to 'typeid' [-Werror,-Wpotentially-evaluated-expression]""

-        //LL_DEBUGS("LLProcess") << "Instantiating " << typeid(mPipes[i]).name()

-        //                     << "('" << desc << "')" << LL_ENDL;

-    }

-}

-

-// Helper to obtain a description string, given a Params block

-static std::string getDesc(const LLProcess::Params& params)

-{

-    // If caller specified a description string, by all means use it.

-    if (params.desc.isProvided())

-        return params.desc;

-

-    // Caller didn't say. Use the executable name -- but use just the filename

-    // part. On Mac, for instance, full pathnames get cumbersome.

-    return LLProcess::basename(params.executable);

-}

-

-//static

-std::string LLProcess::basename(const std::string& path)

-{

-    // If there are Linden utility functions to manipulate pathnames, I

-    // haven't found them -- and for this usage, Boost.Filesystem seems kind

-    // of heavyweight.

-    std::string::size_type delim = path.find_last_of("\\/");

-    // If path contains no pathname delimiters, return the whole thing.

-    if (delim == std::string::npos)

-        return path;

-

-    // Return just the part beyond the last delimiter.

-    return path.substr(delim + 1);

-}

-

-LLProcess::~LLProcess()

-{

-    // In the Linden viewer, there's at least one static LLProcessPtr. Its

-    // destructor will be called *after* ll_cleanup_apr(). In such a case,

-    // unregistering is pointless (and fatal!) -- and kill(), which also

-    // relies on APR, is impossible.

-    if (! gAPRPoolp)

-        return;

-

-    // Only in state RUNNING are we registered for callback. In UNSTARTED we

-    // haven't yet registered. And since receiving the callback is the only

-    // way we detect child termination, we only change from state RUNNING at

-    // the same time we unregister.

-    if (mStatus.mState == RUNNING)

-    {

-        // We're still registered for a callback: unregister. Do it before

-        // we even issue the kill(): even if kill() somehow prompted an

-        // instantaneous callback (unlikely), this object is going away! Any

-        // information updated in this object by such a callback is no longer

-        // available to any consumer anyway.

-        apr_proc_other_child_unregister(this);

-        // One less LLProcess to poll for

-        sProcessListener.dropPoll(*this);

-    }

-

-    if (mAttached)

-    {

-        kill("destructor");

-    }

-

-    if (mPool)

-    {

-        apr_pool_destroy(mPool);

-        mPool = NULL;

-    }

-}

-

-bool LLProcess::kill(const std::string& who)

-{

-    if (isRunning())

-    {

-        LL_INFOS("LLProcess") << who << " killing " << mDesc << LL_ENDL;

-

-#if LL_WINDOWS

-        int sig = -1;

-#else  // Posix

-        int sig = SIGTERM;

-#endif

-

-        ll_apr_warn_status(apr_proc_kill(&mProcess, sig));

-    }

-

-    return ! isRunning();

-}

-

-//static

-bool LLProcess::kill(const LLProcessPtr& p, const std::string& who)

-{

-    if (! p)

-        return true;                // process dead! (was never running)

-    return p->kill(who);

-}

-

-bool LLProcess::isRunning() const

-{

-    return getStatus().mState == RUNNING;

-}

-

-//static

-bool LLProcess::isRunning(const LLProcessPtr& p)

-{

-    if (! p)

-        return false;

-    return p->isRunning();

-}

-

-LLProcess::Status LLProcess::getStatus() const

-{

-    return mStatus;

-}

-

-//static

-LLProcess::Status LLProcess::getStatus(const LLProcessPtr& p)

-{

-    if (! p)

-    {

-        // default-constructed Status has mState == UNSTARTED

-        return Status();

-    }

-    return p->getStatus();

-}

-

-std::string LLProcess::getStatusString() const

-{

-    return getStatusString(getStatus());

-}

-

-std::string LLProcess::getStatusString(const Status& status) const

-{

-    return getStatusString(mDesc, status);

-}

-

-//static

-std::string LLProcess::getStatusString(const std::string& desc, const LLProcessPtr& p)

-{

-    if (! p)

-    {

-        // default-constructed Status has mState == UNSTARTED

-        return getStatusString(desc, Status());

-    }

-    return desc + " " + p->getStatusString();

-}

-

-//static

-std::string LLProcess::getStatusString(const std::string& desc, const Status& status)

-{

-    if (status.mState == UNSTARTED)

-        return desc + " was never launched";

-

-    if (status.mState == RUNNING)

-        return desc + " running";

-

-    if (status.mState == EXITED)

-        return STRINGIZE(desc << " exited with code " << status.mData);

-

-    if (status.mState == KILLED)

-#if LL_WINDOWS

-        return STRINGIZE(desc << " killed with exception " << std::hex << status.mData);

-#else

-        return STRINGIZE(desc << " killed by signal " << status.mData

-                         << " (" << apr_signal_description_get(status.mData) << ")");

-#endif

-

-    return STRINGIZE(desc << " in unknown state " << status.mState << " (" << status.mData << ")");

-}

-

-// Classic-C-style APR callback

-void LLProcess::status_callback(int reason, void* data, int status)

-{

-    // Our only role is to bounce this static method call back into object

-    // space.

-    static_cast<LLProcess*>(data)->handle_status(reason, status);

-}

-

-#define tabent(symbol) { symbol, #symbol }

-static struct ReasonCode

-{

-    int code;

-    const char* name;

-} reasons[] =

-{

-    tabent(APR_OC_REASON_DEATH),

-    tabent(APR_OC_REASON_UNWRITABLE),

-    tabent(APR_OC_REASON_RESTART),

-    tabent(APR_OC_REASON_UNREGISTER),

-    tabent(APR_OC_REASON_LOST),

-    tabent(APR_OC_REASON_RUNNING)

-};

-#undef tabent

-

-// Object-oriented callback

-void LLProcess::handle_status(int reason, int status)

-{

-    {

-        // This odd appearance of LL_DEBUGS is just to bracket a lookup that will

-        // only be performed if in fact we're going to produce the log message.

-        LL_DEBUGS("LLProcess") << empty;

-        std::string reason_str;

-        for (const ReasonCode& rcp : reasons)

-        {

-            if (reason == rcp.code)

-            {

-                reason_str = rcp.name;

-                break;

-            }

-        }

-        if (reason_str.empty())

-        {

-            reason_str = STRINGIZE("unknown reason " << reason);

-        }

-        LL_CONT << mDesc << ": handle_status(" << reason_str << ", " << status << ")" << LL_ENDL;

-    }

-

-    if (! (reason == APR_OC_REASON_DEATH || reason == APR_OC_REASON_LOST))

-    {

-        // We're only interested in the call when the child terminates.

-        return;

-    }

-

-    // Somewhat oddly, APR requires that you explicitly unregister even when

-    // it already knows the child has terminated. We must pass the same 'data'

-    // pointer as for the register() call, which was our 'this'.

-    apr_proc_other_child_unregister(this);

-    // don't keep polling for a terminated process

-    sProcessListener.dropPoll(*this);

-    // We overload mStatus.mState to indicate whether the child is registered

-    // for APR callback: only RUNNING means registered. Track that we've

-    // unregistered. We know the child has terminated; might be EXITED or

-    // KILLED; refine below.

-    mStatus.mState = EXITED;

-

-    // Make last-gasp calls for each of the ReadPipes we have on hand. Since

-    // they're listening on "mainloop", we can be sure they'll eventually

-    // collect all pending data from the child. But we want to be able to

-    // guarantee to our consumer that by the time we post on the "postend"

-    // LLEventPump, our ReadPipes are already buffering all the data there

-    // will ever be from the child. That lets the "postend" listener decide

-    // what to do with that final data.

-    for (size_t i = 0; i < mPipes.size(); ++i)

-    {

-        std::string error;

-        ReadPipeImpl* ppipe = getPipePtr<ReadPipeImpl>(error, FILESLOT(i));

-        if (ppipe)

-        {

-            static LLSD trivial;

-            ppipe->tick(trivial);

-        }

-    }

-

-//  wi->rv = apr_proc_wait(wi->child, &wi->rc, &wi->why, APR_NOWAIT);

-    // It's just wrong to call apr_proc_wait() here. The only way APR knows to

-    // call us with APR_OC_REASON_DEATH is that it's already reaped this child

-    // process, so calling wait() will only produce "huh?" from the OS. We

-    // must rely on the status param passed in, which unfortunately comes

-    // straight from the OS wait() call, which means we have to decode it by

-    // hand.

-    mStatus = interpret_status(status);

-    LL_INFOS("LLProcess") << getStatusString() << LL_ENDL;

-

-    // If caller requested notification on child termination, send it.

-    if (! mPostend.empty())

-    {

-        LLEventPumps::instance().obtain(mPostend)

-            .post(LLSDMap

-                  ("id",     getProcessID())

-                  ("desc",   mDesc)

-                  ("state",  mStatus.mState)

-                  ("data",   mStatus.mData)

-                  ("string", getStatusString())

-                 );

-    }

-}

-

-LLProcess::id LLProcess::getProcessID() const

-{

-    return mProcess.pid;

-}

-

-LLProcess::handle LLProcess::getProcessHandle() const

-{

-#if LL_WINDOWS

-    return mProcess.hproc;

-#else

-    return mProcess.pid;

-#endif

-}

-

-std::string LLProcess::getPipeName(FILESLOT) const

-{

-    // LLProcess::FileParam::type "npipe" is not yet implemented

-    return "";

-}

-

-template<class PIPETYPE>

-PIPETYPE* LLProcess::getPipePtr(std::string& error, FILESLOT slot)

-{

-    if (slot >= NSLOTS)

-    {

-        error = STRINGIZE(mDesc << " has no slot " << slot);

-        return NULL;

-    }

-    if (mPipes.is_null(slot))

-    {

-        error = STRINGIZE(mDesc << ' ' << whichfile(slot) << " not a monitored pipe");

-        return NULL;

-    }

-    // Make sure we dynamic_cast in pointer domain so we can test, rather than

-    // accepting runtime's exception.

-    PIPETYPE* ppipe = dynamic_cast<PIPETYPE*>(&mPipes[slot]);

-    if (! ppipe)

-    {

-        error = STRINGIZE(mDesc << ' ' << whichfile(slot) << " not a " << typeid(PIPETYPE).name());

-        return NULL;

-    }

-

-    error.clear();

-    return ppipe;

-}

-

-template <class PIPETYPE>

-PIPETYPE& LLProcess::getPipe(FILESLOT slot)

-{

-    std::string error;

-    PIPETYPE* wp = getPipePtr<PIPETYPE>(error, slot);

-    if (! wp)

-    {

-        LLTHROW(NoPipe(error));

-    }

-    return *wp;

-}

-

-template <class PIPETYPE>

-boost::optional<PIPETYPE&> LLProcess::getOptPipe(FILESLOT slot)

-{

-    std::string error;

-    PIPETYPE* wp = getPipePtr<PIPETYPE>(error, slot);

-    if (! wp)

-    {

-        LL_DEBUGS("LLProcess") << error << LL_ENDL;

-        return boost::optional<PIPETYPE&>();

-    }

-    return *wp;

-}

-

-LLProcess::WritePipe& LLProcess::getWritePipe(FILESLOT slot)

-{

-    return getPipe<WritePipe>(slot);

-}

-

-boost::optional<LLProcess::WritePipe&> LLProcess::getOptWritePipe(FILESLOT slot)

-{

-    return getOptPipe<WritePipe>(slot);

-}

-

-LLProcess::ReadPipe& LLProcess::getReadPipe(FILESLOT slot)

-{

-    return getPipe<ReadPipe>(slot);

-}

-

-boost::optional<LLProcess::ReadPipe&> LLProcess::getOptReadPipe(FILESLOT slot)

-{

-    return getOptPipe<ReadPipe>(slot);

-}

-

-//static

-std::string LLProcess::getline(std::istream& in)

-{

-    std::string line;

-    std::getline(in, line);

-    // Blur the distinction between "\r\n" and plain "\n". std::getline() will

-    // have eaten the "\n", but we could still end up with a trailing "\r".

-    std::string::size_type lastpos = line.find_last_not_of("\r");

-    if (lastpos != std::string::npos)

-    {

-        // Found at least one character that's not a trailing '\r'. SKIP OVER

-        // IT and erase the rest of the line.

-        line.erase(lastpos+1);

-    }

-    return line;

-}

-

-std::ostream& operator<<(std::ostream& out, const LLProcess::Params& params)

-{

-    if (params.cwd.isProvided())

-    {

-        out << "cd " << LLStringUtil::quote(params.cwd) << ": ";

-    }

-    out << LLStringUtil::quote(params.executable);

-    for (const std::string& arg : params.args)

-    {

-        out << ' ' << LLStringUtil::quote(arg);

-    }

-    return out;

-}

-

-/*****************************************************************************

-*   Windows specific

-*****************************************************************************/

-#if LL_WINDOWS

-

-static std::string WindowsErrorString(const std::string& operation);

-

-void LLProcess::autokill()

-{

-    // hopefully now handled by apr_procattr_autokill_set()

-}

-

-LLProcess::handle LLProcess::isRunning(handle h, const std::string& desc)

-{

-    // This direct Windows implementation is because we have no access to the

-    // apr_proc_t struct: we expect it's been destroyed.

-    if (! h)

-        return 0;

-

-    DWORD waitresult = WaitForSingleObject(h, 0);

-    if(waitresult == WAIT_OBJECT_0)

-    {

-        // the process has completed.

-        if (! desc.empty())

-        {

-            DWORD status = 0;

-            if (! GetExitCodeProcess(h, &status))

-            {

-                LL_WARNS("LLProcess") << desc << " terminated, but "

-                                      << WindowsErrorString("GetExitCodeProcess()") << LL_ENDL;

-            }

-            {

-                LL_INFOS("LLProcess") << getStatusString(desc, interpret_status(status))

-                                      << LL_ENDL;

-            }

-        }

-        CloseHandle(h);

-        return 0;

-    }

-

-    return h;

-}

-

-static LLProcess::Status interpret_status(int status)

-{

-    LLProcess::Status result;

-

-    // This bit of code is cribbed from apr/threadproc/win32/proc.c, a

-    // function (unfortunately static) called why_from_exit_code():

-    /* See WinNT.h STATUS_ACCESS_VIOLATION and family for how

-     * this class of failures was determined

-     */

-    if ((status & 0xFFFF0000) == 0xC0000000)

-    {

-        result.mState = LLProcess::KILLED;

-    }

-    else

-    {

-        result.mState = LLProcess::EXITED;

-    }

-    result.mData = status;

-

-    return result;

-}

-

-/// GetLastError()/FormatMessage() boilerplate

-static std::string WindowsErrorString(const std::string& operation)

-{

-    auto result = GetLastError();

-    return STRINGIZE(operation << " failed (" << result << "): "

-                     << windows_message<std::string>(result));

-}

-

-/*****************************************************************************

-*   Posix specific

-*****************************************************************************/

-#else // Mac and linux

-

-#include <signal.h>

-#include <fcntl.h>

-#include <errno.h>

-#include <sys/wait.h>

-

-void LLProcess::autokill()

-{

-    // What we ought to do here is to:

-    // 1. create a unique process group and run all autokill children in that

-    //    group (see https://jira.secondlife.com/browse/SWAT-563);

-    // 2. figure out a way to intercept control when the viewer exits --

-    //    gracefully or not;

-    // 3. when the viewer exits, kill off the aforementioned process group.

-

-    // It's point 2 that's troublesome. Although I've seen some signal-

-    // handling logic in the Posix viewer code, I haven't yet found any bit of

-    // code that's run no matter how the viewer exits (a try/finally for the

-    // whole process, as it were).

-}

-

-// Attempt to reap a process ID -- returns true if the process has exited and been reaped, false otherwise.

-static bool reap_pid(pid_t pid, LLProcess::Status* pstatus=NULL)

-{

-    LLProcess::Status dummy;

-    if (! pstatus)

-    {

-        // If caller doesn't want to see Status, give us a target anyway so we

-        // don't have to have a bunch of conditionals.

-        pstatus = &dummy;

-    }

-

-    int status = 0;

-    pid_t wait_result = ::waitpid(pid, &status, WNOHANG);

-    if (wait_result == pid)

-    {

-        *pstatus = interpret_status(status);

-        return true;

-    }

-    if (wait_result == 0)

-    {

-        pstatus->mState = LLProcess::RUNNING;

-        pstatus->mData  = 0;

-        return false;

-    }

-

-    // Clear caller's Status block; caller must interpret UNSTARTED to mean

-    // "if this PID was ever valid, it no longer is."

-    *pstatus = LLProcess::Status();

-

-    // We've dealt with the success cases: we were able to reap the child

-    // (wait_result == pid) or it's still running (wait_result == 0). It may

-    // be that the child terminated but didn't hang around long enough for us

-    // to reap. In that case we still have no Status to report, but we can at

-    // least state that it's not running.

-    if (wait_result == -1 && errno == ECHILD)

-    {

-        // No such process -- this may mean we're ignoring SIGCHILD.

-        return true;

-    }

-

-    // Uh, should never happen?!

-    LL_WARNS("LLProcess") << "LLProcess::reap_pid(): waitpid(" << pid << ") returned "

-                          << wait_result << "; not meaningful?" << LL_ENDL;

-    // If caller is looping until this pid terminates, and if we can't find

-    // out, better to break the loop than to claim it's still running.

-    return true;

-}

-

-LLProcess::id LLProcess::isRunning(id pid, const std::string& desc)

-{

-    // This direct Posix implementation is because we have no access to the

-    // apr_proc_t struct: we expect it's been destroyed.

-    if (! pid)

-        return 0;

-

-    // Check whether the process has exited, and reap it if it has.

-    LLProcess::Status status;

-    if(reap_pid(pid, &status))

-    {

-        // the process has exited.

-        if (! desc.empty())

-        {

-            std::string statstr(desc + " apparently terminated: no status available");

-            // We don't just pass UNSTARTED to getStatusString() because, in

-            // the context of reap_pid(), that state has special meaning.

-            if (status.mState != UNSTARTED)

-            {

-                statstr = getStatusString(desc, status);

-            }

-            LL_INFOS("LLProcess") << statstr << LL_ENDL;

-        }

-        return 0;

-    }

-

-    return pid;

-}

-

-static LLProcess::Status interpret_status(int status)

-{

-    LLProcess::Status result;

-

-    if (WIFEXITED(status))

-    {

-        result.mState = LLProcess::EXITED;

-        result.mData  = WEXITSTATUS(status);

-    }

-    else if (WIFSIGNALED(status))

-    {

-        result.mState = LLProcess::KILLED;

-        result.mData  = WTERMSIG(status);

-    }

-    else                            // uh, shouldn't happen?

-    {

-        result.mState = LLProcess::EXITED;

-        result.mData  = status;     // someone else will have to decode

-    }

-

-    return result;

-}

-

-#endif  // Posix

+/**
+ * @file llprocess.cpp
+ * @brief Utility class for launching, terminating, and tracking the state of processes.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llprocess.h"
+#include "llsdutil.h"
+#include "llsdserialize.h"
+#include "llsingleton.h"
+#include "llstring.h"
+#include "stringize.h"
+#include "llapr.h"
+#include "apr_signal.h"
+#include "llevents.h"
+#include "llexception.h"
+
+#include <boost/bind.hpp>
+#include <boost/asio/streambuf.hpp>
+#include <boost/asio/buffers_iterator.hpp>
+#include <iostream>
+#include <stdexcept>
+#include <limits>
+#include <algorithm>
+#include <vector>
+#include <typeinfo>
+#include <utility>
+
+/*****************************************************************************
+*   Helpers
+*****************************************************************************/
+static const char* whichfile_[] = { "stdin", "stdout", "stderr" };
+static std::string empty;
+static LLProcess::Status interpret_status(int status);
+static std::string getDesc(const LLProcess::Params& params);
+
+static std::string whichfile(LLProcess::FILESLOT index)
+{
+    if (index < LL_ARRAY_SIZE(whichfile_))
+        return whichfile_[index];
+    return STRINGIZE("file slot " << index);
+}
+
+/**
+ * Ref-counted "mainloop" listener. As long as there are still outstanding
+ * LLProcess objects, keep listening on "mainloop" so we can keep polling APR
+ * for process status.
+ */
+class LLProcessListener
+{
+    LOG_CLASS(LLProcessListener);
+public:
+    LLProcessListener():
+        mCount(0)
+    {}
+
+    void addPoll(const LLProcess&)
+    {
+        // Unconditionally increment mCount. If it was zero before
+        // incrementing, listen on "mainloop".
+        if (mCount++ == 0)
+        {
+            LL_DEBUGS("LLProcess") << "listening on \"mainloop\"" << LL_ENDL;
+            mConnection = LLEventPumps::instance().obtain("mainloop")
+                .listen("LLProcessListener", boost::bind(&LLProcessListener::tick, this, _1));
+        }
+    }
+
+    void dropPoll(const LLProcess&)
+    {
+        // Unconditionally decrement mCount. If it's zero after decrementing,
+        // stop listening on "mainloop".
+        if (--mCount == 0)
+        {
+            LL_DEBUGS("LLProcess") << "disconnecting from \"mainloop\"" << LL_ENDL;
+            mConnection.disconnect();
+        }
+    }
+
+private:
+    /// called once per frame by the "mainloop" LLEventPump
+    bool tick(const LLSD&)
+    {
+        // Tell APR to sense whether each registered LLProcess is still
+        // running and call handle_status() appropriately. We should be able
+        // to get the same info from an apr_proc_wait(APR_NOWAIT) call; but at
+        // least in APR 1.4.2, testing suggests that even with APR_NOWAIT,
+        // apr_proc_wait() blocks the caller. We can't have that in the
+        // viewer. Hence the callback rigmarole. (Once we update APR, it's
+        // probably worth testing again.) Also -- although there's an
+        // apr_proc_other_child_refresh() call, i.e. get that information for
+        // one specific child, it accepts an 'apr_other_child_rec_t*' that's
+        // mentioned NOWHERE else in the documentation or header files! I
+        // would use the specific call in LLProcess::getStatus() if I knew
+        // how. As it is, each call to apr_proc_other_child_refresh_all() will
+        // call callbacks for ALL still-running child processes. That's why we
+        // centralize such calls, using "mainloop" to ensure it happens once
+        // per frame, and refcounting running LLProcess objects to remain
+        // registered only while needed.
+        LL_DEBUGS("LLProcess") << "calling apr_proc_other_child_refresh_all()" << LL_ENDL;
+        apr_proc_other_child_refresh_all(APR_OC_REASON_RUNNING);
+        return false;
+    }
+
+    /// If this object is destroyed before mCount goes to zero, stop
+    /// listening on "mainloop" anyway.
+    LLTempBoundListener mConnection;
+    unsigned mCount;
+};
+static LLProcessListener sProcessListener;
+
+/*****************************************************************************
+*   WritePipe and ReadPipe
+*****************************************************************************/
+LLProcess::BasePipe::~BasePipe() {}
+const LLProcess::BasePipe::size_type
+      // use funky syntax to call max() to avoid blighted max() macros
+      LLProcess::BasePipe::npos((std::numeric_limits<LLProcess::BasePipe::size_type>::max)());
+
+class WritePipeImpl: public LLProcess::WritePipe
+{
+    LOG_CLASS(WritePipeImpl);
+public:
+    WritePipeImpl(const std::string& desc, apr_file_t* pipe):
+        mDesc(desc),
+        mPipe(pipe),
+        // Essential to initialize our std::ostream with our special streambuf!
+        mStream(&mStreambuf)
+    {
+        mConnection = LLEventPumps::instance().obtain("mainloop")
+            .listen(LLEventPump::inventName("WritePipe"),
+                    boost::bind(&WritePipeImpl::tick, this, _1));
+
+#if ! LL_WINDOWS
+        // We can't count on every child process reading everything we try to
+        // write to it. And if the child terminates with WritePipe data still
+        // pending, unless we explicitly suppress it, Posix will hit us with
+        // SIGPIPE. That would terminate the viewer, boom. "Ignoring" it means
+        // APR gets the correct errno, passes it back to us, we log it, etc.
+        signal(SIGPIPE, SIG_IGN);
+#endif
+    }
+
+    virtual std::ostream& get_ostream() { return mStream; }
+    virtual size_type size() const { return mStreambuf.size(); }
+
+    bool tick(const LLSD&)
+    {
+        typedef boost::asio::streambuf::const_buffers_type const_buffer_sequence;
+        // If there's anything to send, try to send it.
+        std::size_t total(mStreambuf.size()), consumed(0);
+        if (total)
+        {
+            const_buffer_sequence bufs = mStreambuf.data();
+            // In general, our streambuf might contain a number of different
+            // physical buffers; iterate over those.
+            bool keepwriting = true;
+            for (const_buffer_sequence::const_iterator bufi(bufs.begin()), bufend(bufs.end());
+                 bufi != bufend && keepwriting; ++bufi)
+            {
+                // http://www.boost.org/doc/libs/1_49_0_beta1/doc/html/boost_asio/reference/buffer.html#boost_asio.reference.buffer.accessing_buffer_contents
+                // Although apr_file_write() accepts const void*, we
+                // manipulate const char* so we can increment the pointer.
+                const char* remainptr = boost::asio::buffer_cast<const char*>(*bufi);
+                std::size_t remainlen = boost::asio::buffer_size(*bufi);
+                while (remainlen)
+                {
+                    // Tackle the current buffer in discrete chunks. On
+                    // Windows, we've observed strange failures when trying to
+                    // write big lengths (~1 MB) in a single operation. Even a
+                    // 32K chunk seems too large. At some point along the way
+                    // apr_file_write() returns 11 (Resource temporarily
+                    // unavailable, i.e. EAGAIN) and says it wrote 0 bytes --
+                    // even though it did write the chunk! Our next write
+                    // attempt retries with the same chunk, resulting in the
+                    // chunk being duplicated at the child end. Using smaller
+                    // chunks is empirically more reliable.
+                    std::size_t towrite((std::min)(remainlen, std::size_t(4*1024)));
+                    apr_size_t written(towrite);
+                    apr_status_t err = apr_file_write(mPipe, remainptr, &written);
+                    // EAGAIN is exactly what we want from a nonblocking pipe.
+                    // Rather than waiting for data, it should return immediately.
+                    if (! (err == APR_SUCCESS || APR_STATUS_IS_EAGAIN(err)))
+                    {
+                        LL_WARNS("LLProcess") << "apr_file_write(" << towrite << ") on " << mDesc
+                                              << " got " << err << ":" << LL_ENDL;
+                        ll_apr_warn_status(err);
+                    }
+
+                    // 'written' is modified to reflect the number of bytes actually
+                    // written. Make sure we consume those later. (Don't consume them
+                    // now, that would invalidate the buffer iterator sequence!)
+                    consumed += written;
+                    // don't forget to advance to next chunk of current buffer
+                    remainptr += written;
+                    remainlen -= written;
+
+                    char msgbuf[512];
+                    LL_DEBUGS("LLProcess") << "wrote " << written << " of " << towrite
+                                           << " bytes to " << mDesc
+                                           << " (original " << total << "),"
+                                           << " code " << err << ": "
+                                           << apr_strerror(err, msgbuf, sizeof(msgbuf))
+                                           << LL_ENDL;
+
+                    // The parent end of this pipe is nonblocking. If we weren't able
+                    // to write everything we wanted, don't keep banging on it -- that
+                    // won't change until the child reads some. Wait for next tick().
+                    if (written < towrite)
+                    {
+                        keepwriting = false; // break outer loop over buffers too
+                        break;
+                    }
+                } // next chunk of current buffer
+            }     // next buffer
+            // In all, we managed to write 'consumed' bytes. Remove them from the
+            // streambuf so we don't keep trying to send them. This could be
+            // anywhere from 0 up to mStreambuf.size(); anything we haven't yet
+            // sent, we'll try again later.
+            mStreambuf.consume(consumed);
+        }
+
+        return false;
+    }
+
+private:
+    std::string mDesc;
+    apr_file_t* mPipe;
+    LLTempBoundListener mConnection;
+    boost::asio::streambuf mStreambuf;
+    std::ostream mStream;
+};
+
+class ReadPipeImpl: public LLProcess::ReadPipe
+{
+    LOG_CLASS(ReadPipeImpl);
+public:
+    ReadPipeImpl(const std::string& desc, apr_file_t* pipe, LLProcess::FILESLOT index):
+        mDesc(desc),
+        mPipe(pipe),
+        mIndex(index),
+        // Essential to initialize our std::istream with our special streambuf!
+        mStream(&mStreambuf),
+        mPump("ReadPipe", true),    // tweak name as needed to avoid collisions
+        mLimit(0),
+        mEOF(false)
+    {
+        mConnection = LLEventPumps::instance().obtain("mainloop")
+            .listen(LLEventPump::inventName("ReadPipe"),
+                    boost::bind(&ReadPipeImpl::tick, this, _1));
+    }
+
+    ~ReadPipeImpl()
+    {
+        if (mConnection.connected())
+        {
+            mConnection.disconnect();
+        }
+    }
+
+    // Much of the implementation is simply connecting the abstract virtual
+    // methods with implementation data concealed from the base class.
+    virtual std::istream& get_istream() { return mStream; }
+    virtual std::string getline() { return LLProcess::getline(mStream); }
+    virtual LLEventPump& getPump() { return mPump; }
+    virtual void setLimit(size_type limit) { mLimit = limit; }
+    virtual size_type getLimit() const { return mLimit; }
+    virtual size_type size() const { return mStreambuf.size(); }
+
+    virtual std::string read(size_type len)
+    {
+        // Read specified number of bytes into a buffer.
+        size_type readlen((std::min)(size(), len));
+        // Formally, &buffer[0] is invalid for a vector of size() 0. Exit
+        // early in that situation.
+        if (! readlen)
+            return "";
+        // Make a buffer big enough.
+        std::vector<char> buffer(readlen);
+        mStream.read(&buffer[0], readlen);
+        // Since we've already clamped 'readlen', we can think of no reason
+        // why mStream.read() should read fewer than 'readlen' bytes.
+        // Nonetheless, use the actual retrieved length.
+        return std::string(&buffer[0], mStream.gcount());
+    }
+
+    virtual std::string peek(size_type offset=0, size_type len=npos) const
+    {
+        // Constrain caller's offset and len to overlap actual buffer content.
+        std::size_t real_offset = (std::min)(mStreambuf.size(), std::size_t(offset));
+        size_type   want_end    = (len == npos)? npos : (real_offset + len);
+        std::size_t real_end    = (std::min)(mStreambuf.size(), std::size_t(want_end));
+        boost::asio::streambuf::const_buffers_type cbufs = mStreambuf.data();
+        return std::string(boost::asio::buffers_begin(cbufs) + real_offset,
+                           boost::asio::buffers_begin(cbufs) + real_end);
+    }
+
+    virtual size_type find(const std::string& seek, size_type offset=0) const
+    {
+        // If we're passing a string of length 1, use find(char), which can
+        // use an O(n) std::find() rather than the O(n^2) std::search().
+        if (seek.length() == 1)
+        {
+            return find(seek[0], offset);
+        }
+
+        // If offset is beyond the whole buffer, can't even construct a valid
+        // iterator range; can't possibly find the string we seek.
+        if (offset > mStreambuf.size())
+        {
+            return npos;
+        }
+
+        boost::asio::streambuf::const_buffers_type cbufs = mStreambuf.data();
+        boost::asio::buffers_iterator<boost::asio::streambuf::const_buffers_type>
+            begin(boost::asio::buffers_begin(cbufs)),
+            end  (boost::asio::buffers_end(cbufs)),
+            found(std::search(begin + offset, end, seek.begin(), seek.end()));
+        return (found == end)? npos : (found - begin);
+    }
+
+    virtual size_type find(char seek, size_type offset=0) const
+    {
+        // If offset is beyond the whole buffer, can't even construct a valid
+        // iterator range; can't possibly find the char we seek.
+        if (offset > mStreambuf.size())
+        {
+            return npos;
+        }
+
+        boost::asio::streambuf::const_buffers_type cbufs = mStreambuf.data();
+        boost::asio::buffers_iterator<boost::asio::streambuf::const_buffers_type>
+            begin(boost::asio::buffers_begin(cbufs)),
+            end  (boost::asio::buffers_end(cbufs)),
+            found(std::find(begin + offset, end, seek));
+        return (found == end)? npos : (found - begin);
+    }
+
+    bool tick(const LLSD&)
+    {
+        // Once we've hit EOF, skip all the rest of this.
+        if (mEOF)
+            return false;
+
+        typedef boost::asio::streambuf::mutable_buffers_type mutable_buffer_sequence;
+        // Try, every time, to read into our streambuf. In fact, we have no
+        // idea how much data the child might be trying to send: keep trying
+        // until we're convinced we've temporarily exhausted the pipe.
+        enum PipeState { RETRY, EXHAUSTED, CLOSED };
+        PipeState state = RETRY;
+        std::size_t committed(0);
+        do
+        {
+            // attempt to read an arbitrary size
+            mutable_buffer_sequence bufs = mStreambuf.prepare(4096);
+            // In general, the mutable_buffer_sequence returned by prepare() might
+            // contain a number of different physical buffers; iterate over those.
+            std::size_t tocommit(0);
+            for (mutable_buffer_sequence::const_iterator bufi(bufs.begin()), bufend(bufs.end());
+                 bufi != bufend; ++bufi)
+            {
+                // http://www.boost.org/doc/libs/1_49_0_beta1/doc/html/boost_asio/reference/buffer.html#boost_asio.reference.buffer.accessing_buffer_contents
+                std::size_t toread(boost::asio::buffer_size(*bufi));
+                apr_size_t gotten(toread);
+                apr_status_t err = apr_file_read(mPipe,
+                                                 boost::asio::buffer_cast<void*>(*bufi),
+                                                 &gotten);
+                // EAGAIN is exactly what we want from a nonblocking pipe.
+                // Rather than waiting for data, it should return immediately.
+                if (! (err == APR_SUCCESS || APR_STATUS_IS_EAGAIN(err)))
+                {
+                    // Handle EOF specially: it's part of normal-case processing.
+                    if (err == APR_EOF)
+                    {
+                        LL_DEBUGS("LLProcess") << "EOF on " << mDesc << LL_ENDL;
+                    }
+                    else
+                    {
+                        LL_WARNS("LLProcess") << "apr_file_read(" << toread << ") on " << mDesc
+                                              << " got " << err << ":" << LL_ENDL;
+                        ll_apr_warn_status(err);
+                    }
+                    // Either way, though, we won't need any more tick() calls.
+                    mConnection.disconnect();
+                    // Ignore any subsequent calls we might get anyway.
+                    mEOF = true;
+                    state = CLOSED; // also break outer retry loop
+                    break;
+                }
+
+                // 'gotten' was modified to reflect the number of bytes actually
+                // received. Make sure we commit those later. (Don't commit them
+                // now, that would invalidate the buffer iterator sequence!)
+                tocommit += gotten;
+                LL_DEBUGS("LLProcess") << "filled " << gotten << " of " << toread
+                                       << " bytes from " << mDesc << LL_ENDL;
+
+                // The parent end of this pipe is nonblocking. If we weren't even
+                // able to fill this buffer, don't loop to try to fill the next --
+                // that won't change until the child writes more. Wait for next
+                // tick().
+                if (gotten < toread)
+                {
+                    // break outer retry loop too
+                    state = EXHAUSTED;
+                    break;
+                }
+            }
+
+            // Don't forget to "commit" the data!
+            mStreambuf.commit(tocommit);
+            committed += tocommit;
+
+            // state is changed from RETRY when we can't fill any one buffer
+            // of the mutable_buffer_sequence established by the current
+            // prepare() call -- whether due to error or not enough bytes.
+            // That is, if state is still RETRY, we've filled every physical
+            // buffer in the mutable_buffer_sequence. In that case, for all we
+            // know, the child might have still more data pending -- go for it!
+        } while (state == RETRY);
+
+        // Once we recognize that the pipe is closed, make one more call to
+        // listener. The listener might be waiting for a particular substring
+        // to arrive, or a particular length of data or something. The event
+        // with "eof" == true announces that nothing further will arrive, so
+        // use it or lose it.
+        if (committed || state == CLOSED)
+        {
+            // If we actually received new data, publish it on our LLEventPump
+            // as advertised. Constrain it by mLimit. But show listener the
+            // actual accumulated buffer size, regardless of mLimit.
+            size_type datasize((std::min)(mLimit, size_type(mStreambuf.size())));
+            mPump.post(LLSDMap
+                       ("data", peek(0, datasize))
+                       ("len", LLSD::Integer(mStreambuf.size()))
+                       ("slot", LLSD::Integer(mIndex))
+                       ("name", whichfile(mIndex))
+                       ("desc", mDesc)
+                       ("eof", state == CLOSED));
+        }
+
+        return false;
+    }
+
+private:
+    std::string mDesc;
+    apr_file_t* mPipe;
+    LLProcess::FILESLOT mIndex;
+    LLTempBoundListener mConnection;
+    boost::asio::streambuf mStreambuf;
+    std::istream mStream;
+    LLEventStream mPump;
+    size_type mLimit;
+    bool mEOF;
+};
+
+/*****************************************************************************
+*   LLProcess itself
+*****************************************************************************/
+/// Need an exception to avoid constructing an invalid LLProcess object, but
+/// internal use only
+struct LLProcessError: public LLException
+{
+    LLProcessError(const std::string& msg): LLException(msg) {}
+};
+
+LLProcessPtr LLProcess::create(const LLSDOrParams& params)
+{
+    try
+    {
+        return LLProcessPtr(new LLProcess(params));
+    }
+    catch (const LLProcessError& e)
+    {
+        LL_WARNS("LLProcess") << e.what() << LL_ENDL;
+
+        // If caller is requesting an event on process termination, send one
+        // indicating bad launch. This may prevent someone waiting forever for
+        // a termination post that can't arrive because the child never
+        // started.
+        if (params.postend.isProvided())
+        {
+            LLEventPumps::instance().obtain(params.postend)
+                .post(LLSDMap
+                      // no "id"
+                      ("desc", getDesc(params))
+                      ("state", LLProcess::UNSTARTED)
+                      // no "data"
+                      ("string", e.what())
+                     );
+        }
+
+        return LLProcessPtr();
+    }
+}
+
+/// Call an apr function returning apr_status_t. On failure, log warning and
+/// throw LLProcessError mentioning the function call that produced that
+/// result.
+#define chkapr(func)                            \
+    if (ll_apr_warn_status(func))               \
+        throw LLProcessError(#func " failed")
+
+LLProcess::LLProcess(const LLSDOrParams& params):
+    mAutokill(params.autokill),
+    // Because 'autokill' originally meant both 'autokill' and 'attached', to
+    // preserve existing semantics, we promise that mAttached defaults to the
+    // same setting as mAutokill.
+    mAttached(params.attached.isProvided()? params.attached : params.autokill),
+    mPool(NULL),
+    mPipes(NSLOTS)
+{
+    // Hmm, when you construct a ptr_vector with a size, it merely reserves
+    // space, it doesn't actually make it that big. Explicitly make it bigger.
+    // Because of ptr_vector's odd semantics, have to push_back(0) the right
+    // number of times! resize() wants to default-construct new BasePipe
+    // instances, which fails because it's pure virtual. But because of the
+    // constructor call, these push_back() calls should require no new
+    // allocation.
+    for (size_t i = 0; i < mPipes.capacity(); ++i)
+        mPipes.push_back(0);
+
+    if (! params.validateBlock(true))
+    {
+        LLTHROW(LLProcessError(STRINGIZE("not launched: failed parameter validation\n"
+                                         << LLSDNotationStreamer(params))));
+    }
+
+    mPostend = params.postend;
+
+    apr_pool_create(&mPool, gAPRPoolp);
+    if (!mPool)
+    {
+        LLTHROW(LLProcessError(STRINGIZE("failed to create apr pool")));
+    }
+
+    apr_procattr_t *procattr = NULL;
+    chkapr(apr_procattr_create(&procattr, mPool));
+
+    // IQA-490, CHOP-900: On Windows, ask APR to jump through hoops to
+    // constrain the set of handles passed to the child process. Before we
+    // changed to APR, the Windows implementation of LLProcessLauncher called
+    // CreateProcess(bInheritHandles=false), meaning to pass NO open handles
+    // to the child process. Now that we support pipes, though, we must allow
+    // apr_proc_create() to pass bInheritHandles=true. But without taking
+    // special pains, that causes trouble in a number of ways, due to the fact
+    // that the viewer is constantly opening and closing files -- most of
+    // which CreateProcess() passes to every child process!
+#if ! defined(APR_HAS_PROCATTR_CONSTRAIN_HANDLE_SET)
+    // Our special preprocessor symbol isn't even defined -- wrong APR
+    LL_WARNS("LLProcess") << "This version of APR lacks Linden "
+                          << "apr_procattr_constrain_handle_set() extension" << LL_ENDL;
+#else
+    chkapr(apr_procattr_constrain_handle_set(procattr, 1));
+#endif
+
+    // For which of stdin, stdout, stderr should we create a pipe to the
+    // child? In the viewer, there are only a couple viable
+    // apr_procattr_io_set() alternatives: inherit the viewer's own stdxxx
+    // handle (APR_NO_PIPE, e.g. for stdout, stderr), or create a pipe that's
+    // blocking on the child end but nonblocking at the viewer end
+    // (APR_CHILD_BLOCK).
+    // Other major options could include explicitly creating a single APR pipe
+    // and passing it as both stdout and stderr (apr_procattr_child_out_set(),
+    // apr_procattr_child_err_set()), or accepting a filename, opening it and
+    // passing that apr_file_t (simple <, >, 2> redirect emulation).
+    std::vector<apr_int32_t> select;
+    for (const FileParam& fparam : params.files)
+    {
+        // Every iteration, we're going to append an item to 'select'. At the
+        // top of the loop, its size() is, in effect, an index. Use that to
+        // pick a string description for messages.
+        std::string which(whichfile(FILESLOT(select.size())));
+        if (fparam.type().empty())  // inherit our file descriptor
+        {
+            select.push_back(APR_NO_PIPE);
+        }
+        else if (fparam.type() == "pipe") // anonymous pipe
+        {
+            if (! fparam.name().empty())
+            {
+                LL_WARNS("LLProcess") << "For " << params.executable()
+                                      << ": internal names for reusing pipes ('"
+                                      << fparam.name() << "' for " << which
+                                      << ") are not yet supported -- creating distinct pipe"
+                                      << LL_ENDL;
+            }
+            // The viewer can't block for anything: the parent end MUST be
+            // nonblocking. As the APR documentation itself points out, it
+            // makes very little sense to set nonblocking I/O for the child
+            // end of a pipe: only a specially-written child could deal with
+            // that.
+            select.push_back(APR_CHILD_BLOCK);
+        }
+        else
+        {
+            LLTHROW(LLProcessError(STRINGIZE("For " << params.executable()
+                                             << ": unsupported FileParam for " << which
+                                             << ": type='" << fparam.type()
+                                             << "', name='" << fparam.name() << "'")));
+        }
+    }
+    // By default, pass APR_NO_PIPE for unspecified slots.
+    while (select.size() < NSLOTS)
+    {
+        select.push_back(APR_NO_PIPE);
+    }
+    chkapr(apr_procattr_io_set(procattr, select[STDIN], select[STDOUT], select[STDERR]));
+
+    // Thumbs down on implicitly invoking the shell to invoke the child. From
+    // our point of view, the other major alternative to APR_PROGRAM_PATH
+    // would be APR_PROGRAM_ENV: still copy environment, but require full
+    // executable pathname. I don't see a downside to searching the PATH,
+    // though: if our caller wants (e.g.) a specific Python interpreter, s/he
+    // can still pass the full pathname.
+    chkapr(apr_procattr_cmdtype_set(procattr, APR_PROGRAM_PATH));
+    // YES, do extra work if necessary to report child exec() failures back to
+    // parent process.
+    chkapr(apr_procattr_error_check_set(procattr, 1));
+    // Do not start a non-autokill child in detached state. On Posix
+    // platforms, this setting attempts to daemonize the new child, closing
+    // std handles and the like, and that's a bit more detachment than we
+    // want. autokill=false just means not to implicitly kill the child when
+    // the parent terminates!
+//  chkapr(apr_procattr_detach_set(procattr, mAutokill? 0 : 1));
+
+    if (mAutokill)
+    {
+#if ! defined(APR_HAS_PROCATTR_AUTOKILL_SET)
+        // Our special preprocessor symbol isn't even defined -- wrong APR
+        LL_WARNS("LLProcess") << "This version of APR lacks Linden apr_procattr_autokill_set() extension" << LL_ENDL;
+#elif ! APR_HAS_PROCATTR_AUTOKILL_SET
+        // Symbol is defined, but to 0: expect apr_procattr_autokill_set() to
+        // return APR_ENOTIMPL.
+#else   // APR_HAS_PROCATTR_AUTOKILL_SET nonzero
+        ll_apr_warn_status(apr_procattr_autokill_set(procattr, 1));
+#endif
+    }
+
+    // In preparation for calling apr_proc_create(), we collect a number of
+    // const char* pointers obtained from std::string::c_str(). Turns out
+    // LLInitParam::Block's helpers Optional, Mandatory, Multiple et al.
+    // guarantee that converting to the wrapped type (std::string in our
+    // case), e.g. by calling operator(), returns a reference to *the same
+    // instance* of the wrapped type that's stored in our Block subclass.
+    // That's important! We know 'params' persists throughout this method
+    // call; but without that guarantee, we'd have to assume that converting
+    // one of its members to std::string might return a different (temp)
+    // instance. Capturing the c_str() from a temporary std::string is Bad Bad
+    // Bad. But armed with this knowledge, when you see params.cwd().c_str(),
+    // grit your teeth and smile and carry on.
+
+    if (params.cwd.isProvided())
+    {
+        chkapr(apr_procattr_dir_set(procattr, params.cwd().c_str()));
+    }
+
+    // create an argv vector for the child process
+    std::vector<const char*> argv;
+
+    // Add the executable path. See above remarks about c_str().
+    argv.push_back(params.executable().c_str());
+
+    // Add arguments. See above remarks about c_str().
+    for (const std::string& arg : params.args)
+    {
+        argv.push_back(arg.c_str());
+    }
+
+    // terminate with a null pointer
+    argv.push_back(NULL);
+
+    // Launch! The NULL would be the environment block, if we were passing
+    // one. Hand-expand chkapr() macro so we can fill in the actual command
+    // string instead of the variable names.
+    if (ll_apr_warn_status(apr_proc_create(&mProcess, argv[0], &argv[0], NULL, procattr,
+                                           mPool)))
+    {
+        LLTHROW(LLProcessError(STRINGIZE(params << " failed")));
+    }
+
+    // arrange to call status_callback()
+    apr_proc_other_child_register(&mProcess, &LLProcess::status_callback, this, mProcess.in,
+                                  mPool);
+    // and make sure we poll it once per "mainloop" tick
+    sProcessListener.addPoll(*this);
+    mStatus.mState = RUNNING;
+
+    mDesc = STRINGIZE(getDesc(params) << " (" << mProcess.pid << ')');
+    LL_INFOS("LLProcess") << mDesc << ": launched " << params << LL_ENDL;
+
+    // Unless caller explicitly turned off autokill (child should persist),
+    // take steps to terminate the child. This is all suspenders-and-belt: in
+    // theory our destructor should kill an autokill child, but in practice
+    // that doesn't always work (e.g. VWR-21538).
+    if (mAutokill)
+    {
+/*==========================================================================*|
+        // NO: There may be an APR bug, not sure -- but at least on Mac, when
+        // gAPRPoolp is destroyed, OUR process receives SIGTERM! Apparently
+        // either our own PID is getting into the list of processes to kill()
+        // (unlikely), or somehow one of those PIDs is getting zeroed first,
+        // so that kill() sends SIGTERM to the whole process group -- this
+        // process included. I'd have to build and link with a debug version
+        // of APR to know for sure. It's too bad: this mechanism would be just
+        // right for dealing with static autokill LLProcessPtr variables,
+        // which aren't destroyed until after APR is no longer available.
+
+        // Tie the lifespan of this child process to the lifespan of our APR
+        // pool: on destruction of the pool, forcibly kill the process. Tell
+        // APR to try SIGTERM and suspend 3 seconds. If that didn't work, use
+        // SIGKILL.
+        apr_pool_note_subprocess(gAPRPoolp, &mProcess, APR_KILL_AFTER_TIMEOUT);
+|*==========================================================================*/
+
+        // On Windows, associate the new child process with our Job Object.
+        autokill();
+    }
+
+    // Instantiate the proper pipe I/O machinery
+    // want to be able to point to apr_proc_t::in, out, err by index
+    typedef apr_file_t* apr_proc_t::*apr_proc_file_ptr;
+    static apr_proc_file_ptr members[] =
+        { &apr_proc_t::in, &apr_proc_t::out, &apr_proc_t::err };
+    for (size_t i = 0; i < NSLOTS; ++i)
+    {
+        if (select[i] != APR_CHILD_BLOCK)
+            continue;
+        std::string desc(STRINGIZE(mDesc << ' ' << whichfile(FILESLOT(i))));
+        apr_file_t* pipe(mProcess.*(members[i]));
+        if (i == STDIN)
+        {
+            mPipes.replace(i, new WritePipeImpl(desc, pipe));
+        }
+        else
+        {
+            mPipes.replace(i, new ReadPipeImpl(desc, pipe, FILESLOT(i)));
+        }
+        // Removed temporaily for Xcode 7 build tests: error was:
+        // "error: expression with side effects will be evaluated despite
+        // being used as an operand to 'typeid' [-Werror,-Wpotentially-evaluated-expression]""
+        //LL_DEBUGS("LLProcess") << "Instantiating " << typeid(mPipes[i]).name()
+        //                     << "('" << desc << "')" << LL_ENDL;
+    }
+}
+
+// Helper to obtain a description string, given a Params block
+static std::string getDesc(const LLProcess::Params& params)
+{
+    // If caller specified a description string, by all means use it.
+    if (params.desc.isProvided())
+        return params.desc;
+
+    // Caller didn't say. Use the executable name -- but use just the filename
+    // part. On Mac, for instance, full pathnames get cumbersome.
+    return LLProcess::basename(params.executable);
+}
+
+//static
+std::string LLProcess::basename(const std::string& path)
+{
+    // If there are Linden utility functions to manipulate pathnames, I
+    // haven't found them -- and for this usage, Boost.Filesystem seems kind
+    // of heavyweight.
+    std::string::size_type delim = path.find_last_of("\\/");
+    // If path contains no pathname delimiters, return the whole thing.
+    if (delim == std::string::npos)
+        return path;
+
+    // Return just the part beyond the last delimiter.
+    return path.substr(delim + 1);
+}
+
+LLProcess::~LLProcess()
+{
+    // In the Linden viewer, there's at least one static LLProcessPtr. Its
+    // destructor will be called *after* ll_cleanup_apr(). In such a case,
+    // unregistering is pointless (and fatal!) -- and kill(), which also
+    // relies on APR, is impossible.
+    if (! gAPRPoolp)
+        return;
+
+    // Only in state RUNNING are we registered for callback. In UNSTARTED we
+    // haven't yet registered. And since receiving the callback is the only
+    // way we detect child termination, we only change from state RUNNING at
+    // the same time we unregister.
+    if (mStatus.mState == RUNNING)
+    {
+        // We're still registered for a callback: unregister. Do it before
+        // we even issue the kill(): even if kill() somehow prompted an
+        // instantaneous callback (unlikely), this object is going away! Any
+        // information updated in this object by such a callback is no longer
+        // available to any consumer anyway.
+        apr_proc_other_child_unregister(this);
+        // One less LLProcess to poll for
+        sProcessListener.dropPoll(*this);
+    }
+
+    if (mAttached)
+    {
+        kill("destructor");
+    }
+
+    if (mPool)
+    {
+        apr_pool_destroy(mPool);
+        mPool = NULL;
+    }
+}
+
+bool LLProcess::kill(const std::string& who)
+{
+    if (isRunning())
+    {
+        LL_INFOS("LLProcess") << who << " killing " << mDesc << LL_ENDL;
+
+#if LL_WINDOWS
+        int sig = -1;
+#else  // Posix
+        int sig = SIGTERM;
+#endif
+
+        ll_apr_warn_status(apr_proc_kill(&mProcess, sig));
+    }
+
+    return ! isRunning();
+}
+
+//static
+bool LLProcess::kill(const LLProcessPtr& p, const std::string& who)
+{
+    if (! p)
+        return true;                // process dead! (was never running)
+    return p->kill(who);
+}
+
+bool LLProcess::isRunning() const
+{
+    return getStatus().mState == RUNNING;
+}
+
+//static
+bool LLProcess::isRunning(const LLProcessPtr& p)
+{
+    if (! p)
+        return false;
+    return p->isRunning();
+}
+
+LLProcess::Status LLProcess::getStatus() const
+{
+    return mStatus;
+}
+
+//static
+LLProcess::Status LLProcess::getStatus(const LLProcessPtr& p)
+{
+    if (! p)
+    {
+        // default-constructed Status has mState == UNSTARTED
+        return Status();
+    }
+    return p->getStatus();
+}
+
+std::string LLProcess::getStatusString() const
+{
+    return getStatusString(getStatus());
+}
+
+std::string LLProcess::getStatusString(const Status& status) const
+{
+    return getStatusString(mDesc, status);
+}
+
+//static
+std::string LLProcess::getStatusString(const std::string& desc, const LLProcessPtr& p)
+{
+    if (! p)
+    {
+        // default-constructed Status has mState == UNSTARTED
+        return getStatusString(desc, Status());
+    }
+    return desc + " " + p->getStatusString();
+}
+
+//static
+std::string LLProcess::getStatusString(const std::string& desc, const Status& status)
+{
+    if (status.mState == UNSTARTED)
+        return desc + " was never launched";
+
+    if (status.mState == RUNNING)
+        return desc + " running";
+
+    if (status.mState == EXITED)
+        return STRINGIZE(desc << " exited with code " << status.mData);
+
+    if (status.mState == KILLED)
+#if LL_WINDOWS
+        return STRINGIZE(desc << " killed with exception " << std::hex << status.mData);
+#else
+        return STRINGIZE(desc << " killed by signal " << status.mData
+                         << " (" << apr_signal_description_get(status.mData) << ")");
+#endif
+
+    return STRINGIZE(desc << " in unknown state " << status.mState << " (" << status.mData << ")");
+}
+
+// Classic-C-style APR callback
+void LLProcess::status_callback(int reason, void* data, int status)
+{
+    // Our only role is to bounce this static method call back into object
+    // space.
+    static_cast<LLProcess*>(data)->handle_status(reason, status);
+}
+
+#define tabent(symbol) { symbol, #symbol }
+static struct ReasonCode
+{
+    int code;
+    const char* name;
+} reasons[] =
+{
+    tabent(APR_OC_REASON_DEATH),
+    tabent(APR_OC_REASON_UNWRITABLE),
+    tabent(APR_OC_REASON_RESTART),
+    tabent(APR_OC_REASON_UNREGISTER),
+    tabent(APR_OC_REASON_LOST),
+    tabent(APR_OC_REASON_RUNNING)
+};
+#undef tabent
+
+// Object-oriented callback
+void LLProcess::handle_status(int reason, int status)
+{
+    {
+        // This odd appearance of LL_DEBUGS is just to bracket a lookup that will
+        // only be performed if in fact we're going to produce the log message.
+        LL_DEBUGS("LLProcess") << empty;
+        std::string reason_str;
+        for (const ReasonCode& rcp : reasons)
+        {
+            if (reason == rcp.code)
+            {
+                reason_str = rcp.name;
+                break;
+            }
+        }
+        if (reason_str.empty())
+        {
+            reason_str = STRINGIZE("unknown reason " << reason);
+        }
+        LL_CONT << mDesc << ": handle_status(" << reason_str << ", " << status << ")" << LL_ENDL;
+    }
+
+    if (! (reason == APR_OC_REASON_DEATH || reason == APR_OC_REASON_LOST))
+    {
+        // We're only interested in the call when the child terminates.
+        return;
+    }
+
+    // Somewhat oddly, APR requires that you explicitly unregister even when
+    // it already knows the child has terminated. We must pass the same 'data'
+    // pointer as for the register() call, which was our 'this'.
+    apr_proc_other_child_unregister(this);
+    // don't keep polling for a terminated process
+    sProcessListener.dropPoll(*this);
+    // We overload mStatus.mState to indicate whether the child is registered
+    // for APR callback: only RUNNING means registered. Track that we've
+    // unregistered. We know the child has terminated; might be EXITED or
+    // KILLED; refine below.
+    mStatus.mState = EXITED;
+
+    // Make last-gasp calls for each of the ReadPipes we have on hand. Since
+    // they're listening on "mainloop", we can be sure they'll eventually
+    // collect all pending data from the child. But we want to be able to
+    // guarantee to our consumer that by the time we post on the "postend"
+    // LLEventPump, our ReadPipes are already buffering all the data there
+    // will ever be from the child. That lets the "postend" listener decide
+    // what to do with that final data.
+    for (size_t i = 0; i < mPipes.size(); ++i)
+    {
+        std::string error;
+        ReadPipeImpl* ppipe = getPipePtr<ReadPipeImpl>(error, FILESLOT(i));
+        if (ppipe)
+        {
+            static LLSD trivial;
+            ppipe->tick(trivial);
+        }
+    }
+
+//  wi->rv = apr_proc_wait(wi->child, &wi->rc, &wi->why, APR_NOWAIT);
+    // It's just wrong to call apr_proc_wait() here. The only way APR knows to
+    // call us with APR_OC_REASON_DEATH is that it's already reaped this child
+    // process, so calling wait() will only produce "huh?" from the OS. We
+    // must rely on the status param passed in, which unfortunately comes
+    // straight from the OS wait() call, which means we have to decode it by
+    // hand.
+    mStatus = interpret_status(status);
+    LL_INFOS("LLProcess") << getStatusString() << LL_ENDL;
+
+    // If caller requested notification on child termination, send it.
+    if (! mPostend.empty())
+    {
+        LLEventPumps::instance().obtain(mPostend)
+            .post(LLSDMap
+                  ("id",     getProcessID())
+                  ("desc",   mDesc)
+                  ("state",  mStatus.mState)
+                  ("data",   mStatus.mData)
+                  ("string", getStatusString())
+                 );
+    }
+}
+
+LLProcess::id LLProcess::getProcessID() const
+{
+    return mProcess.pid;
+}
+
+LLProcess::handle LLProcess::getProcessHandle() const
+{
+#if LL_WINDOWS
+    return mProcess.hproc;
+#else
+    return mProcess.pid;
+#endif
+}
+
+std::string LLProcess::getPipeName(FILESLOT) const
+{
+    // LLProcess::FileParam::type "npipe" is not yet implemented
+    return "";
+}
+
+template<class PIPETYPE>
+PIPETYPE* LLProcess::getPipePtr(std::string& error, FILESLOT slot)
+{
+    if (slot >= NSLOTS)
+    {
+        error = STRINGIZE(mDesc << " has no slot " << slot);
+        return NULL;
+    }
+    if (mPipes.is_null(slot))
+    {
+        error = STRINGIZE(mDesc << ' ' << whichfile(slot) << " not a monitored pipe");
+        return NULL;
+    }
+    // Make sure we dynamic_cast in pointer domain so we can test, rather than
+    // accepting runtime's exception.
+    PIPETYPE* ppipe = dynamic_cast<PIPETYPE*>(&mPipes[slot]);
+    if (! ppipe)
+    {
+        error = STRINGIZE(mDesc << ' ' << whichfile(slot) << " not a " << typeid(PIPETYPE).name());
+        return NULL;
+    }
+
+    error.clear();
+    return ppipe;
+}
+
+template <class PIPETYPE>
+PIPETYPE& LLProcess::getPipe(FILESLOT slot)
+{
+    std::string error;
+    PIPETYPE* wp = getPipePtr<PIPETYPE>(error, slot);
+    if (! wp)
+    {
+        LLTHROW(NoPipe(error));
+    }
+    return *wp;
+}
+
+template <class PIPETYPE>
+boost::optional<PIPETYPE&> LLProcess::getOptPipe(FILESLOT slot)
+{
+    std::string error;
+    PIPETYPE* wp = getPipePtr<PIPETYPE>(error, slot);
+    if (! wp)
+    {
+        LL_DEBUGS("LLProcess") << error << LL_ENDL;
+        return boost::optional<PIPETYPE&>();
+    }
+    return *wp;
+}
+
+LLProcess::WritePipe& LLProcess::getWritePipe(FILESLOT slot)
+{
+    return getPipe<WritePipe>(slot);
+}
+
+boost::optional<LLProcess::WritePipe&> LLProcess::getOptWritePipe(FILESLOT slot)
+{
+    return getOptPipe<WritePipe>(slot);
+}
+
+LLProcess::ReadPipe& LLProcess::getReadPipe(FILESLOT slot)
+{
+    return getPipe<ReadPipe>(slot);
+}
+
+boost::optional<LLProcess::ReadPipe&> LLProcess::getOptReadPipe(FILESLOT slot)
+{
+    return getOptPipe<ReadPipe>(slot);
+}
+
+//static
+std::string LLProcess::getline(std::istream& in)
+{
+    std::string line;
+    std::getline(in, line);
+    // Blur the distinction between "\r\n" and plain "\n". std::getline() will
+    // have eaten the "\n", but we could still end up with a trailing "\r".
+    std::string::size_type lastpos = line.find_last_not_of("\r");
+    if (lastpos != std::string::npos)
+    {
+        // Found at least one character that's not a trailing '\r'. SKIP OVER
+        // IT and erase the rest of the line.
+        line.erase(lastpos+1);
+    }
+    return line;
+}
+
+std::ostream& operator<<(std::ostream& out, const LLProcess::Params& params)
+{
+    if (params.cwd.isProvided())
+    {
+        out << "cd " << LLStringUtil::quote(params.cwd) << ": ";
+    }
+    out << LLStringUtil::quote(params.executable);
+    for (const std::string& arg : params.args)
+    {
+        out << ' ' << LLStringUtil::quote(arg);
+    }
+    return out;
+}
+
+/*****************************************************************************
+*   Windows specific
+*****************************************************************************/
+#if LL_WINDOWS
+
+static std::string WindowsErrorString(const std::string& operation);
+
+void LLProcess::autokill()
+{
+    // hopefully now handled by apr_procattr_autokill_set()
+}
+
+LLProcess::handle LLProcess::isRunning(handle h, const std::string& desc)
+{
+    // This direct Windows implementation is because we have no access to the
+    // apr_proc_t struct: we expect it's been destroyed.
+    if (! h)
+        return 0;
+
+    DWORD waitresult = WaitForSingleObject(h, 0);
+    if(waitresult == WAIT_OBJECT_0)
+    {
+        // the process has completed.
+        if (! desc.empty())
+        {
+            DWORD status = 0;
+            if (! GetExitCodeProcess(h, &status))
+            {
+                LL_WARNS("LLProcess") << desc << " terminated, but "
+                                      << WindowsErrorString("GetExitCodeProcess()") << LL_ENDL;
+            }
+            {
+                LL_INFOS("LLProcess") << getStatusString(desc, interpret_status(status))
+                                      << LL_ENDL;
+            }
+        }
+        CloseHandle(h);
+        return 0;
+    }
+
+    return h;
+}
+
+static LLProcess::Status interpret_status(int status)
+{
+    LLProcess::Status result;
+
+    // This bit of code is cribbed from apr/threadproc/win32/proc.c, a
+    // function (unfortunately static) called why_from_exit_code():
+    /* See WinNT.h STATUS_ACCESS_VIOLATION and family for how
+     * this class of failures was determined
+     */
+    if ((status & 0xFFFF0000) == 0xC0000000)
+    {
+        result.mState = LLProcess::KILLED;
+    }
+    else
+    {
+        result.mState = LLProcess::EXITED;
+    }
+    result.mData = status;
+
+    return result;
+}
+
+/// GetLastError()/FormatMessage() boilerplate
+static std::string WindowsErrorString(const std::string& operation)
+{
+    auto result = GetLastError();
+    return STRINGIZE(operation << " failed (" << result << "): "
+                     << windows_message<std::string>(result));
+}
+
+/*****************************************************************************
+*   Posix specific
+*****************************************************************************/
+#else // Mac and linux
+
+#include <signal.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+
+void LLProcess::autokill()
+{
+    // What we ought to do here is to:
+    // 1. create a unique process group and run all autokill children in that
+    //    group (see https://jira.secondlife.com/browse/SWAT-563);
+    // 2. figure out a way to intercept control when the viewer exits --
+    //    gracefully or not;
+    // 3. when the viewer exits, kill off the aforementioned process group.
+
+    // It's point 2 that's troublesome. Although I've seen some signal-
+    // handling logic in the Posix viewer code, I haven't yet found any bit of
+    // code that's run no matter how the viewer exits (a try/finally for the
+    // whole process, as it were).
+}
+
+// Attempt to reap a process ID -- returns true if the process has exited and been reaped, false otherwise.
+static bool reap_pid(pid_t pid, LLProcess::Status* pstatus=NULL)
+{
+    LLProcess::Status dummy;
+    if (! pstatus)
+    {
+        // If caller doesn't want to see Status, give us a target anyway so we
+        // don't have to have a bunch of conditionals.
+        pstatus = &dummy;
+    }
+
+    int status = 0;
+    pid_t wait_result = ::waitpid(pid, &status, WNOHANG);
+    if (wait_result == pid)
+    {
+        *pstatus = interpret_status(status);
+        return true;
+    }
+    if (wait_result == 0)
+    {
+        pstatus->mState = LLProcess::RUNNING;
+        pstatus->mData  = 0;
+        return false;
+    }
+
+    // Clear caller's Status block; caller must interpret UNSTARTED to mean
+    // "if this PID was ever valid, it no longer is."
+    *pstatus = LLProcess::Status();
+
+    // We've dealt with the success cases: we were able to reap the child
+    // (wait_result == pid) or it's still running (wait_result == 0). It may
+    // be that the child terminated but didn't hang around long enough for us
+    // to reap. In that case we still have no Status to report, but we can at
+    // least state that it's not running.
+    if (wait_result == -1 && errno == ECHILD)
+    {
+        // No such process -- this may mean we're ignoring SIGCHILD.
+        return true;
+    }
+
+    // Uh, should never happen?!
+    LL_WARNS("LLProcess") << "LLProcess::reap_pid(): waitpid(" << pid << ") returned "
+                          << wait_result << "; not meaningful?" << LL_ENDL;
+    // If caller is looping until this pid terminates, and if we can't find
+    // out, better to break the loop than to claim it's still running.
+    return true;
+}
+
+LLProcess::id LLProcess::isRunning(id pid, const std::string& desc)
+{
+    // This direct Posix implementation is because we have no access to the
+    // apr_proc_t struct: we expect it's been destroyed.
+    if (! pid)
+        return 0;
+
+    // Check whether the process has exited, and reap it if it has.
+    LLProcess::Status status;
+    if(reap_pid(pid, &status))
+    {
+        // the process has exited.
+        if (! desc.empty())
+        {
+            std::string statstr(desc + " apparently terminated: no status available");
+            // We don't just pass UNSTARTED to getStatusString() because, in
+            // the context of reap_pid(), that state has special meaning.
+            if (status.mState != UNSTARTED)
+            {
+                statstr = getStatusString(desc, status);
+            }
+            LL_INFOS("LLProcess") << statstr << LL_ENDL;
+        }
+        return 0;
+    }
+
+    return pid;
+}
+
+static LLProcess::Status interpret_status(int status)
+{
+    LLProcess::Status result;
+
+    if (WIFEXITED(status))
+    {
+        result.mState = LLProcess::EXITED;
+        result.mData  = WEXITSTATUS(status);
+    }
+    else if (WIFSIGNALED(status))
+    {
+        result.mState = LLProcess::KILLED;
+        result.mData  = WTERMSIG(status);
+    }
+    else                            // uh, shouldn't happen?
+    {
+        result.mState = LLProcess::EXITED;
+        result.mData  = status;     // someone else will have to decode
+    }
+
+    return result;
+}
+
+#endif  // Posix