magic.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2025 Oğuz Toraman <oguz.toraman@tutanota.com> */
/* SPDX-License-Identifier: LGPL-3.0-only */
 
#ifndef MAGIC_HPP
#define MAGIC_HPP
 
#include <algorithm>
#include <bitset>
#include <expected>
#include <map>
#include <memory>
#include <string_view>
#include <vector>
 
#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 {
        /* clang-format off */
        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  
        /* clang-format on */
    };
 
    enum class parameters : std::size_t {
        /* clang-format off */
        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, 
        mag_warn_max   = 9uz  
        /* clang-format on */
    };
 
    using flags_container_t = std::vector<flags>;
 
    using parameter_value_map_t = std::map<parameters, std::size_t>;
 
    static std::string_view default_database_file;
 
    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 */