Clamav杀毒软件源码分析笔记[二]

 

  Clamav杀毒软件源码分析笔记[二]

刺猬@http://blog.youkuaiyun.com/littlehedgehog

[读取命令行参数]

开始正儿八经地分析源码了. 从哪里入手呢，当然还是按照书上的来，我们先来看看Clamd的程序如何从生到死，Clamd是杀毒软件的服务端，我们在客户端提交要查杀的信息，然后Clamd服务端进行按照我们指令办事，然后把结果返回给我们。这个貌似是unix程序的一个经典构架了，所谓的客户端直接跟用户打交道，然后解析用户输入，把真正要做的工作再传给服务端完成。服务端其实是一个无名英雄了。 话说回来这里第一步我们就要处理命令行下琐碎的各个参数选项.为了让Clamd服务端按照我们要求来运行，这貌似是个相当麻烦的工作,比女人都麻烦,呵呵. 不过还好网上有不少linux fans 都写过相应的博文了.  还是先来看源码吧: [./clamd/options.c]

1. /* 这个是clamd的主函数 文件名为options,那么这个主函数就主要在处理这个选项(参数选项)问题了*/
2. int main(int argc, char **argv)
3. {
4.     int ret, opt_index, i, len;
5.     struct optstruct *opt;
7.     const char *getopt_parameters = "hc:V";
9.     static struct option long_options[] =
10.     {
11.         {"help", 0, 0, 'h'},
12.         {"config-file", 1, 0, 'c'},
13.         {"version", 0, 0, 'V'},
14.         {"debug", 0, 0, 0},
15.         {0, 0, 0, 0}
16.     };
18. #if defined(C_LINUX) && defined(CL_DEBUG)
19.     /* njh@bandsman.co.uk: create a dump if needed */
20.     struct rlimit rlim;
22.     rlim.rlim_cur = rlim.rlim_max = RLIM_INFINITY;
23.     if (setrlimit(RLIMIT_CORE, &rlim) < 0)
24.         perror("setrlimit");
25. #endif
26.     opt=(struct optstruct*)mcalloc(1, sizeof(struct optstruct));
27.     opt->optlist = NULL;
28.     opt->filename = NULL;
30.     while (1)
31.     {
33.         opt_index=0;
34.         ret=getopt_long(argc, argv, getopt_parameters, long_options, &opt_index);
36.         if (ret == -1)
37.             break;
39.         switch (ret)
40.         {
41.         case 0:
42.             register_long_option(opt, long_options[opt_index].name);
43.             break;
45.         default:
46.             if (strchr(getopt_parameters, ret))
47.                 register_char_option(opt, ret);
48.             else
49.             {
50.                 fprintf(stderr, "ERROR: Unknown option passed./n");
51.                 free_opt(opt);
52.                 exit(40);
53.             }
54.         }
55.     }
57.     if (optind < argc)
58.     {
60.         len=0;
62.         /* count length of non-optin arguments 下面是处理非选项参数*/
64.         for (i=optind; i<argc; i++)
65.             len+=strlen(argv[i]);
67.         len=len+argc-optind-1; /* add spaces between arguments */
68.         opt->filename=(char*)mcalloc(len + 256, sizeof(char));
70.         for (i=optind; i<argc; i++)
71.         {
72.             strncat(opt->filename, argv[i], strlen(argv[i]));
73.             if (i != argc-1)
74.                 strncat(opt->filename, " ", 1);
75.         }
77.     }
79.     clamd(opt);
81.     free_opt(opt);
83.     cli_dbgmsg("exit main()");
84.     return(0);
85. }

代码不长,逻辑也不复杂. 不过在理解GNU提供给我们截获参数选项操作之前,我们确实应该先来明确一下处理的关键点在哪里.比如说有如下命令行 command -h   这是我们来获取command使用帮助的时候键入的命令. 也就是说按照约定,我们键入-h 就是表明要显示出帮助手册,但是在linux/unix里,我们有时候也键入全称来输入参数,比如说command --help 两横加上全称,同样也是表明我们需要帮助手册.为了能处理以上两种情况,我们需要做更多的准备.  好了,下面的文字是网上拷来的,呵呵,这也是代码复用的思想...

