发送数据包

清疚 2022-08-19 08:23 329阅读 0赞

提起发送数据包大家可能会想到使用SOCKET编程来实现，但其实WinPcap也提供了发送数据包的API，尽管从名字上来看它应该是用来数据捕捉的。值得注意的是，libpcap不支持发送数据包的功能，因此下面提到的函数都是WinPcap的扩展，在UNIX平台下是不支持的。下面这个实例程序正是利用了WinPcap中的pcap\_sendpacket()来发送单个数据包。

![复制代码][copycode.gif]

#include <stdlib.h>
    #include <stdio.h>
    #define HAVE_REMOTE
    #include <pcap.h>
    
    
    int main(int argc, char **argv)
    {
        
        pcap_t *fp;
        char errbuf[PCAP_ERRBUF_SIZE];
        u_char packet[100];
        int i;
    
        /* 检查命令行参数的合法性 */
        if (argc != 2)
        {
        
            printf("usage: %s interface (e.g. 'rpcap://eth0')", argv[0]);
            return -1;
        }
    
        /* 打开输出设备 */
        if ( (fp= pcap_open(argv[1],            // 设备名
                            100,                // 要捕获的部分 (只捕获前100个字节)
                            PCAP_OPENFLAG_PROMISCUOUS,  // 混杂模式
                            1000,               // 读超时时间
                            NULL,               // 远程机器验证
                            errbuf              // 错误缓冲
                           ) ) == NULL)
        {
        
            fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", argv[1]);
            return -1;
        }
    
        /* 假设在以太网上，设置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]=i%256;
        }
    
        /* 发送数据包 */
        if (pcap_sendpacket(fp, packet, 100 /* size */) != 0)
        {
        
            fprintf(stderr,"\nError sending the packet: %s\n", pcap_geterr(fp));
            return -1;
        }
    
        return 0;
    }

![复制代码][copycode.gif]

下面是pcap\_sendpacket()函数的声明：

int pcap\_sendpacket(pcap\_t \*, const u\_char \*, int);

这三个参数的含义分别是发送数据包的适配器、要发送的数据和缓冲的长度。需要注意的是，缓冲直接发送至网络，不会有任何的控制和加工。这就意味着程序需要构造正确的协议头，使得数据包更有意义。该函数的返回值为0表示发送成功，-1表示发送失败。

但是我们知道，在真正的应用程序中我们往往需要发送多个数据包，事实上WinPcap也支持发送多个数据包，而且WinPcap的这种方式会更高级、更强大，结构会更优。它支持发送队列的方法，即利用队列作为将要发送至网络的数据包的容器。我们来看看下面这个例子。

![复制代码][copycode.gif]

#include <stdlib.h>
    #include <stdio.h>
    
    #define HAVE_REMOTE
    #define WPCAP
    #include <pcap.h>
    
    void usage();
    
    int main(int argc, char **argv)
    {
        
        pcap_t *indesc,*outdesc;
        char errbuf[PCAP_ERRBUF_SIZE];
        char source[PCAP_BUF_SIZE];
        FILE *capfile;
        int caplen, sync;
        u_int res;
        pcap_send_queue *squeue;
        struct pcap_pkthdr *pktheader;
        const u_char *pktdata;
        float cpu_time;
        u_int npacks = 0;
    
        /* 检查命令行参数的合法性 */
        if (argc <= 2 || argc >= 5)
        {
        
            usage();
            return -1;
        }
    
        /* 获取捕获文件长度 */
        capfile=fopen(argv[1],"rb");
        if(!capfile)
        {
        
            printf("Capture file not found!\n");
            return -1;
        }
    
        fseek(capfile , 0, SEEK_END);
        caplen= ftell(capfile)- sizeof(struct pcap_file_header);
        fclose(capfile);
    
        /* 检查时间戳是否合法 */
        if(argc == 4 && argv[3][0] == 's')
            sync = TRUE;
        else
            sync = FALSE;
    
        /* 开始捕获 */
        /* 根据WinPcap的新语法创建一个源字符串 */
        if ( pcap_createsrcstr( source,         // 源字符串
                                PCAP_SRC_FILE,  // 我们要打开的文件
                                NULL,           // 远程主机
                                NULL,           // 远程主机的端口
                                argv[1],        // 我们要打开的文件名
                                errbuf          // 错误缓冲
                              ) != 0)
        {
        
            fprintf(stderr,"\nError creating a source string\n");
            return -1;
        }
    
        /* 打开捕获文件 */
        if ( (indesc= pcap_open(source, 65536, PCAP_OPENFLAG_PROMISCUOUS, 1000, NULL, errbuf) ) == NULL)
        {
        
            fprintf(stderr,"\nUnable to open the file %s.\n", source);
            return -1;
        }
    
        /* 打开要输出的适配器 */
        if ( (outdesc= pcap_open(argv[2], 100, PCAP_OPENFLAG_PROMISCUOUS, 1000, NULL, errbuf) ) == NULL)
        {
        
            fprintf(stderr,"\nUnable to open adapter %s.\n", source);
            return -1;
        }
    
        /* 检查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;
            }
    
            npacks++;
        }
    
        if (res == -1)
        {
        
            printf("Corrupted input file.\n");
            pcap_sendqueue_destroy(squeue);
            return -1;
        }
    
        /* 发送队列 */
    
        cpu_time = (float)clock ();
    
        if ((res = pcap_sendqueue_transmit(outdesc, squeue, sync)) < squeue->len)
        {
        
            printf("An error occurred sending the packets: %s. Only %d bytes were sent\n", pcap_geterr(outdesc), res);
        }
    
        cpu_time = (clock() - cpu_time)/CLK_TCK;
    
        printf ("\n\nElapsed time: %5.3f\n", cpu_time);
        printf ("\nTotal packets generated = %d", npacks);
        printf ("\nAverage packets per second = %d", (int)((double)npacks/cpu_time));
        printf ("\n");
    
        /* 释放发送队列 */
        pcap_sendqueue_destroy(squeue);
    
        /* 关闭输入文件 */
        pcap_close(indesc);
    
        /*
         * 释放输出适配器
         * IMPORTANT: 记得一定要关闭适配器，不然就不能保证
         * 所有的数据包都回被发送出去
         */
        pcap_close(outdesc);
    
    
        return 0;
    }
    
    
    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);
    }

