path: root/indra/llmessage/lliohttpserver.cpp

/**
 * @file lliohttpserver.cpp
 * @author Phoenix
 * @date 2005-10-05
 * @brief Implementation of the http server classes
 *
 * $LicenseInfo:firstyear=2005&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 "lliohttpserver.h"

#include "llapr.h"
#include "llbuffer.h"
#include "llbufferstream.h"
#include "llhttpconstants.h"
#include "llfasttimer.h"
#include "llhttpnode.h"
#include "lliopipe.h"
#include "lliosocket.h"
#include "llioutil.h"
#include "llmemorystream.h"
#include "llpumpio.h"
#include "llsd.h"
#include "llsdserialize_xml.h"
#include "llstl.h"
#include "lltimer.h"

#include <sstream>

#include <boost/tokenizer.hpp>

static const char HTTP_VERSION_STR[] = "HTTP/1.0";

static LLIOHTTPServer::timing_callback_t sTimingCallback = NULL;
static void* sTimingCallbackData = NULL;

class LLHTTPPipe : public LLIOPipe
{
public:
    LLHTTPPipe(const LLHTTPNode& node)
        : mNode(node),
          mResponse(NULL),
          mState(STATE_INVOKE),
          mChainLock(0),
          mLockedPump(NULL),
          mStatusCode(0)
        { }
    virtual ~LLHTTPPipe()
    {
        if (mResponse.notNull())
        {
            mResponse->nullPipe();
        }
    }

private:
    // LLIOPipe API implementation.
    virtual EStatus process_impl(
        const LLChannelDescriptors& channels,
        LLIOPipe::buffer_ptr_t& buffer,
        bool& eos,
        LLSD& context,
        LLPumpIO* pump);

    const LLHTTPNode& mNode;

    class Response : public LLHTTPNode::Response
    {
    public:

        static LLPointer<Response> create(LLHTTPPipe* pipe);
        virtual ~Response();

        // from LLHTTPNode::Response
        virtual void result(const LLSD&);
        virtual void extendedResult(S32 code, const std::string& body, const LLSD& headers);
        virtual void extendedResult(S32 code, const LLSD& body, const LLSD& headers);
        virtual void status(S32 code, const std::string& message);

        void nullPipe();

    private:
        Response() : mPipe(NULL) {} // Must be accessed through LLPointer.
        LLHTTPPipe* mPipe;
    };
    friend class Response;

    LLPointer<Response> mResponse;

    enum State
    {
        STATE_INVOKE,
        STATE_DELAYED,
        STATE_LOCKED,
        STATE_GOOD_RESULT,
        STATE_STATUS_RESULT,
        STATE_EXTENDED_RESULT,
        STATE_EXTENDED_LLSD_RESULT
    };
    State mState;

    S32 mChainLock;
    LLPumpIO* mLockedPump;

    void lockChain(LLPumpIO*);
    void unlockChain();

    LLSD mResult;
    S32 mStatusCode;
    std::string mStatusMessage;
    LLSD mHeaders;
};

LLIOPipe::EStatus LLHTTPPipe::process_impl(
    const LLChannelDescriptors& channels,
    buffer_ptr_t& buffer,
    bool& eos,
    LLSD& context,
    LLPumpIO* pump)
{
    LL_PROFILE_ZONE_SCOPED;
    PUMP_DEBUG;
    LL_DEBUGS() << "LLSDHTTPServer::process_impl" << LL_ENDL;

    // Once we have all the data, We need to read the sd on
    // the the in channel, and respond on  the out channel

    if(!eos) return STATUS_BREAK;
    if(!pump || !buffer) return STATUS_PRECONDITION_NOT_MET;

    PUMP_DEBUG;
    if (mState == STATE_INVOKE)
    {
        PUMP_DEBUG;
        mState = STATE_DELAYED;
            // assume deferred unless mResponse does otherwise
        mResponse = Response::create(this);

        // *TODO: Babbage: Parameterize parser?
        // *TODO: We should look at content-type and do the right
        // thing. Phoenix 2007-12-31
        LLBufferStream istr(channels, buffer.get());

        static LLTimer timer;
        timer.reset();

        std::string verb = context[CONTEXT_REQUEST][CONTEXT_VERB];
        if(verb == HTTP_VERB_GET)
        {
            mNode.get(LLHTTPNode::ResponsePtr(mResponse), context);
        }
        else if(verb == HTTP_VERB_PUT)
        {
            LLSD input;
            if (mNode.getContentType() == LLHTTPNode::CONTENT_TYPE_LLSD)
            {
                LLSDSerialize::fromXML(input, istr);
            }
            else if (mNode.getContentType() == LLHTTPNode::CONTENT_TYPE_TEXT)
            {
                std::ostringstream strstrm;
                strstrm << istr.rdbuf();
                input = strstrm.str();
            }
            mNode.put(LLHTTPNode::ResponsePtr(mResponse), context, input);
        }
        else if(verb == HTTP_VERB_POST)
        {
            LLSD input;
            if (mNode.getContentType() == LLHTTPNode::CONTENT_TYPE_LLSD)
            {
                LLSDSerialize::fromXML(input, istr);
            }
            else if (mNode.getContentType() == LLHTTPNode::CONTENT_TYPE_TEXT)
            {
                std::ostringstream strstrm;
                strstrm << istr.rdbuf();
                input = strstrm.str();
            }
            mNode.post(LLHTTPNode::ResponsePtr(mResponse), context, input);
        }
        else if(verb == HTTP_VERB_DELETE)
        {
            mNode.del(LLHTTPNode::ResponsePtr(mResponse), context);
        }
        else if(verb == HTTP_VERB_OPTIONS)
        {
            mNode.options(LLHTTPNode::ResponsePtr(mResponse), context);
        }
        else
        {
            mResponse->methodNotAllowed();
        }

        F32 delta = timer.getElapsedTimeF32();
        if (sTimingCallback)
        {
            LLHTTPNode::Description desc;
            mNode.describe(desc);
            LLSD info = desc.getInfo();
            std::string timing_name = info["description"];
            timing_name += " ";
            timing_name += verb;
            sTimingCallback(timing_name.c_str(), delta, sTimingCallbackData);
        }

        // Log all HTTP transactions.
        // TODO: Add a way to log these to their own file instead of indra.log
        // It is just too spammy to be in indra.log.
        LL_DEBUGS() << verb << " " << context[CONTEXT_REQUEST][CONTEXT_PATH].asString()
            << " " << mStatusCode << " " <<  mStatusMessage << " " << delta
            << "s" << LL_ENDL;

        // Log Internal Server Errors
        //if(mStatusCode == HTTP_INTERNAL_SERVER_ERROR)
        //{
        //  LL_WARNS() << "LLHTTPPipe::process_impl:500:Internal Server Error"
        //          << LL_ENDL;
        //}
    }

    PUMP_DEBUG;
    switch (mState)
    {
        case STATE_DELAYED:
            lockChain(pump);
            mState = STATE_LOCKED;
            return STATUS_BREAK;

        case STATE_LOCKED:
            // should never ever happen!
            return STATUS_ERROR;

        case STATE_GOOD_RESULT:
        {
            LLSD headers = mHeaders;
            headers[HTTP_OUT_HEADER_CONTENT_TYPE] = HTTP_CONTENT_LLSD_XML;
            context[CONTEXT_RESPONSE][CONTEXT_HEADERS] = headers;
            LLBufferStream ostr(channels, buffer.get());
            LLSDSerialize::toXML(mResult, ostr);

            return STATUS_DONE;
        }

        case STATE_STATUS_RESULT:
        {
            LLSD headers = mHeaders;
            headers[HTTP_OUT_HEADER_CONTENT_TYPE] = HTTP_CONTENT_TEXT_PLAIN;
            context[CONTEXT_RESPONSE][CONTEXT_HEADERS] = headers;
            context[CONTEXT_RESPONSE]["statusCode"] = mStatusCode;
            context[CONTEXT_RESPONSE]["statusMessage"] = mStatusMessage;
            LLBufferStream ostr(channels, buffer.get());
            ostr << mStatusMessage;

            return STATUS_DONE;
        }
        case STATE_EXTENDED_RESULT:
        {
            context[CONTEXT_RESPONSE][CONTEXT_HEADERS] = mHeaders;
            context[CONTEXT_RESPONSE]["statusCode"] = mStatusCode;
            LLBufferStream ostr(channels, buffer.get());
            ostr << mStatusMessage;

            return STATUS_DONE;
        }
        case STATE_EXTENDED_LLSD_RESULT:
        {
            LLSD headers = mHeaders;
            headers[HTTP_OUT_HEADER_CONTENT_TYPE] = HTTP_CONTENT_LLSD_XML;
            context[CONTEXT_RESPONSE][CONTEXT_HEADERS] = headers;
            context[CONTEXT_RESPONSE]["statusCode"] = mStatusCode;
            LLBufferStream ostr(channels, buffer.get());
            LLSDSerialize::toXML(mResult, ostr);

            return STATUS_DONE;
        }
        default:
            LL_WARNS() << "LLHTTPPipe::process_impl: unexpected state "
                << mState << LL_ENDL;

            return STATUS_BREAK;
    }
//  PUMP_DEBUG; // unreachable
}

LLPointer<LLHTTPPipe::Response> LLHTTPPipe::Response::create(LLHTTPPipe* pipe)
{
    LLPointer<Response> result = new Response();
    result->mPipe = pipe;
    return result;
}

// virtual
LLHTTPPipe::Response::~Response()
{
}

void LLHTTPPipe::Response::nullPipe()
{
    mPipe = NULL;
}

// virtual
void LLHTTPPipe::Response::result(const LLSD& r)
{
    if(! mPipe)
    {
        LL_WARNS() << "LLHTTPPipe::Response::result: NULL pipe" << LL_ENDL;
        return;
    }

    mPipe->mStatusCode = HTTP_OK;
    mPipe->mStatusMessage = "OK";
    mPipe->mResult = r;
    mPipe->mState = STATE_GOOD_RESULT;
    mPipe->mHeaders = mHeaders;
    mPipe->unlockChain();
}

void LLHTTPPipe::Response::extendedResult(S32 code, const LLSD& r, const LLSD& headers)
{
    if(! mPipe)
    {
        LL_WARNS() << "LLHTTPPipe::Response::extendedResult: NULL pipe" << LL_ENDL;
        return;
    }

    mPipe->mStatusCode = code;
    mPipe->mStatusMessage = "(LLSD)";
    mPipe->mResult = r;
    mPipe->mHeaders = headers;
    mPipe->mState = STATE_EXTENDED_LLSD_RESULT;
    mPipe->unlockChain();
}

void LLHTTPPipe::Response::extendedResult(S32 code, const std::string& body, const LLSD& headers)
{
    if(! mPipe)
    {
        LL_WARNS() << "LLHTTPPipe::Response::status: NULL pipe" << LL_ENDL;
        return;
    }

    mPipe->mStatusCode = code;
    mPipe->mStatusMessage = body;
    mPipe->mHeaders = headers;
    mPipe->mState = STATE_EXTENDED_RESULT;
    mPipe->unlockChain();
}

// virtual
void LLHTTPPipe::Response::status(S32 code, const std::string& message)
{
    if(! mPipe)
    {
        LL_WARNS() << "LLHTTPPipe::Response::status: NULL pipe" << LL_ENDL;
        return;
    }

    mPipe->mStatusCode = code;
    mPipe->mStatusMessage = message;
    mPipe->mState = STATE_STATUS_RESULT;
    mPipe->mHeaders = mHeaders;
    mPipe->unlockChain();
}

void LLHTTPPipe::lockChain(LLPumpIO* pump)
{
    if (mChainLock != 0) { return; }

    mLockedPump = pump;
    mChainLock = pump->setLock();
}

void LLHTTPPipe::unlockChain()
{
    if (mChainLock == 0) { return; }

    mLockedPump->clearLock(mChainLock);
    mLockedPump = NULL;
    mChainLock = 0;
}



/**
 * @class LLHTTPResponseHeader
 * @brief Class which correctly builds HTTP headers on a pipe
 * @see LLIOPipe
 *
 * An instance of this class can be placed in a chain where it will
 * wait for an end of stream. Once it gets that, it will count the
 * bytes on CHANNEL_OUT (or the size of the buffer in io pipe versions
 * prior to 2) prepend that data to the request in an HTTP format, and
 * supply all normal HTTP response headers.
 */
