src/libs/common/FileFunctions.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26
  27 #include <wx/dir.h>             // Needed for wxDir
  28 #include <wx/fs_zip.h>          // Needed for wxZipFSHandler
  29 #include <wx/wfstream.h>        // wxFileInputStream
  30 #include <wx/zipstrm.h>         // Needed for wxZipInputStream
  31 #include <wx/zstream.h>         // Needed for wxZlibInputStream
  32 #include <wx/log.h>             // Needed for wxSysErrorMsg
  33
  34 #ifdef __WXMAC__
  35 #include <zlib.h> // Do_not_auto_remove
  36 #endif
  37 #include <algorithm>            // Needed for std::min
  38
  39 #include "FileFunctions.h"
  40 #include "StringFunctions.h"
  41 #include "SmartPtr.h"           // Needed for CSmartPtr
  42
  43 //
  44 // This class assumes that the following line has been executed:
  45 //
  46 //      wxConvFileName = &aMuleConvBrokenFileNames;
  47 //
  48 // This line is necessary so that wxWidgets handles unix file names correctly.
  49 //
  50 CDirIterator::CDirIterator(const CPath& dir)
  51         : wxDir(dir.GetRaw())
  52 {
  53 }
  54
  55
  56 CDirIterator::~CDirIterator()
  57 {
  58 }
  59
  60
  61 CPath CDirIterator::GetFirstFile(FileType type, const wxString& mask)
  62 {
  63         if (!IsOpened()) {
  64                 return CPath();
  65         }
  66
  67         wxString fileName;
  68         if (!GetFirst(&fileName, mask, type)) {
  69                 return CPath();
  70         }
  71
  72         return CPath(fileName);
  73 }
  74
  75
  76 CPath CDirIterator::GetNextFile()
  77 {
  78         wxString fileName;
  79         if (!GetNext(&fileName)) {
  80                 return CPath();
  81         }
  82
  83         return CPath(fileName);
  84 }
  85
  86
  87 bool CDirIterator::HasSubDirs(const wxString& spec)
  88 {
  89         // Checking IsOpened() in case we don't have permissions to read that dir.
  90         return IsOpened() && wxDir::HasSubDirs(spec);
  91 }
  92
  93
  94 static EFileType GuessFiletype(const wxString& file)
  95 {
  96         wxFile archive(file, wxFile::read);
  97         if (!archive.IsOpened()) {
  98                 return EFT_Error;
  99         }
 100         static const uint8 UTF8bom[3] = {0xEF, 0xBB, 0xBF};
 101         uint8 head[10] = {0, 0};
 102         int read = archive.Read(head, std::min<off_t>(10, archive.Length()));
 103
 104         if (read == wxInvalidOffset || read == 0) {
 105                 return EFT_Unknown;
 106         } else if ((head[0] == 'P') && (head[1] == 'K')) {
 107                 // Zip-archives have a header of "PK".
 108                 return EFT_Zip;
 109         } else if (head[0] == 0x1F && head[1] == 0x8B) {
 110                 // Gzip-archives have a header of 0x1F8B
 111                 return EFT_GZip;
 112         } else if (head[0] == 0xE0 || head[0] == 0x0E) {
 113                 // MET files have either of these headers
 114                 return EFT_Met;
 115         }
 116
 117         // Check at most the first ten chars, if all are printable,
 118         // then we can probably assume it is ascii text-file.
 119         for (int i = 0; i < read; ++i) {
 120                 if (!(          isprint(head[i])
 121                                 ||      isspace(head[i])
 122                                 ||      (i < 3 && head[i] == UTF8bom[i]))) {
 123                         return EFT_Unknown;
 124                 }
 125         }
 126
 127         return EFT_Text;
 128 }
 129
 130
 131 /**
 132  * Replaces the zip-archive with "guarding.p2p" or "ipfilter.dat",
 133  * if either of those files are found in the archive.
 134  */
 135 static bool UnpackZipFile(const wxString& file, const wxChar* files[])
 136 {
 137         wxTempFile target(file);
 138         CSmartPtr<wxZipEntry> entry;
 139         wxFFileInputStream fileInputStream(file);
 140         wxZipInputStream zip(fileInputStream);
 141         bool run = true;
 142         while (run) {
 143                 entry.reset(zip.GetNextEntry());
 144                 if (entry.get() == NULL) {
 145                         break;
 146                 }
 147                 // access meta-data
 148                 wxString name = entry->GetName();
 149                 // We only care about the files specified in the array
 150                 // probably needed to weed out included nfos
 151                 for (int i = 0; run && files[i]; i++) {
 152                         if (name.CmpNoCase(files[i]) == 0) {
 153                                 // we found the entry we want
 154                                 // read 'zip' to access the entry's data
 155                                 char buffer[10240];
 156                                 while (!zip.Eof()) {
 157                                         zip.Read(buffer, sizeof(buffer));
 158                                         target.Write(buffer, zip.LastRead());
 159                                 }
 160                                 run = false;
 161                         }
 162                 }
 163         }
 164
 165         if (target.Length()) {
 166                 target.Commit();
 167                 return true;
 168         }
 169
 170         return false;
 171 }
 172
 173
 174 /**
 175  * Unpacks a GZip file and replaces the archive.
 176  */
 177 static bool UnpackGZipFile(const wxString& file)
 178 {
 179         wxTempFile target(file);
 180
 181         bool write = false;
 182
 183 #ifdef __WXMAC__
 184         // AddDebugLogLineN( logFileIO, wxT("Reading gzip stream") );
 185
 186         gzFile inputFile = gzopen(filename2char(file), "rb");
 187         if (inputFile != NULL) {
 188                 char buffer[10240];
 189                 write = true;
 190
 191                 while (int bytesRead = gzread(inputFile, buffer, sizeof(buffer))) {
 192                         if (bytesRead > 0) {
 193                                 // AddDebugLogLineN(logFileIO, CFormat(wxT("Read %u bytes")) % bytesRead);
 194                                 target.Write(buffer, bytesRead);
 195                         } else if (bytesRead < 0) {
 196                                 wxString errString;
 197                                 int gzerrnum;
 198                                 const char* gzerrstr = gzerror(inputFile, &gzerrnum);
 199                                 if (gzerrnum == Z_ERRNO) {
 200                                         errString = wxSysErrorMsg();
 201                                 } else {
 202                                         errString = wxString::FromAscii(gzerrstr);
 203                                 }
 204
 205                                 // AddDebugLogLineN( logFileIO, wxT("Error reading gzip stream (") + errString + wxT(")") );
 206                                 write = false;
 207                                 break;
 208                         }
 209                 }
 210
 211                 // AddDebugLogLineN( logFileIO, wxT("End reading gzip stream") );
 212                 gzclose(inputFile);
 213         } else {
 214                 // AddDebugLogLineN( logFileIO, wxT("Error opening gzip file (") + wxString(wxSysErrorMsg()) + wxT(")") );
 215         }
 216 #else
 217         {
 218                 // AddDebugLogLineN( logFileIO, wxT("Reading gzip stream") );
 219
 220                 wxFileInputStream source(file);
 221                 wxZlibInputStream inputStream(source);
 222
 223                 while (!inputStream.Eof()) {
 224                         char buffer[10240];
 225                         inputStream.Read(buffer, sizeof(buffer));
 226
 227                         // AddDebugLogLineN(logFileIO, CFormat(wxT("Read %u bytes")) % inputStream.LastRead());
 228                         if (inputStream.LastRead()) {
 229                                 target.Write(buffer, inputStream.LastRead());
 230                         } else {
 231                                 break;
 232                         }
 233                 };
 234
 235                 // AddDebugLogLineN( logFileIO, wxT("End reading gzip stream") );
 236
 237                 write = inputStream.IsOk() || inputStream.Eof();
 238         }
 239 #endif
 240
 241         if (write) {
 242                 target.Commit();
 243                 // AddDebugLogLineN( logFileIO, wxT("Commited gzip stream") );
 244         }
 245
 246         return write;
 247 }
 248
 249
 250 UnpackResult UnpackArchive(const CPath& path, const wxChar* files[])
 251 {
 252         const wxString file = path.GetRaw();
 253
 254         // Attempt to discover the filetype and uncompress
 255         EFileType type = GuessFiletype(file);
 256         switch (type) {
 257                 case EFT_Zip:
 258                         if (UnpackZipFile(file, files)) {
 259                                 // Unpack nested archives if needed.
 260                                 return UnpackResult(true, UnpackArchive(path, files).second);
 261                         } else {
 262                                 return UnpackResult(false, EFT_Error);
 263                         }
 264
 265                 case EFT_GZip:
 266                         if (UnpackGZipFile(file)) {
 267                                 // Unpack nested archives if needed.
 268                                 return UnpackResult(true, UnpackArchive(path, files).second);
 269                         } else {
 270                                 return UnpackResult(false, EFT_Error);
 271                         }
 272
 273                 default:
 274                         return UnpackResult(false, type);
 275         }
 276 }
 277 // File_checked_for_headers