Home | History | Annotate | Download | only in google 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "third_party/zlib/google/zip_internal.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/files/file_util.h"
     10 #include "base/logging.h"
     11 #include "base/strings/utf_string_conversions.h"
     12 #include "base/time/time.h"
     13 
     14 #if defined(USE_SYSTEM_MINIZIP)
     15 #include <minizip/ioapi.h>
     16 #include <minizip/unzip.h>
     17 #include <minizip/zip.h>
     18 #else
     19 #include "third_party/zlib/contrib/minizip/unzip.h"
     20 #include "third_party/zlib/contrib/minizip/zip.h"
     21 #if defined(OS_WIN)
     22 #include "third_party/zlib/contrib/minizip/iowin32.h"
     23 #elif defined(OS_POSIX)
     24 #include "third_party/zlib/contrib/minizip/ioapi.h"
     25 #endif  // defined(OS_POSIX)
     26 #endif  // defined(USE_SYSTEM_MINIZIP)
     27 
     28 namespace {
     29 
     30 #if defined(OS_WIN)
     31 typedef struct {
     32   HANDLE hf;
     33   int error;
     34 } WIN32FILE_IOWIN;
     35 
     36 // This function is derived from third_party/minizip/iowin32.c.
     37 // Its only difference is that it treats the char* as UTF8 and
     38 // uses the Unicode version of CreateFile.
     39 void* ZipOpenFunc(void *opaque, const char* filename, int mode) {
     40   DWORD desired_access = 0, creation_disposition = 0;
     41   DWORD share_mode = 0, flags_and_attributes = 0;
     42   HANDLE file = 0;
     43   void* ret = NULL;
     44 
     45   if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) {
     46     desired_access = GENERIC_READ;
     47     creation_disposition = OPEN_EXISTING;
     48     share_mode = FILE_SHARE_READ;
     49   } else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) {
     50     desired_access = GENERIC_WRITE | GENERIC_READ;
     51     creation_disposition = OPEN_EXISTING;
     52   } else if (mode & ZLIB_FILEFUNC_MODE_CREATE) {
     53     desired_access = GENERIC_WRITE | GENERIC_READ;
     54     creation_disposition = CREATE_ALWAYS;
     55   }
     56 
     57   base::string16 filename16 = base::UTF8ToUTF16(filename);
     58   if ((filename != NULL) && (desired_access != 0)) {
     59     file = CreateFile(filename16.c_str(), desired_access, share_mode,
     60         NULL, creation_disposition, flags_and_attributes, NULL);
     61   }
     62 
     63   if (file == INVALID_HANDLE_VALUE)
     64     file = NULL;
     65 
     66   if (file != NULL) {
     67     WIN32FILE_IOWIN file_ret;
     68     file_ret.hf = file;
     69     file_ret.error = 0;
     70     ret = malloc(sizeof(WIN32FILE_IOWIN));
     71     if (ret == NULL)
     72       CloseHandle(file);
     73     else
     74       *(static_cast<WIN32FILE_IOWIN*>(ret)) = file_ret;
     75   }
     76   return ret;
     77 }
     78 #endif
     79 
     80 #if defined(OS_POSIX)
     81 // Callback function for zlib that opens a file stream from a file descriptor.
     82 void* FdOpenFileFunc(void* opaque, const char* filename, int mode) {
     83   FILE* file = NULL;
     84   const char* mode_fopen = NULL;
     85 
     86   if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
     87     mode_fopen = "rb";
     88   else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
     89     mode_fopen = "r+b";
     90   else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
     91     mode_fopen = "wb";
     92 
     93   if ((filename != NULL) && (mode_fopen != NULL))
     94     file = fdopen(*static_cast<int*>(opaque), mode_fopen);
     95 
     96   return file;
     97 }
     98 
     99 // We don't actually close the file stream since that would close
    100 // the underlying file descriptor, and we don't own it. However we do need to
    101 // flush buffers and free |opaque| since we malloc'ed it in FillFdOpenFileFunc.
    102 int CloseFileFunc(void* opaque, void* stream) {
    103   fflush(static_cast<FILE*>(stream));
    104   free(opaque);
    105   return 0;
    106 }
    107 
    108 // Fills |pzlib_filecunc_def| appropriately to handle the zip file
    109 // referred to by |fd|.
    110 void FillFdOpenFileFunc(zlib_filefunc_def* pzlib_filefunc_def, int fd) {
    111   fill_fopen_filefunc(pzlib_filefunc_def);
    112   pzlib_filefunc_def->zopen_file = FdOpenFileFunc;
    113   pzlib_filefunc_def->zclose_file = CloseFileFunc;
    114   int* ptr_fd = static_cast<int*>(malloc(sizeof(fd)));
    115   *ptr_fd = fd;
    116   pzlib_filefunc_def->opaque = ptr_fd;
    117 }
    118 #endif  // defined(OS_POSIX)
    119 
    120 #if defined(OS_WIN)
    121 // Callback function for zlib that opens a file stream from a Windows handle.
    122 void* HandleOpenFileFunc(void* opaque, const char* filename, int mode) {
    123   WIN32FILE_IOWIN file_ret;
    124   file_ret.hf = static_cast<HANDLE>(opaque);
    125   file_ret.error = 0;
    126   if (file_ret.hf == INVALID_HANDLE_VALUE)
    127     return NULL;
    128 
    129   void* ret = malloc(sizeof(WIN32FILE_IOWIN));
    130   if (ret != NULL)
    131     *(static_cast<WIN32FILE_IOWIN*>(ret)) = file_ret;
    132   return ret;
    133 }
    134 #endif
    135 
    136 // A struct that contains data required for zlib functions to extract files from
    137 // a zip archive stored in memory directly. The following I/O API functions
    138 // expect their opaque parameters refer to this struct.
    139 struct ZipBuffer {
    140   const char* data;  // weak
    141   size_t length;
    142   size_t offset;
    143 };
    144 
    145 // Opens the specified file. When this function returns a non-NULL pointer, zlib
    146 // uses this pointer as a stream parameter while compressing or uncompressing
    147 // data. (Returning NULL represents an error.) This function initializes the
    148 // given opaque parameter and returns it because this parameter stores all
    149 // information needed for uncompressing data. (This function does not support
    150 // writing compressed data and it returns NULL for this case.)
    151 void* OpenZipBuffer(void* opaque, const char* /*filename*/, int mode) {
    152   if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) != ZLIB_FILEFUNC_MODE_READ) {
    153     NOTREACHED();
    154     return NULL;
    155   }
    156   ZipBuffer* buffer = static_cast<ZipBuffer*>(opaque);
    157   if (!buffer || !buffer->data || !buffer->length)
    158     return NULL;
    159   buffer->offset = 0;
    160   return opaque;
    161 }
    162 
    163 // Reads compressed data from the specified stream. This function copies data
    164 // refered by the opaque parameter and returns the size actually copied.
    165 uLong ReadZipBuffer(void* opaque, void* /*stream*/, void* buf, uLong size) {
    166   ZipBuffer* buffer = static_cast<ZipBuffer*>(opaque);
    167   DCHECK_LE(buffer->offset, buffer->length);
    168   size_t remaining_bytes = buffer->length - buffer->offset;
    169   if (!buffer || !buffer->data || !remaining_bytes)
    170     return 0;
    171   size = std::min(size, static_cast<uLong>(remaining_bytes));
    172   memcpy(buf, &buffer->data[buffer->offset], size);
    173   buffer->offset += size;
    174   return size;
    175 }
    176 
    177 // Writes compressed data to the stream. This function always returns zero
    178 // because this implementation is only for reading compressed data.
    179 uLong WriteZipBuffer(void* /*opaque*/,
    180                      void* /*stream*/,
    181                      const void* /*buf*/,
    182                      uLong /*size*/) {
    183   NOTREACHED();
    184   return 0;
    185 }
    186 
    187 // Returns the offset from the beginning of the data.
    188 long GetOffsetOfZipBuffer(void* opaque, void* /*stream*/) {
    189   ZipBuffer* buffer = static_cast<ZipBuffer*>(opaque);
    190   if (!buffer)
    191     return -1;
    192   return static_cast<long>(buffer->offset);
    193 }
    194 
    195 // Moves the current offset to the specified position.
    196 long SeekZipBuffer(void* opaque, void* /*stream*/, uLong offset, int origin) {
    197   ZipBuffer* buffer = static_cast<ZipBuffer*>(opaque);
    198   if (!buffer)
    199     return -1;
    200   if (origin == ZLIB_FILEFUNC_SEEK_CUR) {
    201     buffer->offset = std::min(buffer->offset + static_cast<size_t>(offset),
    202                               buffer->length);
    203     return 0;
    204   }
    205   if (origin == ZLIB_FILEFUNC_SEEK_END) {
    206     buffer->offset = (buffer->length > offset) ? buffer->length - offset : 0;
    207     return 0;
    208   }
    209   if (origin == ZLIB_FILEFUNC_SEEK_SET) {
    210     buffer->offset = std::min(buffer->length, static_cast<size_t>(offset));
    211     return 0;
    212   }
    213   NOTREACHED();
    214   return -1;
    215 }
    216 
    217 // Closes the input offset and deletes all resources used for compressing or
    218 // uncompressing data. This function deletes the ZipBuffer object referred by
    219 // the opaque parameter since zlib deletes the unzFile object and it does not
    220 // use this object any longer.
    221 int CloseZipBuffer(void* opaque, void* /*stream*/) {
    222   if (opaque)
    223     free(opaque);
    224   return 0;
    225 }
    226 
    227 // Returns the last error happened when reading or writing data. This function
    228 // always returns zero, which means there are not any errors.
    229 int GetErrorOfZipBuffer(void* /*opaque*/, void* /*stream*/) {
    230   return 0;
    231 }
    232 
    233 // Returns a zip_fileinfo struct with the time represented by |file_time|.
    234 zip_fileinfo TimeToZipFileInfo(const base::Time& file_time) {
    235   base::Time::Exploded file_time_parts;
    236   file_time.LocalExplode(&file_time_parts);
    237 
    238   zip_fileinfo zip_info = {};
    239   if (file_time_parts.year >= 1980) {
    240     // This if check works around the handling of the year value in
    241     // contrib/minizip/zip.c in function zip64local_TmzDateToDosDate
    242     // It assumes that dates below 1980 are in the double digit format.
    243     // Hence the fail safe option is to leave the date unset. Some programs
    244     // might show the unset date as 1980-0-0 which is invalid.
    245     zip_info.tmz_date.tm_year = file_time_parts.year;
    246     zip_info.tmz_date.tm_mon = file_time_parts.month - 1;
    247     zip_info.tmz_date.tm_mday = file_time_parts.day_of_month;
    248     zip_info.tmz_date.tm_hour = file_time_parts.hour;
    249     zip_info.tmz_date.tm_min = file_time_parts.minute;
    250     zip_info.tmz_date.tm_sec = file_time_parts.second;
    251   }
    252 
    253   return zip_info;
    254 }
    255 }  // namespace
    256 
    257 namespace zip {
    258 namespace internal {
    259 
    260 unzFile OpenForUnzipping(const std::string& file_name_utf8) {
    261   zlib_filefunc_def* zip_func_ptrs = NULL;
    262 #if defined(OS_WIN)
    263   zlib_filefunc_def zip_funcs;
    264   fill_win32_filefunc(&zip_funcs);
    265   zip_funcs.zopen_file = ZipOpenFunc;
    266   zip_func_ptrs = &zip_funcs;
    267 #endif
    268   return unzOpen2(file_name_utf8.c_str(), zip_func_ptrs);
    269 }
    270 
    271 #if defined(OS_POSIX)
    272 unzFile OpenFdForUnzipping(int zip_fd) {
    273   zlib_filefunc_def zip_funcs;
    274   FillFdOpenFileFunc(&zip_funcs, zip_fd);
    275   // Passing dummy "fd" filename to zlib.
    276   return unzOpen2("fd", &zip_funcs);
    277 }
    278 #endif
    279 
    280 #if defined(OS_WIN)
    281 unzFile OpenHandleForUnzipping(HANDLE zip_handle) {
    282   zlib_filefunc_def zip_funcs;
    283   fill_win32_filefunc(&zip_funcs);
    284   zip_funcs.zopen_file = HandleOpenFileFunc;
    285   zip_funcs.opaque = zip_handle;
    286   return unzOpen2("fd", &zip_funcs);
    287 }
    288 #endif
    289 
    290 // static
    291 unzFile PrepareMemoryForUnzipping(const std::string& data) {
    292   if (data.empty())
    293     return NULL;
    294 
    295   ZipBuffer* buffer = static_cast<ZipBuffer*>(malloc(sizeof(ZipBuffer)));
    296   if (!buffer)
    297     return NULL;
    298   buffer->data = data.data();
    299   buffer->length = data.length();
    300   buffer->offset = 0;
    301 
    302   zlib_filefunc_def zip_functions;
    303   zip_functions.zopen_file = OpenZipBuffer;
    304   zip_functions.zread_file = ReadZipBuffer;
    305   zip_functions.zwrite_file = WriteZipBuffer;
    306   zip_functions.ztell_file = GetOffsetOfZipBuffer;
    307   zip_functions.zseek_file = SeekZipBuffer;
    308   zip_functions.zclose_file = CloseZipBuffer;
    309   zip_functions.zerror_file = GetErrorOfZipBuffer;
    310   zip_functions.opaque = static_cast<void*>(buffer);
    311   return unzOpen2(NULL, &zip_functions);
    312 }
    313 
    314 zipFile OpenForZipping(const std::string& file_name_utf8, int append_flag) {
    315   zlib_filefunc_def* zip_func_ptrs = NULL;
    316 #if defined(OS_WIN)
    317   zlib_filefunc_def zip_funcs;
    318   fill_win32_filefunc(&zip_funcs);
    319   zip_funcs.zopen_file = ZipOpenFunc;
    320   zip_func_ptrs = &zip_funcs;
    321 #endif
    322   return zipOpen2(file_name_utf8.c_str(),
    323                   append_flag,
    324                   NULL,  // global comment
    325                   zip_func_ptrs);
    326 }
    327 
    328 #if defined(OS_POSIX)
    329 zipFile OpenFdForZipping(int zip_fd, int append_flag) {
    330   zlib_filefunc_def zip_funcs;
    331   FillFdOpenFileFunc(&zip_funcs, zip_fd);
    332   // Passing dummy "fd" filename to zlib.
    333   return zipOpen2("fd", append_flag, NULL, &zip_funcs);
    334 }
    335 #endif
    336 
    337 zip_fileinfo GetFileInfoForZipping(const base::FilePath& path) {
    338   base::Time file_time;
    339   base::File::Info file_info;
    340   if (base::GetFileInfo(path, &file_info))
    341     file_time = file_info.last_modified;
    342   return TimeToZipFileInfo(file_time);
    343 }
    344 
    345 bool ZipOpenNewFileInZip(zipFile zip_file,
    346                          const std::string& str_path,
    347                          const zip_fileinfo* file_info) {
    348   // Section 4.4.4 http://www.pkware.com/documents/casestudies/APPNOTE.TXT
    349   // Setting the Language encoding flag so the file is told to be in utf-8.
    350   const uLong LANGUAGE_ENCODING_FLAG = 0x1 << 11;
    351 
    352   if (ZIP_OK != zipOpenNewFileInZip4(
    353                     zip_file,  // file
    354                     str_path.c_str(),  // filename
    355                     file_info,  // zipfi
    356                     NULL,  // extrafield_local,
    357                     0u,  // size_extrafield_local
    358                     NULL,  // extrafield_global
    359                     0u,  // size_extrafield_global
    360                     NULL,  // comment
    361                     Z_DEFLATED,  // method
    362                     Z_DEFAULT_COMPRESSION,  // level
    363                     0,  // raw
    364                     -MAX_WBITS,  // windowBits
    365                     DEF_MEM_LEVEL,  // memLevel
    366                     Z_DEFAULT_STRATEGY,  // strategy
    367                     NULL,  // password
    368                     0,  // crcForCrypting
    369                     0,  // versionMadeBy
    370                     LANGUAGE_ENCODING_FLAG)) {  // flagBase
    371     DLOG(ERROR) << "Could not open zip file entry " << str_path;
    372     return false;
    373   }
    374   return true;
    375 }
    376 
    377 }  // namespace internal
    378 }  // namespace zip
    379