uselib 函数详解

1. 函数介绍

uselib 是Linux系统调用，用于将指定的共享库加载到调用进程的地址空间中。它允许程序动态加载和使用共享库，而无需在编译时链接这些库。这个函数主要用于实现动态库加载和插件系统。

2. 函数原型

#include <unistd.h>
int uselib(const char *library);

3. 功能

uselib 将指定路径的共享库文件加载到当前进程的地址空间中，使得库中的符号可以在运行时被解析和使用。它主要用于动态加载共享库，支持构建灵活的插件架构和模块化应用程序。

4. 参数

• *const char library: 指向共享库文件路径的字符串指针

5. 返回值

• 成功: 返回0
• 失败: 返回-1，并设置errno

6. 相似函数，或关联函数

• dlopen/dlsym/dlclose: 更现代的动态库加载接口
• mmap: 内存映射文件
• ld.so: 动态链接器
• RTLD_*: 动态加载标志

7. 示例代码

示例1：基础uselib使用

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <sys/stat.h>
#include <fcntl.h>

/**
 * 演示基础uselib使用方法
 */
int demo_uselib_basic() {
    const char *library_path = "/lib/x86_64-linux-gnu/libc.so.6";  // 系统C库
    int result;
    
    printf("=== 基础uselib使用示例 ===\n");
    
    // 显示当前系统信息
    printf("系统信息:\n");
    system("uname -a");
    printf("\n");
    
    // 检查库文件是否存在
    printf("1. 检查库文件:\n");
    printf("   库文件路径: %s\n", library_path);
    
    struct stat st;
    if (stat(library_path, &st) == 0) {
        printf("   ✓ 文件存在\n");
        printf("   文件大小: %ld 字节\n", st.st_size);
        printf("   文件权限: %o\n", st.st_mode & 0777);
    } else {
        printf("   ✗ 文件不存在: %s\n", strerror(errno));
        printf("   注意：不同系统的库路径可能不同\n");
        return 0;  // 不返回错误，因为这是演示
    }
    
    // 尝试使用uselib加载库
    printf("\n2. 使用uselib加载库:\n");
    printf("   调用: uselib(\"%s\")\n", library_path);
    
    result = uselib(library_path);
    if (result == 0) {
        printf("   ✓ 库加载成功\n");
        
        // 验证库是否真的被加载
        printf("   验证库加载状态:\n");
        
        // 尝试使用dlopen检查库是否可用
        void *handle = dlopen(library_path, RTLD_LAZY | RTLD_NOLOAD);
        if (handle) {
            printf("   ✓ 通过dlopen验证库已加载\n");
            dlclose(handle);
        } else {
            printf("   ℹ uselib可能只是标记库为已加载\n");
        }
        
    } else {
        printf("   ✗ 库加载失败: %s\n", strerror(errno));
        if (errno == ENOENT) {
            printf("   原因：文件不存在\n");
        } else if (errno == EACCES) {
            printf("   原因：权限不足\n");
        } else if (errno == ENOEXEC) {
            printf("   原因：文件不是有效的可执行文件\n");
        } else if (errno == EPERM) {
            printf("   原因：操作被禁止（可能已过时）\n");
        }
    }
    
    // 演示加载不存在的库
    printf("\n3. 演示加载不存在的库:\n");
    const char *nonexistent_lib = "/nonexistent/library.so";
    printf("   尝试加载: %s\n", nonexistent_lib);
    
    result = uselib(nonexistent_lib);
    if (result == -1) {
        printf("   ✓ 预期失败: %s\n", strerror(errno));
        if (errno == ENOENT) {
            printf("   正确：文件不存在\n");
        }
    } else {
        printf("   ✗ 意外成功\n");
    }
    
    // 显示uselib的历史和现状
    printf("\n4. uselib状态说明:\n");
    printf("   历史作用：早期Linux用于动态加载共享库\n");
    printf("   当前状态：在现代Linux中已被弃用\n");
    printf("   替代方案：使用dlopen/dlsym等现代接口\n");
    printf("   兼容性：某些系统可能仍支持，但不推荐使用\n");
    
    return 0;
}