class LLHTTPResponseHeader : public LLIOPipe
{
public:
    LLHTTPResponseHeader() : mCode(0) {}
    virtual ~LLHTTPResponseHeader() {}

protected:
    /* @name LLIOPipe virtual implementations
     */
    //@{
    /**
     * @brief Process the data in buffer
     */
    EStatus process_impl(
        const LLChannelDescriptors& channels,
        buffer_ptr_t& buffer,
        bool& eos,
        LLSD& context,
        LLPumpIO* pump);
    //@}

protected:
    S32 mCode;
};


/**
 * LLHTTPResponseHeader
 */

// virtual
LLIOPipe::EStatus LLHTTPResponseHeader::process_impl(
    const LLChannelDescriptors& channels,
    buffer_ptr_t& buffer,
    bool& eos,
    LLSD& context,
    LLPumpIO* pump)
{
    LL_PROFILE_ZONE_SCOPED;
    PUMP_DEBUG;
    if(eos)
    {
        PUMP_DEBUG;
        //mGotEOS = true;
        std::ostringstream ostr;
        std::string message = context[CONTEXT_RESPONSE]["statusMessage"];

        int code = context[CONTEXT_RESPONSE]["statusCode"];
        if (code < HTTP_OK)
        {
            code = HTTP_OK;
            message = "OK";
        }

        ostr << HTTP_VERSION_STR << " " << code << " " << message << "\r\n";

        S32 content_length = buffer->countAfter(channels.in(), NULL);
        if(0 < content_length)
        {
            ostr << HTTP_OUT_HEADER_CONTENT_LENGTH << ": " << content_length << "\r\n";
        }
        // *NOTE: This guard can go away once the LLSD static map
        // iterator is available. Phoenix. 2008-05-09
        LLSD headers = context[CONTEXT_RESPONSE][CONTEXT_HEADERS];
        if(headers.isDefined())
        {
            LLSD::map_iterator iter = headers.beginMap();
            LLSD::map_iterator end = headers.endMap();
            for(; iter != end; ++iter)
            {
                ostr << (*iter).first << ": " << (*iter).second.asString()
                    << "\r\n";
            }
        }
        ostr << "\r\n";

        LLChangeChannel change(channels.in(), channels.out());
        std::for_each(buffer->beginSegment(), buffer->endSegment(), change);
        std::string header = ostr.str();
        buffer->prepend(channels.out(), (U8*)header.c_str(), header.size());
        PUMP_DEBUG;
        return STATUS_DONE;
    }
    PUMP_DEBUG;
    return STATUS_OK;
}



