wirshark发包工具源码

需要下载https://link.csdn.net/?target=https%3A%2F%2Fwww.winpcap.org%2Finstall%2Fbin%2FWpdPack_4_1_2.zip开源库并且使用。
目前只能发送udp的码流

#define HAVE_REMOTE
#define WPCAP
#pragma comment(lib,“wpcap.lib”)
#include <pcap.h>
#include <stdlib.h>
#include <stdio.h>
#include<Winsock2.h>
#include
#include<windows.h>
#include “kdvtype.h”
#include<string.h>
#include <iphlpapi.h>

#pragma comment(lib,“ws2_32.lib”)
#pragma comment(lib,“iphlpapi.lib”)

using namespace std;

#define ETHER_ADDR_LEN 6
#define ETHERTYPE_PUP 0x0200 /* Xerox PUP /
#define ETHERTYPE_SPRITE 0x0500 / Sprite /
#define ETHERTYPE_IP 0x0800 / IP /
#define ETHERTYPE_ARP 0x0806 / Address resolution /
#define ETHERTYPE_REVARP 0x8035 / Reverse ARP /
#define ETHERTYPE_AT 0x809B / AppleTalk protocol /
#define ETHERTYPE_AARP 0x80F3 / AppleTalk ARP /
#define ETHERTYPE_VLAN 0x8100 / IEEE 802.1Q VLAN tagging /
#define ETHERTYPE_IPX 0x8137 / IPX /
#define ETHERTYPE_IPV6 0x86dd / IP protocol version 6 /
#define ETHERTYPE_LOOPBACK 0x9000 / used to test interfaces /
#define MaxQueueLength 2500000 / max length of queue */
#define DATA_NO_ERROR 0
#define IP_HEADER_ERROR -1

s32 data_handle(pcap_pkthdr * &pktheader,const u8 * &pchBuffer,s32 nInDlt);
u16 CalcChecksum(u16 *pwBuffer, s32 nSize);

s8 *g_pachSrcIP = new char[20];//存储源IP地址
s8 *g_pachDstIP = new char[20];//存储目的IP地址
u16 g_wSport = 0;//发送端口
u16 g_wDport = 0;//接收端口
s8 errbuf[PCAP_ERRBUF_SIZE] = { 0 };//用于保存错误信息
s32 g_nRtpLen = 0;
u16 g_nOldPT = 0;
u16 g_nNewPT = 0;

//保存以太网首部
struct TEther_header
{
u8 ether_dhost[ETHER_ADDR_LEN]; //目的MAC地址
u8 ether_shost[ETHER_ADDR_LEN]; //源MAC地址
u16 ether_type; //帧类型
};

//保存IPV4首部
struct TIp_header
{
u8 ihl:4; //IP header length
u8 version:4; //IP version
u8 tos; //Type of service
u16 tot_len; //Total length
u16 id; //Unique identifier
u16 frag_off; //Fragment offset field
u8 ttl; //Time to live
u8 protocol; //Protocol type
u16 check; //IP checksum
unsigned int saddr; //Source address
unsigned int daddr; //Destination address
};

//保存TCP首部
struct TTcphdr
{
u16 srcport; // 源端口
u16 dstport; // 目的端口
u32 seqnum; // 顺序号
u32 acknum; // 确认号
u8 dataoff; // TCP头长
u8 flags; // 标志（URG、ACK等）
u16 window; // 窗口大小
u16 check; // 校验和
u16 urg_ptr; // 紧急指针
};

//保存UDP首部
struct TUdphdr
{
u16 source; //source port
u16 dest; //destination port
u16 len; //udp length
u16 check; //udp checksum
};

//保存RTP首部
struct TRtphdr
{
u16 cc:4; /* CSRC count /
u16 x:1; / header extension flag /
u16 p:1; / padding flag /
u16 v:2; / packet type /
u16 pt:7; / payload type /
u16 m:1; / marker bit /
u16 seq; / sequence number /
u32 ts; / timestamp /
u32 ssrc; / synchronization source */
};

//保存UDP伪首部
struct TPsd_Header
{
u32 sourceip; //源IP地址
u32 destip; //目的IP地址
u8 mbz; //置空(0)
u8 ptcl; //协议类型
u16 plen; //UDP数据包总长度（单位:字节）
};

