Winpcap教程（高级应用）

循序渐进学习使用WINPCAP（五）

WinPcap或libpca最强大的特点之一就是数据流的过滤引擎。它提供一种高效的方法来只捕获网络数据流的某些数据而且常常和系统的捕获机制相集成。过滤数据的函数是pcap_compile() 和 pcap_setfilter()来实现的。


pcap_compile()来编译一个过滤设备，它通过一个高层的boolean型变量和字串产生一系列的能够被底层驱动所解释的二进制编码。boolean表示语法能够在这个文件的过滤表示语法中找到。

pcap_setfilter() 用来联系一个在内核驱动上过滤的过滤器，这时所有网络数据包都将流经过滤器，并拷贝到应用程序中。

下面的代码展示了如何编译并社定一个过滤设备。注意我们必须从pcap_if结构中获得掩码，因为一些过滤器的创建需要这个参数。

下面的代码段中的pcap_compile()的"ip and tcp"参数说明只有IPV4和TCP数据才会被内核保存并被传递到应用程序。



   if(d->addresses != NULL)
      /* 获得第一个接口地址的掩码 */
      netmask=((struct sockaddr_in *)(d->addresses->netmask))->sin_addr.S_un.S_addr;
   else
      /* 如果这个接口没有地址那么我们假设他为C类地址 */
      netmask=0xffffff;


   //compile the filter
   if(pcap_compile(adhandle, &fcode, "ip and tcp", 1, netmask) <0 ){
      fprintf(stderr,"/nUnable to compile the packet filter. Check the syntax./n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }
   
   //set the filter
   if(pcap_setfilter(adhandle, &fcode)<0){
      fprintf(stderr,"/nError setting the filter./n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }

如何你想进一步查看本节中用过滤器过滤数据流的例子可以查看下一节《数据的解包》。

循序渐进学习使用WINPCAP（六）

现在经过上几节的学习能够进行数据报的捕获和过滤了，我们想用一个简单的"real world"程序将我们所学的

知识应用于实际。
这一节里我们将利用以前的代码并将其引申从而建立一个更实用的程序。该程序的主要目的是如何显示出所捕

获的数据报的内容，尤其是对它的协议头的分析和说明。这个程序名叫UDPdump它将在屏幕上显示出我们网络上

UDP数据的信息。
在此我们选择解析UDP而不用TCP因为他比TCP简单更加的直观明了。下面让我们来看看原代码。




/*
* Copyright (c) 1999 - 2002
*  Politecnico di Torino.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that: (1) source code distributions
* retain the above copyright notice and this paragraph in its entirety, (2)
* distributions including binary code include the above copyright notice and
* this paragraph in its entirety in the documentation or other materials
* provided with the distribution, and (3) all advertising materials mentioning
* features or use of this software display the following acknowledgement:
* ``This product includes software developed by the Politecnico
* di Torino, and its contributors.&#39;&#39; Neither the name of
* the University nor the names of its contributors may be used to endorse
* or promote products derived from this software without specific prior
* written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS&#39;&#39; AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/

#include "pcap.h"

/* 4 BIT的IP头定义 */
typedef struct ip_address{
   u_char byte1;
   u_char byte2;
   u_char byte3;
   u_char byte4;
}ip_address;

/* IPv4 头的定义 */
typedef struct ip_header{
   u_char  ver_ihl;      // 4 bit的版本信息 + 4 bits的头长
   u_char  tos;        // TOS类型
   u_short tlen;        // 总长度
   u_short identification; // Identification
   u_short flags_fo;     // Flags (3 bits) + Fragment offset (13 bits)
   u_char  ttl;        // 生存期
   u_char  proto;       // 后面的协议信息
   u_short crc;        // 校验和
   ip_address  saddr;    // 源IP
   ip_address  daddr;    // 目的IP
   u_int  op_pad;      // Option + Padding
}ip_header;

/* UDP header*/
typedef struct udp_header{
   u_short sport;       // Source port
   u_short dport;       // Destination port
   u_short len;        // Datagram length
   u_short crc;        // Checksum
}udp_header;

/* 定义处理包的函数 */
void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data);


main()
{
   pcap_if_t *alldevs;
   pcap_if_t *d;
   int inum;
   int i=0;
   pcap_t *adhandle;
   char errbuf[PCAP_ERRBUF_SIZE];
   u_int netmask;
   char packet_filter[] = "ip and udp";
   struct bpf_program fcode;
  
   /* Retrieve the device list */
   if (pcap_findalldevs(&alldevs, errbuf) == -1)
   {
      fprintf(stderr,"Error in pcap_findalldevs: %s/n", errbuf);
      exit(1);
   }
   
   /* Print the list */
   for(d=alldevs; d; d=d->next)
   {
      printf("%d. %s", ++i, d->name);
      if (d->description)
        printf(" (%s)/n", d->description);
      else
        printf(" (No description available)/n");
   }

   if(i==0)
   {
      printf("/nNo interfaces found! Make sure WinPcap is installed./n");
      return -1;
   }
   
   printf("Enter the interface number (1-%d):",i);
   scanf("%d", &inum);
   
   if(inum < 1 || inum > i)
   {
      printf("/nInterface number out of range./n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }

   /* Jump to the selected adapter */
   for(d=alldevs, i=0; i< inum-1 ;d=d->next, i++);
   
   /* Open the adapter */
   if ( (adhandle= pcap_open_live(d->name, // name of the device
                    65536,    // portion of the packet to capture.
                           // 65536 grants that the whole packet will be captured on

all the MACs.
                    1,      // promiscuous mode
                    1000,    // read timeout
                    errbuf    // error buffer
                    ) ) == NULL)
   {
      fprintf(stderr,"/nUnable to open the adapter. %s is not supported by WinPcap/n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }
   
   /* Check the link layer. We support only Ethernet for simplicity. */
   if(pcap_datalink(adhandle) != DLT_EN10MB)
   {
      fprintf(stderr,"/nThis program works only on Ethernet networks./n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }
   
   if(d->addresses != NULL)
      /* Retrieve the mask of the first address of the interface */
      netmask=((struct sockaddr_in *)(d->addresses->netmask))->sin_addr.S_un.S_addr;
   else
      /* If the interface is without addresses we suppose to be in a C class network */
      netmask=0xffffff;


   //compile the filter
   if(pcap_compile(adhandle, &fcode, packet_filter, 1, netmask) <0 ){
      fprintf(stderr,"/nUnable to compile the packet filter. Check the syntax./n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }
   
   //set the filter
   if(pcap_setfilter(adhandle, &fcode)<0){
      fprintf(stderr,"/nError setting the filter./n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }
   
   printf("/nlistening on %s.../n", d->description);
   
   /* At this point, we don&#39;t need any more the device list. Free it */
   pcap_freealldevs(alldevs);
   
   /* start the capture */
   pcap_loop(adhandle, 0, packet_handler, NULL);
   
   return 0;
}

/* Callback function invoked by libpcap for every incoming packet */
void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data)
{
   struct tm *ltime;
   char timestr[16];
   ip_header *ih;
   udp_header *uh;
   u_int ip_len;
   u_short sport,dport;

   /* convert the timestamp to readable format */
   ltime=localtime(&header->ts.tv_sec);
   strftime( timestr, sizeof timestr, "%H:%M:%S", ltime);

   /* print timestamp and length of the packet */
   printf("%s.%.6d len:%d ", timestr, header->ts.tv_usec, header->len);

   /* 找到IP头的位置 */
   ih = (ip_header *) (pkt_data +
      14); //14为以太头的长度

   /* 找到UDP的位置 */
   ip_len = (ih->ver_ihl & 0xf) * 4;
   uh = (udp_header *) ((u_char*)ih + ip_len);

   /* 将端口信息从网络型转变为主机顺序 */
   sport = ntohs( uh->sport );
   dport = ntohs( uh->dport );

   /* print ip addresses and udp ports */
   printf("%d.%d.%d.%d.%d -> %d.%d.%d.%d.%d/n",
      ih->saddr.byte1,
      ih->saddr.byte2,
      ih->saddr.byte3,
      ih->saddr.byte4,
      sport,
      ih->daddr.byte1,
      ih->daddr.byte2,
      ih->daddr.byte3,
      ih->daddr.byte4,
      dport);
}

首先我门设置UDP过滤，用这种方法我们确保packet_handler()只接受到基于IPV4的UDP数据。我们同样定义了

两个数据结构来描述IP 和UDP的头部信息，packet_handler()用这两个结构来定位头部的各种字段。
packet_handler()虽然只是限于处理一些UDP数据但却显示了复杂的嗅探器如tcpdump/WinDump的工作原理。
首先我们对MAC地址的头部并不感兴趣所以我们跳过它。不过在开始捕获之前我们用pcap_datalink()来检查MAC

层，所以以上的程序只能够工作在Ethernet networks上，再次我们确保MAC头为14 bytes。
MAC头之后是IP头，我们从中提取出了目的地址。IP之后是UDP，在确定UDP的位置时有点复杂，因为IP的长度以

为版本的不同而不同，所以我们用头长字段来定位UDP，一旦 我们确定了UDP的起始位置，我们就可以解析出原

和目的端口。
下面是我们打印出来的一些结果：

1. {A7FD048A-5D4B-478E-B3C1-34401AC3B72F} (Xircom t 10/100 Adapter)
Enter the interface number (1-2):1

listening on Xircom CardBus Ethernet 10/100 Adapter...
16:13:15.312784 len:87 130.192.31.67.2682 -> 130.192.3.21.53
16:13:15.314796 len:137 130.192.3.21.53 -> 130.192.31.67.2682
16:13:15.322101 len:78 130.192.31.67.2683 -> 130.192.3.21.53

上面每一行都显示出不同的数据包的内容.

循序渐进学习使用WINPCAP（七）

通过以前的学习我门已经熟悉了从网卡上捕获数据包，现在我门将学习如何处理数据包。WINPCAP为我们提供了很多API来将流经网络的数据包保存到一个堆文件并读取堆的内容。这一节将讲述如何使用所有的这些API。
这种文件的格式很简单，但包含了所捕获的数据报的二进制内容，这种文件格式也是很多网络工具的标准如WinDump, Ethereal 还有 Snort等.


关于如何将数据包保存到文件：

首先我们看看如何以LIBPCAP的格式写数据包。
下面的例子演示了如何从指定的接口上捕获数据包并将它们存储到一个指定的文件。


#include "pcap.h"

/* 定义处理数据的函数原形 */
void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data);

main(int argc, char **argv)
{
   pcap_if_t *alldevs;
   pcap_if_t *d;
   int inum;
   int i=0;
   pcap_t *adhandle;//定义文件句柄
   char errbuf[PCAP_ERRBUF_SIZE];
   pcap_dumper_t *dumpfile;


   
   /* 检查命令行参数 是否带有文件名*/
   if(argc != 2){

      printf("usage: %s filename", argv[0]);
      return -1;

   }
   
   /* 获得驱动列表 */
   if (pcap_findalldevs(&alldevs, errbuf) == -1)
   {
      fprintf(stderr,"Error in pcap_findalldevs: %s/n", errbuf);
      exit(1);
   }
   
   /* 打印 list */
   for(d=alldevs; d; d=d->next)
   {
      printf("%d. %s", ++i, d->name);
      if (d->description)
        printf(" (%s)/n", d->description);
      else
        printf(" (No description available)/n");
   }

   if(i==0)
   {
      printf("/nNo interfaces found! Make sure WinPcap is installed./n");
      return -1;
   }
   
   printf("Enter the interface number (1-%d):",i);
   scanf("%d", &inum);
   
   if(inum < 1 || inum > i)
   {
      printf("/nInterface number out of range./n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }
      
   /* 跳转到指定的网卡 */
   for(d=alldevs, i=0; i< inum-1 ;d=d->next, i++);
   
   /* Open the adapter */
   if ( (adhandle = pcap_open_live(d->name, // name of the device
                    65536,    // portion of the packet to capture.
                           // 65536 grants that the whole packet will be captured on all the MACs.
                    1,      // promiscuous mode
                    1000,    // read timeout
                    errbuf    // error buffer
                    ) ) == NULL)
   {
      fprintf(stderr,"/nUnable to open the adapter. %s is not supported by WinPcap/n");
      /* Free the device list */
      pcap_freealldevs(alldevs);
      return -1;
   }

   /* 打开文件 */
   dumpfile = pcap_dump_open(adhandle, argv[1]);
   if(dumpfile==NULL){
      fprintf(stderr,"/nError opening output file/n");
      return -1;
   }
   
   printf("/nlistening on %s.../n", d->description);
   
   /* At this point, we don&#39;t need any more the device list. Free it */
   pcap_freealldevs(alldevs);
   
   /* 循环捕获数据并调用packet_handler函数把数据存储到堆文件 */
   pcap_loop(adhandle, 0, packet_handler, (unsigned char *)dumpfile);

   return 0;
}

/* Callback function invoked by libpcap for every incoming packet */

void packet_handler(u_char *dumpfile, const struct pcap_pkthdr *header, const u_char *pkt_data)
{
   /* 此函数功能将数据报存储到堆文件 */
   pcap_dump(dumpfile, header, pkt_data);
}

正如你看到的那样该程序的结构非常类似与以前的例子，区别是：
一旦打开网卡就调用pcap_dump_open()来打开一个文件，该调用将文件和某个网卡相关联。
packet_handler()内部通过调用pcap_dump()来将捕获的数据报存储到文件。pcap_dump()的参数和 packet_handler()一样，所以用起来比较方便。

从文件读数据包：

下面我们来看如何从文件读取数据内容。下面的代码打开了 一个堆文件并打印了其中的每个包内容。
pcap_open_offline()用来打开一个堆文件，之后用pcap_loop()来循环从文件中读取数据。你能发现读取脱机的数据几乎和实时的从网卡上读取一摸一样。



#include <stdio.h>
#include <pcap.h>

#define LINE_LEN 16

void dispatcher_handler(u_char *, const struct pcap_pkthdr *, const u_char *);

main(int argc, char **argv) {
   
   pcap_t *fp;
   char errbuf[PCAP_ERRBUF_SIZE];


   if(argc != 2){

      printf("usage: %s filename", argv[0]);
      return -1;

   }
   
   /* 打开一个存储有数据的堆文件 */
   if ( (fp = pcap_open_offline(argv[1], errbuf) ) == NULL)
   {
      fprintf(stderr,"/nError opening dump file/n");
      return -1;
   }
   
   // 读取数据直到遇到 EOF标志。
   pcap_loop(fp, 0, dispatcher_handler, NULL);

   return 0;
}



void dispatcher_handler(u_char *temp1,
                const struct pcap_pkthdr *header, const u_char *pkt_data)
{
   u_int i=0;
   
   /* print pkt timestamp and pkt len */
   printf("%ld:%ld (%ld)/n", header->ts.tv_sec, header->ts.tv_usec, header->len);      
   
   /* Print the packet */
   for (i=1; (i < header->caplen + 1 ) ; i++)
   {
      printf("%.2x ", pkt_data[i-1]);
      if ( (i % LINE_LEN) == 0) printf("/n");
   }
   
   printf("/n/n");   
   
}


下面的代码具有一样的作用，只不过是用pcap_next_ex()来代替pcap_loop()循环读取数据而已。




#include <stdio.h>
#include <pcap.h>

#define LINE_LEN 16

main(int argc, char **argv) {
   
   pcap_t *fp;
   char errbuf[PCAP_ERRBUF_SIZE];
   struct pcap_pkthdr *header;
   u_char *pkt_data;
   u_int i=0;
   int res;

   if(argc != 2){

      printf("usage: %s filename", argv[0]);
      return -1;

   }
   
   /* Open a capture file */
   if ( (fp = pcap_open_offline(argv[1], errbuf) ) == NULL)
   {
      fprintf(stderr,"/nError opening dump file/n");
      return -1;
   }
   
   /* Retrieve the packets from the file */
   while((res = pcap_next_ex( fp, &header, &pkt_data)) >= 0){
      /* print pkt timestamp and pkt len */
      printf("%ld:%ld (%ld)/n", header->ts.tv_sec, header->ts.tv_usec, header->len);      
      
      /* Print the packet */
      for (i=1; (i < header->caplen + 1 ) ; i++)
      {
        printf("%.2x ", pkt_data[i-1]);
        if ( (i % LINE_LEN) == 0) printf("/n");
      }
      
      printf("/n/n");   
   }
   
   
   if(res == -1){
      printf("Error reading the packets: %s/n", pcap_geterr(fp));
   }
   
   return 0;
}



用pcap_live_dump将数据写到文件：
WinPcap的最新版本提供了一个进一步的方法来将数据包存储到磁盘，就是使用pcap_live_dump()函数。他需要三个参数：一个文件名，和一个该文件允许的最大长度还有一个参数是该文件所允许的最大包的数量。对这些参数来说 0 意味着没有最大限制。注：我们可以在调用pcap_live_dump()前设置一个过滤器来定义哪些数据报需要存储。

pcap_live_dump() 是非阻塞的，所以他会立刻返回：数据的存储过程将会异步的进行，直到文件到达了指定的最大长度或最大数据报的数目为止。
应用程序能够用pcap_live_dump_ended()来等检查是否数据存储完毕，如果你指定的最大长度参数和数据报数量为0，那么该操作将永远阻塞。

pcap_live_dump() 和 pcap_dump()的不同从设置的最大极限来说就是性能的问题。pcap_live_dump()采用WinPcap NPF驱动来从内核级的层次上向文件中写数据，从而使内存拷贝最小化。
显然，这些特点当前在其他的操作系统下是不能够实现的，pcap_live_dump()是WinPcap所特有的，而且只能够应用于Win32环境.

循序渐进学习使用WINPCAP（八）

尽管WinPcap从名字上来看表明他的主要目的是捕获数据包，但是他还为原始网络提供了一些其他的功能，其中

之一就是用户可以发送数据包，这也就是本节的主要内容。需要指出的是原来的libpcap并不提供数据包 的发

送功能，这里所说的功能都是WinPcap的扩展功能，所以并不能够工作在UNIX下。

用pcap_sendpacket来发送一个数据包：

下面的代码是一个最简单的发送数据的方法。打开一个适配器后就可以用 pcap_sendpacket（）来手工发送一

个数据包了。这个函数需要的参数：一个装有要发送数据的缓冲区，要发送的长度，和一个适配器。注意缓冲

区中的数据将不被内核协议处理，只是作为最原始的数据流被发送，所以我门必须填充好正确的协议头以便正

确的将数据发送。




#include <stdlib.h>
#include <stdio.h>

#include <pcap.h>

void usage();

void main(int argc, char **argv) {
   pcap_t *fp;
   char error[PCAP_ERRBUF_SIZE];
   u_char packet[100];
   int i;

   /* Check the validity of the command line */
   if (argc != 2)
   {
      printf("usage: %s inerface", argv[0]);
      return;
   }

   /* 打开指定网卡 */
   if((fp = pcap_open_live(argv[1], 100, 1, 1000, error) ) == NULL)
   {
      fprintf(stderr,"/nError opening adapter: %s/n", error);
      return;
   }

   /* 假设网络环境为ethernet，我门把目的MAC设为1:1:1:1:1:1*/
   packet[0]=1;
   packet[1]=1;
   packet[2]=1;
   packet[3]=1;
   packet[4]=1;
   packet[5]=1;
   
   /* 假设源MAC为 2:2:2:2:2:2 */
   packet[6]=2;
   packet[7]=2;
   packet[8]=2;
   packet[9]=2;
   packet[10]=2;
   packet[11]=2;
   
   /* 填充发送包的剩余部分 */
   for(i=12;i<100;i++){
      packet=i%256;
   }

   /* 发送包 */
   pcap_sendpacket(fp,
      packet,
      100);

   return;
}

发送队列：
pcap_sendpacket()只是提供一个简单的直接的发送数据的方法，而发送队列提供一个高级的强大的和最优的机

制来发送一组数据包，队列实际上是一个装有要发送数据的一个容器，他有一个最大值来表明他所能够 容纳的

最大比特数。
pcap_sendqueue_alloc()用来创建一个队列，并指定该队列的大小。
一旦队列被创建就可以调用pcap_sendqueue_queue()来将数据存储到队列中，这个函数接受一个带有时间戳和

长度的pcap_pkthdr结构和一个装有数据报的缓冲区。这些参数同样也应用于pcap_next_ex() 和

pcap_handler()中，所以给要捕获的数据包或要从文件读取的数据包排队就是pcap_sendqueue_queue()的事情

了。
WinPcap调用pcap_sendqueue_transmit()来发送数据包，注意，第三个参数如果非零，那么发送将是同步的，

这将站用很大的CPU资源，因为发生在内核驱动的同步发送是通过"brute force"loops的，但是一般情况下能够

精确到微秒。
需要指出的是用pcap_sendqueue_transmit()来发送比用pcap_sendpacket()来发送一系列的数据要高效的多，

因为他的数据是在内核级上被缓冲。
当不再需要队列时可以用pcap_sendqueue_destroy()来释放掉所有的队列资源。

下面的代码演示了如何用发送队列来发送数据，该示例用pcap_open_offline()打开了一个文件，然后将数据

从文件移动到已分配的队列，这时就同步地传送队列（如果用户指定为同步的话）。


/*
* Copyright (c) 1999 - 2002
*  Politecnico di Torino.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that: (1) source code distributions
* retain the above copyright notice and this paragraph in its entirety, (2)
* distributions including binary code include the above copyright notice and
* this paragraph in its entirety in the documentation or other materials
* provided with the distribution, and (3) all advertising materials mentioning
* features or use of this software display the following acknowledgement:
* ``This product includes software developed by the Politecnico
* di Torino, and its contributors.&#39;&#39; Neither the name of
* the University nor the names of its contributors may be used to endorse
* or promote products derived from this software without specific prior
* written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS&#39;&#39; AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/

#include <stdlib.h>
#include <stdio.h>

#include <pcap.h>

void usage();

void main(int argc, char **argv) {
   pcap_t *indesc,*outdesc;
   char error[PCAP_ERRBUF_SIZE];
   FILE *capfile;
   int caplen,
      sync;
   u_int res;
   pcap_send_queue *squeue;
   struct pcap_pkthdr *pktheader;
   u_char *pktdata;

   /* Check the validity of the command line */
   if (argc <= 2 || argc >= 5)
   {
      usage();
      return;
   }
      
   /* 得到文件长度 */
   capfile=fopen(argv[1],"rb");
   if(!capfile){
      printf("Capture file not found!/n");
      return;
   }
   
   fseek(capfile , 0, SEEK_END);
   caplen= ftell(capfile)- sizeof(struct pcap_file_header);
   fclose(capfile);
        
   /* 检查确保时间戳被忽略 */
   if(argc == 4 && argv[3][0] == &#39;s&#39;)
      sync = TRUE;
   else
      sync = FALSE;

   /* Open the capture */
   if((indesc = pcap_open_offline(argv[1], error)) == NULL){
      fprintf(stderr,"/nError opening the input file: %s/n", error);
      return;
   }

   /* Open the output adapter */
   if((outdesc = pcap_open_live(argv[2], 100, 1, 1000, error) ) == NULL)
   {
      fprintf(stderr,"/nError opening adapter: %s/n", error);
      return;
   }

   /* 检测MAC类型 */
   if(pcap_datalink(indesc) != pcap_datalink(outdesc)){
      printf("Warning: the datalink of the capture differs from the one of the selected

interface./n");
      printf("Press a key to continue, or CTRL+C to stop./n");
      getchar();
   }

   /* 给对列分配空间 */
   squeue = pcap_sendqueue_alloc(caplen);

   /* 从文件获得包来填充队列 */
   while((res = pcap_next_ex( indesc, &pktheader, &pktdata)) == 1){
      if(pcap_sendqueue_queue(squeue, pktheader, pktdata) == -1){
        printf("Warning: packet buffer too small, not all the packets will be sent./n");
        break;
      }
   }

   if(res == -1){
      printf("Corrupted input file./n");
      pcap_sendqueue_destroy(squeue);
      return;
   }

   /* 传送队列数据 */
   
   if((res = pcap_sendqueue_transmit(outdesc, squeue, sync)) < squeue->len)
   {
      printf("An error occurred sending the packets: %s. Only %d bytes were sent/n", error,

res);
   }
   
   /* free the send queue */
   pcap_sendqueue_destroy(squeue);

   return;
}


void usage()
{
   
   printf("/nSendcap, sends a libpcap/tcpdump capture file to the net. Copyright (C) 2002 Loris

Degioanni./n");
   printf("/nUsage:/n");
   printf("/t sendcap file_name adapter [s]/n");
   printf("/nParameters:/n");
   printf("/nfile_name: the name of the dump file that will be sent to the network/n");
   printf("/nadapter: the device to use. Use /"WinDump -D/" for a list of valid devices/n");
   printf("/ns: if present, forces the packets to be sent synchronously, i.e. respecting the

timestamps in the dump file. This option will work only under Windows NTx./n/n");

   exit(0);
}

循序渐进学习使用WINPCAP（九）

http://www.chmhelp.cn/views/WinPcap%2B%E4%B8%AD%E6%96%87%E6%8A%80%E6%9C%AF%E6%96%87%E6%A1%A3%2B4.0.1/group__wpcap__tut9.html

这一节将展示WinPcap的另一高级功能：收集网络流量的统计信息。WinPcap的统计引擎在内核层次上对到来的数据进行分类。如果你想了解更多的细节请查看NPF驱动指南。
为了利用这个功能来监视网络，我门的程序必须打开一个网卡并用pcap_setmode()将其设置为统计模式。注意pcap_setmode()要用 MODE_STAT来将网卡设置为统计模式。
在统计模式下编写一个程序来监视TCP流量只是几行代码的事情，下面的例子说明了如何来实现该功能的。


/*
* Copyright (c) 1999 - 2002
*  Politecnico di Torino.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that: (1) source code distributions
* retain the above copyright notice and this paragraph in its entirety, (2)
* distributions including binary code include the above copyright notice and
* this paragraph in its entirety in the documentation or other materials
* provided with the distribution, and (3) all advertising materials mentioning
* features or use of this software display the following acknowledgement:
* ``This product includes software developed by the Politecnico
* di Torino, and its contributors.&#39;&#39; Neither the name of
* the University nor the names of its contributors may be used to endorse
* or promote products derived from this software without specific prior
* written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS&#39;&#39; AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/

#include <stdlib.h>
#include <stdio.h>

#include <pcap.h>

void usage();

void dispatcher_handler(u_char *,
   const struct pcap_pkthdr *, const u_char *);


void main(int argc, char **argv) {
   pcap_t *fp;
   char error[PCAP_ERRBUF_SIZE];
   struct timeval st_ts;
   u_int netmask;
   struct bpf_program fcode;
  
   /* Check the validity of the command line */
   if (argc != 2)
   {
      usage();
      return;
   }
      
   /* Open the output adapter */
   if((fp = pcap_open_live(argv[1], 100, 1, 1000, error) ) == NULL)
   {
      fprintf(stderr,"/nError opening adapter: %s/n", error);
      return;
   }

   /* Don&#39;t care about netmask, it won&#39;t be used for this filter */
   netmask=0xffffff;

   //compile the filter
   if(pcap_compile(fp, &fcode, "tcp", 1, netmask) <0 ){
      fprintf(stderr,"/nUnable to compile the packet filter. Check the syntax./n");
      /* Free the device list */
      return;
   }
   
   //set the filter
   if(pcap_setfilter(fp, &fcode)<0){
      fprintf(stderr,"/nError setting the filter./n");
      /* Free the device list */
      return;
   }

   /* 将网卡设置为统计模式 */
   pcap_setmode(fp, MODE_STAT);

   printf("TCP traffic summary:/n");

   /* Start the main loop */
   pcap_loop(fp, 0, dispatcher_handler, (PUCHAR)&st_ts);

   return;
}

void dispatcher_handler(u_char *state, const struct pcap_pkthdr *header, const u_char *pkt_data)
{
   struct timeval *old_ts = (struct timeval *)state;
   u_int delay;
   LARGE_INTEGER Bps,Pps;
   struct tm *ltime;
   char timestr[16];

   /* 从最近一次的采样以微秒计算延迟时间 */
   /* This value is obtained from the timestamp that the associated with the sample. */
   delay=(header->ts.tv_sec - old_ts->tv_sec) * 1000000 - old_ts->tv_usec + header->ts.tv_usec;
   /* 获得每秒的比特数 */
   Bps.QuadPart=(((*(LONGLONG*)(pkt_data + 8)) * 8 * 1000000) / (delay));
   /*                              ^    ^
                                  |    |
                                  |    |
                                  |    |
                 converts bytes in bits --     |
                                      |
              delay is expressed in microseconds --
   */

   /* 获得每秒的数据包数 */
   Pps.QuadPart=(((*(LONGLONG*)(pkt_data)) * 1000000) / (delay));

   /* 将时间戳转变为可读的标准格式 */
   ltime=localtime(&header->ts.tv_sec);
   strftime( timestr, sizeof timestr, "%H:%M:%S", ltime);

   /* Print timestamp*/
   printf("%s ", timestr);

   /* Print the samples */
   printf("BPS=%I64u ", Bps.QuadPart);
   printf("PPS=%I64u/n", Pps.QuadPart);

   //store current timestamp
   old_ts->tv_sec=header->ts.tv_sec;
   old_ts->tv_usec=header->ts.tv_usec;
}


void usage()
{
   
   printf("/nShows the TCP traffic load, in bits per second and packets per second./nCopyright (C) 2002 Loris Degioanni./n");
   printf("/nUsage:/n");
   printf("/t tcptop adapter/n");
   printf("/t You can use /"WinDump -D/" if you don&#39;t know the name of your adapters./n");

   exit(0);
}

在设置为统计模式前可以设置一个过滤器来指定要捕获的协议包。如果没有设置过滤器那么整个网络数据都将被监视。一旦设置了 过滤器就可以调用pcap_setmode()来设置为统计模式，之后网卡开始工作在统计模式下。
需要指出的是pcap_open_live()的第四个参数(to_ms)定义了采样的间隔，回调函数pcap_loop()每隔一定间隔就获取一次采样统计，这个采样被装入pcap_loop()的第二和第三个参数，过程如下图所示：
______________
|struct timeval ts |                     
|_____________|
|bpf_u_int32     |
|caplen=16       |      struct pcap_pkthdr*
|_____________|      (参数2)
| bpf_u_int32    |
|  len=16         |
|_____________|

__________________________
|large_integer  Accepted packet |
|_________________________|       uchar *
| large_integer  Accepted bits    |       (参数3)
|_________________________|



用两个64位的计数器分别记录最近一次间隔数据包数量和比特数量。
本例子中，网卡打开时设置超时为1000毫秒，也就是说dispatcher_handler()每隔1秒就被调用一次。过滤器也

设置为只监视TCP包，然后pcap_setmode() and pcap_loop()被调用，注意一个指向timeval的指针 作为参数传

送到pcap_loop()。这个timeval结构将用来存储个时间戳以计算两次采样的时间间隔。
dispatcher_handler()用该间隔来获取每秒的比特数和数据包数，并把着两个数显示在显示器上。
最后指出的是目前这个例子是比任何一个利用传统方法在用户层统计的包捕获程序都高效。因为统计模式需要

最小数量的数据拷贝和上下环境交换，同时还有最小的内存需求，所以CPU是最优的。