svn merge -r 80357:80990 svn+ssh://svn.lindenlab.com/svn/linden/branches/Branch_1-19-1-Server --> release

Merge patches from 1.19.1 Server branch:

* QAR-293 Fix for hardcoded TTLs in web dataservices
* DEV-10826 fix for busted binary and notation parse if handed an unlimited parse size
* Bounce apache2 processes before starting backbone/dataserver/simulator
* Changing web-ds TTL in a way that any query that has 0 < ttl <=60 will have ttl = 61.
* Partial reversion of multiagent-chat to 1.19.0 to address fast memory leak
* Fixed minor, non user facing bug in multiagentchat
* set-classified-stats: Rewrote to use new MDB2 query reformatting syntax
* Fixed possible bad conversion of vivox data
* DEV-550, caching changes to DirClassifieds Query
* QAR-240 (DEV-8488) Prevent residents from purging stuff that isn't trash on the backend
* More mem leak fixes for multiagent-chat
* QAR-274 Fetch inventory descendents over TCP (via HTTP cap) instead of UDP
* DEV-10151: Sometimes group IMs appear to be person to person IMs
* QAR-321 Changes to crash_reporter
* DEV-11004 Speed up people search query using FORCE INDEX (PRIMARY) on the username table if the first-name query fragment is >= 3 chars
* DEV-11004 Speed up people search query using FORCE INDEX (PRIMARY).  Web service version of this, must use two named queries because we need to change the query based on input string length.

1 files changed, 799 insertions, 163 deletions

diff --git a/indra/llmessage/llcurl.cpp b/indra/llmessage/llcurl.cpp
index 9b5e6cd4e6..8b9a45ff3f 100644
--- a/indra/llmessage/llcurl.cpp
+++ b/indra/llmessage/llcurl.cpp
@@ -2,7 +2,7 @@
  * @file llcurl.h
  * @author Zero / Donovan
  * @date 2006-10-15
- * @brief Curl wrapper
+ * @brief Implementation of wrapper around libcurl.
  *
  * $LicenseInfo:firstyear=2006&license=viewergpl$
  * 
@@ -31,13 +31,29 @@
  * $/LicenseInfo$
  */
 
+#if LL_WINDOWS
+#define SAFE_SSL 1
+#elif LL_DARWIN
+#define SAFE_SSL 1
+#else
+#define SAFE_SSL 1
+#endif
+
 #include "linden_common.h"
 
 #include "llcurl.h"
 
+#include <algorithm>
 #include <iomanip>
+#include <curl/curl.h>
+#if SAFE_SSL
+#include <openssl/crypto.h>
+#endif
 
+#include "llbufferstream.h"
+#include "llstl.h"
 #include "llsdserialize.h"
+#include "llthread.h"
 
 //////////////////////////////////////////////////////////////////////////////
 /*
@@ -55,40 +71,112 @@
 	do this.
  */
 
-using namespace std;
-	
+//////////////////////////////////////////////////////////////////////////////
+
+static const S32 EASY_HANDLE_POOL_SIZE		= 5;
+static const S32 MULTI_PERFORM_CALL_REPEAT	= 5;
+static const S32 CURL_REQUEST_TIMEOUT = 30; // seconds
+static const S32 MAX_ACTIVE_REQUEST_COUNT = 100;
+
+// DEBUG //
+S32 gCurlEasyCount = 0;
+S32 gCurlMultiCount = 0;
+
+//////////////////////////////////////////////////////////////////////////////
+
+//static
+std::vector<LLMutex*> LLCurl::sSSLMutex;
+std::string LLCurl::sCAPath;
+std::string LLCurl::sCAFile;
+
+//static
+void LLCurl::setCAPath(const std::string& path)
+{
+	sCAPath = path;
+}
+
+//static
+void LLCurl::setCAFile(const std::string& file)
+{
+	sCAFile = file;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
 LLCurl::Responder::Responder()
 	: mReferenceCount(0)
 {
 }
+
 LLCurl::Responder::~Responder()
 {
 }
 
 // virtual
-void LLCurl::Responder::error(U32 status, const std::stringstream& content)
+void LLCurl::Responder::error(U32 status, const std::string& reason)
 {
-	llinfos << "LLCurl::Responder::error " << status << ": " << content.str() << llendl;
+	llinfos << status << ": " << reason << llendl;
 }
 
 // virtual
-void LLCurl::Responder::result(const std::stringstream& content)
+void LLCurl::Responder::result(const LLSD& content)
 {
+	llwarns << "Virtual Function not implemented" << llendl;
 }
 
 // virtual
-void LLCurl::Responder::completed(U32 status, const std::stringstream& content)
+void LLCurl::Responder::completedRaw(U32 status, const std::string& reason,
+									 const LLChannelDescriptors& channels,
+									 const LLIOPipe::buffer_ptr_t& buffer)
 {
-	if (200 <= status &&  status < 300)
+	if (isGoodStatus(status))
+	{
+		LLSD content;
+		LLBufferStream istr(channels, buffer.get());
+		LLSDSerialize::fromXML(content, istr);
+/*
+		const S32 parseError = -1;
+		if(LLSDSerialize::fromXML(content, istr) == parseError)
+		{
+			mStatus = 498;
+			mReason = "Client Parse Error";
+		}
+*/
+		completed(status, reason, content);
+	}
+	else if (status == 400)
+	{
+		// Get reason from buffer
+		char tbuf[4096];
+		S32 len = 4096;
+		buffer->readAfter(channels.in(), NULL, (U8*)tbuf, len);
+		tbuf[len] = 0;
+		completed(status, std::string(tbuf), LLSD());
+	}
+	else
+	{
+		completed(status, reason, LLSD());
+	}
+}
+
+// virtual
+void LLCurl::Responder::completed(U32 status, const std::string& reason, const LLSD& content)
+{
+	if (isGoodStatus(status))
 	{
 		result(content);
 	}
 	else
 	{
-		error(status, content);
+		error(status, reason);
 	}
 }
 
+//virtual
+void LLCurl::Responder::completedHeader(U32 status, const std::string& reason, const LLSD& content)
+{
+
+}
 
 namespace boost
 {
@@ -106,226 +194,456 @@ namespace boost
 	}
 };
 
