// 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"
#include "chrome/common/zip_internal.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"

namespace {

#if defined(OS_POSIX)
// Wrap file descriptors in a class so that we don't leak them in tests.
class FdWrapper {
 public:
  typedef enum {
    READ_ONLY,
    READ_WRITE
  } AccessMode;

  FdWrapper(const FilePath& file, AccessMode mode) : fd_(-1) {
    switch (mode) {
    case READ_ONLY:
      fd_ = open(file.value().c_str(), O_RDONLY);
      break;
    case READ_WRITE:
      fd_ = open(file.value().c_str(),
                 O_RDWR | O_CREAT,
                 S_IRUSR | S_IWUSR);
      break;
    default:
      NOTREACHED();
    }
    return;
  }

  ~FdWrapper() {
    close(fd_);
  }

  int fd() { return fd_; }

 private:
  int fd_;
};
#endif

}   // namespace

namespace zip {

// Make the test a PlatformTest to setup autorelease pools properly on Mac.
class ZipReaderTest : public PlatformTest {
 protected:
  virtual void SetUp() {
    PlatformTest::SetUp();

    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
    test_dir_ = temp_dir_.path();

    ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_));
    test_data_dir_ = test_data_dir_.AppendASCII("zip");

    test_zip_file_ = test_data_dir_.AppendASCII("test.zip");
    evil_zip_file_ = test_data_dir_.AppendASCII("evil.zip");
    evil_via_invalid_utf8_zip_file_ = test_data_dir_.AppendASCII(
        "evil_via_invalid_utf8.zip");
    evil_via_absolute_file_name_zip_file_ = test_data_dir_.AppendASCII(
        "evil_via_absolute_file_name.zip");

    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/")));
    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/")));
    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/baz.txt")));
    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();
  }

  // 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;
  FdWrapper zip_fd_wrapper(test_zip_file_, FdWrapper::READ_ONLY);
  ASSERT_TRUE(reader.OpenFromFd(zip_fd_wrapper.fd()));
}
#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;
  FdWrapper zip_fd_wrapper(test_zip_file_, FdWrapper::READ_ONLY);
  ASSERT_TRUE(reader.OpenFromFd(zip_fd_wrapper.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());
}

TEST_F(ZipReaderTest, LocateAndOpenEntry_NonExistentFile) {
  std::set<FilePath> actual_contents;
  ZipReader reader;
  ASSERT_TRUE(reader.Open(test_zip_file_));
  FilePath target_path(FILE_PATH_LITERAL("nonexistent.txt"));
  ASSERT_FALSE(reader.LocateAndOpenEntry(target_path));
  EXPECT_EQ(NULL, reader.current_entry_info());
}

TEST_F(ZipReaderTest, ExtractCurrentEntryToFilePath_RegularFile) {
  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));
  ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
      test_dir_.AppendASCII("quux.txt")));
  // Read the output file ans 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());
}

