Second Life viewer sources 1.18.1.2

29 files changed, 560 insertions, 578 deletions

diff --git a/linden/indra/llcommon/indra_constants.h b/linden/indra/llcommon/indra_constants.h
index 9024b12..21635b5 100644
--- a/linden/indra/llcommon/indra_constants.h
+++ b/linden/indra/llcommon/indra_constants.h
@@ -130,10 +130,12 @@ const	char	CLOUD_LAYER_CODE				= '8';
 
 // keys
 // Bit masks for various keyboard modifier keys.
-const MASK MASK_NONE =          0x0000;
-const MASK MASK_CONTROL =       0x0001;
-const MASK MASK_ALT =           0x0002;
-const MASK MASK_SHIFT =         0x0004;
+const MASK MASK_NONE =                  0x0000;
+const MASK MASK_CONTROL =               0x0001;         // Mapped to cmd on Macs
+const MASK MASK_ALT =                   0x0002;
+const MASK MASK_SHIFT =                 0x0004;
+const MASK MASK_NORMALKEYS =    0x0007;     // A real mask - only get the bits for normal modifier keys
+const MASK MASK_MAC_CONTROL =   0x0008;         // Un-mapped Ctrl key on Macs, not used on Windows
 
 // Special keys go into >128
 const KEY KEY_SPECIAL = 0x80;   // special keys start here
diff --git a/linden/indra/llcommon/llapr.h b/linden/indra/llcommon/llapr.h
index e7b12d5..6edfc18 100644
--- a/linden/indra/llcommon/llapr.h
+++ b/linden/indra/llcommon/llapr.h
@@ -31,7 +31,7 @@
 #ifndef LL_LLAPR_H
 #define LL_LLAPR_H
 
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
 #include <sys/param.h>  // Need PATH_MAX in APR headers...
 #endif
 
diff --git a/linden/indra/llcommon/llcommon.vcproj b/linden/indra/llcommon/llcommon.vcproj
index 399dae3..5557f94 100644
--- a/linden/indra/llcommon/llcommon.vcproj
+++ b/linden/indra/llcommon/llcommon.vcproj
@@ -445,9 +445,6 @@
                                 RelativePath=".\llnametable.h">
                         </File>
                         <File
-                                RelativePath=".\llpagemem.h">
-                        </File>
-                        <File
                                 RelativePath=".\llpreprocessor.h">
                         </File>
                         <File
diff --git a/linden/indra/llcommon/lldate.cpp b/linden/indra/llcommon/lldate.cpp
index ccc314d..47e5370 100644
--- a/linden/indra/llcommon/lldate.cpp
+++ b/linden/indra/llcommon/lldate.cpp
@@ -72,6 +72,54 @@ std::string LLDate::asString() const
         return stream.str();
 }
 
