Merge pull from vir/drano

14 files changed, 725 insertions, 52 deletions

diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 0f40a670fa..d98781e9e6 100644
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -254,6 +254,14 @@ if (LL_TESTS)
     "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_llsdmessage_peer.py"
     )
 
+  LL_ADD_INTEGRATION_TEST(
+    llhttpclient
+    "llhttpclient.cpp"
+    "${test_libs}"
+    ${PYTHON_EXECUTABLE}
+    "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_llsdmessage_peer.py"
+    )
+
   LL_ADD_INTEGRATION_TEST(llavatarnamecache "" "${test_libs}")
   LL_ADD_INTEGRATION_TEST(llhost "" "${test_libs}")
   LL_ADD_INTEGRATION_TEST(llpartdata "" "${test_libs}")
diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp
index 97f2792686..fbc3cc6de2 100644
--- a/indra/llmessage/llavatarnamecache.cpp
+++ b/indra/llmessage/llavatarnamecache.cpp
@@ -87,6 +87,9 @@ namespace LLAvatarNameCache
     /// Time when unrefreshed cached names were checked last
     static F64 sLastExpireCheck;
 
+	/// Time-to-live for a temp cache entry.
+	const F64 TEMP_CACHE_ENTRY_LIFETIME = 60.0;
+
 	//-----------------------------------------------------------------------
 	// Internal methods
 	//-----------------------------------------------------------------------
@@ -274,7 +277,7 @@ void LLAvatarNameCache::handleAgentError(const LLUUID& agent_id)
     {
         // there is no existing cache entry, so make a temporary name from legacy
         LL_WARNS("AvNameCache") << "LLAvatarNameCache get legacy for agent "
-                                << agent_id << LL_ENDL;
+								<< agent_id << LL_ENDL;
         gCacheName->get(agent_id, false,  // legacy compatibility
                         boost::bind(&LLAvatarNameCache::legacyNameCallback,
                                     _1, _2, _3));
@@ -287,13 +290,14 @@ void LLAvatarNameCache::handleAgentError(const LLUUID& agent_id)
         // Clear this agent from the pending list
         LLAvatarNameCache::sPendingQueue.erase(agent_id);
 
-        const LLAvatarName& av_name = existing->second;
+        LLAvatarName& av_name = existing->second;
         LL_DEBUGS("AvNameCache") << "LLAvatarNameCache use cache for agent "
                                  << agent_id 
                                  << "user '" << av_name.mUsername << "' "
                                  << "display '" << av_name.mDisplayName << "' "
                                  << "expires in " << av_name.mExpires - LLFrameTimer::getTotalSeconds() << " seconds"
                                  << LL_ENDL;
+		av_name.mExpires = LLFrameTimer::getTotalSeconds() + TEMP_CACHE_ENTRY_LIFETIME; // reset expiry time so we don't constantly rerequest.
     }
 }
 
@@ -402,10 +406,12 @@ void LLAvatarNameCache::legacyNameCallback(const LLUUID& agent_id,
 							 << LL_ENDL;
 	buildLegacyName(full_name, &av_name);
 
-	// Don't add to cache, the data already exists in the legacy name system
-	// cache and we don't want or need duplicate storage, because keeping the
-	// two copies in sync is complex.
-	processName(agent_id, av_name, false);
+	// Add to cache, because if we don't we'll keep rerequesting the
+	// same record forever.  buildLegacyName should always guarantee
+	// that these records expire reasonably soon
+	// (in TEMP_CACHE_ENTRY_LIFETIME seconds), so if the failure was due
+	// to something temporary we will eventually request and get the right data.
+	processName(agent_id, av_name, true);
 }
 
 void LLAvatarNameCache::requestNamesViaLegacy()
@@ -583,7 +589,7 @@ void LLAvatarNameCache::buildLegacyName(const std::string& full_name,
 	av_name->mDisplayName = full_name;
 	av_name->mIsDisplayNameDefault = true;
 	av_name->mIsTemporaryName = true;
-	av_name->mExpires = F64_MAX; // not used because these are not cached
+	av_name->mExpires = LLFrameTimer::getTotalSeconds() + TEMP_CACHE_ENTRY_LIFETIME;
 	LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::buildLegacyName "
 							 << full_name
 							 << LL_ENDL;
diff --git a/indra/llmessage/llcurl.cpp b/indra/llmessage/llcurl.cpp
index 3bcaffc275..4cfa48cbd9 100644
--- a/indra/llmessage/llcurl.cpp
+++ b/indra/llmessage/llcurl.cpp
@@ -271,10 +271,10 @@ void LLCurl::Easy::releaseEasyHandle(CURL* handle)
 
 		if(sFreeHandles.size() < MAX_NUM_FREE_HANDLES)
 		{
-			sFreeHandles.insert(handle);
-		}
-		else
-		{
+		sFreeHandles.insert(handle);
+	}
+	else
+	{
 			LLCurl::deleteEasyHandle(handle) ;
 		}
 	}
