零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程

《零入门kubernetes网络实战》视频专栏地址

https://www.ixigua.com/7193641905282875942

本篇文章视频地址(稍后上传)


本篇文章是在上一篇文章的基础之上,重点介绍

  • 以太网帧、
  • ICMP、
  • UDP、
  • TCP、
  • ARP、
  • IP

协议的封装过程,

并用golang解析

  • 以太网帧、
  • ICMP、
  • UDP、
  • TCP、
  • ARP、
  • IP

协议的报文头结构,以及对应的数据内容

用到的测试代码是
上一篇文章中的测试用例1中的代码。

代码占用的篇幅量太大,不再这里重新展示了。

1、本篇文章的核心点

本篇文章的核心点:

  • 把ICMP、ARP、IP、TCP、UDP协议的封装过程进行展示
  • 使用golang对ICMP、ARP、IP、TCP、UDP协议的报文头进行解析
    • 通过tcpdump命令进行抓包,使用wireshark进行抓包分析
    • 跟golang解析的报文头进行对比,检测一下我们解析的报文头是否有问题
  • 不会介绍ARP、ICMP、IP、TCP、UDP协议的原理。

2、测试环境介绍

两台虚拟机

  • centos7.5 10.211.55.122
  • centos7.5 10.211.55.123

3、OSI七层模型介绍

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第1张图片

4、网络信息传输模型图

客户端发送数据到服务器端的完整路线

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第2张图片

5、帧

5.1、什么叫做帧

在数据链路传输的数据包叫做帧。

也就是说
数据链路层以帧为单位进行传输和处理数据。

在数据链路层里,将位组合成字节,并将字节组合成帧。

5.2、帧结构分类

至少存在

  • 以太网帧
  • PPP帧

6、以太网帧介绍

6.1、以太网帧结构 6.1.1、封装过程流程图

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第3张图片

怎么看这个图呢?

  • 从上往下看
  • 从IP层到数据链路层,增加了哪些字段
  • 从数据链路层到物理层,增加哪些字段
    • 插入8个字节,目前不用关心。
    • 这8个字节,表明开始读取以太网帧了。也就是起始位置。

6.1.2、以太网帧结构

看上面图中第2行,从左到右看

  • 目的MAC地址,
    • 占用6个字节
    • 接收方设备的硬件地址
  • 源MAC地址
    • 占用6个字节
    • 发送方设备的硬件地址
  • 类型
    • 占用2个字节
    • 表示封装的数据的类型。如:
      • 0x0800代表IP协议帧
      • 0x0806代表ARP协议帧
      • 0x8864代表PPPoE
      • 0x86dd代表IPv6
      • 其他协议栈可以参考网址https://www.pianshen.com/article/5115861078/
      • 注意:
        • 没有TCP,UDP,ICMP。
        • 也就说,不能将TCP,UDP,ICMP数据直接封装到以太网帧里。
        • 必须先封装放到IP协议栈里。
  • 数据
    • 被封装的具体内容。
    • 占用46~1500字节
      • 如果不足46字节时,会进行填充到46字节
      • 最大占用1500字节。
      • 最大值也叫做最大传输单元(MTU)
    • 内容的类型是有要求的
      • 在上面"类型"里已经说明了
  • FCS
    • 帧校验序列

6.2、以太网帧报文头解析介绍

代码在前一篇文章中测试用例1的

etherheader.go文件中

先看一下main.go文件中的tapToUDP函数

读取原理,前面介绍tun设备时,已经介绍过了。

这里又简单的说明了一次。

然后,打开etherheader.go文件
零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第4张图片

7、IP报文介绍

7.1、IP报文封装过程

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第5张图片

什么是封装呢?

简单的说,就是在上一层的基础上又添加一些东西而已。

添加的东西都有一定的规则。

上一层到下一层,添加了哪些属性。

7.2、IP报文详细结构如下:包括IP报文头结构+IP报文数据

从上面的图中,可以看出来
一个IP报文包括2部分构成

  • IP报文头
    • 固定部分占用20个字节
    • 可变长部分占用0~40个字节
  • 具体数据部分

