Add an API to unpack Zip files directly from and to file descriptors.

chrome/common/zip_reader_unittest.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 "chrome/common/zip_reader.h"
 
+#if defined(OS_POSIX)
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
 #include <set>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/md5.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 28 matching lines @@
     test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/quux.txt")));
     test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar.txt")));
     test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo.txt")));
     test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/.hidden")));
   }
 
   virtual void TearDown() {
     PlatformTest::TearDown();
   }
 
+#if defined(OS_POSIX)
+  // Helper functions for ZipReader tests that use file descriptors.
+  int OpenFileReadOnly(const FilePath& file) {
+    return open(file.value().c_str(), O_RDONLY);
+  }
+
+  int OpenFileReadWrite(const FilePath& file) {
+    return open(file.value().c_str(),
+                O_RDWR | O_CREAT,
+                S_IRUSR | S_IWUSR);
+  }
+#endif
+
   // The path to temporary directory used to contain the test operations.
   FilePath test_dir_;
   // The path to the test data directory where test.zip etc. are located.
   FilePath test_data_dir_;
   // The path to test.zip in the test data directory.
   FilePath test_zip_file_;
   // The path to evil.zip in the test data directory.
   FilePath evil_zip_file_;
   // The path to evil_via_invalid_utf8.zip in the test data directory.
   FilePath evil_via_invalid_utf8_zip_file_;
   // The path to evil_via_absolute_file_name.zip in the test data directory.
   FilePath evil_via_absolute_file_name_zip_file_;
   std::set<FilePath> test_zip_contents_;
 
   ScopedTempDir temp_dir_;
 };
 
 TEST_F(ZipReaderTest, Open_ValidZipFile) {
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
 }
 
+#if defined(OS_POSIX)
+TEST_F(ZipReaderTest, Open_ValidZipFd) {
+  ZipReader reader;
+  int zip_fd = OpenFileReadOnly(test_zip_file_);
+  ASSERT_TRUE(reader.OpenFromFd(zip_fd));

[satorux1, 2011/12/13 05:23:08]

We should close the fd, but adding close(fd) here will leak the fd if ASSERT
fails.

I'd introduce a wrapper class to ensure fd is closed, like

  FdWrapper wrapper(test_zip_file_, FdWrapper::READ_ONLY);
  ASSERT_TRUE(reader.OpenFromFd(wrapper.fd());

[Jorge Lucangeli Obes, 2011/12/14 23:17:55]

Done.

+}
+#endif
+
 TEST_F(ZipReaderTest, Open_NonExistentFile) {
   ZipReader reader;
   ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("nonexistent.zip")));
 }
 
 TEST_F(ZipReaderTest, Open_ExistentButNonZipFile) {
   ZipReader reader;
   ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("create_test_zip.sh")));
 }
 
 // Iterate through the contents in the test zip file, and compare that the
 // contents collected from the zip reader matches the expected contents.
 TEST_F(ZipReaderTest, Iteration) {
   std::set<FilePath> actual_contents;
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
   while (reader.HasMore()) {
     ASSERT_TRUE(reader.OpenCurrentEntryInZip());
     actual_contents.insert(reader.current_entry_info()->file_path());
     ASSERT_TRUE(reader.AdvanceToNextEntry());
   }
   EXPECT_FALSE(reader.AdvanceToNextEntry());  // Shouldn't go further.
   EXPECT_EQ(test_zip_contents_.size(),
             static_cast<size_t>(reader.num_entries()));
   EXPECT_EQ(test_zip_contents_.size(), actual_contents.size());
   EXPECT_EQ(test_zip_contents_, actual_contents);
 }
 