void main()
{
s32 nPcaplen = 0;
s32 nErr = 0;
s32 nCont = 0;
s32 nRet = 0;
s32 nInDlt = 0;
s32 nIndex = 0;
s32 nGet = 0;
s32 nLoop = 0;
s32 nSend = 0;
s32 nBind = 0;
long lCurTvUsec = 0;
long lCurTvSec = 0;
long lLastTvUsec = 0;
long lLastTvSec = 0;
long lDifTvUsec = 0;
s8 *file = new char[20];
s8 *DstIP = new char[20];
s8 *SrcIP = new char[20];
s8 packet_filter[512] = {“ip and udp and not icmp”};
u16 wDstPort = 0;
u16 wSrcPort = 0;
unsigned int res = 0;
unsigned int netmask = 0;
pcap_send_queue *ptSqueue = NULL;
struct pcap_pkthdr pktheader = NULL;
struct bpf_program fcode;
const u8 pktdata = NULL;
pcap_t ptIndev = NULL;
pcap_t ptOutdev = NULL;
pcap_if_t *alldevs =NULL;
pcap_if_t *d = NULL;
FILE *fp = NULL;
pcap_if_t *ptTemp = NULL;
struct sockaddr_in tDstAddr;
struct sockaddr_in tSrcAddr;

//从配置文件获取数据
LPTSTR lpPath =LPTSTR(new char[MAX_PATH]);
strcpy((char *)lpPath,"./config.ini");
GetPrivateProfileString("FILTERINFO","SRC_IP",NULL,SrcIP,20,lpPath);//获取过滤的源IP，默认返回值NULL
GetPrivateProfileString("FILTERINFO","DST_IP",NULL,DstIP,20,lpPath);//获取过滤的目的IP，默认返回值NULL
GetPrivateProfileString("SENDINFO","SRC_IP",NULL,g_pachSrcIP,20,lpPath);//获取发送的源IP，默认返回值NULL
GetPrivateProfileString("SENDINFO","DST_IP",NULL,g_pachDstIP,20,lpPath);//获取发送的目的IP，默认返回值NULL
GetPrivateProfileString("FILE","NAME",NULL,file,20,lpPath);//由NAME字段获取文件名，默认返回值NULL
wSrcPort = (u16)GetPrivateProfileInt("FILTERINFO","SRC_PORT",0,lpPath);//获取过滤的源端口,默认返回值0
wDstPort = (u16)GetPrivateProfileInt("FILTERINFO","DST_PORT",0,lpPath);//获取过滤的目的端口,默认返回值0
g_wSport = (u16)GetPrivateProfileInt("SENDINFO","SRC_PORT",0,lpPath);//由SRC_PORT字段获取源端口,默认返回值0
g_wDport = (u16)GetPrivateProfileInt("SENDINFO","DST_PORT",0,lpPath);//由DST_PORT字段获取目的端口,默认返回值0
g_nOldPT = (u16)GetPrivateProfileInt("SETPT","OLDPT",0, lpPath);
g_nNewPT = (u16)GetPrivateProfileInt("SETPT", "NEWPT", 0, lpPath);

printf("+++wSrcPort:%d\n",wSrcPort);
//添加过滤条件
if(*SrcIP != '0')
{
	sprintf(packet_filter,"%s and src host %s",packet_filter,SrcIP);
}

if(*DstIP != '0')
{
	sprintf(packet_filter,"%s and dst host %s",packet_filter,DstIP);
}

if(wSrcPort != 0)
{
	sprintf(packet_filter,"%s and src port %u",packet_filter,wSrcPort);
}

if(wDstPort != 0)
{
	sprintf(packet_filter,"%s and dst port %u",packet_filter,wDstPort);
}

WSADATA WSAData;
WORD sockVersion = MAKEWORD(2,2);//当前版本号为2.2
if(WSAStartup(sockVersion,&WSAData)!=0)
{
	printf("WSAStartup error\n");
	return;
}

SOCKET nSockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //创建套接字
//判断创建是否成功
if(nSockfd == SOCKET_ERROR)
{
	printf("socket error:%d\n", WSAGetLastError);
	closesocket(nSockfd);
	return;
}

memset(&tSrcAddr,0,sizeof(tSrcAddr));
tSrcAddr.sin_family = AF_INET; //IP协议
tSrcAddr.sin_port = htons(g_wSport);//端口
tSrcAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//设置IP地址

nBind = bind(nSockfd,(SOCKADDR *)&tSrcAddr,sizeof(SOCKADDR));
if (nBind == SOCKET_ERROR)
{
	printf("bind error:%d\n", WSAGetLastError);
	closesocket(nSockfd);
	return;
}
memset(&tDstAddr,0,sizeof(tDstAddr));
tDstAddr.sin_family = AF_INET; //IP协议
tDstAddr.sin_port = htons(g_wDport);//端口
tDstAddr.sin_addr.S_un.S_addr = inet_addr(g_pachDstIP);//设置IP地址

/*s32 nFlag = 1;
if(setsockopt(nSockfd, IPPROTO_IP, IP_HDRINCL, (s8 *)&nFlag, sizeof(nFlag))<0)
{
    printf("setsockopt() error!/n");
	printf("错误代码是：%d\n",WSAGetLastError());
    closesocket(nSockfd);
	system("pause");
	return;   
}*/

//获取网卡接口列表
if(pcap_findalldevs_ex(PCAP_SRC_IF_STRING,NULL,&alldevs,errbuf) == -1)
{
	printf("error in pcap_findalldevs_ex:%s",errbuf);
	system("pause");
	return ;
}

printf("网络接口设备列表如下：\n");

for(d = alldevs; d!=NULL; d = d->next)
{
	printf("%d. %s", ++nIndex, d->name);
    if(d->description)
	{
		printf(" (%s)\n", d->description);
	}
    else
	{
		printf(" (No description available)\n");
	}
}

printf("\n请选择设备：\n");
while(1)
{
	cin>>nGet;
	if(nGet <=0 || nGet >nIndex)
	{
		printf("输入错误，请重新输入\n");
	}
	else
	{
		break;
	}
}

//跳转至指定设备
for(s32 i = 1; i < nGet; i++)
{
	alldevs = alldevs->next;
}
ptTemp = alldevs;

//打开pcap文件
nErr = fopen_s(&fp,file,"r");
if(nErr != 0)
{
	 printf("open pcap file error , please check file name\n");
	 pcap_freealldevs(ptTemp);
	 system("pause");
	 return;
}

//获取pcap文件长度
if(fseek(fp,0,SEEK_END) == -1)//错误返回-1
{
	perror("get pcap file length error:");//打印错误原因
	system("pause");
	return;
}
nPcaplen = ftell(fp) - sizeof(struct pcap_file_header);//ftell用于得到文件位置指针当前位置相对于文件首的偏移字节数
fclose(fp);

printf("是否循环发送:\n1.是  2.否\n");
cin>>nLoop;

do{
	//打开数据包文件并进行读取，数据格式与tcpdump和tcpslice兼容
	if((ptIndev = pcap_open_offline(file,errbuf))==NULL)
	{
		printf("pcap_open_offline error: %s\n",errbuf);//errbuf传递错误信息
		printf("warning ：Pcapng format is not supported!\n");//无法打开pcapng文件，需要转化成pcap文件 
		pcap_freealldevs(ptTemp);
		system("pause");
		return;
	}	

	//获取数据包捕获描述符，查看数据包
	if((ptOutdev = pcap_open_live(ptTemp->name,//指定打开的设备名
		65536,//捕获数据的最大字节数
		1,    //设置混杂模式
		1000, //读取超时时间 单位：毫秒
		errbuf)) == NULL)
	{
		printf("pcap_open_live error :%s\n",errbuf);
		pcap_freealldevs(ptTemp);
		system("pause");
		return;
	}

	nInDlt = pcap_datalink(ptIndev);//获取链路层类型

	//这里只考虑以太网和Linux
	if(nInDlt!=DLT_EN10MB && nInDlt!=DLT_LINUX_SLL)
	{
		printf("program works only on Ethernet networks and Linux cooked capture!\n");
		pcap_freealldevs(ptTemp);
		system("pause");
		return;
	}

	//获取netmask
	if(ptTemp->addresses != NULL)
	{
		netmask = ((struct sockaddr_in*)(ptTemp->addresses->netmask))->sin_addr.S_un.S_addr;
	}
	else
	{
		netmask = 0xffffff;/* 255.255.255.0 */
	}

	//编译过滤器
	if(pcap_compile(ptIndev,&fcode,packet_filter,1,netmask)<0)
	{
		printf("compile error\n");
		printf("Warning ：incorrect ip address or port!");
		pcap_freealldevs(ptTemp);
		system("pause");
		return;
	}

	if(pcap_setfilter(ptIndev,&fcode) < 0)
	{
		printf("setfilter error\n");
		pcap_freealldevs(ptTemp);
		system("pause");
		return;
	}

	//按帧发送
	while((res = pcap_next_ex(ptIndev, &pktheader, &pktdata)) == 1)
	{
		nCont++;
		nRet = data_handle(pktheader,pktdata,nInDlt);

		lDifTvUsec = (pktheader->ts.tv_sec-lLastTvSec)*1000+(pktheader->ts.tv_usec-lLastTvUsec)/1000;
		if(nCont == 1 || lDifTvUsec < 0)
		{
			lDifTvUsec = 0;
		}
		printf("ts.tv_sec = %ld , tv_usec =%ld  ", pktheader->ts.tv_sec, pktheader->ts.tv_usec);
		printf("lDifTvUsec= %ld  ",lDifTvUsec);
		Sleep(lDifTvUsec);

		nSend = sendto(nSockfd,(s8 *)pktdata,nRet,0,(struct sockaddr *)&tDstAddr, sizeof(SOCKADDR));
		printf("nSend = %d\n",nSend);
		if(nSend < 0)
		{
			printf("sendto error:%d\n", WSAGetLastError);
			goto stop;
		}
		
		lLastTvSec = pktheader->ts.tv_sec;//获取时间戳秒位
		lLastTvUsec = pktheader->ts.tv_usec;//获取时间戳毫秒位
	}

	/*//获取最后一个数据包，将最后一帧所在队列发送
	if (res == (unsigned int)-2)
	{
		nCont++;
		nRet = data_handle(pktheader,pktdata,nInDlt);

		lDifTvUsec = (pktheader->ts.tv_sec-lLastTvSec)*1000+(pktheader->ts.tv_usec-lLastTvUsec)/1000;

		nSend = sendto(nSockfd,(s8 *)pktdata,nRet,0,(struct sockaddr *)&tDstAddr, sizeof(SOCKADDR));
		printf("nSend = %d\n",nSend);
		if(nSend < 0)
		{
			printf("sendto error:%d\n", WSAGetLastError);
			goto stop;
		}

		lLastTvSec = 0;//获取时间戳秒位
		lLastTvUsec = 0;//获取时间戳毫秒位
	}*/

	lLastTvSec = 0;
	lLastTvUsec = 0;
	nCont = 0;
}while(nLoop == 1);

stop:
pcap_freealldevs(ptTemp);
pcap_close(ptIndev);
pcap_close(ptOutdev);
closesocket(nSockfd);
WSACleanup();
return;
}