一个IP报文,包括IP报文头+数据部分,最多可以占用65535个字节

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第6张图片

首先注意一点:
IP报文的存储结构并不是如上图的样子,是个长方形。
IP报文是存储一个切片里。
只是IP报文的属性比较多,这里为了表达清楚,而如此绘画的。
前5行,每行占用4个字节。
按照图中的顺序存储的属性。
先版本号,然后头部长度,以此类推。

IP报文头结构的具体属性解释,可以参考下面的文章
https://wenku.baidu.com/view/f4559240f6335a8102d276a20029bd64783e62f1.html

7.3、使用golang来解析IP报文

7.3.1、对前篇文章测试用例1中的代码,进行更新

从上图中,可以看出来,
IP头部是由两部分构成的:
第一部分是固定部分,固定占用20个字节。
第二部分是可选部分,最少占用0个字节,最多占用40个字节。

因此,我们需要对测试用例1中的client包下的main.go文件以及ipv4header.go文件进行更新。

7.3.1.1、更新main.go文件中的tapToUDP函数

tapToUDP函数的最新内容如下:(直接copy即可)

func tapToUDP(udpConn *net.UDPConn, tapFile *os.File) {
	packet := make([]byte, 1024*64)
	size := 0
	var err error
	for {
		if size, err = tapFile.Read(packet); err != nil {
			return
		}

		te := MACType(packet[:size])
		printMACHeader(packet[:size])

		if strings.EqualFold(fmt.Sprintf("%x", te), "0800") {
			b := packet[14:size]
			printIPv4Header(b)
			hl := getIPv4HeaderLen(b)
			if b[9] == 1 {
				icmpPacket := b[hl:]
				printICMPHeader(icmpPacket)
			}

			if b[9] == 6 {
				tcpPacket := b[hl:]
				printTCPHeader(tcpPacket)
			}

			if b[9] == 17 {
				udpPacket := b[hl:]
				printUDPHeader(udpPacket)
			}
		}

		if strings.EqualFold(fmt.Sprintf("%x", te), "0806") {
			b := packet[14:size]
			printARPHeader(b)
		}

		rAddr, err := net.ResolveUDPAddr("udp", remoteAddr)
		if err != nil {
			log.Fatalln("failed to get udp socket:", err)
			return
		}
		if size, err = udpConn.WriteTo(packet[:size], rAddr); err != nil {
			fmt.Println(err.Error())
			return
		}
		fmt.Printf("tapToUDP--->Write Msg To UDP Conn OK! size:%d\n", size)
	}
}

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第7张图片

7.3.1.2、更新ipv4header.go文件中,新增一个函数getIPv4HeaderLen

在ipv4header.go文件中,新增加一个函数

func getIPv4HeaderLen(packet []byte) int {
	header := packet[0]
	headerLen := header & 0x0f * 4
	hl, _ := strconv.Atoi(fmt.Sprintf("%d", headerLen))
	return hl
}

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第8张图片

7.4、对ipv4header.go文件中的部分代码进行说明

在测试用例1中的ipv4header.go文件里

7.4.1、printVersionIPv4函数说明

该函数打印的是IP协议的版本号,
IP协议有两个版本号:

  • IPv4
  • IPv6

上面的图中,已经说明版本号占用的是第一个字节的前4个bit;

第一个字节,即packet[0]

而函数printVersionIPv4的参数类型是字节切片

只能按照字节获取

1个字节等于8个bit

那么,如何获取前4个bit的值呢?
直接将前4个字节向右移动4位即可,即packet[0]>>4

7.4.2、printHeaderLenIPv4函数说明

该函数是打印一个IP报文的头部长度
包括:固定长度+可选项长度

上面图中,已经说明,头部长度在第1个字节的后4个bit存储。
即:

  • 第1个字节用packet[0]来获取
  • 只有后4个bit有用,即packet[0]&0x0f
    • 0x0f,转换成二进制是0b00001111;
    • 0跟任何数相与的话,结果都是0
    • 即,将前4位置0
    • 即,前4位bit的数无意义了

