#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

1 files changed, 956 insertions, 956 deletions

diff --git a/indra/llmessage/llxfermanager.cpp b/indra/llmessage/llxfermanager.cpp
index f9b59d7e42..ea1fe0a963 100644
--- a/indra/llmessage/llxfermanager.cpp
+++ b/indra/llmessage/llxfermanager.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llxfermanager.cpp
  * @brief implementation of LLXferManager class for a collection of xfers
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -46,7 +46,7 @@ const S32 LL_DEFAULT_MAX_REQUEST_FIFO_XFERS = 1000;
 
 // Kills the connection if a viewer download queue hits this many requests backed up
 // Also set in simulator.xml at "hard_limit_outgoing_xfers_per_circuit"
-const S32 LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS = 500;	
+const S32 LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS = 500;
 
 // Use this to show sending some ConfirmXferPacket messages
 //#define LL_XFER_PROGRESS_MESSAGES 1
@@ -58,88 +58,88 @@ const S32 LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS = 500;
 
 LLXferManager::LLXferManager ()
 {
-	init();
+    init();
 }
 
 ///////////////////////////////////////////////////////////
 
 LLXferManager::~LLXferManager ()
 {
-	cleanup();
+    cleanup();
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::init()
 {
-	cleanup();
+    cleanup();
 
-	setMaxOutgoingXfersPerCircuit(LL_DEFAULT_MAX_SIMULTANEOUS_XFERS);
-	setHardLimitOutgoingXfersPerCircuit(LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS);
-	setMaxIncomingXfers(LL_DEFAULT_MAX_REQUEST_FIFO_XFERS);
+    setMaxOutgoingXfersPerCircuit(LL_DEFAULT_MAX_SIMULTANEOUS_XFERS);
+    setHardLimitOutgoingXfersPerCircuit(LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS);
+    setMaxIncomingXfers(LL_DEFAULT_MAX_REQUEST_FIFO_XFERS);
 
-	// Turn on or off ack throttling
-	mUseAckThrottling = FALSE;
-	setAckThrottleBPS(100000);
+    // Turn on or off ack throttling
+    mUseAckThrottling = FALSE;
+    setAckThrottleBPS(100000);
 }
-	
+
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::cleanup ()
 {
-	for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer());
-	mOutgoingHosts.clear();
+    for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer());
+    mOutgoingHosts.clear();
 
-	for_each(mSendList.begin(), mSendList.end(), DeletePointer());
-	mSendList.clear();
+    for_each(mSendList.begin(), mSendList.end(), DeletePointer());
+    mSendList.clear();
 
-	for_each(mReceiveList.begin(), mReceiveList.end(), DeletePointer());
-	mReceiveList.clear();
+    for_each(mReceiveList.begin(), mReceiveList.end(), DeletePointer());
+    mReceiveList.clear();
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::setMaxIncomingXfers(S32 max_num)
 {
-	mMaxIncomingXfers = max_num;
+    mMaxIncomingXfers = max_num;
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::setMaxOutgoingXfersPerCircuit(S32 max_num)
 {
-	mMaxOutgoingXfersPerCircuit = max_num;
+    mMaxOutgoingXfersPerCircuit = max_num;
 }
 
 void LLXferManager::setHardLimitOutgoingXfersPerCircuit(S32 max_num)
 {
-	mHardLimitOutgoingXfersPerCircuit = max_num;
+    mHardLimitOutgoingXfersPerCircuit = max_num;
 }
 
 void LLXferManager::setUseAckThrottling(const BOOL use)
 {
-	mUseAckThrottling = use;
+    mUseAckThrottling = use;
 }
 
 void LLXferManager::setAckThrottleBPS(const F32 bps)
 {
-	// Let's figure out the min we can set based on the ack retry rate
-	// and number of simultaneous.
-
-	// Assuming we're running as slow as possible, this is the lowest ack
-	// rate we can use.
-	F32 min_bps = (1000.f * 8.f* mMaxIncomingXfers) / LL_PACKET_TIMEOUT;
-
-	// Set
-	F32 actual_rate = llmax(min_bps*1.1f, bps);
-	LL_DEBUGS("AppInit") << "LLXferManager ack throttle min rate: " << min_bps << LL_ENDL;
-	LL_DEBUGS("AppInit") << "LLXferManager ack throttle actual rate: " << actual_rate << LL_ENDL;
-	#ifdef LL_XFER_DIAGNOISTIC_LOGGING
-	LL_INFOS("Xfer") << "LLXferManager ack throttle min rate: " << min_bps << LL_ENDL;
-	LL_INFOS("Xfer") << "LLXferManager ack throttle actual rate: " << actual_rate << LL_ENDL;
-	#endif // LL_XFER_DIAGNOISTIC_LOGGING
-
-	mAckThrottle.setRate(actual_rate);
+    // Let's figure out the min we can set based on the ack retry rate
+    // and number of simultaneous.
+
+    // Assuming we're running as slow as possible, this is the lowest ack
+    // rate we can use.
+    F32 min_bps = (1000.f * 8.f* mMaxIncomingXfers) / LL_PACKET_TIMEOUT;
+
+    // Set
+    F32 actual_rate = llmax(min_bps*1.1f, bps);
+    LL_DEBUGS("AppInit") << "LLXferManager ack throttle min rate: " << min_bps << LL_ENDL;
+    LL_DEBUGS("AppInit") << "LLXferManager ack throttle actual rate: " << actual_rate << LL_ENDL;
+    #ifdef LL_XFER_DIAGNOISTIC_LOGGING
+    LL_INFOS("Xfer") << "LLXferManager ack throttle min rate: " << min_bps << LL_ENDL;
+    LL_INFOS("Xfer") << "LLXferManager ack throttle actual rate: " << actual_rate << LL_ENDL;
+    #endif // LL_XFER_DIAGNOISTIC_LOGGING
+
+    mAckThrottle.setRate(actual_rate);
 }
 
 
@@ -147,69 +147,69 @@ void LLXferManager::setAckThrottleBPS(const F32 bps)
 
 void LLXferManager::updateHostStatus()
 {
-	// Clear the outgoing host list
-	for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer());
-	mOutgoingHosts.clear();
-	
-	// Loop through all outgoing xfers and re-build mOutgoingHosts
-	for (xfer_list_t::iterator send_iter = mSendList.begin();
-			send_iter != mSendList.end(); ++send_iter)
-	{
-		LLHostStatus *host_statusp = NULL;
-		for (status_list_t::iterator iter = mOutgoingHosts.begin();
-			 iter != mOutgoingHosts.end(); ++iter)
-		{
-			if ((*iter)->mHost == (*send_iter)->mRemoteHost)
-			{	// Already have this host
-				host_statusp = *iter;
-				break;
-			}
-		}
-		if (!host_statusp)
-		{	// Don't have this host, so add it
-			host_statusp = new LLHostStatus();
-			if (host_statusp)
-			{
-				host_statusp->mHost = (*send_iter)->mRemoteHost;
-				mOutgoingHosts.push_front(host_statusp);
-			}
-		}
-		if (host_statusp)
-		{	// Do the accounting
-			if ((*send_iter)->mStatus == e_LL_XFER_PENDING)
-			{
-				host_statusp->mNumPending++;
-			}
-			else if ((*send_iter)->mStatus == e_LL_XFER_IN_PROGRESS)
-			{
-				host_statusp->mNumActive++;
-			}
-		}
-	}	
+    // Clear the outgoing host list
+    for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer());
+    mOutgoingHosts.clear();
+
+    // Loop through all outgoing xfers and re-build mOutgoingHosts
+    for (xfer_list_t::iterator send_iter = mSendList.begin();
+            send_iter != mSendList.end(); ++send_iter)
+    {
+        LLHostStatus *host_statusp = NULL;
+        for (status_list_t::iterator iter = mOutgoingHosts.begin();
+             iter != mOutgoingHosts.end(); ++iter)
+        {
+            if ((*iter)->mHost == (*send_iter)->mRemoteHost)
+            {   // Already have this host
+                host_statusp = *iter;
+                break;
+            }
+        }
+        if (!host_statusp)
+        {   // Don't have this host, so add it
+            host_statusp = new LLHostStatus();
+            if (host_statusp)
+            {
+                host_statusp->mHost = (*send_iter)->mRemoteHost;
+                mOutgoingHosts.push_front(host_statusp);
+            }
+        }
+        if (host_statusp)
+        {   // Do the accounting
+            if ((*send_iter)->mStatus == e_LL_XFER_PENDING)
+            {
+                host_statusp->mNumPending++;
+            }
+            else if ((*send_iter)->mStatus == e_LL_XFER_IN_PROGRESS)
+            {
+                host_statusp->mNumActive++;
+            }
+        }
+    }
 
 #ifdef LL_XFER_DIAGNOISTIC_LOGGING
-	for (xfer_list_t::iterator send_iter = mSendList.begin();
-			send_iter != mSendList.end(); ++send_iter)
-	{
-		LLXfer * xferp = *send_iter;
-		LL_INFOS("Xfer") << "xfer to host " << xferp->mRemoteHost
-			<< " is " << xferp->mXferSize << " bytes"
-			<< ", status " << (S32)(xferp->mStatus)
-			<< ", waiting for ACK: " << (S32)(xferp->mWaitingForACK)
-			<< " in frame " << (S32) LLFrameTimer::getFrameCount()
-			<< LL_ENDL;
-	}
-
-	for (status_list_t::iterator iter = mOutgoingHosts.begin();
-		 iter != mOutgoingHosts.end(); ++iter)
-	{
-		LL_INFOS("Xfer") << "LLXfer host " << (*iter)->mHost.getIPandPort() 
-			<< " has " << (*iter)->mNumActive
-			<< " active, " << (*iter)->mNumPending
-			<< " pending" 
-			<< " in frame " << (S32) LLFrameTimer::getFrameCount()
-			<< LL_ENDL;
-	}
+    for (xfer_list_t::iterator send_iter = mSendList.begin();
+            send_iter != mSendList.end(); ++send_iter)
+    {
+        LLXfer * xferp = *send_iter;
+        LL_INFOS("Xfer") << "xfer to host " << xferp->mRemoteHost
+            << " is " << xferp->mXferSize << " bytes"
+            << ", status " << (S32)(xferp->mStatus)
+            << ", waiting for ACK: " << (S32)(xferp->mWaitingForACK)
+            << " in frame " << (S32) LLFrameTimer::getFrameCount()
+            << LL_ENDL;
+    }
+
+    for (status_list_t::iterator iter = mOutgoingHosts.begin();
+         iter != mOutgoingHosts.end(); ++iter)
+    {
+        LL_INFOS("Xfer") << "LLXfer host " << (*iter)->mHost.getIPandPort()
+            << " has " << (*iter)->mNumActive
+            << " active, " << (*iter)->mNumPending
+            << " pending"
+            << " in frame " << (S32) LLFrameTimer::getFrameCount()
+            << LL_ENDL;
+    }
 #endif // LL_XFER_DIAGNOISTIC_LOGGING
 
 }
