memoryzipstream.cc

Go to the documentation of this file.

#include "ion/base/memoryzipstream.h"

#include <cstring>

#include "ion/base/logging.h"
#include "ion/base/staticsafedeclare.h"
#include "third_party/unzip/unzip.h"
#include "third_party/zlib/src/contrib/minizip/zip.h"

namespace ion {
namespace base {

struct MemoryZipStream::ZipStreamInfo : public Allocatable {
  ZipStreamInfo() : position(0U), buffer(GetAllocator()) {}
  zlib_filefunc_def def;
  size_t position;
  DataVector buffer;
};

namespace {

typedef long ZipLong;  // NOLINT

static voidpf ZCALLBACK
    OpenZipStream(voidpf opaque, const char* filename, int mode) {
  if (MemoryZipStream::ZipStreamInfo* info =
        reinterpret_cast<MemoryZipStream::ZipStreamInfo*>(opaque))
    info->position = 0U;
  return opaque;
}

static uLong ZCALLBACK
ReadFromZipStream(voidpf opaque, voidpf stream, void* buf, uLong size) {
  uLong bytes_read = 0;
  if (MemoryZipStream::ZipStreamInfo* info =
      reinterpret_cast<MemoryZipStream::ZipStreamInfo*>(opaque)) {
    if (info->position + size > info->buffer.size()) {
       const int64 available = info->buffer.size() - info->position;
       size = available < 0 ? 0 : static_cast<uLong>(available);
    }
    if (size) {
      memcpy(buf, &info->buffer[info->position], size);
      info->position += size;
      bytes_read = size;
    }
  }
  return bytes_read;
}

static uLong ZCALLBACK WriteToZipStream(
    voidpf opaque, voidpf stream, const void* buf, uLong size) {
  uLong bytes_written = 0;
  if (MemoryZipStream::ZipStreamInfo* info =
      reinterpret_cast<MemoryZipStream::ZipStreamInfo*>(opaque)) {
    if (info->position + size > info->buffer.size())
      info->buffer.resize(info->position + size);

    memcpy(&info->buffer[info->position], buf, size);
    info->position += size;

    bytes_written = size;
  }
  return bytes_written;
}

static ZipLong ZCALLBACK TellZipStream(voidpf opaque, voidpf stream) {
  ZipLong position = 0;
  if (MemoryZipStream::ZipStreamInfo* info =
        reinterpret_cast<MemoryZipStream::ZipStreamInfo*>(opaque))
    position = static_cast<ZipLong>(info->position);
  return position;
}

static ZipLong ZCALLBACK
SeekZipStream(voidpf opaque, voidpf stream, uLong offset, int origin) {
  bool ok = true;
  if (MemoryZipStream::ZipStreamInfo* info =
        reinterpret_cast<MemoryZipStream::ZipStreamInfo*>(opaque)) {
    ok = false;
    const int64 size = info->buffer.size();
    if (origin == SEEK_SET) {
      ok = true;
      info->position = offset;
    } else if (origin == SEEK_CUR) {
      ok = (static_cast<size_t>(offset) + info->position) <=
           static_cast<size_t>(size);
      if (ok)
        info->position += offset;
    } else if (origin == SEEK_END) {
      const int64 new_pos = size - static_cast<int64>(offset);
      ok = new_pos >= 0 && new_pos <= size;
      if (ok)
        info->position = offset + static_cast<size_t>(size);
    }
  }
  return ok ? 0 : -1;
}

static int ZCALLBACK CloseZipStream(voidpf opaque, voidpf stream) {
  return 0;
}

static int ZCALLBACK ErrorZipStream(voidpf opaque, voidpf stream) {
  LOG(ERROR) << "An error occurred in a MemoryZipStream";
  return -1;
}

struct ScopedUnzip {
  explicit ScopedUnzip(MemoryZipStream::ZipStreamInfo* info)
      : handle(info->buffer.size() ? unzAttach(&info->def, &info->def) : NULL) {
  }
  ~ScopedUnzip() {
    if (handle)
      unzDetach(&handle);
  }
  operator bool() { return handle != NULL; }