/*=============================================================================
函 数 名： CalcChecksum
功 能： 校验和计算, 在外壳调用前保证为nSize偶数
算法实现： （可选项）
全局变量： 无
参 数： u16 wBuffer
s32 nSize 偶数
返 回 值： u16
=============================================================================/
u16 CalcChecksum(u16 *pwBuffer, s32 nSize)
{
u32 dwCkSum = 0;

//把所有16位的字相加，如果遇到进位，则将高于16字节的进位部分的值加到最低位上
while (nSize > 1)
{
    dwCkSum += *pwBuffer++;
    nSize  -= sizeof(u16);
}
if(nSize)
{
    dwCkSum += *(u8*)pwBuffer;
}

dwCkSum  = (dwCkSum >> 16) + (dwCkSum & 0xffff);
dwCkSum += (dwCkSum >> 16);

return (u16)(~dwCkSum);//取反

}

/=============================================================================
函数名 ：udp data_handle
功能 ：数据包处理
算法实现 ：（可选项）
引用全局变量：无
输入参数说明：
&pktheader 数据包头的引用
&pchBuffer 数据包内容的引用
nDlt 数据包文件描述符
&dwTimeStamp 数据包时间戳的引用
返回值说明： 正常返回DATA_NO_ERROR
=============================================================================/
s32 data_handle(pcap_pkthdr * &pktheader,const u8 * &pchBuffer,s32 nDlt)
{
s32 nRtpLen = 0;
//对于Linux 只需偏移2个字节即可
if(nDlt == DLT_LINUX_SLL)
{
pchBuffer += 2;
pktheader->len -= 2;
pktheader->caplen -= 2;
}

TEther_header* ptEther_header  =  (TEther_header*)pchBuffer;//以太网首部指针
TIp_header* ptIp_header	=	(TIp_header*)(pchBuffer + sizeof(TEther_header));//IP数据头指针
TUdphdr* ptUdp_header  =  (TUdphdr*)(pchBuffer + sizeof(TEther_header) + sizeof(TIp_header));//UDP数据头指针
TRtphdr* ptRtp_header =  (TRtphdr*)(pchBuffer + sizeof(TEther_header) + sizeof(TIp_header)+sizeof(TUdphdr));//RTP数据头指针

pchBuffer = (u8 *)ptRtp_header;

if (ptRtp_header->pt == g_nOldPT)
{
	ptRtp_header->pt = g_nNewPT;
}

nRtpLen = htons(ptUdp_header->len)-8;
return nRtpLen;

}

/=============================================================================
函数名 ：udp data_handle
功能 ：数据包处理
算法实现 ：（可选项）
引用全局变量：无
输入参数说明：
&pktheader 数据包头的引用
&pchBuffer 数据包内容的引用
nDlt 数据包文件描述符
&dwTimeStamp 数据包时间戳的引用
返回值说明： 正常返回DATA_NO_ERROR
=============================================================================/
s32 tcp_data_handle(pcap_pkthdr * &pktheader,const u8 * &pchBuffer,s32 nDlt)
{
s32 nRtpLen = 0;
//对于Linux 只需偏移2个字节即可
if(nDlt == DLT_LINUX_SLL)
{
pchBuffer += 2;
pktheader->len -= 2;
pktheader->caplen -= 2;
}

TEther_header* ptEther_header  =  (TEther_header*)pchBuffer;//以太网首部指针
TIp_header* ptIp_header	=	(TIp_header*)(pchBuffer + sizeof(TEther_header));//IP数据头指针
//TUdphdr* ptUdp_header  =  (TUdphdr*)(pchBuffer + sizeof(TEther_header) + sizeof(TIp_header));//UDP数据头指针
//TRtphdr* ptRtp_header =  (TRtphdr*)(pchBuffer + sizeof(TEther_header) + sizeof(TIp_header)+sizeof(TUdphdr));//RTP数据头指针

TTcphdr* ptTcp_header  =  (TTcphdr*)(pchBuffer + sizeof(TEther_header) + sizeof(TIp_header));//TCP数据头指针
TRtphdr* ptRtp_header =  (TRtphdr*)(pchBuffer + sizeof(TEther_header) + sizeof(TIp_header)+sizeof(TTcphdr));//RTP数据头指针

pchBuffer = (u8 *)ptRtp_header;

if (ptRtp_header->pt == g_nOldPT)
{
	ptRtp_header->pt = g_nNewPT;
}
printf("+++pt:%d\n",ptRtp_header->pt);
nRtpLen = htons(ptTcp_header->window)-20;
return nRtpLen;

}

/*#define _CRT_SECURE_NO_WARNINGS // 消除fopen告警
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include
#include <winsock2.h>

#pragma comment(lib, “ws2_32.lib”)

int main(int argn, char*agrv[])
{
if(argn < 2)
{
printf(“请把要解析的文件作为第一个参数.\n”);
getchar();
return 0;
}

FILE *fp = fopen(agrv[1], "rb");
if (!fp) 
{
	printf("打开文件 %s 失败.\n", agrv[1]);
	getchar();
	return 0;
}

WSADATA WSAData;
WSAStartup(MAKEWORD(2, 0), &WSAData);

int Sockfd = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(2020);
sin.sin_addr.s_addr	= INADDR_ANY;//dwBindIp

if (bind(Sockfd, (struct sockaddr*) &sin, sizeof(sin)) < 0)
{
	printf("服务绑定端口%d失败，请检查端口是否被其他服务占用！\n", 2020);
	closesocket(Sockfd);
	return -1;
}

struct sockaddr_in dst;
memset(&dst, 0, sizeof(dst));
dst.sin_family = AF_INET;
dst.sin_addr.s_addr = inet_addr("1.2.3.4");;
dst.sin_port = htons(2021);

char *buf = new char[64 * 1024];
int addr_len = sizeof(dst);
unsigned short rtp_len;
while (true)
{
	if (2 != fread(&rtp_len, 1, 2, fp))
		break;
	rtp_len = ntohs(rtp_len);
	printf("+++rtp_len:%d\n",rtp_len);
	if (rtp_len != fread(buf, 1, rtp_len, fp))
		break;
	printf("+++rtp_len1:%d\n",rtp_len);
	sendto(Sockfd, buf, rtp_len, 0, (sockaddr*)&dst, addr_len);
	Sleep(1);
}
printf("转换完毕.\n");
delete buf;
return 0;

}*/

config.ini配置文件
[FILTERINFO]
SRC_IP = 172.16.65.92
SRC_PORT = 554

DST_IP = 172.16.64.86
DST_PORT = 13591

[SENDINFO]
DST_IP = 172.16.131.171
DST_PORT = 50000

SRC_IP = 172.16.64.84
SRC_PORT = 59001

[FILE]
NAME = “rtsp_tcp2.pcap”