moving some loading functionality to dpmdk

dpmdk/include/CommonModuleAPI.hpp

@@ -31,6 +31,8 @@
 
 #include <iostream>
 #include <string>
+#include <sys/stat.h>
+#include <dlfcn.h>
 
 /**
  * @brief Fatal log level constant
@@ -161,6 +163,59 @@ extern "C" {
      * @return The module path
      */
     const char* dpm_get_module_path(void);
+
+    /**
+     * @brief Checks if a module exists
+     *
+     * Verifies if a module exists at the configured module path.
+     *
+     * @param module_name Name of the module to check
+     * @return true if the module exists, false otherwise
+     */
+    bool dpm_module_exists(const char* module_name);
+
+    /**
+     * @brief Loads a DPM module
+     *
+     * Attempts to load a module from the configured module path.
+     *
+     * @param module_name Name of the module to load
+     * @param module_handle Pointer to store the loaded module handle
+     * @return 0 on success, non-zero on failure
+     */
+    int dpm_load_module(const char* module_name, void** module_handle);
+
+    /**
+     * @brief Checks if a symbol exists in a module
+     *
+     * Verifies if a specific symbol exists in a loaded module.
+     *
+     * @param module_handle Handle to a loaded module
+     * @param symbol_name Name of the symbol to check
+     * @return true if the symbol exists, false otherwise
+     */
+    bool dpm_symbol_exists(void* module_handle, const char* symbol_name);
+
+    /**
+     * @brief Executes a symbol in a module
+     *
+     * Attempts to execute a function in a loaded module.
+     *
+     * @param module_handle Handle to a loaded module
+     * @param symbol_name Name of the symbol to execute
+     * @param args Arguments to pass to the function
+     * @return 0 on success, non-zero on failure
+     */
+    int dpm_execute_symbol(void* module_handle, const char* symbol_name, void* args);
+
+    /**
+     * @brief Unloads a module
+     *
+     * Frees resources used by a loaded module.
+     *
+     * @param module_handle Handle to a loaded module
+     */
+    void dpm_unload_module(void* module_handle);
 }
 
 /**

dpmdk/include/StandaloneModuleImpl.hpp

@@ -33,6 +33,8 @@
 #include <iostream>
 #include <string>
 #include <cstdlib>
+#include <sys/stat.h>
+#include <dlfcn.h>
 
 // All implementations must be inline to prevent multiple definition errors when included in multiple files
 /**
@@ -93,10 +95,102 @@ inline void dpm_set_logging_level(int level) {
  */
 inline const char* dpm_get_module_path(void) {
     // Get from environment variable or use default
-    const char* env_path = getenv("DPM_MODULE_PATH");
+    const char* env_path = dpm_get_config("modules", "modules_path");
     return env_path ? env_path : "/usr/lib/dpm/modules/";
 }
 
