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

 

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

刺猬@http://blog.csdn.net/littlehedgehog

[获取配置文件信息]

说来比较打击积极性的是我们还得做一番比较麻烦的但是却又没多少挑战性的事业，因为如果clamd这个服务端全部都用命令行来指定信息的话，Clamav估计会没有市场，因为打字就会累死管理员。我们要设置比如像多久升级一次啊，升级服务器在哪里下载这些东西这些乱七八糟的东西，我们都要给程序指定。去看看配置文件吧，想想看如果那些都要靠人来输入，这容易让人抓狂。但是配置文件这个是必须要看的。我们捡一个例子来说：

1. # Maximal size of the log file.
2. # Value of 0 disables the limit.
3. # You may use 'M' or 'm' for megabytes (1M = 1m = 1048576 bytes)
4. # and 'K' or 'k' for kilobytes (1K = 1k = 1024 bytes). To specify the size
5. # in bytes just don't use modifiers.
6. # Default: 1M
7. #LogFileMaxSize 2M
8. 
   

就看最后一行了吧，这里是设置log日志文件的大小，参数就是LogFileMaxSize，而参数值就是2M，中间用空格隔开。这里设置log文件因为clamd是后台作业的，它就像哑巴一样，没有终端可以提供给它打印信息。当然它在后台还是可以打开文件的，所以就让它往log文件里面写内容，我们事后来查。

这里是分析的主函数，贴着方便分析。

