diff options
Diffstat (limited to 'indra/newview/llxmlrpctransaction.cpp')
| -rw-r--r-- | indra/newview/llxmlrpctransaction.cpp | 632 |
1 files changed, 316 insertions, 316 deletions
diff --git a/indra/newview/llxmlrpctransaction.cpp b/indra/newview/llxmlrpctransaction.cpp index a77c31eee3..1cd72a1cc5 100644 --- a/indra/newview/llxmlrpctransaction.cpp +++ b/indra/newview/llxmlrpctransaction.cpp @@ -1,25 +1,25 @@ -/** +/** * @file llxmlrpctransaction.cpp - * @brief LLXMLRPCTransaction and related class implementations + * @brief LLXMLRPCTransaction and related class implementations * * $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$ */ @@ -65,7 +65,7 @@ namespace boost { - using ::boost::movelib::unique_ptr; // move unique_ptr into the boost namespace. + using ::boost::movelib::unique_ptr; // move unique_ptr into the boost namespace. } // Static instance of LLXMLRPCListener declared here so that every time we @@ -77,168 +77,168 @@ static LLXMLRPCListener listener("LLXMLRPCTransaction"); LLXMLRPCValue LLXMLRPCValue::operator[](const char* id) const { - return LLXMLRPCValue(XMLRPC_VectorGetValueWithID(mV, id)); + return LLXMLRPCValue(XMLRPC_VectorGetValueWithID(mV, id)); } std::string LLXMLRPCValue::asString() const { - const char* s = XMLRPC_GetValueString(mV); - return s ? s : ""; + const char* s = XMLRPC_GetValueString(mV); + return s ? s : ""; } -int LLXMLRPCValue::asInt() const { return XMLRPC_GetValueInt(mV); } -bool LLXMLRPCValue::asBool() const { return XMLRPC_GetValueBoolean(mV) != 0; } -double LLXMLRPCValue::asDouble() const { return XMLRPC_GetValueDouble(mV); } +int LLXMLRPCValue::asInt() const { return XMLRPC_GetValueInt(mV); } +bool LLXMLRPCValue::asBool() const { return XMLRPC_GetValueBoolean(mV) != 0; } +double LLXMLRPCValue::asDouble() const { return XMLRPC_GetValueDouble(mV); } LLXMLRPCValue LLXMLRPCValue::rewind() { - return LLXMLRPCValue(XMLRPC_VectorRewind(mV)); + return LLXMLRPCValue(XMLRPC_VectorRewind(mV)); } LLXMLRPCValue LLXMLRPCValue::next() { - return LLXMLRPCValue(XMLRPC_VectorNext(mV)); + return LLXMLRPCValue(XMLRPC_VectorNext(mV)); } bool LLXMLRPCValue::isValid() const { - return mV != NULL; + return mV != NULL; } LLXMLRPCValue LLXMLRPCValue::createArray() { - return LLXMLRPCValue(XMLRPC_CreateVector(NULL, xmlrpc_vector_array)); + return LLXMLRPCValue(XMLRPC_CreateVector(NULL, xmlrpc_vector_array)); } LLXMLRPCValue LLXMLRPCValue::createStruct() { - return LLXMLRPCValue(XMLRPC_CreateVector(NULL, xmlrpc_vector_struct)); + return LLXMLRPCValue(XMLRPC_CreateVector(NULL, xmlrpc_vector_struct)); } void LLXMLRPCValue::append(LLXMLRPCValue& v) { - XMLRPC_AddValueToVector(mV, v.mV); + XMLRPC_AddValueToVector(mV, v.mV); } void LLXMLRPCValue::appendString(const std::string& v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueString(NULL, v.c_str(), 0)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueString(NULL, v.c_str(), 0)); } void LLXMLRPCValue::appendInt(int v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueInt(NULL, v)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueInt(NULL, v)); } void LLXMLRPCValue::appendBool(bool v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueBoolean(NULL, v)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueBoolean(NULL, v)); } void LLXMLRPCValue::appendDouble(double v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueDouble(NULL, v)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueDouble(NULL, v)); } void LLXMLRPCValue::append(const char* id, LLXMLRPCValue& v) { - XMLRPC_SetValueID(v.mV, id, 0); - XMLRPC_AddValueToVector(mV, v.mV); + XMLRPC_SetValueID(v.mV, id, 0); + XMLRPC_AddValueToVector(mV, v.mV); } void LLXMLRPCValue::appendString(const char* id, const std::string& v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueString(id, v.c_str(), 0)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueString(id, v.c_str(), 0)); } void LLXMLRPCValue::appendInt(const char* id, int v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueInt(id, v)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueInt(id, v)); } void LLXMLRPCValue::appendBool(const char* id, bool v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueBoolean(id, v)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueBoolean(id, v)); } void LLXMLRPCValue::appendDouble(const char* id, double v) { - XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueDouble(id, v)); + XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueDouble(id, v)); } void LLXMLRPCValue::cleanup() { - XMLRPC_CleanupValue(mV); - mV = NULL; + XMLRPC_CleanupValue(mV); + mV = NULL; } XMLRPC_VALUE LLXMLRPCValue::getValue() const { - return mV; + return mV; } class LLXMLRPCTransaction::Handler : public LLCore::HttpHandler { -public: - Handler(LLCore::HttpRequest::ptr_t &request, LLXMLRPCTransaction::Impl *impl); - virtual ~Handler(); +public: + Handler(LLCore::HttpRequest::ptr_t &request, LLXMLRPCTransaction::Impl *impl); + virtual ~Handler(); - virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response); + virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response); - typedef std::shared_ptr<LLXMLRPCTransaction::Handler> ptr_t; + typedef std::shared_ptr<LLXMLRPCTransaction::Handler> ptr_t; private: - LLXMLRPCTransaction::Impl *mImpl; - LLCore::HttpRequest::ptr_t mRequest; + LLXMLRPCTransaction::Impl *mImpl; + LLCore::HttpRequest::ptr_t mRequest; }; class LLXMLRPCTransaction::Impl { public: - typedef LLXMLRPCTransaction::EStatus EStatus; + typedef LLXMLRPCTransaction::EStatus EStatus; - LLCore::HttpRequest::ptr_t mHttpRequest; + LLCore::HttpRequest::ptr_t mHttpRequest; - EStatus mStatus; - CURLcode mCurlCode; - std::string mStatusMessage; - std::string mStatusURI; - LLCore::HttpResponse::TransferStats::ptr_t mTransferStats; - Handler::ptr_t mHandler; - LLCore::HttpHandle mPostH; + EStatus mStatus; + CURLcode mCurlCode; + std::string mStatusMessage; + std::string mStatusURI; + LLCore::HttpResponse::TransferStats::ptr_t mTransferStats; + Handler::ptr_t mHandler; + LLCore::HttpHandle mPostH; - std::string mURI; + std::string mURI; - std::string mProxyAddress; + std::string mProxyAddress; - std::string mResponseText; - XMLRPC_REQUEST mResponse; - std::string mCertStore; - LLSD mErrorCertData; + std::string mResponseText; + XMLRPC_REQUEST mResponse; + std::string mCertStore; + LLSD mErrorCertData; - Impl(const std::string& uri, XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams); - Impl(const std::string& uri, - const std::string& method, LLXMLRPCValue params, bool useGzip); - ~Impl(); + Impl(const std::string& uri, XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams); + Impl(const std::string& uri, + const std::string& method, LLXMLRPCValue params, bool useGzip); + ~Impl(); - bool process(); + bool process(); - void setStatus(EStatus code, const std::string& message = "", const std::string& uri = ""); - void setHttpStatus(const LLCore::HttpStatus &status); + void setStatus(EStatus code, const std::string& message = "", const std::string& uri = ""); + void setHttpStatus(const LLCore::HttpStatus &status); private: - void init(XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams); + void init(XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams); }; -LLXMLRPCTransaction::Handler::Handler(LLCore::HttpRequest::ptr_t &request, - LLXMLRPCTransaction::Impl *impl) : - mImpl(impl), - mRequest(request) +LLXMLRPCTransaction::Handler::Handler(LLCore::HttpRequest::ptr_t &request, + LLXMLRPCTransaction::Impl *impl) : + mImpl(impl), + mRequest(request) { } @@ -246,105 +246,105 @@ LLXMLRPCTransaction::Handler::~Handler() { } -void LLXMLRPCTransaction::Handler::onCompleted(LLCore::HttpHandle handle, - LLCore::HttpResponse * response) +void LLXMLRPCTransaction::Handler::onCompleted(LLCore::HttpHandle handle, + LLCore::HttpResponse * response) { - LLCore::HttpStatus status = response->getStatus(); + LLCore::HttpStatus status = response->getStatus(); - if (!status) - { + if (!status) + { mImpl->setHttpStatus(status); LLSD errordata = status.getErrorData(); mImpl->mErrorCertData = errordata; - if ((status.toULong() != CURLE_SSL_PEER_CERTIFICATE) && - (status.toULong() != CURLE_SSL_CACERT)) - { - // if we have a curl error that's not already been handled - // (a non cert error), then generate the warning message as - // appropriate - LL_WARNS() << "LLXMLRPCTransaction error " - << status.toHex() << ": " << status.toString() << LL_ENDL; - LL_WARNS() << "LLXMLRPCTransaction request URI: " - << mImpl->mURI << LL_ENDL; - } - - return; - } - - mImpl->setStatus(LLXMLRPCTransaction::StatusComplete); - mImpl->mTransferStats = response->getTransferStats(); - - // the contents of a buffer array are potentially noncontiguous, so we - // will need to copy them into an contiguous block of memory for XMLRPC. - LLCore::BufferArray *body = response->getBody(); - char * bodydata = new char[body->size()]; - - body->read(0, bodydata, body->size()); - - mImpl->mResponse = XMLRPC_REQUEST_FromXML(bodydata, body->size(), 0); - - delete[] bodydata; - - bool hasError = false; - bool hasFault = false; - int faultCode = 0; - std::string faultString; - - LLXMLRPCValue error(XMLRPC_RequestGetError(mImpl->mResponse)); - if (error.isValid()) - { - hasError = true; - faultCode = error["faultCode"].asInt(); - faultString = error["faultString"].asString(); - } - else if (XMLRPC_ResponseIsFault(mImpl->mResponse)) - { - hasFault = true; - faultCode = XMLRPC_GetResponseFaultCode(mImpl->mResponse); - faultString = XMLRPC_GetResponseFaultString(mImpl->mResponse); - } - - if (hasError || hasFault) - { - mImpl->setStatus(LLXMLRPCTransaction::StatusXMLRPCError); - - LL_WARNS() << "LLXMLRPCTransaction XMLRPC " - << (hasError ? "error " : "fault ") - << faultCode << ": " - << faultString << LL_ENDL; - LL_WARNS() << "LLXMLRPCTransaction request URI: " - << mImpl->mURI << LL_ENDL; - } + if ((status.toULong() != CURLE_SSL_PEER_CERTIFICATE) && + (status.toULong() != CURLE_SSL_CACERT)) + { + // if we have a curl error that's not already been handled + // (a non cert error), then generate the warning message as + // appropriate + LL_WARNS() << "LLXMLRPCTransaction error " + << status.toHex() << ": " << status.toString() << LL_ENDL; + LL_WARNS() << "LLXMLRPCTransaction request URI: " + << mImpl->mURI << LL_ENDL; + } + + return; + } + + mImpl->setStatus(LLXMLRPCTransaction::StatusComplete); + mImpl->mTransferStats = response->getTransferStats(); + + // the contents of a buffer array are potentially noncontiguous, so we + // will need to copy them into an contiguous block of memory for XMLRPC. + LLCore::BufferArray *body = response->getBody(); + char * bodydata = new char[body->size()]; + + body->read(0, bodydata, body->size()); + + mImpl->mResponse = XMLRPC_REQUEST_FromXML(bodydata, body->size(), 0); + + delete[] bodydata; + + bool hasError = false; + bool hasFault = false; + int faultCode = 0; + std::string faultString; + + LLXMLRPCValue error(XMLRPC_RequestGetError(mImpl->mResponse)); + if (error.isValid()) + { + hasError = true; + faultCode = error["faultCode"].asInt(); + faultString = error["faultString"].asString(); + } + else if (XMLRPC_ResponseIsFault(mImpl->mResponse)) + { + hasFault = true; + faultCode = XMLRPC_GetResponseFaultCode(mImpl->mResponse); + faultString = XMLRPC_GetResponseFaultString(mImpl->mResponse); + } + + if (hasError || hasFault) + { + mImpl->setStatus(LLXMLRPCTransaction::StatusXMLRPCError); + + LL_WARNS() << "LLXMLRPCTransaction XMLRPC " + << (hasError ? "error " : "fault ") + << faultCode << ": " + << faultString << LL_ENDL; + LL_WARNS() << "LLXMLRPCTransaction request URI: " + << mImpl->mURI << LL_ENDL; + } } //========================================================================= LLXMLRPCTransaction::Impl::Impl(const std::string& uri, - XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams) - : mHttpRequest(), - mStatus(LLXMLRPCTransaction::StatusNotStarted), - mURI(uri), - mResponse(0) + XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams) + : mHttpRequest(), + mStatus(LLXMLRPCTransaction::StatusNotStarted), + mURI(uri), + mResponse(0) { - init(request, useGzip, httpParams); + init(request, useGzip, httpParams); } LLXMLRPCTransaction::Impl::Impl(const std::string& uri, - const std::string& method, LLXMLRPCValue params, bool useGzip) - : mHttpRequest(), - mStatus(LLXMLRPCTransaction::StatusNotStarted), - mURI(uri), - mResponse(0) -{ - XMLRPC_REQUEST request = XMLRPC_RequestNew(); - XMLRPC_RequestSetMethodName(request, method.c_str()); - XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); - XMLRPC_RequestSetData(request, params.getValue()); - - init(request, useGzip, LLSD()); + const std::string& method, LLXMLRPCValue params, bool useGzip) + : mHttpRequest(), + mStatus(LLXMLRPCTransaction::StatusNotStarted), + mURI(uri), + mResponse(0) +{ + XMLRPC_REQUEST request = XMLRPC_RequestNew(); + XMLRPC_RequestSetMethodName(request, method.c_str()); + XMLRPC_RequestSetRequestType(request, xmlrpc_request_call); + XMLRPC_RequestSetData(request, params.getValue()); + + init(request, useGzip, LLSD()); // DEV-28398: without this XMLRPC_RequestFree() call, it looks as though // the 'request' object is simply leaked. It's less clear to me whether we // should also ask to free request value data (second param 1), since the @@ -354,266 +354,266 @@ LLXMLRPCTransaction::Impl::Impl(const std::string& uri, void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams) { - LLCore::HttpOptions::ptr_t httpOpts; - LLCore::HttpHeaders::ptr_t httpHeaders; + LLCore::HttpOptions::ptr_t httpOpts; + LLCore::HttpHeaders::ptr_t httpHeaders; - if (!mHttpRequest) - { - mHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest); - } + if (!mHttpRequest) + { + mHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest); + } - // LLRefCounted starts with a 1 ref, so don't add a ref in the smart pointer - httpOpts = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()); + // LLRefCounted starts with a 1 ref, so don't add a ref in the smart pointer + httpOpts = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()); - // delay between repeats will start from 5 sec and grow to 20 sec with each repeat - httpOpts->setMinBackoff(5E6L); - httpOpts->setMaxBackoff(20E6L); + // delay between repeats will start from 5 sec and grow to 20 sec with each repeat + httpOpts->setMinBackoff(5E6L); + httpOpts->setMaxBackoff(20E6L); - httpOpts->setTimeout(httpParams.has("timeout") ? httpParams["timeout"].asInteger() : 40L); - if (httpParams.has("retries")) - { - httpOpts->setRetries(httpParams["retries"].asInteger()); - } - if (httpParams.has("DNSCacheTimeout")) - { - httpOpts->setDNSCacheTimeout(httpParams["DNSCacheTimeout"].asInteger()); - } + httpOpts->setTimeout(httpParams.has("timeout") ? httpParams["timeout"].asInteger() : 40L); + if (httpParams.has("retries")) + { + httpOpts->setRetries(httpParams["retries"].asInteger()); + } + if (httpParams.has("DNSCacheTimeout")) + { + httpOpts->setDNSCacheTimeout(httpParams["DNSCacheTimeout"].asInteger()); + } - bool vefifySSLCert = !gSavedSettings.getBOOL("NoVerifySSLCert"); - mCertStore = gSavedSettings.getString("CertStore"); + bool vefifySSLCert = !gSavedSettings.getBOOL("NoVerifySSLCert"); + mCertStore = gSavedSettings.getString("CertStore"); - httpOpts->setSSLVerifyPeer( vefifySSLCert ); - httpOpts->setSSLVerifyHost( vefifySSLCert ? 2 : 0); + httpOpts->setSSLVerifyPeer( vefifySSLCert ); + httpOpts->setSSLVerifyHost( vefifySSLCert ? 2 : 0); - // LLRefCounted starts with a 1 ref, so don't add a ref in the smart pointer - httpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()); + // LLRefCounted starts with a 1 ref, so don't add a ref in the smart pointer + httpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()); - httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_TEXT_XML); + httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_TEXT_XML); - std::string user_agent = stringize( - LLVersionInfo::instance().getChannel(), ' ', - LLVersionInfo::instance().getMajor(), '.', - LLVersionInfo::instance().getMinor(), '.', - LLVersionInfo::instance().getPatch(), " (", - LLVersionInfo::instance().getBuild(), ')'); + std::string user_agent = stringize( + LLVersionInfo::instance().getChannel(), ' ', + LLVersionInfo::instance().getMajor(), '.', + LLVersionInfo::instance().getMinor(), '.', + LLVersionInfo::instance().getPatch(), " (", + LLVersionInfo::instance().getBuild(), ')'); - httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, user_agent); + httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, user_agent); - ///* Setting the DNS cache timeout to -1 disables it completely. - //This might help with bug #503 */ - //httpOpts->setDNSCacheTimeout(-1); + ///* Setting the DNS cache timeout to -1 disables it completely. + //This might help with bug #503 */ + //httpOpts->setDNSCacheTimeout(-1); - LLCore::BufferArray::ptr_t body = LLCore::BufferArray::ptr_t(new LLCore::BufferArray()); + LLCore::BufferArray::ptr_t body = LLCore::BufferArray::ptr_t(new LLCore::BufferArray()); - // TODO: See if there is a way to serialize to a preallocated buffer I'm - // not fond of the copy here. - int requestSize(0); - char * requestText = XMLRPC_REQUEST_ToXML(request, &requestSize); + // TODO: See if there is a way to serialize to a preallocated buffer I'm + // not fond of the copy here. + int requestSize(0); + char * requestText = XMLRPC_REQUEST_ToXML(request, &requestSize); - body->append(requestText, requestSize); - - XMLRPC_Free(requestText); + body->append(requestText, requestSize); - mHandler = LLXMLRPCTransaction::Handler::ptr_t(new Handler( mHttpRequest, this )); + XMLRPC_Free(requestText); - mPostH = mHttpRequest->requestPost(LLCore::HttpRequest::DEFAULT_POLICY_ID, - mURI, body.get(), httpOpts, httpHeaders, mHandler); + mHandler = LLXMLRPCTransaction::Handler::ptr_t(new Handler( mHttpRequest, this )); + + mPostH = mHttpRequest->requestPost(LLCore::HttpRequest::DEFAULT_POLICY_ID, + mURI, body.get(), httpOpts, httpHeaders, mHandler); } LLXMLRPCTransaction::Impl::~Impl() { - if (mResponse) - { - XMLRPC_RequestFree(mResponse, 1); - } + if (mResponse) + { + XMLRPC_RequestFree(mResponse, 1); + } } bool LLXMLRPCTransaction::Impl::process() { - if (!mPostH || !mHttpRequest) - { - LL_WARNS() << "transaction failed." << LL_ENDL; - return true; //failed, quit. - } + if (!mPostH || !mHttpRequest) + { + LL_WARNS() << "transaction failed." << LL_ENDL; + return true; //failed, quit. + } - switch (mStatus) - { - case LLXMLRPCTransaction::StatusComplete: - case LLXMLRPCTransaction::StatusCURLError: - case LLXMLRPCTransaction::StatusXMLRPCError: - case LLXMLRPCTransaction::StatusOtherError: - { - return true; - } + switch (mStatus) + { + case LLXMLRPCTransaction::StatusComplete: + case LLXMLRPCTransaction::StatusCURLError: + case LLXMLRPCTransaction::StatusXMLRPCError: + case LLXMLRPCTransaction::StatusOtherError: + { + return true; + } - case LLXMLRPCTransaction::StatusNotStarted: - { - setStatus(LLXMLRPCTransaction::StatusStarted); - break; - } + case LLXMLRPCTransaction::StatusNotStarted: + { + setStatus(LLXMLRPCTransaction::StatusStarted); + break; + } - default: - break; - } + default: + break; + } - LLCore::HttpStatus status = mHttpRequest->update(0); + LLCore::HttpStatus status = mHttpRequest->update(0); - status = mHttpRequest->getStatus(); - if (!status) - { - return false; - } + status = mHttpRequest->getStatus(); + if (!status) + { + return false; + } - return false; + return false; } void LLXMLRPCTransaction::Impl::setStatus(EStatus status, - const std::string& message, const std::string& uri) -{ - mStatus = status; - mStatusMessage = message; - mStatusURI = uri; - - if (mStatusMessage.empty()) - { - switch (mStatus) - { - case StatusNotStarted: - mStatusMessage = "(not started)"; - break; - - case StatusStarted: - mStatusMessage = "(waiting for server response)"; - break; - - case StatusDownloading: - mStatusMessage = "(reading server response)"; - break; - - case StatusComplete: - mStatusMessage = "(done)"; - break; - default: - // Usually this means that there's a problem with the login server, - // not with the client. Direct user to status page. - mStatusMessage = LLTrans::getString("server_is_down"); - mStatusURI = "http://status.secondlifegrid.net/"; - } - } + const std::string& message, const std::string& uri) +{ + mStatus = status; + mStatusMessage = message; + mStatusURI = uri; + + if (mStatusMessage.empty()) + { + switch (mStatus) + { + case StatusNotStarted: + mStatusMessage = "(not started)"; + break; + + case StatusStarted: + mStatusMessage = "(waiting for server response)"; + break; + + case StatusDownloading: + mStatusMessage = "(reading server response)"; + break; + + case StatusComplete: + mStatusMessage = "(done)"; + break; + default: + // Usually this means that there's a problem with the login server, + // not with the client. Direct user to status page. + mStatusMessage = LLTrans::getString("server_is_down"); + mStatusURI = "http://status.secondlifegrid.net/"; + } + } } void LLXMLRPCTransaction::Impl::setHttpStatus(const LLCore::HttpStatus &status) { - CURLcode code = static_cast<CURLcode>(status.toULong()); - std::string message; - std::string uri = "http://support.secondlife.com"; - LLURI failuri(mURI); - LLStringUtil::format_map_t args; + CURLcode code = static_cast<CURLcode>(status.toULong()); + std::string message; + std::string uri = "http://support.secondlife.com"; + LLURI failuri(mURI); + LLStringUtil::format_map_t args; - switch (code) - { - case CURLE_COULDNT_RESOLVE_HOST: - args["[HOSTNAME]"] = failuri.hostName(); - message = LLTrans::getString("couldnt_resolve_host", args); - break; + switch (code) + { + case CURLE_COULDNT_RESOLVE_HOST: + args["[HOSTNAME]"] = failuri.hostName(); + message = LLTrans::getString("couldnt_resolve_host", args); + break; #if CURLE_SSL_PEER_CERTIFICATE != CURLE_SSL_CACERT - case CURLE_SSL_PEER_CERTIFICATE: - message = LLTrans::getString("ssl_peer_certificate"); - break; + case CURLE_SSL_PEER_CERTIFICATE: + message = LLTrans::getString("ssl_peer_certificate"); + break; #endif - case CURLE_SSL_CACERT: - case CURLE_SSL_CONNECT_ERROR: - message = LLTrans::getString("ssl_connect_error"); - break; + case CURLE_SSL_CACERT: + case CURLE_SSL_CONNECT_ERROR: + message = LLTrans::getString("ssl_connect_error"); + break; - default: - break; - } + default: + break; + } - mCurlCode = code; - setStatus(StatusCURLError, message, uri); + mCurlCode = code; + setStatus(StatusCURLError, message, uri); } LLXMLRPCTransaction::LLXMLRPCTransaction( - const std::string& uri, XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams) + const std::string& uri, XMLRPC_REQUEST request, bool useGzip, const LLSD& httpParams) : impl(* new Impl(uri, request, useGzip, httpParams)) { } LLXMLRPCTransaction::LLXMLRPCTransaction( - const std::string& uri, - const std::string& method, LLXMLRPCValue params, bool useGzip) + const std::string& uri, + const std::string& method, LLXMLRPCValue params, bool useGzip) : impl(* new Impl(uri, method, params, useGzip)) { } LLXMLRPCTransaction::~LLXMLRPCTransaction() { - delete &impl; + delete &impl; } bool LLXMLRPCTransaction::process() { - return impl.process(); + return impl.process(); } LLXMLRPCTransaction::EStatus LLXMLRPCTransaction::status(int* curlCode) { - if (curlCode) - { - *curlCode = - (impl.mStatus == StatusCURLError) - ? impl.mCurlCode - : CURLE_OK; - } - - return impl.mStatus; + if (curlCode) + { + *curlCode = + (impl.mStatus == StatusCURLError) + ? impl.mCurlCode + : CURLE_OK; + } + + return impl.mStatus; } std::string LLXMLRPCTransaction::statusMessage() { - return impl.mStatusMessage; + return impl.mStatusMessage; } LLSD LLXMLRPCTransaction::getErrorCertData() { - return impl.mErrorCertData; + return impl.mErrorCertData; } std::string LLXMLRPCTransaction::statusURI() { - return impl.mStatusURI; + return impl.mStatusURI; } XMLRPC_REQUEST LLXMLRPCTransaction::response() { - return impl.mResponse; + return impl.mResponse; } LLXMLRPCValue LLXMLRPCTransaction::responseValue() { - return LLXMLRPCValue(XMLRPC_RequestGetData(impl.mResponse)); + return LLXMLRPCValue(XMLRPC_RequestGetData(impl.mResponse)); } F64 LLXMLRPCTransaction::transferRate() { - if (impl.mStatus != StatusComplete) - { - return 0.0L; - } - - double rate_bits_per_sec = impl.mTransferStats->mSpeedDownload * 8.0; - - LL_INFOS("AppInit") << "Buffer size: " << impl.mResponseText.size() << " B" << LL_ENDL; - LL_DEBUGS("AppInit") << "Transfer size: " << impl.mTransferStats->mSizeDownload << " B" << LL_ENDL; - LL_DEBUGS("AppInit") << "Transfer time: " << impl.mTransferStats->mTotalTime << " s" << LL_ENDL; - LL_INFOS("AppInit") << "Transfer rate: " << rate_bits_per_sec / 1000.0 << " Kb/s" << LL_ENDL; - - return rate_bits_per_sec; + if (impl.mStatus != StatusComplete) + { + return 0.0L; + } + + double rate_bits_per_sec = impl.mTransferStats->mSpeedDownload * 8.0; + + LL_INFOS("AppInit") << "Buffer size: " << impl.mResponseText.size() << " B" << LL_ENDL; + LL_DEBUGS("AppInit") << "Transfer size: " << impl.mTransferStats->mSizeDownload << " B" << LL_ENDL; + LL_DEBUGS("AppInit") << "Transfer time: " << impl.mTransferStats->mTotalTime << " s" << LL_ENDL; + LL_INFOS("AppInit") << "Transfer rate: " << rate_bits_per_sec / 1000.0 << " Kb/s" << LL_ENDL; + + return rate_bits_per_sec; } |