+//@ brief Converts time in seconds since EPOCH
+//        to RFC 1123 compliant date format
+//        E.g. 1184797044.037586 == Wednesday, 18 Jul 2007 22:17:24 GMT
+//        in RFC 1123. HTTP dates are always in GMT and RFC 1123
+//        is one of the standards used and the prefered format
+std::string LLDate::asRFC1123() const
+{
+    std::ostringstream stream;
+    toHTTPDateStream(stream);
+    return stream.str();
+}
+
+void LLDate::toHTTPDateStream(std::ostream& s) const
+{
+    // http://apr.apache.org/docs/apr/0.9/group__apr__time.html
+    apr_time_t time = (apr_time_t)(mSecondsSinceEpoch * LL_APR_USEC_PER_SEC);
+
+    apr_time_exp_t exp_time ; //Apache time module
+
+    if (apr_time_exp_gmt(&exp_time, time) != APR_SUCCESS)
+    {
+        // Return Epoch UTC date
+        s << "Thursday, 01 Jan 1970 00:00:00 GMT" ;
+        return;
+    }
+
+    s << std::dec << std::setfill('0');
+#if( LL_WINDOWS || __GNUC__ > 2)
+    s << std::right ;
+#else
+    s.setf(ios::right);
+#endif    
+    std::string day = weekdays[exp_time.tm_wday];
+    std::string month = months[exp_time.tm_mon];
+
+    s << std::setw(day.length()) << (day)
+      << ", " << std::setw(2) << (exp_time.tm_mday)
+      << ' ' << std::setw(month.length()) << (month)
+      << ' ' << std::setw(4) << (exp_time.tm_year + 1900)
+          << ' ' << std::setw(2) << (exp_time.tm_hour)
+          << ':' << std::setw(2) << (exp_time.tm_min)
+          << ':' << std::setw(2) << (exp_time.tm_sec)
+      << " GMT";
+
+    // RFC 1123 date does not use microseconds
+    llinfos << "Date in RFC 1123 format is " << s << llendl;
+}
+
 void LLDate::toStream(std::ostream& s) const
 {
         apr_time_t time = (apr_time_t)(mSecondsSinceEpoch * LL_APR_USEC_PER_SEC);
diff --git a/linden/indra/llcommon/lldate.h b/linden/indra/llcommon/lldate.h
index f8bd625..5d90a54 100644
--- a/linden/indra/llcommon/lldate.h
+++ b/linden/indra/llcommon/lldate.h
@@ -77,7 +77,9 @@ public:
          * @return A string representation of the date.
          */
         std::string asString() const;
+        std::string asRFC1123() const;
         void toStream(std::ostream&) const;
+        void toHTTPDateStream(std::ostream&) const;
         /** 
          * @brief Set the date from an ISO-8601 string.
          *
@@ -119,4 +121,8 @@ std::ostream& operator<<(std::ostream& s, const LLDate& date);
 std::istream& operator>>(std::istream& s, LLDate& date);
 
 
+const static std::string weekdays[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
+
+const static std::string months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
 #endif // LL_LLDATE_H
diff --git a/linden/indra/llcommon/llfasttimer.cpp b/linden/indra/llcommon/llfasttimer.cpp
index 2b1d58f..6c0f9ac 100644
--- a/linden/indra/llcommon/llfasttimer.cpp
+++ b/linden/indra/llcommon/llfasttimer.cpp
@@ -33,7 +33,7 @@
 #if LL_WINDOWS
 #include <time.h>
 
-#elif LL_LINUX
+#elif LL_LINUX || LL_SOLARIS
 #include <time.h>
 #include <sys/time.h>
 #include <sched.h>
@@ -91,7 +91,7 @@ U64 get_cpu_clock_count()
 #endif // LL_WINDOWS
 
 
-#if LL_LINUX
+#if (LL_LINUX || LL_SOLARIS) && (defined(__i386__) || defined(__amd64__))
 U64 get_cpu_clock_count()
 {
         U64 x;
@@ -100,7 +100,7 @@ U64 get_cpu_clock_count()
 }
 #endif
 
-#if LL_DARWIN
+#if LL_DARWIN || (LL_SOLARIS && defined(__sparc__))
 //
 // Mac implementation of CPU clock
 //
@@ -115,7 +115,7 @@ U64 get_cpu_clock_count()
 //////////////////////////////////////////////////////////////////////////////
 
 //static
-#if LL_LINUX || LL_DARWIN
+#if LL_LINUX || LL_DARWIN || LL_SOLARIS
 // Both Linux and Mac use gettimeofday for accurate time
 U64 LLFastTimer::countsPerSecond()
 {
diff --git a/linden/indra/llcommon/llfixedbuffer.cpp b/linden/indra/llcommon/llfixedbuffer.cpp
index 397fcfd..6defd92 100644
--- a/linden/indra/llcommon/llfixedbuffer.cpp
+++ b/linden/indra/llcommon/llfixedbuffer.cpp
@@ -82,7 +82,7 @@ void LLFixedBuffer::setMaxLines(S32 max_lines)
 
 void LLFixedBuffer::removeExtraLines()
 {
-        while ((S32)mLines.size() > llmax(0, (S32)(mMaxLines - 1)))
+        while ((S32)mLines.size() > llmax((S32)0, (S32)(mMaxLines - 1)))
         {
                 mLines.pop_front();
                 mAddTimes.pop_front();
diff --git a/linden/indra/llcommon/llhash.h b/linden/indra/llcommon/llhash.h
index c3c4ec9..793783f 100644
--- a/linden/indra/llcommon/llhash.h
+++ b/linden/indra/llcommon/llhash.h
@@ -42,6 +42,8 @@
 #  else
 #    include <hashtable.h>
 #  endif
+#elif LL_SOLARIS
+#include <ext/hashtable.h>
 #else
 #error Please define your platform.
 #endif
@@ -53,7 +55,7 @@ template<class T> inline size_t llhash(T value)
 #elif ( (defined _STLPORT_VERSION) || ((LL_LINUX) && (__GNUC__ <= 2)) )
         std::hash<T> H;
         return H(value);
-#elif LL_DARWIN || LL_LINUX
+#elif LL_DARWIN || LL_LINUX || LL_SOLARIS
         __gnu_cxx::hash<T> H;
         return H(value);
 #else
diff --git a/linden/indra/llcommon/llmemory.cpp b/linden/indra/llcommon/llmemory.cpp
index 284c8e7..65f3409 100644
--- a/linden/indra/llcommon/llmemory.cpp
+++ b/linden/indra/llcommon/llmemory.cpp
@@ -69,6 +69,7 @@ S32 LLMemType::sCurType = LLMemType::MTYPE_INIT;
 S32 LLMemType::sType[LLMemType::MTYPE_MAX_DEPTH];
 S32 LLMemType::sMemCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
 S32 LLMemType::sMaxMemCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
+S32 LLMemType::sNewCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
 S32 LLMemType::sOverheadMem = 0;
 
 const char* LLMemType::sTypeDesc[LLMemType::MTYPE_NUM_TYPES] =
@@ -133,7 +134,7 @@ void LLMemType::printMem()
         {
                 if (sMemCount[i])
                 {
-                        llinfos << llformat("MEM: % 20s %03d MB (%03d MB)",sTypeDesc[i],sMemCount[i]>>20,sMaxMemCount[i]>>20) << llendl;
+                        llinfos << llformat("MEM: % 20s %03d MB (%03d MB) in %06d News",sTypeDesc[i],sMemCount[i]>>20,sMaxMemCount[i]>>20, sNewCount[i]) << llendl;
                 }
                 misc_mem -= sMemCount[i];
         }
@@ -180,6 +181,7 @@ void* ll_allocate (size_t size)
         {
                 LLMemType::sMaxMemCount[LLMemType::sCurType] = LLMemType::sMemCount[LLMemType::sCurType];
         }
+        LLMemType::sNewCount[LLMemType::sCurType]++;
 #endif
         return (void*)p;
 }
@@ -205,6 +207,7 @@ void ll_release (void *pin)
 #if MEM_TRACK_TYPE
         LLMemType::sMemCount[type] -= size;
         LLMemType::sOverheadMem -= 4;
+        LLMemType::sNewCount[type]--;
 #endif
         LLMemType::sTotalMem -= size;
         free(p);
diff --git a/linden/indra/llcommon/llmemtype.h b/linden/indra/llcommon/llmemtype.h
index 501b5f5..9bab72e 100644
--- a/linden/indra/llcommon/llmemtype.h
+++ b/linden/indra/llcommon/llmemtype.h
@@ -41,6 +41,7 @@ extern void ll_release (void *p);
 #define MEM_TRACK_TYPE (1 && MEM_TRACK_MEM)
 
 #if MEM_TRACK_TYPE
+#define MEM_DUMP_DATA 1
 #define MEM_TYPE_NEW(T) \
 static void* operator new(size_t s) { LLMemType mt(T); return ll_allocate(s); } \
 static void  operator delete(void* p) { ll_release(p); }
@@ -143,6 +144,7 @@ public:
         static S32 sType[MTYPE_MAX_DEPTH];
         static S32 sMemCount[MTYPE_NUM_TYPES];
         static S32 sMaxMemCount[MTYPE_NUM_TYPES];
+        static S32 sNewCount[MTYPE_NUM_TYPES];
         static S32 sOverheadMem;
         static const char* sTypeDesc[MTYPE_NUM_TYPES];
 #endif
diff --git a/linden/indra/llcommon/llpagemem.h b/linden/indra/llcommon/llpagemem.h
deleted file mode 100644
index f3d6061..0000000
--- a/linden/indra/llcommon/llpagemem.h
+++ /dev/null
@@ -1,393 +0,0 @@
-/** 
- * @file llpagemem.h
- *
- * Copyright (c) 2002-2007, 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.
- */
-#ifndef LL_LLPAGEMEM_H
-#define LL_LLPAGEMEM_H
-
-#if !LL_DARWIN
-#include "malloc.h"
-#endif
-
-#include "llrand.h"
-
-
-#ifndef __GNUC__
-template <class Object, U32 mPageSize=1024> 
-class LLPageMemory 
-{
-private:
-
-        union XObject
-        {
-                XObject *mNextFreeObject;
-                U8               mObject[sizeof(Object)];
-        };
-
-        template <U32 mPageSize> struct Page
-        {
-                XObject *mFirstFreeObject;
-                U32      mObjectCount;
-                U8       mObjects[mPageSize-8];
-
-                void init(U32 mObjPerPage)
-                {
-                        XObject *o = (XObject*)&mObjects;
-                        mObjectCount     = 0;
-                        mFirstFreeObject = o;
-        
-                        for (U32 i = 0; i < mObjPerPage-1; i++) 
-                        {
-                                o->mNextFreeObject = o+1;
-                                o++;
-                        }
-                        o->mNextFreeObject = NULL;
-                };
-
-                Object* alloc()
-                {
-                        if (mFirstFreeObject)
-                        {
-                                XObject     *ret = mFirstFreeObject;
-                                mFirstFreeObject = mFirstFreeObject->mNextFreeObject;
-                                ret->mNextFreeObject = NULL;
-                                mObjectCount++;
-                                return (Object*)&ret->mObject;
-                        };
-                        return NULL;
-                }
-        };
-
-        U32     mObjPerPage;
-        U32     mMaxPages;
-        U32     mObjectCount;
-
-        Page<mPageSize>*   mPageMemory;
-        Page<mPageSize>*   mFirstPage;
-
-public:
-        U32 precise, anywhere, fail;
-
-        void    init()
-        {
-                Page<mPageSize> *p = mFirstPage;
-                for (U32 i = 0; i < mMaxPages; i++) 
-                {
-                        p[i].init(mObjPerPage);
-                }
-
-                precise  = 0;
-                anywhere = 0;
-                fail     = 0;
-        };
-
-public:
-
-        Page<mPageSize>*  pageof(Object *object)
-        {
-                return (Page<mPageSize>*) ((((U32)object - 8) / mPageSize) * mPageSize );
-        }
-
-        LLPageMemory(U32 maxObjects)
-        {
-                mObjPerPage = (mPageSize-8) / sizeof(Object);
-                mMaxPages   = (maxObjects / mObjPerPage) + 1;
-                mObjectCount= 0;
-
-                //printf("%d objects per page, %d pages total, %d/%d objects\n",
-                //      mObjPerPage, mMaxPages, mMaxPages * mObjPerPage,maxObjects);
-
-                mPageMemory = (Page<mPageSize>*)calloc(mPageSize,mMaxPages+1);
-                mFirstPage = mPageMemory;
-                U32 fix = ((U32)mPageMemory % mPageSize);
-                if (fix) mFirstPage = (Page<mPageSize>*)((U32)mPageMemory+mPageSize-fix);
-        
-                //printf("fix = %d\n",fix);
-
-                init();
-        };
-
-        LLPageMemory(void *pageMem, U32 bytes)
-        {
-        }
-
-        ~LLPageMemory()
-        {
-                if (mPageMemory)
-                {
-                        free(mPageMemory);
-                }
-        }
-        
-        Object*     alloc(Object *after=NULL)
-        {
-                Page<mPageSize> * p = mFirstPage;
-                Object          * o = NULL;
-                U32               i = mMaxPages;
-
-                if (after)
-                {
-                        o = pageof(after)->alloc();
-                        if (o) 
-                        {
-                                precise++;
-                                return o;
-                        }
-                        return NULL;
-                }
-
-                F32 frac   = 1.0f / (F32)mMaxPages;             
-                F32 thresh = 0.0f;
-                for (i = 0; i < mMaxPages; i++)
-                {
-                        if (thresh > ((F32)p[i].mObjectCount / (F32)mObjPerPage))
-                        {
-                                o = p[i].alloc();
-                                if (o) 
-                                {
-                                        //printf("allocating page %x obj %x\n",p, o);
-                                        anywhere++;
-                                        return o;
-                                }
-                        }
-                        thresh += frac;
-                } 
-
-                fail++;
-                return NULL;
-        };
-
-        void        free(Object *o)
-        {
-                if (!o) return;
-
-                Page<mPageSize> *page = pageof(o);
-                XObject *obj = (XObject*)o;
-
-                //printf("freeing %x\n",obj);
-
-                obj->mNextFreeObject    = page->mFirstFreeObject;
-                page->mFirstFreeObject  = obj;
-                page->mObjectCount--;
-
-                //printf("freeing page %x %d\n",page, page->mObjectCount);
-        };
-
-        U32  indexof(Object *object)
-        {
-                if (!object) return -1;
-
-                return ((((U32)object-8) % mPageSize) / sizeof(Object)) + 
-                           ((pageof(object) - mFirstPage) * mObjPerPage);
-        }
-
-
-        void dump()
-        {
-
-                for (U32 i=0;i < mMaxPages;i++)
-                {
-                        //printf("page %d   %d/%d objects\n",i,mFirstPage[i].mObjectCount,mObjPerPage);
-                }
-                //printf("precise = %d anywhere %d ratio = %f\n",precise,anywhere,(F32)precise/(F32)(anywhere+precise));
-                //printf("fail = %d\n",fail);
-
-        }
-
-        static void test()
-        {
-                struct Foo
-                {
-                        U32 ord;
-                        U32 foo[8];
-                };
-
-                const U32 count = 100;
-                U32 i,c;
-                U32 mix = 50;
-
-                LLPageMemory<Foo> mem(count);
-                LLRand rand(LLUUID::getRandomSeed());
-
-                Foo *obj[count];
-
-                for (i=0;i<count;i++) obj[i] = 0;
-
-                U32 x= 0;
-                for (U32 run=0; run < 10000 ;run++)
-                {
-                        U32 m =rand.llrand(count);
-                        for (c=0;c < m;c++)
-                        {
-                                U32 j = rand.llrand(count);
-                                if (obj[j]) 
-                                {
-                                        mem.free(obj[j]);
-                                        obj[j] = 0;
-                                }
-                        }
-
-                        m =rand.llrand(count);
-                        for (c=0;c<m;c++)
-                        {
-                                U32 i = rand.llrand(count);
-                                while (obj[i] && i < count) i++;
-
-                                if (!obj[i]) 
-                                {
-                                        if (i > 0) obj[i] = mem.alloc(obj[i-1]);
-                                        else       obj[i] = mem.alloc();
-                                        if (obj[i]) obj[i]->ord = x++;
-                                }
-                        }
-                }
-
-                for (i = 0; i< count; i++)
-                {
-                        //printf("obj[%2d] = %08x %02d %4d\n",i,obj[i],mem.indexof(obj[i]),(obj[i] ? obj[i]->ord : -1));
-                }
-
-                mem.dump();
-        }
-};
-
-
-template <class Object> 
-class LLObjectPool
-{
-private:
-
-        class XObject
-        {
-        public:
-                Object   mObject;
-                U32      mNextFreeObject;
-
-                XObject() { mObject = NULL; mNextFreeObject = 0; }
-        };
-
-        U32      mNumObjects;
-        U32              mMaxObjects;
-        XObject* mObjects;
-        U32      mFirstFreeObject;
-
-        U32 indexof(XObject *xobj) { return (xobj - mObjects); }
-
-public:
-        LLObjectPool(U32 maxObjects)
-        {
-                mMaxObjects = maxObjects;
-                mFirstFreeObject = 0;
-
-                mObjects = new XObject[mMaxObjects];
-
-                //printf("objectpool allocated %d bytes\n",sizeof(XObject) * mMaxObjects);
-
-                for (U32 i=0;i<mMaxObjects;i++) mObjects[i].mNextFreeObject = i+1;
-        };
-
-        ~LLObjectPool()
-        {
-                delete [] mObjects;
-                mObjects = NULL;
-        }
-
-        Object*     alloc(Object *after=NULL)
-        {
-                XObject *obj     = &mObjects[mFirstFreeObject];
-                mFirstFreeObject = obj->mNextFreeObject;
-                if (mFirstFreeObject >= mMaxObjects)
-                {
-                        llerrs << "Attempted to allocate too many objects out of pool\n" << llendl;
-                        llassert(0);
-                }
-                return &obj->mObject;
-        };
-
-        void        free(Object *obj)
-        {
-                if (!obj) return;
-                XObject *xobj         = (XObject*)obj;
-                xobj->mNextFreeObject = mFirstFreeObject;
-                mFirstFreeObject      = indexof(xobj);
-        };
-
-        static void test()
-        {
-                struct Foo
-                {
-                        U32 ord;
-                        U32 foo[8];
-                };
-
-                const U32 count = 100;
-                U32 i,c;
-                U32 mix = 50;
-
-                LLPageMemory<Foo> mem(count);
-                LLRand rand(LLUUID::getRandomSeed());
-
-                Foo *obj[count];
-
-                for (i=0;i<count;i++) obj[i] = 0;
-
-                U32 x= 0;
-                for (U32 run=0; run < 10000 ;run++)
-                {
-                        U32 m =rand.llrand(count);
-                        for (c=0;c < m;c++)
-                        {
-                                U32 j = rand.llrand(count);
-                                if (obj[j]) 
-                                {
-                                        mem.free(obj[j]);
-                                        obj[j] = 0;
-                                }
-                        }
-
-                        m =rand.llrand(count);
-                        for (c=0;c<m;c++)
-                        {
-                                U32 i = rand.llrand(count);
-                                while (obj[i] && i < count) i++;
-
-                                if (!obj[i]) 
-                                {
-                                        if (i > 0) obj[i] = mem.alloc(obj[i-1]);
-                                        else       obj[i] = mem.alloc();
-                                        if (obj[i]) obj[i]->ord = x++;
-                                }
-                        }
-                }
-
-                for (i = 0; i< count; i++)
-                {
-                        //printf("obj[%2d] = %08x %02d %4d\n",i,obj[i],mem.indexof(obj[i]),(obj[i] ? obj[i]->ord : -1));
-                }
-        }
-};
-#endif // !defined __GNUC__
-
-#endif
diff --git a/linden/indra/llcommon/llpreprocessor.h b/linden/indra/llcommon/llpreprocessor.h
index 495b9e8..f19d5a0 100644
--- a/linden/indra/llcommon/llpreprocessor.h
+++ b/linden/indra/llcommon/llpreprocessor.h
@@ -62,6 +62,11 @@
         #ifndef LL_LIBXUL_ENABLED
                 #define LL_LIBXUL_ENABLED               1
         #endif // def LL_LIBXUL_ENABLED
+#elif LL_SOLARIS
+        #define LL_QUICKTIME_ENABLED    0
+        #ifndef LL_LIBXUL_ENABLED
+                #define LL_LIBXUL_ENABLED               0
+        #endif // def LL_LIBXUL_ENABLED
 #endif
 
 #if LL_LIBXUL_ENABLED && !defined(MOZILLA_INTERNAL_API)
@@ -71,12 +76,22 @@
         #define MOZILLA_INTERNAL_API 1
 #endif
 
-// Deal with minor differences on Unixy OSes.
-#if LL_DARWIN || LL_LINUX
+// Figure out differences between compilers
+#if defined(__GNUC__)
         #define GCC_VERSION (__GNUC__ * 10000 \
                                                 + __GNUC_MINOR__ * 100 \
                                                 + __GNUC_PATCHLEVEL__)