int main() {
    return demo_uselib_basic();
}

示例2：现代动态库加载对比

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <sys/stat.h>
#include <unistd.h>

/**
 * 现代动态库加载演示
 */
int demo_modern_dl_loading() {
    const char *system_lib = "/lib/x86_64-linux-gnu/libc.so.6";
    const char *math_lib = "/lib/x86_64-linux-gnu/libm.so.6";
    
    printf("=== 现代动态库加载对比演示 ===\n");
    
    // 1. 使用dlopen加载系统库
    printf("1. 使用dlopen加载系统库:\n");
    printf("   加载目标: %s\n", system_lib);
    
    void *libc_handle = dlopen(system_lib, RTLD_LAZY);
    if (libc_handle) {
        printf("   ✓ dlopen加载成功\n");
        
        // 获取函数符号
        void *(*malloc_func)(size_t) = dlsym(libc_handle, "malloc");
        if (malloc_func) {
            printf("   ✓ 成功获取malloc函数地址: %p\n", malloc_func);
            
            // 测试函数调用
            void *ptr = malloc_func(1024);
            if (ptr) {
                printf("   ✓ malloc函数调用成功\n");
                void (*free_func)(void*) = dlsym(libc_handle, "free");
                if (free_func) {
                    free_func(ptr);
                    printf("   ✓ free函数调用成功\n");
                }
            }
        } else {
            printf("   ✗ 获取malloc函数失败: %s\n", dlerror());
        }
        
        // 不立即关闭，继续使用
    } else {
        printf("   ✗ dlopen加载失败: %s\n", dlerror());
    }
    
    // 2. 加载数学库
    printf("\n2. 加载数学库:\n");
    printf("   加载目标: %s\n", math_lib);
    
    void *libm_handle = dlopen(math_lib, RTLD_LAZY);
    if (libm_handle) {
        printf("   ✓ 数学库加载成功\n");
        
        // 获取sin函数
        double (*sin_func)(double) = dlsym(libm_handle, "sin");
        if (sin_func) {
            printf("   ✓ 成功获取sin函数地址: %p\n", sin_func);
            
            // 测试函数调用
            double result = sin_func(3.14159 / 2);  // sin(π/2) ≈ 1
            printf("   ✓ sin(π/2) = %.6f\n", result);
        } else {
            printf("   ✗ 获取sin函数失败: %s\n", dlerror());
        }
    } else {
        printf("   ✗ 数学库加载失败: %s\n", dlerror());
    }
    
    // 3. 错误处理演示
    printf("\n3. 错误处理演示:\n");
    printf("   尝试加载不存在的库:\n");
    
    void *bad_handle = dlopen("/nonexistent/badlib.so", RTLD_LAZY);
    if (bad_handle) {
        printf("   ✗ 意外成功加载不存在的库\n");
        dlclose(bad_handle);
    } else {
        printf("   ✓ 正确处理不存在的库: %s\n", dlerror());
    }
    
    // 4. 符号查找演示
    printf("\n4. 符号查找演示:\n");
    
    // 在libc中查找各种函数
    const char *functions[] = {"printf", "strlen", "memcpy", "memset", NULL};
    
    for (int i = 0; functions[i]; i++) {
        void *func_addr = dlsym(libc_handle, functions[i]);
        if (func_addr) {
            printf("   %s: %p\n", functions[i], func_addr);
        } else {
            printf("   %s: 未找到 (%s)\n", functions[i], dlerror());
        }
    }
    
    // 5. 库信息显示
    printf("\n5. 加载的库信息:\n");
    
    if (libc_handle) {
        // 获取库信息（注意：这不是标准的dlinfo）
        printf("   C库句柄: %p\n", libc_handle);
        
        // 显示库引用计数（伪代码，实际需要更复杂的实现）
        printf("   C库已加载\n");
    }
    
    if (libm_handle) {
        printf("   数学库句柄: %p\n", libm_handle);
        printf("   数学库已加载\n");
    }
    
    // 6. 清理资源
    printf("\n6. 清理资源:\n");
    
    if (libc_handle) {
        if (dlclose(libc_handle) == 0) {
            printf("   ✓ C库句柄关闭成功\n");
        } else {
            printf("   ✗ C库句柄关闭失败: %s\n", dlerror());
        }
    }
    
    if (libm_handle) {
        if (dlclose(libm_handle) == 0) {
            printf("   ✓ 数学库句柄关闭成功\n");
        } else {
            printf("   ✗ 数学库句柄关闭失败: %s\n", dlerror());
        }
    }
    
    // 7. 显示现代动态加载的优势
    printf("\n=== 现代动态加载优势 ===\n");
    printf("1. 功能完整:\n");
    printf("   ✓ 支持符号查找和调用\n");
    printf("   ✓ 支持引用计数管理\n");
    printf("   ✓ 支持错误处理和诊断\n");
    printf("   ✓ 支持多种加载模式\n");
    
    printf("\n2. 安全特性:\n");
    printf("   ✓ 支持版本检查\n");
    printf("   ✓ 支持依赖关系管理\n");
    printf("   ✓ 支持安全的库卸载\n");
    printf("   ✓ 支持插件隔离\n");
    
    printf("\n3. 灵活性:\n");
    printf("   ✓ 支持运行时库选择\n");
    printf("   ✓ 支持条件加载\n");
    printf("   ✓ 支持热插拔\n");
    printf("   ✓ 支持延迟加载\n");
    
    return 0;
}

