[原创]基于proc文件系统的简易主机端口扫描器

duanjigang

前几天因为工作需要,看了看Linux下的netstat的实现代码,自己便也写了一个简单的端口扫描器,贴出来显摆一下(^_^),希望能对某些朋友的开发工作有用.

          

基于proc文件系统的简易主机端口扫描器

一 引言
     proc文件是内核的一个快照, 它存储了系统运行时的状态信息,同时又可以作为输入接口- 用户可以修改/proc目录下一些文件中的内容来改变内核运行时的参数设置. 本文属于对第一种功能的应用,即通过读取proc文件来实现netstat命令的一些基本功能, 包括TCP和UDP端口的扫描(支持IPV6格式的地址).
二  /proc/net/文件介绍
打开Linux源代码中的文档proc.txt
(linux-2.6.16.20\Documentation\filesystems),我们可以在目录表中看到一栏
1.4                         Networking info in /proc/net
猜测一下,/proc/net目录下的文件大概存储的就是与网络有关的信息吧,定位到1.4看看具体的解释:
表1-6: /proc/net下的ipv6信息.
.................................................................
文件                    内容
udp6                    udp套接字(ipv6)
tcp6                    tcp套接字(ipv6)
raw6                    原始设备统计信息(ipv6)
.............
正如目录所介绍的, /proc/net下的文件存储了系统运行时与网络相关的信息,其中tcp文件中存储了TCP套接字的信息, udp文件中存储了UDP套接字的信息,本文的程序中要实现的端口扫描器的直接数据就是来源于此(还有tcp6文件和udp6文件).
三 从数据源入手
首先我们应该明确, 协议端口的概念只有在IP层以上的传输层才是有意义的, 因为IP层只能将IP数据包传送到主机,而无法分发给具体的进程, 为了实现传输层进程到进程的通讯功能, 除了使用主机IP地址外, 在TCP/IP协议中又加入了进程的区分标志,就是端口号的概念. 本文要实现的端口扫描程序就是要获取此类协议端口的信息.而这些协议端口又是与TCP,UDP套接字相关联的,所以只要获取到所有的套接字信息,也就取到了端口的信息,而proc文件系统正好在/proc/net的tcp(6)和udp(6)文件中为我们提供了所有的tcp与udp套接字的信息,所以我们可以很容易的从这些文件中解析出所有的端口信息.
接下来,看一下具体的文件内容:
less /pro/net/tcp
sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode
0: 00000000:8000 00000000:0000 0A 00000000:00000000 00:00000000 00000000    29        0 4804 1 f73bd700 3000 0 0 2 -1                             
   1: 3A00AA0A:00C7 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 25926 1 f73bc080 3000 0 0 2 -1                           
   2: 00000000:008B 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 5819 1 f6d37700 3000 0 0 2 -1                             
   3: 00000000:006F 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 4759 1 f73bdb80 3000 0 0 2 -1  
根据标题提示, 并和netstat -tn命令的输出进行对比, 可以分析出这个文件中每列数据的意义: 第一列是打开套接字的编号,1,2,3..表示打开了几个此种类型的套接字, 第二列是本地地址,格式为"十六进制(网络字节序)的IP地址:端口号", 第三列是远程地址,第四列是连接状态(st = status), 后面的信息与我们的程序没什么关系,不做介绍;而且文件中的每行都代表了一个完整的套接字的信息.同样可知, udp文件中的信息也是类似的组织起来的,只是在远程地址和状态上有些区别(udp套接字中对于远程地址不给出任何信息,而且UDP套接字不存在连接状态的概念).
      需要注意的另外一个问题就是, 如果我们的程序所在的机子支持IPV6协议的话,那么这个端口扫描程序应该也能表示出此类的IP地址,暂不谈IPV4和IPV6的具体区别有那些,单单从tcp和tcp6(如果你所使用的内核版本支持IPV6的话,/proc/net下面应该会有这个文件的)文件中的内容来对比, 可以得出一个初步的结论,那就是IPV4的IP地址采用8位的16进制数来表示,而IPV6的地址采用32位的16进制数来表示,所以你可以将一个IPV4的地址表示为XX.XX.XX.XX的形式, 而将一个IPV6的地址表示为
XXXX.XXXX.XXXX.XXXX. XXXX.XXXX.XXXX.XXXX的形式,事实上IPV6地址就是这样表示的(IPV4地址长度为128位,采用8位16进制数表示,而新的IPV6地址为128位,采用32位16进制数来表示),关于两者的细微区别,可以查阅其它资料,因为我并不知道太多..
      在netstat的源代码中,系统将每个套接字的所有信息存储在一个sockaddr_in结构体中,所以对于不同版本的IP协议, 就要使用不同类型的struct sockaddr_in,这一点似乎有些麻烦.仔细分析我们要实现的功能和proc目录下的文件, 可以发现, proc文件中存储的是纯粹的数据, 而其他的实现都是可选的,所以我们应该可以不使用任何与平台相关的数据结构就能完成这个功能,在本文中,我就是这么做的: 为了将128位的IPV6地址和32的IPV4地址采用统一的方式进行存储, 我们使用一个32字节的字符数组来存储IP地址, 每一位存储一个字符格式的十六进制数字,而没有采用网络编程的sockaddr结构体. 因为我的目的是使这个程序尽可能的简单,并尽量减少与平台的关联,因为它的原理很简单,就是读文件,所以,理论上说,在任何平台上,这个程序的代码都应该能编译通过,即所谓的平台无关性.事实上,本文的代码正式这样的(如果windows系统也提供了相同的proc文件的话,这个程序不需要任何修改马上就能应用于新的平台.)
