QAR-628 merge string-cleanup-5 -r 90476:90508 -> release

dataserver-is-deprecated

49 files changed, 361 insertions, 447 deletions

diff --git a/indra/llmessage/llassetstorage.cpp b/indra/llmessage/llassetstorage.cpp
index 9d32afc2f0..af149d0f62 100644
--- a/indra/llmessage/llassetstorage.cpp
+++ b/indra/llmessage/llassetstorage.cpp
@@ -59,7 +59,7 @@
 LLAssetStorage *gAssetStorage = NULL;
 LLMetrics *LLAssetStorage::metric_recipient = NULL;
 
-const LLUUID CATEGORIZE_LOST_AND_FOUND_ID("00000000-0000-0000-0000-000000000010");
+const LLUUID CATEGORIZE_LOST_AND_FOUND_ID(std::string("00000000-0000-0000-0000-000000000010"));
 
 const U64 TOXIC_ASSET_LIFETIME = (120 * 1000000);		// microseconds
 
@@ -137,20 +137,20 @@ void LLAssetInfo::setFromNameValue( const LLNameValue& nv )
 	str.assign( nv.mName );
 	pos1 = str.find('|');
 	buf.assign( str, 0, pos1++ );
-	mType = LLAssetType::lookup( buf.c_str() );
+	mType = LLAssetType::lookup( buf );
 	buf.assign( str, pos1, std::string::npos );
-	mUuid.set( buf.c_str() );
+	mUuid.set( buf );
 
 	// convert the value to useful information
 	str.assign( nv.getAsset() );
 	pos1 = str.find('|');
 	buf.assign( str, 0, pos1++ );
-	mCreatorID.set( buf.c_str() );
+	mCreatorID.set( buf );
 	pos2 = str.find( '|', pos1 );
 	buf.assign( str, pos1, (pos2++) - pos1 );
-	setName( buf.c_str() );
+	setName( buf );
 	buf.assign( str, pos2, std::string::npos );
-	setDescription( buf.c_str() );
+	setDescription( buf );
 	llinfos << "uuid: " << mUuid << llendl;
 	llinfos << "creator: " << mCreatorID << llendl;
 }
@@ -1238,7 +1238,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid, LLAssetType::EType type, vo
 void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 status, LLExtStat ext_status)
 {
 	LLLegacyAssetRequest *legacy = (LLLegacyAssetRequest *)user_data;
-	char filename[LL_MAX_PATH] = "";	/* Flawfinder: ignore */ 
+	std::string filename;
 
 	// Check if the asset is marked toxic, and don't load bad stuff
 	BOOL toxic = gAssetStorage->isAssetToxic( uuid );
@@ -1248,10 +1248,10 @@ void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs, const LLUUID &uuid, LLAss
 	{
 		LLVFile file(vfs, uuid, type);
 
-		char uuid_str[UUID_STR_LENGTH];	/* Flawfinder: ignore */ 
+		std::string uuid_str;
 
 		uuid.toString(uuid_str);
-		snprintf(filename,sizeof(filename),"%s.%s",gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str).c_str(),LLAssetType::lookup(type));	/* Flawfinder: ignore */
+		filename = llformat("%s.%s",gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str).c_str(),LLAssetType::lookup(type));
 
 		LLFILE* fp = LLFile::fopen(filename, "wb");	/* Flawfinder: ignore */ 
 		if (fp)
@@ -1275,7 +1275,7 @@ void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs, const LLUUID &uuid, LLAss
 		}
 	}
 
-	legacy->mDownCallback(filename, uuid, legacy->mUserData, status, ext_status);
+	legacy->mDownCallback(filename.c_str(), uuid, legacy->mUserData, status, ext_status);
 	delete legacy;
 }
 
@@ -1294,7 +1294,7 @@ void LLAssetStorage::storeAssetData(
 {
 	llwarns << "storeAssetData: wrong version called" << llendl;
 	// LLAssetStorage metric: Virtual base call
-	reportMetric( LLUUID::null, asset_type, NULL, LLUUID::null, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 1" );
+	reportMetric( LLUUID::null, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 1" );
 }
 
 // virtual
@@ -1313,13 +1313,13 @@ void LLAssetStorage::storeAssetData(
 {
 	llwarns << "storeAssetData: wrong version called" << llendl;
 	// LLAssetStorage metric: Virtual base call
-	reportMetric( asset_id, asset_type, NULL, requesting_agent_id, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 2" );
+	reportMetric( asset_id, asset_type, LLStringUtil::null, requesting_agent_id, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 2" );
 }
 
 // virtual
 // this does nothing, viewer and sim both override this.
 void LLAssetStorage::storeAssetData(
-	const char* filename,
+	const std::string& filename,
 	const LLUUID& asset_id,
 	LLAssetType::EType asset_type,
 	LLStoreAssetCallback callback,
@@ -1331,13 +1331,13 @@ void LLAssetStorage::storeAssetData(
 {
 	llwarns << "storeAssetData: wrong version called" << llendl;
 	// LLAssetStorage metric: Virtual base call
-	reportMetric( asset_id, asset_type, NULL, LLUUID::null, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 3" );
+	reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 3" );
 }
 
 // virtual
 // this does nothing, viewer and sim both override this.
 void LLAssetStorage::storeAssetData(
-	const char* filename,
+	const std::string& filename,
 	const LLTransactionID &transactoin_id,
 	LLAssetType::EType asset_type,
 	LLStoreAssetCallback callback,
@@ -1349,7 +1349,7 @@ void LLAssetStorage::storeAssetData(
 {
 	llwarns << "storeAssetData: wrong version called" << llendl;
 	// LLAssetStorage metric: Virtual base call
-	reportMetric( LLUUID::null, asset_type, NULL, LLUUID::null, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 4" );
+	reportMetric( LLUUID::null, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_BAD_FUNCTION, __FILE__, __LINE__, "Illegal call to base: LLAssetStorage::storeAssetData 4" );
 }
 
 // static
@@ -1396,9 +1396,9 @@ void LLAssetStorage::clearTempAssetData()
 { }
 
 // static
-void LLAssetStorage::reportMetric( const LLUUID& asset_id, const LLAssetType::EType asset_type, const char *filename,
+void LLAssetStorage::reportMetric( const LLUUID& asset_id, const LLAssetType::EType asset_type, const std::string& in_filename,
 								   const LLUUID& agent_id, S32 asset_size, EMetricResult result,
-								   const char *file, const S32 line, const char *message )
+								   const char *file, const S32 line, const std::string& in_message )
 {
 	if( !metric_recipient )
 	{
@@ -1406,18 +1406,13 @@ void LLAssetStorage::reportMetric( const LLUUID& asset_id, const LLAssetType::ET
 		return;
 	}
 
-	filename = filename ? filename : "";
-	file = file ? file : "";
-
-	// Create revised message - message = "message :: file:line"
-	std::string new_message; //( message );
-	new_message = message; // << " " << file << " " << line;
-	new_message += " :: ";
-	new_message += filename;
-	char line_string[16];
-	sprintf( line_string, ":%d", line );
-	new_message += line_string;
-	message = new_message.c_str();
+	std::string filename(in_filename);
+	if (filename.empty())
+		filename = ll_safe_string(file);
+	
+	// Create revised message - new_message = "in_message :: file:line"
+	std::stringstream new_message;
+	new_message << in_message << " :: " << filename << ":" << line;
 
 	// Change always_report to true if debugging... do not check it in this way
 	static bool always_report = false;
@@ -1430,16 +1425,16 @@ void LLAssetStorage::reportMetric( const LLUUID& asset_id, const LLAssetType::ET
 		LLSD stats;
 		stats["asset_id"] = asset_id;
 		stats["asset_type"] = asset_type;
-		stats["filename"] = filename? filename : "";
+		stats["filename"] = filename;
 		stats["agent_id"] = agent_id;
 		stats["asset_size"] = (S32)asset_size;
 		stats["result"] = (S32)result;
 
-		metric_recipient->recordEventDetails( metric_name, message, success, stats);
+		metric_recipient->recordEventDetails( metric_name, new_message.str(), success, stats);
 	}
 	else
 	{
-		metric_recipient->recordEvent(metric_name, message, success);
+		metric_recipient->recordEvent(metric_name, new_message.str(), success);
 	}
 }
 
diff --git a/indra/llmessage/llassetstorage.h b/indra/llmessage/llassetstorage.h
index b1007e83c6..1b83d17c8f 100644
--- a/indra/llmessage/llassetstorage.h
+++ b/indra/llmessage/llassetstorage.h
@@ -378,7 +378,7 @@ public:
 	 * AssetID version.
 	 */
 	virtual void storeAssetData(
-		const char* filename,
+		const std::string& filename,
 		const LLUUID& asset_id,
 		LLAssetType::EType type,
 		LLStoreAssetCallback callback,
@@ -392,7 +392,7 @@ public:
 	 * TransactionID version
 	 */
 	virtual void storeAssetData(
-		const char * filename,
+		const std::string& filename,
 		const LLTransactionID &transaction_id,
 		LLAssetType::EType type,
 		LLStoreAssetCallback callback,
@@ -451,9 +451,9 @@ protected:
 
 	static class LLMetrics *metric_recipient;
 
-	static void reportMetric( const LLUUID& asset_id, const LLAssetType::EType asset_type, const char *filename,
-					   const LLUUID& agent_id, S32 asset_size, EMetricResult result,
-					   const char *file, const S32 line, const char *message ); 
+	static void reportMetric( const LLUUID& asset_id, const LLAssetType::EType asset_type, const std::string& filename,
+							  const LLUUID& agent_id, S32 asset_size, EMetricResult result,
+							  const char* file, const S32 line, const std::string& message ); 
 public:
 	static void setMetricRecipient( LLMetrics *recip )
 	{
diff --git a/indra/llmessage/llcachename.cpp b/indra/llmessage/llcachename.cpp
index 1ad5179455..2cc82f7c23 100644
--- a/indra/llmessage/llcachename.cpp
+++ b/indra/llmessage/llcachename.cpp
@@ -43,10 +43,9 @@
 #include "message.h"
 
 // Constants
-// probably need a setUIString() call in the interface
-const char* const CN_WAITING = "(Loading...)"; // *TODO: translate
-const char* const CN_NOBODY = "(nobody)"; // *TODO: translate
-const char* const CN_NONE = "(none)"; // *TODO: translate
+static const std::string CN_WAITING("(Loading...)"); // *TODO: translate
+static const std::string CN_NOBODY("(nobody)"); // *TODO: translate
+static const std::string CN_NONE("(none)"); // *TODO: translate
 
 // llsd serialization constants
 static const std::string AGENTS("agents");
@@ -78,16 +77,13 @@ public:
 public:
 	bool mIsGroup;
 	U32 mCreateTime;	// unix time_t
-	char mFirstName[DB_FIRST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
-	char mLastName[DB_LAST_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
-	char mGroupName[DB_GROUP_NAME_BUF_SIZE]; /*Flawfinder: ignore*/
+	std::string mFirstName;
+	std::string mLastName;
+	std::string mGroupName;
 };
 
 LLCacheNameEntry::LLCacheNameEntry()
 {
-	mFirstName[0] = '\0';
-	mLastName[0]  = '\0';
-	mGroupName[0] = '\0';
 }
 
 
@@ -235,7 +231,7 @@ public:
 	static void handleUUIDGroupNameRequest(LLMessageSystem* msg, void** userdata);
 	static void handleUUIDGroupNameReply(LLMessageSystem* msg, void** userdata);
 
-	void notifyObservers(const LLUUID& id, const char* first, const char* last, BOOL group);
+	void notifyObservers(const LLUUID& id, const std::string& first, const std::string& last, BOOL group);
 };
 
 
@@ -390,8 +386,8 @@ void LLCacheName::importFile(LLFILE* fp)
 		LLCacheNameEntry* entry = new LLCacheNameEntry();
 		entry->mIsGroup = false;
 		entry->mCreateTime = create_time;
-		LLString::copy(entry->mFirstName, firstname, DB_FIRST_NAME_BUF_SIZE);
-		LLString::copy(entry->mLastName, lastname, DB_LAST_NAME_BUF_SIZE);
+		entry->mFirstName = firstname;
+		entry->mLastName = lastname;
 		impl.mCache[id] = entry;
 
 		count++;
@@ -426,12 +422,8 @@ bool LLCacheName::importFile(std::istream& istr)
 		LLCacheNameEntry* entry = new LLCacheNameEntry();
 		entry->mIsGroup = false;
 		entry->mCreateTime = ctime;
-		std::string first = agent[FIRST].asString();
-		first.copy(entry->mFirstName, DB_FIRST_NAME_BUF_SIZE, 0);
-		entry->mFirstName[llmin(first.size(),(std::string::size_type)DB_FIRST_NAME_BUF_SIZE-1)] = '\0';
-		std::string last = agent[LAST].asString();
-		last.copy(entry->mLastName, DB_LAST_NAME_BUF_SIZE, 0);
-		entry->mLastName[llmin(last.size(),(std::string::size_type)DB_LAST_NAME_BUF_SIZE-1)] = '\0';
+		entry->mFirstName = agent[FIRST].asString();
+		entry->mLastName = agent[LAST].asString();
 		impl.mCache[id] = entry;
 		++count;
 	}
@@ -451,9 +443,7 @@ bool LLCacheName::importFile(std::istream& istr)
 		LLCacheNameEntry* entry = new LLCacheNameEntry();
 		entry->mIsGroup = true;
 		entry->mCreateTime = ctime;
-		std::string name = group[NAME].asString();
-		name.copy(entry->mGroupName, DB_GROUP_NAME_BUF_SIZE, 0);
-		entry->mGroupName[llmin(name.size(), (std::string::size_type)DB_GROUP_NAME_BUF_SIZE-1)] = '\0';
+		entry->mGroupName = group[NAME].asString();
 		impl.mCache[id] = entry;
 		++count;
 	}
@@ -471,8 +461,8 @@ void LLCacheName::exportFile(std::ostream& ostr)
 		// Only write entries for which we have valid data.
 		LLCacheNameEntry* entry = iter->second;
 		if(!entry
-		   || (NULL != strchr(entry->mFirstName, '?'))
-		   || (NULL != strchr(entry->mGroupName, '?')))
+		   || (std::string::npos != entry->mFirstName.find('?'))
+		   || (std::string::npos != entry->mGroupName.find('?')))
 		{
 			continue;
 		}
@@ -480,13 +470,13 @@ void LLCacheName::exportFile(std::ostream& ostr)
 		// store it
 		LLUUID id = iter->first;
 		std::string id_str = id.asString();
-		if(entry->mFirstName[0] && entry->mLastName[0])
+		if(!entry->mFirstName.empty() && !entry->mLastName.empty())
 		{
 			data[AGENTS][id_str][FIRST] = entry->mFirstName;
 			data[AGENTS][id_str][LAST] = entry->mLastName;
 			data[AGENTS][id_str][CTIME] = (S32)entry->mCreateTime;
 		}
-		else if(entry->mIsGroup && entry->mGroupName[0])
+		else if(entry->mIsGroup && !entry->mGroupName.empty())
 		{
 			data[GROUPS][id_str][NAME] = entry->mGroupName;
 			data[GROUPS][id_str][CTIME] = (S32)entry->mCreateTime;
@@ -534,16 +524,6 @@ BOOL LLCacheName::getFullName(const LLUUID& id, std::string& fullname)
 	return res;
 }
 
-// *TODO: Deprecate
-BOOL LLCacheName::getName(const LLUUID& id, char* first, char* last)
-{
-	std::string first_name, last_name;
-	BOOL res = getName(id, first_name, last_name);
-	strcpy(first, first_name.c_str());
-	strcpy(last, last_name.c_str());
-	return res;
-}
-
 BOOL LLCacheName::getGroupName(const LLUUID& id, std::string& group)
 {
 	if(id.isNull())
@@ -553,7 +533,7 @@ BOOL LLCacheName::getGroupName(const LLUUID& id, std::string& group)
 	}
 
 	LLCacheNameEntry* entry = get_ptr_in_map(impl.mCache,id);
-	if (entry && !entry->mGroupName[0])
+	if (entry && entry->mGroupName.empty())
 	{
 		// COUNTER-HACK to combat James' HACK in exportFile()...
 		// this group name was loaded from a name cache that did not
@@ -578,16 +558,6 @@ BOOL LLCacheName::getGroupName(const LLUUID& id, std::string& group)
 	}
 }
 
-// *TODO: Deprecate
-BOOL LLCacheName::getGroupName(const LLUUID& id, char* group)
-{
-	std::string group_name;
-	BOOL res = getGroupName(id, group_name);
-	strcpy(group, group_name.c_str());
-	return res;
-}
-
-
 // TODO: Make the cache name callback take a SINGLE std::string,
 // not a separate first and last name.
 void LLCacheName::get(const LLUUID& id, BOOL is_group, LLCacheNameCallback callback, void* user_data)
@@ -716,9 +686,9 @@ void LLCacheName::dumpStats()
 }
 
 //static 
-LLString LLCacheName::getDefaultName()
+std::string LLCacheName::getDefaultName()
 {
-	return LLString(CN_WAITING);
+	return CN_WAITING;
 }
 
 void LLCacheName::Impl::processPendingAsks()
@@ -813,7 +783,7 @@ void LLCacheName::Impl::sendRequest(
 }
 
 void LLCacheName::Impl::notifyObservers(const LLUUID& id,
-	const char* first, const char* last, BOOL is_group)
+	const std::string& first, const std::string& last, BOOL is_group)
 {
 	for (Observers::const_iterator i = mObservers.begin(),
 								   end = mObservers.end();
@@ -917,19 +887,17 @@ void LLCacheName::Impl::processUUIDReply(LLMessageSystem* msg, bool isGroup)
 		entry->mCreateTime = (U32)time(NULL);
 		if (!isGroup)
 		{
-			msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_FirstName, DB_FIRST_NAME_BUF_SIZE, entry->mFirstName, i);
-			msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_LastName,  DB_LAST_NAME_BUF_SIZE, entry->mLastName, i);
+			msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_FirstName, entry->mFirstName, i);
+			msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_LastName,  entry->mLastName, i);
 		}
 		else
 		{
-			msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_GroupName, DB_GROUP_NAME_BUF_SIZE, entry->mGroupName, i);
+			msg->getStringFast(_PREHASH_UUIDNameBlock, _PREHASH_GroupName, entry->mGroupName, i);
 		}
 
 		if (!isGroup)
 		{
-			notifyObservers(id,
-							entry->mFirstName, entry->mLastName,
-							FALSE);
+			notifyObservers(id, entry->mFirstName, entry->mLastName, FALSE);
 		}
 		else
 		{
diff --git a/indra/llmessage/llcachename.h b/indra/llmessage/llcachename.h
index 5dfde80622..879eb5fadb 100644
--- a/indra/llmessage/llcachename.h
+++ b/indra/llmessage/llcachename.h
@@ -37,7 +37,7 @@ class LLHost;
 class LLUUID;
 
 // agent_id/group_id, first_name, last_name, is_group, user_data
-typedef void (*LLCacheNameCallback)(const LLUUID&, const char*, const char*, BOOL, void*);
+typedef void (*LLCacheNameCallback)(const LLUUID&, const std::string&, const std::string&, BOOL, void*);
 
 // Here's the theory:
 // If you request a name that isn't in the cache, it returns "waiting"
@@ -75,7 +75,6 @@ public:
 	// last must be at least DB_LAST_NAME_BUF_SIZE characters.
 	// If not available, copies the string "waiting".
 	// Returns TRUE iff available.
-	BOOL getName(const LLUUID& id, char* first, char* last);
 	BOOL getName(const LLUUID& id, std::string& first, std::string& last);
 	BOOL getFullName(const LLUUID& id, std::string& fullname);
 	
@@ -83,7 +82,6 @@ public:
 	// provided. The caller must allocate at least
 	// DB_GROUP_NAME_BUF_SIZE characters. If not available, this
 	// method copies the string "waiting". Returns TRUE iff available.
-	BOOL getGroupName(const LLUUID& id, char* group);
 	BOOL getGroupName(const LLUUID& id, std::string& group);
 
 	// Call the callback with the group or avatar name.
@@ -107,7 +105,7 @@ public:
 	void dump();		// Dumps the contents of the cache
 	void dumpStats();	// Dumps the sizes of the cache and associated queues.
 
-	static LLString getDefaultName();
+	static std::string getDefaultName();
 
 private:
 
diff --git a/indra/llmessage/llcircuit.cpp b/indra/llmessage/llcircuit.cpp
index 0db9f8e2f1..431fe802f6 100644
--- a/indra/llmessage/llcircuit.cpp
+++ b/indra/llmessage/llcircuit.cpp
@@ -184,7 +184,7 @@ LLCircuitData::~LLCircuitData()
 		std::ostream_iterator<TPACKETID> append(str, " ");
 		str << "MSG: -> " << mHost << "\tABORTING RELIABLE:\t";
 		std::copy(doomed.begin(), doomed.end(), append);
-		llinfos << str.str().c_str() << llendl;
+		llinfos << str.str() << llendl;
 	}
 }
 
@@ -204,7 +204,7 @@ void LLCircuitData::ackReliablePacket(TPACKETID packet_num)
 			std::ostringstream str;
 			str << "MSG: <- " << packetp->mHost << "\tRELIABLE ACKED:\t"
 				<< packetp->mPacketID;
-			llinfos << str.str().c_str() << llendl;
+			llinfos << str.str() << llendl;
 		}
 		if (packetp->mCallback)
 		{
@@ -238,7 +238,7 @@ void LLCircuitData::ackReliablePacket(TPACKETID packet_num)
 			std::ostringstream str;
 			str << "MSG: <- " << packetp->mHost << "\tRELIABLE ACKED:\t"
 				<< packetp->mPacketID;
-			llinfos << str.str().c_str() << llendl;
+			llinfos << str.str() << llendl;
 		}
 		if (packetp->mCallback)
 		{
@@ -342,7 +342,7 @@ S32 LLCircuitData::resendUnackedPackets(const F64 now)
 				std::ostringstream str;
 				str << "MSG: -> " << packetp->mHost
 					<< "\tRESENDING RELIABLE:\t" << packetp->mPacketID;
-				llinfos << str.str().c_str() << llendl;
+				llinfos << str.str() << llendl;
 			}
 
 			packetp->mBuffer[0] |= LL_RESENT_FLAG;  // tag packet id as being a resend	
@@ -403,7 +403,7 @@ S32 LLCircuitData::resendUnackedPackets(const F64 now)
 				std::ostringstream str;
 				str << "MSG: -> " << packetp->mHost << "\tABORTING RELIABLE:\t"
 					<< packetp->mPacketID;
-				llinfos << str.str().c_str() << llendl;
+				llinfos << str.str() << llendl;
 			}
 
 			if (packetp->mCallback)
@@ -710,7 +710,7 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 			{
 				std::ostringstream str;
 				str << "MSG: <- " << mHost << "\tRECOVERING LOST:\t" << id;
-				llinfos << str.str().c_str() << llendl;
+				llinfos << str.str() << llendl;
 			}
 			//			llinfos << "removing potential lost: " << id << llendl;
 			mPotentialLostPackets.erase(id);
@@ -729,7 +729,7 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 						std::ostringstream str;
 						str << "MSG: <- " << mHost << "\tPACKET GAP:\t"
 							<< index;
-						llinfos << str.str().c_str() << llendl;
+						llinfos << str.str() << llendl;
 					}
 
 //						llinfos << "adding potential lost: " << index << llendl;
@@ -747,7 +747,7 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 					std::ostringstream str;
 					str << "MSG: <- " << mHost << "\tPACKET GAP:\t"
 						<< id << " expected " << index;
-					llinfos << str.str().c_str() << llendl;
+					llinfos << str.str() << llendl;
 				}
 			}
 				
@@ -969,7 +969,7 @@ BOOL LLCircuitData::updateWatchDogTimers(LLMessageSystem *msgsys)
 				std::ostringstream str;
 				str << "MSG: <- " << mHost << "\tLOST PACKET:\t"
 					<< (*it).first;
-				llinfos << str.str().c_str() << llendl;
+				llinfos << str.str() << llendl;
 			}
 			mPotentialLostPackets.erase(it++);
 		}
