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.

7 files changed, 1039 insertions, 606 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();
 }
+
diff --git a/indra/llmessage/llcurl.h b/indra/llmessage/llcurl.h
index 53287c2988..48c14d9460 100644
--- a/indra/llmessage/llcurl.h
+++ b/indra/llmessage/llcurl.h
@@ -1,8 +1,8 @@
-/**
+/** 
  * @file llcurl.h
  * @author Zero / Donovan
  * @date 2006-10-15
- * @brief Curl wrapper
+ * @brief A wrapper around libcurl.
  *
  * $LicenseInfo:firstyear=2006&license=viewergpl$
  * 
@@ -41,104 +41,183 @@
 #include <vector>
 
 #include <boost/intrusive_ptr.hpp>
-#include <curl/curl.h>
+#include <curl/curl.h> // TODO: remove dependency
 
-// #include "llhttpclient.h"
+#include "llbuffer.h"
+#include "lliopipe.h"
+#include "llsd.h"
+
+class LLMutex;
+
+// For whatever reason, this is not typedef'd in curl.h
+typedef size_t (*curl_header_callback)(void *ptr, size_t size, size_t nmemb, void *stream);
 
 class LLCurl
 {
+	LOG_CLASS(LLCurl);
+	
 public:
+	class Easy;
 	class Multi;
 
+	struct TransferInfo
+	{
+		TransferInfo() : mSizeDownload(0.0), mTotalTime(0.0), mSpeedDownload(0.0) {}
+		F64 mSizeDownload;
+		F64 mTotalTime;
+		F64 mSpeedDownload;
+	};
+	
 	class Responder
 	{
+	//LOG_CLASS(Responder);
 	public:
+
 		Responder();
 		virtual ~Responder();
 
-		virtual void error(U32 status, const std::stringstream& content);	// called with bad status codes
+		/**
+		 * @brief return true if the status code indicates success.
+		 */
+		static bool isGoodStatus(U32 status)
+		{
+			return((200 <= status) && (status < 300));
+		}
+		
+		virtual void error(U32 status, const std::string& reason);
+			// called with non-200 status codes
 		
-		virtual void result(const std::stringstream& content);
+		virtual void result(const LLSD& content);
 		
-		virtual void completed(U32 status, const std::stringstream& content);
+		// Override point for clients that may want to use this class when the response is some other format besides LLSD
+		virtual void completedRaw(U32 status, const std::string& reason,
+								  const LLChannelDescriptors& channels,
+								  const LLIOPipe::buffer_ptr_t& buffer);
+
+		virtual void completed(U32 status, const std::string& reason, const LLSD& content);
 			/**< The default implemetnation calls
 				either:
 				* result(), or
 				* error() 
 			*/
 			
+			// Override to handle parsing of the header only.  Note: this is the only place where the contents
+			// of the header can be parsed.  In the ::completed call above only the body is contained in the LLSD.
+			virtual void completedHeader(U32 status, const std::string& reason, const LLSD& content);
+
 	public: /* but not really -- don't touch this */
 		U32 mReferenceCount;
 	};
 	typedef boost::intrusive_ptr<Responder>	ResponderPtr;
-	
-	class Easy
-	{
-	public:
-		Easy();
-		~Easy();
-		
-		void get(const std::string& url, ResponderPtr);
-		void getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr);
-
-		void perform();
 
-	private:
-		void prep(const std::string& url, ResponderPtr);
-		void report(CURLcode);
-		
-		CURL*				mHandle;
-		struct curl_slist*	mHeaders;
-		
-		std::string			mURL;
-		std::string			mRange;
-		std::stringstream	mRequest;
 
-		std::stringstream	mOutput;
-		char				mErrorBuffer[CURL_ERROR_SIZE];
-
-		std::stringstream	mHeaderOutput; // Debug
-		
-		ResponderPtr		mResponder;
-
-		friend class Multi;
-	};
+	/**
+	 * @ brief Set certificate authority file used to verify HTTPS certs.
+	 */
+	static void setCAFile(const std::string& file);
 
+	/**
+	 * @ brief Set certificate authority path used to verify HTTPS certs.
+	 */
+	static void setCAPath(const std::string& path);
+	
+	/**
+	 * @ brief Get certificate authority file used to verify HTTPS certs.
+	 */
+	static const std::string& getCAFile() { return sCAFile; }
+
+	/**
+	 * @ brief Get certificate authority path used to verify HTTPS certs.
+	 */
+	static const std::string& getCAPath() { return sCAPath; }
+
+	/**
+	 * @ brief Initialize LLCurl class
+	 */
+	static void initClass();
+
+	/**
+	 * @ brief Cleanup LLCurl class
+	 */
+	static void cleanupClass();
+
+	/**
+	 * @ brief curl error code -> string
+	 */
+	static std::string strerror(CURLcode errorcode);
+	
+	// For OpenSSL callbacks
+	static std::vector<LLMutex*> sSSLMutex;
 
