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
