llxfer_vfile.cpp

Go to the documentation of this file.

#include "linden_common.h"

#include "llxfer_vfile.h"
#include "lluuid.h"
#include "llerror.h"
#include "llmath.h"
#include "llvfile.h"
#include "llvfs.h"
#include "lldir.h"

// size of chunks read from/written to disk
const U32 LL_MAX_XFER_FILE_BUFFER = 65536;


LLXfer_VFile::LLXfer_VFile ()
: LLXfer(-1)
{
        init(NULL, LLUUID::null, LLAssetType::AT_NONE);
}

LLXfer_VFile::LLXfer_VFile (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type)
: LLXfer(-1)
{
        init(vfs, local_id, type);
}


LLXfer_VFile::~LLXfer_VFile ()
{
        free();
}


void LLXfer_VFile::init (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type)
{

        mVFS = vfs;
        mLocalID = local_id;
        mType = type;

        mVFile = NULL;

        char id_string[UUID_STR_LENGTH];                        /* Flawfinder : ignore */
        mLocalID.toString(id_string);

        snprintf(mName, sizeof(mName), "VFile %s:%s", id_string, LLAssetType::lookup(mType));           /* Flawfinder : ignore */
}
        

void LLXfer_VFile::free ()
{
        LLVFile file(mVFS, mTempID, mType, LLVFile::WRITE);
        file.remove();

        delete mVFile;
        mVFile = NULL;

        LLXfer::free();
}


S32 LLXfer_VFile::initializeRequest(U64 xfer_id,
                                                                        LLVFS* vfs,
                                                                        const LLUUID& local_id,
                                                                        const LLUUID& remote_id,
                                                                        LLAssetType::EType type,
                                                                        const LLHost& remote_host,
                                                                        void (*callback)(void**,S32,LLExtStat),
                                                                        void** user_data)
{
        S32 retval = 0;  // presume success
        
        mRemoteHost = remote_host;

        mVFS = vfs;
        mLocalID = local_id;
        mRemoteID = remote_id;
        mType = type;

        mID = xfer_id;
        mCallback = callback;
        mCallbackDataHandle = user_data;
        mCallbackResult = LL_ERR_NOERR;

        char id_string[UUID_STR_LENGTH];                /* Flawfinder : ignore */
        mLocalID.toString(id_string);

        snprintf(mName, sizeof(mName), "VFile %s:%s", id_string, LLAssetType::lookup(mType));           /* Flawfinder : ignore */

        llinfos << "Requesting " << mName << llendl;

        if (mBuffer)
        {
                delete[] mBuffer;
                mBuffer = NULL;
        }

        mBuffer = new char[LL_MAX_XFER_FILE_BUFFER];

        mBufferLength = 0;
        mPacketNum = 0;
        mTempID.generate();
        mStatus = e_LL_XFER_PENDING;
        return retval;
}


S32 LLXfer_VFile::startDownload()
{
        S32 retval = 0;  // presume success
        LLVFile file(mVFS, mTempID, mType, LLVFile::APPEND);

        gMessageSystem->newMessageFast(_PREHASH_RequestXfer);
        gMessageSystem->nextBlockFast(_PREHASH_XferID);
        gMessageSystem->addU64Fast(_PREHASH_ID, mID);
        gMessageSystem->addStringFast(_PREHASH_Filename, "");
        gMessageSystem->addU8("FilePath", (U8) LL_PATH_NONE);
        gMessageSystem->addBOOL("DeleteOnCompletion", FALSE);
        gMessageSystem->addBOOL("UseBigPackets", BOOL(mChunkSize == LL_XFER_LARGE_PAYLOAD));
        gMessageSystem->addUUIDFast(_PREHASH_VFileID, mRemoteID);
        gMessageSystem->addS16Fast(_PREHASH_VFileType, (S16)mType);

        gMessageSystem->sendReliable(mRemoteHost);              
        mStatus = e_LL_XFER_IN_PROGRESS;

        return (retval);
}


S32 LLXfer_VFile::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; 
        
        delete mVFile;
        mVFile = NULL;
        if(mVFS->getExists(mLocalID, mType))
        {
                mVFile = new LLVFile(mVFS, mLocalID, mType, LLVFile::READ);

                if (mVFile->getSize() <= 0)
                {
                        delete mVFile;
                        mVFile = NULL;

                        return LL_ERR_FILE_EMPTY;
                }
        }

        if(mVFile)
        {
                setXferSize(mVFile->getSize());
                mStatus = e_LL_XFER_PENDING;
        }
        else
        {
                retval = LL_ERR_FILE_NOT_FOUND;
        }

        return (retval);
}

void LLXfer_VFile::setXferSize (S32 xfer_size)
{       
        LLXfer::setXferSize(xfer_size);

        // Don't do this on the server side, where we have a persistent mVFile
        // It would be nice if LLXFers could tell which end of the pipe they were
        if (! mVFile)
        {
                LLVFile file(mVFS, mTempID, mType, LLVFile::APPEND);
                file.setMaxSize(xfer_size);
        }
}


S32 LLXfer_VFile::getMaxBufferSize ()
{
        return(LL_MAX_XFER_FILE_BUFFER);
}


S32 LLXfer_VFile::suck(S32 start_position)
{
        S32 retval = 0;

        if (mVFile)
        {
                // grab a buffer from the right place in the file
                if (! mVFile->seek(start_position, 0))
                {
                        llwarns << "VFile Xfer Can't seek to position " << start_position << ", file length " << mVFile->getSize() << llendl;
                        llwarns << "While sending file " << mLocalID << llendl;
                        return -1;
                }
                
                if (mVFile->read((U8*)mBuffer, LL_MAX_XFER_FILE_BUFFER))                /* Flawfinder : ignore */
                {
                        mBufferLength = mVFile->getLastBytesRead();
                        mBufferStartOffset = start_position;

                        mBufferContainsEOF = mVFile->eof();
                }
                else
                {
                        retval = -1;
                }
        }
        else
        {
                retval = -1;
        }

        return (retval);
}


S32 LLXfer_VFile::flush()
{
        S32 retval = 0;
        if (mBufferLength)
        {
                LLVFile file(mVFS, mTempID, mType, LLVFile::APPEND);

                file.write((U8*)mBuffer, mBufferLength);
                        
                mBufferLength = 0;
        }
        return (retval);
}


S32 LLXfer_VFile::processEOF()
{
        S32 retval = 0;
        mStatus = e_LL_XFER_COMPLETE;

        flush();

        if (!mCallbackResult)
        {
                LLVFile file(mVFS, mTempID, mType, LLVFile::WRITE);
                if (! file.rename(mLocalID, mType))
                {
                        llinfos << "copy from temp file failed: unable to rename to " << mLocalID << llendl;
                }

        }

        if (mVFile)
        {
                delete mVFile;
                mVFile = NULL;
        }

        retval = LLXfer::processEOF();

        return(retval);
}


BOOL LLXfer_VFile::matchesLocalFile(const LLUUID &id, LLAssetType::EType type)
{
        return (id == mLocalID && type == mType);
}


BOOL LLXfer_VFile::matchesRemoteFile(const LLUUID &id, LLAssetType::EType type)
{
        return (id == mRemoteID && type == mType);
}


const char * LLXfer_VFile::getName() 
{
        return mName;
}


// hacky - doesn't matter what this is
// as long as it's different from the other classes
U32 LLXfer_VFile::getXferTypeTag()
{
        return LLXfer::XFER_VFILE;
}

---