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. 小结

 

转载于:https://www.cnblogs.com/s7vens/archive/2012/04/16/2451635.html