Eliminate resource leaks from zip::ZipFiles and

third_party/zlib/google/zip_internal.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "third_party/zlib/google/zip_internal.h"
 
 #include <algorithm>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ skipping 61 matching lines @@
       CloseHandle(file);
     else
       *(static_cast<WIN32FILE_IOWIN*>(ret)) = file_ret;
   }
   return ret;
 }
 #endif
 
 #if defined(OS_POSIX)
 // Callback function for zlib that opens a file stream from a file descriptor.
+// Since we do not own the file descriptor, dup it so that we can fdopen/fclose
+// a file stream.
 void* FdOpenFileFunc(void* opaque, const char* filename, int mode) {
   FILE* file = NULL;
   const char* mode_fopen = NULL;
 
   if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
     mode_fopen = "rb";
   else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
     mode_fopen = "r+b";
   else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
     mode_fopen = "wb";
 
-  if ((filename != NULL) && (mode_fopen != NULL))
-    file = fdopen(*static_cast<int*>(opaque), mode_fopen);
+  if ((filename != NULL) && (mode_fopen != NULL)) {
+    int fd = dup(*static_cast<int*>(opaque));
+    if (fd != -1)
+      file = fdopen(fd, mode_fopen);
+  }
 
   return file;
 }
 
-// We don't actually close the file stream since that would close
-// the underlying file descriptor, and we don't own it. However we do need to
-// flush buffers and free |opaque| since we malloc'ed it in FillFdOpenFileFunc.
-int CloseFileFunc(void* opaque, void* stream) {
-  fflush(static_cast<FILE*>(stream));
-  free(opaque);
+int FdCloseFileFunc(void* opaque, void* stream) {
+  fclose(static_cast<FILE*>(stream));
+  free(opaque); // malloc'ed in FillFdOpenFileFunc()
   return 0;
 }
 
 // Fills |pzlib_filecunc_def| appropriately to handle the zip file
 // referred to by |fd|.
 void FillFdOpenFileFunc(zlib_filefunc_def* pzlib_filefunc_def, int fd) {
   fill_fopen_filefunc(pzlib_filefunc_def);
   pzlib_filefunc_def->zopen_file = FdOpenFileFunc;
-  pzlib_filefunc_def->zclose_file = CloseFileFunc;
+  pzlib_filefunc_def->zclose_file = FdCloseFileFunc;
   int* ptr_fd = static_cast<int*>(malloc(sizeof(fd)));
   *ptr_fd = fd;
   pzlib_filefunc_def->opaque = ptr_fd;
 }
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_WIN)
 // Callback function for zlib that opens a file stream from a Windows handle.
+// Does not take ownership of the handle.
 void* HandleOpenFileFunc(void* opaque, const char* filename, int mode) {
   WIN32FILE_IOWIN file_ret;
   file_ret.hf = static_cast<HANDLE>(opaque);
   file_ret.error = 0;
   if (file_ret.hf == INVALID_HANDLE_VALUE)
     return NULL;
 
   void* ret = malloc(sizeof(WIN32FILE_IOWIN));
   if (ret != NULL)
     *(static_cast<WIN32FILE_IOWIN*>(ret)) = file_ret;
   return ret;
 }
+
+int HandleCloseFileFunc(void* opaque, void* stream) {
+  free(stream); // malloc'ed in HandleOpenFileFunc()
+  return 0;
+}
 #endif
 
 // A struct that contains data required for zlib functions to extract files from
 // a zip archive stored in memory directly. The following I/O API functions
 // expect their opaque parameters refer to this struct.
 struct ZipBuffer {
   const char* data;  // weak
   size_t length;
   size_t offset;
 };
@@ skipping 131 matching lines @@
   // Passing dummy "fd" filename to zlib.
   return unzOpen2("fd", &zip_funcs);
 }
 #endif
 
 #if defined(OS_WIN)
 unzFile OpenHandleForUnzipping(HANDLE zip_handle) {
   zlib_filefunc_def zip_funcs;
   fill_win32_filefunc(&zip_funcs);
   zip_funcs.zopen_file = HandleOpenFileFunc;
+  zip_funcs.zclose_file = HandleCloseFileFunc;
   zip_funcs.opaque = zip_handle;
   return unzOpen2("fd", &zip_funcs);
 }
 #endif
 
 // static
 unzFile PrepareMemoryForUnzipping(const std::string& data) {
   if (data.empty())
     return NULL;
 
@@ skipping 74 matching lines @@
                     0,  // versionMadeBy
                     LANGUAGE_ENCODING_FLAG)) {  // flagBase
     DLOG(ERROR) << "Could not open zip file entry " << str_path;
     return false;
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace zip