/**
 * @class LLHTTPResponder
 * @brief This class
 * @see LLIOPipe
 *
 * <b>NOTE:</b> You should not need to create or use one of these, the
 * details are handled by the HTTPResponseFactory.
 */
class LLHTTPResponder : public LLIOPipe
{
public:
    LLHTTPResponder(const LLHTTPNode& tree, const LLSD& ctx);
    ~LLHTTPResponder();

protected:
    /**
     * @brief Read data off of CHANNEL_IN keeping track of last read position.
     *
     * This is a quick little hack to read headers. It is not IO
     * optimal, but it makes it easier for me to implement the header
     * parsing. Plus, there should never be more than a few headers.
     * This method will tend to read more than necessary, find the
     * newline, make the front part of dest look like a c string, and
     * move the read head back to where the newline was found. Thus,
     * the next read will pick up on the next line.
     * @param channel The channel to read in the buffer
     * @param buffer The heap array of processed data
     * @param dest Destination for the data to be read
     * @param[in,out] len <b>in</b> The size of the buffer. <b>out</b> how
     * much was read. This value is not useful for determining where to
     * seek orfor string assignment.
     * @returns Returns true if a line was found.
     */
    bool readHeaderLine(
        const LLChannelDescriptors& channels,
        buffer_ptr_t buffer,
        U8* dest,
        S32& len);

