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

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

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

[客户端处理]

服务端已经把主要的工作都已经处理的差不多了,剩下来也就是服务端等待客户端提出请求,然后根据客户端的请求做相应的工作. 所以客户端所做的事情就只是提交数据,然后坐享其成.服务端是在垂帘听政呢,还是做幕后英雄?话不多说了,下面进入正题.

客户端(clamdscan)的主函数main和clamscan其实用的是同一个main,当然里面的内容同样还是处理命令行,配置文件等相关信息,乏善可陈,经过这系列处理之后,我们来到了client这个客户端的逻辑处理主函数.但是我还是不准备详细来说这个函数,因为它除了因为客户端只是创建socket和使用connect对服务端进行连接而不需要啥绑定,监听,实在和服务端的创建没多少代码上的区别. 只是在连接的时候,我们要分配置文件里是设定的本地连接还是网络连接. 如下所示:

1. /* 创建套间字 并建立链接*/
2. int dconnect(const struct optstruct *opt)
3. {
4.     struct sockaddr_un server;                              //这里定义了两个地址,注意一个为AF_UNIX,而另一个为AF_INET
5.     struct sockaddr_in server2;
6.     struct hostent *he;
7.     struct cfgstruct *copt, *cpt;
8.     const char *clamav_conf = getargl(opt, "config-file");  //从config-file中获取配置文件名
9.     int sockd;
10. 
    
11. 
    
12.     if (!clamav_conf)
13.         clamav_conf = DEFAULT_CFG;
14. 
    
15.     if ((copt = parsecfg(clamav_conf, 1)) == NULL)
16.     {
17.         mprintf("@Can't parse the configuration file./n");
18.         return -1;
19.     }
20. 
    
21.     memset((char *) &server, 0, sizeof(server));
22.     memset((char *) &server2, 0, sizeof(server2));
23. 
    
24.     /* Set default address to connect to 这里默认是设置为本地地址*/
25.     server2.sin_addr.s_addr = inet_addr("127.0.0.1");
26. 
    
27.     if (cfgopt(copt, "TCPSocket") && cfgopt(copt, "LocalSocket"))   //TCPSocket 和   LocalSocket 只能配置一个
28.     {
29.         mprintf("@Clamd is not configured properly./n");
30.         return -1;
31.     }
32.     else if ((cpt = cfgopt(copt, "LocalSocket")))       //本地socket,也就是用AF_UNIX地址域啦
33.     {
34. 
    
35.         server.sun_family = AF_UNIX;
36.         strncpy(server.sun_path, cpt->strarg, sizeof(server.sun_path));
37. 
    
38.         if ((sockd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
39.         {
40.             perror("socket()");
41.             mprintf("@Can't create the socket./n");
42.             return -1;
43.         }
44. 
    
45.         if (connect(sockd, (struct sockaddr *) &server, sizeof(struct sockaddr_un)) < 0)
46.         {
47.             close(sockd);
48.             perror("connect()");
49.             mprintf("@Can't connect to clamd./n");
50.             return -1;
51.         }
52. 
    
53.     }
54.     else if ((cpt = cfgopt(copt, "TCPSocket")))
55.     {
56. 
    
57.         if ((sockd = socket(SOCKET_INET, SOCK_STREAM, 0)) < 0)
58.         {
59.             perror("socket()");
60.             mprintf("@Can't create the socket./n");
61.             return -1;
62.         }
63. 
    
64.         server2.sin_family = AF_INET;
65.         server2.sin_port = htons(cpt->numarg);
66. 
    
67.         if ((cpt = cfgopt(copt, "TCPAddr")))
68.         {
69.             if ((he = gethostbyname(cpt->strarg)) == 0)     //这里默认的地址其实是127.0.0.1 还是本地的
70.             {
71.                 close(sockd);
72.                 perror("gethostbyname()");
73.                 mprintf("@Can't lookup clamd hostname./n");
74.                 return -1;
75.             }
76.             server2.sin_addr = *(struct in_addr *) he->h_addr_list[0];      //确实可能存在一个主机对应多个IP地址,比如多个网卡,这里只取第一个了
77.         }
78. 
    
79.         if (connect(sockd, (struct sockaddr *) &server2, sizeof(struct sockaddr_in)) < 0)
80.         {
81.             close(sockd);
82.             perror("connect()");
83.             mprintf("@Can't connect to clamd./n");
84.             return -1;
85.         }
86. 
    
87.     }
88.     else
89.     {
90.         mprintf("@Clamd is not configured properly./n");
91.         return -1;
92.     }
93. 
    
94.     return sockd;
95. }
96. 
    
97. 
    

建立完连接之后,我们要做得就是提交各种任务给服务端让它做了,不能让它手下一大批线程给闲着.这里我们还是依照书上内容,看看stream扫描:

1.   else if (!strcmp(opt->filename, "-"))  /* scan data from stdin  这个是作者的规定,哈哈我也没办法 比如cat testfile | clamscan - 后面加一个"-"表明从stdin获得数据流 所以这里用了cat的输出作为扫描的输入　*/
2.     {
3.         if ((sockd = dconnect(opt)) < 0)
4.             return 2;
6.         if ((ret = dsstream(sockd, opt)) >= 0)
7.             *infected += ret;
8.         else
9.             errors++;
11.         close(sockd);
12.     }

stream的扫描就是在命令行里面加上一个'-', 利用linux强大的重定向功能,我们把文件的内容作为数据流传给服务端.

1. /* 把文件标准输入流通过临时套间字传递给服务端扫描 
2.  * 整个过程如下:
3.  * 1 通知服务端我们要传数据流过来
4.  * 2 服务端分配临时端口,这个端口是为了接收我们的数据流设定的
5.  * 3 传数据流过去呗
6.  */
7. int dsstream(int sockd, const struct optstruct *opt)
8. {
9.     int wsockd, loopw = 60, bread, port, infected = 0;
10.     struct sockaddr_in server;
11.     struct sockaddr_in peer;
12.     int peer_size;
13.     char buff[4096], *pt;
15.     //这里告诉服务端我们传的是数据流
16.     if (write(sockd, "STREAM", 6) <= 0)
17.     {
18.         mprintf("@Can't write to the socket./n");
19.         return 2;
20.     }
22.     memset(buff, 0, sizeof(buff));
23.     /* 读取服务端传过来的端口号 */
24.     while (loopw)
25.     {
26.         read(sockd, buff, sizeof(buff));
27.         if ((pt = strstr(buff, "PORT")))
28.         {
29.             pt += 5;
30.             sscanf(pt, "%d", &port);    //注意sscanf用法
31.             break;
32.         }
33.         loopw--;
34.     }
36.     if (!loopw)
37.     {
38.         mprintf("@Daemon not ready for stream scanning./n");
39.         return -1;
40.     }
42.     /* connect to clamd */
44.     if ((wsockd = socket(SOCKET_INET, SOCK_STREAM, 0)) < 0)
45.     {
46.         perror("socket()");
47.         mprintf("@Can't create the socket./n");
48.         return -1;
49.     }
51.     server.sin_family = AF_INET;
52.     server.sin_port = htons(port);
53.     
54.     /* 通过socket获取对方信息*/
55.     peer_size = sizeof(peer);
56.     if (getpeername(sockd, (struct sockaddr *) &peer, &peer_size) < 0)
57.     {
58.         perror("getpeername()");
59.         mprintf("@Can't get socket peer name./n");
60.         return -1;
61.     }
62.     
63.     /*看看对方在哪里,是本地还是外面的...*/
64.     switch (peer.sin_family)
65.     {
66.     case AF_UNIX:
67.         server.sin_addr.s_addr = inet_addr("127.0.0.1");
68.         break;
69.     case AF_INET:
70.         server.sin_addr.s_addr = peer.sin_addr.s_addr;
71.         break;
72.     default:
73.         mprintf("@Unexpected socket type: %d./n", peer.sin_family);
74.         return -1;
75.     }
77.     if (connect(wsockd, (struct sockaddr *) &server, sizeof(struct sockaddr_in)) < 0)
78.     {
79.         close(wsockd);
80.         perror("connect()");
81.         mprintf("@Can't connect to clamd [port: %d]./n", port);
82.         return -1;
83.     }
84.     /* 从标准输入读取数据流然后写入到socket 服务端自会接应*/
85.     while ((bread = read(0, buff, sizeof(buff))) > 0)
86.     {
87.         if (write(wsockd, buff, bread) <= 0)
88.         {
89.             mprintf("@Can't write to the socket./n");
90.             close(wsockd);
91.             return -1;
92.         }
93.     }
94.     close(wsockd);
96.     memset(buff, 0, sizeof(buff));
97.     /* 下面是服务端的反馈消息 */
98.     while ((bread = read(sockd, buff, sizeof(buff))) > 0)
99.     {
100.         mprintf("%s", buff);
101.         if (strstr(buff, "FOUND/n"))
102.         {
103.             infected++;
104.             logg("%s", buff);
106.         }
107.         else if (strstr(buff, "ERROR/n"))
108.         {
109.             logg("%s", buff);
110.             return -1;
111.         }
112.         memset(buff, 0, sizeof(buff));
113.     }
115.     return infected;
116. }

 

这里有个小问题 在42行有句　if ((wsockd = socket(SOCKET_INET, SOCK_STREAM, 0)) < 0)

我们直接定死了是SOCKET_INET,那如果服务端在本地怎么办呢? 看看67行的处理:   server.sin_addr.s_addr = inet_addr("127.0.0.1");  也就是如果是UNIX域就是用本地IP地址作为sockaddr的地址了.

如果我们扫描到了病毒,这里我们就需要转移病毒文件了,因为这只是个扫毒软件,不能杀毒:

1. /* 隔离病毒文件   说的比较通俗点儿就是转移目录,转移了...*/
2. void move_infected(const char *filename, const struct optstruct *opt)
3. {
4.     char *movedir, *movefilename, *tmp, numext[4 + 1];
5.     struct stat fstat, mfstat;
6.     int n, len, movefilename_size;
7.     struct utimbuf ubuf;
8. 
   
9. 
   
10.     if (!(movedir = getargl(opt, "move")))      //文件隔离的目录
11.     {
12.         /* Should never reach here */
13.         mprintf("@getargc() returned NULL/n", filename);
14.         notmoved++;
15.         return;
16.     }
17.     
18.     /* 检查调用进程是否可以对指定的文件执行某种操作 */
19.     if (access(movedir, W_OK|X_OK) == -1)
20.     {
21.         mprintf("@error moving file '%s': cannot write to '%s': %s/n", filename, movedir, strerror(errno));
22.         notmoved++;
23.         return;
24.     }
25.     
26.     /* 查看病毒文件的stat */
27.     if (stat(filename, &fstat) == -1)
28.     {
29.         mprintf("@Can't stat file %s/n", filename);
30.         mprintf("Try to run clamdscan with clamd privileges/n");
31.         notmoved++;
32.         return;
33.     }
34. 
    
35.     if (!(tmp = strrchr(filename, '/')))
36.         tmp = (char *) filename;
37. 
    
38.     /* numext 是指如果病毒文件在隔离目录下面有同名文件,那我们要加后缀,比如有个virus文件,那就在后面加上一些字符串,避免同一文件夹下同名文件冲突,这个就是后缀预留空间 */
39.     movefilename_size = sizeof(char) * (strlen(movedir) + strlen(tmp) + sizeof(numext) + 2);
40. 
    
41.     if (!(movefilename = mmalloc(movefilename_size)))
42.     {
43.         mprintf("@Memory allocation error/n");
44.         exit(2);
45.     }
46. 
    
47.     if (!(strrcpy(movefilename, movedir)))
48.     {
49.         mprintf("@strrcpy() returned NULL/n");
50.         notmoved++;
51.         free(movefilename);
52.         return;
53.     }
54.     
55.     /* "路径名/" */
56.     strcat(movefilename, "/");
57.     /* "路径名/文件名" */
58.     if (!(strcat(movefilename, tmp)))
59.     {
60.         mprintf("@strcat() returned NULL/n");
61.         notmoved++;
62.         free(movefilename);
63.         return;
64.     }
65.     
66.     /* 这里我们用完整的路径名试探,看看这个文件存在不,呃,就这样吧,不知道怎么表达了 */
67.     if (!stat(movefilename, &mfstat))
68.     {
69.         if (fstat.st_ino == mfstat.st_ino)  /* It's the same file 通过inode号检验确实是同一个文件,注意文件名相同不能判定同一文件　*/
70.         {
71.             mprintf("File excluded '%s'/n", filename);
72.             logg("File excluded '%s'/n", filename);
73.             notmoved++;
74.             free(movefilename);
75.             return;
76.         }
77.         else            //到这里了,那就是隔离目录下面有同名文件
78.         {
79.             /* file exists - try to append an ordinal number to the
80.             * quranatined file in an attempt not to overwrite existing
81.             * files in quarantine
82.             */
83.             len = strlen(movefilename);
84.             n = 0;
85.             do
86.             {
87.                 /* reset the movefilename to it's initial value by
88.                 * truncating to the original filename length
89.                 */
90.                 movefilename[len] = 0;
91.                 /* append .XXX */
92.                 sprintf(numext, ".%03d", n++);  //右边对齐 最后格式是: 病毒名.032
93.                 strcat(movefilename, numext);   //加后缀
94.             }
95.             while (!stat(movefilename, &mfstat) && (n < 1000));     //这里只试探1000次,我想应该够了吧,除非你PC成了毒窝了...
96.         }
97.     }
98.     /* 两种方式来处理  第一个就是改名字,其实文件都在磁盘,具体路径还不是我们自己设定而已,所以改名就能转移目录*/
99.     if (rename(filename, movefilename) == -1)
100.     {
101.         if (filecopy(filename, movefilename) == -1)     //第二种方法就是直接拷贝了... 
102.         {
103.             mprintf("@cannot move '%s' to '%s': %s/n", filename, movefilename, strerror(errno));
104.             notmoved++;
105.             free(movefilename);
106.             return;
107.         }
108. 
     
109.         /* 下面由于我们是新建一个文件,然后拷贝原文件内容,所以文件权限和时间属性都变了,这里要改回来*/
110.         chmod(movefilename, fstat.st_mode);
111.         chown(movefilename, fstat.st_uid, fstat.st_gid);
112. 
     
113.         ubuf.actime = fstat.st_atime;
114.         ubuf.modtime = fstat.st_mtime;
115.         utime(movefilename, &ubuf);
116. 
     
117.         if (unlink(filename))       //删除原文件
118.         {
119.             mprintf("@cannot unlink '%s': %s/n", filename, strerror(errno));
120.             notremoved++;
121.             free(movefilename);
122.             return;
123.         }
124.     }
125. 
     
126.     mprintf("%s: moved to '%s'/n", filename, movefilename);
127.     logg("%s: moved to '%s'/n", filename, movefilename);
128. 
     
129.     free(movefilename);
130. }

转移主要就是一个copy,再加上同名文件的处理问题,有时候当你电脑成病毒窝的时候,可能病毒很多,统统转移到一个目录下面的时候造成同名冲突的可能性比较打,为了避免覆盖,这里就加上后缀. 这个好像很普遍的处理办法吧....