int main() {
    return demo_modern_dl_loading();
}

示例3：插件系统架构演示

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <dirent.h>
#include <sys/stat.h>

/**
 * 插件接口定义
 */
typedef struct {
    const char *name;
    const char *version;
    const char *description;
    int (*initialize)(void);
    int (*execute)(const char *params);
    int (*finalize)(void);
} plugin_interface_t;

/**
 * 插件管理器
 */
typedef struct {
    plugin_interface_t *plugins[32];
    int plugin_count;
    char plugin_directory[256];
} plugin_manager_t;

/**
 * 初始化插件管理器
 */
int init_plugin_manager(plugin_manager_t *manager, const char *plugin_dir) {
    strncpy(manager->plugin_directory, plugin_dir, sizeof(manager->plugin_directory) - 1);
    manager->plugin_directory[sizeof(manager->plugin_directory) - 1] = '\0';
    manager->plugin_count = 0;
    
    printf("插件管理器初始化:\n");
    printf("  插件目录: %s\n", manager->plugin_directory);
    
    // 检查目录是否存在
    struct stat st;
    if (stat(manager->plugin_directory, &st) == 0) {
        if (S_ISDIR(st.st_mode)) {
            printf("  ✓ 插件目录存在\n");
        } else {
            printf("  ✗ 路径不是目录\n");
            return -1;
        }
    } else {
        printf("  ℹ 插件目录不存在，将创建空目录\n");
        // 在实际应用中可能会创建目录
    }
    
    return 0;
}

/**
 * 扫描并加载插件
 */
int scan_and_load_plugins(plugin_manager_t *manager) {
    printf("扫描插件目录: %s\n", manager->plugin_directory);
    
    DIR *dir = opendir(manager->plugin_directory);
    if (!dir) {
        printf("  无法打开插件目录: %s\n", strerror(errno));
        return -1;
    }
    
    struct dirent *entry;
    int loaded_count = 0;
    
    printf("  发现的插件文件:\n");
    
    while ((entry = readdir(dir)) != NULL) {
        // 检查是否为.so文件
        if (strstr(entry->d_name, ".so")) {
            printf("    %s\n", entry->d_name);
            loaded_count++;
            
            // 构造完整路径
            char full_path[512];
            snprintf(full_path, sizeof(full_path), "%s/%s", 
                     manager->plugin_directory, entry->d_name);
            
            // 演示加载过程（实际应用中会真正加载）
            printf("    模拟加载插件: %s\n", entry->d_name);
            
            // 在实际应用中，这里会使用dlopen加载库
            // 并获取插件接口函数
        }
    }
    
    closedir(dir);
    
    printf("  共发现 %d 个插件文件\n", loaded_count);
    manager->plugin_count = loaded_count;
    
    return 0;
}