+/**
+ * @brief Standalone implementation of dpm_module_exists
+ */
+inline bool dpm_module_exists(const char* module_name) {
+    if (!module_name) return false;
+
+    // Get the module path
+    const char* module_path = dpm_get_module_path();
+    if (!module_path) return false;
+
+    // Build path to the module
+    std::string module_file = std::string(module_path) + "/" + module_name + ".so";
+
+    // Check if file exists
+    struct stat buffer;
+    return (stat(module_file.c_str(), &buffer) == 0);
+}
+
+/**
+ * @brief Standalone implementation of dpm_load_module
+ */
+inline int dpm_load_module(const char* module_name, void** module_handle) {
+    if (!module_name || !module_handle) return 1;
+
+    // Get the module path
+    const char* module_path = dpm_get_module_path();
+    if (!module_path) return 1;
+
+    // Build path to the module
+    std::string module_file = std::string(module_path) + "/" + module_name + ".so";
+
+    // Check if the file exists
+    if (!dpm_module_exists(module_name)) return 1;
+
+    // Load the module
+    *module_handle = dlopen(module_file.c_str(), RTLD_LAZY);
+    if (!*module_handle) return 1;
+
+    return 0;
+}
+
+/**
+ * @brief Standalone implementation of dpm_symbol_exists
+ */
+inline bool dpm_symbol_exists(void* module_handle, const char* symbol_name) {
+    if (!module_handle || !symbol_name) return false;
+
+    // Clear any error
+    dlerror();
+
+    // Look up the symbol
+    void* symbol = dlsym(module_handle, symbol_name);
+
+    // Check for errors
+    const char* error = dlerror();
+    if (error) return false;
+
+    return (symbol != NULL);
+}
+
+/**
+ * @brief Standalone implementation of dpm_execute_symbol
+ */
+inline int dpm_execute_symbol(void* module_handle, const char* symbol_name, void* args) {
+    if (!module_handle || !symbol_name) return 1;
+
+    // Clear any error
+    dlerror();
+
+    // Look up the symbol
+    void* symbol = dlsym(module_handle, symbol_name);
+
+    // Check for errors
+    const char* error = dlerror();
+    if (error || !symbol) return 1;
+
+    // Cast to function pointer and call
+    typedef int (*FunctionPtr)(void*);
+    FunctionPtr func = (FunctionPtr)symbol;
+
+    return func(args);
+}
+
+/**
+ * @brief Standalone implementation of dpm_unload_module
+ */
+inline void dpm_unload_module(void* module_handle) {
+    if (module_handle) {
+        dlclose(module_handle);
+    }
+}
+
 /**
  * @brief Standalone module main function
  *

dpmdk/src/CommonModuleAPI.cpp

@@ -1,11 +1,9 @@
 /**
 * @file CommonModuleAPI.cpp
- * @brief Implementation stub for DPM module interface
+ * @brief Implementation for DPMDK functions
  *
- * This file serves primarily as a documentation reference for the module
- * interface. The actual implementations of dpm_get_config and dpm_log are
- * provided by the DPM core, while dpm_module_execute, dpm_module_get_version,
- * and dpm_get_description must be implemented by each module.
+ * Implements the module utility functions provided by the DPMDK library
+ * for module interoperability and loading.
  *
  * @copyright Copyright (c) 2025 SILO GROUP LLC
  * @author Chris Punches <chris.punches@silogroup.org>
@@ -28,5 +26,86 @@
  * For bug reports or contributions, please contact the dhlp-contributors
  * mailing list at: https://lists.darkhorselinux.org/mailman/listinfo/dhlp-contributors
  */
-
 #include "CommonModuleAPI.hpp"
+
+// Only define these functions when not in standalone mode
+#ifndef BUILD_STANDALONE
+
+extern "C" bool dpm_module_exists(const char* module_name) {
+    if (!module_name) return false;
+
+    // Get the module path
+    const char* module_path = dpm_get_module_path();
+    if (!module_path) return false;
+
+    // Build path to the module
+    std::string module_file = std::string(module_path) + "/" + module_name + ".so";
+
+    // Check if file exists
+    struct stat buffer;
+    return (stat(module_file.c_str(), &buffer) == 0);
+}
+
+extern "C" int dpm_load_module(const char* module_name, void** module_handle) {
+    if (!module_name || !module_handle) return 1;
+
+    // Get the module path
+    const char* module_path = dpm_get_module_path();
+    if (!module_path) return 1;
+
+    // Build path to the module
+    std::string module_file = std::string(module_path) + "/" + module_name + ".so";
+
+    // Check if the file exists
+    if (!dpm_module_exists(module_name)) return 1;
+
+    // Load the module
+    *module_handle = dlopen(module_file.c_str(), RTLD_LAZY);
+    if (!*module_handle) return 1;
+
+    return 0;
+}
+
+extern "C" bool dpm_symbol_exists(void* module_handle, const char* symbol_name) {
+    if (!module_handle || !symbol_name) return false;
+
+    // Clear any error
+    dlerror();
+
+    // Look up the symbol
+    void* symbol = dlsym(module_handle, symbol_name);
+
+    // Check for errors
+    const char* error = dlerror();
+    if (error) return false;
+
+    return (symbol != NULL);
+}
+
+extern "C" int dpm_execute_symbol(void* module_handle, const char* symbol_name, void* args) {
+    if (!module_handle || !symbol_name) return 1;
+
+    // Clear any error
+    dlerror();
+
+    // Look up the symbol
+    void* symbol = dlsym(module_handle, symbol_name);
+
+    // Check for errors
+    const char* error = dlerror();
+    if (error || !symbol) return 1;
+
+    // Cast to function pointer and call
+    typedef int (*FunctionPtr)(void*);
+    FunctionPtr func = (FunctionPtr)symbol;
+
+    return func(args);
+}
+
+extern "C" void dpm_unload_module(void* module_handle) {
+    if (module_handle) {
+        dlclose(module_handle);
+    }
+}
+
+#endif // BUILD_STANDALONE