Fix line endlings

1 files changed, 581 insertions, 581 deletions

diff --git a/indra/llcorehttp/_httpservice.cpp b/indra/llcorehttp/_httpservice.cpp
index 10a8c87550..5880fb7e87 100644
--- a/indra/llcorehttp/_httpservice.cpp
+++ b/indra/llcorehttp/_httpservice.cpp
@@ -1,581 +1,581 @@
-/**

- * @file _httpservice.cpp

- * @brief Internal definitions of the Http service thread

- *

- * $LicenseInfo:firstyear=2012&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2012-2014, 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$

- */

-

-#include "_httpservice.h"

-

-#include <boost/bind.hpp>

-#include <boost/function.hpp>

-

-#include "_httpoperation.h"

-#include "_httprequestqueue.h"

-#include "_httppolicy.h"

-#include "_httplibcurl.h"

-#include "_thread.h"

-#include "_httpinternal.h"

-

-#include "lltimer.h"

-#include "llthread.h"

-#include "llexception.h"

-#include "llmemory.h"

-

-namespace

-{

-

-static const char * const LOG_CORE("CoreHttp");

-

-} // end anonymous namespace

-

-

-namespace LLCore

-{

-

-const HttpService::OptionDescriptor HttpService::sOptionDesc[] =

-{ //    isLong     isDynamic  isGlobal    isClass

-    {   true,       true,       true,       true,       false   },      // PO_CONNECTION_LIMIT

-    {   true,       true,       false,      true,       false   },      // PO_PER_HOST_CONNECTION_LIMIT

-    {   false,      false,      true,       false,      false   },      // PO_CA_PATH

-    {   false,      false,      true,       false,      false   },      // PO_CA_FILE

-    {   false,      true,       true,       false,      false   },      // PO_HTTP_PROXY

-    {   true,       true,       true,       false,      false   },      // PO_LLPROXY

-    {   true,       true,       true,       false,      false   },      // PO_TRACE

-    {   true,       true,       false,      true,       false   },      // PO_ENABLE_PIPELINING

-    {   true,       true,       false,      true,       false   },      // PO_THROTTLE_RATE

-    {   false,      false,      true,       false,      true    }       // PO_SSL_VERIFY_CALLBACK

-};

-HttpService * HttpService::sInstance(NULL);

-volatile HttpService::EState HttpService::sState(NOT_INITIALIZED);

-

-HttpService::HttpService()

-    : mRequestQueue(NULL),

-      mExitRequested(0U),

-      mThread(NULL),

-      mPolicy(NULL),

-      mTransport(NULL),

-      mLastPolicy(0)

-{}

-

-

-HttpService::~HttpService()

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    mExitRequested = 1U;

-    if (RUNNING == sState)

-    {

-        // Trying to kill the service object with a running thread

-        // is a bit tricky.

-        if (mRequestQueue)

-        {

-            if (mRequestQueue->stopQueue())

-            {

-                // Give mRequestQueue a chance to finish

-                ms_sleep(10);

-            }

-        }

-

-        if (mThread)

-        {

-            if (! mThread->timedJoin(250))

-            {

-                // Failed to join, expect problems ahead so do a hard termination.

-                LL_WARNS(LOG_CORE) << "Destroying HttpService with running thread.  Expect problems." << LL_NEWLINE

-                                    << "State: " << S32(sState)

-                                    << " Last policy: " << U32(mLastPolicy)

-                                    << LL_ENDL;

-

-                mThread->cancel();

-            }

-        }

-    }

-

-    if (mRequestQueue)

-    {

-        mRequestQueue->release();

-        mRequestQueue = NULL;

-    }

-

-    delete mTransport;

-    mTransport = NULL;

-

-    delete mPolicy;

-    mPolicy = NULL;

-

-    if (mThread)

-    {

-        mThread->release();

-        mThread = NULL;

-    }

-}

-

-

-void HttpService::init(HttpRequestQueue * queue)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    llassert_always(! sInstance);

-    llassert_always(NOT_INITIALIZED == sState);

-    sInstance = new HttpService();

-

-    queue->addRef();

-    sInstance->mRequestQueue = queue;

-    sInstance->mPolicy = new HttpPolicy(sInstance);

-    sInstance->mTransport = new HttpLibcurl(sInstance);

