Print done when done.

1 files changed, 416 insertions, 0 deletions

diff --git a/indra/llmessage/llxfer_file.cpp b/indra/llmessage/llxfer_file.cpp
new file mode 100644
index 0000000000..da72467c76
--- /dev/null
+++ b/indra/llmessage/llxfer_file.cpp
@@ -0,0 +1,416 @@
+/** 
+ * @file llxfer_file.cpp
+ * @brief implementation of LLXfer_File class for a single xfer (file)
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#if !LL_WINDOWS
+#include <errno.h>
+#include <unistd.h>
+#endif
+
+#include "llxfer_file.h"
+#include "lluuid.h"
+#include "llerror.h"
+#include "llmath.h"
+#include "llstring.h"
+#include "lldir.h"
+
+// size of chunks read from/written to disk
+const U32 LL_MAX_XFER_FILE_BUFFER = 65536;
+
+// local function to copy a file
+S32 copy_file(const char* from, const char* to);
+
+///////////////////////////////////////////////////////////
+
+LLXfer_File::LLXfer_File (S32 chunk_size)
+: LLXfer(chunk_size)
+{
+	init(LLString::null, FALSE, chunk_size);
+}
+
+LLXfer_File::LLXfer_File (const LLString& local_filename, BOOL delete_local_on_completion, S32 chunk_size)
+: LLXfer(chunk_size)
+{
+	init(local_filename, delete_local_on_completion, chunk_size);
+}
+
+///////////////////////////////////////////////////////////
+
+LLXfer_File::~LLXfer_File ()
+{
+	free();
+}
+
+///////////////////////////////////////////////////////////
+
+void LLXfer_File::init (const LLString& local_filename, BOOL delete_local_on_completion, S32 chunk_size)
+{
+
+	mFp = NULL;
+	mLocalFilename[0] = 0;
+	mRemoteFilename[0] = 0;
+	mRemotePath = LL_PATH_NONE;
+	mTempFilename[0] = 0;
+	mDeleteLocalOnCompletion = FALSE;
+	mDeleteRemoteOnCompletion = FALSE;
+
+	if (!local_filename.empty())
+	{
+		strncpy(mLocalFilename, local_filename.c_str(), LL_MAX_PATH);		/* Flawfinder : ignore */
+
+		// 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 */
+	}
+}
+	
+///////////////////////////////////////////////////////////
+
+void LLXfer_File::free ()
+{
+	if (mFp)
+	{
+		fclose(mFp);
+		mFp = NULL;
+	}
+
+	LLFile::remove(mTempFilename);
+
+	if (mDeleteLocalOnCompletion)
+	{
+		lldebugs << "Removing file: " << mLocalFilename << llendl;
+		LLFile::remove(mLocalFilename);
+	}
+	else
+	{
+		lldebugs << "Keeping local file: " << mLocalFilename << llendl;
+	}
+
+	LLXfer::free();
+}
+
+///////////////////////////////////////////////////////////
+
+S32 LLXfer_File::initializeRequest(U64 xfer_id,
+								   const LLString& local_filename,
+								   const LLString& remote_filename,
+								   ELLPath remote_path,
+								   const LLHost& remote_host,
+								   BOOL delete_remote_on_completion,
+								   void (*callback)(void**,S32),
+								   void** user_data)
+{
+ 	S32 retval = 0;  // presume success
+	
+	mID = xfer_id;
+	strncpy(mLocalFilename, local_filename.c_str(), LL_MAX_PATH);		/* Flawfinder : ignore */
+	strncpy(mRemoteFilename,remote_filename.c_str(), LL_MAX_PATH);		/* Flawfinder : ignore */
+	mRemotePath = remote_path;
+	mRemoteHost = remote_host;
+	mDeleteRemoteOnCompletion = delete_remote_on_completion;
+
+	snprintf(mTempFilename, sizeof(mTempFilename), "%s",gDirUtilp->getTempFilename().c_str());		/* Flawfinder : ignore */
+
+	mCallback = callback;
+	mCallbackDataHandle = user_data;
+	mCallbackResult = LL_ERR_NOERR;
+
+	llinfos << "Requesting xfer from " << remote_host << " for file: " << mLocalFilename << llendl;
+
+	if (mBuffer)
+	{
+		delete(mBuffer);
+		mBuffer = NULL;
+	}
+
+	mBuffer = new char[LL_MAX_XFER_FILE_BUFFER];
+	mBufferLength = 0;
+
+	mPacketNum = 0;
+
+ 	mStatus = e_LL_XFER_PENDING;
+	return retval;
+}
+
+///////////////////////////////////////////////////////////
+
+S32 LLXfer_File::startDownload()
+{
+ 	S32 retval = 0;  // presume success
+	mFp = LLFile::fopen(mTempFilename,"w+b");		/* Flawfinder : ignore */
+	if (mFp)
+	{
+		fclose(mFp);
+		mFp = NULL;
+
+		gMessageSystem->newMessageFast(_PREHASH_RequestXfer);
+		gMessageSystem->nextBlockFast(_PREHASH_XferID);
+		gMessageSystem->addU64Fast(_PREHASH_ID, mID);
+		gMessageSystem->addStringFast(_PREHASH_Filename, mRemoteFilename);
+		gMessageSystem->addU8("FilePath", (U8) mRemotePath);
+		gMessageSystem->addBOOL("DeleteOnCompletion", mDeleteRemoteOnCompletion);
+		gMessageSystem->addBOOL("UseBigPackets", BOOL(mChunkSize == LL_XFER_LARGE_PAYLOAD));
+		gMessageSystem->addUUIDFast(_PREHASH_VFileID, LLUUID::null);
+		gMessageSystem->addS16Fast(_PREHASH_VFileType, -1);
+	
+		gMessageSystem->sendReliable(mRemoteHost);		
+		mStatus = e_LL_XFER_IN_PROGRESS;
+	}
+	else
+	{
+		llwarns << "Couldn't create file to be received!" << llendl;
+		retval = -1;
+	}
+
+	return (retval);
+}
+
+///////////////////////////////////////////////////////////
+
+S32 LLXfer_File::startSend (U64 xfer_id, const LLHost &remote_host)
+{
+	S32 retval = LL_ERR_NOERR;  // presume success
+	
+    mRemoteHost = remote_host;
+	mID = xfer_id;
+   	mPacketNum = -1;
+
+//	cout << "Sending file: " << mLocalFilename << endl;
+
+	delete [] mBuffer;
+	mBuffer = new char[LL_MAX_XFER_FILE_BUFFER];
+
+	mBufferLength = 0;
+	mBufferStartOffset = 0;	
+	
+	mFp = LLFile::fopen(mLocalFilename,"rb");		/* Flawfinder : ignore */
+	if (mFp)
+	{
+		fseek(mFp,0,SEEK_END);
+	
+		S32 file_size = ftell(mFp);
+		if (file_size <= 0)
+		{
+			return LL_ERR_FILE_EMPTY;
+		}
+		setXferSize(file_size);
+
+		fseek(mFp,0,SEEK_SET);
+	}
+	else
+	{
+		llinfos << "Warning: " << mLocalFilename << " not found." << llendl;
+		return (LL_ERR_FILE_NOT_FOUND);
+	}
+
+	mStatus = e_LL_XFER_PENDING;
+
+	return (retval);
+}
+
+///////////////////////////////////////////////////////////
+
+S32 LLXfer_File::getMaxBufferSize ()
+{
+	return(LL_MAX_XFER_FILE_BUFFER);
+}
+
+///////////////////////////////////////////////////////////
+
+S32 LLXfer_File::suck(S32 start_position)
+{
+	S32 retval = 0;
+
+	if (mFp)
+	{
+		// grab a buffer from the right place in the file
+		fseek (mFp,start_position,SEEK_SET);
+		
+		mBufferLength = (U32)fread(mBuffer,1,LL_MAX_XFER_FILE_BUFFER,mFp);
+		mBufferStartOffset = start_position;
+			
+		if (feof(mFp))
+		{
+			mBufferContainsEOF = TRUE;
+		}
+		else
+		{
+			mBufferContainsEOF = FALSE;
+		}		
+	}
+	else
+	{
+		retval = -1;
+	}
+
+	return (retval);
+}
+
+///////////////////////////////////////////////////////////
+
+S32 LLXfer_File::flush()
+{
+	S32 retval = 0;
+	if (mBufferLength)
+	{
+		if (mFp)
+		{
+			llerrs << "Overwriting open file pointer!" << llendl;
+		}
+		mFp = LLFile::fopen(mTempFilename,"a+b");		/* Flawfinder : ignore */
+
+		if (mFp)
+		{
+			fwrite(mBuffer,1,mBufferLength,mFp);
+//			llinfos << "******* wrote " << mBufferLength << " bytes of file xfer" << llendl;
+			fclose(mFp);
+			mFp = NULL;
+			
+			mBufferLength = 0;
+		}
+		else
+		{
+			llwarns << "LLXfer_File::flush() unable to open " << mTempFilename << " for writing!" << llendl;
+			retval = LL_ERR_CANNOT_OPEN_FILE;
+		}
+	}
+	return (retval);
+}
+
+///////////////////////////////////////////////////////////
+
+S32 LLXfer_File::processEOF()
+{
+	S32 retval = 0;
+	mStatus = e_LL_XFER_COMPLETE;
+
+	S32 flushval = flush();
+
+	// If we have no other errors, our error becomes the error generated by
+	// flush.
+	if (!mCallbackResult)
+	{
+		mCallbackResult = flushval;
+	}
+
+	LLFile::remove(mLocalFilename);
+
+	if (!mCallbackResult)
+	{
+		if (LLFile::rename(mTempFilename,mLocalFilename))
+		{
+#if !LL_WINDOWS
+			S32 error_number = errno;
+			llinfos << "Rename failure (" << error_number << ") - "
+					<< mTempFilename << " to " << mLocalFilename << llendl;
+			if(EXDEV == error_number)
+			{
+				if(copy_file(mTempFilename, mLocalFilename) == 0)
+				{
+					llinfos << "Rename across mounts; copying+unlinking the file instead." << llendl;
+					unlink(mTempFilename);
+				}
+				else
+				{
+					llwarns << "Copy failure - " << mTempFilename << " to "
+							<< mLocalFilename << llendl;
+				}
+			}
+			else
+			{
+				//FILE* fp = LLFile::fopen(mTempFilename, "r");
+				//llwarns << "File " << mTempFilename << " does "
+				//		<< (!fp ? "not" : "" ) << " exit." << llendl;
+				//if(fp) fclose(fp);
+				//fp = LLFile::fopen(mLocalFilename, "r");
+				//llwarns << "File " << mLocalFilename << " does "
+				//		<< (!fp ? "not" : "" ) << " exit." << llendl;
+				//if(fp) fclose(fp);
+				llwarns << "Rename fatally failed, can only handle EXDEV ("
+						<< EXDEV << ")" << llendl;
+			}
+#else
+			llwarns << "Rename failure - " << mTempFilename << " to "
+					<< mLocalFilename << llendl;
+#endif
+		}
+	}
+
+	if (mFp)
+	{
+		fclose(mFp);
+		mFp = NULL;
+	}
+
+	retval = LLXfer::processEOF();
+
+	return(retval);
+}
+
+///////////////////////////////////////////////////////////
+
+BOOL LLXfer_File::matchesLocalFilename(const LLString& filename) 
+{
+	return (filename == mLocalFilename);
+}
+
+///////////////////////////////////////////////////////////
+
+BOOL LLXfer_File::matchesRemoteFilename(const LLString& filename, ELLPath remote_path) 
+{
+	return ((filename == mRemoteFilename) && (remote_path == mRemotePath));
+}
+
+
+///////////////////////////////////////////////////////////
+
+const char * LLXfer_File::getName() 
+{
+	return (mLocalFilename);
+}
+
+///////////////////////////////////////////////////////////
+
+// hacky - doesn't matter what this is
+// as long as it's different from the other classes
+U32 LLXfer_File::getXferTypeTag()
+{
+	return LLXfer::XFER_FILE;
+}
+
+///////////////////////////////////////////////////////////
+
+#if !LL_WINDOWS
+
+// This is really close to, but not quite a general purpose copy
+// 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 rv = 0;
+	FILE* in = LLFile::fopen(from, "rb");
+	FILE* out = LLFile::fopen(to, "wb");
+	if(in && out)
+	{
+		S32 read = 0;
+		const S32 COPY_BUFFER_SIZE = 16384;
+		U8 buffer[COPY_BUFFER_SIZE];
+		while(((read = fread(buffer, 1, sizeof(buffer), in)) > 0)
+			  && (fwrite(buffer, 1, read, out) == (U32)read));		/* Flawfinder : ignore */
+		if(ferror(in) || ferror(out)) rv = -2;
+	}
+	else
+	{
+		rv = -1;
+	}
+	if(in) fclose(in);
+	if(out) fclose(out);
+	return rv;
+}
+#endif