+
 //////////////////////////////////////////////////////////////////////////////
 
-size_t
-curlOutputCallback(void* data, size_t size, size_t nmemb, void* user_data)
+
+class LLCurl::Easy
 {
-	stringstream& output = *(stringstream*)user_data;
+	LOG_CLASS(Easy);
+
+private:
+	Easy();
 	
-	size_t n = size * nmemb;
-	output.write((const char*)data, n);
-	if (!((istream&)output).good()) {
-		std::cerr << "WHAT!?!?!? istream side bad" << std::endl;
-	}
-	if (!((ostream&)output).good()) {
-		std::cerr << "WHAT!?!?!? ostream side bad" << std::endl;
-	}
+public:
+	static Easy* getEasy();
+	~Easy();
 
-	return n;
-}
+	CURL* getCurlHandle() const { return mCurlEasyHandle; }
 
-// Only used if request contained a body (post or put), Not currently implemented.
-// size_t
-// curlRequestCallback(void* data, size_t size, size_t nmemb, void* user_data)
-// {
-// 	stringstream& request = *(stringstream*)user_data;
+	void setErrorBuffer();
+	void setCA();
 	
-// 	size_t n = size * nmemb;
-// 	request.read((char*)data, n);
-// 	return request.gcount();
-// }
-
+	void setopt(CURLoption option, S32 value);
+	// These assume the setter does not free value!
+	void setopt(CURLoption option, void* value);
+	void setopt(CURLoption option, char* value);
+	// Copies the string so that it is gauranteed to stick around
+	void setoptString(CURLoption option, const std::string& value);
+	
+	void slist_append(const char* str);
+	void setHeaders();
+	
+	U32 report(CURLcode);
+	void getTransferInfo(LLCurl::TransferInfo* info);
 
+	void prepRequest(const std::string& url, ResponderPtr, bool post = false);
+	
+	const char* getErrorBuffer();
 
+	std::stringstream& getInput() { return mInput; }
+	std::stringstream& getHeaderOutput() { return mHeaderOutput; }
+	LLIOPipe::buffer_ptr_t& getOutput() { return mOutput; }
+	const LLChannelDescriptors& getChannels() { return mChannels; }
+	
+	void resetState();
 
+private:	
+	CURL*				mCurlEasyHandle;
+	struct curl_slist*	mHeaders;
+	
+	std::stringstream	mRequest;
+	LLChannelDescriptors mChannels;
+	LLIOPipe::buffer_ptr_t mOutput;
+	std::stringstream	mInput;
+	std::stringstream	mHeaderOutput;
+	char				mErrorBuffer[CURL_ERROR_SIZE];
+
+	// Note: char*'s not strings since we pass pointers to curl
+	std::vector<char*>	mStrings;
+	
+	ResponderPtr		mResponder;
+};
 
 LLCurl::Easy::Easy()