1. //分析配置文件 message表示是否要显示信息
2. struct cfgstruct *parsecfg(const char *cfgfile, int messages)
3. {
4.     char buff[LINE_LENGTH], *name, *arg;
5.     FILE *fs;
6.     int line = 0, i, found, ctype, calc;
7.     struct cfgstruct *copt = NULL;
8.     struct cfgoption *pt;
10.     struct cfgoption cfg_options[] =
11.     {
12.         {"LogFile", OPT_STR
13.         },
14.         {"LogFileUnlock", OPT_NOARG},
15.         {"LogFileMaxSize", OPT_COMPSIZE},
16.         {"LogTime", OPT_NOARG},
17.         {"LogClean", OPT_NOARG},
18.         {"LogVerbose", OPT_NOARG}, /* clamd + freshclam */
19.         {"LogSyslog", OPT_NOARG},
20.         {"LogFacility", OPT_STR},
21.         {"PidFile", OPT_STR},
22.         {"TemporaryDirectory", OPT_STR},
23.         {"DisableDefaultScanOptions", OPT_NOARG},
24.         {"ScanPE", OPT_NOARG},
25.         {"DetectBrokenExecutables", OPT_NOARG},
26.         {"ScanMail", OPT_NOARG},
27.         {"MailFollowURLs", OPT_NOARG},
28.         {"ScanHTML", OPT_NOARG},
29.         {"ScanOLE2", OPT_NOARG},
30.         {"ScanArchive", OPT_NOARG},
31.         {"ScanRAR", OPT_NOARG},
32.         {"ArchiveMaxFileSize", OPT_COMPSIZE},
33.         {"ArchiveMaxRecursion", OPT_NUM},
34.         {"ArchiveMaxFiles", OPT_NUM},
35.         {"ArchiveMaxCompressionRatio", OPT_NUM},
36.         {"ArchiveLimitMemoryUsage", OPT_NOARG},
37.         {"ArchiveBlockEncrypted", OPT_NOARG},
38.         {"ArchiveBlockMax", OPT_NOARG},
39.         {"DataDirectory", OPT_STR}, /* obsolete */
40.         {"DatabaseDirectory", OPT_STR}, /* clamd + freshclam */
41.         {"TCPAddr", OPT_STR},
42.         {"TCPSocket", OPT_NUM},
43.         {"LocalSocket", OPT_STR},
44.         {"MaxConnectionQueueLength", OPT_NUM},
45.         {"StreamMaxLength", OPT_COMPSIZE},
46.         {"StreamMinPort", OPT_NUM},
47.         {"StreamMaxPort", OPT_NUM},
48.         {"MaxThreads", OPT_NUM},
49.         {"ReadTimeout", OPT_NUM},
50.         {"IdleTimeout", OPT_NUM},
51.         {"MaxDirectoryRecursion", OPT_NUM},
52.         {"FollowDirectorySymlinks", OPT_NOARG},
53.         {"FollowFileSymlinks", OPT_NOARG},
54.         {"ExitOnOOM", OPT_NOARG},
55.         {"Foreground", OPT_NOARG}, /* clamd + freshclam */
56.         {"Debug", OPT_NOARG},
57.         {"LeaveTemporaryFiles", OPT_NOARG},
58.         {"FixStaleSocket", OPT_NOARG},
59.         {"User", OPT_STR},
60.         {"AllowSupplementaryGroups", OPT_NOARG},
61.         {"SelfCheck", OPT_NUM},
62.         {"VirusEvent", OPT_FULLSTR},
63.         {"ClamukoScanOnLine", OPT_NOARG}, /* old name */
64.         {"ClamukoScanOnAccess", OPT_NOARG},
65.         {"ClamukoScanOnOpen", OPT_NOARG},
66.         {"ClamukoScanOnClose", OPT_NOARG},
67.         {"ClamukoScanOnExec", OPT_NOARG},
68.         {"ClamukoIncludePath", OPT_STR},
69.         {"ClamukoExcludePath", OPT_STR},
70.         {"ClamukoMaxFileSize", OPT_COMPSIZE},
71.         {"ClamukoScanArchive", OPT_NOARG},
72.         {"DatabaseOwner", OPT_STR}, /* freshclam */
73.         {"Checks", OPT_NUM}, /* freshclam */
74.         {"UpdateLogFile", OPT_STR}, /* freshclam */
75.         {"DNSDatabaseInfo", OPT_STR}, /* freshclam */
76.         {"DatabaseMirror", OPT_STR}, /* freshclam */
77.         {"MaxAttempts", OPT_NUM}, /* freshclam */
78.         {"HTTPProxyServer", OPT_STR}, /* freshclam */
79.         {"HTTPProxyPort", OPT_NUM}, /* freshclam */
80.         {"HTTPProxyUsername", OPT_STR}, /* freshclam */
81.         {"HTTPProxyPassword", OPT_STR}, /* freshclam */
82.         {"NotifyClamd", OPT_OPTARG}, /* freshclam */
83.         {"OnUpdateExecute", OPT_FULLSTR}, /* freshclam */
84.         {"OnErrorExecute", OPT_FULLSTR}, /* freshclam */
85.         {"LocalIPAddress", OPT_STR}, /* freshclam */
86.         {0, 0}
87.     };
90.     if ((fs = fopen(cfgfile, "r")) == NULL)
91.         return NULL;
93.     while (fgets(buff, LINE_LENGTH, fs)) //每次读一行
94.     {
96.         line++;
98.         if (buff[0] == '#')
99.             continue;
101.         if (!strncmp("Example", buff, 7))   //clamd.conf 里面本来有一个example，提供给用户照着样子设置  同时就要求用户设置好了后要把example注释掉(前面加一个#)
102.         {
103.             if (messages)
104.                 fprintf(stderr, "ERROR: Please edit the example config file %s./n", cfgfile);
105.             fclose(fs);
106.             return NULL;
107.         }
110.         if ((name = cli_strtok(buff, 0, " /r/n")))
111.         {
112.             arg = cli_strtok(buff, 1, " /r/n");
113.             found = 0;
114.             for (i = 0; ; i++)
115.             {
116.                 pt = &cfg_options[i];       //从选项数组中依次寻找
117.                 if (pt->name)
118.                 {
119.                     if (!strcmp(name, pt->name))
120.                     {
121.                         found = 1;
122.                         switch (pt->argtype)
123.                         {
124.                         case OPT_STR:       //字符串参数
125.                             if (!arg)
126.                             {
127.                                 if (messages)
128.                                     fprintf(stderr, "ERROR: Parse error at line %d: Option %s requires string as argument./n", line, name);
129.                                 fclose(fs);
130.                                 return NULL;
131.                             }
132.                             copt = regcfg(copt, name, arg, 0);
133.                             break;
134.                         case OPT_FULLSTR:   //占一行的字符串参数 
135.                             if (!arg)
136.                             {
137.                                 if (messages)
138.                                     fprintf(stderr, "ERROR: Parse error at line %d: Option %s requires string as argument./n", line, name);
139.                                 fclose(fs);
140.                                 return NULL;
141.                             }
142.                             /* FIXME: this one is an ugly hack of the above case */
143.                             free(arg);
144.                             arg = strstr(buff, " ");
145.                             arg = strdup(++arg);
146.                             copt = regcfg(copt, name, arg, 0);
147.                             break;
148.                         case OPT_NUM:       //参数是数字
149.                             if (!arg || !isnumb(arg))
150.                             {
151.                                 if (messages)
152.                                     fprintf(stderr, "ERROR: Parse error at line %d: Option %s requires numerical argument./n", line, name);
153.                                 fclose(fs);
154.                                 return NULL;
155.                             }
156.                             copt = regcfg(copt, name, NULL, atoi(arg));
157.                             free(arg);
158.                             break;
159.                         case OPT_COMPSIZE:      //表示转换Kb和Mb到byte  这里是处理用户设置的一些文件大小选项
160.                             if (!arg)
161.                             {
162.                                 if (messages)
163.                                     fprintf(stderr, "ERROR: Parse error at line %d: Option %s requires argument./n", line, name);
164.                                 fclose(fs);
165.                                 return NULL;
166.                             }
167.                             ctype = tolower(arg[strlen(arg) - 1]);      //全设置为小写 方便下面比较
168.                             if (ctype == 'm' || ctype == 'k')
169.                             {
170.                                 char *cpy = (char *) mcalloc(strlen(arg), sizeof(char));
171.                                 strncpy(cpy, arg, strlen(arg) - 1);
172.                                 if (!isnumb(cpy))       //如果不是数字
173.                                 {
174.                                     if (messages)
175.                                         fprintf(stderr, "ERROR: Parse error at line %d: Option %s requires numerical (raw/K/M) argument./n", line, name);
176.                                     fclose(fs);
177.                                     return NULL;
178.                                 }
179.                                 if (ctype == 'm')   //mb转化为b
180.                                     calc = atoi(cpy) * 1024 * 1024;
181.                                 else
182.                                     calc = atoi(cpy) * 1024;
183.                                 free(cpy);
184.                             }
185.                             else
186.                             {
187.                                 if (!isnumb(arg))
188.                                 {
189.                                     if (messages)
190.                                         fprintf(stderr, "ERROR: Parse error at line %d: Option %s requires numerical (raw/K/M) argument./n", line, name);
191.                                     fclose(fs);
192.                                     return NULL;
193.                                 }
194.                                 calc = atoi(arg);
195.                             }
196.                             copt = regcfg(copt, name, NULL, calc);
197.                             free(arg);
198.                             break;
199.                         case OPT_NOARG:
200.                             if (arg)
201.                             {
202.                                 if (messages)
203.                                     fprintf(stderr, "ERROR: Parse error at line %d: Option %s doesn't support arguments (got '%s')./n", line, name, arg);
204.                                 fclose(fs);
205.                                 return NULL;
206.                             }
207.                             copt = regcfg(copt, name, NULL, 0);
208.                             break;
209.                         case OPT_OPTARG:
210.                             copt = regcfg(copt, name, arg, 0);
211.                             break;
212.                         default:
213.                             if (messages)
214.                                 fprintf(stderr, "ERROR: Parse error at line %d: Option %s is of unknown type %d/n", line, name, pt->argtype);
215.                             free(name);
216.                             free(arg);
217.                             break;
218.                         }
219.                     }
220.                 }
221.                 else
222.                     break;
223.             }
225.             if (!found)
226.             {
227.                 if (messages)
228.                     fprintf(stderr, "ERROR: Parse error at line %d: Unknown option %s./n", line, name);
229.                 fclose(fs);
230.                 return NULL;
231.             }
232.         }
233.     }
235.     fclose(fs);
236.     return copt;
237. }