#if defined(OS_POSIX)
TEST_F(ZipReaderTest, FdExtractCurrentEntryToFilePath_RegularFile) {
  ZipReader reader;
  FdWrapper zip_fd_wrapper(test_zip_file_, FdWrapper::READ_ONLY);
  ASSERT_TRUE(reader.OpenFromFd(zip_fd_wrapper.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;
  FdWrapper zip_fd_wrapper(test_zip_file_, FdWrapper::READ_ONLY);
  ASSERT_TRUE(reader.OpenFromFd(zip_fd_wrapper.fd()));
  FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
  FilePath out_path = test_dir_.AppendASCII("quux.txt");
  FdWrapper out_fd_w(out_path, FdWrapper::READ_WRITE);
  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
  ASSERT_TRUE(reader.ExtractCurrentEntryToFd(out_fd_w.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")));
}

TEST_F(ZipReaderTest, ExtractCurrentEntryIntoDirectory_RegularFile) {
  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));
  ASSERT_TRUE(reader.ExtractCurrentEntryIntoDirectory(test_dir_));
  // Sub directories should be created.
  ASSERT_TRUE(file_util::DirectoryExists(test_dir_.AppendASCII("foo/bar")));
  // And the file should be created.
  std::string output;
  ASSERT_TRUE(file_util::ReadFileToString(
      test_dir_.AppendASCII("foo/bar/quux.txt"), &output));
  const std::string md5 = base::MD5String(output);
  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
  EXPECT_EQ(kExpectedMD5, md5);
}

TEST_F(ZipReaderTest, current_entry_info_RegularFile) {
  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));
  ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();

  EXPECT_EQ(target_path, current_entry_info->file_path());
  EXPECT_EQ(13527, current_entry_info->original_size());

  // The expected time stamp: 2009-05-29 06:22:20
  base::Time::Exploded exploded = {};  // Zero-clear.
  current_entry_info->last_modified().LocalExplode(&exploded);
  EXPECT_EQ(2009, exploded.year);
  EXPECT_EQ(5, exploded.month);
  EXPECT_EQ(29, exploded.day_of_month);
  EXPECT_EQ(6, exploded.hour);
  EXPECT_EQ(22, exploded.minute);
  EXPECT_EQ(20, exploded.second);
  EXPECT_EQ(0, exploded.millisecond);

  EXPECT_FALSE(current_entry_info->is_unsafe());
  EXPECT_FALSE(current_entry_info->is_directory());
}

TEST_F(ZipReaderTest, current_entry_info_DotDotFile) {
  ZipReader reader;
  ASSERT_TRUE(reader.Open(evil_zip_file_));
  FilePath target_path(FILE_PATH_LITERAL(
      "../levilevilevilevilevilevilevilevilevilevilevilevil"));
  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
  ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
  EXPECT_EQ(target_path, current_entry_info->file_path());

  // This file is unsafe because of ".." in the file name.
  EXPECT_TRUE(current_entry_info->is_unsafe());
  EXPECT_FALSE(current_entry_info->is_directory());
}

TEST_F(ZipReaderTest, current_entry_info_InvalidUTF8File) {
  ZipReader reader;
  ASSERT_TRUE(reader.Open(evil_via_invalid_utf8_zip_file_));
  // The evil file is the 2nd file in the zip file.
  // We cannot locate by the file name ".\x80.\\evil.txt",
  // as FilePath may internally convert the string.
  ASSERT_TRUE(reader.AdvanceToNextEntry());
  ASSERT_TRUE(reader.OpenCurrentEntryInZip());
  ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();

  // This file is unsafe because of invalid UTF-8 in the file name.
  EXPECT_TRUE(current_entry_info->is_unsafe());
  EXPECT_FALSE(current_entry_info->is_directory());
}

TEST_F(ZipReaderTest, current_entry_info_AbsoluteFile) {
  ZipReader reader;
  ASSERT_TRUE(reader.Open(evil_via_absolute_file_name_zip_file_));
  FilePath target_path(FILE_PATH_LITERAL("/evil.txt"));
  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
  ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
  EXPECT_EQ(target_path, current_entry_info->file_path());

  // This file is unsafe because of the absolute file name.
  EXPECT_TRUE(current_entry_info->is_unsafe());
  EXPECT_FALSE(current_entry_info->is_directory());
}

TEST_F(ZipReaderTest, current_entry_info_Directory) {
  ZipReader reader;
  ASSERT_TRUE(reader.Open(test_zip_file_));
  FilePath target_path(FILE_PATH_LITERAL("foo/bar/"));
  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
  ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();

  EXPECT_EQ(FilePath(FILE_PATH_LITERAL("foo/bar/")),
            current_entry_info->file_path());
  // The directory size should be zero.
  EXPECT_EQ(0, current_entry_info->original_size());

  // The expected time stamp: 2009-05-31 15:49:52
  base::Time::Exploded exploded = {};  // Zero-clear.
  current_entry_info->last_modified().LocalExplode(&exploded);
  EXPECT_EQ(2009, exploded.year);
  EXPECT_EQ(5, exploded.month);
  EXPECT_EQ(31, exploded.day_of_month);
  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