merge up to 3.4.4

1 files changed, 218 insertions, 5 deletions

diff --git a/indra/llmessage/llcurl.cpp b/indra/llmessage/llcurl.cpp
index 10c83e6572..8ffa8e4271 100644
--- a/indra/llmessage/llcurl.cpp
+++ b/indra/llmessage/llcurl.cpp
@@ -294,6 +294,8 @@ LLCurl::Easy* LLCurl::Easy::getEasy()
 	// multi handles cache if they are added to one.
 	CURLcode result = curl_easy_setopt(easy->mCurlEasyHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0);
 	check_curl_code(result);
+	result = curl_easy_setopt(easy->mCurlEasyHandle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+	check_curl_code(result);
 	
 	++gCurlEasyCount;
 	return easy;
@@ -482,7 +484,8 @@ void LLCurl::Easy::prepRequest(const std::string& url,
 
 	//setopt(CURLOPT_VERBOSE, 1); // useful for debugging
 	setopt(CURLOPT_NOSIGNAL, 1);
-
+	setopt(CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+	
 	// Set the CURL options for either Socks or HTTP proxy
 	LLProxy::getInstance()->applyProxySettings(this);
 
@@ -938,8 +941,8 @@ bool LLCurlThread::CurlRequest::processRequest()
 
 		if(!completed)
 		{
-		setPriority(LLQueuedThread::PRIORITY_LOW) ;
-	}
+			setPriority(LLQueuedThread::PRIORITY_LOW) ;
+		}
 	}
 
 	return completed ;
@@ -949,7 +952,7 @@ void LLCurlThread::CurlRequest::finishRequest(bool completed)
 {
 	if(mMulti->isDead())
 	{
-	mCurlThread->deleteMulti(mMulti) ;
+		mCurlThread->deleteMulti(mMulti) ;
 	}
 	else
 	{
@@ -993,6 +996,7 @@ void LLCurlThread::killMulti(LLCurl::Multi* multi)
 		return ;
 	}
 
+
 	multi->markDead() ;
 }
 
@@ -1098,7 +1102,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,
@@ -1117,6 +1123,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;
@@ -1244,6 +1255,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