-    sState = INITIALIZED;

-}

-

-

-void HttpService::term()

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    if (sInstance)

-    {

-        if (RUNNING == sState && sInstance->mThread)

-        {

-            // Unclean termination.  Thread appears to be running.  We'll

-            // try to give the worker thread a chance to cancel using the

-            // exit flag...

-            sInstance->mExitRequested = 1U;

-            sInstance->mRequestQueue->stopQueue();

-

-            // And a little sleep

-            for (int i(0); i < 10 && RUNNING == sState; ++i)

-            {

-                ms_sleep(100);

-            }

-        }

-

-        delete sInstance;

-        sInstance = NULL;

-    }

-    sState = NOT_INITIALIZED;

-}

-

-

-HttpRequest::policy_t HttpService::createPolicyClass()

-{

-    mLastPolicy = mPolicy->createPolicyClass();

-    return mLastPolicy;

-}

-

-

-bool HttpService::isStopped()

-{

-    // What is really wanted here is something like:

-    //

-    //     HttpService * service = instanceOf();

-    //     return STOPPED == sState && (! service || ! service->mThread || ! service->mThread->joinable());

-    //

-    // But boost::thread is not giving me a consistent story on joinability

-    // of a thread after it returns.  Debug and non-debug builds are showing

-    // different behavior on Linux/Etch so we do a weaker test that may

-    // not be globally correct (i.e. thread *is* stopping, may not have

-    // stopped but will very soon):

-

-    return STOPPED == sState;

-}

-

-

-/// Threading:  callable by consumer thread *once*.

-void HttpService::startThread()

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    llassert_always(! mThread || STOPPED == sState);

-    llassert_always(INITIALIZED == sState || STOPPED == sState);

-

-    if (mThread)

-    {

-        mThread->release();

-    }

-

-    // Push current policy definitions, enable policy & transport components

-    mPolicy->start();

-    mTransport->start(mLastPolicy + 1);

-

-    mThread = new LLCoreInt::HttpThread(boost::bind(&HttpService::threadRun, this, _1));

-    sState = RUNNING;

-}

-

-

-/// Threading:  callable by worker thread.

-void HttpService::stopRequested()

-{

-    mExitRequested = 1U;

-}

-

-

-/// Try to find the given request handle on any of the request

-/// queues and cancel the operation.

-///

-/// @return         True if the request was canceled.

-///

-/// Threading:  callable by worker thread.

-bool HttpService::cancel(HttpHandle handle)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    bool canceled(false);

-

-    // Request can't be on request queue so skip that.

-

-    // Check the policy component's queues first

-    canceled = mPolicy->cancel(handle);

-

-    if (! canceled)

-    {

-        // If that didn't work, check transport's.

-        canceled = mTransport->cancel(handle);

-    }

-

-    return canceled;

-}

-

-

-/// Threading:  callable by worker thread.

-void HttpService::shutdown()

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    // Disallow future enqueue of requests

-    mRequestQueue->stopQueue();

-

-    // Cancel requests already on the request queue

-    HttpRequestQueue::OpContainer ops;

-    mRequestQueue->fetchAll(false, ops);

-

-    for (HttpRequestQueue::OpContainer::iterator it = ops.begin();

-        it != ops.end(); ++it)

-    {

-        (*it)->cancel();

-    }

-    ops.clear();

-

-    // Shutdown transport canceling requests, freeing resources

-    mTransport->shutdown();

-

-    // And now policy

-    mPolicy->shutdown();

-}

-

-

-// Working thread loop-forever method.  Gives time to

-// each of the request queue, policy layer and transport

-// layer pieces and then either sleeps for a small time

-// or waits for a request to come in.  Repeats until

-// requested to stop.

-void HttpService::threadRun(LLCoreInt::HttpThread * thread)

