magic.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2024 Oğuz Toraman <oguz.toraman@tutanota.com> */
/* SPDX-License-Identifier: LGPL-3.0-only */
 
#ifndef MAGIC_HPP
#define MAGIC_HPP
 
#include <map>
#include <bitset>
#include <vector>
#include <memory>
#include <expected>
 
#include <file_concepts.hpp>
#include <magic_exception.hpp>
 
namespace recognition {
 
class magic {
public:
 
    using flags_mask_t = std::bitset<30uz>;
 
    using file_type_t = std::string;
 
    using error_message_t = std::string;
 
    using expected_file_type_t = std::expected<file_type_t, error_message_t>;
 
    using types_of_files_t = std::map<std::filesystem::path, file_type_t>;
 
    using expected_types_of_files_t = std::map<std::filesystem::path, expected_file_type_t>;
 
    enum flags : unsigned long long {
        none              = 0ULL,       
        debug             = 1ULL << 0,  
        symlink           = 1ULL << 1,  
        compress          = 1ULL << 2,  
        devices           = 1ULL << 3,  
        mime_type         = 1ULL << 4,  
        continue_search   = 1ULL << 5,  
        check_database    = 1ULL << 6,  
        preserve_atime    = 1ULL << 7,  
        raw               = 1ULL << 8,  
        error             = 1ULL << 9,  
        mime_encoding     = 1ULL << 10, 
        mime              = 1ULL << 11, 
        apple             = 1ULL << 12, 
        extension         = 1ULL << 13, 
        compress_transp   = 1ULL << 14, 
        no_compress_fork  = 1ULL << 15, 
        nodesc            = 1ULL << 16, 
        no_check_compress = 1ULL << 17, 
        no_check_tar      = 1ULL << 18, 
        no_check_soft     = 1ULL << 19, 
        no_check_apptype  = 1ULL << 20, 
        no_check_elf      = 1ULL << 21, 
        no_check_text     = 1ULL << 22, 
        no_check_cdf      = 1ULL << 23, 
        no_check_csv      = 1ULL << 24, 
        no_check_tokens   = 1ULL << 25, 
        no_check_encoding = 1ULL << 26, 
        no_check_json     = 1ULL << 27, 
        no_check_simh     = 1ULL << 28, 
        no_check_builtin  = 1ULL << 29  
    };
 
    enum class parameters : std::size_t {
        indir_max      = 0uz, 
        name_max       = 1uz, 
        elf_phnum_max  = 2uz, 
        elf_shnum_max  = 3uz, 
        elf_notes_max  = 4uz, 
        regex_max      = 5uz, 
        bytes_max      = 6uz, 
        encoding_max   = 7uz, 
        elf_shsize_max = 8uz  
    };
 
    using flags_container_t = std::vector<flags>;
 
    using parameter_value_map_t = std::map<parameters, std::size_t>;
 
    static constexpr auto default_database_file = "/usr/share/misc/magic";
 
    magic() noexcept;
 
    explicit magic(flags_mask_t flags_mask, const std::filesystem::path& database_file = default_database_file);
 
    explicit magic(const flags_container_t& flags_container, const std::filesystem::path& database_file = default_database_file);
 
    magic(magic&& other) noexcept;
 
    magic(const magic&) = delete;
 
    magic& operator=(magic&& other) noexcept;
 
    magic& operator=(const magic&) = delete;
 
    ~magic();
 
    [[nodiscard]]
    operator bool() const noexcept;
 
    bool check(const std::filesystem::path& database_file = default_database_file) const noexcept;
 
    void close() noexcept;
 
    bool compile(const std::filesystem::path& database_file = default_database_file) const noexcept;
 
    [[nodiscard]]
    flags_container_t get_flags() const;
 
    [[nodiscard]]
    std::size_t get_parameter(parameters parameter) const;
 
    [[nodiscard]]
    parameter_value_map_t get_parameters() const;
 
    [[nodiscard]]
    static std::string get_version() noexcept;
 
    [[nodiscard]]
    file_type_t identify_file(const std::filesystem::path& path) const;
 
    [[nodiscard]]
    expected_file_type_t
        identify_file(const std::filesystem::path& path, std::nothrow_t) const noexcept;
 
    [[nodiscard]]
    types_of_files_t identify_files(
        const std::filesystem::path& directory,
        std::filesystem::directory_options option = std::filesystem::directory_options::follow_directory_symlink
    ) const
    {
        return identify_files_impl(
            std::filesystem::recursive_directory_iterator{directory, option}
        );
    }
 
    [[nodiscard]]
    expected_types_of_files_t identify_files(
        const std::filesystem::path& directory, std::nothrow_t,
        std::filesystem::directory_options option = std::filesystem::directory_options::follow_directory_symlink
    ) const noexcept
    {
        return identify_files_impl(
            std::filesystem::recursive_directory_iterator{directory, option},  std::nothrow
        );
    }
 
    [[nodiscard]]
    types_of_files_t identify_files(const file_concepts::file_container auto& files) const
    {
        return identify_files_impl(files);
    }
 
    [[nodiscard]]
    expected_types_of_files_t identify_files(
        const file_concepts::file_container auto& files, std::nothrow_t
    ) const noexcept
    {
        return identify_files_impl(files, std::nothrow);
    }
 
    [[nodiscard]]
    bool is_open() const noexcept;
 
    void load_database_file(const std::filesystem::path& database_file = default_database_file);
 
    void open(flags_mask_t flags_mask);
 
    void open(const flags_container_t& flags_container);
 
    void set_flags(flags_mask_t flags_mask);
 
    void set_flags(const flags_container_t& flags_container);
 
    void set_parameter(parameters parameter, std::size_t value);
 
    void set_parameters(const parameter_value_map_t& parameters);
 
private:
    class magic_private;
    std::unique_ptr<magic_private> m_impl;
 
    [[nodiscard]]
    types_of_files_t identify_files_impl(const std::ranges::range auto& files) const
    {
        types_of_files_t types_of_files;
        std::ranges::for_each(files,
            [&](const std::filesystem::path& file){
                types_of_files[file] = identify_file(file);
            }
        );
        return types_of_files;
    }
 
    [[nodiscard]]
    expected_types_of_files_t identify_files_impl(const std::ranges::range auto& files, std::nothrow_t) const noexcept
    {
        expected_types_of_files_t expected_types_of_files;
        std::ranges::for_each(files,
            [&](const std::filesystem::path& file){
                expected_types_of_files[file] = identify_file(file, std::nothrow);
            }
        );
        return expected_types_of_files;
    }
 
    friend std::string to_string(flags);
    friend std::string to_string(parameters);
};
 
[[nodiscard]]
std::string to_string(
    const magic::types_of_files_t& types_of_files,
    const std::string& type_separator = " -> ",
    const std::string& file_separator = "\n"
);
 
[[nodiscard]]
std::string to_string(const magic::expected_file_type_t& expected_file_type);
 
[[nodiscard]]
std::string to_string(
    const magic::expected_types_of_files_t& expected_types_of_files,
    const std::string& type_separator = " -> ",
    const std::string& file_separator = "\n"
);
 
[[nodiscard]]
std::string to_string(magic::flags flag);
 
[[nodiscard]]
std::string to_string(const magic::flags_container_t& flags, const std::string& separator = ", ");
 
[[nodiscard]]
std::string to_string(magic::parameters parameter);
 
[[nodiscard]]
std::string to_string(
    const magic::parameter_value_map_t& parameters,
    const std::string& value_separator = ": ",
    const std::string& parameter_separator = ", "
);
 
} /* namespace recognition */
 
#endif /* MAGIC_HPP */