Source/cmArchiveWrite.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#include "cmArchiveWrite.h"

#include <cstdlib>
#include <ctime>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <thread>

#include <cm/algorithm>
#include <cm/string_view>

#include <cm3p/archive.h>
#include <cm3p/archive_entry.h>

#include "cmsys/Directory.hxx"
#ifdef _WIN32
#  include "cmsys/Encoding.hxx"
#endif
#include "cmsys/FStream.hxx"

#include "cm_parse_date.h"

#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"

#ifndef __LA_SSIZE_T
#  define __LA_SSIZE_T la_ssize_t
#endif

static std::string cm_archive_error_string(struct archive* a)
{
  char const* e = archive_error_string(a);
  return e ? e : "unknown error";
}

// Set path to be written to the archive.
static void cm_archive_entry_copy_pathname(struct archive_entry* e,
                                           char const* dest)
{
#ifdef _WIN32
  // libarchive converts our UTF-8 encoding to the archive's encoding.
  // `archive_entry_update_pathname_utf8` always populates the WCS form too.
  // It also populates the MBS form if possible, but we ignore conversion
  // failure because the archive formats support converting directly from
  // the WCS form to the archive's encoding without using the MBS form.
  archive_entry_update_pathname_utf8(e, dest);
#else
  // libarchive converts our locale's encoding to the archive's encoding.
  archive_entry_copy_pathname(e, dest);
#endif
}

// Set path used for filesystem access.
static void cm_archive_entry_copy_sourcepath(struct archive_entry* e,
                                             std::string const& file)
{
#ifdef _WIN32
  archive_entry_copy_sourcepath_w(e, cmsys::Encoding::ToWide(file).c_str());
#else
  archive_entry_copy_sourcepath(e, file.c_str());
#endif
}

class cmArchiveWrite::Entry
{
  struct archive_entry* Object;

public:
  Entry()
    : Object(archive_entry_new())
  {
  }
  ~Entry() { archive_entry_free(this->Object); }
  Entry(Entry const&) = delete;
  Entry& operator=(Entry const&) = delete;
  operator struct archive_entry *() { return this->Object; }
};

struct cmArchiveWrite::Callback
{
  // archive_write_callback
  static __LA_SSIZE_T Write(struct archive* /*unused*/, void* cd,
                            void const* b, size_t n)
  {
    cmArchiveWrite* self = static_cast<cmArchiveWrite*>(cd);
    if (self->Stream.write(static_cast<char const*>(b),
                           static_cast<std::streamsize>(n))) {
      return static_cast<__LA_SSIZE_T>(n);
    }
    return static_cast<__LA_SSIZE_T>(-1);
  }
};