+	: mHeaders(NULL),
+	  mCurlEasyHandle(NULL)
 {
-	mHeaders = 0;
-	mHeaders = curl_slist_append(mHeaders, "Connection: keep-alive");
-	mHeaders = curl_slist_append(mHeaders, "Keep-alive: 300");
-	mHeaders = curl_slist_append(mHeaders, "Content-Type: application/xml");
-		// FIXME: shouldn't be there for GET/DELETE
-		// FIXME: should have ACCEPT headers
-		
-	mHandle = curl_easy_init();
+	mErrorBuffer[0] = 0;
+}
+
+LLCurl::Easy* LLCurl::Easy::getEasy()
+{
+	Easy* easy = new Easy();
+	easy->mCurlEasyHandle = curl_easy_init();
+	if (!easy->mCurlEasyHandle)
+	{
+		// this can happen if we have too many open files (fails in c-ares/ares_init.c)
+		llwarns << "curl_multi_init() returned NULL! Easy handles: " << gCurlEasyCount << " Multi handles: " << gCurlMultiCount << llendl;
+		delete easy;
+		return NULL;
+	}
+	++gCurlEasyCount;
+	return easy;
 }
 
 LLCurl::Easy::~Easy()
 {
-	curl_easy_cleanup(mHandle);
+	curl_easy_cleanup(mCurlEasyHandle);
+	--gCurlEasyCount;
 	curl_slist_free_all(mHeaders);
+	for_each(mStrings.begin(), mStrings.end(), DeletePointer());
 }
 
-void
-LLCurl::Easy::get(const string& url, ResponderPtr responder)
+void LLCurl::Easy::resetState()
 {
-	prep(url, responder);
-	curl_easy_setopt(mHandle, CURLOPT_HTTPGET, 1);
+ 	curl_easy_reset(mCurlEasyHandle);
+
+	if (mHeaders)
+	{
+		curl_slist_free_all(mHeaders);
+		mHeaders = NULL;
+	}
+
+	mRequest.str("");
+	mRequest.clear();
+
+	mOutput.reset();
+	
+	mInput.str("");
+	mInput.clear();
+	
+	mErrorBuffer[0] = 0;
+	
+	mHeaderOutput.str("");
+	mHeaderOutput.clear();
 }
 
-void
-LLCurl::Easy::getByteRange(const string& url, S32 offset, S32 length, ResponderPtr responder)
+void LLCurl::Easy::setErrorBuffer()
 {
-	mRange = llformat("Range: bytes=%d-%d", offset,offset+length-1);
-	mHeaders = curl_slist_append(mHeaders, mRange.c_str());
-	prep(url, responder);
-	curl_easy_setopt(mHandle, CURLOPT_HTTPGET, 1);
+	setopt(CURLOPT_ERRORBUFFER, &mErrorBuffer);
 }
 
-void
-LLCurl::Easy::perform()
+const char* LLCurl::Easy::getErrorBuffer()
 {
-	report(curl_easy_perform(mHandle));
+	return mErrorBuffer;
 }
 
