庖丁解牛-----winpcap源码彻底解密(一)

转载自： http://blog.csdn.net/smilestone_322/article/details/6084620 最近忙一个项目，需要使用winpcap抓取网络数据包，调用winpcap提供的api进行抓包后，发现丢包情况比较严重，而且cpu占用率比较大。所以下定决心，对winpcap源码进行分析，因为对驱动和对Ndis网络驱动比较熟悉，所以分析源码还不是很费劲，其实winpcap底层的npf不过是一个Ndis协议驱动，所以它能做的工作就是捕获数据包，而不能做防火墙等使用，要做防火墙，一般使用的都是Ndis中间层过滤驱动，呵呵，不多说了，超出了本文的范围。下面分析源代码的一点经验，供大家分享，共同进步。
总的来说，winpcap主要有3个文件需要关注，wpcap.dll, parket.dll, npf.sys。其中wpcap和packet属于应用层的程序，npf属于内核层的程序，即npf就是一个Ndis的协议驱动。在本文中主要分析这几个文件和他们之间是怎么通信的，对于驱动的基础知识和Ndis驱动程序不在进行重点讲解，如果对本文的内容看不明白，大家可以在回过头学习驱动的知识，也可以和我交流。
首先我们从上往下层层分析，即先分析winpcap的wpcap.dll，然后分析parket.dll，最后分析底层的npf。对于大多数应用开发的人来说，使用wpcap.dll就足够了，因为它提供的api函数足够你捕获网络数据包，从而分析网络数据包，解析网络数据包。下面讲解下数据包的捕获流程。
数据包的捕获流程一般都分为以下几步：
1） 查找设备，也就是说查找网卡设备，调用的函数是pcap_findalldevs
2） 打开对应的网卡设备，调用的函数为pcap_open_live
3） 过滤数据包，在解析之前过滤数据包，可以减少解析的数据包数，增强数据包解析的能力，主要调用2个函数，pcap_compile编译过滤器，采用pcap_setfiter；
4） 获取数据包，主要的函数有pcap_loop，pcap_dispatch,pcap_next,pcap_next_ex这4个函数，这四个函数的区别可以参考winpcap的手册。
5） 关闭设备，pcap_freealldevs;

这是基本的数据包捕获流程，对一般的应用层的开发者来说，知道这些已经足够了。
但是当网络数据很大的时候，比如大块的文件传输，等，就需要考虑丢包情况了。下面介绍改善性能的api。怎样设置内核缓冲，怎样设置用户缓冲区，如何设置内核缓冲区到用户缓冲区的拷贝数据的最小值，即当内核缓冲区的数据达到这个值时，才能被上层的应用程序读走。在分析这些之前，必先知道数据包是怎么从网卡到达应用程序的。对于linux和windows系统，稍有不同，linux下采用libcap抓取网络数据包，windows采用winpcap抓取网络数据包。数据包从网卡到应用程序的过程如下：



图1：linux下数据包捕获流程




图2：winpcap数据包捕获流程
从linux和windows抓包过程可以看出，libcap和winpcap的不同之处如下：
（1）Libcap在BPF中采用2个缓冲区，即store buffer和hold buffer，从网卡拷贝的数据首先放入到store buffer ，然后再复制到hold buffer，就是一个乒乓操作经过hold buffer拷贝到应用程序的user buffer 中，这两个缓冲区的大小一般为32k。而winpcap采用的是一个循环缓冲区，即内核缓冲区，kernel buffer，内核缓冲区的默认大小为1M，可以采用pcap_setbuff对内核缓冲区进行修改。
（2）libcap的内核缓冲区和用户缓冲区大小在应用层是不可以更改的，如果需要更改，必须修改内核代码，然后重新编译，而winpcap提供了修改内核缓冲区和用户缓冲区的api函数，用户可以方便的设置缓冲区的大小，用户缓冲区的默认大小为256k，可以使用pcap_setuserbuffer进行设置。
（3）从图中可以看出，libcap只有2层，内核层和用户层，而winpcap有3层，在用户层又分为packet.dll和wpcap.dll，这样层次更加清晰，方便用户的理解，当然用户可以直接调用wpcap.dll的api进行数据包操作，也可以调用packet.dll进行数据包操作。
（4）对数据包的捕获一般要经过3个内存的拷贝，首先是网卡拷贝到内核缓冲区，然后内核缓冲区拷贝到用户缓冲区，然后通过api将用户缓冲区的数据包读走，进行协议分析，然后把数据保存起来，放入应用程序开辟的内存中。这一点它们都是类似的。
(5) winpcap提供了直接从内核缓冲区将数据写入文件的方法，这样减少了数据包的拷贝次数，提高了收包的速度。
（6）如何将数据包从内核缓冲区直接提供给应用程序，这是提高数据包捕获性能的好方法？
读者可以尝试这样去做，可以降低cpu占用率和丢包率。
(7)libcap老的版本没有发送数据包的函数，winpcap有pcap_sendpacket发送数据包；
（8）winpcap采用pcap_setmintocopy设置每次从内核缓冲区拷贝到用户缓冲区的最小值，当内核缓冲区的数据小于这个值时，读操作不返回，直到超时为止；

