netlink套接字实现类似ss命令，统计套接字以及TCP信息

SCDXMOE

参考了 ss的源代码
以及 netlink相关资料：http://blog.csdn.net/scdxmoe/article/details/27711205

实现结果为：
gcc netlink_dig_530_7.c -o netlink_dig_530_7
./netlink_dig_530_7

state      family     l.addr     l.port       r.addr     r.rport   
LISTEN     AF_INET   localhost      53         0.0.0.0        0         
LISTEN     AF_INET   (null)         21         0.0.0.0        0         
LISTEN     AF_INET   (null)         22         0.0.0.0        0         
LISTEN     AF_INET   (null)         22         0.0.0.0        0         
LISTEN     AF_INET   localhost      631        0.0.0.0        0         
LISTEN     AF_INET   (null)         12865      0.0.0.0        0         
ESTAB      AF_INET   ubuntu.local   59208      91.189.89.134  80        
ESTAB      AF_INET   ubuntu.local   22         192.168.0.248  9689      
ESTAB      AF_INET   ubuntu.local   22         192.168.0.248  9295      
ESTAB      AF_INET   ubuntu.local   35531      91.189.94.25   80        
ESTAB      AF_INET   ubuntu.local   22         192.168.0.248  9691  

本文的实验 并没有实现怎么样获取TCP的窗口值

cwnd和RTT值，在ss源码中我看到了他利用了/proc
文件来实现获取窗口和RTT值，怎么样用netlink套接


字实现呢？还请教各位大神

谢谢!
源代码如下：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <string.h>
   
6. #include <fcntl.h>
   
7. #include <errno.h>
   
8. #include <string.h>
   
9. #include <asm/types.h>
   
10. #include <sys/socket.h>
    
11. #include <linux/netlink.h>
    
12. #include <linux/inet_diag.h>
    
13. #include <netinet/tcp.h>
    
14. #include <netdb.h>
    
15. #include<arpa/inet.h>
    
16. struct sk_req {
    
17.     struct nlmsghdr nlh;
    
18.     struct inet_diag_req r;
    
19. };
    
20. 
    
21. 
    
22. typedef struct{
    
23. __u8 family;
    
24. __u8 bytelen;
    
25. __s16 bitlen;
    
26. __u32 flags;
    
27. __u32 data[8];
    
28. } inet_prefix;
    
29. 
    
30. /*struct namerec
    
31. {
    
32.         struct namerec *next;
    
33.         const char *name;
    
34.         inet_prefix addr;
    
35. };*/
    
36. 
    
37. struct tcpstat
    
38. {
    
39.         inet_prefix     local;
    
40.         inet_prefix     remote;
    
41.         int             lport;
    
42.         int             rport;
    
43.         int             state;
    
44.         int             rq, wq;
    
45.         int             timer;
    
46.                  int             rq, wq;
    
47.         int             timer;
    
48.         int             timeout;
    
49.         int             retrs;
    
50.         unsigned        ino;
    
51.         int             probes;
    
52.         unsigned        uid;
    
53.         int             refcnt;
    
54.         unsigned long long sk;
    
55.         int             rto, ato, qack, cwnd, ssthresh;
    
56. };
    
57. enum {
    
58.         SS_UNKNOWN,
    
59.         SS_ESTABLISHED,
    
60.         SS_SYN_SENT,
    
61.         SS_SYN_RECV,
    
62.         SS_FIN_WAIT1,
    
63.         SS_FIN_WAIT2,
    
64.         SS_TIME_WAIT,
    
65.         SS_CLOSE,
    
66.         SS_CLOSE_WAIT,
    
67.         SS_LAST_ACK,
    
68.         SS_LISTEN,
    
69.         SS_CLOSING,
    
70.         SS_MAX
    
71. };
    
72. 
    
73. static const char *sstate_name[] = {
    
74.         "UNKNOWN",
    
75.         [SS_ESTABLISHED] = "ESTAB",
    
76.         [SS_SYN_SENT] = "SYN-SENT",
    
77.         [SS_SYN_RECV] = "SYN-RECV",
    
78.         [SS_FIN_WAIT1] = "FIN-WAIT-1",
    
79.         [SS_FIN_WAIT2] = "FIN-WAIT-2",
    
80.         [SS_TIME_WAIT] = "TIME-WAIT",
    
81.         [SS_CLOSE] = "UNCONN",
    
82.         [SS_CLOSE_WAIT] = "CLOSE-WAIT",
    
83.         [SS_LAST_ACK] = "LAST-ACK",
    
84.         [SS_LISTEN] =   "LISTEN",
    
85.         [SS_CLOSING] = "CLOSING",
    
86. };
    
