SingularityViewer/indra/llmessage/llhttpclient.cpp

/** 
 * @file llhttpclient.cpp
 * @brief Implementation of classes for making HTTP requests.
 *
 * $LicenseInfo:firstyear=2006&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 "llhttpclient.h"

#include "llassetstorage.h"
#include "lliopipe.h"
#include "llurlrequest.h"
#include "llbufferstream.h"
#include "llsdserialize.h"
#include "llvfile.h"
#include "llvfs.h"
#include "lluri.h"
#include "llpumpio.h"		// LLPumpIO::chain_t

#include "message.h"

const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
#ifdef AI_UNUSED
#endif // AI_UNUSED
////////////////////////////////////////////////////////////////////////////

// Responder class moved to LLCurl

namespace
{
#if 0
	class LLHTTPClientURLAdaptor : public LLURLRequestComplete
	{
	public:
		LLHTTPClientURLAdaptor(LLCurl::ResponderPtr responder)
			: LLURLRequestComplete(), mResponder(responder), mStatus(499),
			  mReason("LLURLRequest complete w/no status")
		{
		}
		
		~LLHTTPClientURLAdaptor()
		{
		}

		virtual void httpStatus(U32 status, const std::string& reason)
		{
			LLURLRequestComplete::httpStatus(status,reason);

			mStatus = status;
			mReason = reason;
		}

		virtual void complete(const LLChannelDescriptors& channels,
							  const buffer_ptr_t& buffer)
		{
			if (mResponder.get())
			{
				// Allow clients to parse headers before we attempt to parse
				// the body and provide completed/result/error calls.
				mResponder->completedHeader(mStatus, mReason, mHeaderOutput);
				mResponder->completedRaw(mStatus, mReason, channels, buffer);
			}
		}
		virtual void header(const std::string& header, const std::string& value)
		{
			mHeaderOutput[header] = value;
		}

	private:
		LLCurl::ResponderPtr mResponder;
		U32 mStatus;
		std::string mReason;
		LLSD mHeaderOutput;
	};
#endif

	class Injector : public LLIOPipe
	{
	public:
		virtual const char* contentType() = 0;
	};

	class LLSDInjector : public Injector
	{
	public:
		LLSDInjector(const LLSD& sd) : mSD(sd) {}
		virtual ~LLSDInjector() {}

		const char* contentType() { return "application/llsd+xml"; }

		virtual EStatus process_impl(const LLChannelDescriptors& channels,
			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
		{
			LLBufferStream ostream(channels, buffer.get());
			LLSDSerialize::toXML(mSD, ostream);
			eos = true;
			return STATUS_DONE;
		}

		const LLSD mSD;
	};

	class RawInjector : public Injector
	{
	public:
		RawInjector(const U8* data, S32 size) : mData(data), mSize(size) {}
		virtual ~RawInjector() {delete [] mData;}

		const char* contentType() { return "application/octet-stream"; }

		virtual EStatus process_impl(const LLChannelDescriptors& channels,
			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
		{
			LLBufferStream ostream(channels, buffer.get());
			ostream.write((const char *)mData, mSize);  // hopefully chars are always U8s
			eos = true;
			return STATUS_DONE;
		}

		const U8* mData;
		S32 mSize;
	};
	
	class FileInjector : public Injector
	{
	public:
		FileInjector(const std::string& filename) : mFilename(filename) {}
		virtual ~FileInjector() {}

		const char* contentType() { return "application/octet-stream"; }

		virtual EStatus process_impl(const LLChannelDescriptors& channels,
			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
		{
			LLBufferStream ostream(channels, buffer.get());

			llifstream fstream(mFilename, std::iostream::binary | std::iostream::out);
			if(fstream.is_open())
			{
				fstream.seekg(0, std::ios::end);
				U32 fileSize = fstream.tellg();
				fstream.seekg(0, std::ios::beg);
				std::vector<char> fileBuffer(fileSize);
				fstream.read(&fileBuffer[0], fileSize);
				ostream.write(&fileBuffer[0], fileSize);
				fstream.close();
				eos = true;
				return STATUS_DONE;
			}
			
			return STATUS_ERROR;
		}

		const std::string mFilename;
	};
	
	class VFileInjector : public Injector
	{
	public:
		VFileInjector(const LLUUID& uuid, LLAssetType::EType asset_type) : mUUID(uuid), mAssetType(asset_type) {}
		virtual ~VFileInjector() {}

		const char* contentType() { return "application/octet-stream"; }

		virtual EStatus process_impl(const LLChannelDescriptors& channels,
			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
		{
			LLBufferStream ostream(channels, buffer.get());
			
			LLVFile vfile(gVFS, mUUID, mAssetType, LLVFile::READ);
			S32 fileSize = vfile.getSize();
			std::vector<U8> fileBuffer(fileSize);
			vfile.read(&fileBuffer[0], fileSize);
			ostream.write((char*)&fileBuffer[0], fileSize);
			eos = true;
			return STATUS_DONE;
		}

		const LLUUID mUUID;
		LLAssetType::EType mAssetType;
	};

	LLPumpIO* theClientPump = NULL;
}

static void request(
	const std::string& url,
	LLURLRequest::ERequestAction method,
	Injector* body_injector,
	LLCurl::ResponderPtr responder,
	const F32 timeout = HTTP_REQUEST_EXPIRY_SECS,
	const LLSD& headers = LLSD())
{
	if (responder)
	{
		// For possible debug output from within the responder.
		responder->setURL(url);
	}

	if (!LLHTTPClient::hasPump())
	{
		responder->fatalError("No pump");
		return;
	}
	LLPumpIO::chain_t chain;

	LLURLRequest* req;
	try
	{
		req = new LLURLRequest(method, url);
	}
	catch(AICurlNoEasyHandle& error)
	{
		llwarns << "Failed to create LLURLRequest: " << error.what() << llendl;
		// This is what the old LL code did: no recovery whatsoever (but also no leaks or crash).
		return ;
	}

	req->checkRootCertificate(true);

	lldebugs << LLURLRequest::actionAsVerb(method) << " " << url << " " << headers << llendl;

	// Insert custom headers if the caller sent any.

	std::vector<std::string> headers_vector;
	bool has_content_type = false;
	bool has_accept = false;

	// Note that headers always is a map, unless no argument was passed.
	if (headers.isMap())
	{
		if (headers.has("Cookie"))
		{
			req->allowCookies();
		}

		LLSD::map_const_iterator iter = headers.beginMap();
		LLSD::map_const_iterator const end  = headers.endMap();

		for (; iter != end; ++iter)
		{
			// If the header is "Pragma" with no value, the caller intends to
			// force libcurl to drop the Pragma header it so gratuitously inserts.
			// Before inserting the header, force libcurl to not use the proxy.
			if (iter->first.compare("Pragma") == 0 && iter->second.asString().empty())
			{
				req->useProxy(false);
			}
			if (iter->first.compare("Content-Type") == 0)
			{
				has_content_type = true;
			}
			if (iter->first.compare("Accept") == 0)
			{
				has_accept = true;
			}

			std::ostringstream header;
			header << iter->first << ": " << iter->second.asString();
			headers_vector.push_back(header.str());
		}
	}

	if (method == LLURLRequest::HTTP_PUT || method == LLURLRequest::HTTP_POST)
	{
		if (!has_content_type)
		{
			// If the Content-Type header was passed in, it has
			// already been added as a header through req->addHeader
			// in the loop above. We defer to the caller's wisdom, but
			// if they did not specify a Content-Type, then ask the
			// injector.
			headers_vector.push_back(llformat("Content-Type: %s", body_injector->contentType()));
		}
	}
	else
	{
		// Check to see if we have already set Accept or not. If no one
		// set it, set it to application/llsd+xml since that's what we
		// almost always want.
		if (!has_accept)
		{
			headers_vector.push_back("Accept: application/llsd+xml");
		}
	}
	if (method == LLURLRequest::HTTP_POST && gMessageSystem)
	{
		headers_vector.push_back(llformat("X-SecondLife-UDP-Listen-Port: %d", gMessageSystem->mPort));
	}

	if (method == LLURLRequest::HTTP_PUT || method == LLURLRequest::HTTP_POST)
	{
		//AIFIXME:
		chain.push_back(LLIOPipe::ptr_t(body_injector));
	}

	//AIFIXME: chain.push_back(LLIOPipe::ptr_t(req));

	AICurlEasyRequest_wat buffered_easy_request_w(*req->mCurlEasyRequest);
	AICurlResponderBuffer_wat buffer_w(*req->mCurlEasyRequest);
	buffer_w->prepRequest(buffered_easy_request_w, headers_vector, responder);

	req->setRequestTimeOut(timeout);
	//AIFIXME: theClientPump->addChain(chain, timeout);
}


void LLHTTPClient::getByteRange(
	const std::string& url,
	S32 offset,
	S32 bytes,
	ResponderPtr responder,
	const LLSD& hdrs,
	const F32 timeout)
{
	LLSD headers = hdrs;
	if(offset > 0 || bytes > 0)
	{
		std::string range = llformat("bytes=%d-%d", offset, offset+bytes-1);
		headers["Range"] = range;
	}
    request(url, LLURLRequest::HTTP_GET, NULL, responder, timeout, headers);
}

void LLHTTPClient::head(
	const std::string& url,
	ResponderPtr responder,
	const LLSD& headers,
	const F32 timeout)
{
	request(url, LLURLRequest::HTTP_HEAD, NULL, responder, timeout, headers);
}

void LLHTTPClient::get(const std::string& url, ResponderPtr responder, const LLSD& headers, const F32 timeout)
{
	request(url, LLURLRequest::HTTP_GET, NULL, responder, timeout, headers);
}
void LLHTTPClient::getHeaderOnly(const std::string& url, ResponderPtr responder, const LLSD& headers, const F32 timeout)
{
	request(url, LLURLRequest::HTTP_HEAD, NULL, responder, timeout, headers);
}
void LLHTTPClient::getHeaderOnly(const std::string& url, ResponderPtr responder, const F32 timeout)
{
	getHeaderOnly(url, responder, LLSD(), timeout);
}

void LLHTTPClient::get(const std::string& url, const LLSD& query, ResponderPtr responder, const LLSD& headers, const F32 timeout)
{
	LLURI uri;
	
	uri = LLURI::buildHTTP(url, LLSD::emptyArray(), query);
	get(uri.asString(), responder, headers, timeout);
}

// A simple class for managing data returned from a curl http request.
class LLHTTPBuffer
{
public:
	LLHTTPBuffer() { }

	static size_t curl_write(char* ptr, size_t size, size_t nmemb, void* user_data)
	{
		LLHTTPBuffer* self = (LLHTTPBuffer*)user_data;
		
		size_t bytes = (size * nmemb);
		self->mBuffer.append(ptr,bytes);
		return nmemb;
	}

	LLSD asLLSD()
	{
		LLSD content;

		if (mBuffer.empty()) return content;
		
		std::istringstream istr(mBuffer);
		LLSDSerialize::fromXML(content, istr);
		return content;
	}

	std::string asString()
	{
		return mBuffer;
	}

private:
	std::string mBuffer;
};

// These calls are blocking! This is usually bad, unless you're a dataserver. Then it's awesome.

/**
	@brief does a blocking request on the url, returning the data or bad status.

	@param url URI to verb on.
	@param method the verb to hit the URI with.
	@param body the body of the call (if needed - for instance not used for GET and DELETE, but is for POST and PUT)
	@param headers HTTP headers to use for the request.
	@param timeout Curl timeout to use. Defaults to 5. Rationale:
	Without this timeout, blockingGet() calls have been observed to take
	up to 90 seconds to complete.  Users of blockingGet() already must 
	check the HTTP return code for validity, so this will not introduce
	new errors.  A 5 second timeout will succeed > 95% of the time (and 
	probably > 99% of the time) based on my statistics. JC

	@returns an LLSD map: {status: integer, body: map}
  */