@@ -453,9 +453,9 @@ size_t curlReadCallback(char* data, size_t size, size_t nmemb, void* user_data)
 	LLCurl::Easy* easy = (LLCurl::Easy*)user_data;
 	
 	S32 n = size * nmemb;
-	S32 startpos = easy->getInput().tellg();
+	S32 startpos = (S32)easy->getInput().tellg();
 	easy->getInput().seekg(0, std::ios::end);
-	S32 endpos = easy->getInput().tellg();
+	S32 endpos = (S32)easy->getInput().tellg();
 	easy->getInput().seekg(startpos, std::ios::beg);
 	S32 maxn = endpos - startpos;
 	n = llmin(n, maxn);
@@ -560,16 +560,16 @@ LLCurl::Multi::Multi(F32 idle_time_out)
 	}
 	
 	//llassert_always(mCurlMultiHandle);	
-	
+
 	if(mCurlMultiHandle)
 	{
-		if(LLCurl::getCurlThread()->getThreaded())
-		{
-			mMutexp = new LLMutex(NULL) ;
-			mDeletionMutexp = new LLMutex(NULL) ;
-			mEasyMutexp = new LLMutex(NULL) ;
-		}
-		LLCurl::getCurlThread()->addMulti(this) ;
+	if(LLCurl::getCurlThread()->getThreaded())
+	{
+		mMutexp = new LLMutex(NULL) ;
+		mDeletionMutexp = new LLMutex(NULL) ;
+		mEasyMutexp = new LLMutex(NULL) ;
+	}
+	LLCurl::getCurlThread()->addMulti(this) ;
 
 		mIdleTimeOut = idle_time_out ;
 		if(mIdleTimeOut < LLCurl::sCurlRequestTimeOut)
@@ -577,8 +577,8 @@ LLCurl::Multi::Multi(F32 idle_time_out)
 			mIdleTimeOut = LLCurl::sCurlRequestTimeOut ;
 		}
 
-		++gCurlMultiCount;
-	}
+	++gCurlMultiCount;
+}
 }
 
 LLCurl::Multi::~Multi()
@@ -617,7 +617,7 @@ void LLCurl::Multi::cleanup()
 	mDeletionMutexp = NULL ;
 	delete mEasyMutexp ;
 	mEasyMutexp = NULL ;
-	
+
 	mQueued = 0 ;
 	mState = STATE_COMPLETED;
 	
@@ -738,7 +738,7 @@ bool LLCurl::Multi::doPerform()
 		}
 
 		mQueued = q;	
-		setState(STATE_COMPLETED) ;		
+		setState(STATE_COMPLETED) ;
 		mIdleTimer.reset() ;
 	}
 	else if(mIdleTimer.getElapsedTimeF32() > mIdleTimeOut) //idle for too long, remove it.
@@ -1033,7 +1033,7 @@ void LLCurlRequest::addMulti()
 		mActiveRequestCount = 0 ;
 		return;
 	}
-
+	
 	mMultiSet.insert(multi);
 	mActiveMulti = multi;
 	mActiveRequestCount = 0;
@@ -1074,7 +1074,9 @@ void LLCurlRequest::get(const std::string& url, LLCurl::ResponderPtr responder)
 {
 	getByteRange(url, headers_t(), 0, -1, responder);
 }
-	
+
+// Note: (length==0) is interpreted as "the rest of the file", i.e. the whole file if (offset==0) or
+// the remainder of the file if not.
 bool LLCurlRequest::getByteRange(const std::string& url,
 								 const headers_t& headers,
 								 S32 offset, S32 length,
@@ -1092,6 +1094,11 @@ bool LLCurlRequest::getByteRange(const std::string& url,
 		std::string range = llformat("Range: bytes=%d-%d", offset,offset+length-1);
 		easy->slist_append(range.c_str());
 	}
+	else if (offset > 0)
+	{
+		std::string range = llformat("Range: bytes=%d-", offset);
+		easy->slist_append(range.c_str());
+	}
 	easy->setHeaders();
 	bool res = addEasy(easy);
 	return res;
@@ -1217,6 +1224,208 @@ S32 LLCurlRequest::getQueued()
 	return queued;
 }
 