-void
-LLCurl::Easy::prep(const std::string& url, ResponderPtr responder)
+void LLCurl::Easy::setCA()
 {
-#if !LL_DARWIN
- 	curl_easy_reset(mHandle); // SJB: doesn't exisit on OSX 10.3.9
-#else
-	// SJB: equivalent? fast?
- 	curl_easy_cleanup(mHandle);
- 	mHandle = curl_easy_init();
-#endif
-	
-	curl_easy_setopt(mHandle, CURLOPT_PRIVATE, this);
-
-//	curl_easy_setopt(mHandle, CURLOPT_VERBOSE, 1); // usefull for debugging
-	curl_easy_setopt(mHandle, CURLOPT_NOSIGNAL, 1);
-	curl_easy_setopt(mHandle, CURLOPT_WRITEFUNCTION, &curlOutputCallback);
-	curl_easy_setopt(mHandle, CURLOPT_WRITEDATA, &mOutput);
-#if 1 // For debug
-	curl_easy_setopt(mHandle, CURLOPT_HEADERFUNCTION, &curlOutputCallback);
-	curl_easy_setopt(mHandle, CURLOPT_HEADERDATA, &mHeaderOutput);
-#endif
-	curl_easy_setopt(mHandle, CURLOPT_ERRORBUFFER, &mErrorBuffer);
-	curl_easy_setopt(mHandle, CURLOPT_ENCODING, "");
-	curl_easy_setopt(mHandle, CURLOPT_SSL_VERIFYPEER, false);
-	curl_easy_setopt(mHandle, CURLOPT_HTTPHEADER, mHeaders);
-
-	mOutput.str("");
-	if (!((istream&)mOutput).good()) {
-		std::cerr << "WHAT!?!?!? istream side bad" << std::endl;
+	if(!sCAPath.empty())
+	{
+		setoptString(CURLOPT_CAPATH, sCAPath);
 	}
-	if (!((ostream&)mOutput).good()) {
-		std::cerr << "WHAT!?!?!? ostream side bad" << std::endl;
+	if(!sCAFile.empty())
+	{
+		setoptString(CURLOPT_CAINFO, sCAFile);
 	}
+}
 
-	mURL = url;
-	curl_easy_setopt(mHandle, CURLOPT_URL, mURL.c_str());
+void LLCurl::Easy::setHeaders()
+{
+	setopt(CURLOPT_HTTPHEADER, mHeaders);
+}
 
-	mResponder = responder;
+void LLCurl::Easy::getTransferInfo(LLCurl::TransferInfo* info)
+{
+	curl_easy_getinfo(mCurlEasyHandle, CURLINFO_SIZE_DOWNLOAD, &info->mSizeDownload);
+	curl_easy_getinfo(mCurlEasyHandle, CURLINFO_TOTAL_TIME, &info->mTotalTime);
+	curl_easy_getinfo(mCurlEasyHandle, CURLINFO_SPEED_DOWNLOAD, &info->mSpeedDownload);
 }
 
-void
-LLCurl::Easy::report(CURLcode code)
+U32 LLCurl::Easy::report(CURLcode code)
 {
-	if (!mResponder) return;
-	
-	long responseCode;
+	U32 responseCode = 0;	
+	std::string responseReason;
 	
 	if (code == CURLE_OK)
 	{
-		curl_easy_getinfo(mHandle, CURLINFO_RESPONSE_CODE, &responseCode);
+		curl_easy_getinfo(mCurlEasyHandle, CURLINFO_RESPONSE_CODE, &responseCode);
+		//*TODO: get reason from first line of mHeaderOutput
 	}
 	else
 	{
 		responseCode = 499;
+		responseReason = strerror(code) + " : " + mErrorBuffer;
+	}
+		
+	if (mResponder)
+	{	
+		mResponder->completedRaw(responseCode, responseReason, mChannels, mOutput);
+		mResponder = NULL;
 	}
 	
-	mResponder->completed(responseCode, mOutput);
-	mResponder = NULL;
+	resetState();
+	return responseCode;
 }
 
+// Note: these all assume the caller tracks the value (i.e. keeps it persistant)
+void LLCurl::Easy::setopt(CURLoption option, S32 value)
+{
+	curl_easy_setopt(mCurlEasyHandle, option, value);
+}
 
+void LLCurl::Easy::setopt(CURLoption option, void* value)
+{
+	curl_easy_setopt(mCurlEasyHandle, option, value);
+}
 
+void LLCurl::Easy::setopt(CURLoption option, char* value)
+{
+	curl_easy_setopt(mCurlEasyHandle, option, value);
+}
 
+// Note: this copies the string so that the caller does not have to keep it around
+void LLCurl::Easy::setoptString(CURLoption option, const std::string& value)
+{
+	char* tstring = new char[value.length()+1];
+	strcpy(tstring, value.c_str());
+	mStrings.push_back(tstring);
+	curl_easy_setopt(mCurlEasyHandle, option, tstring);
+}
 
+void LLCurl::Easy::slist_append(const char* str)
+{
+	mHeaders = curl_slist_append(mHeaders, str);
+}
 
-LLCurl::Multi::Multi()
+size_t curlReadCallback(char* data, size_t size, size_t nmemb, void* user_data)
 {
-	mHandle = curl_multi_init();
+	LLCurl::Easy* easy = (LLCurl::Easy*)user_data;
+	
+	S32 n = size * nmemb;
+	S32 startpos = easy->getInput().tellg();
+	easy->getInput().seekg(0, std::ios::end);
+	S32 endpos = easy->getInput().tellg();
+	easy->getInput().seekg(startpos, std::ios::beg);
+	S32 maxn = endpos - startpos;
+	n = llmin(n, maxn);
+	easy->getInput().read((char*)data, n);
+
+	return n;
 }
 
-LLCurl::Multi::~Multi()
+size_t curlWriteCallback(char* data, size_t size, size_t nmemb, void* user_data)
 {
-	// FIXME: should clean up excess handles in mFreeEasy
-	curl_multi_cleanup(mHandle);
+	LLCurl::Easy* easy = (LLCurl::Easy*)user_data;
+	
+	S32 n = size * nmemb;
+	easy->getOutput()->append(easy->getChannels().in(), (const U8*)data, n);
+
+	return n;
 }
 
+size_t curlHeaderCallback(void* data, size_t size, size_t nmemb, void* user_data)
+{
+	LLCurl::Easy* easy = (LLCurl::Easy*)user_data;
+	
+	size_t n = size * nmemb;
+	easy->getHeaderOutput().write((const char*)data, n);
 
-void
-LLCurl::Multi::get(const std::string& url, ResponderPtr responder)
+	return n;
+}
+
+void LLCurl::Easy::prepRequest(const std::string& url, ResponderPtr responder, bool post)
 {
-	LLCurl::Easy* easy = easyAlloc();
-	easy->get(url, responder);
-	curl_multi_add_handle(mHandle, easy->mHandle);
+	resetState();
+	
+	if (post) setoptString(CURLOPT_ENCODING, "");
+
+//	setopt(CURLOPT_VERBOSE, 1); // usefull for debugging
+	setopt(CURLOPT_NOSIGNAL, 1);
+
+	mOutput.reset(new LLBufferArray);
+	setopt(CURLOPT_WRITEFUNCTION, (void*)&curlWriteCallback);
+	setopt(CURLOPT_WRITEDATA, (void*)this);
+
+	setopt(CURLOPT_READFUNCTION, (void*)&curlReadCallback);
+	setopt(CURLOPT_READDATA, (void*)this);
+	
+	setopt(CURLOPT_HEADERFUNCTION, (void*)&curlHeaderCallback);
+	setopt(CURLOPT_HEADERDATA, (void*)this);
+
+	setErrorBuffer();
+	setCA();
+
+	setopt(CURLOPT_SSL_VERIFYPEER, true);
+	setopt(CURLOPT_TIMEOUT, CURL_REQUEST_TIMEOUT);
+
+	setoptString(CURLOPT_URL, url);
+
+	mResponder = responder;
+
+	if (!post)
+	{
+		slist_append("Connection: keep-alive");
+		slist_append("Keep-alive: 300");
+	}
+	// *FIX: should have ACCEPT headers
 }
+
+////////////////////////////////////////////////////////////////////////////
+
+class LLCurl::Multi
+{
+	LOG_CLASS(Multi);
+public:
+	
+	Multi();
+	~Multi();
+
+	Easy* allocEasy();
+	bool addEasy(Easy* easy);
 	
-void
-LLCurl::Multi::getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr responder)
+	void removeEasy(Easy* easy);
+
+	S32 process();
+	S32 perform();
+	
+	CURLMsg* info_read(S32* msgs_in_queue);
+
+	S32 mQueued;
+	S32 mErrorCount;
+	
+private:
+	void easyFree(Easy*);
+	
+	CURLM* mCurlMultiHandle;
+
+	typedef std::set<Easy*> easy_active_list_t;
+	easy_active_list_t mEasyActiveList;
+	typedef std::map<CURL*, Easy*> easy_active_map_t;
+	easy_active_map_t mEasyActiveMap;
+	typedef std::set<Easy*> easy_free_list_t;
+	easy_free_list_t mEasyFreeList;
+};
+
+LLCurl::Multi::Multi()
+	: mQueued(0),
+	  mErrorCount(0)
 {
-	LLCurl::Easy* easy = easyAlloc();
-	easy->getByteRange(url, offset, length, responder);
-	curl_multi_add_handle(mHandle, easy->mHandle);
+	mCurlMultiHandle = curl_multi_init();
+	if (!mCurlMultiHandle)
+	{
+		llwarns << "curl_multi_init() returned NULL! Easy handles: " << gCurlEasyCount << " Multi handles: " << gCurlMultiCount << llendl;
+		mCurlMultiHandle = curl_multi_init();
+	}
+	llassert_always(mCurlMultiHandle);
+	++gCurlMultiCount;
 }
+
+LLCurl::Multi::~Multi()
+{
+	// Clean up active
+	for(easy_active_list_t::iterator iter = mEasyActiveList.begin();
+		iter != mEasyActiveList.end(); ++iter)
+	{
+		Easy* easy = *iter;
+		curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle());
+		delete easy;
+	}
+	mEasyActiveList.clear();
+	mEasyActiveMap.clear();
 	
-void
-LLCurl::Multi::process()
+	// Clean up freed
+	for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer());	
+	mEasyFreeList.clear();
+
+	curl_multi_cleanup(mCurlMultiHandle);
+	--gCurlMultiCount;
+}
+
+CURLMsg* LLCurl::Multi::info_read(S32* msgs_in_queue)
 {
-	int count;
-	for (int call_count = 0; call_count < 5; call_count += 1)
+	CURLMsg* curlmsg = curl_multi_info_read(mCurlMultiHandle, msgs_in_queue);
+	return curlmsg;
+}
+
+
+S32 LLCurl::Multi::perform()
+{
+	S32 q = 0;
+	for (S32 call_count = 0;
+		 call_count < MULTI_PERFORM_CALL_REPEAT;
+		 call_count += 1)
 	{
-		if (CURLM_CALL_MULTI_PERFORM != curl_multi_perform(mHandle, &count))
+		CURLMcode code = curl_multi_perform(mCurlMultiHandle, &q);
+		if (CURLM_CALL_MULTI_PERFORM != code || q == 0)
 		{
 			break;
 		}
 	}
-		
+	mQueued = q;
+	return q;
+}
+
+S32 LLCurl::Multi::process()
+{
+	perform();
+	
 	CURLMsg* msg;
 	int msgs_in_queue;
-	while ((msg = curl_multi_info_read(mHandle, &msgs_in_queue)))
+
+	S32 processed = 0;
+	while ((msg = info_read(&msgs_in_queue)))
 	{
-		if (msg->msg != CURLMSG_DONE) continue;
-		Easy* easy = 0;
-		curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &easy);
-		if (!easy) continue;
-		easy->report(msg->data.result);
-		
-		curl_multi_remove_handle(mHandle, easy->mHandle);
-		easyFree(easy);
+		++processed;
+		if (msg->msg == CURLMSG_DONE)
+		{
+			U32 response = 0;
+			easy_active_map_t::iterator iter = mEasyActiveMap.find(msg->easy_handle);
+			if (iter != mEasyActiveMap.end())
+			{
+				Easy* easy = iter->second;
+				response = easy->report(msg->data.result);
+				removeEasy(easy);
+			}
+			else
+			{
+				response = 499;
+				//*TODO: change to llwarns
+				llerrs << "cleaned up curl request completed!" << llendl;
+			}
+			if (response >= 400)
+			{
+				// failure of some sort, inc mErrorCount for debugging and flagging multi for destruction
+				++mErrorCount;
+			}
+		}
 	}