-{

-    LL_PROFILER_SET_THREAD_NAME("HttpService");

-

-    boost::this_thread::disable_interruption di;

-

-    LLThread::registerThreadID();

-

-    ELoopSpeed loop(REQUEST_SLEEP);

-    while (! mExitRequested)

-    {

-        LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-        try

-        {

-            loop = processRequestQueue(loop);

-

-            // Process ready queue issuing new requests as needed

-            ELoopSpeed new_loop = mPolicy->processReadyQueue();

-            loop = (std::min)(loop, new_loop);

-

-            // Give libcurl some cycles

-            new_loop = mTransport->processTransport();

-            loop = (std::min)(loop, new_loop);

-

-            // Determine whether to spin, sleep briefly or sleep for next request

-            if (REQUEST_SLEEP != loop)

-            {

-                ms_sleep(HTTP_SERVICE_LOOP_SLEEP_NORMAL_MS);

-            }

-        }

-        catch (const LLContinueError&)

-        {

-            LOG_UNHANDLED_EXCEPTION("");

-        }

-        catch (std::bad_alloc&)

-        {

-            LLMemory::logMemoryInfo(true);

-

-            //output possible call stacks to log file.

-            LLError::LLUserWarningMsg::showOutOfMemory();

-            LLError::LLCallStacks::print();

-

-            LL_ERRS() << "Bad memory allocation in HttpService::threadRun()!" << LL_ENDL;

-        }

-        catch (...)

-        {

-            CRASH_ON_UNHANDLED_EXCEPTION("");

-        }

-    }

-

-    shutdown();

-    sState = STOPPED;

-}

-

-

-HttpService::ELoopSpeed HttpService::processRequestQueue(ELoopSpeed loop)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    HttpRequestQueue::OpContainer ops;

-    const bool wait_for_req(REQUEST_SLEEP == loop);

-

-    mRequestQueue->fetchAll(wait_for_req, ops);

-    while (! ops.empty())

-    {

-        HttpOperation::ptr_t op(ops.front());

-        ops.erase(ops.begin());

-

-        // Process operation

-        if (! mExitRequested)

-        {

-            // Setup for subsequent tracing

-            long tracing(HTTP_TRACE_OFF);

-            mPolicy->getGlobalOptions().get(HttpRequest::PO_TRACE, &tracing);

-            op->mTracing = (std::max)(op->mTracing, int(tracing));

-

-            if (op->mTracing > HTTP_TRACE_OFF)

-            {

-                LL_INFOS(LOG_CORE) << "TRACE, FromRequestQueue, Handle:  "

-                                   << op->getHandle()

-                                   << LL_ENDL;

-            }

-

-            // Stage

-            op->stageFromRequest(this);

-        }

-

-        // Done with operation

-        op.reset();

-    }

-

-    // Queue emptied, allow polling loop to sleep

-    return REQUEST_SLEEP;

-}

-

-

-HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,

-                                        long * ret_value)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range

-        || opt >= HttpRequest::PO_LAST                                                  // ditto

-        || (! sOptionDesc[opt].mIsLong)                                                 // datatype is long

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range

-        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass))    // class setting permitted

-                                                                                        // can always get, no dynamic check

-    {

-        return HttpStatus(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);

-    }

-

-    HttpStatus status;

-    if (pclass == HttpRequest::GLOBAL_POLICY_ID)

-    {

-        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());

-

-        status = opts.get(opt, ret_value);

-    }

-    else

-    {

-        HttpPolicyClass & opts(mPolicy->getClassOptions(pclass));

-

-        status = opts.get(opt, ret_value);

-    }

-

-    return status;

-}

-

-

-HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,

-                                        std::string * ret_value)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);

-

-    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range

-        || opt >= HttpRequest::PO_LAST                                                  // ditto

-        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range

-        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass))    // class setting permitted

-                                                                                        // can always get, no dynamic check

-    {

-        return status;

-    }

-

-    // Only global has string values

-    if (pclass == HttpRequest::GLOBAL_POLICY_ID)

-    {

-        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());

-

-        status = opts.get(opt, ret_value);

-    }

-

-    return status;

-}

-

-HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,

-    HttpRequest::policyCallback_t * ret_value)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);

-

-    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range

-        || opt >= HttpRequest::PO_LAST                                                  // ditto

-        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range

-        || (pclass == HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsGlobal) // global setting permitted

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsClass)) // class setting permitted

-        // can always get, no dynamic check

-    {

-        return status;

-    }

-

-    // Only global has callback values

-    if (pclass == HttpRequest::GLOBAL_POLICY_ID)

-    {

-        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());

-

-        status = opts.get(opt, ret_value);

-    }

-

-    return status;

-}

-

-

-

-HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,

-                                        long value, long * ret_value)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);

-

-    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range

