UNP Chapter 25 - 原始套接口
25.1. 概述
原始套接口提供以下三种TCP及UDP套接口一般不提供的功能。
1. 使用原始套接口可以读写ICMPv4,IGMPv4,ICMPv6分组。例如:Ping程序,就使用原始套接口发送ICMP回射请求,并接受ICMP回射应答。用于多播路由的守护进程:mrouted,同样利用原始套接口来发送和接收IGMPv4分组。上述功能同样允许使用ICMP或IGMP构造的应用程序完成作为用户进程处理,而不必在增加过多的内核编码。例如,路由器发现守护进程(在Solaris 2.x下名为in.rdisc,TCPv1的附录F说明如何获得公开可得版本的源代码)即以这种方式构造。它处理内核完全不知道的两个ICMP消息(路由器通告和路由器征求)。
2. 使用原始套接口可以读写特殊的IPv4数据报,内核不处理这些数据报的IPv4协议字段。
3. 利用原始套接口,好似用IP_HDRINCL套接口选项可以构造自己的IPv4头部。
25.2. 原始套接口创建
创建一个原始套接口涉及以下几步:
1. 当第二个参数是SOCK_RAW时,调用socket函数创建一个原始套接口。第三个参数(协议)一般不应为0,例如,为了创建一个IPv4原始套接口,我们可以这样写:
int sockfd; sockfd = socket(AF_INET, SOCK_RAW, protocol);
其中protocol参数值为形如IPPROTO_xxx的常值,由<netinet/in.h>头文件定义,如IPPROTO_IGMP。但要注意,头文件里定义了一个协议名,如IPPROTO_EGP,并不意味这内核肯定支持它。
为了防止普通用户向网络写自己的IP数据报,只有超级用户才有权创建原始套接口。
2. 可以设置IP_HDRINCL套接口选项:
const int on = 1; if ( setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0 )
我们将在下一节介绍这个选项的效果。
3. 可以对原始套接口调用bind函数,但并不常用。该函数仅用来设置本地地址:对于一个原始套接口而言端口号没有什么意义。当进行输出的时候,bind设置在原始套接口上所发送的数据报中将用到的源IP地址(仅当IP_HDRINCL套接口选项未设置时),若不调用bind,则由内核将源IP地址设成外出接口的主IP地址。
4. 在原始套接口上可调用connect函数,但也不常用。connect函数仅设置目的地址,再重申一遍:端口号对原始套接口而言没有意义。对于输出而言,调用connect之后,由于目的地址已经指定,我们可以调用write或send,而不是sendto了。
25.3. 原始套接口输出
原始套接口的输出遵循以下规则:
1. 普通输出通过调用sendto或sendmsg并指定目的IP地址来完成。如果套接口已经连接,也可以调用write,writev或send
2. 如果IP_HDRINCL选项未设置,则内核写的数据起始地址指IP头部之后的第一个字节。因为这种情况下,内核将构造IP头部,并将它安在来自进程的数据之前。内核将IPv4头部的协议字段设置成用户在调用socket函数时所给的第三个参数。
3. 如果IP_HDRINCL选项已设置,则内核写的数据起始地址指IP头部的第一个字节。用户所提供的数据大小值必须包括头部的字节数,此时进程构造除了以下两项以外的整个IP头部:(a)IPv4标识字段可以设为0,要求内核设置该值。 (b)IPv4头部的校验和由内核来计算和存储。
4. 对于超出外出接口MTU的分组,内核将其分片。
IPv6的原始套接口与IPv4相比有以下几点不同:
1. IPv6原始套接口发送和接收的协议头部内,所有字段均使用网络字节序。
2. IPv6不存在类似于IPv4中IP_HDRINCL这样的套接口选项。使用IPv6原始套机口无法读写整个IPv6分组(包括扩展头部),不过通过套接口选项及辅助数据,我们几乎可得到IPv6头部的所有字段和所有扩展头部。但要读写整个IPv6数据报,仍必须使用数据链路访问。
3. IPv6原始套接口的校验和处理有差异
对于ICMPv6原始套接口而言,总是由内核来计算并在ICMPv6头部内存储其校验和。这一点与ICMPv4原始套接口有所不同,ICMPv4原始套接口由应用进程来计算并存储校验和。
25.4. 原始套接口输入
对于原始套接口输入,我们要回答的第一个问题是:接收到的哪些IP分组将传递给原始套接口。浙江遵循如下规则:
1. 接收到的TCP分组和UDP分组决不会传递给任何原始套接口,如果一个进程希望读取包括TCP或UDP分组的IP数据报,那么它们必须在数据链路层读入
2. 当内核处理完ICMP消息之后,绝大部分ICMP分组将传递给原始套接口。对源自Berkeley的实现而言,除了回射请求,时间戳请求和地址掩码请求将完全由内核处理以外,所有收到的ICMP分组都将传递给某个原始套接口。
3. 当内核处理完IGMP消息之后,所有IGMP分组都将传递给某个原始套接口。
4. 所有带有内核不能识别的协议字段的IP数据报都将传递给某个原始套机口。内核对这些分组唯一做的就是检验IP头部中的某些字段:IP版本,IPv4头部校验和,头部长度以及目的IP地址。
5. 如果数据报以片段形式到达,则该分组将在所有片段到达并重组后才传给原始套接口。
当内核准备好一个待传递的数据报之后,内核将对所有进程的原始套接口进行检查,以寻找所有匹配的套接口。每个匹配的套接口都将收到一个该IP数据报的拷贝。以下是对每个原始套接口所做的三个测试,只有当这三个测试都为真时,数据报才会递送给该套接口。
1. 如果在创建原始套接口时,所指定的protocol参数不为零(socket的第三个参数),则接收到的数据报的协议字段应与该值匹配。否则该数据报将不递送给该套接口。
2. 如果此原始套接口之上绑定了一个本地IP地址,那么接收到的数据报的目的IP地址应与该绑定地址相匹配,否则该数据报将不递送给该套接口。
3. 如果此原始套接口通过调用connect指定了一个对方IP地址,那么接收到的数据报的源IP地址应与该连接地址相匹配,否则该数据报将不递送给该套接口。
注意如果一个原始套机口以protocol参数为0的方式创建,并且为调用connect和bind,那么对于内核传递给原始套接口的每一个原始数据报,该套接口都会收到一份拷贝。此外当一个接收到的数据报传递给IPv4原始套机口时,整个数据报都将传递给进程。对于原始IPv6套接口,出扩展头部外的整个数据报内容都传递给套接口。
在传递给应用进程的IPv4头部内,ip_len,ip_off,ip_id是主机字节序的,其他字段是网络字节序的。在Linux下,所有字段均为网络字节序。
原始ICMPv6套接口接收绝大部分内核收到的ICMPv4消息,但是ICMPv6是ICMPv4的一个超集,包括ARP和IGMP的功能。这项需要过滤分组数量,过滤器用 struct icmp6_filter数据类型声明,该数据类型由<netinet/icmp6.h>定义。一个原始ICMPv6套接口的当前过滤器可用setsockopt和getsockopt来设置和获取,其中level参数为IPPROTO_CIMPV6,optname参数为ICMP6_FILTER。
以下是操作icmp6_filter结构的6个宏:
#include <netinet/icmp6.h> void ICMP6_FILTER_SETPASSALL(struct icmp6_filter * filt); void ICMP6_FILTER_SETBLOCKALL(struct icmp6_filter * filt); void ICMP6_FILTER_SETPASS(int msgtype, struct icmp6_filter * filt); void ICMP6_FILTER_SETBLOCK(int msgtype, struct icmp6_filter * filt); int ICMP6_FILTER_WILLPASS(int msgtype, const struct icmp6_filter * filt); int ICMP6_FILTER_WILLBLOCK(int msgtype, const struct icmp6_filter * filt); /*返回值:如果过滤器传递(阻塞)相应消息类型为1,否则为0 */
以上这些宏调用中的filt参数是一个指向某个icmp6_filter变量的指针,前四个宏修改此icmp6_filter变量,后两个宏检查它。msgtype参数值在0~255之间,指定ICMP消息类型。
SETPASSALL宏设定所有消息类型均可传递给应用进程。SETBLOCKALL宏设定没有消息类型可传递。作为缺省,当一个ICMPv6原始套接口创建时,所有ICMPv6消息类型可传递给其应用进程。
SETPASS宏打开某个消息类型向该应用进程的传递,而SETBLOCK宏阻塞某个消息类型的传递。如果给定消息类型可以由过滤器传递时,WILLPASS宏返回1,否则返回0,如果给定消息类型被过滤器所阻塞时,WILLBLOCK宏返回1,否则返回0
作为例子,假想一个只接收ICMPv6路由器通过的应用程序:
struct icmp6_filter myfilt; fd = Socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6); ICMP6_FILTER_SETBLOCKALL(&myfilt); ICMP6_FILTER_SETPASS(NO_ROUTER_ADVERT, &myfilt); Setsockopt(fd, IPPROTO_IMCPV6, ICMP6_FILTER, &myfilt, sizeof(myfilt));
这个例子首先阻塞所有消息类型的传递,然后值传递路由器通告消息。
25.5. Ping程序
本章我们将开发一个同时支持IPv4和IPv6的Ping程序。此程序与公开可得版本有两点不同。首先,此程序忽略了公开可得Ping程序所支持的大量选项。其次,本程序同时支持IPv6和IPv4,而公开可得Ping程序只支持IPv4
Ping的操作非常简单,向某些IP地址发送一个ICMP回射请求,接着该节点返回一个ICMP回射应答。这两个ICMP消息在IPv4和IPv6下均得到支持。图25.1为ICMP消息的格式:
图25.2展示了程序运行的几个例子,第一个使用IPv4,第二个使用IPv6,注意一下#号提示符,它表示超级用户,因为只有超级用户才有权限创建原始套接口
图25.3为组成整个Ping程序的函数的概貌。
程序分两大部分:一部分读取一个原始套接口上收到的所有消息,并输出ICMP回射应答,另一部分每隔一秒发送一个回射请求。另一部分由SIGALRM信号每秒驱动一次。
图25.4给出所有程序都包括的头文件ping.h
/*包括IPv4和ICMPv4的基本头文件,定义部分全程变量以及函数原型 */ #include "unp.h" #include <netinet/in_systm.h> #include <netinet/ip.h> #include <netinet/ip_icmp.h> #define BUFSIZE 1500 /* globals */ char recvbuf[BUFSIZE]; char sendbuf[BUFSIZE]; int datalen; /* #bytes of data, following ICMP header */ char * host; int nsent; /* add 1 for each sendto() */ pid_t pid; /* our PID */ int sockfd; int verbose; /* function prototypes */ void proc_v4(char * , ssize_t, struct timeval * ); void proc_v6(char * , ssize_t, struct timeval * ); void send_v4(void); void send_v6(void); void readloop(void); void sig_alrm(int); void tv_sub(struct timeval * , struct timeval * ); /*我们使用proto结构来处理IPv4与IPv6的差异。此结构包含两个函数指针,两个套接口地址结果指针,这两个套接口地址结构的大小,以及ICMP的协议值。全程变量指针pr将指向为IPv4或IPv6初始化的某个proto结构 */ struct proto { void (* fproc)(char * , ssize_t, struct timeval *); void (* fsend)(void); struct sockaddr * sasend; /* sockaddr{} for send, from getaddrinfo */ struct sockaddr * sarecv; /* sockaddr{} for receiving */ socklen_t salen; /* length of sockaddr{}s */ int icmpproto; /* IPPROTO_xxx value for ICMP */ } * pr; /*我们包括两个定义IPv6和ICMPv6结构和常值的头文件 */ #ifdef IPV6 #include "ip6.h" /* should be <netinet/ip6.h> */ #include "icmp6.h" /* should be <netinet/icmp6.h> */ #endif
下面是main函数
#include "ping.h" /*给IPv4和IPv6分别定义proto结构,由于不知道最终使用的是IPv4还是IPv6,套接口地址结构指针被初始化为NULL */ struct proto proto_v4 = {proc_v4, send_v4, NULL, NULL, 0, IPPROTO_ICMP}; #ifdef IPV6 struct proto proto_v6 = {proc_v6, send_v6, NULL, NULL, 0, IPPROTO_ICMP}; #endif /*设置随同回射请求一起发送的可选数据长度为56个字节,这样,如产生IPv4数据报,则总长为84个字节(20字节IPv4头部,8字节ICMP头部);如果产生IPv6数据报,则总长104字节。回射请求中所包含的任何数据,都要由回射应答返回。在本例中,我们将在回射请求数据区的前8个字节内存储该回射请求发出的时间,以便在接收到回射应答后使用它来计算和输出RTT */ int datalen = 56; /* data that goes with ICMP echo request */ int main(int argc, char * * argv) { int c; struct addrinfo * ai; /*本程序唯一的命令行选项是 -v,它决定是否输出收到的大多数ICMP消息(当然,我们不输出属于运行中的另一个Ping进程的回射应答)。 */ opterr = 0; /* dont want getopt() writing to stderr */ while( (c = getopt(argc, argv, "v") != -1 ) { switch(c) { case 'v': verbose++; break; case '?': err_quit("unrecongized option: %c", c); } } if( optind != argc -1 ) err_quit("usage: ping[-v] <hostname>"); host = argv[optind]; pid = getpid(); Signal(SIGALRM, sig_alrm); /*在命令行参数中必须有一个主机名或主机IP地址。这里调用host_serv来处理,返回的addrinfo结构含有地址族:或AF_INET或AF_INET6,接着全局pr初始化为正确的proto结构。我们还要通过IN6_IS_ADDR_V4MAPPED来确认一个IPv6地址不是一个IPv4映射的,这是因为即使有host_serv返回的地址是一个IPv6地址,发送给主机的仍然是IPv4地址。 */ ai = Host_serv(host, NULL, 0, 0); printf("PING %s (%s): %d data bytes\n", ai->ai_canonname, Sock_ntop_host(ai->ai_addr, ai->ai_addrlen), datalen); /* initialize according to protocol */ if(ai->ai_family == AF_INET) { pr = &proto_v4; #ifdef IPV6 } else if (ai->ai_family == AF_INET6) { pr = &proto_v6; if(IN6_IS_ADDR_V4MAPPED(&(((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr))) err_quit("cannot ping IPv4-mapped IPv6 address"); } #endif } else err_quit("unknown address family %d", ai->ai_family); pr->sasend = ai->ai_addr; pr->sarecv = Calloc(1, ai->ai_addrlen); pr->salen = ai->ai_addrlen; /*readloop处理接收分组事宜 */ readloop(); exit(0); }
下面是readloop函数
#include "ping.h" void readloop(void) { int size; char recvbuf[BUFSIZE]; socklen_t len; ssize_t n; struct timeval tval; /*创建一个拥有合适协议的原始套接口 */ sockfd = Socket(pr->sasend->sa_family, SOCK_RAW, pr->icmpproto); /*将进程的有效用户ID设成进程的实际用户ID */ setuid(getuid()); /* dont need special permissions any more */ /*将套接口接收缓冲区设为61440字节,这要比缺省值大得多。这样做主要是为了减少接收缓冲区溢出的可能性 */ size = 60 * 1024; /* OK if setsockopt fails */ /* */ setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)); /*调用信号处理程序发送一个分组,并调度下一次SIGALRM为一秒之后。 */ sig_alrm(SIGALRM); /* send first packet */ /*程序的主循环是一个无限循环,它读取返回给ICMP原始套接口的每个分组 */ for ( ; ; ) { len = pr->salen; n = recvfrom(sockfd, recvbuf, sizeof(recvbuf), 0, pr->sarecv, &len); if(n<0) { if(errno == EINTR) continue; else err_sys("recvfrom error"); } Gettimeofday(&tval, NULL); (*pr->fproc)(recvbuf, n, &tval); } }
下面是tv_sub函数,用于将两个timeval结构相减,并将结果存入第一个timeval结构中。
#include "unp.h" void tv_sub(struct timeval * out, struct timeval * in) { if( (out->tv_usec -= in->tv_usec) < 0 ) /* out -= in */ { --out->tv_sec; out->tv_usec += 1000000; } out->tv_sec -= in->tv_sec; }
下面是proc_v4,用于处理所有收到的ICMPv4消息。图25.9标出了代码所用的各种头部,指针及长度。
#include "ping.h" void proc_v4(char * ptr, ssize_t len, struct timeval * tvrecv) { int hlen1, icmplen; double rtt; struct ip * ip; struct icmp * icmp; struct timeval * tvsend; /*IPv4头部长度字段是以4字节为一个单位计数的,将它乘以4才是以字节为单位的头部长度。这使我们可以正确设置icmp以指向ICMP头部的起始地址 */
ip = (struct ip *) ptr; /* start of IP header */ hlen1 = ip->ip_hi << 2; /* length of IP header */ icmp = (struct icmp *) (ptr + hlen1); /* start of ICMP header */ if( (icmplen = len - hlen1) < 8 ) err_quit("icmplen (%d) <8", icmplen); /*如果所收到的消息是一个ICMP回射应答,那么我们必须检查标识符字段,看看这个应答是不是对我们这个进程发出的请求的响应。如果在这个主机上进程被运行了多次,每个进程都将获得本主机所接收到的ICMP消息的一份拷贝 */
if( icmp->icmp_type == ICMP_ECHOREPLY) { if( icmp->icmp_id != pid) return; /* not a response to our ECHO_REQUEST */ if( icmplen < 16 ) err_quit("icmplen (%d) < 16", icmplen); /*通过将消息发出时间与当前时间相减,计算RTT */
tvsend = (struct timeval *)icmp->icmp_data; tv_sub(tvrecv, tvsend); rtt = tvrecv->tv_sec * 1000.0 + tvrecv->tv_usec / 1000.0; printf("$d bytes from %s: seq=%u, ttl=%d, rtt=%.3f ms\n", icmplen, Sock_notp_host(pr->sarecv, pr->salen), icmp->icmp_seq, ip->ip_ttl, rtt); } else if (verbose) /*如果用户指定了 -v 命令行选项,这段程序将输出所收到的所有其他ICMP消息的类型字段和代码字段 */ { printf("%d bytes from %s: type = %d, code = %d\n", icmplen, Sock_ntop_host(pr->sarecv, pr->salen), icmp->icmp_type, icmp->icmp_code); } }
ICMPv6消息由函数proc_v6处理,图25.11为ICMPv6应答结构:头部,指针及长度
#include "ping.h" void proc_v6(char * ptr, ssize_t len, struct timeval * tvrecv) { #ifdef IPV6 int hlen1, icmp6len; double rtt; struct ip6_hdr * ip6; struct icmp6_hdr * icmp6; struct itmeval * tvsend; /*IPv6头部长度固定为40字节,接下来是ICMPv6头部 */ ip6 = (struct ip6_hdr *) ptr; /* start of IPv6 header */ hlen1 = sizeof(struct ip6_hdr); if(ip6->ip6_nxt != IPPROTO_ICMPV6) err_quit("next header not IPPROTO_ICMPV6"); icmp6 = (struct icmp6_hdr *)(ptr + hlen1); if( (icmp6len = len - hlen1) < 8) err_quit("icmp6len (%d) < 8", icmp6len); /*如果ICMP消息类型为回射应答,则检查标识符字段,看是不是给我们的应答。如果一切正常,则计算RTT,并和序列号及IPv6跳限一起输出 */ if(icmp6->icmp6_type == ICMP6_ECHO_REPLY) { if(icmp6->icmp6_id != pid) return; /* not a response to our ECHO_REQUEST */ if(icmp6len < 16) err_quit("icmp6len (%d) < 16", icmp6len); tvsend = (struct timeval *) (icmp6 + 1); tv_sub(tvrecv, tvsend); rtt = tvrecv->tv_sec * 1000.0 + tvrecv->tv_usec / 1000.0; printf("%d bytes from %s: seq=%u, hlim=%d, rtt=%.3f ms\n", icmp6len, Sock_ntop_host(pr->sarecv, pr->salen), icmp6->icmp6_seq, ip6->ip6_hlim, rtt); } else if(verbose) /*如果用户指定了 -v 选项,则输出接收到的所有其他ICMP消息的类型和代码字段 */ { printf("%d bytes from %s: type = %d, code = %d\n", icmp6len, Sock_ntop_host(pr->sarecv, pr->salen), icmp6->icmp6_type, icmp->icmp6_code); } #endif /* IPV6 */ }
我们的SIGALRM信号处理函数是sig_alrm函数
#include "ping.h" void sig_alrm(int signo) { (*pr->fsend)(); alarm(1); return; /* probably interrupts recvfrom() */ }
函数send_v4构造一个ICMPv4回射请求消息并写入原始套接口
#include "ping.h" void send_v4(void) { int len; struct icmp * icmp; /*构造ICMPv4消息,用进程ID设置标识符字段,用全程变量nsent设置序列号,并为下一个分组将nsent增1,当前时间存入ICMP消息的数据部分 */ icmp = (struct icmp *) sendbuf; icmp->icmp_type = ICMP_ECHO; icmp->icmp_code = 0; icmp->icmp_id = pid; icmp->icmp_seq = nsent++; Gettimeofday( (struct timeval *) icmp->icmp_data, NULL); /*为了计算ICMP校验和,我们先设置校验和字段为0,然后调用函数in_cksum来计算校验和,将结果存入校验和字段。 */ len = 8 + datalen; /* checksum ICMP header and data */ icmp->icmp_cksum = 0; icmp->icmp_cksum = in_cksum((u_short*)icmp, len); Sendto(sockfd, sendbuf, len, 0, pr->sasend, pr->salen); /*ICMP消息通过原始套接口发送。由于我们没有使用IP_HDRINCL,内核将为我们构造IPv4分组的头部并将其安在我们的缓冲区前 */
}
函数in_cksum的一个实现,第一个while循环计算所有16位值只和,如果长度为奇数,则最后一个字节加入和中。这个实现对Ping程序而言还不错,但对内核使用的大数据量的校验和计算不大适合。
unsigned short in_cksum(unsigned short * addr, int len) { int nleft = len; int sum = 0; unsigned short * w = addr; unsigned short answer = 0; /* * Our algorithm is simple, using a 32 bit accumulator (sum), * we add sequential 16 bit words to it, and at the end, * fold back all the carry bits from the top 16 bits into the lower 16 bits */ while(nleft > 1) { sum += *w++; nleft -= 2; } if(nleft == 1) { *(unsigned char *)(&answer) = *(unsigned char *)w; sum += answer; } /* add back carry outs from top 16 bits to low 16 bits */ sum = (sum >>16) + (sum & 0xffff); /* add hi 16 to low 16 */ sum += (sum >> 16); /* add carry */ answer = ~sum; /* truncate to 16 bits */ return(answer); }
函数send_v6如下,它构造并发送ICMPv6回射请求。
#include "ping.h" void send_v6() { #ifdef IPV6 int len; struct icmp6_hdr * icmp6; icmp6 = (struct icmp6_hdr *)sendbuf; icmp6->icmp6_type = ICMP6_ECHO_REQUEST; icmp6->icmp6_code = 0; icmp6->icmp6_id = pid; icmp6->icmp6_seq = nsent++; Gettimeofday((struct timeval *)(icmp6+1), NULL); len = 8 + datalen; /* 8-byte ICMPv6 header */ Sendto(sockfd, sendbuf, len, 0, pr->sasend, pr->salen); /* kernel calculates and stores checksum for us */ #endif /* IPV6 */ }
25.6. Traceroute程序
本节我们将开发一个自己的Traceroute程序,同时支持IPv4和IPv6
Traceroute的用途是确定从我们的主机到目的地之间IP数据报行进的路径。Traceroute使用IPv4的TTL字段或IPv6的跳限字段以及两个ICMP消息。一开始,它向目的主机发送一个TTL(或跳限)为1的UDP数据报。这个数据报导致头一跳的路由器返回一个“time exceeded in transmit(传输中超时)”错。接着每次对TTL加1,并分别发出UDP数据报,这样可以一次一次确定下一个路由器。当UDP数据报终于到达目的主机时,希望目的主机能返回一个“port unreachable(端口不可达)”错,这通过向一个期望未被使用的随机端口发送UDP数据报来实现。
下面是程序要使用的trace.h头文件
/*我们包括标准IPv4头文件,该头文件定义了IPv4,ICMPv4和UDP的结构及常值。rec结构用于定义我们将要发送的UDP数据报的数据部分。不过我们将发现,其实我们不需要检查这些数据,这是用于调试目的 */ #include "unp.h" #include <netinet/in_systm.h> #include <netinet/ip.h> #include <netinet/ip_icmp.h> #include <netinet/udp.h> #define BUFSIZE 1500 struct rec /* format of outgoing UDP data */ { u_short rec_seq; /* sequence number */ u_short rec_ttl; /* TTL packet left with */ struct timeval rec_tv; /* time packet left */ }; /* globals */ char recvbuf[BUFSIZE]; char sendbuf[BUFSIZE]; int datalen; /* #bytes of data, following ICMP header */ char * host; u_short sport, dport; int nsent; /* add 1 for each sendto() */ pid_t pid; /* our PID */ int probe, nprobes; int sendfd, recvfd; /* send on UDP sock, read on raw ICMP sock */ int ttl, max_ttl; int verbose; /* function prototypes */ char * icmpcode_v4(int); char * icmpcode_v6(int); int recv_v4(int, struct timeval *); int recv_v6(int, struct timeval *); void sig_alrm(int); void traceloop(void); void tv_sub(struct timeval *, struct timeval *); /*定义一个proto结构来处理IPv4和IPv6两协议之间的不同,该结构含有函数指针、指向套接口地址结构的指针,及其他在两个IP版本之间有区别的常值。当main函数处理完目的地址以后,全程变量pr指针指向某个初始化为IPv4或IPv6类型的proto结构 */ struct proto { char * (*icmpcode)(int); int (*recv)(int, struct timeval *); struct sockaddr * sasend; /* sockaddr{} for send, from getaddrinfo */ struct sockaddr * sarecv; /* sockaddr{} for receiving */ struct sockaddr * salast; /* last sockaddr{} for receiving */ struct sockaddr * sabind; /* sockaddr{} for binding source port */ socklen_t salen; /* length of sockaddr{}s */ int icmpproto; /* IPPROTO_xxx value for ICMP */ int ttllevel; /* setsockopt() level to set TTL */ int ttloptname; /* setsockopt() name to set TTL */ } * ptr; /*包括定义了IPv6及ICMPv6结构及常值的头文件 */ #ifdef IPV6 #include "ip6.h" /* should be <netinet/ip.h> */ #include "icmp6.h" /* should be <netinet/icmp6.h> */ #endif
下面为main函数,它处理命令行参数,给IPv4或IPv6初始化pr指针,并调用traceloop函数
#include "trace.h" /*我们给IPv4和IPv6分别定义一个proto结构,不过直到函数尾,才为套接口地址结构的指针分配地址 */ struct proto proto_v4 = {icmpcode_v4, recv_v4, NULL, NULL, NULL, NULL, 0, IPPROTO_ICMP, IPPROTO_IP, IP_TTL}; #ifdef IPV6 struct proto proto_v6 = {icmpcode_v6, recv_v6, NULL, NULL, NULL, NULL, 0, IPPROTO_ICMPV6, IPPROTO_IPV6, IPV6_UNICAST_HOPS}; #endif /*最大TTL或跳限缺省设为30,不过 -m 参数可以让用户修改此值。对于每一个TTL值,我们将发三个控测分组。目的端口缺省设为32768+666,且每发一个UDP数据报就增1. */ int datalen = sizeof(struct rec); /* defaults */ int max_ttl = 30; int nprobes = 3; u_short dport = 32768 + 666; int main(int argc, char * * argv) { int c; struct addrinfo * ai; /* -v 参数是程序输出收到的大多数ICMP消息 */ opterr = 0; /* dont want getopt() writing to stderr */ while( ( c = getopt(argc, argv, "m:v" ) != -1) { switch(c) { case 'm': if( (max_ttl = atoi(optarg) ) <= 1) err_quit("invalid -m value"); break; case 'v': verbose++; break; case '?': err_quit("unrecognized option: %c", c); } } if (optind != argc-1) err_quit("usage: traceroute [ -m <maxttl> -v] <hostname>"); host = argv[optind]; pid = getpid(); Signal(SIGALRM, sig_alrm); /*使用host_serv函数处理目的的主机名或IP地址。该函数返回一个指向addrinfo结构的指针。根据返回地址类型的不同(IPv4或IPv6),初始化proto结构。将该结构指针存入全程变量pr */ ai = Host_serv(host, NULL, 0, 0); printf("traceroute to %s (%s): %d hops max, %d data bytes\n", ai->ai_canonname, Sock_ntop_host(ai->ai_addr, ai->ai_addrlen), max_ttl, datalen); /* initialize according to protocol */ if(ai->ai_family == AF_INET) { pr = &proto_v4; #ifdef IPV6 } else if (ai->ai_family == AF_INET6) { pr = &proto_v6; if(IN6_IS_ADDR_V4MAPPED( &(((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr)) ) err_quit("cannot traceroute IPv4-mapped IPv6 address"); #endif } else err_quit("unknown address family %d", ai->ai_family); pr->sasend = ai->ai_addr; /* contains destination address */ pr->sarecv = Calloc(1, ai->ai_addrlen); pr->salast = Calloc(1, ai->ai_addrlen); pr->sabind = Calloc(1, ai->ai_addrlen); pr->salen = ai->ai_addrlen; traceloop(); /* */ exit(0); }
traceloop函数发送数据报并读取返回的ICMP消息,这是程序的主循环。
#include "trace.h" void traceloop(void) { int seq, code, done; double rtt; struct rec * rec; struct timeval tvrecv; /* */ recvfd = Socket(pr->sasend->sa_family, SOCK_RAW, pr->icmpproto); setuid(getuid()); /* dont need special permissions any more */ sendfd = Socket(pr->sasend->sa_family, SOCK_DGRAM, 0); /* */ pr->sabind->sa_family = pr->sasend->sa_family; sport = (getpid() & 0xffff) | 0x8000; /* our source UDP port # */ sock_set_port(pr->sabind, pr->salen, htons(sport)); Bind(sendfd, pr->sabind, pr->salen); /* */ sig_alrm(SIGALRM); /* */ seq = 0; done = 0; for (ttl = 1; ttl <= max_ttl && done ==0; ttl++) { Setsockopt(sendfd, pr->ttllevel, pr->ttloptname, &ttl, sizeof(int)); bzero(pr->salast, pr->salen); printf("%2d", ttl); fflush(stdout); for(probe = 0; probe < nprobes; probe++) { rec = (struct rec *)sendbuf; rec->rec_seq = ++seq; rec->rec_ttl = ttl; Gettimeofday(&rec->rec_tv, NULL); /* */ sock_set_port(pr->sasend, pr->salen, htons(dport+seq)); Sendto(sendfd, sendbuf, datalen, 0, pr->sasend, pr->salen); /* */ if( (code = (*pr->recv)(seq, &tvrecv) ) == -3 ) printf(" * "); /* timeout, no reply */ else { char str[NI_MAXHOST]; if(sock_cmp_addr(pr->sarecv, pr->salast, pr->salen) != 0) { if(getnameinfo(pr->sarecv, pr->salen, str, sizeof(str), NULL, 0, 0) ==0) printf(" %s (%s)", str, Sock_ntop_host(pr->sarecv, pr->salen); else printf(" %s", Sock_ntop_host(pr->sarecv, pr->salen)); memcpy(pr->salast, pr->sarecv, pr->salen); } tv_sub(&tvrecv, &rec->rec_tv); rtt = tvrecv.tv_sec * 1000.0 + tvrecv.tv_usec / 1000.0; printf(" %.3f ms", rtt); if(code == -1) /* port unreachable: at destination */ done++; else if(code >= 0) printf(" (ICMP %s)", (*pr->icmpcode)(code) ); } fflush(stdout); } printf("\n"); } }
h
25.8. 小结