四 程序实现过程中需要注意的问题
分析/proc/net/tcp文件的格式可以发现:
   第一,文件中的每一行字符串对应了一个套接字的信息,因此我们可以通过解析这一行字符串来生成一个套接字的信息(对于UDP来说是一个套接字,对于tcp来说就是一对套接字),不妨将之称为一个协议端口信息,如果你平时对函数设计很重视的话,你可能马上会想到构造一个函数,它的输入是一个字符串,返回一个有效或者无效的表示端口信息的结构体,对了,其实我也是这么想的.
   第二,/proc/net/udp文件和/proc/net/tcp文件中的数据格式几乎是一摸一样,所以对于udp和tcp端口,完全没有必要使用不同的函数来读取并解析,而只要通过一个通用的函数加上若干个标志位就可以了, 而要区分是udp还是tcp,是ipv6还是ipv4,文件名已经足够了.
    第三,注意到/proc文件中的数据是网络字节序存储的,所以我们要手动将其转换成主机上的本地字节序,这样就不会得到错误的数据了.
    第四,为了将IPV4与IPV6的地址统一存储,并且不使用数据结构sockaddr_in,我们将IP地址存储在一个32个字节的数组中,并且每次扫描时都尝试去读取一个v6版本的文件(tcp6和udp6), 如果存在这个文件的话,说明系统支持IPV6,反之,如果系统不支持IPV6,打开文件会失败,当然我们将认为这是一个正常的情况(因为该系统根本不支持IPV6,但是如果打开tcp或者udp文件出错,那你就得注意了).
     第五,一般的端口都是与服务名或者程序名绑定的,在Linux系统上,你可以通过查看/etc/service文件来获取这些信息, 另外, linux系统提供了若干函数来获取服务的端口以及服务名等信息,在netdb.h文件中(/usr/include/netdb.h)中有定义

1. 
   
2. struct servent
   
3. {
   
4.   char *s_name;//正式的服务名称
   
5.   char ** s_aliases;//服务别名列表
   
6.   int s_port;//服务端口
   
7.   char* s_proto;//使用的协议
   
8. }

复制代码

如果你已经知道了一个服务的名字,就可以通过函数

1. 
   
2. struct servent * getservbyname(char*serv_name, char* proto)

复制代码

来获取这个服务的其它信息,从而得到端口的数值,反之,如果你已经拿到了一个端口号,就可以通过函数

1. 
   
2. struct servent * getservbyport(int proto, const char)

复制代码

来获取这个服务的其它信息,从而得到服务的名字,但有一个前提,那就是函数的返回值必须是一个有效的指向struct servent类型的指针,因为并不是每次调用这些函数都能返回一个有效的结构体指针,举个例子,当你调用

1. 
   
2. getservebyname("ssh", "tcp")

复制代码

时,肯定会返回一个有效的结构提指针,因为这个服务在大多数Linux系统中是存在的,所以代码

1. 
   
2. Struct servent * serv = getservbyname("ssh", "tcp"),
   
3. printf("%d",  ntohs(serv->s_port))

复制代码

将会输出22,因为一般的ssh服务使用的都是tcp协议,并且占用22号端口,但是,

1. 
   
2. getservbyname("ning", "ning")

复制代码

肯定会返回一个无效的结构体指针,暂不说"ning"这个服务名存不存在,一个名为"ning"的协议应该不存在吧.当然,对于getservbyport也需要注意返回指针是否有效的问题,所以在这些函数返回之后,一定要先检验指针的有效性,然后再去引用其中的值,如果你直接去取其中的成员;如下

1. 
   
2. Struct servent* serv = getservbyport(ntohs(9999), "ning");
   
3. Printf("%s\n", serv->s_name);

复制代码

可以肯定程序会在此处出现段错误, 因为你访问了无效的指针,所以应该加上一句判断

1. 
   
2. if(serv)
   
3. {
   
4.   Printf("%s\n", serv->s_name);
   
5. }

复制代码

