src/libs/common/FileFunctions.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002-2008 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 <memory>               // Needed for std::auto_ptr
  38
  39 #include "FileFunctions.h"
  40 #include "StringFunctions.h"
  41
  42 //
  43 // This class assumes that the following line has been executed:
  44 //
  45 //      wxConvFileName = &aMuleConvBrokenFileNames;
  46 //
  47 // This line is necessary so that wxWidgets handles unix file names correctly.
  48 //
  49 CDirIterator::CDirIterator(const CPath& dir)
  50         : wxDir(dir.GetRaw())
  51 {
  52 }
  53
  54
  55 CDirIterator::~CDirIterator()
  56 {
  57 }
  58
  59
  60 CPath CDirIterator::GetFirstFile(FileType type, const wxString& mask)
  61 {
  62         if (!IsOpened()) {
  63                 return CPath();
  64         }
  65
  66         wxString fileName;
  67         if (!GetFirst(&fileName, mask, type)) {
  68                 return CPath();
  69         }
  70
  71         return CPath(fileName);
  72 }
  73
  74
  75 CPath CDirIterator::GetNextFile()
  76 {
  77         wxString fileName;
  78         if (!GetNext(&fileName)) {
  79                 return CPath();
  80         }
  81
  82         return CPath(fileName);
  83 }
  84
  85
  86 bool CDirIterator::HasSubDirs(const wxString& spec)
  87 {
  88         // Checking IsOpened() in case we don't have permissions to read that dir.
  89         return IsOpened() && wxDir::HasSubDirs(spec);
  90 }
  91
  92
  93 EFileType GuessFiletype(const wxString& file)
  94 {
  95         wxFile archive(file, wxFile::read);
  96         if (!archive.IsOpened()) {
  97                 return EFT_Error;
  98         }
  99         static const uint8 UTF8bom[3] = {0xEF, 0xBB, 0xBF};
 100         uint8 head[10] = {0, 0};
 101         int read = archive.Read(head, std::min<off_t>(10, archive.Length()));
 102
 103         if (read == wxInvalidOffset || read == 0) {
 104                 return EFT_Unknown;
 105         } else if ((head[0] == 'P') && (head[1] == 'K')) {
 106                 // Zip-archives have a header of "PK".
 107                 return EFT_Zip;
 108         } else if (head[0] == 0x1F && head[1] == 0x8B) {
 109                 // Gzip-archives have a header of 0x1F8B
 110                 return EFT_GZip;
 111         } else if (head[0] == 0xE0 || head[0] == 0x0E) {
 112                 // MET files have either of these headers
 113                 return EFT_Met;
 114         }
 115
 116         // Check at most the first ten chars, if all are printable,
 117         // then we can probably assume it is ascii text-file.
 118         for (int i = 0; i < read; ++i) {
 119                 if (!(          isprint(head[i])
 120                                 ||      isspace(head[i])
 121                                 ||      (i < 3 && head[i] == UTF8bom[i]))) {
 122                         return EFT_Unknown;
 123                 }
 124         }
 125
 126         return EFT_Text;
 127 }
 128
 129
 130 /**
 131  * Replaces the zip-archive with "guarding.p2p" or "ipfilter.dat",
 132  * if either of those files are found in the archive.
 133  */
 134 bool UnpackZipFile(const wxString& file, const wxChar* files[])
 135 {
 136         wxZipFSHandler archive;
 137         wxString filename = archive.FindFirst(
 138                 wxT("file:") + file + wxT("#zip:/*"), wxFILE);
 139
 140         wxTempFile target(file);
 141
 142         while (!filename.IsEmpty() && !target.Length()) {
 143                 // Extract the filename part of the URI
 144                 filename = filename.AfterLast(wxT(':')).Lower();
 145
 146                 // We only care about the files specified in the array
 147                 for (size_t i = 0; files[i] && !target.Length(); ++i) {
 148                         if (files[i] == filename) {
 149                                 std::auto_ptr<wxZipEntry> entry;
 150                                 wxFFileInputStream fileInputStream(file);
 151                                 wxZipInputStream zip(fileInputStream);
 152                                 while (entry.reset(zip.GetNextEntry()), entry.get() != NULL) {
 153                                         // access meta-data
 154                                         wxString name = entry->GetName();
 155                                         // read 'zip' to access the entry's data
 156                                         if (name == filename) {
 157                                                 char buffer[10240];
 158                                                 while (!zip.Eof()) {
 159                                                         zip.Read(buffer, sizeof(buffer));
 160                                                         target.Write(buffer, zip.LastRead());
 161                                                 }
 162                                                 break;
 163                                         }
 164                                 }
 165                         }
 166                 }
 167
 168                 filename = archive.FindNext();
 169         }
 170
 171         if (target.Length()) {
 172                 target.Commit();
 173                 return true;
 174         }
 175
 176         return false;
 177 }
 178
 179
 180 /**
 181  * Unpacks a GZip file and replaces the archive.
 182  */
 183 bool UnpackGZipFile(const wxString& file)
 184 {
 185         char buffer[10240];
 186         wxTempFile target(file);
 187
 188         bool write = false;
 189
 190 #ifdef __WXMAC__
 191         // AddDebugLogLineM( false, logFileIO, wxT("Reading gzip stream") );
 192
 193         gzFile inputFile = gzopen(filename2char(file), "rb");
 194         if (inputFile != NULL) {
 195                 write = true;
 196
 197                 while (int bytesRead = gzread(inputFile, buffer, sizeof(buffer))) {
 198                         if (bytesRead > 0) {
 199                                 // AddDebugLogLineM( false, logFileIO, wxString::Format(wxT("Read %u bytes"), bytesRead) );
 200                                 target.Write(buffer, bytesRead);
 201                         } else if (bytesRead < 0) {
 202                                 wxString errString;
 203                                 int gzerrnum;
 204                                 const char* gzerrstr = gzerror(inputFile, &gzerrnum);
 205                                 if (gzerrnum == Z_ERRNO) {
 206                                         errString = wxSysErrorMsg();
 207                                 } else {
 208                                         errString = wxString::FromAscii(gzerrstr);
 209                                 }
 210
 211                                 // AddDebugLogLineM( false, logFileIO, wxT("Error reading gzip stream (") + errString + wxT(")") );
 212                                 write = false;
 213                                 break;
 214                         }
 215                 }
 216
 217                 // AddDebugLogLineM( false, logFileIO, wxT("End reading gzip stream") );
 218                 gzclose(inputFile);
 219         } else {
 220                 // AddDebugLogLineM( false, logFileIO, wxT("Error opening gzip file (") + wxString(wxSysErrorMsg()) + wxT(")") );
 221         }
 222 #else
 223         {
 224                 // AddDebugLogLineM( false, logFileIO, wxT("Reading gzip stream") );
 225
 226                 wxFileInputStream source(file);
 227                 wxZlibInputStream inputStream(source);
 228
 229                 while (!inputStream.Eof()) {
 230                         inputStream.Read(buffer, sizeof(buffer));
 231
 232                         // AddDebugLogLineM( false, logFileIO, wxString::Format(wxT("Read %u bytes"),inputStream.LastRead()) );
 233                         if (inputStream.LastRead()) {
 234                                 target.Write(buffer, inputStream.LastRead());
 235                         } else {
 236                                 break;
 237                         }
 238                 };
 239
 240                 // AddDebugLogLineM( false, logFileIO, wxT("End reading gzip stream") );
 241
 242                 write = inputStream.IsOk() || inputStream.Eof();
 243         }
 244 #endif
 245
 246         if (write) {
 247                 target.Commit();
 248                 // AddDebugLogLineM( false, logFileIO, wxT("Commited gzip stream") );
 249         }
 250
 251         return write;
 252 }
 253
 254
 255 UnpackResult UnpackArchive(const CPath& path, const wxChar* files[])
 256 {
 257         const wxString file = path.GetRaw();
 258
 259         // Attempt to discover the filetype and uncompress
 260         EFileType type = GuessFiletype(file);
 261         switch (type) {
 262                 case EFT_Zip:
 263                         if (UnpackZipFile(file, files)) {
 264                                 // Unpack nested archives if needed.
 265                                 return UnpackResult(true, UnpackArchive(path, files).second);
 266                         } else {
 267                                 return UnpackResult(false, EFT_Error);
 268                         }
 269
 270                 case EFT_GZip:
 271                         if (UnpackGZipFile(file)) {
 272                                 // Unpack nested archives if needed.
 273                                 return UnpackResult(true, UnpackArchive(path, files).second);
 274                         } else {
 275                                 return UnpackResult(false, EFT_Error);
 276                         }
 277
 278                 default:
 279                         return UnpackResult(false, type);
 280         }
 281 }
 282 // File_checked_for_headers