TarReader.h

#include <zlib.h>
#include <NDEVR/File.h>
#include <filesystem>
#include <fstream>
#include <string>
#include <vector>
#include <cstdint>
#include <cstring>
#include <system_error>
#include <chrono>
 
namespace fs = std::filesystem;
namespace NDEVR
{
    class TAR
    {
    public:
        using u8 = unsigned char;
        using u32 = uint32_t;
        using u64 = uint64_t;

        struct Reader {
            virtual ~Reader() {}

            virtual bool read_exact(u8* dst, size_t n) = 0;

            virtual bool eof() const = 0;
        };

        struct FileReader final : Reader {
            std::ifstream f; 

            explicit FileReader(const std::string& p) : f(p, std::ios::binary) {}

            bool read_exact(u8* dst, size_t n) override {
                f.read(reinterpret_cast<char*>(dst), std::streamsize(n));
                return bool(f);
            }

            bool eof() const override { return f.eof(); }
        };

        struct GzReader final : Reader {
            gzFile g = nullptr; 

            explicit GzReader(const std::string& p) { g = gzopen(p.c_str(), "rb"); gzbuffer(g, 1 << 20); }

            ~GzReader() override { if (g) gzclose(g); }

            bool read_exact(u8* dst, size_t n) override {
                size_t got = 0;
                while (got < n) {
                    int r = gzread(g, dst + got, unsigned(n - got));
                    if (r <= 0) return false;
                    got += size_t(r);
                }
                return true;
            }

            bool eof() const override { return gzeof(g) != 0; }
        };

        static inline bool starts_with(const fs::path& a, const fs::path& base) {
            auto A = fs::weakly_canonical(a);
            auto B = fs::weakly_canonical(base);
            auto ar = A.begin(), br = B.begin();
            for (; br != B.end(); ++br, ++ar) {
                if (ar == A.end() || *ar != *br) return false;
            }
            return true;
        }

        static inline bool all_zero(const u8* p, size_t n) {
            for (size_t i = 0; i < n; ++i) if (p[i] != 0) return false;
            return true;
        }

        static inline u64 parse_octal(const char* p, size_t n) {
            u64 v = 0;
            size_t i = 0;
            while (i < n && (p[i] == ' ' || p[i] == '\t' || p[i] == '\0')) ++i;
            for (; i < n; ++i) {
                if (p[i] < '0' || p[i] > '7') break;
                v = (v << 3) + u64(p[i] - '0');
            }
            return v;
        }

        static inline u64 tar_checksum(const u8* h) {
            u64 s = 0;
            for (size_t i = 0; i < 512; ++i) {
                if (i >= 148 && i < 156) s += 32;
                else s += h[i];
            }
            return s;
        }

        struct TarHdr {
            char name[100];     
            char mode[8];       
            char uid[8];        
            char gid[8];        
            char size[12];      
            char mtime[12];     
            char chksum[8];     
            char typeflag;      
            char linkname[100]; 
            char magic[6];      
            char version[2];    
            char uname[32];     
            char gname[32];     
            char devmajor[8];   
            char devminor[8];   
            char prefix[155];   
            char pad[12];       
        };

        static inline std::string hdr_name(const TarHdr& h) {
            std::string n;
            if (h.prefix[0]) {
                n.assign(h.prefix, strnlen(h.prefix, sizeof(h.prefix)));
                n.push_back('/');
                n.append(h.name, strnlen(h.name, sizeof(h.name)));
            }
            else {
                n.assign(h.name, strnlen(h.name, sizeof(h.name)));
            }
            return n;
        }

        static inline bool valid_hdr(const u8* blk) {
            const TarHdr& h = *reinterpret_cast<const TarHdr*>(blk);
            u64 chk = parse_octal(h.chksum, sizeof(h.chksum));
            return chk == tar_checksum(blk);
        }

        static inline std::string read_pax_string(const std::string& rec) {
            return rec;
        }

