UT_Archive.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_Archive.h
 *
 * COMMENTS:
 *
 */

#ifndef __UT_ARCHIVE_H__
#define __UT_ARCHIVE_H__

#include "UT_API.h"

#include "UT_NonCopyable.h"
#include "UT_SharedPtr.h"
#include "UT_UniquePtr.h"
#include "UT_StringHolder.h"
#if defined(WIN32)
        #include "UT_NTUtil.h"
#endif

#include <SYS/SYS_Compiler.h>

struct archive_entry;
struct archive;

class UT_ArchiveReader;
class UT_WorkBuffer;

class UT_API UT_Archive
{
public:
    static const int OK;
    static const int WARN;
    static const int FATAL;
    static const int EXTRACT_ACL;
    static const int EXTRACT_CLEAR_NOCHANGE_FFLAGS;
    static const int EXTRACT_MAC_METADATA;
    static const int EXTRACT_TIME;
    static const int EXTRACT_XATTR;
};

class UT_API UT_ArchiveEntry
{
public:
    int64_t gid() const;
    int64_t uid() const;
    int64_t size() const;
    int64_t ino64() const;
    mode_t fileType() const;

    UT_StringHolder gname() const;
    UT_StringHolder hardlink() const;
    UT_StringHolder pathname() const;
    UT_StringHolder symlink() const;
    UT_StringHolder uname() const;

    void setGid(int64_t gid);
    void setUid(int64_t uid);
    void setSize(int64_t size);
    void setIno64(int64_t ino);

    void setGName(const char* gname);
    void setHardlink(const char* hardlink);
    void setPathname(const char* pathname);
    void setSymlink(const char* symlink);
    void setUName(const char* uname);
    void setMTime(time_t t, int64_t v);

    bool operator==(const UT_ArchiveEntry& entry) const
    {
        return myEntry == entry.myEntry;
    }
    bool operator!=(const UT_ArchiveEntry& entry) const
    {
        return !(*this == entry);
    }
    explicit operator bool() const
    {
        return myEntry != nullptr;
    }
private:
    friend class UT_ArchiveReader;

    UT_ArchiveEntry(archive_entry* entry);

    UT_SharedPtr<archive_entry> myEntry;
};

class UT_API UT_ArchiveReader
{
private:
    UT_ArchiveReader();
public:
    ~UT_ArchiveReader() = default;
    UT_NON_COPYABLE(UT_ArchiveReader)

    // Movable but non-copyable
    UT_ArchiveReader(UT_ArchiveReader&& a) :
        myArchive(std::move(a.myArchive))
    {}
    UT_ArchiveReader& operator=(UT_ArchiveReader&& a)
    {
        myArchive = std::move(a.myArchive);
        return *this;
    }

    enum class format
    {
        _ALL,
        _ZIP,
        _RAR,
        _TAR,
        _RAW,
        _7ZIP,
        _AR,
        _CAB,
        _CPIO,
        _ISO9660,
        _LHA,
        _MTREE,
        _XAR
    };
    enum class filter
    {
        _NONE,
        _ALL,
        _BZIP2,
        _COMPRESS,
        _GZIP,
        _LZIP,
        _LZMA,
        _XZ,
        _UU,
        _RPM,
        _LRZIP,
        _LZOP,
        _GRZIP
    };

    /// Deleter for smart pointers
    struct UT_API Deleter
    {
        void operator()(archive* a);
    };

    class UT_API iterator
    {
    public:
        iterator(UT_ArchiveReader* reader, const UT_ArchiveEntry& entry)
            : myReader(reader), myEntry(entry)
        {
        }

        bool operator==(const iterator& other) const
        {
            return myEntry == other.myEntry;
        }
        bool operator!=(const iterator& other) const
        {
            return !(*this == other);
        }

        UT_ArchiveEntry operator*() { return myEntry; }

        iterator& operator++()
        {
            myEntry = myReader->nextEntry();
            return *this;
        }

    private:
        UT_ArchiveReader* myReader;
        UT_ArchiveEntry myEntry;
    };

    /// @{
    /// Begin and end iterator suitable for iterating over the entries in the
    /// archive.
    iterator begin() { return iterator(this, nextEntry()); }
    iterator end() { return iterator(this, nullptr); }
    /// @}

    /// @{
    /// Create an archive ready for reading.
    template <format FORMAT = format::_ALL, filter FILTER = filter::_ALL>
    SYS_NO_DISCARD_RESULT static UT_ArchiveReader create(
            const char* filename,
            size_t block_size)
    {
        UT_ArchiveReader a;
        a.initFormat<FORMAT>();
        a.initFilter<FILTER>();
        a.openFile(filename, block_size);
        return a;
    }
    template <format FORMAT = format::_ALL, filter FILTER = filter::_ALL>
    SYS_NO_DISCARD_RESULT static UT_ArchiveReader createW(
            const wchar_t* filename,
            size_t block_size)
    {
        UT_ArchiveReader a;
        a.initFormat<FORMAT>();
        a.initFilter<FILTER>();
        a.openFileW(filename, block_size);
        return a;
    }
    /// @}

    /// Get the next entry in the archive.
    SYS_NO_DISCARD_RESULT UT_ArchiveEntry nextEntry();

    /// True if the archive can continue to be used.
    SYS_NO_DISCARD_RESULT bool isValid() const;
    explicit operator bool() const { return isValid(); }

    /// Get the current error string for the archive.
    SYS_NO_DISCARD_RESULT UT_StringHolder errorString() const;

    /// Skip the current entry.
    int readSkip();
    /// Read the contents of the entry into the workbuffer.
    int read(UT_ArchiveEntry& entry, UT_WorkBuffer& data);
    /// Extract the entry from the archive.
    int extract(UT_ArchiveEntry& entry, int flags);

    /// Helper to read a specific file from an archive file
    static bool readFile(
            const char* filename,
            const UT_StringHolder& pathname,
            UT_WorkBuffer& data)
    {
        UT_ArchiveReader reader(create(filename, 1240));
        if (!reader)
            return false;

        for (auto&& e : reader)
        {
            if (e.pathname() != pathname)
                continue;

            int r = reader.read(e, data);
            return r > 0;
        }
        return false;
    }

    /// @{
    /// Init the format and filter for the archive. In most cases create()
    /// should be used in favour of these functions.
    template <format FORMAT>
    void initFormat();
    template <filter FILTER>
    void initFilter();
    /// @}

    /// @{
    /// Open an archive file. These functions are only used if extra
    /// functionality is required. create() should be used in most cases.
    int openFileW(const wchar_t* filename, size_t block_size);
    int openFile(const char* filename, size_t block_size);
    /// @}

private:
    UT_UniquePtr<archive, Deleter> myArchive;
};

#endif // __UT_ARCHIVE_H__