87. 
    
88. /*  Base info structure. It contains socket identity (addrs/ports/cookie)
    
89. * and, alas, the information shown by netstat.
    
90. /*  Base info structure. It contains socket identity (addrs/ports/cookie)
    
91. * and, alas, the information shown by netstat.
    
92. 
    
93. struct nlmsghdr {
    
94.         __u32           nlmsg_len;      // Length of message including header
    
95.         __u16           nlmsg_type;     // Message content
    
96.         __u16           nlmsg_flags;    //Additional flags
    
97.         __u32           nlmsg_seq;      // Sequence number
    
98.         __u32           nlmsg_pid;      // Sending process port ID
    
99. };*/
    
100. 
     
101. //#ifdef RESOLVE_HOSTNAMES
     
102. struct namerec
     
103. {
     
104.         struct namerec *next;
     
105.         const char *name;
     
106.         inet_prefix addr;
     
107. };
     
108. 
     
109. #define NHASH 257
     
110. static struct namerec *nht[NHASH];
     
111. 
     
112. static const char *resolve_address(const void *addr, int len, int af)
     
113. {
     
114.         struct namerec *n;
     
115.         struct hostent *h_ent;
     
116.         unsigned hash;
     
117.         static int notfirst;
     
118. 
     
119. 
     
120.         if (af == AF_INET6 && ((__u32*)addr)[0] == 0 &&
     
121.             ((__u32*)addr)[1] == 0 && ((__u32*)addr)[2] == htonl(0xffff)) {
     
122.                 af = AF_INET;
     
123.                 addr += 12;
     
124.                 len = 4;
     
125.         }
     
126. 
     
127.         hash = *(__u32 *)(addr + len - 4) % NHASH;
     
128. 
     
129.         for (n = nht[hash]; n; n = n->next) {
     
130.                 if (n->addr.family == af &&
     
131.                     n->addr.bytelen == len &&
     
132.                     memcmp(n->addr.data, addr, len) == 0)
     
133.                         return n->name;
     
134.   memcmp(n->addr.data, addr, len) == 0)
     
135.                         return n->name;
     
136.         }
     
137.         if ((n = malloc(sizeof(*n))) == NULL)
     
138.                 return NULL;
     
139.         n->addr.family = af;
     
140.         n->addr.bytelen = len;
     
141.         n->name = NULL;
     
142.         memcpy(n->addr.data, addr, len);
     
143.         n->next = nht[hash];
     
144.         nht[hash] = n;
     
145.         if (++notfirst == 1)
     
146.                 sethostent(1);
     
147.         fflush(stdout);
     
148. 
     
149.         if ((h_ent = gethostbyaddr(addr, len, af)) != NULL)
     
150.                 n->name = strdup(h_ent->h_name);
     
151. 
     
152.         /* Even if we fail, "negative" entry is remembered. */
     
153.         return n->name;
     
154. }
     
155. //#endif
     
156. 
     
157. 
     
158. const char *rt_addr_n2a(int af, int len, const void *addr, char *buf, int buflen)
     
159. {
     
160.         switch (af) {
     
161.         case AF_INET:
     
162.         case AF_INET6:
     
163.                 return inet_ntop(af, addr, buf, buflen);
     
164.         /*case AF_IPX:
     
165.                 return ipx_ntop(af, addr, buf, buflen);
     
166.         case AF_DECnet:
     
167.         {
     
168.                 struct dn_naddr dna = { 2, { 0, 0, }};
     
169.                 memcpy(dna.a_addr, addr, 2);
     
170.                 return dnet_ntop(af, &dna, buf, buflen);
     
171.         }*/
     
172.         default:
     
173.                 return "???";
     
174.         }
     
175. }
     
176. 
     
177. 
     
178. 
     
179. void print_info(struct inet_diag_msg *pkg,struct nlmsghdr *h)
     