+LLCurlTextureRequest::LLCurlTextureRequest(S32 concurrency) : 
+	LLCurlRequest(), 
+	mConcurrency(concurrency),
+	mInQueue(0),
+	mMutex(NULL),
+	mHandleCounter(1),
+	mTotalIssuedRequests(0),
+	mTotalReceivedBits(0)
+{
+	mGlobalTimer.reset();
+}
+
+LLCurlTextureRequest::~LLCurlTextureRequest()
+{
+	mRequestMap.clear();
+
+	for(req_queue_t::iterator iter = mCachedRequests.begin(); iter != mCachedRequests.end(); ++iter)
+	{
+		delete *iter;
+	}
+	mCachedRequests.clear();
+}
+
+//return 0: success
+// > 0: cached handle
+U32 LLCurlTextureRequest::getByteRange(const std::string& url,
+								 const headers_t& headers,
+								 S32 offset, S32 length, U32 pri,
+								 LLCurl::ResponderPtr responder, F32 delay_time)
+{
+	U32 ret_val = 0;
+	bool success = false;	
+
+	if(mInQueue < mConcurrency && delay_time < 0.f)
+	{
+		success = LLCurlRequest::getByteRange(url, headers, offset, length, responder);		
+	}
+
+	LLMutexLock lock(&mMutex);
+
+	if(success)
+	{
+		mInQueue++;
+		mTotalIssuedRequests++;
+	}
+	else
+	{
+		request_t* request = new request_t(mHandleCounter, url, headers, offset, length, pri, responder);
+		if(delay_time > 0.f)
+		{
+			request->mStartTime = mGlobalTimer.getElapsedTimeF32() + delay_time;
+		}
+
+		mCachedRequests.insert(request);
+		mRequestMap[mHandleCounter] = request;
+		ret_val = mHandleCounter;
+		mHandleCounter++;
+
+		if(!mHandleCounter)
+		{
+			mHandleCounter = 1;
+		}
+	}
+
+	return ret_val;
+}
+
+void LLCurlTextureRequest::completeRequest(S32 received_bytes)
+{
+	LLMutexLock lock(&mMutex);
+
+	llassert_always(mInQueue > 0);
+
+	mInQueue--;
+	mTotalReceivedBits += received_bytes * 8;
+}
+
+void LLCurlTextureRequest::nextRequests()
+{
+	if(mCachedRequests.empty() || mInQueue >= mConcurrency)
+	{
+		return;
+	}
+
+	F32 cur_time = mGlobalTimer.getElapsedTimeF32();
+
+	req_queue_t::iterator iter;	
+	{
+		LLMutexLock lock(&mMutex);
+		iter = mCachedRequests.begin();
+	}
+	while(1)
+	{
+		request_t* request = *iter;
+		if(request->mStartTime < cur_time)
+		{
+			if(!LLCurlRequest::getByteRange(request->mUrl, request->mHeaders, request->mOffset, request->mLength, request->mResponder))
+			{
+				break;
+			}
+
+			LLMutexLock lock(&mMutex);
+			++iter;
+			mInQueue++;
+			mTotalIssuedRequests++;
+			mCachedRequests.erase(request);
+			mRequestMap.erase(request->mHandle);
+			delete request;
+
+			if(iter == mCachedRequests.end() || mInQueue >= mConcurrency)
+			{
+				break;
+			}
+		}
+		else
+		{
+			LLMutexLock lock(&mMutex);
+			++iter;
+			if(iter == mCachedRequests.end() || mInQueue >= mConcurrency)
+			{
+				break;
+			}
+		}
+	}
+
+	return;
+}
+
+void LLCurlTextureRequest::updatePriority(U32 handle, U32 pri)
+{
+	if(!handle)
+	{
+		return;
+	}
+
+	LLMutexLock lock(&mMutex);
+
+	std::map<S32, request_t*>::iterator iter = mRequestMap.find(handle);
+	if(iter != mRequestMap.end())
+	{
+		request_t* req = iter->second;
+		
+		if(req->mPriority != pri)
+		{
+			mCachedRequests.erase(req);
+			req->mPriority = pri;
+			mCachedRequests.insert(req);
+		}
+	}
+}
+
+void LLCurlTextureRequest::removeRequest(U32 handle)
+{
+	if(!handle)
+	{
+		return;
+	}
+
+	LLMutexLock lock(&mMutex);
+
+	std::map<S32, request_t*>::iterator iter = mRequestMap.find(handle);
+	if(iter != mRequestMap.end())
+	{
+		request_t* req = iter->second;
+		mRequestMap.erase(iter);
+		mCachedRequests.erase(req);
+		delete req;
+	}
+}
+
+bool LLCurlTextureRequest::isWaiting(U32 handle)
+{
+	if(!handle)
+	{
+		return false;
+	}
+
+	LLMutexLock lock(&mMutex);
+	return mRequestMap.find(handle) != mRequestMap.end();
+}
+
+U32 LLCurlTextureRequest::getTotalReceivedBits()
+{
+	LLMutexLock lock(&mMutex);
+
+	U32 bits = mTotalReceivedBits;
+	mTotalReceivedBits = 0;
+	return bits;
+}
+
+U32 LLCurlTextureRequest::getTotalIssuedRequests()
+{
+	LLMutexLock lock(&mMutex);
+	return mTotalIssuedRequests;
+}
+
+S32 LLCurlTextureRequest::getNumRequests()
+{
+	LLMutexLock lock(&mMutex);
+	return mInQueue;
+}
+
 ////////////////////////////////////////////////////////////////////////////
 // For generating one easy request
 // associated with a single multi request
