| /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying |
| file Copyright.txt or https://cmake.org/licensing for details. */ |
| #include "cmArchiveWrite.h" |
| |
| #include <cstring> |
| #include <ctime> |
| #include <iostream> |
| #include <sstream> |
| |
| #include "cmsys/Directory.hxx" |
| #include "cmsys/Encoding.hxx" |
| #include "cmsys/FStream.hxx" |
| |
| #include "cm_get_date.h" |
| #include "cm_libarchive.h" |
| |
| #include "cmLocale.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) |
| { |
| const char* e = archive_error_string(a); |
| return e ? e : "unknown error"; |
| } |
| |
| static void cm_archive_entry_copy_pathname(struct archive_entry* e, |
| const std::string& dest) |
| { |
| #if cmsys_STL_HAS_WSTRING |
| archive_entry_copy_pathname_w(e, cmsys::Encoding::ToWide(dest).c_str()); |
| #else |
| archive_entry_copy_pathname(e, dest.c_str()); |
| #endif |
| } |
| |
| static void cm_archive_entry_copy_sourcepath(struct archive_entry* e, |
| const std::string& file) |
| { |
| #if cmsys_STL_HAS_WSTRING |
| 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(const Entry&) = delete; |
| Entry& operator=(const Entry&) = delete; |
| operator struct archive_entry*() { return this->Object; } |
| }; |
| |
| struct cmArchiveWrite::Callback |
| { |
| // archive_write_callback |
| static __LA_SSIZE_T Write(struct archive* /*unused*/, void* cd, |
| const void* b, size_t n) |
| { |
| cmArchiveWrite* self = static_cast<cmArchiveWrite*>(cd); |
| if (self->Stream.write(static_cast<const char*>(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) |
| : Stream(os) |
| , Archive(archive_write_new()) |
| , Disk(archive_read_disk_new()) |
| , Verbose(false) |
| , Format(format) |
| { |
| 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; |
| } |
| 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; |
| } |
| break; |
| } |
| #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 |
| |
| 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; |
| } |
| |
| // 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; |
| } |
| |
| 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; |
| } |
| } |
| |
| cmArchiveWrite::~cmArchiveWrite() |
| { |
| archive_read_free(this->Disk); |
| archive_write_free(this->Archive); |
| } |
| |
| bool cmArchiveWrite::Add(std::string path, size_t skip, const char* prefix, |
| bool recursive) |
| { |
| if (!path.empty() && path.back() == '/') { |
| path.erase(path.size() - 1); |
| } |
| this->AddPath(path.c_str(), skip, prefix, recursive); |
| return this->Okay(); |
| } |
| |
| bool cmArchiveWrite::AddPath(const char* path, size_t skip, const char* prefix, |
| bool recursive) |
| { |
| if (strcmp(path, ".") != 0 || |
| (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) { |
| const char* file = d.GetFile(i); |
| if (strcmp(file, ".") != 0 && strcmp(file, "..") != 0) { |
| next.erase(end); |
| next += file; |
| if (!this->AddPath(next.c_str(), skip, prefix)) { |
| return false; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| bool cmArchiveWrite::AddFile(const char* file, size_t skip, const char* 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 >= strlen(file)) { |
| return true; |
| } |
| const char* out = file + skip; |
| |
| cmLocaleRAII localeRAII; |
| static_cast<void>(localeRAII); |
| |
| // 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); |
| if (archive_read_disk_entry_from_file(this->Disk, e, -1, nullptr) != |
| ARCHIVE_OK) { |
| this->Error = cmStrCat("Unable to read from file '", file, |
| "': ", cm_archive_error_string(this->Disk)); |
| return false; |
| } |
| if (!this->MTime.empty()) { |
| time_t now; |
| time(&now); |
| time_t t = cm_get_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()) { |
| archive_entry_set_mtime(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(const char* file, size_t size) |
| { |
| cmsys::ifstream fin(file, 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; |
| } |