@@ -218,34 +218,34 @@ void LLXferManager::updateHostStatus()
 
 void LLXferManager::printHostStatus()
 {
-	LLHostStatus *host_statusp = NULL;
-	if (!mOutgoingHosts.empty())
-	{
-		LL_INFOS("Xfer") << "Outgoing Xfers:" << LL_ENDL;
-
-		for (status_list_t::iterator iter = mOutgoingHosts.begin();
-			 iter != mOutgoingHosts.end(); ++iter)
-		{
-			host_statusp = *iter;
-			LL_INFOS("Xfer") << "    " << host_statusp->mHost << "  active: " << host_statusp->mNumActive << "  pending: " << host_statusp->mNumPending << LL_ENDL;
-		}
-	}	
+    LLHostStatus *host_statusp = NULL;
+    if (!mOutgoingHosts.empty())
+    {
+        LL_INFOS("Xfer") << "Outgoing Xfers:" << LL_ENDL;
+
+        for (status_list_t::iterator iter = mOutgoingHosts.begin();
+             iter != mOutgoingHosts.end(); ++iter)
+        {
+            host_statusp = *iter;
+            LL_INFOS("Xfer") << "    " << host_statusp->mHost << "  active: " << host_statusp->mNumActive << "  pending: " << host_statusp->mNumPending << LL_ENDL;
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////
 
 LLXfer * LLXferManager::findXferByID(U64 id, xfer_list_t & xfer_list)
 {
-	for (xfer_list_t::iterator iter = xfer_list.begin();
-		 iter != xfer_list.end();
-		 ++iter)
-	{
-		if ((*iter)->mID == id)
-		{
-			return(*iter);
-		}
-	}
-	return(NULL);
+    for (xfer_list_t::iterator iter = xfer_list.begin();
+         iter != xfer_list.end();
+         ++iter)
+    {
+        if ((*iter)->mID == id)
+        {
+            return(*iter);
+        }
+    }
+    return(NULL);
 }
 
 
@@ -254,270 +254,270 @@ LLXfer * LLXferManager::findXferByID(U64 id, xfer_list_t & xfer_list)
 // WARNING:  this invalidates iterators from xfer_list
 void LLXferManager::removeXfer(LLXfer *delp, xfer_list_t & xfer_list)
 {
-	if (delp)
-	{	
-		std::string direction = "send";
-		if (&xfer_list == &mReceiveList)
-		{
-			direction = "receive";
-		}
-
-		// This assumes that delp will occur in the list once at most
-		// Find the pointer in the list
-		for (xfer_list_t::iterator iter = xfer_list.begin();
-			 iter != xfer_list.end();
-			 ++iter)
-		{
-			if ((*iter) == delp)
-			{
-				LL_DEBUGS("Xfer") << "Deleting xfer to host " << (*iter)->mRemoteHost
-					<< " of " << (*iter)->mXferSize << " bytes"
-					<< ", status " << (S32)((*iter)->mStatus)
-					<< " from the " << direction << " list"
-					<< LL_ENDL;
-
-				xfer_list.erase(iter);
-				delete (delp);
-				break;
-			}
-		}
-	}
+    if (delp)
+    {
+        std::string direction = "send";
+        if (&xfer_list == &mReceiveList)
+        {
+            direction = "receive";
+        }
+
+        // This assumes that delp will occur in the list once at most
+        // Find the pointer in the list
+        for (xfer_list_t::iterator iter = xfer_list.begin();
+             iter != xfer_list.end();
+             ++iter)
+        {
+            if ((*iter) == delp)
+            {
+                LL_DEBUGS("Xfer") << "Deleting xfer to host " << (*iter)->mRemoteHost
+                    << " of " << (*iter)->mXferSize << " bytes"
+                    << ", status " << (S32)((*iter)->mStatus)
+                    << " from the " << direction << " list"
+                    << LL_ENDL;
+
+                xfer_list.erase(iter);
+                delete (delp);
+                break;
+            }
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////
 
 LLHostStatus * LLXferManager::findHostStatus(const LLHost &host)
 {
-	LLHostStatus *host_statusp = NULL;
-
-	for (status_list_t::iterator iter = mOutgoingHosts.begin();
-		 iter != mOutgoingHosts.end(); ++iter)
-	{
-		host_statusp = *iter;
-		if (host_statusp->mHost == host)
-		{
-			return (host_statusp);
-		}
-	}
-	return 0;
+    LLHostStatus *host_statusp = NULL;
+
+    for (status_list_t::iterator iter = mOutgoingHosts.begin();
+         iter != mOutgoingHosts.end(); ++iter)
+    {
+        host_statusp = *iter;
+        if (host_statusp->mHost == host)
+        {
+            return (host_statusp);
+        }
+    }
+    return 0;
 }
 
 ///////////////////////////////////////////////////////////
- 
+
 S32 LLXferManager::numPendingXfers(const LLHost &host)
 {
-	LLHostStatus *host_statusp = findHostStatus(host);
-	if (host_statusp)
-	{
-		return host_statusp->mNumPending;
-	}
-	return 0;
+    LLHostStatus *host_statusp = findHostStatus(host);
+    if (host_statusp)
+    {
+        return host_statusp->mNumPending;
+    }
+    return 0;
 }
 
 ///////////////////////////////////////////////////////////
 
 S32 LLXferManager::numActiveXfers(const LLHost &host)
 {
-	LLHostStatus *host_statusp = findHostStatus(host);
-	if (host_statusp)
-	{
-		return host_statusp->mNumActive;
-	}
-	return 0;
+    LLHostStatus *host_statusp = findHostStatus(host);
+    if (host_statusp)
+    {
+        return host_statusp->mNumActive;
+    }
+    return 0;
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::changeNumActiveXfers(const LLHost &host, S32 delta)
 {
-	LLHostStatus *host_statusp = NULL;
-
-	for (status_list_t::iterator iter = mOutgoingHosts.begin();
-		 iter != mOutgoingHosts.end(); ++iter)
-	{
-		host_statusp = *iter;
-		if (host_statusp->mHost == host)
-		{
-			host_statusp->mNumActive += delta;
-		}
-	}
+    LLHostStatus *host_statusp = NULL;
+
+    for (status_list_t::iterator iter = mOutgoingHosts.begin();
+         iter != mOutgoingHosts.end(); ++iter)
+    {
+        host_statusp = *iter;
+        if (host_statusp->mHost == host)
+        {
+            host_statusp->mNumActive += delta;
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::registerCallbacks(LLMessageSystem *msgsystem)
 {
-	msgsystem->setHandlerFuncFast(_PREHASH_ConfirmXferPacket,  process_confirm_packet, NULL);
-	msgsystem->setHandlerFuncFast(_PREHASH_RequestXfer,        process_request_xfer,        NULL);
-	msgsystem->setHandlerFuncFast(_PREHASH_SendXferPacket,	   	continue_file_receive,		 NULL);
-	msgsystem->setHandlerFuncFast(_PREHASH_AbortXfer, 	   	process_abort_xfer,		     NULL);
+    msgsystem->setHandlerFuncFast(_PREHASH_ConfirmXferPacket,  process_confirm_packet, NULL);
+    msgsystem->setHandlerFuncFast(_PREHASH_RequestXfer,        process_request_xfer,        NULL);
+    msgsystem->setHandlerFuncFast(_PREHASH_SendXferPacket,      continue_file_receive,       NULL);
+    msgsystem->setHandlerFuncFast(_PREHASH_AbortXfer,       process_abort_xfer,          NULL);
 }
 
 ///////////////////////////////////////////////////////////
 
 U64 LLXferManager::getNextID ()
 {
-	LLUUID a_guid;
+    LLUUID a_guid;
+
+    a_guid.generate();
 
-	a_guid.generate();
 
-	
-	return(*((U64*)(a_guid.mData)));
+    return(*((U64*)(a_guid.mData)));
 }
 
 ///////////////////////////////////////////////////////////
 
 S32 LLXferManager::encodePacketNum(S32 packet_num, BOOL is_EOF)
 {
-	if (is_EOF)
-	{
-		packet_num |= 0x80000000;
-	}
-	return packet_num;
+    if (is_EOF)
+    {
+        packet_num |= 0x80000000;
+    }
+    return packet_num;
 }
 
 ///////////////////////////////////////////////////////////
 
 S32 LLXferManager::decodePacketNum(S32 packet_num)
 {
-	return(packet_num & 0x0FFFFFFF);
+    return(packet_num & 0x0FFFFFFF);
 }
 
 ///////////////////////////////////////////////////////////
 
 BOOL LLXferManager::isLastPacket(S32 packet_num)
 {
-	return(packet_num & 0x80000000);
+    return(packet_num & 0x80000000);
 }
 
 ///////////////////////////////////////////////////////////
 
 U64 LLXferManager::requestFile(const std::string& local_filename,
-								const std::string& remote_filename,
-								ELLPath remote_path,
-								const LLHost& remote_host,
-								BOOL delete_remote_on_completion,
-								void (*callback)(void**,S32,LLExtStat),
-								void** user_data,
-								BOOL is_priority,
-								BOOL use_big_packets)
+                                const std::string& remote_filename,
+                                ELLPath remote_path,
+                                const LLHost& remote_host,
+                                BOOL delete_remote_on_completion,
+                                void (*callback)(void**,S32,LLExtStat),
+                                void** user_data,
+                                BOOL is_priority,
+                                BOOL use_big_packets)
 {
-	LLXfer_File* file_xfer_p = NULL;
-
-	// First check to see if it's already requested
-	for (xfer_list_t::iterator iter = mReceiveList.begin();
-			iter != mReceiveList.end(); ++iter)
-	{
-		if ((*iter)->getXferTypeTag() == LLXfer::XFER_FILE)
-		{
-			file_xfer_p = (LLXfer_File*)(*iter);
-			if (file_xfer_p->matchesLocalFilename(local_filename)
-				&& file_xfer_p->matchesRemoteFilename(remote_filename, remote_path)
-				&& (remote_host == file_xfer_p->mRemoteHost)
-				&& (callback == file_xfer_p->mCallback)
-				&& (user_data == file_xfer_p->mCallbackDataHandle))
-			{
-				// Already have the request	(already in progress)
-				return (*iter)->mID;
-			}
-		}
-	}
-
-	U64 xfer_id = 0;
-
-	S32 chunk_size = use_big_packets ? LL_XFER_LARGE_PAYLOAD : -1;
-	file_xfer_p = new LLXfer_File(chunk_size);
-	if (file_xfer_p)
-	{
-		addToList(file_xfer_p, mReceiveList, is_priority);
-
-		// Remove any file by the same name that happens to be lying
-		// around.
-		// 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 &&
-		   (remote_filename.substr(remote_filename.length()-4) == ".tmp"))
-		{
-			LLFile::remove(local_filename, ENOENT);
-		}
-		xfer_id = getNextID();
-		file_xfer_p->initializeRequest(
-			xfer_id,
-			local_filename,
-			remote_filename,
-			remote_path,
-			remote_host,
-			delete_remote_on_completion,
-			callback,user_data);
-		startPendingDownloads();
-	}
-	else
-	{
-		LL_ERRS("Xfer") << "Xfer allocation error" << LL_ENDL;
-	}
-	return xfer_id;
+    LLXfer_File* file_xfer_p = NULL;
+
+    // First check to see if it's already requested
+    for (xfer_list_t::iterator iter = mReceiveList.begin();
+            iter != mReceiveList.end(); ++iter)
+    {
+        if ((*iter)->getXferTypeTag() == LLXfer::XFER_FILE)
+        {
+            file_xfer_p = (LLXfer_File*)(*iter);
+            if (file_xfer_p->matchesLocalFilename(local_filename)
+                && file_xfer_p->matchesRemoteFilename(remote_filename, remote_path)
+                && (remote_host == file_xfer_p->mRemoteHost)
+                && (callback == file_xfer_p->mCallback)
+                && (user_data == file_xfer_p->mCallbackDataHandle))
+            {
+                // Already have the request (already in progress)
+                return (*iter)->mID;
+            }
+        }
+    }
+
+    U64 xfer_id = 0;
+
+    S32 chunk_size = use_big_packets ? LL_XFER_LARGE_PAYLOAD : -1;
+    file_xfer_p = new LLXfer_File(chunk_size);
+    if (file_xfer_p)
+    {
+        addToList(file_xfer_p, mReceiveList, is_priority);
+
+        // Remove any file by the same name that happens to be lying
+        // around.
+        // 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 &&
+           (remote_filename.substr(remote_filename.length()-4) == ".tmp"))
+        {
+            LLFile::remove(local_filename, ENOENT);
+        }
+        xfer_id = getNextID();
+        file_xfer_p->initializeRequest(
+            xfer_id,
+            local_filename,
+            remote_filename,
+            remote_path,
+            remote_host,
+            delete_remote_on_completion,
+            callback,user_data);
+        startPendingDownloads();
+    }
+    else
+    {
+        LL_ERRS("Xfer") << "Xfer allocation error" << LL_ENDL;
+    }
+    return xfer_id;
 }
 
 void LLXferManager::requestVFile(const LLUUID& local_id,
-								 const LLUUID& remote_id,
-								 LLAssetType::EType type,
-								 const LLHost& remote_host,
-								 void (*callback)(void**,S32,LLExtStat),
-								 void** user_data,
-								 BOOL is_priority)
+                                 const LLUUID& remote_id,
+                                 LLAssetType::EType type,
+                                 const LLHost& remote_host,
+                                 void (*callback)(void**,S32,LLExtStat),
+                                 void** user_data,
+                                 BOOL is_priority)
 {
-	LLXfer_VFile * xfer_p = NULL;
-
-	for (xfer_list_t::iterator iter = mReceiveList.begin();
-			iter != mReceiveList.end(); ++iter)
-	{	// Find any matching existing requests
-		if ((*iter)->getXferTypeTag() == LLXfer::XFER_VFILE)
-		{
-			xfer_p = (LLXfer_VFile*) (*iter);
-			if (xfer_p->matchesLocalFile(local_id, type)
-				&& xfer_p->matchesRemoteFile(remote_id, type)
-				&& (remote_host == xfer_p->mRemoteHost)
-				&& (callback == xfer_p->mCallback)
-				&& (user_data == xfer_p->mCallbackDataHandle))
-
-			{	// Have match, don't add a duplicate
-				#ifdef LL_XFER_DIAGNOISTIC_LOGGING
-				LL_INFOS("Xfer") << "Dropping duplicate xfer request for " << remote_id
-					<< " on " << remote_host.getIPandPort()
-					<< " local id " << local_id
-					<< LL_ENDL;
-				#endif	// LL_XFER_DIAGNOISTIC_LOGGING
-
-				return;
-			}
-		}
-	}
-
-	xfer_p = new LLXfer_VFile();
-	if (xfer_p)
-	{
-		#ifdef LL_XFER_DIAGNOISTIC_LOGGING
-		LL_INFOS("Xfer") << "Starting file xfer for " << remote_id
-			<< " type " << LLAssetType::lookupHumanReadable(type)
-			<< " from " << xfer_p->mRemoteHost.getIPandPort()
-			<< ", local id " << local_id
-			<< LL_ENDL;
-		#endif	// LL_XFER_DIAGNOISTIC_LOGGING
-
-		addToList(xfer_p, mReceiveList, is_priority);
-		((LLXfer_VFile *)xfer_p)->initializeRequest(getNextID(),
-			local_id,
-			remote_id,
-			type,
-			remote_host,
-			callback,
-			user_data);
-		startPendingDownloads();
-	}
-	else
-	{
-		LL_ERRS("Xfer") << "Xfer allocation error" << LL_ENDL;
-	}
+    LLXfer_VFile * xfer_p = NULL;
+
+    for (xfer_list_t::iterator iter = mReceiveList.begin();
+            iter != mReceiveList.end(); ++iter)
+    {   // Find any matching existing requests
+        if ((*iter)->getXferTypeTag() == LLXfer::XFER_VFILE)
+        {
+            xfer_p = (LLXfer_VFile*) (*iter);
+            if (xfer_p->matchesLocalFile(local_id, type)
+                && xfer_p->matchesRemoteFile(remote_id, type)
+                && (remote_host == xfer_p->mRemoteHost)
+                && (callback == xfer_p->mCallback)
+                && (user_data == xfer_p->mCallbackDataHandle))
+
+            {   // Have match, don't add a duplicate
+                #ifdef LL_XFER_DIAGNOISTIC_LOGGING
+                LL_INFOS("Xfer") << "Dropping duplicate xfer request for " << remote_id
+                    << " on " << remote_host.getIPandPort()
+                    << " local id " << local_id
+                    << LL_ENDL;
+                #endif  // LL_XFER_DIAGNOISTIC_LOGGING
+
+                return;
+            }
+        }
+    }
+
+    xfer_p = new LLXfer_VFile();
+    if (xfer_p)
+    {
+        #ifdef LL_XFER_DIAGNOISTIC_LOGGING
+        LL_INFOS("Xfer") << "Starting file xfer for " << remote_id
+            << " type " << LLAssetType::lookupHumanReadable(type)
+            << " from " << xfer_p->mRemoteHost.getIPandPort()
+            << ", local id " << local_id
+            << LL_ENDL;
+        #endif  // LL_XFER_DIAGNOISTIC_LOGGING
+
+        addToList(xfer_p, mReceiveList, is_priority);
+        ((LLXfer_VFile *)xfer_p)->initializeRequest(getNextID(),
+            local_id,
+            remote_id,
+            type,
+            remote_host,
+            callback,
+            user_data);
+        startPendingDownloads();
+    }
+    else
+    {
+        LL_ERRS("Xfer") << "Xfer allocation error" << LL_ENDL;
+    }
 
 }
 
@@ -525,105 +525,105 @@ void LLXferManager::requestVFile(const LLUUID& local_id,
 
 void LLXferManager::processReceiveData (LLMessageSystem *mesgsys, void ** /*user_data*/)
 {
-	// there's sometimes an extra 4 bytes added to an xfer payload
-	const S32 BUF_SIZE = LL_XFER_LARGE_PAYLOAD + 4;
-	char fdata_buf[BUF_SIZE];		/* Flawfinder : ignore */
-	S32 fdata_size;
-	U64 id;
-	S32 packetnum;
-	LLXfer * xferp;
-	
-	mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
-	mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Packet, packetnum);
-
-	fdata_size = mesgsys->getSizeFast(_PREHASH_DataPacket,_PREHASH_Data);
-	if (fdata_size < 0 ||
-		fdata_size > BUF_SIZE)
-	{
-		char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
-		LL_WARNS("Xfer") << "Received invalid xfer data size of " << fdata_size
-			<< " in packet number " << packetnum 
-			<< " from " << mesgsys->getSender()
-			<< " for xfer id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF)) 
-			<< LL_ENDL;
-		return;
-	}
-	mesgsys->getBinaryDataFast(_PREHASH_DataPacket, _PREHASH_Data, fdata_buf, fdata_size, 0, BUF_SIZE);
-
-	xferp = findXferByID(id, mReceiveList);
-	if (!xferp)
-	{
-		char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
-		LL_WARNS("Xfer") << "received xfer data from " << mesgsys->getSender()
-			<< " for non-existent xfer id: "
-			<< U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << LL_ENDL;
-		return;
-	}
-
-	S32 xfer_size;
-
-	if (decodePacketNum(packetnum) != xferp->mPacketNum) // is the packet different from what we were expecting?
-	{
-		// confirm it if it was a resend of the last one, since the confirmation might have gotten dropped
-		if (decodePacketNum(packetnum) == (xferp->mPacketNum - 1))
-		{
-			LL_INFOS("Xfer") << "Reconfirming xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet " << packetnum << LL_ENDL; 			sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
-		}
-		else
-		{
-			LL_INFOS("Xfer") << "Ignoring xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " recv'd packet " << packetnum << "; expecting " << xferp->mPacketNum << LL_ENDL;
-		}
-		return;		
-	}
-
-	S32 result = 0;
-
-	if (xferp->mPacketNum == 0) // first packet has size encoded as additional S32 at beginning of data
-	{
-		ntohmemcpy(&xfer_size,fdata_buf,MVT_S32,sizeof(S32));
-		
+    // there's sometimes an extra 4 bytes added to an xfer payload
+    const S32 BUF_SIZE = LL_XFER_LARGE_PAYLOAD + 4;
+    char fdata_buf[BUF_SIZE];       /* Flawfinder : ignore */
+    S32 fdata_size;
+    U64 id;
+    S32 packetnum;
+    LLXfer * xferp;
+
+    mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
+    mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Packet, packetnum);
+
+    fdata_size = mesgsys->getSizeFast(_PREHASH_DataPacket,_PREHASH_Data);
+    if (fdata_size < 0 ||
+        fdata_size > BUF_SIZE)
+    {
+        char U64_BUF[MAX_STRING];       /* Flawfinder : ignore */
+        LL_WARNS("Xfer") << "Received invalid xfer data size of " << fdata_size
+            << " in packet number " << packetnum
+            << " from " << mesgsys->getSender()
+            << " for xfer id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF))
+            << LL_ENDL;
+        return;
+    }
+    mesgsys->getBinaryDataFast(_PREHASH_DataPacket, _PREHASH_Data, fdata_buf, fdata_size, 0, BUF_SIZE);
+
+    xferp = findXferByID(id, mReceiveList);
+    if (!xferp)
+    {
+        char U64_BUF[MAX_STRING];       /* Flawfinder : ignore */
+        LL_WARNS("Xfer") << "received xfer data from " << mesgsys->getSender()
+            << " for non-existent xfer id: "
+            << U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << LL_ENDL;
+        return;
+    }
+
+    S32 xfer_size;
+
+    if (decodePacketNum(packetnum) != xferp->mPacketNum) // is the packet different from what we were expecting?
+    {
+        // confirm it if it was a resend of the last one, since the confirmation might have gotten dropped
+        if (decodePacketNum(packetnum) == (xferp->mPacketNum - 1))
+        {
+            LL_INFOS("Xfer") << "Reconfirming xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet " << packetnum << LL_ENDL;            sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
+        }
+        else
+        {
+            LL_INFOS("Xfer") << "Ignoring xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " recv'd packet " << packetnum << "; expecting " << xferp->mPacketNum << LL_ENDL;
+        }
+        return;
+    }
+
+    S32 result = 0;
+
+    if (xferp->mPacketNum == 0) // first packet has size encoded as additional S32 at beginning of data
+    {
+        ntohmemcpy(&xfer_size,fdata_buf,MVT_S32,sizeof(S32));
+
 // do any necessary things on first packet ie. allocate memory
-		xferp->setXferSize(xfer_size);
-
-		// adjust buffer start and size
-		result = xferp->receiveData(&(fdata_buf[sizeof(S32)]),fdata_size-(sizeof(S32)));
-	}
-	else
-	{
-		result = xferp->receiveData(fdata_buf,fdata_size);
-	}
-	
-	if (result == LL_ERR_CANNOT_OPEN_FILE)
-	{
-			xferp->abort(LL_ERR_CANNOT_OPEN_FILE);
-			removeXfer(xferp,mReceiveList);
-			startPendingDownloads();
-			return;		
-	}
-
-	xferp->mPacketNum++;  // expect next packet
-
-	if (!mUseAckThrottling)
-	{
-		// No throttling, confirm right away
-		sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
-	}
-	else
-	{
-		// Throttling, put on queue to be confirmed later.
-		LLXferAckInfo ack_info;
-		ack_info.mID = id;
-		ack_info.mPacketNum = decodePacketNum(packetnum);
-		ack_info.mRemoteHost = mesgsys->getSender();
-		mXferAckQueue.push_back(ack_info);
-	}
-
-	if (isLastPacket(packetnum))
-	{
-		xferp->processEOF();
-		removeXfer(xferp,mReceiveList);
-		startPendingDownloads();
-	}
+        xferp->setXferSize(xfer_size);
+
+        // adjust buffer start and size
+        result = xferp->receiveData(&(fdata_buf[sizeof(S32)]),fdata_size-(sizeof(S32)));
+    }
+    else
+    {
+        result = xferp->receiveData(fdata_buf,fdata_size);
+    }
+
+    if (result == LL_ERR_CANNOT_OPEN_FILE)
+    {
+            xferp->abort(LL_ERR_CANNOT_OPEN_FILE);
+            removeXfer(xferp,mReceiveList);
+            startPendingDownloads();
+            return;
+    }
+
+    xferp->mPacketNum++;  // expect next packet
+
+    if (!mUseAckThrottling)
+    {
+        // No throttling, confirm right away
+        sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
+    }
+    else
+    {
+        // Throttling, put on queue to be confirmed later.
+        LLXferAckInfo ack_info;
+        ack_info.mID = id;
+        ack_info.mPacketNum = decodePacketNum(packetnum);
+        ack_info.mRemoteHost = mesgsys->getSender();
+        mXferAckQueue.push_back(ack_info);
+    }
+
+    if (isLastPacket(packetnum))
+    {
+        xferp->processEOF();
+        removeXfer(xferp,mReceiveList);
+        startPendingDownloads();
+    }
 }
 
 ///////////////////////////////////////////////////////////
@@ -631,363 +631,363 @@ void LLXferManager::processReceiveData (LLMessageSystem *mesgsys, void ** /*user
 void LLXferManager::sendConfirmPacket (LLMessageSystem *mesgsys, U64 id, S32 packetnum, const LLHost &remote_host)
 {
 #ifdef LL_XFER_PROGRESS_MESSAGES
-	if (!(packetnum % 50))
-	{
-		cout << "confirming xfer packet #" << packetnum << endl;
-	}
+    if (!(packetnum % 50))
+    {
+        cout << "confirming xfer packet #" << packetnum << endl;
+    }
 #endif
-	mesgsys->newMessageFast(_PREHASH_ConfirmXferPacket);
-	mesgsys->nextBlockFast(_PREHASH_XferID);
-	mesgsys->addU64Fast(_PREHASH_ID, id);
-	mesgsys->addU32Fast(_PREHASH_Packet, packetnum);
+    mesgsys->newMessageFast(_PREHASH_ConfirmXferPacket);
+    mesgsys->nextBlockFast(_PREHASH_XferID);
+    mesgsys->addU64Fast(_PREHASH_ID, id);
+    mesgsys->addU32Fast(_PREHASH_Packet, packetnum);
 
-	// Ignore a circuit failure here, we'll catch it with another message
-	mesgsys->sendMessage(remote_host);
+    // Ignore a circuit failure here, we'll catch it with another message
+    mesgsys->sendMessage(remote_host);
 }
 
 ///////////////////////////////////////////////////////////
 
 static bool find_and_remove(std::multiset<std::string>& files,
-		const std::string& filename)
+        const std::string& filename)
 {
-	std::multiset<std::string>::iterator ptr;
-	if ( (ptr = files.find(filename)) != files.end())
-	{
-		//erase(filename) erases *all* entries with that key
-		files.erase(ptr);
-		return true;
-	}
-	return false;
+    std::multiset<std::string>::iterator ptr;
+    if ( (ptr = files.find(filename)) != files.end())
+    {
+        //erase(filename) erases *all* entries with that key
+        files.erase(ptr);
+        return true;
+    }
+    return false;
 }
 
 void LLXferManager::expectFileForRequest(const std::string& filename)
 {
-	mExpectedRequests.insert(filename);
+    mExpectedRequests.insert(filename);
 }
 
 bool LLXferManager::validateFileForRequest(const std::string& filename)
 {
-	return find_and_remove(mExpectedRequests, filename);
+    return find_and_remove(mExpectedRequests, filename);
 }
 
 void LLXferManager::expectFileForTransfer(const std::string& filename)
 {
-	mExpectedTransfers.insert(filename);
+    mExpectedTransfers.insert(filename);
 }
 
 bool LLXferManager::validateFileForTransfer(const std::string& filename)
 {
-	return find_and_remove(mExpectedTransfers, filename);
+    return find_and_remove(mExpectedTransfers, filename);
 }
 
 /* Present in fireengine, not used by viewer
 void LLXferManager::expectVFileForRequest(const std::string& filename)
 {
-	mExpectedVFileRequests.insert(filename);
+    mExpectedVFileRequests.insert(filename);
 }
 
 bool LLXferManager::validateVFileForRequest(const std::string& filename)
 {
-	return find_and_remove(mExpectedVFileRequests, filename);
+    return find_and_remove(mExpectedVFileRequests, filename);
 }
 
 void LLXferManager::expectVFileForTransfer(const std::string& filename)
 {
-	mExpectedVFileTransfers.insert(filename);
+    mExpectedVFileTransfers.insert(filename);
 }
 
 bool LLXferManager::validateVFileForTransfer(const std::string& filename)
 {
-	return find_and_remove(mExpectedVFileTransfers, filename);
+    return find_and_remove(mExpectedVFileTransfers, filename);
 }
 */
 
 static bool remove_prefix(std::string& filename, const std::string& prefix)
 {
-	if (std::equal(prefix.begin(), prefix.end(), filename.begin()))
-	{
-		filename = filename.substr(prefix.length());
-		return true;
-	}
-	return false;
+    if (std::equal(prefix.begin(), prefix.end(), filename.begin()))
+    {
+        filename = filename.substr(prefix.length());
+        return true;
+    }
+    return false;
 }
 
 static bool verify_cache_filename(const std::string& filename)
 {
-	//NOTE: This routine is only used to check file names that our own
-	// code places in the cache directory.	As such, it can be limited
-	// to this very restrictive file name pattern.	It does not need to
-	// handle other characters. The only known uses of this are (with examples):
-	//	sim to sim object pass:			fc0b72d8-9456-63d9-a802-a557ef847313.tmp
-	//	sim to viewer mute list:		mute_b78eacd0-1244-448e-93ca-28ede242f647.tmp
-	//	sim to viewer task inventory:	inventory_d8ab59d2-baf0-0e79-c4c2-a3f99b9fcf45.tmp
-	
-	//IMPORTANT: Do not broaden the filenames accepted by this routine
-	// without careful analysis. Anything allowed by this function can
-	// be downloaded by the viewer.
-	
-	size_t len = filename.size();
-	//const boost::regex expr("[0-9a-zA-Z_-]<1,46>\.tmp");
-	if (len < 5 || len > 50)
-	{	
-		return false;
-	}
-	for(size_t i=0; i<(len-4); ++i)
-	{	
-		char c = filename[i];
-		bool ok = isalnum(c) || '_'==c || '-'==c;
-		if (!ok)
-		{
-			return false;
-		}
-	}
-	return filename[len-4] == '.'
-		&& filename[len-3] == 't'
-		&& filename[len-2] == 'm'
-		&& filename[len-1] == 'p';
+    //NOTE: This routine is only used to check file names that our own
+    // code places in the cache directory.  As such, it can be limited
+    // to this very restrictive file name pattern.  It does not need to
+    // handle other characters. The only known uses of this are (with examples):
+    //  sim to sim object pass:         fc0b72d8-9456-63d9-a802-a557ef847313.tmp
+    //  sim to viewer mute list:        mute_b78eacd0-1244-448e-93ca-28ede242f647.tmp
+    //  sim to viewer task inventory:   inventory_d8ab59d2-baf0-0e79-c4c2-a3f99b9fcf45.tmp
+
+    //IMPORTANT: Do not broaden the filenames accepted by this routine
+    // without careful analysis. Anything allowed by this function can
+    // be downloaded by the viewer.
+
+    size_t len = filename.size();
+    //const boost::regex expr("[0-9a-zA-Z_-]<1,46>\.tmp");
+    if (len < 5 || len > 50)
+    {
+        return false;
+    }
+    for(size_t i=0; i<(len-4); ++i)
+    {
+        char c = filename[i];
+        bool ok = isalnum(c) || '_'==c || '-'==c;
+        if (!ok)
+        {
+            return false;
+        }
+    }
+    return filename[len-4] == '.'
+        && filename[len-3] == 't'
+        && filename[len-2] == 'm'
+        && filename[len-1] == 'p';
 }
 
 void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user_data*/)
 {
-		
-	U64 id;
-	std::string local_filename;
-	ELLPath local_path = LL_PATH_NONE;
-	S32 result = LL_ERR_NOERR;
-	LLUUID	uuid;
-	LLAssetType::EType type;
-	S16 type_s16;
-	BOOL b_use_big_packets;
-
-	mesgsys->getBOOL("XferID", "UseBigPackets", b_use_big_packets);
-	
-	mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
-	char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
-	LL_INFOS("Xfer") << "xfer request id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF))
-		   << " to " << mesgsys->getSender() << LL_ENDL;
-
-	mesgsys->getStringFast(_PREHASH_XferID, _PREHASH_Filename, local_filename);
-	
-	{
-		U8 local_path_u8;
-		mesgsys->getU8("XferID", "FilePath", local_path_u8);
-		local_path = (ELLPath)local_path_u8;
-	}
-
-	mesgsys->getUUIDFast(_PREHASH_XferID, _PREHASH_VFileID, uuid);
-	mesgsys->getS16Fast(_PREHASH_XferID, _PREHASH_VFileType, type_s16);
-	type = (LLAssetType::EType)type_s16;
-
-	LLXfer *xferp;
-
-	if (uuid != LLUUID::null)
-	{	// Request for an asset - use a cache file
-		if(NULL == LLAssetType::lookup(type))
-		{
-			LL_WARNS("Xfer") << "Invalid type for xfer request: " << uuid << ":"
-					<< type_s16 << " to " << mesgsys->getSender() << LL_ENDL;
-			return;
-		}
-
-		LL_INFOS("Xfer") << "starting vfile transfer: " << uuid << "," << LLAssetType::lookup(type) << " to " << mesgsys->getSender() << LL_ENDL;
-
-		xferp = (LLXfer *)new LLXfer_VFile(uuid, type);
-		if (xferp)
-		{
-			mSendList.push_front(xferp);
-			result = xferp->startSend(id,mesgsys->getSender());
-		}
-		else
-		{
-			LL_ERRS("Xfer") << "Xfer allcoation error" << LL_ENDL;
-		}
-	}
-	else if (!local_filename.empty())
-	{	// Was given a file name to send
-		// See DEV-21775 for detailed security issues
-
-		if (local_path == LL_PATH_NONE)
-		{
-			// this handles legacy simulators that are passing objects
-			// by giving a filename that explicitly names the cache directory
-			static const std::string legacy_cache_prefix = "data/";
-			if (remove_prefix(local_filename, legacy_cache_prefix))
-			{
-				local_path = LL_PATH_CACHE;
-			}
-		}
-
-		switch (local_path)
-		{
-			case LL_PATH_NONE:
-				if(!validateFileForTransfer(local_filename))
-				{
-					LL_WARNS("Xfer") << "SECURITY: Unapproved filename '" << local_filename << LL_ENDL;
-					return;
-				}
-				break;
-
-			case LL_PATH_CACHE:
-				if(!verify_cache_filename(local_filename))
-				{
-					LL_WARNS("Xfer") << "SECURITY: Illegal cache filename '" << local_filename << LL_ENDL;
-					return;
-				}
-				break;
-
-			default:
-				LL_WARNS("Xfer") << "SECURITY: Restricted file dir enum: " << (U32)local_path << LL_ENDL;
-				return;
-		}
-
-		// If we want to use a special path (e.g. LL_PATH_CACHE), we want to make sure we create the
-		// proper expanded filename.
-		std::string expanded_filename;
-		if (local_path != LL_PATH_NONE)
-		{
-			expanded_filename = gDirUtilp->getExpandedFilename( local_path, local_filename );
-		}
-		else
-		{
-			expanded_filename = local_filename;
-		}
-		LL_INFOS("Xfer") << "starting file transfer: " <<  expanded_filename << " to " << mesgsys->getSender() << LL_ENDL;
-
-		BOOL delete_local_on_completion = FALSE;
-		mesgsys->getBOOL("XferID", "DeleteOnCompletion", delete_local_on_completion);
-
-		// -1 chunk_size causes it to use the default
-		xferp = (LLXfer *)new LLXfer_File(expanded_filename, delete_local_on_completion, b_use_big_packets ? LL_XFER_LARGE_PAYLOAD : -1);
-		
-		if (xferp)
-		{
-			mSendList.push_front(xferp);
-			result = xferp->startSend(id,mesgsys->getSender());
-		}
-		else
-		{
-			LL_ERRS("Xfer") << "Xfer allcoation error" << LL_ENDL;
-		}
-	}
-	else
-	{	// no uuid or filename - use the ID sent
-		char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
-		LL_INFOS("Xfer") << "starting memory transfer: "
-			<< U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << " to "
-			<< mesgsys->getSender() << LL_ENDL;
-
-		xferp = findXferByID(id, mSendList);
-		
-		if (xferp)
-		{
-			result = xferp->startSend(id,mesgsys->getSender());
-		}
-		else
-		{
-			LL_INFOS("Xfer") << "Warning: xfer ID " << U64_BUF << " not found." << LL_ENDL;
-			result = LL_ERR_FILE_NOT_FOUND;
-		}
-	}
-
-	if (result)
-	{
-		if (xferp)
-		{
-			xferp->abort(result);
-			removeXfer(xferp, mSendList);
-		}
-		else // can happen with a memory transfer not found
-		{
-			LL_INFOS("Xfer") << "Aborting xfer to " << mesgsys->getSender() << " with error: " << result << LL_ENDL;
-
-			mesgsys->newMessageFast(_PREHASH_AbortXfer);
-			mesgsys->nextBlockFast(_PREHASH_XferID);
-			mesgsys->addU64Fast(_PREHASH_ID, id);
-			mesgsys->addS32Fast(_PREHASH_Result, result);
-	
-			mesgsys->sendMessage(mesgsys->getSender());		
-		}
-	}
-	else if(xferp)
-	{
-		// Figure out how many transfers the host has requested
-		LLHostStatus *host_statusp = findHostStatus(xferp->mRemoteHost);
-		if (host_statusp)
-		{
-			if (host_statusp->mNumActive < mMaxOutgoingXfersPerCircuit)
-			{	// Not many transfers in progress already, so start immediately
-				xferp->sendNextPacket();
-				changeNumActiveXfers(xferp->mRemoteHost,1);
-				LL_DEBUGS("Xfer") << "Starting xfer ID " << U64_to_str(id) << " immediately" << LL_ENDL;
-			}
-			else if (mHardLimitOutgoingXfersPerCircuit == 0 ||
-				     (host_statusp->mNumActive + host_statusp->mNumPending) < mHardLimitOutgoingXfersPerCircuit)
-			{	// Must close the file handle and wait for earlier ones to complete
-				LL_INFOS("Xfer") << "  queueing xfer request id " << U64_to_str(id) << ", " 
-								 << host_statusp->mNumActive << " active and "
-								 << host_statusp->mNumPending << " pending ahead of this one" 
-								 << LL_ENDL;
-				xferp->closeFileHandle();	// Close the file handle until we're ready to send again
-			}
-			else if (mHardLimitOutgoingXfersPerCircuit > 0)
-			{	// Way too many requested ... it's time to stop being nice and kill the circuit
-				xferp->closeFileHandle();	// Close the file handle in any case
-				LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(xferp->mRemoteHost);
-				if (cdp)
-				{
-					if (cdp->getTrusted())
-					{	// Trusted internal circuit - don't kill it
-						LL_WARNS("Xfer") << "Trusted circuit to " << xferp->mRemoteHost << " has too many xfer requests in the queue " 
-										<< host_statusp->mNumActive << " active and "
-										<< host_statusp->mNumPending << " pending ahead of this one" 
-										<< LL_ENDL;
-					}
-					else
-					{	// Untrusted circuit - time to stop messing around and kill it
-						LL_WARNS("Xfer") << "Killing circuit to " << xferp->mRemoteHost << " for having too many xfer requests in the queue " 
-										<< host_statusp->mNumActive << " active and "
-										<< host_statusp->mNumPending << " pending ahead of this one" 
-										<< LL_ENDL;
-						gMessageSystem->disableCircuit(xferp->mRemoteHost);
-					}
-				}
-				else
-				{	// WTF?   Why can't we find a circuit?  Try to kill it off
-					LL_WARNS("Xfer") << "Backlog with circuit to " << xferp->mRemoteHost << " with too many xfer requests in the queue " 
-									<< host_statusp->mNumActive << " active and "
-									<< host_statusp->mNumPending << " pending ahead of this one" 
-									<< " but no LLCircuitData found???"
-									<< LL_ENDL;
-					gMessageSystem->disableCircuit(xferp->mRemoteHost);
-				}
-			}
-		}
-		else
-		{
-			LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no LLHostStatus found for id " << U64_to_str(id)	
-				<< " host " << xferp->mRemoteHost << LL_ENDL;
-		}
-	}
-	else
-	{
-		LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no xfer found for id " << U64_to_str(id)	<< LL_ENDL;
-	}
+
+    U64 id;
+    std::string local_filename;
+    ELLPath local_path = LL_PATH_NONE;
+    S32 result = LL_ERR_NOERR;
+    LLUUID  uuid;
+    LLAssetType::EType type;
+    S16 type_s16;
+    BOOL b_use_big_packets;
+
+    mesgsys->getBOOL("XferID", "UseBigPackets", b_use_big_packets);
+
+    mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
+    char U64_BUF[MAX_STRING];       /* Flawfinder : ignore */
+    LL_INFOS("Xfer") << "xfer request id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF))
+           << " to " << mesgsys->getSender() << LL_ENDL;
+
+    mesgsys->getStringFast(_PREHASH_XferID, _PREHASH_Filename, local_filename);
+
+    {
+        U8 local_path_u8;
+        mesgsys->getU8("XferID", "FilePath", local_path_u8);
+        local_path = (ELLPath)local_path_u8;
+    }
+
+    mesgsys->getUUIDFast(_PREHASH_XferID, _PREHASH_VFileID, uuid);
+    mesgsys->getS16Fast(_PREHASH_XferID, _PREHASH_VFileType, type_s16);
+    type = (LLAssetType::EType)type_s16;
+
+    LLXfer *xferp;
+
+    if (uuid != LLUUID::null)
+    {   // Request for an asset - use a cache file
+        if(NULL == LLAssetType::lookup(type))
+        {
+            LL_WARNS("Xfer") << "Invalid type for xfer request: " << uuid << ":"
+                    << type_s16 << " to " << mesgsys->getSender() << LL_ENDL;
+            return;
+        }
+
+        LL_INFOS("Xfer") << "starting vfile transfer: " << uuid << "," << LLAssetType::lookup(type) << " to " << mesgsys->getSender() << LL_ENDL;
+
+        xferp = (LLXfer *)new LLXfer_VFile(uuid, type);
+        if (xferp)
+        {
+            mSendList.push_front(xferp);
+            result = xferp->startSend(id,mesgsys->getSender());
+        }
+        else
+        {
+            LL_ERRS("Xfer") << "Xfer allcoation error" << LL_ENDL;
+        }
+    }
+    else if (!local_filename.empty())
+    {   // Was given a file name to send
+        // See DEV-21775 for detailed security issues
+
+        if (local_path == LL_PATH_NONE)
+        {
+            // this handles legacy simulators that are passing objects
+            // by giving a filename that explicitly names the cache directory
+            static const std::string legacy_cache_prefix = "data/";
+            if (remove_prefix(local_filename, legacy_cache_prefix))
+            {
+                local_path = LL_PATH_CACHE;
+            }
+        }
+
+        switch (local_path)
+        {
+            case LL_PATH_NONE:
+                if(!validateFileForTransfer(local_filename))
+                {
+                    LL_WARNS("Xfer") << "SECURITY: Unapproved filename '" << local_filename << LL_ENDL;
+                    return;
+                }
+                break;
+
+            case LL_PATH_CACHE:
+                if(!verify_cache_filename(local_filename))
+                {
+                    LL_WARNS("Xfer") << "SECURITY: Illegal cache filename '" << local_filename << LL_ENDL;
+                    return;
+                }
+                break;
+
+            default:
+                LL_WARNS("Xfer") << "SECURITY: Restricted file dir enum: " << (U32)local_path << LL_ENDL;
+                return;
+        }
+
+        // If we want to use a special path (e.g. LL_PATH_CACHE), we want to make sure we create the
+        // proper expanded filename.
+        std::string expanded_filename;
+        if (local_path != LL_PATH_NONE)
+        {
+            expanded_filename = gDirUtilp->getExpandedFilename( local_path, local_filename );
+        }
+        else
+        {
+            expanded_filename = local_filename;
+        }
+        LL_INFOS("Xfer") << "starting file transfer: " <<  expanded_filename << " to " << mesgsys->getSender() << LL_ENDL;
+
+        BOOL delete_local_on_completion = FALSE;
+        mesgsys->getBOOL("XferID", "DeleteOnCompletion", delete_local_on_completion);
+
+        // -1 chunk_size causes it to use the default
+        xferp = (LLXfer *)new LLXfer_File(expanded_filename, delete_local_on_completion, b_use_big_packets ? LL_XFER_LARGE_PAYLOAD : -1);
+
+        if (xferp)
+        {
+            mSendList.push_front(xferp);
+            result = xferp->startSend(id,mesgsys->getSender());
+        }
+        else
+        {
+            LL_ERRS("Xfer") << "Xfer allcoation error" << LL_ENDL;
+        }
+    }
+    else
+    {   // no uuid or filename - use the ID sent
+        char U64_BUF[MAX_STRING];       /* Flawfinder : ignore */
+        LL_INFOS("Xfer") << "starting memory transfer: "
+            << U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << " to "
+            << mesgsys->getSender() << LL_ENDL;
+
+        xferp = findXferByID(id, mSendList);
+
+        if (xferp)
+        {
+            result = xferp->startSend(id,mesgsys->getSender());
+        }
+        else
+        {
+            LL_INFOS("Xfer") << "Warning: xfer ID " << U64_BUF << " not found." << LL_ENDL;
+            result = LL_ERR_FILE_NOT_FOUND;
+        }
+    }
+
+    if (result)
+    {
+        if (xferp)
+        {
+            xferp->abort(result);
+            removeXfer(xferp, mSendList);
+        }
+        else // can happen with a memory transfer not found
+        {
+            LL_INFOS("Xfer") << "Aborting xfer to " << mesgsys->getSender() << " with error: " << result << LL_ENDL;
+
+            mesgsys->newMessageFast(_PREHASH_AbortXfer);
+            mesgsys->nextBlockFast(_PREHASH_XferID);
+            mesgsys->addU64Fast(_PREHASH_ID, id);
+            mesgsys->addS32Fast(_PREHASH_Result, result);
+
+            mesgsys->sendMessage(mesgsys->getSender());
+        }
+    }
+    else if(xferp)
+    {
+        // Figure out how many transfers the host has requested
+        LLHostStatus *host_statusp = findHostStatus(xferp->mRemoteHost);
+        if (host_statusp)
+        {
+            if (host_statusp->mNumActive < mMaxOutgoingXfersPerCircuit)
+            {   // Not many transfers in progress already, so start immediately
+                xferp->sendNextPacket();
+                changeNumActiveXfers(xferp->mRemoteHost,1);
+                LL_DEBUGS("Xfer") << "Starting xfer ID " << U64_to_str(id) << " immediately" << LL_ENDL;
+            }
+            else if (mHardLimitOutgoingXfersPerCircuit == 0 ||
+                     (host_statusp->mNumActive + host_statusp->mNumPending) < mHardLimitOutgoingXfersPerCircuit)
+            {   // Must close the file handle and wait for earlier ones to complete
+                LL_INFOS("Xfer") << "  queueing xfer request id " << U64_to_str(id) << ", "
+                                 << host_statusp->mNumActive << " active and "
+                                 << host_statusp->mNumPending << " pending ahead of this one"
+                                 << LL_ENDL;
+                xferp->closeFileHandle();   // Close the file handle until we're ready to send again
+            }
+            else if (mHardLimitOutgoingXfersPerCircuit > 0)
+            {   // Way too many requested ... it's time to stop being nice and kill the circuit
+                xferp->closeFileHandle();   // Close the file handle in any case
+                LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(xferp->mRemoteHost);
+                if (cdp)
+                {
+                    if (cdp->getTrusted())
+                    {   // Trusted internal circuit - don't kill it
+                        LL_WARNS("Xfer") << "Trusted circuit to " << xferp->mRemoteHost << " has too many xfer requests in the queue "
+                                        << host_statusp->mNumActive << " active and "
+                                        << host_statusp->mNumPending << " pending ahead of this one"
+                                        << LL_ENDL;
+                    }
+                    else
+                    {   // Untrusted circuit - time to stop messing around and kill it
+                        LL_WARNS("Xfer") << "Killing circuit to " << xferp->mRemoteHost << " for having too many xfer requests in the queue "
+                                        << host_statusp->mNumActive << " active and "
+                                        << host_statusp->mNumPending << " pending ahead of this one"
+                                        << LL_ENDL;
+                        gMessageSystem->disableCircuit(xferp->mRemoteHost);
+                    }
+                }
+                else
+                {   // WTF?   Why can't we find a circuit?  Try to kill it off
+                    LL_WARNS("Xfer") << "Backlog with circuit to " << xferp->mRemoteHost << " with too many xfer requests in the queue "
+                                    << host_statusp->mNumActive << " active and "
+                                    << host_statusp->mNumPending << " pending ahead of this one"
+                                    << " but no LLCircuitData found???"
+                                    << LL_ENDL;
+                    gMessageSystem->disableCircuit(xferp->mRemoteHost);
+                }
+            }
+        }
+        else
+        {
+            LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no LLHostStatus found for id " << U64_to_str(id)
+                << " host " << xferp->mRemoteHost << LL_ENDL;
+        }
+    }
+    else
+    {
+        LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no xfer found for id " << U64_to_str(id) << LL_ENDL;
+    }
 }
- 
+
 ///////////////////////////////////////////////////////////
 
 // Return true if host is in a transfer-flood sitation.  Same check for both internal and external hosts
 bool LLXferManager::isHostFlooded(const LLHost & host)
 {
-	bool flooded = false;
-	LLHostStatus *host_statusp = findHostStatus(host);
-	if (host_statusp)
-	{
-		flooded = (mHardLimitOutgoingXfersPerCircuit > 0 &&
-				    (host_statusp->mNumActive + host_statusp->mNumPending) >= (S32)(mHardLimitOutgoingXfersPerCircuit * 0.8f));
-	}
-
-	return flooded;
+    bool flooded = false;
+    LLHostStatus *host_statusp = findHostStatus(host);
+    if (host_statusp)
+    {
+        flooded = (mHardLimitOutgoingXfersPerCircuit > 0 &&
+                    (host_statusp->mNumActive + host_statusp->mNumPending) >= (S32)(mHardLimitOutgoingXfersPerCircuit * 0.8f));
+    }
+
+    return flooded;
 }
 
 
@@ -995,26 +995,26 @@ bool LLXferManager::isHostFlooded(const LLHost & host)
 
 void LLXferManager::processConfirmation (LLMessageSystem *mesgsys, void ** /*user_data*/)
 {
-	U64 id = 0;
-	S32 packetNum = 0;
-
-	mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
-	mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Packet, packetNum);
-
-	LLXfer* xferp = findXferByID(id, mSendList);
-	if (xferp)
-	{
-//		cout << "confirmed packet #" << packetNum << " ping: "<< xferp->ACKTimer.getElapsedTimeF32() <<  endl;
-		xferp->mWaitingForACK = FALSE;
-		if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
-		{
-			xferp->sendNextPacket();
-		}
-		else
-		{
-			removeXfer(xferp, mSendList);
-		}
-	}
+    U64 id = 0;
+    S32 packetNum = 0;
+
+    mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
+    mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Packet, packetNum);
+
+    LLXfer* xferp = findXferByID(id, mSendList);
+    if (xferp)
+    {
+//      cout << "confirmed packet #" << packetNum << " ping: "<< xferp->ACKTimer.getElapsedTimeF32() <<  endl;
+        xferp->mWaitingForACK = FALSE;
+        if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
+        {
+            xferp->sendNextPacket();
+        }
+        else
+        {
+            removeXfer(xferp, mSendList);
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////
@@ -1022,229 +1022,229 @@ void LLXferManager::processConfirmation (LLMessageSystem *mesgsys, void ** /*use
 // Called from LLMessageSystem::processAcks()
 void LLXferManager::retransmitUnackedPackets()
 {
-	LLXfer *xferp;
-
-	xfer_list_t::iterator iter = mReceiveList.begin();
-	while (iter != mReceiveList.end())
-	{
-		xferp = (*iter);
-		if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
-		{
-			// if the circuit dies, abort
-			if (! gMessageSystem->mCircuitInfo.isCircuitAlive( xferp->mRemoteHost ))
-			{
-				LL_WARNS("Xfer") << "Xfer found in progress on dead circuit, aborting transfer to " 
-					<< xferp->mRemoteHost.getIPandPort()
-					<< LL_ENDL;
-				xferp->mCallbackResult = LL_ERR_CIRCUIT_GONE;
-				xferp->processEOF();
-
-				iter = mReceiveList.erase(iter);	// iter is set to next one after the deletion point
-				delete (xferp);
-				continue;
- 			}
-				
-		}
-		++iter;
-	}
-
-	// Re-build mOutgoingHosts data
-	updateHostStatus();
-
-	F32 et;
-	iter = mSendList.begin();
-	while (iter != mSendList.end())
-	{
-		xferp = (*iter);
-		if (xferp->mWaitingForACK && ( (et = xferp->ACKTimer.getElapsedTimeF32()) > LL_PACKET_TIMEOUT))
-		{
-			if (xferp->mRetries > LL_PACKET_RETRY_LIMIT)
-			{
-				LL_INFOS("Xfer") << "dropping xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet retransmit limit exceeded, xfer dropped" << LL_ENDL;
-				xferp->abort(LL_ERR_TCP_TIMEOUT);
-				iter = mSendList.erase(iter);
-				delete xferp;
-				continue;
-			}
-			else
-			{
-				LL_INFOS("Xfer") << "resending xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet unconfirmed after: "<< et << " sec, packet " << xferp->mPacketNum << LL_ENDL;
-				xferp->resendLastPacket();
-			}
-		}
-		else if ((xferp->mStatus == e_LL_XFER_REGISTERED) && ( (et = xferp->ACKTimer.getElapsedTimeF32()) > LL_XFER_REGISTRATION_TIMEOUT))
-		{
-			LL_INFOS("Xfer") << "registered xfer never requested, xfer dropped" << LL_ENDL;
-			xferp->abort(LL_ERR_TCP_TIMEOUT);
-			iter = mSendList.erase(iter);
-			delete xferp;
-			continue;
-		}
-		else if (xferp->mStatus == e_LL_XFER_ABORTED)
-		{
-			LL_WARNS("Xfer") << "Removing aborted xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << LL_ENDL;
-			iter = mSendList.erase(iter);
-			delete xferp;
-			continue;
-		}
-		else if (xferp->mStatus == e_LL_XFER_PENDING)
-		{
-//			LL_INFOS("Xfer") << "*** numActiveXfers = " << numActiveXfers(xferp->mRemoteHost) << "        mMaxOutgoingXfersPerCircuit = " << mMaxOutgoingXfersPerCircuit << LL_ENDL;   
-			if (numActiveXfers(xferp->mRemoteHost) < mMaxOutgoingXfersPerCircuit)
-			{
-				if (xferp->reopenFileHandle())
-				{
-					LL_WARNS("Xfer") << "Error re-opening file handle for xfer ID " << U64_to_str(xferp->mID)
-						<< " to host " << xferp->mRemoteHost << LL_ENDL;
-					xferp->abort(LL_ERR_CANNOT_OPEN_FILE);
-					iter = mSendList.erase(iter);
-					delete xferp;
-					continue;
-				}
-				else
-				{	// No error re-opening the file, send the first packet
-					LL_DEBUGS("Xfer") << "Moving pending xfer ID " << U64_to_str(xferp->mID) << " to active" << LL_ENDL;
-					xferp->sendNextPacket();
-					changeNumActiveXfers(xferp->mRemoteHost,1);
-				}
-			}
-		}
-		++iter;
-	} // end while() loop
-
-	//
-	// HACK - if we're using xfer confirm throttling, throttle our xfer confirms here
-	// so we don't blow through bandwidth.
-	//
-
-	while (mXferAckQueue.size())
-	{
-		if (mAckThrottle.checkOverflow(1000.0f*8.0f))
-		{
-			break;
-		}
-		//LL_INFOS("Xfer") << "Confirm packet queue length:" << mXferAckQueue.size() << LL_ENDL;
-		LLXferAckInfo ack_info = mXferAckQueue.front();
-		mXferAckQueue.pop_front();
-		//LL_INFOS("Xfer") << "Sending confirm packet" << LL_ENDL;
-		sendConfirmPacket(gMessageSystem, ack_info.mID, ack_info.mPacketNum, ack_info.mRemoteHost);
-		mAckThrottle.throttleOverflow(1000.f*8.f); // Assume 1000 bytes/packet
-	}
+    LLXfer *xferp;
+
+    xfer_list_t::iterator iter = mReceiveList.begin();
+    while (iter != mReceiveList.end())
+    {
+        xferp = (*iter);
+        if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
+        {
+            // if the circuit dies, abort
+            if (! gMessageSystem->mCircuitInfo.isCircuitAlive( xferp->mRemoteHost ))
+            {
+                LL_WARNS("Xfer") << "Xfer found in progress on dead circuit, aborting transfer to "
+                    << xferp->mRemoteHost.getIPandPort()
+                    << LL_ENDL;
+                xferp->mCallbackResult = LL_ERR_CIRCUIT_GONE;
+                xferp->processEOF();
+
+                iter = mReceiveList.erase(iter);    // iter is set to next one after the deletion point
+                delete (xferp);
+                continue;
+            }
+
+        }
+        ++iter;
+    }
+
+    // Re-build mOutgoingHosts data
+    updateHostStatus();
+
+    F32 et;
+    iter = mSendList.begin();
+    while (iter != mSendList.end())
+    {
+        xferp = (*iter);
+        if (xferp->mWaitingForACK && ( (et = xferp->ACKTimer.getElapsedTimeF32()) > LL_PACKET_TIMEOUT))
+        {
+            if (xferp->mRetries > LL_PACKET_RETRY_LIMIT)
+            {
+                LL_INFOS("Xfer") << "dropping xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet retransmit limit exceeded, xfer dropped" << LL_ENDL;
+                xferp->abort(LL_ERR_TCP_TIMEOUT);
+                iter = mSendList.erase(iter);
+                delete xferp;
+                continue;
+            }
+            else
+            {
+                LL_INFOS("Xfer") << "resending xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet unconfirmed after: "<< et << " sec, packet " << xferp->mPacketNum << LL_ENDL;
+                xferp->resendLastPacket();
+            }
+        }
+        else if ((xferp->mStatus == e_LL_XFER_REGISTERED) && ( (et = xferp->ACKTimer.getElapsedTimeF32()) > LL_XFER_REGISTRATION_TIMEOUT))
+        {
+            LL_INFOS("Xfer") << "registered xfer never requested, xfer dropped" << LL_ENDL;
+            xferp->abort(LL_ERR_TCP_TIMEOUT);
+            iter = mSendList.erase(iter);
+            delete xferp;
+            continue;
+        }
+        else if (xferp->mStatus == e_LL_XFER_ABORTED)
+        {
+            LL_WARNS("Xfer") << "Removing aborted xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << LL_ENDL;
+            iter = mSendList.erase(iter);
+            delete xferp;
+            continue;
+        }
+        else if (xferp->mStatus == e_LL_XFER_PENDING)
+        {
+//          LL_INFOS("Xfer") << "*** numActiveXfers = " << numActiveXfers(xferp->mRemoteHost) << "        mMaxOutgoingXfersPerCircuit = " << mMaxOutgoingXfersPerCircuit << LL_ENDL;
+            if (numActiveXfers(xferp->mRemoteHost) < mMaxOutgoingXfersPerCircuit)
+            {
+                if (xferp->reopenFileHandle())
+                {
+                    LL_WARNS("Xfer") << "Error re-opening file handle for xfer ID " << U64_to_str(xferp->mID)
+                        << " to host " << xferp->mRemoteHost << LL_ENDL;
+                    xferp->abort(LL_ERR_CANNOT_OPEN_FILE);
+                    iter = mSendList.erase(iter);
+                    delete xferp;
+                    continue;
+                }
+                else
+                {   // No error re-opening the file, send the first packet
+                    LL_DEBUGS("Xfer") << "Moving pending xfer ID " << U64_to_str(xferp->mID) << " to active" << LL_ENDL;
+                    xferp->sendNextPacket();
+                    changeNumActiveXfers(xferp->mRemoteHost,1);
+                }
+            }
+        }
+        ++iter;
+    } // end while() loop
+
+    //
+    // HACK - if we're using xfer confirm throttling, throttle our xfer confirms here
+    // so we don't blow through bandwidth.
+    //
+
+    while (mXferAckQueue.size())
+    {
+        if (mAckThrottle.checkOverflow(1000.0f*8.0f))
+        {
+            break;
+        }
+        //LL_INFOS("Xfer") << "Confirm packet queue length:" << mXferAckQueue.size() << LL_ENDL;
+        LLXferAckInfo ack_info = mXferAckQueue.front();
+        mXferAckQueue.pop_front();
+        //LL_INFOS("Xfer") << "Sending confirm packet" << LL_ENDL;
+        sendConfirmPacket(gMessageSystem, ack_info.mID, ack_info.mPacketNum, ack_info.mRemoteHost);
+        mAckThrottle.throttleOverflow(1000.f*8.f); // Assume 1000 bytes/packet
+    }
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::abortRequestById(U64 xfer_id, S32 result_code)
 {
-	LLXfer * xferp = findXferByID(xfer_id, mReceiveList);
-	if (xferp)
-	{
-		if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
-		{
-			// causes processAbort();
-			xferp->abort(result_code);
-		}
-		else
-		{
-			xferp->mCallbackResult = result_code;
-			xferp->processEOF(); //should notify requester
-			removeXfer(xferp, mReceiveList);
-		}
-		// Since already removed or marked as aborted no need
-		// to wait for processAbort() to start new download
-		startPendingDownloads();
-	}
+    LLXfer * xferp = findXferByID(xfer_id, mReceiveList);
+    if (xferp)
+    {
+        if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
+        {
+            // causes processAbort();
+            xferp->abort(result_code);
+        }
+        else
+        {
+            xferp->mCallbackResult = result_code;
+            xferp->processEOF(); //should notify requester
+            removeXfer(xferp, mReceiveList);
+        }
+        // Since already removed or marked as aborted no need
+        // to wait for processAbort() to start new download
+        startPendingDownloads();
+    }
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::processAbort (LLMessageSystem *mesgsys, void ** /*user_data*/)
 {
-	U64 id = 0;
-	S32 result_code = 0;
-	LLXfer * xferp;
-
-	mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
-	mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Result, result_code);
-
-	xferp = findXferByID(id, mReceiveList);
-	if (xferp)
-	{
-		xferp->mCallbackResult = result_code;
-		xferp->processEOF();
-		removeXfer(xferp, mReceiveList);
-		startPendingDownloads();
-	}
+    U64 id = 0;
+    S32 result_code = 0;
+    LLXfer * xferp;
+
+    mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
+    mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Result, result_code);
+
+    xferp = findXferByID(id, mReceiveList);
+    if (xferp)
+    {
+        xferp->mCallbackResult = result_code;
+        xferp->processEOF();
+        removeXfer(xferp, mReceiveList);
+        startPendingDownloads();
+    }
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::startPendingDownloads()
 {
-	// This method goes through the list, and starts pending
-	// operations until active downloads == mMaxIncomingXfers. I copy
-	// the pending xfers into a temporary data structure because the
-	// xfers are stored as an intrusive linked list where older
-	// requests get pushed toward the back. Thus, if we didn't do a
-	// stateful iteration, it would be possible for old requests to
-	// never start.
-	LLXfer* xferp;
-	std::list<LLXfer*> pending_downloads;
-	S32 download_count = 0;
-	S32 pending_count = 0;
-	for (xfer_list_t::iterator iter = mReceiveList.begin();
-		 iter != mReceiveList.end();
-		 ++iter)
-	{
-		xferp = (*iter);
-		if(xferp->mStatus == e_LL_XFER_PENDING)
-		{	// Count and accumulate pending downloads
-			++pending_count;
-			pending_downloads.push_front(xferp);
-		}
-		else if(xferp->mStatus == e_LL_XFER_IN_PROGRESS)
-		{	// Count downloads in progress
-			++download_count;
-		}
-	}
-
-	S32 start_count = mMaxIncomingXfers - download_count;
-
-	LL_DEBUGS("Xfer") << "LLXferManager::startPendingDownloads() - XFER_IN_PROGRESS: "
-			 << download_count << " XFER_PENDING: " << pending_count
-			 << " startring " << llmin(start_count, pending_count) << LL_ENDL;
-
-	if((start_count > 0) && (pending_count > 0))
-	{
-		S32 result;
-		for (std::list<LLXfer*>::iterator iter = pending_downloads.begin();
-			 iter != pending_downloads.end(); ++iter)
-		{
-			xferp = *iter;
-			if (start_count-- <= 0)
-				break;
-			result = xferp->startDownload();
-			if(result)
-			{
-				xferp->abort(result);
-				++start_count;
-			}
-		}
-	}
+    // This method goes through the list, and starts pending
+    // operations until active downloads == mMaxIncomingXfers. I copy
+    // the pending xfers into a temporary data structure because the
+    // xfers are stored as an intrusive linked list where older
+    // requests get pushed toward the back. Thus, if we didn't do a
+    // stateful iteration, it would be possible for old requests to
+    // never start.
+    LLXfer* xferp;
+    std::list<LLXfer*> pending_downloads;
+    S32 download_count = 0;
+    S32 pending_count = 0;
+    for (xfer_list_t::iterator iter = mReceiveList.begin();
+         iter != mReceiveList.end();
+         ++iter)
+    {
+        xferp = (*iter);
+        if(xferp->mStatus == e_LL_XFER_PENDING)
+        {   // Count and accumulate pending downloads
+            ++pending_count;
+            pending_downloads.push_front(xferp);
+        }
+        else if(xferp->mStatus == e_LL_XFER_IN_PROGRESS)
+        {   // Count downloads in progress
+            ++download_count;
+        }
+    }
+
+    S32 start_count = mMaxIncomingXfers - download_count;
+
+    LL_DEBUGS("Xfer") << "LLXferManager::startPendingDownloads() - XFER_IN_PROGRESS: "
+             << download_count << " XFER_PENDING: " << pending_count
+             << " startring " << llmin(start_count, pending_count) << LL_ENDL;
+
+    if((start_count > 0) && (pending_count > 0))
+    {
+        S32 result;
+        for (std::list<LLXfer*>::iterator iter = pending_downloads.begin();
+             iter != pending_downloads.end(); ++iter)
+        {
+            xferp = *iter;
+            if (start_count-- <= 0)
+                break;
+            result = xferp->startDownload();
+            if(result)
+            {
+                xferp->abort(result);
+                ++start_count;
+            }
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////
 
 void LLXferManager::addToList(LLXfer* xferp, xfer_list_t & xfer_list, BOOL is_priority)
 {
-	if(is_priority)
-	{
-		xfer_list.push_back(xferp);
-	}
-	else
-	{
-		xfer_list.push_front(xferp);
-	}
+    if(is_priority)
+    {
+        xfer_list.push_back(xferp);
+    }
+    else
+    {
+        xfer_list.push_front(xferp);
+    }
 }
 
 ///////////////////////////////////////////////////////////
@@ -1256,47 +1256,47 @@ LLXferManager *gXferManager = NULL;
 
 void start_xfer_manager()
 {
-	gXferManager = new LLXferManager();
+    gXferManager = new LLXferManager();
 }
 
 void cleanup_xfer_manager()
 {
-	if (gXferManager)
-	{
-		delete(gXferManager);
-		gXferManager = NULL;
-	}
+    if (gXferManager)
+    {
+        delete(gXferManager);
+        gXferManager = NULL;
+    }
 }
 
 void process_confirm_packet (LLMessageSystem *mesgsys, void **user_data)
 {
-	gXferManager->processConfirmation(mesgsys,user_data);
+    gXferManager->processConfirmation(mesgsys,user_data);
 }
 
 void process_request_xfer(LLMessageSystem *mesgsys, void **user_data)
 {
-	gXferManager->processFileRequest(mesgsys,user_data);
+    gXferManager->processFileRequest(mesgsys,user_data);
 }
 
 void continue_file_receive(LLMessageSystem *mesgsys, void **user_data)
 {
 #if LL_TEST_XFER_REXMIT
-	if (ll_frand() > 0.05f)
-	{
+    if (ll_frand() > 0.05f)
+    {
 #endif
-		gXferManager->processReceiveData(mesgsys,user_data);
+        gXferManager->processReceiveData(mesgsys,user_data);
 #if LL_TEST_XFER_REXMIT
-	}
-	else
-	{
-		cout << "oops! dropped a xfer packet" << endl;
-	}
+    }
+    else
+    {
+        cout << "oops! dropped a xfer packet" << endl;
+    }
 #endif
 }
 
 void process_abort_xfer(LLMessageSystem *mesgsys, void **user_data)
 {
-	gXferManager->processAbort(mesgsys,user_data);
+    gXferManager->processAbort(mesgsys,user_data);
 }