summaryrefslogtreecommitdiff
path: root/indra/llmessage
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llmessage')
-rw-r--r--indra/llmessage/llcurl.cpp962
-rw-r--r--indra/llmessage/llcurl.h205
-rw-r--r--indra/llmessage/llhttpassetstorage.cpp9
-rw-r--r--indra/llmessage/llhttpclient.cpp157
-rw-r--r--indra/llmessage/llhttpclient.h77
-rw-r--r--indra/llmessage/llurlrequest.cpp209
-rw-r--r--indra/llmessage/llurlrequest.h26
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);
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-27 05:53:00 +0000