Merged Experimental branch (exp) back into main line (next).

Git thought many files (almost 100) had merge conflicts. But, after
resolving the conflicts (which were mostly trivial), almost all the
files turned out to be the same as in the exp branch. So, the
conflicts are not listed here. Check the diff between commit 244ffe8
and this commit to see what really changed.

90 files changed, 2731 insertions, 769 deletions

diff --git a/linden/indra/llcommon/CMakeLists.txt b/linden/indra/llcommon/CMakeLists.txt
index 3f14be6..ed04ca6 100644
--- a/linden/indra/llcommon/CMakeLists.txt
+++ b/linden/indra/llcommon/CMakeLists.txt
@@ -4,6 +4,7 @@ project(llcommon)
 
 include(00-Common)
 include(LLCommon)
+include(Linking)
 
 include_directories(
     ${EXPAT_INCLUDE_DIRS}
@@ -12,9 +13,13 @@ include_directories(
     )
 
 set(llcommon_SOURCE_FILES
+    aiaprpool.cpp
+    imageids.cpp
+    indra_constants.cpp
     llapp.cpp
     llapr.cpp
     llassettype.cpp
+    llavatarname.cpp
     llbase32.cpp
     llbase64.cpp
     llcommon.cpp
@@ -42,6 +47,7 @@ set(llcommon_SOURCE_FILES
     llmetrics.cpp
     llmortician.cpp
     llprocessor.cpp
+    llprocesslauncher.cpp
     llqueuedthread.cpp
     llrand.cpp
     llrun.cpp
@@ -70,6 +76,8 @@ set(llcommon_SOURCE_FILES
 set(llcommon_HEADER_FILES
     CMakeLists.txt
 
+    aiaprpool.h
+    aithreadsafe.h
     bitpack.h
     ctype_workaround.h
     doublelinkedlist.h
@@ -83,6 +91,7 @@ set(llcommon_HEADER_FILES
     llassettype.h
     llassoclist.h
     llavatarconstants.h
+    llavatarname.h
     llbase32.h
     llbase64.h
     llboost.h
@@ -136,12 +145,14 @@ set(llcommon_HEADER_FILES
     llnametable.h
     llpreprocessor.h
     llpriqueuemap.h
+    llprocesslauncher.h
     llprocessor.h
     llptrskiplist.h
     llptrskipmap.h
     llqueuedthread.h
     llrand.h
     llrun.h
+    llscopedvolatileaprpool.h
     llsd.h
     llsdserialize.h
     llsdserialize_xml.h
@@ -188,11 +199,22 @@ set_source_files_properties(${llcommon_HEADER_FILES}
 
 list(APPEND llcommon_SOURCE_FILES ${llcommon_HEADER_FILES})
 
-add_library (llcommon ${llcommon_SOURCE_FILES})
+add_library (llcommon SHARED ${llcommon_SOURCE_FILES})
 target_link_libraries(
     llcommon
     ${APRUTIL_LIBRARIES}
     ${APR_LIBRARIES}
     ${EXPAT_LIBRARIES}
     ${ZLIB_LIBRARIES}
+    ${WINDOWS_LIBRARIES}
     )
+
+if (DARWIN)
+  # don't embed a full path in the library's install name
+  set_target_properties(
+    llcommon
+    PROPERTIES
+    BUILD_WITH_INSTALL_RPATH 1
+    INSTALL_NAME_DIR "@executable_path/../Resources"
+    )
+endif (DARWIN)
diff --git a/linden/indra/llcommon/aiaprpool.cpp b/linden/indra/llcommon/aiaprpool.cpp
new file mode 100644
index 0000000..d3748e9
--- /dev/null
+++ b/linden/indra/llcommon/aiaprpool.cpp
@@ -0,0 +1,198 @@
+/**
+ * @file aiaprpool.cpp
+ *
+ * Copyright (c) 2010, Aleric Inglewood.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   04/04/2010
+ *   - Initial version, written by Aleric Inglewood @ SL
+ *
+ *   10/11/2010
+ *   - Changed filename, class names and license to a more
+ *     company-neutral format.
+ *   - Added APR_HAS_THREADS #if's to allow creation and destruction
+ *     of subpools by threads other than the parent pool owner.
+ */
+
+#include "linden_common.h"
+
+#include "llerror.h"
+#include "aiaprpool.h"
+#include "llthread.h"
+
+// Create a subpool from parent.
+void AIAPRPool::create(AIAPRPool& parent)
+{
+        llassert(!mPool);                       // Must be non-initialized.
+        mParent = &parent;
+        if (!mParent)                           // Using the default parameter?
+        {
+                // By default use the root pool of the current thread.
+                mParent = &AIThreadLocalData::tldata().mRootPool;
+        }
+        llassert(mParent->mPool);       // Parent must be initialized.
+#if APR_HAS_THREADS
+        // As per the documentation of APR (ie http://apr.apache.org/docs/apr/1.4/apr__pools_8h.html):
+        //
+        // Note that most operations on pools are not thread-safe: a single pool should only be
+        // accessed by a single thread at any given time. The one exception to this rule is creating
+        // a subpool of a given pool: one or more threads can safely create subpools at the same
+        // time that another thread accesses the parent pool.
+        //
+        // In other words, it's safe for any thread to create a (sub)pool, independent of who
+        // owns the parent pool.
+        mOwner = apr_os_thread_current();
+#else
+        mOwner = mParent->mOwner;
+        llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+#endif
+        apr_status_t const apr_pool_create_status = apr_pool_create(&mPool, mParent->mPool);
+        llassert_always(apr_pool_create_status == APR_SUCCESS);
+        llassert(mPool);                        // Initialized.
+        apr_pool_cleanup_register(mPool, this, &s_plain_cleanup, &apr_pool_cleanup_null);
+}
+
+// Destroy the (sub)pool, if any.
+void AIAPRPool::destroy(void)
+{
+        // Only do anything if we are not already (being) destroyed.
+        if (mPool)
+        {
+#if !APR_HAS_THREADS
+                // If we are a root pool, then every thread may destruct us: in that case
+                // we have to assume that no other thread will use this pool concurrently,
+                // of course. Otherwise, if we are a subpool, only the thread that owns
+                // the parent may destruct us, since that is the pool that is still alive,
+                // possibly being used by others and being altered here.
+                llassert(!mParent || apr_os_thread_equal(mParent->mOwner, apr_os_thread_current()));
+#endif
+                apr_pool_t* pool = mPool;
+                mPool = NULL;                           // Mark that we are BEING destructed.
+                apr_pool_cleanup_kill(pool, this, &s_plain_cleanup);
+                apr_pool_destroy(pool);
+        }
+}
+
+bool AIAPRPool::parent_is_being_destructed(void)
+{
+        return mParent && (!mParent->mPool || mParent->parent_is_being_destructed());
+}
+
+AIAPRInitialization::AIAPRInitialization(void)
+{
+        static bool apr_initialized = false;
+
+        if (!apr_initialized)
+        {
+                apr_initialize();
+        }
+
+        apr_initialized = true;
+}
+
+bool AIAPRRootPool::sCountInitialized = false;
+apr_uint32_t volatile AIAPRRootPool::sCount;
+
+extern apr_thread_mutex_t* gLogMutexp;
+extern apr_thread_mutex_t* gCallStacksLogMutexp;
+
+AIAPRRootPool::AIAPRRootPool(void) : AIAPRInitialization(), AIAPRPool(0)
+{
+        // sCountInitialized don't need locking because when we get here there is still only a single thread.
+        if (!sCountInitialized)
+        {
+                // Initialize the logging mutex
+                apr_thread_mutex_create(&gLogMutexp, APR_THREAD_MUTEX_UNNESTED, mPool);
+                apr_thread_mutex_create(&gCallStacksLogMutexp, APR_THREAD_MUTEX_UNNESTED, mPool);
+
+                apr_status_t status = apr_atomic_init(mPool);
+                llassert_always(status == APR_SUCCESS);
+                apr_atomic_set32(&sCount, 1);   // Set to 1 to account for the global root pool.
+                sCountInitialized = true;
+
+                // Initialize thread-local APR pool support.
+                // Because this recursively calls AIAPRRootPool::AIAPRRootPool(void)
+                // it must be done last, so that sCount is already initialized.
+                AIThreadLocalData::init();
+        }
+        apr_atomic_inc32(&sCount);
+}
+
+AIAPRRootPool::~AIAPRRootPool()
+{
+        if (!apr_atomic_dec32(&sCount))
+        {
+                // The last pool was destructed. Cleanup remainder of APR.
+                LL_INFOS("APR") << "Cleaning up APR" << LL_ENDL;
+
+                if (gLogMutexp)
+                {
+                        // Clean up the logging mutex
+
+                        // All other threads NEED to be done before we clean up APR, so this is okay.
+                        apr_thread_mutex_destroy(gLogMutexp);
+                        gLogMutexp = NULL;
+                }
+                if (gCallStacksLogMutexp)
+                {
+                        // Clean up the logging mutex
+
+                        // All other threads NEED to be done before we clean up APR, so this is okay.
+                        apr_thread_mutex_destroy(gCallStacksLogMutexp);
+                        gCallStacksLogMutexp = NULL;
+                }
+
+                // Must destroy ALL, and therefore this last AIAPRRootPool, before terminating APR.
+                static_cast<AIAPRRootPool*>(this)->destroy();
+
+                apr_terminate();
+        }
+}
+
+//static
+AIAPRRootPool& AIAPRRootPool::get(void)
+{
+  static AIAPRRootPool global_APRpool(0);               // This is what used to be gAPRPoolp.
+  return global_APRpool;
+}
+
+void AIVolatileAPRPool::clearVolatileAPRPool()
+{
+        llassert_always(mNumActiveRef > 0);
+        if (--mNumActiveRef == 0)
+        {
+                if (isOld())
+                {
+                        destroy();
+                        mNumTotalRef = 0 ;
+                }
+                else
+                {
+                        // This does not actually free the memory,
+                        // it just allows the pool to re-use this memory for the next allocation.
+                        clear();
+                }
+        }
+
+        // Paranoia check if the pool is jammed.
+        llassert(mNumTotalRef < (FULL_VOLATILE_APR_POOL << 2)) ;
+}
diff --git a/linden/indra/llcommon/aiaprpool.h b/linden/indra/llcommon/aiaprpool.h
new file mode 100644
index 0000000..ac523a9
--- /dev/null
+++ b/linden/indra/llcommon/aiaprpool.h
@@ -0,0 +1,240 @@
+/**
+ * @file aiaprpool.h
+ * @brief Implementation of AIAPRPool.
+ *
+ * Copyright (c) 2010, Aleric Inglewood.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   04/04/2010
+ *   - Initial version, written by Aleric Inglewood @ SL
+ *
+ *   10/11/2010
+ *   - Changed filename, class names and license to a more
+ *     company-neutral format.
+ *   - Added APR_HAS_THREADS #if's to allow creation and destruction
+ *     of subpools by threads other than the parent pool owner.
+ */
+
+#ifndef AIAPRPOOL_H
+#define AIAPRPOOL_H
+
+#ifdef LL_WINDOWS
+//#include <ws2tcpip.h>         
+# define WIN32_LEAN_AND_MEAN
+# include <winsock2.h> // Needed before including apr_portable.h
+#endif
+
+#include "apr_portable.h"
+#include "apr_pools.h"
+#include "llerror.h"
+
+extern void ll_init_apr();
+
+/**
+ * @brief A wrapper around the APR memory pool API.
+ *
+ * Usage of this class should be restricted to passing it to libapr-1 function calls that need it.
+ *
+ */
+class LL_COMMON_API AIAPRPool
+{
+protected:
+        apr_pool_t* mPool;                                      //!< Pointer to the underlaying pool. NULL if not initialized.
+        AIAPRPool* mParent;                     //!< Pointer to the parent pool, if any. Only valid when mPool is non-zero.
+        apr_os_thread_t mOwner;                         //!< The thread that owns this memory pool. Only valid when mPool is non-zero.
+
+public:
+        //! Construct an uninitialized (destructed) pool.
+        AIAPRPool(void) : mPool(NULL) { }
+
+    //! Construct a subpool from an existing pool.
+        // This is not a copy-constructor, this class doesn't have one!
+        AIAPRPool(AIAPRPool& parent) : mPool(NULL) { create(parent); }
+
+        //! Destruct the memory pool (free all of it's subpools and allocated memory).
+        ~AIAPRPool() { destroy(); }
+
+protected:
+        // Create a pool that is allocated from the Operating System. Only used by AIAPRRootPool.
+        AIAPRPool(int) : mPool(NULL), mParent(NULL), mOwner(apr_os_thread_current())
+        {
+                apr_status_t const apr_pool_create_status = apr_pool_create(&mPool, NULL);
+                llassert_always(apr_pool_create_status == APR_SUCCESS);
+                llassert(mPool);
+                apr_pool_cleanup_register(mPool, this, &s_plain_cleanup, &apr_pool_cleanup_null);
+        }
+
+public:
+        //! Create a subpool from parent. May only be called for an uninitialized/destroyed pool.
+        // The default parameter causes the root pool of the current thread to be used.
+        void create(AIAPRPool& parent = *static_cast<AIAPRPool*>(NULL));
+
+        //! Destroy the (sub)pool, if any.
+        void destroy(void);
+
+        // Use some safebool idiom (http://www.artima.com/cppsource/safebool.html) rather than operator bool.
+        typedef apr_pool_t* const AIAPRPool::* const bool_type;
+        //! Return true if the pool is initialized.
+        operator bool_type() const { return mPool ? &AIAPRPool::mPool : 0; }
+
+        // Painful, but we have to either provide access to this, or wrap
+        // every APR function call that needs a apr_pool_t* to be passed.
+        // NEVER destroy a pool that is returned by this function!
+        apr_pool_t* operator()(void) const
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                return mPool;
+        }
+
+        // Free all memory without destructing the pool.
+        void clear(void)
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                apr_pool_clear(mPool);
+        }
+
+// These methods would make this class 'complete' (as wrapper around the libapr
+// pool functions), but we don't use memory pools in the viewer (only when
+// we are forced to pass one to a libapr call), so don't define them in order
+// not to encourage people to use them.
+#if 0
+        void* palloc(size_t size)
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                return apr_palloc(mPool, size);
+        }
+        void* pcalloc(size_t size)
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                return apr_pcalloc(mPool, size);
+        }
+#endif
+
+private:
+        bool parent_is_being_destructed(void);
+        static apr_status_t s_plain_cleanup(void* userdata) { return static_cast<AIAPRPool*>(userdata)->plain_cleanup(); }
+
+        apr_status_t plain_cleanup(void)
+        {
+                if (mPool &&                                            // We are not being destructed,
+                        parent_is_being_destructed())   // but our parent is.
+                  // This means the pool is being destructed recursively by libapr
+                  // because one of it's parents is being destructed.
+                {
+                        mPool = NULL;   // Stop destroy() from destructing the pool again.
+                }
+                return APR_SUCCESS;
+        }
+};
+
+class AIAPRInitialization
+{
+public:
+        AIAPRInitialization(void);
+};
+
+/**
+ * @brief Root memory pool (allocates memory from the operating system).
+ *
+ * This class should only be used by AIThreadLocalData and AIThreadSafeSimpleDCRootPool_pbase
+ * (and LLMutexRootPool when APR_HAS_THREADS isn't defined).
+ */
+class LL_COMMON_API AIAPRRootPool : public AIAPRInitialization, public AIAPRPool
+{
+private:
+        friend class AIThreadLocalData;
+        friend class AIThreadSafeSimpleDCRootPool_pbase;
+#if !APR_HAS_THREADS
+        friend class LLMutexRootPool;
+#endif
+        //! Construct a root memory pool.
+        //  Should only be used by AIThreadLocalData and AIThreadSafeSimpleDCRootPool_pbase.
+        AIAPRRootPool(void);
+        ~AIAPRRootPool();
+
+private:
+        // Keep track of how many root pools exist and when the last one is destructed.
+        static bool sCountInitialized;
+        static apr_uint32_t volatile sCount;
+
+public:
+        // Return a global root pool that is independent of AIThreadLocalData.
+        // Normally you should not use this. Only use for early initialization
+        // (before main) and deinitialization (after main).
+        static AIAPRRootPool& get(void);
+
+#if APR_POOL_DEBUG
+        void grab_ownership(void)
+        {
+                // You need a patched libapr to use this.
+                // See http://web.archiveorange.com/archive/v/5XO9y2zoxUOMt6Gmi1OI
+                apr_pool_owner_set(mPool);
+        }
+#endif
+
+private:
+        // Used for constructing the Special Global Root Pool (returned by AIAPRRootPool::get).
+        // It is the same as the default constructor but omits to increment sCount. As a result,
+        // we must be sure that at least one other AIAPRRootPool is created before termination
+        // of the application (which is the case: we create one AIAPRRootPool per thread).
+        AIAPRRootPool(int) : AIAPRInitialization(), AIAPRPool(0) { }
+};
+
+//! Volatile memory pool
+//
+// 'Volatile' APR memory pool which normally only clears memory,
+// and does not destroy the pool (the same pool is reused) for
+// greater efficiency. However, as a safe guard the apr pool
+// is destructed every FULL_VOLATILE_APR_POOL uses to allow
+// the system memory to be allocated more efficiently and not
+// get scattered through RAM.
+//
+class LL_COMMON_API AIVolatileAPRPool : protected AIAPRPool
+{
+public:
+        AIVolatileAPRPool(void) : mNumActiveRef(0), mNumTotalRef(0) { }
+
+        apr_pool_t* getVolatileAPRPool(void)
+        {
+                if (!mPool) create();
+                ++mNumActiveRef;
+                ++mNumTotalRef;
+                return AIAPRPool::operator()();
+        }
+        void clearVolatileAPRPool(void);
+
+        bool isOld(void) const { return mNumTotalRef > FULL_VOLATILE_APR_POOL; }
+        bool isUnused() const { return mNumActiveRef == 0; }
+
+private:
+        S32 mNumActiveRef;      // Number of active uses of the pool.
+        S32 mNumTotalRef;       // Number of total uses of the pool since last creation.
+
+        // Maximum number of references to AIVolatileAPRPool until the pool is recreated.
+        static S32 const FULL_VOLATILE_APR_POOL = 1024;
+};
+
+#endif // AIAPRPOOL_H
diff --git a/linden/indra/llcommon/aithreadsafe.h b/linden/indra/llcommon/aithreadsafe.h
new file mode 100644
index 0000000..e1b93ba
--- /dev/null
+++ b/linden/indra/llcommon/aithreadsafe.h
@@ -0,0 +1,463 @@
+/**
+ * @file aithreadsafe.h
+ * @brief Implementation of AIThreadSafe, AIReadAccessConst, AIReadAccess and AIWriteAccess.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   31/03/2010
+ *   Initial version, written by Aleric Inglewood @ SL
+ */
+
+#ifndef AITHREADSAFE_H
+#define AITHREADSAFE_H
+
+#include <new>
+
+#include "llthread.h"
+#include "llerror.h"
+
+template<typename T> struct AIReadAccessConst;
+template<typename T> struct AIReadAccess;
+template<typename T> struct AIWriteAccess;
+template<typename T> struct AIAccess;
+
+template<typename T>
+class AIThreadSafeBits
+{
+private:
+        // AIThreadSafe is a wrapper around an instance of T.
+        // Because T might not have a default constructor, it is constructed
+        // 'in place', with placement new, in the memory reserved here.
+        //
+        // Make sure that the memory that T will be placed in is properly
+        // aligned by using an array of long's.
+        long mMemory[(sizeof(T) + sizeof(long) - 1) / sizeof(long)];
+
+public:
+        // The wrapped objects are constructed in-place with placement new *outside*
+        // of this object (by AITHREADSAFE macro(s) or derived classes).
+        // However, we are responsible for the destruction of the wrapped object.
+        ~AIThreadSafeBits() { ptr()->~T(); }
+
+        // Only for use by AITHREADSAFE, see below.
+        void* memory() const { return const_cast<long*>(&mMemory[0]); }
+
+protected:
+        // Accessors.
+        T const* ptr() const { return reinterpret_cast<T const*>(mMemory); }
+        T* ptr() { return reinterpret_cast<T*>(mMemory); }
+};
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread, allowing concurrent readers.
+ *
+ * Use AITHREADSAFE to define instances of any type, and use AIReadAccessConst,
+ * AIReadAccess and AIWriteAccess to get access to the instance.
+ *
+ * For example,
+ *
+ * <code>
+ * class Foo { public: Foo(int, int); };
+ *
+ * AITHREADSAFE(Foo, foo, (2, 3));
+ *
+ * AIReadAccess<Foo> foo_r(foo);
+ * // Use foo_r-> for read access.
+ *
+ * AIWriteAccess<Foo> foo_w(foo);
+ * // Use foo_w-> for write access.
+ * </code>
+ *
+ * If <code>foo</code> is constant, you have to use <code>AIReadAccessConst<Foo></code>.
+ *
+ * It is possible to pass access objects to a function that
+ * downgrades the access, for example:
+ *
+ * <code>
+ * void readfunc(AIReadAccess const& access);
+ *
+ * AIWriteAccess<Foo> foo_w(foo);
+ * readfunc(foo_w);                                     // readfunc will perform read access to foo_w.
+ * </code>
+ *
+ * If <code>AIReadAccess</code> is non-const, you can upgrade the access by creating
+ * an <code>AIWriteAccess</code> object from it. For example:
+ *
+ * <code>
+ * AIWriteAccess<Foo> foo_w(foo_r);
+ * </code>
+ *
+ * This API is Robust(tm). If you try anything that could result in problems,
+ * it simply won't compile. The only mistake you can still easily make is
+ * to obtain write access to an object when it is not needed, or to unlock
+ * an object in between accesses while the state of the object should be
+ * preserved. For example:
+ *
+ * <code>
+ * // This resets foo to point to the first file and then returns that.
+ * std::string filename = AIWriteAccess<Foo>(foo)->get_first_filename();
+ *
+ * // WRONG! The state between calling get_first_filename and get_next_filename should be preserved!
+ *
+ * AIWriteAccess<Foo> foo_w(foo);       // Wrong. The code below only needs read-access.
+ * while (!filename.empty())
+ * {
+ *     something(filename);
+ *     filename = foo_w->next_filename();
+ * }
+ * </code>
+ *
+ * Correct would be
+ *
+ * <code>
+ * AIReadAccess<Foo> foo_r(foo);
+ * std::string filename = AIWriteAccess<Foo>(foo_r)->get_first_filename();
+ * while (!filename.empty())
+ * {
+ *     something(filename);
+ *     filename = foo_r->next_filename();
+ * }
+ * </code>
+ *
+ */
+template<typename T>
+class AIThreadSafe : public AIThreadSafeBits<T>
+{
+protected:
+        // Only these may access the object (through ptr()).
+        friend struct AIReadAccessConst<T>;
+        friend struct AIReadAccess<T>;
+        friend struct AIWriteAccess<T>;
+
+        // Locking control.
+        AIRWLock mRWLock;
+
+        // For use by AIThreadSafeDC
+        AIThreadSafe(void) { }
+        AIThreadSafe(AIAPRPool& parent) : mRWLock(parent) { }
+
+public:
+        // Only for use by AITHREADSAFE, see below.
+        AIThreadSafe(T* object) { llassert(object == AIThreadSafeBits<T>::ptr()); }
+};
+
+/**
+ * @brief Instantiate an static, global or local object of a given type wrapped in AIThreadSafe, using an arbitrary constructor.
+ *
+ * For example, instead of doing
+ *
+ * <code>
+ * Foo foo(x, y);
+ * static Bar bar;
+ * </code>
+ *
+ * One can instantiate a thread-safe instance with
+ *
+ * <code>
+ * AITHREADSAFE(Foo, foo, (x, y));
+ * static AITHREADSAFE(Bar, bar, );
+ * </code>
+ *
+ * Note: This macro does not allow to allocate such object on the heap.
+ *       If that is needed, have a look at AIThreadSafeDC.
+ */
+#define AITHREADSAFE(type, var, paramlist) AIThreadSafe<type> var(new (var.memory()) type paramlist)
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * This class is the same as an AIThreadSafe wrapper, except that it can only
+ * be used for default constructed objects.
+ *
+ * For example, instead of
+ *
+ * <code>
+ * Foo foo;
+ * </code>
+ *
+ * One would use
+ *
+ * <code>
+ * AIThreadSafeDC<Foo> foo;
+ * </code>
+ *
+ * The advantage over AITHREADSAFE is that this object can be allocated with
+ * new on the heap. For example:
+ *
+ * <code>
+ * AIThreadSafeDC<Foo>* ptr = new AIThreadSafeDC<Foo>;
+ * </code>
+ *
+ * which is not possible with AITHREADSAFE.
+ */
+template<typename T>
+class AIThreadSafeDC : public AIThreadSafe<T>
+{
+public:
+        // Construct a wrapper around a default constructed object.
+        AIThreadSafeDC(void) { new (AIThreadSafe<T>::ptr()) T; }
+};
+
+/**
+ * @brief Read lock object and provide read access.
+ */
+template<typename T>
+struct AIReadAccessConst
+{
+        //! Internal enum for the lock-type of the AI*Access object.
+        enum state_type
+        {
+                readlocked,                     //!< A AIReadAccessConst or AIReadAccess.
+                read2writelocked,       //!< A AIWriteAccess constructed from a AIReadAccess.
+                writelocked,            //!< A AIWriteAccess constructed from a AIThreadSafe.
+                write2writelocked       //!< A AIWriteAccess constructed from (the AIReadAccess base class of) a AIWriteAccess.
+        };
+
+        //! Construct a AIReadAccessConst from a constant AIThreadSafe.
+        AIReadAccessConst(AIThreadSafe<T> const& wrapper)
+                : mWrapper(const_cast<AIThreadSafe<T>&>(wrapper)),
+                  mState(readlocked)
+                {
+                        mWrapper.mRWLock.rdlock();
+                }
+
+        //! Destruct the AI*Access object.
+        // These should never be dynamically allocated, so there is no need to make this virtual.
+        ~AIReadAccessConst()
+                {
+                        if (mState == readlocked)
+                                mWrapper.mRWLock.rdunlock();
+                        else if (mState == writelocked)
+                                mWrapper.mRWLock.wrunlock();
+                        else if (mState == read2writelocked)
+                                mWrapper.mRWLock.wr2rdlock();
+                }
+
+        //! Access the underlaying object for read access.
+        T const* operator->() const { return mWrapper.ptr(); }
+
+        //! Access the underlaying object for read access.
+        T const& operator*() const { return *mWrapper.ptr(); }
+
+protected:
+        //! Constructor used by AIReadAccess.
+        AIReadAccessConst(AIThreadSafe<T>& wrapper, state_type state)
+                : mWrapper(wrapper), mState(state) { }
+
+        AIThreadSafe<T>& mWrapper;      //!< Reference to the object that we provide access to.
+        state_type const mState;        //!< The lock state that mWrapper is in.
+
+private:
+        // Disallow copy constructing directly.
+        AIReadAccessConst(AIReadAccessConst const&);
+};
+
+/**
+ * @brief Read lock object and provide read access, with possible promotion to write access.
+ */
+template<typename T>
+struct AIReadAccess : public AIReadAccessConst<T>
+{
+        typedef typename AIReadAccessConst<T>::state_type state_type;
+        using AIReadAccessConst<T>::readlocked;
+
+        //! Construct a AIReadAccess from a non-constant AIThreadSafe.
+        AIReadAccess(AIThreadSafe<T>& wrapper) : AIReadAccessConst<T>(wrapper, readlocked) { this->mWrapper.mRWLock.rdlock(); }
+
+protected:
+        //! Constructor used by AIWriteAccess.
+        AIReadAccess(AIThreadSafe<T>& wrapper, state_type state) : AIReadAccessConst<T>(wrapper, state) { }
+
+        friend class AIWriteAccess<T>;
+};
+
+/**
+ * @brief Write lock object and provide read/write access.
+ */
+template<typename T>
+struct AIWriteAccess : public AIReadAccess<T>
+{
+        using AIReadAccessConst<T>::readlocked;
+        using AIReadAccessConst<T>::read2writelocked;
+        using AIReadAccessConst<T>::writelocked;
+        using AIReadAccessConst<T>::write2writelocked;
+
+        //! Construct a AIWriteAccess from a non-constant AIThreadSafe.
+        AIWriteAccess(AIThreadSafe<T>& wrapper) : AIReadAccess<T>(wrapper, writelocked) { this->mWrapper.mRWLock.wrlock();}
+
+        //! Promote read access to write access.
+        explicit AIWriteAccess(AIReadAccess<T>& access)
+                : AIReadAccess<T>(access.mWrapper, (access.mState == readlocked) ? read2writelocked : write2writelocked)
+                {
+                        if (this->mState == read2writelocked)
+                        {
+                                this->mWrapper.mRWLock.rd2wrlock();
+                        }
+                }
+
+        //! Access the underlaying object for (read and) write access.
+        T* operator->() const { return this->mWrapper.ptr(); }
+
+        //! Access the underlaying object for (read and) write access.
+        T& operator*() const { return *this->mWrapper.ptr(); }
+};
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * Use AITHREADSAFESIMPLE to define instances of any type, and use AIAccess
+ * to get access to the instance.
+ *
+ * For example,
+ *
+ * <code>
+ * class Foo { public: Foo(int, int); };
+ *
+ * AITHREADSAFESIMPLE(Foo, foo, (2, 3));
+ *
+ * AIAccess<Foo> foo_w(foo);
+ * // Use foo_w-> for read and write access.
+ *
+ * See also AIThreadSafe
+ */
+template<typename T>
+class AIThreadSafeSimple : public AIThreadSafeBits<T>
+{
+protected:
+        // Only this one may access the object (through ptr()).
+        friend struct AIAccess<T>;
+
+        // Locking control.
+        LLMutex mMutex;
+
+        // For use by AIThreadSafeSimpleDC
+        AIThreadSafeSimple(void) { }
+        AIThreadSafeSimple(AIAPRPool& parent) : mMutex(parent) { }
+
+public:
+        // Only for use by AITHREADSAFESIMPLE, see below.
+        AIThreadSafeSimple(T* object) { llassert(object == AIThreadSafeBits<T>::ptr()); }
+};
+
+/**
+ * @brief Instantiate an static, global or local object of a given type wrapped in AIThreadSafeSimple, using an arbitrary constructor.
+ *
+ * For example, instead of doing
+ *
+ * <code>
+ * Foo foo(x, y);
+ * static Bar bar;
+ * </code>
+ *
+ * One can instantiate a thread-safe instance with
+ *
+ * <code>
+ * AITHREADSAFESIMPLE(Foo, foo, (x, y));
+ * static AITHREADSAFESIMPLE(Bar, bar, );
+ * </code>
+ *
+ * Note: This macro does not allow to allocate such object on the heap.
+ *       If that is needed, have a look at AIThreadSafeSimpleDC.
+ */
+#define AITHREADSAFESIMPLE(type, var, paramlist) AIThreadSafeSimple<type> var(new (var.memory()) type paramlist)
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * This class is the same as an AIThreadSafeSimple wrapper, except that it can only
+ * be used for default constructed objects.
+ *
+ * For example, instead of
+ *
+ * <code>
+ * Foo foo;
+ * </code>
+ *
+ * One would use
+ *
+ * <code>
+ * AIThreadSafeSimpleDC<Foo> foo;
+ * </code>
+ *
+ * The advantage over AITHREADSAFESIMPLE is that this object can be allocated with
+ * new on the heap. For example:
+ *
+ * <code>
+ * AIThreadSafeSimpleDC<Foo>* ptr = new AIThreadSafeSimpleDC<Foo>;
+ * </code>
+ *
+ * which is not possible with AITHREADSAFESIMPLE.
+ */
+template<typename T>
+class AIThreadSafeSimpleDC : public AIThreadSafeSimple<T>
+{
+public:
+        // Construct a wrapper around a default constructed object.
+        AIThreadSafeSimpleDC(void) { new (AIThreadSafeSimple<T>::ptr()) T; }
+
+protected:
+        // For use by AIThreadSafeSimpleDCRootPool
+        AIThreadSafeSimpleDC(AIAPRPool& parent) : AIThreadSafeSimple<T>(parent) { new (AIThreadSafeSimple<T>::ptr()) T; }
+};
+
+// Helper class for AIThreadSafeSimpleDCRootPool to assure initialization of
+// the root pool before constructing AIThreadSafeSimpleDC.
+class AIThreadSafeSimpleDCRootPool_pbase
+{
+protected:
+        AIAPRRootPool mRootPool;
+
+private:
+        template<typename T> friend class AIThreadSafeSimpleDCRootPool;
+        AIThreadSafeSimpleDCRootPool_pbase(void) { }
+};
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * The same as AIThreadSafeSimpleDC except that this class creates its own AIAPRRootPool
+ * for the internally used mutexes and condition, instead of using the current threads
+ * root pool. The advantage of this is that it can be used for objects that need to
+ * be accessed from the destructors of global objects (after main). The disadvantage
+ * is that it's less efficient to use your own root pool, therefore it's use should be
+ * restricted to those cases where it is absolutely necessary.
+ */
+template<typename T>
+class AIThreadSafeSimpleDCRootPool : private AIThreadSafeSimpleDCRootPool_pbase, public AIThreadSafeSimpleDC<T>
+{
+public:
+        // Construct a wrapper around a default constructed object, using memory allocated
+        // from the operating system for the internal APR objects (mutexes and conditional),
+        // as opposed to allocated from the current threads root pool.
+        AIThreadSafeSimpleDCRootPool(void) :
+                AIThreadSafeSimpleDCRootPool_pbase(),
+                AIThreadSafeSimpleDC<T>(mRootPool) { }
+};
+
+/**
+ * @brief Write lock object and provide read/write access.
+ */
+template<typename T>
+struct AIAccess
+{
+        //! Construct a AIAccess from a non-constant AIThreadSafeSimple.
+        AIAccess(AIThreadSafeSimple<T>& wrapper) : mWrapper(wrapper) { this->mWrapper.mMutex.lock(); }
+
+        //! Access the underlaying object for (read and) write access.
+        T* operator->() const { return this->mWrapper.ptr(); }
+
+        //! Access the underlaying object for (read and) write access.
+        T& operator*() const { return *this->mWrapper.ptr(); }
+
+        ~AIAccess() { this->mWrapper.mMutex.unlock(); }
+
+protected:
+        AIThreadSafeSimple<T>& mWrapper;        //!< Reference to the object that we provide access to.
+
+private:
+        // Disallow copy constructing directly.
+        AIAccess(AIAccess const&);
+};
+
+#endif
diff --git a/linden/indra/llcommon/imageids.cpp b/linden/indra/llcommon/imageids.cpp
new file mode 100644
index 0000000..e5343fe
--- /dev/null
+++ b/linden/indra/llcommon/imageids.cpp
@@ -0,0 +1,79 @@
+/**
+ * @file imageids.cpp
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ *
+ * Copyright (c) 2001-2010, Linden Research, Inc.
+ *
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ *
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ *
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ *
+ */
+
+#include "linden_common.h"
+
+#include "imageids.h"
+
+#include "lluuid.h"
+
+//
+// USE OF THIS FILE IS DEPRECATED
+//
+// Please use viewerart.ini and the standard
+// art import path.                                                                                                                                                     // indicates if file is only
+                                                                                                                                                // on dataserver, or also
+                                                                                                                                                        // pre-cached on viewer
+
+// Grass Images
+const LLUUID IMG_SMOKE                  ("b4ba225c-373f-446d-9f7e-6cb7b5cf9b3d");  // VIEWER
+
+const LLUUID IMG_DEFAULT                ("d2114404-dd59-4a4d-8e6c-49359e91bbf0");  // VIEWER
+
+const LLUUID IMG_SUN                    ("cce0f112-878f-4586-a2e2-a8f104bba271"); // dataserver
+const LLUUID IMG_MOON                   ("d07f6eed-b96a-47cd-b51d-400ad4a1c428"); // dataserver
+const LLUUID IMG_CLOUD_POOF             ("fc4b9f0b-d008-45c6-96a4-01dd947ac621"); // dataserver
+const LLUUID IMG_SHOT                   ("35f217a3-f618-49cf-bbca-c86d486551a9"); // dataserver
+const LLUUID IMG_SPARK                  ("d2e75ac1-d0fb-4532-820e-a20034ac814d"); // dataserver
+const LLUUID IMG_FIRE                   ("aca40aa8-44cf-44ca-a0fa-93e1a2986f82"); // dataserver
+const LLUUID IMG_FACE_SELECT    ("a85ac674-cb75-4af6-9499-df7c5aaf7a28"); // face selector
+const LLUUID IMG_DEFAULT_AVATAR ("c228d1cf-4b5d-4ba8-84f4-899a0796aa97"); // dataserver
+const LLUUID IMG_INVISIBLE              ("3a367d1c-bef1-6d43-7595-e88c1e3aadb3"); // dataserver
+
+const LLUUID IMG_EXPLOSION                              ("68edcf47-ccd7-45b8-9f90-1649d7f12806"); // On dataserver
+const LLUUID IMG_EXPLOSION_2                    ("21ce046c-83fe-430a-b629-c7660ac78d7c"); // On dataserver
+const LLUUID IMG_EXPLOSION_3                    ("fedea30a-1be8-47a6-bc06-337a04a39c4b"); // On dataserver
+const LLUUID IMG_EXPLOSION_4                    ("abf0d56b-82e5-47a2-a8ad-74741bb2c29e"); // On dataserver
+const LLUUID IMG_SMOKE_POOF                             ("1e63e323-5fe0-452e-92f8-b98bd0f764e3"); // On dataserver
+
+const LLUUID IMG_BIG_EXPLOSION_1                ("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); // On dataserver
+const LLUUID IMG_BIG_EXPLOSION_2                ("9c8eca51-53d5-42a7-bb58-cef070395db8"); // On dataserver
+
+const LLUUID IMG_BLOOM1                             ("3c59f7fe-9dc8-47f9-8aaf-a9dd1fbc3bef"); // VIEWER
+const LLUUID TERRAIN_DIRT_DETAIL                ("0bc58228-74a0-7e83-89bc-5c23464bcec5"); // VIEWER
+const LLUUID TERRAIN_GRASS_DETAIL               ("63338ede-0037-c4fd-855b-015d77112fc8"); // VIEWER
+const LLUUID TERRAIN_MOUNTAIN_DETAIL    ("303cd381-8560-7579-23f1-f0a880799740"); // VIEWER
+const LLUUID TERRAIN_ROCK_DETAIL                ("53a2f406-4895-1d13-d541-d2e3b86bc19c"); // VIEWER
+
+const LLUUID DEFAULT_WATER_NORMAL               ("822ded49-9a6c-f61c-cb89-6df54f42cdf4"); // VIEWER
+
+const LLUUID DEFAULT_UNREZZED_AVATAR_PARTICLE   ("c6e07fda-aea5-4149-acb6-6f09980e0db5"); // VIEWER only
diff --git a/linden/indra/llcommon/imageids.h b/linden/indra/llcommon/imageids.h
index 832708c..516fda1 100644
--- a/linden/indra/llcommon/imageids.h
+++ b/linden/indra/llcommon/imageids.h
@@ -33,46 +33,44 @@
 #ifndef LL_IMAGEIDS_H
 #define LL_IMAGEIDS_H
 
-#include "lluuid.h"
-
 //
 // USE OF THIS FILE IS DEPRECATED
 //
 // Please use viewerart.ini and the standard
-// art import path.                                                                                                                                                     // indicates if file is only
-                                                                                                                                                // on dataserver, or also
-                                                                                                                                                        // pre-cached on viewer
+// art import path.
+
+class LLUUID;
 
-// Grass Images
-const LLUUID IMG_SMOKE                  ("b4ba225c-373f-446d-9f7e-6cb7b5cf9b3d");  // VIEWER
+LL_COMMON_API extern const LLUUID IMG_SMOKE;
 
-const LLUUID IMG_DEFAULT                ("d2114404-dd59-4a4d-8e6c-49359e91bbf0");  // VIEWER
+LL_COMMON_API extern const LLUUID IMG_DEFAULT;
 
-const LLUUID IMG_SUN                    ("cce0f112-878f-4586-a2e2-a8f104bba271"); // dataserver
-const LLUUID IMG_MOON                   ("d07f6eed-b96a-47cd-b51d-400ad4a1c428"); // dataserver
-const LLUUID IMG_CLOUD_POOF             ("fc4b9f0b-d008-45c6-96a4-01dd947ac621"); // dataserver
-const LLUUID IMG_SHOT                   ("35f217a3-f618-49cf-bbca-c86d486551a9"); // dataserver
-const LLUUID IMG_SPARK                  ("d2e75ac1-d0fb-4532-820e-a20034ac814d"); // dataserver
-const LLUUID IMG_FIRE                   ("aca40aa8-44cf-44ca-a0fa-93e1a2986f82"); // dataserver
-const LLUUID IMG_FACE_SELECT    ("a85ac674-cb75-4af6-9499-df7c5aaf7a28"); // face selector
-const LLUUID IMG_DEFAULT_AVATAR ("c228d1cf-4b5d-4ba8-84f4-899a0796aa97"); // dataserver
-const LLUUID IMG_INVISIBLE              ("3a367d1c-bef1-6d43-7595-e88c1e3aadb3"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_SUN;
+LL_COMMON_API extern const LLUUID IMG_MOON;
+LL_COMMON_API extern const LLUUID IMG_CLOUD_POOF;
+LL_COMMON_API extern const LLUUID IMG_SHOT;
+LL_COMMON_API extern const LLUUID IMG_SPARK;
+LL_COMMON_API extern const LLUUID IMG_FIRE;
+LL_COMMON_API extern const LLUUID IMG_FACE_SELECT;
+LL_COMMON_API extern const LLUUID IMG_DEFAULT_AVATAR;
+LL_COMMON_API extern const LLUUID IMG_INVISIBLE;
 
-const LLUUID IMG_EXPLOSION                              ("68edcf47-ccd7-45b8-9f90-1649d7f12806"); // On dataserver
-const LLUUID IMG_EXPLOSION_2                    ("21ce046c-83fe-430a-b629-c7660ac78d7c"); // On dataserver
-const LLUUID IMG_EXPLOSION_3                    ("fedea30a-1be8-47a6-bc06-337a04a39c4b"); // On dataserver
-const LLUUID IMG_EXPLOSION_4                    ("abf0d56b-82e5-47a2-a8ad-74741bb2c29e"); // On dataserver
-const LLUUID IMG_SMOKE_POOF                             ("1e63e323-5fe0-452e-92f8-b98bd0f764e3"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION;
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_2;
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_3;
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_4;
+LL_COMMON_API extern const LLUUID IMG_SMOKE_POOF;
 
-const LLUUID IMG_BIG_EXPLOSION_1                ("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); // On dataserver
-const LLUUID IMG_BIG_EXPLOSION_2                ("9c8eca51-53d5-42a7-bb58-cef070395db8"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_BIG_EXPLOSION_1;
+LL_COMMON_API extern const LLUUID IMG_BIG_EXPLOSION_2;
 
-const LLUUID IMG_BLOOM1                             ("3c59f7fe-9dc8-47f9-8aaf-a9dd1fbc3bef"); // VIEWER
-const LLUUID TERRAIN_DIRT_DETAIL                ("0bc58228-74a0-7e83-89bc-5c23464bcec5"); // VIEWER
-const LLUUID TERRAIN_GRASS_DETAIL               ("63338ede-0037-c4fd-855b-015d77112fc8"); // VIEWER
-const LLUUID TERRAIN_MOUNTAIN_DETAIL    ("303cd381-8560-7579-23f1-f0a880799740"); // VIEWER
-const LLUUID TERRAIN_ROCK_DETAIL                ("53a2f406-4895-1d13-d541-d2e3b86bc19c"); // VIEWER
+LL_COMMON_API extern const LLUUID IMG_BLOOM1;
+LL_COMMON_API extern const LLUUID TERRAIN_DIRT_DETAIL;
+LL_COMMON_API extern const LLUUID TERRAIN_GRASS_DETAIL;
+LL_COMMON_API extern const LLUUID TERRAIN_MOUNTAIN_DETAIL;
+LL_COMMON_API extern const LLUUID TERRAIN_ROCK_DETAIL;
 
-const LLUUID DEFAULT_WATER_NORMAL               ("822ded49-9a6c-f61c-cb89-6df54f42cdf4"); // VIEWER
+LL_COMMON_API extern const LLUUID DEFAULT_WATER_NORMAL;
 
+LL_COMMON_API extern const LLUUID DEFAULT_UNREZZED_AVATAR_PARTICLE;
 #endif
diff --git a/linden/indra/llcommon/indra_constants.cpp b/linden/indra/llcommon/indra_constants.cpp
new file mode 100644
index 0000000..64cbb11
--- /dev/null
+++ b/linden/indra/llcommon/indra_constants.cpp
@@ -0,0 +1,47 @@
+/**
+ * @file indra_constants.cpp
+ * @brief some useful short term constants for Indra
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ *
+ * Copyright (c) 2001-2010, Linden Research, Inc.
+ *
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ *
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ *
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "indra_constants.h"
+
+#include "lluuid.h"
+
+// "agent id" for things that should be done to ALL agents
+const LLUUID LL_UUID_ALL_AGENTS("44e87126-e794-4ded-05b3-7c42da3d5cdb");
+
+// Governor Linden's agent id.
+const LLUUID ALEXANDRIA_LINDEN_ID("ba2a564a-f0f1-4b82-9c61-b7520bfcd09f");
+const LLUUID GOVERNOR_LINDEN_ID("3d6181b0-6a4b-97ef-18d8-722652995cf1");
+const LLUUID REALESTATE_LINDEN_ID("3d6181b0-6a4b-97ef-18d8-722652995cf1");
+// Maintenance's group id.
+const LLUUID MAINTENANCE_GROUP_ID("dc7b21cd-3c89-fcaa-31c8-25f9ffd224cd");
diff --git a/linden/indra/llcommon/indra_constants.h b/linden/indra/llcommon/indra_constants.h
index 96c0a1f..b765d4d 100644
--- a/linden/indra/llcommon/indra_constants.h
+++ b/linden/indra/llcommon/indra_constants.h
@@ -34,7 +34,9 @@
 #define LL_INDRA_CONSTANTS_H
 
 #include "stdtypes.h"
-#include "lluuid.h"
+#include "llpreprocessor.h"
+
+class LLUUID;
 
 // At 45 Hz collisions seem stable and objects seem
 // to settle down at a reasonable rate.
@@ -151,6 +153,11 @@ const	char	WATER_LAYER_CODE				= 'W';
 const   char    WIND_LAYER_CODE                                 = '7';
 const   char    CLOUD_LAYER_CODE                                = '8';
 
+// Extended land layer for Aurora Sim
+const   char    AURORA_LAND_LAYER_CODE                  = 'M';
+const   char    AURORA_WIND_LAYER_CODE                  = '9';
+const   char    AURORA_CLOUD_LAYER_CODE                 = ':';
+
 // keys
 // Bit masks for various keyboard modifier keys.
 const MASK MASK_NONE =                  0x0000;
@@ -261,14 +268,15 @@ const U8 GOD_LIKE = 1;
 const U8 GOD_NOT = 0;
 
 // "agent id" for things that should be done to ALL agents
-const LLUUID LL_UUID_ALL_AGENTS("44e87126-e794-4ded-05b3-7c42da3d5cdb");
+LL_COMMON_API extern const LLUUID LL_UUID_ALL_AGENTS;
+
+// inventory library owner
+LL_COMMON_API extern const LLUUID ALEXANDRIA_LINDEN_ID;
 
-// Governor Linden's agent id.
-const LLUUID ALEXANDRIA_LINDEN_ID("ba2a564a-f0f1-4b82-9c61-b7520bfcd09f");
-const LLUUID GOVERNOR_LINDEN_ID("3d6181b0-6a4b-97ef-18d8-722652995cf1");
-const LLUUID REALESTATE_LINDEN_ID("3d6181b0-6a4b-97ef-18d8-722652995cf1");
+LL_COMMON_API extern const LLUUID GOVERNOR_LINDEN_ID;
+LL_COMMON_API extern const LLUUID REALESTATE_LINDEN_ID;
 // Maintenance's group id.
-const LLUUID MAINTENANCE_GROUP_ID("dc7b21cd-3c89-fcaa-31c8-25f9ffd224cd");
+LL_COMMON_API extern const LLUUID MAINTENANCE_GROUP_ID;
 
 // Flags for kick message
 const U32 KICK_FLAGS_DEFAULT    = 0x0;
diff --git a/linden/indra/llcommon/linden_common.h b/linden/indra/llcommon/linden_common.h
index 25dd629..bf844b9 100644
--- a/linden/indra/llcommon/linden_common.h
+++ b/linden/indra/llcommon/linden_common.h
@@ -51,16 +51,16 @@
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
-#include <iostream>
-#include <fstream>
+#include <iosfwd>
 
-// Work Microsoft compiler warnings
+// Work around Microsoft compiler warnings in STL headers
 #ifdef LL_WINDOWS
 #pragma warning (disable : 4702) // unreachable code
 #pragma warning (disable : 4244) // conversion from time_t to S32
 #endif  //      LL_WINDOWS
 
-#include <algorithm>
+// *TODO: Eliminate these, most library .cpp files don't need them.
+// Add them to llviewerprecompiledheaders.h if necessary.
 #include <list>
 #include <map>
 #include <vector>
@@ -76,18 +76,21 @@
 #pragma warning (disable : 4512) // assignment operator could not be generated
 #pragma warning (disable : 4706) // assignment within conditional (even if((x = y)) )
 #pragma warning (disable : 4265) // boost 1.36.0, non-virtual destructor in boost::exception_detail::*
+
+// Reenable warnings we disabled above
+#pragma warning (3 : 4702) // unreachable code, we like level 3, not 4
+// moved msvc warnings to llpreprocessor.h  *TODO - delete this comment after merge conflicts are unlikely -brad
 #endif  //      LL_WINDOWS
 
 // Linden only libs in alpha-order other than stdtypes.h
+// *NOTE: Please keep includes here to a minimum, see above.
 #include "stdtypes.h"
 #include "lldefs.h"
 #include "llerror.h"
 #include "llextendedstatus.h"
-#include "llfasttimer.h"
+// Don't do this, adds 15K lines of header code to every library file.
+//#include "llfasttimer.h"
 #include "llfile.h"
 #include "llformat.h"
-#include "llstring.h"
-#include "llsys.h"
-#include "lltimer.h"
 
 #endif
diff --git a/linden/indra/llcommon/llapp.cpp b/linden/indra/llcommon/llapp.cpp
index 199315f..eedc503 100644
--- a/linden/indra/llcommon/llapp.cpp
+++ b/linden/indra/llcommon/llapp.cpp
@@ -119,13 +119,8 @@ void LLApp::commonCtor()
                 mOptions.append(sd);
         }
 
-        // Make sure we clean up APR when we exit
-        // Don't need to do this if we're cleaning up APR in the destructor
-        //atexit(ll_cleanup_apr);
-
         // Set the application to this instance.
         sApplication = this;
-
 }
 
 LLApp::LLApp(LLErrorThread *error_thread) :
@@ -420,7 +415,7 @@ void LLApp::incSigChildCount()
 int LLApp::getPid()
 {
 #if LL_WINDOWS
-        return 0;
+        return GetCurrentProcessId();
 #else
         return getpid();
 #endif
diff --git a/linden/indra/llcommon/llapp.h b/linden/indra/llcommon/llapp.h
index f8a593c..96112c9 100644
--- a/linden/indra/llcommon/llapp.h
+++ b/linden/indra/llcommon/llapp.h
@@ -34,14 +34,17 @@
 #define LL_LLAPP_H
 
 #include <map>
-#include "llapr.h"
 #include "llrun.h"
 #include "llsd.h"
 
 // Forward declarations
+template <typename Type> class LLAtomic32;
+typedef LLAtomic32<U32> LLAtomicU32;
 class LLErrorThread;
-class LLApp;
-
+class LLLiveFile;
+#if LL_LINUX
+typedef struct siginfo siginfo_t;
+#endif
 
 typedef void (*LLAppErrorHandler)();
 typedef void (*LLAppChildCallback)(int pid, bool exited, int status);
@@ -62,7 +65,7 @@ public:
 };
 #endif
 
-class LLApp
+class LL_COMMON_API LLApp
 {
         friend class LLErrorThread;
 public:
@@ -189,8 +192,6 @@ public:
 #if !LL_WINDOWS
         static U32  getSigChildCount();
         static void incSigChildCount();
-#else
-#define getpid GetCurrentProcessId
 #endif
         static int getPid();
 
diff --git a/linden/indra/llcommon/llapr.cpp b/linden/indra/llcommon/llapr.cpp
index 7e3a26c..a013d9c 100644
--- a/linden/indra/llcommon/llapr.cpp
+++ b/linden/indra/llcommon/llapr.cpp
@@ -34,220 +34,7 @@
 
 #include "linden_common.h"
 #include "llapr.h"
-
-apr_pool_t *gAPRPoolp = NULL; // Global APR memory pool
-apr_thread_mutex_t *gLogMutexp = NULL;
-apr_thread_mutex_t *gCallStacksLogMutexp = NULL;
-
-const S32 FULL_VOLATILE_APR_POOL = 1024 ; //number of references to LLVolatileAPRPool
-
-void ll_init_apr()
-{
-        if (!gAPRPoolp)
-        {
-                // Initialize APR and create the global pool
-                apr_initialize();
-                apr_pool_create(&gAPRPoolp, NULL);
-                
-                // Initialize the logging mutex
-                apr_thread_mutex_create(&gLogMutexp, APR_THREAD_MUTEX_UNNESTED, gAPRPoolp);
-                apr_thread_mutex_create(&gCallStacksLogMutexp, APR_THREAD_MUTEX_UNNESTED, gAPRPoolp);
-
-                // Initialize thread-local APR pool support.
-                LLVolatileAPRPool::initLocalAPRFilePool();
-        }
-}
-
-
-void ll_cleanup_apr()
-{
-        LL_INFOS("APR") << "Cleaning up APR" << LL_ENDL;
-
-        if (gLogMutexp)
-        {
-                // Clean up the logging mutex
-
-                // All other threads NEED to be done before we clean up APR, so this is okay.
-                apr_thread_mutex_destroy(gLogMutexp);
-                gLogMutexp = NULL;
-        }
-        if (gCallStacksLogMutexp)
-        {
-                // Clean up the logging mutex
-
-                // All other threads NEED to be done before we clean up APR, so this is okay.
-                apr_thread_mutex_destroy(gCallStacksLogMutexp);
-                gCallStacksLogMutexp = NULL;
-        }
-        if (gAPRPoolp)
-        {
-                apr_pool_destroy(gAPRPoolp);
-                gAPRPoolp = NULL;
-        }
-        apr_terminate();
-}
-
-//
-//
-//LLAPRPool
-//
-LLAPRPool::LLAPRPool(apr_pool_t *parent, apr_size_t size, BOOL releasePoolFlag) 
-{
-        mParent = parent ;
-        mReleasePoolFlag = releasePoolFlag ;
-        mMaxSize = size ;
-        mPool = NULL ;
-
-        createAPRPool() ;
-}
-
-LLAPRPool::~LLAPRPool() 
-{
-        releaseAPRPool() ;
-}
-
-void LLAPRPool::createAPRPool()
-{
-        if(mPool)
-        {
-                return ;
-        }
-
-        mStatus = apr_pool_create(&mPool, mParent);
-        ll_apr_warn_status(mStatus) ;
-
-        if(mMaxSize > 0) //size is the number of blocks (which is usually 4K), NOT bytes.
-        {
-                apr_allocator_t *allocator = apr_pool_allocator_get(mPool); 
-                if (allocator) 
-                { 
-                        apr_allocator_max_free_set(allocator, mMaxSize) ;
-                }
-        }
-}
-
-void LLAPRPool::releaseAPRPool()
-{
-        if(!mPool)
-        {
-                return ;
-        }
-
-        if(!mParent || mReleasePoolFlag)
-        {
-                apr_pool_destroy(mPool) ;
-                mPool = NULL ;
-        }
-}
-
-apr_pool_t* LLAPRPool::getAPRPool() 
-{
-        if(!mPool)
-        {
-                createAPRPool() ;
-        }
-        
-        return mPool ; 
-}
-LLVolatileAPRPool::LLVolatileAPRPool(apr_pool_t *parent, apr_size_t size, BOOL releasePoolFlag) 
-                                  : LLAPRPool(parent, size, releasePoolFlag)
-{
-        mNumActiveRef = 0 ;
-        mNumTotalRef = 0 ;
-}
-
-apr_pool_t* LLVolatileAPRPool::getVolatileAPRPool() 
-{
-        mNumTotalRef++ ;
-        mNumActiveRef++ ;
-        return getAPRPool() ;
-}
-
-void LLVolatileAPRPool::clearVolatileAPRPool() 
-{
-        if(mNumActiveRef > 0)
-        {
-                mNumActiveRef--;
-                if(mNumActiveRef < 1)
-                {
-                        if(isFull()) 
-                        {
-                                mNumTotalRef = 0 ;
-
-                                //destroy the apr_pool.
-                                releaseAPRPool() ;
-                        }
-                        else 
-                        {
-                                //This does not actually free the memory, 
-                                //it just allows the pool to re-use this memory for the next allocation. 
-                                apr_pool_clear(mPool) ;
-                        }
-                }
-        }
-        else
-        {
-                llassert_always(mNumActiveRef > 0) ;
-        }
-
-        //paranoia check if the pool is jammed.
-        //will remove the check before going to release.
-        llassert_always(mNumTotalRef < (FULL_VOLATILE_APR_POOL << 2)) ;
-}
-
-BOOL LLVolatileAPRPool::isFull()
-{
-        return mNumTotalRef > FULL_VOLATILE_APR_POOL ;
-}
-
-#ifdef SHOW_ASSERT
-// This allows the use of llassert(is_main_thread()) to assure the current thread is the main thread.
-static void* gIsMainThread;
-bool is_main_thread() { return gIsMainThread == LLVolatileAPRPool::getLocalAPRFilePool(); }
-#endif
-
-// The thread private handle to access the LocalAPRFilePool.
-apr_threadkey_t* LLVolatileAPRPool::sLocalAPRFilePoolKey;
-
-// This should be called exactly once, before the first call to createLocalAPRFilePool.
-// static
-void LLVolatileAPRPool::initLocalAPRFilePool()
-{
-        apr_status_t status = apr_threadkey_private_create(&sLocalAPRFilePoolKey, &destroyLocalAPRFilePool, gAPRPoolp);
-        ll_apr_assert_status(status);                   // Or out of memory, or system-imposed limit on the
-                                                        // total number of keys per process {PTHREAD_KEYS_MAX}
-                                                        // has been exceeded.
-        // Create the thread-local pool for the main thread (this function is called by the main thread).
-        createLocalAPRFilePool();
-#ifdef SHOW_ASSERT
-        gIsMainThread = getLocalAPRFilePool();
-#endif
-}
-
-// This should be called once for every thread, before it uses getLocalAPRFilePool.
-// static
-void LLVolatileAPRPool::createLocalAPRFilePool()
-{
-        void* thread_local_data = new LLVolatileAPRPool;
-        apr_status_t status = apr_threadkey_private_set(thread_local_data, sLocalAPRFilePoolKey);
-        llassert_always(status == APR_SUCCESS);
-}
-
-// This is called once for every thread when the thread is destructed.
-// static
-void LLVolatileAPRPool::destroyLocalAPRFilePool(void* thread_local_data)
-{
-        delete reinterpret_cast<LLVolatileAPRPool*>(thread_local_data);
-}
-
-// static
-LLVolatileAPRPool* LLVolatileAPRPool::getLocalAPRFilePool()
-{
-        void* thread_local_data;
-        apr_status_t status = apr_threadkey_private_get(&thread_local_data, sLocalAPRFilePoolKey);
-        llassert_always(status == APR_SUCCESS);
-        return reinterpret_cast<LLVolatileAPRPool*>(thread_local_data);
-}
+#include "llscopedvolatileaprpool.h"
 
 //---------------------------------------------------------------------
 //
@@ -310,13 +97,15 @@ void ll_apr_assert_status(apr_status_t status)
 //
 LLAPRFile::LLAPRFile()
         : mFile(NULL),
-          mCurrentFilePoolp(NULL)
+          mVolatileFilePoolp(NULL),
+          mRegularFilePoolp(NULL)
 {
 }
 
 LLAPRFile::LLAPRFile(const std::string& filename, apr_int32_t flags, access_t access_type)
         : mFile(NULL),
-          mCurrentFilePoolp(NULL)
+          mVolatileFilePoolp(NULL),
+          mRegularFilePoolp(NULL)
 {
         open(filename, flags, access_type);
 }
@@ -335,10 +124,16 @@ apr_status_t LLAPRFile::close()
                 mFile = NULL ;
         }
 
-        if(mCurrentFilePoolp)
+        if (mVolatileFilePoolp)
         {
-                mCurrentFilePoolp->clearVolatileAPRPool() ;
-                mCurrentFilePoolp = NULL ;
+                mVolatileFilePoolp->clearVolatileAPRPool() ;
+                mVolatileFilePoolp = NULL ;
+        }
+
+        if (mRegularFilePoolp)
+        {
+                delete mRegularFilePoolp;
+                mRegularFilePoolp = NULL;
         }
 
         return ret ;
@@ -347,25 +142,28 @@ apr_status_t LLAPRFile::close()
 apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, access_t access_type, S32* sizep)
 {
         llassert_always(!mFile);
-        llassert_always(!mCurrentFilePoolp);
+        llassert_always(!mVolatileFilePoolp && !mRegularFilePoolp);
 
-        // Access the pool and increment it's reference count.
-        // The reference count of LLVolatileAPRPool objects will be decremented
-        // again in LLAPRFile::close by calling mCurrentFilePoolp->clearVolatileAPRPool().
-        apr_pool_t* pool;
-        if (access_type == local)
-        {
-                // Use a "volatile" thread-local pool.
-                mCurrentFilePoolp = LLVolatileAPRPool::getLocalAPRFilePool();
-                pool = mCurrentFilePoolp->getVolatileAPRPool();
-        }
-        else
+        apr_status_t status;
         {
-                llassert(is_main_thread());
-                pool = gAPRPoolp;
+                apr_pool_t* apr_file_open_pool;
+                if (access_type == local)
+                {
+                        // Use a "volatile" thread-local pool.
+                        mVolatileFilePoolp = &AIThreadLocalData::tldata().mVolatileAPRPool;
+                        // Access the pool and increment it's reference count.
+                        // The reference count of AIVolatileAPRPool objects will be decremented
+                        // again in LLAPRFile::close by calling mVolatileFilePoolp->clearVolatileAPRPool().
+                        apr_file_open_pool = mVolatileFilePoolp->getVolatileAPRPool();
+                }
+                else
+                {
+                        mRegularFilePoolp = new AIAPRPool(AIThreadLocalData::tldata().mRootPool);
+                        apr_file_open_pool = (*mRegularFilePoolp)();
+                }
+                status = apr_file_open(&mFile, filename.c_str(), flags, APR_OS_DEFAULT, apr_file_open_pool);
         }
-        apr_status_t s = apr_file_open(&mFile, filename.c_str(), flags, APR_OS_DEFAULT, pool);
-        if (s != APR_SUCCESS || !mFile)
+        if (status != APR_SUCCESS || !mFile)
         {
                 mFile = NULL ;
                 close() ;
@@ -373,7 +171,7 @@ apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, acc
                 {
                         *sizep = 0;
                 }
-                return s;
+                return status;
         }
 
         if (sizep)
@@ -390,7 +188,7 @@ apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, acc
                 *sizep = file_size;
         }
 
-        return s;
+        return status;
 }
 
 // File I/O
@@ -440,17 +238,6 @@ S32 LLAPRFile::seek(apr_seek_where_t where, S32 offset)
 //static components of LLAPRFile
 //
 
-// Used in the static functions below.
-class LLScopedVolatileAPRFilePool {
-private:
-        LLVolatileAPRPool* mPool;
-        apr_pool_t* apr_pool;
-public:
-        LLScopedVolatileAPRFilePool() : mPool(LLVolatileAPRPool::getLocalAPRFilePool()), apr_pool(mPool->getVolatileAPRPool()) { }
-        ~LLScopedVolatileAPRFilePool() { mPool->clearVolatileAPRPool(); }
-        operator apr_pool_t*() const { return apr_pool; }
-};
-
 //static
 S32 LLAPRFile::seek(apr_file_t* file_handle, apr_seek_where_t where, S32 offset)
 {
@@ -487,7 +274,7 @@ S32 LLAPRFile::seek(apr_file_t* file_handle, apr_seek_where_t where, S32 offset)
 S32 LLAPRFile::readEx(const std::string& filename, void *buf, S32 offset, S32 nbytes)
 {
         apr_file_t* file_handle;
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         apr_status_t s = apr_file_open(&file_handle, filename.c_str(), APR_READ|APR_BINARY, APR_OS_DEFAULT, pool);
         if (s != APR_SUCCESS || !file_handle)
         {
@@ -539,7 +326,7 @@ S32 LLAPRFile::writeEx(const std::string& filename, void *buf, S32 offset, S32 n
         }
         
         apr_file_t* file_handle;
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         apr_status_t s = apr_file_open(&file_handle, filename.c_str(), flags, APR_OS_DEFAULT, pool);
         if (s != APR_SUCCESS || !file_handle)
         {
@@ -584,7 +371,7 @@ bool LLAPRFile::remove(const std::string& filename)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_remove(filename.c_str(), pool);
 
         if (s != APR_SUCCESS)
@@ -601,7 +388,7 @@ bool LLAPRFile::rename(const std::string& filename, const std::string& newname)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_rename(filename.c_str(), newname.c_str(), pool);
         
         if (s != APR_SUCCESS)
@@ -619,7 +406,7 @@ bool LLAPRFile::isExist(const std::string& filename, apr_int32_t flags)
         apr_file_t* file_handle;
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_open(&file_handle, filename.c_str(), flags, APR_OS_DEFAULT, pool);
 
         if (s != APR_SUCCESS || !file_handle)
@@ -640,7 +427,7 @@ S32 LLAPRFile::size(const std::string& filename)
         apr_finfo_t info;
         apr_status_t s;
         
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_open(&file_handle, filename.c_str(), APR_READ, APR_OS_DEFAULT, pool);
         
         if (s != APR_SUCCESS || !file_handle)
@@ -669,7 +456,7 @@ bool LLAPRFile::makeDir(const std::string& dirname)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_dir_make(dirname.c_str(), APR_FPROT_OS_DEFAULT, pool);
                 
         if (s != APR_SUCCESS)
@@ -686,7 +473,7 @@ bool LLAPRFile::removeDir(const std::string& dirname)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_remove(dirname.c_str(), pool);
         
         if (s != APR_SUCCESS)
diff --git a/linden/indra/llcommon/llapr.h b/linden/indra/llcommon/llapr.h
index 7f770b0..ded15f5 100644
--- a/linden/indra/llcommon/llapr.h
+++ b/linden/indra/llcommon/llapr.h
@@ -48,74 +48,8 @@
 #include "apr_atomic.h"
 #include "llstring.h"
 
-extern apr_thread_mutex_t* gLogMutexp;
-extern apr_thread_mutex_t* gCallStacksLogMutexp;
-
-/** 
- * @brief initialize the common apr constructs -- apr itself, the
- * global pool, and a mutex.
- */
-void ll_init_apr();
-
-/** 
- * @brief Cleanup those common apr constructs.
- */
-void ll_cleanup_apr();
-
-//
-//LL apr_pool
-//manage apr_pool_t, destroy allocated apr_pool in the destruction function.
-//
-class LLAPRPool
-{
-public:
-        LLAPRPool(apr_pool_t *parent = NULL, apr_size_t size = 0, BOOL releasePoolFlag = TRUE) ;
-        ~LLAPRPool() ;
-
-        apr_pool_t* getAPRPool() ;
-        apr_status_t getStatus() {return mStatus ; }
-
-protected:
-        void releaseAPRPool() ;
-        void createAPRPool() ;
-
-protected:
-        apr_pool_t*  mPool ;              //pointing to an apr_pool
-        apr_pool_t*  mParent ;                    //parent pool
-        apr_size_t   mMaxSize ;           //max size of mPool, mPool should return memory to system if allocated memory beyond this limit. However it seems not to work.
-        apr_status_t mStatus ;            //status when creating the pool
-        BOOL         mReleasePoolFlag ;   //if set, mPool is destroyed when LLAPRPool is deleted. default value is true.
-};
-
-//
-//volatile LL apr_pool
-//which clears memory automatically.
-//so it can not hold static data or data after memory is cleared
-//
-class LLVolatileAPRPool : protected LLAPRPool
-{
-public:
-        LLVolatileAPRPool(apr_pool_t *parent = NULL, apr_size_t size = 0, BOOL releasePoolFlag = TRUE);
-        ~LLVolatileAPRPool(){}
-
-        apr_pool_t* getVolatileAPRPool() ;
-        
-        void        clearVolatileAPRPool() ;
-
-        BOOL        isFull() ;
-        BOOL        isEmpty() {return !mNumActiveRef ;}
-
-        static void initLocalAPRFilePool();
-        static void createLocalAPRFilePool();
-        static void destroyLocalAPRFilePool(void* thread_local_data);
-        static LLVolatileAPRPool* getLocalAPRFilePool();
-
-private:
-        S32 mNumActiveRef ; //number of active pointers pointing to the apr_pool.
-        S32 mNumTotalRef ;  //number of total pointers pointing to the apr_pool since last creating.   
-
-        static apr_threadkey_t*         sLocalAPRFilePoolKey;
-} ;
+class AIAPRPool;
+class AIVolatileAPRPool;
 
 /** 
  * @class LLScopedLock
@@ -126,7 +60,7 @@ private:
  * destructor handles the unlock. Instances of this class are
  * <b>not</b> thread safe.
  */
-class LLScopedLock : private boost::noncopyable
+class LL_COMMON_API LLScopedLock : private boost::noncopyable
 {
 public:
         /**
@@ -201,12 +135,13 @@ typedef LLAtomic32<S32> LLAtomicS32;
 //      2, a global pool.
 //
 
-class LLAPRFile : boost::noncopyable
+class LL_COMMON_API LLAPRFile : boost::noncopyable
 {
         // make this non copyable since a copy closes the file
 private:
         apr_file_t* mFile ;
-        LLVolatileAPRPool *mCurrentFilePoolp ; //currently in use apr_pool, could be one of them: sAPRFilePoolp, or a temp pool. 
+        AIVolatileAPRPool* mVolatileFilePoolp;  // (Thread local) APR pool currently in use.
+        AIAPRPool* mRegularFilePoolp;           // ...or a regular pool.
 
 public:
         enum access_t {
@@ -257,10 +192,8 @@ public:
  * APR_SUCCESS.
  * @return Returns <code>true</code> if status is an error condition.
  */
-bool ll_apr_warn_status(apr_status_t status);
-
-void ll_apr_assert_status(apr_status_t status);
+bool LL_COMMON_API ll_apr_warn_status(apr_status_t status);
 
-extern "C" apr_pool_t* gAPRPoolp; // Global APR memory pool
+void LL_COMMON_API ll_apr_assert_status(apr_status_t status);
 
 #endif // LL_LLAPR_H
diff --git a/linden/indra/llcommon/llassettype.h b/linden/indra/llcommon/llassettype.h
index 4077b8d..9f611ae 100644
--- a/linden/indra/llcommon/llassettype.h
+++ b/linden/indra/llcommon/llassettype.h
@@ -37,7 +37,7 @@
 
 #include "stdenums.h"   // for EDragAndDropType
 
-class LLAssetType
+class LL_COMMON_API LLAssetType
 {
 public:
         enum EType
diff --git a/linden/indra/llcommon/llavatarname.cpp b/linden/indra/llcommon/llavatarname.cpp
new file mode 100644
index 0000000..ebe8c88
--- /dev/null
+++ b/linden/indra/llcommon/llavatarname.cpp
@@ -0,0 +1,150 @@
+/** 
+ * @file llavatarname.cpp
+ * @brief Represents name-related data for an avatar, such as the
+ * username/SLID ("bobsmith123" or "james.linden") and the display
+ * name ("James Cook")
+ *
+ * $LicenseInfo:firstyear=2010&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$
+ */
+#include "linden_common.h"
+
+#include "llavatarname.h"
+
+#include "lldate.h"
+#include "llsd.h"
+
+bool LLAvatarName::sOmitResidentAsLastName = false;
+
+// Store these in pre-built std::strings to avoid memory allocations in
+// LLSD map lookups
+static const std::string USERNAME("username");
+static const std::string DISPLAY_NAME("display_name");
+static const std::string LEGACY_FIRST_NAME("legacy_first_name");
+static const std::string LEGACY_LAST_NAME("legacy_last_name");
+static const std::string IS_DISPLAY_NAME_DEFAULT("is_display_name_default");
+static const std::string DISPLAY_NAME_EXPIRES("display_name_expires");
+static const std::string DISPLAY_NAME_NEXT_UPDATE("display_name_next_update");
+
+LLAvatarName::LLAvatarName()
+:       mUsername(),
+        mDisplayName(),
+        mLegacyFirstName(),
+        mLegacyLastName(),
+        mIsDisplayNameDefault(false),
+        mIsDummy(false),
+        mExpires(F64_MAX),
+        mNextUpdate(0.0)
+{ }
+
+bool LLAvatarName::operator<(const LLAvatarName& rhs) const
+{
+        if (mUsername == rhs.mUsername)
+                return mDisplayName < rhs.mDisplayName;
+        else
+                return mUsername < rhs.mUsername;
+}
+
+LLSD LLAvatarName::asLLSD() const
+{
+        LLSD sd;
+        sd[USERNAME] = mUsername;
+        sd[DISPLAY_NAME] = mDisplayName;
+        sd[LEGACY_FIRST_NAME] = mLegacyFirstName;
+        sd[LEGACY_LAST_NAME] = mLegacyLastName;
+        sd[IS_DISPLAY_NAME_DEFAULT] = mIsDisplayNameDefault;
+        sd[DISPLAY_NAME_EXPIRES] = LLDate(mExpires);
+        sd[DISPLAY_NAME_NEXT_UPDATE] = LLDate(mNextUpdate);
+        return sd;
+}
+
+void LLAvatarName::fromLLSD(const LLSD& sd)
+{
+        mUsername = sd[USERNAME].asString();
+        mDisplayName = sd[DISPLAY_NAME].asString();
+        mLegacyFirstName = sd[LEGACY_FIRST_NAME].asString();
+        mLegacyLastName = sd[LEGACY_LAST_NAME].asString();
+        mIsDisplayNameDefault = sd[IS_DISPLAY_NAME_DEFAULT].asBoolean();
+        LLDate expires = sd[DISPLAY_NAME_EXPIRES];
+        mExpires = expires.secondsSinceEpoch();
+        LLDate next_update = sd[DISPLAY_NAME_NEXT_UPDATE];
+        mNextUpdate = next_update.secondsSinceEpoch();
+}
+
+std::string LLAvatarName::getCompleteName() const
+{
+        std::string name;
+        if (!mUsername.empty())
+        {
+                name = mDisplayName + " (" + mUsername + ")";
+        }
+        else
+        {
+                // ...display names are off, legacy name is in mDisplayName
+                name = mDisplayName;
+        }
+        return name;
+}
+
+std::string LLAvatarName::getLegacyName() const
+{
+        std::string name;
+        name.reserve(mLegacyFirstName.size() + 1 + mLegacyLastName.size());
+        name = mLegacyFirstName;
+        if (!sOmitResidentAsLastName || mLegacyLastName != "Resident")
+        {
+                name += " ";
+                name += mLegacyLastName;
+        }
+        return name;
+}
+
+std::string LLAvatarName::getNames(bool linefeed) const
+{
+        std::string name;
+
+        if (mUsername.empty())
+        {
+                // ...display names are off, legacy name is in mDisplayName
+                name = mDisplayName;
+                if (sOmitResidentAsLastName)
+                {
+                        LLStringUtil::replaceString(name, " Resident", "");
+                }
+        }
+        else
+        {
+                name = getLegacyName();
+                if (name != mDisplayName)
+                {
+                        if (linefeed)
+                        {
+                                name = mDisplayName + "\n[" + name + "]";
+                        }
+                        else
+                        {
+                                name = mDisplayName + " [" + name + "]";
+                        }
+                }
+        }
+
+        return name;
+}
diff --git a/linden/indra/llcommon/llavatarname.h b/linden/indra/llcommon/llavatarname.h
new file mode 100644
index 0000000..3b6c6ea
--- /dev/null
+++ b/linden/indra/llcommon/llavatarname.h
@@ -0,0 +1,105 @@
+/** 
+ * @file llavatarname.h
+ * @brief Represents name-related data for an avatar, such as the
+ * username/SLID ("bobsmith123" or "james.linden") and the display
+ * name ("James Cook")
+ *
+ * $LicenseInfo:firstyear=2010&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$
+ */
+#ifndef LLAVATARNAME_H
+#define LLAVATARNAME_H
+
+#include <string>
+
+class LLSD;
+
+class LL_COMMON_API LLAvatarName
+{
+public:
+        LLAvatarName();
+        
+        bool operator<(const LLAvatarName& rhs) const;
+
+        LLSD asLLSD() const;
+
+        void fromLLSD(const LLSD& sd);
+
+        // For normal names, returns "James Linden (james.linden)"
+        // When display names are disabled returns just "James Linden"
+        std::string getCompleteName() const;
+
+        // For normal names, returns "Whatever Display Name (John Doe)" when
+        // display name and legacy name are different, or just "John Doe"
+        // when they are equal or when display names are disabled.
+        // When linefeed == true, the space between the display name and
+        // the opening parenthesis for the legacy name is replaced with a
+        // line feed.
+        std::string getNames(bool linefeed = false) const;
+
+        // Returns "James Linden" or "bobsmith123 Resident" for backwards
+        // compatibility with systems like voice and muting
+        std::string getLegacyName() const;
+
+        // "bobsmith123" or "james.linden", US-ASCII only
+        std::string mUsername;
+
+        // "Jose' Sanchez" or "James Linden", UTF-8 encoded Unicode
+        // Contains data whether or not user has explicitly set
+        // a display name; may duplicate their username.
+        std::string mDisplayName;
+
+        // For "James Linden", "James"
+        // For "bobsmith123", "bobsmith123"
+        // Used to communicate with legacy systems like voice and muting which
+        // rely on old-style names.
+        std::string mLegacyFirstName;
+
+        // For "James Linden", "Linden"
+        // For "bobsmith123", "Resident"
+        // see above for rationale
+        std::string mLegacyLastName;
+
+        // If true, both display name and SLID were generated from
+        // a legacy first and last name, like "James Linden (james.linden)"
+        bool mIsDisplayNameDefault;
+
+        // Under error conditions, we may insert "dummy" records with
+        // names equal to legacy name into caches as placeholders.
+        // These can be shown in UI, but are not serialized.
+        bool mIsDummy;
+
+        // Names can change, so need to keep track of when name was
+        // last checked.
+        // Unix time-from-epoch seconds for efficiency
+        F64 mExpires;
+        
+        // You can only change your name every N hours, so record
+        // when the next update is allowed
+        // Unix time-from-epoch seconds
+        F64 mNextUpdate;
+
+        // true to prevent the displaying of "Resident" as a last name
+        // in legacy names
+        static bool sOmitResidentAsLastName;
+};
+
+#endif
diff --git a/linden/indra/llcommon/llbase32.h b/linden/indra/llcommon/llbase32.h
index 63a93e1..47cd893 100644
--- a/linden/indra/llcommon/llbase32.h
+++ b/linden/indra/llcommon/llbase32.h
@@ -34,7 +34,7 @@
 #ifndef LLBASE32_H
 #define LLBASE32_h
 
-class LLBase32
+class LL_COMMON_API LLBase32
 {
 public:
         static std::string encode(const U8* input, size_t input_size);
diff --git a/linden/indra/llcommon/llbase64.h b/linden/indra/llcommon/llbase64.h
index 58414bb..15b27a6 100644
--- a/linden/indra/llcommon/llbase64.h
+++ b/linden/indra/llcommon/llbase64.h
@@ -34,7 +34,7 @@
 #ifndef LLBASE64_H
 #define LLBASE64_h
 
-class LLBase64
+class LL_COMMON_API LLBase64
 {
 public:
         static std::string encode(const U8* input, size_t input_size);
diff --git a/linden/indra/llcommon/llcommon.cpp b/linden/indra/llcommon/llcommon.cpp
index 2cbb718..298dd46 100644
--- a/linden/indra/llcommon/llcommon.cpp
+++ b/linden/indra/llcommon/llcommon.cpp
@@ -35,17 +35,9 @@
 #include "llthread.h"
 
 //static
-BOOL LLCommon::sAprInitialized = FALSE;
-
-//static
 void LLCommon::initClass()
 {
         LLMemory::initClass();
-        if (!sAprInitialized)
-        {
-                ll_init_apr();
-                sAprInitialized = TRUE;
-        }
         LLTimer::initClass();
         LLThreadSafeRefCount::initThreadSafeRefCount();
 //      LLWorkerThread::initClass();
@@ -59,10 +51,5 @@ void LLCommon::cleanupClass()
 //      LLWorkerThread::cleanupClass();
         LLThreadSafeRefCount::cleanupThreadSafeRefCount();
         LLTimer::cleanupClass();
-        if (sAprInitialized)
-        {
-                ll_cleanup_apr();
-                sAprInitialized = FALSE;
-        }
         LLMemory::cleanupClass();
 }
diff --git a/linden/indra/llcommon/llcommon.h b/linden/indra/llcommon/llcommon.h
index 5f77988..300ebe2 100644
--- a/linden/indra/llcommon/llcommon.h
+++ b/linden/indra/llcommon/llcommon.h
@@ -38,13 +38,11 @@
 #include "lltimer.h"
 #include "llfile.h"
 
-class LLCommon
+class LL_COMMON_API LLCommon
 {
 public:
         static void initClass();
         static void cleanupClass();
-private:
-        static BOOL sAprInitialized;
 };
 
 #endif
diff --git a/linden/indra/llcommon/llcrc.h b/linden/indra/llcommon/llcrc.h
index 27fae7d..7436906 100644
--- a/linden/indra/llcommon/llcrc.h
+++ b/linden/indra/llcommon/llcrc.h
@@ -50,7 +50,7 @@
 //  llinfos << "File crc: " << crc.getCRC() << llendl;
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-class LLCRC
+class LL_COMMON_API LLCRC
 {
 protected:
         U32 mCurrent;
diff --git a/linden/indra/llcommon/llcriticaldamp.h b/linden/indra/llcommon/llcriticaldamp.h
index ad98284..13e37d8 100644
--- a/linden/indra/llcommon/llcriticaldamp.h
+++ b/linden/indra/llcommon/llcriticaldamp.h
@@ -38,7 +38,7 @@
 
 #include "llframetimer.h"
 
-class LLCriticalDamp 
+class LL_COMMON_API LLCriticalDamp
 {
 public:
         LLCriticalDamp();
diff --git a/linden/indra/llcommon/llcursortypes.h b/linden/indra/llcommon/llcursortypes.h
index bea7035..836ecc3 100644
--- a/linden/indra/llcommon/llcursortypes.h
+++ b/linden/indra/llcommon/llcursortypes.h
@@ -77,6 +77,6 @@ enum ECursorType {
         UI_CURSOR_COUNT                 // Number of elements in this enum (NOT a cursor)
 };
 
-ECursorType getCursorFromString(const std::string& cursor_string);
+LL_COMMON_API ECursorType getCursorFromString(const std::string& cursor_string);
 
 #endif // LL_LLCURSORTYPES_H
diff --git a/linden/indra/llcommon/lldate.cpp b/linden/indra/llcommon/lldate.cpp
index 41a3af3..be29448 100644
--- a/linden/indra/llcommon/lldate.cpp
+++ b/linden/indra/llcommon/lldate.cpp
@@ -113,6 +113,8 @@ void LLDate::toHTTPDateStream(std::ostream& s) const
 #else
     s.setf(ios::right);
 #endif    
+        static char const* const weekdays[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
+        static char const* const months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
     std::string day = weekdays[exp_time.tm_wday];
     std::string month = months[exp_time.tm_mon];
 
diff --git a/linden/indra/llcommon/lldate.h b/linden/indra/llcommon/lldate.h
index 7cc9c8a..d27da79 100644
--- a/linden/indra/llcommon/lldate.h
+++ b/linden/indra/llcommon/lldate.h
@@ -46,7 +46,7 @@
  *
  * The date class represents a point in time after epoch - 1970-01-01.
  */
-class LLDate
+class LL_COMMON_API LLDate
 {
 public:
         /** 
@@ -153,14 +153,9 @@ private:
 };
 
 // Helper function to stream out a date
-std::ostream& operator<<(std::ostream& s, const LLDate& date);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLDate& date);
 
 // Helper function to stream in a date
-std::istream& operator>>(std::istream& s, LLDate& date);
-
-
-const static std::string weekdays[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
-
-const static std::string months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+LL_COMMON_API std::istream& operator>>(std::istream& s, LLDate& date);
 
 #endif // LL_LLDATE_H
diff --git a/linden/indra/llcommon/llerror.cpp b/linden/indra/llcommon/llerror.cpp
index 30b61a9..aeba629 100644
--- a/linden/indra/llcommon/llerror.cpp
+++ b/linden/indra/llcommon/llerror.cpp
@@ -46,6 +46,8 @@
 # include <unistd.h>
 #endif // !LL_WINDOWS
 #if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 # include <windows.h>
 #endif // LL_WINDOWS
 #include <vector>
@@ -58,7 +60,9 @@
 #include "llsd.h"
 #include "llsdserialize.h"
 #include "llstl.h"
+#include "lltimer.h"
 
+extern apr_thread_mutex_t* gCallStacksLogMutexp;
 
 namespace {
 #if !LL_WINDOWS
@@ -164,6 +168,9 @@ namespace {
                                 }
                         }
                         fprintf(stderr, "%s\n", message.c_str());
+#if LL_WINDOWS
+                    fflush(stderr); //Now using a buffer. flush is required.
+#endif
                         if (ANSI_YES == mUseANSI) colorANSI("0"); // reset
                 }
         
@@ -559,7 +566,7 @@ namespace
 #if LL_WINDOWS
                 LLError::addRecorder(new RecordToWinDebug);
 #endif
-
+                llwarns << "Load LogControlFile from Directory:"<< dir << llendl;
                 LogControlFile& e = LogControlFile::fromDirectory(dir);
 
                 // NOTE: We want to explicitly load the file before we add it to the event timer
@@ -869,6 +876,9 @@ You get:
         
 */
 
+apr_thread_mutex_t* gLogMutexp;
+apr_thread_mutex_t* gCallStacksLogMutexp;
+
 namespace {
         bool checkLevelMap(const LevelMap& map, const std::string& key,
                                                 LLError::ELevel& level)
diff --git a/linden/indra/llcommon/llerror.h b/linden/indra/llcommon/llerror.h
index 6794be4..5a4c644 100644
--- a/linden/indra/llcommon/llerror.h
+++ b/linden/indra/llcommon/llerror.h
@@ -131,7 +131,7 @@ namespace LLError
         
         class CallSite;
         
-        class Log
+        class LL_COMMON_API Log
         {
         public:
                 static bool shouldLog(CallSite&);
@@ -140,7 +140,7 @@ namespace LLError
                 static void flush(std::ostringstream*, const CallSite&);
         };
         
-        class CallSite
+        class LL_COMMON_API CallSite
         {
                 // Represents a specific place in the code where a message is logged
                 // This is public because it is used by the macros below.  It is not
@@ -189,7 +189,7 @@ namespace LLError
         //LLCallStacks is designed not to be thread-safe.
    //so try not to use it in multiple parallel threads at same time.
    //Used in a single thread at a time is fine.
-   class LLCallStacks
+   class LL_COMMON_API LLCallStacks
    {
    private:
        static char**  sBuffer ;
@@ -239,7 +239,7 @@ typedef LLError::NoClassInfo _LL_CLASS_TO_LOG;
 */
 
 #define lllog(level, broadTag, narrowTag, once) \
-        { \
+        do { \
                 static LLError::CallSite _site( \
                         level, __FILE__, __LINE__, typeid(_LL_CLASS_TO_LOG), __FUNCTION__, broadTag, narrowTag, once);\
                 if (_site.shouldLog()) \
@@ -252,7 +252,7 @@ typedef LLError::NoClassInfo _LL_CLASS_TO_LOG;
                         LLError::End(); \
                         LLError::Log::flush(_out, _site); \
                 } \
-        }
+        } while(0)
 
 // DEPRECATED: Use the new macros that allow tags and *look* like macros.
 #define lldebugs        lllog(LLError::LEVEL_DEBUG, NULL, NULL, false)
diff --git a/linden/indra/llcommon/llerrorcontrol.h b/linden/indra/llcommon/llerrorcontrol.h
index a55d706..54138b2 100644
--- a/linden/indra/llcommon/llerrorcontrol.h
+++ b/linden/indra/llcommon/llerrorcontrol.h
@@ -52,12 +52,12 @@ class LLSD;
 
 namespace LLError
 {
-        void initForServer(const std::string& identity);
+        LL_COMMON_API void initForServer(const std::string& identity);
                 // resets all logging settings to defaults needed by server processes
                 // logs to stderr, syslog, and windows debug log
                 // the identity string is used for in the syslog
 
-        void initForApplication(const std::string& dir);
+        LL_COMMON_API void initForApplication(const std::string& dir);
                 // resets all logging settings to defaults needed by applicaitons
                 // logs to stderr and windows debug log
                 // sets up log configuration from the file logcontrol.xml in dir
@@ -68,13 +68,14 @@ namespace LLError
                 Setting a level means log messages at that level or above.
         */
         
-        void setPrintLocation(bool);
-        void setDefaultLevel(LLError::ELevel);
-        void setFunctionLevel(const std::string& function_name, LLError::ELevel);
-        void setClassLevel(const std::string& class_name, LLError::ELevel);
-        void setFileLevel(const std::string& file_name, LLError::ELevel);
+        LL_COMMON_API void setPrintLocation(bool);
+        LL_COMMON_API void setDefaultLevel(LLError::ELevel);
+        LL_COMMON_API void setFunctionLevel(const std::string& function_name, LLError::ELevel);
+        LL_COMMON_API void setClassLevel(const std::string& class_name, LLError::ELevel);
+        LL_COMMON_API void setFileLevel(const std::string& file_name, LLError::ELevel);
+        LL_COMMON_API void setTagLevel(const std::string& file_name, LLError::ELevel);
         
-        void configure(const LLSD&);
+        LL_COMMON_API void configure(const LLSD&);
                 // the LLSD can configure all of the settings
                 // usually read automatically from the live errorlog.xml file
 
@@ -84,25 +85,25 @@ namespace LLError
         */
 
         typedef void(*FatalFunction)(const std::string& message);
-        void crashAndLoop(const std::string& message);
+        LL_COMMON_API void crashAndLoop(const std::string& message);
                 // Default fatal funtion: access null pointer and loops forever
 
-        void setFatalFunction(FatalFunction);
+        LL_COMMON_API void setFatalFunction(FatalFunction);
                 // The fatal function will be called when an message of LEVEL_ERROR
                 // is logged.  Note: supressing a LEVEL_ERROR message from being logged
                 // (by, for example, setting a class level to LEVEL_NONE), will keep
                 // the that message from causing the fatal funciton to be invoked.
                 
         typedef std::string (*TimeFunction)();
-        std::string utcTime();
+        LL_COMMON_API std::string utcTime();
         
-        void setTimeFunction(TimeFunction);
+        LL_COMMON_API void setTimeFunction(TimeFunction);
                 // The function is use to return the current time, formatted for
                 // display by those error recorders that want the time included.
 
 
 
-        class Recorder
+        class LL_COMMON_API Recorder
         {
                 // An object that handles the actual output or error messages.
         public:
@@ -116,17 +117,17 @@ namespace LLError
                         // included in the text of the message
         };
         
-        void addRecorder(Recorder*);
-        void removeRecorder(Recorder*);
+        LL_COMMON_API void addRecorder(Recorder*);
+        LL_COMMON_API void removeRecorder(Recorder*);
                 // each error message is passed to each recorder via recordMessage()
         
-        void logToFile(const std::string& filename);
-        void logToFixedBuffer(LLFixedBuffer*);
+        LL_COMMON_API void logToFile(const std::string& filename);
+        LL_COMMON_API void logToFixedBuffer(LLFixedBuffer*);
                 // Utilities to add recorders for logging to a file or a fixed buffer
                 // A second call to the same function will remove the logger added
                 // with the first.
                 // Passing the empty string or NULL to just removes any prior.
-        std::string logFileName();
+        LL_COMMON_API std::string logFileName();
                 // returns name of current logging file, empty string if none
 
 
@@ -135,11 +136,11 @@ namespace LLError
         */
 
         class Settings;
-        Settings* saveAndResetSettings();
-        void restoreSettings(Settings *);
+        LL_COMMON_API Settings* saveAndResetSettings();
+        LL_COMMON_API void restoreSettings(Settings *);
                 
-        std::string abbreviateFile(const std::string& filePath);
-        int shouldLogCallCount();
+        LL_COMMON_API std::string abbreviateFile(const std::string& filePath);
+        LL_COMMON_API int shouldLogCallCount();
         
 };
 
diff --git a/linden/indra/llcommon/llerrorthread.cpp b/linden/indra/llcommon/llerrorthread.cpp
index 4c779c5..e2b106a 100644
--- a/linden/indra/llcommon/llerrorthread.cpp
+++ b/linden/indra/llcommon/llerrorthread.cpp
@@ -32,6 +32,7 @@
 #include "linden_common.h"
 #include "llerrorthread.h"
 #include "llapp.h"
+#include "lltimer.h"
 
 LLErrorThread::LLErrorThread()
         : LLThread("Error"),
diff --git a/linden/indra/llcommon/llerrorthread.h b/linden/indra/llcommon/llerrorthread.h
index f1d6ffc..3121d29 100644
--- a/linden/indra/llcommon/llerrorthread.h
+++ b/linden/indra/llcommon/llerrorthread.h
@@ -35,7 +35,7 @@
 
 #include "llthread.h"
 
-class LLErrorThread : public LLThread
+class LL_COMMON_API LLErrorThread : public LLThread
 {
 public:
         LLErrorThread();
diff --git a/linden/indra/llcommon/llevent.h b/linden/indra/llcommon/llevent.h
index 60887a0..6b223a8 100644
--- a/linden/indra/llcommon/llevent.h
+++ b/linden/indra/llcommon/llevent.h
@@ -44,7 +44,7 @@ class LLEventDispatcher;
 class LLObservable;
 
 // Abstract event. All events derive from LLEvent
-class LLEvent : public LLThreadSafeRefCount
+class LL_COMMON_API LLEvent : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLEvent();
@@ -72,7 +72,7 @@ private:
 };
 
 // Abstract listener. All listeners derive from LLEventListener
-class LLEventListener : public LLThreadSafeRefCount
+class LL_COMMON_API LLEventListener : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLEventListener();
@@ -89,7 +89,7 @@ public:
 };
 
 // A listener which tracks references to it and cleans up when it's deallocated
-class LLSimpleListener : public LLEventListener
+class LL_COMMON_API LLSimpleListener : public LLEventListener
 {
 public:
         void clearDispatchers();
@@ -114,7 +114,7 @@ struct LLListenerEntry
 // Base class for a dispatcher - an object which listens
 // to events being fired and relays them to their
 // appropriate destinations.
-class LLEventDispatcher : public LLThreadSafeRefCount
+class LL_COMMON_API LLEventDispatcher : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLEventDispatcher();
@@ -157,7 +157,7 @@ private:
 // In order for this class to work properly, it needs
 // an instance of an LLEventDispatcher to route events to their
 // listeners.
-class LLObservable
+class LL_COMMON_API LLObservable
 {
 public:
         // Initialize with the default Dispatcher
diff --git a/linden/indra/llcommon/llfasttimer.cpp b/linden/indra/llcommon/llfasttimer.cpp
index 4aa23bb..5f091d5 100644
--- a/linden/indra/llcommon/llfasttimer.cpp
+++ b/linden/indra/llcommon/llfasttimer.cpp
@@ -42,6 +42,7 @@
 #include <sched.h>
 #elif LL_DARWIN
 #include <sys/time.h>
+#include "lltimer.h"    // get_clock_count()
 #else 
 #error "architecture not supported"
 #endif
diff --git a/linden/indra/llcommon/llfasttimer.h b/linden/indra/llcommon/llfasttimer.h
index 8c1cf47..602a2f7 100644
--- a/linden/indra/llcommon/llfasttimer.h
+++ b/linden/indra/llcommon/llfasttimer.h
@@ -35,9 +35,9 @@
 
 #define FAST_TIMER_ON 1
 
-U64 get_cpu_clock_count();
+LL_COMMON_API U64 get_cpu_clock_count();
 
-class LLFastTimer
+class LL_COMMON_API LLFastTimer
 {
 public:
         enum EFastTimerType
diff --git a/linden/indra/llcommon/llfile.cpp b/linden/indra/llcommon/llfile.cpp
index 2a76f7f..6b68630 100644
--- a/linden/indra/llcommon/llfile.cpp
+++ b/linden/indra/llcommon/llfile.cpp
@@ -34,6 +34,8 @@
  */
 
 #if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #endif
 
diff --git a/linden/indra/llcommon/llfile.h b/linden/indra/llcommon/llfile.h
index c6092f7..ee37605 100644
--- a/linden/indra/llcommon/llfile.h
+++ b/linden/indra/llcommon/llfile.h
@@ -70,7 +70,7 @@ typedef struct stat		llstat;
 
 #include "llstring.h" // safe char* -> std::string conversion
 
-class   LLFile
+class LL_COMMON_API LLFile
 {
 public:
         // All these functions take UTF8 path/filenames.
@@ -95,7 +95,7 @@ public:
 
 #if USE_LLFILESTREAMS
 
-class   llifstream      :       public  std::basic_istream < char , std::char_traits < char > >
+class LL_COMMON_API llifstream  :       public  std::basic_istream < char , std::char_traits < char > >
 {
         // input stream associated with a C stream
 public:
@@ -136,7 +136,7 @@ private:
 };
 
 
-class   llofstream      :       public  std::basic_ostream< char , std::char_traits < char > >
+class LL_COMMON_API llofstream  :       public  std::basic_ostream< char , std::char_traits < char > >
 {
 public:
         typedef std::basic_ostream< char , std::char_traits < char > > _Myt;
@@ -185,7 +185,7 @@ private:
 //#define       llifstream      std::ifstream
 //#define       llofstream      std::ofstream
 
-class   llifstream      :       public  std::ifstream
+class LL_COMMON_API llifstream  :       public  std::ifstream
 {
 public:
         llifstream() : std::ifstream()
@@ -203,7 +203,7 @@ public:
 };
 
 
-class   llofstream      :       public  std::ofstream
+class LL_COMMON_API llofstream  :       public  std::ofstream
 {
 public:
         llofstream() : std::ofstream()
diff --git a/linden/indra/llcommon/llfindlocale.cpp b/linden/indra/llcommon/llfindlocale.cpp
index 505f5c5..71675af 100644
--- a/linden/indra/llcommon/llfindlocale.cpp
+++ b/linden/indra/llcommon/llfindlocale.cpp
@@ -39,6 +39,8 @@
 #include <ctype.h>
 
 #ifdef WIN32
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #include <winnt.h>
 #endif
diff --git a/linden/indra/llcommon/llfindlocale.h b/linden/indra/llcommon/llfindlocale.h
index f17c774..b812a06 100644
--- a/linden/indra/llcommon/llfindlocale.h
+++ b/linden/indra/llcommon/llfindlocale.h
@@ -59,8 +59,8 @@ typedef enum {
 /* This allocates/fills in a FL_Locale structure with pointers to
    strings (which should be treated as static), or NULL for inappropriate /
    undetected fields. */
-FL_Success FL_FindLocale(FL_Locale **locale, FL_Domain domain);
+LL_COMMON_API FL_Success FL_FindLocale(FL_Locale **locale, FL_Domain domain);
 /* This should be used to free the struct written by FL_FindLocale */
-void FL_FreeLocale(FL_Locale **locale);
+LL_COMMON_API void FL_FreeLocale(FL_Locale **locale);
 
 #endif /*__findlocale_h_*/
diff --git a/linden/indra/llcommon/llfixedbuffer.cpp b/linden/indra/llcommon/llfixedbuffer.cpp
index e9d6029..37a12ad 100644
--- a/linden/indra/llcommon/llfixedbuffer.cpp
+++ b/linden/indra/llcommon/llfixedbuffer.cpp
@@ -33,9 +33,8 @@
 #include "llfixedbuffer.h"
 
 LLFixedBuffer::LLFixedBuffer(const U32 max_lines)
-                          : mMutex(NULL)
+        : mMaxLines(max_lines)
 {
-        mMaxLines = max_lines;
         mTimer.reset();
 }
 
diff --git a/linden/indra/llcommon/llfixedbuffer.h b/linden/indra/llcommon/llfixedbuffer.h
index 992a024..51d0701 100644
--- a/linden/indra/llcommon/llfixedbuffer.h
+++ b/linden/indra/llcommon/llfixedbuffer.h
@@ -41,7 +41,7 @@
 
 // Fixed size buffer for console output and other things.
 
-class LLFixedBuffer
+class LL_COMMON_API LLFixedBuffer
 {
 public:
         LLFixedBuffer(const U32 max_lines = 20);
diff --git a/linden/indra/llcommon/llformat.h b/linden/indra/llcommon/llformat.h
index 44c62d9..ad30d4f 100644
--- a/linden/indra/llcommon/llformat.h
+++ b/linden/indra/llcommon/llformat.h
@@ -40,6 +40,6 @@
 // *NOTE: buffer limited to 1024, (but vsnprintf prevents overrun)
 // should perhaps be replaced with boost::format.
 
-std::string llformat(const char *fmt, ...);
+LL_COMMON_API std::string llformat(const char *fmt, ...);
 
 #endif // LL_LLFORMAT_H
diff --git a/linden/indra/llcommon/llframetimer.h b/linden/indra/llcommon/llframetimer.h
index 8f51272..f4775a9 100644
--- a/linden/indra/llcommon/llframetimer.h
+++ b/linden/indra/llcommon/llframetimer.h
@@ -43,7 +43,7 @@
 #include "lltimer.h"
 #include "timing.h"
 
-class LLFrameTimer 
+class LL_COMMON_API LLFrameTimer
 {
 public:
         LLFrameTimer() : mStartTime( sFrameTime ), mExpiry(0), mStarted(TRUE) {}
diff --git a/linden/indra/llcommon/llheartbeat.h b/linden/indra/llcommon/llheartbeat.h
index fecb5b1..6f70269 100644
--- a/linden/indra/llcommon/llheartbeat.h
+++ b/linden/indra/llcommon/llheartbeat.h
@@ -40,7 +40,7 @@
 // Note: Win32 does not support the heartbeat/smackdown system;
 //   heartbeat-delivery turns into a no-op there.
 
-class LLHeartbeat
+class LL_COMMON_API LLHeartbeat
 {
 public:
         // secs_between_heartbeat: after a heartbeat is successfully delivered,
diff --git a/linden/indra/llcommon/llliveappconfig.h b/linden/indra/llcommon/llliveappconfig.h
index 55d84a4..3251a7c 100644
--- a/linden/indra/llcommon/llliveappconfig.h
+++ b/linden/indra/llcommon/llliveappconfig.h
@@ -37,7 +37,7 @@
 
 class LLApp;
 
-class LLLiveAppConfig : public LLLiveFile
+class LL_COMMON_API LLLiveAppConfig : public LLLiveFile
 {
 public:
         // To use this, instantiate a LLLiveAppConfig object inside your main loop.
diff --git a/linden/indra/llcommon/lllivefile.h b/linden/indra/llcommon/lllivefile.h
index fddf006..72f16fd 100644
--- a/linden/indra/llcommon/lllivefile.h
+++ b/linden/indra/llcommon/lllivefile.h
@@ -36,7 +36,7 @@
 const F32 configFileRefreshRate = 5.0; // seconds
 
 
-class LLLiveFile
+class LL_COMMON_API LLLiveFile
 {
 public:
         LLLiveFile(const std::string &filename, const F32 refresh_period = 5.f);
diff --git a/linden/indra/llcommon/lllog.h b/linden/indra/llcommon/lllog.h
index 7ac6c8a..4b6777b 100644
--- a/linden/indra/llcommon/lllog.h
+++ b/linden/indra/llcommon/lllog.h
@@ -41,7 +41,7 @@ class LLLogImpl;
 class LLApp;
 class LLSD;
 
-class LLLog
+class LL_COMMON_API LLLog
 {
 public:
         LLLog(LLApp* app);
diff --git a/linden/indra/llcommon/lllslconstants.h b/linden/indra/llcommon/lllslconstants.h
index fc5363f..25a15e4 100644..100755
--- a/linden/indra/llcommon/lllslconstants.h
+++ b/linden/indra/llcommon/lllslconstants.h
@@ -5,7 +5,7 @@
  *
  * $LicenseInfo:firstyear=2006&license=viewergpl$
  * 
- * Copyright (c) 2006-2009, Linden Research, Inc.
+ * Copyright (c) 2006-2010, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -189,9 +189,6 @@ const S32 OBJECT_OWNER = 6;
 const S32 OBJECT_GROUP = 7;
 const S32 OBJECT_CREATOR = 8;
 
-// llTextBox() magic token string - yes this is a hack.  sue me.
-const std::string TEXTBOX_MAGIC_TOKEN = "!!llTextBox!!";
-
 // changed() event flags
 const U32       CHANGED_NONE = 0x0;
 const U32       CHANGED_INVENTORY = 0x1;
diff --git a/linden/indra/llcommon/llmd5.cpp b/linden/indra/llcommon/llmd5.cpp
index 14b4f9f..887979b 100644
--- a/linden/indra/llcommon/llmd5.cpp
+++ b/linden/indra/llcommon/llmd5.cpp
@@ -83,6 +83,7 @@ documentation and/or software.
 #include "llmd5.h"
 
 #include <cassert>
+#include <iostream>
 
 // how many bytes to grab at a time when checking files
 const int LLMD5::BLOCK_LEN = 4096;
diff --git a/linden/indra/llcommon/llmd5.h b/linden/indra/llcommon/llmd5.h
index d8bca03..df9d732 100644
--- a/linden/indra/llcommon/llmd5.h
+++ b/linden/indra/llcommon/llmd5.h
@@ -80,7 +80,7 @@ const int MD5RAW_BYTES = 16;
 const int MD5HEX_STR_SIZE = 33;  // char hex[MD5HEX_STR_SIZE]; with null
 const int MD5HEX_STR_BYTES = 32; // message system fixed size
 
-class LLMD5 {
+class LL_COMMON_API LLMD5 {
 // first, some types:
   typedef unsigned       int uint4; // assumes integer is 4 words long
   typedef unsigned short int uint2; // assumes short integer is 2 words long
diff --git a/linden/indra/llcommon/llmemory.cpp b/linden/indra/llcommon/llmemory.cpp
index a6de3d2..2b01442 100644
--- a/linden/indra/llcommon/llmemory.cpp
+++ b/linden/indra/llcommon/llmemory.cpp
@@ -33,6 +33,8 @@
 #include "linden_common.h"
 
 #if defined(LL_WINDOWS)
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 # include <windows.h>
 # include <psapi.h>
 #elif defined(LL_DARWIN)
@@ -283,6 +285,11 @@ LLRefCount::LLRefCount() :
 {
 }
 
+LLRefCount::LLRefCount(const LLRefCount& other)
+:   mRef(0)
+{
+}
+
 LLRefCount::~LLRefCount()
 { 
         if (mRef != 0)
@@ -290,7 +297,13 @@ LLRefCount::~LLRefCount()
                 llerrs << "deleting non-zero reference" << llendl;
         }
 }
-        
+
+LLRefCount& LLRefCount::operator=(const LLRefCount&)
+{
+        // do nothing, since ref count is specific to *this* reference
+        return *this;
+}
+
 //----------------------------------------------------------------------------
 
 #if defined(LL_WINDOWS)
diff --git a/linden/indra/llcommon/llmemory.h b/linden/indra/llcommon/llmemory.h
index b5c0711..9aa4b85 100644
--- a/linden/indra/llcommon/llmemory.h
+++ b/linden/indra/llcommon/llmemory.h
@@ -45,7 +45,7 @@ const U32 LLREFCOUNT_SENTINEL_VALUE = 0xAAAAAAAA;
 
 //----------------------------------------------------------------------------
 
-class LLMemory
+class LL_COMMON_API LLMemory
 {
 public:
         static void initClass();
@@ -68,12 +68,12 @@ private:
 
 //----------------------------------------------------------------------------
 
-class LLRefCount
+class LL_COMMON_API LLRefCount
 {
 protected:
-        LLRefCount(const LLRefCount&); // not implemented
+        LLRefCount(const LLRefCount&);
 private:
-        LLRefCount&operator=(const LLRefCount&); // not implemented
+        LLRefCount&operator=(const LLRefCount&);
 
 protected:
         virtual ~LLRefCount(); // use unref()
@@ -467,6 +467,6 @@ private:
 
 // Return the resident set size of the current process, in bytes.
 // Return value is zero if not known.
-U64 getCurrentRSS();
+LL_COMMON_API U64 getCurrentRSS();
 
 #endif
diff --git a/linden/indra/llcommon/llmemorystream.h b/linden/indra/llcommon/llmemorystream.h
index f348632..fa0f5d2 100644
--- a/linden/indra/llcommon/llmemorystream.h
+++ b/linden/indra/llcommon/llmemorystream.h
@@ -52,7 +52,7 @@
  * be careful to always pass in a valid memory location that exists
  * for at least as long as this streambuf.
  */
-class LLMemoryStreamBuf : public std::streambuf
+class LL_COMMON_API LLMemoryStreamBuf : public std::streambuf
 {
 public:
         LLMemoryStreamBuf(const U8* start, S32 length);
@@ -74,7 +74,7 @@ protected:
  * be careful to always pass in a valid memory location that exists
  * for at least as long as this streambuf.
  */
-class LLMemoryStream : public std::istream
+class LL_COMMON_API LLMemoryStream : public std::istream
 {
 public:
         LLMemoryStream(const U8* start, S32 length);
diff --git a/linden/indra/llcommon/llmemtype.h b/linden/indra/llcommon/llmemtype.h
index a9ebc20..d4cc67e 100644
--- a/linden/indra/llcommon/llmemtype.h
+++ b/linden/indra/llcommon/llmemtype.h
@@ -57,7 +57,7 @@ static void  operator delete(void* p) { ll_release(p); }
 
 //----------------------------------------------------------------------------
 
-class LLMemType
+class LL_COMMON_API LLMemType
 {
 public:
         // Also update sTypeDesc in llmemory.cpp
diff --git a/linden/indra/llcommon/llmetrics.h b/linden/indra/llcommon/llmetrics.h
index 1d91e8c..f6f49eb 100644
--- a/linden/indra/llcommon/llmetrics.h
+++ b/linden/indra/llcommon/llmetrics.h
@@ -38,7 +38,7 @@
 class LLMetricsImpl;
 class LLSD;
 
-class LLMetrics
+class LL_COMMON_API LLMetrics
 {
 public:
         LLMetrics();
diff --git a/linden/indra/llcommon/llmortician.h b/linden/indra/llcommon/llmortician.h
index 247632f..55a101a 100644
--- a/linden/indra/llcommon/llmortician.h
+++ b/linden/indra/llcommon/llmortician.h
@@ -35,7 +35,7 @@
 
 #include "stdtypes.h"
 
-class LLMortician 
+class LL_COMMON_API LLMortician
 {
 public:
         LLMortician() { mIsDead = FALSE; }
diff --git a/linden/indra/llcommon/llpreprocessor.h b/linden/indra/llcommon/llpreprocessor.h
index 2e4fd47..6886e3a 100644
--- a/linden/indra/llcommon/llpreprocessor.h
+++ b/linden/indra/llcommon/llpreprocessor.h
@@ -92,47 +92,63 @@
 
 #endif
 
-
 // Deal with the differeneces on Windows
-#if LL_MSVC
-namespace snprintf_hack
-{
-        int snprintf(char *str, size_t size, const char *format, ...);
-}
-
-// #define snprintf safe_snprintf               /* Flawfinder: ignore */
-using snprintf_hack::snprintf;
-#endif  // LL_MSVC
-
-// Static linking with apr on windows needs to be declared.
-#ifdef LL_WINDOWS
-#ifndef APR_DECLARE_STATIC
-#define APR_DECLARE_STATIC // For APR on Windows
-#endif
-#ifndef APU_DECLARE_STATIC
-#define APU_DECLARE_STATIC // For APR util on Windows
-#endif
-#endif
-
 #if defined(LL_WINDOWS)
 #define BOOST_REGEX_NO_LIB 1
 #define CURL_STATICLIB 1
 #define XML_STATIC
 #endif  //      LL_WINDOWS
 
-
 // Deal with VC6 problems
 #if LL_MSVC
 #pragma warning( 3           : 4701 )   // "local variable used without being initialized"  Treat this as level 3, not level 4.
 #pragma warning( 3           : 4702 )   // "unreachable code"  Treat this as level 3, not level 4.
 #pragma warning( 3           : 4189 )   // "local variable initialized but not referenced"  Treat this as level 3, not level 4.
 //#pragma warning( 3    : 4018 )        // "signed/unsigned mismatch"  Treat this as level 3, not level 4.
+#pragma warning( 3      :  4263 )       // 'function' : member function does not override any base class virtual member function
+#pragma warning( 3      :  4264 )       // "'virtual_function' : no override available for virtual member function from base 'class'; function is hidden"
 #pragma warning( 3       : 4265 )       // "class has virtual functions, but destructor is not virtual"
-#pragma warning( disable : 4786 )       // silly MS warning deep inside their <map> include file
+//#pragma warning( disable : 4265 )     // boost 1.36.0, non-virtual destructor in boost::exception_detail::*
+#pragma warning( 3      :  4266 )       // 'function' : no override available for virtual member function from base 'type'; function is hidden
+#pragma warning (disable : 4180)        // qualifier applied to function type has no meaning; ignored
 #pragma warning( disable : 4284 )       // silly MS warning deep inside their <map> include file
 #pragma warning( disable : 4503 )       // 'decorated name length exceeded, name was truncated'. Does not seem to affect compilation.
 #pragma warning( disable : 4800 )       // 'BOOL' : forcing value to bool 'true' or 'false' (performance warning)
 #pragma warning( disable : 4996 )       // warning: deprecated
+
+// Linker optimization with "extern template" generates these warnings
+#pragma warning( disable : 4231 )       // nonstandard extension used : 'extern' before template explicit instantiation
+#pragma warning( disable : 4506 )   // no definition for inline function
+
+// level 4 warnings that we need to disable:
+#pragma warning (disable : 4100) // unreferenced formal parameter
+#pragma warning (disable : 4127) // conditional expression is constant (e.g. while(1) )
+#pragma warning (disable : 4244) // possible loss of data on conversions
+#pragma warning (disable : 4396) // the inline specifier cannot be used when a friend declaration refers to a specialization of a function template
+#pragma warning (disable : 4512) // assignment operator could not be generated
+#pragma warning (disable : 4706) // assignment within conditional (even if((x = y)) )
+
+#pragma warning (disable : 4251) // member needs to have dll-interface to be used by clients of class
+#pragma warning (disable : 4275) // non dll-interface class used as base for dll-interface class
 #endif  //      LL_MSVC
 
+#if LL_WINDOWS
+#define LL_DLLEXPORT __declspec(dllexport)
+#define LL_DLLIMPORT __declspec(dllimport)
+#elif LL_LINUX
+#define LL_DLLEXPORT __attribute__ ((visibility("default")))
+#define LL_DLLIMPORT
+#else
+#define LL_DLLEXPORT
+#define LL_DLLIMPORT
+#endif // LL_WINDOWS
+
+#ifdef llcommon_EXPORTS
+// Compiling llcommon (shared)
+#define LL_COMMON_API LL_DLLEXPORT
+#else // llcommon_EXPORTS
+// Using llcommon (shared)
+#define LL_COMMON_API LL_DLLIMPORT
+#endif // llcommon_EXPORTS
+
 #endif  //      not LL_LINDEN_PREPROCESSOR_H
diff --git a/linden/indra/llcommon/llprocesslauncher.cpp b/linden/indra/llcommon/llprocesslauncher.cpp
new file mode 100644
index 0000000..e27aaa3
--- /dev/null
+++ b/linden/indra/llcommon/llprocesslauncher.cpp
@@ -0,0 +1,346 @@
+/** 
+ * @file llprocesslauncher.cpp
+ * @brief Utility class for launching, terminating, and tracking the state of processes.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+ 
+#include "linden_common.h"
+
+#include "llprocesslauncher.h"
+
+#include <iostream>
+#if LL_DARWIN || LL_LINUX
+// not required or present on Win32
+#include <sys/wait.h>
+#endif
+
+LLProcessLauncher::LLProcessLauncher()
+{
+#if LL_WINDOWS
+        mProcessHandle = 0;
+#else
+        mProcessID = 0;
+#endif
+}
+
+LLProcessLauncher::~LLProcessLauncher()
+{
+        kill();
+}
+
+void LLProcessLauncher::setExecutable(const std::string &executable)
+{
+        mExecutable = executable;
+}
+
+void LLProcessLauncher::setWorkingDirectory(const std::string &dir)
+{
+        mWorkingDir = dir;
+}
+
+void LLProcessLauncher::clearArguments()
+{
+        mLaunchArguments.clear();
+}
+
+void LLProcessLauncher::addArgument(const std::string &arg)
+{
+        mLaunchArguments.push_back(arg);
+}
+
+void LLProcessLauncher::addArgument(const char *arg)
+{
+        mLaunchArguments.push_back(std::string(arg));
+}
+
+#if LL_WINDOWS
+
+int LLProcessLauncher::launch(void)
+{
+        // If there was already a process associated with this object, kill it.
+        kill();
+        orphan();
+
+        int result = 0;
+        
+        PROCESS_INFORMATION pinfo;
+        STARTUPINFOA sinfo;
+        memset(&sinfo, 0, sizeof(sinfo));
+        
+        std::string args = "\"" + mExecutable + "\"";
+        for(int i = 0; i < (int)mLaunchArguments.size(); i++)
+        {
+                args += " ";
+                args += mLaunchArguments[i];
+        }
+        LL_INFOS("Plugin") << "Executable: " << mExecutable << " arguments: " << args << LL_ENDL;
+        
+        // So retarded.  Windows requires that the second parameter to CreateProcessA be a writable (non-const) string...
+        char *args2 = new char[args.size() + 1];
+        strcpy(args2, args.c_str());
+
+        if( ! CreateProcessA( NULL, args2, NULL, NULL, FALSE, 0, NULL, NULL, &sinfo, &pinfo ) )
+        {
+                // TODO: do better than returning the OS-specific error code on failure...
+                result = GetLastError();
+                if(result == 0)
+                {
+                        // Make absolutely certain we return a non-zero value on failure.
+                        result = -1;
+                }
+        }
+        else
+        {
+                // foo = pinfo.dwProcessId; // get your pid here if you want to use it later on
+                // CloseHandle(pinfo.hProcess); // stops leaks - nothing else
+                mProcessHandle = pinfo.hProcess;
+                CloseHandle(pinfo.hThread); // stops leaks - nothing else
+        }               
+        
+        delete[] args2;
+        
+        return result;
+}
+
+bool LLProcessLauncher::isRunning(void)
+{
+        if(mProcessHandle != 0)         
+        {
+                DWORD waitresult = WaitForSingleObject(mProcessHandle, 0);
+                if(waitresult == WAIT_OBJECT_0)
+                {
+                        // the process has completed.
+                        mProcessHandle = 0;
+                }                       
+        }
+
+        return (mProcessHandle != 0);
+}
+bool LLProcessLauncher::kill(void)
+{
+        bool result = true;
+        
+        if(mProcessHandle != 0)
+        {
+                TerminateProcess(mProcessHandle,0);
+
+                if(isRunning())
+                {
+                        result = false;
+                }
+        }
+        
+        return result;
+}
+
+void LLProcessLauncher::orphan(void)
+{
+        // Forget about the process
+        mProcessHandle = 0;
+}
+
+// static 
+void LLProcessLauncher::reap(void)
+{
+        // No actions necessary on Windows.
+}
+
+#else // Mac and linux
+
+#include <signal.h>
+#include <fcntl.h>
+#include <errno.h>
+
+static std::list<pid_t> sZombies;
+
+// Attempt to reap a process ID -- returns true if the process has exited and been reaped, false otherwise.
+static bool reap_pid(pid_t pid)
+{
+        bool result = false;
+        
+        pid_t wait_result = ::waitpid(pid, NULL, WNOHANG);
+        if(wait_result == pid)
+        {
+                result = true;
+        }
+        else if(wait_result == -1)
+        {
+                if(errno == ECHILD)
+                {
+                        // No such process -- this may mean we're ignoring SIGCHILD.
+                        result = true;
+                }
+        }
+        
+        return result;
+}
+
+int LLProcessLauncher::launch(void)
+{
+        // If there was already a process associated with this object, kill it.
+        kill();
+        orphan();
+        
+        int result = 0;
+        int current_wd = -1;
+        
+        // create an argv vector for the child process
+        const char ** fake_argv = new const char *[mLaunchArguments.size() + 2];  // 1 for the executable path, 1 for the NULL terminator
+
+        int i = 0;
+        
+        // add the executable path
+        fake_argv[i++] = mExecutable.c_str();
+        
+        // and any arguments
+        for(int j=0; j < mLaunchArguments.size(); j++)
+                fake_argv[i++] = mLaunchArguments[j].c_str();
+        
+        // terminate with a null pointer
+        fake_argv[i] = NULL;
+        
+        if(!mWorkingDir.empty())
+        {
+                // save the current working directory
+                current_wd = ::open(".", O_RDONLY);
+        
+                // and change to the one the child will be executed in
+                if (::chdir(mWorkingDir.c_str()))
+                {
+                        // chdir failed
+                }
+        }
+                
+        // flush all buffers before the child inherits them
+        ::fflush(NULL);
+
+        pid_t id = vfork();
+        if(id == 0)
+        {
+                // child process
+                
+                ::execv(mExecutable.c_str(), (char * const *)fake_argv);
+                
+                // If we reach this point, the exec failed.
+                // Use _exit() instead of exit() per the vfork man page.
+                _exit(0);
+        }
+
+        // parent process
+        
+        if(current_wd >= 0)
+        {
+                // restore the previous working directory
+                if (::fchdir(current_wd))
+                {
+                        // chdir failed
+                }
+                ::close(current_wd);
+        }
+        
+        delete[] fake_argv;
+        
+        mProcessID = id;
+        
+        // At this point, the child process will have been created (since that's how vfork works -- the child borrowed our execution context until it forked)
+        // If the process doesn't exist at this point, the exec failed.
+        if(!isRunning())
+        {
+                result = -1;
+        }
+        
+        return result;
+}
+
+bool LLProcessLauncher::isRunning(void)
+{
+        if(mProcessID != 0)
+        {
+                // Check whether the process has exited, and reap it if it has.
+                if(reap_pid(mProcessID))
+                {
+                        // the process has exited.
+                        mProcessID = 0;
+                }
+        }
+        
+        return (mProcessID != 0);
+}
+
+bool LLProcessLauncher::kill(void)
+{
+        bool result = true;
+        
+        if(mProcessID != 0)
+        {
+                // Try to kill the process.  We'll do approximately the same thing whether the kill returns an error or not, so we ignore the result.
+                (void)::kill(mProcessID, SIGTERM);
+                
+                // This will have the side-effect of reaping the zombie if the process has exited.
+                if(isRunning())
+                {
+                        result = false;
+                }
+        }
+        
+        return result;
+}
+
+void LLProcessLauncher::orphan(void)
+{
+        // Disassociate the process from this object
+        if(mProcessID != 0)
+        {       
+                // We may still need to reap the process's zombie eventually
+                sZombies.push_back(mProcessID);
+        
+                mProcessID = 0;
+        }
+}
+
+// static 
+void LLProcessLauncher::reap(void)
+{
+        // Attempt to real all saved process ID's.
+        
+        std::list<pid_t>::iterator iter = sZombies.begin();
+        while(iter != sZombies.end())
+        {
+                if(reap_pid(*iter))
+                {
+                        iter = sZombies.erase(iter);
+                }
+                else
+                {
+                        iter++;
+                }
+        }
+}
+
+#endif
diff --git a/linden/indra/llcommon/llprocesslauncher.h b/linden/indra/llcommon/llprocesslauncher.h
new file mode 100644
index 0000000..9833a13
--- /dev/null
+++ b/linden/indra/llcommon/llprocesslauncher.h
@@ -0,0 +1,91 @@
+/** 
+ * @file llprocesslauncher.h
+ * @brief Utility class for launching, terminating, and tracking the state of processes.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+ 
+#ifndef LL_LLPROCESSLAUNCHER_H
+#define LL_LLPROCESSLAUNCHER_H
+
+#if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
+#include <windows.h>
+#endif
+
+
+/*
+        LLProcessLauncher handles launching external processes with specified command line arguments.
+        It also keeps track of whether the process is still running, and can kill it if required.
+*/
+
+class LL_COMMON_API LLProcessLauncher
+{
+        LOG_CLASS(LLProcessLauncher);
+public:
+        LLProcessLauncher();
+        virtual ~LLProcessLauncher();
+        
+        void setExecutable(const std::string &executable);
+        void setWorkingDirectory(const std::string &dir);
+
+        void clearArguments();
+        void addArgument(const std::string &arg);
+        void addArgument(const char *arg);
+                
+        int launch(void);
+        bool isRunning(void);
+        
+        // Attempt to kill the process -- returns true if the process is no longer running when it returns.
+        // Note that even if this returns false, the process may exit some time after it's called.
+        bool kill(void);
+        
+        // Use this if you want the external process to continue execution after the LLProcessLauncher instance controlling it is deleted.
+        // Normally, the destructor will attempt to kill the process and wait for termination.
+        // This should only be used if the viewer is about to exit -- otherwise, the child process will become a zombie after it exits.
+        void orphan(void);      
+        
+        // This needs to be called periodically on Mac/Linux to clean up zombie processes.
+        static void reap(void);
+private:
+        std::string mExecutable;
+        std::string mWorkingDir;
+        std::vector<std::string> mLaunchArguments;
+        
+#if LL_WINDOWS
+        HANDLE mProcessHandle;
+#else
+        pid_t mProcessID;
+
+public:
+        pid_t getProcessID() const { return mProcessID; }
+#endif
+};
+
+#endif // LL_LLPROCESSLAUNCHER_H
diff --git a/linden/indra/llcommon/llqueuedthread.cpp b/linden/indra/llcommon/llqueuedthread.cpp
index caf4c2a..bee95be 100644
--- a/linden/indra/llcommon/llqueuedthread.cpp
+++ b/linden/indra/llcommon/llqueuedthread.cpp
@@ -32,6 +32,7 @@
 #include "linden_common.h"
 #include "llqueuedthread.h"
 #include "llstl.h"
+#include "lltimer.h"
 
 //============================================================================
 
diff --git a/linden/indra/llcommon/llqueuedthread.h b/linden/indra/llcommon/llqueuedthread.h
index aa7c6e4..e0e0f1b 100644
--- a/linden/indra/llcommon/llqueuedthread.h
+++ b/linden/indra/llcommon/llqueuedthread.h
@@ -47,7 +47,7 @@
 // Note: ~LLQueuedThread is O(N) N=# of queued threads, assumed to be small
 //   It is assumed that LLQueuedThreads are rarely created/destroyed.
 
-class LLQueuedThread : public LLThread
+class LL_COMMON_API LLQueuedThread : public LLThread
 {
         //------------------------------------------------------------------------
 public:
@@ -80,7 +80,7 @@ public:
         //------------------------------------------------------------------------
 public:
 
-        class QueuedRequest : public LLSimpleHashEntry<handle_t>
+        class LL_COMMON_API QueuedRequest : public LLSimpleHashEntry<handle_t>
         {
                 friend class LLQueuedThread;
                 
diff --git a/linden/indra/llcommon/llrand.h b/linden/indra/llcommon/llrand.h
index d12597b..73ea179 100644
--- a/linden/indra/llcommon/llrand.h
+++ b/linden/indra/llcommon/llrand.h
@@ -65,32 +65,32 @@
 /**
  *@brief Generate a float from [0, RAND_MAX).
  */
-S32 ll_rand();
+LL_COMMON_API S32 ll_rand();
 
 /**
  *@brief Generate a float from [0, val) or (val, 0].
  */
-S32 ll_rand(S32 val);
+LL_COMMON_API S32 ll_rand(S32 val);
 
 /**
  *@brief Generate a float from [0, 1.0).
  */
-F32 ll_frand();
+LL_COMMON_API F32 ll_frand();
 
 /**
  *@brief Generate a float from [0, val) or (val, 0].
  */
-F32 ll_frand(F32 val);
+LL_COMMON_API F32 ll_frand(F32 val);
 
 /**
  *@brief Generate a double from [0, 1.0).
  */
-F64 ll_drand();
+LL_COMMON_API F64 ll_drand();
 
 /**
  *@brief Generate a double from [0, val) or (val, 0].
  */
-F64 ll_drand(F64 val);
+LL_COMMON_API F64 ll_drand(F64 val);
 
 /**
  * @brief typedefs for good boost lagged fibonacci.
diff --git a/linden/indra/llcommon/llrun.h b/linden/indra/llcommon/llrun.h
index 77b23d9..0f8d51d 100644
--- a/linden/indra/llcommon/llrun.h
+++ b/linden/indra/llcommon/llrun.h
@@ -38,6 +38,8 @@
 #include <vector>
 #include <boost/shared_ptr.hpp>
 
+#include "llpreprocessor.h"
+
 class LLRunnable;
 
 /** 
@@ -48,7 +50,7 @@ class LLRunnable;
  * which are scheduled to run on a repeating or one time basis.
  * @see LLRunnable
  */
-class LLRunner
+class LL_COMMON_API LLRunner
 {
 public:
         /**
@@ -149,7 +151,7 @@ protected:
  * something useful.
  * @see LLRunner
  */
-class LLRunnable
+class LL_COMMON_API LLRunnable
 {
 public:
         LLRunnable();
diff --git a/linden/indra/llcommon/llscopedvolatileaprpool.h b/linden/indra/llcommon/llscopedvolatileaprpool.h
new file mode 100644
index 0000000..724dc7f
--- /dev/null
+++ b/linden/indra/llcommon/llscopedvolatileaprpool.h
@@ -0,0 +1,58 @@
+/**
+ * @file llscopedvolatileaprpool.h
+ * @brief Implementation of LLScopedVolatileAPRPool
+ *
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ *
+ * Copyright (c) 2010, Linden Research, Inc.
+ *
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ *
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ *
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLSCOPEDVOLATILEAPRPOOL_H
+#define LL_LLSCOPEDVOLATILEAPRPOOL_H
+
+#include "llthread.h"
+
+//! Scoped volatile memory pool.
+//
+// As the AIVolatileAPRPool should never keep allocations very
+// long, it's most common use is for allocations with a lifetime
+// equal to it's scope.
+//
+// This is a convenience class that makes just a little easier to type.
+//
+class LLScopedVolatileAPRPool
+{
+private:
+        AIVolatileAPRPool& mPool;
+        apr_pool_t* mScopedAPRpool;
+public:
+        LLScopedVolatileAPRPool() : mPool(AIThreadLocalData::tldata().mVolatileAPRPool), mScopedAPRpool(mPool.getVolatileAPRPool()) { }
+        ~LLScopedVolatileAPRPool() { mPool.clearVolatileAPRPool(); }
+        // Only use this to pass the pointer to a libapr-1 function that requires it.
+        operator apr_pool_t*() const { return mScopedAPRpool; }
+};
+
+#endif
diff --git a/linden/indra/llcommon/llsd.cpp b/linden/indra/llcommon/llsd.cpp
index 2cc94c2..be40bb6 100644
--- a/linden/indra/llcommon/llsd.cpp
+++ b/linden/indra/llcommon/llsd.cpp
@@ -75,7 +75,7 @@ protected:
                 ///< This constructor is used for static objects and causes the
                 //   suppresses adjusting the debugging counters when they are
                 //       finally initialized.
-                
+
         virtual ~Impl();
         
         bool shared() const                                                     { return mUseCount > 1; }
@@ -162,6 +162,7 @@ namespace
                 
                 virtual LLSD::Type type() const { return T; }
 
+                using LLSD::Impl::assign;
                 virtual void assign(LLSD::Impl*& var, DataRef value) {
                         if (shared())
                         {
@@ -348,6 +349,10 @@ namespace
 
                 virtual LLSD::Boolean asBoolean() const { return !mData.empty(); }
 
+                using LLSD::Impl::get; // Unhiding get(LLSD::Integer)
+                using LLSD::Impl::erase; // Unhiding erase(LLSD::Integer)
+                using LLSD::Impl::ref; // Unhiding ref(LLSD::Integer)
+
                 virtual bool has(const LLSD::String&) const; 
                 virtual LLSD get(const LLSD::String&) const; 
                         LLSD& insert(const LLSD::String& k, const LLSD& v);
@@ -440,6 +445,11 @@ namespace
                 virtual LLSD::Boolean asBoolean() const { return !mData.empty(); }
 
                 virtual int size() const; 
+
+                using LLSD::Impl::get; // Unhiding get(LLSD::Integer)
+                using LLSD::Impl::erase; // Unhiding erase(LLSD::Integer)
+                using LLSD::Impl::ref; // Unhiding ref(LLSD::Integer)
+
                 virtual LLSD get(LLSD::Integer) const;
                         void set(LLSD::Integer, const LLSD&);
                         LLSD& insert(LLSD::Integer, const LLSD&);
diff --git a/linden/indra/llcommon/llsd.h b/linden/indra/llcommon/llsd.h
index d2845a3..552bb57 100644
--- a/linden/indra/llcommon/llsd.h
+++ b/linden/indra/llcommon/llsd.h
@@ -89,7 +89,7 @@
         @nosubgrouping
 */
 
-class LLSD
+class LL_COMMON_API LLSD
 {
 public:
                 LLSD();         ///< initially Undefined
@@ -387,7 +387,7 @@ struct llsd_select_string : public std::unary_function<LLSD, LLSD::String>
         }
 };
 
-std::ostream& operator<<(std::ostream& s, const LLSD& llsd);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLSD& llsd);
 
 /** QUESTIONS & TO DOS
         - Would Binary be more convenient as usigned char* buffer semantics?
diff --git a/linden/indra/llcommon/llsdserialize.h b/linden/indra/llcommon/llsdserialize.h
index f7cd91b..a01b6dc 100644
--- a/linden/indra/llcommon/llsdserialize.h
+++ b/linden/indra/llcommon/llsdserialize.h
@@ -43,7 +43,7 @@
  * @class LLSDParser
  * @brief Abstract base class for LLSD parsers.
  */
-class LLSDParser : public LLRefCount
+class LL_COMMON_API LLSDParser : public LLRefCount
 {
 protected:
         /** 
@@ -220,7 +220,7 @@ protected:
  * @class LLSDNotationParser
  * @brief Parser which handles the original notation format for LLSD.
  */
-class LLSDNotationParser : public LLSDParser
+class LL_COMMON_API LLSDNotationParser : public LLSDParser
 {
 protected:
         /** 
@@ -293,7 +293,7 @@ private:
  * @class LLSDXMLParser
  * @brief Parser which handles XML format LLSD.
  */
-class LLSDXMLParser : public LLSDParser
+class LL_COMMON_API LLSDXMLParser : public LLSDParser
 {
 protected:
         /** 
@@ -341,7 +341,7 @@ private:
  * @class LLSDBinaryParser
  * @brief Parser which handles binary formatted LLSD.
  */
-class LLSDBinaryParser : public LLSDParser
+class LL_COMMON_API LLSDBinaryParser : public LLSDParser
 {
 protected:
         /** 
@@ -406,7 +406,7 @@ private:
  * @class LLSDFormatter
  * @brief Abstract base class for formatting LLSD.
  */
-class LLSDFormatter : public LLRefCount
+class LL_COMMON_API LLSDFormatter : public LLRefCount
 {
 protected:
         /** 
@@ -478,7 +478,7 @@ protected:
  * @class LLSDNotationFormatter
  * @brief Formatter which outputs the original notation format for LLSD.
  */
-class LLSDNotationFormatter : public LLSDFormatter
+class LL_COMMON_API LLSDNotationFormatter : public LLSDFormatter
 {
 protected:
         /** 
@@ -519,7 +519,7 @@ public:
  * @class LLSDXMLFormatter
  * @brief Formatter which outputs the LLSD as XML.
  */
-class LLSDXMLFormatter : public LLSDFormatter
+class LL_COMMON_API LLSDXMLFormatter : public LLSDFormatter
 {
 protected:
         /** 
@@ -587,7 +587,7 @@ protected:
  * Map: '{' + 4 byte integer size  every(key + value) + '}'<br>
  *  map keys are serialized as 'k' + 4 byte integer size + string
  */
-class LLSDBinaryFormatter : public LLSDFormatter
+class LL_COMMON_API LLSDBinaryFormatter : public LLSDFormatter
 {
 protected:
         /** 
@@ -676,7 +676,7 @@ typedef LLSDOStreamer<LLSDXMLFormatter>			LLSDXMLStreamer;
  * @class LLSDSerialize
  * @brief Serializer / deserializer for the various LLSD formats
  */
-class LLSDSerialize
+class LL_COMMON_API LLSDSerialize
 {
 public:
         enum ELLSD_Serialize
diff --git a/linden/indra/llcommon/llsdserialize_xml.cpp b/linden/indra/llcommon/llsdserialize_xml.cpp
index c12ca35..33206b4 100644
--- a/linden/indra/llcommon/llsdserialize_xml.cpp
+++ b/linden/indra/llcommon/llsdserialize_xml.cpp
@@ -562,7 +562,7 @@ void LLSDXMLParser::Impl::parsePart(const char* buf, int len)
 
 #ifdef XML_PARSER_PERFORMANCE_TESTS
 
-extern U64 totalTime();
+extern LL_COMMON_API U64 totalTime();
 U64     readElementTime = 0;
 U64 startElementTime = 0;
 U64 endElementTime = 0;
diff --git a/linden/indra/llcommon/llsdutil.h b/linden/indra/llcommon/llsdutil.h
index b67ad52..4740a30 100644
--- a/linden/indra/llcommon/llsdutil.h
+++ b/linden/indra/llcommon/llsdutil.h
@@ -68,28 +68,28 @@ LLSD ll_sd_from_color4(const LLColor4& c);
 LLColor4 ll_color4_from_sd(const LLSD& sd);
 
 // U32
-LLSD ll_sd_from_U32(const U32);
-U32 ll_U32_from_sd(const LLSD& sd);
+LL_COMMON_API LLSD ll_sd_from_U32(const U32);
+LL_COMMON_API U32 ll_U32_from_sd(const LLSD& sd);
 
 // U64
-LLSD ll_sd_from_U64(const U64);
-U64 ll_U64_from_sd(const LLSD& sd);
+LL_COMMON_API LLSD ll_sd_from_U64(const U64);
+LL_COMMON_API U64 ll_U64_from_sd(const LLSD& sd);
 
 // IP Address
-LLSD ll_sd_from_ipaddr(const U32);
-U32 ll_ipaddr_from_sd(const LLSD& sd);
+LL_COMMON_API LLSD ll_sd_from_ipaddr(const U32);
+LL_COMMON_API U32 ll_ipaddr_from_sd(const LLSD& sd);
 
 // Binary to string
-LLSD ll_string_from_binary(const LLSD& sd);
+LL_COMMON_API LLSD ll_string_from_binary(const LLSD& sd);
 
 //String to binary
-LLSD ll_binary_from_string(const LLSD& sd);
+LL_COMMON_API LLSD ll_binary_from_string(const LLSD& sd);
 
 // Serializes sd to static buffer and returns pointer, useful for gdb debugging.
-char* ll_print_sd(const LLSD& sd);
+LL_COMMON_API char* ll_print_sd(const LLSD& sd);
 
 // Serializes sd to static buffer and returns pointer, using "pretty printing" mode.
-char* ll_pretty_print_sd(const LLSD& sd);
+LL_COMMON_API char* ll_pretty_print_sd(const LLSD& sd);
 
 //compares the structure of an LLSD to a template LLSD and stores the
 //"valid" values in a 3rd LLSD. Default values
@@ -98,7 +98,7 @@ char* ll_pretty_print_sd(const LLSD& sd);
 //Returns false if the test is of same type but values differ in type
 //Otherwise, returns true
 
-BOOL compare_llsd_with_template(
+LL_COMMON_API BOOL compare_llsd_with_template(
         const LLSD& llsd_to_test,
         const LLSD& template_llsd,
         LLSD& resultant_llsd);
diff --git a/linden/indra/llcommon/llsecondlifeurls.h b/linden/indra/llcommon/llsecondlifeurls.h
index 9c64b57..e3932d0 100644
--- a/linden/indra/llcommon/llsecondlifeurls.h
+++ b/linden/indra/llcommon/llsecondlifeurls.h
@@ -34,14 +34,14 @@
 #define LL_LLSECONDLIFEURLS_H
 
 
-extern const std::string AUCTION_URL; 
+LL_COMMON_API extern const std::string AUCTION_URL; 
 
-extern const std::string EVENTS_URL;
+LL_COMMON_API extern const std::string EVENTS_URL;
 
 // Currency page
-extern const std::string BUY_CURRENCY_URL;
+LL_COMMON_API extern const std::string BUY_CURRENCY_URL;
 
 // Release Notes Redirect URL for Server and Viewer
-extern const std::string RELEASE_NOTES_BASE_URL;
+LL_COMMON_API extern const std::string RELEASE_NOTES_BASE_URL;
 
 #endif
diff --git a/linden/indra/llcommon/llsimplehash.h b/linden/indra/llcommon/llsimplehash.h
index 0ba2a30..5df93b6 100644
--- a/linden/indra/llcommon/llsimplehash.h
+++ b/linden/indra/llcommon/llsimplehash.h
@@ -64,7 +64,7 @@ public:
 };
 
 template <typename HASH_KEY_TYPE, int TABLE_SIZE>
-class LLSimpleHash
+class LL_COMMON_API LLSimpleHash
 {
 public:
         LLSimpleHash()
diff --git a/linden/indra/llcommon/llstat.h b/linden/indra/llcommon/llstat.h
index 66521a3..951091b 100644
--- a/linden/indra/llcommon/llstat.h
+++ b/linden/indra/llcommon/llstat.h
@@ -52,7 +52,7 @@ class	LLSD;
 // amounts of time with very low memory cost.
 //
 
-class LLStatAccum
+class LL_COMMON_API LLStatAccum
 {
 protected:
         LLStatAccum(bool use_frame_timer);
@@ -109,7 +109,7 @@ public:
         F64     mLastSampleValue;
 };
 
-class LLStatMeasure : public LLStatAccum
+class LL_COMMON_API LLStatMeasure : public LLStatAccum
         // gathers statistics about things that are measured
         // ex.: tempature, time dilation
 {
@@ -124,7 +124,7 @@ public:
 };
 
 
-class LLStatRate : public LLStatAccum
+class LL_COMMON_API LLStatRate : public LLStatAccum
         // gathers statistics about things that can be counted over time
         // ex.: LSL instructions executed, messages sent, simulator frames completed
         // renders it in terms of rate of thing per second
@@ -140,7 +140,7 @@ public:
 };
 
 
-class LLStatTime : public LLStatAccum
+class LL_COMMON_API LLStatTime : public LLStatAccum
         // gathers statistics about time spent in a block of code
         // measure average duration per second in the block
 {
@@ -171,7 +171,7 @@ private:
 
 
 // Use this class on the stack to record statistics about an area of code
-class LLPerfBlock
+class LL_COMMON_API LLPerfBlock
 {
 public:
     struct StatEntry
@@ -213,7 +213,7 @@ private:
 
 // ----------------------------------------------------------------------------
 
-class LLPerfStats
+class LL_COMMON_API LLPerfStats
 {
 public:
     LLPerfStats(const std::string& process_name = "unknown", S32 process_pid = 0);
@@ -249,7 +249,7 @@ private:
 };
 
 // ----------------------------------------------------------------------------
-class LLStat
+class LL_COMMON_API LLStat
 {
 public:
         LLStat(const U32 num_bins = 32, BOOL use_frame_timer = FALSE);
diff --git a/linden/indra/llcommon/llstreamtools.h b/linden/indra/llcommon/llstreamtools.h
index a6dc4d5..371fac5 100644
--- a/linden/indra/llcommon/llstreamtools.h
+++ b/linden/indra/llcommon/llstreamtools.h
@@ -39,23 +39,23 @@
 // unless specifed otherwise these all return input_stream.good()
 
 // skips spaces and tabs
-bool skip_whitespace(std::istream& input_stream);
+LL_COMMON_API bool skip_whitespace(std::istream& input_stream);
 
 // skips whitespace and newlines
-bool skip_emptyspace(std::istream& input_stream);
+LL_COMMON_API bool skip_emptyspace(std::istream& input_stream);
 
 // skips emptyspace and lines that start with a #
-bool skip_comments_and_emptyspace(std::istream& input_stream);
+LL_COMMON_API bool skip_comments_and_emptyspace(std::istream& input_stream);
 
 // skips to character after next newline
-bool skip_line(std::istream& input_stream);
+LL_COMMON_API bool skip_line(std::istream& input_stream);
 
 // skips to beginning of next non-emptyspace
-bool skip_to_next_word(std::istream& input_stream);
+LL_COMMON_API bool skip_to_next_word(std::istream& input_stream);
 
 // skips to character after the end of next keyword 
 // a 'keyword' is defined as the first word on a line
-bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream);
+LL_COMMON_API bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream);
 
 // skip_to_start_of_next_keyword() is disabled -- might tickle corruption bug 
 // in windows iostream
@@ -65,14 +65,14 @@ bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream
 
 // characters are pulled out of input_stream and appended to output_string
 // returns result of input_stream.good() after characters are pulled
-bool get_word(std::string& output_string, std::istream& input_stream);
-bool get_line(std::string& output_string, std::istream& input_stream);
+LL_COMMON_API bool get_word(std::string& output_string, std::istream& input_stream);
+LL_COMMON_API bool get_line(std::string& output_string, std::istream& input_stream);
 
 // characters are pulled out of input_stream (up to a max of 'n')
 // and appended to output_string 
 // returns result of input_stream.good() after characters are pulled
-bool get_word(std::string& output_string, std::istream& input_stream, int n);
-bool get_line(std::string& output_string, std::istream& input_stream, int n);
+LL_COMMON_API bool get_word(std::string& output_string, std::istream& input_stream, int n);
+LL_COMMON_API bool get_line(std::string& output_string, std::istream& input_stream, int n);
 
 // unget_line() is disabled -- might tickle corruption bug in windows iostream
 //// backs up the input_stream by line_size + 1 characters
@@ -82,28 +82,28 @@ bool get_line(std::string& output_string, std::istream& input_stream, int n);
 
 // removes the last char in 'line' if it matches 'c'
 // returns true if removed last char
-bool remove_last_char(char c, std::string& line);
+LL_COMMON_API bool remove_last_char(char c, std::string& line);
 
 // replaces escaped characters with the correct characters from left to right
 // "\\" ---> '\\' 
 // "\n" ---> '\n' 
-void unescape_string(std::string& line);
+LL_COMMON_API void unescape_string(std::string& line);
 
 // replaces unescaped characters with expanded equivalents from left to right
 // '\\' ---> "\\" 
 // '\n' ---> "\n" 
-void escape_string(std::string& line);
+LL_COMMON_API void escape_string(std::string& line);
 
 // replaces each '\n' character with ' '
-void replace_newlines_with_whitespace(std::string& line);
+LL_COMMON_API void replace_newlines_with_whitespace(std::string& line);
 
 // erases any double-quote characters in line
-void remove_double_quotes(std::string& line);
+LL_COMMON_API void remove_double_quotes(std::string& line);
 
 // the 'keyword' is defined as the first word on a line
 // the 'value' is everything after the keyword on the same line
 // starting at the first non-whitespace and ending right before the newline
-void get_keyword_and_value(std::string& keyword, 
+LL_COMMON_API void get_keyword_and_value(std::string& keyword,
                                                    std::string& value, 
                                                    const std::string& line);
 
@@ -111,13 +111,13 @@ void get_keyword_and_value(std::string& keyword,
 // read anymore or until we hit the count.  Some istream
 // implimentations have a max that they will read.
 // Returns the number of bytes read.
-std::streamsize fullread(
+LL_COMMON_API std::streamsize fullread(
         std::istream& istr,
         char* buf,
         std::streamsize requested);
 
 
-std::istream& operator>>(std::istream& str, const char *tocheck);
+LL_COMMON_API std::istream& operator>>(std::istream& str, const char *tocheck);
 
 #endif
 
diff --git a/linden/indra/llcommon/llstring.cpp b/linden/indra/llcommon/llstring.cpp
index 1f653c1..cd5a9f2 100644
--- a/linden/indra/llcommon/llstring.cpp
+++ b/linden/indra/llcommon/llstring.cpp
@@ -50,7 +50,8 @@ std::string ll_safe_string(const char* in)
 
 std::string ll_safe_string(const char* in, S32 maxlen)
 {
-        if(in) return std::string(in, maxlen);
+//KOKUA FIXME:  Which wormhole all the antistrings (strings with negative length) come from ?
+        if(in && maxlen > 0) return std::string(in, maxlen);
         return std::string();
 }
 
@@ -595,6 +596,40 @@ std::string utf8str_removeCRLF(const std::string& utf8str)
         return out;
 }
 
+bool is_hex_string(U8* str, S32 len)
+{
+        bool rv = true;
+        U8* c = str;
+        while(rv && len--)
+        {
+                switch(*c)
+                {
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                case 'a':
+                case 'b':
+                case 'c':
+                case 'd':
+                case 'e':
+                case 'f':
+                        ++c;
+                        break;
+                default:
+                        rv = false;
+                        break;
+                }
+        }
+        return rv;
+}
+
 #if LL_WINDOWS
 // documentation moved to header. Phoenix 2007-11-27
 namespace snprintf_hack
diff --git a/linden/indra/llcommon/llstring.h b/linden/indra/llcommon/llstring.h
index 7db62bc..a592e2c 100644
--- a/linden/indra/llcommon/llstring.h
+++ b/linden/indra/llcommon/llstring.h
@@ -34,12 +34,14 @@
 #define LL_LLSTRING_H
 
 #include <string>
+#include <cstdio>
+#include <algorithm>
+#include <map>
 
 #if LL_LINUX || LL_SOLARIS
 #include <wctype.h>
 #include <wchar.h>
 #endif
-#include "linden_common.h"
 
 #include <string.h>
 
@@ -144,7 +146,7 @@ struct char_traits<U16>
 };
 #endif
 
-class LLStringOps
+class LL_COMMON_API LLStringOps
 {
 public:
         static char toUpper(char elem) { return toupper((unsigned char)elem); }
@@ -179,8 +181,8 @@ public:
  * @brief Return a string constructed from in without crashing if the
  * pointer is NULL.
  */
-std::string ll_safe_string(const char* in);
-std::string ll_safe_string(const char* in, S32 maxlen);
+std::string LL_COMMON_API ll_safe_string(const char* in);
+std::string LL_COMMON_API ll_safe_string(const char* in, S32 maxlen);
 
 
 // Allowing assignments from non-strings into format_map_t is apparently
@@ -209,7 +211,7 @@ public:
         /////////////////////////////////////////////////////////////////////////////////////////
         // Static Utility functions that operate on std::strings
 
-        static std::basic_string<T> null;
+        static std::basic_string<T> const null;
         
         typedef std::map<LLFormatMapString, LLFormatMapString> format_map_t;
         static S32 format(std::basic_string<T>& s, const format_map_t& fmt_map);
@@ -236,7 +238,8 @@ public:
         static void     replaceTabsWithSpaces( std::basic_string<T>& string, size_type spaces_per_tab );
         static void     replaceNonstandardASCII( std::basic_string<T>& string, T replacement );
         static void     replaceChar( std::basic_string<T>& string, T target, T replacement );
-
+        static void replaceString( std::basic_string<T>& string, std::basic_string<T> target, std::basic_string<T> replacement );
+        
         static BOOL     containsNonprintable(const std::basic_string<T>& string);
         static void     stripNonprintable(std::basic_string<T>& string);
 
@@ -299,7 +302,7 @@ public:
 
 };
 
-template<class T> std::basic_string<T> LLStringUtilBase<T>::null;
+template<class T> std::basic_string<T> const LLStringUtilBase<T>::null;
 
 typedef LLStringUtilBase<char> LLStringUtil;
 typedef LLStringUtilBase<llwchar> LLWStringUtil;
@@ -349,7 +352,7 @@ inline std::string chop_tail_copy(
  * @brief This translates a nybble stored as a hex value from 0-f back
  * to a nybble in the low order bits of the return byte.
  */
-U8 hex_as_nybble(char hex);
+LL_COMMON_API U8 hex_as_nybble(char hex);
 
 /**
  * @brief read the contents of a file into a string.
@@ -360,7 +363,7 @@ U8 hex_as_nybble(char hex);
  * @param filename The full name of the file to read.
  * @return Returns true on success. If false, str is unmodified.
  */
-bool _read_file_into_string(std::string& str, const std::string& filename);
+LL_COMMON_API bool _read_file_into_string(std::string& str, const std::string& filename);
 
 /**
  * Unicode support
@@ -369,52 +372,52 @@ bool _read_file_into_string(std::string& str, const std::string& filename);
 // Make the incoming string a utf8 string. Replaces any unknown glyph
 // with the UNKOWN_CHARACTER. Once any unknown glph is found, the rest
 // of the data may not be recovered.
-std::string rawstr_to_utf8(const std::string& raw);
+LL_COMMON_API std::string rawstr_to_utf8(const std::string& raw);
 
 //
 // We should never use UTF16 except when communicating with Win32!
 //
 typedef std::basic_string<U16> llutf16string;
 
-LLWString utf16str_to_wstring(const llutf16string &utf16str, S32 len);
-LLWString utf16str_to_wstring(const llutf16string &utf16str);
+LL_COMMON_API LLWString utf16str_to_wstring(const llutf16string &utf16str, S32 len);
+LL_COMMON_API LLWString utf16str_to_wstring(const llutf16string &utf16str);
 
-llutf16string wstring_to_utf16str(const LLWString &utf32str, S32 len);
-llutf16string wstring_to_utf16str(const LLWString &utf32str);
+LL_COMMON_API llutf16string wstring_to_utf16str(const LLWString &utf32str, S32 len);
+LL_COMMON_API llutf16string wstring_to_utf16str(const LLWString &utf32str);
 
-llutf16string utf8str_to_utf16str ( const std::string& utf8str, S32 len);
-llutf16string utf8str_to_utf16str ( const std::string& utf8str );
+LL_COMMON_API llutf16string utf8str_to_utf16str ( const std::string& utf8str, S32 len);
+LL_COMMON_API llutf16string utf8str_to_utf16str ( const std::string& utf8str );
 
-LLWString utf8str_to_wstring(const std::string &utf8str, S32 len);
-LLWString utf8str_to_wstring(const std::string &utf8str);
+LL_COMMON_API LLWString utf8str_to_wstring(const std::string &utf8str, S32 len);
+LL_COMMON_API LLWString utf8str_to_wstring(const std::string &utf8str);
 // Same function, better name. JC
 inline LLWString utf8string_to_wstring(const std::string& utf8_string) { return utf8str_to_wstring(utf8_string); }
 
 //
-S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
+LL_COMMON_API S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
 
-std::string wstring_to_utf8str(const LLWString &utf32str, S32 len);
-std::string wstring_to_utf8str(const LLWString &utf32str);
+LL_COMMON_API std::string wstring_to_utf8str(const LLWString &utf32str, S32 len);
+LL_COMMON_API std::string wstring_to_utf8str(const LLWString &utf32str);
 
-std::string utf16str_to_utf8str(const llutf16string &utf16str, S32 len);
-std::string utf16str_to_utf8str(const llutf16string &utf16str);
+LL_COMMON_API std::string utf16str_to_utf8str(const llutf16string &utf16str, S32 len);
+LL_COMMON_API std::string utf16str_to_utf8str(const llutf16string &utf16str);
 
 // Length of this UTF32 string in bytes when transformed to UTF8
-S32 wstring_utf8_length(const LLWString& wstr); 
+LL_COMMON_API S32 wstring_utf8_length(const LLWString& wstr);
 
 // Length in bytes of this wide char in a UTF8 string
-S32 wchar_utf8_length(const llwchar wc); 
+LL_COMMON_API S32 wchar_utf8_length(const llwchar wc);
 
-std::string utf8str_tolower(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_tolower(const std::string& utf8str);
 
 // Length in llwchar (UTF-32) of the first len units (16 bits) of the given UTF-16 string.
-S32 utf16str_wstring_length(const llutf16string &utf16str, S32 len);
+LL_COMMON_API S32 utf16str_wstring_length(const llutf16string &utf16str, S32 len);
 
 // Length in utf16string (UTF-16) of wlen wchars beginning at woffset.
-S32 wstring_utf16_length(const LLWString & wstr, S32 woffset, S32 wlen);
+LL_COMMON_API S32 wstring_utf16_length(const LLWString & wstr, S32 woffset, S32 wlen);
 
 // Length in wstring (i.e., llwchar count) of a part of a wstring specified by utf16 length (i.e., utf16 units.)
-S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, S32 woffset, S32 utf16_length, BOOL *unaligned = NULL);
+LL_COMMON_API S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, S32 woffset, S32 utf16_length, BOOL *unaligned = NULL);
 
 /**
  * @brief Properly truncate a utf8 string to a maximum byte count.
@@ -426,11 +429,11 @@ S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, S32 woffset
  * @param max_len The maximum number of bytes in the return value.
  * @return Returns a valid utf8 string with byte count <= max_len.
  */
-std::string utf8str_truncate(const std::string& utf8str, const S32 max_len);
+LL_COMMON_API std::string utf8str_truncate(const std::string& utf8str, const S32 max_len);
 
-std::string utf8str_trim(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_trim(const std::string& utf8str);
 
-S32 utf8str_compare_insensitive(
+LL_COMMON_API S32 utf8str_compare_insensitive(
         const std::string& lhs,
         const std::string& rhs);
 
@@ -441,17 +444,19 @@ S32 utf8str_compare_insensitive(
  * @param target_char The wchar to be replaced
  * @param replace_char The wchar which is written on replace
  */
-std::string utf8str_substChar(
+LL_COMMON_API std::string utf8str_substChar(
         const std::string& utf8str,
         const llwchar target_char,
         const llwchar replace_char);
 
-std::string utf8str_makeASCII(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_makeASCII(const std::string& utf8str);
 
 // Hack - used for evil notecards.
-std::string mbcsstring_makeASCII(const std::string& str); 
+LL_COMMON_API std::string mbcsstring_makeASCII(const std::string& str);
 
-std::string utf8str_removeCRLF(const std::string& utf8str);
+LL_COMMON_API std::string utf8str_removeCRLF(const std::string& utf8str);
+
+LL_COMMON_API bool is_hex_string(U8* str, S32 len);
 
 
 #if LL_WINDOWS
@@ -476,14 +481,21 @@ std::string utf8str_removeCRLF(const std::string& utf8str);
  * formatted string.
  *
  */
-int safe_snprintf(char* str, size_t size, const char* format, ...);
+
+// Deal with the differeneces on Windows
+namespace snprintf_hack
+{
+    LL_COMMON_API int snprintf(char *str, size_t size, const char *format, ...);
+}
+
+using snprintf_hack::snprintf;
 
 /**
  * @brief Convert a wide string to std::string
  *
  * This replaces the unsafe W2A macro from ATL.
  */
-std::string ll_convert_wide_to_string(const wchar_t* in);
+LL_COMMON_API std::string ll_convert_wide_to_string(const wchar_t* in);
 
 //@}
 #endif // LL_WINDOWS
@@ -506,7 +518,7 @@ namespace LLStringFn
          * with zero non-printable characters.
          * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
          */
-        void replace_nonprintable_in_ascii(
+        LL_COMMON_API void replace_nonprintable_in_ascii(
                 std::basic_string<char>& string,
                 char replacement);
 
@@ -520,7 +532,7 @@ namespace LLStringFn
          * with zero non-printable characters and zero pipe characters.
          * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
          */
-        void replace_nonprintable_and_pipe_in_ascii(std::basic_string<char>& str,
+        LL_COMMON_API void replace_nonprintable_and_pipe_in_ascii(std::basic_string<char>& str,
                                                                            char replacement);
 
 
@@ -529,7 +541,7 @@ namespace LLStringFn
          * Returns a copy of the string with those characters removed.
          * Works with US ASCII and UTF-8 encoded strings.  JC
          */
-        std::string strip_invalid_xml(const std::string& input);
+        LL_COMMON_API std::string strip_invalid_xml(const std::string& input);
 
 
         /**
@@ -540,7 +552,7 @@ namespace LLStringFn
          * with zero non-printable characters.
          * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
          */
-        void replace_ascii_controlchars(
+        LL_COMMON_API void replace_ascii_controlchars(
                 std::basic_string<char>& string,
                 char replacement);
 }
@@ -870,6 +882,7 @@ void LLStringUtilBase<T>::addCRLF(std::basic_string<T>& string)
                 }
 
                 string.assign(t, size);
+                delete[] t;
         }
 }
 
@@ -900,11 +913,22 @@ template<class T>
 void LLStringUtilBase<T>::replaceChar( std::basic_string<T>& string, T target, T replacement )
 {
         size_type found_pos = 0;
-        for (found_pos = string.find(target, found_pos); 
-                found_pos != std::basic_string<T>::npos; 
-                found_pos = string.find(target, found_pos))
+        while( (found_pos = string.find(target, found_pos)) != std::basic_string<T>::npos ) 
         {
                 string[found_pos] = replacement;
+                found_pos++; // avoid infinite defeat if target == replacement
+        }
+}
+
+//static
+template<class T> 
+void LLStringUtilBase<T>::replaceString( std::basic_string<T>& string, std::basic_string<T> target, std::basic_string<T> replacement )
+{
+        size_type found_pos = 0;
+        while( (found_pos = string.find(target, found_pos)) != std::basic_string<T>::npos )
+        {
+                string.replace( found_pos, target.length(), replacement );
+                found_pos += replacement.length(); // avoid infinite defeat if replacement contains target
         }
 }
 
diff --git a/linden/indra/llcommon/llstringtable.h b/linden/indra/llcommon/llstringtable.h
index 4492063..b13b016 100644
--- a/linden/indra/llcommon/llstringtable.h
+++ b/linden/indra/llcommon/llstringtable.h
@@ -56,7 +56,7 @@
 
 const U32 MAX_STRINGS_LENGTH = 256;
 
-class LLStringTableEntry
+class LL_COMMON_API LLStringTableEntry
 {
 public:
         LLStringTableEntry(const char *str)
@@ -81,7 +81,7 @@ public:
         S32  mCount;
 };
 
-class LLStringTable
+class LL_COMMON_API LLStringTable
 {
 public:
         LLStringTable(int tablesize);
@@ -115,7 +115,7 @@ public:
 #endif  
 };
 
-extern LLStringTable gStringTable;
+extern LL_COMMON_API LLStringTable gStringTable;
 
 //============================================================================
 
@@ -125,7 +125,7 @@ extern LLStringTable gStringTable;
 
 typedef const std::string* LLStdStringHandle;
 
-class LLStdStringTable
+class LL_COMMON_API LLStdStringTable
 {
 public:
         LLStdStringTable(S32 tablesize = 0)
diff --git a/linden/indra/llcommon/llsys.cpp b/linden/indra/llcommon/llsys.cpp
index a56ac47..95dd2e5 100644
--- a/linden/indra/llcommon/llsys.cpp
+++ b/linden/indra/llcommon/llsys.cpp
@@ -76,6 +76,75 @@ extern int errno;
 static const S32 CPUINFO_BUFFER_SIZE = 16383;
 LLCPUInfo gSysCPU;
 
+#if LL_WINDOWS
+#ifndef DLLVERSIONINFO
+typedef struct _DllVersionInfo
+{
+    DWORD cbSize;
+    DWORD dwMajorVersion;
+    DWORD dwMinorVersion;
+    DWORD dwBuildNumber;
+    DWORD dwPlatformID;
+}DLLVERSIONINFO;
+#endif
+
+#ifndef DLLGETVERSIONPROC
+typedef int (FAR WINAPI *DLLGETVERSIONPROC) (DLLVERSIONINFO *);
+#endif
+
+bool get_shell32_dll_version(DWORD& major, DWORD& minor, DWORD& build_number)
+{
+        bool result = false;
+        const U32 BUFF_SIZE = 32767;
+        WCHAR tempBuf[BUFF_SIZE];
+        if(GetSystemDirectory((LPWSTR)&tempBuf, BUFF_SIZE))
+        {
+                
+                std::basic_string<WCHAR> shell32_path(tempBuf);
+
+                // Shell32.dll contains the DLLGetVersion function. 
+                // according to msdn its not part of the API
+                // so you have to go in and get it.
+                // http://msdn.microsoft.com/en-us/library/bb776404(VS.85).aspx
+                shell32_path += TEXT("\\shell32.dll");
+
+                HMODULE hDllInst = LoadLibrary(shell32_path.c_str());   //load the DLL
+                if(hDllInst) 
+                {  // Could successfully load the DLL
+                        DLLGETVERSIONPROC pDllGetVersion;
+                        /*
+                        You must get this function explicitly because earlier versions of the DLL
+                        don't implement this function. That makes the lack of implementation of the
+                        function a version marker in itself.
+                        */
+                        pDllGetVersion = (DLLGETVERSIONPROC) GetProcAddress(hDllInst, 
+                                                                                                                                "DllGetVersion");
+
+                        if(pDllGetVersion) 
+                        {    
+                                // DLL supports version retrieval function
+                                DLLVERSIONINFO    dvi;
+
+                                ZeroMemory(&dvi, sizeof(dvi));
+                                dvi.cbSize = sizeof(dvi);
+                                HRESULT hr = (*pDllGetVersion)(&dvi);
+
+                                if(SUCCEEDED(hr)) 
+                                { // Finally, the version is at our hands
+                                        major = dvi.dwMajorVersion;
+                                        minor = dvi.dwMinorVersion;
+                                        build_number = dvi.dwBuildNumber;
+                                        result = true;
+                                } 
+                        } 
+
+                        FreeLibrary(hDllInst);  // Release DLL
+                } 
+        }
+        return result;
+}
+#endif // LL_WINDOWS
+
 LLOSInfo::LLOSInfo() :
         mMajorVer(0), mMinorVer(0), mBuild(0)
 {
@@ -98,44 +167,74 @@ LLOSInfo::LLOSInfo() :
         mMinorVer = osvi.dwMinorVersion;
         mBuild = osvi.dwBuildNumber;
 
+        DWORD shell32_major, shell32_minor, shell32_build;
+        bool got_shell32_version = get_shell32_dll_version(shell32_major, 
+                                                                                                           shell32_minor, 
+                                                                                                           shell32_build);
+
         switch(osvi.dwPlatformId)
         {
         case VER_PLATFORM_WIN32_NT:
                 {
                         // Test for the product.
-                        if(osvi.dwMajorVersion <= 4)
+                        if (osvi.dwMajorVersion <= 4)
                         {
                                 mOSStringSimple = "Microsoft Windows NT ";
                         }
-                        else if(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
+                        else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
                         {
                                 mOSStringSimple = "Microsoft Windows 2000 ";
                         }
-                        else if(osvi.dwMajorVersion ==5 && osvi.dwMinorVersion == 1)
+                        else if (osvi.dwMajorVersion ==5 && osvi.dwMinorVersion == 1)
                         {
                                 mOSStringSimple = "Microsoft Windows XP ";
                         }
-                        else if(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2)
+                        else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2)
                         {
-                                 if(osvi.wProductType == VER_NT_WORKSTATION)
+                                if (osvi.wProductType == VER_NT_WORKSTATION)
+                                {
                                         mOSStringSimple = "Microsoft Windows XP x64 Edition ";
-                                 else
-                                         mOSStringSimple = "Microsoft Windows Server 2003 ";
+                                }
+                                else
+                                {
+                                        mOSStringSimple = "Microsoft Windows Server 2003 ";
+                                }
                         }
-                        else if(osvi.dwMajorVersion == 6 && osvi.dwMinorVersion <= 1)
+                        else if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion <= 2)
                         {
-                                if(osvi.dwMinorVersion == 0)
+                                if (osvi.dwMinorVersion == 0)
                                 {
-                                        mOSStringSimple = "Microsoft Windows Vista ";
+                                        if (osvi.wProductType == VER_NT_WORKSTATION)
+                                        {
+                                                mOSStringSimple = "Microsoft Windows Vista ";
+                                        }
+                                        else
+                                        {
+                                                mOSStringSimple = "Windows Server 2008 ";
+                                        }
+
                                 }
-                                else if(osvi.dwMinorVersion == 1)
+                                else if (osvi.dwMinorVersion == 1)
                                 {
-                                        mOSStringSimple = "Microsoft Windows 7 ";
+                                        if (osvi.wProductType == VER_NT_WORKSTATION)
+                                        {
+                                                mOSStringSimple = "Microsoft Windows 7 ";
+                                        }
+                                        else
+                                        {
+                                                mOSStringSimple = "Windows Server 2008 R2 ";
+                                        }
                                 }
-
-                                if(osvi.wProductType != VER_NT_WORKSTATION)
+                                else if (osvi.dwMinorVersion == 2)
                                 {
-                                        mOSStringSimple += "Server ";
+                                        if (osvi.wProductType == VER_NT_WORKSTATION)
+                                        {
+                                                mOSStringSimple = "Microsoft Windows 8 ";
+                                        }
+                                        else
+                                        {
+                                                mOSStringSimple = "Windows Server 2012 ";
+                                        }
                                 }
 
                                 ///get native system info if available..
@@ -146,8 +245,8 @@ LLOSInfo::LLOSInfo() :
                                 pGNSI = (PGNSI) GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),  "GetNativeSystemInfo"); //load kernel32 get function
                                 if(NULL != pGNSI) //check if it has failed
                                         pGNSI(&si); //success
-                                else
-                                        GetSystemInfo(&si); //if it fails get regular system info
+                                else 
+                                        GetSystemInfo(&si); //if it fails get regular system info 
                                 //(Warning: If GetSystemInfo it may result in incorrect information in a WOW64 machine, if the kernel fails to load)
 
                                 //msdn microsoft finds 32 bit and 64 bit flavors this way..
@@ -206,6 +305,7 @@ LLOSInfo::LLOSInfo() :
                                                                   csdversion.c_str(),
                                                                   (osvi.dwBuildNumber & 0xffff));
                         }
+
                         mOSString = mOSStringSimple + tmpstr;
                 }
                 break;
@@ -235,6 +335,20 @@ LLOSInfo::LLOSInfo() :
                 mOSString = mOSStringSimple;
                 break;
         }
+
+        std::string compatibility_mode;
+        if(got_shell32_version)
+        {
+                if(osvi.dwMajorVersion != shell32_major || osvi.dwMinorVersion != shell32_minor)
+                {
+                        compatibility_mode = llformat(" compatibility mode. real ver: %d.%d (Build %d)", 
+                                                                                        shell32_major,
+                                                                                        shell32_minor,
+                                                                                        shell32_build);
+                }
+        }
+        mOSString += compatibility_mode;
+
 #else
         struct utsname un;
         if(uname(&un) != -1)
@@ -262,8 +376,8 @@ LLOSInfo::LLOSInfo() :
                 else if (ostype == "Linux")
                 {
                         // Only care about major and minor Linux versions, truncate at second '.'
-                        S32 idx1 = mOSStringSimple.find_first_of(".", 0);
-                        S32 idx2 = (idx1 != std::string::npos) ? mOSStringSimple.find_first_of(".", idx1+1) : std::string::npos;
+                        std::string::size_type idx1 = mOSStringSimple.find_first_of(".", 0);
+                        std::string::size_type idx2 = (idx1 != std::string::npos) ? mOSStringSimple.find_first_of(".", idx1+1) : std::string::npos;
                         std::string simple = mOSStringSimple.substr(0, idx2);
                         if (simple.length() > 0)
                                 mOSStringSimple = simple;
@@ -429,15 +543,15 @@ LLCPUInfo::LLCPUInfo()
         mHasSSE = info->_Ext.SSE_StreamingSIMD_Extensions;
         mHasSSE2 = info->_Ext.SSE2_StreamingSIMD2_Extensions;
         mHasAltivec = info->_Ext.Altivec_Extensions;
-        mCPUMhz = (S32)(proc.GetCPUFrequency(50)/1000000.0);
+        mCPUMHz = (F64)(proc.GetCPUFrequency(50)/1000000.0);
         mFamily.assign( info->strFamily );
         mCPUString = "Unknown";
 
 #if LL_WINDOWS || LL_DARWIN || LL_SOLARIS
         out << proc.strCPUName;
-        if (200 < mCPUMhz && mCPUMhz < 10000)           // *NOTE: cpu speed is often way wrong, do a sanity check
+        if (200 < mCPUMHz && mCPUMHz < 10000)           // *NOTE: cpu speed is often way wrong, do a sanity check
         {
-                out << " (" << mCPUMhz << " MHz)";
+                out << " (" << mCPUMHz << " MHz)";
         }
         mCPUString = out.str();
         
@@ -482,7 +596,7 @@ LLCPUInfo::LLCPUInfo()
         if (LLStringUtil::convertToF64(cpuinfo["cpu mhz"], mhz)
             && 200.0 < mhz && mhz < 10000.0)
         {
-                mCPUMhz = (S32)llrint(mhz);
+                mCPUMHz = (F64)llrint(mhz);
         }
         if (!cpuinfo["model name"].empty())
                 mCPUString = cpuinfo["model name"];
@@ -505,9 +619,9 @@ bool LLCPUInfo::hasSSE2() const
         return mHasSSE2;
 }
 
-S32 LLCPUInfo::getMhz() const
+F64 LLCPUInfo::getMHz() const
 {
-        return mCPUMhz;
+        return mCPUMHz;
 }
 
 std::string LLCPUInfo::getCPUString() const
@@ -554,7 +668,7 @@ void LLCPUInfo::stream(std::ostream& s) const
         s << "->mHasSSE:     " << (U32)mHasSSE << std::endl;
         s << "->mHasSSE2:    " << (U32)mHasSSE2 << std::endl;
         s << "->mHasAltivec: " << (U32)mHasAltivec << std::endl;
-        s << "->mCPUMhz:     " << mCPUMhz << std::endl;
+        s << "->mCPUMHz:     " << mCPUMHz << std::endl;
         s << "->mCPUString:  " << mCPUString << std::endl;
 }
 
@@ -631,6 +745,26 @@ U32 LLMemoryInfo::getPhysicalMemoryClamped() const
         }
 }
 
+//static
+void LLMemoryInfo::getAvailableMemoryKB(U32& avail_physical_mem_kb, U32& avail_virtual_mem_kb)
+{
+#if LL_WINDOWS
+        MEMORYSTATUSEX state;
+        state.dwLength = sizeof(state);
+        GlobalMemoryStatusEx(&state);
+
+        avail_physical_mem_kb = (U32)(state.ullAvailPhys/1024) ;
+        avail_virtual_mem_kb = (U32)(state.ullAvailVirtual/1024) ;
+
+#else
+        //do not know how to collect available memory info for other systems.
+        //leave it blank here for now.
+
+        avail_physical_mem_kb = -1 ;
+        avail_virtual_mem_kb = -1 ;
+#endif
+}
+
 void LLMemoryInfo::stream(std::ostream& s) const
 {
 #if LL_WINDOWS
diff --git a/linden/indra/llcommon/llsys.h b/linden/indra/llcommon/llsys.h
index 03f48ca..e481c88 100644
--- a/linden/indra/llcommon/llsys.h
+++ b/linden/indra/llcommon/llsys.h
@@ -45,7 +45,7 @@
 #include <iosfwd>
 #include <string>
 
-class LLOSInfo
+class LL_COMMON_API LLOSInfo
 {
 public:
         LLOSInfo();
@@ -70,7 +70,7 @@ private:
 };
 
 
-class LLCPUInfo
+class LL_COMMON_API LLCPUInfo
 {
 public:
         LLCPUInfo();    
@@ -81,7 +81,7 @@ public:
         bool hasAltivec() const;
         bool hasSSE() const;
         bool hasSSE2() const;
-        S32      getMhz() const;
+        F64 getMHz() const;
 
         // Family is "AMD Duron" or "Intel Pentium Pro"
         const std::string& getFamily() const { return mFamily; }
@@ -90,7 +90,7 @@ private:
         bool mHasSSE;
         bool mHasSSE2;
         bool mHasAltivec;
-        S32 mCPUMhz;
+        F64 mCPUMHz;
         std::string mFamily;
         std::string mCPUString;
 };
@@ -99,7 +99,7 @@ private:
 //
 //      CLASS           LLMemoryInfo
 
-class LLMemoryInfo
+class LL_COMMON_API LLMemoryInfo
 
 /*!     @brief          Class to query the memory subsystem
 
@@ -120,18 +120,21 @@ public:
         **  be returned.
         */
         U32 getPhysicalMemoryClamped() const; ///< Memory size in clamped bytes
+
+        //get the available memory infomation in KiloBytes.
+        static void getAvailableMemoryKB(U32& avail_physical_mem_kb, U32& avail_virtual_mem_kb);
 };
 
 
-std::ostream& operator<<(std::ostream& s, const LLOSInfo& info);
-std::ostream& operator<<(std::ostream& s, const LLCPUInfo& info);
-std::ostream& operator<<(std::ostream& s, const LLMemoryInfo& info);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLOSInfo& info);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLCPUInfo& info);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLMemoryInfo& info);
 
 // gunzip srcfile into dstfile.  Returns FALSE on error.
-BOOL gunzip_file(const std::string& srcfile, const std::string& dstfile);
+LL_COMMON_API BOOL gunzip_file(const std::string& srcfile, const std::string& dstfile);
 // gzip srcfile into dstfile.  Returns FALSE on error.
-BOOL gzip_file(const std::string& srcfile, const std::string& dstfile);
+LL_COMMON_API BOOL gzip_file(const std::string& srcfile, const std::string& dstfile);
 
-extern LLCPUInfo gSysCPU;
+LL_COMMON_API extern LLCPUInfo gSysCPU;
 
 #endif // LL_LLSYS_H
diff --git a/linden/indra/llcommon/llthread.cpp b/linden/indra/llcommon/llthread.cpp
index 692d6c4..f7732cb 100644
--- a/linden/indra/llcommon/llthread.cpp
+++ b/linden/indra/llcommon/llthread.cpp
@@ -72,8 +72,8 @@ void *APR_THREAD_FUNC LLThread::staticRun(apr_thread_t *apr_threadp, void *datap
         // Set thread state to running
         threadp->mStatus = RUNNING;
 
-        // Create a thread local APRFile pool.
-        LLVolatileAPRPool::createLocalAPRFilePool();
+        // Create a thread local data.
+        AIThreadLocalData::create(threadp);
 
         // Run the user supplied function
         threadp->run();
@@ -87,24 +87,14 @@ void *APR_THREAD_FUNC LLThread::staticRun(apr_thread_t *apr_threadp, void *datap
 }
 
 
-LLThread::LLThread(const std::string& name, apr_pool_t *poolp) :
+LLThread::LLThread(std::string const& name) :
         mPaused(false),
         mName(name),
         mAPRThreadp(NULL),
-        mStatus(STOPPED)
+        mStatus(STOPPED),
+        mThreadLocalData(NULL)
 {
-        // Thread creation probably CAN be paranoid about APR being initialized, if necessary
-        if (poolp)
-        {
-                mIsLocalPool = false;
-                mAPRPoolp = poolp;
-        }
-        else
-        {
-                mIsLocalPool = true;
-                apr_pool_create(&mAPRPoolp, NULL); // Create a subpool for this thread
-        }
-        mRunCondition = new LLCondition(mAPRPoolp);
+        mRunCondition = new LLCondition;
 }
 
 
@@ -147,24 +137,18 @@ void LLThread::shutdown()
                 if (!isStopped())
                 {
                         // This thread just wouldn't stop, even though we gave it time
-                        llwarns << "LLThread::~LLThread() exiting thread before clean exit!" << llendl;
+                        llwarns << "LLThread::shutdown() exiting thread before clean exit!" << llendl;
                         return;
                 }
                 mAPRThreadp = NULL;
         }
 
         delete mRunCondition;
-        
-        if (mIsLocalPool)
-        {
-                apr_pool_destroy(mAPRPoolp);
-        }
 }
 
-
 void LLThread::start()
 {
-        apr_thread_create(&mAPRThreadp, NULL, staticRun, (void *)this, mAPRPoolp);      
+        apr_thread_create(&mAPRThreadp, NULL, staticRun, (void *)this, tldata().mRootPool());
 
         // We won't bother joining
         apr_thread_detach(mAPRThreadp);
@@ -265,38 +249,72 @@ void LLThread::wakeLocked()
         }
 }
 
-//============================================================================
+#ifdef SHOW_ASSERT
+// This allows the use of llassert(is_main_thread()) to assure the current thread is the main thread.
+static apr_os_thread_t main_thread_id;
+bool is_main_thread() { return apr_os_thread_equal(main_thread_id, apr_os_thread_current()); }
+#endif
 
-LLMutex::LLMutex(apr_pool_t *poolp) :
-        mAPRMutexp(NULL)
+// The thread private handle to access the AIThreadLocalData instance.
+apr_threadkey_t* AIThreadLocalData::sThreadLocalDataKey;
+
+//static
+void AIThreadLocalData::init(void)
 {
-        //if (poolp)
-        //{
-        //      mIsLocalPool = false;
-        //      mAPRPoolp = poolp;
-        //}
-        //else
+        // Only do this once.
+        if (sThreadLocalDataKey)
         {
-                mIsLocalPool = true;
-                apr_pool_create(&mAPRPoolp, NULL); // Create a subpool for this thread
+                return;
         }
-        apr_thread_mutex_create(&mAPRMutexp, APR_THREAD_MUTEX_UNNESTED, mAPRPoolp);
+
+        apr_status_t status = apr_threadkey_private_create(&sThreadLocalDataKey, &AIThreadLocalData::destroy, AIAPRRootPool::get()());
+        ll_apr_assert_status(status);   // Or out of memory, or system-imposed limit on the
+                                                                        // total number of keys per process {PTHREAD_KEYS_MAX}
+                                                                        // has been exceeded.
+
+        // Create the thread-local data for the main thread (this function is called by the main thread).
+        AIThreadLocalData::create(NULL);
+
+#ifdef SHOW_ASSERT
+        // This function is called by the main thread.
+        main_thread_id = apr_os_thread_current();
+#endif
 }
 
-LLMutex::~LLMutex()
+// This is called once for every thread when the thread is destructed.
+//static
+void AIThreadLocalData::destroy(void* thread_local_data)
 {
-#if _DEBUG
-        llassert(!isLocked()); // better not be locked!
-#endif
-        apr_thread_mutex_destroy(mAPRMutexp);
-        mAPRMutexp = NULL;
-        if (mIsLocalPool)
+        delete reinterpret_cast<AIThreadLocalData*>(thread_local_data);
+}
+
+//static
+void AIThreadLocalData::create(LLThread* threadp)
+{
+        AIThreadLocalData* new_tld = new AIThreadLocalData;
+        if (threadp)
         {
-                apr_pool_destroy(mAPRPoolp);
+                threadp->mThreadLocalData = new_tld;
         }
+        apr_status_t status = apr_threadkey_private_set(new_tld, sThreadLocalDataKey);
+        llassert_always(status == APR_SUCCESS);
 }
 
-bool LLMutex::isLocked()
+//static
+AIThreadLocalData& AIThreadLocalData::tldata(void)
+{
+        if (!sThreadLocalDataKey)
+                AIThreadLocalData::init();
+
+        void* data;
+        apr_status_t status = apr_threadkey_private_get(&data, sThreadLocalDataKey);
+        llassert_always(status == APR_SUCCESS);
+        return *static_cast<AIThreadLocalData*>(data);
+}
+
+//============================================================================
+
+bool LLMutexBase::isLocked()
 {
         if (!tryLock())
         {
@@ -308,12 +326,9 @@ bool LLMutex::isLocked()
 
 //============================================================================
 
-LLCondition::LLCondition(apr_pool_t *poolp) :
-        LLMutex(poolp)
+LLCondition::LLCondition(AIAPRPool& parent) : LLMutex(parent)
 {
-        // base class (LLMutex) has already ensured that mAPRPoolp is set up.
-
-        apr_thread_cond_create(&mAPRCondp, mAPRPoolp);
+        apr_thread_cond_create(&mAPRCondp, mPool());
 }
 
 LLCondition::~LLCondition()
@@ -349,7 +364,7 @@ void LLThreadSafeRefCount::initThreadSafeRefCount()
 {
         if (!sMutex)
         {
-                sMutex = new LLMutex(0);
+                sMutex = new LLMutex;
         }
 }
 
diff --git a/linden/indra/llcommon/llthread.h b/linden/indra/llcommon/llthread.h
index ed76a3b..1e982cc 100644
--- a/linden/indra/llcommon/llthread.h
+++ b/linden/indra/llcommon/llthread.h
@@ -38,12 +38,29 @@
 #include "llmemory.h"
 
 #include "apr_thread_cond.h"
+#include "aiaprpool.h"
 
 class LLThread;
 class LLMutex;
 class LLCondition;
 
-class LLThread
+class LL_COMMON_API AIThreadLocalData
+{
+private:
+        static apr_threadkey_t* sThreadLocalDataKey;
+
+public:
+        // Thread-local memory pool.
+        AIAPRRootPool mRootPool;
+        AIVolatileAPRPool mVolatileAPRPool;
+
+        static void init(void);
+        static void destroy(void* thread_local_data);
+        static void create(LLThread* pthread);
+        static AIThreadLocalData& tldata(void);
+};
+
+class LL_COMMON_API LLThread
 {
 public:
         typedef enum e_thread_status
@@ -53,7 +70,7 @@ public:
                 QUITTING= 2     // Someone wants this thread to quit
         } EThreadStatus;
 
-        LLThread(const std::string& name, apr_pool_t *poolp = NULL);
+        LLThread(std::string const& name);
         virtual ~LLThread(); // Warning!  You almost NEVER want to destroy a thread unless it's in the STOPPED state.
         virtual void shutdown(); // stops the thread
         
@@ -82,7 +99,8 @@ public:
         // this kicks off the apr thread
         void start(void);
 
-        apr_pool_t *getAPRPool() { return mAPRPoolp; }
+        // Return thread-local data for the current thread.
+        static AIThreadLocalData& tldata(void) { return AIThreadLocalData::tldata(); }
 
 private:
         bool                            mPaused;
@@ -95,10 +113,11 @@ protected:
         LLCondition*            mRunCondition;
 
         apr_thread_t            *mAPRThreadp;
-        apr_pool_t                      *mAPRPoolp;
-        bool                            mIsLocalPool;
         EThreadStatus           mStatus;
 
+        friend void AIThreadLocalData::create(LLThread* threadp);
+        AIThreadLocalData*      mThreadLocalData;
+
         void setQuitting();
         
         // virtual function overridden by subclass -- this will be called when the thread runs
@@ -125,12 +144,9 @@ protected:
 
 //============================================================================
 
-class LLMutex
+class LL_COMMON_API LLMutexBase
 {
 public:
-        LLMutex(apr_pool_t *apr_poolp); // NULL pool constructs a new pool for the mutex
-        ~LLMutex();
-        
         void lock() { apr_thread_mutex_lock(mAPRMutexp); }
         void unlock() { apr_thread_mutex_unlock(mAPRMutexp); }
         // Returns true if lock was obtained successfully.
@@ -139,16 +155,60 @@ public:
         bool isLocked();        // non-blocking, but does do a lock/unlock so not free
 
 protected:
-        apr_thread_mutex_t *mAPRMutexp;
-        apr_pool_t                      *mAPRPoolp;
-        bool                            mIsLocalPool;
+        // mAPRMutexp is initialized and uninitialized in the derived class.
+        apr_thread_mutex_t*     mAPRMutexp;
+};
+
+class LL_COMMON_API LLMutex : public LLMutexBase
+{
+public:
+        LLMutex(AIAPRPool& parent = LLThread::tldata().mRootPool) : mPool(parent)
+        {
+                apr_thread_mutex_create(&mAPRMutexp, APR_THREAD_MUTEX_UNNESTED, mPool());
+        }
+        ~LLMutex()
+        {
+                llassert(!isLocked()); // better not be locked!
+                apr_thread_mutex_destroy(mAPRMutexp);
+                mAPRMutexp = NULL;
+        }
+
+protected:
+        AIAPRPool mPool;
 };
 
+#if APR_HAS_THREADS
+// No need to use a root pool in this case.
+typedef LLMutex LLMutexRootPool;
+#else   // APR_HAS_THREADS
+class LL_COMMON_API LLMutexRootPool : public LLMutexBase
+{
+public:
+        LLMutexRootPool(void)
+        {
+                apr_thread_mutex_create(&mAPRMutexp, APR_THREAD_MUTEX_UNNESTED, mRootPool());
+        }
+        ~LLMutexRootPool()
+        {
+#if APR_POOL_DEBUG
+                // It is allowed to destruct root pools from a different thread.
+                mRootPool.grab_ownership();
+#endif
+                llassert(!isLocked()); // better not be locked!
+                apr_thread_mutex_destroy(mAPRMutexp);
+                mAPRMutexp = NULL;
+        }
+
+protected:
+        AIAPRRootPool mRootPool;
+};
+#endif  // APR_HAS_THREADS
+
 // Actually a condition/mutex pair (since each condition needs to be associated with a mutex).
-class LLCondition : public LLMutex
+class LL_COMMON_API LLCondition : public LLMutex
 {
 public:
-        LLCondition(apr_pool_t *apr_poolp); // Defaults to global pool, could use the thread pool as well.
+        LLCondition(AIAPRPool& parent = LLThread::tldata().mRootPool);
         ~LLCondition();
         
         void wait();            // blocks
@@ -159,10 +219,10 @@ protected:
         apr_thread_cond_t *mAPRCondp;
 };
 
-class LLMutexLock
+class LL_COMMON_API LLMutexLock
 {
 public:
-        LLMutexLock(LLMutex* mutex)
+        LLMutexLock(LLMutexBase* mutex)
         {
                 mMutex = mutex;
                 mMutex->lock();
@@ -172,7 +232,102 @@ public:
                 mMutex->unlock();
         }
 private:
-        LLMutex* mMutex;
+        LLMutexBase* mMutex;
+};
+
+class AIRWLock
+{
+public:
+        AIRWLock(AIAPRPool& parent = LLThread::tldata().mRootPool) :
+                mWriterWaitingMutex(parent), mNoHoldersCondition(parent), mHoldersCount(0), mWriterIsWaiting(false) { }
+
+private:
+        LLMutex mWriterWaitingMutex;            //!< This mutex is locked while some writer is waiting for access.
+        LLCondition mNoHoldersCondition;        //!< Access control for mHoldersCount. Condition true when there are no more holders.
+        int mHoldersCount;                                      //!< Number of readers or -1 if a writer locked this object.
+        // This is volatile because we read it outside the critical area of mWriterWaitingMutex, at [1].
+        // That means that other threads can change it while we are already in the (inlined) function rdlock.
+        // Without volatile, the following assembly would fail:
+        // register x = mWriterIsWaiting;
+        // /* some thread changes mWriterIsWaiting */
+        // if (x ...
+        // However, because the function is fuzzy to begin with (we don't mind that this race
+        // condition exists) it would work fine without volatile. So, basically it's just here
+        // out of principle ;). -- Aleric
+    bool volatile mWriterIsWaiting;             //!< True when there is a writer waiting for write access.
+
+public:
+        void rdlock(bool high_priority = false)
+        {
+                // Give a writer a higher priority (kinda fuzzy).
+                if (mWriterIsWaiting && !high_priority) // [1] If there is a writer interested,
+                {
+                        mWriterWaitingMutex.lock();                     // [2] then give it precedence and wait here.
+                        // If we get here then the writer got it's access; mHoldersCount == -1.
+                        mWriterWaitingMutex.unlock();
+                }
+                mNoHoldersCondition.lock();                             // [3] Get exclusive access to mHoldersCount.
+                while (mHoldersCount == -1)                             // [4]
+                {
+                        mNoHoldersCondition.wait();                     // [5] Wait till mHoldersCount is (or just was) 0.
+                }
+                ++mHoldersCount;                                                // One more reader.
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
+        void rdunlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                if (--mHoldersCount == 0)                               // Was this the last reader?
+                {
+                        mNoHoldersCondition.signal();           // Tell waiting threads, see [5], [6] and [7].
+                }
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
+        void wrlock(void)
+        {
+                mWriterWaitingMutex.lock();                             // Block new readers, see [2],
+                mWriterIsWaiting = true;                                // from this moment on, see [1].
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                while (mHoldersCount != 0)                              // Other readers or writers have this lock?
+                {
+                        mNoHoldersCondition.wait();                     // [6] Wait till mHoldersCount is (or just was) 0.
+                }
+                mWriterIsWaiting = false;                               // Stop checking the lock for new readers, see [1].
+                mWriterWaitingMutex.unlock();                   // Release blocked readers, they will still hang at [3].
+                mHoldersCount = -1;                                             // We are a writer now (will cause a hang at [5], see [4]).
+                mNoHoldersCondition.unlock();                   // Release lock on mHolders (readers go from [3] to [5]).
+        }
+        void wrunlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                mHoldersCount = 0;                                              // We have no writer anymore.
+                mNoHoldersCondition.signal();                   // Tell waiting threads, see [5], [6] and [7].
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
+        void rd2wrlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount. Blocks new readers at [3].
+                if (--mHoldersCount > 0)                                // Any other reads left?
+                {
+                        mWriterWaitingMutex.lock();                     // Block new readers, see [2],
+                        mWriterIsWaiting = true;                        // from this moment on, see [1].
+                        while (mHoldersCount != 0)                      // Other readers (still) have this lock?
+                        {
+                                mNoHoldersCondition.wait();             // [7] Wait till mHoldersCount is (or just was) 0.
+                        }
+                        mWriterIsWaiting = false;                       // Stop checking the lock for new readers, see [1].
+                        mWriterWaitingMutex.unlock();           // Release blocked readers, they will still hang at [3].
+                }
+                mHoldersCount = -1;                                             // We are a writer now (will cause a hang at [5], see [4]).
+                mNoHoldersCondition.unlock();                   // Release lock on mHolders (readers go from [3] to [5]).
+        }
+        void wr2rdlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                mHoldersCount = 1;                                              // Turn writer into a reader.
+                mNoHoldersCondition.signal();                   // Tell waiting readers, see [5].
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
 };
 
 //============================================================================
@@ -187,12 +342,11 @@ void LLThread::unlockData()
         mRunCondition->unlock();
 }
 
-
 //============================================================================
 
 // see llmemory.h for LLPointer<> definition
 
-class LLThreadSafeRefCount
+class LL_COMMON_API LLThreadSafeRefCount
 {
 public:
         static void initThreadSafeRefCount(); // creates sMutex
@@ -244,7 +398,7 @@ private:
 
 // Simple responder for self destructing callbacks
 // Pure virtual class
-class LLResponder : public LLThreadSafeRefCount
+class LL_COMMON_API LLResponder : public LLThreadSafeRefCount
 {
 protected:
         virtual ~LLResponder();
diff --git a/linden/indra/llcommon/lltimer.cpp b/linden/indra/llcommon/lltimer.cpp
index fa6efaf..b825c1e 100644
--- a/linden/indra/llcommon/lltimer.cpp
+++ b/linden/indra/llcommon/lltimer.cpp
@@ -33,6 +33,7 @@
 #include "linden_common.h"
 
 #include "lltimer.h"
+#include "timing.h"     // totalTime prototype.
 
 #include "u64.h"
 
@@ -51,9 +52,6 @@
 //
 // Locally used constants
 //
-const U32 SEC_PER_DAY = 86400;
-const F64 SEC_TO_MICROSEC = 1000000.f;
-const U64 SEC_TO_MICROSEC_U64 = 1000000;
 const F64 USEC_TO_SEC_F64 = 0.000001;
 
 
@@ -527,6 +525,34 @@ struct tm* utc_to_pacific_time(time_t utc_time, BOOL pacific_daylight_time)
 }
 
 
+struct tm* utc_to_offset_time(time_t utc_time, S32 offset, BOOL DST)
+{
+        if (DST)
+        {
+                //Add one then
+                offset++;
+        }
+
+        // We subtract off the PST/PDT offset _before_ getting
+        // "UTC" time, because this will handle wrapping around
+        // for 5 AM UTC -> 10 PM PDT of the previous day.
+        utc_time -= (-1 * offset) * MIN_PER_HOUR * SEC_PER_MIN;
+ 
+        // Internal buffer to PST/PDT (see above)
+        struct tm* internal_time = gmtime(&utc_time);
+
+        /*
+        // Don't do this, this won't correctly tell you if daylight savings is active in CA or not.
+        if (pacific_daylight_time)
+        {
+                internal_time->tm_isdst = 1;
+        }
+        */
+
+        return internal_time;
+}
+
+
 void microsecondsToTimecodeString(U64 current_time, std::string& tcstring)
 {
         U64 hours;
diff --git a/linden/indra/llcommon/lltimer.h b/linden/indra/llcommon/lltimer.h
index e2cf1c7..8590328 100644
--- a/linden/indra/llcommon/lltimer.h
+++ b/linden/indra/llcommon/lltimer.h
@@ -39,6 +39,7 @@
 #include <limits.h>
 
 #include "stdtypes.h"
+#include "llpreprocessor.h"
 #include "lldate.h"
 
 #include <string>
@@ -54,7 +55,7 @@ const U32	USEC_PER_HOUR	= USEC_PER_MIN * MIN_PER_HOUR;
 const U32       SEC_PER_HOUR    = SEC_PER_MIN * MIN_PER_HOUR;
 const F64       SEC_PER_USEC    = 1.0 / (F64) USEC_PER_SEC;
 
-class LLTimer 
+class LL_COMMON_API LLTimer
 {
 public:
         static LLTimer *sTimer;                         // global timer
@@ -113,17 +114,17 @@ public:
 //
 // Various functions for initializing/accessing clock and timing stuff.  Don't use these without REALLY knowing how they work.
 //
-U64 get_clock_count();
-F64 calc_clock_frequency(U32 msecs);
-void update_clock_frequencies();
+LL_COMMON_API U64 get_clock_count();
+LL_COMMON_API F64 calc_clock_frequency(U32 msecs);
+LL_COMMON_API void update_clock_frequencies();
 
 // Sleep for milliseconds
-void ms_sleep(U32 ms);
-U32 micro_sleep(U64 us, U32 max_yields = 0xFFFFFFFF);
+LL_COMMON_API void ms_sleep(U32 ms);
+LL_COMMON_API U32 micro_sleep(U64 us, U32 max_yields = 0xFFFFFFFF);
 
 // Returns the correct UTC time in seconds, like time(NULL).
 // Useful on the viewer, which may have its local clock set wrong.
-time_t time_corrected();
+LL_COMMON_API time_t time_corrected();
 
 static inline time_t time_min()
 {
@@ -154,24 +155,25 @@ static inline time_t time_max()
 }
 
 // Correction factor used by time_corrected() above.
-extern S32 gUTCOffset;
+LL_COMMON_API extern S32 gUTCOffset;
 
 // Is the current computer (in its current time zone)
 // observing daylight savings time?
-BOOL is_daylight_savings();
+LL_COMMON_API BOOL is_daylight_savings();
 
 // Converts internal "struct tm" time buffer to Pacific Standard/Daylight Time
 // Usage:
 // S32 utc_time;
 // utc_time = time_corrected();
 // struct tm* internal_time = utc_to_pacific_time(utc_time, gDaylight);
-struct tm* utc_to_pacific_time(time_t utc_time, BOOL pacific_daylight_time);
+LL_COMMON_API struct tm* utc_to_pacific_time(time_t utc_time, BOOL pacific_daylight_time);
+LL_COMMON_API struct tm* utc_to_offset_time(time_t utc_time, S32 offset, BOOL DST);
 
-void microsecondsToTimecodeString(U64 current_time, std::string& tcstring);
-void secondsToTimecodeString(F32 current_time, std::string& tcstring);
+LL_COMMON_API void microsecondsToTimecodeString(U64 current_time, std::string& tcstring);
+LL_COMMON_API void secondsToTimecodeString(F32 current_time, std::string& tcstring);
 
 // class for scheduling a function to be called at a given frequency (approximate, inprecise)
-class LLEventTimer 
+class LL_COMMON_API LLEventTimer 
 {
 public:
         LLEventTimer(F32 period);       // period is the amount of time between each call to tick() in seconds
diff --git a/linden/indra/llcommon/lluri.h b/linden/indra/llcommon/lluri.h
index 156d80b..57bbedf 100644
--- a/linden/indra/llcommon/lluri.h
+++ b/linden/indra/llcommon/lluri.h
@@ -47,7 +47,7 @@ class LLApp;
  * See: http://www.ietf.org/rfc/rfc3986.txt
  *
  */
-class LLURI
+class LL_COMMON_API LLURI
 {
 public:
   LLURI();
@@ -189,6 +189,6 @@ private:
 };
 
 // this operator required for tut
-bool operator!=(const LLURI& first, const LLURI& second);
+LL_COMMON_API bool operator!=(const LLURI& first, const LLURI& second);
 
 #endif // LL_LLURI_H
diff --git a/linden/indra/llcommon/lluuid.h b/linden/indra/llcommon/lluuid.h
index 4b32138..c78fb12 100644
--- a/linden/indra/llcommon/lluuid.h
+++ b/linden/indra/llcommon/lluuid.h
@@ -35,6 +35,7 @@
 #include <iostream>
 #include <set>
 #include "stdtypes.h"
+#include "llpreprocessor.h"
 
 const S32 UUID_BYTES = 16;
 const S32 UUID_WORDS = 4;
@@ -47,7 +48,7 @@ struct uuid_time_t {
         U32 low;
                 };
 
-class LLUUID
+class LL_COMMON_API LLUUID
 {
 public:
         //
@@ -106,8 +107,8 @@ public:
         LLUUID combine(const LLUUID& other) const;
         void combine(const LLUUID& other, LLUUID& result) const;  
 
-        friend std::ostream&     operator<<(std::ostream& s, const LLUUID &uuid);
-        friend std::istream&     operator>>(std::istream& s, LLUUID &uuid);
+        friend LL_COMMON_API std::ostream&       operator<<(std::ostream& s, const LLUUID &uuid);
+        friend LL_COMMON_API std::istream&       operator>>(std::istream& s, LLUUID &uuid);
 
         void toString(char *out) const;         // Does not allocate memory, needs 36 characters (including \0)
         void toString(std::string& out) const;
@@ -323,7 +324,7 @@ typedef std::set<LLUUID, lluuid_less> uuid_list_t;
  */
 typedef LLUUID LLAssetID;
 
-class LLTransactionID : public LLUUID
+class LL_COMMON_API LLTransactionID : public LLUUID
 {
 public:
         LLTransactionID() : LLUUID() { }
diff --git a/linden/indra/llcommon/llworkerthread.cpp b/linden/indra/llcommon/llworkerthread.cpp
index 8195e1c..e238a89 100644
--- a/linden/indra/llcommon/llworkerthread.cpp
+++ b/linden/indra/llcommon/llworkerthread.cpp
@@ -43,7 +43,7 @@
 LLWorkerThread::LLWorkerThread(const std::string& name, bool threaded) :
         LLQueuedThread(name, threaded)
 {
-        mDeleteMutex = new LLMutex(NULL);
+        mDeleteMutex = new LLMutex;
 }
 
 LLWorkerThread::~LLWorkerThread()
@@ -183,7 +183,6 @@ LLWorkerClass::LLWorkerClass(LLWorkerThread* workerthread, const std::string& na
         : mWorkerThread(workerthread),
           mWorkerClassName(name),
           mRequestHandle(LLWorkerThread::nullHandle()),
-          mMutex(NULL),
           mWorkFlags(0)
 {
         if (!mWorkerThread)
diff --git a/linden/indra/llcommon/llworkerthread.h b/linden/indra/llcommon/llworkerthread.h
index 708d812..8e0dd8a 100644
--- a/linden/indra/llcommon/llworkerthread.h
+++ b/linden/indra/llcommon/llworkerthread.h
@@ -50,7 +50,7 @@ class LLWorkerClass;
 // Note: ~LLWorkerThread is O(N) N=# of worker threads, assumed to be small
 //   It is assumed that LLWorkerThreads are rarely created/destroyed.
 
-class LLWorkerThread : public LLQueuedThread
+class LL_COMMON_API LLWorkerThread : public LLQueuedThread
 {
         friend class LLWorkerClass;
 public:
@@ -114,7 +114,7 @@ public:
 // Only one background task can be active at a time (per instance).
 //  i.e. don't call addWork() if haveWork() returns true
 
-class LLWorkerClass
+class LL_COMMON_API LLWorkerClass
 {
         friend class LLWorkerThread;
         friend class LLWorkerThread::WorkRequest;
@@ -194,7 +194,7 @@ protected:
         U32 mRequestPriority; // last priority set
 
 private:
-        LLMutex mMutex;
+        LLMutexRootPool mMutex;         // Use LLMutexRootPool since this object is created and destructed by multiple threads.
         LLAtomicU32 mWorkFlags;
 };
 
diff --git a/linden/indra/llcommon/metaclass.h b/linden/indra/llcommon/metaclass.h
index cc10f16..f38bcd2 100644
--- a/linden/indra/llcommon/metaclass.h
+++ b/linden/indra/llcommon/metaclass.h
@@ -43,7 +43,7 @@
 class LLReflective;
 class LLMetaProperty;
 class LLMetaMethod;
-class LLMetaClass
+class LL_COMMON_API LLMetaClass
 {
 public:
 
diff --git a/linden/indra/llcommon/metaproperty.h b/linden/indra/llcommon/metaproperty.h
index e5ac359..6c016c5 100644
--- a/linden/indra/llcommon/metaproperty.h
+++ b/linden/indra/llcommon/metaproperty.h
@@ -41,7 +41,7 @@
 
 class LLMetaClass;
 class LLReflective;
-class LLMetaProperty
+class LL_COMMON_API LLMetaProperty
 {
 public:
         LLMetaProperty(const std::string& name, const LLMetaClass& object_class);
diff --git a/linden/indra/llcommon/reflective.h b/linden/indra/llcommon/reflective.h
index e2c18eb..a135376 100644
--- a/linden/indra/llcommon/reflective.h
+++ b/linden/indra/llcommon/reflective.h
@@ -36,7 +36,7 @@
 #define LL_REFLECTIVE_H
 
 class LLMetaClass;
-class LLReflective
+class LL_COMMON_API LLReflective
 {
 public:
         LLReflective();
diff --git a/linden/indra/llcommon/stdtypes.h b/linden/indra/llcommon/stdtypes.h
index af0b4dd..aed1e46 100644
--- a/linden/indra/llcommon/stdtypes.h
+++ b/linden/indra/llcommon/stdtypes.h
@@ -64,10 +64,17 @@ typedef long long unsigned int		U64;
 #endif
 #endif
 
+#ifdef LL_DARWIN
+        #ifndef BOOL
+                #define BOOL S32
+        #endif
+#else
+        typedef S32                             BOOL;
+#endif
+
 typedef float                           F32;
 typedef double                          F64;
 
-typedef S32                             BOOL;
 typedef U8                              KEY;
 typedef U32                             MASK;
 typedef U32                             TPACKETID;
diff --git a/linden/indra/llcommon/timing.h b/linden/indra/llcommon/timing.h
index 2b9f60a..cfc637e 100644
--- a/linden/indra/llcommon/timing.h
+++ b/linden/indra/llcommon/timing.h
@@ -44,6 +44,6 @@ const U64 SEC_TO_MICROSEC_U64 = 1000000;
 const U32 SEC_PER_DAY = 86400;
 
 // This is just a stub, implementation in lltimer.cpp.  This file will be deprecated in the future.
-U64 totalTime();                                        // Returns current system time in microseconds
+LL_COMMON_API U64 totalTime();                                  // Returns current system time in microseconds
 
 #endif
diff --git a/linden/indra/llcommon/u64.h b/linden/indra/llcommon/u64.h
index 09a6b3e..eb51131 100644
--- a/linden/indra/llcommon/u64.h
+++ b/linden/indra/llcommon/u64.h
@@ -39,14 +39,14 @@
  * @param str The string to parse.
  * @return Returns the first U64 value found in the string or 0 on failure.
  */
-U64 str_to_U64(const std::string& str);
+LL_COMMON_API U64 str_to_U64(const std::string& str);
 
 /**
  * @brief Given a U64 value, return a printable representation.
  * @param value The U64 to turn into a printable character array.
  * @return Returns the result string.
  */
-std::string U64_to_str(U64 value);
+LL_COMMON_API std::string U64_to_str(U64 value);
 
 /**
  * @brief Given a U64 value, return a printable representation.
@@ -65,16 +65,16 @@ std::string U64_to_str(U64 value);
  * @param result_size The size of the buffer allocated. Use U64_BUF.
  * @return Returns the result pointer.
  */
-char* U64_to_str(U64 value, char* result, S32 result_size);
+LL_COMMON_API char* U64_to_str(U64 value, char* result, S32 result_size);
 
 /**
  * @brief Convert a U64 to the closest F64 value.
  */
-F64 U64_to_F64(const U64 value);
+LL_COMMON_API F64 U64_to_F64(const U64 value);
 
 /**
  * @brief Helper function to wrap strtoull() which is not available on windows.
  */
-U64 llstrtou64(const char* str, char** end, S32 base);
+LL_COMMON_API U64 llstrtou64(const char* str, char** end, S32 base);
 
 #endif