    /**
     * @brief Mark the request as bad, and handle appropriately
     *
     * @param channels The channels to use in the buffer.
     * @param buffer The heap array of processed data.
     */
    void markBad(const LLChannelDescriptors& channels, buffer_ptr_t buffer);

protected:
    /* @name LLIOPipe virtual implementations
     */
    //@{
    /**
     * @brief Process the data in buffer
     */
    EStatus process_impl(
        const LLChannelDescriptors& channels,
        buffer_ptr_t& buffer,
        bool& eos,
        LLSD& context,
        LLPumpIO* pump);
    //@}

protected:
    enum EState
    {
        STATE_NOTHING,
        STATE_READING_HEADERS,
        STATE_LOOKING_FOR_EOS,
        STATE_DONE,
        STATE_SHORT_CIRCUIT
    };

    LLSD mBuildContext;
    EState mState;
    U8* mLastRead;
    std::string mVerb;
    std::string mAbsPathAndQuery;
    std::string mPath;
    std::string mQuery;
    std::string mVersion;
    S32 mContentLength;
    LLSD mHeaders;

    // handle the urls
    const LLHTTPNode& mRootNode;
};

LLHTTPResponder::LLHTTPResponder(const LLHTTPNode& tree, const LLSD& ctx) :
    mBuildContext(ctx),
    mState(STATE_NOTHING),
    mLastRead(NULL),
    mContentLength(0),
    mRootNode(tree)
{
}