+#if defined(OS_POSIX)
+// Open the test zip file from a file descriptor, iterate through its contents,
+// and compare that they match the expected contents.
+TEST_F(ZipReaderTest, FdIteration) {
+  std::set<FilePath> actual_contents;
+  ZipReader reader;
+  int zip_fd = OpenFileReadOnly(test_zip_file_);

[satorux1, 2011/12/13 05:23:08]

ditto. the fd is leaked.

[Jorge Lucangeli Obes, 2011/12/14 23:17:55]

Done.

+  ASSERT_TRUE(reader.OpenFromFd(zip_fd));
+  while (reader.HasMore()) {
+    ASSERT_TRUE(reader.OpenCurrentEntryInZip());
+    actual_contents.insert(reader.current_entry_info()->file_path());
+    ASSERT_TRUE(reader.AdvanceToNextEntry());
+  }
+  EXPECT_FALSE(reader.AdvanceToNextEntry());  // Shouldn't go further.
+  EXPECT_EQ(test_zip_contents_.size(),
+            static_cast<size_t>(reader.num_entries()));
+  EXPECT_EQ(test_zip_contents_.size(), actual_contents.size());
+  EXPECT_EQ(test_zip_contents_, actual_contents);
+}
+#endif
 
 TEST_F(ZipReaderTest, LocateAndOpenEntry_ValidFile) {
   std::set<FilePath> actual_contents;
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
   FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   EXPECT_EQ(target_path, reader.current_entry_info()->file_path());
 }
 
@@ skipping 18 matching lines @@
   ASSERT_TRUE(file_util::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
                                           &output));
   const std::string md5 = base::MD5String(output);
   const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
   EXPECT_EQ(kExpectedMD5, md5);
   // quux.txt should be larger than kZipBufSize so that we can exercise
   // the loop in ExtractCurrentEntry().
   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 }
 
+#if defined(OS_POSIX)
+TEST_F(ZipReaderTest, FdExtractCurrentEntryToFilePath_RegularFile) {
+  ZipReader reader;
+  int zip_fd = OpenFileReadOnly(test_zip_file_);
+  ASSERT_TRUE(reader.OpenFromFd(zip_fd));
+  FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
+      test_dir_.AppendASCII("quux.txt")));
+  // Read the output file and compute the MD5.
+  std::string output;
+  ASSERT_TRUE(file_util::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
+                                          &output));
+  const std::string md5 = base::MD5String(output);
+  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
+  EXPECT_EQ(kExpectedMD5, md5);
+  // quux.txt should be larger than kZipBufSize so that we can exercise
+  // the loop in ExtractCurrentEntry().
+  EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
+}
+
+TEST_F(ZipReaderTest, FdExtractCurrentEntryToFd_RegularFile) {
+  ZipReader reader;
+  int zip_fd = OpenFileReadOnly(test_zip_file_);
+  ASSERT_TRUE(reader.OpenFromFd(zip_fd));
+  FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  FilePath out_path = test_dir_.AppendASCII("quux.txt");
+  int out_fd = OpenFileReadWrite(out_path);
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  ASSERT_TRUE(reader.ExtractCurrentEntryToFd(out_fd));
+  // Read the output file and compute the MD5.
+  std::string output;
+  ASSERT_TRUE(file_util::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
+                                          &output));
+  const std::string md5 = base::MD5String(output);
+  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
+  EXPECT_EQ(kExpectedMD5, md5);
+  // quux.txt should be larger than kZipBufSize so that we can exercise
+  // the loop in ExtractCurrentEntry().
+  EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
+}
+#endif
+
 TEST_F(ZipReaderTest, ExtractCurrentEntryToFilePath_Directory) {
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
   FilePath target_path(FILE_PATH_LITERAL("foo/"));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
       test_dir_.AppendASCII("foo")));
   // The directory should be created.
   ASSERT_TRUE(file_util::DirectoryExists(test_dir_.AppendASCII("foo")));
 }
@@ skipping 103 matching lines @@
   EXPECT_EQ(15, exploded.hour);
   EXPECT_EQ(49, exploded.minute);
   EXPECT_EQ(52, exploded.second);
   EXPECT_EQ(0, exploded.millisecond);
 
   EXPECT_FALSE(current_entry_info->is_unsafe());
   EXPECT_TRUE(current_entry_info->is_directory());
 }
 
 }  // namespace zip