// Copyright 2014 The Chromium OS 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 "volume_archive_libarchive.h"

#include <algorithm>
#include <cerrno>
#include <limits>

#include "archive_entry.h"
#include "ppapi/cpp/logging.h"

namespace {

const int64_t kArchiveReadDataError = -1;  // Negative value means error.

std::string ArchiveError(const std::string& message, archive* archive_object) {
  return message + archive_error_string(archive_object);
}

// Sets the libarchive internal error to a VolumeReader related error.
// archive_error_string function must work on valid strings, but in case of
// errors in the custom functions, libarchive API assumes the error is set by
// us. If we don't set it, we will get a Segmentation Fault because
// archive_error_string will work on invalid memory.
void SetLibarchiveErrorToVolumeReaderError(archive* archive_object) {
  archive_set_error(archive_object,
                    EIO /* I/O error. */,
                    "%s" /* Format string similar to printf. */,
                    volume_archive_constants::kVolumeReaderError);
}

ssize_t CustomArchiveRead(archive* archive_object,
                          void* client_data,
                          const void** buffer) {
  VolumeArchiveLibarchive* volume_archive =
      static_cast<VolumeArchiveLibarchive*>(client_data);

  int64_t read_bytes = volume_archive->reader()->Read(
      volume_archive->reader_data_size(), buffer);
  if (read_bytes == ARCHIVE_FATAL)
    SetLibarchiveErrorToVolumeReaderError(archive_object);
  return read_bytes;
}

int64_t CustomArchiveSkip(archive* archive_object,
                          void* client_data,
                          int64_t request) {
  VolumeArchiveLibarchive* volume_archive =
      static_cast<VolumeArchiveLibarchive*>(client_data);
  // VolumeReader::Skip returns 0 in case of failure and CustomArchiveRead is
  // used instead, so there is no need to check for VolumeReader error.
  return volume_archive->reader()->Skip(request);
}

int64_t CustomArchiveSeek(archive* archive_object,
                          void* client_data,
                          int64_t offset,
                          int whence) {
  VolumeArchiveLibarchive* volume_archive =
      static_cast<VolumeArchiveLibarchive*>(client_data);

  int64_t new_offset = volume_archive->reader()->Seek(offset, whence);
  if (new_offset == ARCHIVE_FATAL)
    SetLibarchiveErrorToVolumeReaderError(archive_object);

  return new_offset;
}

const char* CustomArchivePassphrase(
    archive* archive_object, void* client_data) {
  VolumeArchiveLibarchive* volume_archive =
      static_cast<VolumeArchiveLibarchive*>(client_data);

  return volume_archive->reader()->Passphrase();
}

}  // namespace

VolumeArchiveLibarchive::VolumeArchiveLibarchive(VolumeReader* reader)
    : VolumeArchive(reader),
      reader_data_size_(volume_archive_constants::kMinimumDataChunkSize),
      archive_(NULL),
      current_archive_entry_(NULL),
      last_read_data_offset_(0),
      last_read_data_length_(0),
      decompressed_data_(NULL),
      decompressed_data_size_(0),
      decompressed_error_(false) {
}

VolumeArchiveLibarchive::~VolumeArchiveLibarchive() {
  Cleanup();
}

bool VolumeArchiveLibarchive::Init(const std::string& encoding) {
  archive_ = archive_read_new();
  if (!archive_) {
    set_error_message(volume_archive_constants::kArchiveReadNewError);
    return false;
  }

  // TODO(cmihail): Once the bug mentioned at
  // https://github.com/libarchive/libarchive/issues/373 is resolved
  // add RAR file handler to manifest.json.
  if (archive_read_support_format_rar(archive_) != ARCHIVE_OK ||
      archive_read_support_format_zip_seekable(archive_) != ARCHIVE_OK) {
    set_error_message(ArchiveError(
        volume_archive_constants::kArchiveSupportErrorPrefix, archive_));
    return false;
  }

  // Default encoding for file names in headers. Note, that another one may be
  // used if specified in the archive.
  std::string options = std::string("hdrcharset=") + encoding;
  if (!encoding.empty() &&
      archive_read_set_options(archive_, options.c_str()) != ARCHIVE_OK) {
    set_error_message(ArchiveError(
        volume_archive_constants::kArchiveSupportErrorPrefix, archive_));
    return false;
  }

  // Set callbacks for processing the archive's data and open the archive.
  // The callback data is the VolumeArchive itself.
  int ok = ARCHIVE_OK;
  if (archive_read_set_read_callback(archive_, CustomArchiveRead) != ok ||
      archive_read_set_skip_callback(archive_, CustomArchiveSkip) != ok ||
      archive_read_set_seek_callback(archive_, CustomArchiveSeek) != ok ||
      archive_read_set_passphrase_callback(
          archive_, this, CustomArchivePassphrase) != ok ||
      archive_read_set_callback_data(archive_, this) != ok ||
      archive_read_open1(archive_) != ok) {
    set_error_message(ArchiveError(
        volume_archive_constants::kArchiveOpenErrorPrefix, archive_));
    return false;
  }

  return true;
}