-	class Multi
-	{
-	public:
-		Multi();
-		~Multi();
+	// OpenSSL callbacks
+	static void LLCurl::ssl_locking_callback(int mode, int type, const char *file, int line);
+	static unsigned long LLCurl::ssl_thread_id(void);
+	
+	
+	
+private:
 
-		void get(const std::string& url, ResponderPtr);
-		void getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr);
+	static std::string sCAPath;
+	static std::string sCAFile;
+};
 
-		void process();
-		
-	private:
-		Easy* easyAlloc();
-		void easyFree(Easy*);
-		
-		CURLM* mHandle;
-		
-		typedef std::vector<Easy*>	EasyList;
-		EasyList mFreeEasy;
-	};
+namespace boost
+{
+	void intrusive_ptr_add_ref(LLCurl::Responder* p);
+	void intrusive_ptr_release(LLCurl::Responder* p);
+};
 
 
-	static void get(const std::string& url, ResponderPtr);
-	static void getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr responder);
+class LLCurlRequest
+{
+public:
+	LLCurlRequest();
+	~LLCurlRequest();
+
+	void get(const std::string& url, LLCurl::ResponderPtr responder);
+	bool getByteRange(const std::string& url, S32 offset, S32 length, LLCurl::ResponderPtr responder);
+	bool post(const std::string& url, const LLSD& data, LLCurl::ResponderPtr responder);
+	S32  process();
+	S32  getQueued();
+
+private:
+	void addMulti();
+	LLCurl::Easy* allocEasy();
+	bool addEasy(LLCurl::Easy* easy);
 	
-    static void initClass(); // *NOTE:Mani - not thread safe!
-	static void process();
-	static void cleanup(); // *NOTE:Mani - not thread safe!
+private:
+	typedef std::set<LLCurl::Multi*> curlmulti_set_t;
+	curlmulti_set_t mMultiSet;
+	LLCurl::Multi* mActiveMulti;
+	S32 mActiveRequestCount;
 };
 
-namespace boost
+class LLCurlEasyRequest
 {
-	void intrusive_ptr_add_ref(LLCurl::Responder* p);
-	void intrusive_ptr_release(LLCurl::Responder* p);
+public:
+	LLCurlEasyRequest();
+	~LLCurlEasyRequest();
+	void setopt(CURLoption option, S32 value);
+	void setoptString(CURLoption option, const std::string& value);
+	void setPost(char* postdata, S32 size);
+	void setHeaderCallback(curl_header_callback callback, void* userdata);
+	void setWriteCallback(curl_write_callback callback, void* userdata);
+	void setReadCallback(curl_read_callback callback, void* userdata);
+	void slist_append(const char* str);
+	void sendRequest(const std::string& url);
+	void requestComplete();
+	S32 perform();
+	bool getResult(CURLcode* result, LLCurl::TransferInfo* info = NULL);
+	std::string getErrorString();
+
+private:
+	CURLMsg* info_read(S32* queue, LLCurl::TransferInfo* info);
+	
+private:
+	LLCurl::Multi* mMulti;
+	LLCurl::Easy* mEasy;
+	bool mRequestSent;
+	bool mResultReturned;
 };
 
 #endif // LL_LLCURL_H
diff --git a/indra/llmessage/llhttpassetstorage.cpp b/indra/llmessage/llhttpassetstorage.cpp
index cf9bde6fec..2179064807 100644
--- a/indra/llmessage/llhttpassetstorage.cpp
+++ b/indra/llmessage/llhttpassetstorage.cpp
@@ -422,11 +422,8 @@ void LLHTTPAssetStorage::_init(const char *web_host, const char *local_web_host,
 	mLocalBaseURL = local_web_host;
 	mHostName = host_name;
 
-	// 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);
-
+	// curl_global_init moved to LLCurl::initClass()
+	
 	mCurlMultiHandle = curl_multi_init();
 }
 
@@ -435,7 +432,7 @@ LLHTTPAssetStorage::~LLHTTPAssetStorage()
 	curl_multi_cleanup(mCurlMultiHandle);
 	mCurlMultiHandle = NULL;
 	
-	curl_global_cleanup();
+	// curl_global_cleanup moved to LLCurl::initClass()
 }
 
 // storing data is simpler than getting it, so we just overload the whole method
