15 files changed, 256 insertions, 63 deletions

diff --git a/linden/indra/llcommon/llapp.cpp b/linden/indra/llcommon/llapp.cpp
index b0751b8..2347ac9 100644
--- a/linden/indra/llcommon/llapp.cpp
+++ b/linden/indra/llcommon/llapp.cpp
@@ -47,6 +47,7 @@
 //
 #if LL_WINDOWS
 LONG WINAPI default_windows_exception_handler(struct _EXCEPTION_POINTERS *exception_infop);
+BOOL ConsoleCtrlHandler(DWORD fdwCtrlType);
 #else
 #include <unistd.h> // for fork()
 void setup_signals();
@@ -219,6 +220,11 @@ void LLApp::setupErrorHandling()
         // Disable this until the viewer gets ported so server crashes can be JIT debugged.
         //LPTOP_LEVEL_EXCEPTION_FILTER prev_filter;
         //prev_filter = SetUnhandledExceptionFilter(default_windows_exception_handler);
+
+        // This sets a callback to handle w32 signals to the console window.
+        // The viewer shouldn't be affected, sicne its a windowed app.
+        SetConsoleCtrlHandler( (PHANDLER_ROUTINE) ConsoleCtrlHandler, TRUE);
+
 #else
         //
         // Start up signal handling.
@@ -399,6 +405,34 @@ LONG WINAPI default_windows_exception_handler(struct _EXCEPTION_POINTERS *except
         return retval;
 }
 
