#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

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;
 }