diff --git a/indra/llmessage/llhttpclient.cpp b/indra/llmessage/llhttpclient.cpp
index 23295476ff..3b892aec50 100644
--- a/indra/llmessage/llhttpclient.cpp
+++ b/indra/llmessage/llhttpclient.cpp
@@ -1,4 +1,4 @@
-/** 
+ /** 
  * @file llhttpclient.cpp
  * @brief Implementation of classes for making HTTP requests.
  *
@@ -38,7 +38,6 @@
 #include "llurlrequest.h"
 #include "llbufferstream.h"
 #include "llsdserialize.h"
-#include "llsdutil.h"
 #include "llvfile.h"
 #include "llvfs.h"
 #include "lluri.h"
@@ -47,85 +46,18 @@
 #include <curl/curl.h>
 
 const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
-static std::string gCABundle;
+////////////////////////////////////////////////////////////////////////////
 
+// Responder class moved to LLCurl
 
-LLHTTPClient::Responder::Responder()
-	: mReferenceCount(0)
-{
-}
-
-LLHTTPClient::Responder::~Responder()
-{
-}
-
-// virtual
-void LLHTTPClient::Responder::error(U32 status, const std::string& reason)
-{
-	llinfos << "LLHTTPClient::Responder::error "
-		<< status << ": " << reason << llendl;
-}
-
-// virtual
-void LLHTTPClient::Responder::result(const LLSD& content)
-{
-}
-
-// virtual 
-void LLHTTPClient::Responder::completedRaw(
-	U32 status,
-	const std::string& reason,
-	const LLChannelDescriptors& channels,
-	const LLIOPipe::buffer_ptr_t& buffer)
-{
-	LLBufferStream istr(channels, buffer.get());
-	LLSD content;
-
-	if (isGoodStatus(status))
-	{
-		LLSDSerialize::fromXML(content, istr);
-/*
-		const S32 parseError = -1;
-		if(LLSDSerialize::fromXML(content, istr) == parseError)
-		{
-			mStatus = 498;
-			mReason = "Client Parse Error";
-		}
-*/
-	}
-	
-	completed(status, reason, content);
-}
-
-// virtual
-void LLHTTPClient::Responder::completed(
-	U32 status,
-	const std::string& reason,
-	const LLSD& content)
-{
-	if(isGoodStatus(status))
-	{
-		result(content);
-	}
-	else
-	{
-		error(status, reason);
-	}
-}
-
-// virtual
-void LLHTTPClient::Responder::completedHeader(U32 status, const std::string& reason, const LLSD& content)
-{
-
-}
 namespace
 {
 	class LLHTTPClientURLAdaptor : public LLURLRequestComplete
 	{
 	public:
-		LLHTTPClientURLAdaptor(LLHTTPClient::ResponderPtr responder)
-			: mResponder(responder),
-				mStatus(499), mReason("LLURLRequest complete w/no status")
+		LLHTTPClientURLAdaptor(LLCurl::ResponderPtr responder)
+			: mResponder(responder), mStatus(499),
+			  mReason("LLURLRequest complete w/no status")
 		{
 		}
 		
@@ -140,7 +72,7 @@ namespace
 		}
 
 		virtual void complete(const LLChannelDescriptors& channels,
-								const buffer_ptr_t& buffer)
+							  const buffer_ptr_t& buffer)
 		{
 			if (mResponder.get())
 			{
@@ -154,7 +86,7 @@ namespace
 		}
 
 	private:
-		LLHTTPClient::ResponderPtr mResponder;
+		LLCurl::ResponderPtr mResponder;
 		U32 mStatus;
 		std::string mReason;
 		LLSD mHeaderOutput;
@@ -267,13 +199,14 @@ namespace
 	LLPumpIO* theClientPump = NULL;
 }
 