之所以在这里对这个问题讨论这么多,我们的最终目的就是在获取到每个端口的时候,再去检测看它是不是一个知名端口,如果是的话,就在数字格式端口的后面加上此端口对应的服务名,以便于理解,并与netstat的-n和-N参数相统一.
     还需要注意的就是,在proc文件系统中, IPV6地址是用32个字节存储起来的字符串,IPV4地址是用8个字节存储的字符串,所以我们可以通过这个字段的长度来区分是IPV4还是IPV6格式的地址, 在netstat的源码中和我的代码中都是这么做的,因为我还没有什么更好的办法来区分这二者.
     最后一个问题(程序员讨论的问题大都是针对策略而很少涉及机制,因为他们都知道要去做什么,但是却会为采取那种方法去实现要求的功能(怎么做)而产生争议.经常是每个人都有一套自己的实现方法,而且他能就自己的方法讲出一定的优缺点来.但是最终还是得采取一个最好的途径,在本文中也是如此)是: 我们已经知道,文件中的每一行存储了一个端口信息,所以,有人马上会想到一个主意,那就是每读一行,就对这行进行解析,然后得到一个端口信息,接着读下一行.这是一种可行的方法.但是对于有经验的程序员来说,他可能会不太满意这种做法,因为,作为程序来说,我们要求某一模块(或者某一段代码)的功能尽可能单一,不要跟其他段之间有太大的关联.而且在文件的读写中间去解析读到的内容,并构造一个结构体,(我个人认为)这本身就是是一个不太好的编程习惯,你必须清楚,你是在读写文件,每打开一个文件,就对应产生了一个文件描述符,而每个文件被打开的次数都是有上限的,因此你的程序必须用尽可能短的时间来处理文件的读写过程,从而避免可能出现的错误或者系统瓶颈.这个道理在系统的中断处理中体现的特别明显(读文件和解析内容应该正好对应了中断上半部处理和下半部处理).所以,在本文的程序中我们总是先将文件的所有有用信息读取到一个缓存中,关闭文件.然后再逐行进行解析,得到端口的信息,事实上,Linux下有些版本的netstat的源代码也是这么处理的.
       作为实现不止一个功能的程序来说,用户并不期望在每次运行该程序时都去启动它所有的功能,而是希望有选择的执行这些功能,这也符合常规的思想,所以自然而然的就是,我们的程序必须能够接受用户传递的不同参数并进行不同的处理(这是任何一个Linux命令最起码的功能).在一开始的时候,我使用了Linux的getopt函数进行处理,但是为了使代码的编译尽可能不依赖于平台(因为它的功能只与系统提供的功能有关),我最终放弃了这个函数,而且由于本人比较懒惰, 所以也没有去仔细的阅读别人给我的适用于多平台的getopt函数,而是做了一个比较笨拙的处理: 程序只接受一个输入参数,这个参数是一个字符串,而且它的值只能为tcp,udp,或者all这三者之一.对于tcp参数,我们打印tcp套接字的所有端口信息,对于udp参数,我们打印udp套接字的所有端口信息,当然all就是打印所有的信息了,对于不同的参数,我们统一调用do_command函数来进行响应.这种处理确实有些逊色.
        在文章将要结束的时候,忽然意识到这个端口扫描器其实就是一个简单的读文件的C程序,只要知道proc文件的功能,谁都做的出来,而且语言的选择也决不局限于C语言,你也可以用perl,shell,python,ruby等来处理,相信使用shell的awk命令应该不用花费太大气力也能作出这个功能来.
五 源代码以及Makefile

1. 
   
2. #ifndef _PORT_SCANNER_
   
3. #define _PORT_SCANNER_
   
4. /**********PortScanner.h**************
   
5. *
   
6. *author :duanjigang @2006-12 <duanjigang1983@126.com>
   
7. *
   
8. */
   
9. #include <stdlib.h>
   
10. #include <stdio.h>
    
11. #include <string.h>
    
12. /*
    
13. include this file when the program is complied
    
14. on a unix os, macro "__LINUX__" was defined in
    
15. the Makefile with flag -D  
    
16. */
    
17. #ifdef __LINUX__
    
18. #include <netdb.h>
    
19. #endif
    
20. 
    
21. #define PROC_TCP "/proc/net/tcp" /*tcp sockets*/
    
22. #define PROC_UDP "/proc/net/udp" /*udp sockets*/
    
23. #define PROC_TCP6 "/proc/net/tcp6" /*tcp sockets for ipv6*/
    
24. #define PROC_UDP6 "/proc/net/udp6" /*udp sockets for ipv6*/
    
25. 
    
26. #define ADDR_SIZE 32 /*size  of a char array to
    
27. store a 32 BYTE long address*/
    
28. #define ERROR_STATUS 0
    
29. #define INVALID_PORT -1
    
30. /*
    
31. define protocol type for our program, just tcp and udp
    
32. */
    
33. typedef enum
    
34. {
    
35. ERROR_PROTO,
    
36. UDP_PROTO,
    
37. TCP_PROTO
    
38. } PROTO_TYPE;
    
39. /*
    
40. check an valid protocol type
    
41. */
    
42. static int VALID_PROTO(PROTO_TYPE type)
    
43. {
    
44. int nRet = 0;
    
45. switch(type)
    
46. {
    
47. case UDP_PROTO:
    
48. case TCP_PROTO:
    
49.          nRet =1;
    
50.          break;
    
51. default : break;
    
52. }
    
53. return nRet;
    
54. }
    
55. /*
    
56. get the name of a specific protocol
    
57. */
    
58. static char * STR_PROTO(PROTO_TYPE type)
    
59. {
    
60. static char szRet[20];
    
61. switch(type)
    
62. {
    
63. case UDP_PROTO: sprintf(szRet, "udp");break;
    
64. case TCP_PROTO: sprintf(szRet, "tcp"); break;
    
65. default: sprintf(szRet,  "UNKNOW PROTO");break;
    
66. }
    
67. return szRet;
    
68. }
    
