archive_r_ruby 0.1.0

data/ext/archive_r/vendor/archive_r/src/archive_stack_orchestrator.h

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/path_hierarchy.h"
+#include "archive_type.h"
+#include "archive_stack_cursor.h"
+#include "entry_fault_error.h"
+#include "multi_volume_manager.h"
+#include <limits>
+#include <memory>
+#include <string>
+#include <sys/types.h>
+#include <unordered_set>
+
+namespace archive_r {
+
+class ArchiveStackOrchestrator {
+public:
+  explicit ArchiveStackOrchestrator(const ArchiveOption &options = {});
+  ArchiveStackOrchestrator(const ArchiveStackOrchestrator &) = delete;
+  ArchiveStackOrchestrator &operator=(const ArchiveStackOrchestrator &) = delete;
+
+  ~ArchiveStackOrchestrator();
+
+  void open_root_hierarchy(const PathHierarchy &root_hierarchy);
+
+  bool advance(bool descend_request = true);
+  const std::string &current_entryname();
+
+  size_t depth() const;
+  PathHierarchy current_entry_hierarchy();
+  bool synchronize_to_hierarchy(const PathHierarchy &path_hierarchy);
+
+  StreamArchive *current_archive();
+  ssize_t read_head(void *buff, size_t len);
+
+  const std::unordered_set<std::string> &metadata_keys() const { return _metadata_keys; }
+  const ArchiveOption &options() const { return _archive_options; }
+
+  void mark_entry_as_multi_volume(const PathHierarchy &entry_path, const std::string &base_name, PathEntry::Parts::Ordering ordering = PathEntry::Parts::Ordering::Natural);
+  bool descend_pending_multi_volumes();
+
+private:
+  ArchiveOption _archive_options;
+  std::unordered_set<std::string> _metadata_keys;
+  ArchiveStackCursor _head;
+  MultiVolumeManager _multi_volume_manager;
+
+  void dispatch_fault(EntryFault fault);
+};
+
+} // namespace archive_r

data/ext/archive_r/vendor/archive_r/src/archive_type.cc

