谁有关于ipv6的小程序给一个？

linus

或者相关的程序开发资料

kj501

去看看《UNIX网络编程》

Tetris

要涉及协议的还是只要socket程序设计？如果是socket程序设计一般都写成协议无关的，不会专门成IPv6

Tetris

等一下，找我一个经典程序给你。

linus

谢谢！涉及协议的最好，贴出来或者发到我的邮箱jinchangjiu@163.com

my_aying

也给我一个如何？呵呵，谢谢了mr_aying@163.com

Tetris

ipdump.c

1. 
   
2. /* I like BSD style better. */
   
3. #define _BSD_SOURCE
   
4. #include <errno.h>
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <sys/ioctl.h>
   
8. #include <net/if.h>
   
9. #include <net/ethernet.h>
   
10. #include <netinet/in.h>
    
11. #include <netinet/ip.h>
    
12. #ifdef IPV6
    
13. # include <netinet/ip6.h>
    
14. #endif
    
15. #include <netinet/tcp.h>
    
16. #include <netinet/udp.h>
    
17. #include <arpa/inet.h>
    
18. #include <unistd.h>
    
19. #include <string.h>
    
20. #include "ipdump.h"
    
21.                                                                                 
    
22. #ifdef IPV6
    
23. # define IP_PACKET_MAX \
    
24.     (sizeof (struct ether_header) + sizeof (struct ip6_hdr) + 65535)
    
25. #else
    
26. # define IP_PACKET_MAX \
    
27.     (sizeof (struct ether_header) + 65535)
    
28. #endif
    
29.                                                                                 
    
30. static char __recvbuf[IP_PACKET_MAX];
    
31. const void *__packet_data_ptr;
    
32. size_t __packet_data_len;
    
33.                                                                                 
    
34. static int __proc_tcp_packet(const struct tcphdr *tcp, size_t len,
    
35.                              struct ippacket *packet)
    
36. {
    
37.     if (len >= sizeof (struct tcphdr) && len >= tcp->th_off << 2)
    
38.     {
    
39.         packet->tcp_seq = ntohl(tcp->th_seq);
    
40.         packet->tcp_flags = tcp->th_flags;
    
41.         packet->sport = ntohs(tcp->th_sport);
    
42.         packet->dport = ntohs(tcp->th_dport);
    
43.                                                                                 
    
44.         __packet_data_ptr = (const char *)tcp + (tcp->th_off << 2);
    
45.         __packet_data_len = len - (tcp->th_off << 2);
    
46.         return 0;
    
47.     }
    
48.     else
    
49.     {
    
50.         errno = EBADMSG;
    
51.         return -1;
    
52.     }
    
53. }
    
54.                                                                                 
    
55. static int __proc_udp_packet(const struct udphdr *udp, size_t len,
    
56.                              struct ippacket *packet)
    
57. {
    
58.     if (len >= sizeof (struct udphdr))
    
59.     {
    
60.         packet->tcp_flags = 0;
    
61.         packet->tcp_seq = 0;
    
62.         packet->sport = ntohs(udp->uh_sport);
    
63.         packet->dport = ntohs(udp->uh_dport);
    
64.                                                                                 
    
65.         __packet_data_ptr = udp + 1;
    
66.         __packet_data_len = len - sizeof (struct udphdr);
    
67.         return 0;
    
68.     }
    
69.     else
    
70.     {
    
71.         errno = EBADMSG;
    
72.         return -1;
    
73.     }
    
74. }
    
75.                                                                                 
    
76. static int __proc_other_packet(const void *other, size_t len,
    
77.                                struct ippacket *packet)
    
78. {
    
79.     packet->tcp_flags = 0;
    
80.     packet->tcp_seq = 0;
    
81.     packet->dport = packet->sport = 0;
    
82.                                                                                 
    
83.     __packet_data_ptr = other;
    
84.     __packet_data_len = len;
    
85.     return 0;
    
86. }
    
87.                                                                                 
    
88. inline static int __proc_ip4_packet(const struct ip *ip4, size_t len,
    
89.                                     struct ippacket *packet)
    