69. /*
    
70. ipversion type
    
71. */
    
72. typedef enum
    
73. {
    
74.   IP_VERSION_ERROR = 0,
    
75.   IP_VERSION4 = 4,
    
76.   IP_VERSION6 = 6,
    
77. } IP_VERSION_TYPE;
    
78. /*
    
79. define tcp status for a tcp connection
    
80. */
    
81. #ifndef _TCP_STATUS_
    
82. #define _TCP_STATUS_
    
83. #define TCP_STATUS_COUNT 12 /*size of this array*/
    
84. static const char * TCP_STATUS [] =
    
85. {
    
86.   "ERROR_STATUS",
    
87.   "TCP_ESTABLISHED",
    
88.   "TCP_SYN_SENT",
    
89.   "TCP_SYN_RECV",
    
90.   "TCP_FIN_WAIT1",
    
91.   "TCP_FIN_WAIT2",
    
92.   "TCP_TIME_WAIT",
    
93.   "TCP_CLOSE",
    
94.   "TCP_CLOSE_WAIT",
    
95.   "TCP_LAST_ACK",
    
96.   "TCP_LISTEN",
    
97.   "TCP_CLOSING",
    
98. };
    
99. #endif
    
100. /*
     
101. define a struct for a (pair of) port(s)
     
102. noticed that with a udp sockets, nStatus is of no meaning  
     
103. */
     
104. struct port
     
105. {
     
106. char szLocalAddr[ADDR_SIZE]; //local ip addres
     
107. char szRemotAddr[ADDR_SIZE]; //remete ip address
     
108. IP_VERSION_TYPE nVersion; //ip version
     
109. int nLocalPort; //local port
     
110. int nRemotPort; //remote port if exists
     
111. int nStatus;//status for tcp sockets but not udp sockets
     
112. PROTO_TYPE proto; //tcp or udp
     
113. };
     
114. 
     
115. /*
     
116. just cleanup the memory of a  port stuct
     
117. return 0 when the pointer is an invalid one
     
118. */
     
119. extern int init(struct port * port);
     
120. /*
     
121. decode contents of data and store all information into
     
122. struct port, return 0 when port or data is an invalid pointer
     
123. */
     
124. extern int fill_data (struct port * port, const char * data);
     
125. /*
     
126. get the information in struct port with a user-readable format
     
127. if flag equals to 1, the formation is print to the screen too
     
128. when it is return in a buffer, we must use type to
     
129. decide the format of this string that will be returned and printed
     
130. */
     
131. extern char* print (const struct port* port, int flag, PROTO_TYPE type);
     
132. /*
     
133. array, an array used to store all the port information of a
     
134. protocol decided by protocol type
     
135. size: the max number of ports can stored in this array
     
136. */
     
137. extern int get_port_list(struct port * array, int size, PROTO_TYPE type);
     
138. static unsigned int SHOW_TCP = 0X01;
     
139. static unsigned int SHOW_UDP = 0X02;
     
140. static unsigned int SHOW_ALL = 0X0F;
     
141. /*
     
142. deal with input parameters
     
143. */
     
144. extern int do_command(unsigned int command);
     
145. #endif
     

复制代码

[ 本帖最后由 duanjigang 于 2006-12-3 19:11 编辑 ]

duanjigang

超过字符上限了,丫的,贴在底下吧

1. 
   
2. /**********PortScanner.c**************
   
3. *
   
4. *author :duanjigang @2006-12 <duanjigang1983@126.com>
   
5. *
   
6. */
   
7. #include "PortScanner.h"
   
8. int init (struct port * port)
   
9. {
   
10.         if(!port)
    
11.         {
    
12.                 return 0;
    
13.         }
    
14.         memset(port->szLocalAddr, '\0', ADDR_SIZE);
    
15.         memset(port->szRemotAddr, '\0', ADDR_SIZE);
    
16.         port->nLocalPort = port->nRemotPort = INVALID_PORT;
    
17.         port->nStatus = ERROR_STATUS;
    
18.         port->nVersion = IP_VERSION_ERROR;
    
19.         port->proto = ERROR_PROTO;
    
20.         return 1;
    
21. }
    
22. 
    
23. int fill_data (struct port * port, const char * data)
    