这里作者在解析配置文件时用了自己的一个函数：char *cli_strtok(const char *line, int fieldno, const char *delim) 注意这个函数的用意是指在line中查找第fieldno个指定字符分解符delim，这里的delim是个字符串。为什么不用strtok呢，因为strtok只能提供分界字符，而这里我们需要的是多个可能的分界符。仍举刚才的例子： LogFileMaxSize 2M ，这里我们要挖掘出参数LogFileMaxSize ，参数值2M，中间可能是隔一个空格，也可能是其它字符，比如’/r'等,所以我们传递进去分界符是" /r/n". 看看源代码吧

1. /*
2. * char *cli_strok(const char *line, int fieldno, char *delim)
3. * Return a copy of field <fieldno> from the string <line>, where
4. * fields are delimited by any char from <delim>, or NULL if <line>
5. * doesn't have <fieldno> fields or not enough memory is available.
6. * The caller has to free() the result afterwards.
7. */
8. char *cli_strtok(const char *line, int fieldno, const char *delim)
9. {
10.     int counter = 0, i, j;
11.     char *buffer = NULL;
12. 
    
13. 
    
14.     /* step to arg # <fieldno> */
15.     for (i=0; line[i] && counter != fieldno; i++)   //count 是计数器 这个其实不说也知道
16.     {
17.         if (strchr(delim, line[i]))         //注意 是在delim里面查找当前字符line[i]
18.         {
19.             counter++;
20.             while(line[i+1] && strchr(delim, line[i+1]))        //这里是过滤多个 比如你连续输入了多个空格
21.             {
22.                 i++;
23.             }
24.         }
25.     }
26.     if (!line[i]) 
27.     {
28.         /* end of buffer before field reached */
29.         return NULL;
30.     }
31. 
    
32.     for (j=i; line[j]; j++)         //这里的i已经是空格后面一个字符了 这里我们是为了选取从这个空格到下个空格之间的字符串
33.     {
34.         if (strchr(delim, line[j]))
35.         {
36.             break;
37.         }
38.     }
39.     if (i == j) 
40.     {
41.         return NULL;
42.     }
43.     buffer = malloc(j-i+1);     //开辟空间
44.     if(!buffer)
45.         return NULL;
46.     strncpy(buffer, line+i, j-i);
47.     buffer[j-i] = '/0';
48. 
    
49.     return buffer;
50. }
51. 
    