cmArchiveWrite::cmArchiveWrite(std::ostream& os, Compress c,
                               std::string const& format,
                               std::string const& encoding,
                               int compressionLevel, int numThreads)
  : Stream(os)
  , Archive(archive_write_new())
  , Disk(archive_read_disk_new())
  , Format(format)
{
  // Upstream fixed an issue with their integer parsing in 3.4.0
  // which would cause spurious errors to be raised from `strtoull`.

  if (archive_write_set_format_by_name(this->Archive, format.c_str()) !=
      ARCHIVE_OK) {
    this->Error = cmStrCat("archive_write_set_format_by_name: ",
                           cm_archive_error_string(this->Archive));
    return;
  }

  bool is7zip = (format == "7zip");
  bool isZip = (format == "zip");
  bool isFormatSupportsCompressionNatively = (is7zip || isZip);

  if (numThreads < 1) {
    int upperLimit = (numThreads == 0) ? std::numeric_limits<int>::max()
                                       : std::abs(numThreads);

    numThreads =
      cm::clamp<int>(std::thread::hardware_concurrency(), 1, upperLimit);
  }

  std::string sNumThreads = std::to_string(numThreads);

  if (!isFormatSupportsCompressionNatively) {
    switch (c) {
      case CompressNone:
        if (archive_write_add_filter_none(this->Archive) != ARCHIVE_OK) {
          this->Error = cmStrCat("archive_write_add_filter_none: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }
        break;
      case CompressCompress:
        if (archive_write_add_filter_compress(this->Archive) != ARCHIVE_OK) {
          this->Error = cmStrCat("archive_write_add_filter_compress: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }
        break;
      case CompressGZip: {
        if (archive_write_add_filter_gzip(this->Archive) != ARCHIVE_OK) {
          this->Error = cmStrCat("archive_write_add_filter_gzip: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }
        std::string source_date_epoch;
        cmSystemTools::GetEnv("SOURCE_DATE_EPOCH", source_date_epoch);
        if (!source_date_epoch.empty()) {
          // We're not able to specify an arbitrary timestamp for gzip.
          // The next best thing is to omit the timestamp entirely.
          if (archive_write_set_filter_option(
                this->Archive, "gzip", "timestamp", nullptr) != ARCHIVE_OK) {
            this->Error = cmStrCat("archive_write_set_filter_option: ",
                                   cm_archive_error_string(this->Archive));
            return;
          }
        }
      } break;
      case CompressBZip2:
        if (archive_write_add_filter_bzip2(this->Archive) != ARCHIVE_OK) {
          this->Error = cmStrCat("archive_write_add_filter_bzip2: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }
        break;
      case CompressLZMA:
        if (archive_write_add_filter_lzma(this->Archive) != ARCHIVE_OK) {
          this->Error = cmStrCat("archive_write_add_filter_lzma: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }
        break;
      case CompressXZ:
        if (archive_write_add_filter_xz(this->Archive) != ARCHIVE_OK) {
          this->Error = cmStrCat("archive_write_add_filter_xz: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }

#if ARCHIVE_VERSION_NUMBER >= 3004000

#  ifdef _AIX
        // FIXME: Using more than 2 threads creates an empty archive.
        // Enforce this limit pending further investigation.
        if (numThreads > 2) {
          numThreads = 2;
          sNumThreads = std::to_string(numThreads);
        }
#  endif
        if (archive_write_set_filter_option(this->Archive, "xz", "threads",
                                            sNumThreads.c_str()) !=
            ARCHIVE_OK) {
          this->Error = cmStrCat("archive_compressor_xz_options: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }
#endif

        break;
      case CompressZstd:
        if (archive_write_add_filter_zstd(this->Archive) != ARCHIVE_OK) {
          this->Error = cmStrCat("archive_write_add_filter_zstd: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }

#if ARCHIVE_VERSION_NUMBER >= 3006000
        if (archive_write_set_filter_option(this->Archive, "zstd", "threads",
                                            sNumThreads.c_str()) !=
            ARCHIVE_OK) {
          this->Error = cmStrCat("archive_compressor_zstd_options: ",
                                 cm_archive_error_string(this->Archive));
          return;
        }
#endif
        break;
      case CompressPPMd:
        this->Error = cmStrCat("PPMd is not supported for ", format);
        return;
    }
  }

  // 7zip always uses UTF16-LE for the headers and doesn't support
  // header encoding specification.
  // arbsd can use the default encoding of the system only.
  if (!is7zip && format != "arbsd" && encoding != "OEM") {
    char const* formatForOptions = format == "paxr" ? "pax" : format.c_str();
    if (archive_write_set_format_option(this->Archive, formatForOptions,
                                        "hdrcharset",
                                        encoding.c_str()) != ARCHIVE_OK) {
      this->Error = cmStrCat("archive_write_set_format_option(hdrcharset): ",
                             cm_archive_error_string(this->Archive));
      return;
    }
  }

  if (isFormatSupportsCompressionNatively || compressionLevel != 0) {
    std::string compressionLevelStr = std::to_string(compressionLevel);
    std::string archiveFilterName;
    switch (c) {
      case CompressNone:
        if (is7zip || isZip) {
          archiveFilterName = "store";
        } else {
          // Nothing to do - the value should be empty
        }
        break;
      case CompressCompress:
        if (is7zip || isZip) {
          this->Error =
            cmStrCat("CompressCompress is not supported for ", format);
        } else {
          // Nothing to do - the value should be empty
        }
        break;
      case CompressGZip:
        if (is7zip || isZip) {
          archiveFilterName = "deflate";
        } else {
          archiveFilterName = "gzip";
        }
        break;
      case CompressBZip2:
#if ARCHIVE_VERSION_NUMBER < 3008000
        if (isZip) {
          this->Error = cmStrCat("BZip2 is not supported for ", format,
                                 ". Please, build CMake with libarchive 3.8.0 "
                                 "or newer if you want to use it.");
          return;
        }
#endif
        archiveFilterName = "bzip2";
        break;
      case CompressLZMA:
#if ARCHIVE_VERSION_NUMBER < 3008000
        if (isZip) {
          this->Error = cmStrCat("LZMA is not supported for ", format,
                                 ". Please, build CMake with libarchive 3.8.0 "
                                 "or newer if you want to use it.");
          return;
        }
#endif
        if (is7zip) {
          archiveFilterName = "lzma1";
        } else {
          archiveFilterName = "lzma";
        }
        break;
      case CompressXZ:
#if ARCHIVE_VERSION_NUMBER < 3008000
        if (isZip) {
          this->Error = cmStrCat("LZMA2 (XZ) is not supported for ", format,
                                 ". Please, build CMake with libarchive 3.8.0 "
                                 "or newer if you want to use it.");
          return;
        }
#endif
        if (is7zip) {
          archiveFilterName = "lzma2";
        } else {
          archiveFilterName = "xz";
        }
        break;
      case CompressZstd:
#if ARCHIVE_VERSION_NUMBER < 3008000
        if (is7zip || isZip) {
          this->Error = cmStrCat("Zstd is not supported for ", format,
                                 ". Please, build CMake with libarchive 3.8.0 "
                                 "or newer if you want to use it.");
          return;
        }
#endif
        archiveFilterName = "zstd";
        break;
      case CompressPPMd:
        if (is7zip) {
          archiveFilterName = "ppmd";
        } else {
          this->Error = cmStrCat("PPMd is not supported for ", format);
        }
        return;
    }

    if (isFormatSupportsCompressionNatively) {
      if (archiveFilterName.empty()) {
        this->Error = cmStrCat("Unknown compression method for ", format);
        return;
      }

      if (archive_write_set_format_option(
            this->Archive, format.c_str(), "compression",
            archiveFilterName.c_str()) != ARCHIVE_OK) {
        this->Error =
          cmStrCat("archive_write_set_format_option(compression): ",
                   cm_archive_error_string(this->Archive));
        return;
      }

#if ARCHIVE_VERSION_NUMBER >= 3008000
      if (archive_write_set_format_option(this->Archive, format.c_str(),
                                          "threads",
                                          sNumThreads.c_str()) != ARCHIVE_OK) {
        this->Error = cmStrCat("archive_write_set_format_option(threads): ",
                               cm_archive_error_string(this->Archive));
        return;
      }
#endif

      if (compressionLevel != 0) {
        if (archive_write_set_format_option(
              this->Archive, format.c_str(), "compression-level",
              compressionLevelStr.c_str()) != ARCHIVE_OK) {
          this->Error =
            cmStrCat("archive_write_set_format_option(compression-level): ",
                     cm_archive_error_string(this->Archive));
          return;
        }
      }
    } else if (compressionLevel != 0 && !archiveFilterName.empty()) {
      if (archive_write_set_filter_option(
            this->Archive, archiveFilterName.c_str(), "compression-level",
            compressionLevelStr.c_str()) != ARCHIVE_OK) {
        this->Error = cmStrCat("archive_write_set_filter_option: ",
                               cm_archive_error_string(this->Archive));
        return;
      }
    }
  }

#if !defined(_WIN32) || defined(__CYGWIN__)
  if (archive_read_disk_set_standard_lookup(this->Disk) != ARCHIVE_OK) {
    this->Error = cmStrCat("archive_read_disk_set_standard_lookup: ",
                           cm_archive_error_string(this->Archive));
    return;
  }
#endif

  // do not pad the last block!!
  if (archive_write_set_bytes_in_last_block(this->Archive, 1)) {
    this->Error = cmStrCat("archive_write_set_bytes_in_last_block: ",
                           cm_archive_error_string(this->Archive));
    return;
  }
}

bool cmArchiveWrite::Open()
{
  if (!this->Error.empty()) {
    return false;
  }
  if (archive_write_open(
        this->Archive, this, nullptr,
        reinterpret_cast<archive_write_callback*>(&Callback::Write),
        nullptr) != ARCHIVE_OK) {
    this->Error =
      cmStrCat("archive_write_open: ", cm_archive_error_string(this->Archive));
    return false;
  }
  return true;
}

bool cmArchiveWrite::SetExcludePatterns(
  std::vector<std::string> const& patterns)
{
  if (patterns.empty()) {
    return true;
  }
  if (!this->MatchObject) {
    this->MatchObject = archive_match_new();
    if (!this->MatchObject) {
      this->Error = "archive_match_new: out of memory";
      return false;
    }
  }
  // NOLINTNEXTLINE(readability-use-anyofallof)
  for (std::string const& pattern : patterns) {
    // Reject empty patterns ourselves.  libarchive would reject them too, but
    // only after allocating an error message on the match object that
    // archive_match_free() does not release.
    if (pattern.empty()) {
      this->Error = "exclusion pattern must not be empty";
      return false;
    }
    if (archive_match_exclude_pattern(this->MatchObject, pattern.c_str()) !=
        ARCHIVE_OK) {
      this->Error =
        cmStrCat("Failed to add to exclusion list: ", pattern, " (",
                 cm_archive_error_string(this->MatchObject), ')');
      return false;
    }
  }
  return true;
}

cmArchiveWrite::~cmArchiveWrite()
{
  if (this->MatchObject) {
    archive_match_free(this->MatchObject);
  }
  archive_read_free(this->Disk);
  archive_write_free(this->Archive);
}

bool cmArchiveWrite::Add(std::string path, size_t skip, char const* prefix,
                         bool recursive)
{
  if (!path.empty() && path.back() == '/') {
    path.erase(path.size() - 1);
  }
  this->AddPath(path, skip, prefix, recursive);
  return this->Okay();
}

bool cmArchiveWrite::AddPath(std::string const& path, size_t skip,
                             char const* prefix, bool recursive)
{
  // Skip paths whose archive entry name matches an exclusion pattern.  For a
  // directory this also prevents descending into it, pruning the subtree.
  if (this->MatchObject && skip < path.length()) {
    cm::string_view out = cm::string_view(path).substr(skip);
    std::string dest = cmStrCat(prefix ? prefix : "", out);
    Entry e;
    cm_archive_entry_copy_pathname(e, dest.c_str());
    int matched = archive_match_path_excluded(this->MatchObject, e);
    if (matched < 0) {
      this->Error = cmStrCat("archive_match_path_excluded: ",
                             cm_archive_error_string(this->MatchObject));
      return false;
    }
    if (matched > 0) {
      return true;
    }
  }
  if (path != "." || (this->Format != "zip" && this->Format != "7zip")) {
    if (!this->AddFile(path, skip, prefix)) {
      return false;
    }
  }
  if ((!cmSystemTools::FileIsDirectory(path) || !recursive) ||
      cmSystemTools::FileIsSymlink(path)) {
    return true;
  }
  cmsys::Directory d;
  if (d.Load(path)) {
    std::string next = cmStrCat(path, '/');
    if (next == "./" && (this->Format == "zip" || this->Format == "7zip")) {
      next.clear();
    }
    std::string::size_type end = next.size();
    unsigned long n = d.GetNumberOfFiles();
    for (unsigned long i = 0; i < n; ++i) {
      std::string const& file = d.GetFileName(i);
      if (file != "." && file != "..") {
        next.erase(end);
        next += file;
        if (!this->AddPath(next, skip, prefix)) {
          return false;
        }
      }
    }
  }
  return true;
}

bool cmArchiveWrite::AddFile(std::string const& file, size_t skip,
                             char const* prefix)
{
  this->Error = "";
  // Skip the file if we have no name for it.  This may happen on a
  // top-level directory, which does not need to be included anyway.
  if (skip >= file.length()) {
    return true;
  }
  cm::string_view out = cm::string_view(file).substr(skip);

  // Meta-data.
  std::string dest = cmStrCat(prefix ? prefix : "", out);
  if (this->Verbose) {
    std::cout << dest << "\n";
  }
  Entry e;
  cm_archive_entry_copy_sourcepath(e, file);
  cm_archive_entry_copy_pathname(e, dest.c_str());
  if (archive_read_disk_entry_from_file(this->Disk, e, -1, nullptr) !=
      ARCHIVE_OK) {
    this->Error =
      cmStrCat("Unable to read from file:\n  ", file, "\nbecause:\n  ",
               cm_archive_error_string(this->Disk));
    return false;
  }
  if (!this->MTime.empty()) {
    time_t now;
    time(&now);
    time_t t = cm_parse_date(now, this->MTime.c_str());
    if (t == -1) {
      this->Error = cmStrCat("unable to parse mtime '", this->MTime, '\'');
      return false;
    }
    archive_entry_set_mtime(e, t, 0);
  } else {
    std::string source_date_epoch;
    cmSystemTools::GetEnv("SOURCE_DATE_EPOCH", source_date_epoch);
    if (!source_date_epoch.empty()) {
      std::istringstream iss(source_date_epoch);
      time_t epochTime;
      iss >> epochTime;
      if (iss.eof() && !iss.fail()) {
        // Set all of the file times to the epoch time to handle archive
        // formats that include creation/access time.
        archive_entry_set_mtime(e, epochTime, 0);
        archive_entry_set_atime(e, epochTime, 0);
        archive_entry_set_ctime(e, epochTime, 0);
        archive_entry_set_birthtime(e, epochTime, 0);
      }
    }
  }

  // manages the uid/guid of the entry (if any)
  if (this->Uid.IsSet() && this->Gid.IsSet()) {
    archive_entry_set_uid(e, this->Uid.Get());
    archive_entry_set_gid(e, this->Gid.Get());
  }

  if (!this->Uname.empty() && !this->Gname.empty()) {
    archive_entry_set_uname(e, this->Uname.c_str());
    archive_entry_set_gname(e, this->Gname.c_str());
  }

  // manages the permissions
  if (this->Permissions.IsSet()) {
    archive_entry_set_perm(e, this->Permissions.Get());
  }

  if (this->PermissionsMask.IsSet()) {
    int perm = archive_entry_perm(e);
    archive_entry_set_perm(e, perm & this->PermissionsMask.Get());
  }

  // Clear acl and xattr fields not useful for distribution.
  archive_entry_acl_clear(e);
  archive_entry_xattr_clear(e);
  archive_entry_set_fflags(e, 0, 0);

  if (this->Format == "pax" || this->Format == "paxr") {
    // Sparse files are a GNU tar extension.
    // Do not use them in standard tar files.
    archive_entry_sparse_clear(e);
  }

  if (archive_write_header(this->Archive, e) != ARCHIVE_OK) {
    this->Error = cmStrCat("archive_write_header: ",
                           cm_archive_error_string(this->Archive));
    return false;
  }

  // do not copy content of symlink
  if (!archive_entry_symlink(e)) {
    // Content.
    if (size_t size = static_cast<size_t>(archive_entry_size(e))) {
      return this->AddData(file, size);
    }
  }
  return true;
}

bool cmArchiveWrite::AddData(std::string const& file, size_t size)
{
  cmsys::ifstream fin(file.c_str(), std::ios::in | std::ios::binary);
  if (!fin) {
    this->Error = cmStrCat("Error opening \"", file,
                           "\": ", cmSystemTools::GetLastSystemError());
    return false;
  }

  char buffer[16384];
  size_t nleft = size;
  while (nleft > 0) {
    using ssize_type = std::streamsize;
    size_t const nnext = nleft > sizeof(buffer) ? sizeof(buffer) : nleft;
    ssize_type const nnext_s = static_cast<ssize_type>(nnext);
    fin.read(buffer, nnext_s);
    // Some stream libraries (older HPUX) return failure at end of
    // file on the last read even if some data were read.  Check
    // gcount instead of trusting the stream error status.
    if (static_cast<size_t>(fin.gcount()) != nnext) {
      break;
    }
    if (archive_write_data(this->Archive, buffer, nnext) != nnext_s) {
      this->Error = cmStrCat("archive_write_data: ",
                             cm_archive_error_string(this->Archive));
      return false;
    }
    nleft -= nnext;
  }
  if (nleft > 0) {
    this->Error = cmStrCat("Error reading \"", file,
                           "\": ", cmSystemTools::GetLastSystemError());
    return false;
  }
  return true;
}