lliohttpserver.cpp

Go to the documentation of this file.

#include "linden_common.h"

#include "lliohttpserver.h"

#include "llapr.h"
#include "llbuffer.h"
#include "llbufferstream.h"
#include "llhttpnode.h"
#include "lliopipe.h"
#include "lliosocket.h"
#include "llioutil.h"
#include "llmemtype.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 const std::string CONTEXT_REQUEST("request");
static const std::string CONTEXT_RESPONSE("response");
static const std::string HTTP_VERB_GET("GET");
static const std::string HTTP_VERB_PUT("PUT");
static const std::string HTTP_VERB_POST("POST");
static const std::string HTTP_VERB_DELETE("DELETE");

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), 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 status(S32 code, const std::string& message);

                void nullPipe();

        private:
                Response() {;} // 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 mState;

        S32 mChainLock;
        LLPumpIO* mLockedPump;

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

        LLSD mGoodResult;
        S32 mStatusCode;
        std::string mStatusMessage;     
};

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

    // 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]["verb"];
                if(verb == HTTP_VERB_GET)
                {
                        mNode.get(LLHTTPNode::ResponsePtr(mResponse), context);
                }
                else if(verb == HTTP_VERB_PUT)
                {
                        LLSD input;
                        LLSDSerialize::fromXML(input, istr);
                        mNode.put(LLHTTPNode::ResponsePtr(mResponse), context, input);
                }
                else if(verb == HTTP_VERB_POST)
                {
                        LLSD input;
                        LLSDSerialize::fromXML(input, istr);
                        mNode.post(LLHTTPNode::ResponsePtr(mResponse), context, input);
                }
                else if(verb == HTTP_VERB_DELETE)
                {
                        mNode.del(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.
                lldebugs << verb << " " << context[CONTEXT_REQUEST]["path"].asString()
                        << " " << mStatusCode << " " <<  mStatusMessage << " " << delta
                        << "s" << llendl;

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

        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:
                {
                        context[CONTEXT_RESPONSE]["contentType"] = "application/xml";
                        LLBufferStream ostr(channels, buffer.get());
                        LLSDSerialize::toXML(mGoodResult, ostr);

                        return STATUS_DONE;
                }

                case STATE_STATUS_RESULT:
                {
                        context[CONTEXT_RESPONSE]["contentType"] = "text/plain";
                        context[CONTEXT_RESPONSE]["statusCode"] = mStatusCode;
                        context[CONTEXT_RESPONSE]["statusMessage"] = mStatusMessage;
                        LLBufferStream ostr(channels, buffer.get());
                        ostr << mStatusMessage << std::ends;

                        return STATUS_DONE;
                }
                default:
                        llwarns << "LLHTTPPipe::process_impl: unexpected state "
                                << mState << llendl;

                        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)
        {
                llwarns << "LLHTTPPipe::Response::result: NULL pipe" << llendl;
                return;
        }

        mPipe->mStatusCode = 200;
        mPipe->mStatusMessage = "OK";
        mPipe->mGoodResult = r;
        mPipe->mState = STATE_GOOD_RESULT;
        mPipe->unlockChain();   
}

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

        mPipe->mStatusCode = code;
        mPipe->mStatusMessage = message;
        mPipe->mState = STATE_STATUS_RESULT;
        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 : public LLIOPipe
{
public:
        LLHTTPResponseHeader() {}
        virtual ~LLHTTPResponseHeader() {}

protected:
        /* @name LLIOPipe virtual implementations
         */

        EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

protected:
        S32 mCode;
};