/**
 * 插件调用演示
 */
void demonstrate_plugin_calls() {
    printf("=== 插件调用演示 ===\n");
    
    // 模拟插件接口
    printf("1. 插件接口定义:\n");
    printf("   typedef struct {\n");
    printf("       const char *name;\n");
    printf("       const char *version;\n");
    printf("       const char *description;\n");
    printf("       int (*initialize)(void);\n");
    printf("       int (*execute)(const char *params);\n");
    printf("       int (*finalize)(void);\n");
    printf("   } plugin_interface_t;\n");
    
    // 模拟插件实例
    printf("\n2. 插件实例演示:\n");
    
    struct {
        const char *name;
        const char *version;
        const char *description;
    } mock_plugins[] = {
        {"数据库插件", "1.0.0", "提供数据库访问功能"},
        {"网络插件", "2.1.3", "提供网络通信功能"},
        {"图形插件", "1.5.2", "提供图形渲染功能"},
        {"音频插件", "3.0.1", "提供音频处理功能"},
        {NULL, NULL, NULL}
    };
    
    for (int i = 0; mock_plugins[i].name; i++) {
        printf("  插件 %d:\n", i + 1);
        printf("    名称: %s\n", mock_plugins[i].name);
        printf("    版本: %s\n", mock_plugins[i].version);
        printf("    描述: %s\n", mock_plugins[i].description);
        printf("    状态: 模拟加载成功\n");
    }
    
    // 模拟插件调用
    printf("\n3. 插件调用演示:\n");
    
    for (int i = 0; mock_plugins[i].name; i++) {
        printf("  调用插件 %d (%s):\n", i + 1, mock_plugins[i].name);
        printf("    initialize() -> 成功\n");
        printf("    execute(\"参数%d\") -> 执行成功\n", i + 1);
        printf("    finalize() -> 成功\n");
    }
}

/**
 * 演示插件系统架构
 */
int demo_plugin_system_architecture() {
    plugin_manager_t manager;
    
    printf("=== 插件系统架构演示 ===\n");
    
    // 初始化插件管理器
    printf("1. 初始化插件管理器:\n");
    if (init_plugin_manager(&manager, "/usr/lib/plugins") != 0) {
        printf("插件管理器初始化失败\n");
        return -1;
    }
    
    // 扫描插件
    printf("\n2. 扫描插件:\n");
    scan_and_load_plugins(&manager);
    
    // 演示插件调用
    printf("\n3. 插件调用演示:\n");
    demonstrate_plugin_calls();
    
    // 显示插件系统架构
    printf("\n=== 插件系统架构说明 ===\n");
    printf("1. 核心组件:\n");
    printf("   ✓ 插件管理器: 负责插件的加载、卸载和管理\n");
    printf("   ✓ 插件接口: 定义插件的标准接口\n");
    printf("   ✓ 插件加载器: 使用dlopen动态加载插件\n");
    printf("   ✓ 符号解析器: 使用dlsym获取插件函数\n");
    
    printf("\n2. 加载流程:\n");
    printf("   1. 扫描插件目录\n");
    printf("   2. 验证插件文件\n");
    printf("   3. 动态加载库文件\n");
    printf("   4. 获取插件接口\n");
    printf("   5. 调用初始化函数\n");
    printf("   6. 注册插件实例\n");
    
    printf("\n3. 调用流程:\n");
    printf("   1. 查找目标插件\n");
    printf("   2. 验证插件状态\n");
    printf("   3. 调用插件函数\n");
    printf("   4. 处理返回结果\n");
    printf("   5. 错误处理\n");
    
    printf("\n4. 安全考虑:\n");
    printf("   ✓ 插件签名验证\n");
    printf("   ✓ 沙箱环境隔离\n");
    printf("   ✓ 权限控制\n");
    printf("   ✓ 资源限制\n");
    printf("   ✓ 异常处理\n");
    
    return 0;
}

int main() {
    return demo_plugin_system_architecture();
}

示例4：动态库版本管理

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <sys/utsname.h>

/**
 * 库版本信息结构
 */