同样的在处理配置文件时候我们也是采用了链表的形式,把参数和参数值以及参数类别加入节点在组装成链表. 来先看看节点,这个稍有不同.

1. struct cfgstruct
2. {
3.     char *optname;      //选项名
4.     char *strarg;       //参数(字符串)
5.     int numarg;         //参数(数字)  参数有字符串和数字两种形式 所以我们要分开装
6.     struct cfgstruct *nextarg;      //下一个参数值
7.     struct cfgstruct *next;         //下一个参数    这两者又是什么关系?  I hear you ask  注意 一个参数可能有多个参数值 所以这里作者这样设置
8.     /*
9.         --->(参数类型一)--->(参数类型二)--->(参数类型三)....
10.             |
11.             |
12.             参数一
13.             |
14.             |
15.             参数二
17.             可以这么理解 next是连接参数主干的  而nextarg是分支
18.     */
19. };
21. 
    

因为一个参数可能有多个参数值,所以形成这种变态的树形结构. 但是无伤大雅的,我们接着看如何把节点加入链表,作者命名为register,比较专业...

1. struct cfgstruct *regcfg(struct cfgstruct *copt, char *optname, char *strarg, int numarg)
2. {
3.     struct cfgstruct *newnode, *pt;
5.     newnode = (struct cfgstruct *) mmalloc(sizeof(struct cfgstruct));
6.     newnode->optname = optname;
7.     newnode->nextarg = NULL;
8.     newnode->next = NULL;
10.     /*下面是根据不同类型参数值(数字还是字符串 To be or Not to be ？)*/
11.     if (strarg)
12.         newnode->strarg = strarg;
13.     else
14.     {
15.         newnode->strarg = NULL;
16.         newnode->numarg = numarg;
17.     }
19.     if ((pt = cfgopt(copt, optname)))   //在链表中搜索
20.     {
21.         while (pt->nextarg)             //如果找到了一个和该参数相同类型的节点  那我们加入到它的nextarg中去  在分支上做文章
22.             pt = pt->nextarg;
24.         pt->nextarg = newnode;
25.         return copt;
26.     }
27.     else                                //没找到 在链表主干上添上一笔
28.     {
29.         newnode->next = copt;
30.         return newnode;                 //特别要注意这个返回值  它表明我们这个链表是个栈链表  也就是所caller里面的那个copt永远都是指向链表开头的  这也就是为什么我们能搜索的原因(cfpopt)
31.     }
32. }

我最后专门强调了这个返回值,因为这个是一个单链表,我们必须要把握住链表的头部,俗话说擒贼先擒王嘛. 比如这里我们要搜索,那肯定要从头部开始了.

1. 
   
2. struct cfgstruct *cfgopt(const struct cfgstruct *copt, const char *optname)
3. {
4.     struct cfgstruct *handler;
5. 
   
6.     handler = (struct cfgstruct *) copt;        //从链表开头搜索  
7.     /*为了找到这个参数 我们不惜用上了死循环*/
8.     while (1)
9.     {
10.         if (handler)
11.         {
12.             if (handler->optname)
13.                 if (!strcmp(handler->optname, optname))     //参数名相同 表示找到了
14.                     return handler;
15.         }
16.         else
17.             break;      //链表为空 说明一个问题——到头了
18.         handler = handler->next;
19.     }
20. 
    
21.     return NULL;
22. }