ip := layers.IPv4{

Version: 4,

TTL: 220,

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

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

Flags: layers.IPv4DontFragment,

}

v4defragger := ip4defrag.NewIPv4Defragmenter()

b := gopacket.NewSerializeBuffer()

ops := gopacket.SerializeOptions{

FixLengths: true,

ComputeChecksums: true,

}

ip.SerializeTo(b, ops)

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

_, err := v4defragger.DefragIPv4(pack.Layer(layers.LayerTypeIPv4).(*layers.IPv4))

if err != nil {

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

}

v4defragger := ip4defrag.NewIPv4Defragmenter()

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

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

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

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

result, err := v4defragger.DefragIPv4(pack1.Layer(layers.LayerTypeIPv4).(*layers.IPv4))

if err != nil {

t.Fatalf("error defragmenting pack1")

}

if result != nil {

t.Fatalf("unexpected defragmented packet after pack1")

}

result, err = v4defragger.DefragIPv4(pack2.Layer(layers.LayerTypeIPv4).(*layers.IPv4))

if err != nil {

t.Fatalf("error defragmenting pack2")

}

if result != nil {

t.Fatalf("unexpected defragmented packet after pack2")

}

result, err = v4defragger.DefragIPv4(pack3.Layer(layers.LayerTypeIPv4).(*layers.IPv4))

if err != nil {

t.Fatalf("error defragmenting pack3")

}

if result != nil {

t.Fatalf("unexpected defragmented packet after pack3")

}

result, err = v4defragger.DefragIPv4(pack4.Layer(layers.LayerTypeIPv4).(*layers.IPv4))

if err != nil {

t.Fatalf("error defragmenting pack4")

}

if result == nil {

t.Fatalf("missing defragmented packet after pack4")

}

ip := result

// 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)

tcpFinished := make(chan bool)

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, tcpFinished, 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())