@@ -1114,7 +1114,7 @@ void LLCircuit::sendAcks()
 				str << "MSG: -> " << cd->mHost << "\tPACKET ACKS:\t";
 				std::ostream_iterator<TPACKETID> append(str, " ");
 				std::copy(cd->mAcks.begin(), cd->mAcks.end(), append);
-				llinfos << str.str().c_str() << llendl;
+				llinfos << str.str() << llendl;
 			}
 
 			// empty out the acks list
diff --git a/indra/llmessage/lldatapacker.cpp b/indra/llmessage/lldatapacker.cpp
index 2ebd1b7176..83fb0b85cd 100644
--- a/indra/llmessage/lldatapacker.cpp
+++ b/indra/llmessage/lldatapacker.cpp
@@ -170,16 +170,16 @@ BOOL LLDataPacker::unpackFixed(F32 &value, const char *name,
 // LLDataPackerBinaryBuffer implementation
 //---------------------------------------------------------------------------
 
-BOOL LLDataPackerBinaryBuffer::packString(const char *value, const char *name)
+BOOL LLDataPackerBinaryBuffer::packString(const std::string& value, const char *name)
 {
 	BOOL success = TRUE;
-	S32 length = (S32)strlen(value) + 1; /*Flawfinder: ignore*/
+	S32 length = value.length()+1;
 
 	success &= verifyLength(length, name);
 
 	if (mWriteEnabled) 
 	{
-		htonmemcpy(mCurBufferp, value, MVT_VARIABLE, length);  
+		htonmemcpy(mCurBufferp, value.c_str(), MVT_VARIABLE, length);  
 	}
 	mCurBufferp += length;
 	return success;
@@ -577,18 +577,18 @@ void LLDataPackerBinaryBuffer::dumpBufferToLog()
 //---------------------------------------------------------------------------
 // LLDataPackerAsciiBuffer implementation
 //---------------------------------------------------------------------------
-BOOL LLDataPackerAsciiBuffer::packString(const char *value, const char *name)
+BOOL LLDataPackerAsciiBuffer::packString(const std::string& value, const char *name)
 {
 	BOOL success = TRUE;
 	writeIndentedName(name);
 	int numCopied = 0;
 	if (mWriteEnabled) 
 	{
-		numCopied = snprintf(mCurBufferp,getBufferSize()-getCurrentSize(),"%s\n", value);		/* Flawfinder: ignore */
+		numCopied = snprintf(mCurBufferp,getBufferSize()-getCurrentSize(),"%s\n", value.c_str());		/* Flawfinder: ignore */
 	}
 	else
 	{
-		numCopied = (S32)strlen(value) + 1; /*Flawfinder: ignore*/
+		numCopied = value.length() + 1; /*Flawfinder: ignore*/
 	}
 
 	// snprintf returns number of bytes that would have been written
@@ -1242,9 +1242,9 @@ BOOL LLDataPackerAsciiBuffer::packUUID(const LLUUID &value, const char *name)
 	int numCopied = 0;
 	if (mWriteEnabled)
 	{
-		char tmp_str[64]; /* Flawfinder: ignore */ 
+		std::string tmp_str;
 		value.toString(tmp_str);
-	    	numCopied = snprintf(mCurBufferp,getBufferSize()-getCurrentSize(),"%s\n", tmp_str);	/* Flawfinder: ignore */
+		numCopied = snprintf(mCurBufferp,getBufferSize()-getCurrentSize(),"%s\n", tmp_str.c_str());	/* Flawfinder: ignore */
 	}
 	else
 	{
@@ -1376,13 +1376,13 @@ std::string convertF32ToString(F32 val)
 //---------------------------------------------------------------------------
 // LLDataPackerAsciiFile implementation
 //---------------------------------------------------------------------------
-BOOL LLDataPackerAsciiFile::packString(const char *value, const char *name)
+BOOL LLDataPackerAsciiFile::packString(const std::string& value, const char *name)
 {
 	BOOL success = TRUE;
 	writeIndentedName(name);
 	if (mFP)
 	{
-		fprintf(mFP,"%s\n", value);	
+		fprintf(mFP,"%s\n", value.c_str());	
 	}
 	else if (mOutputStream)
 	{
@@ -1829,11 +1829,11 @@ BOOL LLDataPackerAsciiFile::packUUID(const LLUUID &value, const char *name)
 {
 	BOOL success = TRUE;
 	writeIndentedName(name);
-	char tmp_str[64]; /*Flawfinder: ignore */
+	std::string tmp_str;
 	value.toString(tmp_str);
 	if (mFP)
 	{
-		fprintf(mFP,"%s\n", tmp_str);
+		fprintf(mFP,"%s\n", tmp_str.c_str());
 	}
 	else if (mOutputStream)
 	{
@@ -1877,7 +1877,7 @@ void LLDataPackerAsciiFile::writeIndentedName(const char *name)
 	}
 	else if (mOutputStream)
 	{
-		*mOutputStream << indent_buf.c_str() << name << "\t";
+		*mOutputStream << indent_buf << name << "\t";
 	}
 }
 
diff --git a/indra/llmessage/lldatapacker.h b/indra/llmessage/lldatapacker.h
index d6d1f5c1da..eac70e8c78 100644
--- a/indra/llmessage/lldatapacker.h
+++ b/indra/llmessage/lldatapacker.h
@@ -49,7 +49,7 @@ public:
 
 	virtual BOOL		hasNext() const = 0;
 
-	virtual BOOL		packString(const char *value, const char *name) = 0;
+	virtual BOOL		packString(const std::string& value, const char *name) = 0;
 	virtual BOOL		unpackString(std::string& value, const char *name) = 0;
 
 	virtual BOOL		packBinaryData(const U8 *value, S32 size, const char *name) = 0;
@@ -127,7 +127,7 @@ public:
 	{
 	}
 
-	/*virtual*/ BOOL		packString(const char *value, const char *name);
+	/*virtual*/ BOOL		packString(const std::string& value, const char *name);
 	/*virtual*/ BOOL		unpackString(std::string& value, const char *name);
 
 	/*virtual*/ BOOL		packBinaryData(const U8 *value, S32 size, const char *name);
@@ -229,7 +229,7 @@ public:
 		mWriteEnabled = FALSE;
 	}
 
-	/*virtual*/ BOOL		packString(const char *value, const char *name);
+	/*virtual*/ BOOL		packString(const std::string& value, const char *name);
 	/*virtual*/ BOOL		unpackString(std::string& value, const char *name);
 
 	/*virtual*/ BOOL		packBinaryData(const U8 *value, S32 size, const char *name);
@@ -358,7 +358,7 @@ public:
 	{
 	}
 
-	/*virtual*/ BOOL		packString(const char *value, const char *name);
+	/*virtual*/ BOOL		packString(const std::string& value, const char *name);
 	/*virtual*/ BOOL		unpackString(std::string& value, const char *name);
 
 	/*virtual*/ BOOL		packBinaryData(const U8 *value, S32 size, const char *name);
diff --git a/indra/llmessage/lldispatcher.cpp b/indra/llmessage/lldispatcher.cpp
index d0e1e68b8a..64bfb04ea7 100644
--- a/indra/llmessage/lldispatcher.cpp
+++ b/indra/llmessage/lldispatcher.cpp
@@ -111,8 +111,7 @@ bool LLDispatcher::unpackMessage(
 		LLDispatcher::sparam_t& parameters)
 {
 	char buf[MAX_STRING];	/*Flawfinder: ignore*/
-	msg->getStringFast(_PREHASH_MethodData, _PREHASH_Method, MAX_STRING, buf);
-	method.assign(buf);
+	msg->getStringFast(_PREHASH_MethodData, _PREHASH_Method, method);
 	msg->getUUIDFast(_PREHASH_MethodData, _PREHASH_Invoice, invoice);
 	S32 size;
 	S32 count = msg->getNumberOfBlocksFast(_PREHASH_ParamList);
diff --git a/indra/llmessage/llhost.cpp b/indra/llmessage/llhost.cpp
index 4d10f06051..48666ffde7 100644
--- a/indra/llmessage/llhost.cpp
+++ b/indra/llmessage/llhost.cpp
@@ -66,34 +66,15 @@ LLHost::LLHost(const std::string& ip_and_port)
 	}
 }
 
-void LLHost::getString(char* buffer, S32 length) const
+std::string LLHost::getString() const
 {
-	if (((U32) length) < MAXADDRSTR + 1 + 5)
-	{
-		llerrs << "LLHost::getString - string too short" << llendl;
-		return;
-	}
-
-	snprintf(buffer, length, "%s:%u", u32_to_ip_string(mIP), mPort); 	/* Flawfinder: ignore */
-}
-
-void LLHost::getIPString(char* buffer, S32 length) const
-{
-	if ( ((U32) length) < MAXADDRSTR)
-	{
-		llerrs << "LLHost::getIPString - string too short" << llendl;
-		return;
-	}
-
-	snprintf(buffer, length, "%s", u32_to_ip_string(mIP));	/* Flawfinder: ignore */
+	return llformat("%s:%u", u32_to_ip_string(mIP), mPort);
 }
 
 
 std::string LLHost::getIPandPort() const
 {
-	char buffer[MAXADDRSTR + 1 + 5];	/*Flawfinder: ignore*/
-	getString(buffer, sizeof(buffer));
-	return buffer;
+	return getString();
 }
 
 
@@ -103,35 +84,6 @@ std::string LLHost::getIPString() const
 }
 
 
-void LLHost::getHostName(char *buf, S32 len) const
-{
-	hostent *he;
-
-	if (INVALID_HOST_IP_ADDRESS == mIP)
-	{
-		llwarns << "LLHost::getHostName() : Invalid IP address" << llendl;
-		buf[0] = '\0';
-		return;
-	}
-	he = gethostbyaddr((char *)&mIP, sizeof(mIP), AF_INET);
-	if (!he)
-	{
-#if LL_WINDOWS
-		llwarns << "LLHost::getHostName() : Couldn't find host name for address " << mIP << ", Error: " 
-			<< WSAGetLastError() << llendl;
-#else
-		llwarns << "LLHost::getHostName() : Couldn't find host name for address " << mIP << ", Error: " 
-			<< h_errno << llendl;
-#endif
-		buf[0] = '\0';						
-	}
-	else
-	{
-		strncpy(buf, he->h_name, len); /*Flawfinder: ignore*/
-		buf[len-1] = '\0';
-	}
-}
-
 std::string LLHost::getHostName() const
 {
 	hostent* he;
@@ -158,28 +110,20 @@ std::string LLHost::getHostName() const
 	}
 }
 
-BOOL LLHost::setHostByName(const char *string)
+BOOL LLHost::setHostByName(const std::string& hostname)
 {
 	hostent *he;
-	char local_name[MAX_STRING];  /*Flawfinder: ignore*/
-
-	if (strlen(string)+1 > MAX_STRING) /*Flawfinder: ignore*/
-	{
-		llerrs << "LLHost::setHostByName() : Address string is too long: " 
-			<< string << llendl;
-	}
+	std::string local_name(hostname);
 
-	strncpy(local_name, string,MAX_STRING);  /*Flawfinder: ignore*/
-	local_name[MAX_STRING-1] = '\0';
 #if LL_WINDOWS
 	// We may need an equivalent for Linux, but not sure - djs
-	_strupr(local_name);
+	LLStringUtil::toUpper(local_name);
 #endif
 
-	he = gethostbyname(local_name);	
+	he = gethostbyname(local_name.c_str());	
 	if(!he) 
 	{
-		U32 ip_address = inet_addr(string);
+		U32 ip_address = inet_addr(hostname.c_str());
 		he = gethostbyaddr((char *)&ip_address, sizeof(ip_address), AF_INET);
 	}
 
diff --git a/indra/llmessage/llhost.h b/indra/llmessage/llhost.h
index a865ad616c..516150540f 100644
--- a/indra/llmessage/llhost.h
+++ b/indra/llmessage/llhost.h
@@ -61,10 +61,10 @@ public:
 		mIP = ipv4_addr;
 	}
 
-	LLHost( const char *ipv4_addr, U32 port )
+	LLHost( const std::string& ipv4_addr, U32 port )
 	:	mPort( port )
 	{ 
-		mIP = ip_string_to_u32(ipv4_addr);
+		mIP = ip_string_to_u32(ipv4_addr.c_str());
 	}
 
 	explicit LLHost(const U64 ip_port)
@@ -82,11 +82,11 @@ public:
 
 	// MANIPULATORS
 	void	set( U32 ip, U32 port )				{ mIP = ip; mPort = port; }
-	void	set( const char* ipstr, U32 port )	{ mIP = ip_string_to_u32(ipstr); mPort = port; }
-	void	setAddress( const char* ipstr )		{ mIP = ip_string_to_u32(ipstr); }
+	void	set( const std::string& ipstr, U32 port )	{ mIP = ip_string_to_u32(ipstr.c_str()); mPort = port; }
+	void	setAddress( const std::string& ipstr )		{ mIP = ip_string_to_u32(ipstr.c_str()); }
 	void	setAddress( U32 ip )				{ mIP = ip; }
 	void	setPort( U32 port )					{ mPort = port; }
-	BOOL    setHostByName(const char *hname);
+	BOOL    setHostByName(const std::string& hname);
 
 	LLHost&	operator=(const LLHost &rhs);
 	void    invalidate()                        { mIP = INVALID_HOST_IP_ADDRESS; mPort = INVALID_PORT;};
@@ -96,10 +96,8 @@ public:
 	U32		getPort() const								{ return mPort; }
 	BOOL	isOk() const								{ return (mIP != INVALID_HOST_IP_ADDRESS) && (mPort != INVALID_PORT); }
 	size_t	hash() const								{ return (mIP << 16) | (mPort & 0xffff); }
-	void	getString(char* buffer, S32 length) const;	    // writes IP:port into buffer
-	void	getIPString(char* buffer, S32 length) const;	// writes IP into buffer
+	std::string getString() const;
 	std::string getIPString() const;
-	void    getHostName(char *buf, S32 len) const;
 	std::string getHostName() const;
 	std::string getIPandPort() const;
 
diff --git a/indra/llmessage/llhttpassetstorage.cpp b/indra/llmessage/llhttpassetstorage.cpp
index e5254bbc0f..6332c247a9 100644
--- a/indra/llmessage/llhttpassetstorage.cpp
+++ b/indra/llmessage/llhttpassetstorage.cpp
@@ -81,8 +81,8 @@ class LLHTTPAssetRequest : public LLAssetRequest
 {
 public:
 	LLHTTPAssetRequest(LLHTTPAssetStorage *asp, const LLUUID &uuid, 
-					LLAssetType::EType type, LLAssetStorage::ERequestType rt,
-					const char *url, CURLM *curl_multi);
+					   LLAssetType::EType type, LLAssetStorage::ERequestType rt,
+					   const std::string& url, CURLM *curl_multi);
 	virtual ~LLHTTPAssetRequest();
 	
 	void setupCurlHandle();
@@ -103,7 +103,7 @@ public:
 
 	CURL  *mCurlHandle;
 	CURLM *mCurlMultiHandle;
-	char  *mURLBuffer;
+	std::string mURLBuffer;
 	struct curl_slist *mHTTPHeaders;
 	LLVFile *mVFile;
 	LLUUID  mTmpUUID;
@@ -122,7 +122,7 @@ LLHTTPAssetRequest::LLHTTPAssetRequest(LLHTTPAssetStorage *asp,
 						const LLUUID &uuid, 
 						LLAssetType::EType type, 
 						LLAssetStorage::ERequestType rt,
-						const char *url, 
+						const std::string& url, 
 						CURLM *curl_multi)
 	: LLAssetRequest(uuid, type),
 	mZInitialized(false)
@@ -137,11 +137,7 @@ LLHTTPAssetRequest::LLHTTPAssetRequest(LLHTTPAssetStorage *asp,
 	mZInputBuffer = NULL;
 	mZInputExhausted = false;
 	
-	mURLBuffer = new char[strlen(url) + 1]; /*Flawfinder: ignore*/
-	if (mURLBuffer)
-	{
-	    strcpy(mURLBuffer, url);	/*Flawfinder: ignore*/
-	}
+	mURLBuffer = url;
 }
 
 LLHTTPAssetRequest::~LLHTTPAssetRequest()
@@ -156,7 +152,6 @@ LLHTTPAssetRequest::~LLHTTPAssetRequest()
 	{
 		curl_slist_free_all(mHTTPHeaders);
 	}
-	delete[] mURLBuffer;
 	delete   mVFile;
 	finishCompressedUpload();
 }
@@ -242,7 +237,7 @@ void LLHTTPAssetRequest::setupCurlHandle()
 	mCurlHandle = curl_easy_init();
 	curl_easy_setopt(mCurlHandle, CURLOPT_NOSIGNAL, 1);
 	curl_easy_setopt(mCurlHandle, CURLOPT_NOPROGRESS, 1);
-	curl_easy_setopt(mCurlHandle, CURLOPT_URL, mURLBuffer);
+	curl_easy_setopt(mCurlHandle, CURLOPT_URL, mURLBuffer.c_str());
 	curl_easy_setopt(mCurlHandle, CURLOPT_PRIVATE, this);
 	if (LLAssetStorage::RT_DOWNLOAD == mRequestType)
 	{
@@ -400,9 +395,9 @@ size_t LLHTTPAssetRequest::curlCompressedUploadCallback(
 
 LLHTTPAssetStorage::LLHTTPAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
 									 LLVFS *vfs, const LLHost &upstream_host,
-									 const char *web_host,
-									 const char *local_web_host,
-									 const char *host_name)
+									 const std::string& web_host,
+									 const std::string& local_web_host,
+									 const std::string& host_name)
 	: LLAssetStorage(msg, xfer, vfs, upstream_host)
 {
 	_init(web_host, local_web_host, host_name);
@@ -410,15 +405,15 @@ LLHTTPAssetStorage::LLHTTPAssetStorage(LLMessageSystem *msg, LLXferManager *xfer
 
 LLHTTPAssetStorage::LLHTTPAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
 									   LLVFS *vfs,
-									   const char *web_host,
-									   const char *local_web_host,
-									   const char *host_name)
+									   const std::string& web_host,
+									   const std::string& local_web_host,
+									   const std::string& host_name)
 	: LLAssetStorage(msg, xfer, vfs)
 {
 	_init(web_host, local_web_host, host_name);
 }
 
-void LLHTTPAssetStorage::_init(const char *web_host, const char *local_web_host, const char* host_name)
+void LLHTTPAssetStorage::_init(const std::string& web_host, const std::string& local_web_host, const std::string& host_name)
 {
 	mBaseURL = web_host;
 	mLocalBaseURL = local_web_host;
@@ -470,7 +465,7 @@ void LLHTTPAssetStorage::storeAssetData(
 		{
 			message = "Added to upload queue";
 		}
-		reportMetric( uuid, type, NULL, requesting_agent_id, size, MR_OKAY, __FILE__, __LINE__, message );
+		reportMetric( uuid, type, LLStringUtil::null, requesting_agent_id, size, MR_OKAY, __FILE__, __LINE__, message );
 
 		// this will get picked up and transmitted in checkForTimeouts
 		if(store_local)
@@ -492,7 +487,7 @@ void LLHTTPAssetStorage::storeAssetData(
 		if (callback)
 		{
 			// LLAssetStorage metric: Zero size VFS
-			reportMetric( uuid, type, NULL, requesting_agent_id, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );
+			reportMetric( uuid, type, LLStringUtil::null, requesting_agent_id, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );
 			callback(uuid, user_data,  LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LL_EXSTAT_NONEXISTENT_FILE);
 		}
 	}
@@ -500,7 +495,7 @@ void LLHTTPAssetStorage::storeAssetData(
 
 // virtual
 void LLHTTPAssetStorage::storeAssetData(
-	const char* filename,
+	const std::string& filename,
 	const LLUUID& asset_id,
 	LLAssetType::EType asset_type,
 	LLStoreAssetCallback callback,
@@ -597,7 +592,7 @@ LLSD LLHTTPAssetStorage::getPendingDetails(LLAssetStorage::ERequestType rt,
 			LLSD& pending = sd["requests"][i];
 			// See if this pending request is running.
 			const LLAssetRequest* req = findRequest(running, 
-									LLAssetType::lookup(pending["type"].asString().c_str()),
+									LLAssetType::lookup(pending["type"].asString()),
 									pending["asset_id"]);
 			if (req)
 			{
@@ -768,11 +763,11 @@ void LLHTTPAssetStorage::checkForTimeouts()
 		// Setup this curl download request
 		// We need to generate a new request here
 		// since the one in the list could go away
-		char tmp_url[MAX_STRING]; /*Flawfinder: ignore*/
-		char uuid_str[UUID_STR_LENGTH]; /*Flawfinder: ignore*/
+		std::string tmp_url;
+		std::string uuid_str;
 		req->getUUID().toString(uuid_str);
 		std::string base_url = getBaseURL(req->getUUID(), req->getType());
-		snprintf(tmp_url, sizeof(tmp_url), "%s/%36s.%s", base_url.c_str() , uuid_str, LLAssetType::lookup(req->getType()));	/* Flawfinder: ignore */
+		tmp_url = llformat("%s/%36s.%s", base_url.c_str() , uuid_str.c_str(), LLAssetType::lookup(req->getType()));
 
 		LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), 
 										req->getType(), RT_DOWNLOAD, tmp_url, mCurlMultiHandle);
@@ -805,12 +800,11 @@ void LLHTTPAssetStorage::checkForTimeouts()
 
 		bool do_compress = req->getType() == LLAssetType::AT_OBJECT;
 
-		char tmp_url[MAX_STRING];/*Flawfinder: ignore*/
-		char uuid_str[UUID_STR_LENGTH];/*Flawfinder: ignore*/
+		std::string tmp_url;
+		std::string uuid_str;
 		req->getUUID().toString(uuid_str);
-		snprintf(tmp_url, sizeof(tmp_url), 					/* Flawfinder: ignore */
-				do_compress ? "%s/%s.%s.gz" : "%s/%s.%s",
-				mBaseURL.c_str(), uuid_str, LLAssetType::lookup(req->getType())); 
+		tmp_url = mBaseURL + "/" + uuid_str + "." + LLAssetType::lookup(req->getType());
+		if (do_compress) tmp_url += ".gz";
 
 		LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), 
 									req->getType(), RT_UPLOAD, tmp_url, mCurlMultiHandle);
@@ -876,12 +870,12 @@ void LLHTTPAssetStorage::checkForTimeouts()
 		// setup this curl upload request
 		LLVFile file(mVFS, req->getUUID(), req->getType());
 
-		char tmp_url[MAX_STRING]; /*Flawfinder: ignore*/
-		char uuid_str[UUID_STR_LENGTH]; /*Flawfinder: ignore*/
+		std::string tmp_url;
+		std::string uuid_str;
 		req->getUUID().toString(uuid_str);
 		
 		// KLW - All temporary uploads are saved locally "http://localhost:12041/asset"
-		snprintf(tmp_url, sizeof(tmp_url), "%s/%36s.%s", mLocalBaseURL.c_str(), uuid_str, LLAssetType::lookup(req->getType())); 	/* Flawfinder: ignore */
+		tmp_url = llformat("%s/%36s.%s", mLocalBaseURL.c_str(), uuid_str.c_str(), LLAssetType::lookup(req->getType()));
 
 		LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), 
 										req->getType(), RT_LOCALUPLOAD, tmp_url, mCurlMultiHandle);
@@ -1160,7 +1154,7 @@ size_t LLHTTPAssetStorage::nullOutputCallback(void *data, size_t size, size_t nm
 
 // blocking asset fetch which bypasses the VFS
 // this is a very limited function for use by the simstate loader and other one-offs
-S32 LLHTTPAssetStorage::getURLToFile(const LLUUID& uuid, LLAssetType::EType asset_type, const LLString &url, const char *filename, progress_callback callback, void *userdata)
+S32 LLHTTPAssetStorage::getURLToFile(const LLUUID& uuid, LLAssetType::EType asset_type, const std::string &url, const std::string& filename, progress_callback callback, void *userdata)
 {
 	// *NOTE: There is no guarantee that the uuid and the asset_type match
 	// - not that it matters. - Doug
@@ -1174,7 +1168,7 @@ S32 LLHTTPAssetStorage::getURLToFile(const LLUUID& uuid, LLAssetType::EType asse
 	}
 
 	// make sure we use the normal curl setup, even though we don't really need a request object
-	LLHTTPAssetRequest req(this, uuid, asset_type, RT_DOWNLOAD, url.c_str(), mCurlMultiHandle);
+	LLHTTPAssetRequest req(this, uuid, asset_type, RT_DOWNLOAD, url, mCurlMultiHandle);
 	req.mFP = fp;
 	
 	req.setupCurlHandle();
diff --git a/indra/llmessage/llhttpassetstorage.h b/indra/llmessage/llhttpassetstorage.h
index e6ec39e27e..91876eb969 100644
--- a/indra/llmessage/llhttpassetstorage.h
+++ b/indra/llmessage/llhttpassetstorage.h
@@ -48,15 +48,15 @@ class LLHTTPAssetStorage : public LLAssetStorage
 public:
 	LLHTTPAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
 					   LLVFS *vfs, const LLHost &upstream_host,
-					   const char *web_host,
-					   const char *local_web_host,
-					   const char *host_name);
+					   const std::string& web_host,
+					   const std::string& local_web_host,
+					   const std::string& host_name);
 
 	LLHTTPAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
 					   LLVFS *vfs,
-					   const char *web_host,
-					   const char *local_web_host,
-					   const char *host_name);
+					   const std::string& web_host,
+					   const std::string& local_web_host,
+					   const std::string& host_name);
 
 
 	virtual ~LLHTTPAssetStorage();