-static void request(
-	const std::string& url,
-	LLURLRequest::ERequestAction method,
-	Injector* body_injector,
-	LLHTTPClient::ResponderPtr responder,
-    const LLSD& headers,
-	const F32 timeout=HTTP_REQUEST_EXPIRY_SECS)
+static void request(const std::string& url,
+					LLURLRequest::ERequestAction method,
+					Injector* body_injector,
+					LLCurl::ResponderPtr responder,
+					const LLSD& headers = LLSD(),
+					const F32 timeout = HTTP_REQUEST_EXPIRY_SECS,
+					S32 offset = 0,
+					S32 bytes = 0)
 {
 	if (!LLHTTPClient::hasPump())
 	{
@@ -283,7 +216,7 @@ static void request(
 	LLPumpIO::chain_t chain;
 
 	LLURLRequest *req = new LLURLRequest(method, url);
-	req->requestEncoding("");
+	req->checkRootCertificate(true);
 
     // Insert custom headers is the caller sent any
     if (headers.isMap())
@@ -308,10 +241,6 @@ static void request(
             req->addHeader(header.str().c_str());
         }
     }
-	if (!gCABundle.empty())
-	{
-		req->checkRootCertificate(true, gCABundle.c_str());
-	}
 	req->setCallback(new LLHTTPClientURLAdaptor(responder));
 
 	if (method == LLURLRequest::HTTP_POST  &&  gMessageSystem)
@@ -327,19 +256,26 @@ static void request(
 
    		chain.push_back(LLIOPipe::ptr_t(body_injector));
 	}
+
+	if (method == LLURLRequest::HTTP_GET && (offset > 0 || bytes > 0))
+	{
+		std::string range = llformat("Range: bytes=%d-%d", offset,offset+bytes-1);
+		req->addHeader(range.c_str());
+   	}
+	
 	chain.push_back(LLIOPipe::ptr_t(req));
 
 	theClientPump->addChain(chain, timeout);
 }
 
-static void request(
-	const std::string& url,
-	LLURLRequest::ERequestAction method,
-	Injector* body_injector,
-	LLHTTPClient::ResponderPtr responder,
-	const F32 timeout=HTTP_REQUEST_EXPIRY_SECS)
+
+void LLHTTPClient::getByteRange(const std::string& url,
+								S32 offset, S32 bytes,
+								ResponderPtr responder,
+								const LLSD& headers,
+								const F32 timeout)
 {
-    request(url, method, body_injector, responder, LLSD(), timeout);
+    request(url, LLURLRequest::HTTP_GET, NULL, responder, LLSD(), timeout, offset, bytes);
 }
 
 void LLHTTPClient::head(const std::string& url, ResponderPtr responder, const F32 timeout)
@@ -355,10 +291,6 @@ void LLHTTPClient::getHeaderOnly(const std::string& url, ResponderPtr responder,
 {
 	request(url, LLURLRequest::HTTP_HEAD, NULL, responder, headers, timeout);
 }
-void LLHTTPClient::get(const std::string& url, ResponderPtr responder, const F32 timeout)
-{
-	get(url, responder, LLSD(), timeout);
-}
 void LLHTTPClient::getHeaderOnly(const std::string& url, ResponderPtr responder, const F32 timeout)
 {
 	getHeaderOnly(url, responder, LLSD(), timeout);
@@ -372,11 +304,6 @@ void LLHTTPClient::get(const std::string& url, const LLSD& query, ResponderPtr r
 	get(uri.asString(), responder, headers, timeout);
 }
 
-void LLHTTPClient::get(const std::string& url, const LLSD& query, ResponderPtr responder, const F32 timeout)
-{
-	get(url, query, responder, LLSD(), timeout);
-}
-
 // A simple class for managing data returned from a curl http request.
 class LLHTTPBuffer
 {
@@ -412,6 +339,7 @@ private:
 	std::string mBuffer;
 };
 
+// *TODO: Deprecate (only used by dataserver)
 // This call is blocking! This is probably usually bad. :(
 LLSD LLHTTPClient::blockingGet(const std::string& url)
 {
@@ -505,24 +433,3 @@ bool LLHTTPClient::hasPump()
 {
 	return theClientPump != NULL;
 }
-
-void LLHTTPClient::setCABundle(const std::string& caBundle)
-{
-	gCABundle = caBundle;
-}
-
-namespace boost
-{
-	void intrusive_ptr_add_ref(LLHTTPClient::Responder* p)
-	{
-		++p->mReferenceCount;
-	}
-	
-	void intrusive_ptr_release(LLHTTPClient::Responder* p)
-	{
-		if(p && 0 == --p->mReferenceCount)
-		{
-			delete p;
-		}
-	}
-};
diff --git a/indra/llmessage/llhttpclient.h b/indra/llmessage/llhttpclient.h
index 1fbf0c36dc..b011761f5f 100644
--- a/indra/llmessage/llhttpclient.h
+++ b/indra/llmessage/llhttpclient.h
@@ -41,7 +41,7 @@
 #include <boost/intrusive_ptr.hpp>
 
 #include "llassettype.h"
-#include "llbuffer.h"
+#include "llcurl.h"
 #include "lliopipe.h"
 
 extern const F32 HTTP_REQUEST_EXPIRY_SECS;
@@ -54,57 +54,18 @@ class LLSD;
 class LLHTTPClient
 {
 public:
-	class Responder
-	{
-	public:
-		Responder();
-		virtual ~Responder();
-
-		/**
-		 * @brief return true if the status code indicates success.
-		 */
-		static bool isGoodStatus(U32 status)
-		{
-			return((200 <= status) && (status < 300));
-		}
-
-		virtual void error(U32 status, const std::string& reason);	// called with bad status codes
-		
-		virtual void result(const LLSD& content);
-		
-		// Override point for clients that may want to use this class
-		// when the response is some other format besides LLSD
-		virtual void completedRaw(
-			U32 status,
-			const std::string& reason,
-			const LLChannelDescriptors& channels,
-			const LLIOPipe::buffer_ptr_t& buffer);
-
-		virtual void completed(
-			U32 status,
-			const std::string& reason,
-			const LLSD& content);
-			/**< The default implemetnation calls
-				either:
-				* result(), or
-				* error() 
-			*/
-
-		// Override to handle parsing of the header only.  Note: this is the only place where the contents
-		// of the header can be parsed.  In the ::completed call above only the body is contained in the LLSD.
-		virtual void completedHeader(U32 status, const std::string& reason, const LLSD& content);
-
-	public: /* but not really -- don't touch this */
-		U32 mReferenceCount;
-	};
-
-	typedef boost::intrusive_ptr<Responder>	ResponderPtr;
-	
+	// class Responder moved to LLCurl
+
+	// For convenience
+	typedef LLCurl::Responder Responder;
+	typedef LLCurl::ResponderPtr ResponderPtr;
+
+	// non-blocking
 	static void head(const std::string& url, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	static void get(const std::string& url, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	static void get(const std::string& url, ResponderPtr, const LLSD& headers, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	static void get(const std::string& url, const LLSD& query, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	static void get(const std::string& url, const LLSD& query, ResponderPtr, const LLSD& headers, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+	static void getByteRange(const std::string& url, S32 offset, S32 bytes, ResponderPtr, const LLSD& headers=LLSD(), const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+	static void get(const std::string& url, ResponderPtr, const LLSD& headers = LLSD(), const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+	static void get(const std::string& url, const LLSD& query, ResponderPtr, const LLSD& headers = LLSD(), const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+
 	static void put(const std::string& url, const LLSD& body, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
 	static void getHeaderOnly(const std::string& url, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
 	static void getHeaderOnly(const std::string& url, ResponderPtr, const LLSD& headers, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
@@ -127,20 +88,6 @@ public:
 		///< must be called before any of the above calls are made
 	static bool hasPump();
 		///< for testing
-	
-	static void setCABundle(const std::string& caBundle);
-		///< use this root CA bundle when checking SSL connections
-		///< defaults to the standard system root CA bundle
-		///< @see LLURLRequest::checkRootCertificate()
 };
 
-
-
-namespace boost
-{
-	void intrusive_ptr_add_ref(LLHTTPClient::Responder* p);
-	void intrusive_ptr_release(LLHTTPClient::Responder* p);
-};
-
-
 #endif // LL_LLHTTPCLIENT_H
diff --git a/indra/llmessage/llurlrequest.cpp b/indra/llmessage/llurlrequest.cpp
index 631eea3e88..f850656785 100644
--- a/indra/llmessage/llurlrequest.cpp
+++ b/indra/llmessage/llurlrequest.cpp
@@ -37,6 +37,7 @@
 #include <curl/curl.h>
 #include <algorithm>
 
+#include "llcurl.h"
 #include "llioutil.h"
 #include "llmemtype.h"
 #include "llpumpio.h"
@@ -52,8 +53,7 @@ static const U32 HTTP_STATUS_PIPE_ERROR = 499;
 const std::string CONTEXT_DEST_URI_SD_LABEL("dest_uri");
 
 
-static
-size_t headerCallback(void* data, size_t size, size_t nmemb, void* user);
+static size_t headerCallback(void* data, size_t size, size_t nmemb, void* user);
 
 /**
  * class LLURLRequestDetail
@@ -63,12 +63,8 @@ class LLURLRequestDetail
 public:
 	LLURLRequestDetail();
 	~LLURLRequestDetail();
-	CURLM* mCurlMulti;
- 	CURL* mCurl;
-	struct curl_slist* mHeaders;
-	char* mURL;
-	char mCurlErrorBuf[CURL_ERROR_SIZE + 1];		/* Flawfinder: ignore */
-	bool mNeedToRemoveEasyHandle;
+	std::string mURL;
+	LLCurlEasyRequest* mCurlRequest;
 	LLBufferArray* mResponseBuffer;
 	LLChannelDescriptors mChannels;
 	U8* mLastRead;
@@ -77,11 +73,7 @@ public:
 };
 
 LLURLRequestDetail::LLURLRequestDetail() :
-	mCurlMulti(NULL),
-	mCurl(NULL),
-	mHeaders(NULL),
-	mURL(NULL),
-	mNeedToRemoveEasyHandle(false),
+	mCurlRequest(NULL),
 	mResponseBuffer(NULL),
 	mLastRead(NULL),
 	mBodyLimit(0),
@@ -89,34 +81,13 @@ LLURLRequestDetail::LLURLRequestDetail() :
 	
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
-	mCurlErrorBuf[0] = '\0';
+	mCurlRequest = new LLCurlEasyRequest();
 }
 
 LLURLRequestDetail::~LLURLRequestDetail()
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
-	if(mCurl)
-	{
-		if(mNeedToRemoveEasyHandle && mCurlMulti)
-		{
-			curl_multi_remove_handle(mCurlMulti, mCurl);
-			mNeedToRemoveEasyHandle = false;
-		}
-		curl_easy_cleanup(mCurl);
-		mCurl = NULL;
-	}
-	if(mCurlMulti)
-	{
-		curl_multi_cleanup(mCurlMulti);
-		mCurlMulti = NULL;
-	}
-	if(mHeaders)
-	{
-		curl_slist_free_all(mHeaders);
-		mHeaders = NULL;
-	}
-	delete[] mURL;
-	mURL = NULL;
+	delete mCurlRequest;
 	mResponseBuffer = NULL;
 	mLastRead = NULL;
 }
@@ -126,9 +97,6 @@ LLURLRequestDetail::~LLURLRequestDetail()
  * class LLURLRequest
  */
 
-static std::string sCAFile("");
-static std::string sCAPath("");
-
 LLURLRequest::LLURLRequest(LLURLRequest::ERequestAction action) :
 	mAction(action)
 {
@@ -155,31 +123,13 @@ LLURLRequest::~LLURLRequest()
 void LLURLRequest::setURL(const std::string& url)
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
-	if(mDetail->mURL)
-	{
-		// *NOTE: if any calls to set the url have been made to curl,
-		// this will probably lead to a crash.
-		delete[] mDetail->mURL;
-		mDetail->mURL = NULL;
-	}
-	if(!url.empty())
-	{
-		mDetail->mURL = new char[url.size() + 1];
-		url.copy(mDetail->mURL, url.size());
-		mDetail->mURL[url.size()] = '\0';
-	}
+	mDetail->mURL = url;
 }
 
 void LLURLRequest::addHeader(const char* header)
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
-	mDetail->mHeaders = curl_slist_append(mDetail->mHeaders, header);
-}
-
-void LLURLRequest::requestEncoding(const char* encoding)
-{
-	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_ENCODING, encoding);
+	mDetail->mCurlRequest->slist_append(header);
 }
 
 void LLURLRequest::setBodyLimit(U32 size)
@@ -188,22 +138,17 @@ void LLURLRequest::setBodyLimit(U32 size)
 	mDetail->mIsBodyLimitSet = true;
 }
 
-void LLURLRequest::checkRootCertificate(bool check, const char* caBundle)
+void LLURLRequest::checkRootCertificate(bool check)
 {
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_SSL_VERIFYPEER, (check? TRUE : FALSE));
-	if (caBundle)
-	{
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_CAINFO, caBundle);
-	}
+	mDetail->mCurlRequest->setopt(CURLOPT_SSL_VERIFYPEER, (check? TRUE : FALSE));
+	mDetail->mCurlRequest->setoptString(CURLOPT_ENCODING, "");
 }
 
 void LLURLRequest::setCallback(LLURLRequestComplete* callback)
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
 	mCompletionCallback = callback;
-
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_HEADERFUNCTION, &headerCallback);
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_WRITEHEADER, callback);
+	mDetail->mCurlRequest->setHeaderCallback(&headerCallback, (void*)callback);
 }
 
 // Added to mitigate the effect of libcurl looking
@@ -239,11 +184,11 @@ void LLURLRequest::useProxy(bool use_proxy)
 
     if (env_proxy && use_proxy)
     {
-        curl_easy_setopt(mDetail->mCurl, CURLOPT_PROXY, env_proxy);
+		mDetail->mCurlRequest->setoptString(CURLOPT_PROXY, env_proxy);
     }
     else
     {
-        curl_easy_setopt(mDetail->mCurl, CURLOPT_PROXY, "");
+        mDetail->mCurlRequest->setoptString(CURLOPT_PROXY, "");
     }
 }
 
@@ -309,27 +254,20 @@ LLIOPipe::EStatus LLURLRequest::process_impl(
 	case STATE_PROCESSING_RESPONSE:
 	{
 		PUMP_DEBUG;
-		const S32 MAX_CALLS = 5;
-		S32 count = MAX_CALLS;
-		CURLMcode code;
 		LLIOPipe::EStatus status = STATUS_BREAK;
-		S32 queue;
-		do
-		{
-			LLFastTimer t2(LLFastTimer::FTM_CURL);
-			code = curl_multi_perform(mDetail->mCurlMulti, &queue);			
-		}while((CURLM_CALL_MULTI_PERFORM == code) && (queue > 0) && count--);
-		CURLMsg* curl_msg;
-		do
+		mDetail->mCurlRequest->perform();
+		while(1)
 		{
-			curl_msg = curl_multi_info_read(mDetail->mCurlMulti, &queue);
-			if(curl_msg && (curl_msg->msg == CURLMSG_DONE))
+			CURLcode result;
+			bool newmsg = mDetail->mCurlRequest->getResult(&result);
+			if (!newmsg)
 			{
-				mState = STATE_HAVE_RESPONSE;
+				break;
+			}
 
-				CURLcode result = curl_msg->data.result;
-				switch(result)
-				{
+			mState = STATE_HAVE_RESPONSE;
+			switch(result)
+			{
 				case CURLE_OK:
 				case CURLE_WRITE_ERROR:
 					// NB: The error indication means that we stopped the
@@ -352,31 +290,21 @@ LLIOPipe::EStatus LLURLRequest::process_impl(
 						mCompletionCallback = NULL;
 					}
 					break;
+				case CURLE_FAILED_INIT:
 				case CURLE_COULDNT_CONNECT:
 					status = STATUS_NO_CONNECTION;
 					break;
 				default:
-					llwarns << "URLRequest Error: " << curl_msg->data.result
+					llwarns << "URLRequest Error: " << result
 							<< ", "
-#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.
-							<< curl_msg->data.result
-#else // LL_DARWIN
-							<< curl_easy_strerror(curl_msg->data.result)
-#endif // LL_DARWIN
+							<< LLCurl::strerror(result)
 							<< ", "
-							<< (mDetail->mURL ? mDetail->mURL : "<EMPTY URL>")
+							<< (mDetail->mURL.empty() ? "<EMPTY URL>" : mDetail->mURL)
 							<< llendl;
 					status = STATUS_ERROR;
 					break;
-				}
-				curl_multi_remove_handle(mDetail->mCurlMulti, mDetail->mCurl);
-				mDetail->mNeedToRemoveEasyHandle = false;
 			}
-		}while(curl_msg && (queue > 0));
+		}
 		return status;
 	}
 	case STATE_HAVE_RESPONSE:
@@ -397,26 +325,9 @@ void LLURLRequest::initialize()
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
 	mState = STATE_INITIALIZED;
 	mDetail = new LLURLRequestDetail;
-	mDetail->mCurl = curl_easy_init();
-	mDetail->mCurlMulti = curl_multi_init();
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_NOSIGNAL, 1);
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_WRITEFUNCTION, &downCallback);
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_WRITEDATA, this);
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_READFUNCTION, &upCallback);
-	curl_easy_setopt(mDetail->mCurl, CURLOPT_READDATA, this);
-	curl_easy_setopt(
-		mDetail->mCurl,
-		CURLOPT_ERRORBUFFER,
-		mDetail->mCurlErrorBuf);
-
-	if(sCAPath != std::string(""))
-	{
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_CAPATH, sCAPath.c_str());
-	}
-	if(sCAFile != std::string(""))
-	{
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_CAINFO, sCAFile.c_str());
-	}
+	mDetail->mCurlRequest->setopt(CURLOPT_NOSIGNAL, 1);
+	mDetail->mCurlRequest->setWriteCallback(&downCallback, (void*)this);
+	mDetail->mCurlRequest->setReadCallback(&upCallback, (void*)this);
 }
 
 bool LLURLRequest::configure()
