merge changes for 3.7.27-release

7 files changed, 198 insertions, 39 deletions

diff --git a/indra/llcommon/llmd5.cpp b/indra/llcommon/llmd5.cpp
index ed80af36d8..f942a976b7 100755
--- a/indra/llcommon/llmd5.cpp
+++ b/indra/llcommon/llmd5.cpp
@@ -118,6 +118,12 @@ void LLMD5::update (const uint1 *input, const uint4 input_length) {
 
   buffer_space = 64 - buffer_index;  // how much space is left in buffer
 
+  // now, transform each 64-byte piece of the input, bypassing the buffer
+  if (input == NULL || input_length == 0){
+	  std::cerr << "LLMD5::update:  Invalid input!" << std::endl;
+	  return;
+  }
+
   // Transform as many times as possible.
   if (input_length >= buffer_space) { // ie. we have enough to fill the buffer
     // fill the rest of the buffer and transform
@@ -127,12 +133,6 @@ void LLMD5::update (const uint1 *input, const uint4 input_length) {
 		buffer_space);
     transform (buffer);
 
-    // now, transform each 64-byte piece of the input, bypassing the buffer
-  if (input == NULL || input_length == 0){
-	std::cerr << "LLMD5::update:  Invalid input!" << std::endl;
-	return;
-  }
-
     for (input_index = buffer_space; input_index + 63 < input_length; 
 	 input_index += 64)
       transform (input+input_index);
diff --git a/indra/llcommon/llmemory.cpp b/indra/llcommon/llmemory.cpp
index e0b2aa87c2..ae11988df8 100755
--- a/indra/llcommon/llmemory.cpp
+++ b/indra/llcommon/llmemory.cpp
@@ -63,13 +63,18 @@ LLPrivateMemoryPoolManager::mem_allocation_info_t LLPrivateMemoryPoolManager::sM
 
 void ll_assert_aligned_func(uintptr_t ptr,U32 alignment)
 {
-#ifdef SHOW_ASSERT
-	// Redundant, place to set breakpoints.
-	if (ptr%alignment!=0)
-	{
-		LL_WARNS() << "alignment check failed" << LL_ENDL;
-	}
-	llassert(ptr%alignment==0);
+#if defined(LL_WINDOWS) && defined(LL_DEBUG_BUFFER_OVERRUN)
+	//do not check
+	return;
+#else
+	#ifdef SHOW_ASSERT
+		// Redundant, place to set breakpoints.
+		if (ptr%alignment!=0)
+		{
+			LL_WARNS() << "alignment check failed" << LL_ENDL;
+		}
+		llassert(ptr%alignment==0);
+	#endif
 #endif
 }
 
@@ -2148,3 +2153,60 @@ void LLPrivateMemoryPoolTester::fragmentationtest()
 }
 #endif
 //--------------------------------------------------------------------
+
+#if defined(LL_WINDOWS) && defined(LL_DEBUG_BUFFER_OVERRUN)
+
+#include <map>
+
+struct mem_info {
+	std::map<void*, void*> memory_info;
+	LLMutex mutex;
+
+	static mem_info& get() {
+		static mem_info instance;
+		return instance;
+	}
+
+private:
+	mem_info(){}
+};
+
+void* ll_aligned_malloc_fallback( size_t size, int align )
+{
+	SYSTEM_INFO sysinfo;
+	GetSystemInfo(&sysinfo);
+	
+	unsigned int for_alloc = sysinfo.dwPageSize;
+	while(for_alloc < size) for_alloc += sysinfo.dwPageSize;
+	
+	void *p = VirtualAlloc(NULL, for_alloc+sysinfo.dwPageSize, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
+	if(NULL == p) {
+		// call debugger
+		__asm int 3;
+	}
+	DWORD old;
+	BOOL Res = VirtualProtect((void*)((char*)p + for_alloc), sysinfo.dwPageSize, PAGE_NOACCESS, &old);
+	if(FALSE == Res) {
+		// call debugger
+		__asm int 3;
+	}
+
+	void* ret = (void*)((char*)p + for_alloc-size);
+	
+	{
+		LLMutexLock lock(&mem_info::get().mutex);
+		mem_info::get().memory_info.insert(std::pair<void*, void*>(ret, p));
+	}
+	
+
+	return ret;
+}
+
+void ll_aligned_free_fallback( void* ptr )
+{
+	LLMutexLock lock(&mem_info::get().mutex);
+	VirtualFree(mem_info::get().memory_info.find(ptr)->second, 0, MEM_RELEASE);
+	mem_info::get().memory_info.erase(ptr);
+}
+
+#endif
diff --git a/indra/llcommon/llmemory.h b/indra/llcommon/llmemory.h
index 7d1d541a4b..c4c9cc0566 100755
--- a/indra/llcommon/llmemory.h
+++ b/indra/llcommon/llmemory.h
@@ -94,32 +94,44 @@ template <typename T> T* LL_NEXT_ALIGNED_ADDRESS_64(T* address)
 
 #define LL_ALIGN_16(var) LL_ALIGN_PREFIX(16) var LL_ALIGN_POSTFIX(16)
 
-
-inline void* ll_aligned_malloc_fallback( size_t size, int align )
-{
-#if defined(LL_WINDOWS)
-	return _aligned_malloc(size, align);
+//------------------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------------------------
+	// for enable buffer overrun detection predefine LL_DEBUG_BUFFER_OVERRUN in current library
+	// change preprocessro code to: #if 1 && defined(LL_WINDOWS)
+
+#if 0 && defined(LL_WINDOWS)
+	void* ll_aligned_malloc_fallback( size_t size, int align );
+	void ll_aligned_free_fallback( void* ptr );
+//------------------------------------------------------------------------------------------------
 #else
-	void* mem = malloc( size + (align - 1) + sizeof(void*) );
-	char* aligned = ((char*)mem) + sizeof(void*);
-	aligned += align - ((uintptr_t)aligned & (align - 1));
-
-	((void**)aligned)[-1] = mem;
-	return aligned;
-#endif
-}
+	inline void* ll_aligned_malloc_fallback( size_t size, int align )
+	{
+	#if defined(LL_WINDOWS)
+		return _aligned_malloc(size, align);
+	#else
+		void* mem = malloc( size + (align - 1) + sizeof(void*) );
+		char* aligned = ((char*)mem) + sizeof(void*);
+		aligned += align - ((uintptr_t)aligned & (align - 1));
+
+		((void**)aligned)[-1] = mem;
+		return aligned;
+	#endif
+	}
 
-inline void ll_aligned_free_fallback( void* ptr )
-{
-#if defined(LL_WINDOWS)
-	_aligned_free(ptr);
-#else
-	if (ptr)
+	inline void ll_aligned_free_fallback( void* ptr )
 	{
-		free( ((void**)ptr)[-1] );
+	#if defined(LL_WINDOWS)
+		_aligned_free(ptr);
+	#else
+		if (ptr)
+		{
+			free( ((void**)ptr)[-1] );
+		}
+	#endif
 	}
 #endif
-}
+//------------------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------------------------
 
 #if !LL_USE_TCMALLOC
 inline void* ll_aligned_malloc_16(size_t size) // returned hunk MUST be freed with ll_aligned_free_16().
diff --git a/indra/llcommon/llstacktrace.cpp b/indra/llcommon/llstacktrace.cpp
index e0e9056380..bbf0e1e141 100755
--- a/indra/llcommon/llstacktrace.cpp
+++ b/indra/llcommon/llstacktrace.cpp
@@ -125,6 +125,30 @@ bool ll_get_stack_trace(std::vector<std::string>& lines)
 	return false;
 }
 
+void ll_get_stack_trace_internal(std::vector<std::string>& lines)
+{
+	const S32 MAX_STACK_DEPTH = 100;
+	const S32 STRING_NAME_LENGTH = 256;
+
+	HANDLE process = GetCurrentProcess();
+	SymInitialize( process, NULL, TRUE );
+
+	void *stack[MAX_STACK_DEPTH];
+
+	unsigned short frames = RtlCaptureStackBackTrace_fn( 0, MAX_STACK_DEPTH, stack, NULL );
+	SYMBOL_INFO *symbol = (SYMBOL_INFO*)calloc(sizeof(SYMBOL_INFO) + STRING_NAME_LENGTH * sizeof(char), 1);
+	symbol->MaxNameLen = STRING_NAME_LENGTH-1;
+	symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+
+	for(unsigned int i = 0; i < frames; i++) 
+	{
+		SymFromAddr(process, (DWORD64)(stack[i]), 0, symbol);
+		lines.push_back(symbol->Name);
+	}
+
+	free( symbol );
+}
+
 #else
 
 bool ll_get_stack_trace(std::vector<std::string>& lines)
@@ -132,5 +156,10 @@ bool ll_get_stack_trace(std::vector<std::string>& lines)
 	return false;
 }
 
