网编day5-广播组播-抓包

最新推荐文章于 2026-06-24 09:52:11 发布
原创 最新推荐文章于 2026-06-24 09:52:11 发布 · 302 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
华清学习笔记网编

当前文章被收录于：

华清学习笔记网编
6 篇文章 0 人学习
订阅专栏 查看详情
本文围绕网络编程展开，介绍了服务器模型，包括循环服务器和并发服务器（多进程/多线程、IO多路复用）；阐述了广播、组播和本地套接字通信；讲解了wireshark抓包工具使用及网络协议头分析；分析了TCP粘包、拆包原因及解决办法，还说明了TCP建立可靠通信的原因及与UDP的区别。

7.2 网络编程_day5

一.服务器模型

【1】 循环服务器

特点: 循环服务器,同一时刻,服务器只能连接一个客户端请求;
框架:

TCP服务器流程: 
      socket()
       bind();
       listen()
     while(1)
         {
             accept()
             while(1)
             {
                recv();
              }
            close(accpetfd);
        }
      close(sockfd);      

UDP服务器流程: 
     socket();
       bind();
     while(1)
       {     
         recvfrom();
       }
    close(sockfd);

TCP全双工通信:
在这里插入图片描述

./server:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <pthread.h>  
#include <signal.h>
#include <sys/wait.h>
int main(int argc, char const *argv[])
{
    if(argc != 2)
    {
        printf("please input %s <port>\n",argv[0]);
        return -1;
    }
    //1.创建流式套接字
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0)
    {
       perror("socket err:");
       return -1;
    }
    printf("socket is ok\n");
    //2.填充ipv4结构体
    struct sockaddr_in saddr,caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int len = sizeof(caddr);
    //绑定套接字
    if(bind(sockfd,(struct sockaddr *)&saddr,sizeof(saddr)) < 0)
    {
        perror("bind err:");
        return -1;
    }
    printf("bind is ok\n");
    //3/监听
    if(listen(sockfd,5) < 0)
    {
        perror("listen is err:");
        return -1;
    }
    printf("listen is ok\n");

    while(1)
    {
        //阻塞等待客户端链接
        int acceptfd = accept(sockfd,(struct sockaddr *)&caddr,&len);
        if(acceptfd < 0)
        {
            perror("accept is err:");
            return -1;
        }
        printf("client ip: %s  port %d\n",inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port));

        //创建进程
        pid_t pid = fork();
        if(pid < 0)
        {
            perror("fork is err:");
            return -1;
        }
        else if(pid == 0)  //子进程
        {
            //循环发送
            char buf[128];
            while(1)
            {
                fgets(buf,sizeof(buf),stdin);
                  if(buf[strlen(buf)-1] == '\n')
                    buf[strlen(buf)-1] = '\0';

                send(acceptfd,buf,sizeof(buf),0);
            }
            //exit(0);
        }
        else //父进程
        {
            //循环接受
            char buf[128];
            while(1)
            {
                int revbyte = recv(acceptfd,buf,sizeof(buf),0);
                if(revbyte < 0)
                {
                    perror("recv is err:");
                    return -1;
                }
                else if(revbyte == 0)
                {
                    printf("client is exit\n");
                    kill(pid,SIGINT); //终止子进程运行
                    
                    wait(NULL);
                    break;
                }
                else
                {
                    printf("%s\n",buf);
                }
            }
        }

    }
    close(sockfd);
    return 0;
}

./client:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <pthread.h>


void *handler(void * arg)
{
    int sockfd = *((int *)arg);
    char buf[128];
    while(1)
    {
        //接受
       int recvbyte = recv(sockfd,buf,sizeof(buf),0);
        if(recvbyte < 0)
        {
          perror("recv is err:");
          return NULL;
        }
        else
        {
            printf("%s\n",buf);
        }
    }
}