-        || opt >= HttpRequest::PO_LAST                                                  // ditto

-        || (! sOptionDesc[opt].mIsLong)                                                 // datatype is long

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range

-        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass)     // class setting permitted

-        || (RUNNING == sState && ! sOptionDesc[opt].mIsDynamic))                        // dynamic setting permitted

-    {

-        return status;

-    }

-

-    if (pclass == HttpRequest::GLOBAL_POLICY_ID)

-    {

-        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());

-

-        status = opts.set(opt, value);

-        if (status && ret_value)

-        {

-            status = opts.get(opt, ret_value);

-        }

-    }

-    else

-    {

-        HttpPolicyClass & opts(mPolicy->getClassOptions(pclass));

-

-        status = opts.set(opt, value);

-        if (status)

-        {

-            mTransport->policyUpdated(pclass);

-            if (ret_value)

-            {

-                status = opts.get(opt, ret_value);

-            }

-        }

-    }

-

-    return status;

-}

-

-

-HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,

-                                        const std::string & value, std::string * ret_value)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);

-

-    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range

-        || opt >= HttpRequest::PO_LAST                                                  // ditto

-        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range

-        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass)     // class setting permitted

-        || (RUNNING == sState && ! sOptionDesc[opt].mIsDynamic))                        // dynamic setting permitted

-    {

-        return status;

-    }

-

-    // String values are always global (at this time).

-    if (pclass == HttpRequest::GLOBAL_POLICY_ID)

-    {

-        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());

-

-        status = opts.set(opt, value);

-        if (status && ret_value)

-        {

-            status = opts.get(opt, ret_value);

-        }

-    }

-

-    return status;

-}

-

-HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,

-    HttpRequest::policyCallback_t value, HttpRequest::policyCallback_t * ret_value)

-{

-    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;

-    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);

-

-    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range

-        || opt >= HttpRequest::PO_LAST                                                  // ditto

-        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range

-        || (pclass == HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsGlobal) // global setting permitted

-        || (pclass != HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsClass)      // class setting permitted

-        || (RUNNING == sState && !sOptionDesc[opt].mIsDynamic))                     // dynamic setting permitted

-    {

-        return status;

-    }

-

-    // Callbacks values are always global (at this time).

-    if (pclass == HttpRequest::GLOBAL_POLICY_ID)

-    {

-        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());

-

-        status = opts.set(opt, value);

-        if (status && ret_value)

-        {

-            status = opts.get(opt, ret_value);

-        }

-    }

-

-    return status;

-}

-

-

-}  // end namespace LLCore