// virtual
LLIOPipe::EStatus LLHTTPResponseHeader::process_impl(
        const LLChannelDescriptors& channels,
        buffer_ptr_t& buffer,
        bool& eos,
        LLSD& context,
        LLPumpIO* pump)
{
        PUMP_DEBUG;
        LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER);
        if(eos)
        {
                PUMP_DEBUG;
                //mGotEOS = true;
                std::ostringstream ostr;
                std::string message = context[CONTEXT_RESPONSE]["statusMessage"];
                
                int code = context[CONTEXT_RESPONSE]["statusCode"];
                if (code < 200)
                {
                        code = 200;
                        message = "OK";
                }
                
                ostr << HTTP_VERSION_STR << " " << code << " " << message << "\r\n";
                
                std::string type = context[CONTEXT_RESPONSE]["contentType"].asString();
                if (!type.empty())
                {
                        ostr << "Content-Type: " << type << "\r\n";
                }
                S32 content_length = buffer->countAfter(channels.in(), NULL);
                if(0 < content_length)
                {
                        ostr << "Content-Length: " << content_length << "\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 : public LLIOPipe
{
public:
        LLHTTPResponder(const LLHTTPNode& tree, const LLSD& ctx);
        ~LLHTTPResponder();

protected:
        bool readLine(
                const LLChannelDescriptors& channels,
                buffer_ptr_t buffer,
                U8* dest,
                S32& len);
        
        void markBad(const LLChannelDescriptors& channels, buffer_ptr_t buffer);

protected:
        /* @name LLIOPipe virtual implementations
         */

        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)
{
        LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER);
}

// virtual
LLHTTPResponder::~LLHTTPResponder()
{
        LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER);
        //lldebugs << "destroying LLHTTPResponder" << llendl;
}

bool LLHTTPResponder::readLine(
        const LLChannelDescriptors& channels,
        buffer_ptr_t buffer,
        U8* dest,
        S32& len)
{
        LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER);
        --len;
        U8* last = buffer->readAfter(channels.in(), mLastRead, dest, len);
        dest[len] = '\0';
        U8* newline = (U8*)strchr((char*)dest, '\n');
        if(!newline)
        {
                if(len)
                {
                        lldebugs << "readLine failed - too long maybe?" << llendl;
                        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)
{
        LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER);
        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)
{
        PUMP_DEBUG;
        LLMemType m1(LLMemType::MTYPE_IO_HTTP_SERVER);
        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';
                        llinfos << (*seg_iter).getChannel() << ": " << buf
                                        << llendl;
                        ++seg_iter;
                }
                }
#endif
                
                PUMP_DEBUG;
                if(readLine(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))
                                {
                                        header >> mAbsPathAndQuery;
                                        header >> mVersion;

                                        lldebugs << "http request: "
                                                         << mVerb
                                                         << " " << mAbsPathAndQuery
                                                         << " " << mVersion << llendl;

                                        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;
                                        lldebugs << "unknown http verb: " << mVerb << llendl;
                                        markBad(channels, buffer);
                                }
                        }
                        if(parse_all)
                        {
                                bool keep_parsing = true;
                                while(keep_parsing)
                                {
                                        if(read_next_line)
                                        {
                                                len = HEADER_BUFFER_SIZE;       
                                                readLine(channels, buffer, (U8*)buf, len);
                                        }
                                        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;
                                                lldebugs << "bad header: " << buf << llendl;
                                                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);
                                        LLString::toLower(name);
                                        if("content-length" == name)
                                        {
                                                lldebugs << "Content-Length: " << value << llendl;
                                                mContentLength = atoi(value.c_str());
                                        }
                                        else
                                        {
                                                LLString::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]["verb"] = mVerb;
                const LLHTTPNode* node = mRootNode.traverse(mPath, context);
                if(node)
                {
                        //llinfos << "LLHTTPResponder::process_impl found node for "
                        //      << mAbsPathAndQuery << llendl;

                        // Copy everything after mLast read to the out.
                        LLBufferArray::segment_iterator_t seg_iter;
                        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';
                                        llinfos << (*seg_iter).getChannel() << ": " << buf
                                                        << llendl;
                                        ++seg_iter;
                                }
#endif
                        }

                        //
                        // *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]["path"] = mPath;
                        context[CONTEXT_REQUEST]["query-string"] = mQuery;
                        context[CONTEXT_REQUEST]["remote-host"]
                                = mBuildContext["remote-host"];
                        context[CONTEXT_REQUEST]["remote-port"]
                                = mBuildContext["remote-port"];
                        context[CONTEXT_REQUEST]["headers"] = mHeaders;

                        const LLChainIOFactory* protocolHandler
                                = node->getProtocolHandler();
                        if (protocolHandler)
                        {
                                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
                {
                        llwarns << "LLHTTPResponder::process_impl didn't find a node for "
                                << mAbsPathAndQuery << llendl;
                        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)
    {
        llerrs << "Unable to initialize socket" << llendl;
    }

    LLHTTPResponseFactory* factory = new LLHTTPResponseFactory;
        boost::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;
}

---