zipassetmanager.cc

Go to the documentation of this file.

#include "ion/base/zipassetmanager.h"

#include <cstring>
#include <vector>

#include "ion/base/invalid.h"
#include "ion/base/lockguards.h"
#include "ion/base/logging.h"
#include "ion/base/scopedallocation.h"
#include "ion/base/staticsafedeclare.h"
#include "ion/base/stringutils.h"
#include "ion/port/fileutils.h"

#include "third_party/unzip/unzip.h"
#include "third_party/zlib/src/contrib/minizip/ioapi.h"

namespace ion {
namespace base {

namespace {

static const char kManifestFilename[] = "__asset_manifest__.txt";

}  // anonymous namespace

ZipAssetManager::ZipAssetManager() {}

ZipAssetManager::~ZipAssetManager() {
  Reset();
}

bool ZipAssetManager::RegisterAssetData(const void* data, size_t data_size) {
  zlib_filefunc_def def;
  voidpf mem_zipfile =
      mem_simple_create_file(&def, const_cast<void*>(data), data_size);
  if (void* zipfile = unzAttach(mem_zipfile, &def)) {
    FileInfo file_info;
    file_info.zip_handle = zipfile;
    ZipAssetManager* manager = GetManager();
    LockGuard guard(&manager->mutex_);
    manager->zipfiles_.insert(zipfile);

    bool contains_manifest = false;
    {
      static const int kBufSize = 1024;
      base::ScopedAllocation<char> buf(base::kShortTerm, kBufSize);
      unz_file_info info;
      do {
        if (unzGetCurrentFileInfo(
                zipfile, &info, buf.Get(), kBufSize, 0, 0, 0, 0) == UNZ_OK) {
#if ION_DEBUG
          if (manager->file_cache_.find(buf.Get()) !=
              manager->file_cache_.end()) {
            DLOG(WARNING)
                << "Same file registered multiple times risks use after free "
                << "if the result of GetFileData is still in use. "
                << "Duplicate entry: " << buf.Get();
          }
#endif
          manager->file_cache_[buf.Get()] = file_info;
          manager->file_cache_[buf.Get()].data_ptr.reset(new std::string());
          if (strcmp(kManifestFilename, buf.Get()) == 0)
            contains_manifest = true;
        }
      } while (unzGoToNextFile(zipfile) == UNZ_OK);
    }

    if (contains_manifest) {
      const std::vector<std::string> mappings =
          base::SplitString(
              manager->GetFileDataLocked(kManifestFilename, NULL), "\n");
      const size_t count = mappings.size();
      for (size_t i = 0; i < count; ++i) {
        std::vector<std::string> mapping =
            base::SplitString(mappings[i], "|");
        DCHECK_EQ(2U, mapping.size());
        while (base::StartsWith(mapping[0], "/"))
          base::RemovePrefix("/", &mapping[0]);
        FileCache::iterator it =
            manager->file_cache_.find(port::GetCanonicalFilePath(mapping[0]));
        DCHECK(it != manager->file_cache_.end());
        it->second.original_name = mapping[1];
        it->second.timestamp = std::chrono::system_clock::time_point();
        port::GetFileModificationTime(mapping[1], &it->second.timestamp);
      }
      manager->file_cache_.erase(kManifestFilename);
    }
    return true;
  } else {
    free(mem_zipfile);
    return false;
  }
}

bool ZipAssetManager::ContainsFile(const std::string& filename) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  return manager->ContainsFileLocked(filename);
}

bool ZipAssetManager::ContainsFileLocked(const std::string& filename) {
  return file_cache_.find(filename) != file_cache_.end();
}

bool ZipAssetManager::IsFileCached(const std::string& filename) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  FileCache::const_iterator it = manager->file_cache_.find(filename);
  return it != manager->file_cache_.end() &&
      manager->FileIsCached(it->second);
}

std::vector<std::string> ZipAssetManager::GetRegisteredFileNames() {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  std::vector<std::string> filenames;
  for (const auto& file : manager->file_cache_)
    filenames.push_back(file.first);
  return filenames;
}

std::shared_ptr<const std::string> ZipAssetManager::GetFileDataPtr(
    const std::string& filename) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  if (!IsInvalidReference(manager->GetFileDataLocked(filename, NULL))) {
    FileCache::iterator it = manager->file_cache_.find(filename);
    return it->second.data_ptr;
  }
  return std::shared_ptr<const std::string>();
}