@@ -429,13 +340,14 @@ bool LLURLRequest::configure()
 	switch(mAction)
 	{
 	case HTTP_HEAD:
-		// These are in addition to the HTTP_GET options.
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_HEADER, 1);
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_NOBODY, 1);
-		
+		mDetail->mCurlRequest->setopt(CURLOPT_HEADER, 1);
+		mDetail->mCurlRequest->setopt(CURLOPT_NOBODY, 1);
+		mDetail->mCurlRequest->setopt(CURLOPT_FOLLOWLOCATION, 1);
+		rv = true;
+		break;
 	case HTTP_GET:
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_HTTPGET, 1);
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_FOLLOWLOCATION, 1);
+		mDetail->mCurlRequest->setopt(CURLOPT_HTTPGET, 1);
+		mDetail->mCurlRequest->setopt(CURLOPT_FOLLOWLOCATION, 1);
 		rv = true;
 		break;
 
@@ -444,8 +356,8 @@ bool LLURLRequest::configure()
 		// to turning this on, and I am not too sure what it means.
 		addHeader("Expect:");
 
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_UPLOAD, 1);
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_INFILESIZE, bytes);
+		mDetail->mCurlRequest->setopt(CURLOPT_UPLOAD, 1);
+		mDetail->mCurlRequest->setopt(CURLOPT_INFILESIZE, bytes);
 		rv = true;
 		break;
 