typedef struct {
    char name[64];
    char version[32];
    char filepath[256];
    void *handle;
    int is_loaded;
    unsigned long load_time;
} library_version_t;

/**
 * 版本管理器
 */
typedef struct {
    library_version_t libraries[16];
    int library_count;
    int max_libraries;
} version_manager_t;

/**
 * 初始化版本管理器
 */
int init_version_manager(version_manager_t *manager) {
    memset(manager, 0, sizeof(version_manager_t));
    manager->max_libraries = 16;
    manager->library_count = 0;
    
    printf("版本管理器初始化完成\n");
    printf("最大库数量: %d\n", manager->max_libraries);
    
    return 0;
}

/**
 * 添加库版本信息
 */
int add_library_version(version_manager_t *manager, 
                       const char *name, const char *version, const char *filepath) {
    if (manager->library_count >= manager->max_libraries) {
        printf("库数量已达上限\n");
        return -1;
    }
    
    library_version_t *lib = &manager->libraries[manager->library_count];
    
    strncpy(lib->name, name, sizeof(lib->name) - 1);
    lib->name[sizeof(lib->name) - 1] = '\0';
    
    strncpy(lib->version, version, sizeof(lib->version) - 1);
    lib->version[sizeof(lib->version) - 1] = '\0';
    
    strncpy(lib->filepath, filepath, sizeof(lib->filepath) - 1);
    lib->filepath[sizeof(lib->filepath) - 1] = '\0';
    
    lib->handle = NULL;
    lib->is_loaded = 0;
    lib->load_time = 0;
    
    manager->library_count++;
    
    printf("添加库版本信息:\n");
    printf("  名称: %s\n", lib->name);
    printf("  版本: %s\n", lib->version);
    printf("  路径: %s\n", lib->filepath);
    
    return 0;
}

/**
 * 显示系统库信息
 */
void show_system_library_info() {
    printf("=== 系统库信息 ===\n");
    
    // 显示系统信息
    struct utsname sys_info;
    if (uname(&sys_info) == 0) {
        printf("系统名称: %s\n", sys_info.sysname);
        printf("节点名称: %s\n", sys_info.nodename);
        printf("发行版本: %s\n", sys_info.release);
        printf("系统版本: %s\n", sys_info.version);
        printf("硬件架构: %s\n", sys_info.machine);
    }
    
    // 显示常见系统库
    printf("\n常见系统库路径:\n");
    
    const char *common_lib_paths[] = {
        "/lib/x86_64-linux-gnu/libc.so.6",
        "/lib/x86_64-linux-gnu/libm.so.6",
        "/lib/x86_64-linux-gnu/libdl.so.2",
        "/lib/x86_64-linux-gnu/librt.so.1",
        "/lib/x86_64-linux-gnu/libpthread.so.0",
        NULL
    };
    
    for (int i = 0; common_lib_paths[i]; i++) {
        struct stat st;
        if (stat(common_lib_paths[i], &st) == 0) {
            printf("  %s (存在)\n", common_lib_paths[i]);
        } else {
            printf("  %s (不存在)\n", common_lib_paths[i]);
        }
    }
}

/**
 * 演示版本管理
 */