static LLSD blocking_request(
	const std::string& url,
	LLURLRequest::ERequestAction method,
	const LLSD& body,
	const LLSD& headers = LLSD(),
	const F32 timeout = 5
)
{
	lldebugs << "blockingRequest of " << url << llendl;

	S32 http_status = 499;
	LLSD response = LLSD::emptyMap();

	try
	{
		AICurlEasyRequest easy_request(false);
		AICurlEasyRequest_wat curlEasyRequest_w(*easy_request);

		LLHTTPBuffer http_buffer;
		
		// * Set curl handle options
		curlEasyRequest_w->setopt(CURLOPT_TIMEOUT, (long)timeout);	// seconds, see warning at top of function.
		curlEasyRequest_w->setWriteCallback(&LLHTTPBuffer::curl_write, &http_buffer);

		// * Setup headers.
		if (headers.isMap())
		{
			LLSD::map_const_iterator iter = headers.beginMap();
			LLSD::map_const_iterator end  = headers.endMap();
			for (; iter != end; ++iter)
			{
				std::ostringstream header;
				header << iter->first << ": " << iter->second.asString() ;
				lldebugs << "header = " << header.str() << llendl;
				curlEasyRequest_w->addHeader(header.str().c_str());
			}
		}
		
		// Needs to stay alive until after the call to perform().
		std::ostringstream ostr;

		// * Setup specific method / "verb" for the URI (currently only GET and POST supported + poppy)
		if (method == LLURLRequest::HTTP_GET)
		{
			curlEasyRequest_w->setopt(CURLOPT_HTTPGET, 1);
		}
		else if (method == LLURLRequest::HTTP_POST)
		{
			//copied from PHP libs, correct?
			curlEasyRequest_w->addHeader("Content-Type: application/llsd+xml");
			LLSDSerialize::toXML(body, ostr);
			curlEasyRequest_w->setPost(ostr.str().c_str(), ostr.str().length());
		}
		
		// * Do the action using curl, handle results
		curlEasyRequest_w->addHeader("Accept: application/llsd+xml");
		curlEasyRequest_w->finalizeRequest(url);

		S32 curl_success = curlEasyRequest_w->perform();
		curlEasyRequest_w->getinfo(CURLINFO_RESPONSE_CODE, &http_status);
		// if we get a non-404 and it's not a 200 OR maybe it is but you have error bits,
		if ( http_status != 404 && (http_status != 200 || curl_success != 0) )
		{
			// We expect 404s, don't spam for them.
			llwarns << "CURL REQ URL: " << url << llendl;
			llwarns << "CURL REQ METHOD TYPE: " << LLURLRequest::actionAsVerb(method) << llendl;
			llwarns << "CURL REQ HEADERS: " << headers.asString() << llendl;
			llwarns << "CURL REQ BODY: " << ostr.str() << llendl;
			llwarns << "CURL HTTP_STATUS: " << http_status << llendl;
			llwarns << "CURL ERROR: " << curlEasyRequest_w->getErrorString() << llendl;
			llwarns << "CURL ERROR BODY: " << http_buffer.asString() << llendl;
			response["body"] = http_buffer.asString();
		}
		else
		{
			response["body"] = http_buffer.asLLSD();
			lldebugs << "CURL response: " << http_buffer.asString() << llendl;
		}
	}
	catch(AICurlNoEasyHandle const& error)
	{
		response["body"] = error.what();
	}

	response["status"] = http_status;
	return response;
}