180. {
     
181.                 struct tcpstat s;
     
182.                 char buf[1024];
     
183.                 const char *ap = buf;//存放ip地址
     
184.                 char buf2[1024];
     
185.                 const char *ap2 = buf2;//存放ip地址
     
186. 
     
187.                 struct inet_diag_msg *r = NLMSG_DATA(h);
     
188.                 s.state = r->idiag_state;
     
189.                 s.local.family = s.remote.family = r->idiag_family;
     
190.                 s.lport = ntohs(r->id.idiag_sport);
     
191.                 s.rport = ntohs(r->id.idiag_dport);
     
192.                 s.local.family = s.remote.family = r->idiag_family;
     
193.                 if (s.local.family == AF_INET) {
     
194.                 //这里 打印
     
195.                 s.local.bytelen = s.remote.bytelen = 4;
     
196.                 } else {
     
197.                 s.local.bytelen = s.remote.bytelen = 16;
     
198.                 }
     
199.                 memcpy(s.local.data, r->id.idiag_src, s.local.bytelen);
     
200.                 memcpy(s.remote.data, r->id.idiag_dst, s.local.bytelen);
     
201.                 //printf("\n%-*s %-*s %-*s %-*s %-*s %-*s\n", 10,"state",10,"family",10,"l.addr",10,"l.port",10,"r.addr",10,"r.rport");
     
202.                 printf("%-*s ", 10, sstate_name[s.state]);
     
203.                 printf("%-*s",10,"AF_INET" );
     
204. 
     
205.                 //printf("\n--------------\n");
     
206.                 const inet_prefix *a=&s.remote;
     
207.                 const void *addr =  a->data;
     
208. 
     
209.                 ap=resolve_address(&s.local.data,4,AF_INET);
     
210.                 printf("%-*s",15, ap);
     
211.                 printf("%-*d ", 10,s.lport );
     
212.                 //ap2=resolve_address(&s.remote.data,4,AF_INET);
     
213.                 ap2=rt_addr_n2a(AF_INET,4,addr,buf2,sizeof(buf2));
     
214.                 printf("%-*s", 15, ap2);
     
215.                 printf("%-*d\n",10,s.rport);
     
216. 
     
217.                 //printf("L.port:%-*d R.prot:%-*d\n", 10,s.lport ,10,s.rport);
     
218. 
     
219.                 //printf("idiag_state:%d\n", pkg->idiag_state);
     
220. 
     
221.                 //printf("idiag_state:%d\n", pkg->idiag_state);
     
222.                 //printf("Family:%s\n", pkg->idiag_family == AF_INET ? "AF_INET" : "AF_INET6");
     
223.        // printf("dport:%d, sprot:%d\n", ntohs(pkg->id.idiag_sport), ntohs(pkg->id.idiag_sport));
     
224.                 //printf("idiag_state:%d\n", pkg->idiag_state);
     
225. 
     
226. }
     
227. 
     
228. 
     
229. int main(int argc, char **argv)
     
230. {
     
231.         int fd;
     
232.     struct sk_req req;
     
233.     struct sockaddr_nl dest_addr;
     
234.     struct msghdr msg;
     
235.     char buf[8192];
     
236.     char src_ip[20];
     
237.     char dest_ip[20];
     
238.     struct iovec iov;
     
239.     if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_INET_DIAG)) < 0) {
     
240.         //eprint(__LINE__, errno, "socket");
     
241.                 printf("socket error\n");
     
242.         return -1;
     
243.     }
     
244. 
     
245. req.nlh.nlmsg_len = sizeof(req);
     
246. req.nlh.nlmsg_type = TCPDIAG_GETSOCK;
     
247. req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
     
248. req.nlh.nlmsg_pid = 0;
     
249. 
     
250. memset(&req.r, 0, sizeof(req.r));
     
251. req.r.idiag_family = AF_INET;
     
252. req.r.idiag_states = ((1 << TCP_CLOSING + 1) - 1);
     
253. iov.iov_base = &req;
     
254. iov.iov_len = sizeof(req);
     
255. 
     
256. memset(&dest_addr, 0, sizeof(dest_addr));
     
257. dest_addr.nl_family = AF_NETLINK;
     
258. memset(&dest_addr, 0, sizeof(dest_addr));
     
259. dest_addr.nl_family = AF_NETLINK;
     
260. dest_addr.nl_pid = 0;
     
261. dest_addr.nl_groups = 0;
     
262. 
     
263. 
     
