Linux 动态链接库使用详解：dlopen/dlsym/dlclose/dlerror | 极客日志

C

Linux 动态链接库使用详解：dlopen/dlsym/dlclose/dlerror

Linux 下通过 dlopen 系列 API 实现动态链接库加载。核心包括打开库、获取符号地址、关闭库及错误处理。配合 RTLD 标志位控制解析时机与作用域，支持运行时模块扩展。编译需添加 -ldl 等参数，适用于 Apache 等服务器插件场景。

鲜活发布于 2025/1/210 浏览

Linux 动态链接库使用详解：dlopen/dlsym/dlclose/dlerror

Linux 动态链接库使用详解

在 Linux 环境下，动态链接库提供了极大的灵活性。它允许程序在运行时加载模块，而不需要重新编译主程序。Apache Web 服务器就是利用这种机制在运行过程中加载模块的典型例子，这使得添加或删除功能时非常便捷。

核心 API 概览

要使用动态链接库，首先需要在代码中包含 <dlfcn.h> 头文件，并在编译时链接 -ldl 库。

dlopen：打开库

void *dlopen(const char *pathname, int mode);

这个函数负责将指定的动态库文件装入内存并返回一个句柄（handle）。

pathname：库文件的路径，可以是绝对路径或相对路径。
mode：控制符号解析和可见性的标志位组合。

返回值：成功返回库引用句柄，失败返回 NULL。

dlsym：获取符号地址

void *dlsym(void *handle, const char *symbol);

拿到 dlopen 返回的句柄后，用 dlsym 去查找具体的函数或变量地址。返回值是 void*，通常需要强制转换为对应的函数指针类型才能调用。

dlclose：关闭库

int dlclose(void *handle);

用于卸载之前打开的动态库。只有当该库的使用计数降为 0 时，系统才会真正将其从内存中移除。

dlerror：错误处理

const char *dlerror(void);

当上述操作失败时，dlerror 会返回具体的错误信息字符串。注意，每次调用 dlerror 后会清空之前的错误状态，所以如果 dlopen 失败了，紧接着调用 dlerror 获取原因通常是最稳妥的做法。

关键标志位说明

dlopen 的 mode 参数决定了库的行为，常见的标志包括：

RTLD_LAZY：暂缓决定。在 dlopen 返回前，不立即解析未定义的符号，等到真正调用时才解析。这对变量引用总是立即解析，仅对函数引用有效。

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

#define LIB_PATH "./libcaculate.so"

typedef int (*CAC_FUNC)(int, int);

int main() {
    void *handle;
    char *error;
    CAC_FUNC cac_func = NULL;

    // 打开动态链接库，使用 RTLD_LAZY 延迟解析
    handle = dlopen(LIB_PATH, RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "%s\n", dlerror());
        exit(EXIT_FAILURE);
    }

    // 清除可能存在的旧错误
    dlerror();

    // 获取 add 函数地址
    cac_func = (CAC_FUNC)dlsym(handle, "add");
    if ((error = dlerror()) != NULL) {
        fprintf(stderr, "%s\n", error);
        exit(EXIT_FAILURE);
    }
    printf("add: %d\n", (*cac_func)(2, 7));

    // 获取 sub 函数地址
    cac_func = (CAC_FUNC)dlsym(handle, "sub");
    printf("sub: %d\n", cac_func(9, 2));

    // 获取 mul 函数地址
    cac_func = (CAC_FUNC)dlsym(handle, "mul");
    printf("mul: %d\n", cac_func(3, 2));

    // 获取 div 函数地址
    cac_func = (CAC_FUNC)dlsym(handle, "div");
    printf("div: %d\n", cac_func(8, 2));

    // 关闭库
    dlclose(handle);
    return 0;
}

#include <stdlib.h>
#include <dlfcn.h>
#include <stdio.h>

typedef struct __test {
    int i;
    void (*echo_fun)(struct __test *p);
} Test;

// 供动态库使用的注册函数
void __register(Test *p) {
    p->i = 1;
    p->echo_fun(p);
}

int main(void) {
    void *handle = NULL;
    char *myso = "./mylib.so";

    if ((handle = dlopen(myso, RTLD_NOW)) == NULL) {
        printf("dlopen - %s\n", dlerror());
        exit(-1);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

typedef struct __test {
    int i;
    void (*echo_fun)(struct __test *p);
} Test;

// 申明注册函数原型
extern void __register(Test *p);

static void __printf(Test *p) {
    printf("i = %d\n", p->i);
}

// 动态库申请一个全局变量空间
static Test config = { .i = 0, .echo_fun = __printf };

// 加载动态库的自动初始化函数
void _init(void) {
    printf("init\n");
    __register(&config); // 调用主程序的注册函数
}

#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

typedef struct {
    const char *module;
    int (*GetValue)(char *pszVal);
    int (*PrintfHello)();
} hello_ST_API;

int GetValue(char *pszVal) {
    int retval = -1;
    if (pszVal)
        retval = sprintf(pszVal, "%s", "123456");
    printf("%s, %d, pszVer = %s\n", __FUNCTION__, __LINE__, pszVal);
    return retval;
}

int PrintfHello() {
    int retval = -1;
    printf("%s, %d, hello everyone\n", __FUNCTION__, __LINE__);
    return 0;
}

const hello_ST_API Hello = {
    .module = "hello",
    GetValue,
    PrintfHello,
};

#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <dlfcn.h>

typedef struct {
    const char *module;
    int (*GetValue)(char *pszVal);
    int (*PrintfHello)();
} hello_ST_API;

int main(int argc, char **argv) {
    hello_ST_API *hello;
    int i = 0;
    void *handle;
    char psValue[20] = {0};

    handle = dlopen("./hello.so", RTLD_LAZY);
    if (!handle) {
        printf("%s,%d, NULL == handle\n", __FUNCTION__, __LINE__);
        return -1;
    }

    dlerror();
    hello = dlsym(handle, "Hello");
    if (!hello) {
        printf("%s,%d, NULL == handle\n", __FUNCTION__, __LINE__);
        return -1;
    }

    if (hello && hello->PrintfHello)
        i = hello->PrintfHello();
    printf("%s, %d, i = %d\n", __FUNCTION__, __LINE__, i);

    if (hello && hello->GetValue)
        i = hello->GetValue(psValue);

    if (hello && hello->module)
        printf("%s, %d, module = %s\n", __FUNCTION__, __LINE__, hello->module);

    dlclose(handle);
    return 0;
}