int demo_version_management() {
    version_manager_t manager;
    
    printf("=== 动态库版本管理演示 ===\n");
    
    // 初始化版本管理器
    printf("1. 初始化版本管理器:\n");
    if (init_version_manager(&manager) != 0) {
        return -1;
    }
    
    // 显示系统信息
    printf("\n2. 系统库信息:\n");
    show_system_library_info();
    
    // 添加库版本信息
    printf("\n3. 添加库版本信息:\n");
    
    add_library_version(&manager, "libc", "2.31", "/lib/x86_64-linux-gnu/libc.so.6");
    add_library_version(&manager, "libm", "2.31", "/lib/x86_64-linux-gnu/libm.so.6");
    add_library_version(&manager, "libdl", "2.31", "/lib/x86_64-linux-gnu/libdl.so.2");
    add_library_version(&manager, "librt", "2.31", "/lib/x86_64-linux-gnu/librt.so.1");
    add_library_version(&manager, "libpthread", "2.31", "/lib/x86_64-linux-gnu/libpthread.so.0");
    
    // 显示所有库信息
    printf("\n4. 所有库版本信息:\n");
    printf("%-15s %-10s %-40s %-10s\n", "名称", "版本", "路径", "状态");
    printf("%-15s %-10s %-40s %-10s\n", "----", "----", "----", "----");
    
    for (int i = 0; i < manager.library_count; i++) {
        library_version_t *lib = &manager.libraries[i];
        printf("%-15s %-10s %-40s %-10s\n", 
               lib->name, lib->version, lib->filepath,
               lib->is_loaded ? "已加载" : "未加载");
    }
    
    // 演示版本比较
    printf("\n5. 版本比较演示:\n");
    
    struct {
        const char *version1;
        const char *version2;
        const char *description;
    } version_pairs[] = {
        {"2.31", "2.30", "向前兼容"},
        {"2.29", "2.31", "向后兼容检查"},
        {"3.0.0", "2.9.9", "大版本升级"},
        {"2.31.1", "2.31.0", "补丁版本"},
        {NULL, NULL, NULL}
    };
    
    for (int i = 0; version_pairs[i].version1; i++) {
        printf("  %s vs %s: %s\n", 
               version_pairs[i].version1, version_pairs[i].version2,
               version_pairs[i].description);
    }
    
    // 显示版本管理策略
    printf("\n=== 版本管理策略 ===\n");
    printf("1. 版本兼容性:\n");
    printf("   ✓ 主版本号变化：可能不兼容\n");
    printf("   ✓ 次版本号变化：向后兼容\n");
    printf("   ✓ 修订版本号变化：完全兼容\n");
    
    printf("\n2. 加载策略:\n");
    printf("   ✓ 优先加载最新兼容版本\n");
    printf("   ✓ 支持版本回退\n");
    printf("   ✓ 支持并行版本加载\n");
    printf("   ✓ 支持版本冲突解决\n");
    
    printf("\n3. 安全策略:\n");
    printf("   ✓ 版本签名验证\n");
    printf("   ✓ 依赖关系检查\n");
    printf("   ✓ 兼容性测试\n");
    printf("   ✓ 回滚机制\n");
    
    return 0;
}

int main() {
    return demo_version_management();
}

示例5：现代动态加载最佳实践

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <sys/stat.h>
#include <time.h>

/**
 * 安全的动态加载器
 */
typedef struct {
    void *handle;
    char library_path[256];
    time_t load_time;
    int reference_count;
    int is_valid;
} secure_loader_t;

/**
 * 初始化安全加载器
 */
int init_secure_loader(secure_loader_t *loader, const char *library_path) {
    // 验证库文件
    struct stat st;
    if (stat(library_path, &st) != 0) {
        printf("库文件不存在: %s\n", library_path);
        return -1;
    }
    
    if (!S_ISREG(st.st_mode)) {
        printf("路径不是常规文件: %s\n", library_path);
        return -1;
    }
    
    // 检查文件权限
    if (!(st.st_mode & S_IRUSR)) {
        printf("没有读取权限: %s\n", library_path);
        return -1;
    }
    
    // 初始化加载器
    loader->handle = NULL;
    strncpy(loader->library_path, library_path, sizeof(loader->library_path) - 1);
    loader->library_path[sizeof(loader->library_path) - 1] = '\0';
    loader->load_time = 0;
    loader->reference_count = 0;
    loader->is_valid = 1;
    
    printf("安全加载器初始化:\n");
    printf("  库路径: %s\n", loader->library_path);
    printf("  文件大小: %ld 字节\n", st.st_size);
    printf("  修改时间: %s", ctime(&st.st_mtime));
    
    return 0;
}

/**
 * 安全加载库
 */
int secure_load_library(secure_loader_t *loader) {
    if (!loader->is_valid) {
        printf("加载器无效\n");
        return -1;
    }
    
    printf("安全加载库: %s\n", loader->library_path);
    
    // 使用RTLD_LAZY延迟加载
    loader->handle = dlopen(loader->library_path, RTLD_LAZY);
    if (!loader->handle) {
        printf("加载失败: %s\n", dlerror());
        return -1;
    }
    
    loader->load_time = time(NULL);
    loader->reference_count = 1;
    
    printf("  ✓ 加载成功\n");
    printf("  加载时间: %s", ctime(&loader->load_time));
    
    return 0;
}

