#pragma once #include #include #include #include #include #include #include #include #include #include namespace hex::prv { /** * @brief Represent the data source for a tab in the UI */ class Provider { public: struct Description { std::string name; std::string value; }; struct MenuEntry { std::string name; std::function callback; }; constexpr static size_t MaxPageSize = 0x1000'0000; Provider(); virtual ~Provider(); /** * @brief Opens this provider * @note The return value of this function allows to ensure the provider is available, * so calling Provider::isAvailable() just after a call to open() that returned true is redundant. * @note This is not related to the EventProviderOpened event * @return true if the provider was opened successfully, else false */ [[nodiscard]] virtual bool open() = 0; /** * @brief Closes this provider * @note This function is called when the user requests for a provider to be closed, e.g. by closing a tab. * In general, this function should close the underlying data source but leave the provider in a state where * it can be opened again later by calling the open() function again. */ virtual void close() = 0; /** * @brief Checks if this provider is open and can be used to access data * @return Generally, if the open() function succeeded and the data source was successfully opened, this * function should return true */ [[nodiscard]] virtual bool isAvailable() const = 0; /** * @brief Checks if the data in this provider can be read * @return True if the provider is readable, false otherwise */ [[nodiscard]] virtual bool isReadable() const = 0; /** * @brief Controls if the user can write data to this specific provider. * This may be false for e.g. a file opened in read-only */ [[nodiscard]] virtual bool isWritable() const = 0; /** * @brief Controls if the user can resize this provider * @return True if the provider is resizable, false otherwise */ [[nodiscard]] virtual bool isResizable() const = 0; /** * @brief Controls whether the provider can be saved ("saved", not "saved as") * This is mainly used by providers that aren't buffered, and so don't need to be saved * This function will usually return false for providers that aren't writable, but this isn't guaranted */ [[nodiscard]] virtual bool isSavable() const = 0; /** * @brief Controls whether we can dump data from this provider (e.g. "save as", or "export -> .."). * Typically disabled for process with sparse data, like the Process memory provider * where the virtual address space is several TiBs large. * Default implementation returns true. */ [[nodiscard]] virtual bool isDumpable() const; /** * @brief Controls whether this provider can be saved as a recent entry * Typically used for providers that do not retain data, e.g. the memory provider */ [[nodiscard]] virtual bool isSavableAsRecent() const { return true; } /** * @brief Read data from this provider, applying overlays and patches * @param offset offset to start reading the data * @param buffer buffer to write read data * @param size number of bytes to read * @param overlays apply overlays and patches is true. Same as readRaw() if false */ virtual void read(u64 offset, void *buffer, size_t size, bool overlays = true); /** * @brief Write data to the patches of this provider. Will not directly modify provider. * @param offset offset to start writing the data * @param buffer buffer to take data to write from * @param size number of bytes to write */ virtual void write(u64 offset, const void *buffer, size_t size); /** * @brief Read data from this provider, without applying overlays and patches * @param offset offset to start reading the data * @param buffer buffer to write read data * @param size number of bytes to read */ virtual void readRaw(u64 offset, void *buffer, size_t size) = 0; /** * @brief Write data directly to this provider * @param offset offset to start writing the data * @param buffer buffer to take data to write from * @param size number of bytes to write */ virtual void writeRaw(u64 offset, const void *buffer, size_t size) = 0; /** * @brief Get the full size of the data in this provider * @return The size of the entire available data of this provider */ [[nodiscard]] virtual size_t getActualSize() const = 0; /** * @brief Gets the type name of this provider * @note This is mainly used to be stored in project files and recents to be able to later on * recreate this exact provider type. This needs to be unique across all providers, this is usually something * like "hex.builtin.provider.memory" or "hex.builtin.provider.file" * @return The provider's type name */ [[nodiscard]] virtual std::string getTypeName() const = 0; /** * @brief Gets a human readable representation of the current provider * @note This is mainly used to display the provider in the UI. For example, the file provider * will return the file name here * @return The name of the current provider */ [[nodiscard]] virtual std::string getName() const = 0; virtual void resize(size_t newSize); virtual void insert(u64 offset, size_t size); virtual void remove(u64 offset, size_t size); virtual void save(); virtual void saveAs(const std::fs::path &path); void applyOverlays(u64 offset, void *buffer, size_t size) const; [[nodiscard]] std::map &getPatches(); [[nodiscard]] const std::map &getPatches() const; void applyPatches(); [[nodiscard]] Overlay *newOverlay(); void deleteOverlay(Overlay *overlay); [[nodiscard]] const std::list> &getOverlays(); [[nodiscard]] size_t getPageSize() const; void setPageSize(size_t pageSize); [[nodiscard]] u32 getPageCount() const; [[nodiscard]] u32 getCurrentPage() const; void setCurrentPage(u32 page); virtual void setBaseAddress(u64 address); [[nodiscard]] virtual u64 getBaseAddress() const; [[nodiscard]] virtual u64 getCurrentPageAddress() const; [[nodiscard]] virtual size_t getSize() const; [[nodiscard]] virtual std::optional getPageOfAddress(u64 address) const; [[nodiscard]] virtual std::vector getDataDescription() const; [[nodiscard]] virtual std::variant queryInformation(const std::string &category, const std::string &argument); void addPatch(u64 offset, const void *buffer, size_t size, bool createUndo = false); void createUndoPoint(); void undo(); void redo(); [[nodiscard]] bool canUndo() const; [[nodiscard]] bool canRedo() const; [[nodiscard]] virtual bool hasFilePicker() const; virtual bool handleFilePicker(); virtual std::vector getMenuEntries() { return { }; } [[nodiscard]] virtual bool hasLoadInterface() const; [[nodiscard]] virtual bool hasInterface() const; virtual bool drawLoadInterface(); virtual void drawInterface(); [[nodiscard]] u32 getID() const; void setID(u32 id); [[nodiscard]] virtual nlohmann::json storeSettings(nlohmann::json settings = { }) const; virtual void loadSettings(const nlohmann::json &settings); void markDirty(bool dirty = true) { this->m_dirty = dirty; } [[nodiscard]] bool isDirty() const { return this->m_dirty; } [[nodiscard]] virtual std::pair getRegionValidity(u64 address) const; void skipLoadInterface() { this->m_skipLoadInterface = true; } [[nodiscard]] bool shouldSkipLoadInterface() const { return this->m_skipLoadInterface; } void setErrorMessage(const std::string &errorMessage) { this->m_errorMessage = errorMessage; } [[nodiscard]] const std::string& getErrorMessage() const { return this->m_errorMessage; } protected: u32 m_currPage = 0; u64 m_baseAddress = 0; std::list> m_patches; decltype(m_patches)::iterator m_currPatches; std::list> m_overlays; u32 m_id; /** * @brief true if there is any data that needs to be saved */ bool m_dirty = false; /** * @brief Control whetever to skip provider initialization * initialization may be asking the user for information related to the provider, * e.g. a process ID for the process memory provider * this is used mainly when restoring a provider with already known initialization information * for example when loading a project or loading a provider from the "recent" lsit * */ bool m_skipLoadInterface = false; std::string m_errorMessage; size_t m_pageSize = MaxPageSize; }; }