+	return processed;
 }
 
-
-
-LLCurl::Easy*
-LLCurl::Multi::easyAlloc()
+LLCurl::Easy* LLCurl::Multi::allocEasy()
 {
 	Easy* easy = 0;
-	
-	if (mFreeEasy.empty())
+
+	if (mEasyFreeList.empty())
 	{
-		easy = new Easy();
+		easy = Easy::getEasy();
 	}
 	else
 	{
-		easy = mFreeEasy.back();
-		mFreeEasy.pop_back();
+		easy = *(mEasyFreeList.begin());
+		mEasyFreeList.erase(easy);
+	}
+	if (easy)
+	{
+		mEasyActiveList.insert(easy);
+		mEasyActiveMap[easy->getCurlHandle()] = easy;
 	}
-
 	return easy;
 }
 
-void
-LLCurl::Multi::easyFree(Easy* easy)
+bool LLCurl::Multi::addEasy(Easy* easy)
 {
-	if (mFreeEasy.size() < 5)
+	CURLMcode mcode = curl_multi_add_handle(mCurlMultiHandle, easy->getCurlHandle());
+	if (mcode != CURLM_OK)
 	{
-		mFreeEasy.push_back(easy);
+		llwarns << "Curl Error: " << curl_multi_strerror(mcode) << llendl;
+		return false;
+	}
+	return true;
+}
+
+void LLCurl::Multi::easyFree(Easy* easy)
+{
+	mEasyActiveList.erase(easy);
+	mEasyActiveMap.erase(easy->getCurlHandle());
+	if (mEasyFreeList.size() < EASY_HANDLE_POOL_SIZE)
+	{
+		easy->resetState();
+		mEasyFreeList.insert(easy);
 	}
 	else
 	{
@@ -333,53 +651,371 @@ LLCurl::Multi::easyFree(Easy* easy)
 	}
 }
 