        static inline void apply_mode(const fs::path& p, u64 mode) {
            std::error_code ec;
            fs::perms perm = fs::perms::none;
            if (mode & 0400) perm |= fs::perms::owner_read;
            if (mode & 0200) perm |= fs::perms::owner_write;
            if (mode & 0100) perm |= fs::perms::owner_exec;
            if (mode & 0040) perm |= fs::perms::group_read;
            if (mode & 0020) perm |= fs::perms::group_write;
            if (mode & 0010) perm |= fs::perms::group_exec;
            if (mode & 0004) perm |= fs::perms::others_read;
            if (mode & 0002) perm |= fs::perms::others_write;
            if (mode & 0001) perm |= fs::perms::others_exec;
            fs::permissions(p, perm, fs::perm_options::replace, ec);
        }

        static inline void apply_mtime(const fs::path& p, u64 mtime) {
            std::error_code ec;
            auto tp = std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(mtime));
            auto ftime = fs::file_time_type::clock::now() + (tp - std::chrono::system_clock::now());
            fs::last_write_time(p, ftime, ec);
        }

        static inline bool read_block(Reader& r, u8* buf) {
            return r.read_exact(buf, 512);
        }

        static inline bool skip_bytes(Reader& r, u64 n, std::vector<u8>& tmp) {
            tmp.resize(size_t(std::min<u64>(n, 1 << 20)));
            u64 left = n;
            while (left) {
                size_t chunk = size_t(std::min<u64>(left, tmp.size()));
                if (!r.read_exact(tmp.data(), chunk)) return false;
                left -= chunk;
            }
            return true;
        }

