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

实战示例

基础函数调用

下面是一个简单的例子，演示如何加载包含加减乘除函数的库并调用它们。

#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;
}

编译命令：gcc -rdynamic -o foo foo.c -ldl

结构体与回调交互

有时候我们需要动态库和主程序之间进行更复杂的交互，比如传递结构体指针或回调函数。

主程序：

#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); // 调用主程序的注册函数
}

编译动态库：gcc -shared -fPIC -nostartfiles -o mylib.so mylib.c

编译主程序：gcc test.c -ldl -rdynamic

在这个例子中，主程序通过 dlopen 加载 .so 文件，动态库会自动运行 _init() 初始化函数。这展示了主程序和动态库如何通过函数指针相互调用。

接口封装示例

对于大型库，我们通常会定义一个全局结构体来封装多个函数指针，这样就不需要多次调用 dlsym。

生成动态库 hello.c：

#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,
};

编译指令：gcc -shared -o hello.so hello.c

dlopen 调用代码：

#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;
}

编译指令：gcc -o test hello_dlopen.c -ldl

运行结果会显示正常的输出，这说明通过 dlsym 找到全局结构体后，可以直接用指针访问库内的多个函数，比逐个查找更高效。

编译注意事项

1. 创建动态库：使用 -shared 选项，并以 .so 后缀命名。建议放在 /lib 或 /usr/lib 等公用目录，或者确保程序能找到相对路径。
2. 编译可执行文件：必须包含 -ldl 以链接动态加载库。同时建议使用 -rdynamic 选项，它将所有符号添加到动态符号表中，方便调试和向后跟踪。
3. 位置无关代码：编译 .so 文件时通常加上 -fPIC，这样多个可执行文件可以共享同一份库代码，节省内存空间。
4. 错误检查：务必检查 dlopen 和 dlsym 的返回值，并使用 dlerror 获取具体错误信息，否则很难排查问题。