VolumeArchive::Result VolumeArchiveLibarchive::GetNextHeader() {
  // Headers are being read from the central directory (in the ZIP format), so
  // use a large block size to save on IPC calls. The headers in EOCD are
  // grouped one by one.
  reader_data_size_ = volume_archive_constants::kMaximumDataChunkSize;

  // Reset to 0 for new VolumeArchive::ReadData operation.
  last_read_data_offset_ = 0;
  decompressed_data_size_ = 0;

  // Archive data is skipped automatically by next call to
  // archive_read_next_header.
  switch (archive_read_next_header(archive_, &current_archive_entry_)) {
    case ARCHIVE_EOF:
      return RESULT_EOF;
    case ARCHIVE_OK:
      return RESULT_SUCCESS;
    default:
      set_error_message(ArchiveError(
          volume_archive_constants::kArchiveNextHeaderErrorPrefix, archive_));
      return RESULT_FAIL;
  }
}

VolumeArchive::Result VolumeArchiveLibarchive::GetNextHeader(
    const char** pathname,
    int64_t* size,
    bool* is_directory,
    time_t* modification_time) {
  Result ret = GetNextHeader();

  if (ret == RESULT_SUCCESS) {
    *pathname = archive_entry_pathname(current_archive_entry_);
    *size = archive_entry_size(current_archive_entry_);
    *modification_time = archive_entry_mtime(current_archive_entry_);
    *is_directory = archive_entry_filetype(current_archive_entry_) == AE_IFDIR;
  }

  return ret;
}

bool VolumeArchiveLibarchive::SeekHeader(int64_t index) {
  // Reset to 0 for new VolumeArchive::ReadData operation.
  last_read_data_offset_ = 0;
  decompressed_data_size_ = 0;

  if (archive_read_seek_header(archive_, index) != ARCHIVE_OK) {
    set_error_message(ArchiveError(
        volume_archive_constants::kArchiveNextHeaderErrorPrefix, archive_));
    return false;
  }

  return true;
}