packet[0]&0x0f*4?为什么最后乘以4呢?

头部长度占用4bit位,这里我们假设用每个bit位代表4个字节

那么,用二进制表示,4bit最小值是0b0000

4bit最大值是0b1111,即15

转换成字节数是15*4=60个字节

即,头部长度最多占用60个字节。

7.4.3、printAllLenIPv4函数说明

该函数是打印一个IP报文的长度;这里的长度包括IP头部长度+具体数据长度

uint16(packet[2])<<8|uint16(packet[3]) 什么意思呢?
首先,观察IP报文结构图中,显示IP报文总长度占用的第3个字节packet[2],以及第4个字节packet[3];

在golang中byte是uint8的别名,取值范围是0~255

假设当前IP报文的总长度是1000,已经超过byte的最大存储值255了, 一个字节已经存储不下了,

此时,可以使用两个字节进行存储。
将1000转换为二进制0000001111101000,可以

  • 将前8个bit,即00000011存储到packet[2]里,
  • 将后8个bit,即11101000存储到packet[3]里

这样的话,就可以存储起来了。

现在,过程反过来了;如何通过读取packet[2], packet[3]的值来获得1000?

我们需要将packet[2],packet[3]转换成二进制,并且将packet[2]放到packet[3]前面,因此,涉及到packet[2]的移位操作;

因为packet[2]的类型byte,一共才占用8位,因此,如果直接读取packet[2]的值,向左移动8的话,会导致数据丢失的;

因此,需要先将packet[2]的值,强制转换为uint16,再向左移动8位;

即,00000011->0000000000000011->0000001100000000

uint16类型不能uint8类型进行异或操作,位数不对。

因此,也必须将packet[3]强制转换为uint16

最终变为uint16(packet[2])<<8|uint16(packet[3])

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第9张图片

7.4.4、printDstIPv4函数说明

获取IP的两种方式

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第10张图片

8、TCP报文

8.1、TCP数据段封装过程

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第11张图片

TCP报文头同样有两部分组成:

  • 固定部分,占20个字节
  • 可变长部分,占0~40个字节

8.2、TCP报文头的结构如下

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第12张图片

每个属性的具体含义,可以参考下面的网址:

https://blog.csdn.net/marywang56/article/details/76151064

8.3、使用golang解析TCP报文头部结构

8.3.1、分析main.go文件中的tapToUDP函数

测试用例1的client包下的main.go文件里

8.3.2、分析tcpheader.go文件

主要分析一下

TCP报文头中的CWR、ACK、FIN这三个属性,如何获取进行分析;以及如何获取TCP报文中的数据部分进行简单分析一下。

其他属性的获取方式,跟以前很类似,不再过多介绍了。

8.3.2.1、printTCPFlagFIN函数说明

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第13张图片

8.3.2.2、printTCPFlagCWR函数说明

CWR占用的是packet[13]字节中的第1个bit位,需要将剩余的属性全部置为0,

即,packet[13]&0x80

为什么还要向右移动7位呢?
零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第14张图片

8.3.2.3、printTCPFlagACK函数说明

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第15张图片

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第16张图片

8.3.2.4、printTCPData函数说明

8.4、测试

提供一个简单的tcp测试用例,抓包分析,

然后跟Wireshark软件进行对比分析

查看,我们golang解析的是否正确

8.4.1、启动helloworld级别的点对点VPN服务

将前一篇文章中的测试用例1启动即可。

前面文章中,已经说明了启动方式。

8.4.2、TCP测试用例

8.4.2.1、TCP服务器端代码

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strings"
)

const (
	ip   = "10.244.3.3"
	port = 9898
)

