ip := layers.IPv4{

Version: 4,

TTL: 220,

SrcIP: net.IPv4(1, 1, 1, 1),

DstIP: net.IPv4(2, 2, 2, 2),

Flags: layers.IPv4DontFragment,

}

nomalPack := make(chan gopacket.Packet, 5)

fragV4Pack := make(chan gopacket.Packet, 5)

b := gopacket.NewSerializeBuffer()

ops := gopacket.SerializeOptions{

FixLengths: true,

ComputeChecksums: true,

}

ip.SerializeTo(b, ops)

pack := gopacket.NewPacket(b.Bytes(), layers.LinkTypeIPv4, gopacket.Default)

fragV4Pack <- pack

err := v4Defrag(fragV4Pack, nomalPack)

if err != nil {

t.Errorf("v4defrag do not return err when no frag pack is in")

}

nomalPack := make(chan gopacket.Packet, 5)

fragV4Pack := make(chan gopacket.Packet, 5)

go v4Defrag(fragV4Pack, nomalPack)

pack1 := gopacket.NewPacket(testPing1Frag1, layers.LinkTypeEthernet, gopacket.Default)

fragV4Pack <- pack1

pack2 := gopacket.NewPacket(testPing1Frag2, layers.LinkTypeEthernet, gopacket.Default)

fragV4Pack <- pack2

pack3 := gopacket.NewPacket(testPing1Frag3, layers.LinkTypeEthernet, gopacket.Default)

fragV4Pack <- pack3

pack4 := gopacket.NewPacket(testPing1Frag4, layers.LinkTypeEthernet, gopacket.Default)

fragV4Pack <- pack4

result := <-nomalPack

ip := result.Layer(layers.LayerTypeIPv4)

//TEST if the ip matches expectation

if ip == nil {

t.Errorf("defrag does not return IPV4 LAYER")

}

if len(ip.LayerPayload()) != 4508 {

t.Fatalf("defrag: expecting a packet of 4508 bytes, got %d", len(ip.LayerPayload()))

}

validPayload := append(testPing1Frag1[34:], testPing1Frag2[34:]...)

validPayload = append(validPayload, testPing1Frag3[34:]...)

validPayload = append(validPayload, testPing1Frag4[34:]...)

if bytes.Compare(validPayload, ip.LayerPayload()) != 0 {

fmt.Println(bytediff.BashOutput.String(

bytediff.Diff(validPayload, ip.LayerPayload())))

t.Errorf("defrag: payload is not correctly defragmented")

}

handle, err := pcap.OpenOffline("tcptest.pcap")

if err != nil {

panic(err)

}

packetSource := gopacket.NewPacketSource(handle, handle.LinkType())

defer handle.Close()

tcpPack := make(chan gopacket.Packet, 10)

nomalPack := make(chan gopacket.Packet, 5)

for input_pack := range packetSource.Packets() { // send tcp package for channel

tcpLayer := input_pack.Layer(layers.LayerTypeTCP)

if tcpLayer != nil {

tcpPack <- input_pack

// send packet to tcp ASSEMBLER

}

}

streamFactory := &DNSStreamFactory{normal: nomalPack}

streamPool := tcpassembly.NewStreamPool(streamFactory)

assembler := tcpassembly.NewAssembler(streamPool)

go tcpAssemble(tcpPack, assembler)

pack := <-nomalPack

udpLayer := pack.Layer(layers.LayerTypeUDP)

if udpLayer == nil {

t.Errorf("can not fine udp Layer in result")

}

dns_message := new(dns.Msg)

err = dns_message.Unpack(udpLayer.LayerPayload())

if err != nil {

t.Errorf("can not parse dns message")

}

fmt.Printf(dns_message.String())