studio/src/plugins/bnp_manager/bnp_file.cpp

   1 // Object Viewer Qt - BNP Manager Plugin - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2011  Roland WINKLMEIER <roland.m.winklmeier@gmail.com>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 // Project includes
  18 #include "bnp_file.h"
  19
  20 // Nel includes
  21 #include <nel/misc/debug.h>
  22 #include <nel/misc/file.h>
  23 #include <nel/misc/path.h>
  24 #include <nel/misc/algo.h>
  25 #include <nel/misc/common.h>
  26
  27 // Qt includes
  28
  29 using namespace NLMISC;
  30 using namespace std;
  31
  32
  33 namespace BNPManager
  34 {
  35
  36 PackedFile::PackedFile()
  37 {
  38         m_size = 0;
  39         m_pos = 0;
  40 }
  41
  42 NLMISC_SAFE_SINGLETON_IMPL(BNPFileHandle);
  43
  44 BNPFileHandle::BNPFileHandle()
  45 {
  46         m_offsetFromBeginning = 0;
  47 }
  48 // ***************************************************************************
  49 BNPFileHandle::~BNPFileHandle()
  50 {
  51         // Erase the list
  52         m_packedFiles.clear();
  53 }
  54 // ***************************************************************************
  55 void BNPFileHandle::releaseInstance()
  56 {
  57         if (_Instance)
  58         {
  59                 NLMISC::INelContext::getInstance().releaseSingletonPointer("BNPFileHandle", _Instance);
  60                 delete _Instance;
  61                 _Instance = NULL;
  62         }
  63 }
  64 // ***************************************************************************
  65 void BNPFileHandle::createFile(string filePath)
  66 {
  67         // Only set the filepath. Header will be created after files have been added
  68         m_openedBNPFile = filePath;
  69         m_packedFiles.clear();
  70
  71         nlinfo("Created file %s.", filePath.c_str() );
  72 }
  73 // ***************************************************************************
  74 bool BNPFileHandle::unpack(const string &dirName, const vector<string>& fileList)
  75 {
  76         CIFile bnp;
  77         bnp.open(m_openedBNPFile);
  78
  79         TPackedFilesList::iterator it_files = m_packedFiles.begin();
  80
  81         for (it_files; it_files != m_packedFiles.end(); it_files++)
  82         {
  83                 // Check if the file should be unpacked or not
  84                 if (find(fileList.begin(), fileList.end(), it_files->m_name) != fileList.end())
  85                 {
  86                         string filename = dirName + "/" + it_files->m_name;
  87
  88                         COFile out;
  89                         if ( out.open(filename) )
  90                         {
  91                                 bnp.seek(it_files->m_pos, IStream::begin);
  92                                 uint8 *ptr = new uint8[it_files->m_size];
  93                                 bnp.serialBuffer(ptr,it_files->m_size);
  94                                 out.serialBuffer(ptr,it_files->m_size);
  95                                 delete [] ptr;
  96                         }
  97                         out.close();
  98                 }
  99         }
 100
 101         bnp.close();
 102         return true;
 103 }
 104 // ***************************************************************************
 105 // Read the header from a big file
 106 bool BNPFileHandle::readHeader(const std::string &filePath)
 107 {
 108         m_packedFiles.clear();
 109
 110         m_openedBNPFile = filePath;
 111
 112         CIFile bnp;
 113         bnp.open (filePath);
 114
 115         bnp.seek(0, IStream::end);
 116         uint32 nFileSize = bnp.getFileSize();
 117         bnp.seek(nFileSize-sizeof(uint32), IStream::begin);
 118
 119         uint32 nOffsetFromBeginning;
 120
 121         bnp.serial(nOffsetFromBeginning);
 122
 123         if ( !bnp.seek (nOffsetFromBeginning, IStream::begin) )
 124         {
 125                 nlwarning("Could not read offset from beginning");
 126                 bnp.close();
 127                 return false;
 128         }
 129
 130         uint32 nNbFile;
 131         bnp.serial(nNbFile);
 132
 133         for (uint32 i = 0; i < nNbFile; ++i)
 134         {
 135                 uint8 nStringSize;
 136                 char sName[256];
 137
 138                 bnp.serial(nStringSize);
 139                 bnp.serialBuffer( (uint8*)sName, nStringSize);
 140                 sName[nStringSize] = 0;
 141
 142                 PackedFile tmpPackedFile;
 143                 tmpPackedFile.m_name = sName;
 144                 tmpPackedFile.m_path = m_openedBNPFile;
 145
 146                 bnp.serial(tmpPackedFile.m_size);
 147                 bnp.serial(tmpPackedFile.m_pos);
 148
 149                 m_packedFiles.push_back (tmpPackedFile);
 150         }
 151
 152         bnp.close();
 153         return true;
 154 }
 155 // ***************************************************************************
 156 void BNPFileHandle::list(TPackedFilesList& FileList)
 157 {
 158         PackedFile tmpFile;
 159         TPackedFilesList::iterator it = m_packedFiles.begin();
 160         while (it != m_packedFiles.end() )
 161         {
 162                 tmpFile.m_name = it->m_name;
 163                 tmpFile.m_pos = it->m_pos;
 164                 tmpFile.m_size = it->m_size;
 165                 tmpFile.m_path = it->m_path;
 166                 FileList.push_back(tmpFile);
 167                 it++;
 168         }
 169 }
 170 // ***************************************************************************
 171 bool BNPFileHandle::writeHeader( const std::string &filePath, uint32 offset )
 172 {
 173         COFile bnp;
 174         bnp.open(filePath, true);
 175         if ( !bnp.isOpen() )
 176                 return false;
 177
 178         uint32 nNbFile = (uint32)m_packedFiles.size();
 179         bnp.serial(nNbFile);
 180
 181         for (uint32 i = 0; i < nNbFile; ++i)
 182         {
 183                 uint8 nStringSize = (uint8)m_packedFiles[i].m_name.size();
 184                 bnp.serial( nStringSize );
 185                 bnp.serialBuffer( (uint8*)m_packedFiles[i].m_name.c_str(), nStringSize   );
 186                 bnp.serial(m_packedFiles[i].m_size);
 187                 bnp.serial(m_packedFiles[i].m_pos);
 188         }
 189
 190         bnp.serial(offset);
 191
 192         bnp.close();
 193
 194         return true;
 195 }
 196 // ***************************************************************************
 197 void BNPFileHandle::fileNames(std::vector<std::string> &fileNames)
 198 {
 199         TPackedFilesList::iterator it = m_packedFiles.begin();
 200         while (it != m_packedFiles.end() )
 201         {
 202                 fileNames.push_back(it->m_name);
 203                 it++;
 204         }
 205 }
 206 // ***************************************************************************
 207 void BNPFileHandle::addFiles( const vector<string> &filePathes)
 208 {
 209         uint32 OffsetFromBeginning = 0;
 210
 211         // create packed files and add them to the private vector
 212         vector<string>::const_iterator it_vec = filePathes.begin();
 213         while (it_vec != filePathes.end() )
 214         {
 215                 PackedFile tmpFile;
 216                 tmpFile.m_name = CFile::getFilename (*it_vec);
 217                 // Leave position to 0 and set the value during the new bnp file is creating
 218                 // We need the position only for the header at the end
 219                 tmpFile.m_pos = 0;
 220                 tmpFile.m_size = CFile::getFileSize(*it_vec);
 221                 tmpFile.m_path = *it_vec;
 222                 m_packedFiles.push_back( tmpFile );
 223
 224                 it_vec++;
 225         }
 226
 227         // sort packed files alphabetic
 228         std::sort ( m_packedFiles.begin(), m_packedFiles.end(), compare );
 229
 230         // create a new temporary bnp file with extension *.tmp
 231         TPackedFilesList::iterator it_packed = m_packedFiles.begin();
 232         while (it_packed != m_packedFiles.end() )
 233         {
 234                 append(m_openedBNPFile + ".tmp", *it_packed);
 235                 // Set now the new offset for the new header
 236                 it_packed->m_pos = OffsetFromBeginning;
 237                 OffsetFromBeginning += it_packed->m_size;
 238
 239                 it_packed++;
 240         }
 241
 242         writeHeader(m_openedBNPFile + ".tmp", OffsetFromBeginning);
 243
 244         // Delete any previous existing file
 245         if (CFile::fileExists( m_openedBNPFile ))
 246                 CFile::deleteFile( m_openedBNPFile );
 247         string src = m_openedBNPFile + ".tmp";
 248         CFile::moveFile(m_openedBNPFile, src);
 249 }
 250 // ***************************************************************************
 251 void BNPFileHandle::deleteFiles( const vector<string>& fileNames)
 252 {
 253         vector<string>::const_iterator it_vec;
 254         TPackedFilesList::iterator it_packed;
 255         uint32 OffsetFromBeginning = 0;
 256         string tmpFile = m_openedBNPFile + ".tmp";
 257
 258         // create a new temporary bnp file with extension *.tmp
 259         it_packed = m_packedFiles.begin();
 260         while (it_packed != m_packedFiles.end() )
 261         {
 262                 // check each packed file if it should be deleted
 263                 it_vec = find (fileNames.begin(), fileNames.end(), it_packed->m_name );
 264                 if ( it_vec != fileNames.end() )
 265                 {
 266                         nlinfo("Deleting file %s.", it_packed->m_name.c_str() );
 267                         it_packed = m_packedFiles.erase(it_packed);
 268                 }
 269                 else
 270                 {
 271                         append(tmpFile, *it_packed);
 272                         // Set now the new offset for the new header
 273                         it_packed->m_pos = OffsetFromBeginning;
 274                         OffsetFromBeginning += it_packed->m_size;
 275
 276                         it_packed++;
 277                 }
 278         }
 279
 280         writeHeader(tmpFile, OffsetFromBeginning);
 281
 282         CFile::deleteFile( m_openedBNPFile );
 283         string src = m_openedBNPFile + ".tmp";
 284         CFile::moveFile(m_openedBNPFile, src);
 285 }
 286 // ***************************************************************************
 287 void BNPFileHandle::append(const string &destination, const PackedFile &source)
 288 {
 289         // check if the file exists and create one if not
 290         if ( !CFile::fileExists(destination) )
 291                 CFile::createEmptyFile( destination );
 292
 293         COFile bnpfile;
 294         CIFile packedfile;
 295         bnpfile.open(destination, true);
 296         packedfile.open(source.m_path);
 297         if ( !bnpfile.isOpen() ) return;
 298
 299
 300         uint8 *ptr = new uint8[source.m_size];
 301
 302         // check if the source is a bnp file.
 303         if ( nlstricmp( CFile::getExtension(source.m_path), "bnp" ) == 0 )
 304         {
 305                 // Jump to the file position inside the bnp
 306                 packedfile.seek(source.m_pos, IStream::begin);
 307         }
 308         // Read the source
 309         packedfile.serialBuffer(ptr, source.m_size);
 310
 311         // Append the data to the destination
 312         bnpfile.serialBuffer(ptr, source.m_size);
 313
 314         delete [] ptr;
 315
 316         packedfile.close();
 317         bnpfile.close();
 318 }
 319 // ***************************************************************************
 320 bool BNPFileHandle::compare(const PackedFile &left, const PackedFile &right)
 321 {
 322         return nlstricmp (left.m_name.c_str(), right.m_name.c_str()) < 0;
 323 }
 324 } // namespace BNPManager