func main() {
	l, err := net.Listen("tcp", fmt.Sprintf("%s:%d", ip, port))
	if err != nil {
		fmt.Println("listen error:", err)
		os.Exit(1)
	}
	defer l.Close()
	fmt.Printf("listening on :%v", fmt.Sprintf("%s:%d", ip, port))
	for {
		conn, err := l.Accept()
		if err != nil {
			fmt.Println("accept error:", err)
			os.Exit(1)
		}
		fmt.Printf("message %s->%s\n", conn.RemoteAddr(), conn.LocalAddr())
		go handleRequest(conn)
	}
}

func handleRequest(conn net.Conn) {
	ip := conn.RemoteAddr().String()
	defer func() {
		fmt.Println("disconnect:" + ip)
		conn.Close()
	}()
	reader := bufio.NewReader(conn)
	writer := bufio.NewWriter(conn)

	for {
		b, _, err := reader.ReadLine()
		if err != nil {
			return
		}
		writer.Write([]byte(strings.ToUpper(string(b))))
		writer.Write([]byte("\n"))
		writer.Flush()
	}
}

TCP服务器端,只是将接收到的内容,转换为大写而已。

反馈给客户端。

8.4.2.2、TCP客户端代码

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"sync"
)

const (
	ip   = "10.244.3.3"
	port = 9898
)

func main() {
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", ip, port))
	if err != nil {
		fmt.Println("connect error", err)
		os.Exit(1)
	}
	defer conn.Close()
	var wg sync.WaitGroup
	wg.Add(2)
	go handleWrite(conn, &wg)
	go handleRead(conn, &wg)
	wg.Wait()
}

func handleWrite(conn net.Conn, wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 0; i < 1; i++ {

		writer := bufio.NewWriter(conn)
		writer.Write([]byte("hello456"))
		writer.Write([]byte("\n"))
		writer.Flush()
	}
	fmt.Println("write done")
}

func handleRead(conn net.Conn, wg *sync.WaitGroup) {
	defer wg.Done()
	reader := bufio.NewReader(conn)
	for i := 0; i < 1; i++ {
		line, _, err := reader.ReadLine()
		if err != nil {
			fmt.Println("read error", err)
			return
		}

		fmt.Printf("Read Msg From Tcp Server:%v\n", string(line))
	}
	fmt.Println("read done")
}

注意:

tcp客户端请求内容是
"hello456"
在使用golang进行解析时,查看一下是否是"hello456"

8.4.2.3、本地编译,上传到10.211.55.122,10.211.55.123节点上去

Makefile参考内容如下

build:
	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o tcpclient ./client/main.go
	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o tcpserver ./server/main.go

scp:
	scp tcpclient [email protected]:/root
	scp tcpserver [email protected]:/root

all:
	make build && make scp

在本地执行

make all

即可

8.4.2.4、登陆到10.211.55.122节点上, 进行抓包

tcpdump -nn -i tap99 -w tcp.pcap

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第17张图片

8.4.2.5、登陆到10.211.55.123节点上,启动TCP服务器端服务

./tcpserver 

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第18张图片

8.4.2.6、登陆到10.211.55.122节点上,启动TCP客户端服务

./tcpclient 

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第19张图片

日志显示,已经将请求的内容,转换为了大写,说明确实是服务器端反馈的。

8.4.2.7、将抓包结果上传到wireshark里查看

8.4.2.8、在10.211.55.122节点上查看一下客户端日志 并跟 Wireshark里解析的数据包进行对比

9、UDP报文介绍

9.1、UDP报文封装过程介绍

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第20张图片

UDP报文的封装过程,跟TCP是一样的。

只是UDP的报文结构跟TCP不同。

9.2、UDP报文结构介绍

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第21张图片

很明显,UDP的报文结构比TCP简单多了。

UDP报文头固定占用8个字节。

源端口

  • 源端口:
    • 主机的应用程序使用的端口号。
  • 目的端口:
    • 目的主机的应用程序使用的端口号。
  • 总长度:
    • 是指UDP头部和UDP数据的字节长度。
    • 因为UDP头 部长度为8字节,所以该字段的最小值为8。
      • 也就是说,数据部分可以为空
  • 校验和:
    • 检测UDP数据报在传输中是否有错,有错则丢弃。

9.3、使用golang解析UDP报文头部结构