@@ -1229,15 +1438,15 @@ LLCurlEasyRequest::LLCurlEasyRequest()
 	
 	if(mMulti->isValid())
 	{
-		mEasy = mMulti->allocEasy();
-		if (mEasy)
-		{
-			mEasy->setErrorBuffer();
-			mEasy->setCA();
-			// Set proxy settings if configured to do so.
-			LLProxy::getInstance()->applyProxySettings(mEasy);
-		}
+	mEasy = mMulti->allocEasy();
+	if (mEasy)
+	{
+		mEasy->setErrorBuffer();
+		mEasy->setCA();
+		// Set proxy settings if configured to do so.
+		LLProxy::getInstance()->applyProxySettings(mEasy);
 	}
+}
 	else
 	{
 		LLCurl::getCurlThread()->killMulti(mMulti) ;
@@ -1506,7 +1715,8 @@ void LLCurl::cleanupClass()
 	delete sHandleMutexp ;
 	sHandleMutexp = NULL ;
 
-	llassert(Easy::sActiveHandles.empty());
+	// removed as per https://jira.secondlife.com/browse/SH-3115
+	//llassert(Easy::sActiveHandles.empty());
 }
 
 //static 
diff --git a/indra/llmessage/llcurl.h b/indra/llmessage/llcurl.h
index fd664c0fa1..87cb192141 100644
--- a/indra/llmessage/llcurl.h
+++ b/indra/llmessage/llcurl.h
@@ -413,6 +413,71 @@ private:
 	BOOL mProcessing;
 };
 