+/**
+ * @file _httpservice.cpp
+ * @brief Internal definitions of the Http service thread
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012-2014, 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$
+ */
+
+#include "_httpservice.h"
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+#include "_httpoperation.h"
+#include "_httprequestqueue.h"
+#include "_httppolicy.h"
+#include "_httplibcurl.h"
+#include "_thread.h"
+#include "_httpinternal.h"
+
+#include "lltimer.h"
+#include "llthread.h"
+#include "llexception.h"
+#include "llmemory.h"
+
+namespace
+{
+
+static const char * const LOG_CORE("CoreHttp");
+
+} // end anonymous namespace
+
+
+namespace LLCore
+{
+
+const HttpService::OptionDescriptor HttpService::sOptionDesc[] =
+{ //    isLong     isDynamic  isGlobal    isClass
+    {   true,       true,       true,       true,       false   },      // PO_CONNECTION_LIMIT
+    {   true,       true,       false,      true,       false   },      // PO_PER_HOST_CONNECTION_LIMIT
+    {   false,      false,      true,       false,      false   },      // PO_CA_PATH
+    {   false,      false,      true,       false,      false   },      // PO_CA_FILE
+    {   false,      true,       true,       false,      false   },      // PO_HTTP_PROXY
+    {   true,       true,       true,       false,      false   },      // PO_LLPROXY
+    {   true,       true,       true,       false,      false   },      // PO_TRACE
+    {   true,       true,       false,      true,       false   },      // PO_ENABLE_PIPELINING
+    {   true,       true,       false,      true,       false   },      // PO_THROTTLE_RATE
+    {   false,      false,      true,       false,      true    }       // PO_SSL_VERIFY_CALLBACK
+};
+HttpService * HttpService::sInstance(NULL);
+volatile HttpService::EState HttpService::sState(NOT_INITIALIZED);
+
+HttpService::HttpService()
+    : mRequestQueue(NULL),
+      mExitRequested(0U),
+      mThread(NULL),
+      mPolicy(NULL),
+      mTransport(NULL),
+      mLastPolicy(0)
+{}
+
+
+HttpService::~HttpService()
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    mExitRequested = 1U;
+    if (RUNNING == sState)
+    {
+        // Trying to kill the service object with a running thread
+        // is a bit tricky.
+        if (mRequestQueue)
+        {
+            if (mRequestQueue->stopQueue())
+            {
+                // Give mRequestQueue a chance to finish
+                ms_sleep(10);
+            }
+        }
+
+        if (mThread)
+        {
+            if (! mThread->timedJoin(250))
+            {
+                // Failed to join, expect problems ahead so do a hard termination.
+                LL_WARNS(LOG_CORE) << "Destroying HttpService with running thread.  Expect problems." << LL_NEWLINE
+                                    << "State: " << S32(sState)
+                                    << " Last policy: " << U32(mLastPolicy)
+                                    << LL_ENDL;
+
+                mThread->cancel();
+            }
+        }
+    }
+
+    if (mRequestQueue)
+    {
+        mRequestQueue->release();
+        mRequestQueue = NULL;
+    }
+
+    delete mTransport;
+    mTransport = NULL;
+
+    delete mPolicy;
+    mPolicy = NULL;
+
+    if (mThread)
+    {
+        mThread->release();
+        mThread = NULL;
+    }
+}
+
+
+void HttpService::init(HttpRequestQueue * queue)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    llassert_always(! sInstance);
+    llassert_always(NOT_INITIALIZED == sState);
+    sInstance = new HttpService();
+
+    queue->addRef();
+    sInstance->mRequestQueue = queue;
+    sInstance->mPolicy = new HttpPolicy(sInstance);
+    sInstance->mTransport = new HttpLibcurl(sInstance);
+    sState = INITIALIZED;
+}
+
+
+void HttpService::term()
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    if (sInstance)
+    {
+        if (RUNNING == sState && sInstance->mThread)
+        {
+            // Unclean termination.  Thread appears to be running.  We'll
+            // try to give the worker thread a chance to cancel using the
+            // exit flag...
+            sInstance->mExitRequested = 1U;
+            sInstance->mRequestQueue->stopQueue();
+
+            // And a little sleep
+            for (int i(0); i < 10 && RUNNING == sState; ++i)
+            {
+                ms_sleep(100);
+            }
+        }
+
+        delete sInstance;
+        sInstance = NULL;
+    }
+    sState = NOT_INITIALIZED;
+}
+
+
+HttpRequest::policy_t HttpService::createPolicyClass()
+{
+    mLastPolicy = mPolicy->createPolicyClass();
+    return mLastPolicy;
+}
+
+
+bool HttpService::isStopped()
+{
+    // What is really wanted here is something like:
+    //
+    //     HttpService * service = instanceOf();
+    //     return STOPPED == sState && (! service || ! service->mThread || ! service->mThread->joinable());
+    //
+    // But boost::thread is not giving me a consistent story on joinability
+    // of a thread after it returns.  Debug and non-debug builds are showing
+    // different behavior on Linux/Etch so we do a weaker test that may
+    // not be globally correct (i.e. thread *is* stopping, may not have
+    // stopped but will very soon):
+
+    return STOPPED == sState;
+}
+
+
+/// Threading:  callable by consumer thread *once*.
+void HttpService::startThread()
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    llassert_always(! mThread || STOPPED == sState);
+    llassert_always(INITIALIZED == sState || STOPPED == sState);
+
+    if (mThread)
+    {
+        mThread->release();
+    }
+
+    // Push current policy definitions, enable policy & transport components
+    mPolicy->start();
+    mTransport->start(mLastPolicy + 1);
+
+    mThread = new LLCoreInt::HttpThread(boost::bind(&HttpService::threadRun, this, _1));
+    sState = RUNNING;
+}
+
+
+/// Threading:  callable by worker thread.
+void HttpService::stopRequested()
+{
+    mExitRequested = 1U;
+}
+
+
+/// Try to find the given request handle on any of the request
+/// queues and cancel the operation.
+///
+/// @return         True if the request was canceled.
+///
+/// Threading:  callable by worker thread.
+bool HttpService::cancel(HttpHandle handle)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    bool canceled(false);
+
+    // Request can't be on request queue so skip that.
+
+    // Check the policy component's queues first
+    canceled = mPolicy->cancel(handle);
+
+    if (! canceled)
+    {
+        // If that didn't work, check transport's.
+        canceled = mTransport->cancel(handle);
+    }
+
+    return canceled;
+}
+
+
+/// Threading:  callable by worker thread.
+void HttpService::shutdown()
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    // Disallow future enqueue of requests
+    mRequestQueue->stopQueue();
+
+    // Cancel requests already on the request queue
+    HttpRequestQueue::OpContainer ops;
+    mRequestQueue->fetchAll(false, ops);
+
+    for (HttpRequestQueue::OpContainer::iterator it = ops.begin();
+        it != ops.end(); ++it)
+    {
+        (*it)->cancel();
+    }
+    ops.clear();
+
+    // Shutdown transport canceling requests, freeing resources
+    mTransport->shutdown();
+
+    // And now policy
+    mPolicy->shutdown();
+}
+
+
+// Working thread loop-forever method.  Gives time to
+// each of the request queue, policy layer and transport
+// layer pieces and then either sleeps for a small time
+// or waits for a request to come in.  Repeats until
+// requested to stop.
+void HttpService::threadRun(LLCoreInt::HttpThread * thread)
+{
+    LL_PROFILER_SET_THREAD_NAME("HttpService");
+
+    boost::this_thread::disable_interruption di;
+
+    LLThread::registerThreadID();
+
+    ELoopSpeed loop(REQUEST_SLEEP);
+    while (! mExitRequested)
+    {
+        LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+        try
+        {
+            loop = processRequestQueue(loop);
+
+            // Process ready queue issuing new requests as needed
+            ELoopSpeed new_loop = mPolicy->processReadyQueue();
+            loop = (std::min)(loop, new_loop);
+
+            // Give libcurl some cycles
+            new_loop = mTransport->processTransport();
+            loop = (std::min)(loop, new_loop);
+
+            // Determine whether to spin, sleep briefly or sleep for next request
+            if (REQUEST_SLEEP != loop)
+            {
+                ms_sleep(HTTP_SERVICE_LOOP_SLEEP_NORMAL_MS);
+            }
+        }
+        catch (const LLContinueError&)
+        {
+            LOG_UNHANDLED_EXCEPTION("");
+        }
+        catch (std::bad_alloc&)
+        {
+            LLMemory::logMemoryInfo(true);
+
+            //output possible call stacks to log file.
+            LLError::LLUserWarningMsg::showOutOfMemory();
+            LLError::LLCallStacks::print();
+
+            LL_ERRS() << "Bad memory allocation in HttpService::threadRun()!" << LL_ENDL;
+        }
+        catch (...)
+        {
+            CRASH_ON_UNHANDLED_EXCEPTION("");
+        }
+    }
+
+    shutdown();
+    sState = STOPPED;
+}
+
+
+HttpService::ELoopSpeed HttpService::processRequestQueue(ELoopSpeed loop)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    HttpRequestQueue::OpContainer ops;
+    const bool wait_for_req(REQUEST_SLEEP == loop);
+
+    mRequestQueue->fetchAll(wait_for_req, ops);
+    while (! ops.empty())
+    {
+        HttpOperation::ptr_t op(ops.front());
+        ops.erase(ops.begin());
+
+        // Process operation
+        if (! mExitRequested)
+        {
+            // Setup for subsequent tracing
+            long tracing(HTTP_TRACE_OFF);
+            mPolicy->getGlobalOptions().get(HttpRequest::PO_TRACE, &tracing);
+            op->mTracing = (std::max)(op->mTracing, int(tracing));
+
+            if (op->mTracing > HTTP_TRACE_OFF)
+            {
+                LL_INFOS(LOG_CORE) << "TRACE, FromRequestQueue, Handle:  "
+                                   << op->getHandle()
+                                   << LL_ENDL;
+            }
+
+            // Stage
+            op->stageFromRequest(this);
+        }
+
+        // Done with operation
+        op.reset();
+    }
+
+    // Queue emptied, allow polling loop to sleep
+    return REQUEST_SLEEP;
+}
+
+
+HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+                                        long * ret_value)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range
+        || opt >= HttpRequest::PO_LAST                                                  // ditto
+        || (! sOptionDesc[opt].mIsLong)                                                 // datatype is long
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range
+        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass))    // class setting permitted
+                                                                                        // can always get, no dynamic check
+    {
+        return HttpStatus(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+    }
+
+    HttpStatus status;
+    if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+    {
+        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+        status = opts.get(opt, ret_value);
+    }
+    else
+    {
+        HttpPolicyClass & opts(mPolicy->getClassOptions(pclass));
+
+        status = opts.get(opt, ret_value);
+    }
+
+    return status;
+}
+
+
+HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+                                        std::string * ret_value)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+
+    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range
+        || opt >= HttpRequest::PO_LAST                                                  // ditto
+        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range
+        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass))    // class setting permitted
+                                                                                        // can always get, no dynamic check
+    {
+        return status;
+    }
+
+    // Only global has string values
+    if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+    {
+        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+        status = opts.get(opt, ret_value);
+    }
+
+    return status;
+}
+
+HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+    HttpRequest::policyCallback_t * ret_value)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+
+    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range
+        || opt >= HttpRequest::PO_LAST                                                  // ditto
+        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range
+        || (pclass == HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsGlobal) // global setting permitted
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsClass)) // class setting permitted
+        // can always get, no dynamic check
+    {
+        return status;
+    }
+
+    // Only global has callback values
+    if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+    {
+        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+        status = opts.get(opt, ret_value);
+    }
+
+    return status;
+}
+
+
+
+HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+                                        long value, long * ret_value)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+
+    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range
+        || opt >= HttpRequest::PO_LAST                                                  // ditto
+        || (! sOptionDesc[opt].mIsLong)                                                 // datatype is long
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range
+        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass)     // class setting permitted
+        || (RUNNING == sState && ! sOptionDesc[opt].mIsDynamic))                        // dynamic setting permitted
+    {
+        return status;
+    }
+
+    if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+    {
+        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+        status = opts.set(opt, value);
+        if (status && ret_value)
+        {
+            status = opts.get(opt, ret_value);
+        }
+    }
+    else
+    {
+        HttpPolicyClass & opts(mPolicy->getClassOptions(pclass));
+
+        status = opts.set(opt, value);
+        if (status)
+        {
+            mTransport->policyUpdated(pclass);
+            if (ret_value)
+            {
+                status = opts.get(opt, ret_value);
+            }
+        }
+    }
+
+    return status;
+}
+
+
+HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+                                        const std::string & value, std::string * ret_value)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+
+    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range
+        || opt >= HttpRequest::PO_LAST                                                  // ditto
+        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range
+        || (pclass == HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsGlobal)    // global setting permitted
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && ! sOptionDesc[opt].mIsClass)     // class setting permitted
+        || (RUNNING == sState && ! sOptionDesc[opt].mIsDynamic))                        // dynamic setting permitted
+    {
+        return status;
+    }
+
+    // String values are always global (at this time).
+    if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+    {
+        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+        status = opts.set(opt, value);
+        if (status && ret_value)
+        {
+            status = opts.get(opt, ret_value);
+        }
+    }
+
+    return status;
+}
+
+HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+    HttpRequest::policyCallback_t value, HttpRequest::policyCallback_t * ret_value)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK;
+    HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+
+    if (opt < HttpRequest::PO_CONNECTION_LIMIT                                          // option must be in range
+        || opt >= HttpRequest::PO_LAST                                                  // ditto
+        || (sOptionDesc[opt].mIsLong)                                                   // datatype is string
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)            // pclass in valid range
+        || (pclass == HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsGlobal) // global setting permitted
+        || (pclass != HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsClass)      // class setting permitted
+        || (RUNNING == sState && !sOptionDesc[opt].mIsDynamic))                     // dynamic setting permitted
+    {
+        return status;
+    }
+
+    // Callbacks values are always global (at this time).
+    if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+    {
+        HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+        status = opts.set(opt, value);
+        if (status && ret_value)
+        {
+            status = opts.get(opt, ret_value);
+        }
+    }
+
+    return status;
+}
+
+
+}  // end namespace LLCore