24. {
    
25.         int nID, nLPort, nRPort, nStatus;
    
26.         char local_address[128], remote_address[128], other[8192];
    
27.         const char* msg = data;
    
28.         memset(local_address, 0, 128);
    
29.         memset(remote_address, 0, 128);
    
30.         sscanf(msg,
    
31.                 "%d: %[0-9A-Fa-f]:%X %[0-9A-Fa-f]:%X %X %s",
    
32.                 &nID,
    
33.                 local_address,
    
34.                 &nLPort,
    
35.                 remote_address,
    
36.                 &nRPort,
    
37.                 &nStatus,
    
38.                 other
    
39.                 );
    
40.         //it is an ip address of ipv6,so with format
    
41.         //like XXXX.XXXX.XXXX.XXXX.XXXX.XXXX.XXXX.XXXX
    
42.         //then when we read this string, its length is
    
43.         //larger than 8(which is the length of a ip address
    
44.         //of ipv4 like "XX.XX.XX.XX")
    
45.         if(strlen(local_address) > 8)
    
46.         {
    
47.                 char * p = port->szLocalAddr;
    
48.                 char * q = local_address;
    
49.                 sprintf(p, "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c"
    
50.                         "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
    
51.                         q[6],  q[7],  q[4],  q[5],
    
52.                         q[2],  q[3],  q[0],  q[1],
    
53.                         q[14], q[15], q[12], q[13],
    
54.                         q[10], q[12], q[8],  q[9],
    
55.                         q[23], q[23], q[20], q[21],
    
56.                         q[18], q[19], q[16], q[17],
    
57.                         q[30], q[31], q[28], q[29],
    
58.                         q[26], q[27], q[24], q[25]
    
59.                         );
    
60.                
    
61.                 p = port->szRemotAddr;
    
62.                 q = remote_address;
    
63.                
    
64.                       sprintf(p, "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c"
    
65.                                   "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
    
66.                                   q[6],  q[7],  q[4],  q[5],
    
67.                                   q[2],  q[3],  q[0],  q[1],
    
68.                                   q[14], q[15], q[12], q[13],
    
69.                                   q[10], q[12], q[8],  q[9],
    
70.                                   q[23], q[23], q[20], q[21],
    
71.                                   q[18], q[19], q[16], q[17],
    
72.                                   q[30], q[31], q[28], q[29],
    
73.                                   q[26], q[27], q[24], q[25]
    
74.                                   );
    
75.                           port->nVersion =IP_VERSION6;
    
76.         }//we got an address of ipv4
    
77.         else
    
78.         {
    
79.                 char * p = port->szLocalAddr;
    
80.                 char * q = local_address;
    
81.                 sprintf(p, "%c%c%c%c%c%c%c%c",
    
82.                         q[6],  q[7],  q[4],  q[5],
    
83.                         q[2],  q[3],  q[0],  q[1]);
    
84.                
    
85.                 p = port->szRemotAddr;
    
86.                 q = remote_address;
    
87.                 sprintf(p, "%c%c%c%c%c%c%c%c",
    
88.                         q[6],  q[7],  q[4],  q[5],
    
89.                         q[2],  q[3],  q[0],  q[1]);
    
90.                 //set the ip version
    
91.                 port->nVersion = IP_VERSION4;
    
92.         }
    
93.         port->nLocalPort = nLPort;
    
94.         port->nRemotPort = nRPort;
    
95.         port->nStatus = nStatus;
    
96.         return 1;
    
97. }
    
98. 
    
99. 
    
100. char* print (const struct port* port, int flag, PROTO_TYPE type)
     
