diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 516daadf9ba3fbd980bc72b0799c568ffebd7b9b..86ecee5b264f9be5e3f8ea6e50e1d92d1a3e7935 100644
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -595,6 +595,10 @@ size_t HttpOpRequest::headerCallback(void * data, size_t size, size_t nmemb, voi
op->mReplyLength = 0;
op->mReplyFullLength = 0;
op->mStatus = HttpStatus();
+ if (op->mReplyHeaders)
+ {
+ op->mReplyHeaders->mHeaders.clear();
+ }
}
else if (op->mProcFlags & PF_SCAN_RANGE_HEADER)
{
@@ -636,9 +640,19 @@ size_t HttpOpRequest::headerCallback(void * data, size_t size, size_t nmemb, voi
if (op->mProcFlags & PF_SAVE_HEADERS)
{
// Save headers in response
- // *FIXME: Implement this...
- ;
-
+ if (! op->mReplyHeaders)
+ {
+ op->mReplyHeaders = new HttpHeaders;
+ }
+ size_t wanted_size(hdr_size);
+ if (wanted_size && '\n' == hdr_data[wanted_size - 1])
+ {
+ if (--wanted_size && '\r' == hdr_data[wanted_size - 1])
+ {
+ --wanted_size;
+ }
+ }
+ op->mReplyHeaders->mHeaders.push_back(std::string(hdr_data, wanted_size));
}
return hdr_size;
diff --git a/indra/llcorehttp/tests/test_httprequest.hpp b/indra/llcorehttp/tests/test_httprequest.hpp
index 42e485703776a9d631dcbe2bb26a966b65439a9d..cac927cfcaeed34e8efd64819c4e740d16e2af20 100644
--- a/indra/llcorehttp/tests/test_httprequest.hpp
+++ b/indra/llcorehttp/tests/test_httprequest.hpp
@@ -29,6 +29,7 @@
#include "httprequest.h"
#include "bufferarray.h"
#include "httphandler.h"
+#include "httpheaders.h"
#include "httpresponse.h"
#include "httpoptions.h"
#include "_httpservice.h"
@@ -73,7 +74,8 @@ public:
const std::string & name)
: mState(state),
mName(name),
- mExpectHandle(LLCORE_HTTP_HANDLE_INVALID)
+ mExpectHandle(LLCORE_HTTP_HANDLE_INVALID),
+ mCheckHeader(false)
{}
virtual void onCompleted(HttpHandle handle, HttpResponse * response)
@@ -95,12 +97,33 @@ public:
{
mState->mHandlerCalls++;
}
+ if (mCheckHeader)
+ {
+ ensure("Response required with header check", response != NULL);
+ HttpHeaders * header(response->getHeaders()); // Will not hold onto this
+ ensure("Some quantity of headers returned", header != NULL);
+ bool found_special(false);
+
+ for (HttpHeaders::container_t::const_iterator iter(header->mHeaders.begin());
+ header->mHeaders.end() != iter;
+ ++iter)
+ {
+ if (std::string::npos != (*iter).find("X-LL-Special"))
+ {
+ found_special = true;
+ break;
+ }
+ }
+ ensure("Special header X-LL-Special in response", found_special);
+ }
+
// std::cout << "TestHandler2::onCompleted() invoked" << std::endl;
}
HttpRequestTestData * mState;
std::string mName;
HttpHandle mExpectHandle;
+ bool mCheckHeader;
};
typedef test_group<HttpRequestTestData> HttpRequestTestGroupType;
@@ -1085,6 +1108,135 @@ void HttpRequestTestObjectType::test<11>()
{
ScopedCurlInit ready;
+ std::string url_base(get_base_url());
+ // std::cerr << "Base: " << url_base << std::endl;
+
+ set_test_name("HttpRequest GET with returned headers");
+
+ // Handler can be stack-allocated *if* there are no dangling
+ // references to it after completion of this method.
+ // Create before memory record as the string copy will bump numbers.
+ TestHandler2 handler(this, "handler");
+
+ // record the total amount of dynamically allocated memory
+ mMemTotal = GetMemTotal();
+ mHandlerCalls = 0;
+
+ HttpRequest * req = NULL;
+ HttpOptions * opts = NULL;
+
+ try
+ {
+ // Get singletons created
+ HttpRequest::createService();
+
+ // Enable tracing
+ HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_TRACE, 2);
+
+ // Start threading early so that thread memory is invariant
+ // over the test.
+ HttpRequest::startThread();
+
+ // create a new ref counted object with an implicit reference
+ req = new HttpRequest();
+ ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
+
+ opts = new HttpOptions();
+ opts->setWantHeaders();
+
+ // Issue a GET that succeeds
+ mStatus = HttpStatus(200);
+ handler.mCheckHeader = true;
+ HttpHandle handle = req->requestGetByteRange(HttpRequest::DEFAULT_POLICY_ID,
+ 0U,
+ url_base,
+ 0,
+ 0,
+ opts,
+ NULL,
+ &handler);
+ ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
+
+ // release options
+ opts->release();
+ opts = NULL;
+
+ // Run the notification pump.
+ int count(0);
+ int limit(10);
+ while (count++ < limit && mHandlerCalls < 1)
+ {
+ req->update(1000);
+ usleep(100000);
+ }
+ ensure("Request executed in reasonable time", count < limit);
+ ensure("One handler invocation for request", mHandlerCalls == 1);
+
+ // Okay, request a shutdown of the servicing thread
+ mStatus = HttpStatus();
+ handler.mCheckHeader = false;
+ handle = req->requestStopThread(&handler);
+ ensure("Valid handle returned for second request", handle != LLCORE_HTTP_HANDLE_INVALID);
+
+ // Run the notification pump again
+ count = 0;
+ limit = 10;
+ while (count++ < limit && mHandlerCalls < 2)
+ {
+ req->update(1000);
+ usleep(100000);
+ }
+ ensure("Second request executed in reasonable time", count < limit);
+ ensure("Second handler invocation", mHandlerCalls == 2);
+
+ // See that we actually shutdown the thread
+ count = 0;
+ limit = 10;
+ while (count++ < limit && ! HttpService::isStopped())
+ {
+ usleep(100000);
+ }
+ ensure("Thread actually stopped running", HttpService::isStopped());
+
+ // release the request object
+ delete req;
+ req = NULL;
+
+ // Shut down service
+ HttpRequest::destroyService();
+
+ ensure("Two handler calls on the way out", 2 == mHandlerCalls);
+
+#if defined(WIN32)
+ // Can only do this memory test on Windows. On other platforms,
+ // the LL logging system holds on to memory and produces what looks
+ // like memory leaks...
+
+ // printf("Old mem: %d, New mem: %d\n", mMemTotal, GetMemTotal());
+ ensure("Memory usage back to that at entry", mMemTotal == GetMemTotal());
+#endif
+ }
+ catch (...)
+ {
+ stop_thread(req);
+ if (opts)
+ {
+ opts->release();
+ opts = NULL;
+ }
+ delete req;
+ HttpRequest::destroyService();
+ throw;
+ }
+}
+
+// *NB: This test must be last. The sleeping webserver
+// won't respond for a long time.
+template <> template <>
+void HttpRequestTestObjectType::test<12>()
+{
+ ScopedCurlInit ready;
+
set_test_name("HttpRequest GET timeout");
// Handler can be stack-allocated *if* there are no dangling
@@ -1117,7 +1269,7 @@ void HttpRequestTestObjectType::test<11>()
opts->setRetries(0); // Don't retry
opts->setTimeout(2);
- // Issue a GET that can't connect
+ // Issue a GET that sleeps
mStatus = HttpStatus(HttpStatus::EXT_CURL_EASY, CURLE_OPERATION_TIMEDOUT);
HttpHandle handle = req->requestGetByteRange(HttpRequest::DEFAULT_POLICY_ID,
0U,
diff --git a/indra/llcorehttp/tests/test_llcorehttp_peer.py b/indra/llcorehttp/tests/test_llcorehttp_peer.py
index 5f0116d38411d2543ecd75eed0e27e1be82eac4e..aedd8acd8315b2e6c2ca0ed7900690a0dc8a7301 100644
--- a/indra/llcorehttp/tests/test_llcorehttp_peer.py
+++ b/indra/llcorehttp/tests/test_llcorehttp_peer.py
@@ -107,6 +107,7 @@ def answer(self, data):
self.send_response(200)
self.send_header("Content-type", "application/llsd+xml")
self.send_header("Content-Length", str(len(response)))
+ self.send_header("X-LL-Special", "Mememememe");
self.end_headers()
self.wfile.write(response)
else: # fail requested
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 2eda6a9b80010792fa550085b3f3bb98ece06b17..4995d9f5ea3bcfcba45a19c87899142b7527acfe 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -1043,8 +1043,9 @@ void LLTextureFetchWorker::startWork(S32 param)
// Threads: Ttf
bool LLTextureFetchWorker::doWork(S32 param)
{
- static const LLCore::HttpStatus http_not_found(HTTP_NOT_FOUND);
- static const LLCore::HttpStatus http_service_unavail(HTTP_SERVICE_UNAVAILABLE);
+ static const LLCore::HttpStatus http_not_found(HTTP_NOT_FOUND); // 404
+ static const LLCore::HttpStatus http_service_unavail(HTTP_SERVICE_UNAVAILABLE); // 503
+ static const LLCore::HttpStatus http_not_sat(HTTP_REQUESTED_RANGE_NOT_SATISFIABLE); // 416;
// Release waiters while we aren't holding the Mw lock.
mFetcher->releaseHttpWaiters();