C语言插件机制(上) -- linux动态库

来源:互联网 发布:上海艾诺科软件 编辑:程序博客网 时间:2024/06/05 09:20

http://abruzzi.iteye.com/blog/739673


前言

插件机制可以使得应用程序在发布之后,在不经过重新编译的情况下修改应用程序的行为,这种形式使得应用的框架比较小巧,也可以给用户一些自由(不是完全的自由,有一定的限制)。Java中,使用*.jar或者其他的脚本引擎都可以完成这样的工作,如Eclipse那样。在C语言中,当然可以使用脚本引擎来实现,比如emacs,内置一个lisp的引擎,用户可以自己为emacs写脚本,访问emacs环境的一些组件,从而定制emacs.这里要讨论的无需使用脚本引擎,而是用C语言访问动态链接库来实现。

Linux下的动态库

Linux环境中,与windows下一样,函数库有两种方式:静态库和动态库,静态库参与连接,由于要将目标代码.o与lib中的函数符号合并在一起,所以最终生成的可执行文件较大。一般以.a结尾。如libxxx.a。而动态库(共享库)则不参与编译,只是在运行时才加载如内存,且仅加载一次,因此最终的可执行文件较小。事实上,当一个可执行文件需要运行动态库中的函数时,系统会在内存中查找,如果已经加载,则直接调用,否则才做一次加载,动态库的结尾一般为.so,如libxxx.so。

 

Linux为动态库的访问提供了4个API,分别为dlopen , dlerror , dlsym 和 dlclose。这些API的原型定义在文件dlfcn.h中,其实现则分别对应有两个库文件(静态库 libdl.a 和动态库 libdl.so)。

 

  • dlopen加载动态库,并返回句柄
  • dlerror如果加载,访问符号出错,可以通过此接口获得详细的描述
  • dlsym返回一个动态库中的符号,即通过函数名获得此函数的指针
  • dlclose完成之后,释放dlopen返回的句柄
动态库的使用较为简单,比如动态库的名称为plugina.so,其中包含这样的函数原型:

C代码  收藏代码
  1. int func(int a, int b);  
可以看下一个例子:

C代码  收藏代码
  1. #include <dlfcn.h>  
  2.   
  3. //句柄  
  4. void *flib;  
  5.   
  6. //入口函数原型  
  7. int (*pfunc)(int a, int b);  
  8.   
  9. //错误信息字符串  
  10. char *error_message;  
  11.   
  12. int plugin_test(){  
  13.     int a = 1, b = 4;  
  14.     int result = 0;  
  15.       
  16.     //加载plugina.so,以RTLD_LAZY方式  
  17.     flib = dlopen("/home/juntao/.libs/plugina.so", RTLD_LAZY);  
  18.     error_message = dlerror();  
  19.       
  20.     if(error_message){  
  21.         return (-1);  
  22.     }  
  23.       
  24.     //找到函数名为func的函数,返回其指针  
  25.     *(void **)(&pfunc) = dlsym(flib, "func");  
  26.     error_message = dlerror();  
  27.     if(error_message){  
  28.         return (-1);  
  29.     }  
  30.       
  31.     //调用pfunc指向的指针,及func函数  
  32.     result = pfunc(a, b);  
  33.       
  34.     //释放  
  35.     int code = dlclose(flib);  
  36.     error_message = dlerror();  
  37.   
  38.     if(error_message){  
  39.         return (-1);  
  40.     }  
  41.       
  42.     return 0;  
  43. }  
 

编译运行

假设plugina.so的源文件为plugina.c,内容为:

C代码  收藏代码
  1. //file plugina.c  
  2.   
  3. int func(int a, int b){  
  4.     int c = 0;  
  5.     c = 3*a + 4*b + 6;  
  6.       
  7.     return c;  
  8. }  

 

我们将这个.c文件编译为.so,命令如下:


//生成plugina.o
$gcc -c -fpic plugina.c

//生成plugina.so
$gcc -shared -lc -o plugina.so plugina.o

 

将动态库访问部分的代码存为plugintest.c,然后使用下列命令编译:

 

C代码  收藏代码
  1. $gcc -o plugintest plugintest.c -ldl  

 

 -ldl意思是,使用库libdl.so,linux下访问搜索路径内的库文件无需加lib前缀。

 

将生成的plugina.so放入路径/home/juntao/.libs/,然后运行plugintest。

 


$./plugintest

result = 25

 

好了,这一次先介绍一些基础知识,相信在此基础上,很多朋友都可以自己设计出一些简单实用的支持“插件”的应用来了,我们下一次详细讨论一个更实际一些的例子,一个计算器的实现,这个计算器只有简单的框剪,所有的运算都通过插件来实现。用户可以通过配置文件来定制插件的路径,入口等信息。




---------------------------------------------------------------





我们在这篇文章中实现一个计算器,计算器程序calc本身不做运算,只是将操作数传递给具体的插件(adder, suber, muler, diver)来完成实际运算。首先,计算器根据插件配置文件plugin.xml来确定插件的位置,名称,入口符号的定义,然后依次调用各个插件完成计算。

 

插件列表

