460 lines
15 KiB
C++
460 lines
15 KiB
C++
/**
|
|
* @file ModuleLoader.cpp
|
|
* @brief Implementation of dynamic module loading and management for DPM
|
|
*
|
|
* Implements the ModuleLoader class methods for finding, loading, validating,
|
|
* and executing DPM modules. It handles the dynamic loading of shared objects
|
|
* and ensures they conform to the expected module interface.
|
|
*
|
|
* @copyright Copyright (c) 2025 SILO GROUP LLC
|
|
* @author Chris Punches <chris.punches@silogroup.org>
|
|
*
|
|
* Part of the Dark Horse Linux Package Manager (DPM)
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* For bug reports or contributions, please contact the dhlp-contributors
|
|
* mailing list at: https://lists.darkhorselinux.org/mailman/listinfo/dhlp-contributors
|
|
*/
|
|
|
|
#include "ModuleLoader.hpp"
|
|
|
|
namespace fs = std::filesystem;
|
|
|
|
// ModuleLoader constructor
|
|
ModuleLoader::ModuleLoader(std::string module_path)
|
|
{
|
|
try {
|
|
_module_path = fs::absolute(module_path).string();
|
|
if (!_module_path.empty() && _module_path.back() != '/') {
|
|
_module_path += '/';
|
|
}
|
|
} catch (const fs::filesystem_error&) {
|
|
_module_path = module_path;
|
|
if (!_module_path.empty() && _module_path.back() != '/') {
|
|
_module_path += '/';
|
|
}
|
|
}
|
|
}
|
|
|
|
// getter for module path
|
|
DPMErrorCategory ModuleLoader::get_module_path(std::string& path) const
|
|
{
|
|
path = _module_path;
|
|
return DPMErrorCategory::SUCCESS;
|
|
}
|
|
|
|
// Helper method to check module path validity
|
|
DPMErrorCategory ModuleLoader::check_module_path() const
|
|
{
|
|
// Verify the path exists and get its properties
|
|
struct stat path_stat;
|
|
if (stat(_module_path.c_str(), &path_stat) != 0) {
|
|
// Check errno to determine the specific error
|
|
switch (errno) {
|
|
case ENOENT:
|
|
return DPMErrorCategory::PATH_NOT_FOUND;
|
|
case EACCES:
|
|
return DPMErrorCategory::PERMISSION_DENIED;
|
|
case ENAMETOOLONG:
|
|
return DPMErrorCategory::PATH_TOO_LONG;
|
|
case ENOTDIR:
|
|
// This happens when a component of the path prefix isn't a directory
|
|
return DPMErrorCategory::PATH_NOT_DIRECTORY;
|
|
default:
|
|
return DPMErrorCategory::UNDEFINED_ERROR;
|
|
}
|
|
}
|
|
|
|
// At this point stat() succeeded, now check if the final path component is a directory
|
|
if (!S_ISDIR(path_stat.st_mode)) {
|
|
return DPMErrorCategory::PATH_NOT_DIRECTORY;
|
|
}
|
|
|
|
// Check read permissions using the stat results
|
|
if ((path_stat.st_mode & S_IRUSR) == 0) {
|
|
return DPMErrorCategory::PERMISSION_DENIED;
|
|
}
|
|
|
|
return DPMErrorCategory::SUCCESS;
|
|
}
|
|
|
|
DPMErrorCategory ModuleLoader::list_available_modules(std::vector<std::string>& modules) const
|
|
{
|
|
// ensure we start with an empty vector
|
|
modules.clear();
|
|
|
|
// Check module path using the helper method
|
|
DPMErrorCategory path_check = check_module_path();
|
|
if (path_check != DPMErrorCategory::SUCCESS) {
|
|
return path_check;
|
|
}
|
|
|
|
// prepare to iterate the directory
|
|
DIR* dir = opendir(_module_path.c_str());
|
|
if (!dir) {
|
|
// Check errno to determine the cause of the failure
|
|
switch (errno) {
|
|
case EACCES:
|
|
return DPMErrorCategory::PERMISSION_DENIED;
|
|
case ENOENT:
|
|
return DPMErrorCategory::PATH_NOT_FOUND;
|
|
case ENOTDIR:
|
|
return DPMErrorCategory::PATH_NOT_DIRECTORY;
|
|
default:
|
|
return DPMErrorCategory::UNDEFINED_ERROR;
|
|
}
|
|
}
|
|
|
|
// read each entry
|
|
struct dirent* entry;
|
|
while ((entry = readdir(dir)) != NULL) {
|
|
// skip . and ..
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
|
|
continue;
|
|
}
|
|
|
|
// build the full path
|
|
std::string full_path = _module_path + entry->d_name;
|
|
|
|
// verify it's a file or a symlink
|
|
struct stat st;
|
|
if (stat(full_path.c_str(), &st) == -1) {
|
|
continue;
|
|
}
|
|
|
|
// Skip if not a regular file or a symlink
|
|
if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
|
|
continue;
|
|
}
|
|
|
|
// get length of filename for boundary checking
|
|
size_t name_len = strlen(entry->d_name);
|
|
|
|
// skip if filename too short to be .so
|
|
if (name_len <= 3) {
|
|
continue;
|
|
}
|
|
|
|
// verify file ends in .so
|
|
if (strcmp(entry->d_name + name_len - 3, ".so") != 0) {
|
|
continue;
|
|
}
|
|
|
|
// calculate the module name length
|
|
size_t module_name_len = name_len - 3;
|
|
|
|
// create space for the module name
|
|
char * module_name = (char*) malloc(module_name_len + 1);
|
|
if (!module_name) {
|
|
closedir(dir);
|
|
return DPMErrorCategory::UNDEFINED_ERROR;
|
|
}
|
|
|
|
// copy the name without .so
|
|
strncpy(module_name, entry->d_name, module_name_len);
|
|
module_name[module_name_len] = '\0';
|
|
|
|
// add to our list
|
|
modules.push_back(std::string(module_name));
|
|
|
|
// clean up
|
|
free(module_name);
|
|
}
|
|
|
|
// clean up
|
|
closedir(dir);
|
|
|
|
return DPMErrorCategory::SUCCESS;
|
|
}
|
|
|
|
DPMErrorCategory ModuleLoader::load_module(const std::string& module_name, void*& module_handle) const
|
|
{
|
|
// First check if the module exists in the list of available modules
|
|
std::vector<std::string> available_modules;
|
|
DPMErrorCategory list_error = list_available_modules( available_modules );
|
|
|
|
// if there was a listing error, return that
|
|
if ( list_error != DPMErrorCategory::SUCCESS ) {
|
|
return list_error;
|
|
}
|
|
|
|
// Check if the requested module is in the list of available modules
|
|
bool module_found = false;
|
|
for ( size_t i = 0; i < available_modules.size(); i++ ) {
|
|
if ( available_modules[i] == module_name ) {
|
|
module_found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if the supplied module isn't in the list of available modules, return the error
|
|
if ( !module_found ) {
|
|
return DPMErrorCategory::MODULE_NOT_FOUND;
|
|
}
|
|
|
|
// construct the path to load the module from based on supplied identifier
|
|
// DPM uses whatever the file name is
|
|
std::string module_so_path = _module_path + module_name + ".so";
|
|
|
|
// go ahead and open the module
|
|
module_handle = dlopen(module_so_path.c_str(), RTLD_LAZY);
|
|
if (!module_handle) {
|
|
return DPMErrorCategory::MODULE_LOAD_FAILED;
|
|
}
|
|
|
|
// if there was a loading error, return that
|
|
const char * load_error = dlerror();
|
|
if ( load_error != nullptr ) {
|
|
return DPMErrorCategory::MODULE_LOAD_FAILED;
|
|
}
|
|
|
|
// validate the module's exposed API
|
|
// return an error if it's not up to spec
|
|
std::vector<std::string> missing_symbols;
|
|
DPMErrorCategory validate_error = validate_module_interface( module_handle, missing_symbols );
|
|
if ( validate_error != DPMErrorCategory::SUCCESS ) {
|
|
// we failed to validate the interface, so close the module handle since we won't use it
|
|
dlclose( module_handle );
|
|
return validate_error;
|
|
}
|
|
|
|
// return what's going to be a success
|
|
return validate_error;
|
|
}
|
|
|
|
DPMErrorCategory ModuleLoader::execute_module(const std::string& module_name, const std::string& command) const {
|
|
// declare a module_handle
|
|
void * module_handle;
|
|
|
|
// attempt to load the module
|
|
DPMErrorCategory load_error = load_module(module_name, module_handle);
|
|
if (load_error != DPMErrorCategory::SUCCESS) {
|
|
return load_error;
|
|
}
|
|
|
|
// Clear any previous error state and handle any residual failure
|
|
const char* pre_error = dlerror();
|
|
if (pre_error != nullptr) {
|
|
dlclose(module_handle);
|
|
return DPMErrorCategory::UNDEFINED_ERROR;
|
|
}
|
|
|
|
// declare a function pointer type to hold the module symbol to execute
|
|
typedef int (*ExecuteFn) (const char*, int, char** );
|
|
|
|
// populate that void pointer to the execute symbol in the module with
|
|
ExecuteFn execute_fn = (ExecuteFn) dlsym(module_handle, "dpm_module_execute");
|
|
|
|
// do basic error handling to detect if the symbol look up was successful
|
|
const char * dlsym_error = dlerror();
|
|
if (dlsym_error != nullptr) {
|
|
dlclose(module_handle);
|
|
return DPMErrorCategory::SYMBOL_NOT_FOUND;
|
|
}
|
|
|
|
// check if the void pointer was populated
|
|
if (execute_fn == nullptr) {
|
|
dlclose(module_handle);
|
|
return DPMErrorCategory::SYMBOL_NOT_FOUND;
|
|
}
|
|
|
|
// Split the command by spaces to get arguments
|
|
std::vector<std::string> args;
|
|
std::string arg;
|
|
std::istringstream iss(command);
|
|
while (iss >> arg) {
|
|
args.push_back(arg);
|
|
}
|
|
|
|
// Create argc and argv for all arguments
|
|
int argc = args.size();
|
|
char** argv = new char*[argc];
|
|
for (int i = 0; i < argc; i++) {
|
|
argv[i] = strdup(args[i].c_str());
|
|
}
|
|
|
|
// Get the first argument as the command (or empty string if no arguments)
|
|
const char* cmd = "";
|
|
if (!args.empty()) {
|
|
cmd = args[0].c_str();
|
|
}
|
|
|
|
// execute the function with all arguments
|
|
int exec_error = execute_fn(cmd, argc, argv);
|
|
|
|
// Clean up
|
|
for (int i = 0; i < argc; i++) {
|
|
free(argv[i]);
|
|
}
|
|
delete[] argv;
|
|
|
|
// irregardless of result, this is the time to close the module handle
|
|
dlclose(module_handle);
|
|
|
|
// if the result of execution was not 0, return an error
|
|
if (exec_error != 0) {
|
|
return DPMErrorCategory::SYMBOL_EXECUTION_FAILED;
|
|
}
|
|
|
|
// if we made it here, assume it was successful
|
|
return DPMErrorCategory::SUCCESS;
|
|
}
|
|
|
|
DPMErrorCategory ModuleLoader::get_module_version( void * module_handle, std::string& version ) const
|
|
{
|
|
// validate that the module is even loaded
|
|
if ( !module_handle ) {
|
|
version = "DPM ERROR";
|
|
return DPMErrorCategory::MODULE_NOT_LOADED;
|
|
}
|
|
|
|
// Clear any previous error state and handle any residual failure
|
|
const char* pre_error = dlerror();
|
|
if ( pre_error != nullptr ) {
|
|
version = pre_error;
|
|
return DPMErrorCategory::UNDEFINED_ERROR;
|
|
}
|
|
|
|
// declare a function pointer type to hold the module symbol to execute
|
|
typedef const char * (* VersionFn)();
|
|
|
|
// populate that void pointer to execute the symbol in the module with
|
|
VersionFn version_fn = (VersionFn) dlsym( module_handle, "dpm_module_get_version" );
|
|
|
|
// Check for errors from dlsym
|
|
const char* error = dlerror();
|
|
if (error != nullptr) {
|
|
version = error;
|
|
return DPMErrorCategory::SYMBOL_NOT_FOUND;
|
|
}
|
|
|
|
// check if the void pointer was populated
|
|
if ( version_fn == nullptr ) {
|
|
version = "ERROR";
|
|
return DPMErrorCategory::SYMBOL_NOT_FOUND;
|
|
}
|
|
|
|
// execute the loaded symbol
|
|
const char * ver = version_fn();
|
|
|
|
// check the return, and throw an error if it's a null value
|
|
if ( ver == nullptr ) {
|
|
version = "MODULE ERROR";
|
|
return DPMErrorCategory::INVALID_MODULE;
|
|
}
|
|
|
|
// Set the version string with the result
|
|
version = ver;
|
|
|
|
// if you made it here, assume success
|
|
return DPMErrorCategory::SUCCESS;
|
|
}
|
|
|
|
DPMErrorCategory ModuleLoader::get_module_description( void * module_handle, std::string& description ) const
|
|
{
|
|
// validate that the module is even loaded
|
|
if (!module_handle) {
|
|
description = "DPM ERROR";
|
|
return DPMErrorCategory::MODULE_NOT_LOADED;
|
|
}
|
|
|
|
// Clear any previous error state and handle any residual failure
|
|
const char* pre_error = dlerror();
|
|
if ( pre_error != nullptr ) {
|
|
description = pre_error;
|
|
return DPMErrorCategory::UNDEFINED_ERROR;
|
|
}
|
|
|
|
// declare a function pointer type to hold the module symbol to execute
|
|
typedef const char * (* DescriptionFn)();
|
|
|
|
// populate that void pointer to execute the symbol in the module with
|
|
DescriptionFn description_fn = (DescriptionFn) dlsym( module_handle, "dpm_get_description" );
|
|
|
|
// check for errors from dlsym
|
|
const char * error = dlerror();
|
|
if ( error != nullptr ) {
|
|
description = "ERROR";
|
|
return DPMErrorCategory::SYMBOL_NOT_FOUND;
|
|
}
|
|
|
|
// check if the void pointer was populated
|
|
if ( description_fn == nullptr ) {
|
|
description = "ERROR";
|
|
return DPMErrorCategory::INVALID_MODULE;
|
|
}
|
|
|
|
// execute the loaded symbol
|
|
const char* desc = description_fn();
|
|
|
|
// check the return, and throw an error if it's a null value
|
|
if ( desc == nullptr ) {
|
|
description = "MODULE ERROR";
|
|
return DPMErrorCategory::INVALID_MODULE;
|
|
}
|
|
|
|
// Set the description string with the result
|
|
description = desc;
|
|
|
|
// if you made it here, assume success
|
|
return DPMErrorCategory::SUCCESS;
|
|
}
|
|
|
|
DPMErrorCategory ModuleLoader::validate_module_interface( void* module_handle, std::vector<std::string>& missing_symbols ) const
|
|
{
|
|
// validate that the module is even loaded
|
|
if ( !module_handle ) {
|
|
return DPMErrorCategory::MODULE_NOT_LOADED;
|
|
}
|
|
|
|
// ensure our starting point of missing symbols is empty
|
|
missing_symbols.clear();
|
|
|
|
// get the size of the loop (should be equal to the number of required symbols)
|
|
size_t num_symbols = module_interface::required_symbols.size();
|
|
|
|
// check for any residual lingering errors
|
|
const char * pre_error = dlerror();
|
|
if ( pre_error != nullptr ) {
|
|
return DPMErrorCategory::UNDEFINED_ERROR;
|
|
}
|
|
|
|
// declare a function pointer type to hold the module symbol to execute
|
|
typedef const char * (* ModuleInterfaceFn)();
|
|
|
|
// iterate through self.required_symbols
|
|
for ( size_t i = 0; i < num_symbols; i++ ) {
|
|
|
|
// attempt to load each required symbol
|
|
ModuleInterfaceFn loaded_required_symbol = (ModuleInterfaceFn) dlsym( module_handle, module_interface::required_symbols[i].c_str() );
|
|
|
|
// check for an error from dlsym
|
|
const char * dlsym_error = dlerror();
|
|
if (dlsym_error != nullptr) {
|
|
// if nullptr, it didn't load, so assume it's missing
|
|
missing_symbols.push_back(module_interface::required_symbols[i]);
|
|
}
|
|
|
|
}
|
|
|
|
// if there are no missing symbols, return successfully -- the module has a valid API
|
|
if ( missing_symbols.empty() ) {
|
|
return DPMErrorCategory::SUCCESS;
|
|
}
|
|
|
|
// if not successful, the module's API is invalid and return the appropriate error code
|
|
return DPMErrorCategory::INVALID_MODULE;
|
|
}
|