const std::string& ZipAssetManager::GetFileData(const std::string& filename) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  return manager->GetFileDataLocked(filename, NULL);
}

bool ZipAssetManager::GetFileDataNoCache(const std::string& filename,
                                         std::string* out) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  return !IsInvalidReference(manager->GetFileDataLocked(filename, out));
}

const std::string& ZipAssetManager::GetFileDataLocked(
    const std::string& filename, std::string* out) {
  if (!ContainsFileLocked(filename)) {
    return InvalidReference<const std::string>();
  } else {
    FileCache::iterator it = file_cache_.find(filename);
    if (!FileIsCached(it->second)) {
      if (!out)
        out = it->second.data_ptr.get();
      else
        out->clear();
      unz_file_info info;
      if (unzLocateFile(it->second.zip_handle, filename.c_str(), 0) == UNZ_OK &&
          unzOpenCurrentFile(it->second.zip_handle) == UNZ_OK &&
          unzGetCurrentFileInfo(
              it->second.zip_handle, &info, 0, 0, 0, 0, 0, 0) ==
              UNZ_OK) {
        out->resize(info.uncompressed_size);
        unzReadCurrentFile(it->second.zip_handle, &(*out)[0],
                           static_cast<unsigned int>(info.uncompressed_size));
      }
      return *out;
    } else if (out) {
      out->clear();
      out->swap(*it->second.data_ptr);
      return *out;
    } else {
      return *it->second.data_ptr;
    }
  }
}

bool ZipAssetManager::SetFileData(const std::string& filename,
                                  const std::string& source) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  if (!manager->ContainsFileLocked(filename)) {
    return false;
  } else {
    FileCache::iterator it = manager->file_cache_.find(filename);
    *it->second.data_ptr = source;
    it->second.timestamp = std::chrono::system_clock::now();
    return true;
  }
}

bool ZipAssetManager::SaveFileData(const std::string& filename) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  const std::string& data = manager->GetFileDataLocked(filename, NULL);
  FileCache::const_iterator it = manager->file_cache_.find(filename);
  if (it != manager->file_cache_.end() &&
      !base::IsInvalidReference(data) && !it->second.original_name.empty()) {
    if (FILE* fp = port::OpenFile(it->second.original_name, "wb")) {
      const size_t count =
          fwrite(data.c_str(), sizeof(data[0]), data.length(), fp);
      fclose(fp);
      return count == data.length();
    }
  }
  return false;
}

void ZipAssetManager::Reset() {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  for (std::set<void*>::iterator it = manager->zipfiles_.begin();
       it != manager->zipfiles_.end(); it++)
    unzClose(*it);
  manager->file_cache_.clear();
  manager->zipfiles_.clear();
}

bool ZipAssetManager::UpdateFileIfChanged(
    const std::string& filename,
    std::chrono::system_clock::time_point* timestamp) {
  ZipAssetManager* manager = GetManager();
  LockGuard guard(&manager->mutex_);
  std::chrono::system_clock::time_point new_timestamp;
  FileCache::iterator it = manager->file_cache_.find(filename);
  if (it != manager->file_cache_.end() && !it->second.original_name.empty()) {
    const bool found =
        port::GetFileModificationTime(it->second.original_name, &new_timestamp);
    if (found && new_timestamp > it->second.timestamp) {
      it->second.timestamp = new_timestamp;
      if (FILE* fp = port::OpenFile(it->second.original_name, "rb")) {
        fseek(fp, 0, SEEK_END);
        const size_t length = ftell(fp);
        rewind(fp);

        it->second.data_ptr->resize(length);
        fread(&((*it->second.data_ptr)[0]), sizeof(char), length, fp);
        fclose(fp);
      }
      *timestamp = new_timestamp;
      return true;
    }
  }

  return false;
}

ZipAssetManager* ZipAssetManager::GetManager() {
  ION_DECLARE_SAFE_STATIC_POINTER(ZipAssetManager, s_manager);
  return s_manager;
}

bool ZipAssetManager::FileIsCached(const FileInfo& info) {
  return !info.data_ptr->empty();
}

}  // namespace base
}  // namespace ion