src/rararchive.cc

   1 /***************************************************************************
   2  *  Copyright (C) 2006-2008  Kent Gustavsson <nedo80@gmail.com>
   3  ****************************************************************************/
   4  /*
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20
  21 //
  22 // Class: RARArchive
  23 //
  24 // Created by: Kent Gustavsson <nedo80@gmail.com>
  25 // Created on: Sun Mar  5 00:40:27 2006
  26 //
  27
  28 #include "rararchive.h"
  29 #include <fstream>
  30 #include <sstream>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <unistd.h>
  34 #include <stdlib.h>
  35 #include <cstdlib>
  36 #include <time.h>
  37
  38 RARArchive::RARArchive()
  39 {
  40         default_date = 0;
  41 }
  42
  43
  44 RARArchive::~RARArchive()
  45 {
  46         std::vector <std::ifstream*>::iterator iter;
  47
  48         for( iter = streams.begin() ; iter != streams.end() ; iter++)
  49         {
  50                 (*iter)->close();
  51         }
  52 }
  53
  54 int
  55 RARArchive::Init(std::string filename)
  56 {
  57         struct stat st;
  58         stat(filename.c_str(), &st);
  59         default_date = st.st_mtime;
  60
  61 // Hate this part
  62         this->filename = filename;
  63
  64         volsuffix = ".rar";
  65         voldigits = 0;
  66         std::string numprefix;
  67         std::size_t offset;
  68
  69         offset = volsuffix.size();
  70         if ( offset <= filename.size() &&
  71         filename.substr(filename.size()-offset) == volsuffix )
  72         {
  73                 /* Ends in ".rar"; check for "part<N>.rar" */
  74                 numprefix = "part";
  75         }
  76         else
  77         {
  78                 /* Try ".<N>" */
  79                 volsuffix = "";
  80                 numprefix = ".";
  81         }
  82
  83         while(true)
  84         {
  85                 offset = voldigits+volsuffix.size();
  86                 if ( offset >= filename.size() ||
  87                 !isdigit(filename[filename.size()-offset-1]))
  88                 {
  89                         break;
  90                 }
  91
  92                 voldigits++;
  93                 if ( voldigits > 5 )
  94                         return false;
  95         }
  96
  97         offset = numprefix.size() + voldigits + volsuffix.size();
  98         if ( offset <= filename.size() && filename.substr(
  99         filename.size() - offset, numprefix.size()) == numprefix )
 100         {
 101                 offset = volsuffix.size()+voldigits;
 102                 volprefix = filename.substr(0, filename.size()-offset);
 103                 firstfile = atoi( filename.substr(
 104                         filename.size()-offset, voldigits).c_str() );
 105         }
 106         else
 107                 voldigits = 0;
 108
 109         return true;
 110 }
 111
 112 std::string
 113 RARArchive::GetFileName(int n)
 114 {
 115         if ( n == 0 )
 116                 return filename;
 117
 118         std::stringstream f;
 119
 120         if ( voldigits == 0 )
 121         {
 122                 /* n=0 => .rar (see above), n=1 => .r00, n=2 => .r01, etc */
 123                 if( n-1 < 10 )
 124                         f << filename.substr(0,filename.size()-2) << 0 << n-1;
 125                 else
 126                         f << filename.substr(0,filename.size()-2) << n-1;
 127         }
 128         else
 129         {
 130                 char prev;
 131
 132                 f << volprefix;
 133
 134                 prev = f.fill ('0');
 135                 f.width (voldigits);
 136                 f << n + firstfile;
 137                 f.fill(prev);
 138                 f.width(0);
 139
 140                 f << volsuffix;
 141         }
 142
 143         return f.str();
 144 }
 145
 146 bool
 147 RARArchive::HasFile(std::string f)
 148 {
 149         if( fileblocks.find(f) == fileblocks.end() )
 150                 return false;
 151         return true;
 152
 153 }
 154
 155 bool
 156 RARArchive::HasFolder(std::string f)
 157 {
 158         if( folderblocks.find(f) == folderblocks.end() )
 159                 return false;
 160         return true;
 161
 162 }
 163 unsigned long long int
 164 RARArchive::GetFileSize(std::string file)
 165 {
 166         unsigned long long int size = 0;
 167         if( fileblocks.find(file) == fileblocks.end() )
 168                 return 0;
 169
 170         std::vector <FileBlock *>::iterator i;
 171         for(i = fileblocks[file].begin() ; i != fileblocks[file].end() ; i++ )
 172         {
 173                 size += (*i)->GetDataSize();
 174         }
 175
 176         return size;
 177 }
 178
 179 void
 180 RARArchive::Parse(bool showcompressed)
 181 {
 182         int n = 0;
 183         for(;;)
 184         {
 185                 std::ifstream *file = new std::ifstream(GetFileName(n++).c_str());
 186                 if(!file->good())
 187                         return;
 188                 streams.push_back(file);
 189
 190                 for(;;)
 191                 {
 192                         if(!file->good())
 193                                 break;
 194
 195                         char buf[4];
 196                         file->read(buf,3);
 197                         //for some rar files there are seeks past file end, then directly to file end
 198                         //which makes file->good() return true, but there is nothing to read
 199                         //so with file->gcount() we check if we actually read something
 200                         //otherwise we use old bufer and crash somewhere
 201                         if(file->gcount()==0)
 202                                 break;
 203
 204                         file->seekg (-3, std::ios::cur);
 205
 206                         switch( buf[2] )
 207                         {
 208                                 case 0x00:
 209                                         break;
 210                                 case 0x72:
 211                                         blocks.push_back( new MarkerBlock(*file) );
 212                                         break;
 213                                 case 0x73:
 214                                         blocks.push_back( new ArchiveBlock(*file) );
 215                                         break;
 216                                 case 0x74:
 217                                         FileBlock *f;
 218                                         f = new FileBlock(*file);
 219
 220                                         if ( showcompressed || !f->isCompressed() )
 221                                         {
 222                                                 if ( f->isFolder() )
 223                                                         folderblocks[f->GetFileName()].push_back(f);
 224                                                 else
 225                                                 {
 226                                                         fileblocks[f->GetFileName()].push_back(f);
 227
 228                                                         for ( int pos = 0 ; ( pos = f->GetFileName().find("\\", pos) ) != std::string::npos ; pos++)
 229                                                         {
 230                                                                 if( folderblocks.find(f->GetFileName().substr(0,pos)) == folderblocks.end())
 231                                                                         folderblocks[f->GetFileName().substr(0,pos)].push_back(NULL);
 232                                                         }
 233                                                 }
 234                                         }
 235
 236                                         blocks.push_back( f );
 237
 238                                         break;
 239                                 default:
 240                                         blocks.push_back( new RARBlock(*file) );
 241                         }
 242
 243                         if ( buf[2] == 0 || buf[2] == 0x7B || buf[2] == 0x78 )
 244                         {
 245
 246                                 break;
 247                         }
 248                 }
 249                 file->clear();
 250                 file->seekg(0);
 251         }
 252
 253 }
 254
 255 unsigned int
 256 RARArchive::Read(const char *path, char *buf, size_t size, off_t offset)
 257 {
 258         unsigned int pos = 0;
 259         if ( fileblocks.find(path) == fileblocks.end() )
 260         //      return -ENOENT;
 261                 return -1;
 262
 263         std::vector <FileBlock *>::iterator i;
 264         for(i = fileblocks[path].begin() ; i != fileblocks[path].end() ; i++ )
 265         {
 266                 if ( (*i)->GetDataSize() > offset )
 267                 {
 268                         unsigned int len = (*i)->GetData(buf + pos, offset, size);
 269                         pos += len;
 270                         size -= len;
 271                         offset = 0;
 272                 }
 273                 else
 274                 {
 275                         offset -= (*i)->GetDataSize();
 276                 }
 277         }
 278         return pos;
 279 }
 280
 281 std::vector < std::string >
 282 RARArchive::GetFolders()
 283 {
 284         std::vector <std::string> retdata;
 285
 286         std::map<std::string, std::vector <FileBlock *> >::iterator iter;
 287
 288         for( iter = folderblocks.begin() ; iter != folderblocks.end() ; iter++)
 289                 retdata.push_back(iter->first);
 290
 291
 292         return retdata;
 293 }
 294
 295 std::vector < std::string >
 296 RARArchive::GetFiles()
 297 {
 298         std::vector <std::string> retdata;
 299         std::map<std::string, std::vector <FileBlock * > >::iterator iter;
 300
 301         for( iter = fileblocks.begin() ; iter != fileblocks.end() ; iter++)
 302         {
 303                 retdata.push_back(iter->first);
 304         }
 305
 306         return retdata;
 307 }
 308
 309 void
 310 RARArchive::PrintFiles()
 311 {
 312
 313
 314         std::map<std::string, std::vector <FileBlock * > >::iterator iter;
 315
 316         for( iter = fileblocks.begin() ; iter != fileblocks.end() ; iter++)
 317         {
 318                 unsigned long long int s = 0;
 319                 std::vector <FileBlock *>::iterator i;
 320                 for(i = iter->second.begin() ; i != iter->second.end() ; i++ )
 321                 {
 322                         s += (*i)->GetDataSize();
 323                 }
 324
 325                 std::cout << iter->first << " blocks: " << iter->second.size() << " size: " << s << std::endl;
 326         }
 327 }
 328
 329 void
 330 RARArchive::GetDate(std::string file, struct timespec* tp)
 331 {
 332         if( fileblocks.find(file) == fileblocks.end() )
 333         {
 334                 tp->tv_sec = default_date;
 335                 tp->tv_nsec = 0;
 336                 return;
 337         }
 338
 339         std::vector <FileBlock *>::iterator i;
 340         i = fileblocks[file].begin();
 341         (*i)->GetFileDate(tp);
 342 }
 343
 344 void
 345 RARArchive::PrintFolders()
 346 {
 347         std::map<std::string, std::vector <FileBlock * > >::iterator iter;
 348
 349         for( iter = folderblocks.begin() ; iter != folderblocks.end() ; iter++)
 350         {
 351                 unsigned long long int s = 0;
 352                 std::vector <FileBlock *>::iterator i;
 353                 for(i = iter->second.begin() ; i != iter->second.end() ; i++ )
 354                         s += (*i)->GetDataSize();
 355
 356                 std::cout << iter->first << " blocks: " << iter->second.size() << " size: " << s << std::endl;
 357         }
 358 }
 359