        static int Extract(const File& src, const File& dest)
        {
            std::error_code ec;
            fs::create_directories(dest.c_str(), ec);
            if (ec) return -1;
 
            std::ifstream probe(src.c_str(), std::ios::binary);
            if (!probe) return -2;
            unsigned char sig[2] = { 0,0 };
            probe.read(reinterpret_cast<char*>(sig), 2);
            probe.close();
 
            std::unique_ptr<Reader> rd;
            if (sig[0] == 0x1F && sig[1] == 0x8B) rd = std::make_unique<GzReader>(src.c_str());
            else rd = std::make_unique<FileReader>(src.c_str());
 
            if (auto* gr = dynamic_cast<GzReader*>(rd.get()); gr && !gr->g) return -3;
            if (auto* fr = dynamic_cast<FileReader*>(rd.get()); fr && !fr->f) return -3;
 
            fs::path base = fs::absolute(dest.c_str());
            std::vector<u8> block(512), tmp;
            std::string pax_path, pax_linkpath, gnu_longname, gnu_longlink;
 
            for (;;) {
                if (!read_block(*rd, block.data())) return -4;
                if (all_zero(block.data(), 512)) {
                    if (!read_block(*rd, block.data())) return 0;
                    if (all_zero(block.data(), 512)) return 0;
                }
                if (!valid_hdr(block.data())) return -5;
 
                const TarHdr& h = *reinterpret_cast<const TarHdr*>(block.data());
                u64 size = parse_octal(h.size, sizeof(h.size));
                u64 mode = parse_octal(h.mode, sizeof(h.mode));
                u64 mtime = parse_octal(h.mtime, sizeof(h.mtime));
                char type = h.typeflag ? h.typeflag : '0';
 
                std::string name = hdr_name(h);
                if (!gnu_longname.empty()) { name = gnu_longname; gnu_longname.clear(); }
                if (!pax_path.empty()) { name = pax_path; pax_path.clear(); }
 
                std::string linkname;
                if (h.linkname[0]) linkname.assign(h.linkname, strnlen(h.linkname, sizeof(h.linkname)));
                if (!gnu_longlink.empty()) { linkname = gnu_longlink; gnu_longlink.clear(); }
                if (!pax_linkpath.empty()) { linkname = pax_linkpath; pax_linkpath.clear(); }
 
                if (!std::strncmp(h.magic, "ustar", 5)) {}
 
                if (type == 'x') {
                    std::string pax;
                    pax.resize(size_t(size));
                    if (size) {
                        tmp.resize(size_t(size));
                        if (!rd->read_exact(tmp.data(), size_t(size))) return -6;
                        pax.assign(reinterpret_cast<char*>(tmp.data()), pax.size());
                    }
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -6;
                    size_t i = 0;
                    while (i < pax.size()) {
                        size_t j = pax.find('\n', i);
                        if (j == std::string::npos) break;
                        std::string line = pax.substr(i, j - i);
                        size_t sp = line.find(' ');
                        if (sp != std::string::npos) {
                            std::string kv = line.substr(sp + 1);
                            if (kv.rfind("path=", 0) == 0) pax_path = kv.substr(5);
                            else if (kv.rfind("linkpath=", 0) == 0) pax_linkpath = kv.substr(9);
                        }
                        i = j + 1;
                    }
                    continue;
                }
 
                if (type == 'g') {
                    if (size) {
                        if (!skip_bytes(*rd, size, tmp)) return -7;
                    }
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -7;
                    continue;
                }
 
                if (type == 'L') {
                    if (size == 0) continue;
                    tmp.resize(size_t(size));
                    if (!rd->read_exact(tmp.data(), size_t(size))) return -8;
                    gnu_longname.assign(reinterpret_cast<char*>(tmp.data()), size_t(size));
                    while (!gnu_longname.empty() && (gnu_longname.back() == '\0' || gnu_longname.back() == '\n')) gnu_longname.pop_back();
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -8;
                    continue;
                }
 
                if (type == 'K') {
                    if (size == 0) continue;
                    tmp.resize(size_t(size));
                    if (!rd->read_exact(tmp.data(), size_t(size))) return -9;
                    gnu_longlink.assign(reinterpret_cast<char*>(tmp.data()), size_t(size));
                    while (!gnu_longlink.empty() && (gnu_longlink.back() == '\0' || gnu_longlink.back() == '\n')) gnu_longlink.pop_back();
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -9;
                    continue;
                }
 
                fs::path out = fs::absolute(base / fs::path(name).lexically_normal());
                if (!starts_with(out, base)) {
                    u64 skip = size + ((512 - (size % 512)) % 512);
                    if (skip && !skip_bytes(*rd, skip, tmp)) return -10;
                    continue;
                }
 
                switch (type) {
                case '0':
                case '\0':
                case '7': {
                    fs::create_directories(out.parent_path(), ec);
                    std::ofstream of(out, std::ios::binary | std::ios::trunc);
                    if (!of) return -11;
                    u64 left = size;
                    tmp.resize(size_t(std::min<u64>(left, 1 << 20)));
                    while (left) {
                        size_t chunk = size_t(std::min<u64>(left, tmp.size()));
                        if (!rd->read_exact(tmp.data(), chunk)) return -12;
                        of.write(reinterpret_cast<char*>(tmp.data()), std::streamsize(chunk));
                        if (!of) return -12;
                        left -= chunk;
                    }
                    of.flush();
                    apply_mode(out, mode & 0777);
                    apply_mtime(out, mtime);
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -12;
                } break;
                case '5': {
                    fs::create_directories(out, ec);
                    apply_mode(out, mode & 0777);
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -13;
                } break;
                case '2': {
                    fs::create_directories(out.parent_path(), ec);
                    std::error_code sec;
                    fs::remove(out, sec);
                    if (!linkname.empty()) {
                        std::error_code lec;
                        fs::create_symlink(linkname, out, lec);
                    }
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -14;
                } break;
                case '1': {
                    fs::create_directories(out.parent_path(), ec);
                    if (!linkname.empty()) {
                        std::error_code hec;
                        if (fs::exists(base / linkname)) fs::create_hard_link(base / linkname, out, hec);
                    }
                    u64 pad = (512 - (size % 512)) % 512;
                    if (pad && !skip_bytes(*rd, pad, tmp)) return -15;
                } break;
                default: {
                    u64 pad_all = size + ((512 - (size % 512)) % 512);
                    if (pad_all && !skip_bytes(*rd, pad_all, tmp)) return -16;
                } break;
                }
            }
        }
    };
 
} // class ndv_tar