+//for texture fetch only
+class LLCurlTextureRequest : public LLCurlRequest
+{
+public:
+	LLCurlTextureRequest(S32 concurrency);
+	~LLCurlTextureRequest();
+
+	U32 getByteRange(const std::string& url, const headers_t& headers, S32 offset, S32 length, U32 pri, LLCurl::ResponderPtr responder, F32 delay_time = -1.f);
+	void nextRequests();
+	void completeRequest(S32 received_bytes);
+
+	void updatePriority(U32 handle, U32 pri);
+	void removeRequest(U32 handle);
+
+	U32 getTotalReceivedBits();
+	U32 getTotalIssuedRequests();
+	S32 getNumRequests();
+	bool isWaiting(U32 handle);
+	
+private:
+	LLMutex mMutex;
+	S32 mConcurrency;
+	S32 mInQueue; //request currently in queue.
+	U32 mHandleCounter;
+	U32 mTotalIssuedRequests;
+	U32 mTotalReceivedBits;
+
+	typedef struct _request_t
+	{
+		_request_t(U32 handle, const std::string& url, const headers_t& headers, S32 offset, S32 length, U32 pri, LLCurl::ResponderPtr responder) :
+				mHandle(handle), mUrl(url), mHeaders(headers), mOffset(offset), mLength(length), mPriority(pri), mResponder(responder), mStartTime(0.f)
+				{}
+
+		U32  mHandle;
+		std::string mUrl;
+		LLCurlRequest::headers_t mHeaders;
+		S32 mOffset;
+		S32 mLength;
+		LLCurl::ResponderPtr mResponder;
+		U32 mPriority;
+		F32 mStartTime; //start time to issue this request
+	} request_t;
+
+	struct request_compare
+	{
+		bool operator()(const request_t* lhs, const request_t* rhs) const
+		{
+			if(lhs->mPriority != rhs->mPriority)
+			{
+				return lhs->mPriority > rhs->mPriority; // higher priority in front of queue (set)
+			}
+			else
+			{
+				return (U32)lhs < (U32)rhs;
+			}
+		}
+	};
+
+	typedef std::set<request_t*, request_compare> req_queue_t;
+	req_queue_t mCachedRequests;
+	std::map<S32, request_t*> mRequestMap;
+
+	LLFrameTimer mGlobalTimer;
+};
+
 class LLCurlEasyRequest
 {
 public:
diff --git a/indra/llmessage/llhttpclient.cpp b/indra/llmessage/llhttpclient.cpp
index 231cb7ca8f..0c325a68aa 100644
--- a/indra/llmessage/llhttpclient.cpp
+++ b/indra/llmessage/llhttpclient.cpp
@@ -158,7 +158,7 @@ namespace
 			if(fstream.is_open())
 			{
 				fstream.seekg(0, std::ios::end);
-				U32 fileSize = fstream.tellg();
+				U32 fileSize = (U32)fstream.tellg();
 				fstream.seekg(0, std::ios::beg);
 				std::vector<char> fileBuffer(fileSize);
 				fstream.read(&fileBuffer[0], fileSize);
diff --git a/indra/llmessage/llmime.cpp b/indra/llmessage/llmime.cpp
index 943a734927..9d9c4ebd68 100644
--- a/indra/llmessage/llmime.cpp
+++ b/indra/llmessage/llmime.cpp
@@ -388,7 +388,7 @@ bool LLMimeParser::Impl::parseHeaders(
 		// not to read past limit when we get() the newline.
 		S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
 		istr.getline(mBuffer, max_get, '\r');
-		mScanCount += istr.gcount();
+		mScanCount += (S32)istr.gcount();
 		int c = istr.get();
 		if(EOF == c)
 		{
@@ -496,7 +496,7 @@ void LLMimeParser::Impl::scanPastSeparator(
 		// past limit when we get() the newline.
 		S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
 		istr.getline(mBuffer, max_get, '\r');
-		mScanCount += istr.gcount();
+		mScanCount += (S32)istr.gcount();
 		if(istr.gcount() >= LINE_BUFFER_LENGTH - 1)
 		{
 			// that's way too long to be a separator, so ignore it.
diff --git a/indra/llmessage/llsdmessage.cpp b/indra/llmessage/llsdmessage.cpp
index 9148c9dd15..1c93c12d99 100644
--- a/indra/llmessage/llsdmessage.cpp
+++ b/indra/llmessage/llsdmessage.cpp
@@ -88,7 +88,7 @@ bool LLSDMessage::httpListener(const LLSD& request)
                                                        request,
                                                        url, "POST", reply, error),
                        LLSD(),      // headers
-                       timeout);
+                       (F32)timeout);
     return false;
 }
 
diff --git a/indra/llmessage/llsdmessagebuilder.cpp b/indra/llmessage/llsdmessagebuilder.cpp
index 2698a271ee..615221e0ad 100644
--- a/indra/llmessage/llsdmessagebuilder.cpp
+++ b/indra/llmessage/llsdmessagebuilder.cpp
@@ -317,7 +317,7 @@ void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data)
 
 			// S64 not supported in LLSD so we just truncate it
 			case MVT_S64:
-				addS32(varname, *(S64*)mvci.getData());
+				addS32(varname, (S32)*(S64*)mvci.getData());
 				break;
 
 			case MVT_F32:
diff --git a/indra/llmessage/llxfer.h b/indra/llmessage/llxfer.h
index 989e8b2cab..f9348eb11f 100644
--- a/indra/llmessage/llxfer.h
+++ b/indra/llmessage/llxfer.h
@@ -29,6 +29,7 @@
 
 #include "message.h"
 #include "lltimer.h"
+#include "llextendedstatus.h"
 
 const S32 LL_XFER_LARGE_PAYLOAD = 7680;
 
diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp
index d0b0e178b8..6a425cfe98 100644
--- a/indra/llmessage/message.cpp
+++ b/indra/llmessage/message.cpp
@@ -3147,7 +3147,7 @@ bool LLMessageSystem::generateDigestForWindowAndUUIDs(char* digest, const S32 wi
 		LL_ERRS("Messaging") << "Trying to generate complex digest on a machine without a shared secret!" << llendl;
 	}
 
-	U32 now = time(NULL);
+	U32 now = (U32)time(NULL);
 
 	now /= window;
 
@@ -3167,7 +3167,7 @@ bool LLMessageSystem::isMatchingDigestForWindowAndUUIDs(const char* digest, cons
 	}
 	
 	char our_digest[MD5HEX_STR_SIZE];	/* Flawfinder: ignore */
-	U32 now = time(NULL);
+	U32 now = (U32)time(NULL);
 
 	now /= window;
 
@@ -3213,7 +3213,7 @@ bool LLMessageSystem::generateDigestForWindow(char* digest, const S32 window) co
 		LL_ERRS("Messaging") << "Trying to generate simple digest on a machine without a shared secret!" << llendl;
 	}
 
