assembly.hpp

#pragma once
 
#include <string>
#include <vector>
#include <filesystem>
#include <plugify/load_flag.hpp>
#include <plugify/mem_addr.hpp>
#include <plugify_export.h>
 
namespace plugify {
    class Assembly {
    public:
        struct Section {
            Section() : size{0} {}
 
            Section(std::string_view sectionName, uintptr_t sectionBase, size_t sectionSize)
                : name(sectionName), base{sectionBase}, size{sectionSize} {}
 
            operator bool() const noexcept { return base; }
 
            std::string name{}; 
            MemAddr base;       
            size_t size;        
        };
 
        struct Handle {
            Handle(void* systemHandle) : handle{systemHandle} {}
 
            operator bool() const noexcept { return handle; }
 
            operator void*() const noexcept { return handle; }
 
            void* handle{}; 
        };
 
        Assembly() : _handle{nullptr} {}
 
        ~Assembly();
 
        // Delete copy constructor and copy assignment operator.
        Assembly(const Assembly&) = delete;
        Assembly& operator=(const Assembly&) = delete;
        //Assembly& operator=(const Assembly&) && = delete;
 
        // Delete move constructor and move assignment operator.
        Assembly(Assembly&& rhs) noexcept = delete;
        Assembly& operator=(Assembly&& rhs) noexcept = delete;
        //Assembly& operator=(Assembly&&) && = delete;
 
        using SearchDirs = std::vector<std::filesystem::path>;
 
        explicit Assembly(std::string_view moduleName, LoadFlag flags = LoadFlag::Default, const SearchDirs& additionalSearchDirectories = {}, bool sections = false);
 
        explicit Assembly(const char* moduleName, LoadFlag flags = LoadFlag::Default, const SearchDirs& additionalSearchDirectories = {}, bool sections = false)
            : Assembly(std::string_view(moduleName), flags, additionalSearchDirectories, sections) {}
 
        explicit Assembly(const std::string& moduleName, LoadFlag flags = LoadFlag::Default, const SearchDirs& additionalSearchDirectories = {}, bool sections = false)
            : Assembly(std::string_view(moduleName), flags, additionalSearchDirectories, sections) {}
 
        explicit Assembly(const std::filesystem::path& modulePath, LoadFlag flags = LoadFlag::Default, const SearchDirs& additionalSearchDirectories = {}, bool sections = false);
 
        explicit Assembly(MemAddr moduleMemory, LoadFlag flags = LoadFlag::Default, const SearchDirs& additionalSearchDirectories = {}, bool sections = false);
 
        explicit Assembly(Handle moduleHandle, LoadFlag flags = LoadFlag::Default, const SearchDirs& additionalSearchDirectories = {}, bool sections = false);
 
        static std::pair<std::vector<uint8_t>, std::string> PatternToMaskedBytes(std::string_view input);
 
        MemAddr FindPattern(MemAddr pattern, std::string_view mask, MemAddr startAddress = nullptr, const Section * moduleSection = nullptr) const;
 
        MemAddr FindPattern(std::string_view pattern, MemAddr startAddress = nullptr, Section* moduleSection = nullptr) const;
 
        MemAddr GetVirtualTableByName(std::string_view tableName, bool decorated = false) const;
 
        MemAddr GetFunctionByName(std::string_view functionName) const noexcept;
 
        Section GetSectionByName(std::string_view sectionName) const noexcept;
 
        void* GetHandle() const noexcept;
 
        MemAddr GetBase() const noexcept;
 
        const std::filesystem::path& GetPath() const noexcept;
 
        const std::string& GetError() const noexcept;
 
        bool IsValid() const noexcept { return _handle != nullptr; }
 
        explicit operator bool() const noexcept { return _handle != nullptr; }
 
        bool operator==(const Assembly& assembly) const noexcept { return _handle == assembly._handle; }
 
    private:
        bool Init(std::filesystem::path modulePath, LoadFlag flags, const SearchDirs& additionalSearchDirectories, bool sections);
 
        bool InitFromName(std::string_view moduleName, LoadFlag flags, const SearchDirs& additionalSearchDirectories, bool sections, bool extension = false);
 
        bool InitFromMemory(MemAddr moduleMemory, LoadFlag flags, const SearchDirs& additionalSearchDirectories, bool sections);
 
        bool InitFromHandle(Handle moduleHandle, LoadFlag flags, const SearchDirs& additionalSearchDirectories, bool sections);
 
        bool LoadSections();
 
    private:
        void* _handle;                
        std::filesystem::path _path;  
        std::string _error;           
        Section _executableCode;      
        std::vector<Section> _sections; 
    };
 
    int TranslateLoading(LoadFlag flags) noexcept;
 
    LoadFlag TranslateLoading(int flags) noexcept;
 
} // namespace plugify