// virtual
LLHTTPResponder::~LLHTTPResponder()
{
    //LL_DEBUGS() << "destroying LLHTTPResponder" << LL_ENDL;
}

bool LLHTTPResponder::readHeaderLine(
    const LLChannelDescriptors& channels,
    buffer_ptr_t buffer,
    U8* dest,
    S32& len)
{
    --len;
    U8* last = buffer->readAfter(channels.in(), mLastRead, dest, len);
    dest[len] = '\0';
    U8* newline = (U8*)strchr((char*)dest, '\n');
    if(!newline)
    {
        if(len)
        {
            LL_DEBUGS() << "readLine failed - too long maybe?" << LL_ENDL;
            markBad(channels, buffer);
        }
        return false;
    }
    S32 offset = -((len - 1) - (newline - dest));
    ++newline;
    *newline = '\0';
    mLastRead = buffer->seek(channels.in(), last, offset);
    return true;
}

void LLHTTPResponder::markBad(
    const LLChannelDescriptors& channels,
    buffer_ptr_t buffer)
{
    mState = STATE_SHORT_CIRCUIT;
    LLBufferStream out(channels, buffer.get());
    out << HTTP_VERSION_STR << " 400 Bad Request\r\n\r\n<html>\n"
        << "<title>Bad Request</title>\n<body>\nBad Request.\n"
        << "</body>\n</html>\n";
}