101. {
     
102.        
     
103.         if(!port || !VALID_PROTO(type))
     
104.         {
     
105.                 fprintf(stderr, "invalid proto type %d\n", type);
     
106.                 return 0;
     
107.         }
     
108.         else
     
109.         {
     
110.                 int npos;
     
111.                 static char szRet[256];
     
112. 
     
113.                 #ifdef __LINUX__
     
114.                 struct servent* serv;
     
115.                 #endif
     
116. 
     
117.                 const char * l = port->szLocalAddr;
     
118.                 const char * r = port->szRemotAddr;
     
119.                 // to avoiding an exception when  index(we used it to get
     
120.                 //a string from array TCP_STATUS) is larger than the
     
121.                 //size of array TCP_STATUS, we check 'nStatus'
     
122.                 memset(szRet, 0, 256);
     
123.                 npos = (port->nStatus >=0 && port->nStatus < TCP_STATUS_COUNT) ?
     
124.                         port->nStatus : 0;
     
125.                 if(port->nVersion == IP_VERSION6)
     
126.                 {
     
127.                         const char * p = port->szLocalAddr;
     
128.                         char szTem[20], szRem[256];
     
129.                         int i = 32;
     
130.                         sprintf(szRet,  "%d/%s\t\t  %c%c%c%c.%c%c%c%c.%c%c%c%c.%c%c%c%c."
     
131.                                 "%c%c%c%c.%c%c%c%c.%c%c%c%c.%c%c%c%c",
     
132.                                 type,
     
133.                                 STR_PROTO(type),
     
134.                                 p[--i], p[--i],p[--i],p[--i],
     
135.                                 p[--i], p[--i],p[--i],p[--i],
     
136.                                 p[--i], p[--i],p[--i],p[--i],
     
137.                                 p[--i], p[--i],p[--i],p[--i],
     
138.                                 p[--i], p[--i],p[--i],p[--i],
     
139.                                 p[--i], p[--i],p[--i],p[--i],
     
140.                                 p[--i], p[--i],p[--i],p[--i],
     
141.                                 p[--i], p[--i],p[--i],p[--i]
     
142.                                 );
     
143.                         memset(szTem, 0, 20);
     
144.                         sprintf(szTem, ":%d", port->nLocalPort);
     
145.                         strcat(szRet + strlen(szRet), szTem);
     
146. 
     
147.                         #ifdef __LINUX__
     
148.                          serv = getservbyport(ntohs(port->nLocalPort),
     
149.                          STR_PROTO(type));
     
150.                          if(serv)
     
151.                          {
     
152.                             strcat(szRet + strlen(szRet), "(");
     
153.                             strcat(szRet + strlen(szRet), serv->s_name);
     
154.                             strcat(szRet + strlen(szRet), ") ");  
     
155.                           }                    
     
156.                         #endif
     
157.                         strcat(szRet + strlen(szRet), "\t\t");
     
158.                         i = 32;
     
159.                         p = port->szRemotAddr;
     
160.                         memset(szRem, 0, 256);
     
161.                         sprintf(szRem, "%c%c%c%c.%c%c%c%c.%c%c%c%c.%c%c%c%c."
     
162.                                 "%c%c%c%c.%c%c%c%c.%c%c%c%c.%c%c%c%c",
     
163.                                 p[--i], p[--i], p[--i], p[--i],
     
164.                                 p[--i], p[--i], p[--i], p[--i],
     
165.                                 p[--i], p[--i], p[--i], p[--i],
     
166.                                 p[--i], p[--i], p[--i], p[--i],
     
167.                                 p[--i], p[--i], p[--i], p[--i],
     
168.                                 p[--i], p[--i], p[--i], p[--i],
     
169.                                 p[--i], p[--i], p[--i], p[--i],
     
170.                                 p[--i], p[--i], p[--i], p[--i]
     
171.                                 );
     
172.                 memset(szTem, 0, 20);
     
173.                                 sprintf(szTem, ":%d\t%s\n", port->nRemotPort, TCP_STATUS[npos]);
     
174.                             strcat(szRem + strlen(szRem), szTem);
     
175.                                 strcat(szRet + strlen(szRet), type == TCP_PROTO ? szRem : " *:*");       
     
176.                 }
     
177.                 else
     
178.                 {
     
179.                         const char * p = port->szLocalAddr;
     
180.                         char szTem[20], szRem[256];
     
181.                         int i = 8;
     
182.                        
     
183.                         sprintf(szRet, "%d/%s\t\t  %c%c.%c%c.%c%c.%c%c",
     
184.                                 type,
     
185.                                 STR_PROTO(type),
     
186.                                 p[--i], p[--i],p[--i],p[--i],
     
187.                                 p[--i], p[--i],p[--i],p[--i]
     
188.                                 );
     
189.                         memset(szTem, 0, 20);
     
190.                         sprintf(szTem, ":%d", port->nLocalPort);
     
191.                         strcat(szRet + strlen(szRet), szTem);       
     
192.                          #ifdef __LINUX__
     
193.                          serv = getservbyport(htons(port->nLocalPort),
     
194.                          STR_PROTO(type));
     
195.                          if(serv)
     
196.                          {
     
197.                             strcat(szRet + strlen(szRet), "(");
     
198.                             strcat(szRet + strlen(szRet), serv->s_name);
     
199.                             strcat(szRet + strlen(szRet), ") ");
     
200.                           }
     
201.                         #endif
     
202.                         strcat(szRet + strlen(szRet), "\t\t");
     
203.                         i = 8;
     
204.                         p = port->szRemotAddr;
     
205.                         memset(szRem, 0, 256);
     
206.                         sprintf(szRem, "%c%c.%c%c.%c%c.%c%c",
     
207.                                 p[--i], p[--i],p[--i],p[--i],
     
208.                                 p[--i], p[--i],p[--i],p[--i]
     
209.                                 );
     
210.                        
     
211.                         memset(szTem, 0, 20);
     
212.                         sprintf(szTem, ":%d\t%s\n", port->nRemotPort, TCP_STATUS[npos]);
     
213.                         strcat(szRem + strlen(szRem), szTem);
     
214.                         strcat(szRet + strlen(szRet), type == TCP_PROTO ? szRem : "*:*");
     
215.                 }
     
216.                 if(flag)
     
217.                 {
     
218.                         printf("%s\n", szRet);
     
219.                 }
     
220.                 return szRet;
     
221.         }
     
222. }
     
223. int get_port_list(struct port * array, int size, PROTO_TYPE type)
     
