Improve Zip File Scanning on Mac

third_party/zlib/google/zip_reader.cc

 // Copyright (c) 2012 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_reader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
@@ skipping 271 matching lines @@
   const int result = unzLocateFile(zip_file_,
                                    path_in_zip.AsUTF8Unsafe().c_str(),
                                    kDefaultCaseSensivityOfOS);
   if (result != UNZ_OK)
     return false;
 
   // Then Open the entry.
   return OpenCurrentEntryInZip();
 }
 
-bool ZipReader::ExtractCurrentEntry(WriterDelegate* delegate) const {
+bool ZipReader::ExtractCurrentEntry(WriterDelegate* delegate,
+                                    uint64_t num_bytes_to_extract) const {
   DCHECK(zip_file_);
 
   const int open_result = unzOpenCurrentFile(zip_file_);
   if (open_result != UNZ_OK)
     return false;
 
   if (!delegate->PrepareOutput())
     return false;
+  std::unique_ptr<char[]> buf(new char[internal::kZipBufSize]);
+  uint64_t total_num_bytes_extracted = 0;
+  bool entire_file_extracted = false;
+  bool extraction_complete = false;
+  bool entire_buffer_written_to_delegate = false;
 
-  bool success = true;  // This becomes false when something bad happens.
-  std::unique_ptr<char[]> buf(new char[internal::kZipBufSize]);
   while (true) {
-    const int num_bytes_read = unzReadCurrentFile(zip_file_, buf.get(),
-                                                  internal::kZipBufSize);
+    const int num_bytes_read =
+        unzReadCurrentFile(zip_file_, buf.get(), internal::kZipBufSize);
+
+    // Ensures function returns true if the |num_bytes_to_extract| cap has
+    // been hit, but also the entire file has been read (i.e. the file size
+    // is the same as |num_bytes_to_extract|).
+    if (extraction_complete) {
+      if (entire_buffer_written_to_delegate && num_bytes_read == 0)
+        entire_file_extracted = true;
+      break;
+    }
+
     if (num_bytes_read == 0) {
-      // Reached the end of the file.
+      entire_file_extracted = true;
       break;
     } else if (num_bytes_read < 0) {
       // If num_bytes_read < 0, then it's a specific UNZ_* error code.
-      success = false;
       break;
     } else if (num_bytes_read > 0) {
       // Some data is read.
-      if (!delegate->WriteBytes(buf.get(), num_bytes_read)) {
-        success = false;
-        break;
+      auto unread_bytes = base::CheckedNumeric<uint64_t>(num_bytes_to_extract) -
+                          total_num_bytes_extracted;
+      uint64_t num_bytes_to_write =
+          std::min<uint64_t>(unread_bytes.ValueOrDie(),
+                             base::checked_cast<uint64_t>(num_bytes_read));
+      total_num_bytes_extracted += num_bytes_to_write;
+      // If error or cap on extraction has been hit, sets boolean to true to the
+      // loop breaks on the next iteration.
+      if (!delegate->WriteBytes(buf.get(), num_bytes_to_write) ||
+          num_bytes_to_extract == total_num_bytes_extracted) {
+        extraction_complete = true;
+        if (num_bytes_to_write ==
+            base::checked_cast<uint64_t>(num_bytes_read)) {
+          entire_buffer_written_to_delegate = true;
+        }
       }
     }
   }
 
   unzCloseCurrentFile(zip_file_);
 
-  return success;
+  return entire_file_extracted;
 }
 
 bool ZipReader::ExtractCurrentEntryToFilePath(
     const base::FilePath& output_file_path) const {
   DCHECK(zip_file_);
 
   // If this is a directory, just create it and return.
   if (current_entry_info()->is_directory())
     return base::CreateDirectory(output_file_path);
 
   bool success = false;
   {
     FilePathWriterDelegate writer(output_file_path);
-    success = ExtractCurrentEntry(&writer);
+    success =
+        ExtractCurrentEntry(&writer, std::numeric_limits<uint64_t>::max());
   }
 
   if (success &&
       current_entry_info()->last_modified() != base::Time::UnixEpoch()) {
     base::TouchFile(output_file_path,
                     base::Time::Now(),
                     current_entry_info()->last_modified());
   }
 
   return success;
@@ skipping 59 matching lines @@
 
 bool ZipReader::ExtractCurrentEntryToFile(base::File* file) const {
   DCHECK(zip_file_);
 
   // If this is a directory, there's nothing to extract to the file, so return
   // false.
   if (current_entry_info()->is_directory())
     return false;
 
   FileWriterDelegate writer(file);
-  return ExtractCurrentEntry(&writer);
+  return ExtractCurrentEntry(&writer, std::numeric_limits<uint64_t>::max());
 }
 
-bool ZipReader::ExtractCurrentEntryToString(size_t max_read_bytes,
+bool ZipReader::ExtractCurrentEntryToString(uint64_t max_read_bytes,
                                             std::string* output) const {
   DCHECK(output);
   DCHECK(zip_file_);
-  DCHECK_NE(0U, max_read_bytes);
+
+  if (max_read_bytes == 0) {
+    output->clear();
+    return true;
+  }
 
   if (current_entry_info()->is_directory()) {
     output->clear();
     return true;
   }
 
   // The original_size() is the best hint for the real size, so it saves
   // doing reallocations for the common case when the uncompressed size is
   // correct. However, we need to assume that the uncompressed size could be
   // incorrect therefore this function needs to read as much data as possible.
   std::string contents;
   contents.reserve(
-      static_cast<size_t>(std::min(static_cast<int64_t>(max_read_bytes),
+      static_cast<size_t>(std::min(base::checked_cast<int64_t>(max_read_bytes),
                                    current_entry_info()->original_size())));
 
   StringWriterDelegate writer(max_read_bytes, &contents);
-  if (!ExtractCurrentEntry(&writer))
+  if (!ExtractCurrentEntry(&writer, max_read_bytes)) {
+    if (contents.length() < max_read_bytes) {
+      // There was an error in extracting entry. If ExtractCurrentEntry()
+      // returns false, the entire file was not read - in which case
+      // contents.length() should equal |max_read_bytes| unless an error
+      // occurred which caused extraction to be aborted.
+      output->clear();
+    } else {
+      // |num_bytes| is less than the length of current entry.
+      output->swap(contents);
+    }
     return false;
+  }
   output->swap(contents);
   return true;
 }
 
 bool ZipReader::OpenInternal() {
   DCHECK(zip_file_);
 
   unz_global_info zip_info = {};  // Zero-clear.
   if (unzGetGlobalInfo(zip_file_, &zip_info) != UNZ_OK) {
     return false;
@@ skipping 69 matching lines @@
 }
 
 bool FileWriterDelegate::WriteBytes(const char* data, int num_bytes) {
   int bytes_written = file_->WriteAtCurrentPos(data, num_bytes);
   if (bytes_written > 0)
     file_length_ += bytes_written;
   return bytes_written == num_bytes;
 }
 
 }  // namespace zip