增加对pcap的支持以方便调试

[66hh]

如题

附上简易实现代码

io/pcap.go

package io

import (
	"context"
	"hash/crc32"
	"sort"
	"strings"
	"time"

	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
	"github.com/google/gopacket/pcap"
)

var _ PacketIO = (*pcapPacketIO)(nil)

type pcapPacketIO struct {
	pcap     *pcap.Handle
	lastTime *time.Time
}

func NewPcapPacketIO(pcapFile string) (PacketIO, error) {
	handle, err := pcap.OpenOffline(pcapFile)

	if err != nil {
		return nil, err
	}

	return &pcapPacketIO{
		pcap:     handle,
		lastTime: nil,
	}, nil
}

func (n *pcapPacketIO) Register(ctx context.Context, cb PacketCallback) error {
	go func() {
		packetSource := gopacket.NewPacketSource(n.pcap, n.pcap.LinkType())
		for packet := range packetSource.Packets() {

			if n.lastTime == nil {
				n.lastTime = &packet.Metadata().Timestamp
			} else {
				t := packet.Metadata().Timestamp.Sub(*n.lastTime)
				time.Sleep(t)
				n.lastTime = &packet.Metadata().Timestamp
			}

			ethernetLayer := packet.Layer(layers.LayerTypeEthernet)

			var id uint32 = 0
			var address []string

			if ethernetLayer.(*layers.Ethernet).EthernetType == 0x0800 {
				ipLayer := packet.Layer(layers.LayerTypeIPv4)
				ipPacket := ipLayer.(*layers.IPv4)
				address = append(address, string(ipPacket.DstIP))
				address = append(address, string(ipPacket.SrcIP))
			}
			if ethernetLayer.(*layers.Ethernet).EthernetType == 0x86DD {
				ipLayer := packet.Layer(layers.LayerTypeIPv6)
				ipPacket := ipLayer.(*layers.IPv6)
				address = append(address, string(ipPacket.DstIP))
				address = append(address, string(ipPacket.SrcIP))
			}

			if len(address) != 0 {
				sort.Sort(sort.StringSlice(address))
				id = crc32.Checksum([]byte(strings.Join(address, ",")), crc32.IEEETable)
			}

			cb(&pcapPacket{
				streamID: id,
				data:     ethernetLayer.LayerPayload(),
			}, nil)

		}

	}()

	return nil
}

func (n *pcapPacketIO) SetVerdict(p Packet, v Verdict, newPacket []byte) error {
	return nil
}

func (n *pcapPacketIO) Close() error {
	return nil
}

var _ Packet = (*pcapPacket)(nil)

type pcapPacket struct {
	streamID uint32
	data     []byte
}

func (p *pcapPacket) StreamID() uint32 {
	return p.streamID
}

func (p *pcapPacket) Data() []byte {
	return p.data
}