int main(int argc, char const *argv[])
{
	if(argc != 3)
	{
	    printf("please input %s <port> < ip>\n",argv[0]);
	}
	//socket
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd < 0)
	{
	  perror("sockfd is err:");
	  return -1;
	}
	//填充结构体
	struct sockaddr_in caddr;
	caddr.sin_family = AF_INET;
	caddr.sin_port = htons(atoi(argv[2]));
    caddr.sin_addr.s_addr = inet_addr(argv[1]);
    //链接
	if(connect(sockfd,(struct sockaddr *)&caddr,sizeof(caddr)) < 0)
	{
	  perror("connect is err:");
	  return -1;
	}

    //1.创建线程ID
    pthread_t tid;
    pthread_create(&tid,NULL,handler,&sockfd);
    pthread_detach(tid);

    char buf[128];
    while(1)
    {
        //发送
        fgets(buf,sizeof(buf),stdin);
        if(buf[strlen(buf)-1] == '\n')
           buf[strlen(buf)-1] = '\0';
        
        send(sockfd,buf,sizeof(buf),0);

        if(strncmp(buf,"quit",4) == 0)
        {
            break;
        }
    }
    close(sockfd);
    return 0;
}

【2】 并发服务器

特点: 同一时刻可以相应多个客户端的请求 (同时连接多个客户端,并能够通信)

1.多进程/多线程实现并发

每来一个客户端连接, 开一个进程/线程来专门处理客户端的数据, 实现简单, 资源占用大;

框架:

socket()
bind();
listen();
while(1)
{
	accept();
	if(fork() == 0)  //子进程
	{
		while(1)
		{
			process();
		}
		close(client_fd);
		exit();
	}
	else
	{
	}
}

在这里插入图片描述

函数接口:

创建线程 pthread_create

退出线程: pthread_exit(void *retval)
将线程设置为游离态,自动回收线程资源, pthread_detach

2.IO多路复用
特点: 借助select,poll,epoll机制, 将新连接的客户端描述符增加到描述符表中,只需要一个线程即可处理所有的客户端连接,在嵌入式开发中应用广泛,但代码复杂度较高。

并发服务器总结:

多进程:
优点: 服务器更稳定 , 父子进程资源独立, 安全性高一点
缺点: 需要开辟多个进程,大量消耗资源
多线程:
优点: 相对多进程, 资源开销小, 线程共享同一个进程的资源
缺点: 需要开辟多个线程,而且线程安全性较差
IO多路复用:
优点: 节省资源, 减小系统开销,性能高;
缺点: 代码复杂性高

【1】广播和组播 UDP

一.广播 （UDP协议）

广播地址: 主机号最大的地址;

以192.168.1.0 (255.255.255.0) 网段为例，最大的主机地址192.168.1.255代表该网段的广播地址

●前面介绍的数据包发送方式只有一个接受方，称为单播
●如果同时发给局域网中的所有主机，称为广播
(同一局域网内的主机都会接收到，如果其他主机没有加入广播站，就会将消息丢弃)

●只有用户数据报(使用UDP协议)套接字才能广播
●一般被设计为局域网搜索协议

广播代码流程,主要基于 setsockopt:

setsockopt 设置套接字的属性

头文件:
  #include<sys.socket.h>    
  #include<sys/types.h>      
  #include<sys/time.h>
  
原型:  int setsockopt(int sockfd,int level,int optname,\
                         void *optval,socklen_t optlen)
功能： 获得/设置套接字属性
参数：
     sockfd：套接字描述符
     level：协议层
     optname：选项名
     optval:选项值
     optlen:选项值大小

返回值:  成功 0    失败-1

socket属性
选项名称 说明 数据类型
==== SOL_SOCKET 应用层 ====
SO_BROADCAST 允许发送广播数据 int
SO_DEBUG 允许调试 int
SO_DONTROUTE 不查找路由 int
SO_ERROR 获得套接字错误 int
SO_KEEPALIVE 保持连接 int
SO_LINGER 延迟关闭连接 struct linger
SO_OOBINLINE 带外数据放入正常数据流 int
SO_RCVBUF 接收缓冲区大小 int
SO_SNDBUF 发送缓冲区大小 int
SO_RCVLOWAT 接收缓冲区下限 int
SO_SNDLOWAT 发送缓冲区下限 int
SO_RCVTIMEO 接收超时 struct timeval
SO_SNDTIMEO 发送超时 struct timeval
SO_REUSEADDR 允许重用本地地址和端口 int
SO_TYPE 获得套接字类型 int
SO_BSDCOMPAT 与BSD系统兼容 int
==== IPPROTO_IP 网络层 ====
IP_HDRINCL 在数据包中包含IP首部 int
IP_OPTINOS IP首部选项 int
IP_TOS 服务类型 int
IP_TTL 生存时间 int
IP_ADD_MEMBERSHIP 将指定的IP加入多播组 struct ip_mreq
==== IPPRO_TCP 传输层 ====
TCP_MAXSEG TCP最大数据段的大小 int
TCP_NODELAY 不使用Nagle算法 int
端口与地址复用:

int opt = 1;

setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

广播的发送者：

  1. 创建用户数据报套接字;
sockfd = socket(AF_INET,SOCK_DGRAM,0);

2.setsockopt可以设置套接字属性，先设定该套接字允许发送广播

	  int optval = 1;
     //  SOL_SOCKET 传输层      SO_BROADCAST 允许发送广播
setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST,&optval,sizeo(optval));

3.接收方地址指定为广播地址,指定端口号

 struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[2]));
    addr.sin_addr.s_addr = inet_addr(argv[1]);
  1. 发送数据包
 sendto(sockfd,buf,sizeof(buf),0,\
            (struct sockaddr*)&addr,sizeof(addr));

发送者需要借助 setsockopt 开通广播权限:
在这里插入图片描述

广播的接收者：

基本无需改动

  1. 创建用户数据报套接字
    sockfd = socket(AF_INET,SOCK_DGRAM,0);

  2. 绑定IP地址(广播IP或0.0.0.0)和端口
    广播的接收者需要加入 广播站
    struct sockaddr_in saddr,caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[2]));
    saddr.sin_addr.s_addr = inet_addr(“0.0.0.0”);
    //广播地址或0.0.0.0
    //0.0.0.0 是一个特殊的IP地址，用于表示服务器端将监听所有可用的网络接口
    // 而不仅仅是IP地址,广播地址也会监听。

    socklen_t len = sizeof(caddr);
    bind(sockfd,(struct sockaddr *)&saddr,sizeof(saddr));

  3. 等待接收数据
    recvfrom(sockfd,buf,sizeof(buf),0,
    (struct sockaddr *)&caddr,&len);

在这里插入图片描述

广播的缺点：
     广播方式发给所有的主机，过多的广播会大量的占用网络带宽，造成广播风暴，影响正常的通信

二.组播（多播）

。单播方式只能发给一个接收方
。 组播是一个人发送，加入到多播组的主机接收数据
。 多播方式既可以发给多个主机，又能避免像广播一样造成过多的负载：

组播的地址:
IP的二级划分中 D类IP:
第一字节的前四位固定为 1110
D类IP ： 224.0.0.1 - 239.255.255.255
224.10.10.10

组播的接收者:

1.创建用户数据报套接字;

sockfd = socket(AF_INET,SOCK_DGRAM,0);
  1. 加入多播组 ： 只有接收者加入多播组 (广播是发送者需要设置广播属性，组播是接收者加入多播组)
    //2.将主机假如多播组
  struct ip_mreq mreq;   //组播的结构体变量
      mreq.imr_multiaddr.s_addr = inet_addr(argv[1]);   //组IP
      mreq.imr_interface.s_addr = inet_addr("0.0.0.0"); //本地IP加入到上面的多播组
    //设置套接字  
    //记得去表内查找 组播属于IPPROTO_IP网络层，IP_ADD_MEMBERSHIP组播 struct mreq 数据类型
    //该函数接口将结构体内的本地IP，绑定到了组IP内
    setsockopt(sockfd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq));
  1. 绑定组播IP地址(绑定组播IP或0.0.0.0)和端口
    //3. 填充结构体： 绑定组播ip和端口
    struct sockaddr_in saddr,caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[2]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0"); //组IP
  1. 接收数据包
 recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&caddr,&len);

组播的发送者

  1. 创建用户数据报套接字;
sockfd = socket(AF_INET,SOCK_DGRAM,0);
  1. 指定接收方地址指定为组播地址 224.0.0.10 （224.0.0.1 - 239.255.255.255都可以） 并指定接收端端口信息
    //2. 填充结构体： 组播ip 和 端口
   struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[2]));
    addr.sin_addr.s_addr = inet_addr(argv[1]); //组播的IP
  1. 发送数据包
sendto(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&addr,sizeof(addr));

三. 本地套接字通信

特性:

· unix网络编程最开始有的编程都是一台主机内进程和进程之间的编程。(本地通信)
· socket同样可以用于本地间进程通信, 创建套接字时使用本地协议AF_LOCAL或AF_UNIX
· 分为流式套接字和数据报套接字
· 和其他进程间通信相比使用方便、效率更高，常用于前后台进程通信。
unix域套接字编程，实现本间进程的通信，依赖的是s类型的文件；(套接字文件)