@@ -0,0 +1,552 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_type.h"
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <unordered_map>
+
+namespace archive_r {
+
+namespace {
+
+[[noreturn]] void throw_archive_fault(const std::string &message, struct archive *ar = nullptr) {
+  const int err = ar ? archive_errno(ar) : 0;
+  throw make_entry_fault_error(message, {}, err);
+}
+
+} // namespace
+
+void archive_deleter::operator()(struct archive *a) const {
+  if (a) {
+    archive_read_close(a);
+    archive_read_free(a);
+  }
+}
+
+static void set_passphrases(struct archive *ar, const std::vector<std::string> &passphrases) {
+  size_t index = 0;
+  for (const auto &passphrase : passphrases) {
+    if (archive_read_add_passphrase(ar, passphrase.c_str()) != ARCHIVE_OK) {
+      char buf[1024];
+      std::snprintf(buf, sizeof(buf), "Failed to add passphrase (index %zu): %s", index, archive_error_string(ar));
+      throw_archive_fault(buf, ar);
+    }
+    ++index;
+  }
+}
+
+static void configure_formats(struct archive *ar, const std::vector<std::string> &format_names) {
+  if (format_names.empty()) {
+    archive_read_support_format_all(ar);
+    return;
+  }
+
+  using FormatHandler = int (*)(struct archive *);
+  static const std::unordered_map<std::string, FormatHandler> kFormatHandlers = {
+    { "7zip", archive_read_support_format_7zip },   { "ar", archive_read_support_format_ar },           { "cab", archive_read_support_format_cab }, { "cpio", archive_read_support_format_cpio },
+    { "empty", archive_read_support_format_empty }, { "iso9660", archive_read_support_format_iso9660 }, { "lha", archive_read_support_format_lha }, { "mtree", archive_read_support_format_mtree },
+    { "rar", archive_read_support_format_rar },     { "raw", archive_read_support_format_raw },         { "tar", archive_read_support_format_tar }, { "warc", archive_read_support_format_warc },
+    { "xar", archive_read_support_format_xar },     { "zip", archive_read_support_format_zip },
+  };
+
+  for (const auto &format : format_names) {
+    auto it = kFormatHandlers.find(format);
+    if (it == kFormatHandlers.end()) {
+      char buf[1024];
+      std::snprintf(buf, sizeof(buf), "Unsupported archive format specified (%s)", format.c_str());
+      throw_archive_fault(buf);
+    }
+
+    int r = it->second(ar);
+    if (r != ARCHIVE_OK) {
+      char buf[1024];
+      std::snprintf(buf, sizeof(buf), "Failed to enable format (%s): %s", format.c_str(), archive_error_string(ar));
+      throw_archive_fault(buf, ar);
+    }
+  }
+}
+
+static std::string format_archive_error(struct archive *ar, const std::string &prefix) {
+  std::string message = prefix;
+
+  if (!ar) {
+    return message;
+  }
+
+  if (const char *err = archive_error_string(ar)) {
+    if (*err) {
+      message += ": ";
+      message += err;
+    }
+  }
+
+  const int code = archive_errno(ar);
+  if (code != 0) {
+    message += " (libarchive errno=";
+    message += std::to_string(code);
+    message += ')';
+  }
+
+  return message;
+}
+
+archive_ptr new_read_archive_common(const std::vector<std::string> &passphrases, const std::vector<std::string> &format_names, open_delegate archive_open) {
+  archive_ptr ar(archive_read_new());
+  if (!ar) {
+    throw_archive_fault("archive_read_new failed.");
+  }
+
+  configure_formats(ar.get(), format_names);
+  archive_read_support_filter_all(ar.get());
+  set_passphrases(ar.get(), passphrases);
+
+  if (archive_open(ar.get()) != ARCHIVE_OK) {
+    char buf[1024];
+    std::snprintf(buf, sizeof(buf), "archive_read_open failed: (%d)%s", archive_errno(ar.get()), archive_error_string(ar.get()));
+    throw_archive_fault(buf, ar.get());
+  }
+
+  return ar;
+}
+
+Archive::Archive()
+    : _ar(nullptr)
+    , current_entry(nullptr)
+    , _at_eof(false)
+    , _current_entry_content_ready(false) {}
+
+Archive::~Archive() { close_archive(); }
+
+void Archive::close_archive() {
+  if (_ar) {
+    archive_read_close(_ar);
+    archive_read_free(_ar);
+    _ar = nullptr;
+  }
+  current_entry = nullptr;
+  current_entryname.clear();
+  _current_entry_content_ready = false;
+}
+
+void Archive::rewind() {
+  close_archive();
+  current_entryname.clear();
+  current_entry = nullptr;
+  _at_eof = false;
+  open_archive();
+  _current_entry_content_ready = false;
+}
+
+bool Archive::skip_to_next_header() {
+  if (!_ar) {
+    throw std::logic_error("Archive handle is not initialized");
+  }
+
+  if (_at_eof) {
+    current_entry = nullptr;
+    current_entryname.clear();
+    _current_entry_content_ready = false;
+    return false;
+  }
+
+  const int r = archive_read_next_header(_ar, &current_entry);
+
+  if (r == ARCHIVE_EOF) {
+    _at_eof = true;
+    current_entry = nullptr;
+    current_entryname.clear();
+    _current_entry_content_ready = false;
+    return false;
+  }
+
+  if (r == ARCHIVE_FAILED || r == ARCHIVE_FATAL || r == ARCHIVE_RETRY) {
+    const std::string message = format_archive_error(_ar, "Failed to read next header");
+    _at_eof = true;
+    current_entry = nullptr;
+    current_entryname.clear();
+    _current_entry_content_ready = false;
+    raise_archive_error(message);
+  }
+
+  const char *name = archive_entry_pathname(current_entry);
+  if (name == nullptr) {
+    throw make_entry_fault_error("Failed to retrieve entry pathname (archive_entry_pathname returned null)", {}, 0);
+  }
+  current_entryname = std::string(name);
+  _current_entry_content_ready = true;
+  return true;
+}
+
+bool Archive::skip_data() {
+  if (!_ar) {
+    throw std::logic_error("Archive handle is not initialized");
+  }
+
+  int r = archive_read_data_skip(_ar);
+  if (r != ARCHIVE_OK) {
+    raise_archive_error(format_archive_error(_ar, "Failed to skip data"));
+  }
+  _current_entry_content_ready = false;
+  return true;
+}
+
+bool Archive::skip_to_entry(const std::string &entryname) {
+
+  if (current_entryname == entryname && _current_entry_content_ready) {
+    return true;
+  }
+
+  if (_at_eof) {
+    rewind();
+  }
+
+  const std::string start_position = current_entryname;
+
+  if (search_forward_until_eof(entryname)) {
+    return true;
+  }
+
+  if (start_position.empty()) {
+    return false;
+  }
+
+  rewind();
+
+  return search_until_position(entryname, start_position);
+}
+
+bool Archive::skip_to_eof() {
+  while (!_at_eof) {
+    skip_to_next_header();
+  }
+  return true;
+}
+
+bool Archive::search_forward_until_eof(const std::string &entryname) {
+  while (skip_to_next_header()) {
+    if (current_entryname == entryname) {
+      return true;
+    }
+    if (!skip_data()) {
+      return false;
+    }
+  }
+  return false;
+}
+
+bool Archive::search_until_position(const std::string &entryname, const std::string &stop_position) {
+  while (skip_to_next_header()) {
+    if (current_entryname == entryname) {
+      return true;
+    }
+    if (current_entryname == stop_position) {
+      break;
+    }
+    if (!skip_data()) {
+      return false;
+    }
+  }
+  return false;
+}
+
+ssize_t Archive::read_current(void *buff, size_t len) {
+  if (!_ar) {
+    throw std::logic_error("Archive handle is not initialized");
+  }
+
+  const ssize_t bytes_read = archive_read_data(_ar, buff, len);
+  if (bytes_read < 0) {
+    raise_archive_error(format_archive_error(_ar, "Failed to read data"));
+  }
+
+  _current_entry_content_ready = false;
+  return bytes_read;
+}
+
+uint64_t Archive::current_entry_size() const {
+  if (!current_entry) {
+    return 0;
+  }
+  return archive_entry_size(current_entry);
+}
+
+mode_t Archive::current_entry_filetype() const {
+  if (!current_entry) {
+    return 0;
+  }
+  return archive_entry_filetype(current_entry);
+}
+
+EntryMetadataMap Archive::current_entry_metadata(const std::unordered_set<std::string> &allowed_keys) const {
+  EntryMetadataMap metadata;
+  if (!current_entry || allowed_keys.empty()) {
+    return metadata;
+  }
+
+  auto wants = [&allowed_keys](const std::string &key) { return allowed_keys.find(key) != allowed_keys.end(); };
+
+  const char *pathname_utf8 = archive_entry_pathname_utf8(current_entry);
+  if (pathname_utf8 && *pathname_utf8 && wants("pathname")) {
+    metadata["pathname"] = std::string(pathname_utf8);
+  } else {
+    const char *pathname = archive_entry_pathname(current_entry);
+    if (pathname && *pathname && wants("pathname")) {
+      metadata["pathname"] = std::string(pathname);
+    }
+  }
+
+  if (const char *sourcepath = archive_entry_sourcepath(current_entry)) {
+    if (wants("sourcepath")) {
+      metadata["sourcepath"] = std::string(sourcepath);
+    }
+  }
+
+  if (const char *symlink_utf8 = archive_entry_symlink_utf8(current_entry)) {
+    if (wants("symlink")) {
+      metadata["symlink"] = std::string(symlink_utf8);
+    }
+  }
+
+  if (const char *hardlink_utf8 = archive_entry_hardlink_utf8(current_entry)) {
+    if (wants("hardlink")) {
+      metadata["hardlink"] = std::string(hardlink_utf8);
+    }
+  } else if (const char *hardlink = archive_entry_hardlink(current_entry)) {
+    if (wants("hardlink")) {
+      metadata["hardlink"] = std::string(hardlink);
+    }
+  }
+
+  if (const char *uname_utf8 = archive_entry_uname_utf8(current_entry)) {
+    if (wants("uname")) {
+      metadata["uname"] = std::string(uname_utf8);
+    }
+  } else if (const char *uname = archive_entry_uname(current_entry)) {
+    if (wants("uname")) {
+      metadata["uname"] = std::string(uname);
+    }
+  }
+
+  if (const char *gname_utf8 = archive_entry_gname_utf8(current_entry)) {
+    if (wants("gname")) {
+      metadata["gname"] = std::string(gname_utf8);
+    }
+  } else if (const char *gname = archive_entry_gname(current_entry)) {
+    if (wants("gname")) {
+      metadata["gname"] = std::string(gname);
+    }
+  }
+
+  if (wants("uid")) {
+    bool has_uid = archive_entry_uname(current_entry) != nullptr;
+    if (!has_uid) {
+      has_uid = archive_entry_uid(current_entry) != 0;
+    }
+    if (has_uid) {
+      metadata["uid"] = static_cast<int64_t>(archive_entry_uid(current_entry));
+    }
+  }
+
+  if (wants("gid")) {
+    bool has_gid = archive_entry_gname(current_entry) != nullptr;
+    if (!has_gid) {
+      has_gid = archive_entry_gid(current_entry) != 0;
+    }
+    if (has_gid) {
+      metadata["gid"] = static_cast<int64_t>(archive_entry_gid(current_entry));
+    }
+  }
+
+  if (wants("perm")) {
+    metadata["perm"] = static_cast<uint64_t>(archive_entry_perm(current_entry));
+  }
+
+  if (wants("mode")) {
+    metadata["mode"] = static_cast<uint64_t>(archive_entry_mode(current_entry));
+  }
+
+  if (wants("filetype")) {
+    metadata["filetype"] = static_cast<uint64_t>(archive_entry_filetype(current_entry));
+  }
+
+  if (archive_entry_size_is_set(current_entry) && wants("size")) {
+    metadata["size"] = static_cast<uint64_t>(archive_entry_size(current_entry));
+  }
+
+  if (archive_entry_dev_is_set(current_entry) && wants("dev")) {
+    metadata["dev"] = EntryMetadataDeviceNumbers{ static_cast<uint64_t>(archive_entry_devmajor(current_entry)), static_cast<uint64_t>(archive_entry_devminor(current_entry)) };
+  }
+
+  if (wants("rdev")) {
+    const dev_t rdev = archive_entry_rdev(current_entry);
+    if (rdev != 0) {
+      metadata["rdev"] = EntryMetadataDeviceNumbers{ static_cast<uint64_t>(archive_entry_rdevmajor(current_entry)), static_cast<uint64_t>(archive_entry_rdevminor(current_entry)) };
+    }
+  }
+
+  if (archive_entry_ino_is_set(current_entry)) {
+    if (wants("ino")) {
+      metadata["ino"] = static_cast<uint64_t>(archive_entry_ino(current_entry));
+    }
+    if (wants("ino64")) {
+      metadata["ino64"] = static_cast<uint64_t>(archive_entry_ino64(current_entry));
+    }
+  }
+
+  if (wants("nlink")) {
+    metadata["nlink"] = static_cast<uint64_t>(archive_entry_nlink(current_entry));
+  }
+
+  if (const char *strmode = archive_entry_strmode(current_entry)) {
+    if (wants("strmode")) {
+      metadata["strmode"] = std::string(strmode);
+    }
+  }
+
+  auto record_time = [&metadata, &wants](const char *key, bool is_set, time_t seconds, long nanoseconds) {
+    if (!wants(key) || !is_set) {
+      return;
+    }
+    metadata[key] = EntryMetadataTime{ static_cast<int64_t>(seconds), static_cast<int32_t>(nanoseconds) };
+  };
+
+  record_time("atime", archive_entry_atime_is_set(current_entry) != 0, archive_entry_atime(current_entry), archive_entry_atime_nsec(current_entry));
+  record_time("birthtime", archive_entry_birthtime_is_set(current_entry) != 0, archive_entry_birthtime(current_entry), archive_entry_birthtime_nsec(current_entry));
+  record_time("ctime", archive_entry_ctime_is_set(current_entry) != 0, archive_entry_ctime(current_entry), archive_entry_ctime_nsec(current_entry));
+  record_time("mtime", archive_entry_mtime_is_set(current_entry) != 0, archive_entry_mtime(current_entry), archive_entry_mtime_nsec(current_entry));
+
+  unsigned long fflags_set = 0;
+  unsigned long fflags_clear = 0;
+  archive_entry_fflags(current_entry, &fflags_set, &fflags_clear);
+  if ((fflags_set != 0 || fflags_clear != 0) && wants("fflags")) {
+    metadata["fflags"] = EntryMetadataFileFlags{ static_cast<uint64_t>(fflags_set), static_cast<uint64_t>(fflags_clear) };
+  }
+
+  if (const char *fflags_text = archive_entry_fflags_text(current_entry)) {
+    if (wants("fflags_text")) {
+      metadata["fflags_text"] = std::string(fflags_text);
+    }
+  }
+
+  auto store_encryption_flag = [&metadata, &wants](const char *key, int value) {
+    if (!wants(key) || value < 0) {
+      return;
+    }
+    metadata[key] = (value != 0);
+  };
+
+  store_encryption_flag("is_data_encrypted", archive_entry_is_data_encrypted(current_entry));
+  store_encryption_flag("is_metadata_encrypted", archive_entry_is_metadata_encrypted(current_entry));
+  store_encryption_flag("is_encrypted", archive_entry_is_encrypted(current_entry));
+
+  if (wants("symlink_type")) {
+    const int symlink_type = archive_entry_symlink_type(current_entry);
+    if (symlink_type != 0) {
+      metadata["symlink_type"] = static_cast<int64_t>(symlink_type);
+    }
+  }
+
+  ssize_t acl_length = 0;
+  char *acl_text = wants("acl_text") ? archive_entry_acl_to_text(current_entry, &acl_length, ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA) : nullptr;
+  if (acl_text) {
+    if (acl_length >= 0) {
+      metadata["acl_text"] = std::string(acl_text, static_cast<size_t>(acl_length));
+    } else {
+      metadata["acl_text"] = std::string(acl_text);
+    }
+    std::free(acl_text);
+  }
+
+  if (wants("acl_types")) {
+    const int acl_types = archive_entry_acl_types(current_entry);
+    if (acl_types != 0) {
+      metadata["acl_types"] = static_cast<int64_t>(acl_types);
+    }
+  }
+
+  const int xattr_count = archive_entry_xattr_count(current_entry);
+  if (xattr_count > 0 && wants("xattr")) {
+    std::vector<EntryMetadataXattr> xattrs;
+    xattrs.reserve(static_cast<size_t>(xattr_count));
+    archive_entry_xattr_reset(current_entry);
+    const char *name = nullptr;
+    const void *value = nullptr;
+    size_t size = 0;
+    while (archive_entry_xattr_next(current_entry, &name, &value, &size) == ARCHIVE_OK) {
+      EntryMetadataXattr xattr;
+      if (name) {
+        xattr.name = name;
+      }
+      if (value && size > 0) {
+        const auto *begin = static_cast<const uint8_t *>(value);
+        xattr.value.assign(begin, begin + size);
+      }
+      xattrs.push_back(std::move(xattr));
+    }
+    if (!xattrs.empty()) {
+      metadata["xattr"] = std::move(xattrs);
+    }
+  }
+
+  const int sparse_count = archive_entry_sparse_count(current_entry);
+  if (sparse_count > 0 && wants("sparse")) {
+    std::vector<EntryMetadataSparseChunk> sparse_regions;
+    sparse_regions.reserve(static_cast<size_t>(sparse_count));
+    archive_entry_sparse_reset(current_entry);
+    la_int64_t offset = 0;
+    la_int64_t length = 0;
+    while (archive_entry_sparse_next(current_entry, &offset, &length) == ARCHIVE_OK) {
+      sparse_regions.push_back(EntryMetadataSparseChunk{ static_cast<int64_t>(offset), static_cast<int64_t>(length) });
+    }
+    if (!sparse_regions.empty()) {
+      metadata["sparse"] = std::move(sparse_regions);
+    }
+  }
+
+  if (wants("mac_metadata")) {
+    size_t mac_metadata_size = 0;
+    const void *mac_metadata = archive_entry_mac_metadata(current_entry, &mac_metadata_size);
+    if (mac_metadata && mac_metadata_size > 0) {
+      const auto *begin = static_cast<const uint8_t *>(mac_metadata);
+      metadata["mac_metadata"] = std::vector<uint8_t>(begin, begin + mac_metadata_size);
+    }
+  }
+
+  static constexpr struct {
+    int type;
+    const char *name;
+    size_t length;
+  } kDigestDescriptors[] = { { ARCHIVE_ENTRY_DIGEST_MD5, "md5", 16 },       { ARCHIVE_ENTRY_DIGEST_RMD160, "rmd160", 20 }, { ARCHIVE_ENTRY_DIGEST_SHA1, "sha1", 20 },
+                             { ARCHIVE_ENTRY_DIGEST_SHA256, "sha256", 32 }, { ARCHIVE_ENTRY_DIGEST_SHA384, "sha384", 48 }, { ARCHIVE_ENTRY_DIGEST_SHA512, "sha512", 64 } };
+
+  if (wants("digests")) {
+    std::vector<EntryMetadataDigest> digests;
+    for (const auto &descriptor : kDigestDescriptors) {
+      const unsigned char *digest = archive_entry_digest(current_entry, descriptor.type);
+      if (!digest) {
+        continue;
+      }
+      EntryMetadataDigest digest_entry;
+      digest_entry.algorithm = descriptor.name;
+      digest_entry.value.assign(digest, digest + descriptor.length);
+      digests.push_back(std::move(digest_entry));
+    }
+    if (!digests.empty()) {
+      metadata["digests"] = std::move(digests);
+    }
+  }
+
+  return metadata;
+}
+
+[[noreturn]] void Archive::raise_archive_error(const std::string &message) {
+  const int err = _ar ? archive_errno(_ar) : 0;
+  throw make_entry_fault_error(message, {}, err);
+}
+
+} // namespace archive_r

