UNP Chapter 25 - 原始套接口（icmp的实现）

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.3为组成整个Ping程序的函数的概貌。

ping命令的实现程序

ping.h文件

/*包括IPv4和ICMPv4的基本头文件，定义部分全程变量以及函数原型 */

#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;

主文件，main.c

#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdarg.h>

#include "ping.h"
#undef IPV6
//              printf("%d bytes from %s: type = %d, code = %d\n", icmplen, Sock_ntop_host(pr->sarecv, pr->salen), icmp->icmp_type, icmp->icmp_code);
#define Gettimeofday  gettimeofday
#define Sock_ntop_host(X,Y)  inet_ntop(AF_INET,&(((struct sockaddr_in*)(X))->sin_addr),strip,Y)
char strip[128] ; 
err_doit(int errnoflag, const char *fmt, va_list ap)
{
        int             errno_save;
        char    buf[255];

        errno_save = errno;             /* value caller might want printed */
        vsprintf(buf, fmt, ap);
        if (errnoflag)
                sprintf(buf+strlen(buf), ": %s", strerror(errno_save));
        strcat(buf, "\n");
        fflush(stdout);         /* in case stdout and stderr are the same */
        fputs(buf, stderr);
        fflush(stderr);         /* SunOS 4.1.* doesn't grok NULL argument */
        return;
}



err_sys(const char *fmt, ...)
{
        va_list         ap;

        va_start(ap, fmt);
        err_doit(1, fmt, ap);
        va_end(ap);
        exit(1);
}

err_quit(const char *fmt, ...)
{
        va_list         ap;

        va_start(ap, fmt);
        err_doit(0, fmt, ap);
        va_end(ap);
        exit(1);
}

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_hl << 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_ntop_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);
            }
}


/*给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 */



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;
}
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);
}

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分组的头部并将其安在我们的缓冲区前 */
}


void sig_alrm(int signo)
{
  (*pr->fsend)();
  alarm(1);
  return; /* probably interrupts recvfrom() */
}

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);
  if(sockfd<0){
     perror("socket:");
     exit(-1);
  }

  /*将进程的有效用户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);
  }
}


struct addrinfo *
Host_serv(const char *host, const char *serv, int family, int socktype)
{
        int                             n;
        struct addrinfo hints, *res;

        bzero(&hints, sizeof(struct addrinfo));
        hints.ai_flags = AI_CANONNAME;  /* always return canonical name */
        hints.ai_family = family;               /* 0, AF_INET, AF_INET6, etc. */
        hints.ai_socktype = socktype;   /* 0, SOCK_STREAM, SOCK_DGRAM, etc. */

        if ( (n = getaddrinfo(host, serv, &hints, &res)) != 0)
                err_quit("host_serv error for %s, %s: %s",
                                 (host == NULL) ? "(no hostname)" : host,
                                 (serv == NULL) ? "(no service name)" : serv,
                                 gai_strerror(n));

        return(res);    /* return pointer to first on linked list */
}

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);
}

ping运行效果

[root@localhost raw_sock]# ./a.out -v 10.33.28.254
PING 10.33.28.254 (10.33.28.254): 56 data bytes
64 bytes from 10.33.28.254: seq=0, ttl=255, rtt=1.733 ms
64 bytes from 10.33.28.254: seq=1, ttl=255, rtt=1.668 ms
64 bytes from 10.33.28.254: seq=2, ttl=255, rtt=0.863 ms
64 bytes from 10.33.28.254: seq=3, ttl=255, rtt=0.990 ms
64 bytes from 10.33.28.254: seq=4, ttl=255, rtt=1.239 ms
64 bytes from 10.33.28.254: seq=5, ttl=255, rtt=4.184 ms

参考：http://www.cnblogs.com/s7vens/archive/2012/04/16/2451635.html