+void ll_get_stack_trace_internal(std::vector<std::string>& lines)
+{
+
+}
+
 #endif
 
diff --git a/indra/llcommon/llstacktrace.h b/indra/llcommon/llstacktrace.h
index ca72c64c5d..335765386a 100755
--- a/indra/llcommon/llstacktrace.h
+++ b/indra/llcommon/llstacktrace.h
@@ -33,6 +33,7 @@
 #include <string>
 
 LL_COMMON_API bool ll_get_stack_trace(std::vector<std::string>& lines);
+LL_COMMON_API void ll_get_stack_trace_internal(std::vector<std::string>& lines);
 
 #endif
 
diff --git a/indra/llcommon/lluriparser.cpp b/indra/llcommon/lluriparser.cpp
index ef4481d32f..8270c630d8 100644
--- a/indra/llcommon/lluriparser.cpp
+++ b/indra/llcommon/lluriparser.cpp
@@ -29,7 +29,7 @@
 #include "linden_common.h"
 #include "lluriparser.h"
 
-LLUriParser::LLUriParser(const std::string& u) : mTmpScheme(false), mRes(0)
+LLUriParser::LLUriParser(const std::string& u) : mTmpScheme(false), mNormalizedTmp(false), mRes(0)
 {
 	mState.uri = &mUri;
 
@@ -118,17 +118,39 @@ void LLUriParser::fragment(const std::string& s)
 
 void LLUriParser::textRangeToString(UriTextRangeA& textRange, std::string& str)
 {
+	str = "";
+
+	if(&textRange == NULL)
+	{
+		return;
+	}
+
+	if(textRange.first == NULL)
+	{
+		return;
+	}
+
+	if(textRange.afterLast == NULL)
+	{
+		return;
+	}
+
 	S32 len = textRange.afterLast - textRange.first;
 	if (len)
 	{
-		str = textRange.first;
-		str = str.substr(0, len);
+		str.assign(textRange.first, len);
 	}
 }
 
 void LLUriParser::extractParts()
 {
-	if (mTmpScheme)
+	if(&mUri == NULL)
+	{
+		LL_WARNS() << "mUri is NULL for uri: " << mNormalizedUri << LL_ENDL;
+		return;
+	}
+
+	if (mTmpScheme || mNormalizedTmp)
 	{
 		mScheme.clear();
 	}
@@ -157,6 +179,7 @@ void LLUriParser::extractParts()
 
 S32 LLUriParser::normalize()
 {
+	mNormalizedTmp = mTmpScheme;
 	if (!mRes)
 	{
 		mRes = uriNormalizeSyntaxExA(&mUri, URI_NORMALIZE_SCHEME | URI_NORMALIZE_HOST);
@@ -175,29 +198,58 @@ S32 LLUriParser::normalize()
 				if (!mRes)
 				{
 					mNormalizedUri = &label_buf[mTmpScheme ? 7 : 0];
+					mTmpScheme = false;
 				}
 			}
 		}
 	}
 
+	if(mTmpScheme)
+	{
+		mNormalizedUri = mNormalizedUri.substr(7);
+		mTmpScheme = false;
+	}
+
 	return mRes;
 }
 
 void LLUriParser::glue(std::string& uri) const
 {
+	std::string first_part;
+	glueFirst(first_part);
+
+	std::string second_part;
+	glueSecond(second_part);
+
+	uri = first_part + second_part;
+}
+
+void LLUriParser::glueFirst(std::string& uri) const
+{
 	if (mScheme.size())
 	{
 		uri = mScheme;
 		uri += "://";
 	}
+	else
+	{
+		uri.clear();
+	}
 
 	uri += mHost;
+}
 
+void LLUriParser::glueSecond(std::string& uri) const
+{
 	if (mPort.size())
 	{
-		uri += ':';
+		uri = ':';
 		uri += mPort;
 	}
+	else
+	{
+		uri.clear();
+	}
 
 	uri += mPath;
 
diff --git a/indra/llcommon/lluriparser.h b/indra/llcommon/lluriparser.h
index 719f916837..561431e8f9 100644
--- a/indra/llcommon/lluriparser.h
+++ b/indra/llcommon/lluriparser.h
@@ -60,6 +60,8 @@ public:
 
 	void extractParts();
 	void glue(std::string& uri) const;
+	void glueFirst(std::string& uri) const;
+	void glueSecond(std::string& uri) const;
 	bool test() const;
 	S32 normalize();
 
@@ -79,6 +81,7 @@ private:
 
 	S32 mRes;
 	bool mTmpScheme;
+	bool mNormalizedTmp;
 };
 
 #endif // LL_LLURIPARSER_H