/**
 * 获取符号地址
 */
void* secure_get_symbol(secure_loader_t *loader, const char *symbol_name) {
    if (!loader->handle) {
        printf("库未加载\n");
        return NULL;
    }
    
    void *symbol = dlsym(loader->handle, symbol_name);
    if (!symbol) {
        printf("符号未找到: %s (%s)\n", symbol_name, dlerror());
        return NULL;
    }
    
    printf("获取符号成功: %s -> %p\n", symbol_name, symbol);
    return symbol;
}

/**
 * 安全卸载库
 */
int secure_unload_library(secure_loader_t *loader) {
    if (!loader->handle) {
        printf("库未加载\n");
        return 0;
    }
    
    loader->reference_count--;
    if (loader->reference_count > 0) {
        printf("引用计数: %d，延迟卸载\n", loader->reference_count);
        return 0;
    }
    
    printf("卸载库: %s\n", loader->library_path);
    
    if (dlclose(loader->handle) != 0) {
        printf("卸载失败: %s\n", dlerror());
        return -1;
    }
    
    loader->handle = NULL;
    loader->load_time = 0;
    
    printf("  ✓ 卸载成功\n");
    return 0;
}

/**
 * 演示现代动态加载最佳实践
 */
int demo_modern_best_practices() {
    secure_loader_t loader;
    const char *system_lib = "/lib/x86_64-linux-gnu/libc.so.6";
    
    printf("=== 现代动态加载最佳实践演示 ===\n");
    
    // 1. 安全初始化
    printf("1. 安全初始化:\n");
    if (init_secure_loader(&loader, system_lib) != 0) {
        printf("安全加载器初始化失败\n");
        return -1;
    }
    
    // 2. 安全加载
    printf("\n2. 安全加载:\n");
    if (secure_load_library(&loader) != 0) {
        printf("安全加载失败\n");
        return -1;
    }
    
    // 3. 符号获取和使用
    printf("\n3. 符号获取和使用:\n");
    
    // 获取并使用malloc
    void* (*malloc_func)(size_t) = 
        (void* (*)(size_t))secure_get_symbol(&loader, "malloc");
    if (malloc_func) {
        printf("  测试malloc函数:\n");
        void *ptr = malloc_func(1024);
        if (ptr) {
            printf("    分配1024字节成功: %p\n", ptr);
            
            // 获取并使用free
            void (*free_func)(void*) = 
                (void (*)(void*))secure_get_symbol(&loader, "free");
            if (free_func) {
                free_func(ptr);
                printf("    释放内存成功\n");
            }
        }
    }
    
    // 获取并使用printf
    int (*printf_func)(const char*, ...) = 
        (int (*)(const char*, ...))secure_get_symbol(&loader, "printf");
    if (printf_func) {
        printf("  测试printf函数:\n");
        printf_func("    这是通过动态加载的printf输出\n");
    }
    
    // 4. 错误处理演示
    printf("\n4. 错误处理演示:\n");
    
    // 尝试获取不存在的符号
    void *nonexistent = secure_get_symbol(&loader, "nonexistent_function");
    if (!nonexistent) {
        printf("    ✓ 正确处理不存在的符号\n");
    }
    
    // 尝试加载不存在的库
    secure_loader_t bad_loader;
    if (init_secure_loader(&bad_loader, "/nonexistent/badlib.so") != 0) {
        printf("    ✓ 正确拒绝不存在的库文件\n");
    }
    
    // 5. 安全卸载
    printf("\n5. 安全卸载:\n");
    if (secure_unload_library(&loader) != 0) {
        printf("安全卸载失败\n");
        return -1;
    }
    
    printf("    ✓ 安全卸载完成\n");
    
    // 显示最佳实践总结
    printf("\n=== 现代动态加载最佳实践 ===\n");
    printf("1. 安全性最佳实践:\n");
    printf("   ✓ 文件完整性验证\n");
    printf("   ✓ 权限检查\n");
    printf("   ✓ 路径安全检查\n");
    printf("   ✓ 符号白名单\n");
    
    printf("\n2. 错误处理最佳实践:\n");
    printf("   ✓ 详细的错误信息\n");
    printf("   ✓ 优雅的降级处理\n");
    printf("   ✓ 资源清理\n");
    printf("   ✓ 日志记录\n");
    
    printf("\n3. 性能优化最佳实践:\n");
    printf("   ✓ 延迟加载\n");
    printf("   ✓ 引用计数\n");
    printf("   ✓ 缓存机制\n");
    printf("   ✓ 预加载策略\n");
    
    printf("\n4. 资源管理最佳实践:\n");
    printf("   ✓ 自动资源清理\n");
    printf("   ✓ 内存泄漏检测\n");
    printf("   ✓ 生命周期管理\n");
    printf("   ✓ 监控和统计\n");
    
    return 0;
}