TCP，UDP 都是依赖IP 端口号进行通信,实现两个主机通信
本地通信不需要ip和端口，所以无法进行两个主机通信

核心代码:

#include <sys/socket.h>
#include <sys/un.h>

struct sockaddr_un {
sa_family_t sun_family;               /* 本地协议 AF_UNIX */
char       sun_path[UNIX_PATH_MAX];  /* 本地路径 s类型的套接字文件 */
};

unix socket = socket(AF_UNIX, type, 0); //type为流式或数据包套接字
                                
struct sockaddr_un myaddr;
myaddr.sun_family = AF_UNIX; //填充UNIX域套接字
strcpy(saddr.sun_path,"./myunix"); // 创建套接字的路径(将套接字创建到哪? 服务器与客户端一致)

相关代码:

./server:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

void list_server(int acceptfd, char *buf, int size);
void put_server(int acceptfd, char *buf, int size);
void get_server(int acceptfd,char *buf, int size);
int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    //1.创建流式套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //链接
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    printf("sockfd:%d\n", sockfd); //3
    //填充ipv4的通信结构体

    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1])); //"8888" int a= atoi("8888")//a=8888
    //saddr.sin_addr.s_addr = inet_addr(argv[1]);

    //设置服务器自动获取自己主机的ip
    // saddr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY  0x00000000 "0.0.0.0"
    // saddr.sin_addr.s_addr = INADDR_ANY;
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");

    socklen_t len = sizeof(caddr);

    //2.绑定套接字 ip和端口(自己)
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }
    printf("bind ok.\n");

    //3.监听
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    printf("listen ok.\n");
    //4.阻塞等待客户端链接
    while (1)
    {
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("accept err.");
            return -1;
        }
        printf("acceptfd=%d\n", acceptfd); //通信
        printf("client:ip=%s port=%d\n",
               inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
        //循环收发消息
        char buf[128];
        int ret;
        while (1)
        {
            ret = recv(acceptfd, buf, sizeof(buf), 0);
            if (ret < 0)
            {
                perror("recv err.");
                return -1;
            }
            else if (ret == 0)
            {
                printf("client exit\n");
                break;
            }
            else
            {
                if (strncmp(buf, "list", 4) == 0)
                { //打开当前目录读文件判断文件是普通文件将文件名传给客户端
                    list_server(acceptfd, buf, sizeof(buf));
                }
                else if (strncmp(buf, "put ", 4) == 0)
                { //接收文件(本地：打开新建文件接收客户端发送过来的内容写到文件)
                    put_server(acceptfd, buf, sizeof(buf));
                }
                else if (strncmp(buf, "get ", 4) == 0)
                { //发送文件
                    //(本地：打开文件读文件内容发送给客户端)
                    get_server(acceptfd, buf, sizeof(buf));
                }
            }
        }
        close(acceptfd);
    }
    close(sockfd);
    return 0;
}
//3、get
void get_server(int acceptfd,char *buf, int size) //buf->put xxx.c
{
    //1>打开文件 读
    int fd = open(buf + 4, O_RDONLY);
    if (fd < 0)
    {
        perror("open file err.");
        return;
    }
    int ret; //实际读到的个数
    while ((ret = read(fd, buf, size - 1)) != 0)
    {
        buf[ret] = '\0';
        send(acceptfd, buf, size, 0);
    }
    strcpy(buf, "get ok.");
    send(acceptfd, buf, size, 0);
}
//2.接收文件(本地：打开新建文件接收客户端发送过来的内容写到文件)
void put_server(int acceptfd, char *buf, int size)
{
    int fd = open(buf + 4, O_TRUNC | O_CREAT | O_WRONLY, 0666);
    if (fd < 0)
    {
        perror("open err.");
        return;
    }
    while (1)
    {
        if (recv(acceptfd, buf, size, 0) < 0)
        {
            perror("recv err.");
            return;
        }
        if (strncmp(buf, "put ok.", 7) == 0)
            break;
        write(fd, buf, strlen(buf));
    }
}