// virtual
LLIOPipe::EStatus LLHTTPResponder::process_impl(
    const LLChannelDescriptors& channels,
    buffer_ptr_t& buffer,
    bool& eos,
    LLSD& context,
    LLPumpIO* pump)
{
    LL_PROFILE_ZONE_SCOPED;
    PUMP_DEBUG;
    LLIOPipe::EStatus status = STATUS_OK;

    // parsing headers
    if((STATE_NOTHING == mState) || (STATE_READING_HEADERS == mState))
    {
        PUMP_DEBUG;
        status = STATUS_BREAK;
        mState = STATE_READING_HEADERS;
        const S32 HEADER_BUFFER_SIZE = 1024;
        char buf[HEADER_BUFFER_SIZE + 1];  /*Flawfinder: ignore*/
        S32 len = HEADER_BUFFER_SIZE;

#if 0
        if(true)
        {
        LLBufferArray::segment_iterator_t seg_iter = buffer->beginSegment();
        char buf[1024];   /*Flawfinder: ignore*/
        while(seg_iter != buffer->endSegment())
        {
            memcpy(buf, (*seg_iter).data(), (*seg_iter).size());      /*Flawfinder: ignore*/
            buf[(*seg_iter).size()] = '\0';
            LL_INFOS() << (*seg_iter).getChannel() << ": " << buf
                    << LL_ENDL;
            ++seg_iter;
        }
        }
#endif

        PUMP_DEBUG;
        if(readHeaderLine(channels, buffer, (U8*)buf, len))
        {
            bool read_next_line = false;
            bool parse_all = true;
            if(mVerb.empty())
            {
                read_next_line = true;
                LLMemoryStream header((U8*)buf, len);
                header >> mVerb;

                if((HTTP_VERB_GET == mVerb)
                   || (HTTP_VERB_POST == mVerb)
                   || (HTTP_VERB_PUT == mVerb)
                   || (HTTP_VERB_DELETE == mVerb)
                   || (HTTP_VERB_OPTIONS == mVerb))
                {
                    header >> mAbsPathAndQuery;
                    header >> mVersion;

                    LL_DEBUGS() << "http request: "
                             << mVerb
                             << " " << mAbsPathAndQuery
                             << " " << mVersion << LL_ENDL;

                    std::string::size_type delimiter
                        = mAbsPathAndQuery.find('?');
                    if (delimiter == std::string::npos)
                    {
                        mPath = mAbsPathAndQuery;
                        mQuery = "";
                    }
                    else
                    {
                        mPath = mAbsPathAndQuery.substr(0, delimiter);
                        mQuery = mAbsPathAndQuery.substr(delimiter+1);
                    }

                    if(!mAbsPathAndQuery.empty())
                    {
                        if(mVersion.empty())
                        {
                            // simple request.
                            parse_all = false;
                            mState = STATE_DONE;
                            mVersion.assign("HTTP/1.0");
                        }
                    }
                }
                else
                {
                    read_next_line = false;
                    parse_all = false;
                    LL_DEBUGS() << "unknown http verb: " << mVerb << LL_ENDL;
                    markBad(channels, buffer);
                }
            }
            if(parse_all)
            {
                bool keep_parsing = true;
                while(keep_parsing)
                {
                    if(read_next_line)
                    {
                        len = HEADER_BUFFER_SIZE;
                        if (!readHeaderLine(channels, buffer, (U8*)buf, len))
                        {
                            // Failed to read the header line, probably too long.
                            // readHeaderLine already marked the channel/buffer as bad.
                            keep_parsing = false;
                            break;
                        }
                    }
                    if(0 == len)
                    {
                        return status;
                    }
                    if(buf[0] == '\r' && buf[1] == '\n')
                    {
                        // end-o-headers
                        keep_parsing = false;
                        mState = STATE_LOOKING_FOR_EOS;
                        break;
                    }
                    char* pos_colon = strchr(buf, ':');
                    if(NULL == pos_colon)
                    {
                        keep_parsing = false;
                        LL_DEBUGS() << "bad header: " << buf << LL_ENDL;
                        markBad(channels, buffer);
                        break;
                    }
                    // we've found a header
                    read_next_line = true;
                    std::string name(buf, pos_colon - buf);
                    std::string value(pos_colon + 2);
                    LLStringUtil::toLower(name);
                    if(HTTP_IN_HEADER_CONTENT_LENGTH == name)
                    {
                        LL_DEBUGS() << "Content-Length: " << value << LL_ENDL;
                        mContentLength = atoi(value.c_str());
                    }
                    else
                    {
                        LLStringUtil::trimTail(value);
                        mHeaders[name] = value;
                    }
                }
            }
        }
    }

    PUMP_DEBUG;
    // look for the end of stream based on
    if(STATE_LOOKING_FOR_EOS == mState)
    {
        if(0 == mContentLength)
        {
            mState = STATE_DONE;
        }
        else if(buffer->countAfter(channels.in(), mLastRead) >= mContentLength)
        {
            mState = STATE_DONE;
        }
        // else more bytes should be coming.
    }

    PUMP_DEBUG;
    if(STATE_DONE == mState)
    {
        // hey, hey, we should have everything now, so we pass it to
        // a content handler.
        context[CONTEXT_REQUEST][CONTEXT_VERB] = mVerb;
        const LLHTTPNode* node = mRootNode.traverse(mPath, context);
        if(node)
        {
            //LL_INFOS() << "LLHTTPResponder::process_impl found node for "
            //  << mAbsPathAndQuery << LL_ENDL;

            // Copy everything after mLast read to the out.
            LLBufferArray::segment_iterator_t seg_iter;

            buffer->lock();
            seg_iter = buffer->splitAfter(mLastRead);
            if(seg_iter != buffer->endSegment())
            {
                LLChangeChannel change(channels.in(), channels.out());
                ++seg_iter;
                std::for_each(seg_iter, buffer->endSegment(), change);

#if 0
                seg_iter = buffer->beginSegment();
                char buf[1024];   /*Flawfinder: ignore*/
                while(seg_iter != buffer->endSegment())
                {
                    memcpy(buf, (*seg_iter).data(), (*seg_iter).size());      /*Flawfinder: ignore*/
                    buf[(*seg_iter).size()] = '\0';
                    LL_INFOS() << (*seg_iter).getChannel() << ": " << buf
                            << LL_ENDL;
                    ++seg_iter;
                }
#endif
            }
            buffer->unlock();
            //
            // *FIX: get rid of extra bytes off the end
            //

            // Set up a chain which will prepend a content length and
            // HTTP headers.
            LLPumpIO::chain_t chain;
            chain.push_back(LLIOPipe::ptr_t(new LLIOFlush));
            context[CONTEXT_REQUEST][CONTEXT_PATH] = mPath;
            context[CONTEXT_REQUEST][CONTEXT_QUERY_STRING] = mQuery;
            context[CONTEXT_REQUEST][CONTEXT_REMOTE_HOST]
                = mBuildContext[CONTEXT_REMOTE_HOST];
            context[CONTEXT_REQUEST][CONTEXT_REMOTE_PORT]
                = mBuildContext[CONTEXT_REMOTE_PORT];
            context[CONTEXT_REQUEST][CONTEXT_HEADERS] = mHeaders;

            const LLChainIOFactory* protocolHandler
                = node->getProtocolHandler();
            if (protocolHandler)
            {
                LL_DEBUGS() << "HTTP context: " << context << LL_ENDL;
                protocolHandler->build(chain, context);
            }
            else
            {
                // this is a simple LLHTTPNode, so use LLHTTPPipe
                chain.push_back(LLIOPipe::ptr_t(new LLHTTPPipe(*node)));
            }

            // Add the header - which needs to have the same
            // channel information as the link before it since it
            // is part of the response.
            LLIOPipe* header = new LLHTTPResponseHeader;
            chain.push_back(LLIOPipe::ptr_t(header));

            // We need to copy all of the pipes _after_ this so
            // that the response goes out correctly.
            LLPumpIO::links_t current_links;
            pump->copyCurrentLinkInfo(current_links);
            LLPumpIO::links_t::iterator link_iter = current_links.begin();
            LLPumpIO::links_t::iterator links_end = current_links.end();
            bool after_this = false;
            for(; link_iter < links_end; ++link_iter)
            {
                if(after_this)
                {
                    chain.push_back((*link_iter).mPipe);
                }
                else if(this == (*link_iter).mPipe.get())
                {
                    after_this = true;
                }
            }

            // Do the final build of the chain, and send it on
            // it's way.
            LLChannelDescriptors chnl = channels;
            LLPumpIO::LLLinkInfo link;
            LLPumpIO::links_t links;
            LLPumpIO::chain_t::iterator it = chain.begin();
            LLPumpIO::chain_t::iterator end = chain.end();
            while(it != end)
            {
                link.mPipe = *it;
                link.mChannels = chnl;
                links.push_back(link);
                chnl = LLBufferArray::makeChannelConsumer(chnl);
                ++it;
            }
            pump->addChain(
                links,
                buffer,
                context,
                DEFAULT_CHAIN_EXPIRY_SECS);

            status = STATUS_STOP;
        }
        else
        {
            LL_WARNS() << "LLHTTPResponder::process_impl didn't find a node for "
                << mAbsPathAndQuery << LL_ENDL;
            LLBufferStream str(channels, buffer.get());
            mState = STATE_SHORT_CIRCUIT;
            str << HTTP_VERSION_STR << " 404 Not Found\r\n\r\n<html>\n"
                << "<title>Not Found</title>\n<body>\nNode '" << mAbsPathAndQuery
                << "' not found.\n</body>\n</html>\n";
        }
    }

    if(STATE_SHORT_CIRCUIT == mState)
    {
        //status = mNext->process(buffer, true, pump, context);
        status = STATUS_DONE;
    }
    PUMP_DEBUG;
    return status;
}