  unzFile handle;
};

struct ScopedZip {
  explicit ScopedZip(MemoryZipStream::ZipStreamInfo* info)
      : handle(info->buffer.size()
                   ? zipOpen2("", APPEND_STATUS_ADDINZIP, NULL, &info->def)
                   : zipOpen2("", APPEND_STATUS_CREATE, NULL, &info->def)) {}
  ~ScopedZip() {
    if (handle)
      zipClose(handle, "");
  }
  operator bool() { return handle != NULL; }

  zipFile handle;
};

}  // anonymous namespace

MemoryZipStream::MemoryZipStream()
    : info_(new(GetAllocator()) ZipStreamInfo()) {
  InitCallbacks();
}

MemoryZipStream::MemoryZipStream(const DataVector& data)
    : info_(new(GetAllocator()) ZipStreamInfo()) {
  info_->buffer = data;
  InitCallbacks();
}

MemoryZipStream::MemoryZipStream(DataVector* data)
    : info_(new(GetAllocator()) ZipStreamInfo()) {
  info_->buffer.swap(*data);
  InitCallbacks();
}

MemoryZipStream::~MemoryZipStream() {}

void MemoryZipStream::AddFile(const std::string& filename,
                              const DataVector& data) {
  if (ScopedZip zip = ScopedZip(info_.get())) {
    zipOpenNewFileInZip(
        zip.handle, filename.c_str(), NULL, NULL, 0, NULL, 0, NULL, Z_DEFLATED,
        Z_BEST_COMPRESSION);
    zipWriteInFileInZip(zip.handle, data.data(),
                        static_cast<unsigned int>(data.size()));
    zipCloseFileInZip(zip.handle);
  }
}

void MemoryZipStream::AddFile(const std::string& filename,
                              const std::string& data) {
  DataVector vec(*this, data.begin(), data.end());
  AddFile(filename, vec);
}

bool MemoryZipStream::ContainsFile(const std::string& filename) {
  bool contains = false;
  if (ScopedUnzip unz = ScopedUnzip(info_.get()))
    contains = unzLocateFile(unz.handle, filename.c_str(), 0) == UNZ_OK;
  return contains;
}

const MemoryZipStream::DataVector MemoryZipStream::GetFileData(
    const std::string& filename) {
  DataVector data(*this);
  if (ScopedUnzip unz = ScopedUnzip(info_.get())) {
    unz_file_info info;
    static const int kStringLength = 256;
    char extra_field[kStringLength + 1];
    char comment[kStringLength + 1];
    if (unzLocateFile(unz.handle, filename.c_str(), 0) == UNZ_OK &&
        unzOpenCurrentFile(unz.handle) == UNZ_OK &&
        unzGetCurrentFileInfo(unz.handle, &info, NULL, 0, extra_field,
                              kStringLength, comment, kStringLength) ==
            UNZ_OK) {
      data.resize(info.uncompressed_size);
      unzReadCurrentFile(unz.handle, &data[0],
                         static_cast<unsigned int>(info.uncompressed_size));
    }
  }
  return data;
}

const MemoryZipStream::DataVector& MemoryZipStream::GetData() const {
  return info_->buffer;
}

void MemoryZipStream::InitCallbacks() {
  info_->def.zopen_file = OpenZipStream;
  info_->def.zread_file = ReadFromZipStream;
  info_->def.zwrite_file = WriteToZipStream;
  info_->def.ztell_file = TellZipStream;
  info_->def.zseek_file = SeekZipStream;
  info_->def.zclose_file = CloseZipStream;
  info_->def.zerror_file = ErrorZipStream;
  info_->def.opaque = info_.get();
}

}  // namespace base
}  // namespace ion