LLSD LLHTTPClient::blockingGet(const std::string& url)
{
	return blocking_request(url, LLURLRequest::HTTP_GET, LLSD());
}

LLSD LLHTTPClient::blockingPost(const std::string& url, const LLSD& body)
{
	return blocking_request(url, LLURLRequest::HTTP_POST, body);
}

void LLHTTPClient::put(
	const std::string& url,
	const LLSD& body,
	ResponderPtr responder,
	const LLSD& headers,
	const F32 timeout)
{
	request(url, LLURLRequest::HTTP_PUT, new LLSDInjector(body), responder, timeout, headers);
}

void LLHTTPClient::post(
	const std::string& url,
	const LLSD& body,
	ResponderPtr responder,
	const LLSD& headers,
	const F32 timeout)
{
	request(url, LLURLRequest::HTTP_POST, new LLSDInjector(body), responder, timeout, headers);
}

void LLHTTPClient::postRaw(
	const std::string& url,
	const U8* data,
	S32 size,
	ResponderPtr responder,
	const LLSD& headers,
	const F32 timeout)
{
	request(url, LLURLRequest::HTTP_POST, new RawInjector(data, size), responder, timeout, headers);
}

void LLHTTPClient::postFile(
	const std::string& url,
	const std::string& filename,
	ResponderPtr responder,
	const LLSD& headers,
	const F32 timeout)
{
	request(url, LLURLRequest::HTTP_POST, new FileInjector(filename), responder, timeout, headers);
}

void LLHTTPClient::postFile(
	const std::string& url,
	const LLUUID& uuid,
	LLAssetType::EType asset_type,
	ResponderPtr responder,
	const LLSD& headers,
	const F32 timeout)
{
	request(url, LLURLRequest::HTTP_POST, new VFileInjector(uuid, asset_type), responder, timeout, headers);
}

// static
void LLHTTPClient::del(
	const std::string& url,
	ResponderPtr responder,
	const LLSD& headers,
	const F32 timeout)
{
	request(url, LLURLRequest::HTTP_DELETE, NULL, responder, timeout, headers);
}

// static
void LLHTTPClient::move(
	const std::string& url,
	const std::string& destination,
	ResponderPtr responder,
	const LLSD& hdrs,
	const F32 timeout)
{
	LLSD headers = hdrs;
	headers["Destination"] = destination;
	request(url, LLURLRequest::HTTP_MOVE, NULL, responder, timeout, headers);
}


//static
void LLHTTPClient::setPump(LLPumpIO& pump)
{
	theClientPump = &pump;
}

//static
bool LLHTTPClient::hasPump()
{
	return theClientPump != NULL;
}

//static
LLPumpIO& LLHTTPClient::getPump()
{
	return *theClientPump;
}