下面由上到下对各个函数进行解析：
（1） pcap_findalldevs
intpcap_findalldevs(pcap_if_t **alldevsp,char *errbuf)
{
pcap_if_t *devlist =NULL;
int ret = 0;
const char *desc;
char *AdaptersName;
ULONG NameLength;
char *name;
if (!PacketGetAdapterNames(NULL, &NameLength))
{
DWORD last_error =GetLastError();
if (last_error !=ERROR_INSUFFICIENT_BUFFER)
{
snprintf(errbuf,PCAP_ERRBUF_SIZE,
"PacketGetAdapterNames: %s",
pcap_win32strerror());
return (-1);
}
}
if (NameLength > 0)
AdaptersName = (char*)malloc(NameLength);
else
{
*alldevsp = NULL;
return 0;
}
if (AdaptersName ==NULL)
{
snprintf(errbuf,PCAP_ERRBUF_SIZE, "Cannot allocate enough memory to list the adapters.");
return (-1);
}
if (!PacketGetAdapterNames(AdaptersName, &NameLength)) {
snprintf(errbuf,PCAP_ERRBUF_SIZE,
"PacketGetAdapterNames: %s",
pcap_win32strerror());
free(AdaptersName);
return (-1);
}
/*
* "PacketGetAdapterNames()" returned a list of
* null-terminated ASCII interface name strings,
* terminated by a null string, followed by a list
* of null-terminated ASCII interface description
* strings, terminated by a null string.
* This means there are two ASCII nulls at the end
* of the first list.
*
* Find the end of the first list; that's the
* beginning of the second list.
*/
desc = &AdaptersName[0];
while (*desc !='/0' || *(desc + 1) !='/0')
desc++;
/*
* Found it - "desc" points to the first of the two
* nulls at the end of the list of names, so the
* first byte of the list of descriptions is two bytes
* after it.
*/
desc += 2;

/*
* Loop over the elements in the first list.
*/
name = &AdaptersName[0];
while (*name !='/0') {
/*
* Add an entry for this interface.
*/
if (pcap_add_if_win32(&devlist,name, desc, errbuf)
== -1) {
/*
* Failure.
*/
ret = -1;
break;
}
name += strlen(name) + 1;
desc += strlen(desc) + 1;
}
if (ret != -1) {
/*
* We haven't had any errors yet; do any platform-specific
* operations to add devices.
*/
if (pcap_platform_finddevs(&devlist,errbuf) < 0)
ret = -1;
}
if (ret == -1) {
/*
* We had an error; free the list we've been constructing.
*/
if (devlist !=NULL) {
pcap_freealldevs(devlist);
devlist = NULL;
}
}
*alldevsp = devlist;
free(AdaptersName);
return (ret);
}