//list：打开当前目录读文件判断文件是普通文件将文件名传给客户端
void list_server(int acceptfd, char *buf, int size)
{
    //1.打开当前目录文件
    DIR *dir = opendir("./");
    if (dir == NULL)
    {
        perror("opendir err.");
        return;
    }
    //2.循环读目录文件  readdir
    struct dirent *dp = NULL;
    struct stat st;
    while ((dp = readdir(dir)) != NULL)
    {
        //dp->d_name拿到的文件名
        //判断文件属性stat
        stat(dp->d_name, &st);
        if (S_ISREG(st.st_mode))
        {
            strcpy(buf, dp->d_name);
            send(acceptfd, buf, size, 0);
        }
    }
    //发送结束标志
    strcpy(buf, "list ok.");
    send(acceptfd, buf, size, 0);
}

./client:

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>


int main(int argc, char const *argv[])
{
//1.创建套接字 - 返回建立连接的文件描述符
    int sockfd = socket(AF_UNIX,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("socket is err:");
        return -1;
    }
    printf("sockfd: %d\n",sockfd);

    //定义选项值
    int op = 1;
    //将socket套接字设置为 允许端口重用
    setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&op,sizeof(op));

    //2. 绑定套接字  -  填充结构体
    struct sockaddr_un saddr;
     saddr.sun_family = AF_UNIX;
     strcpy(saddr.sun_path,"./fd");

     connect(sockfd,(struct sockaddr *)&saddr,sizeof(saddr));

     char buf[128];

     while(1)
     {
         fgets(buf,sizeof(buf),stdin);

          send(sockfd,buf,sizeof(buf),0);
     }

close(sockfd);
return 0;
}

【1】wireshark抓包工具

一.抓包工具的使用:

  1. 安装
    虚拟机 : sudo apt-get install wireshark

windows: 小飞机

注：抓包的过程，就是抓网卡流经的一些数据。启动时不加sudo找不到网卡，没有办法找到内容。
wireshark可以用来抓包，必须是流经网卡的包：
两台不同的主机通信 或 两台不同的操作系统(windows linux)之间 才可以进行抓包
服务器端代码运行在ubuntu
客户端代码运行在windows下

使用流程：

  1. 先运行服务器
  2. 打开TCP/UDPbg
  3. wireshark
    在这里插入图片描述

抓包工具界面如下：
在这里插入图片描述

过滤其他无关的包：
在这里插入图片描述

客户端连接服务器，产生握手包：
在这里插入图片描述

发送消息：
在这里插入图片描述

客户端和服务器断开，产生挥手包 ：

在这里插入图片描述

##【2】抓包工具与包头分析：

在这里插入图片描述

【3】网络协议头的分析 [了解]
在这里插入图片描述

【4】以太网完整帧格式：
在这里插入图片描述

对于网络层最大数据帧长度是1500字节（MTU： 最大传输单元）
对于链路层最大数据长度是1518字节（1500(网络层)+14(以太网)+4(CRC检错）)

TCP粘包、拆包发生原因:
发生TCP粘包或拆包有很多原因，常见的几点：
1、要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包。
2、待发送数据大于MSS（传输层的最大报文长度），TCP在传输前将进行拆包。
3、要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据一次发送出去，将会发生粘包。
4、接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包。
粘包、拆包解决办法:
解决问题的关键在于如何给每个数据包添加边界信息，常用的方法有如下：
1、发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，
通过读取包首部的长度字段，便知道每一个数据包的实际长度了。
2、发送端将每个数据包封装为固定长度（不够的可以通过补0填充);
这样接收端每次从接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。
3、可以在数据包之间设置边界，如添加特殊符号，这样，接收端通过这个边界就可以将不同的数据包拆分开。

以太网头：

以太网中封装了 目的mac地址 以 及 源mac地址, 还有ip类型， 以太网又称之为mac头 -快递员
切换网络时, ip地址会改变, mac地址不会改变
在这里插入图片描述

0x0800 只接收发往本机的mac的ip类型的数据帧
0x0806 只接收发往本机的ARP类型的数据帧
ARP: ARP协议用于将IP地址解析为MAC地址。（数据的封包传输中，既需要知道对方IP，也需要知道MAC）
RARP: RARP协议则是与ARP相反的过程，它用于将MAC地址解析为IP地址。
0x8035 只接受发往本机的RARP类型的数据帧
0x0003 接收发往本机的MAC所有类型: ip,arp,rarp数据帧， 接收从本机发出去的数据帧,
当打开混杂模式打开的情况下，会接收到非发往本地的MAC数据帧

IP头：

在这里插入图片描述

拆包:
id标识: 接收方接收到这么多的数据包, 如何判别是一个包? 通过相同id标识来识别
flags: 拆包时, 如果该数据包后续还有拆好的包, 那么flags 为 M, 否则为D
在这里插入图片描述

