目录
原始套接字指的是在传输层下面使用的套接字，之前使用的流式套接字和数据报套接字是工作在传输层的，并且在接受和发送的时候只能对数据部分进行操作，如果想要自己组建一个报文，那么就需要使用原始套接字。并且原始套接字还可以监听所有经过本机网卡的数据帧或者数据包。
【原始套接字的创建】
原始套接字的创建也是使用socket函数，但是形参比起TCP或者UDP有所不同
当编译完成生成可执行文件的时候，执行需要加sudo
int socket(PF_PACKET,SOCK_RAW,protocol);功能
创建链路层的原始套接字
参数
protocol：用来指定接受或者发送的数据包类型
ETH_P_IP：IPV4数据包
ETH_P_ARP：ARP数据包
ETH_P_ALL：任何协议类型的数据包
注意：protocol这个参数需要转为网络字节序，也就是使用htons()
返回值
成功：>0，链路层套接字
失败：<0，出错
【协议格式】
1.UDP数据格式
UDP的报文头由64位8个字节组成，用来标识网络通信之前源进程与目的进程的端口号
2.TCP数据格式
TCP的报文头格式相比于UDP更为的复杂，首先为源端口号和目的端口号，因为TCP会进行确认，于是就会有序列号和确认号，因为TCP的头部长度至少为20字节（没有选项的情况下），且头部长度中仅为4位，最多只能表示15，不足以表示正确长度。所以头部长度为实际长度除以4，也就是如果头部实际长度为20，那么头部长度这个选项为5。
3.IP报文数据格式
版本这个选项是看使用的是IPV4还是IPV6，如果是前者为4。首部长度和UDP报文头的相同，选项为IP实际报文头长度除以4。服务类型一般为0，总长度为IP报文头的长度加上数据的长度。标识一般为0，标识和片偏移也一般为0。生存时间TTL表示此数据经过一个路由器递减的次数，可以大致填写，协议类型根据实际情况填写。头部校验需要使用特定的函数校验，然后填写进去，未校验前先填写0。
4.MAC报文数据格式
MAC报文的报文较为简单，只需要填写目的MAC,源MAC以及数据的类型即可
【使用原始套接字捕获网络数据】
原始套接字可以捕获任何经过当前主机网卡的数据，那么使用原始套接字接受数据，然后通过组包把数据拆拆解到定义的相应数组中，就可以获取相应的想要获取的数据
通过对接受到的数据的拆解，我们可以得到很多报文中的数据
可见我们通过原始套接字成功捕获到各个数据的类型以及源MAC目的MAC，源IP目的IP
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/ether.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
int socket_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL));
if( socket_fd < 0 )
{
perror("socket:");
return 0;
}
printf("socket = %d \n",socket_fd);
unsigned char data[1500] = "";
unsigned char src_mac[18] = "";
unsigned char dst_mac[18] = "";
unsigned char type[2] = "";
unsigned char src_ip[16] = "";
unsigned char dst_ip[16] = "";
while(1)
{
recvfrom(socket_fd,data,sizeof(data),0,NULL,NULL);
/************* 解析目的Mac和源Mac ************/
sprintf(src_mac,"%02x:%02x:%02x:%02x:%02x:%02x",\
data[0],data[1],data[2],data[3],data[4],data[5]);
sprintf(dst_mac,"%02x:%02x:%02x:%02x:%02x:%02x",\
data[6],data[7],data[8],data[9],data[10],data[11]);
/************* 解析数据类型 ************/
sprintf(type,"0x%02x%02x",data[12],data[13]);
if( data[13] == 0x00 )
{
printf("\tIP数据报--->%s\n",type);
unsigned char* ip_head = data+14;
inet_ntop(AF_INET,(unsigned int*)(ip_head+12),src_ip,16);
inet_ntop(AF_INET,(unsigned int*)(ip_head+16),dst_ip,16);
printf("\tsrc_ip%s ------> dst_ip%s \n",src_ip,dst_ip);
}
else if( data[13] == 0x06 )
{
printf("\tARP数据报--->%s\n",type);
}
if( data[13] == 0x35 )
{
printf("\tRARP数据报--->%s\n",type);
}
printf("src_mac:%s --------> dst_mac%s \n",src_mac,dst_mac);
}
close(socket_fd);
return 0;
}
【使用原始套接字发送网络数据】
通过原始套接字发送组建好的数据，使用sendto发送完整的数据帧
sendto(sock_raw_fd,msg,msg_len,0,(struct sockaddr*)&sll,sizof(sll));功能
msg：完整的数据格式
msg_len：帧的实际长度
sll：本地主机上的帧数据，出去的网卡地址
sll结构体的数据类型和头文件
struct sockaddr_ll sll
#include <netpacket/packet.h>
获取本地机的接口数据
#include <sys/ioctl.h>
int ioctl(int fd, int request, void*);具体的获得网络接口可以封装为一个函数，具体函数如下
如果想要使用原始套接字发送数据，那么就需要使用这个发送函数，第一个形参为套接字，第二个位发送的数据，第三个为数据长度，第四个为网络接口的名称（可以使用ifconfig查看）
int my_send(int socket_fd , char* msg , int msg_len , char* net_name )
{
struct ifreq ethreq;
//把你要发送的网卡名称赋值进去
strncpy(ethreq.ifr_name,net_name,IFNAMSIZ);
if( -1 == ioctl(socket_fd, SIOCGIFINDEX ,ðreq) )
{
perror("sockfd");
close(socket_fd);
_exit(-1);
}
struct sockaddr_ll sll;
memset(&sll,0,sizeof(sll));
//通过网卡名获取网络接口
sll.sll_ifindex = ethreq.ifr_ifindex;
//发送
int len = sendto(socket_fd,msg,msg_len,0,(struct sockaddr *)&sll,sizeof(sll));
return len;
}【发送ARP报文获取未知的MAC地址】
1.实现原理
如果我们想向一台主机发送报文，比如说A主机向B主机发送ping命令（ICMP），但是A主机只有B主机的IP地址，而没有B主机的MAC地址，此时需要使用ARP报文来获取B主机的MAC地址，才能成功ping通
2.ARP数据报文格式
3.实现
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/ether.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <string.h>
#include <netpacket/packet.h>
int my_send(int socket_fd , unsigned char* msg , int msg_len , char* net_name )
{
struct ifreq ethreq;
//把你要发送的网卡名称赋值进去
strncpy(ethreq.ifr_name,net_name,IFNAMSIZ);
if( -1 == ioctl(socket_fd, SIOCGIFINDEX ,ðreq) )
{
perror("sockfd");
close(socket_fd);
_exit(-1);
}
struct sockaddr_ll sll;
memset(&sll,0,sizeof(sll));
//通过网卡名获取网络接口
sll.sll_ifindex = ethreq.ifr_ifindex;
//发送
int len = sendto(socket_fd,msg,msg_len,0,(struct sockaddr *)&sll,sizeof(sll));
return len;
}
int main(int argc, char const *argv[])
{
//创建原始套接字
int socket_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL));
if( socket_fd < 0 )
{
perror("socket:");
return 0;
}
printf("socket = %d \n",socket_fd);
//创建发送的数据
unsigned char msg[512] = {
//------------------------------- mac头
0xff,0xff,0xff,0xff,0xff,0xff, //目的mac
0x00,0x0c,0x29,0xxx,0xxx,0xxx, //源mac <-----------------------
0x08,0x06, //帧类型
//------------------------------- ARP报文
0x00,0x01, //硬件类型
0x08,0x00, //协议类型
0x06, //硬件地址长度
0x04, //协议地址长度
0x00,0x01, //选项 ARP请求
0x00,0x0c,0x29,0xxx,0xxx,0xxx, //源mac <-----------------------
192,168,x,xxx, //源IP
0x00,0x00,0x00,0x00,0x00,0x00, //目的mac
192,168,x,xxx, //目的IP
};
//通过网络接口发送数据
int len = my_send(socket_fd,msg,42,"ens33");
printf("发送报文长度为%d\n",len);
//使用循环接受符合要求数据
unsigned char rec_data[1500] = "";
unsigned char src_mac[18] = "";
unsigned char src_ip[16] = "";
while(1)
{
recvfrom(socket_fd,rec_data,sizeof(rec_data),0,NULL,NULL);
unsigned short mac_type = ntohs(*(unsigned short *)(rec_data + 12));
//需要ARP数据报，其他过滤
if( mac_type == 0x0806 )
{
unsigned short op = ntohs(*(unsigned short *)(rec_data + 20));
if( 0x02 == op )
{
//获取需要的mac地址
sprintf(src_mac,"%02x:%02x:%02x:%02x:%02x:%02x",\
rec_data[6],rec_data[7],rec_data[8],rec_data[9],rec_data[10],rec_data[11]);
//获取IP
inet_ntop(AF_INET,(unsigned int*)(rec_data+28),src_ip,16);
printf("%s的mac地址为----->%s\n",src_ip,src_mac);
break;
}
}
}
close(socket_fd);
return 0;
}
3.1数据帧的组包
一般来说，进行网络通信定义的数组的类型为无符号字符类型，因为有时候接受或者发送的时候会接受到图片，而图片的RGB的范围为0-255，如果使用有符号字符会出错。
组包时注意要按照网络字节序也就是大端形式组包
//创建发送的数据
unsigned char msg[512] = {
//------------------------------- 以太网头
0xff,0xff,0xff,0xff,0xff,0xff, //目的mac
//全 ff 表示广播
0x00,0x0c,0x29,0xxx,0xxx,0xxx, //源mac <-----------------------
0x08,0x06, //帧类型
//------------------------------- ARP报文
0x00,0x01, //硬件类型
0x08,0x00, //协议类型
0x06, //硬件地址长度
0x04, //协议地址长度
0x00,0x01, //选项 ARP请求
0x00,0x0c,0x29,0xxx,0xxx,0xxx, //源mac <-----------------------
192,168,x,xxx, //源IP
0x00,0x00,0x00,0x00,0x00,0x00, //目的mac
//此时不知道目的MAC地址，使用0
192,168,x,xxx, //目的IP
};【ARP欺骗】
1.实现原理
一般来说，主机是不会判断自身是否发送过ARP请求报文的，所以另一台主机只需要伪装一个ARP应答报文，然后任意修改报文中源MAC的地址，此时在接受的主机那里，arp表中相应IP的MAC就会被修改。
此时在组建数据帧的时候，源MAC和op选项需要修改
2.使用协议结构体组建数据
我们一开始在组建ARP报文获取已知IP未知MAC主机的MAC地址的时候，是直接定义一段连续的空间来人为一个字节一个字节组建的，这样是十分繁琐的，接下来使用结构体进行组包
具体的实现原理就是，定义一段连续的内存空间用来组建数据，然后通过不同结构体的指针操控的空间大小，来对这段连续的空间进行赋值
这里我们需要以太网头部结构体以及ARP数据结构体
以太网头部结构体
#include <net/ethernet.h>
struct ether_header
{
u_int8_t ether_dhost[ETH_ALEN]; //目的MAC地址
u_int8_t ether_shost[ETH_ALEN]; //源MAC地址
u_int16_t ether_type; //帧类型
};
ARP数据结构体
#include <net/if_arp.h>
/********************** ARP头部 ***************************/
typedef struct
{
unsigned short int ar_hrd; //硬件类型
unsigned short int ar_pro; //协议类型
unsigned char ar_hln; //硬件地址长度
unsigned char ar_pln; //协议地址长度
unsigned short int ar_op; //op
#if 1
unsigned char __ar_sha[ETH_ALEN]; //发送源mac
unsigned char __ar_sip[4]; //发送IP
unsigned char __ar_tha[ETH_ALEN]; //接受的mac
unsigned char __ar_tip[4]; //发送IP
#endif
}ARPHDR;3.实现
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/ether.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <string.h>
#include <netpacket/packet.h>
#include <net/ethernet.h>
#include <net/if_arp.h>
/********************** ARP头部 ***************************/
typedef struct
{
unsigned short int ar_hrd; /* Format of hardware address. */
unsigned short int ar_pro; /* Format of protocol address. */
unsigned char ar_hln; /* Length of hardware address. */
unsigned char ar_pln; /* Length of protocol address. */
unsigned short int ar_op; /* ARP opcode (command). */
#if 1
/* Ethernet looks like this : This bit is variable sized
however... */
unsigned char __ar_sha[ETH_ALEN]; /* Sender hardware address. */
unsigned char __ar_sip[4]; /* Sender IP address. */
unsigned char __ar_tha[ETH_ALEN]; /* Target hardware address. */
unsigned char __ar_tip[4]; /* Target IP address. */
#endif
}ARPHDR;
/*******************************************************************/
int my_send(int socket_fd , char* msg , int msg_len , char* net_name )
{
struct ifreq ethreq;
//把你要发送的网卡名称赋值进去
strncpy(ethreq.ifr_name,net_name,IFNAMSIZ);
if( -1 == ioctl(socket_fd, SIOCGIFINDEX ,ðreq) )
{
perror("sockfd");
close(socket_fd);
_exit(-1);
}
struct sockaddr_ll sll;
memset(&sll,0,sizeof(sll));
//通过网卡名获取网络接口
sll.sll_ifindex = ethreq.ifr_ifindex;
//发送
int len = sendto(socket_fd,msg,msg_len,0,(struct sockaddr *)&sll,sizeof(sll));
return len;
}
int main(int argc, char const *argv[])
{
//创建原始套接字
int socket_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL));
if( socket_fd < 0 )
{
perror("socket:");
return 0;
}
printf("socket = %d \n",socket_fd);
//创建发送的数据
unsigned char msg[512] = {0};
//使用结构体来对数据进行填充
unsigned char src_ip[4] = {192,168,xxx,xxx}; //<-----------------
unsigned char dst_ip[4] = {192,168,xxx,xxx}; //<-----------------
unsigned char dst_mac[6] = {0x62,0xa3,0x34,0xxx,0xxx,0xxx}; //<-----------------
unsigned char src_mac[6] = {0xee,0xee,0xee,0xee,0xee,0xee};
//以太网头部
struct ether_header* mac_head = (struct ether_header*)msg;
memcpy(mac_head->ether_dhost,dst_mac,6);//以太网头部的目的mac
memcpy(mac_head->ether_shost,src_mac,6);//以太网头部的源mac
mac_head->ether_type = htons(0x0806); //以太网头部的帧类型
//ARP报
ARPHDR* arp_head = (ARPHDR*)(msg+14);
arp_head->ar_hrd = htons(1); //硬件类型
arp_head->ar_pro = htons(0x0800); //协议类型
arp_head->ar_hln = 6; //硬件地址长度
arp_head->ar_pln = 4; //协议地址长度
arp_head->ar_op = htons(2); //op
memcpy(arp_head->__ar_sha,src_mac,6);//发送源mac
memcpy(arp_head->__ar_sip,src_ip,4);//发送IP
memcpy(arp_head->__ar_tha,dst_mac,6);//接受的mac
memcpy(arp_head->__ar_tip,dst_ip,4);//发送IP
int i = 0;
for ( i = 0; i < 10; i++)
{
int len = my_send(socket_fd,msg,42,"ens33");
printf("发送报文长度为%d\n",len);
sleep(1);
}
//通过网络接口发送数据
close(socket_fd);
return 0;
}
【构建UDP报文】
1.协议结构体及实现
构建UDP报文，我们需要以太网头部，IP头部，UDP报文头部以及发送的数据总共四个部分组成
在这里我们需要IP的报文头以及UDP的报文头
#include <netinet/ip.h>
***********************IP的结构***********************************
struct iphdr
{
#if __BYTE_ORDER == __LITTLE_ENDIAN //小端存储
unsigned int ihl:4;//首部长度
unsigned int version:4;//版本
#elif __BYTE_ORDER == __BIG_ENDIAN //大端存储
unsigned int version:4;
unsigned int ihl:4;
#else
# error "Please fix <bits/endian.h>"
#endif
u_int8_t tos;//服务类型
u_int16_t tot_len;//总长度为ip头+UDP头+发送数据长度
u_int16_t id;//标识
u_int16_t frag_off;//标志，片偏移
u_int8_t ttl;//生存时间
u_int8_t protocol;//上层协议udp
u_int16_t check;//校验，等数据填充完毕在校验，这里为0
u_int32_t saddr;//源IP地址，转为32无符号
u_int32_t daddr;//目的IP地址，转为32无符号
};#include <netinet/udp.h>
***********************UDP的结构*****************************
struct udphdr
{
u_int16_t source;//源端口号
u_int16_t dest;//目的端口号
u_int16_t len;//UDP长度为头部加上数据长度
u_int16_t check;//校验
};2.IP头校验及UDP头校验
IP头以及UDP头中的校验位我们需要用到如下函数，然后通过该函数的返回值完成校验
IP头只需要把整个头部放进去，然后通过校验位接受返回值就行
ip_head->check = checksum((unsigned short*)ip_head,20);//校验
UDP校验需要用到伪头部
//********************* 校验函数 ************************
unsigned short checksum(unsigned short *buf, int len)
{
int nword = len / 2;
unsigned long sum;
if (len % 2 == 1)
nword++;
for (sum = 0; nword > 0; nword--)
{
sum += *buf;
buf++;
}
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
return ~sum;
}2.1UDP的伪头部及校验
想要获得UDP头的校验位，那么我们需要构建一个UDP的伪头部进行校验
//********************* udp伪头部结构体 ************************
typedef struct
{
u_int32_t src_ip; //源IP
u_int32_t dst_ip; //目的IP
u_int8_t flag; //标志位0
u_int8_t proto; //协议17表示UDP
u_int16_t len; //UDP长度
}Fake_UDP;
//********************* 具体实现 ************************
//udp的校验需要伪头部
unsigned char fake_head[512] = "";
Fake_UDP *fake_udp_head = (Fake_UDP *)fake_head;
fake_udp_head->src_ip = inet_addr("192.168.x.xxx");//源IP地址，转为32无符号
fake_udp_head->dst_ip = inet_addr("192.168.x.xxx");//目的IP地址，转为32无符号
fake_udp_head->flag = 0;//通常为0
fake_udp_head->proto = 17;//协议UDP
fake_udp_head->len = htons(8+send_data_len);
//把剩下的内容拷贝到伪头部的连续内存中-------------->拷贝的是UDP伪头部下面的内容
memcpy(fake_head+12,udp_head,8+send_data_len);
//校验-------------------------------------------->通过伪头部校验，获得校验值放于真UDP头中
udp_head->check = checksum((unsigned short*)fake_head,20+send_data_len);//校验3.实现
我们这里通过虚拟机组建UDP报文向主机中的网络调试助手发送信息
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/ether.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <string.h>
#include <netpacket/packet.h>
#include <net/ethernet.h>
#include <net/if_arp.h>
#include <netinet/udp.h>
#include <netinet/ip.h>
//********************* udp伪头部结构体 ************************
typedef struct
{
u_int32_t src_ip; //源IP
u_int32_t dst_ip; //目的IP
u_int8_t flag; //标志位0
u_int8_t proto; //协议17表示UDP
u_int16_t len; //UDP长度
}Fake_UDP;
//********************* 校验函数 ************************
unsigned short checksum(unsigned short *buf, int len)
{
int nword = len / 2;
unsigned long sum;
if (len % 2 == 1)
nword++;
for (sum = 0; nword > 0; nword--)
{
sum += *buf;
buf++;
}
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
return ~sum;
}
//********************* 原始套接字发送函数 ************************
int my_send(int socket_fd , char* msg , int msg_len , char* net_name )
{
struct ifreq ethreq;
//把你要发送的网卡名称赋值进去
strncpy(ethreq.ifr_name,net_name,IFNAMSIZ);
if( -1 == ioctl(socket_fd, SIOCGIFINDEX ,ðreq) )
{
perror("sockfd");
close(socket_fd);
_exit(-1);
}
struct sockaddr_ll sll;
memset(&sll,0,sizeof(sll));
//通过网卡名获取网络接口
sll.sll_ifindex = ethreq.ifr_ifindex;
//发送
int len = sendto(socket_fd,msg,msg_len,0,(struct sockaddr *)&sll,sizeof(sll));
return len;
}
//********************* 主函数 ************************
int main(int argc, char const *argv[])
{
//创建原始套接字
int socket_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL));
if( socket_fd < 0 )
{
perror("socket:");
return 0;
}
printf("socket = %d \n",socket_fd);
//通过udp发送的数据
unsigned char send_data[512] = "";
printf("请输入发送的信息:\n");
scanf("%s",send_data);
int send_data_len = strlen(send_data);
//数据长度必须为偶数
send_data_len = send_data_len + send_data_len%2;
//创建发送的数据
unsigned char msg[1500] = {0};
//使用结构体来对数据进行填充
unsigned char src_ip[4] = {192,168,x,xxx};//源IP <----------------------
unsigned char dst_ip[4] = {192,168,x,xxx};//目的IP <----------------------
unsigned char dst_mac[6] = {0x62,0xa3,0x34,0xxx,0xxx,0xxx};//目的mac <---------------
unsigned char src_mac[6] = {0x00,0x0c,0x29,0xxx,0xxx,0xxx};//源mac<------------------
//********************* 以太网头部 ************************
struct ether_header* mac_head = (struct ether_header*)msg;
memcpy(mac_head->ether_dhost,dst_mac,6);//以太网头部的目的mac
memcpy(mac_head->ether_shost,src_mac,6);//以太网头部的源mac
mac_head->ether_type = htons(0x0800); //以太网头部的帧类型
//********************* IP报文头 ************************
struct iphdr* ip_head = (struct iphdr*)(msg+14);
ip_head->version = 4;//版本
ip_head->ihl = 20/4;//长度为总长度除以4
ip_head->tos = 0;//服务类型
ip_head->tot_len = htons(20+8+send_data_len);//总长度为ip头+UDP头+发送数据长度
ip_head->id = htons(0);//标识
ip_head->frag_off = htons(0); //标志，片偏移
ip_head->ttl = 128;//生存时间
ip_head->protocol = 17;//上层协议udp
ip_head->check = htons(0);//校验，等数据填充完毕在校验，这里为0
ip_head->saddr = inet_addr("192.168.x.xxx");//源IP地址，转为32无符号<-----------------
ip_head->daddr = inet_addr("192.168.x.xxx");//目的IP地址，转为32无符号<---------------
ip_head->check = checksum((unsigned short*)ip_head,20);//校验
//********************* UDP报文头 ************************
struct udphdr* udp_head = (struct udphdr*)(msg+14+20);
udp_head->source = htons(8000);//源端口号
udp_head->dest = htons(8000);//目的端口号
udp_head->len = htons(8+send_data_len);//UDP长度为头部加上数据长度
udp_head->check = htons(0);//校验
/******* 犯错点 *******/
/******* udp_head是struct udphdr*类型，+8跳过不是八个字节 *******/
//memcpy(udp_head+8, send_data, send_data_len);//将数据拷到报文头后面
memcpy(msg+14+20+8, send_data, send_data_len);//将数据拷到报文头后面
//udp的校验需要伪头部
unsigned char fake_head[512] = "";
Fake_UDP *fake_udp_head = (Fake_UDP *)fake_head;
fake_udp_head->src_ip = inet_addr("192.168.x.xxx");//源IP地址，转为32无符号<----------
fake_udp_head->dst_ip = inet_addr("192.168.x.xxx");//目的IP地址，转为32无符号<--------
fake_udp_head->flag = 0;//通常为0
fake_udp_head->proto = 17;//协议UDP
fake_udp_head->len = htons(8+send_data_len);
//把剩下的内容拷贝到伪头部的连续内存中
memcpy(fake_head+12,udp_head,8+send_data_len);
//校验
udp_head->check = checksum((unsigned short*)fake_head,20+send_data_len);//校验
//通过网络接口发送数据
int len = my_send(socket_fd,msg,14+20+8+send_data_len,"ens33");
printf("成功发送%d字节\n",len);
close(socket_fd);
return 0;
}