动态库加载函数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)
{
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的使用总结，以供参考交流。