@@ -74,7 +74,7 @@ public:
 		F64 timeout=LL_ASSET_STORAGE_TIMEOUT);
 
 	virtual void storeAssetData(
-		const char* filename,
+		const std::string& filename,
 		const LLUUID& asset_id,
 		LLAssetType::EType atype,
 		LLStoreAssetCallback callback,
@@ -99,7 +99,7 @@ public:
 	// Hack.  One off curl download an URL to a file.  Probably should be elsewhere.
 	// Only used by lldynamicstate.  The API is broken, and should be replaced with
 	// a generic HTTP file fetch - Doug 9/25/06
-	S32 getURLToFile(const LLUUID& uuid, LLAssetType::EType asset_type, const LLString &url, const char *filename, progress_callback callback, void *userdata);
+	S32 getURLToFile(const LLUUID& uuid, LLAssetType::EType asset_type, const std::string &url, const std::string& filename, progress_callback callback, void *userdata);
 	
 	LLAssetRequest* findNextRequest(request_list_t& pending, request_list_t& running);
 
@@ -135,7 +135,7 @@ protected:
 						   void *user_data, BOOL duplicate, BOOL is_priority);
 
 private:
-	void _init(const char *web_host, const char *local_web_host, const char* host_name);
+	void _init(const std::string& web_host, const std::string& local_web_host, const std::string& host_name);
 
 	// This will return the correct base URI for any http asset request
 	std::string getBaseURL(const LLUUID& asset_id, LLAssetType::EType asset_type);