+        #ifndef LL_GNUC
+                #define LL_GNUC 1
+        #endif
+#elif defined(__MSVC_VER__) || defined(_MSC_VER)
+        #ifndef LL_MSVC
+                #define LL_MSVC 1
+        #endif
+#endif
 
+// Deal with minor differences on Unixy OSes.
+#if LL_DARWIN || LL_LINUX
         // Different name, same functionality.
         #define stricmp strcasecmp
         #define strnicmp strncasecmp
@@ -89,9 +104,9 @@
 #endif
 
 // Deal with the differeneces on Windows
-#if LL_WINDOWS
+#if LL_MSVC
 #define snprintf safe_snprintf          /* Flawfinder: ignore */
-#endif  // LL_WINDOWS
+#endif  // LL_MSVC
 
 // Static linking with apr on windows needs to be declared.
 #ifdef LL_WINDOWS
@@ -110,7 +125,7 @@
 
 
 // Deal with VC6 problems
-#if defined(LL_WINDOWS)
+#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.
@@ -121,6 +136,6 @@
 #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
-#endif  //      LL_WINDOWS
+#endif  //      LL_MSVC
 
 #endif  //      not LL_LINDEN_PREPROCESSOR_H
diff --git a/linden/indra/llcommon/llprocessor.cpp b/linden/indra/llcommon/llprocessor.cpp
index bd21351..4d00ab5 100644
--- a/linden/indra/llcommon/llprocessor.cpp
+++ b/linden/indra/llcommon/llprocessor.cpp
@@ -58,7 +58,7 @@
 #       include <windows.h>
 #endif
 
-#if !LL_DARWIN
+#if !LL_DARWIN && !LL_SOLARIS
 
 #ifdef PROCESSOR_FREQUENCY_MEASURE_AVAILABLE
 // We need the QueryPerformanceCounter and Sleep functions
@@ -255,24 +255,24 @@ bool CProcessor::AnalyzeIntelProcessor()
                 /* 0x03 */ "0.13 micron Intel Celeron",
                 /* 0x04 */ "0.13 micron Intel Pentium III",
                 /* 0x05 */ "",
-                /* 0x06 */ "0.13 micron Intel Pentium III mobile",
-                /* 0x07 */ "0.13 micron Intel Celeron mobile",
+                /* 0x06 */ "0.13 micron Intel Pentium III Mobile",
+                /* 0x07 */ "0.13 micron Intel Celeron Mobile",
                 /* 0x08 */ "0.18 micron Intel Pentium 4",
                 /* 0x09 */ "0.13 micron Intel Pentium 4",
-                /* 0x0A */ "0.13 micron Intel Pentium 4",
+                /* 0x0A */ "0.13 micron Intel Celeron",
                 /* 0x0B */ "0.13 micron Intel Pentium 4 Xeon",
-                /* 0x0C */ "",
+                /* 0x0C */ "Intel Xeon MP",
                 /* 0x0D */ "",
                 /* 0x0E */ "0.18 micron Intel Pentium 4 Xeon",
-                /* 0x0F */ "",
+                /* 0x0F */ "Mobile Intel Celeron",
                 /* 0x10 */ "",
-                /* 0x11 */ "",
+                /* 0x11 */ "Mobile Genuine Intel",
                 /* 0x12 */ "Intel Celeron M",
-                /* 0x13 */ "mobile Intel Celeron",
+                /* 0x13 */ "Mobile Intel Celeron",
                 /* 0x14 */ "Intel Celeron",
-                /* 0x15 */ "mobile Intel",
+                /* 0x15 */ "Mobile Genuine Intel",
                 /* 0x16 */ "Intel Pentium M",
-                /* 0x17 */ "mobile Intel Celeron",
+                /* 0x17 */ "Mobile Intel Celeron",
         };
 
         // Only override the brand if we have it in the lookup table.  We should
@@ -300,7 +300,7 @@ bool CProcessor::AnalyzeIntelProcessor()
                         strcpy(CPUInfo.strFamily, "Intel Pentium");     /* Flawfinder: ignore */        
                         break;
                 case 6:                 // Family = 6:  Pentium Pro (80686) processor family
-                        strcpy(CPUInfo.strFamily, "Intel Pentium Pro"); /* Flawfinder: ignore */        
+                        strcpy(CPUInfo.strFamily, "Intel Pentium Pro/2/3, Core");       /* Flawfinder: ignore */        
                         break;
                 case 15:                // Family = 15:  Extended family specific
                         // Masking the extended family