void VolumeArchiveLibarchive::DecompressData(int64_t offset, int64_t length) {
  // TODO(cmihail): As an optimization consider using archive_read_data_block
  // which avoids extra copying in case offset != last_read_data_offset_.
  // The logic will be more complicated because archive_read_data_block offset
  // will not be aligned with the offset of the read request from JavaScript.

  // Requests with offset smaller than last read offset are not supported.
  if (offset < last_read_data_offset_) {
    set_error_message(
        std::string(volume_archive_constants::kArchiveReadDataErrorPrefix) +
        "Reading backwards is not supported.");
    decompressed_error_ = true;
    return;
  }

  // Request with offset greater than last read offset. Skip not needed bytes.
  // Because files are compressed, seeking is not possible, so all of the bytes
  // until the requested position must be unpacked.
  ssize_t size = -1;
  while (offset > last_read_data_offset_) {
    // ReadData will call CustomArchiveRead when calling archive_read_data. Read
    // should not request more bytes than possibly needed, so we request either
    // offset - last_read_data_offset_, kMaximumDataChunkSize in case the former
    // is too big or kMinimumDataChunkSize in case its too small and we might
    // end up with too many IPCs.
    reader_data_size_ =
        std::max(std::min(offset - last_read_data_offset_,
                          volume_archive_constants::kMaximumDataChunkSize),
                 volume_archive_constants::kMinimumDataChunkSize);

    // No need for an offset in dummy_buffer as it will be ignored anyway.
    // archive_read_data receives size_t as length parameter, but we limit it to
    // volume_archive_constants::kDummyBufferSize which is positive and less
    // than size_t maximum. So conversion from int64_t to size_t is safe here.
    size =
        archive_read_data(archive_,
                          dummy_buffer_,
                          std::min(offset - last_read_data_offset_,
                                   volume_archive_constants::kDummyBufferSize));
    PP_DCHECK(size != 0);  // The actual read is done below. We shouldn't get to
                           // end of file here.
    if (size < 0) {        // Error.
      set_error_message(ArchiveError(
          volume_archive_constants::kArchiveReadDataErrorPrefix, archive_));
      decompressed_error_ = true;
      return;
    }
    last_read_data_offset_ += size;
  }

  // Do not decompress more bytes than we can store internally. The
  // kDecompressBufferSize limit is used to avoid huge memory usage.
  int64_t left_length =
      std::min(length, volume_archive_constants::kDecompressBufferSize);

  // ReadData will call CustomArchiveRead when calling archive_read_data. The
  // read should be done with a value similar to length, which is the requested
  // number of bytes, or kMaximumDataChunkSize / kMinimumDataChunkSize
  // in case length is too big or too small.
  reader_data_size_ =
      std::max(std::min(static_cast<int64_t>(left_length),
                        volume_archive_constants::kMaximumDataChunkSize),
               volume_archive_constants::kMinimumDataChunkSize);

  // Perform the actual copy.
  int64_t bytes_read = 0;
  do {
    // archive_read_data receives size_t as length parameter, but we limit it to
    // volume_archive_constants::kMinimumDataChunkSize (see left_length
    // initialization), which is positive and less than size_t maximum.
    // So conversion from int64_t to size_t is safe here.
    size = archive_read_data(
        archive_, decompressed_data_buffer_ + bytes_read, left_length);
    if (size < 0) {  // Error.
      set_error_message(ArchiveError(
          volume_archive_constants::kArchiveReadDataErrorPrefix, archive_));
      decompressed_error_ = true;
      return;
    }
    bytes_read += size;
    left_length -= size;
  } while (left_length > 0 && size != 0);  // There is still data to read.

  // VolumeArchiveLibarchive::DecompressData always stores the data from
  // beginning of the buffer. VolumeArchiveLibarchive::ConsumeData is used
  // to preserve the bytes that are decompressed but not required by
  // VolumeArchiveLibarchive::ReadData.
  decompressed_data_ = decompressed_data_buffer_;
  decompressed_data_size_ = bytes_read;
}

bool VolumeArchiveLibarchive::Cleanup() {
  bool returnValue = true;
  if (archive_ && archive_read_free(archive_) != ARCHIVE_OK) {
    set_error_message(ArchiveError(
        volume_archive_constants::kArchiveReadFreeErrorPrefix, archive_));
    returnValue = false;  // Cleanup should release all resources even
                          // in case of failures.
  }
  archive_ = NULL;

  CleanupReader();

  return returnValue;
}

int64_t VolumeArchiveLibarchive::ReadData(int64_t offset,
                                          int64_t length,
                                          const char** buffer) {
  PP_DCHECK(length > 0);              // Length must be at least 1.
  PP_DCHECK(current_archive_entry_);  // Check that GetNextHeader was called at
                                      // least once. In case it wasn't, this is
                                      // a programmer error.

  // End of archive.
  if (archive_entry_size_is_set(current_archive_entry_) &&
      archive_entry_size(current_archive_entry_) <= offset)
    return 0;

  // In case of first read or no more available data in the internal buffer or
  // offset is different from the last_read_data_offset_, then force
  // VolumeArchiveLibarchive::DecompressData as the decompressed data is
  // invalid.
  if (!decompressed_data_ || last_read_data_offset_ != offset ||
      decompressed_data_size_ == 0)
    DecompressData(offset, length);

  // Decompressed failed.
  if (decompressed_error_)
    return kArchiveReadDataError;

  last_read_data_length_ = length;  // Used for decompress ahead.

  // Assign the output *buffer parameter to the internal buffer.
  *buffer = decompressed_data_;

  // Advance internal buffer for next ReadData call.
  int64_t read_bytes = std::min(decompressed_data_size_, length);
  decompressed_data_ = decompressed_data_ + read_bytes;
  decompressed_data_size_ -= read_bytes;
  last_read_data_offset_ += read_bytes;

  PP_DCHECK(decompressed_data_ + decompressed_data_size_ <=
            decompressed_data_buffer_ +
                volume_archive_constants::kDecompressBufferSize);

  return read_bytes;
}

void VolumeArchiveLibarchive::MaybeDecompressAhead() {
  if (decompressed_data_size_ == 0)
    DecompressData(last_read_data_offset_, last_read_data_length_);
}