============================================

摘自冰火天地 《getopt_long及其使用》

========================================

Linux系统下，需要大量的命令行选项，如果自己手动解析他们的话实在是有违软件复用的思想，不过还好，GNU C library留给我们一个解析命令行的接口(X/Open规范)，好好使用它可以使你的程序改观不少。

使用getopt_long()需要引入头文件

#include <getopt.h>

     现在我们使用一个例子来说明它的使用。

一个应用程序需要如下的短选项和长选项。


      短选项               长选项                           作用

      -h                      --help                           输出程序命令行参数说明然后退出
      -o filename        --output filename      给定输出文件名
      -v                      --version                       显示程序当前版本后退后

为了使用getopt_long函数，我们需要先确定两个结构：

1.一个字符串，包括所需要的短选项字符，如果选项后有参数，字符后加一个":"符号。本例中，这个字符串应该为"ho:v"。(因为-o后面有参数filename，所以字符后面要加":")

2.一个包含长选项字符串的结构体数组，每一个结构体包含4个域，第一个域为长选项字符串，第二个域是一个标识，只能为0或1，分别代表没有、有。第三个域永远为NULL。第四个域为对应的短选项字符串。结构体数组的最后一个元素全部为NULL和0，标识结束。在本例中，它应该像一下的样子：

     const struct option long_options[] = {
         { "help",        0, NULL, 'h' },
         { "output",      1, NULL, 'o' },
         { "version", 0, NULL, 'v' },
         { NULL,          0, NULL, 0}
      };

调用时需要把main的两个参数argc和argv以及上述两个数据结构传给getopt_long。
每次调用getopt_long，它会解析一个符号，返回相应的短选项字符，如果解析完毕返回－1。所以需要使用一个循环来处理所有的参数，而相应的循环里会使用switch语句进行选择。如果getopt_long遇到一个无效的选项字符，它会打印一个错误消息并且返回'?'，很多程序会打印出帮助信息并且中止运行；当getopt_long解析到一个长选项并且发现后面没有参数则返回':'，表示缺乏参数。当处理一个参数时，全局变量optarg指向下一个要处理的变量。当getopt_long处理完所有的选项后，全局变量optind指向第一个未知的选项索引。

这一个例子代码为下:

1. //编译使用gcc -o getopt_long getopt_long.c
2. #include <getopt.h>
3. #include <stdio.h>
4. #include <stdlib.h>
6. /*程序的名字*/
7. const char* program_name;
9. /* 打印程序参数 */
10. void print_usage (FILE* stream, int exit_code)
11. {
12. fprintf (stream, "Usage: %s options [ inputfile ... ]/n", program_name);
13. fprintf (stream, " -h --help                       显示这个帮助信息./n"
14.                              " -o --output filename 将输出定位到文件./n"
15.                              " -v --version                  打印版本信息./n");
16. exit (exit_code);
17. }
20. /* 主程序 */
21. int main (int argc, char* argv[])
22. {
23. int next_option;//下一个要处理的参数符号
24. int haveargv = 0;//是否有我们要的正确参数，一个标识
25.            
26. /* 包含短选项字符的字符串，注意这里的‘：’ */
27.           
28. const char* const short_options = "ho:v";
29.               
30. /* 标识长选项和对应的短选项的数组 */
31.               
32. const struct option long_options[] = {
33.                    { "help",        0, NULL, 'h' },
34.                    { "output",      1, NULL, 'o' },
35.                    { "version", 0, NULL, 'v' },
36.                    { NULL,         0, NULL, 0     }};//最后一个元素标识为NULL
37.                     
38.     /* 此参数用于承放指定的参数，默认为空 */
39. const char* output_filename = NULL;
40. /* 一个标志，是否显示版本号 */
41. int verbose = 0;
43. /* argv[0]始终指向可执行的文件文件名 */
44.                              
45. program_name = argv[0];
46.     
47. do
48. {
49.     next_option = getopt_long (argc, argv, short_options, long_options, NULL);
50.     switch (next_option)
51.     {
52.      case 'h':     /* -h or --help */    
53.        haveargv = 1;
54.        print_usage (stdout, 0);
55.      case 'o':     /* -o or --output */
56.          /* 此时optarg指向--output后的filename */
57.       output_filename = optarg;
58.       haveargv = 1;
59.       break;
60.      case 'v':     /* -v or    --version */
61.       verbose = 1;
62.       haveargv = 1;
63.       break;
64.      case ':':     /* 缺乏长选项内容 */
65.       break;
66.      case '?':     /* 出现一个未指定的参数*/
67.       print_usage (stderr, 1);
68.      case -1:      /* 处理完毕后返回-1 */
69.              if (!haveargv)
70.              {
71.                    print_usage (stderr, 1);
72.              }
73.       break;
74.      default:      /* 未指定的参数出现，出错处理 */
75.       print_usage (stderr, 1);
76.                                   break;
77.     }
78. }while (next_option !=-1);
79.                             
80. if (verbose)
81. {
82.     int i;
83.     for (i = optind; i < argc; ++i)
84.     printf ("Argument: %s/n", argv[i]);
85. }                           
86.                         
87. return 0;
88. }