90. {
    
91.     if (len >= sizeof (struct ip) && len >= ip4->ip_hl << 2)
    
92.     {
    
93.         packet->size = ntohs(ip4->ip_len);
    
94.         packet->family = AF_INET;
    
95.         packet->saddr.in_addr = ip4->ip_src;
    
96.         packet->daddr.in_addr = ip4->ip_dst;
    
97.         packet->protocol = ip4->ip_p;
    
98.                                                                                 
    
99.         len -= ip4->ip_hl << 2;
    
100.         (const char *)ip4 += ip4->ip_hl << 2;
     
101.         if (packet->protocol == IPPROTO_TCP)
     
102.             return __proc_tcp_packet((const struct tcphdr *)ip4, len, packet);
     
103.         else if (packet->protocol == IPPROTO_UDP)
     
104.             return __proc_udp_packet((const struct udphdr *)ip4, len, packet);
     
105.         else
     
106.             return __proc_other_packet(ip4, len, packet);
     
107.     }
     
108.     else
     
109.     {
     
110.         errno = EBADMSG;
     
111.         return -1;
     
112.     }
     
113. }
     
114.                                                                                 
     
115. #ifdef IPV6
     
116. inline static int __proc_ip6_packet(const struct ip6_hdr *ip6, size_t len,
     
117.                                     struct ippacket *packet)
     
118. {
     
119.     if (len >= sizeof (struct ip6_hdr))
     
120.     {
     
121.         packet->size = ntohs(ip6->ip6_plen);
     
122.         packet->family = AF_INET6;
     
123.         packet->saddr.in6_addr = ip6->ip6_src;
     
124.         packet->daddr.in6_addr = ip6->ip6_dst;
     
125.         packet->protocol = ip6->ip6_nxt;
     
126.                                                                                 
     
127.         len -= sizeof (struct ip6_hdr);
     
128.         ip6++;
     
129.         if (packet->protocol == IPPROTO_TCP)
     
130.             return __proc_tcp_packet((const struct tcphdr *)ip6, len, packet);
     
131.         else if (packet->protocol == IPPROTO_UDP)
     
132.             return __proc_udp_packet((const struct udphdr *)ip6, len, packet);
     
133.         else
     
134.             return __proc_other_packet(ip6, len, packet);
     
135.     }
     
136.     else
     
137.     {
     
138.         errno = EBADMSG;
     
139.         return -1;
     
140.     }
     
141. }
     
142. #endif
     
143.                                                                                 
     
144. inline static int __proc_ip_packet(const void *ip, size_t len,
     
145.                                    struct ippacket *packet)
     
146. {
     
147.     unsigned char version;
     
148.                                                                                 
     
149.     if (len > 0)
     
150.     {
     
151.         version = *(unsigned char *)ip >> 4;
     
152.         if (version == 4)
     
153.             return __proc_ip4_packet((const struct ip *)ip, len, packet);
     
154. #ifdef IPV6
     
155.         else if (version == 6)
     
156.             return __proc_ip6_packet((const struct ip6_hdr *)ip, len, packet);
     
157. #endif
     
158.         else
     
159.             errno = EAFNOSUPPORT;
     
160.     }
     
161.     else
     
162.         errno = EBADMSG;
     
163.                                                                                 
     
164.     return -1;
     
165. }
     
166.                                                                                 
     
167. inline static int __mark_packet_dir(const struct ether_header *ethhdr,
     
168.                                     int sockfd, const char *ifname,
     
169.                                     struct ippacket *packet)
     
170. {
     
171.     struct ifreq ifreq;
     
172.                                                                                 
     
173.     strncpy(ifreq.ifr_name, ifname, IFNAMSIZ);
     
174.     if (ioctl(sockfd, SIOCGIFHWADDR, &ifreq) >= 0)
     
175.     {
     
176.         if (memcmp(ifreq.ifr_hwaddr.sa_data, ethhdr->ether_shost,
     
177.                    ETH_ALEN) == 0)
     
178.             packet->direction = IPPACKET_OUT;
     
179.         else
     
180.             packet->direction = IPPACKET_IN;
     
181.                                                                                 
     
182.         return 0;
     
183.     }
     
184.     else
     
185.         return -1;
     
186. }
     