![复制代码][copycode.gif]

介绍一个新的数据类型，pcap\_send\_queue结构体，下面是该结构体的定义。

![复制代码][copycode.gif]

/*!
      \brief A queue of raw packets that will be sent to the network with pcap_sendqueue_transmit().
    */
    struct pcap_send_queue
    {
        
        u_int maxlen;        ///< Maximum size of the the queue, in bytes. This variable contains the size of the buffer field.
        u_int len;            ///< Current size of the queue, in bytes.
        char *buffer;        ///< Buffer containing the packets to be sent.
    };
    
    typedef struct pcap_send_queue pcap_send_queue;

![复制代码][copycode.gif]

pcap\_send\_queue结构体正如其名，它是发送数据队列，具体字段的含义源码中已有说明。  
我们再来看看这个发送队列的生命周期~~

1. 创建发送队列。通过调用pcap\_sendqueue\_alloc()函数：

pcap\_send\_queue\* pcap\_sendqueue\_alloc(u\_int memsize);  
其中memsize表示申请队列的大小，返回的是队列结构体指针。

2. 向队列加入要发送的数据包。通过调用pcap\_sendqueue\_queue()函数：

int pcap\_sendqueue\_queue(pcap\_send\_queue\* queue, const struct pcap\_pkthdr \*pkt\_header, const u\_char \*pkt\_data);

queue表示指向发送队列的指针；pkt\_header表示指向pcap\_pkthdr结构体（dump文件中数据包的首部）的指针；pkt\_data即为将要发送的数据。

本例中是从文件中读取pkt\_header和pkt\_data后再将数据包添加至队列中的。

3. 发送数据队列。通过调用pcap\_sendqueue\_transmit()函数：

u\_int pcap\_sendqueue\_transmit(pcap\_t \*p, pcap\_send\_queue\* queue, int sync);

这里只需要注意第三个参数sync。如果非0，则发送是同步进行的，也就是说，时间戳相符的数据包才会被处理。当然这样会消耗大量的CPU资源，因为同步操作由内核驱动中“忙等”循环实现。尽管这个操作对CPU要求很高，但它对数据包的处理结果通常是很精确的。（通常在数微秒左右，或更少）

需要注意的是利用pcap\_sendqueue\_transmit()发送数据队列比通过send\_packet()发送一系列数据包要高效得多，这是因为发送队列保存在内核级的缓冲区，减少了上下文交换的次数。

4. 释放数据队列。通过调用pcap\_sendqueue\_destroy()函数：

void pcap\_sendqueue\_destroy(pcap\_send\_queue\* queue);

另外需要注意到的一点是，程序中比较了dump文件的链路层和发送数据包的适配器的链路层，如果不同则会打印warning，因为这样发送将毫无意义可言。

最后看一下第二个程序在本机上运行的结果：

![2012031813323135.png][]

作者：[黑剑][Link 1]  
出处：[http://www.cnblogs.com/blacksword/][Link 1]  
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

[copycode.gif]: /images/20220731/2ffe5673656849e79717ed5e45a6a53b.png
[2012031813323135.png]: /images/20220731/690ab809210144a29fd162f190e43f8b.png
[Link 1]: http://www.cnblogs.com/blacksword/