+// Win32 doesn't support signals. This is used instead.
+BOOL ConsoleCtrlHandler(DWORD fdwCtrlType) 
+{ 
+        switch (fdwCtrlType) 
+        { 
+                case CTRL_BREAK_EVENT: 
+                case CTRL_LOGOFF_EVENT: 
+                case CTRL_SHUTDOWN_EVENT: 
+                case CTRL_CLOSE_EVENT: // From end task or the window close button.
+                case CTRL_C_EVENT:  // from CTRL-C on the keyboard
+                        // Just set our state to quitting, not error
+                        if (LLApp::isQuitting() || LLApp::isError())
+                        {
+                                // We're already trying to die, just ignore this signal
+                                if (LLApp::sLogInSignal)
+                                {
+                                        llinfos << "Signal handler - Already trying to quit, ignoring signal!" << llendl;
+                                }
+                                return TRUE;
+                        }
+                        LLApp::setQuitting();
+                        return TRUE; 
+        
+                default: 
+                        return FALSE; 
+        } 
+} 
+
 #else //!LL_WINDOWS
 void LLApp::setChildCallback(pid_t pid, LLAppChildCallback callback)
 {
diff --git a/linden/indra/llcommon/llavatarconstants.h b/linden/indra/llcommon/llavatarconstants.h
index c62cae2..4ba6642 100644
--- a/linden/indra/llcommon/llavatarconstants.h
+++ b/linden/indra/llcommon/llavatarconstants.h
@@ -49,6 +49,7 @@ const U32 AVATAR_MATURE_PUBLISH			= 0x1 << 1;	// profile is "mature"
 const U32 AVATAR_IDENTIFIED                             = 0x1 << 2;     // whether avatar has provided payment info
 const U32 AVATAR_TRANSACTED                             = 0x1 << 3;     // whether avatar has actively used payment info
 const U32 AVATAR_ONLINE                                 = 0x1 << 4; // the online status of this avatar, if known.
+const U32 AVATAR_AGEVERIFIED                    = 0x1 << 5;     // whether avatar has been age-verified
 
 static const std::string VISIBILITY_DEFAULT("default");
 static const std::string VISIBILITY_HIDDEN("hidden");
diff --git a/linden/indra/llcommon/llcommon.vcproj b/linden/indra/llcommon/llcommon.vcproj
index 80704af..0ab544e 100644
--- a/linden/indra/llcommon/llcommon.vcproj
+++ b/linden/indra/llcommon/llcommon.vcproj
@@ -415,6 +415,9 @@
                                 RelativePath=".\llindexedqueue.h">
                         </File>
                         <File
+                                RelativePath=".\llkeythrottle.h">
+                        </File>
+                        <File
                                 RelativePath=".\lllinkedqueue.h">
                         </File>
                         <File
diff --git a/linden/indra/llcommon/llcommon_vc8.vcproj b/linden/indra/llcommon/llcommon_vc8.vcproj
index 1687a89..4790b61 100644
--- a/linden/indra/llcommon/llcommon_vc8.vcproj
+++ b/linden/indra/llcommon/llcommon_vc8.vcproj
@@ -201,7 +201,9 @@
                         />

                         <Tool

                                 Name="VCLibrarianTool"

+                                AdditionalDependencies="psapi.lib"

                                 OutputFile="$(OutDir)/llcommon.lib"

+                                AdditionalLibraryDirectories=""

                         />

                         <Tool

                                 Name="VCALinkTool"

diff --git a/linden/indra/llcommon/llsd.cpp b/linden/indra/llcommon/llsd.cpp
index 305531b..829ea25 100644
--- a/linden/indra/llcommon/llsd.cpp
+++ b/linden/indra/llcommon/llsd.cpp
@@ -36,11 +36,23 @@
 #include "../llmath/llmath.h"
 #include "llformat.h"
 
+#ifndef LL_RELEASE_FOR_DOWNLOAD
+#define NAME_UNNAMED_NAMESPACE
+#endif
+
+#ifdef NAME_UNNAMED_NAMESPACE
+namespace LLSDUnnamedNamespace {
+#else
 namespace {
+#endif
         class ImplMap;
         class ImplArray;
 }
 
+#ifdef NAME_UNNAMED_NAMESPACE
+using namespace LLSDUnnamedNamespace;
+#endif
+
 class LLSD::Impl
         /**< This class is the abstract base class of the implementation of LLSD
                  It provides the reference counting implementation, and the default
@@ -125,7 +137,11 @@ public:
         static U32 sOutstandingCount;
 };
 
+#ifdef NAME_UNNAMED_NAMESPACE
+namespace LLSDUnnamedNamespace {
+#else
 namespace {
+#endif
         template<LLSD::Type T, class Data, class DataRef = Data>
         class ImplBase : public LLSD::Impl
                 ///< This class handles most of the work for a subclass of Impl
@@ -632,7 +648,11 @@ U32 LLSD::Impl::sOutstandingCount = 0;
 
 
 
+#ifdef NAME_UNNAMED_NAMESPACE
+namespace LLSDUnnamedNamespace {
+#else
 namespace {
+#endif
         inline LLSD::Impl& safe(LLSD::Impl* impl)
                 { return LLSD::Impl::safe(impl); }
                 
diff --git a/linden/indra/llcommon/llsd.h b/linden/indra/llcommon/llsd.h
index 1fb917f..65ba7dd 100644
--- a/linden/indra/llcommon/llsd.h
+++ b/linden/indra/llcommon/llsd.h
@@ -376,6 +376,7 @@ struct llsd_select_string : public std::unary_function<LLSD, LLSD::String>
         }
 };
 
+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.cpp b/linden/indra/llcommon/llsdserialize.cpp
index a7470be..5ab9471 100644
--- a/linden/indra/llcommon/llsdserialize.cpp
+++ b/linden/indra/llcommon/llsdserialize.cpp
@@ -1641,4 +1641,9 @@ void serialize_string(const std::string& value, std::ostream& str)
         }
 }
 
+std::ostream& operator<<(std::ostream& s, const LLSD& llsd)
+{
+        s << LLSDNotationStreamer(llsd);
+        return s;
+}
 
diff --git a/linden/indra/llcommon/llstring.cpp b/linden/indra/llcommon/llstring.cpp
index 6dab598..e701ea0 100644
--- a/linden/indra/llcommon/llstring.cpp
+++ b/linden/indra/llcommon/llstring.cpp
@@ -34,6 +34,13 @@
 #include "llstring.h"
 #include "llerror.h"
 
+#if LL_WINDOWS
+#define WIN32_LEAN_AND_MEAN
+#include <winsock2.h>
+#include <windows.h>
+#include <winnls.h> // for WideCharToMultiByte
+#endif
+
 std::string ll_safe_string(const char* in)
 {
         if(in) return std::string(in);
@@ -718,19 +725,7 @@ std::string utf8str_removeCRLF(const std::string& utf8str)
 }
 
 #if LL_WINDOWS
-/* If the size of the passed in buffer is not large enough to hold the string,
- * two bad things happen:
- * 1. resulting formatted string is NOT null terminated
- * 2. Depending on the platform, the return value could be a) the required
- *    size of the buffer to copy the entire formatted string or b) -1.
- *    On Windows with VS.Net 2003, it returns -1 e.g. 
- *
- * safe_snprintf always adds a NULL terminator so that the caller does not
- * need to check for return value or need to add the NULL terminator.
- * It does not, however change the return value - to let the caller know
- * that the passed in buffer size was not large enough to hold the formatted string.
- *
- */
+// documentation moved to header. Phoenix 2007-11-27
 int safe_snprintf(char *str, size_t size, const char *format, ...)
 {
         va_list args;
@@ -742,6 +737,43 @@ int safe_snprintf(char *str, size_t size, const char *format, ...)
         str[size-1] = '\0'; // always null terminate
         return num_written;
 }
+
+std::string ll_convert_wide_to_string(const wchar_t* in)
+{
+        std::string out;
+        if(in)
+        {
+                int len_in = wcslen(in);
+                int len_out = WideCharToMultiByte(
+                        CP_ACP,
+                        0,
+                        in,
+                        len_in,
+                        NULL,
+                        0,
+                        0,
+                        0);
+                // We will need two more bytes for the double NULL ending
+                // created in WideCharToMultiByte().
+                char* pout = new char [len_out + 2];
+                memset(pout, 0, len_out + 2);
+                if(pout)
+                {
+                        WideCharToMultiByte(
+                                CP_ACP,
+                                0,
+                                in,
+                                len_in,
+                                pout,
+                                len_out,
+                                0,
+                                0);
+                        out.assign(pout);
+                        delete[] pout;
+                }
+        }
+        return out;
+}
 #endif // LL_WINDOWS
 
 S32     LLStringOps::collate(const llwchar* a, const llwchar* b)
diff --git a/linden/indra/llcommon/llstring.h b/linden/indra/llcommon/llstring.h
index 70f7d54..ae44ac3 100644
--- a/linden/indra/llcommon/llstring.h
+++ b/linden/indra/llcommon/llstring.h
@@ -481,7 +481,37 @@ std::ostream& operator<<(std::ostream &s, const LLStringBase<T> &str)
 std::ostream& operator<<(std::ostream &s, const LLWString &wstr);
 
 #if LL_WINDOWS
-int safe_snprintf(char *str, size_t size, const char *format, ...);
+/* @name Windows string helpers
+ */
+//@{
+
+/**
+ * @brief Implementation the expected snprintf interface.
+ *
+ * If the size of the passed in buffer is not large enough to hold the string,
+ * two bad things happen:
+ * 1. resulting formatted string is NOT null terminated
+ * 2. Depending on the platform, the return value could be a) the required
+ *    size of the buffer to copy the entire formatted string or b) -1.
+ *    On Windows with VS.Net 2003, it returns -1 e.g. 
+ *
+ * safe_snprintf always adds a NULL terminator so that the caller does not
+ * need to check for return value or need to add the NULL terminator.
+ * It does not, however change the return value - to let the caller know
+ * that the passed in buffer size was not large enough to hold the
+ * formatted string.
+ *
+ */
+int safe_snprintf(char* str, size_t size, const char* format, ...);
+
+/**
+ * @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);
+
+//@}
 #endif // LL_WINDOWS
 
 /**
diff --git a/linden/indra/llcommon/llsys.cpp b/linden/indra/llcommon/llsys.cpp
index 3b57db7..7346b29 100644
--- a/linden/indra/llcommon/llsys.cpp
+++ b/linden/indra/llcommon/llsys.cpp
@@ -65,8 +65,7 @@ static const S32 CPUINFO_BUFFER_SIZE = 16383;
 LLCPUInfo gSysCPU;
 
 LLOSInfo::LLOSInfo() :
-        mMajorVer(0), mMinorVer(0), mBuild(0),
-        mOSString("")
+        mMajorVer(0), mMinorVer(0), mBuild(0)
 {
 
 #if LL_WINDOWS
@@ -94,27 +93,28 @@ LLOSInfo::LLOSInfo() :
                         // Test for the product.
                         if(osvi.dwMajorVersion <= 4)
                         {
-                                mOSString = "Microsoft Windows NT ";
+                                mOSStringSimple = "Microsoft Windows NT ";
                         }
                         else if(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
                         {
-                                mOSString = "Microsoft Windows 2000 ";
+                                mOSStringSimple = "Microsoft Windows 2000 ";
                         }
                         else if(osvi.dwMajorVersion ==5 && osvi.dwMinorVersion == 1)
                         {
-                                mOSString = "Microsoft Windows XP ";
+                                mOSStringSimple = "Microsoft Windows XP ";
                         }
                         else if(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2)
                         {
                                  if(osvi.wProductType == VER_NT_WORKSTATION)
-                                        mOSString = "Microsoft Windows XP x64 Edition ";
-                                 else mOSString = "Microsoft Windows Server 2003 ";
+                                        mOSStringSimple = "Microsoft Windows XP x64 Edition ";
+                                 else
+                                         mOSStringSimple = "Microsoft Windows Server 2003 ";
                         }
                         else if(osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 0)
                         {
                                  if(osvi.wProductType == VER_NT_WORKSTATION)
-                                        mOSString = "Microsoft Windows Vista ";
-                                 else mOSString = "Microsoft Windows Vista Server ";
+                                        mOSStringSimple = "Microsoft Windows Vista ";
+                                 else mOSStringSimple = "Microsoft Windows Vista Server ";
                         }
                         else   // Use the registry on early versions of Windows NT.
                         {
@@ -129,15 +129,15 @@ LLOSInfo::LLOSInfo() :
                                 RegCloseKey( hKey );
                                 if ( lstrcmpi( L"WINNT", szProductType) == 0 )
                                 {
-                                        mOSString += "Professional ";
+                                        mOSStringSimple += "Professional ";
                                 }
                                 else if ( lstrcmpi( L"LANMANNT", szProductType) == 0 )
                                 {
-                                        mOSString += "Server ";
+                                        mOSStringSimple += "Server ";
                                 }
                                 else if ( lstrcmpi( L"SERVERNT", szProductType) == 0 )
                                 {
-                                        mOSString += "Advanced Server ";
+                                        mOSStringSimple += "Advanced Server ";
                                 }
                         }
 
@@ -164,7 +164,7 @@ LLOSInfo::LLOSInfo() :
                                         csdversion.c_str(),
                                         (osvi.dwBuildNumber & 0xffff));  
                         }
-                        mOSString += tmp;
+                        mOSString = mOSStringSimple + tmp;
                 }
                 break;
 
@@ -172,41 +172,65 @@ LLOSInfo::LLOSInfo() :
                 // Test for the Windows 95 product family.
                 if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
                 {
-                        mOSString = "Microsoft Windows 95 ";
+                        mOSStringSimple = "Microsoft Windows 95 ";
                         if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
                         {
-                mOSString += "OSR2 ";
+                mOSStringSimple += "OSR2 ";
                         }
                 } 
                 if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
                 {
-                        mOSString = "Microsoft Windows 98 ";
+                        mOSStringSimple = "Microsoft Windows 98 ";
                         if ( osvi.szCSDVersion[1] == 'A' )
                         {
-                mOSString += "SE ";
+                mOSStringSimple += "SE ";
                         }
                 } 
                 if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
                 {
-                        mOSString = "Microsoft Windows Millennium Edition ";
-                } 
+                        mOSStringSimple = "Microsoft Windows Millennium Edition ";
+                }
+                mOSString = mOSStringSimple;
                 break;
         }
 #else
         struct utsname un;
-        if(uname(&un) != -1)
+        if(uname(&un) != -1)
         {
-                mOSString.append(un.sysname);
-                mOSString.append(" ");
-                mOSString.append(un.release);
+                mOSStringSimple.append(un.sysname);
+                mOSStringSimple.append(" ");
+                mOSStringSimple.append(un.release);
+
+                mOSString = mOSStringSimple;
                 mOSString.append(" ");
                 mOSString.append(un.version);
                 mOSString.append(" ");
                 mOSString.append(un.machine);
+
+                // Simplify 'Simple'
+                std::string ostype = mOSStringSimple.substr(0, mOSStringSimple.find_first_of(" ", 0));
+                if (ostype == "Darwin")
+                {
+                        // Only care about major Darwin versions, truncate at first '.'
+                        S32 idx1 = mOSStringSimple.find_first_of(".", 0);
+                        std::string simple = mOSStringSimple.substr(0, idx1);
+                        if (simple.length() > 0)
+                                mOSStringSimple = simple;
+                }
+                else if (ostype == "Linux")
+                {
+                        // Only care about major and minor Linux versions, truncate at second '.'
+                        S32 idx1 = mOSStringSimple.find_first_of(".", 0);
+                        S32 idx2 = (idx1 != std::string::npos) ? mOSStringSimple.find_first_of(".", idx1+1) : std::string::npos;
+                        std::string simple = mOSStringSimple.substr(0, idx2);
+                        if (simple.length() > 0)
+                                mOSStringSimple = simple;
+                }
         }
         else
         {
-                mOSString.append("Unable to collect OS info");
+                mOSStringSimple.append("Unable to collect OS info");
+                mOSString = mOSStringSimple;
         }
 #endif
 
@@ -255,6 +279,11 @@ const std::string& LLOSInfo::getOSString() const
         return mOSString;
 }
 
+const std::string& LLOSInfo::getOSStringSimple() const
+{
+        return mOSStringSimple;
+}
+
 const S32 STATUS_SIZE = 8192;
 
 //static
diff --git a/linden/indra/llcommon/llsys.h b/linden/indra/llcommon/llsys.h
index fc4e027..332d62c 100644
--- a/linden/indra/llcommon/llsys.h
+++ b/linden/indra/llcommon/llsys.h
@@ -51,6 +51,7 @@ public:
         void stream(std::ostream& s) const;
 
         const std::string& getOSString() const;
+        const std::string& getOSStringSimple() const;
 
         S32 mMajorVer;
         S32 mMinorVer;
@@ -64,6 +65,7 @@ public:
         static U32 getProcessResidentSizeKB();
 private:
         std::string mOSString;
+        std::string mOSStringSimple;
 };
 
 
diff --git a/linden/indra/llcommon/lluri.cpp b/linden/indra/llcommon/lluri.cpp
index df79043..5e4dec7 100644
--- a/linden/indra/llcommon/lluri.cpp
+++ b/linden/indra/llcommon/lluri.cpp
@@ -40,6 +40,8 @@
   
 #include "../llmath/lluuid.h"
 
+// system includes
+#include <boost/tokenizer.hpp>
 
 // static
 std::string LLURI::escape(const std::string& str, const std::string & allowed)
@@ -130,7 +132,7 @@ LLURI::LLURI()
 
 LLURI::LLURI(const std::string& escaped_str)
 {
-        std::string::size_type delim_pos, delim_pos2;
+        std::string::size_type delim_pos;
         delim_pos = escaped_str.find(':');
         std::string temp;
         if (delim_pos == std::string::npos)
@@ -144,13 +146,39 @@ LLURI::LLURI(const std::string& escaped_str)
                 mEscapedOpaque = escaped_str.substr(delim_pos+1);
         }
 
-        if (mScheme == "http" || mScheme == "https" || mScheme == "ftp")
+        parseAuthorityAndPathUsingOpaque();
+
+        delim_pos = mEscapedPath.find('?');
+        if (delim_pos != std::string::npos)
+        {
+                mEscapedQuery = mEscapedPath.substr(delim_pos+1);
+                mEscapedPath = mEscapedPath.substr(0,delim_pos);
+        }
+}
+
+static BOOL isDefault(const std::string& scheme, U16 port)
+{
+        if (scheme == "http")
+                return port == 80;
+        if (scheme == "https")
+                return port == 443;
+        if (scheme == "ftp")
+                return port == 21;
+
+        return FALSE;
+}
+
+void LLURI::parseAuthorityAndPathUsingOpaque()
+{
+        if (mScheme == "http" || mScheme == "https" ||
+                mScheme == "ftp" || mScheme == "secondlife" )
         {
                 if (mEscapedOpaque.substr(0,2) != "//")
                 {
                         return;
                 }
-                
+
+                std::string::size_type delim_pos, delim_pos2;
                 delim_pos = mEscapedOpaque.find('/', 2);
                 delim_pos2 = mEscapedOpaque.find('?', 2);
                 // no path, no query
@@ -182,27 +210,12 @@ LLURI::LLURI(const std::string& escaped_str)
                         mEscapedPath = mEscapedOpaque.substr(delim_pos);
                 }
         }
-
-        delim_pos = mEscapedPath.find('?');
-        if (delim_pos != std::string::npos)
+        else if (mScheme == "about")
         {
-                mEscapedQuery = mEscapedPath.substr(delim_pos+1);
-                mEscapedPath = mEscapedPath.substr(0,delim_pos);
+                mEscapedPath = mEscapedOpaque;
         }
 }
 
-static BOOL isDefault(const std::string& scheme, U16 port)
-{
-        if (scheme == "http")
-                return port == 80;
-        if (scheme == "https")
-                return port == 443;
-        if (scheme == "ftp")
-                return port == 21;
-
-        return FALSE;
-}
-
 LLURI::LLURI(const std::string& scheme,
                          const std::string& userName,
                          const std::string& password,
@@ -440,6 +453,22 @@ std::string LLURI::path() const
         return unescape(mEscapedPath);
 }
 
+LLSD LLURI::pathArray() const
+{
+        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+        boost::char_separator<char> sep("/", "", boost::drop_empty_tokens);
+        tokenizer tokens(mEscapedPath, sep);
+        tokenizer::iterator it = tokens.begin();
+        tokenizer::iterator end = tokens.end();
+
+        LLSD params;
+        for ( ; it != end; ++it)
+        {
+                params.append(*it);
+        }
+        return params;
+}
+
 std::string LLURI::query() const
 {
         return unescape(mEscapedQuery);
diff --git a/linden/indra/llcommon/lluri.h b/linden/indra/llcommon/lluri.h
index 3246dcd..bfe673c 100644
--- a/linden/indra/llcommon/lluri.h
+++ b/linden/indra/llcommon/lluri.h
@@ -107,7 +107,7 @@ public:
   BOOL defaultPort() const;             // true if port is default for scheme
   const std::string& escapedPath() const { return mEscapedPath; }
   std::string path() const;             // ex.: "/abc/def", includes leading slash
-  //    LLSD pathArray() const;                 // above decoded into an array of strings
+  LLSD pathArray() const;                       // above decoded into an array of strings
   std::string query() const;            // ex.: "x=34", section after "?"
   const std::string& escapedQuery() const { return mEscapedQuery; }
   LLSD queryMap() const;                        // above decoded into a map
@@ -135,6 +135,11 @@ public:
         //@}
 
 private:
+         // only "http", "https", "ftp", and "secondlife" schemes are parsed
+         // secondlife scheme parses authority as "" and includes it as part of
+         // the path.  See lluri_tut.cpp
+         // i.e. secondlife://app/login has mAuthority = "" and mPath = "/app/login"
+        void parseAuthorityAndPathUsingOpaque();
         std::string mScheme;
         std::string mEscapedOpaque;
         std::string mEscapedAuthority;
diff --git a/linden/indra/llcommon/llversionserver.h b/linden/indra/llcommon/llversionserver.h
index e36702a..9e1a8f5 100644
--- a/linden/indra/llcommon/llversionserver.h
+++ b/linden/indra/llcommon/llversionserver.h
@@ -34,8 +34,8 @@
 
 const S32 LL_VERSION_MAJOR = 1;
 const S32 LL_VERSION_MINOR = 18;
-const S32 LL_VERSION_PATCH = 3;
-const S32 LL_VERSION_BUILD = 73552;
+const S32 LL_VERSION_PATCH = 6;
+const S32 LL_VERSION_BUILD = 74522;
 
 const char * const LL_CHANNEL = "Second Life Server";
 
diff --git a/linden/indra/llcommon/llversionviewer.h b/linden/indra/llcommon/llversionviewer.h
index 1df8a89..f9f3bf2 100644
--- a/linden/indra/llcommon/llversionviewer.h
+++ b/linden/indra/llcommon/llversionviewer.h
@@ -34,8 +34,8 @@
 
 const S32 LL_VERSION_MAJOR = 1;
 const S32 LL_VERSION_MINOR = 18;
-const S32 LL_VERSION_PATCH = 5;
-const S32 LL_VERSION_BUILD = 3;
+const S32 LL_VERSION_PATCH = 6;
+const S32 LL_VERSION_BUILD = 0;
 
 const char * const LL_CHANNEL = "Second Life Release";