@@ -459,15 +371,13 @@ bool LLURLRequest::configure()
 		addHeader("Content-Type:");
 
 		// Set the handle for an http post
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_POST, 1);
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_POSTFIELDS, NULL);
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_POSTFIELDSIZE, bytes);
+		mDetail->mCurlRequest->setPost(NULL, bytes);
 		rv = true;
 		break;
 
 	case HTTP_DELETE:
 		// Set the handle for an http post
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_CUSTOMREQUEST, "DELETE");
+		mDetail->mCurlRequest->setoptString(CURLOPT_CUSTOMREQUEST, "DELETE");
 		rv = true;
 		break;
 
@@ -477,24 +387,14 @@ bool LLURLRequest::configure()
 	}
 	if(rv)
 	{
-		if(mDetail->mHeaders)
-		{
-			curl_easy_setopt(
-				mDetail->mCurl,
-				CURLOPT_HTTPHEADER,
-				mDetail->mHeaders);
-		}
-		curl_easy_setopt(mDetail->mCurl, CURLOPT_URL, mDetail->mURL);
-		lldebugs << "URL: " << mDetail->mURL << llendl;
-		curl_multi_add_handle(mDetail->mCurlMulti, mDetail->mCurl);
-		mDetail->mNeedToRemoveEasyHandle = true;
+		mDetail->mCurlRequest->sendRequest(mDetail->mURL);
 	}
 	return rv;
 }
 
 // static
 size_t LLURLRequest::downCallback(
-	void* data,
+	char* data,
 	size_t size,
 	size_t nmemb,
 	void* user)