int main() {
    return demo_modern_best_practices();
}

uselib 使用注意事项

历史背景：

1. 早期Linux: 在早期Linux版本中用于动态加载共享库
2. 现代状态: 在现代Linux系统中已被弃用
3. 替代方案: 使用dlopen/dlsym等现代接口

系统要求：

1. 内核版本: 早期支持uselib的Linux内核
2. 权限要求: 通常需要适当的文件访问权限
3. 架构支持: 历史上支持主流架构

安全考虑：

1. 代码注入: 直接加载库文件可能存在安全风险
2. 权限提升: 加载恶意库可能导致权限提升
3. 内存安全: 直接内存操作可能影响系统稳定性

最佳实践：

1. 使用现代接口: 优先使用dlopen/dlsym等现代动态加载接口
2. 安全验证: 加载前验证库文件的完整性和来源
3. 错误处理: 妥善处理加载和使用过程中的各种错误
4. 资源管理: 及时释放加载的库资源

现代动态加载对比

uselib vs dlopen：

// uselib: 已过时的接口
uselib("/lib/libexample.so");

// dlopen: 现代标准接口
void *handle = dlopen("/lib/libexample.so", RTLD_LAZY);

功能对比：

特性	uselib	dlopen
符号获取	不支持	支持
错误处理	有限	完善
引用计数	无	支持
资源管理	手动	自动
安全性	较低	较高

相关函数和工具

现代动态加载接口：

#include <dlfcn.h>

// 动态加载库
void *dlopen(const char *filename, int flag);

// 获取符号地址
void *dlsym(void *handle, const char *symbol);

// 卸载库
int dlclose(void *handle);

// 获取错误信息
char *dlerror(void);

编译选项：

# 链接动态加载库
gcc -o program program.c -ldl

# 位置无关代码
gcc -fPIC -shared -o libexample.so example.c

常见使用场景

1. 插件系统：

// 动态加载插件库
void *plugin = dlopen("plugin.so", RTLD_LAZY);
if (plugin) {
    // 获取插件接口
    plugin_interface_t *interface = dlsym(plugin, "plugin_interface");
    // 使用插件功能
}

2. 模块化应用：

// 根据配置动态加载不同模块
void *module = dlopen(config.module_path, RTLD_LAZY);
// 实现模块化架构

3. 热插拔功能：

// 运行时加载和卸载功能模块
void *feature = dlopen("feature.so", RTLD_LAZY);
// 使用完毕后卸载
dlclose(feature);

总结

uselib 是Linux历史上用于动态加载共享库的系统调用，但在现代Linux系统中已被弃用。开发者应该使用更现代、更安全的动态加载接口如 dlopen/dlsym/dlclose。

现代动态加载提供了：

1. 完整的功能: 支持符号查找、引用计数、错误处理
2. 更好的安全性: 完善的安全检查和错误处理机制
3. 标准兼容: 符合POSIX标准，跨平台支持
4. 丰富的特性: 支持多种加载模式和灵活的配置选项

通过合理使用现代动态加载技术，可以构建灵活、安全、高效的模块化应用程序。