面试: 1. 常用于拆包的是哪个包头? IP
2. IP头哪些内容用于拆包? id身份证明 flags
IP头有两个地址 , 是哪两个地址? 源IP地址 目的IP地址

UDP头：

在这里插入图片描述

UDP终端length可以有效防止udp的粘包问题，让udp有固定的长度
UDP会造成丢包， TCP会造成粘包和拆包
UDP通信没有发送缓存区， 它不保证数据的可靠性。因此，UDP通信是将数据尽快发送出去，不关心数据是否到达目标主机. 但是UDP有接受缓存区, 因为数据发送过快, 如果接收缓存区内数据已满, 则继续发送数据, 可能会出现丢包。
丢包出现原因： 接收缓存区满 网络拥堵， 传输错误
相比之下，TCP是一种面向连接的传输协议，它需要保证数据的可靠性和顺序性。TCP有发送缓存区和接收缓存区， 如果发送频率过快， 且内容小于发送缓存区的大小 ， 可能会导致多个数据的粘包。如果发送的数据大于发送缓存区， 可能会导致拆包。
UDP不会造成粘包和拆包, TCP不会造成丢包
UDP是基于数据报文发送的，每次发送的数据包，在UDP的头部都会有固定的长度， 所以应用层能很好的将UDP的每个数据包分隔开， 不会造成粘包。
TCP是基于字节流的， 每次发送的数据报，在TCP的头部没有固定的长度限制，也就是没有边界，那么很容易在传输数据时，把多个数据包当作一个数据报去发送，成为了粘包，或者传输数据时， 要发送的数据大于发送缓存区的大小，或者要发送的数据大于最大报文长度， 就会拆包；
TCP不会丢包，因为TCP一旦丢包，将会重新发送数据包。（超时/错误重传）

TCP头

在这里插入图片描述

关于TCP Flags

Seq:序列号，所有非应答包的数据段， 都有seq，占4个字节，用于给数据段进行编号的。
Ack:应答号，用于应答(握手包，挥手包，数据包)，告诉对方的下次Seq号从此次Ack号开始
以下三个包，都是由seq序列号的，因为都需要被ACK应答-----------
SYN:握手包，连接的时候产生的包
FIN:挥手包，断开连接产生的包
PSH:数据包，传输数据时候产生的包
ACK:应答包 - 无seq序列号，因为不需要被回复名
(抓包中出现的ACK包内的Seq不用管)

【5】关于TCP建立可靠通信的原因：

1.序列号和确认机制：
每次数据传输，都有PUSH，每次PUSH包发送之后，接收者都会回复一个ACK包，TCP建立高可靠通信的原因之一：

2.三次握手机制：
服务器必须准备好接受外来的连接。这通过调用socket、 bind和listen函数来完成，称为被动打开.
第一次握手：客户通过调用connect进行主动打开。客户端发送一个SYN（表示同步）分节，它告诉服务器客户将在连接中发送到数据的初始序列号。并进入SYN_SEND(发送)状态，等待服务器的确认。

第二次握手：服务器必须确认客户的SYN，同时自己也得发送一个SYN分节，它含有服务器将在同一连接中发送的数据的初始序列号。服务器以单个字节向客户发送SYN和对客户SYN的ACK（表示确认），此时服务器进入SYN_RECV(接收)状态。

第三次握手：客户收到服务器的SYN+ACK。向服务器发送确认分节，此分节发送完毕，客户端和服务器进入ESTABLISHED（确认）状态，完成三次握手。
在这里插入图片描述

3.四次挥手机制:
第一次挥手：主动关闭方发送一个FIN(挥手包)给被动方，进入FIN_WAIT状态；

第二次挥手：被动方接收到FIN(挥手)包，给主动方发送一个ACK(确认)包;并进入CLOSE_WAIT状态，主动方接收到ACK包后，进入FIN_WAIT状态，如果有数据没有发送完毕，则继续发送，一直到发送完毕；

第三次挥手：被动方发送一个FIN包，进入LAST_ACK(最后确认)状态。

第四次挥手：主动关闭方收到FIN包，回复一个FIN包。被动关闭方收到主动关闭方的ACK后关闭连接。

4.超时重传机制：
如果在指定时间内发送方没有收到确认消息(Ack)，发送方会认为数据丢失，重新发送数据。
在这里插入图片描述

