VS2022配置WinPcap开发

winpcap 官网：http://www.winpcap.org/
1.首先下载安装 winpcap.exe，http://www.winpcap.org/install/default.htm
目的是安装相关驱动和 dll，安装完成之后基于 winpcap 的应用程序才能够正常运行。
2.下载 winpcap 的开发包，头文件和库文件：http://www.winpcap.org/devel.htm，解压之后主要是头文件和库文件，记得将 WpdPack 复制到 D 盘（直接放在D盘，不要包含在其他文件夹下），如图所示：

VS2022新建一个C++工程，具体操作可参考我上一篇文章，文章链接如下：http://t.csdnimg.cn/RRO57

创建工程后，首先在 vs 中配置（vc++目录：include 目录和 lib 目录），具体步骤如下：

点击“项目”，再点击最下方的属性：

点击VC++目录，如图所示：

接下来修改“包含目录”和“库目录”，包含目录修改为：D:\WpdPack\Include;$(IncludePath)

库目录修改为：D:\WpdPack\Lib\x64;$(LibraryPath)，如图所示：

接着，link 输入：wpcap.lib，ws2_32.lib，具体步骤如下：

在左边的配置属性找到“链接器”，点击，接着点击“输入”：

然后在“附加依赖项”处，添加wpcap.lib和ws2_32.lib两个库，如图所示：（前面的用这两个替换掉，后面的不要动）

接着点击配置预处理器定义，具体步骤如下：

在配置属性处点击C/C++，接着点击“预处理器”，如图所示：

在“预处理器定义”处修改为“WPCAP;HAVE_REMOTE;WIN32;_CRT_SECURE_NO_WARNINGS;_WINSOCK_DEPRECATED_NO_WARNINGS”，如图所示：

接着点击“应用”，再点击“确定”，如图：

代码如下：

