Second Life viewer sources 1.14.0.0

1 files changed, 118 insertions, 59 deletions

diff --git a/linden/indra/llvfs/llvfs.cpp b/linden/indra/llvfs/llvfs.cpp
index bb211df..88476eb 100644
--- a/linden/indra/llvfs/llvfs.cpp
+++ b/linden/indra/llvfs/llvfs.cpp
@@ -63,12 +63,11 @@ public:
                 mLength = size;
         }
     
-        static BOOL insertFirstLL(LLVFSBlock *first, LLVFSBlock *second)
+        static bool locationSortPredicate(
+                const LLVFSBlock* lhs,
+                const LLVFSBlock* rhs)
         {
-                return first->mLocation != second->mLocation
-                        ? first->mLocation < second->mLocation
-                        : first->mLength < second->mLength;
-
+                return lhs->mLocation < rhs->mLocation;
         }
 
 public:
@@ -129,7 +128,7 @@ public:
         }
 
         #ifdef LL_LITTLE_ENDIAN
-        inline void swizzleCopy(void *dst, void *src, int size) { memcpy(dst, src, size); }
+        inline void swizzleCopy(void *dst, void *src, int size) { memcpy(dst, src, size); /* Flawfinder: ignore */}
 
         #else
         
@@ -156,7 +155,7 @@ public:
                 else
                 {
                         // Perhaps this should assert...
-                        memcpy(dst, src, size);
+                        memcpy(dst, src, size); /* Flawfinder: ignore */
                 }
         }
         
@@ -170,7 +169,7 @@ public:
                 buffer +=4;
                 swizzleCopy(buffer, &mAccessTime, 4);
                 buffer +=4;
-                memcpy(buffer, &mFileID.mData, 16);
+                memcpy(buffer, &mFileID.mData, 16); /* Flawfinder: ignore */    
                 buffer += 16;
                 S16 temp_type = mFileType;
                 swizzleCopy(buffer, &temp_type, 2);
@@ -239,10 +238,15 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
         }
         mValid = VFSVALID_OK;
         mReadOnly = read_only;
-        mIndexFilename = new char[strlen(index_filename) + 1];
-        mDataFilename = new char[strlen(data_filename) + 1];
-        strcpy(mIndexFilename, index_filename);
-        strcpy(mDataFilename, data_filename);
+        mIndexFilename = new char[strlen(index_filename) + 1];  /* Flawfinder: ignore */
+        mDataFilename = new char[strlen(data_filename) + 1];    /* Flawfinder: ignore */
+        if (mIndexFilename == NULL || mDataFilename  == NULL)
+        {
+                llerrs << "Memory Allocation Failure" << llendl;
+                return;
+        }
+        strcpy(mIndexFilename, index_filename); /* Flawfinder: ignore */
+        strcpy(mDataFilename, data_filename);   /* Flawfinder: ignore */
     
         const char *file_mode = mReadOnly ? "rb" : "r+b";
     