@@ -447,17 +447,21 @@ bool CProcessor::AnalyzeIntelProcessor()
                                                 case 1:                 // Model = 8, Brand id = 1:  Celeron (on-die L2 cache) processor model
                                                         strncat(strCPUName, "Intel Celeron (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
-                                                case 2:                 // Model = 8, Brand id = 2:  Pentium III (on-die L2 cache) processor model (my current cpu :-))
+                        case 2:                 // Model = 8, Brand id = 2:  Pentium III (on-die L2 cache) processor model (my current cpu :-))
                                                         strncat(strCPUName, "Intel Pentium III (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                                 case 3:                 // Model = 8, Brand id = 3:  Pentium III Xeon (on-die L2 cache) processor model
-                                                strncat(strCPUName, "Intel Pentium III Xeon (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                            strncat(strCPUName, "Intel Pentium III Xeon (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                                 default:                // ...
                                                         strncat(strCPUName, "Intel Pentium III core (unknown model, 0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                         }
                                         break;
+                                case 9:         // Model = 9:  Intel Pentium M processor, Intel Celeron M processor, model 9
+                                        strcpy(CPUInfo.strModel, "Intel Pentium M Series Processor");    /*Flawfinder: ignore*/
+                                        strncat(strCPUName, "Intel Pentium M Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                                        break;
                                 case 0xA:               // Model = 0xA:  Pentium III/Xeon/Celeron (1 or 2 MB on-die L2 cache) processor model
                                         strcpy(CPUInfo.strModel, "Intel Pentium III/Celeron/Pentium III Xeon - internal L2 cache, 0.18 micron");         /*Flawfinder: ignore*/
                                         // Exact detection:
@@ -466,11 +470,11 @@ bool CProcessor::AnalyzeIntelProcessor()
                                                 case 1:                 // Model = 0xA, Brand id = 1:  Celeron (1 or 2 MB on-die L2 cache (does it exist??)) processor model
                                                         strncat(strCPUName, "Intel Celeron (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
-                                                case 2:                 // Model = 0xA, Brand id = 2:  Pentium III (1 or 2 MB on-die L2 cache (never seen...)) processor model
+                        case 2:                 // Model = 0xA, Brand id = 2:  Pentium III (1 or 2 MB on-die L2 cache (never seen...)) processor model
                                                         strncat(strCPUName, "Intel Pentium III (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                                 case 3:                 // Model = 0xA, Brand id = 3:  Pentium III Xeon (1 or 2 MB on-die L2 cache) processor model
-                                                strncat(strCPUName, "Intel Pentium III Xeon (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                            strncat(strCPUName, "Intel Pentium III Xeon (0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                                 default:                // Getting bored of this............
                                                         strncat(strCPUName, "Intel Pentium III core (unknown model, 0.18 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
@@ -485,20 +489,32 @@ bool CProcessor::AnalyzeIntelProcessor()
                                                 case 3:                 // Model = 0xB, Brand id = 3:  Celeron (Tualatin core) processor model
                                                         strncat(strCPUName, "Intel Celeron (Tualatin core, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
-                                                case 4:                 // Model = 0xB, Brand id = 4:  Pentium III (Tualatin core) processor model
+                        case 4:                 // Model = 0xB, Brand id = 4:  Pentium III (Tualatin core) processor model
                                                         strncat(strCPUName, "Intel Pentium III (Tualatin core, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                                 case 7:                 // Model = 0xB, Brand id = 7:  Celeron mobile (Tualatin core) processor model
-                                                strncat(strCPUName, "Intel Celeron mobile (Tualatin core, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                            strncat(strCPUName, "Intel Celeron mobile (Tualatin core, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                                 default:                // *bored*
                                                         strncat(strCPUName, "Intel Pentium III Tualatin core (unknown model, 0.13 micron process) with internal L2 cache", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                                         break;
                                         }
                                         break;
+                                case 0xD:               // Model = 0xD:  Intel Pentium M processor, Intel Celeron M processor, model D
+                                        strcpy(CPUInfo.strModel, "Intel Pentium M Series Processor");    /*Flawfinder: ignore*/
+                                        strncat(strCPUName, "Intel Pentium M Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                                        break;
+                                case 0xE:               // Model = 0xE:  Intel Core Duo processor, Intel Core Solo processor, model E
+                                        strcpy(CPUInfo.strModel, "Intel Core Series Processor");         /*Flawfinder: ignore*/
+                                        strncat(strCPUName, "Intel Core Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                                        break;  
+                                case 0xF:               // Model = 0xF:  Intel Core 2 Duo processor, model F
+                                        strcpy(CPUInfo.strModel, "Intel Core 2 Series Processor");       /*Flawfinder: ignore*/
+                                        strncat(strCPUName, "Intel Core 2 Series Processor", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                                        break;  
                                 default:                // *more bored*
-                                        strcpy(CPUInfo.strModel, "Unknown Intel Pentium Pro"); /*Flawfinder: ignore*/
-                                        strncat(strCPUName, "Intel Pentium Pro (Unknown model)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
+                                        strcpy(CPUInfo.strModel, "Unknown Intel Pentium Pro/2/3, Core"); /*Flawfinder: ignore*/
+                                        strncat(strCPUName, "Intel Pentium Pro/2/3, Core (Unknown model)", sizeof(strCPUName)-(strlen(strCPUName)-1)); /*Flawfinder: ignore*/
                                         break;
                         }
                         break;
@@ -1538,6 +1554,7 @@ void CProcessor::GetStandardProcessorExtensions()
         CPUInfo._Ext.FXSR_FastStreamingSIMD_ExtensionsSaveRestore       = CheckBit(edxreg, 24);
         CPUInfo._Ext.SSE_StreamingSIMD_Extensions                                       = CheckBit(edxreg, 25);
         CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions                                     = CheckBit(edxreg, 26);
+        CPUInfo._Ext.Altivec_Extensions = false;
         CPUInfo._Ext.SS_SelfSnoop                                                                       = CheckBit(edxreg, 27);
         CPUInfo._Ext.HT_HyperThreading                                                          = CheckBit(edxreg, 28);
         CPUInfo._Ext.HT_HyterThreadingSiblings = (ebxreg >> 16) & 0xFF;
@@ -1643,6 +1660,125 @@ const ProcessorInfo *CProcessor::GetCPUInfo()
         return (&CPUInfo);
 }
 
+#elif LL_SOLARIS
+#include <kstat.h>
+
+// ======================
+// Class constructor:
+/////////////////////////
+CProcessor::CProcessor()
+{
+        uqwFrequency = 0;
+        strCPUName[0] = 0;
+        memset(&CPUInfo, 0, sizeof(CPUInfo));
+}
+
+// unsigned __int64 CProcessor::GetCPUFrequency(unsigned int uiMeasureMSecs)
+// =========================================================================
+// Function to query the current CPU frequency
+////////////////////////////////////////////////////////////////////////////
+F64 CProcessor::GetCPUFrequency(unsigned int /*uiMeasureMSecs*/)
+{
+        if(uqwFrequency == 0){
+                GetCPUInfo();
+        }
+
+        return uqwFrequency;
+}
+
+// const ProcessorInfo *CProcessor::GetCPUInfo()
+// =============================================
+// Calls all the other detection function to create an detailed
+// processor information
+///////////////////////////////////////////////////////////////
+const ProcessorInfo *CProcessor::GetCPUInfo()
+{
+                                        // In Solaris the CPU info is in the kstats
+                                        // try "psrinfo" or "kstat cpu_info" to see all
+                                        // that's available
+        int ncpus=0, i; 
+        kstat_ctl_t     *kc;
+        kstat_t         *ks;
+        kstat_named_t   *ksinfo, *ksi;
+        kstat_t         *CPU_stats_list;
+
+        kc = kstat_open();
+
+        if((int)kc == -1){
+                llwarns << "kstat_open(0 failed!" << llendl;
+                return (&CPUInfo);
+        }
+
+        for (ks = kc->kc_chain; ks != NULL; ks = ks->ks_next) {
+                if (strncmp(ks->ks_module, "cpu_info", 8) == 0 &&
+                        strncmp(ks->ks_name, "cpu_info", 8) == 0)
+                        ncpus++;
+        }
+        
+        if(ncpus < 1){
+                llwarns << "No cpus found in kstats!" << llendl;
+                return (&CPUInfo);
+        }
+
+        for (ks = kc->kc_chain; ks; ks = ks->ks_next) {
+                if (strncmp(ks->ks_module, "cpu_info", 8) == 0 
+                &&  strncmp(ks->ks_name, "cpu_info", 8) == 0 
+                &&  kstat_read(kc, ks, NULL) != -1){     
+                        CPU_stats_list = ks;    // only looking at the first CPU
+                        
+                        break;
+                }
+        }
+
+        if(ncpus > 1)
+                snprintf(strCPUName, sizeof(strCPUName), "%d x ", ncpus); 
+
+        kstat_read(kc, CPU_stats_list, NULL);
+        ksinfo = (kstat_named_t *)CPU_stats_list->ks_data;
+        for(i=0; i < (int)(CPU_stats_list->ks_ndata); ++i){ // Walk the kstats for this cpu gathering what we need
+                ksi = ksinfo++;
+                if(!strcmp(ksi->name, "brand")){
+                        strncat(strCPUName, (char *)KSTAT_NAMED_STR_PTR(ksi),
+                                sizeof(strCPUName)-strlen(strCPUName)-1);
+                        strncat(CPUInfo.strFamily, (char *)KSTAT_NAMED_STR_PTR(ksi),
+                                sizeof(CPUInfo.strFamily)-strlen(CPUInfo.strFamily)-1);
+                        strncpy(CPUInfo.strBrandID, strCPUName,sizeof(CPUInfo.strBrandID)-1);
+                        CPUInfo.strBrandID[sizeof(CPUInfo.strBrandID)-1]='\0';
+                        // DEBUG llinfos << "CPU brand: " << strCPUName << llendl;
+                        continue;
+                }
+
+                if(!strcmp(ksi->name, "clock_MHz")){
+#if defined(__sparc)
+                        llinfos << "Raw kstat clock rate is: " << ksi->value.l << llendl;
+                        uqwFrequency = (F64)(ksi->value.l * 1000000);
+#else
+                        uqwFrequency = (F64)(ksi->value.i64 * 1000000);
+#endif
+                        //DEBUG llinfos << "CPU frequency: " << uqwFrequency << llendl;
+                        continue;
+                }
+
+#if defined(__i386)
+                if(!strcmp(ksi->name, "vendor_id")){
+                        strncpy(CPUInfo.strVendor, (char *)KSTAT_NAMED_STR_PTR(ksi), sizeof(CPUInfo.strVendor)-1);
+                        // DEBUG llinfos << "CPU vendor: " << CPUInfo.strVendor << llendl;
+                        continue;
+                }
+#endif
+        }
+
+        kstat_close(kc);
+
+#if defined(__sparc)            // SPARC does not define a vendor string in kstat
+        strncpy(CPUInfo.strVendor, "Sun Microsystems, Inc.", sizeof(CPUInfo.strVendor)-1);
+#endif
+
+        // DEBUG llinfo << "The system has " << ncpus << " CPUs with a clock rate of " <<  uqwFrequency << "MHz." << llendl;
+        
+        return (&CPUInfo);
+}
+
 #else
 // LL_DARWIN
 
@@ -1891,11 +2027,12 @@ const ProcessorInfo *CProcessor::GetCPUInfo()
                 break;
         }
 
-        // It's kinda like MMX or SSE...
         CPUInfo._Ext.EMMX_MultimediaExtensions = 
         CPUInfo._Ext.MMX_MultimediaExtensions = 
         CPUInfo._Ext.SSE_StreamingSIMD_Extensions =
-        CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions = hasFeature("hw.optional.altivec");
+        CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions = false;
+
+        CPUInfo._Ext.Altivec_Extensions = hasFeature("hw.optional.altivec");
 
 #endif
 
@@ -1912,6 +2049,7 @@ const ProcessorInfo *CProcessor::GetCPUInfo()
         CPUInfo._Ext.MMX_MultimediaExtensions = hasFeature("hw.optional.mmx");
         CPUInfo._Ext.SSE_StreamingSIMD_Extensions = hasFeature("hw.optional.sse");
         CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions = hasFeature("hw.optional.sse2");
+        CPUInfo._Ext.Altivec_Extensions = false;
         CPUInfo._Ext.AA64_AMD64BitArchitecture = hasFeature("hw.optional.x86_64");
 
 #endif
@@ -2015,6 +2153,7 @@ bool CProcessor::CPUInfoToText(char *strBuffer, unsigned int uiMaxLen)
         {
           COPYADD("Processor Serial: Disabled\n");
         }
+#if !LL_SOLARIS         //  NOTE: Why bother printing all this when it's irrelavent
 
         COPYADD("\n\n// CPU Configuration\n////////////////////\n");
         FORMATADD("L1 instruction cache:           %s\n", CPUInfo._L1.Instruction.strCache);
@@ -2065,12 +2204,13 @@ bool CProcessor::CPUInfoToText(char *strBuffer, unsigned int uiMaxLen)
         BOOLADD("SS     Self Snoop:                                 ", CPUInfo._Ext.SS_SelfSnoop);
         BOOLADD("SSE    Streaming SIMD Extensions:                  ", CPUInfo._Ext.SSE_StreamingSIMD_Extensions);
         BOOLADD("SSE2   Streaming SIMD 2 Extensions:                ", CPUInfo._Ext.SSE2_StreamingSIMD2_Extensions);
+        BOOLADD("ALTVEC Altivec Extensions:                         ", CPUInfo._Ext.Altivec_Extensions);
         BOOLADD("TM     Thermal Monitor:                            ", CPUInfo._Ext.TM_ThermalMonitor);
         BOOLADD("TSC    Time Stamp Counter:                         ", CPUInfo._Ext.TSC_TimeStampCounter);
         BOOLADD("VME    Virtual 8086 Mode Enhancements:             ", CPUInfo._Ext.VME_Virtual8086ModeEnhancements);
         BOOLADD("3DNow! Instructions:                               ", CPUInfo._Ext._3DNOW_InstructionExtensions);
         BOOLADD("Enhanced 3DNow! Instructions:                      ", CPUInfo._Ext._E3DNOW_InstructionExtensions);
-
+#endif
         // Yippie!!!
         return true;
 }
diff --git a/linden/indra/llcommon/llprocessor.h b/linden/indra/llcommon/llprocessor.h
index fd9a5da..79dd1e8 100644
--- a/linden/indra/llcommon/llprocessor.h
+++ b/linden/indra/llcommon/llprocessor.h
@@ -40,6 +40,20 @@
 #define PROCESSOR_FREQUENCY_MEASURE_AVAILABLE
 #endif
 
+#if LL_MSVC && _M_X64
+#      define LL_X86_64 1
+#      define LL_X86 1
+#elif LL_MSVC && _M_IX86
+#      define LL_X86 1
+#elif LL_GNUC && ( defined(__amd64__) || defined(__x86_64__) )
+#      define LL_X86_64 1
+#      define LL_X86 1
+#elif LL_GNUC && ( defined(__i386__) )
+#      define LL_X86 1
+#elif LL_GNUC && ( defined(__powerpc__) || defined(__ppc__) )
+#      define LL_PPC 1
+#endif
+
 
 typedef struct ProcessorExtensions
 {
@@ -71,6 +85,7 @@ typedef struct ProcessorExtensions
         bool FXSR_FastStreamingSIMD_ExtensionsSaveRestore;
         bool SSE_StreamingSIMD_Extensions;
         bool SSE2_StreamingSIMD2_Extensions;
+        bool Altivec_Extensions;
         bool SS_SelfSnoop;
         bool HT_HyperThreading;
         unsigned int HT_HyterThreadingSiblings;
diff --git a/linden/indra/llcommon/llsdserialize_xml.cpp b/linden/indra/llcommon/llsdserialize_xml.cpp
index 85d3883..6d2f583 100644
--- a/linden/indra/llcommon/llsdserialize_xml.cpp
+++ b/linden/indra/llcommon/llsdserialize_xml.cpp
@@ -36,7 +36,11 @@
 
 extern "C"
 {
-#include "expat/expat.h"
+#ifdef LL_STANDALONE
+# include <expat.h>
+#else
+# include "expat/expat.h"
+#endif
 }
 
 /**
diff --git a/linden/indra/llcommon/llsdutil.cpp b/linden/indra/llcommon/llsdutil.cpp
index e8b3ac5..0e23054 100644
--- a/linden/indra/llcommon/llsdutil.cpp
+++ b/linden/indra/llcommon/llsdutil.cpp
@@ -35,7 +35,7 @@
 #if LL_WINDOWS
 #       define WIN32_LEAN_AND_MEAN
 #       include <winsock2.h>    // for htonl
-#elif LL_LINUX
+#elif LL_LINUX || LL_SOLARIS
 #       include <netinet/in.h>
 #elif LL_DARWIN
 #       include <arpa/inet.h>
diff --git a/linden/indra/llcommon/llskiplist.h b/linden/indra/llcommon/llskiplist.h
index be3385d..40d0c8a 100644
--- a/linden/indra/llcommon/llskiplist.h
+++ b/linden/indra/llcommon/llskiplist.h
@@ -28,11 +28,10 @@
 #ifndef LL_LLSKIPLIST_H
 #define LL_LLSKIPLIST_H
 
-#include "llerror.h"
-//#include "vmath.h"
+#include "llrand.h"
 
 // NOTA BENE: Insert first needs to be < NOT <=
-
+// Binary depth must be >= 2
 template <class DATA_TYPE, S32 BINARY_DEPTH = 10>
 class LLSkipList
 {
@@ -144,14 +143,11 @@ private:
 // Implementation
 //
 
+
+// Binary depth must be >= 2
 template <class DATA_TYPE, S32 BINARY_DEPTH>
 inline void LLSkipList<DATA_TYPE, BINARY_DEPTH>::init()
 {
-        if (BINARY_DEPTH < 2)
-        {
-                llerrs << "Trying to create skip list with too little depth, "
-                        "must be 2 or greater" << llendl;
-        }
         S32 i;
         for (i = 0; i < BINARY_DEPTH; i++)
         {
diff --git a/linden/indra/llcommon/llstring.h b/linden/indra/llcommon/llstring.h
index adfdfb8..5f48580 100644
--- a/linden/indra/llcommon/llstring.h
+++ b/linden/indra/llcommon/llstring.h
@@ -40,7 +40,7 @@
 #include <errno.h>
 #include <math.h>
 #include <stdarg.h> /* for vsnprintf */
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
 #include <wctype.h>
 #include <wchar.h>
 #endif
@@ -54,7 +54,7 @@ class LLUUID;
 class LLColor4;
 class LLColor4U;
 
-#if (LL_DARWIN || (LL_LINUX && __GNUC__ > 2))
+#if (LL_DARWIN || LL_SOLARIS || (LL_LINUX && __GNUC__ > 2))
 // Template specialization of char_traits for U16s. Only necessary on Mac for now (exists on Windows, unused/broken on Linux/gcc2.95)
 namespace std
 {
@@ -205,7 +205,7 @@ public:
         LLStringBase(const T* s, size_type n);
         LLStringBase(const T* s, size_type pos, size_type n );
         
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
         void clear() { assign(null); }
         
         LLStringBase<T>& assign(const T* s);
@@ -700,7 +700,7 @@ LLStringBase<T>::LLStringBase(const T* s, size_type pos, size_type n ) : std::ba
         }
 }
 
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
 template<class T> 
 LLStringBase<T>& LLStringBase<T>::assign(const T* s)
 {
@@ -1095,7 +1095,7 @@ BOOL LLStringBase<T>::read(std::basic_string<T>& string, const char* filename)
 template<class T> 
 BOOL LLStringBase<T>::write(std::basic_string<T>& string, const char* filename)
 {
-#ifdef LL_LINUX
+#if LL_LINUX  || LL_SOLARIS
     printf("STUBBED: LLStringBase<T>::write at %s:%d\n", __FILE__, __LINE__);
 #else
         llofstream ofs(filename, llofstream::binary);
diff --git a/linden/indra/llcommon/llsys.cpp b/linden/indra/llcommon/llsys.cpp
index 48f2474..25749e1 100644
--- a/linden/indra/llcommon/llsys.cpp
+++ b/linden/indra/llcommon/llsys.cpp
@@ -31,9 +31,13 @@
 #include "llsys.h"
 
 #include <iostream>
-#include <zlib/zlib.h>
+#ifdef LL_STANDALONE
+# include <zlib.h>
+#else
+# include "zlib/zlib.h"
+#endif
 
-#include "processor.h"
+#include "llprocessor.h"
 
 #if LL_WINDOWS
 #       define WIN32_LEAN_AND_MEAN
@@ -44,6 +48,8 @@
 #       include <sys/utsname.h>
 #elif LL_LINUX
 #       include <sys/utsname.h>
+#       include <unistd.h>
+#       include <sys/sysinfo.h>
 const char MEMINFO_FILE[] = "/proc/meminfo";
 const char CPUINFO_FILE[] = "/proc/cpuinfo";
 #endif
@@ -182,7 +188,7 @@ LLOSInfo::LLOSInfo() :
         }
 #else
         struct utsname un;
-        if(0==uname(&un))
+        if(uname(&un) != -1)
         {
                 mOSString.append(un.sysname);
                 mOSString.append(" ");
@@ -252,13 +258,12 @@ U32 LLOSInfo::getProcessVirtualSizeKB()
 #if LL_WINDOWS
 #endif
 #if LL_LINUX
-        FILE* status_filep = LLFile::fopen("/proc/self/status", "r");   /* Flawfinder: ignore */
+        FILE* status_filep = LLFile::fopen("/proc/self/status", "rb");
         S32 numRead = 0;                
         char buff[STATUS_SIZE];         /* Flawfinder: ignore */
-        bzero(buff, STATUS_SIZE);
 
-        rewind(status_filep);
-        fread(buff, 1, STATUS_SIZE-2, status_filep);
+        size_t nbytes = fread(buff, 1, STATUS_SIZE-1, status_filep);
+        buff[nbytes] = '\0';
 
         // All these guys return numbers in KB
         char *memp = strstr(buff, "VmSize:");
@@ -267,6 +272,24 @@ U32 LLOSInfo::getProcessVirtualSizeKB()
                 numRead += sscanf(memp, "%*s %u", &virtual_size);
         }
         fclose(status_filep);
+#elif LL_SOLARIS
+        char proc_ps[LL_MAX_PATH];
+        sprintf(proc_ps, "/proc/%d/psinfo", (int)getpid());
+        int proc_fd = -1;
+        if((proc_fd = open(proc_ps, O_RDONLY)) == -1){
+                llwarns << "unable to open " << proc_ps << llendl;
+                return 0;
+        }
+        psinfo_t proc_psinfo;
+        if(read(proc_fd, &proc_psinfo, sizeof(psinfo_t)) != sizeof(psinfo_t)){
+                llwarns << "Unable to read " << proc_ps << llendl;
+                close(proc_fd);
+                return 0;
+        }
+
+        close(proc_fd);
+
+        virtual_size = proc_psinfo.pr_size;
 #endif
         return virtual_size;
 }
@@ -278,15 +301,14 @@ U32 LLOSInfo::getProcessResidentSizeKB()
 #if LL_WINDOWS
 #endif
 #if LL_LINUX
-        FILE* status_filep = LLFile::fopen("/proc/self/status", "r");   /* Flawfinder: ignore */
+        FILE* status_filep = LLFile::fopen("/proc/self/status", "rb");
         if (status_filep != NULL)
         {
                 S32 numRead = 0;
                 char buff[STATUS_SIZE];         /* Flawfinder: ignore */
-                bzero(buff, STATUS_SIZE);
 
-                rewind(status_filep);
-                fread(buff, 1, STATUS_SIZE-2, status_filep);
+                size_t nbytes = fread(buff, 1, STATUS_SIZE-1, status_filep);
+                buff[nbytes] = '\0';
 
                 // All these guys return numbers in KB
                 char *memp = strstr(buff, "VmRSS:");
@@ -296,47 +318,126 @@ U32 LLOSInfo::getProcessResidentSizeKB()
                 }
                 fclose(status_filep);
         }
+#elif LL_SOLARIS
+        char proc_ps[LL_MAX_PATH];
+        sprintf(proc_ps, "/proc/%d/psinfo", (int)getpid());
+        int proc_fd = -1;
+        if((proc_fd = open(proc_ps, O_RDONLY)) == -1){
+                llwarns << "unable to open " << proc_ps << llendl;
+                return 0;
+        }
+        psinfo_t proc_psinfo;
+        if(read(proc_fd, &proc_psinfo, sizeof(psinfo_t)) != sizeof(psinfo_t)){
+                llwarns << "Unable to read " << proc_ps << llendl;
+                close(proc_fd);
+                return 0;
+        }
+
+        close(proc_fd);
+
+        resident_size = proc_psinfo.pr_rssize;
 #endif
         return resident_size;
 }
 
 LLCPUInfo::LLCPUInfo()
 {
+        std::ostringstream out;
         CProcessor proc;
         const ProcessorInfo* info = proc.GetCPUInfo();
-        mHasSSE = (info->_Ext.SSE_StreamingSIMD_Extensions != 0);
-        mHasSSE2 = (info->_Ext.SSE2_StreamingSIMD2_Extensions != 0);
+        // proc.WriteInfoTextFile("procInfo.txt");
+        mHasSSE = info->_Ext.SSE_StreamingSIMD_Extensions;
+        mHasSSE2 = info->_Ext.SSE2_StreamingSIMD2_Extensions;
+        mHasAltivec = info->_Ext.Altivec_Extensions;
         mCPUMhz = (S32)(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
+        {
+                out << " (" << mCPUMhz << " MHz)";
+        }
+        mCPUString = out.str();
+        
+#elif LL_LINUX
+        std::map< LLString, LLString > cpuinfo;
+        FILE* cpuinfo_fp = LLFile::fopen(CPUINFO_FILE, "rb");
+        if(cpuinfo_fp)
+        {
+                char line[MAX_STRING];
+                memset(line, 0, MAX_STRING);
+                while(fgets(line, MAX_STRING, cpuinfo_fp))
+                {
+                        // /proc/cpuinfo on Linux looks like:
+                        // name\t*: value\n
+                        char* tabspot = strchr( line, '\t' );
+                        if (tabspot == NULL)
+                                continue;
+                        char* colspot = strchr( tabspot, ':' );
+                        if (colspot == NULL)
+                                continue;
+                        char* spacespot = strchr( colspot, ' ' );
+                        if (spacespot == NULL)
+                                continue;
+                        char* nlspot = strchr( line, '\n' );
+                        if (nlspot == NULL)
+                                nlspot = line + strlen( line ); // Fallback to terminating NUL
+                        std::string linename( line, tabspot );
+                        LLString llinename(linename);
+                        LLString::toLower(llinename);
+                        std::string lineval( spacespot + 1, nlspot );
+                        cpuinfo[ llinename ] = lineval;
+                }
+                fclose(cpuinfo_fp);
+        }
+# if LL_X86
+        LLString flags = " " + cpuinfo["flags"] + " ";
+        LLString::toLower(flags);
+        mHasSSE = ( flags.find( " sse " ) != std::string::npos );
+        mHasSSE2 = ( flags.find( " sse2 " ) != std::string::npos );
+        
+        F64 mhz;
+        if (LLString::convertToF64(cpuinfo["cpu mhz"], mhz)
+            && 200.0 < mhz && mhz < 10000.0)
+        {
+                mCPUMhz = (S32)llrint(mhz);
+        }
+        if (!cpuinfo["model name"].empty())
+                mCPUString = cpuinfo["model name"];
+# endif // LL_X86
+#endif // LL_LINUX
 }
 
+bool LLCPUInfo::hasAltivec() const
+{
+        return mHasAltivec;
+}
 
-std::string LLCPUInfo::getCPUString() const
+bool LLCPUInfo::hasSSE() const
 {
-#if LL_WINDOWS || LL_DARWIN
-        std::ostringstream out;
+        return mHasSSE;
+}
 
-        CProcessor proc;
-        (void) proc.GetCPUInfo();
-        out << proc.strCPUName << " ";
-        
-        F32 freq = (F32)(proc.GetCPUFrequency(50) / 1000000.0);
+bool LLCPUInfo::hasSSE2() const
+{
+        return mHasSSE2;
+}
 
-        // cpu speed is often way wrong, do a sanity check
-        if (200.f < freq && freq < 10000.f)
-        {
-                out << "(" << (S32)(freq) << " MHz)";
-        }
+S32 LLCPUInfo::getMhz() const
+{
+        return mCPUMhz;
+}
 
-        return out.str();
-#else
-        return "Can't get terse CPU information";
-#endif
+std::string LLCPUInfo::getCPUString() const
+{
+        return mCPUString;
 }
 
 void LLCPUInfo::stream(std::ostream& s) const
 {
-#if LL_WINDOWS || LL_DARWIN
+#if LL_WINDOWS || LL_DARWIN || LL_SOLARIS
         // gather machine information.
         char proc_buf[CPUINFO_BUFFER_SIZE];             /* Flawfinder: ignore */
         CProcessor proc;
@@ -346,38 +447,41 @@ void LLCPUInfo::stream(std::ostream& s) const
         }
         else
         {
-                s << "Unable to collect processor info";
+                s << "Unable to collect processor information" << std::endl;
         }
 #else
         // *NOTE: This works on linux. What will it do on other systems?
-        FILE* cpuinfo = LLFile::fopen(CPUINFO_FILE, "r");               /* Flawfinder: ignore */
+        FILE* cpuinfo = LLFile::fopen(CPUINFO_FILE, "rb");
         if(cpuinfo)
         {
-                char line[MAX_STRING];          /* Flawfinder: ignore */
+                char line[MAX_STRING];
                 memset(line, 0, MAX_STRING);
                 while(fgets(line, MAX_STRING, cpuinfo))
                 {
-                        line[strlen(line)-1] = ' ';              /*Flawfinder: ignore*/
+                        line[strlen(line)-1] = ' ';
                         s << line;
                 }
                 fclose(cpuinfo);
+                s << std::endl;
         }
         else
         {
-                s << "Unable to collect memory information";
+                s << "Unable to collect processor information" << std::endl;
         }
 #endif
+        // These are interesting as they reflect our internal view of the
+        // CPU's attributes regardless of platform
+        s << "->mHasSSE:     " << (U32)mHasSSE << std::endl;
+        s << "->mHasSSE2:    " << (U32)mHasSSE2 << std::endl;
+        s << "->mHasAltivec: " << (U32)mHasAltivec << std::endl;
+        s << "->mCPUMhz:     " << mCPUMhz << std::endl;
+        s << "->mCPUString:  " << mCPUString << std::endl;
 }
 
 LLMemoryInfo::LLMemoryInfo()
 {
 }
 
-#if LL_LINUX
-#include <unistd.h>
-#include <sys/sysinfo.h>
-#endif
-
 U32 LLMemoryInfo::getPhysicalMemory() const
 {
 #if LL_WINDOWS
@@ -399,7 +503,8 @@ U32 LLMemoryInfo::getPhysicalMemory() const
 #elif LL_LINUX
 
         return getpagesize() * get_phys_pages();
-
+#elif LL_SOLARIS
+        return getpagesize() * sysconf(_SC_PHYS_PAGES);
 #else
         return 0;
 
@@ -433,10 +538,15 @@ void LLMemoryInfo::stream(std::ostream& s) const
         {
                 s << "Unable to collect memory information";
         }
-        
+#elif LL_SOLARIS
+        U64 phys = 0;
+
+        phys = (U64)(sysconf(_SC_PHYS_PAGES)) * (U64)(sysconf(_SC_PAGESIZE)/1024);
+
+        s << "Total Physical Kb:  " << phys << std::endl;
 #else
         // *NOTE: This works on linux. What will it do on other systems?
-        FILE* meminfo = LLFile::fopen(MEMINFO_FILE,"r");                /* Flawfinder: ignore */
+        FILE* meminfo = LLFile::fopen(MEMINFO_FILE,"rb");
         if(meminfo)
         {
                 char line[MAX_STRING];          /* Flawfinder: ignore */
@@ -491,7 +601,11 @@ BOOL gunzip_file(const char *srcfile, const char *dstfile)
         do
         {
                 bytes = gzread(src, buffer, UNCOMPRESS_BUFFER_SIZE);
-                fwrite(buffer, sizeof(U8), bytes, dst);
+                size_t nwrit = fwrite(buffer, sizeof(U8), bytes, dst);
+                if (nwrit < (size_t) bytes)
+                {
+                        llerrs << "Short write on " << tmpfile << llendl;
+                }
         } while(gzeof(src) == 0);
         fclose(dst); 
         dst = NULL;     
diff --git a/linden/indra/llcommon/llsys.h b/linden/indra/llcommon/llsys.h
index 2047d9a..416bd54 100644
--- a/linden/indra/llcommon/llsys.h
+++ b/linden/indra/llcommon/llsys.h
@@ -72,18 +72,21 @@ public:
 
         std::string getCPUString() const;
 
-        BOOL  hasSSE() const    { return mHasSSE; }
-        BOOL  hasSSE2() const   { return mHasSSE2; }
-        S32       getMhz() const        { return mCPUMhz; }
+        bool hasAltivec() const;
+        bool hasSSE() const;
+        bool hasSSE2() const;
+        S32      getMhz() const;
 
         // Family is "AMD Duron" or "Intel Pentium Pro"
         const std::string& getFamily() const { return mFamily; }
 
 private:
-        BOOL mHasSSE;
-        BOOL mHasSSE2;
+        bool mHasSSE;
+        bool mHasSSE2;
+        bool mHasAltivec;
         S32 mCPUMhz;
         std::string mFamily;
+        std::string mCPUString;
 };
 
 class LLMemoryInfo
diff --git a/linden/indra/llcommon/llthread.cpp b/linden/indra/llcommon/llthread.cpp
index 0f833ab..d261c8b 100644
--- a/linden/indra/llcommon/llthread.cpp
+++ b/linden/indra/llcommon/llthread.cpp
@@ -32,7 +32,7 @@
 
 #include "lltimer.h"
 
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
 #include <sched.h>
 #endif
 
@@ -226,7 +226,7 @@ void LLThread::setQuitting()
 // static
 void LLThread::yield()
 {
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
         sched_yield(); // annoyingly, apr_thread_yield  is a noop on linux...
 #else
         apr_thread_yield();
diff --git a/linden/indra/llcommon/lltimer.cpp b/linden/indra/llcommon/lltimer.cpp
index 21fbf0e..6077063 100644
--- a/linden/indra/llcommon/lltimer.cpp
+++ b/linden/indra/llcommon/lltimer.cpp
@@ -37,7 +37,7 @@
 #       include <winsock2.h>
 #       include <windows.h>
 #       include <time.h>
-#elif LL_LINUX
+#elif LL_LINUX || LL_SOLARIS
 #       include <time.h>
 #       include <sys/time.h>
 #       include <sched.h>
@@ -90,7 +90,7 @@ void llyield()
 {
         SleepEx(0, TRUE); // Relinquishes time slice to any thread of equal priority, can be woken up by extended IO functions
 }
-#elif LL_LINUX
+#elif LL_LINUX || LL_SOLARIS
 void ms_sleep(long ms)
 {
         struct timespec t;
@@ -150,7 +150,7 @@ F64 calc_clock_frequency(U32 uiMeasureMSecs)
 #endif // LL_WINDOWS
 
 
-#if LL_LINUX || LL_DARWIN
+#if LL_LINUX || LL_DARWIN || LL_SOLARIS
 // Both Linux and Mac use gettimeofday for accurate time
 F64 calc_clock_frequency(unsigned int uiMeasureMSecs)
 {
@@ -169,7 +169,7 @@ U64 get_clock_count()
 
 void update_clock_frequencies()
 {
-        gClockFrequency = calc_clock_frequency(50);
+        gClockFrequency = calc_clock_frequency(50U);
         gClockFrequencyInv = 1.0/gClockFrequency;
         gClocksToMicroseconds = gClockFrequencyInv * SEC_TO_MICROSEC;
 }
@@ -512,7 +512,7 @@ void secondsToTimecodeString(F32 current_time, char *tcstring)
 std::list<LLEventTimer*> LLEventTimer::sActiveList;
 
 LLEventTimer::LLEventTimer(F32 period)
-: mTimer()
+: mEventTimer()
 {
         mPeriod = period;
         sActiveList.push_back(this);
@@ -528,9 +528,9 @@ void LLEventTimer::updateClass()
         for (std::list<LLEventTimer*>::iterator iter = sActiveList.begin(); iter != sActiveList.end(); ) 
         {
                 LLEventTimer* timer = *iter++;
-                F32 et = timer->mTimer.getElapsedTimeF32();
+                F32 et = timer->mEventTimer.getElapsedTimeF32();
                 if (et > timer->mPeriod) {
-                        timer->mTimer.reset();
+                        timer->mEventTimer.reset();
                         timer->tick();
                 }
         }
diff --git a/linden/indra/llcommon/lltimer.h b/linden/indra/llcommon/lltimer.h
index 94dcbb9..37917d0 100644
--- a/linden/indra/llcommon/lltimer.h
+++ b/linden/indra/llcommon/lltimer.h
@@ -151,7 +151,7 @@ public:
         static void updateClass();
 
 protected:
-        LLTimer mTimer;
+        LLTimer mEventTimer;
         F32 mPeriod;
 
 private:
diff --git a/linden/indra/llcommon/lluri.cpp b/linden/indra/llcommon/lluri.cpp
index 83de022..43d2147 100644
--- a/linden/indra/llcommon/lluri.cpp
+++ b/linden/indra/llcommon/lluri.cpp
@@ -295,9 +295,10 @@ LLURI LLURI::buildHTTP(const std::string& prefix,
                                            const LLSD& query)
 {
         LLURI uri = buildHTTP(prefix, path);
-        uri.mEscapedQuery = mapToQueryString(query);
         // break out and escape each query component
-        uri.mEscapedOpaque += "?" + uri.mEscapedQuery ;
+        uri.mEscapedQuery = mapToQueryString(query);
+        uri.mEscapedOpaque += uri.mEscapedQuery ;
+        uri.mEscapedQuery.erase(0,1); // trim the leading '?'
         return uri;
 }
 
@@ -601,20 +602,30 @@ LLSD LLURI::queryMap(std::string escaped_query_string)
 std::string LLURI::mapToQueryString(const LLSD& queryMap)
 {
         std::string query_string;
-
         if (queryMap.isMap())
         {
-                for (LLSD::map_const_iterator iter = queryMap.beginMap();
-                         iter != queryMap.endMap();
-                         iter++)
+                bool first_element = true;
+                LLSD::map_const_iterator iter = queryMap.beginMap();
+                LLSD::map_const_iterator end = queryMap.endMap();
+                std::ostringstream ostr;
+                for (; iter != end; ++iter)
                 {
-                        query_string += escapeQueryVariable(iter->first) +
-                                (iter->second.isUndefined() ? "" : "=" + escapeQueryValue(iter->second.asString())) + "&" ;
+                        if(first_element)
+                        {
+                                ostr << "?";
+                                first_element = false;
+                        }
+                        else
+                        {
+                                ostr << "&";
+                        }
+                        ostr << escapeQueryVariable(iter->first);
+                        if(iter->second.isDefined())
+                        {
+                                ostr << "=" <<  escapeQueryValue(iter->second.asString());
+                        }
                 }
-                //if (queryMap.size() > 0)
-                //{
-                //      query_string += "?" + query_string ;
-                //}
+                query_string = ostr.str();
         }
         return query_string;
 }
diff --git a/linden/indra/llcommon/lluri.h b/linden/indra/llcommon/lluri.h
index 3f24799..1044c48 100644
--- a/linden/indra/llcommon/lluri.h
+++ b/linden/indra/llcommon/lluri.h
@@ -58,34 +58,42 @@ public:
           
   // construct from escaped string, as would be transmitted on the net
 
-  ~LLURI();
+        ~LLURI();
 
-  static LLURI buildHTTP(const std::string& prefix,
-                         const LLSD& path);
-  static LLURI buildHTTP(const std::string& prefix,
-                         const LLSD& path,
-                         const LLSD& query);
-        // prefix is either a full URL prefix of the form "http://example.com:8080",
-        // or it can be simply a host and optional port like "example.com" or 
-        // "example.com:8080", in these cases, the "http://" will be added
+        static LLURI buildHTTP(
+                const std::string& prefix,
+                const LLSD& path);
 
-  static LLURI buildHTTP(const std::string& host,
-                         const U32& port,
-                         const LLSD& path);
-  static LLURI buildHTTP(const std::string& host,
-                         const U32& port,
-                         const LLSD& path,
-                         const LLSD& query);
-  std::string asString() const;
-  // the whole URI, escaped as needed
+        static LLURI buildHTTP(
+                const std::string& prefix,
+                const LLSD& path,
+                const LLSD& query);
+        ///< prefix is either a full URL prefix of the form
+        /// "http://example.com:8080", or it can be simply a host and
+        /// optional port like "example.com" or "example.com:8080", in
+        /// these cases, the "http://" will be added
+
+        static LLURI buildHTTP(
+                const std::string& host,
+                const U32& port,
+                const LLSD& path);
+        static LLURI buildHTTP(
+                const std::string& host,
+                const U32& port,
+                const LLSD& path,
+                const LLSD& query);
+
+        std::string asString() const;
+        ///< the whole URI, escaped as needed
   
-  // Parts of a URI
-  // These functions return parts of the decoded URI.  The returned
-  // strings are un-escaped as needed
+        /** @name Parts of a URI */
+        //@{
+        // These functions return parts of the decoded URI.  The returned
+        // strings are un-escaped as needed
   
-  // for all schemes
-  std::string scheme() const;           // ex.: "http", note lack of colon
-  std::string opaque() const;           // everything after the colon
+        // for all schemes
+        std::string scheme() const;             ///< ex.: "http", note lack of colon
+        std::string opaque() const;             ///< everything after the colon
   
   // for schemes that follow path like syntax (http, https, ftp)
   std::string authority() const;        // ex.: "host.com:80"
@@ -101,27 +109,34 @@ public:
   const std::string& escapedQuery() const { return mEscapedQuery; }
   LLSD queryMap() const;                        // above decoded into a map
   static LLSD queryMap(std::string escaped_query_string);
-  static std::string mapToQueryString(const LLSD& queryMap);
 
-  // Escaping Utilities
-  // Escape a string by urlencoding all the characters that aren't in the allowed string.
-  static std::string escape(const std::string& str);
-  static std::string escape(const std::string& str, const std::string & allowed); 
-  static std::string unescape(const std::string& str);
+        /**
+         * @brief given a name value map, return a serialized query string.
+         *
+
+         * @param query_map a map of name value. every value must be
+         * representable as a string.
+         * @return Returns an url query string of '?n1=v1&n2=v2&...'
+         */
+        static std::string mapToQueryString(const LLSD& query_map);
 
-        // Functions for building specific URIs for web services
-        // *NOTE: DEPRECATED. use the service builder instead.
-        //static LLURI buildBulkAgentNamesURI(LLApp* app);
-        //static LLURI buildAgentSessionURI(const LLUUID& agent_id, LLApp* app);
-        //static LLURI buildAgentLoginInfoURI(const LLUUID& agent_id, const std::string& dataserver);
-        //static LLURI buildAgentNameURI(const LLUUID& agent_id, LLApp* app);
+        /** @name Escaping Utilities */
+        //@{
+        // Escape a string by urlencoding all the characters that aren't
+        // in the allowed string.
+        static std::string escape(const std::string& str);
+        static std::string escape(
+                const std::string& str,
+                const std::string & allowed); 
+        static std::string unescape(const std::string& str);
+        //@}
 
 private:
-  std::string mScheme;
-  std::string mEscapedOpaque;
-  std::string mEscapedAuthority;
-  std::string mEscapedPath;
-  std::string mEscapedQuery;
+        std::string mScheme;
+        std::string mEscapedOpaque;
+        std::string mEscapedAuthority;
+        std::string mEscapedPath;
+        std::string mEscapedQuery;
 };
 
 #endif // LL_LLURI_H
diff --git a/linden/indra/llcommon/llversion.h b/linden/indra/llcommon/llversion.h
index 9739d04..555698d 100644
--- a/linden/indra/llcommon/llversion.h
+++ b/linden/indra/llcommon/llversion.h
@@ -31,7 +31,7 @@
 
 const S32 LL_VERSION_MAJOR = 1;
 const S32 LL_VERSION_MINOR = 18;
-const S32 LL_VERSION_PATCH = 0;
-const S32 LL_VERSION_BUILD = 6;
+const S32 LL_VERSION_PATCH = 1;
+const S32 LL_VERSION_BUILD = 2;
 
 #endif
diff --git a/linden/indra/llcommon/llworkerthread.cpp b/linden/indra/llcommon/llworkerthread.cpp
index aa0bedf..b4d9485 100644
--- a/linden/indra/llcommon/llworkerthread.cpp
+++ b/linden/indra/llcommon/llworkerthread.cpp
@@ -104,6 +104,8 @@ S32 LLWorkerThread::update(U32 max_time_ms)
                 }
                 delete *iter;
         }
+    // delete and aborted entries mean there's still work to do
+        res += delete_list.size() + abort_list.size();
         return res;
 }
 
diff --git a/linden/indra/llcommon/stdtypes.h b/linden/indra/llcommon/stdtypes.h
index 16b57fa..118278f 100644
--- a/linden/indra/llcommon/stdtypes.h
+++ b/linden/indra/llcommon/stdtypes.h
@@ -31,18 +31,18 @@
 #include <limits.h>
 #include <float.h>
 
-typedef signed char                             S8;
+typedef signed char                     S8;
 typedef unsigned char                   U8;
 typedef signed short                    S16;
 typedef unsigned short                  U16;
-typedef signed int                              S32;
+typedef signed int                      S32;
 typedef unsigned int                    U32;
 
 #if LL_WINDOWS
 // Windows wchar_t is 16-bit
-typedef U32                                             llwchar;
+typedef U32                             llwchar;
 #else
-typedef wchar_t                                 llwchar;
+typedef wchar_t                         llwchar;
 #endif
 
 #if LL_WINDOWS
@@ -53,20 +53,20 @@ typedef unsigned __int64		U64;
 #define U64L(a)                                 (a)
 #else
 typedef long long int                   S64;
-typedef long long unsigned int  U64;
-#if LL_DARWIN || LL_LINUX
-#define S64L(a)                                 (a##LL)
-#define U64L(a)                                 (a##ULL)
+typedef long long unsigned int          U64;
+#if LL_DARWIN || LL_LINUX || LL_SOLARIS
+#define S64L(a)                         (a##LL)
+#define U64L(a)                         (a##ULL)
 #endif
 #endif
 
-typedef float                   F32;
-typedef double                  F64;
+typedef float                           F32;
+typedef double                          F64;
 
 typedef S32                             BOOL;
 typedef U8                              KEY;
 typedef U32                             MASK;
-typedef U32             TPACKETID;
+typedef U32                             TPACKETID;
 
 // Use #define instead of consts to avoid conversion headaches
 #define S8_MAX          (SCHAR_MAX)
diff --git a/linden/indra/llcommon/timing.h b/linden/indra/llcommon/timing.h
index 662d22b..b799001 100644
--- a/linden/indra/llcommon/timing.h
+++ b/linden/indra/llcommon/timing.h
@@ -31,7 +31,7 @@
 
 #include <time.h>
 
-#if LL_LINUX || LL_DARWIN
+#if LL_LINUX || LL_DARWIN || LL_SOLARIS
 #               include <sys/time.h>
 #endif