//#define HAVE_REMOTE
//#define WPCAP
#include "pcap.h" 
#include <winsock2.h>
#include <string.h>
#include <stdio.h>
using namespace std;
#pragma comment(lib, "wpcap.lib")
#pragma comment(lib, "Ws2_32.lib")
#define LINE_LEN 16
#define MAX_ADDR_LEN 16
FILE* file = 0;
int ip_len;
int tcp_len;
// 以太网协议格式的定义
typedef struct ether_header {
	u_char ether_dhost[6]; // 目标 MAC 地址
	u_char ether_shost[6]; // 源 MAC 地址
	u_short ether_type; // 以太网类型
}ether_header;
// 用户保存 4 字节的 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 version_hlen; // 首部长度 版本
	u_char tos; // 服务质量
	u_short tlen; // 总长度
	u_short identification; // 身份识别
	u_short flags_offset; // 标识 分组偏移
	u_char ttl; // 生命周期
	u_char proto; // 协议类型
	u_short checksum; // 包头测验码
	u_int saddr; // 源 IP 地址
	u_int daddr; // 目的 IP 地址
}ip_header;
// 用于保存 TCP 首部
typedef struct tcp_header {
	u_short sport;
	u_short dport;
	u_int sequence; // 序列码
	u_int ack; // 回复码
	u_char hdrLen; // 首部长度保留字
	u_char flags; // 标志
	u_short windows; // 窗口大小
	u_short checksum; // 校验和
	u_short urgent_pointer; // 紧急指针
}tcp_header;
// 用于保存 UDP 的首部
typedef struct udp_header {
	u_short sport; // 源端口
	u_short dport; // 目标端口
	u_short datalen; // UDP 数据长度
	u_short checksum; // 校验和
}udp_header;
// 用于保存 ICMP 的首部
typedef struct icmp_header {
	u_char type; // ICMP 类型
	u_char code; // 代码
	u_short checksum; // 校验和
	u_short identification; // 标识
	u_short sequence; // 序列号
	u_long timestamp; // 时间戳
}icmp_header;
// 用于保存 ARP 的首部
typedef struct arp_header {
	u_short hardware_type; // 格式化的硬件地址
	u_short protocol_type; // 协议地址格式
	u_char hardware_length; // 硬件地址长度
	u_char protocol_length; // 协议地址长度
	u_short operation_code; // 操作码
	u_char source_ethernet_address[6]; // 发送者硬件地址
	u_char source_ip_address[4]; // 发送者协议地址
	u_char destination_ethernet_address[6]; // 目的方硬件地址
	u_char destination_ip_address[4]; // 目的方协议地址
}arp_header;
#define str4cmp(m, c0, c1, c2, c3) \
(m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3)
void http_protocol_packet_handle(u_char* arg, const struct pcap_pkthdr* pkt_header, const
	u_char* pkt_content)
{
	FILE* file1 = 0;
	//下面这个打开文件能写在这里吗？在这里打开有什么问题？写在这里合适吗？如何改进一下？
		if ((file1 = freopen("http.txt", "a", stdout)) == 0)
			printf("Cannot open the file.\n");
	//加上前面的 IP 头以及以太网还有 TCP 头才是 HTTP 数据包头部
	const u_char* http_head = (u_char*)pkt_content + (14 + ip_len + tcp_len);
	if (http_head != NULL) {//报文有内容：
		if (str4cmp(http_head, 'G', 'E', 'T', ' ')) {//判断是否为 GET 请求
			printf("\n===================HTTP Protocol=================\n");
			u_char* uri_start = (u_char*)http_head + 4;
			u_char* p = uri_start;
			printf("当前 HTTP 请求 uri 是:");
			while (true)
			{
				if (str4cmp(p, 'H', 'T', 'T', 'P')) //说明相对 url 读取完毕
					break;
				printf("%c", p[0]);
				p = p + 1;
			}
			printf("\nhost:");
			while (true)
			{
				if (str4cmp(p, 'H', 'o', 's', 't'))
				{
					p = p + 5;//跳过 HOST:
					while (true)
					{
						printf("%c", p[0]);
						if (p[1] == '\n') //如果下一个是换行符，就说明这一行读取结束，host 读取完毕
							break;
						p = p + 1;
					}
					break;
				}
				p = p + 1;
			}
		}
	}
	fclose(stdin);
	fclose(file1);
}
// TCP 协议处理
//u_short sport;
//u_short dport;
//u_int sequence; // 序列码
//u_int ack; // 回复码
//u_char hdrLen; // 首部长度保留字
//u_char flags; // 标志
//u_short windows; // 窗口大小
//u_short checksum; // 校验和
//u_short urgent_pointer; // 紧急指针
// ntohs()是一个函数名，作用是将一个 16 位数由网络字节顺序转换为主机字节顺序
void tcp_protocol_packet_handle(u_char* arg, const struct pcap_pkthdr* pkt_header, const
	u_char* pkt_content)
{
	tcp_header* tcp_protocol;
	tcp_protocol = (tcp_header*)(pkt_content + 14 + 20);
	//cout << sizeof(u_int) << endl;
	printf("===================TCP Protocol=================\n");
	printf("Source Port: %i\n", ntohs(tcp_protocol->sport));
	printf("Destination Port: %i\n", ntohs(tcp_protocol->dport));//8002
	printf("Sequence number: %d\n", ntohl(tcp_protocol->sequence));
	printf("Acknowledgment number: %d\n", ntohl(tcp_protocol->ack));
	printf("Header Length: %d\n", (tcp_protocol->hdrLen >> 4) * 4);
	printf("Flags: 0x%.3x ", tcp_protocol->flags);
	tcp_len = (tcp_protocol->hdrLen >> 4) * 4;
	if (tcp_protocol->flags & 0x08) printf("(PSH)");
	if (tcp_protocol->flags & 0x10) printf("(ACK)");
	if (tcp_protocol->flags & 0x02) printf("(SYN)");
	if (tcp_protocol->flags & 0x20) printf("(URG)");
	if (tcp_protocol->flags & 0x01) printf("(FIN)");
	if (tcp_protocol->flags & 0x04) printf("(RST)");
	if (ntohs(tcp_protocol->dport) == 80)
	{
		//获取 HTTP 数据包的 header 地址 传入 HTTP 解析函数
		http_protocol_packet_handle(arg, pkt_header, pkt_content);
	}
	printf("\n");
	printf("Windows Size: %i\n", ntohs(tcp_protocol->windows));
	printf("Checksum: 0x%.4x\n", ntohs(tcp_protocol->checksum));
	printf("Urgent Pointer: %i\n", ntohs(tcp_protocol->urgent_pointer));
}
// UDP 协议处理
//u_short sport; // 源端口
//u_short dport; // 目标端口
//u_short datalen; // UDP 数据长度
//u_short checksum; // 校验和
void udp_protocol_packet_handle(u_char* arg, const struct pcap_pkthdr* pkt_header, const
	u_char* pkt_content)
{
	udp_header* udp_protocol;
	udp_protocol = (udp_header*)(pkt_content + 14 + 20);
	printf("===================UDP Protocol=================\n");
	printf("Source Port: %i\n", ntohs(udp_protocol->sport));
	printf("Destination Port: %i\n", ntohs(udp_protocol->dport));
	printf("Datalen: %i\n", ntohs(udp_protocol->datalen));
	printf("Checksum: 0x%.4x\n", ntohs(udp_protocol->checksum));
}
// ICMP 协议处理
//u_char type; // ICMP 类型
//u_char code; // 代码
//u_short checksum; // 校验和
//u_short identification; // 标识
//u_short sequence; // 序列号
//u_long timestamp; // 时间戳
void icmp_protocol_packet_handle(u_char* arg, const struct pcap_pkthdr* pkt_header, const
	u_char* pkt_content)
{
	icmp_header* icmp_protocol;
	icmp_protocol = (icmp_header*)(pkt_content + 14 + 20);
	printf("==================ICMP Protocol=================\n");
	printf("Type: %d ", icmp_protocol->type);
	switch (icmp_protocol->type)
	{
	case 8:
		printf("(request)\n");
		break;
	case 0:
		printf("(reply)\n");
		break;
	default:
		printf("\n");
		break;
	}
	printf("Code: %d\n", icmp_protocol->code);
	printf("CheckSum: 0x%.4x\n", ntohs(icmp_protocol->checksum));
	printf("Identification: 0x%.4x\n", ntohs(icmp_protocol->identification));
	printf("Sequence: 0x%.4x\n", ntohs(icmp_protocol->sequence));
}
// ARP 协议处理
//u_short hardware_type; // 格式化的硬件地址
//u_short protocol_type; // 协议地址格式
//u_char hardware_length; // 硬件地址长度
//u_char protocol_length; // 协议地址长度
//u_short operation_code; // 操作码
//u_char source_ethernet_address[6]; // 发送者硬件地址
//u_char source_ip_address[4]; // 发送者协议地址
//u_char destination_ethernet_address[6]; // 目的方硬件地址
//u_char destination_ip_address[4]; // 目的方协议地址
void arp_protocol_packet_handle(u_char* arg, const struct pcap_pkthdr* pkt_header, const
	u_char* pkt_content)
{
	arp_header* arp_protocol;
	arp_protocol = (arp_header*)(pkt_content + 14);
	printf("==================ARP Protocol==================\n");
	printf("Hardware Type: ");
	switch (ntohs(arp_protocol->hardware_type))
	{
	case 1:
		printf("Ethernet");
		break;
	default:
		break;
	}
	printf(" (%d)\n", ntohs(arp_protocol->hardware_type));
	printf("Protocol Type: \n");
	switch (ntohs(arp_protocol->protocol_type))
	{
	case 0x0800:
		printf("%s", "IP");
		break;
	case 0x0806:
		printf("%s", "ARP");
		break;
	case 0x0835:
		printf("%s", "RARP");
		break;
	default:
		printf("%s", "Unknown Protocol");
		break;
	}
	printf(" (0x%04x)\n", ntohs(arp_protocol->protocol_type));
	printf("Hardware Length: %d\n", arp_protocol->hardware_length);
	printf("Protocol Length: %d\n", arp_protocol->protocol_length);
	printf("Operation Code: ");
	switch (ntohs(arp_protocol->operation_code))
	{
	case 1:
		printf("request");
		break;
	case 2:
		printf("reply");
		break;
	default:
		break;
	}
	printf(" (%i)\n", ntohs(arp_protocol->operation_code));
}
// IP 协议处理
//u_char version_hlen; // 首部长度 版本
//u_char tos; // 服务质量
//u_short tlen; // 总长度
//u_short identification; // 身份识别
//u_short flags_offset; // 标识 分组偏移
//u_char ttl; // 生命周期
//u_char proto; // 协议类型
//u_short checksum; // 包头测验码
//u_int saddr; // 源 IP 地址
//u_int daddr; // 目的 IP 地址
void ip_protocol_packet_handle(u_char* arg, const struct pcap_pkthdr* pkt_header, const
	u_char* pkt_content)
{
	ip_header* ip_protocol;
	sockaddr_in source, dest;
	char sourceIP[MAX_ADDR_LEN], destIP[MAX_ADDR_LEN];
	ip_protocol = (ip_header*)(pkt_content + 14);
	source.sin_addr.s_addr = ip_protocol->saddr;
	dest.sin_addr.s_addr = ip_protocol->daddr;
	strncpy(sourceIP, inet_ntoa(source.sin_addr), MAX_ADDR_LEN);
	strncpy(destIP, inet_ntoa(dest.sin_addr), MAX_ADDR_LEN);
	printf("===================IP Protocol==================\n");
	printf("Version: %d\n", ip_protocol->version_hlen >> 4);
	printf("Header Length: %d bytes\n", (ip_protocol->version_hlen & 0x0f) * 4);
	ip_len = (ip_protocol->version_hlen & 0x0f) * 4;
	printf("Tos: %d\n", ip_protocol->tos);
	printf("Total Length: %d\n", ntohs(ip_protocol->tlen));
	printf("Identification: 0x%.4x (%i)\n", ntohs(ip_protocol->identification), ntohs(ip_protocol->identification));
	printf("Flags: %d\n", ntohs(ip_protocol->flags_offset) >> 13);
	printf("---Reserved bit: %d\n", (ntohs(ip_protocol->flags_offset) & 0x8000) >> 15);
	printf("---Don't fragment: %d\n", (ntohs(ip_protocol->flags_offset) & 0x4000) >> 14);
	printf("---More fragment: %d\n", (ntohs(ip_protocol->flags_offset) & 0x2000) >> 13);
	printf("Fragment offset: %d\n", ntohs(ip_protocol->flags_offset) & 0x1fff);
	printf("Time to live: %d\n", ip_protocol->ttl);
	printf("Protocol Type: ");
	switch (ip_protocol->proto)
	{
	case 1:
		printf("ICMP");
		break;
	case 6:
		printf("TCP");
		break;
	case 17:
		printf("UDP");
		break;
	default:
		break;
	}
	printf(" (%d)\n", ip_protocol->proto);
	printf("Header checkSum: 0x%.4x\n", ntohs(ip_protocol->checksum));
	printf("Source: %s\n", sourceIP);
	printf("Destination: %s\n", destIP);
	if (ip_protocol->proto == htons(0x0600))
		tcp_protocol_packet_handle(arg, pkt_header, pkt_content);
	else if (ip_protocol->proto == htons(0x1100))
		udp_protocol_packet_handle(arg, pkt_header, pkt_content);
	else if (ip_protocol->proto == htons(0x0100))
		icmp_protocol_packet_handle(arg, pkt_header, pkt_content);
}
// Ethernet 协议处理
void ethernet_protocol_packet_handle(u_char* arg, const struct pcap_pkthdr* pkt_header, const u_char* pkt_content)
{
	ether_header* ethernet_protocol;//以太网协议
	u_short ethernet_type; //以太网类型
	u_char* mac_string; //以太网地址
	//获取以太网数据内容
	ethernet_protocol = (ether_header*)pkt_content;
	ethernet_type = ntohs(ethernet_protocol->ether_type);
	printf("==============Ethernet Protocol=================\n");
	//以太网目标地址
	mac_string = ethernet_protocol->ether_dhost;
	printf("Destination Mac Address: %02x:%02x:%02x:%02x:%02x:%02x\n", *mac_string,
		*(mac_string + 1), *(mac_string + 2), *(mac_string + 3), *(mac_string + 4), *(mac_string + 5));
	//以太网源地址
	mac_string = ethernet_protocol->ether_shost;
	printf("Source Mac Address: %02x:%02x:%02x:%02x:%02x:%02x\n", *mac_string, *(mac_string + 1), *(mac_string + 2), *(mac_string + 3), *(mac_string + 4), *(mac_string + 5));
	printf("Ethernet type: ");
	switch (ethernet_type)
	{
	case 0x0800:
		printf("%s", "IP");
		break;
	case 0x0806:
		printf("%s", "ARP");
		break;
	case 0x0835:
		printf("%s", "RARP");
		break;
	default:
		printf("%s", "Unknown Protocol");
		break;
	}
	printf(" (0x%04x)\n", ethernet_type);
	switch (ethernet_type)
	{
	case 0x0800:
		ip_protocol_packet_handle(arg, pkt_header, pkt_content);
		break;
	case 0x0806:
		arp_protocol_packet_handle(arg, pkt_header, pkt_content);
		break;
	case 0x0835:
		printf("==============RARP Protocol=================\n");
		printf("RARP\n");
		break;
	default:
		printf("==============Unknown Protocol==============\n");
		printf("Unknown Protocol\n");
		break;
	}
}
int main()
{
	pcap_if_t* alldevs; //适配器列表，它是一个链表的数据结构
	pcap_if_t* d; //保存某个适配器
	pcap_t* fp;
	int res;
	struct pcap_pkthdr* header;
	const u_char* pkt_data;
	time_t local_tv_sec;
	struct tm* ltime;
	char timestr[16];
	int count = 1;
	int i = 0, inum;
	char errbuf[PCAP_ERRBUF_SIZE];
	printf("===============Adapter List===============\n");
	//获取本地设备列表
	if (pcap_findalldevs(&alldevs, errbuf) == -1)
	{
		fprintf(stderr, "Error in pcap_findalldevs: %s\n", errbuf);
		exit(1);
	}
	//htons()作用是将端口号由主机字节序转换为网络字节序的整数值。(host to net)
	//inet_addr()作用是将一个 IP 字符串转化为一个网络字节序的整数值，用于sockaddr_in.sin_addr.s_addr。
		//inet_ntoa()作用是将一个 sin_addr 结构体输出成 IP 字符串(network to ascii)。
		//输出列表
		for (d = alldevs; d != NULL; d = d->next)
		{
			//printf("%d. %s,addr:%s", ++i, d->name, d->addresses->addr->sa_data);
			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;
	}
	//获取选择编号
	while (1)
	{
		printf("\nEnter the interface number (1-%d): ", i);
		scanf("%d",&inum);
		if (inum > 0 && inum <= i)
			break;
	}
	//跳到用户选择的适配器
	for (d = alldevs, i = 0; i < inum - 1; ++i, d = d->next);
	//打开适配器
	if ((fp = pcap_open_live(d->name,65536,1,1000,errbuf)) == NULL)
	{
		fprintf(stderr, "\nError openning adapter: %s\n", errbuf);
		pcap_freealldevs(alldevs);
		return -1;
	}
	//检查链路层的类型
	if (pcap_datalink(fp) != DLT_EN10MB)
	{
		fprintf(stderr, "This program only run on Ethernet networks\n");
		pcap_close(fp);
		pcap_freealldevs(alldevs);
		return -1;
	}
	printf("The program is working......\n");
	printf("The capture file is saving as 'data.txt'\n");
	printf("You can input 'ctrl + C' to stop the program\n");
	if ((file = freopen("data.txt", "w", stdout)) == 0)
		printf("Cannot open the file.\n");
	while ((res = pcap_next_ex(fp, &header, &pkt_data)) >= 0)
	{
		//超时
		if (res == 0)
			continue;
		//将时间戳转化为可识别格式
		local_tv_sec = header->ts.tv_sec;
		ltime = localtime(&local_tv_sec);
		strftime(timestr, sizeof(timestr), "%H:%M:%S", ltime);
		//输出编号、时间戳和包长度
		printf("============================================================================= = \n");
			printf("No.%d\ttime: %s\tlen: %ld\n", count++, timestr, header->len);
		printf("============================================================================= = \n");
			char temp[LINE_LEN + 1];
		//输出包
		for (i = 0; i < header->caplen; ++i)
		{
			printf("%.2x ", pkt_data[i]);
			if (isgraph(pkt_data[i]) || pkt_data[i] == ' ')
				temp[i % LINE_LEN] = pkt_data[i];
			else
				temp[i % LINE_LEN] = '.';
			if (i % LINE_LEN == 15)
			{
				temp[16] = '\0';
				printf(" ");
				printf("%s", temp);
				printf("\n");
				memset(temp, 0, LINE_LEN);
			}
		}
		printf("\n");
		//分析数据包
		ethernet_protocol_packet_handle(NULL, header, pkt_data);
	}
	if (res == -1)
	{
		printf("Error reading the packets: %s\n", pcap_geterr(fp));
		pcap_close(fp);
		pcap_freealldevs(alldevs);
		fclose(stdin);
		if (file)
			fclose(file);
		return -1;
	}
	//释放
	pcap_close(fp);
	pcap_freealldevs(alldevs);
	fclose(stdin);
	if (file)
		fclose(file);
	return 0;
}

将代码粘贴到Main.cpp里，如图：

点击运行：

结果如图所示：

成功啦！