@@ -266,13 +270,23 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
                 {
                         llwarns << "Can't open VFS data file " << mDataFilename << " attempting to use alternate" << llendl;
     
-                        char *temp_index = new char[strlen(mIndexFilename) + 10];
-                        char *temp_data = new char[strlen(mDataFilename) + 10];
+                        char *temp_index = new char[strlen(mIndexFilename) + 10];       /* Flawfinder: ignore */
+                        if (!temp_index)
+                        {
+                                llerrs << "Out of the memory in LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL read_only, const U32 presize, const BOOL remove_after_crash)" << llendl;
+                                return;
+                        }
+                        char *temp_data = new char[strlen(mDataFilename) + 10]; /* Flawfinder: ignore */
+                        if (!temp_data)
+                        {
+                                llerrs << "Out of the memory in LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL read_only, const U32 presize, const BOOL remove_after_crash)" << llendl;
+                                return;
+                        }
 
                         for (U32 count = 0; count < 256; count++)
                         {
-                                sprintf(temp_index, "%s.%u", mIndexFilename, count);
-                                sprintf(temp_data, "%s.%u", mDataFilename, count);
+                                sprintf(temp_index, "%s.%u", mIndexFilename, count);    /* Flawfinder: ignore */
+                                sprintf(temp_data, "%s.%u", mDataFilename, count);      /* Flawfinder: ignore */
     
                                 // try just opening, then creating, each alternate
                                 if ((mDataFP = openAndLock(temp_data, "r+b", FALSE)))
@@ -313,8 +327,13 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
         if (!mReadOnly && mRemoveAfterCrash)
         {
                 llstat marker_info;
-                char* marker = new char[strlen(mDataFilename) + strlen(".open") + 1];
-                sprintf(marker, "%s.open", mDataFilename);
+                char* marker = new char[strlen(mDataFilename) + strlen(".open") + 1];   /* Flawfinder: ignore */
+                if (!marker )
+                {
+                        llerrs << "Out of memory in LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL read_only, const U32 presize, const BOOL remove_after_crash)" << llendl;
+                        return;
+                }
+                sprintf(marker, "%s.open", mDataFilename);      /* Flawfinder: ignore */
                 if (!LLFile::stat(marker, &marker_info))
                 {
                         // marker exists, kill the lock and the VFS files
@@ -361,9 +380,8 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
     
                 U8 *tmp_ptr = buffer;
     
-                LLLinkedList<LLVFSBlock> files_by_loc;
-                files_by_loc.setInsertBefore(LLVFSBlock::insertFirstLL);
-
+                std::vector<LLVFSFileBlock*> files_by_loc;
+                
                 while (tmp_ptr < buffer + fbuf.st_size)
                 {
                         LLVFSFileBlock *block = new LLVFSFileBlock();
@@ -383,7 +401,7 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
                                 block->mFileType < LLAssetType::AT_COUNT)
                         {
                                 mFileBlocks.insert(fileblock_map::value_type(*block, block));
-                                files_by_loc.addDataSorted(block);
+                                files_by_loc.push_back(block);
                         }
                         else
                         if (block->mLength && block->mSize > 0)
@@ -419,22 +437,40 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
                         tmp_ptr += block->SERIAL_SIZE;
                 }
                 delete[] buffer;
-    
-                // discover all the free blocks
-                LLVFSFileBlock *last_file_block = (LLVFSFileBlock*)files_by_loc.getFirstData();
-    
-                if (last_file_block)
+
+                std::sort(
+                        files_by_loc.begin(),
+                        files_by_loc.end(),
+                        LLVFSFileBlock::locationSortPredicate);
+
+                // There are 3 cases that have to be considered.
+                // 1. No blocks
+                // 2. One block.
+                // 3. Two or more blocks.
+                if (!files_by_loc.empty())
                 {
-                        // check for empty space at the beginning
+                        // cur walks through the list.
+                        std::vector<LLVFSFileBlock*>::iterator cur = files_by_loc.begin();
+                        std::vector<LLVFSFileBlock*>::iterator end = files_by_loc.end();
+                        LLVFSFileBlock* last_file_block = *cur;
+                        
+                        // Check to see if there is an empty space before the first file.
                         if (last_file_block->mLocation > 0)
                         {
-                                LLVFSBlock *block = new LLVFSBlock(0, last_file_block->mLocation);
-                                addFreeBlock(block);
+                                // If so, create a free block.
+                                addFreeBlock(new LLVFSBlock(0, last_file_block->mLocation));
                         }
-    
-                        LLVFSFileBlock *cur_file_block;
-                        while ((cur_file_block = (LLVFSFileBlock*)files_by_loc.getNextData()))
+
+                        // Walk through the 2nd+ block.  If there is a free space
+                        // between cur_file_block and last_file_block, add it to
+                        // the free space collection.  This block will not need to
+                        // run in the case there is only one entry in the VFS.
+                        ++cur;
+                        while( cur != end )
                         {
+                                LLVFSFileBlock* cur_file_block = *cur;
+
+                                // Dupe check on the block
                                 if (cur_file_block->mLocation == last_file_block->mLocation
                                         && cur_file_block->mLength == last_file_block->mLength)
                                 {
@@ -451,21 +487,29 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
                                         if (cur_file_block->mLength > 0)
                                         {
                                                 // convert to hole
-                                                LLVFSBlock* block = new LLVFSBlock(cur_file_block->mLocation,
-                                                                                                                   cur_file_block->mLength);
-                                                addFreeBlock(block);
+                                                addFreeBlock(
+                                                        new LLVFSBlock(
+                                                                cur_file_block->mLocation,
+                                                                cur_file_block->mLength));
                                         }
                                         lockData();                                             // needed for sync()
                                         sync(cur_file_block, TRUE);             // remove first on disk
                                         sync(last_file_block, TRUE);    // remove last on disk
                                         unlockData();                                   // needed for sync()
                                         last_file_block = cur_file_block;
+                                        ++cur;
                                         continue;
                                 }
 
-                                U32 loc = last_file_block->mLocation + last_file_block->mLength;
+                                // Figure out where the last block ended.
+                                U32 loc = last_file_block->mLocation+last_file_block->mLength;
+
+                                // Figure out how much space there is between where
+                                // the last block ended and this block begins.
                                 S32 length = cur_file_block->mLocation - loc;
     
+                                // Check for more errors...  Seeing if the current
+                                // entry and the last entry make sense together.
                                 if (length < 0 || loc < 0 || loc > data_size)
                                 {
                                         // Invalid VFS
@@ -487,27 +531,25 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
                                         return;
                                 }
 
+                                // we don't want to add empty blocks to the list...
                                 if (length > 0)
                                 {
-                                        LLVFSBlock *block = new LLVFSBlock(loc, length);
-                                        addFreeBlock(block);
+                                        addFreeBlock(new LLVFSBlock(loc, length));
                                 }
-    
                                 last_file_block = cur_file_block;
+                                ++cur;
                         }
     
                         // also note any empty space at the end
                         U32 loc = last_file_block->mLocation + last_file_block->mLength;
                         if (loc < data_size)
                         {
-                                LLVFSBlock *block = new LLVFSBlock(loc, data_size - loc);
-                                addFreeBlock(block);
+                                addFreeBlock(new LLVFSBlock(loc, data_size - loc));
                         }
                 }
-                else
+                else // There where no blocks in the file.
                 {
-                        LLVFSBlock *first_block = new LLVFSBlock(0, data_size);
-                        addFreeBlock(first_block);
+                        addFreeBlock(new LLVFSBlock(0, data_size));
                 }
         }
         else
@@ -542,8 +584,13 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
         if (!mReadOnly && mRemoveAfterCrash)
         {
                 char* marker = new char[strlen(mDataFilename) + strlen(".open") + 1];
-                sprintf(marker, "%s.open", mDataFilename);
-                FILE* marker_fp = LLFile::fopen(marker, "w");
+                if (!marker)
+                {
+                        llerrs << "Out of memory in LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL read_only, const U32 presize, const BOOL remove_after_crash)" << llendl;
+                        return;
+                }
+                sprintf(marker, "%s.open", mDataFilename);      /* Flawfinder: ignore */
+                FILE* marker_fp = LLFile::fopen(marker, "w");   /* Flawfinder: ignore */
                 if (marker_fp)
                 {
                         fclose(marker_fp);
@@ -586,7 +633,12 @@ LLVFS::~LLVFS()
         if (!mReadOnly && mRemoveAfterCrash)
         {
                 char* marker_file = new char[strlen(mDataFilename) + strlen(".open") + 1];
-                sprintf(marker_file, "%s.open", mDataFilename);
+                if (marker_file == NULL)
+                {
+                        llerrs << "Memory Allocation Failure" << llendl;
+                        return;
+                }
+                sprintf(marker_file, "%s.open", mDataFilename); /* Flawfinder: ignore */
                 LLFile::remove(marker_file);
                 delete [] marker_file;
                 marker_file = NULL;
@@ -738,12 +790,17 @@ BOOL LLVFS::setMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type
         }
     
         // round all sizes upward to KB increments
-        if (max_size & FILE_BLOCK_MASK)
+        // SJB: Need to not round for the new texture-pipeline code so we know the correct
+        //      max file size. Need to investigate the potential problems with this...
+        if (file_type != LLAssetType::AT_TEXTURE)
         {
-                max_size += FILE_BLOCK_MASK;
-                max_size &= ~FILE_BLOCK_MASK;
-        }
-    
+                if (max_size & FILE_BLOCK_MASK)
+                {
+                        max_size += FILE_BLOCK_MASK;
+                        max_size &= ~FILE_BLOCK_MASK;
+                }
+    }
+        
         if (block && block->mLength > 0)
         {    
                 block->mAccessTime = (U32)time(NULL);
@@ -1230,6 +1287,7 @@ void LLVFS::eraseBlockLength(LLVFSBlock *block)
         S32 length = block->mLength;
         blocks_length_map_t::iterator iter = mFreeBlocksByLength.lower_bound(length);
         blocks_length_map_t::iterator end = mFreeBlocksByLength.end();
+        bool found_block = false;
         while(iter != end)
         {
                 LLVFSBlock *tblock = iter->second;
@@ -1237,13 +1295,14 @@ void LLVFS::eraseBlockLength(LLVFSBlock *block)
                 if (tblock == block)
                 {
                         mFreeBlocksByLength.erase(iter);
+                        found_block = true;
                         break;
                 }
                 ++iter;
         }
-        if (iter == end)
+        if(!found_block)
         {
-                llerrs << "eraseBlock could not find block" << llendl;
+                llwarns << "eraseBlock could not find block" << llendl;
         }
 }
 
@@ -1963,7 +2022,7 @@ LLString get_extension(LLAssetType::EType type)
         switch(type)
         {
           case LLAssetType::AT_TEXTURE:
-                extension = ".jp2"; // ".j2c"; // IrfanView recognizes .jp2 -sjb
+                extension = ".j2c";
                 break;
           case LLAssetType::AT_SOUND:
                 extension = ".ogg";
@@ -2033,7 +2092,7 @@ void LLVFS::dumpFiles()
                         lockData();
                         
                         LLString extension = get_extension(type);
-                        LLString filename = id.getString() + extension;
+                        LLString filename = id.asString() + extension;
                         llinfos << " Writing " << filename << llendl;
                         apr_file_t* file = ll_apr_file_open(filename, LL_APR_WB);
                         ll_apr_file_write(file, buffer, size);
@@ -2064,7 +2123,7 @@ FILE *LLVFS::openAndLock(const char *filename, const char *mode, BOOL read_lock)
         // first test the lock in a non-destructive way
         if (strstr(mode, "w"))
         {
-                fp = LLFile::fopen(filename, "rb");
+                fp = LLFile::fopen(filename, "rb");     /* Flawfinder: ignore */
                 if (fp)
                 {
                         fd = fileno(fp);
@@ -2079,7 +2138,7 @@ FILE *LLVFS::openAndLock(const char *filename, const char *mode, BOOL read_lock)
         }
 
         // now actually open the file for use
-        fp = LLFile::fopen(filename, mode);
+        fp = LLFile::fopen(filename, mode);     /* Flawfinder: ignore */
         if (fp)
         {
                 fd = fileno(fp);