LibArchive.h

/*
 * Copyright (C) 2026 Yury Bobylev <bobilev_yury@mail.ru>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
#ifndef LIBARCHIVE_H
#define LIBARCHIVE_H
 
#include <LibArchiveFileData.h>
#include <MLBookProc.h>
#include <archive.h>
#include <filesystem>
#include <istream>
#include <memory>
#include <string>
#include <vector>

class LibArchive
{
public:
  LibArchive(const std::shared_ptr<MLBookProc> &mlbp);
 
  virtual ~LibArchive();

  void
  listFilesInArchive(
      const std::filesystem::path &archive_path,
      std::vector<std::tuple<std::string, uint64_t, uint64_t>> &result);

  void
  listFilesInArchiveBuffer(
      const std::string &buffer,
      std::vector<std::tuple<std::string, uint64_t, uint64_t>> &result);

  void
  listFilesInZip(
      const std::filesystem::path &archive_path,
      std::vector<std::tuple<std::string, uint64_t, uint64_t>> &result);

  void
  listFilesInZipBuffer(
      const std::string &buffer,
      std::vector<std::tuple<std::string, uint64_t, uint64_t>> &result);

  std::filesystem::path
  unpackFileToDirectory(const std::filesystem::path &archive_path,
                        const std::string &filename,
                        const std::filesystem::path &directory,
                        const size_t &offset = size_t(0));

  std::filesystem::path
  unpackBufferFileToDirectory(const std::string &buffer,
                              const std::string &filename,
                              const std::filesystem::path &directory,
                              const size_t &offset = size_t(0));

  std::filesystem::path
  unpackZipFileToDirectory(const std::filesystem::path &archive_path,
                           const std::string &filename,
                           const std::filesystem::path &directory);

  std::filesystem::path
  unpackZipBufferFileToDirectory(const std::string &buffer,
                                 const std::string &filename,
                                 const std::filesystem::path &directory);

  std::string
  unpackFileToBuffer(const std::filesystem::path &archive_path,
                     const std::string &filename,
                     const size_t &offset = size_t(0));

  std::string
  unpackBufferFileToBuffer(const std::string &buffer,
                           const std::string &filename,
                           const size_t &offset = size_t(0));

  std::string
  unpackZipFileToBuffer(const std::filesystem::path &archive_path,
                        const std::string &filename);

  std::string
  unpackZipBufferFileToBuffer(const std::string &buffer,
                              const std::string &filename);

  void
  writeToArchive(const std::filesystem::path &source_object,
                 const std::filesystem::path &archive_path,
                 std::string name_in_archive,
                 const std::filesystem::perms &perms
                 = std::filesystem::perms::none,
                 const bool &overwrite_existing = true);

  void
  writeBufferObjectToArchive(const std::string &buffer,
                             const std::filesystem::path &archive_path,
                             std::string name_in_archive,
                             const std::filesystem::perms &perms,
                             const bool &overwrite_existing);
 
protected:
  std::shared_ptr<archive>
  initForReading(const std::shared_ptr<LibArchiveFileData> &fd);

  std::shared_ptr<archive>
  initForWriting(const std::shared_ptr<LibArchiveFileData> &fd);

  void
  archiveError(const std::shared_ptr<archive> &a, const std::string &message);

  static int
  openCallBack(archive *a, void *client_data);

  static la_ssize_t
  readCallBack(archive *a, void *client_data, const void **buffer);

  static la_int64_t
  skipCallback(archive *a, void *client_data, la_int64_t request);

  static int
  closeCallback(archive *a, void *client_data);

  static la_int64_t
  seekCallback(archive *a, void *client_data, la_int64_t offset, int whence);

  static la_ssize_t
  writeCallback(archive *a, void *client_data, const void *buffer,
                size_t length);

  std::filesystem::path
  unpackToDirectory(std::shared_ptr<LibArchiveFileData> fd,
                    const std::string &filename,
                    const std::filesystem::path &directory);

  void
  unpackToBuffer(std::shared_ptr<LibArchiveFileData> fd,
                 const std::string &filename, std::string &result);

  void
  unpackEntryToDirectory(std::shared_ptr<archive> a,
                         std::shared_ptr<archive_entry> e,
                         const std::filesystem::path &file_path);

  std::string
  unpackEntryToBuffer(std::shared_ptr<archive> a,
                      std::shared_ptr<archive_entry> e);

  void
  writeFile(std::shared_ptr<archive> a, const std::filesystem::path &path,
            std::string name_in_archive, const std::filesystem::perms &perms);

  void
  writeBufferToArchive(std::shared_ptr<archive> a,
                       std::shared_ptr<archive_entry> e,
                       const std::string &buf);

  std::filesystem::perms
  getPermissionsFromEntry(const std::shared_ptr<archive_entry> &e);

  void
  setUsernameGroupname(std::shared_ptr<archive_entry> e);

  std::shared_ptr<MLBookProc> mlbp;
 
private:
  void
  getCentralDirectory(std::shared_ptr<std::istream> f, const uint64_t &fsz,
                      std::string &result);
 
  std::tuple<uint64_t, uint64_t>
  parseEOCDRecord(std::shared_ptr<std::istream> f, const uint64_t &fsz);
 
  std::tuple<uint64_t, uint64_t>
  parseEOCDRecordZip64(std::shared_ptr<std::istream> f, const uint64_t &fsz,
                       const uint64_t &eocd_record_size);
 
  void
  parseCentralDirectory(
      const std::string &central_directory,
      std::vector<std::tuple<std::string, uint64_t, uint64_t>> &result);
 
  void
  parseExtraField(const std::string &extra, uint64_t &compressed_sz,
                  uint64_t &offset, const int &mask);
 
  std::vector<std::tuple<std::filesystem::path, std::filesystem::path>>
  symlinkWriteResolver(const std::filesystem::path &relative,
                       const std::filesystem::path &symlink);
 
  bool
  getUTFfilename(const std::string &extra_field, const std::string &crc_sum,
                 std::string &filename);
 
  std::string
  crc32Sum(unsigned char *buf, size_t len);
 
  int ZIP64_UNCOMPRESSED = 1;
  int ZIP64_COMPRESSED = 2;
  int ZIP64_OFFSET = 4;
};
 
#endif // LIBARCHIVE_H