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;
};

static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_PIPE("HTTP Pipe");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_GET("HTTP Get");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_PUT("HTTP Put");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_POST("HTTP Post");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_DELETE("HTTP Delete");

LLIOPipe::EStatus LLHTTPPipe::process_impl(
	const LLChannelDescriptors& channels,
    buffer_ptr_t& buffer,
    bool& eos,
    LLSD& context,
    LLPumpIO* pump)
{
	LL_RECORD_BLOCK_TIME(FTM_PROCESS_HTTP_PIPE);
	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)
		{
			LL_RECORD_BLOCK_TIME(FTM_PROCESS_HTTP_GET);
			mNode.get(LLHTTPNode::ResponsePtr(mResponse), context);
		}
		else if(verb == HTTP_VERB_PUT)
		{
			LL_RECORD_BLOCK_TIME(FTM_PROCESS_HTTP_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)
		{
			LL_RECORD_BLOCK_TIME(FTM_PROCESS_HTTP_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)
		{
			LL_RECORD_BLOCK_TIME(FTM_PROCESS_HTTP_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
 */

static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_HEADER("HTTP Header");

// virtual
LLIOPipe::EStatus LLHTTPResponseHeader::process_impl(
	const LLChannelDescriptors& channels,
	buffer_ptr_t& buffer,
	bool& eos,
	LLSD& context,
	LLPumpIO* pump)
{
	LL_RECORD_BLOCK_TIME(FTM_PROCESS_HTTP_HEADER);
	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";
}

static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_RESPONDER("HTTP Responder");

// virtual
LLIOPipe::EStatus LLHTTPResponder::process_impl(
	const LLChannelDescriptors& channels,
	buffer_ptr_t& buffer,
	bool& eos,
	LLSD& context,
	LLPumpIO* pump)
{
	LL_RECORD_BLOCK_TIME(FTM_PROCESS_HTTP_RESPONDER);
	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;
	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;
}