-	U32 now = time(NULL);
+	U32 now = (U32)time(NULL);
 
 	now /= window;
 
diff --git a/indra/llmessage/tests/llhttpclient_test.cpp b/indra/llmessage/tests/llhttpclient_test.cpp
new file mode 100644
index 0000000000..843c3bcc4b
--- /dev/null
+++ b/indra/llmessage/tests/llhttpclient_test.cpp
@@ -0,0 +1,376 @@
+/** 
+ * @file llhttpclient_test.cpp
+ * @brief Testing the HTTP client classes.
+ *
+ * $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$
+ */
+
+/**
+ *
+ * These classes test the HTTP client framework.
+ *
+ */
+
+#include <tut/tut.hpp>
+#include "linden_common.h"
+
+#include "lltut.h"
+#include "llhttpclient.h"
+#include "llformat.h"
+#include "llpipeutil.h"
+#include "llproxy.h"
+#include "llpumpio.h"
+
+#include "llsdhttpserver.h"
+#include "lliohttpserver.h"
+#include "lliosocket.h"
+#include "stringize.h"
+
+namespace tut
+{
+	LLSD storage;
+	
+	class LLSDStorageNode : public LLHTTPNode
+	{
+	public:
+		LLSD simpleGet() const					{ return storage; }
+		LLSD simplePut(const LLSD& value) const	{ storage = value; return LLSD(); }
+	};
+
+	class ErrorNode : public LLHTTPNode
+	{
+	public:
+		void get(ResponsePtr r, const LLSD& context) const
+			{ r->status(599, "Intentional error"); }
+		void post(ResponsePtr r, const LLSD& context, const LLSD& input) const
+			{ r->status(input["status"], input["reason"]); }
+	};
+
+	class TimeOutNode : public LLHTTPNode
+	{
+	public:
+		void get(ResponsePtr r, const LLSD& context) const
+		{
+            /* do nothing, the request will eventually time out */ 
+		}
+	};
+
+	LLHTTPRegistration<LLSDStorageNode> gStorageNode("/test/storage");
+	LLHTTPRegistration<ErrorNode>		gErrorNode("/test/error");
+	LLHTTPRegistration<TimeOutNode>		gTimeOutNode("/test/timeout");
+
+	struct HTTPClientTestData
+	{
+	public:
+		HTTPClientTestData():
+			local_server(STRINGIZE("http://127.0.0.1:" << getenv("PORT") << "/"))
+		{
+			apr_pool_create(&mPool, NULL);
+			LLCurl::initClass(false);
+			mServerPump = new LLPumpIO(mPool);
+			mClientPump = new LLPumpIO(mPool);
+
+			LLHTTPClient::setPump(*mClientPump);
+		}
+		
+		~HTTPClientTestData()
+		{
+			delete mServerPump;
+			delete mClientPump;
+			LLProxy::cleanupClass();
+			apr_pool_destroy(mPool);
+		}
+
+		void setupTheServer()
+		{
+			LLHTTPNode& root = LLIOHTTPServer::create(mPool, *mServerPump, 8888);
+
+			LLHTTPStandardServices::useServices();
+			LLHTTPRegistrar::buildAllServices(root);
+		}
+		
+		void runThePump(float timeout = 100.0f)
+		{
+			LLTimer timer;
+			timer.setTimerExpirySec(timeout);
+
+			while(!mSawCompleted && !mSawCompletedHeader && !timer.hasExpired())
+			{
+				if (mServerPump)
+				{
+					mServerPump->pump();
+					mServerPump->callback();
+				}
+				if (mClientPump)
+				{
+					mClientPump->pump();
+					mClientPump->callback();
+				}
+			}
+		}
+
+		void killServer()
+		{
+			delete mServerPump;
+			mServerPump = NULL;
+		}
+
+		const std::string local_server;
+
+	private:
+		apr_pool_t* mPool;
+		LLPumpIO* mServerPump;
+		LLPumpIO* mClientPump;
+
+	protected:
+		void ensureStatusOK()
+		{
+			if (mSawError)
+			{
+				std::string msg =
+					llformat("error() called when not expected, status %d",
+						mStatus); 
+				fail(msg);
+			}
+		}
+	
+		void ensureStatusError()
+		{
+			if (!mSawError)
+			{
+				fail("error() wasn't called");
+			}
+		}
+		
+		LLSD getResult()
+		{
+			return mResult;
+		}
+		LLSD getHeader()
+		{
+			return mHeader;
+		}
+	
+	protected:
+		bool mSawError;
+		U32 mStatus;
+		std::string mReason;
+		bool mSawCompleted;
+		bool mSawCompletedHeader;
+		LLSD mResult;
+		LLSD mHeader;
+		bool mResultDeleted;
+
+		class Result : public LLHTTPClient::Responder
+		{
+		protected:
+			Result(HTTPClientTestData& client)
+				: mClient(client)
+			{
+			}
+		
+		public:
+			static boost::intrusive_ptr<Result> build(HTTPClientTestData& client)
+			{
+				return boost::intrusive_ptr<Result>(new Result(client));
+			}
+			
+			~Result()
+			{
+				mClient.mResultDeleted = true;
+			}
+			
+			virtual void error(U32 status, const std::string& reason)
+			{
+				mClient.mSawError = true;
+				mClient.mStatus = status;
+				mClient.mReason = reason;
+			}
+
+			virtual void result(const LLSD& content)
+			{
+				mClient.mResult = content;
+			}
+
+			virtual void completed(
+							U32 status, const std::string& reason,
+							const LLSD& content)
+			{
+				LLHTTPClient::Responder::completed(status, reason, content);
+				
+				mClient.mSawCompleted = true;
+			}
+
+			virtual void completedHeader(
+				U32 status, const std::string& reason,
+				const LLSD& content)
+			{
+				mClient.mHeader = content;
+				mClient.mSawCompletedHeader = true;
+			}
+
+		private:
+			HTTPClientTestData& mClient;
+		};
+
+		friend class Result;
+
+	protected:
+		LLHTTPClient::ResponderPtr newResult()
+		{
+			mSawError = false;
+			mStatus = 0;
+			mSawCompleted = false;
+			mSawCompletedHeader = false;
+			mResult.clear();
+			mHeader.clear();
+			mResultDeleted = false;
+			
+			return Result::build(*this);
+		}
+	};
+	
+	
+	typedef test_group<HTTPClientTestData>	HTTPClientTestGroup;
+	typedef HTTPClientTestGroup::object		HTTPClientTestObject;
+	HTTPClientTestGroup httpClientTestGroup("http_client");
+
+	template<> template<>
+	void HTTPClientTestObject::test<1>()
+	{
+		LLHTTPClient::get(local_server, newResult());
+		runThePump();
+		ensureStatusOK();
+		ensure("result object wasn't destroyed", mResultDeleted);
+	}
+
+	template<> template<>
+	void HTTPClientTestObject::test<2>()
+	{
+		// Please nobody listen on this particular port...
+		LLHTTPClient::get("http://127.0.0.1:7950", newResult());
+		runThePump();
+		ensureStatusError();
+	}
+
+	template<> template<>
+		void HTTPClientTestObject::test<3>()
+	{
+		LLSD sd;
+
+		sd["list"][0]["one"] = 1;
+		sd["list"][0]["two"] = 2;
+		sd["list"][1]["three"] = 3;
+		sd["list"][1]["four"] = 4;
+		
+		setupTheServer();
+
+		LLHTTPClient::post("http://localhost:8888/web/echo", sd, newResult());
+		runThePump();
+		ensureStatusOK();
+		ensure_equals("echoed result matches", getResult(), sd);
+	}
+
+	template<> template<>
+		void HTTPClientTestObject::test<4>()
+	{
+		LLSD sd;
+
+		sd["message"] = "This is my test message.";
+
+		setupTheServer();
+		LLHTTPClient::put("http://localhost:8888/test/storage", sd, newResult());
+		runThePump();
+		ensureStatusOK();
+
+		LLHTTPClient::get("http://localhost:8888/test/storage", newResult());
+		runThePump();
+		ensureStatusOK();
+		ensure_equals("echoed result matches", getResult(), sd);
+	
+	}
+
+	template<> template<>
+		void HTTPClientTestObject::test<5>()
+	{
+		LLSD sd;
+		sd["status"] = 543;
+		sd["reason"] = "error for testing";
+
+		setupTheServer();
+
+		LLHTTPClient::post("http://localhost:8888/test/error", sd, newResult());
+		runThePump();
+		ensureStatusError();
+		ensure_contains("reason", mReason, sd["reason"]);
+	}
+
+	template<> template<>
+		void HTTPClientTestObject::test<6>()
+	{
+		setupTheServer();
+
+		LLHTTPClient::get("http://localhost:8888/test/timeout", newResult());
+		runThePump(1.0f);
+		killServer();
+		runThePump();
+		ensureStatusError();
+		ensure_equals("reason", mReason, "STATUS_ERROR");
+	}
+
+	template<> template<>
+		void HTTPClientTestObject::test<7>()
+	{
+		// Can not use the little mini server.  The blocking request
+		// won't ever let it run.  Instead get from a known LLSD
+		// source and compare results with the non-blocking get which
+		// is tested against the mini server earlier.
+		LLHTTPClient::get(local_server, newResult());
+		runThePump();
+		ensureStatusOK();
+		LLSD expected = getResult();
+
+		LLSD result;
+		result = LLHTTPClient::blockingGet(local_server);
+		LLSD body = result["body"];
+		ensure_equals("echoed result matches", body.size(), expected.size());
+	}
+	template<> template<>
+		void HTTPClientTestObject::test<8>()
+	{
+		// This is testing for the presence of the Header in the returned results
+		// from an HTTP::get call.
+		LLHTTPClient::get(local_server, newResult());
+		runThePump();
+		ensureStatusOK();
+		LLSD header = getHeader();
+		ensure("got a header", ! header.emptyMap().asBoolean());
+	}
+	template<> template<>
+	void HTTPClientTestObject::test<9>()
+	{
+		LLHTTPClient::head(local_server, newResult());
+		runThePump();
+		ensureStatusOK();
+		ensure("result object wasn't destroyed", mResultDeleted);
+	}
+}
diff --git a/indra/llmessage/tests/llsdmessage_test.cpp b/indra/llmessage/tests/llsdmessage_test.cpp
index 0f2c069303..31a791e4b4 100644
--- a/indra/llmessage/tests/llsdmessage_test.cpp
+++ b/indra/llmessage/tests/llsdmessage_test.cpp
@@ -143,7 +143,7 @@ namespace tut
         httpPump.post(request);
         ensure("got response", netio.pump());
         ensure("success response", success);
