尽管Winpcap清楚地指出了它的目的是数据包的截获，但是它还提供了一些对于原始网络（raw networking）的有用特性。用户可以找到一组完整的发包（send packets）函数。需要注意的是，libpcap目前并没有提供任何的发包的方法。
用pcap_sendpacket()发送单个数据包
下面的代码片断表现了最简单的发送一个数据包的过程。打开适配器后，pcap_sendpacket()被用来发送一个手工的（hand
-crafted）数据包。
试验代码：
#include <stdlib.h>
#include <stdio.h>
#include <pcap.h>
#include <remote-ext.h>
void main(int argc, char** argv){
pcap_t* fp;
char errbuf[PCAP_ERRBUF_SIZE];
u_char packet[100];
int i;
/* Check the validity of the command line*/
if (argc != 2)
{
printf("\tusage: %s interface (e.g. ’rpcap://eth0’)", argv[0]);
return;
}
/* Open the output device */
if ((fp = pcap_open(argv[1], /* name of the device */
100, /* portion of the packet to capture (only the first 100 bytes)*/
PCAP_OPENFLAG_PROMISCUOUS, /* promiscuous mode */
1000, /* read timeout */
NULL, /* authentication on the remote machine */
errbuf /* error buffer */
)) == NULL)
{
fprintf(stderr, "\nUnable to open the adapter. %s is not supported by Winpcap\n", argv[1]);
return;
}
/* Supposing to be on ethernet, set mac destinat to 1:1:1:1:1:1 */
packet[0] = 1;
packet[1] = 1;
packet[2] = 1;
packet[3] = 1;
packet[4] = 1;
packet[5] = 1;
/* set mac source to 2:2:2:2:2:2 */
packet[6] = 2;
packet[7] = 2;
packet[8] = 2;
packet[9] = 2;
packet[10] = 2;
packet[11] = 2;
/* Fill the rest of the packet */
for (i = 12; i < 100; ++ i)
{
packet[i] = i % 256;
}
/* Send down the packet */
if (pcap_sendpacket(fp, packet, 100 /* size */) != 0)
{
fprintf(stderr, "\nError sending the packet: \n", pcap_geterr(fp));
return;
}
return;
}
函数1：
int pcap_sendpacket(pcap_t* p,
u_char* buf,
int size)
发送一个原始数据包（raw packet）到网络上。p是用来发送数据包的那个接口，buf包含着要发送的数据包的数据（包括各种各样的协议头），size是buf所指的缓冲区的尺寸，也就是要发送的数据包的大小。MAC循环冗余码校验不必被包含，因为它很容易被计算出来并被网络接口驱动添加。如果数据包被成功发送，返回0；否则，返回－1。
发送队列（Send queues）
pcap_sendpacket()提供了一个简单快捷的发送单个数据包的方法，发送队列（send queues）提供了一个高级的，强大的，优化的发送一组数据包的机制。发送队列是一个用来保存将要发送到网络上的的众多数据包的容器。它有一个大小，描述了它所能容纳的最大字节数。
通过指定发送队列的大小，pcap_sendqueue_alloc()函数创建一个发送队列。一旦发送队列被创建好，pcap_sendqueue_queue()可以把一个数据包添加到发送队列里。函数pcap_sendqueue_alloc()的参数必须与pcap_next_ex()和pcap_handler()的相同，因此，从一个文件捕获或读取数据包的时候，如何进行pcap_sendqueue_alloc()的参数传递是一个问题。
试验代码：
#include <stdlib.h>
#include <stdio.h>
#include <pcap.h>
#include <remote-ext.h>
void usage();
void 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;
u_char *pktdata;
float cpu_time;
u_int npacks = 0;
/* Check the validity of the command line */
if (argc <= 2 || argc >= 5)
{
usage();
return;
}
/* Retrieve the length of the capture file */
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);
[Page]
/* Chek if the timestamps must be respected */
if(argc == 4 && argv[3][0] == ’s’)
sync = TRUE;
else
sync = FALSE;
/* Open the capture */
/* Create the source string according to the new WinPcap syntax */
if ( pcap_createsrcstr( source, // variable that will keep the source string
PCAP_SRC_FILE, // we want to open a file
NULL, // remote host
NULL, // port on the remote host
argv[1], // name of the file we want to open
errbuf // error buffer
) != 0)
{
fprintf(stderr,"\nError creating a source string\n");
return;
}
/* Open the capture file */
if ( (indesc= pcap_open(source, 65536, PCAP_OPENFLAG_PROMISCUOUS, 1000, NULL, errbuf) ) == NULL)
{
fprintf(stderr,"\nUnable to open the file %s.\n", source);
return;
}
/* Open the output adapter */
if ( (outdesc= pcap_open(argv[2], 100, PCAP_OPENFLAG_PROMISCUOUS, 1000, NULL, errbuf) ) == NULL)
{
fprintf(stderr,"\nUnable to open adapter %s.\n", source);
return;
}
/* Check the MAC type */
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();
}
/* Allocate a send queue */
squeue = pcap_sendqueue_alloc(caplen);
/* Fill the queue with the packets from the file */
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;
}
/* Transmit the queue */
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); [Page]
}
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");
/* free the send queue */
pcap_sendqueue_destroy(squeue);
/* Close the input file */
pcap_close(indesc);
/*
* lose the output adapter
* IMPORTANT: remember to close the adapter, otherwise there will be no guarantee that all the
* packets will be sent!
*/
pcap_close(outdesc);
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);
}
函数1：
pcap_send_queue* pcap_sendqueue_alloc(u_int memsize)
为一个发送队列分配空间，即创建一个用来存储一组原始数据包（raw packet）的缓冲区，这些数据包将用pcap_sendqueue_transmit()提交到网络上。memsize是队列容纳的字节数，因此它决定了队列所能容纳的最大数据量。使用pcap_sendqueue_queue()可以在发送队列中插入数据包。
函数2：
int pcap_sendqueue_queue(pcap_send_queue* queue，
const struct pcap_pkthdr* pkt_header,
const u_char* pkt_data)
添加一个数据包到发送队列中。queue指向发送队列的尾部；pkt_header指向一个pcap_pkthdr结构体，该结构体包含时间戳和数据包的长度；pkt_data指向存放数据包数据部分的缓冲区。
为了提交一个发送队列，Winpcap提供了pcap_sendqueue_transmit()函数。
函数3：
u_int pcap_sendqueue_transmit(pcap_t* p,
pcap_send_queue* queue,
int sync)
该函数将队列里的内容提交到线路上。p是一个指向适配器的指针，数据包将在这个适配器上被发送；queue指向pcap_send_queue结构体，它包含着要发送的所有数据包；sync决定了发送操作是否被同步：如果它是非0（non-zero），发送数据包关系到时间戳，否则，他们将以最快的速度发送（即不考虑时间戳）。
返回值是发送的字节数。如果它小于size参数，将发生一个错误。该错误可能是由于驱动/适配器（driver/adapter）问题或发送队列的不一致/伪造（inconsistent/bogus）引起。
注意：
l 使用该函数的效率比使用pcap_sendpacket()发送一系列数据包的效率高，因为数据包在核心态（kernel-level）被缓冲，所以降低了上下文的交换次数。因此，使用pcap_sendqueue_transmit()更好。
l 当sync被设置为TRUE时，随着一个高精度的时间戳，数据包将在内核伴被同步。这就要求CPU的数量是不可忽略的，通常允许以一个微秒级的精度发送数据包（这依赖于机器性能计数器的准确度）。然而，用pcap_sendpacket()发送数据包不能达到这样一个精确度。
如果第三个参数非0，发送将被同步（synchronized），即相关的时间戳将被注意。这个操作要求注意CPU的数量，因为使用“繁忙 等待（busy wait）”循环，同步发生在内核驱动。
当不再需要一个队列时，可以用pcap_sendqueue_destroy()来删除之，这将释放与该发送队列相关的所有缓冲区。