+void LLCurl::Multi::removeEasy(Easy* easy)
+{
+	curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle());
+	easyFree(easy);
+}
+
+//static
+std::string LLCurl::strerror(CURLcode errorcode)
+{
+#if LL_DARWIN
+	// curl_easy_strerror was added in libcurl 7.12.0.  Unfortunately, the version in the Mac OS X 10.3.9 SDK is 7.10.2...
+	// There's a problem with the custom curl headers in our build that keeps me from #ifdefing this on the libcurl version number
+	// (the correct check would be #if LIBCURL_VERSION_NUM >= 0x070c00).  We'll fix the header problem soon, but for now
+	// just punt and print the numeric error code on the Mac.
+	return llformat("%d", errorcode);
+#else // LL_DARWIN
+	return std::string(curl_easy_strerror(errorcode));
+#endif // LL_DARWIN
+}
+
+////////////////////////////////////////////////////////////////////////////
+// For generating a simple request for data
+// using one multi and one easy per request 
+
+LLCurlRequest::LLCurlRequest()
+	: mActiveMulti(NULL)
+{
+}
+
+LLCurlRequest::~LLCurlRequest()
+{
+	for_each(mMultiSet.begin(), mMultiSet.end(), DeletePointer());
+}
+
+void LLCurlRequest::addMulti()
+{
+	LLCurl::Multi* multi = new LLCurl::Multi();
+	mMultiSet.insert(multi);
+	mActiveMulti = multi;
+	mActiveRequestCount = 0;
+}
+
+LLCurl::Easy* LLCurlRequest::allocEasy()
+{
+	if (!mActiveMulti ||
+		mActiveRequestCount	>= MAX_ACTIVE_REQUEST_COUNT ||
+		mActiveMulti->mErrorCount > 0)
+	{
+		addMulti();
+	}
+	llassert_always(mActiveMulti);
+	++mActiveRequestCount;
+	LLCurl::Easy* easy = mActiveMulti->allocEasy();
+	return easy;
+}
+
+bool LLCurlRequest::addEasy(LLCurl::Easy* easy)
+{
+	llassert_always(mActiveMulti);
+	bool res = mActiveMulti->addEasy(easy);
+	return res;
+}
 