224. {
     
225.     char * lines[65535] = {0}, buffer[8192] = {0};
     
226.         int len = 0, i = 0, nRet = 0, mid = 0;
     
227.         FILE * procfs = 0;
     
228.         char * fv4, *fv6;
     
229.         if(!array || size <= 0)
     
230.         {
     
231.                 fprintf(stderr, "invalid parameter in get_tcp_port_list()\n");
     
232.                 return 0;
     
233.     }
     
234.         if(type == UDP_PROTO)
     
235.         {
     
236.          fv4 = PROC_UDP;
     
237.          fv6 = PROC_UDP6;
     
238.         }else
     
239.         if(type == TCP_PROTO)
     
240.         {
     
241.          fv4 = PROC_TCP;
     
242.          fv6 =PROC_TCP6;
     
243.         }else
     
244.         {
     
245.                 return 0;
     
246.         }
     
247.         if((procfs = fopen(fv4, "r")) == NULL)
     
248.         {
     
249.                 fprintf(stderr, "File %s open faile\n", fv4);
     
250.         }else
     
251.         {
     
252.                 fgets(buffer, sizeof(buffer), procfs);
     
253.                 while(!feof(procfs))
     
254.                 {
     
255.                         memset(buffer, 0, sizeof(buffer));
     
256.                         fgets(buffer, sizeof(buffer), procfs);
     
257.                         len = strlen(buffer) + 1;
     
258.                         lines[i] = (char*)malloc(len);
     
259.                         if(lines[i] != 0)
     
260.                         {
     
261.                                 strcpy(lines[i++], buffer);
     
262.                                 //printf("%s\n", buffer);
     
263.                         }
     
264.                 }
     
265.                 fclose(procfs);
     
266.         }
     
267.         mid = i - 1;
     
268.         if((procfs = fopen(fv6, "r")) == NULL)
     
269.         {
     
270.                 //fprintf(stderr, "open file %s fail\n", fv6);
     
271.         }else
     
272.         {
     
273.                 fgets(buffer, sizeof(buffer), procfs);
     
274.                 while(!feof(procfs))
     
275.                 {
     
276.                         memset(buffer, 0, sizeof(buffer));
     
277.                         fgets(buffer, sizeof(buffer), procfs);
     
278.                         len = strlen(buffer) + 1;
     
279.                         lines[i] = (char*)malloc(len);
     
280.                         if(lines[i] != 0)
     
281.                         {
     
282.                                 strcpy(lines[i++], buffer);
     
283.                                 //printf("%s\n", buffer);
     
284. 
     
285.                         }
     
286.                 }
     
287.                 fclose(procfs);
     
288.         }
     
289.         i--; i--;
     
290.         while(i >= 0 && nRet < size)
     
291.         {
     
292.                 if(i == mid)
     
293.                 {
     
294.                   i = i - 1;
     
295.                   free(lines[mid]);
     
296.                   continue;
     
297.                 }
     
298.                 memset((void*)&(array[nRet]), 0, sizeof(struct port));
     
299.                 init(array + nRet);
     
300.                 if(!fill_data(array + nRet, lines[i--]))
     
301.                 {
     
302.                         fprintf(stderr, "line:\n %s \n has error format\n");
     
303.                         continue;
     
304.                 }else
     
305.                 {
     
306.                   //printf("%s\n", lines[i+1]);
     
307.                   (array[nRet]).proto = type;
     
308.                 }
     
309.         free(lines[i + 1]);
     
310.                 ++nRet;
     
311.         }
     
312.         return nRet;
     
313. }
     
314. 
     
315. int do_command(unsigned int command)
     
316. {
     
317.   struct port port[1024];
     
318.   int size, n = 0;
     
319. 
     
320.   if(command == SHOW_TCP)
     
321.   {
     
322.     n = 0;
     
323.     size = get_port_list(port, 1024, TCP_PROTO);
     
324.     printf("protocol\t\tlocal_address\t\tremote_address\t\tstatus\n");
     
325.     while(n < size)
     
326.     {
     
327.       char * szRet = print(&(port[n++]), 0, port[n].proto);
     
328.       printf("%s\n", szRet);
     
329.     }
     
330.   }else
     
331.   if(command == SHOW_UDP)
     
332.   {
     
333.     size = get_port_list(port, 1024, UDP_PROTO);
     
334.     printf("protocol\t\tlocal_address\t\tremote_address\n");
     
335.     while(n < size)
     
336.     {
     
337.       char * szRet = print(&(port[n++]), 0, port[n].proto);
     
338.       printf("%s\n", szRet);
     
339.     }
     
340. 
     
341.   }else
     
342.   if(command == SHOW_ALL)
     
343.   {
     
344.     size = get_port_list(port, 1024, TCP_PROTO);
     
345.     while(n < size)
     
346.     {
     
347.        /*
     
348.        char * szRet = print(&(port[n++]), 0, port[n].proto);
     
349.        printf("%s\n", szRet);
     
350.        */
     
351.        /*for my beloved gril, we used another format of printf*/
     
352.         print(&(port[n++]), 1, port[n].proto);
     
353.   }
     
354.     n = 0;
     
355.     size = get_port_list(port, 1024, UDP_PROTO);
     
356.     while(n < size)
     
357.     {
     
358.       char * szRet = print(&(port[n++]), 0, port[n].proto);
     
359.       printf("%s\n", szRet);
     
360.     }
     
361. 
     
362.   }else
     
363.   {
     
364.    fprintf(stderr, "UNKNOW COMMAND %d\n", command);
     
365.   }
     
366.   return 1;
     
367. }
     

复制代码

主应用程序

1. 
   
2. /**********nport.c**************
   
3. *
   
4. *author :duanjigang @2006-12 <duanjigang1983@126.com>
   
5. *copyright <duanjigang1983@126.com> <duanjigang1983@gmail.com>
   
6. */
   
7. #include "PortScanner.h"
   
8. int main(int argc, char *argv[])
   
9. {
   
10.   if(argc != 2)
    
11.   {
    
12.    fprintf(stdout, "usage: %s tcp/udp/all\n", argv[0]);
    
13.   }else
    
14.   {
    
15.     if(strncmp(argv[1], "tcp", 3) == 0)
    
16.     {
    
17.       do_command(SHOW_TCP);
    
18.     }else
    
19.     if(strncmp(argv[1], "udp", 3) == 0)
    
20.     {
    
21.       do_command(SHOW_UDP);
    
22.     }else
    
23.     if(strncmp(argv[1], "all", 3) == 0)
    
24.     {
    
25.      do_command(SHOW_ALL);
    
26.     }else
    
27.     {
    
28.      fprintf(stdout, "Unkonw parameter: %s\n", argv[1]);
    
29.     }
    
30.   }
    
31. }
    