187.                                                                                 
     
188. inline static int __proc_ether_packet(const struct ether_header *ether,
     
189.                                       size_t len, int sockfd,
     
190.                                       const char *ifname,
     
191.                                       struct ippacket *packet)
     
192. {
     
193.     if (len >= sizeof (struct ether_header))
     
194.     {
     
195.         if (ntohs(ether->ether_type) == ETHERTYPE_IP)
     
196.         {
     
197.             if (__proc_ip_packet(ether + 1, len - sizeof (struct ether_header),
     
198.                                  packet) >= 0)
     
199.             {
     
200.                 if (__mark_packet_dir(ether, sockfd, ifname, packet) >= 0)
     
201.                     return 0;
     
202.             }
     
203.         }
     
204.         else
     
205.             errno = ENOMSG;
     
206.     }
     
207.     else
     
208.         errno = EBADMSG;
     
209.                                                                                 
     
210.     return -1;
     
211. }
     
212.                                                                                 
     
213. /**
     
214. * Read an IP pakcet from "sockfd". Make sure that "sockfd" is a
     
215. * Linux packet socket.
     
216. */
     
217. int recv_ip_packet(int sockfd, struct ippacket *packet)
     
218. {
     
219.     struct sockaddr sockaddr;
     
220.     socklen_t addrlen = sizeof (struct sockaddr);
     
221.     ssize_t n = recvfrom(sockfd, __recvbuf, IP_PACKET_MAX, 0,
     
222.                          &sockaddr, &addrlen);
     
223.                                                                                 
     
224.     if (n >= 0)
     
225.     {
     
226.         n = __proc_ether_packet((struct ether_header *)__recvbuf, n,
     
227.                                 sockfd, sockaddr.sa_data, packet);
     
228.     }
     
229.                                                                                 
     
230.     return n;
     
231. }
     

复制代码

ipdump.h

1. 
   
2. #ifndef _IPDUMP_H_
   
3. #define _IPDUMP_H_
   
4.                                                                                 
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   
8.                                                                                 
   
9. #define IPPACKET_IN         1
   
10. #define IPPACKET_OUT        2
    
11.                                                                                 
    
12. struct ippacket
    
13. {
    
14.     int direction;
    
15.     unsigned short size;
    
16.     unsigned short family;
    
17.     union
    
18.     {
    
19.         struct in_addr in_addr;
    
20. #ifdef IPV6
    
21.         struct in6_addr in6_addr;
    
22. #endif
    
23.     } saddr, daddr;
    
24.     unsigned short sport;
    
25.     unsigned short dport;
    
26.     unsigned int tcp_seq;
    
27.     unsigned char tcp_flags;
    
28.     unsigned char protocol;
    
29. };
    
30.                                                                                 
    
31. #ifdef __cplusplus
    
32. extern "C"
    
33. {
    
34. #endif
    
35.                                                                                 
    
36. int recv_ip_packet(int sockfd, struct ippacket *packet);
    
37.                                                                                 
    
38. #ifdef __cplusplus
    
39. }
    
40. #endif
    
41.                                                                                 
    
42. #endif
    
43. 
    

复制代码

Tetris

这是去年趋势竞赛题目里的一个模块，其要求是，监视从本机流入和流出的IP包，对每个IP包提取出对方IP地址，上层协议（TCP,UDP,ICMP,OTHERS），对方端口和本地端口（如果上层是TCP或UDP的话），tcp_flags和tcp_seq（如是要上层是TCP的话），包的方向（流入或流出）。我在实现上加入了对IPv6的支持，以及一个隐藏接口用于提取网络包数据，因为另一个模块要监控本机发送与接收的email。

Tetris

这个模块我觉得是一个不错的网络包分析的例子，流程很清晰。

nait

Tetris兄这么强，传授点学习方法啊