source/mupen64launcher/src/czip.cpp

   1 /**
   2  *  @section LICENSE
   3  *
   4  *  PickleLauncher
   5  *  Copyright (C) 2010-2011 Scott Smith
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  *
  20  *  @section LOCATION
  21  */
  22
  23  /*
  24    czip.cpp is based on miniunz.c
  25
  26    miniunz.c
  27    Version 1.1, February 14h, 2010
  28    sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
  29
  30          Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
  31
  32          Modifications of Unzip for Zip64
  33          Copyright (C) 2007-2008 Even Rouault
  34
  35          Modifications for Zip64 support on both zip and unzip
  36          Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
  37 */
  38
  39 #include "czip.h"
  40
  41 CZip::CZip() : CBase(),
  42     UnzipFiles          ()
  43 {
  44 }
  45
  46 CZip::~CZip()
  47 {
  48 }
  49
  50 void CZip::ListFiles( const string& zipfile, vector<string>& list )
  51 {
  52     uint32_t i;
  53     int32_t err;
  54     unzFile uf=NULL;
  55     unz_global_info64 gi;
  56
  57     // Open the zip file
  58     uf = unzOpen64( zipfile.c_str() );
  59
  60     if (uf != NULL)
  61     {
  62         // Get file info for the zip file
  63         err = unzGetGlobalInfo64( uf,&gi );
  64         if (err != UNZ_OK)
  65         {
  66             Log( "error %d with zipfile in unzGetGlobalInfo\n",err);
  67             return;
  68         }
  69     }
  70     else
  71     {
  72         Log( "error with zipfile %s in unzOpen64\n", zipfile.c_str() );
  73         return;
  74     }
  75     Log( "Reading zip file %s\n", zipfile.c_str() );
  76
  77     // Spit out some information about the files in the zip for debug
  78     Log( "  Length  Method     Size Ratio   Date    Time   CRC-32     Name\n" );
  79     Log( "  ------  ------     ---- -----   ----    ----   ------     ----\n" );
  80     for (i=0; i<gi.number_entry; i++)
  81     {
  82         char filename_inzip[256];
  83         unz_file_info64 file_info;
  84         uLong ratio=0;
  85         const char *string_method = NULL;
  86         char charCrypt=' ';
  87         err = unzGetCurrentFileInfo64( uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0 );
  88         if (err != UNZ_OK)
  89         {
  90             Log( "error %d with zipfile in unzGetCurrentFileInfo\n",err);
  91             break;
  92         }
  93         if (file_info.uncompressed_size > 0)
  94             ratio = (uLong)((file_info.compressed_size*100)/file_info.uncompressed_size);
  95
  96         /* display a '*' if the file is crypted */
  97         if ((file_info.flag & 1) != 0)
  98             charCrypt='*';
  99
 100         if (file_info.compression_method == 0)
 101             string_method="Stored";
 102         else
 103         if (file_info.compression_method == Z_DEFLATED)
 104         {
 105             uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
 106             if (iLevel==0)
 107               string_method="Defl:N";
 108             else if (iLevel==1)
 109               string_method="Defl:X";
 110             else if ((iLevel==2) || (iLevel==3))
 111               string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
 112         }
 113         else
 114         if (file_info.compression_method == Z_BZIP2ED)
 115         {
 116               string_method="BZip2 ";
 117         }
 118         else
 119             string_method="Unkn. ";
 120
 121         Display64BitsSize( file_info.uncompressed_size,7 );
 122         Log( "  %6s%c",string_method,charCrypt);
 123         Display64BitsSize( file_info.compressed_size,7 );
 124         Log( " %3lu%%  %2.2lu-%2.2lu-%2.2lu  %2.2lu:%2.2lu  %8.8lx   %s\n",
 125                 ratio,
 126                 (uLong)file_info.tmu_date.tm_mon + 1,
 127                 (uLong)file_info.tmu_date.tm_mday,
 128                 (uLong)file_info.tmu_date.tm_year % 100,
 129                 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
 130                 (uLong)file_info.crc,filename_inzip);
 131         if ((i+1) < gi.number_entry)
 132         {
 133             err = unzGoToNextFile( uf );
 134             if (err != UNZ_OK)
 135             {
 136                 Log( "error %d with zipfile in unzGoToNextFile\n",err);
 137                 break;
 138             }
 139         }
 140
 141         // Save the names of the files in the zip
 142         list.push_back( filename_inzip );
 143     }
 144
 145     // Close the zip file
 146     unzClose( uf );
 147 }
 148
 149 void CZip::ExtractFile( const string& zipfile, const string& location, const string& filename )
 150 {
 151     uint32_t i;
 152     int32_t err;
 153     unzFile uf = NULL;
 154     unz_global_info64 gi;
 155
 156     // Open the zip file
 157     uf = unzOpen64( zipfile.c_str() );
 158
 159     if (uf != NULL)
 160     {
 161         // Get file info for the zip file
 162         err = unzGetGlobalInfo64( uf,&gi );
 163         if (err != UNZ_OK)
 164         {
 165             Log( "error %d with zipfile in unzGetGlobalInfo\n",err);
 166             return;
 167         }
 168     }
 169     else
 170     {
 171         Log( "error with zipfile %s in unzOpen64\n", zipfile.c_str() );
 172         return;
 173     }
 174
 175     for (i=0; i<gi.number_entry; i++)
 176     {
 177         char filename_inzip[256];
 178         unz_file_info64 file_info;
 179
 180         err = unzGetCurrentFileInfo64( uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0 );
 181         if (err != UNZ_OK)
 182         {
 183             Log( "error %d with zipfile in unzGetCurrentFileInfo\n",err);
 184             break;
 185         }
 186
 187         if (filename.compare(filename_inzip) == 0)
 188         {
 189             Extract( uf, location );
 190             break;
 191         }
 192
 193         if ((i+1) < gi.number_entry)
 194         {
 195             err = unzGoToNextFile( uf );
 196             if (err != UNZ_OK)
 197             {
 198                 Log( "error %d with zipfile in unzGoToNextFile\n",err);
 199                 break;
 200             }
 201         }
 202     }
 203
 204     // Close the zip file
 205     unzClose( uf );
 206 }
 207
 208 void CZip::ExtractFiles( const string& zipfile, const string& location )
 209 {
 210     uint16_t i;
 211     int32_t err;
 212     unzFile uf=NULL;
 213     unz_global_info64 gi;
 214
 215     uf = unzOpen64( zipfile.c_str() );
 216
 217     if (uf != NULL)
 218     {
 219         err = unzGetGlobalInfo64( uf, &gi );
 220         if (err != UNZ_OK)
 221         {
 222             Log( "error %d with zipfile in unzGetGlobalInfo \n", err );
 223             return;
 224         }
 225     }
 226     else
 227     {
 228         Log( "error with zipfile in unzOpen64 \n" );
 229         return;
 230     }
 231
 232     for (i=0;i<gi.number_entry;i++)
 233     {
 234         if (Extract( uf, location ) != UNZ_OK)
 235         {
 236             break;
 237         }
 238
 239         if ((uint16_t)(i+1) < gi.number_entry)
 240         {
 241             // Go the next file
 242             err = unzGoToNextFile( uf );
 243             if (err != UNZ_OK)
 244             {
 245                 Log( "error %d with zipfile in unzGoToNextFile\n", err );
 246                 break;
 247             }
 248         }
 249     }
 250
 251     // Close the zip file
 252     unzClose( uf );
 253 }
 254
 255 #define WRITEBUFFERSIZE (8192)
 256 int32_t CZip::Extract( unzFile uf, const string& location )
 257 {
 258     string write_filename;
 259     void*   buf;
 260     char    filename_inzip[256];
 261     int32_t err=UNZ_OK;
 262     FILE*   fout=NULL;
 263     unz_file_info64 file_info;
 264
 265     err = unzGetCurrentFileInfo64( uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0 );
 266     if (err != UNZ_OK)
 267     {
 268         Log( "error %d with zipfile in unzGetCurrentFileInfo\n", err );
 269         return err;
 270     }
 271
 272     buf = (void*)malloc(WRITEBUFFERSIZE);
 273     if (buf == NULL)
 274     {
 275         Log( "Error allocating memory\n" );
 276         free(buf);
 277         return UNZ_INTERNALERROR;
 278     }
 279
 280     err = unzOpenCurrentFile( uf );
 281     if (err != UNZ_OK)
 282     {
 283         Log( "error %d with zipfile in unzOpenCurrentFile\n", err );
 284         free(buf);
 285         return err;
 286     }
 287
 288     write_filename = location + '/' + string(filename_inzip);
 289
 290     fout = fopen64( write_filename.c_str(), "wb" );
 291
 292     if (fout != NULL)
 293     {
 294         Log( " extracting: %s\n", write_filename.c_str() );
 295
 296         do {
 297             err = unzReadCurrentFile( uf, buf, WRITEBUFFERSIZE );
 298             if (err < 0)
 299             {
 300                 Log( "error %d with zipfile in unzReadCurrentFile\n",err);
 301                 break;
 302             }
 303             if (err > 0)
 304             {
 305                 if (fwrite( buf, err, 1, fout ) != 1)
 306                 {
 307                     Log( "error in writing extracted file\n" );
 308                     err = UNZ_ERRNO;
 309                     break;
 310                 }
 311             }
 312         }
 313         while (err > 0);
 314
 315         if (fout)
 316         {
 317             fclose( fout );
 318         }
 319     }
 320
 321     if (err==UNZ_OK)
 322     {
 323         err = unzCloseCurrentFile( uf );
 324         if (err != UNZ_OK)
 325         {
 326             Log( "error %d with zipfile in unzCloseCurrentFile\n",err);
 327         }
 328
 329         AddUnzipFile( write_filename );
 330     }
 331     else
 332     {
 333         unzCloseCurrentFile( uf ); /* don't lose the error */
 334     }
 335
 336     free(buf);
 337     return err;
 338 }
 339
 340 void CZip::Display64BitsSize(ZPOS64_T n, int size_char)
 341 {
 342   /* to avoid compatibility problem , we do here the conversion */
 343   char number[21];
 344   int offset=19;
 345   int pos_string = 19;
 346   number[20]=0;
 347   for (;;) {
 348       number[offset]=(char)((n%10)+'0');
 349       if (number[offset] != '0')
 350           pos_string=offset;
 351       n/=10;
 352       if (offset==0)
 353           break;
 354       offset--;
 355   }
 356   {
 357       int size_display_string = 19-pos_string;
 358       while (size_char > size_display_string)
 359       {
 360           size_char--;
 361           Log( " " );
 362       }
 363   }
 364
 365   Log( "%s",&number[pos_string]);
 366 }
 367
 368 void CZip::AddUnzipFile( const string& filename )
 369 {
 370     uint16_t i;
 371
 372     for (i=0; i<UnzipFiles.size(); i++)
 373     {
 374         if (UnzipFiles.at(i) == filename)
 375             return;
 376     }
 377     UnzipFiles.push_back( filename );
 378 }
 379
 380 void CZip::DelUnzipFiles( void )
 381 {
 382     uint16_t i;
 383
 384     for (i=0; i<UnzipFiles.size(); i++)
 385     {
 386 #if defined(DEBUG)
 387         Log( "Removing file %s\n", UnzipFiles.at(i).c_str() );
 388 #endif
 389         remove( UnzipFiles.at(i).c_str() );
 390     }
 391     UnzipFiles.clear();
 392 }
 393
 394 int8_t CZip::SaveUnzipList( const string& location )
 395 {
 396     uint8_t i;
 397     ofstream   fout;
 398
 399     fout.open(location.c_str(), ios_base::trunc);
 400
 401     if (!fout)
 402     {
 403         Log( "Failed to open ziplist at %s\n", location.c_str() );
 404         return 1;
 405     }
 406
 407     // Write out the profile
 408     if (fout.is_open())
 409     {
 410         for (i=0; i<UnzipFiles.size(); i++)
 411         {
 412             if (UnzipFiles.at(i).length()>0)
 413             {
 414 #if defined(DEBUG)
 415                 Log( "Saving file %s to ziplist\n", UnzipFiles.at(i).c_str());
 416 #endif
 417                 fout << UnzipFiles.at(i) << endl;
 418             }
 419         }
 420     }
 421
 422     return 0;
 423 }
 424
 425 int8_t CZip::LoadUnzipList( const string& location )
 426 {
 427     string          line;
 428     ifstream        fin;
 429
 430     fin.open(location.c_str(), ios_base::in);
 431
 432     if (!fin)
 433     {
 434         Log( "Failed to open unziplist at %s\n", location.c_str() );
 435         return 0;   // Dont stop the app if it cant be opened, default values will be used and then save to file.
 436     }
 437
 438     UnzipFiles.clear();
 439
 440     // Read in the profile
 441     if (fin.is_open())
 442     {
 443         while (!fin.eof())
 444         {
 445             getline(fin,line);
 446
 447             if (line.length() > 0)
 448             {
 449                 UnzipFiles.push_back(line);
 450             }
 451         }
 452     }
 453
 454     return 0;
 455 }
 456