data/ext/archive_r/vendor/archive_r/src/archive_type.h

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include "archive_r/entry_metadata.h"
+#include "entry_fault_error.h"
+#include <archive.h>
+#include <archive_entry.h>
+#include <functional>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <sys/types.h>
+#include <unordered_set>
+#include <vector>
+
+namespace archive_r {
+
+struct archive_deleter {
+  void operator()(struct archive *a) const;
+};
+
+using archive_ptr = std::unique_ptr<struct archive, archive_deleter>;
+using open_delegate = std::function<int(struct archive *ar)>;
+
+struct ArchiveOption {
+  std::vector<std::string> passphrases;   ///< Passphrases for encrypted archives
+  std::vector<std::string> formats;       ///< Specific format names to enable (empty = all)
+  std::vector<std::string> metadata_keys; ///< Metadata keys to capture (empty = none)
+};
+
+archive_ptr new_read_archive_common(const std::vector<std::string> &passphrases, const std::vector<std::string> &format_names, open_delegate archive_open);
+
+struct Archive {
+  Archive();
+  virtual ~Archive();
+
+  Archive(const Archive &) = delete;
+  Archive &operator=(const Archive &) = delete;
+
+  virtual void open_archive() = 0;
+  virtual void close_archive();
+  virtual void rewind();
+
+  bool skip_to_next_header();
+  bool skip_data();
+  bool skip_to_entry(const std::string &entryname);
+  bool skip_to_eof();
+
+  std::string current_entryname;
+  struct archive_entry *current_entry;
+  ssize_t read_current(void *buff, size_t len);
+
+  // Get current entry metadata
+  uint64_t current_entry_size() const;
+  mode_t current_entry_filetype() const;
+  EntryMetadataMap current_entry_metadata(const std::unordered_set<std::string> &allowed_keys) const;
+
+  struct archive *_ar;
+  bool _at_eof;
+
+protected:
+  bool _current_entry_content_ready;
+
+public:
+  bool current_entry_content_ready() const { return _current_entry_content_ready; }
+
+private:
+  [[noreturn]] void raise_archive_error(const std::string &message);
+
+  bool search_forward_until_eof(const std::string &entryname);
+  bool search_until_position(const std::string &entryname, const std::string &stop_position);
+};
+
+} // namespace archive_r