@@ -528,7 +428,7 @@ size_t LLURLRequest::downCallback(
 
 // static
 size_t LLURLRequest::upCallback(
-	void* data,
+	char* data,
 	size_t size,
 	size_t nmemb,
 	void* user)
@@ -548,8 +448,7 @@ size_t LLURLRequest::upCallback(
 	return bytes;
 }
 
-static
-size_t headerCallback(void* data, size_t size, size_t nmemb, void* user)
+static size_t headerCallback(void* data, size_t size, size_t nmemb, void* user)
 {
 	const char* headerLine = (const char*)data;
 	size_t headerLen = size * nmemb;
@@ -605,18 +504,6 @@ size_t headerCallback(void* data, size_t size, size_t nmemb, void* user)
 	return headerLen;
 }
 
-//static 
-void LLURLRequest::setCertificateAuthorityFile(const std::string& file_name)
-{
-	sCAFile = file_name;
-}
-
-//static 
-void LLURLRequest::setCertificateAuthorityPath(const std::string& path)
-{
-	sCAPath = path;
-}
-
 /**
  * LLContextURLExtractor
  */
diff --git a/indra/llmessage/llurlrequest.h b/indra/llmessage/llurlrequest.h
index 5bdb6a1e69..b154794ff1 100644
--- a/indra/llmessage/llurlrequest.h
+++ b/indra/llmessage/llurlrequest.h
@@ -129,18 +129,8 @@ public:
 	 *
 	 * Set whether request will check that remote server
 	 * certificates are signed by a known root CA when using HTTPS.
-	 * Use the supplied root certificate bundle if supplied, else use
-	 * the standard bundle as found by libcurl and openssl.
 	 */
-	void checkRootCertificate(bool check, const char* caBundle = NULL);
-
-	/** 
-	 * @brief Request a particular response encoding if available.
-	 *
-	 * This call is a shortcut for requesting a particular encoding
-	 * from the server, eg, 'gzip'. 
-	 */
-	void requestEncoding(const char* encoding);
+	void checkRootCertificate(bool check);
 
 	/**
 	 * @brief Return at most size bytes of body.
@@ -168,16 +158,6 @@ public:
 	void setCallback(LLURLRequestComplete* callback);
 	//@}
 
-	/**
-	 * @ brief Set certificate authority file used to verify HTTPS certs.
-	 */
-	static void setCertificateAuthorityFile(const std::string& file_name);
-
-	/**
-	 * @ brief Set certificate authority path used to verify HTTPS certs.
-	 */
-	static void setCertificateAuthorityPath(const std::string& path);
-
 	/* @name LLIOPipe virtual implementations
 	 */
 
@@ -234,7 +214,7 @@ private:
 	 * @brief Download callback method.
 	 */
  	static size_t downCallback(
-		void* data,
+		char* data,
 		size_t size,
 		size_t nmemb,
 		void* user);
@@ -243,7 +223,7 @@ private:
 	 * @brief Upload callback method.
 	 */
  	static size_t upCallback(
-		void* data,
+		char* data,
 		size_t size,
 		size_t nmemb,
 		void* user);