264. memset(&msg, 0, sizeof(msg));
     
265. msg.msg_name = (void *)&dest_addr;
     
266. msg.msg_namelen = sizeof(dest_addr);
     
267. msg.msg_iov = &iov;
     
268. msg.msg_iovlen = 1;
     
269. 
     
270. if (sendmsg(fd, &msg, 0) < 0) {
     
271.     //eprint(__LINE__, errno, "sendmsg");
     
272.     printf("socket error\n");
     
273.         return -1;
     
274. }
     
275. printf("\n%-*s %-*s %-*s %-*s   %-*s %-*s\n", 10,"state",10,"family",10,"l.addr",10,"l.port",10,"r.addr",10,"r.rport");
     
276. memset(buf, 0 ,sizeof(buf));
     
277. iov.iov_base = buf;
     
278. iov.iov_len = sizeof(buf);
     
279. while (1) {
     
280.     int status;
     
281.     struct nlmsghdr *h;
     
282.     msg = (struct msghdr) {
     
283.         (void *)&dest_addr, sizeof(dest_addr),
     
284.             &iov, 1, NULL, 0, 0
     
285.     };
     
286.     status = recvmsg(fd, &msg, 0);//recvmsg函数的返回值是读取的字节数,
     
287.     if (status < 0) {
     
288.         if (errno == EINTR)
     
289.             continue;
     
290.         //eprint(__LINE__, errno, "recvmsg");
     
291.         printf("socket error\n");
     
292.                 continue;
     
293.     }
     
294.     if (status == 0) {
     
295.         printf("EOF on netlink\n");
     
296.         close(fd);
     
297.         return 0;
     
298.     }
     
299.     h = (struct nlmsghdr *)buf;
     
300. //      #define NLMSG_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr) && \
     
301.                            (nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && \
     
302.                            (nlh)->nlmsg_len <= (len))
     
303.     while (NLMSG_OK(h, status)) {
     
304.         struct inet_diag_msg *pkg = NULL;
     
305.                 /*
     
306.   struct inet_diag_msg *pkg = NULL;
     
307.                 /*
     
308.                 struct inet_diag_msg {
     
309.         __u8    idiag_family;
     
310.         __u8    idiag_state;
     
311.         __u8    idiag_timer;
     
312.         __u8    idiag_retrans;
     
313. 
     
314.         struct inet_diag_sockid id;
     
315. 
     
316.         __u32   idiag_expires;
     
317.         __u32   idiag_rqueue;
     
318.         __u32   idiag_wqueue;
     
319.         __u32   idiag_uid;
     
320.         __u32   idiag_inode;
     
321. };
     
322.                 */
     
323.         if (h->nlmsg_type == NLMSG_DONE) {
     
324.             close(fd);
     
325.             printf("NLMSG_DONE\n");
     
326.             return 0;
     
327.         }
     
328.         if (h->nlmsg_type == NLMSG_ERROR) {
     
329.             struct nlmsgerr *err;
     
330.             err = (struct nlmsgerr*)NLMSG_DATA(h);
     
331.             fprintf(stderr, "%d Error %d:%s\n", __LINE__, -(err->error), strerror(-(err->error)));
     
332.             close(fd);
     
333.             printf("NLMSG_ERROR\n");
     
334.             return 0;
     
335.         }
     
336.         pkg = (struct inet_diag_msg *)NLMSG_DATA(h);
     
337.         //print_skinfo(pkg);
     
338.         //printf("\n%-*s %-*s %-*s %-*s %-*s %-*s\n", 10,"state",10,"family",10,"l.addr",10,"l.port",10,"r.addr",10,"r.rport");
     
339.                 print_info(pkg,h);
     
340. 
     
341.         //get_tcp_state(pkg->idiag_state);
     
342.         h = NLMSG_NEXT(h, status);
     
343.                 //#define NLMSG_NEXT(nlh,len)    ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
     
344.                                   (struct nlmsghdr*)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
     
345.                 //#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )
     
346.     }//while
     
347. }//while
     
348. close(fd);
     
349. return 0;
     
350. }
     
351.                                                   
     
352.                                 
     
353. 
     
354. 
     
355.                                                                                                    
     
356.                                                                                                                                          
     
357. 
     
358. 
     
359.                                                                              
     
360.                                                                  
     
361.                                        

复制代码

Tinnal

有这个必要吗？