文中涉及到的插件定义在plugin.xml中,文档结构如下:

 

Xml代码  收藏代码
  1. <plugins>  
  2.     <plugin name="adder">  
  3.         <library path="/home/juntao/.libs/adder.so">  
  4.         </library>  
  5.         <entry name="add">  
  6.         </entry>  
  7.     </plugin>  
  8.     <plugin name="suber">  
  9.         <library path="/home/juntao/.libs/suber.so">  
  10.         </library>  
  11.         <entry name="sub">  
  12.         </entry>  
  13.    </plugin>  
  14.    <plugin name="muler">  
  15.         <library path="/home/juntao/.libs/muler.so">  
  16.         </library>  
  17.         <entry name="mul">  
  18.         </entry>  
  19.    </plugin>  
  20.    <plugin name="diver">  
  21.         <library path="/home/juntao/.libs/diver.so">  
  22.         </library>  
  23.         <entry name="div">  
  24.         </entry>  
  25.    </plugin>  
  26. </plugins>  

 

每个插件为一个plugin标签,plugin标签中包含library, entry两个字标签,分别定义动态库文件的路径及名称和插件函数的入口。为了简便,我们不重复设计list及xml解析,这里使用libxml2作为xml的分析器,GLIB中的GSList(单链表)来作为插件列表的链表对象。

 

每一个插件在C语言中的定义如下,非常简单(plugin.h)

 

C代码  收藏代码
  1. #ifndef _PLUGIN_H_  
  2. #define _PLUGIN_H_  
  3.   
  4. typedef struct{  
  5.     char name[64];  
  6.     char path[256];  
  7.     char entry[128];  
  8.     int version;  
  9. }Plugin;  
  10.   
  11. #endif  

 

这里为了行文方便,Plugin结构中的字符串为静态尺寸。

 

计算器 

计算器调用parseconf模块中的load_plugins将plugin.xml中定义的Plugin加载进一个GSList,以备后用:

 

C代码  收藏代码
  1. #include "plugin.h"  
  2.   
  3. extern int load_plugins(char *config, GSList **list);  

 

插件中的函数原型应该符合接口定义:

 

C代码  收藏代码
  1. //pointer to function, which return a double, and get 2 double as input  
  2. double (*pfunc)(double a, double b);  

 

计算器的主要代码如下:

C代码  收藏代码
  1. int calc_test(double a, double b){  
  2.     GSList *list = NULL, *it = NULL;  
  3.     Plugin *pl = NULL;  
  4.       
  5.     //insert a null node into list at first  
  6.     list = g_slist_append(list, NULL);  
  7.       
  8.     int code = 0;  
  9.     double result;  
  10.   
  11.     //load plugin defined in plugin.xml into list  
  12.     load_plugins("plugin.xml", &list);  
  13.       
  14.     for(it = list; it != NULL; it = it->next){  
  15.         pl = (Plugin *)it->data;  
  16.         if(pl == NULL){  
  17.             continue;  
  18.         }else{  
  19.             //open the library  
  20.             flib = dlopen(pl->path, RTLD_LAZY);  
  21.             dlError = dlerror();  
  22.   
  23.             if(dlError){  
  24.                 fprintf(stderr, "open %s failed\n", pl->name);  
  25.                 g_slist_free(list);  
  26.                 return -1;  
  27.             }  
  28.               
  29.             //get the entry  
  30.             *(void **)(&pfunc) = dlsym(flib, pl->entry);  
  31.             dlError = dlerror();  
  32.             if(dlError){  
  33.                 fprintf(stderr, "find symbol %s failed\n", pl->entry);  
  34.                 g_slist_free(list);  
  35.                 return -1;  
  36.             }  
  37.   
  38.             //call the function  
  39.             result = (*pfunc)(a, b);  
  40.             printf("%s(%f, %f) = %f\n", pl->entry, a, b, result);  
  41.               
  42.             //then close it  
  43.             code = dlclose(flib);  
  44.             dlError = dlerror();  
  45.   
  46.             if(code){  
  47.                 fprintf(stderr, "close lib error\n");  
  48.                 g_slist_free(list);  
  49.                 return -1;  
  50.             }  
  51.         }  
  52.     }  
  53.       
  54.     g_slist_free(list);  
  55.     return 0;  
  56. }  

 

首先,定义一个GSList,然后将其传递给load_plugins,load_plugins解析plugin.xml,然后填充list返回,calc_test遍历插件列表,并调用每一个插件定义的entry.

 

除法器

 我们来看一个具体的插件:做除法的模块

 

C代码  收藏代码
  1. #include <stdio.h>  
  2.   
  3. double div(double a, double b){  
  4.     if(b == 0){  
  5.         fprintf(stderr, "div zero error\n");  
  6.         return -1;  
  7.     }else{  
  8.         return a / b;  
  9.     }  
  10. }  

diver.c在编译之后,生成diver.so,将其置于plugin.xml定义的位置处即可。

 

运行结果如下图所示:


其他代码如xml的解析,GSList的使用等与插件机制关系不大,感兴趣的朋友可以在附件中查看。






转自:http://abruzzi.iteye.com/blog/739673



原创粉丝点击