============================================

文章节录完

============================================

把参数一个一个筛选出来后总要放一个地方吧，Clamav的作者选择把参数选项嵌入到一个链表中以方便传递。那我们再来看看如何把得到参数加入链表。这里以register_char_option为例说明：　

2. /*短选项加入链表 比如--config_file=test 注意 这里虽然是个长选项 但是它含有短字符代表，即是字符c    {"config-file", 1, 0, 'c'}    */
3. void register_char_option(struct optstruct *opt, char ch)
4. {
5.     struct optnode *newnode;
7.     newnode = (struct optnode *) mmalloc(sizeof(struct optnode));
8.     newnode->optchar = ch;
9.     if (optarg != NULL)
10.     {
11.         newnode->optarg = (char *) mcalloc(strlen(optarg) + 1, sizeof(char));   //参数值，这里就是test
12.         strcpy(newnode->optarg, optarg);
13.     }
14.     else
15.         newnode->optarg = NULL;
17.     newnode->optname = NULL;    
18.     newnode->next = opt->optlist;   //连入链表
19.     opt->optlist = newnode;
20. }

opt和newnode的结构如下所示：

1. struct optnode
2. {
3.     char optchar;   //短选项名　比如文中举例的 h 选项 
4.     char *optarg;   //参数值， 有时候我们对参数要设定值的，比如 -p 23 这里23就是参数值
5.     char *optname;　//长选项名， 文中举例的help这个字符串就应该放在这里，跟前面h对应
6.     struct optnode *next;　//下一个节点呗，我们要连成链表阿
7. };
8. 
   
9. struct optstruct
10. {
11.     struct optnode *optlist;
12.     char *filename;
13. };

这样我们就得到了一个满载参数的链表了，这样函数传参就会很简单，因为直接可以传递这个链表即可，这样我们拿着链表就相当于得到了用户所有需求，比如你看看main函数里面马上就跟着一句 clamd(opt);  这就是为什么我们要急着转化为链表的原因了。如果需要在链表中搜寻所需的参数那是很简单的，只需要遍历链表即可。比如：

1. //寻找opt参数链表中是否含有指定字符ch的node
2. int optc(const struct optstruct *opt, char ch)
3. {
4.     struct optnode *handler;
6.     handler = opt->optlist;
8.     while (1)
9.     {
10.         if (handler)
11.         {
12.             if (handler->optchar == ch)
13.                 return 1;
14.         }
15.         else
16.             break;
17.         handler = handler->next;
18.     }
20.     return(0);
21. }

非常简洁，因为我们参数本来就不多，否则我们应该重新设计数据结构，比如我们要用hash表来快速定位。