1.关于TCP建立可靠通信的原因
2.TCP与UDP的区别,特点

标签
#单片机 #嵌入式硬件 #网络 #websocket
WS63开发板星闪广播技术详解与实战
最新发布
weixin_29195615的博客
07-21 232
短距无线通信技术是物联网设备互联的基础，其中广播机制作为设备发现与数据传输的核心方式，直接影响组网效率。星闪(SLE)作为新一代无线协议，采用TDD时分双工和动态频道选择技术，相比传统BLE在时延(20μs级)和可靠性上有显著提升。其原生支持多播和AES-128加密的特性，使其在工业控制、智能家居等场景具有独特优势。以海思WS63三模开发板为例，通过配置广播间隔、发射功率等参数，开发者可快速验证星闪在抗干扰、低功耗等方面的性能表现。实测数据显示，其事件触发模式可使设备续航达数月，而±1μs的时钟同步精度则为
别再死记DHCP四步曲了！用华为eNSP模拟器手把手带你抓包分析全过程
weixin_30567225的博客
05-28 562
本文通过华为eNSP模拟器实战演示DHCP协议的四步交互过程，详细解析Discover、Offer、Request和ACK报文的关键字段与隐藏信息。文章结合抓包案例，揭示地址分配、租期维护及特殊场景下的协议行为，帮助网络工程师深入理解DHCP工作原理并掌握排错技巧。
VLC组播软件使用说明+抓包分析
11-17
包含igmp服务器端+客户端+vlc抓包 以及组播软件使用说明word文档
GLM-5.1华为云Day0上线：国产大模型开箱即用实践指南
weixin_33892359的博客
06-24 336
大模型服务化（MaaS）是企业AI落地的核心环节，其本质是将模型推理能力封装为稳定、低延迟、高兼容的API服务。实现这一目标需突破模型优化、硬件适配与云平台深度协同三大技术关卡。其中，量化压缩（如int4）、KV Cache高效管理及OpenAI协议兼容性，直接决定生产可用性；而昇腾910B等国产NPU在内存带宽与原生INT4支持上的优势，正成为提升能效比与首token延迟的关键变量。当前，智谱GLM-5.1在华为云ModelArts实现Day0级交付，标志着国产大模型从实验室走向政务、金融等垂直场景的最后
组播抓包工具
11-16
很好用的UDP抓包工具，简单易懂非常好用，有需求可下载。
广播泛洪_这三种类型的报文，交换机会进行泛洪：广播、组播、未知单播
weixin_39853968的博客
11-22 3750
随着互联网的发展，各种应用层出不穷，日新月异，对网络设备的要求也越来越高，对广大设备厂商也提出更多的要求。不过这些事情都与二层交换机没有关系：) ，因为各种应用的数据到达二层交换机时，都只会变成一个一个数据包(帧)，交换机基本不会去识别其属于哪种类型的应用。对于二层交换机来说，它在转发报文时，只有四种类型的报文：广播、组播、未知单播、已知单播。虽然看起来比较简单，但是根据我多年的经验，能理解这四种...
wireshark 网络分析工具
柒烨~的博客
01-16 2262
1. 捕获过滤器的语法说明 - 类型Type:host(指定)、net(网络)、port(端口) - 方向Dir:src(源)、dst(目的) - 协议Proto:ether、ip、tcp、udp、http、ftp - 逻辑运算符：&&与、‖或、！非
使用Wireshark软件抓包（分析报文）
weixin_43399489的博客
09-08 3885
报文分析软件的工作原理主要是。网卡有四种模式：广播、组播、直接、混杂。网卡通常的缺省工作模式是。
wireshark抓包详细图文教程
热门推荐
WEI的博客
11-11 1万+
wireshark是非常流行的网络封包分析软件，功能十分强大。可以截取各种网络封包，显示网络封包的详细信息。使用wireshark的人必须了解网络协议，否则就看不懂wireshark了。 为了安全考虑，wireshark只能查看封包，而不能修改封包的内容，或者发送封包。 wireshark能获取HTTP，也能获取HTTPS，但是不能解密HTTPS，所以wireshark看不懂HTTPS中的内容，总结，如果是处理HTTP,HTTPS 还是用Fiddler,其他协议比如TCP,UDP 就用wireshark.
华清远见嵌入式学习day23——广播、组播及数据库sqlite3
UemTuBXuR的博客
04-14 366
【1】抓包工具 wireshark windows版本 ubuntu： sudo apt-get install wireshark 运行wireshark: sudo wireshark 过滤： tcp.port == 8888 练习抓包到 10:10 ...
day 3
2403_89660238的博客
12-17 1820
续租的第二阶段：到达租期的80%，也就是还有3h时，要是服务器还不回ack包，那HCP客户端就会向DHCP服务器发送一个DHCP-request包------广播 “我要续租”，如果服务器回ack包了，那就会重新规整为24h，如果3h过去了还不回包，那就断网。3.DHCP客户端向DHCP服务器发送-----DHCP-request包----------广播发送 “我同意使用这个IP地址”DHCP协议------动态主机配置协议，是服务器用来给客户端分配ip地址的。
嗅探技术---网络安全入门笔记DAY5
zsy_zz的博客
10-02 2422
相关网络基础 网络嗅探 网络嗅探技术（网络监听技术 Network Sniffing） 概念：一种在他方未察觉情况下捕获其通信报文或通信内容的技术 对于网络管理员，帮助了解网络运行状况 对黑客，有效收集信息的手段 适用范围：目前只限于局域网 ...
Day34-Linux网络管理4
苦难带不走梦想
03-09 1062
32位二进制数字序列组成的数字序列采用点将32位数字进行分割为4段，每段8位的二进制数，但二进制数不便于记忆，因此转换为10进制数显示，即点分十进制在一个网络范围内，唯一标识一台主机。通过子网划分(通过子网掩码进行划分)可以将一个大的局域网络进行切割为多个小的局域网，这样就解决了上面说的两个问题，而得到的新的局域网络就称为子网1）局域网内机器中毒，大量发广播包。说我是10.0.0.100，我的MAC是（05（网关的MAC））Internet 地址物理地址类型10.0.0.100动态。
【计算机网络全面教学】网络设备与故障排查，从集线器到Wireshark抓包实战Day7（2026年）
我是一颗柠檬的博客
06-16 751
参考答案MAC地址泛洪是一种攻击手段，攻击者向交换机发送大量伪造源MAC地址的数据帧，填满交换机的MAC地址表。当MAC地址表满了之后，交换机无法学习新的MAC地址，只能对所有帧进行泛洪，这样攻击者就能截获其他端口之间的通信。配置端口安全（Port Security），限制每个端口学习的MAC地址数量配置MAC地址表的老化时间和最大条目数使用VLAN隔离，缩小泛洪范围。
wireshark抓组播数据_Wireshark数据抓包教程之认识捕获分析数据包
weixin_39721000的博客
12-19 2766
Wireshark数据抓包教程之认识捕获分析数据包认识Wireshark捕获数据包当我们对Wireshark主窗口各部分作用了解了，学会捕获数据了，接下来就该去认识这些捕获的数据包了。Wireshark将从网络中捕获到的二进制数据按照不同的协议包结构规范，显示在Packet Details面板中。为了帮助用户能够清楚的分析数据，本节将介绍识别数据包的方法。在Wireshark中关于数据包的叫法有三...
【报告分享】 视频号商业玩法（附下载）
行业报告智库
12-29 600
摘要:视频化时代，一方面需要适应用户使用习惯，另一方面，直播和视频号，也能让商业化版图再度扩张。 来源:腾讯广告 如需查看完整报告和报告下载或了解更多，微信公众号：行业报告智库 ...
wireshark抓包实践
master-dragon的专栏
07-09 1129
r，从后面接的文件将数据包数据读出来。那个「文件」是已经存在的文件，并且这个「文件」是由 -w 所制作出来的。-X，可以列出十六进制 (hex) 以及 ASCII 的数据包内容，对于监听数据包内容很有用。-i，后面接要「监听」的网络接口，例如 eth0, lo, ppp0 等等的接口。-A，数据包的内容以 ASCII 显示，通常用来捉取 WWW 的网页数据包资料。-c，监听的数据包数，如果没有这个参数， tcpdump 会持续不断的监听，-q，仅列出较为简短的数据包信息，每一行的内容比较精简。
tcpdump使用详解
SL_ss123的博客
10-10 2596
tcpdump使用
组播分片报文重组后丢包问题
09-29 2227
eth0和eth1在相同的广播域，且开启了混杂模式。业务组播分片报文，在两个接口都会收到。当同一个大包的多个分片在eth0和eth1上产生重组冲突，协议栈会丢包，导致业务收不到。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值