+void LLCurlRequest::get(const std::string& url, LLCurl::ResponderPtr responder)
+{
+	getByteRange(url, 0, -1, responder);
+}
+	
+bool LLCurlRequest::getByteRange(const std::string& url, S32 offset, S32 length, LLCurl::ResponderPtr responder)
+{
+	LLCurl::Easy* easy = allocEasy();
+	if (!easy)
+	{
+		return false;
+	}
+	easy->prepRequest(url, responder);
+	easy->setopt(CURLOPT_HTTPGET, 1);
+	if (length > 0)
+	{
+		std::string range = llformat("Range: bytes=%d-%d", offset,offset+length-1);
+		easy->slist_append(range.c_str());
+	}
+	easy->setHeaders();
+	bool res = addEasy(easy);
+	return res;
+}
 
-namespace
+bool LLCurlRequest::post(const std::string& url, const LLSD& data, LLCurl::ResponderPtr responder)
 {
-	static LLCurl::Multi* sMainMulti = 0;
+	LLCurl::Easy* easy = allocEasy();
+	if (!easy)
+	{
+		return false;
+	}
+	easy->prepRequest(url, responder);
+
+	LLSDSerialize::toXML(data, easy->getInput());
+	S32 bytes = easy->getInput().str().length();
+	
+	easy->setopt(CURLOPT_POST, 1);
+	easy->setopt(CURLOPT_POSTFIELDS, (void*)NULL);
+	easy->setopt(CURLOPT_POSTFIELDSIZE, bytes);
+
+	easy->slist_append("Content-Type: application/xml");
+	easy->setHeaders();
+
+	lldebugs << "POSTING: " << bytes << " bytes." << llendl;
+	bool res = addEasy(easy);
+	return res;
+}
 	
-	LLCurl::Multi*
-	mainMulti()
+// Note: call once per frame
+S32 LLCurlRequest::process()
+{
+	S32 res = 0;
+	for (curlmulti_set_t::iterator iter = mMultiSet.begin();
+		 iter != mMultiSet.end(); )
 	{
-		if (!sMainMulti) {
-			sMainMulti = new LLCurl::Multi();
+		curlmulti_set_t::iterator curiter = iter++;
+		LLCurl::Multi* multi = *curiter;
+		S32 tres = multi->process();
+		res += tres;
+		if (multi != mActiveMulti && tres == 0 && multi->mQueued == 0)
+		{
+			mMultiSet.erase(curiter);
+			delete multi;
 		}
-		return sMainMulti;
 	}
+	return res;
+}
 
-	void freeMulti()
+S32 LLCurlRequest::getQueued()
+{
+	S32 queued = 0;
+	for (curlmulti_set_t::iterator iter = mMultiSet.begin();
+		 iter != mMultiSet.end(); )
 	{
-		delete sMainMulti;
-		sMainMulti = NULL;
+		curlmulti_set_t::iterator curiter = iter++;
+		LLCurl::Multi* multi = *curiter;
+		queued += multi->mQueued;
 	}
+	return queued;
 }
 
-void
-LLCurl::get(const std::string& url, ResponderPtr responder)
+////////////////////////////////////////////////////////////////////////////
+// For generating one easy request
+// associated with a single multi request
+
+LLCurlEasyRequest::LLCurlEasyRequest()
+	: mRequestSent(false),
+	  mResultReturned(false)
 {
-	mainMulti()->get(url, responder);
+	mMulti = new LLCurl::Multi();
+	mEasy = mMulti->allocEasy();
+	if (mEasy)
+	{
+		mEasy->setErrorBuffer();
+		mEasy->setCA();
+	}
 }
-	
-void
-LLCurl::getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr responder)
+
+LLCurlEasyRequest::~LLCurlEasyRequest()
 {
-	mainMulti()->getByteRange(url, offset, length, responder);
+	delete mMulti;
 }
 	
-void LLCurl::initClass()
+void LLCurlEasyRequest::setopt(CURLoption option, S32 value)
 {
-    curl_global_init(CURL_GLOBAL_ALL);
+	if (mEasy)
+	{
+		mEasy->setopt(option, value);
+	}
 }
 
-void
-LLCurl::process()
+void LLCurlEasyRequest::setoptString(CURLoption option, const std::string& value)
 {
-	mainMulti()->process();
+	if (mEasy)
+	{
+		mEasy->setoptString(option, value);
+	}
 }
 