diff --git a/indra/llmessage/llhttpclient.cpp b/indra/llmessage/llhttpclient.cpp
index 52cb8fe1c3..2937edd853 100644
--- a/indra/llmessage/llhttpclient.cpp
+++ b/indra/llmessage/llhttpclient.cpp
@@ -152,7 +152,7 @@ namespace
 		{
 			LLBufferStream ostream(channels, buffer.get());
 
-			llifstream fstream(mFilename.c_str(), std::iostream::binary | std::iostream::out);
+			llifstream fstream(mFilename, std::iostream::binary | std::iostream::out);
             fstream.seekg(0, std::ios::end);
             U32 fileSize = fstream.tellg();
             fstream.seekg(0, std::ios::beg);
diff --git a/indra/llmessage/llhttpsender.cpp b/indra/llmessage/llhttpsender.cpp
index 096bc73e0b..6e86947e6a 100644
--- a/indra/llmessage/llhttpsender.cpp
+++ b/indra/llmessage/llhttpsender.cpp
@@ -52,7 +52,7 @@ LLHTTPSender::~LLHTTPSender()
 }
 
 //virtual 
-void LLHTTPSender::send(const LLHost& host, const char* name, 
+void LLHTTPSender::send(const LLHost& host, const std::string& name, 
 						const LLSD& body, 
 						LLHTTPClient::ResponderPtr response) const
 {
diff --git a/indra/llmessage/llhttpsender.h b/indra/llmessage/llhttpsender.h
index 3a6cd681fa..e555b4485c 100644
--- a/indra/llmessage/llhttpsender.h
+++ b/indra/llmessage/llhttpsender.h
@@ -45,7 +45,7 @@ class LLHTTPSender
 
 	/** @brief Send message to host with body, call response when done */ 
 	virtual void send(const LLHost& host, 
-					  const char* message, const LLSD& body, 
+					  const std::string& message, const LLSD& body, 
 					  LLHTTPClient::ResponderPtr response) const;
 
 	/** @brief Set sender for host, takes ownership of sender. */
diff --git a/indra/llmessage/llinstantmessage.cpp b/indra/llmessage/llinstantmessage.cpp
index 04af44fe26..a7fac2dfc3 100644
--- a/indra/llmessage/llinstantmessage.cpp
+++ b/indra/llmessage/llinstantmessage.cpp
@@ -59,7 +59,7 @@ const S32 VOTE_UNANIMOUS = 2;
 const char EMPTY_BINARY_BUCKET[] = "";
 const S32 EMPTY_BINARY_BUCKET_SIZE = 1;
 const U32 NO_TIMESTAMP = 0;
-const char SYSTEM_FROM[] = "Second Life";
+const std::string SYSTEM_FROM("Second Life");
 const S32 IM_TTL = 1;
 
 
@@ -144,8 +144,8 @@ void LLIMInfo::packMessageBlock(LLMessageSystem* msg) const
 		mFromGroup,
 		LLUUID::null,
 		mToID,
-		mName.c_str(),
-		mMessage.c_str(),
+		mName,
+		mMessage,
 		mOffline,
 		mIMType,
 		mID,
@@ -163,8 +163,8 @@ void pack_instant_message(
 	BOOL from_group,
 	const LLUUID& session_id,
 	const LLUUID& to_id,
-	const char* name,
-	const char* message,
+	const std::string& name,
+	const std::string& message,
 	U8 offline,
 	EInstantMessage dialog,
 	const LLUUID& id,
@@ -202,8 +202,8 @@ void pack_instant_message_block(
 	BOOL from_group,
 	const LLUUID& session_id,
 	const LLUUID& to_id,
-	const char* name,
-	const char* message,
+	const std::string& name,
+	const std::string& message,
 	U8 offline,
 	EInstantMessage dialog,
 	const LLUUID& id,
@@ -229,10 +229,10 @@ void pack_instant_message_block(
 	msg->addU32Fast(_PREHASH_Timestamp, timestamp);
 	msg->addStringFast(_PREHASH_FromAgentName, name);
 	S32 bytes_left = MTUBYTES;
-	if(message)
+	if(!message.empty())
 	{
 		char buffer[MTUBYTES];
-		int num_written = snprintf(buffer, MTUBYTES, "%s", message);	/* Flawfinder: ignore */
+		int num_written = snprintf(buffer, MTUBYTES, "%s", message.c_str());	/* Flawfinder: ignore */
 		// snprintf returns number of bytes that would have been written
 		// had the output not being truncated. In that case, it will
 		// return either -1 or value >= passed in size value . So a check needs to be added
@@ -281,13 +281,9 @@ void LLIMInfo::unpackMessageBlock(LLMessageSystem* msg)
 	mIMType = (EInstantMessage) dialog;
 	msg->getUUIDFast(_PREHASH_MessageBlock, _PREHASH_ID, mID);
 	msg->getU32Fast(_PREHASH_MessageBlock, _PREHASH_Timestamp, mTimeStamp);
-	char name[DB_FULL_NAME_BUF_SIZE];	/*Flawfinder: ignore*/
-	msg->getStringFast(_PREHASH_MessageBlock, _PREHASH_FromAgentName, DB_FULL_NAME_BUF_SIZE, name);
-	mName.assign(name);
+	msg->getStringFast(_PREHASH_MessageBlock, _PREHASH_FromAgentName, mName);
 
-	char message[DB_IM_MSG_BUF_SIZE];	/*Flawfinder: ignore*/
-	msg->getStringFast(_PREHASH_MessageBlock, _PREHASH_Message, DB_IM_MSG_BUF_SIZE, message);
-	mMessage.assign(message);
+	msg->getStringFast(_PREHASH_MessageBlock, _PREHASH_Message, mMessage);
 
 	S32 binary_bucket_size = llmin(
 		MTUBYTES,
diff --git a/indra/llmessage/llinstantmessage.h b/indra/llmessage/llinstantmessage.h
index 9645d4a763..251c1bc85c 100644
--- a/indra/llmessage/llinstantmessage.h
+++ b/indra/llmessage/llinstantmessage.h
@@ -222,7 +222,7 @@ extern const char EMPTY_BINARY_BUCKET[];
 extern const S32 EMPTY_BINARY_BUCKET_SIZE;
 
 extern const U32 NO_TIMESTAMP;
-extern const char SYSTEM_FROM[];
+extern const std::string SYSTEM_FROM;
 
 // Number of retry attempts on sending the im.
 extern const S32 IM_TTL;
@@ -289,8 +289,8 @@ void pack_instant_message(
 	BOOL from_group,
 	const LLUUID& session_id,
 	const LLUUID& to_id,
-	const char* name,
-	const char* message,
+	const std::string& name,
+	const std::string& message,
 	U8 offline = IM_ONLINE,
 	EInstantMessage dialog = IM_NOTHING_SPECIAL,
 	const LLUUID& id = LLUUID::null,
@@ -307,8 +307,8 @@ void pack_instant_message_block(
 	BOOL from_group,
 	const LLUUID& session_id,
 	const LLUUID& to_id,
-	const char* name,
-	const char* message,
+	const std::string& name,
+	const std::string& message,
 	U8 offline = IM_ONLINE,
 	EInstantMessage dialog = IM_NOTHING_SPECIAL,
 	const LLUUID& id = LLUUID::null,
diff --git a/indra/llmessage/lliohttpserver.cpp b/indra/llmessage/lliohttpserver.cpp
index 90f8ef7638..a2e0325ae7 100644
--- a/indra/llmessage/lliohttpserver.cpp
+++ b/indra/llmessage/lliohttpserver.cpp
@@ -707,7 +707,7 @@ LLIOPipe::EStatus LLHTTPResponder::process_impl(
 					read_next_line = true;
 					std::string name(buf, pos_colon - buf);
 					std::string value(pos_colon + 2);
-					LLString::toLower(name);
+					LLStringUtil::toLower(name);
 					if("content-length" == name)
 					{
 						lldebugs << "Content-Length: " << value << llendl;
@@ -715,7 +715,7 @@ LLIOPipe::EStatus LLHTTPResponder::process_impl(
 					}
 					else
 					{
-						LLString::trimTail(value);
+						LLStringUtil::trimTail(value);
 						mHeaders[name] = value;
 					}
 				}
diff --git a/indra/llmessage/lliosocket.cpp b/indra/llmessage/lliosocket.cpp
index ff7c32aee8..ad309434ac 100644
--- a/indra/llmessage/lliosocket.cpp
+++ b/indra/llmessage/lliosocket.cpp
@@ -220,11 +220,11 @@ bool LLSocket::blockingConnect(const LLHost& host)
 {
 	if(!mSocket) return false;
 	apr_sockaddr_t* sa = NULL;
-	char ip_address[MAXADDRSTR];	/*Flawfinder: ignore*/
-	host.getIPString(ip_address, MAXADDRSTR);
+	std::string ip_address;
+	ip_address = host.getIPString();
 	if(ll_apr_warn_status(apr_sockaddr_info_get(
 		&sa,
-		ip_address,
+		ip_address.c_str(),
 		APR_UNSPEC,
 		host.getPort(),
 		0,
diff --git a/indra/llmessage/llmail.cpp b/indra/llmessage/llmail.cpp
index 1a076b7281..6a8931cf73 100644
--- a/indra/llmessage/llmail.cpp
+++ b/indra/llmessage/llmail.cpp
@@ -365,7 +365,7 @@ std::string LLMail::encryptIMEmailAddress(const LLUUID& from_agent_id,
 	std::string address = LLBase32::encode(encrypted, encrypted_size);
 
 	// Make it more pretty for humans.
-	LLString::toLower(address);
+	LLStringUtil::toLower(address);
 
 	delete [] encrypted;
 
diff --git a/indra/llmessage/llmessageconfig.cpp b/indra/llmessage/llmessageconfig.cpp
index 259daada77..0159eb3562 100644
--- a/indra/llmessage/llmessageconfig.cpp
+++ b/indra/llmessage/llmessageconfig.cpp
@@ -97,7 +97,7 @@ void LLMessageConfigFile::loadFile()
 {
 	LLSD data;
     {
-        llifstream file(filename().c_str());
+        llifstream file(filename());
         
         if (file.is_open())
         {
diff --git a/indra/llmessage/llmessagereader.h b/indra/llmessage/llmessagereader.h
index 4687191494..3de94a1d8f 100644
--- a/indra/llmessage/llmessagereader.h
+++ b/indra/llmessage/llmessagereader.h
@@ -69,6 +69,7 @@ class LLMessageReader
 	virtual void getIPAddr(const char *block, const char *var, U32 &ip, S32 blocknum = 0) = 0;
 	virtual void getIPPort(const char *block, const char *var, U16 &port, S32 blocknum = 0) = 0;
 	virtual void getString(const char *block, const char *var, S32 buffer_size, char *buffer, S32 blocknum = 0) = 0;
+	virtual void getString(const char *block, const char *var, std::string& outstr, S32 blocknum = 0) = 0;
 
 	virtual S32	getNumberOfBlocks(const char *blockname) = 0;
 	virtual S32	getSize(const char *blockname, const char *varname) = 0;
diff --git a/indra/llmessage/llmessagethrottle.cpp b/indra/llmessage/llmessagethrottle.cpp
index 912980d738..846d4067ad 100644
--- a/indra/llmessage/llmessagethrottle.cpp
+++ b/indra/llmessage/llmessagethrottle.cpp
@@ -110,7 +110,7 @@ void LLMessageThrottle::pruneEntries()
 	}
 }
 
-BOOL LLMessageThrottle::addViewerAlert(const LLUUID& to, const char* mesg)
+BOOL LLMessageThrottle::addViewerAlert(const LLUUID& to, const std::string& mesg)
 {
 	message_list_t* message_list = &(mMessageList[MTC_VIEWER_ALERT]);
 
@@ -144,7 +144,7 @@ BOOL LLMessageThrottle::addViewerAlert(const LLUUID& to, const char* mesg)
 	}
 }
 
-BOOL LLMessageThrottle::addAgentAlert(const LLUUID& agent, const LLUUID& task, const char* mesg)
+BOOL LLMessageThrottle::addAgentAlert(const LLUUID& agent, const LLUUID& task, const std::string& mesg)
 {
 	message_list_t* message_list = &(mMessageList[MTC_AGENT_ALERT]);
 
diff --git a/indra/llmessage/llmessagethrottle.h b/indra/llmessage/llmessagethrottle.h
index a3267e7d9d..43c0809d94 100644
--- a/indra/llmessage/llmessagethrottle.h
+++ b/indra/llmessage/llmessagethrottle.h
@@ -64,8 +64,8 @@ public:
 	LLMessageThrottle();
 	~LLMessageThrottle();
 
-	BOOL addViewerAlert	(const LLUUID& to, const char* mesg);
-	BOOL addAgentAlert	(const LLUUID& agent, const LLUUID& task, const char* mesg);
+	BOOL addViewerAlert	(const LLUUID& to, const std::string& mesg);
+	BOOL addAgentAlert	(const LLUUID& agent, const LLUUID& task, const std::string& mesg);
 
 	void pruneEntries();
 
diff --git a/indra/llmessage/llmime.cpp b/indra/llmessage/llmime.cpp
index 7d43f38e9a..de46a50bd9 100644
--- a/indra/llmessage/llmime.cpp
+++ b/indra/llmessage/llmime.cpp
@@ -439,9 +439,7 @@ bool LLMimeParser::Impl::parseHeaders(
 		std::string value(colon);
 		for(S32 ii = 0; ii < KNOWN_HEADER_COUNT; ++ii)
 		{
-			if(0 == LLString::compareInsensitive(
-				name.c_str(),
-				KNOWN_HEADER[ii].c_str()))
+			if(0 == LLStringUtil::compareInsensitive(name, KNOWN_HEADER[ii]))
 			{
 				name = KNOWN_HEADER[ii];
 				break;
@@ -525,7 +523,7 @@ void LLMimeParser::Impl::scanPastSeparator(
 		{
 			mContinue = false;
 		}
-		if(0 == LLString::compareStrings(mBuffer, separator.c_str()))
+		if(0 == LLStringUtil::compareStrings(std::string(mBuffer), separator))
 		{
 			found_separator = true;
 		}
diff --git a/indra/llmessage/llnamevalue.cpp b/indra/llmessage/llnamevalue.cpp
index 3503458a3b..13dca3e51f 100644
--- a/indra/llmessage/llnamevalue.cpp
+++ b/indra/llmessage/llnamevalue.cpp
@@ -155,7 +155,7 @@ void LLNameValue::init(const char *name, const char *data, const char *type, con
 	else if (!strcmp(mStringType, "U64"))
 	{
 		mType = NVT_U64;
-		mNameValueReference.u64 = new U64(str_to_U64(data));
+		mNameValueReference.u64 = new U64(str_to_U64(ll_safe_string(data)));
 	}
 	else if (!strcmp(mStringType, "VEC3"))
 	{
diff --git a/indra/llmessage/llsdmessagereader.cpp b/indra/llmessage/llsdmessagereader.cpp
index 4ca7895613..b7d0267423 100755
--- a/indra/llmessage/llsdmessagereader.cpp
+++ b/indra/llmessage/llsdmessagereader.cpp
@@ -243,6 +243,12 @@ void LLSDMessageReader::getString(const char *block, const char *var,
 	buffer[data_size] = '\0';
 }
 
+//virtual 
+void LLSDMessageReader::getString(const char *block, const char *var, 
+						   std::string& outstr, S32 blocknum)
+{
+	outstr = getLLSD(mMessage, block, var, blocknum).asString();
+}
 
 //virtual 
 S32	LLSDMessageReader::getNumberOfBlocks(const char *blockname)
diff --git a/indra/llmessage/llsdmessagereader.h b/indra/llmessage/llsdmessagereader.h
index 66ac1d14ad..bfb0b31218 100755
--- a/indra/llmessage/llsdmessagereader.h
+++ b/indra/llmessage/llsdmessagereader.h
@@ -87,6 +87,8 @@ public:
 						   S32 blocknum = 0);
 	virtual void getString(const char *block, const char *var, 
 						   S32 buffer_size, char *buffer, S32 blocknum = 0);
+	virtual void getString(const char *block, const char *var, std::string& outstr,
+						   S32 blocknum = 0);
 
 	virtual S32	getNumberOfBlocks(const char *blockname);
 	virtual S32	getSize(const char *blockname, const char *varname);
diff --git a/indra/llmessage/llservicebuilder.cpp b/indra/llmessage/llservicebuilder.cpp
index 6442767ebd..c262515e74 100644
--- a/indra/llmessage/llservicebuilder.cpp
+++ b/indra/llmessage/llservicebuilder.cpp
@@ -39,7 +39,7 @@
 void LLServiceBuilder::loadServiceDefinitionsFromFile(
 	const std::string& service_filename)
 {
-	llifstream service_file(service_filename.c_str(), std::ios::binary);
+	llifstream service_file(service_filename, std::ios::binary);
 	if(service_file.is_open())
 	{
 		LLSD service_data;
diff --git a/indra/llmessage/lltemplatemessagereader.cpp b/indra/llmessage/lltemplatemessagereader.cpp
index f9b703b52a..b1395b0b70 100644
--- a/indra/llmessage/lltemplatemessagereader.cpp
+++ b/indra/llmessage/lltemplatemessagereader.cpp
@@ -171,9 +171,6 @@ S32 LLTemplateMessageReader::getNumberOfBlocks(const char *blockname)
 	
 	if (iter == mCurrentRMessageData->mMemberBlocks.end())
 	{
-//		sprintf(errmsg, "Block %s not in message %s", bnamep, mCurrentRMessageData->mName);
-//		llerrs << errmsg << llendl;
-//		return -1;
 		return 0;
 	}
 
@@ -433,6 +430,15 @@ inline void LLTemplateMessageReader::getString(const char *block, const char *va
 	s[buffer_size - 1] = '\0';
 }
 
+inline void LLTemplateMessageReader::getString(const char *block, const char *var, std::string& outstr, S32 blocknum )
+{
+	char s[MTUBYTES];
+	s[0] = '\0';
+	getData(block, var, s, 0, blocknum, MTUBYTES);
+	s[MTUBYTES - 1] = '\0';
+	outstr = s;
+}
+
 //virtual 
 S32 LLTemplateMessageReader::getMessageSize() const
 {
diff --git a/indra/llmessage/lltemplatemessagereader.h b/indra/llmessage/lltemplatemessagereader.h
index 42cd90ea94..ea3ec9a3d8 100644
--- a/indra/llmessage/lltemplatemessagereader.h
+++ b/indra/llmessage/lltemplatemessagereader.h
@@ -88,6 +88,8 @@ public:
 						   S32 blocknum = 0);
 	virtual void getString(const char *block, const char *var, 
 						   S32 buffer_size, char *buffer, S32 blocknum = 0);
+	virtual void getString(const char *block, const char *var,  std::string& outstr,
+						   S32 blocknum = 0);
 
 	virtual S32	getNumberOfBlocks(const char *blockname);
 	virtual S32	getSize(const char *blockname, const char *varname);
diff --git a/indra/llmessage/lltransfersourcefile.cpp b/indra/llmessage/lltransfersourcefile.cpp
index 268421627e..5088b33e0e 100644
--- a/indra/llmessage/lltransfersourcefile.cpp
+++ b/indra/llmessage/lltransfersourcefile.cpp
@@ -67,7 +67,7 @@ void LLTransferSourceFile::initTransfer()
 		return;
 	}
 	// Look for the file.
-	mFP = LLFile::fopen(mParams.getFilename().c_str(), "rb");		/* Flawfinder: ignore */
+	mFP = LLFile::fopen(mParams.getFilename(), "rb");		/* Flawfinder: ignore */
 	if (!mFP)
 	{
 		sendTransferStatus(LLTS_ERROR);
@@ -134,9 +134,9 @@ void LLTransferSourceFile::completionCallback(const LLTSCode status)
 
 	}
 	// Delete the file iff the filename begins with "TEMP"
-	if (mParams.getDeleteOnCompletion() && memcmp(mParams.getFilename().c_str(), "TEMP", 4) == 0)
+	if (mParams.getDeleteOnCompletion() && mParams.getFilename().substr(0, 4) == "TEMP")
 	{
-		LLFile::remove(mParams.getFilename().c_str());
+		LLFile::remove(mParams.getFilename());
 	}
 }
 
@@ -162,7 +162,7 @@ LLTransferSourceParamsFile::LLTransferSourceParamsFile() :
 
 void LLTransferSourceParamsFile::packParams(LLDataPacker &dp) const
 {
-	dp.packString(mFilename.c_str(), "Filename");
+	dp.packString(mFilename, "Filename");
 	dp.packU8((U8)mDeleteOnCompletion, "Delete");
 }
 
diff --git a/indra/llmessage/lltransfersourcefile.h b/indra/llmessage/lltransfersourcefile.h
index 84a6bd259f..0aa0eb8458 100644
--- a/indra/llmessage/lltransfersourcefile.h
+++ b/indra/llmessage/lltransfersourcefile.h
@@ -42,7 +42,7 @@ public:
 	/*virtual*/ void packParams(LLDataPacker &dp) const;
 	/*virtual*/ BOOL unpackParams(LLDataPacker &dp);
 
-	void setFilename(const LLString &filename)		{ mFilename = filename; }
+	void setFilename(const std::string &filename)		{ mFilename = filename; }
 	std::string getFilename() const					{ return mFilename; }
 
 	void setDeleteOnCompletion(BOOL enabled)		{ mDeleteOnCompletion = enabled; }
diff --git a/indra/llmessage/lltransfertargetfile.cpp b/indra/llmessage/lltransfertargetfile.cpp
index d05f80834a..64c001ed6e 100644
--- a/indra/llmessage/lltransfertargetfile.cpp
+++ b/indra/llmessage/lltransfertargetfile.cpp
@@ -80,7 +80,7 @@ LLTSCode LLTransferTargetFile::dataCallback(const S32 packet_id, U8 *in_datap, c
 
 	if (!mFP)
 	{
-		mFP = LLFile::fopen(mParams.mFilename.c_str(), "wb");		/* Flawfinder: ignore */		
+		mFP = LLFile::fopen(mParams.mFilename, "wb");		/* Flawfinder: ignore */		
 
 		if (!mFP)
 		{
@@ -122,7 +122,7 @@ void LLTransferTargetFile::completionCallback(const LLTSCode status)
 		if (mFP)
 		{
 			// Only need to remove file if we successfully opened it.
-			LLFile::remove(mParams.mFilename.c_str());
+			LLFile::remove(mParams.mFilename);
 		}
 	default:
 		break;
diff --git a/indra/llmessage/lltransfertargetfile.h b/indra/llmessage/lltransfertargetfile.h
index 6b837f4890..ba34ba1123 100644
--- a/indra/llmessage/lltransfertargetfile.h
+++ b/indra/llmessage/lltransfertargetfile.h
@@ -40,12 +40,12 @@ class LLTransferTargetParamsFile : public LLTransferTargetParams
 {
 public:
 	LLTransferTargetParamsFile() : LLTransferTargetParams(LLTTT_FILE) {}
-	void setFilename(const LLString& filename)	{ mFilename = filename; }
+	void setFilename(const std::string& filename)	{ mFilename = filename; }
 	void setCallback(LLTTFCompleteCallback cb, void *user_data)		{ mCompleteCallback = cb; mUserData = user_data; }
 
 	friend class LLTransferTargetFile;
 protected:
-	LLString				mFilename;
+	std::string				mFilename;
 	LLTTFCompleteCallback	mCompleteCallback;
 	void *					mUserData;
 };
diff --git a/indra/llmessage/llurlrequest.cpp b/indra/llmessage/llurlrequest.cpp
index e7be235221..5ac55bc83d 100644
--- a/indra/llmessage/llurlrequest.cpp
+++ b/indra/llmessage/llurlrequest.cpp
@@ -542,7 +542,7 @@ LLIOPipe::EStatus LLContextURLExtractor::process_impl(
 	// find the context url
 	if(context.has(CONTEXT_DEST_URI_SD_LABEL))
 	{
-		mRequest->setURL(context[CONTEXT_DEST_URI_SD_LABEL]);
+		mRequest->setURL(context[CONTEXT_DEST_URI_SD_LABEL].asString());
 		return STATUS_DONE;
 	}
 	return STATUS_ERROR;
diff --git a/indra/llmessage/llxfer.cpp b/indra/llmessage/llxfer.cpp
index fefb6f9c63..5682b1c454 100644
--- a/indra/llmessage/llxfer.cpp
+++ b/indra/llmessage/llxfer.cpp
@@ -103,7 +103,7 @@ void LLXfer::free ()
 
 S32 LLXfer::startSend (U64 xfer_id, const LLHost &remote_host)
 {
-	llwarns << "undifferentiated LLXfer::startSend for " << getName() << llendl;
+	llwarns << "undifferentiated LLXfer::startSend for " << getFileName() << llendl;
 	return (-1);
 }
 
@@ -119,7 +119,7 @@ void LLXfer::setXferSize (S32 xfer_size)
 
 S32 LLXfer::startDownload()
 {
-	llwarns << "undifferentiated LLXfer::startDownload for " << getName()
+	llwarns << "undifferentiated LLXfer::startDownload for " << getFileName()
 			<< llendl;
 	return (-1);
 }
@@ -293,13 +293,13 @@ S32 LLXfer::processEOF()
 
 	if (LL_ERR_NOERR == mCallbackResult)
 	{
-		llinfos << "xfer from " << mRemoteHost << " complete: " << getName()
+		llinfos << "xfer from " << mRemoteHost << " complete: " << getFileName()
 				<< llendl;
 	}
 	else
 	{
 		llinfos << "xfer from " << mRemoteHost << " failed, code "
-				<< mCallbackResult << ": " << getName() << llendl;
+				<< mCallbackResult << ": " << getFileName() << llendl;
 	}
 
 	if (mCallback)
@@ -327,7 +327,7 @@ void LLXfer::abort (S32 result_code)
 {
 	mCallbackResult = result_code;
 
-	llinfos << "Aborting xfer from " << mRemoteHost << " named " << getName()
+	llinfos << "Aborting xfer from " << mRemoteHost << " named " << getFileName()
 			<< " - error: " << result_code << llendl;
 
 	gMessageSystem->newMessageFast(_PREHASH_AbortXfer);
@@ -343,11 +343,9 @@ void LLXfer::abort (S32 result_code)
 
 ///////////////////////////////////////////////////////////
 
-const char * LLXfer::getName() 
+std::string LLXfer::getFileName() 
 {
-	static char tmp_str[256];		/* Flawfinder: ignore */
-
-	return (U64_to_str(mID, tmp_str, sizeof(tmp_str)));
+	return U64_to_str(mID);
 }
 
 ///////////////////////////////////////////////////////////
@@ -367,7 +365,7 @@ S32 LLXfer::getMaxBufferSize ()
 
 std::ostream& operator<< (std::ostream& os, LLXfer &hh)
 {
-	os << hh.getName() ;
+	os << hh.getFileName() ;
 	return os;
 }
 
diff --git a/indra/llmessage/llxfer.h b/indra/llmessage/llxfer.h
index 017a521b81..57abc28960 100644
--- a/indra/llmessage/llxfer.h
+++ b/indra/llmessage/llxfer.h
@@ -106,7 +106,7 @@ class LLXfer
 	virtual void setXferSize (S32 data_size);
 	virtual S32  getMaxBufferSize();
 
-	virtual const char *getName();
+	virtual std::string getFileName();
 
 	virtual U32 getXferTypeTag();
 
diff --git a/indra/llmessage/llxfer_file.cpp b/indra/llmessage/llxfer_file.cpp
index 6b71e7db8f..3643c4880d 100644
--- a/indra/llmessage/llxfer_file.cpp
+++ b/indra/llmessage/llxfer_file.cpp
@@ -47,17 +47,17 @@
 const U32 LL_MAX_XFER_FILE_BUFFER = 65536;
 
 // local function to copy a file
-S32 copy_file(const char* from, const char* to);
+S32 copy_file(const std::string& from, const std::string& to);
 
 ///////////////////////////////////////////////////////////
 
 LLXfer_File::LLXfer_File (S32 chunk_size)
 : LLXfer(chunk_size)
 {
-	init(LLString::null, FALSE, chunk_size);
+	init(LLStringUtil::null, FALSE, chunk_size);
 }
 
-LLXfer_File::LLXfer_File (const LLString& local_filename, BOOL delete_local_on_completion, S32 chunk_size)
+LLXfer_File::LLXfer_File (const std::string& local_filename, BOOL delete_local_on_completion, S32 chunk_size)
 : LLXfer(chunk_size)
 {
 	init(local_filename, delete_local_on_completion, chunk_size);
@@ -72,24 +72,24 @@ LLXfer_File::~LLXfer_File ()
 
 ///////////////////////////////////////////////////////////
 
-void LLXfer_File::init (const LLString& local_filename, BOOL delete_local_on_completion, S32 chunk_size)
+void LLXfer_File::init (const std::string& local_filename, BOOL delete_local_on_completion, S32 chunk_size)
 {
 
 	mFp = NULL;
-	mLocalFilename[0] = 0;
-	mRemoteFilename[0] = 0;
+	mLocalFilename.clear();
+	mRemoteFilename.clear();
 	mRemotePath = LL_PATH_NONE;
-	mTempFilename[0] = 0;
+	mTempFilename.clear();
 	mDeleteLocalOnCompletion = FALSE;
 	mDeleteRemoteOnCompletion = FALSE;
 
 	if (!local_filename.empty())
 	{
-		strncpy(mLocalFilename, local_filename.c_str(), LL_MAX_PATH-1);
-		mLocalFilename[LL_MAX_PATH-1] = '\0'; // stupid strncpy.
+		mLocalFilename =  local_filename.substr(0,LL_MAX_PATH-1);
 
 		// You can only automatically delete .tmp file as a safeguard against nasty messages.
-		mDeleteLocalOnCompletion = (delete_local_on_completion && (strstr(mLocalFilename,".tmp") == &mLocalFilename[strlen(mLocalFilename)-4]));		/* Flawfinder : ignore */
+		std::string exten = mLocalFilename.substr(mLocalFilename.length()-4, 4);
+		mDeleteLocalOnCompletion = (delete_local_on_completion && exten == ".tmp");
 	}
 }
 	
@@ -121,8 +121,8 @@ void LLXfer_File::free ()
 ///////////////////////////////////////////////////////////
 
 S32 LLXfer_File::initializeRequest(U64 xfer_id,
-				   const LLString& local_filename,
-				   const LLString& remote_filename,
+				   const std::string& local_filename,
+				   const std::string& remote_filename,
 				   ELLPath remote_path,
 				   const LLHost& remote_host,
 				   BOOL delete_remote_on_completion,
@@ -132,15 +132,13 @@ S32 LLXfer_File::initializeRequest(U64 xfer_id,
  	S32 retval = 0;  // presume success
 	
 	mID = xfer_id;
-	strncpy(mLocalFilename, local_filename.c_str(), LL_MAX_PATH-1);
-	mLocalFilename[LL_MAX_PATH-1] = '\0'; // stupid strncpy.
-	strncpy(mRemoteFilename,remote_filename.c_str(), LL_MAX_PATH-1);
-	mRemoteFilename[LL_MAX_PATH-1] = '\0'; // stupid strncpy.
+	mLocalFilename = local_filename;
+	mRemoteFilename = remote_filename;
 	mRemotePath = remote_path;
 	mRemoteHost = remote_host;
 	mDeleteRemoteOnCompletion = delete_remote_on_completion;
 
-	snprintf(mTempFilename, sizeof(mTempFilename), "%s",gDirUtilp->getTempFilename().c_str());	/* Flawfinder: ignore */
+	mTempFilename = gDirUtilp->getTempFilename();
 
 	mCallback = callback;
 	mCallbackDataHandle = user_data;
@@ -343,7 +341,7 @@ S32 LLXfer_File::processEOF()
 				if(copy_file(mTempFilename, mLocalFilename) == 0)
 				{
 					llinfos << "Rename across mounts; copying+unlinking the file instead." << llendl;
-					unlink(mTempFilename);
+					unlink(mTempFilename.c_str());
 				}
 				else
 				{
@@ -384,14 +382,14 @@ S32 LLXfer_File::processEOF()
 
 ///////////////////////////////////////////////////////////
 
-BOOL LLXfer_File::matchesLocalFilename(const LLString& filename) 
+BOOL LLXfer_File::matchesLocalFilename(const std::string& filename) 
 {
 	return (filename == mLocalFilename);
 }
 
 ///////////////////////////////////////////////////////////
 
-BOOL LLXfer_File::matchesRemoteFilename(const LLString& filename, ELLPath remote_path) 
+BOOL LLXfer_File::matchesRemoteFilename(const std::string& filename, ELLPath remote_path) 
 {
 	return ((filename == mRemoteFilename) && (remote_path == mRemotePath));
 }
@@ -399,9 +397,9 @@ BOOL LLXfer_File::matchesRemoteFilename(const LLString& filename, ELLPath remote
 
 ///////////////////////////////////////////////////////////
 
-const char * LLXfer_File::getName() 
+std::string LLXfer_File::getFileName() 
 {
-	return (mLocalFilename);
+	return mLocalFilename;
 }
 
 ///////////////////////////////////////////////////////////
@@ -421,7 +419,7 @@ U32 LLXfer_File::getXferTypeTag()
 // function. It does not really spam enough information, but is useful
 // for this cpp file, because this should never be called in a
 // production environment.
-S32 copy_file(const char* from, const char* to)
+S32 copy_file(const std::string& from, const std::string& to)
 {
 	S32 rv = 0;
 	LLFILE* in = LLFile::fopen(from, "rb");	/*Flawfinder: ignore*/
diff --git a/indra/llmessage/llxfer_file.h b/indra/llmessage/llxfer_file.h
index 5302302e54..04336c75fe 100644
--- a/indra/llmessage/llxfer_file.h
+++ b/indra/llmessage/llxfer_file.h
@@ -39,25 +39,25 @@ class LLXfer_File : public LLXfer
 {
  protected:
  	LLFILE *mFp;
-	char mLocalFilename[LL_MAX_PATH];		/* Flawfinder : ignore */
-	char mRemoteFilename[LL_MAX_PATH];		/* Flawfinder : ignore */
+	std::string mLocalFilename;
+	std::string mRemoteFilename;
 	ELLPath mRemotePath;
-	char mTempFilename[LL_MAX_PATH];		/* Flawfinder : ignore */
+	std::string mTempFilename;
 
 	BOOL mDeleteLocalOnCompletion;
 	BOOL mDeleteRemoteOnCompletion;
 
  public:
 	LLXfer_File (S32 chunk_size);
-	LLXfer_File (const LLString& local_filename, BOOL delete_local_on_completion, S32 chunk_size);
+	LLXfer_File (const std::string& local_filename, BOOL delete_local_on_completion, S32 chunk_size);
 	virtual ~LLXfer_File();
 
-	virtual void init(const LLString& local_filename, BOOL delete_local_on_completion, S32 chunk_size);
+	virtual void init(const std::string& local_filename, BOOL delete_local_on_completion, S32 chunk_size);
 	virtual void free();
 
 	virtual S32 initializeRequest(U64 xfer_id,
-								  const LLString& local_filename,
-								  const LLString& remote_filename,
+								  const std::string& local_filename,
+								  const std::string& remote_filename,
 								  ELLPath remote_path,
 								  const LLHost& remote_host,
 								  BOOL delete_remote_on_completion,
@@ -72,14 +72,14 @@ class LLXfer_File : public LLXfer
 	virtual S32 suck(S32 start_position);
 	virtual S32 flush();
 
-	virtual BOOL matchesLocalFilename(const LLString& filename);
-	virtual BOOL matchesRemoteFilename(const LLString& filename, ELLPath remote_path);
+	virtual BOOL matchesLocalFilename(const std::string& filename);
+	virtual BOOL matchesRemoteFilename(const std::string& filename, ELLPath remote_path);
 
 	virtual S32  getMaxBufferSize();
 
 	virtual U32 getXferTypeTag();
 
-	virtual const char *getName();
+	virtual std::string getFileName();
 };
 
 #endif
diff --git a/indra/llmessage/llxfer_mem.cpp b/indra/llmessage/llxfer_mem.cpp
index 4c3b1bbebb..dbaa3aebed 100644
--- a/indra/llmessage/llxfer_mem.cpp
+++ b/indra/llmessage/llxfer_mem.cpp
@@ -55,7 +55,7 @@ LLXfer_Mem::~LLXfer_Mem ()
 
 void LLXfer_Mem::init ()
 {
-	mRemoteFilename[0] = '\0';
+	mRemoteFilename.clear();
 	mRemotePath = LL_PATH_NONE;
 	mDeleteRemoteOnCompletion = FALSE;
 }
@@ -120,7 +120,7 @@ S32 LLXfer_Mem::startSend (U64 xfer_id, const LLHost &remote_host)
 	mID = xfer_id;
    	mPacketNum = -1;
 
-//	cout << "Sending file: " << getName() << endl;
+//	cout << "Sending file: " << getFileName() << endl;
 
 	mStatus = e_LL_XFER_PENDING;
 
@@ -135,7 +135,7 @@ S32 LLXfer_Mem::processEOF()
 
 	mStatus = e_LL_XFER_COMPLETE;
 
-	llinfos << "xfer complete: " << getName() << llendl;
+	llinfos << "xfer complete: " << getFileName() << llendl;
 
 	if (mCallback)
 	{
@@ -165,8 +165,7 @@ S32 LLXfer_Mem::initializeRequest(U64 xfer_id,
 	mCallbackDataHandle = user_data;
 	mCallbackResult = LL_ERR_NOERR;
 
-	strncpy(mRemoteFilename, remote_filename.c_str(), LL_MAX_PATH-1);
-	mRemoteFilename[LL_MAX_PATH-1] = '\0'; // stupid strncpy.
+	mRemoteFilename = remote_filename;
 	mRemotePath = remote_path;
 	mDeleteRemoteOnCompletion = delete_remote_on_completion;
 
diff --git a/indra/llmessage/llxfer_mem.h b/indra/llmessage/llxfer_mem.h
index 858b8d1323..a6b95c0fcf 100644
--- a/indra/llmessage/llxfer_mem.h
+++ b/indra/llmessage/llxfer_mem.h
@@ -42,7 +42,7 @@ class LLXfer_Mem : public LLXfer
  private:
  protected:
 	void (*mCallback)(void *, S32, void **, S32, LLExtStat);	
-	char mRemoteFilename[LL_MAX_PATH];		/* Flawfinder : ignore */
+	std::string mRemoteFilename;
 	ELLPath mRemotePath;
 	BOOL mDeleteRemoteOnCompletion;
 
diff --git a/indra/llmessage/llxfer_vfile.cpp b/indra/llmessage/llxfer_vfile.cpp
index b870e5369d..6dd683043b 100644
--- a/indra/llmessage/llxfer_vfile.cpp
+++ b/indra/llmessage/llxfer_vfile.cpp
@@ -74,10 +74,10 @@ void LLXfer_VFile::init (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType
 
 	mVFile = NULL;
 
-	char id_string[UUID_STR_LENGTH];			/* Flawfinder : ignore */
+	std::string id_string;
 	mLocalID.toString(id_string);
 
-	snprintf(mName, sizeof(mName), "VFile %s:%s", id_string, LLAssetType::lookup(mType));		/* Flawfinder : ignore */
+	mName = llformat("VFile %s:%s", id_string.c_str(), LLAssetType::lookup(mType));
 }
 	
 ///////////////////////////////////////////////////////////
@@ -118,10 +118,10 @@ S32 LLXfer_VFile::initializeRequest(U64 xfer_id,
 	mCallbackDataHandle = user_data;
 	mCallbackResult = LL_ERR_NOERR;
 
-	char id_string[UUID_STR_LENGTH];		/* Flawfinder : ignore */
+	std::string id_string;
 	mLocalID.toString(id_string);
 
-	snprintf(mName, sizeof(mName), "VFile %s:%s", id_string, LLAssetType::lookup(mType));		/* Flawfinder : ignore */
+	mName = llformat("VFile %s:%s", id_string.c_str(), LLAssetType::lookup(mType));
 
 	llinfos << "Requesting " << mName << llendl;
 
@@ -328,7 +328,7 @@ BOOL LLXfer_VFile::matchesRemoteFile(const LLUUID &id, LLAssetType::EType type)
 
 //////////////////////////////////////////////////////////
 
-const char * LLXfer_VFile::getName() 
+std::string LLXfer_VFile::getFileName() 
 {
 	return mName;
 }
diff --git a/indra/llmessage/llxfer_vfile.h b/indra/llmessage/llxfer_vfile.h
index 5d57b08e3c..84457edf26 100644
--- a/indra/llmessage/llxfer_vfile.h
+++ b/indra/llmessage/llxfer_vfile.h
@@ -50,7 +50,7 @@ class LLXfer_VFile : public LLXfer
 
 	LLVFS *mVFS;
 
-	char mName[MAX_STRING];		/* Flawfinder : ignore */
+	std::string mName;
 
  public:
 	LLXfer_VFile ();
@@ -85,7 +85,7 @@ class LLXfer_VFile : public LLXfer
 
 	virtual U32 getXferTypeTag();
 
-	virtual const char *getName();
+	virtual std::string getFileName();
 };
 
 #endif
diff --git a/indra/llmessage/llxfermanager.cpp b/indra/llmessage/llxfermanager.cpp
index fc75b3ae75..a94f982b8d 100644
--- a/indra/llmessage/llxfermanager.cpp
+++ b/indra/llmessage/llxfermanager.cpp
@@ -406,8 +406,8 @@ U64 LLXferManager::registerXfer(const void *datap, const S32 length)
 
 ///////////////////////////////////////////////////////////
 
-void LLXferManager::requestFile(const char* local_filename,
-								const char* remote_filename,
+void LLXferManager::requestFile(const std::string& local_filename,
+								const std::string& remote_filename,
 								ELLPath remote_path,
 								const LLHost& remote_host,
 								BOOL delete_remote_on_completion,
@@ -444,7 +444,7 @@ void LLXferManager::requestFile(const char* local_filename,
 		// Note: according to AaronB, this is here to deal with locks on files that were
 		// in transit during a crash,
 		if(delete_remote_on_completion &&
-		   (strstr(remote_filename,".tmp") == &remote_filename[strlen(remote_filename)-4]))		/* Flawfinder : ignore */
+		   (remote_filename.substr(remote_filename.length()-4) == ".tmp"))
 		{
 			LLFile::remove(local_filename);
 		}
@@ -464,7 +464,7 @@ void LLXferManager::requestFile(const char* local_filename,
 	}
 }
 
-void LLXferManager::requestFile(const char* remote_filename,
+void LLXferManager::requestFile(const std::string& remote_filename,
 								ELLPath remote_path,
 								const LLHost& remote_host,
 								BOOL delete_remote_on_completion,
@@ -540,7 +540,7 @@ void LLXferManager::requestVFile(const LLUUID& local_id,
 
 /*
 void LLXferManager::requestXfer(
-								const char *local_filename, 
+								const std::string& local_filename, 
 								BOOL delete_remote_on_completion,
 								U64 xfer_id, 
 								const LLHost &remote_host, 
@@ -634,11 +634,11 @@ void LLXferManager::processReceiveData (LLMessageSystem *mesgsys, void ** /*user
 		// confirm it if it was a resend of the last one, since the confirmation might have gotten dropped
 		if (decodePacketNum(packetnum) == (xferp->mPacketNum - 1))
 		{
-			llinfos << "Reconfirming xfer " << xferp->mRemoteHost << ":" << xferp->getName() << " packet " << packetnum << llendl; 			sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
+			llinfos << "Reconfirming xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet " << packetnum << llendl; 			sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
 		}
 		else
 		{
-			llinfos << "Ignoring xfer " << xferp->mRemoteHost << ":" << xferp->getName() << " recv'd packet " << packetnum << "; expecting " << xferp->mPacketNum << llendl;
+			llinfos << "Ignoring xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " recv'd packet " << packetnum << "; expecting " << xferp->mPacketNum << llendl;
 		}
 		return;		
 	}
@@ -717,7 +717,7 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 {
 		
 	U64 id;
-	char local_filename[MAX_STRING];		/* Flawfinder : ignore */
+	std::string local_filename;
 	ELLPath local_path = LL_PATH_NONE;
 	S32 result = LL_ERR_NOERR;
 	LLUUID	uuid;
@@ -732,7 +732,7 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 	llinfos << "xfer request id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF))
 		   << " to " << mesgsys->getSender() << llendl;
 
-	mesgsys->getStringFast(_PREHASH_XferID, _PREHASH_Filename, MAX_STRING, local_filename);
+	mesgsys->getStringFast(_PREHASH_XferID, _PREHASH_Filename, local_filename);
 	
 	U8 local_path_u8;
 	mesgsys->getU8("XferID", "FilePath", local_path_u8);
@@ -780,7 +780,7 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 			llerrs << "Xfer allcoation error" << llendl;
 		}
 	}
-	else if (strlen(local_filename))		/* Flawfinder : ignore */
+	else if (!local_filename.empty())
 	{
 		std::string expanded_filename = gDirUtilp->getExpandedFilename( local_path, local_filename );
 		llinfos << "starting file transfer: " <<  expanded_filename << " to " << mesgsys->getSender() << llendl;
@@ -923,7 +923,7 @@ void LLXferManager::retransmitUnackedPackets ()
 		{
 			if (xferp->mRetries > LL_PACKET_RETRY_LIMIT)
 			{
-				llinfos << "dropping xfer " << xferp->mRemoteHost << ":" << xferp->getName() << " packet retransmit limit exceeded, xfer dropped" << llendl;
+				llinfos << "dropping xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet retransmit limit exceeded, xfer dropped" << llendl;
 				xferp->abort(LL_ERR_TCP_TIMEOUT);
 				delp = xferp;
 				xferp = xferp->mNext;
@@ -931,7 +931,7 @@ void LLXferManager::retransmitUnackedPackets ()
 			}
 			else
 			{
-				llinfos << "resending xfer " << xferp->mRemoteHost << ":" << xferp->getName() << " packet unconfirmed after: "<< et << " sec, packet " << xferp->mPacketNum << llendl;
+				llinfos << "resending xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet unconfirmed after: "<< et << " sec, packet " << xferp->mPacketNum << llendl;
 				xferp->resendLastPacket();
 				xferp = xferp->mNext;
 			}
@@ -946,7 +946,7 @@ void LLXferManager::retransmitUnackedPackets ()
 		}
 		else if (xferp->mStatus == e_LL_XFER_ABORTED)
 		{
-			llwarns << "Removing aborted xfer " << xferp->mRemoteHost << ":" << xferp->getName() << llendl;
+			llwarns << "Removing aborted xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << llendl;
 			delp = xferp;
 			xferp = xferp->mNext;
 			removeXfer(delp,&mSendList);
diff --git a/indra/llmessage/llxfermanager.h b/indra/llmessage/llxfermanager.h
index c4af8fe937..dff8181584 100644
--- a/indra/llmessage/llxfermanager.h
+++ b/indra/llmessage/llxfermanager.h
@@ -143,8 +143,8 @@ class LLXferManager
 
 // file requesting routines
 // .. to file
-	virtual void requestFile(const char* local_filename,
-							 const char* remote_filename,
+	virtual void requestFile(const std::string& local_filename,
+							 const std::string& remote_filename,
 							 ELLPath remote_path,
 							 const LLHost& remote_host,
  							 BOOL delete_remote_on_completion,
@@ -153,7 +153,7 @@ class LLXferManager
 							 BOOL use_big_packets = FALSE);
 
 // .. to memory
-	virtual void requestFile(const char* remote_filename, 
+	virtual void requestFile(const std::string& remote_filename, 
 							 ELLPath remote_path,
 							 const LLHost &remote_host,
  							 BOOL delete_remote_on_completion,
diff --git a/indra/llmessage/mean_collision_data.h b/indra/llmessage/mean_collision_data.h
index 1643c30594..7ee539720f 100644
--- a/indra/llmessage/mean_collision_data.h
+++ b/indra/llmessage/mean_collision_data.h
@@ -55,15 +55,13 @@ class LLMeanCollisionData
 public:
 	LLMeanCollisionData(const LLUUID &victim, const LLUUID &perp, time_t time, EMeanCollisionType type, F32 mag)
 		: mVictim(victim), mPerp(perp), mTime(time), mType(type), mMag(mag)
-	{ mFirstName[0] = 0; mLastName[0] =  0; }
+	{
+	}
 	
 	LLMeanCollisionData(LLMeanCollisionData *mcd)
-		: mVictim(mcd->mVictim), mPerp(mcd->mPerp), mTime(mcd->mTime), mType(mcd->mType), mMag(mcd->mMag)
-	{ 
-		strncpy(mFirstName, mcd->mFirstName, sizeof(mFirstName) -1); /* Flawfinder: Ignore */
-		mFirstName[sizeof(mFirstName) -1] = '\0'; 
-		strncpy(mLastName, mcd->mLastName, sizeof(mLastName) -1); /* Flawfinder: Ignore */
-		mLastName[sizeof(mLastName) -1] = '\0';
+		: mVictim(mcd->mVictim), mPerp(mcd->mPerp), mTime(mcd->mTime), mType(mcd->mType), mMag(mcd->mMag),
+		  mFirstName(mcd->mFirstName), mLastName(mcd->mLastName)
+	{
 	}		
 	
 	friend std::ostream&	 operator<<(std::ostream& s, const LLMeanCollisionData &a)
@@ -96,8 +94,8 @@ public:
 	time_t mTime;
 	EMeanCollisionType mType;
 	F32	   mMag;
-	char   mFirstName[DB_FIRST_NAME_BUF_SIZE];		/* Flawfinder: Ignore */
-	char   mLastName[DB_LAST_NAME_BUF_SIZE];		/* Flawfinder: Ignore */
+	std::string mFirstName;
+	std::string mLastName;
 };
 
 
diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp
index c1731532ca..290682f7ce 100644
--- a/indra/llmessage/message.cpp
+++ b/indra/llmessage/message.cpp
@@ -286,7 +286,7 @@ void LLMessageSystem::init()
 }
 
 // Read file and build message templates
-LLMessageSystem::LLMessageSystem(const char *filename, U32 port, 
+LLMessageSystem::LLMessageSystem(const std::string& filename, U32 port, 
 								 S32 version_major,
 								 S32 version_minor,
 								 S32 version_patch,
@@ -366,10 +366,9 @@ LLMessageSystem::LLMessageSystem(const char *filename, U32 port,
 
 
 // Read file and build message templates
-void LLMessageSystem::loadTemplateFile(const char* filename,
-									   bool failure_is_fatal)
+void LLMessageSystem::loadTemplateFile(const std::string& filename, bool failure_is_fatal)
 {
-	if(!filename)
+	if(filename.empty())
 	{
 		LL_ERRS("Messaging") << "No template filename specified" << llendl;
 		mbError = TRUE;
@@ -692,9 +691,9 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
 					{
 						std::ostringstream str;
 						str << "MSG: <- " << host;
-						char buffer[MAX_STRING]; /* Flawfinder: ignore*/
-						snprintf(buffer, MAX_STRING, "\t%6d\t%6d\t%6d ", receive_size, (mIncomingCompressedSize ? mIncomingCompressedSize : receive_size), mCurrentRecvPacketID);	/* Flawfinder: ignore */
-						str << buffer << "(unknown)"
+						std::string tbuf;
+						tbuf = llformat( "\t%6d\t%6d\t%6d ", receive_size, (mIncomingCompressedSize ? mIncomingCompressedSize : receive_size), mCurrentRecvPacketID);
+						str << tbuf << "(unknown)"
 							<< (recv_reliable ? " reliable" : "")
 							<< " resent "
 							<< ((acks > 0) ? "acks" : "")
@@ -822,10 +821,9 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
 
 									LLMsgBlkData *msg_block_data = mCurrentRMessageData->mMemberBlocks[bnamep];
 
-									char errmsg[1024];
 									if (!msg_block_data)
 									{
-										sprintf(errmsg, "Block %s #%d not in message %s", block_name, blocknum, mCurrentRMessageData->mName);
+										std::string errmsg = llformat("Block %s #%d not in message %s", block_name, blocknum, mCurrentRMessageData->mName);
 										LL_ERRS("Messaging") << errmsg << llendl;
 									}
 
@@ -833,7 +831,7 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
 
 									if (!vardata.getName())
 									{
-										sprintf(errmsg, "Variable %s not in message %s block %s", vnamep, mCurrentRMessageData->mName, bnamep);
+										std::string errmsg = llformat("Variable %s not in message %s block %s", vnamep, mCurrentRMessageData->mName, bnamep);
 										LL_ERRS("Messaging") << errmsg << llendl;
 									}
 
@@ -1384,8 +1382,8 @@ S32 LLMessageSystem::sendMessage(const LLHost &host)
 	{
 		std::ostringstream str;
 		str << "MSG: -> " << host;
-		char buffer[MAX_STRING];			/* Flawfinder: ignore */
-		snprintf(buffer, MAX_STRING, "\t%6d\t%6d\t%6d ", mSendSize, buffer_length, cdp->getPacketOutID());		/* Flawfinder: ignore */
+		std::string buffer;
+		buffer = llformat( "\t%6d\t%6d\t%6d ", mSendSize, buffer_length, cdp->getPacketOutID());
 		str << buffer
 			<< mMessageBuilder->getMessageName()
 			<< (mSendReliable ? " reliable " : "");
@@ -1413,8 +1411,8 @@ void LLMessageSystem::logMsgFromInvalidCircuit( const LLHost& host, BOOL recv_re
 	{
 		std::ostringstream str;
 		str << "MSG: <- " << host;
-		char buffer[MAX_STRING];			/* Flawfinder: ignore */
-		snprintf(buffer, MAX_STRING, "\t%6d\t%6d\t%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize: mMessageReader->getMessageSize()), mCurrentRecvPacketID);		/* Flawfinder: ignore */
+		std::string buffer;
+		buffer = llformat( "\t%6d\t%6d\t%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize: mMessageReader->getMessageSize()), mCurrentRecvPacketID);
 		str << buffer
 			<< nullToEmpty(mMessageReader->getMessageName())
 			<< (recv_reliable ? " reliable" : "")
@@ -1518,8 +1516,8 @@ void LLMessageSystem::logValidMsg(LLCircuitData *cdp, const LLHost& host, BOOL r
 	{
 		std::ostringstream str;
 		str << "MSG: <- " << host;
-		char buffer[MAX_STRING];			/* Flawfinder: ignore */
-		snprintf(buffer, MAX_STRING, "\t%6d\t%6d\t%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize : mMessageReader->getMessageSize()), mCurrentRecvPacketID);		/* Flawfinder: ignore */
+		std::string buffer;
+		buffer = llformat( "\t%6d\t%6d\t%6d ", mMessageReader->getMessageSize(), (mIncomingCompressedSize ? mIncomingCompressedSize : mMessageReader->getMessageSize()), mCurrentRecvPacketID);
 		str << buffer
 			<< nullToEmpty(mMessageReader->getMessageName())
 			<< (recv_reliable ? " reliable" : "")
@@ -2092,20 +2090,18 @@ void LLMessageSystem::processUseCircuitCode(LLMessageSystem* msg,
 // static
 void LLMessageSystem::processError(LLMessageSystem* msg, void**)
 {
-	char buffer[MTUBYTES];
 	S32 error_code = 0;
 	msg->getS32("Data", "Code", error_code);
 	std::string error_token;
-	msg->getString("Data", "Token", MTUBYTES, buffer);
-	error_token.assign(buffer);
+	msg->getString("Data", "Token", error_token);
+
 	LLUUID error_id;
 	msg->getUUID("Data", "ID", error_id);
 	std::string error_system;
-	msg->getString("Data", "System", MTUBYTES, buffer);
-	error_system.assign(buffer);
+	msg->getString("Data", "System", error_system);
+
 	std::string error_message;
-	msg->getString("Data", "Message", MTUBYTES, buffer);
-	error_message.assign(buffer);
+	msg->getString("Data", "Message", error_message);
 
 	LL_WARNS("Messaging") << "Message error from " << msg->getSender() << " - "
 		<< error_code << " " << error_token << " " << error_id << " \""
@@ -2421,7 +2417,8 @@ void process_deny_trusted_circuit(LLMessageSystem *msg, void **)
 void dump_prehash_files()
 {
 	U32 i;
-	LLFILE* fp = LLFile::fopen("../../indra/llmessage/message_prehash.h", "w");	/* Flawfinder: ignore */
+	std::string filename("../../indra/llmessage/message_prehash.h");
+	LLFILE* fp = LLFile::fopen(filename, "w");	/* Flawfinder: ignore */
 	if (fp)
 	{
 		fprintf(
@@ -2451,7 +2448,8 @@ void dump_prehash_files()
 		fprintf(fp, "\n\n#endif\n");
 		fclose(fp);
 	}
-	fp = LLFile::fopen("../../indra/llmessage/message_prehash.cpp", "w");	/* Flawfinder: ignore */
+	filename = std::string("../../indra/llmessage/message_prehash.cpp");
+	fp = LLFile::fopen(filename, "w");	/* Flawfinder: ignore */
 	if (fp)
 	{
 		fprintf(
@@ -2493,7 +2491,7 @@ bool start_messaging_system(
 	bool failure_is_fatal)
 {
 	gMessageSystem = new LLMessageSystem(
-		template_name.c_str(),
+		template_name,
 		port, 
 		version_major, 
 		version_minor, 
@@ -2587,79 +2585,79 @@ void LLMessageSystem::stopLogging()
 
 void LLMessageSystem::summarizeLogs(std::ostream& str)
 {
-	char buffer[MAX_STRING];  	/* Flawfinder: ignore */ 
-	char tmp_str[MAX_STRING];	 /* Flawfinder: ignore */ 
+ 	std::string buffer;
+	std::string tmp_str;
 	F32 run_time = mMessageSystemTimer.getElapsedTimeF32();
 	str << "START MESSAGE LOG SUMMARY" << std::endl;
-	snprintf(buffer, MAX_STRING, "Run time: %12.3f seconds", run_time);	/* Flawfinder: ignore */
+	buffer = llformat( "Run time: %12.3f seconds", run_time);
 
 	// Incoming
 	str << buffer << std::endl << "Incoming:" << std::endl;
-	U64_to_str(mTotalBytesIn, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total bytes received:      %20s (%5.2f kbits per second)", tmp_str, ((F32)mTotalBytesIn * 0.008f) / run_time);	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mTotalBytesIn);
+	buffer = llformat( "Total bytes received:      %20s (%5.2f kbits per second)", tmp_str.c_str(), ((F32)mTotalBytesIn * 0.008f) / run_time);
 	str << buffer << std::endl;
-	U64_to_str(mPacketsIn, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total packets received:    %20s (%5.2f packets per second)", tmp_str, ((F32) mPacketsIn / run_time));	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mPacketsIn);
+	buffer = llformat( "Total packets received:    %20s (%5.2f packets per second)", tmp_str.c_str(), ((F32) mPacketsIn / run_time));
 	str << buffer << std::endl;
-	snprintf(buffer, MAX_STRING, "Average packet size:       %20.0f bytes", (F32)mTotalBytesIn / (F32)mPacketsIn);	/* Flawfinder: ignore */
+	buffer = llformat( "Average packet size:       %20.0f bytes", (F32)mTotalBytesIn / (F32)mPacketsIn);
 	str << buffer << std::endl;
-	U64_to_str(mReliablePacketsIn, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total reliable packets:    %20s (%5.2f%%)", tmp_str, 100.f * ((F32) mReliablePacketsIn)/((F32) mPacketsIn + 1));		/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mReliablePacketsIn);
+	buffer = llformat( "Total reliable packets:    %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mReliablePacketsIn)/((F32) mPacketsIn + 1));
 	str << buffer << std::endl;
-	U64_to_str(mCompressedPacketsIn, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total compressed packets:  %20s (%5.2f%%)", tmp_str, 100.f * ((F32) mCompressedPacketsIn)/((F32) mPacketsIn + 1));	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mCompressedPacketsIn);
+	buffer = llformat( "Total compressed packets:  %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mCompressedPacketsIn)/((F32) mPacketsIn + 1));
 	str << buffer << std::endl;
 	S64 savings = mUncompressedBytesIn - mCompressedBytesIn;
-	U64_to_str(savings, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total compression savings: %20s bytes", tmp_str);	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(savings);
+	buffer = llformat( "Total compression savings: %20s bytes", tmp_str.c_str());
 	str << buffer << std::endl;
-	U64_to_str(savings/(mCompressedPacketsIn +1), tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str, ((F32) mUncompressedBytesIn)/((F32) mCompressedBytesIn+1));	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(savings/(mCompressedPacketsIn +1));
+	buffer = llformat( "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mUncompressedBytesIn)/((F32) mCompressedBytesIn+1));
 	str << buffer << std::endl;
-	U64_to_str(savings/(mPacketsIn+1), tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str, ((F32) mTotalBytesIn + (F32) savings)/((F32) mTotalBytesIn + 1.f));	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(savings/(mPacketsIn+1));
+	buffer = llformat( "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mTotalBytesIn + (F32) savings)/((F32) mTotalBytesIn + 1.f));
 
 	// Outgoing
 	str << buffer << std::endl << std::endl << "Outgoing:" << std::endl;
-	U64_to_str(mTotalBytesOut, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total bytes sent:          %20s (%5.2f kbits per second)", tmp_str, ((F32)mTotalBytesOut * 0.008f) / run_time );	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mTotalBytesOut);
+	buffer = llformat( "Total bytes sent:          %20s (%5.2f kbits per second)", tmp_str.c_str(), ((F32)mTotalBytesOut * 0.008f) / run_time );
 	str << buffer << std::endl;
-	U64_to_str(mPacketsOut, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total packets sent:        %20s (%5.2f packets per second)", tmp_str, ((F32)mPacketsOut / run_time));	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mPacketsOut);
+	buffer = llformat( "Total packets sent:        %20s (%5.2f packets per second)", tmp_str.c_str(), ((F32)mPacketsOut / run_time));
 	str << buffer << std::endl;
-	snprintf(buffer, MAX_STRING, "Average packet size:       %20.0f bytes", (F32)mTotalBytesOut / (F32)mPacketsOut);	/* Flawfinder: ignore */
+	buffer = llformat( "Average packet size:       %20.0f bytes", (F32)mTotalBytesOut / (F32)mPacketsOut);
 	str << buffer << std::endl;
-	U64_to_str(mReliablePacketsOut, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total reliable packets:    %20s (%5.2f%%)", tmp_str, 100.f * ((F32) mReliablePacketsOut)/((F32) mPacketsOut + 1));		/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mReliablePacketsOut);
+	buffer = llformat( "Total reliable packets:    %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mReliablePacketsOut)/((F32) mPacketsOut + 1));
 	str << buffer << std::endl;
-	U64_to_str(mCompressedPacketsOut, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total compressed packets:  %20s (%5.2f%%)", tmp_str, 100.f * ((F32) mCompressedPacketsOut)/((F32) mPacketsOut + 1));		/* Flawfinder: ignore */
+	tmp_str = U64_to_str(mCompressedPacketsOut);
+	buffer = llformat( "Total compressed packets:  %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mCompressedPacketsOut)/((F32) mPacketsOut + 1));
 	str << buffer << std::endl;
 	savings = mUncompressedBytesOut - mCompressedBytesOut;
-	U64_to_str(savings, tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Total compression savings: %20s bytes", tmp_str);	/* Flawfinder: ignore */
+	tmp_str = U64_to_str(savings);
+	buffer = llformat( "Total compression savings: %20s bytes", tmp_str.c_str());
 	str << buffer << std::endl;
-	U64_to_str(savings/(mCompressedPacketsOut +1), tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str, ((F32) mUncompressedBytesOut)/((F32) mCompressedBytesOut+1));		/* Flawfinder: ignore */
+	tmp_str = U64_to_str(savings/(mCompressedPacketsOut +1));
+	buffer = llformat( "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mUncompressedBytesOut)/((F32) mCompressedBytesOut+1));
 	str << buffer << std::endl;
-	U64_to_str(savings/(mPacketsOut+1), tmp_str, sizeof(tmp_str));
-	snprintf(buffer, MAX_STRING, "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str, ((F32) mTotalBytesOut + (F32) savings)/((F32) mTotalBytesOut + 1.f));		/* Flawfinder: ignore */
+	tmp_str = U64_to_str(savings/(mPacketsOut+1));
+	buffer = llformat( "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mTotalBytesOut + (F32) savings)/((F32) mTotalBytesOut + 1.f));
 	str << buffer << std::endl << std::endl;
-	snprintf(buffer, MAX_STRING, "SendPacket failures:       %20d", mSendPacketFailureCount);	/* Flawfinder: ignore */
+	buffer = llformat( "SendPacket failures:       %20d", mSendPacketFailureCount);
 	str << buffer << std::endl;
-	snprintf(buffer, MAX_STRING, "Dropped packets:           %20d", mDroppedPackets);	/* Flawfinder: ignore */
+	buffer = llformat( "Dropped packets:           %20d", mDroppedPackets);
 	str << buffer << std::endl;
-	snprintf(buffer, MAX_STRING, "Resent packets:            %20d", mResentPackets);	/* Flawfinder: ignore */
+	buffer = llformat( "Resent packets:            %20d", mResentPackets);
 	str << buffer << std::endl;
-	snprintf(buffer, MAX_STRING, "Failed reliable resends:   %20d", mFailedResendPackets);	/* Flawfinder: ignore */
+	buffer = llformat( "Failed reliable resends:   %20d", mFailedResendPackets);
 	str << buffer << std::endl;
-	snprintf(buffer, MAX_STRING, "Off-circuit rejected packets: %17d", mOffCircuitPackets);	/* Flawfinder: ignore */
+	buffer = llformat( "Off-circuit rejected packets: %17d", mOffCircuitPackets);
 	str << buffer << std::endl;
-	snprintf(buffer, MAX_STRING, "On-circuit invalid packets:   %17d", mInvalidOnCircuitPackets);		/* Flawfinder: ignore */
+	buffer = llformat( "On-circuit invalid packets:   %17d", mInvalidOnCircuitPackets);
 	str << buffer << std::endl << std::endl;
 
 	str << "Decoding: " << std::endl;
-	snprintf(buffer, MAX_STRING, "%35s%10s%10s%10s%10s", "Message", "Count", "Time", "Max", "Avg");	/* Flawfinder: ignore */
+	buffer = llformat( "%35s%10s%10s%10s%10s", "Message", "Count", "Time", "Max", "Avg");
 	str << buffer << std:: endl;	
 	F32 avg;
 	for (message_template_name_map_t::const_iterator iter = mMessageTemplates.begin(),
@@ -2670,7 +2668,7 @@ void LLMessageSystem::summarizeLogs(std::ostream& str)
 		if(mt->mTotalDecoded > 0)
 		{
 			avg = mt->mTotalDecodeTime / (F32)mt->mTotalDecoded;
-			snprintf(buffer, MAX_STRING, "%35s%10u%10f%10f%10f", mt->mName, mt->mTotalDecoded, mt->mTotalDecodeTime, mt->mMaxDecodeTimePerMsg, avg);	/* Flawfinder: ignore */
+			buffer = llformat( "%35s%10u%10f%10f%10f", mt->mName, mt->mTotalDecoded, mt->mTotalDecodeTime, mt->mMaxDecodeTimePerMsg, avg);
 			str << buffer << std::endl;
 		}
 	}
@@ -3936,6 +3934,20 @@ void LLMessageSystem::getString(const char *block, const char *var,
 				  blocknum);
 }
 
+void LLMessageSystem::getStringFast(const char *block, const char *var, 
+									std::string& outstr, S32 blocknum)
+{
+	mMessageReader->getString(block, var, outstr, blocknum);
+}
+
+void LLMessageSystem::getString(const char *block, const char *var, 
+								std::string& outstr, S32 blocknum )
+{
+	getStringFast(LLMessageStringTable::getInstance()->getString(block), 
+				  LLMessageStringTable::getInstance()->getString(var), outstr, 
+				  blocknum);
+}
+
 S32	LLMessageSystem::getNumberOfBlocksFast(const char *blockname)
 {
 	return mMessageReader->getNumberOfBlocks(blockname);
diff --git a/indra/llmessage/message.h b/indra/llmessage/message.h
index 7462e1b1df..e2d2ed46e2 100644
--- a/indra/llmessage/message.h
+++ b/indra/llmessage/message.h
@@ -283,7 +283,7 @@ public:
 
 public:
 	// Read file and build message templates
-	LLMessageSystem(const char *filename, U32 port, S32 version_major,
+	LLMessageSystem(const std::string& filename, U32 port, S32 version_major,
 					S32 version_minor, S32 version_patch,
 					bool failure_is_fatal = true);
 
@@ -295,7 +295,7 @@ public:
 	// Read file and build message templates filename must point to a
 	// valid string which specifies the path of a valid linden
 	// template.
-	void loadTemplateFile(const char* filename, bool failure_is_fatal);
+	void loadTemplateFile(const std::string& filename, bool failure_is_fatal);
 
 
 	// methods for building, sending, receiving, and handling messages
@@ -516,6 +516,8 @@ public:
 	void	getIPPort(	const char *block, const char *var, U16 &port, S32 blocknum = 0);
 	void getStringFast(	const char *block, const char *var, S32 buffer_size, char *buffer, S32 blocknum = 0);
 	void	getString(	const char *block, const char *var, S32 buffer_size, char *buffer, S32 blocknum = 0);
+	void getStringFast(	const char *block, const char *var, std::string& outstr, S32 blocknum = 0);
+	void	getString(	const char *block, const char *var, std::string& outstr, S32 blocknum = 0);
 
 
 	// Utility functions to generate a replay-resistant digest check