网编day5-广播组播-抓包

最新推荐文章于 2024-07-12 17:27:21 发布
最新推荐文章于 2024-07-12 17:27:21 发布
阅读量142 收藏
点赞数
分类专栏： 华清学习笔记网编 文章标签： 单片机 嵌入式硬件 网络 websocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ht4091/article/details/133163851
版权

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的区别,特点

ht4091
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广播泛洪_这三种类型的报文，交换机会进行泛洪：广播、组播、未知单播
weixin_39853968的博客
11-22 3194
随着互联网的发展，各种应用层出不穷，日新月异，对网络设备的要求也越来越高，对广大设备厂商也提出更多的要求。不过这些事情都与二层交换机没有关系：) ，因为各种应用的数据到达二层交换机时，都只会变成一个一个数据包(帧)，交换机基本不会去识别其属于哪种类型的应用。对于二层交换机来说，它在转发报文时，只有四种类型的报文：广播、组播、未知单播、已知单播。虽然看起来比较简单，但是根据我多年的经验，能理解这四种...
wireshark抓组播数据_HCIE学习笔记--组播路由协议PIM-DM工作机制解析
weixin_34193979的博客
12-03 1568
拓扑二---PIM--DM扩散 组播源发出的第一份ping包此组播域当中的哪些链路和路由器会接收到？解释对应机制与工作原理组播路由器接口开启了PIM-DM的都会接收到组播报文。在PIM-DM模式的组播环境中，组播源发出的第一份Ping包，会全网泛洪。而邻居是否会处理组播报文，执行下一步的转发动作，取决于RPF机制的检查。RPF机制：接收到组播源发送的组播数据包的接口，与单播IP表去往该组播...
组播抓包工具
11-16
很好用的UDP抓包工具，简单易懂非常好用，有需求可下载。
使用Wireshark软件抓包（分析报文）
weixin_43399489的博客
09-08 2935
报文分析软件的工作原理主要是。网卡有四种模式：广播、组播、直接、混杂。网卡通常的缺省工作模式是。
wireshark抓组播数据_Wireshark数据抓包教程之认识捕获分析数据包
weixin_39721000的博客
12-19 2383
Wireshark数据抓包教程之认识捕获分析数据包认识Wireshark捕获数据包当我们对Wireshark主窗口各部分作用了解了，学会捕获数据了，接下来就该去认识这些捕获的数据包了。Wireshark将从网络中捕获到的二进制数据按照不同的协议包结构规范，显示在Packet Details面板中。为了帮助用户能够清楚的分析数据，本节将介绍识别数据包的方法。在Wireshark中关于数据包的叫法有三...
网络安全-第三阶段网络基础-day16(网络基础01）
最新发布
m0_52695630的博客
07-12 370
当处于不同广播域的机器进行交互时，A电脑11.33.22.5在1广播域-其中交换机网段：111.33.22.x，B电脑111.33.21.6在2广播域111.33.21.x通信时，A电脑发送目标ip地址，自己的ip地址，自己mac地址和数据。在这个交换机内部不是通过之前的广播模式进行找到哪台机器了，而是通过arp协议，向这个域内的几台机器发送arp广播包，然后机器收到后会向交换机发送自己的mac地址，在交换机中有一个缓存表：存储的是每台电脑的ip地址和mac地址。解决这个的办法是划分广播域。
HCIE-Security Day6：5个实验深入浅出理解源NAT
小梁的博客
02-10 2506
NAT是一种地址转换技术，可以将ipv4报文头中的地址做转换，通常情况下，利用nat技术将ipv4报文头中的私网地址转换为公网地址，实现了内网设备与公网设备的互访。 从实现上来说，NAT转换设备都维护一张地址转换表。地址转换的机制分为： 内部网络主机的ip地址和端口转换为nat转换设备外部网络地址和端口 外部网络主机的ip地址和端口转换位nat转换设备内部网路地址和端口 即私有地址+端口与共有地址+端口之间互相转换。 常见的nat转化设备由路由器、防火墙等。 NAT分类 ...
tcpdump - 数据包进行截获的包分析工具
墨鱼菜鸡
07-11 1307
From：http://www.cnblogs.com/ggjucheng/archive/2012/01/14/2322659.html 30 分钟掌握 tcpdump：http://zhuanlan.51cto.com/art/201701/527498.htm Androidtcpdump下载：https://www.androidt...
嗅探技术---网络安全入门笔记DAY5
zsy_zz的博客
10-02 2162
相关网络基础 网络嗅探 网络嗅探技术（网络监听技术 Network Sniffing） 概念：一种在他方未察觉情况下捕获其通信报文或通信内容的技术 对于网络管理员，帮助了解网络运行状况 对黑客，有效收集信息的手段 适用范围：目前只限于局域网 ...
信安学习笔记之网络安全：Day-1【VLAN、trunk、macof、arpspoof】
qq_43709121的博客
07-19 565
1.vlan（虚拟局域网） 参考概念：是对连接到第二层交换机端口的网络用户的逻辑分段，不受网络用户的物理位置限制而根据用户需求进行网络分段。一个vlan可以在一个交换机或跨交换机实现。vlan可以根据网络用户的位置、作用、部门或根据网络用户所使用的应用程序和协议来进行分组。基于交换机的虚拟局域网能够为局域网解决冲突域、广播域、带宽问题。[-----------百度百科](https://baike.baidu.com/item/%E8%99%9A%E6%8B%9F%E5%B1%80%E5%9F%9F%E7%
组播分片报文重组后丢包问题
09-29 1509
eth0和eth1在相同的广播域，且开启了混杂模式。业务组播分片报文，在两个接口都会收到。当同一个大包的多个分片在eth0和eth1上产生重组冲突，协议栈会丢包，导致业务收不到。
wireshark抓包详细图文教程
WEI的博客
11-11 9733
wireshark是非常流行的网络封包分析软件，功能十分强大。可以截取各种网络封包，显示网络封包的详细信息。使用wireshark的人必须了解网络协议，否则就看不懂wireshark了。 为了安全考虑，wireshark只能查看封包，而不能修改封包的内容，或者发送封包。 wireshark能获取HTTP，也能获取HTTPS，但是不能解密HTTPS，所以wireshark看不懂HTTPS中的内容，总结，如果是处理HTTP,HTTPS 还是用Fiddler,其他协议比如TCP,UDP 就用wireshark.
tcpdump使用详解
SL_ss123的博客
10-10 2234
tcpdump使用
wireshark抓包实践
master-dragon的专栏
07-09 587
r，从后面接的文件将数据包数据读出来。那个「文件」是已经存在的文件，并且这个「文件」是由 -w 所制作出来的。-X，可以列出十六进制 (hex) 以及 ASCII 的数据包内容，对于监听数据包内容很有用。-i，后面接要「监听」的网络接口，例如 eth0, lo, ppp0 等等的接口。-A，数据包的内容以 ASCII 显示，通常用来捉取 WWW 的网页数据包资料。-c，监听的数据包数，如果没有这个参数， tcpdump 会持续不断的监听，-q，仅列出较为简短的数据包信息，每一行的内容比较精简。
组播简介（二层组播）
qq_28105413的博客
12-01 8442
1 承载网组播模型 2 二层组播技术 2.1 组管理协议 Internet 组管理协议称为IGMP协议（Internet Group Management Protocol），是因特网协议家族中的一个组播协议。该协议运行在主机和组播路由器之间。IGMP协议共有三个版本，即IGMPv1、v2 和v3。 主机IP软件需要进行组播扩展，才能使主机能够在本地网络上收发组播分组。但仅靠这一点是不够的，因为跨越多个网络的组播转发必须依赖于路由器。路由器为建立组播转发路由必需了解每个组员在Internet中的分布，这要求
windows wireshark抓到未加入组的组播消息
guo_lei_lamant的博客
02-10 2125
Windows wireshark抓到未加入组的数据包
常用的爆款抓包工具综合对比（选择最合适的抓包工具才是最重要的！）
自动化测试馆长
04-12 3103
测试可以用的抓包工具非常多，然而它们各有各的优势，也有对应的不足，所以根据自己的使用场景，选择最适合的抓包工具才是最重要的！
四、网际控制报文协议ICMP
qz的博客
10-18 376
一、ICMP报文的种类 1. 概述 目的：为了更有效的转发IP数据报和提高交付成功的机会，在网际层使用了网际控制报文协议ICMP ICMP允许主机或路由器报告差错情况和提供有关异常情况的报告。 但ICMP不是高层协议(因为ICMP报文是装在IP数据报中，作为其中的数据部分)，而是IP层的协议。 2. ICMP报文的格式 3. ICMP报文的种类 ICMP报文的种类有多种，即ICMP差错报告报文（例如在路由器丢弃分组后向源站发送ICMP差错报告，不需要回复，单向的）和ICMP询问报文（询问其他站或路由器
抓包报文分析
chaoyueziji123的专栏
08-11 2836
虽然用到的抓包工具次数比较多，但是还是记不住这些16进制代码的含义。上次参加CTF竟然有这样的题，今天有时间就分析了一下，记下来 00 23 69 B7 81 24 0C 82 68 56 D3 AC 08 00 45 00 00 32 07 9D 40 0040 06 F9 B9 C0 A8 01 68 3A DD 3C 82 13 A1 21 24 D6 70 14 2F 0F
day--和--day区别
04-18
例如，如果有一个变量day的值为5，执行day--操作后，day的值将变为4，并且表达式的结果为5。这个操作符通常用于循环或迭代中，用于递减计数器或索引。 2. "day"是一个变量名或标识符，用于表示一个存储数据的位置。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值