动态库加载函数dlsym 在C/C++编程中的使用

dlsym函数的功能就是可以从共享库（动态库）中获取符号（全局变量与函数符号）地址，通常用于获取函数符号地址，这样可用于对共享库中函数的包装；下面是函数原型及需要包含的头文件。

#include <dlfcn.h>
void *dlsym(void *handle, const char *symbol);

其中handle可以是dlopen函数返回的handle值，也可以是RTLD_DEFAULT或RTLD_NEXT

RTLD_DEFAULT表示按默认的顺序搜索共享库中符号symbol第一次出现的地址
RTLD_NEXT表示在当前库以后按默认的顺序搜索共享库中符号symbol第一次出现的地址

具体区别可以通过下面的代码dlsym1.c来区别：

#include <stdio.h>
#include <stdlib.h>
#define __USE_GNU     //使用RTLD_DEFAULT和RTLD_NEXT宏需定义
#include <dlfcn.h>

typedef size_t (*strlen_t)(const char *); 
strlen_t strlen_f = NULL, strlen_f1 = NULL;

size_t strlen(const char *str)
{
    printf("%s strlen\n", __FILE__);
    return strlen_f1(str);
}

int main(int argc, char **argv)
{
    strlen_f = dlsym(RTLD_DEFAULT, "strlen");  
    //获取到的是当前文件中函数符号strlen的地址
    if(!strlen_f) {
        printf("default load error %s\n", dlerror());
        return 1;
    }   
    strlen_f1 = dlsym(RTLD_NEXT, "strlen");
    //获取到的是当前库后的系统库中函数符号strlen的地址
    if(!strlen_f1) {
        printf("next load error %s\n", dlerror());
        return 1;
    }   
    printf("strlen is %p\n", strlen);
    printf("strlen_f is %p\n", strlen_f);
    printf("strlen_f1 is %p\n", strlen_f1);
    printf("strlen_f is %ld\n", strlen_f("xuedaon")); //调用当前文件中的函数strlen
    printf("=>>>>>>>>>> <<<<<<<<<<<=\n");
    printf("strlen_f1 is %ld\n", strlen_f1("xuedaon"));  //相当于调用系统库函数strlen
    return 0;
}

编译当前文件dlsym1.c
gcc  dlsym1.c  -ldl 
运行结果如下：

 dlsym函数还可以获取指定库中的函数或全局变量符号，需要先调用dlopen先打开我们指定的动态库文件，才能获取符号地址，具体操作代码事例：

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

int main(int argc, char **argv)
{
    // libhello.so是我们自己封装的一个测试的共享库文件
    // RTLD_LAZY 表示在对符号引用时才解析符号，但只对函数符号引用有效，而对于变量符号的引用总是在加载该动态库的时候立即绑定解析
    void *handle = dlopen("./libhello.so", RTLD_LAZY);  
    if(!handle) {
        printf("open failed: %s\n", dlerror());
        return 1;
    }   
    void *p = dlsym(handle, argv[2]);  //argv[2]对应输入需获取地址的符号名
    if(!p) {
        printf("load failed: %s\n", dlerror());
        return 1;
    }   
    // argv[1]对应输入0表示获取的是全局变量的符号
    // argv[1]对应输入1表示获取的是全局函数的符号
    if(0 == atoi(argv[1])) {
        printf("global is %d\n", *(int*)p);
    }else if(1 == atoi(argv[1])) {
        void (*fp)() = (void (*)())p;
        fp();
    }   
    dlclose(handle);
    return 0;
}

这里的libhello.so库是通过下面的测试代码源文件hello.c封装的，具体内容如下：

#include "hello.h"

int global = 666;

void hello()
{
    printf("hello xuedaon\n");
}

编译上面的dlsym.c文件运行效果如下：  

 运行时传递0表示获取共享库中全局变量global符号的地址，传1 表示获取共享库中函数符号的地址。
注意在上述使用均是用的C编译器实现，如果是在C++编译环境需使用dlsym这些函数需要注意的是由于C++的重载机制导致函数符号在编译阶段会将函数名重新改编，所以在使用时需要使用extern "C"告诉编译器按C的编译方式处理对应的变量或对象。下面是两种编译时生成符号的区别：

 而如果我们将hello.h中加上extern "C"修饰后我们会发现使用gcc与g++编译时被extern "C"修饰的函数不会进行函数名的重新改编。
hello.h 

#pragma once 
#include <stdio.h>
extern "C" {
    extern int global;
    extern void hello();
}

 顺便提一下大家如果想使用dlsym函数获取类对象，那么可利用extern "C"配合函数接口返回类对象的指针或引用来实现。
另外用dlsym函数还可实现对库函数malloc与free的包装来检测我们的代码是否存在内存泄漏（malloc与free若不成对则存在内存泄漏），这里提供一个简单的实现思路代码以供参考：

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

#define TEST_MEM_LEAK 1    //值为1表示加入内存泄露的检测，为0表示不加入

#if TEST_MEM_LEAK

typedef void *(*malloc_t)(size_t size);
malloc_t malloc_f = NULL;

typedef void (*free_t)(void *p);
free_t free_f = NULL;

int malloc_flag = 1;    // 用于防止重复递归无法退出,因为printf函数会调用malloc进行内存分配
int free_flag = 1;

void *malloc(size_t size)学到牛牛 www.xuedaon.com
{
    if(malloc_flag) {          
        malloc_flag = 0;  // 用于防止printf造成递归调用malloc而出错
        printf("malloc\n");
	   void *p = malloc_f(size);
        malloc_flag = 1;  // 用于保证后续再次调用本文件中malloc时flag标志的初始值一致
	   return p;
    } else {
        return malloc_f(size);  // 这里调用dlsym获取的系统库中malloc函数
    }   
}

void free(void *p) 
{
    if(free_flag) {
        free_flag = 0;
        printf("free\n");
        free_f(p);
	   free_flag = 1;
    } else {
        free_f(p);
    }
}
#endif
int main(int argc, char **argv)
{
#if TEST_MEM_LEAK    // 这里if到endif之间的部分可分装成函数调用
    malloc_f = dlsym(RTLD_NEXT, "malloc");
    if(!malloc_f) {
        printf("load malloc failed: %s\n", dlerror());
        return 1;
    }
    free_f = dlsym(RTLD_NEXT, "free");
    if(!free_f) {
        printf("load free failed: %s\n", dlerror());
        return 1;
    }
#endif
    void *p1 = malloc(10);  //这里会先调用本文中的malloc函数
    void *p2 = malloc(20);
    //这里的p2未释放存在内存泄漏，通过利用查看打印的malloc与free次数是否一样来判断
    free(p1);
    return 0;
}

编译运行效果如下：

 这里可以看出调用了两次malloc，而free只调用了一次，存在内存泄漏。
以上就是dlsym的使用总结，以供参考交流。