-        ensure_equals(result.asString(), "success");
+        ensure_equals(result["reply"].asString(), "success");
 
         body["status"] = 499;
         body["reason"] = "custom error message";
diff --git a/indra/llmessage/tests/test_llsdmessage_peer.py b/indra/llmessage/tests/test_llsdmessage_peer.py
index 22edd9dad8..fe4f3a8c01 100644
--- a/indra/llmessage/tests/test_llsdmessage_peer.py
+++ b/indra/llmessage/tests/test_llsdmessage_peer.py
@@ -78,25 +78,32 @@ class TestHTTPRequestHandler(BaseHTTPRequestHandler):
 ##         debug("root node tag %s", tree.getroot().tag)
 ##         return llsd.to_python(tree.getroot())
 
-    def do_GET(self):
+    def do_HEAD(self):
+        self.do_GET(withdata=False)
+
+    def do_GET(self, withdata=True):
         # Of course, don't attempt to read data.
-        self.answer(dict(reply="success", status=500,
-                         reason="Your GET operation requested failure"))
+        data = dict(reply="success", body="avatar", random=17)
+        self.answer(data, withdata=withdata)
 
     def do_POST(self):
         # Read the provided POST data.
         self.answer(self.read_xml())
 
-    def answer(self, data):
+    def answer(self, data, withdata=True):
         debug("%s.answer(%s): self.path = %r", self.__class__.__name__, data, self.path)
         if "fail" not in self.path:
-            response = llsd.format_xml(data.get("reply", llsd.LLSD("success")))
+            data = data.copy()          # we're going to modify
+            # Ensure there's a "reply" key in data, even if there wasn't before
+            data["reply"] = data.get("reply", llsd.LLSD("success"))
+            response = llsd.format_xml(data)
             debug("success: %s", response)
             self.send_response(200)
             self.send_header("Content-type", "application/llsd+xml")
             self.send_header("Content-Length", str(len(response)))
             self.end_headers()
-            self.wfile.write(response)
+            if withdata:
+                self.wfile.write(response)
         else:                           # fail requested
             status = data.get("status", 500)
             # self.responses maps an int status to a (short, long) pair of
diff --git a/indra/llmessage/tests/testrunner.py b/indra/llmessage/tests/testrunner.py
index f2c841532a..5b9beb359b 100644
--- a/indra/llmessage/tests/testrunner.py
+++ b/indra/llmessage/tests/testrunner.py
@@ -35,7 +35,7 @@ import re
 import errno
 import socket
 
-VERBOSE = os.environ.get("INTEGRATION_TEST_VERBOSE", "1") # default to verbose
+VERBOSE = os.environ.get("INTEGRATION_TEST_VERBOSE", "0") # default to quiet
 # Support usage such as INTEGRATION_TEST_VERBOSE=off -- distressing to user if
 # that construct actually turns on verbosity...
 VERBOSE = not re.match(r"(0|off|false|quiet)$", VERBOSE, re.IGNORECASE)