// static
void LLIOHTTPServer::createPipe(LLPumpIO::chain_t& chain,
        const LLHTTPNode& root, const LLSD& ctx)
{
    chain.push_back(LLIOPipe::ptr_t(new LLHTTPResponder(root, ctx)));
}


class LLHTTPResponseFactory : public LLChainIOFactory
{
public:
    bool build(LLPumpIO::chain_t& chain, LLSD ctx) const
    {
        LLIOHTTPServer::createPipe(chain, mTree, ctx);
        return true;
    }

    LLHTTPNode& getRootNode() { return mTree; }

private:
    LLHTTPNode mTree;
};


// static
LLHTTPNode& LLIOHTTPServer::create(
    apr_pool_t* pool, LLPumpIO& pump, U16 port)
{
    LLSocket::ptr_t socket = LLSocket::create(
        pool,
        LLSocket::STREAM_TCP,
        port);
    if(!socket)
    {
        LL_ERRS() << "Unable to initialize socket" << LL_ENDL;
    }

    LLHTTPResponseFactory* factory = new LLHTTPResponseFactory;
    std::shared_ptr<LLChainIOFactory> factory_ptr(factory);

    LLIOServerSocket* server = new LLIOServerSocket(pool, socket, factory_ptr);

    LLPumpIO::chain_t chain;
    chain.push_back(LLIOPipe::ptr_t(server));
    pump.addChain(chain, NEVER_CHAIN_EXPIRY_SECS);

    return factory->getRootNode();
}

// static
void LLIOHTTPServer::setTimingCallback(timing_callback_t callback,
                                       void* data)
{
    sTimingCallback = callback;
    sTimingCallbackData = data;
}