9.3.1、main.go文件里

先看一下前一篇文章中的测试用例1中的客户端代码main.go文件里:

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第22张图片

9.3.2、udpheader.go文件里

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第23张图片

解析原理,跟以前的一样。不再过多解析了。

9.4、测试

提供一个简单的udp测试用例,抓包分析,

然后跟Wireshark软件进行对比分析

查看,我们golang解析的是否正确

9.4.1、启动helloworld级别的点对点VPN服务

将前一篇文章中的测试用例1启动即可。

前面文章中,已经说明了启动方式。

如果已经启动了,忽略即可。

9.4.2、UDP测试用例

其实,tcp测试用例,udp测试用例的逻辑不用心。

我们只是抓包分析。

9.4.2.1、UDP服务器端代码

package main

import (
	"fmt"
	"net"
	"time"
)

const ip = "10.244.3.3"

func main() {
	udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ip, 8989))
	if err != nil {
		fmt.Println("Err resolve UDP address: ", err)
		return
	}

	serverConn, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		fmt.Println("ListenUDP error: ", err)
		return
	}

	var ticker = time.Tick(time.Second * 2) // 每隔2秒钟发送一个数据

	for {
		for _ = range ticker {
			var buff [512]byte
			n, rAddr, err := serverConn.ReadFromUDP(buff[0:])
			if err != nil {
				fmt.Println("Read error: ", err)
				break
			}
			fmt.Println("Read from client: ", string(buff[:n]))
			// 如果使用Write,本地测试时客户端接收不到信息
			serverConn.WriteToUDP([]byte("Hello client"), rAddr)
		}
	}
}

9.4.2.2、UDP客户端代码

package main

import (
	"fmt"
	"net"
)

const ip = "10.244.3.3"

func main() {
	udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ip, 8989))
	if err != nil {
		fmt.Println("Err resolve UDP address: ", err)
		return
	}

	conn, err := net.DialUDP("udp", nil, udpAddr)
	if err != nil {
		fmt.Println("Dial UDP error: ", err)
		return
	}

	size, err := conn.Write([]byte("Hello UDP Server"))
	if err != nil {
		fmt.Printf("Send Msg Failed! error: %v\n", err.Error())
		return
	}
	fmt.Printf("Send Msg OK!size:%d\n", size)

	var buff [512]byte
	n, err := conn.Read(buff[0:])
	if err != nil {
		fmt.Println("ERR: ", err)
	}
	fmt.Printf("Read from server: %v\tlen(msg):%v\n", string(buff[:n]), n)

	//for {
	//	conn.Write([]byte("Hello server"))
	//	var buff [512]byte
	//	n, err := conn.Read(buff[0:])
	//	if err != nil {
	//		fmt.Println("ERR: ", err)
	//		break
	//	}
	//	fmt.Println("Read from server: ", string(buff[:n]))
	//}

}

9.4.2.3、本地编译,上传到10.211.55.122,10.211.55.123节点上去

Makefile参考内容,如下(一定要改成自己的)

build:
	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o udpclient ./client/main.go
	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o udpserver ./server/main.go

scp:
	scp udpclient [email protected]:/root
	scp udpserver [email protected]:/root

all:
	make build && make scp

9.4.2.4、登陆到10.211.55.122节点上, 进行抓包

tcpdump -nn -i tap99 -w udp.pcap

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第24张图片

9.4.2.5、登陆到10.211.55.123节点上,启动UDP服务器端服务

./udpserver 

在这里插入图片描述

9.4.2.6、登陆到10.211.55.122节点上,启动UDP客户端服务

./udpclient 

在这里插入图片描述

9.4.2.7、将抓包结果上传到wireshark里查看

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第25张图片

9.4.2.8、在10.211.55.122节点上查看一下客户端日志 并跟 Wireshark里解析的数据包进行对比

10、ICMP报文

10.1、ICMP封包过程介绍

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第26张图片

10.2、ICMP报文结构介绍

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第27张图片

