[BPF] reassemble the IP fragments

Author: tomastigera

felix/bpf/ut/ip4_defrag_test.go

@@ -37,22 +37,32 @@ func TestIP4Defrag(t *testing.T) {
 	}
 
 	ip := *ipv4Default
+	ip.Id = 0x1234
+	ip.Length = 20 + 8 + 2000
+	ip.Flags = 0
 	udp := *udpDefault
 	udp.Length = 8 + 2000
 
+	// compute ull packet
+	payload := gopacket.Payload(data)
+	udp.SetNetworkLayerForChecksum(&ip)
+
+	pktFull := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(pktFull, gopacket.SerializeOptions{ComputeChecksums: true}, ethDefault, &ip, &udp, payload)
+	Expect(err).NotTo(HaveOccurred())
+
 	dataLen := 1600
 	dataOffset := 0
 
-	ip.Id = 0x1234
 	ip.Flags = layers.IPv4MoreFragments
 	ip.FragOffset = 0
 	ip.Length = 20 + 8 + 1596
 
-	payload := gopacket.Payload(data[dataOffset : dataOffset+dataLen])
+	payload = gopacket.Payload(data[dataOffset : dataOffset+dataLen])
 	udp.SetNetworkLayerForChecksum(&ip)
 
 	pkt0 := gopacket.NewSerializeBuffer()
-	err := gopacket.SerializeLayers(pkt0, gopacket.SerializeOptions{ComputeChecksums: true}, ethDefault, &ip, &udp, payload)
+	err = gopacket.SerializeLayers(pkt0, gopacket.SerializeOptions{ComputeChecksums: true}, ethDefault, &ip, &udp, payload)
 	Expect(err).NotTo(HaveOccurred())
 
 	dataOffset = dataLen
@@ -67,9 +77,9 @@ func TestIP4Defrag(t *testing.T) {
 	Expect(err).NotTo(HaveOccurred())
 
 	dataOffset += dataLen
-	dataLen = 2000 - dataOffset
+	dataLen = 80
 
-	ip.Flags = 0
+	ip.Flags = layers.IPv4MoreFragments
 	ip.FragOffset = uint16((8 + dataOffset) / 8)
 	ip.Length = uint16(20 + dataLen)
 	payload = gopacket.Payload(data[dataOffset : dataOffset+dataLen])
@@ -78,8 +88,24 @@ func TestIP4Defrag(t *testing.T) {
 	err = gopacket.SerializeLayers(pkt2, gopacket.SerializeOptions{ComputeChecksums: true}, ethDefault, &ip, payload)
 	Expect(err).NotTo(HaveOccurred())
 
+	dataOffset += dataLen
+	dataLen = 2000 - dataOffset
+
+	ip.Flags = 0
+	ip.FragOffset = uint16((8 + dataOffset) / 8)
+	ip.Length = uint16(20 + dataLen)
+	payload = gopacket.Payload(data[dataOffset : dataOffset+dataLen])
+
+	pkt3 := gopacket.NewSerializeBuffer()
+	err = gopacket.SerializeLayers(pkt3, gopacket.SerializeOptions{ComputeChecksums: true}, ethDefault, &ip, payload)
+	Expect(err).NotTo(HaveOccurred())
+
+	pktFullR := gopacket.NewPacket(pktFull.Bytes(), layers.LayerTypeEthernet, gopacket.Default)
+
 	runBpfTest(t, "calico_from_host_ep", nil, func(bpfrun bpfProgRunFn) {
-		res, err := bpfrun(pkt0.Bytes())
+		bytes := pkt0.Bytes()
+		copy(bytes[40:42], pktFull.Bytes()[40:42]) // patch in the udp csum for the entire packet
+		res, err := bpfrun(bytes)
 		Expect(err).NotTo(HaveOccurred())
 		pktR := gopacket.NewPacket(res.dataOut, layers.LayerTypeEthernet, gopacket.Default)
 		fmt.Printf("pktR = %+v\n", pktR)
@@ -95,10 +121,29 @@ func TestIP4Defrag(t *testing.T) {
 	})
 
 	runBpfTest(t, "calico_from_host_ep", nil, func(bpfrun bpfProgRunFn) {
-		res, err := bpfrun(pkt2.Bytes())
+		res, err := bpfrun(pkt3.Bytes())
 		Expect(err).NotTo(HaveOccurred())
 		pktR := gopacket.NewPacket(res.dataOut, layers.LayerTypeEthernet, gopacket.Default)
 		fmt.Printf("pktR = %+v\n", pktR)
 		Expect(res.Retval).To(Equal(resTC_ACT_SHOT))
 	})
+
+	runBpfTest(t, "calico_from_host_ep", nil, func(bpfrun bpfProgRunFn) {
+		res, err := bpfrun(pkt2.Bytes())
+		Expect(err).NotTo(HaveOccurred())
+		pktR := gopacket.NewPacket(res.dataOut, layers.LayerTypeEthernet, gopacket.Default)
+		fmt.Printf("pktR = %+v\n", pktR)
+		fmt.Printf("pktFullR = %+v\n", pktFullR)
+		Expect(res.Retval).To(Equal(resTC_ACT_UNSPEC))
+
+		payloadL := pktR.ApplicationLayer()
+		data := payloadL.Payload()
+
+		for i := 0; i < 1000; i++ {
+			Expect(data[i*2]).To(Equal(byte(uint16(i)>>8)), fmt.Sprintf("wrong at index %d", i*2))
+			Expect(data[i*2+1]).To(Equal(byte(uint16(i)&0xff)), fmt.Sprintf("wrong at index %d", i*2+1))
+		}
+
+		Expect(pktFull.Bytes()).To(Equal(res.dataOut))
+	})
 }