-void LLCurl::cleanup()
+void LLCurlEasyRequest::setPost(char* postdata, S32 size)
 {
-	freeMulti();
+	if (mEasy)
+	{
+		mEasy->setopt(CURLOPT_POST, 1);
+		mEasy->setopt(CURLOPT_POSTFIELDS, postdata);
+		mEasy->setopt(CURLOPT_POSTFIELDSIZE, size);
+	}
+}
+
+void LLCurlEasyRequest::setHeaderCallback(curl_header_callback callback, void* userdata)
+{
+	if (mEasy)
+	{
+		mEasy->setopt(CURLOPT_HEADERFUNCTION, (void*)callback);
+		mEasy->setopt(CURLOPT_HEADERDATA, userdata); // aka CURLOPT_WRITEHEADER
+	}
+}
+
+void LLCurlEasyRequest::setWriteCallback(curl_write_callback callback, void* userdata)
+{
+	if (mEasy)
+	{
+		mEasy->setopt(CURLOPT_WRITEFUNCTION, (void*)callback);
+		mEasy->setopt(CURLOPT_WRITEDATA, userdata);
+	}
+}
+
+void LLCurlEasyRequest::setReadCallback(curl_read_callback callback, void* userdata)
+{
+	if (mEasy)
+	{
+		mEasy->setopt(CURLOPT_READFUNCTION, (void*)callback);
+		mEasy->setopt(CURLOPT_READDATA, userdata);
+	}
+}
+
+void LLCurlEasyRequest::slist_append(const char* str)
+{
+	if (mEasy)
+	{
+		mEasy->slist_append(str);
+	}
+}
+
+void LLCurlEasyRequest::sendRequest(const std::string& url)
+{
+	llassert_always(!mRequestSent);
+	mRequestSent = true;
+	if (mEasy)
+	{
+		mEasy->setHeaders();
+		mEasy->setoptString(CURLOPT_URL, url);
+		mMulti->addEasy(mEasy);
+	}
+}
+
+void LLCurlEasyRequest::requestComplete()
+{
+	llassert_always(mRequestSent);
+	mRequestSent = false;
+	if (mEasy)
+	{
+		mMulti->removeEasy(mEasy);
+	}
+}
+
+S32 LLCurlEasyRequest::perform()
+{
+	return mMulti->perform();
+}
+
+// Usage: Call getRestult until it returns false (no more messages)
+bool LLCurlEasyRequest::getResult(CURLcode* result, LLCurl::TransferInfo* info)
+{
+	if (!mEasy)
+	{
+		// Special case - we failed to initialize a curl_easy (can happen if too many open files)
+		//  Act as though the request failed to connect
+		if (mResultReturned)
+		{
+			return false;
+		}
+		else
+		{
+			*result = CURLE_FAILED_INIT;
+			mResultReturned = true;
+			return true;
+		}
+	}
+	// In theory, info_read might return a message with a status other than CURLMSG_DONE
+	// In practice for all messages returned, msg == CURLMSG_DONE
+	// Ignore other messages just in case
+	while(1)
+	{
+		S32 q;
+		CURLMsg* curlmsg = info_read(&q, info);
+		if (curlmsg)
+		{
+			if (curlmsg->msg == CURLMSG_DONE)
+			{
+				*result = curlmsg->data.result;			
+				return true;
+			}
+			// else continue
+		}
+		else
+		{
+			return false;
+		}
+	}
+}
+
+// private
+CURLMsg* LLCurlEasyRequest::info_read(S32* q, LLCurl::TransferInfo* info)
+{
+	if (mEasy)
+	{
+		CURLMsg* curlmsg = mMulti->info_read(q);
+		if (curlmsg && curlmsg->msg == CURLMSG_DONE)
+		{
+			if (info)
+			{
+				mEasy->getTransferInfo(info);
+			}
+		}
+		return curlmsg;
+	}
+	return NULL;
+}
+
+std::string LLCurlEasyRequest::getErrorString()
+{
+	return mEasy ? std::string(mEasy->getErrorBuffer()) : std::string();
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+#if SAFE_SSL
+//static
+void LLCurl::ssl_locking_callback(int mode, int type, const char *file, int line)
+{
+	if (mode & CRYPTO_LOCK)
+	{
+		LLCurl::sSSLMutex[type]->lock();
+	}
+	else
+	{
+		LLCurl::sSSLMutex[type]->unlock();
+	}
+}
+
+//static
+unsigned long LLCurl::ssl_thread_id(void)
+{
+	return LLThread::currentID();
+}
+#endif
+
+void LLCurl::initClass()
+{
+	// Do not change this "unless you are familiar with and mean to control 
+	// internal operations of libcurl"
+	// - http://curl.haxx.se/libcurl/c/curl_global_init.html
+	curl_global_init(CURL_GLOBAL_ALL);
+	
+#if SAFE_SSL
+	S32 mutex_count = CRYPTO_num_locks();
+	for (S32 i=0; i<mutex_count; i++)
+	{
+		sSSLMutex.push_back(new LLMutex(gAPRPoolp));
+	}
+	CRYPTO_set_id_callback(&LLCurl::ssl_thread_id);
+	CRYPTO_set_locking_callback(&LLCurl::ssl_locking_callback);
+#endif
+}
+
+void LLCurl::cleanupClass()
+{
+#if SAFE_SSL
+	CRYPTO_set_locking_callback(NULL);
+	for_each(sSSLMutex.begin(), sSSLMutex.end(), DeletePointer());
+#endif
 	curl_global_cleanup();
 }
+