/获取可用网络适配器的一个列表与它们的描述
BOOLEANPacketGetAdapterNames(PTSTRpStr,PULONG BufferSize)
{
PADAPTER_INFO TAdInfo;
ULONG SizeNeeded = 0;
ULONG SizeNames = 0;
ULONG SizeDesc;
ULONG OffDescriptions;
TRACE_ENTER("PacketGetAdapterNames");
TRACE_PRINT_OS_INFO();
TRACE_PRINT2("Packet DLL version %s, Driver version %s",PacketLibraryVersion, PacketDriverVersion);
TRACE_PRINT1("PacketGetAdapterNames: BufferSize=%u", *BufferSize);
//
// Check the presence on some libraries we rely on, and load them if we found them
//f
PacketLoadLibrariesDynamically();
//d
// Create the adapter information list
//
TRACE_PRINT("Populating the adapter list...");
PacketPopulateAdaptersInfoList();
WaitForSingleObject(g_AdaptersInfoMutex,INFINITE);
if(!g_AdaptersInfoList)
{
ReleaseMutex(g_AdaptersInfoMutex);
*BufferSize = 0;
TRACE_PRINT("No adapters found in the system. Failing.");
SetLastError(ERROR_INSUFFICIENT_BUFFER);
TRACE_EXIT("PacketGetAdapterNames");
return FALSE; // No adapters to return
}
//
// First scan of the list to calculate the offsets and check the sizes
//
for(TAdInfo =g_AdaptersInfoList; TAdInfo !=NULL; TAdInfo =TAdInfo->Next)
{
if(TAdInfo->Flags !=INFO_FLAG_DONT_EXPORT)
{
// Update the size variables
SizeNeeded += (ULONG)strlen(TAdInfo->Name)
+ (ULONG)strlen(TAdInfo->Description) + 2;
SizeNames += (ULONG)strlen(TAdInfo->Name)
+ 1;
}
}

// Check that we don't overflow the buffer.
// Note: 2 is the number of additional separators needed inside the list
if(SizeNeeded + 2 > *BufferSize ||pStr == NULL)
{
ReleaseMutex(g_AdaptersInfoMutex);
TRACE_PRINT1("PacketGetAdapterNames: input buffer too small, we need %u bytes", *BufferSize);
*BufferSize = SizeNeeded + 2; // Report the required size
TRACE_EXIT("PacketGetAdapterNames");
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
OffDescriptions = SizeNames + 1;

//
// Second scan of the list to copy the information
//
for(TAdInfo =g_AdaptersInfoList, SizeNames = 0,SizeDesc =
0; TAdInfo !=NULL; TAdInfo =TAdInfo->Next)
{
if(TAdInfo->Flags !=INFO_FLAG_DONT_EXPORT)
{
// Copy the data
StringCchCopyA(
((PCHAR)pStr) +SizeNames,
*BufferSize - SizeNames,
TAdInfo->Name);
StringCchCopyA(
((PCHAR)pStr) +OffDescriptions + SizeDesc,
*BufferSize - OffDescriptions -SizeDesc,
TAdInfo->Description);

// Update the size variables
SizeNames += (ULONG)strlen(TAdInfo->Name)
+ 1;
SizeDesc += (ULONG)strlen(TAdInfo->Description)
+ 1;
}
}
// Separate the two lists
((PCHAR)pStr)[SizeNames] = 0;
// End the list with a further /0
((PCHAR)pStr)[SizeNeeded + 1] = 0;
ReleaseMutex(g_AdaptersInfoMutex);
TRACE_EXIT("PacketGetAdapterNames");
return TRUE;
}
pcap_findalldevs为wpcap.dll中查找设备列表的函数，里面调用Packet.dll中的PacketGetAdapterNames获取设备列表。它调用PacketPopulateAdaptersInfoList函数，函数PacketPopulateAdaptersInfoList()创建适配器的链表g_AdaptersInfoList。该函数先释放掉g_AdaptersInfoList中旧的内容，然后调用PacketGetAdaptersNPF()函数用新的信息填充该链表。而PacketGetAdaptersNPF调用PacketAddAdapterNPF，从注册表中获取设备信息。PacketAddAdapterNPF又调用PacketRequest，将请求发送到NPF，
{

Result=(BOOLEAN)DeviceIoControl(AdapterObject->hFile,(DWORD)Set ?
(DWORD)BIOCSETOID : (DWORD)BIOCQUERYOID,OidData,sizeof(PACKET_OID_DATA)-1+OidData->Length,OidData,
sizeof(PACKET_OID_DATA)-1+OidData->Length,&BytesReturned,NULL);
}
所有的应用程序和驱动之间通信，最终都是调用DeviceIoControl，WriteFile和ReadFile，Npf中和DeviceIoControl对应的就是NPF_IoControl。

（2） pcap_open_live
pcap_t *
pcap_open_live(constchar *source, int snaplen, intpromisc, int to_ms, char *errbuf)
{
pcap_t *p;
int status;
p = pcap_create(source,errbuf);
if (p == NULL)
return (NULL);
status = pcap_set_snaplen(p,snaplen); //设置最大包长
if (status < 0)
goto fail;
status = pcap_set_promisc(p,promisc); //是否混杂模式
if (status < 0)
goto fail;
status = pcap_set_timeout(p,to_ms); //设置超时
if (status < 0)
goto fail;
/*
* Mark this as opened with pcap_open_live(), so that, for
* example, we show the full list of DLT_ values, rather
* than just the ones that are compatible with capturing
* when not in monitor mode. That allows existing applications
* to work the way they used to work, but allows new applications
* that know about the new open API to, for example, find out the
* DLT_ values that they can select without changing whether
* the adapter is in monitor mode or not.
*/
p->oldstyle = 1;
status = pcap_activate(p);
if (status < 0)
goto fail;
return (p);
fail:
if (status ==PCAP_ERROR || status ==PCAP_ERROR_NO_SUCH_DEVICE ||
status == PCAP_ERROR_PERM_DENIED)
strlcpy(errbuf,p->errbuf, PCAP_ERRBUF_SIZE);
else
snprintf(errbuf,PCAP_ERRBUF_SIZE, "%s: %s",source,
pcap_statustostr(status));
pcap_close(p);
return (NULL);
}
该函数设置最大的包长，设置超时时间，设置混杂模式等。Pcap_open_live调用pcap_activate，pcap_activate定义如下：
Intpcap_activate(pcap_t *p)
{
int status;
status = p->activate_op(p);
if (status >= 0)
p->activated = 1;
return (status);
}
Pcap_activate调用activate_op，该函数是回调函数， p->activate_op = pcap_activate_win32;即pcap_activate调用pcap_activate_win32函数，pcap_activate_win32函数调用PacketOpenAdapter，同时函数设置PacketSetBuff和if(PacketSetMinToCopy(p->adapter,16000)==FALSE)，设置设置最小copysize=16k。PacketOpenAdapter中调用使用NPF
device driver打开网卡(adapter)，同样调用PacketRequest，调用DeviceIoControl，即对应驱动中的NPF_IoControl。

(3) pcap_setfilter
Intpcap_setfilter(pcap_t *p,struct bpf_program *fp)
{
return p->setfilter_op(p,fp);
}
p->setfilter_op =pcap_setfilter_win32_npf;

pcap_setfilter调用pcap_setfilter_win32_npf设置过滤器；
staticint
pcap_setfilter_win32_npf(pcap_t *p, struct bpf_program *fp)
{
if(PacketSetBpf(p->adapter,fp)==FALSE){
/*
* Kernel filter not installed.
* XXX - fall back on userland filtering, as is done
* on other platforms?
*/
snprintf(p->errbuf,PCAP_ERRBUF_SIZE, "Driver error:
cannot set bpf filter: %s",pcap_win32strerror());
return (-1);
}

/*
* Discard any previously-received packets, as they might have
* passed whatever filter was formerly in effect, but might
* not pass this filter (BIOCSETF discards packets buffered
* in the kernel, so you can lose packets in any case).
*/
p->cc = 0;
return (0);
}

BOOLEANPacketSetBpf(LPADAPTERAdapterObject, structbpf_program *fp)
{
DWORD BytesReturned;
BOOLEAN Result;
TRACE_ENTER("PacketSetBpf");
#ifdefHAVE_WANPACKET_API
if (AdapterObject->Flags ==INFO_FLAG_NDISWAN_ADAPTER)
{
Result = WanPacketSetBpfFilter(AdapterObject->pWanAdapter, (PUCHAR)fp->bf_insns,fp->bf_len * sizeof(structbpf_insn));
TRACE_EXIT("PacketSetBpf");
return Result;
}
#endif
#ifdefHAVE_AIRPCAP_API
if(AdapterObject->Flags ==INFO_FLAG_AIRPCAP_CARD)
{
Result = (BOOLEAN)g_PAirpcapSetFilter(AdapterObject->AirpcapAd,
(char*)fp->bf_insns,
fp->bf_len *sizeof(struct bpf_insn));
TRACE_EXIT("PacketSetBpf");
return Result;
}
#endif// HAVE_AIRPCAP_API
#ifdefHAVE_NPFIM_API
if(AdapterObject->Flags == INFO_FLAG_NPFIM_DEVICE)
{
Result = (BOOLEAN)g_NpfImHandlers.NpfImSetBpfFilter(AdapterObject->NpfImHandle,
fp->bf_insns,
fp->bf_len * sizeof(struct bpf_insn));
TRACE_EXIT("PacketSetBpf");
return TRUE;
}
#endif// HAVE_NPFIM_API

#ifdefHAVE_DAG_API
if(AdapterObject->Flags & INFO_FLAG_DAG_CARD)
{
// Delegate the filtering to higher layers since it's too expensive here
TRACE_EXIT("PacketSetBpf");
return TRUE;
}
#endif// HAVE_DAG_API

if (AdapterObject->Flags ==INFO_FLAG_NDIS_ADAPTER)
{
//调用DeviceIoControl设置过滤器
Result = (BOOLEAN)DeviceIoControl(AdapterObject->hFile,BIOCSETF,(char*)fp->bf_insns,fp->bf_len*sizeof(structbpf_insn),NULL,0,&BytesReturned,NULL);
}
else
{
TRACE_PRINT1("Request to set BPF filter on an unknown device type (%u)",AdapterObject->Flags);
Result = FALSE;
}
TRACE_EXIT("PacketSetBpf");
return Result;
}

对应驱动的NPF_IoControl。