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
+// art import path.
-                                                                                                                                                // on dataserver, or also
-                                                                                                                                                        // pre-cached on viewer
+class LLUUID;
-// Grass Images
+LL_COMMON_API extern const LLUUID IMG_SMOKE;
-const LLUUID IMG_SMOKE                  ("b4ba225c-373f-446d-9f7e-6cb7b5cf9b3d");  // VIEWER
-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
+LL_COMMON_API extern const LLUUID IMG_SUN;
-const LLUUID IMG_MOON                   ("d07f6eed-b96a-47cd-b51d-400ad4a1c428"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_MOON;
-const LLUUID IMG_CLOUD_POOF             ("fc4b9f0b-d008-45c6-96a4-01dd947ac621"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_CLOUD_POOF;
-const LLUUID IMG_SHOT                   ("35f217a3-f618-49cf-bbca-c86d486551a9"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_SHOT;
-const LLUUID IMG_SPARK                  ("d2e75ac1-d0fb-4532-820e-a20034ac814d"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_SPARK;
-const LLUUID IMG_FIRE                   ("aca40aa8-44cf-44ca-a0fa-93e1a2986f82"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_FIRE;
-const LLUUID IMG_FACE_SELECT    ("a85ac674-cb75-4af6-9499-df7c5aaf7a28"); // face selector
+LL_COMMON_API extern const LLUUID IMG_FACE_SELECT;
-const LLUUID IMG_DEFAULT_AVATAR ("c228d1cf-4b5d-4ba8-84f4-899a0796aa97"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_DEFAULT_AVATAR;
-const LLUUID IMG_INVISIBLE              ("3a367d1c-bef1-6d43-7595-e88c1e3aadb3"); // dataserver
+LL_COMMON_API extern const LLUUID IMG_INVISIBLE;
-const LLUUID IMG_EXPLOSION                              ("68edcf47-ccd7-45b8-9f90-1649d7f12806"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION;
-const LLUUID IMG_EXPLOSION_2                    ("21ce046c-83fe-430a-b629-c7660ac78d7c"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_2;
-const LLUUID IMG_EXPLOSION_3                    ("fedea30a-1be8-47a6-bc06-337a04a39c4b"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_3;
-const LLUUID IMG_EXPLOSION_4                    ("abf0d56b-82e5-47a2-a8ad-74741bb2c29e"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_EXPLOSION_4;
-const LLUUID IMG_SMOKE_POOF                             ("1e63e323-5fe0-452e-92f8-b98bd0f764e3"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_SMOKE_POOF;
-const LLUUID IMG_BIG_EXPLOSION_1                ("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_BIG_EXPLOSION_1;
-const LLUUID IMG_BIG_EXPLOSION_2                ("9c8eca51-53d5-42a7-bb58-cef070395db8"); // On dataserver
+LL_COMMON_API extern const LLUUID IMG_BIG_EXPLOSION_2;
-const LLUUID IMG_BLOOM1                             ("3c59f7fe-9dc8-47f9-8aaf-a9dd1fbc3bef"); // VIEWER
+LL_COMMON_API extern const LLUUID IMG_BLOOM1;
-const LLUUID TERRAIN_DIRT_DETAIL                ("0bc58228-74a0-7e83-89bc-5c23464bcec5"); // VIEWER
+LL_COMMON_API extern const LLUUID TERRAIN_DIRT_DETAIL;
-const LLUUID TERRAIN_GRASS_DETAIL               ("63338ede-0037-c4fd-855b-015d77112fc8"); // VIEWER
+LL_COMMON_API extern const LLUUID TERRAIN_GRASS_DETAIL;
-const LLUUID TERRAIN_MOUNTAIN_DETAIL    ("303cd381-8560-7579-23f1-f0a880799740"); // VIEWER
+LL_COMMON_API extern const LLUUID TERRAIN_MOUNTAIN_DETAIL;
-const LLUUID TERRAIN_ROCK_DETAIL                ("53a2f406-4895-1d13-d541-d2e3b86bc19c"); // VIEWER
+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.
+LL_COMMON_API extern const LLUUID GOVERNOR_LINDEN_ID;
-const LLUUID ALEXANDRIA_LINDEN_ID("ba2a564a-f0f1-4b82-9c61-b7520bfcd09f");
+LL_COMMON_API extern const LLUUID REALESTATE_LINDEN_ID;
-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");
+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 <iosfwd>
-#include <fstream>
-// 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"
+#include "llscopedvolatileaprpool.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);
-}
 //---------------------------------------------------------------------
 //
@@ -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() ;
+                mVolatileFilePoolp->clearVolatileAPRPool() ;
-                mCurrentFilePoolp = NULL ;
+                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.
+        apr_status_t status;
-        // 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
        {
-                llassert(is_main_thread());
+                apr_pool_t* apr_file_open_pool;
-                pool = gAPRPoolp;
+                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 (status != APR_SUCCESS || !mFile)
-        if (s != 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;
+class AIAPRPool;
-extern apr_thread_mutex_t* gCallStacksLogMutexp;
+class AIVolatileAPRPool;
-/** 
- * @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 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);
+bool LL_COMMON_API ll_apr_warn_status(apr_status_t status);
-void ll_apr_assert_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);
+LL_COMMON_API 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"};
 #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);
+        LL_COMMON_API void setPrintLocation(bool);
-        void setDefaultLevel(LLError::ELevel);
+        LL_COMMON_API void setDefaultLevel(LLError::ELevel);
-        void setFunctionLevel(const std::string& function_name, LLError::ELevel);
+        LL_COMMON_API void setFunctionLevel(const std::string& function_name, LLError::ELevel);
-        void setClassLevel(const std::string& class_name, LLError::ELevel);
+        LL_COMMON_API void setClassLevel(const std::string& class_name, LLError::ELevel);
-        void setFileLevel(const std::string& file_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*);
+        LL_COMMON_API void addRecorder(Recorder*);
-        void removeRecorder(Recorder*);
+        LL_COMMON_API void removeRecorder(Recorder*);
                // each error message is passed to each recorder via recordMessage()
        
-        void logToFile(const std::string& filename);
+        LL_COMMON_API void logToFile(const std::string& filename);
-        void logToFixedBuffer(LLFixedBuffer*);
+        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();
+        LL_COMMON_API Settings* saveAndResetSettings();
-        void restoreSettings(Settings *);
+        LL_COMMON_API void restoreSettings(Settings *);
                
-        std::string abbreviateFile(const std::string& filePath);
+        LL_COMMON_API std::string abbreviateFile(const std::string& filePath);
-        int shouldLogCallCount();
+        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);
+LL_COMMON_API LLSD ll_sd_from_U32(const U32);
-U32 ll_U32_from_sd(const LLSD& sd);
+LL_COMMON_API U32 ll_U32_from_sd(const LLSD& sd);
 // U64
-LLSD ll_sd_from_U64(const U64);
+LL_COMMON_API LLSD ll_sd_from_U64(const U64);
-U64 ll_U64_from_sd(const LLSD& sd);
+LL_COMMON_API U64 ll_U64_from_sd(const LLSD& sd);
 // IP Address
-LLSD ll_sd_from_ipaddr(const U32);
+LL_COMMON_API LLSD ll_sd_from_ipaddr(const U32);
-U32 ll_ipaddr_from_sd(const LLSD& sd);
+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);
+LL_COMMON_API 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_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);
+LL_COMMON_API 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_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_COMMON_API 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, 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);
+LL_COMMON_API 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);
-llutf16string wstring_to_utf16str(const LLWString &utf32str, S32 len);
+LL_COMMON_API 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);
-llutf16string utf8str_to_utf16str ( const std::string& utf8str, S32 len);
+LL_COMMON_API 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 );
-LLWString utf8str_to_wstring(const std::string &utf8str, S32 len);
+LL_COMMON_API 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);
 // 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);
+LL_COMMON_API 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);
-std::string utf16str_to_utf8str(const llutf16string &utf16str, S32 len);
+LL_COMMON_API 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);
 // 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); 
+        while( (found_pos = string.find(target, found_pos)) != std::basic_string<T>::npos ) 
-                found_pos != std::basic_string<T>::npos; 
-                found_pos = string.find(target, found_pos))
        {
                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 ";
+                                        }
                                }
+                                else if (osvi.dwMinorVersion == 2)
-                                if(osvi.wProductType != VER_NT_WORKSTATION)
                                {
-                                        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
+                                else 
-                                        GetSystemInfo(&si); //if it fails get regular system info
+                                        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);
+                        std::string::size_type 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 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);
+LL_COMMON_API std::ostream& operator<<(std::ostream& s, const LLOSInfo& info);
-std::ostream& operator<<(std::ostream& s, const LLCPUInfo& info);
+LL_COMMON_API 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 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.
+        // Create a thread local data.
-        LLVolatileAPRPool::createLocalAPRFilePool();
+        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
+        mRunCondition = new LLCondition;
-        if (poolp)
-        {
-                mIsLocalPool = false;
-                mAPRPoolp = poolp;
-        }
-        else
-        {
-                mIsLocalPool = true;
-                apr_pool_create(&mAPRPoolp, NULL); // Create a subpool for this thread
-        }
-        mRunCondition = new LLCondition(mAPRPoolp);
 }
@@ -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) :
+// The thread private handle to access the AIThreadLocalData instance.
-        mAPRMutexp(NULL)
+apr_threadkey_t* AIThreadLocalData::sThreadLocalDataKey;
+//static
+void AIThreadLocalData::init(void)
 {
-        //if (poolp)
+        // Only do this once.
-        //{
+        if (sThreadLocalDataKey)
-        //      mIsLocalPool = false;
-        //      mAPRPoolp = poolp;
-        //}
-        //else
        {
-                mIsLocalPool = true;
+                return;
-                apr_pool_create(&mAPRPoolp, NULL); // Create a subpool for this thread
        }
-        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
+        delete reinterpret_cast<AIThreadLocalData*>(thread_local_data);
-        llassert(!isLocked()); // better not be locked!
+}
-#endif
-        apr_thread_mutex_destroy(mAPRMutexp);
+//static
-        mAPRMutexp = NULL;
+void AIThreadLocalData::create(LLThread* threadp)
-        if (mIsLocalPool)
+{
+        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) :
+LLCondition::LLCondition(AIAPRPool& parent) : LLMutex(parent)
-        LLMutex(poolp)
 {
-        // base class (LLMutex) has already ensured that mAPRPoolp is set up.
+        apr_thread_cond_create(&mAPRCondp, mPool());
-        apr_thread_cond_create(&mAPRCondp, mAPRPoolp);
 }
 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;
+        // mAPRMutexp is initialized and uninitialized in the derived class.
-        apr_pool_t                      *mAPRPoolp;
+        apr_thread_mutex_t*     mAPRMutexp;
-        bool                            mIsLocalPool;
+};
+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();
+LL_COMMON_API U64 get_clock_count();
-F64 calc_clock_frequency(U32 msecs);
+LL_COMMON_API F64 calc_clock_frequency(U32 msecs);
-void update_clock_frequencies();
+LL_COMMON_API void update_clock_frequencies();
 // Sleep for milliseconds
-void ms_sleep(U32 ms);
+LL_COMMON_API void ms_sleep(U32 ms);
-U32 micro_sleep(U64 us, U32 max_yields = 0xFFFFFFFF);
+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);
+LL_COMMON_API void microsecondsToTimecodeString(U64 current_time, std::string& tcstring);
-void secondsToTimecodeString(F32 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 LL_COMMON_API std::ostream&       operator<<(std::ostream& s, const LLUUID &uuid);
-        friend std::istream&     operator>>(std::istream& s, 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