ICMP报文存在多个类型,不同的类型,ICMP头部属性并不相同。

这里画的是TYPE为8的情况下。

ICMP报文的类型,可以参考下面的文章

https://www.51cto.com/article/207507.html
http://t.zoukankan.com/linfeng-learning-p-12511225.html
https://blog.csdn.net/cixieku3433/article/details/100353399/

10.3、使用golang解析UDP报文头部结构

10.3.1、main.go文件里

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第28张图片

10.3.2、icmpheader.go文件里

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第29张图片

10.4、测试

本次测试的ICMP协议,因此,直接使用ping命令即可,

同样,使用Wireshark软件对ICMP报文进行分析

查看,我们使用golang解析的ICMP报文是否正确

10.4.1、启动helloworld级别的点对点VPN服务

将前一篇文章中的测试用例1启动即可。

前面文章中,已经说明了启动方式。

如果已经启动了,忽略即可。

10.4.2、登录到10.211.55.122客户端上

10.4.2.1、设置抓包命令

tcpdump -nn -i tap99 -w icmp.pcap

在这里插入图片描述

10.4.2.2、使用ping命令创建ICMP数据包

在10.211.55.122节点上ping 10.211.55.123节点上的tap99虚拟网络设备

ping -c 1 10.244.3.3 -I tap99

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第30张图片

10.4.2.3、将抓包结果上传到wireshark里查看

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第31张图片

10.4.2.4、在10.211.55.122节点上查看一下客户端日志 并跟 Wireshark里解析的数据包进行对比

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第32张图片

11、ARP报文

11.1、ARP报文封装过程

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第33张图片

注意:

ARP报文并非是使用IP协议进行封装的。

而是,直接封装到以太网帧里。

11.2、ARP报文结构介绍

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第34张图片

ARP报文跟其他协议报文还是有很大的区别的。

注意到了没,ARP报文是没有头部结构这一说的。

ARP报文的属性,以及占用的字节都已经固定好了。

11.3、使用golang解析arp报文结构

11.3.1、main.go文件里

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第35张图片

11.3.2、arpheader.go文件里

不再介绍了,原理跟解析其他报文完全一样。

很清晰。

11.4、测试

本次测试的arp协议;

根据上面的ARP报文原理,我们已经知道为什么会产生了ARP报文了,

因此,我们可以继续使用ping来测试。

11.4.1、启动helloworld级别的点对点VPN服务

将前一篇文章中的测试用例1启动即可。

前面文章中,已经说明了启动方式。

如果已经启动了,忽略即可。

11.4.2、登录到10.211.55.122客户端上

11.4.2.1、设置抓包命令

tcpdump -nn -i tap99 -w icmp.pcap

在这里插入图片描述

11.4.2.2、使用ping命令创建ICMP数据包

在10.211.55.122节点上ping 10.211.55.123节点上的tap99虚拟网络设备

ping -c 1 10.244.3.3 -I tap99

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第36张图片

11.4.2.3、将抓包结果上传到wireshark里查看

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第37张图片

11.4.2.4、在10.211.55.122节点上查看一下客户端日志 并跟 Wireshark里解析的数据包进行对比

零入门kubernetes网络实战-26->介绍IP-TCP-UDP-ARP-ICMP协议的封装过程以及用golang解析报文头的过程_第38张图片

12、总结

本篇文章主要是介绍了一下ICMP、TCP、UDP、ARP协议的封装过程,以及如何通过golang去解析报文结构。

TCP、UDP、ICMP协议的整体封装过程是一样的;都是封装在IP协议里;再将IP协议封装到以太网帧中。

而ARP协议是直接封装到以太网帧中的。

13、参考文档

  • 图解:Ping 命令的工作原理
    • 很不错的
  • 网络协议栈基本知识
  • IP协议的详细知识总结
  • ipv4报头解析
  • [TCP/IP] TCP报文长度是由什么确定的

<<零入门kubernetes网络实战>>技术专栏之文章目录


你可能感兴趣的:(网络,kubernetes,kubernetes网络实战,docker,golang)