复制代码

makefile

1. 
   
2. #author:duanjigang@2006-12<duanjigang1983@126.com><duanjigang1983@gmail.com>
   
3. #!/bin/sh
   
4. default:
   
5.         gcc -c *.c -D__LINUX__
   
6.         gcc -o nport nport.o PortScanner.o
   
7. clean:
   
8.         rm -fr *.o
   
9. 
   

复制代码

当然,在windows下直接用VC编译肯定能通过,可是你不要指望在windows下执行它也能得到正确的结果

[ 本帖最后由 duanjigang 于 2006-12-3 18:58 编辑 ]

zengg82

好贴！！！！！！！！！！！！！！！！1

支持一下

duanjigang

昨晚加了个班，用shell实现了，虽然我得shell很烂，但是还勉强能实现功能

1. 
   
2. #duanjigang@2006-12-15
   
3. #!/bin/sh
   
4. usage()
   
5. {
   
6. echo "usage: $0 tcp/udp/all"
   
7. }
   
8. tcp()
   
9. {
   
10. if  test -f "temp"
    
11.   then
    
12.    rm   -f "temp"
    
13. fi
    
14. awk -F ':'  'NR != 1 {print $2$3$4$5$6}' /proc/net/tcp > temp
    
15. cat temp | while read sip
    
16. do
    
17.   #echo "$sip"
    
18.    echo "$sip"| awk '{print substr($sip,7,2)"."substr($sip,5,2)"."\
    
19.     substr($sip,3,2)"."substr($sip, 1,2)":"substr($sip,9,4)"=>"\
    
20.     substr($sip,20,2)"."substr($sip,18,2)"."substr($sip,16,2)"."\
    
21.     substr($sip,14,2)":"substr($sip,22,4)" status: " substr($sip, 27,2)}'
    
22. done
    
23. rm -f "temp"
    
24. if test -f "/proc/net/tcp6"
    
25. then
    
26.    awk -F ':'  'NR != 1 {print $2$3$4$5$6}' /proc/net/tcp6 > temp
    
27.    cat temp | while read sip
    
28.    do
    
29.      echo "$sip"| awk '{print substr($sip,29,4)"."substr($sip,25,4)"."\
    
30.     substr($sip,21,2)"."substr($sip,17,4)":"substr($sip,13,4)"."\
    
31.     substr($sip,9,4)"."substr($sip,5,4)"."substr($sip,1,4)":"\
    
32.    substr($sip,33,4)"=>"\
    
33.     substr($sip,66,4)"."substr($sip,62,4)"."\
    
34.     substr($sip,58,4)"."substr($sip,54,4)":"substr($sip,50,4)"."\
    
35.     substr($sip,46,4)"."substr($sip,42,4)"."substr($sip,38,4)\
    
36.     ":"substr($sip,70,4)" status: "substr($sip,75,2)}'
    
37.    done
    
38. fi
    
39. }
    
40. udp()
    
41. {
    
42.   if  test -f "temp"
    
43.   then
    
44.    rm   -f "temp"
    
45. fi
    
46. awk -F ':'  'NR != 1 {print $2$3$4$5$6}' /proc/net/udp > temp
    
47. cat temp | while read sip
    
48. do
    
49.    echo "$sip"| awk '{print substr($sip,7,2)"."substr($sip,5,2)"."\
    
50.     substr($sip,3,2)"."substr($sip, 1,2)":"substr($sip,9,4)"=>*.*"}'
    
51. done
    
52. rm -f "temp"
    
53. if test -f "/proc/net/udp6"
    
54. then
    
55.    awk -F ':'  'NR != 1 {print $2$3$4$5$6}' /proc/net/udp6 > temp
    
56.    cat temp | while read sip
    
57.    do
    
58.      echo "$sip"| awk '{print substr($sip,29,4)"."substr($sip,25,4)"."\
    
59.     substr($sip,21,2)"."substr($sip,17,4)":"substr($sip,13,4)"."\
    
60.     substr($sip,9,4)"."substr($sip,5,4)"."substr($sip,1,4)":"\
    
61.    substr($sip,33,4)"=>*.*"}'
    
62.    done
    
63. fi
    
64. 
    
65. }
    
66. if [ $# -ne 1 ]
    
67. then
    
68.     usage
    
69. exit 0
    
70. else
    
71. case "$1" in
    
72.   tcp) tcp
    
73.   ;;
    
74. udp) udp
    
75. ;;
    
76. all) tcp
    
77.       udp
    
78.       ;;
    
79. *)usage
    
80.   ;;
    
81. esac
    
82. exit 0
    
83. fi
    

复制代码

ThomasLiu83

LZ再接再厉

不错，收藏之~

mq110

加精鼓励一下.

flyhu

非常好。。。proc文件格式说明那里有呢？

isnowran

小样, 小心联想告你侵权

incle

常在CU混,哪有不长进的!

broceliu

不错的 帖子 ！  为了 LZ 的专业