vendor/github.com/google/gopacket/layers/ip6_test.go

   1 // Copyright 2014, Google, Inc. All rights reserved.
   2 //
   3 // Use of this source code is governed by a BSD-style license
   4 // that can be found in the LICENSE file in the root of the source
   5 // tree.
   6
   7 package layers
   8
   9 import (
  10         "bytes"
  11         "github.com/google/gopacket"
  12         "net"
  13         "reflect"
  14         "testing"
  15 )
  16
  17 func TestSerializeIPv6HeaderTLVOptions(t *testing.T) {
  18         //RFC 2460 Appendix B
  19         /*
  20            Example 3
  21
  22            A Hop-by-Hop or Destination Options header containing both options X
  23            and Y from Examples 1 and 2 would have one of the two following
  24            formats, depending on which option appeared first:
  25
  26            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  27            |  Next Header  | Hdr Ext Len=3 | Option Type=X |Opt Data Len=12|
  28            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  29            |                         4-octet field                         |
  30            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  31            |                                                               |
  32            +                         8-octet field                         +
  33            |                                                               |
  34            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  35            | PadN Option=1 |Opt Data Len=1 |       0       | Option Type=Y |
  36            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  37            |Opt Data Len=7 | 1-octet field |         2-octet field         |
  38            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  39            |                         4-octet field                         |
  40            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  41            | PadN Option=1 |Opt Data Len=2 |       0       |       0       |
  42            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  43         */
  44         opt1 := &ipv6HeaderTLVOption{}
  45         opt1.OptionType = 0x1e
  46         opt1.OptionData = []byte{0xaa, 0xaa, 0xaa, 0xaa, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb}
  47         opt1.OptionAlignment = [2]uint8{8, 2}
  48
  49         opt2 := &ipv6HeaderTLVOption{}
  50         opt2.OptionType = 0x3e
  51         opt2.OptionData = []byte{0x11, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44}
  52         opt2.OptionAlignment = [2]uint8{4, 3}
  53
  54         l := serializeIPv6HeaderTLVOptions(nil, []*ipv6HeaderTLVOption{opt1, opt2}, true)
  55         b := make([]byte, l)
  56         serializeIPv6HeaderTLVOptions(b, []*ipv6HeaderTLVOption{opt1, opt2}, true)
  57         got := b
  58         want := []byte{0x1e, 0x0c, 0xaa, 0xaa, 0xaa, 0xaa, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x01, 0x00, 0x3e, 0x07, 0x11, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44, 0x01, 0x02, 0x00, 0x00}
  59
  60         if !bytes.Equal(got, want) {
  61                 t.Errorf("IPv6HeaderTLVOption serialize (X,Y) failed:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
  62         }
  63
  64         /*
  65            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  66            |  Next Header  | Hdr Ext Len=3 | Pad1 Option=0 | Option Type=Y |
  67            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  68            |Opt Data Len=7 | 1-octet field |         2-octet field         |
  69            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  70            |                         4-octet field                         |
  71            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  72            | PadN Option=1 |Opt Data Len=4 |       0       |       0       |
  73            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  74            |       0       |       0       | Option Type=X |Opt Data Len=12|
  75            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  76            |                         4-octet field                         |
  77            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  78            |                                                               |
  79            +                         8-octet field                         +
  80            |                                                               |
  81            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  82         */
  83
  84         l = serializeIPv6HeaderTLVOptions(nil, []*ipv6HeaderTLVOption{opt2, opt1}, true)
  85         b = make([]byte, l)
  86         serializeIPv6HeaderTLVOptions(b, []*ipv6HeaderTLVOption{opt2, opt1}, true)
  87         got = b
  88         want = []byte{0x00, 0x3e, 0x07, 0x11, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x0c, 0xaa, 0xaa, 0xaa, 0xaa, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb}
  89
  90         if !bytes.Equal(got, want) {
  91                 t.Errorf("IPv6HeaderTLVOption serialize (Y,X) failed:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
  92         }
  93 }
  94
  95 var testPacketIPv6HopByHop0 = []byte{
  96         0x60, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
  97         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
  98         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3b, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00,
  99 }
 100
 101 func TestPacketIPv6HopByHop0Serialize(t *testing.T) {
 102         var serialize []gopacket.SerializableLayer = make([]gopacket.SerializableLayer, 0, 2)
 103         var err error
 104
 105         ip6 := &IPv6{}
 106         ip6.Version = 6
 107         ip6.NextHeader = IPProtocolIPv6HopByHop
 108         ip6.HopLimit = 64
 109         ip6.SrcIP = net.ParseIP("2001:db8::1")
 110         ip6.DstIP = net.ParseIP("2001:db8::2")
 111         serialize = append(serialize, ip6)
 112
 113         tlv := &IPv6HopByHopOption{}
 114         tlv.OptionType = 0x01 //PadN
 115         tlv.OptionData = []byte{0x00, 0x00, 0x00, 0x00}
 116         hop := &IPv6HopByHop{}
 117         hop.Options = append(hop.Options, tlv)
 118         hop.NextHeader = IPProtocolNoNextHeader
 119         ip6.HopByHop = hop
 120
 121         buf := gopacket.NewSerializeBuffer()
 122         opts := gopacket.SerializeOptions{FixLengths: true}
 123         err = gopacket.SerializeLayers(buf, opts, serialize...)
 124         if err != nil {
 125                 t.Fatal(err)
 126         }
 127
 128         got := buf.Bytes()
 129         want := testPacketIPv6HopByHop0
 130         if !bytes.Equal(got, want) {
 131                 t.Errorf("IPv6HopByHop serialize failed:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
 132         }
 133 }
 134
 135 func TestPacketIPv6HopByHop0Decode(t *testing.T) {
 136         ip6 := &IPv6{
 137                 BaseLayer: BaseLayer{
 138                         Contents: []byte{
 139                                 0x60, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 140                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 141                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 142                         },
 143                         Payload: []byte{0x3b, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00},
 144                 },
 145                 Version:      6,
 146                 TrafficClass: 0,
 147                 FlowLabel:    0,
 148                 Length:       8,
 149                 NextHeader:   IPProtocolIPv6HopByHop,
 150                 HopLimit:     64,
 151                 SrcIP:        net.IP{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
 152                 DstIP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 153                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
 154         }
 155
 156         hop := &ip6.hbh
 157         hop.ipv6ExtensionBase = ipv6ExtensionBase{
 158                 BaseLayer: BaseLayer{
 159                         Contents: []byte{0x3b, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00},
 160                         Payload:  []byte{},
 161                 },
 162                 NextHeader:   IPProtocolNoNextHeader,
 163                 HeaderLength: uint8(0),
 164                 ActualLength: 8,
 165         }
 166         opt := &IPv6HopByHopOption{
 167                 OptionType:   uint8(0x01),
 168                 OptionLength: uint8(0x04),
 169                 ActualLength: 6,
 170                 OptionData:   []byte{0x00, 0x00, 0x00, 0x00},
 171         }
 172         hop.Options = append(hop.Options, opt)
 173         ip6.HopByHop = hop
 174
 175         p := gopacket.NewPacket(testPacketIPv6HopByHop0, LinkTypeRaw, gopacket.Default)
 176         if p.ErrorLayer() != nil {
 177                 t.Error("Failed to decode packet:", p.ErrorLayer().Error())
 178         }
 179         checkLayers(p, []gopacket.LayerType{LayerTypeIPv6, LayerTypeIPv6HopByHop}, t)
 180         if got, ok := p.Layer(LayerTypeIPv6).(*IPv6); ok {
 181                 want := ip6
 182                 want.HopByHop = got.HopByHop // avoid comparing pointers
 183                 if !reflect.DeepEqual(got, want) {
 184                         t.Errorf("IPv6 packet processing failed:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
 185                 }
 186         } else {
 187                 t.Error("No IPv6 layer type found in packet")
 188         }
 189         if got, ok := p.Layer(LayerTypeIPv6HopByHop).(*IPv6HopByHop); ok {
 190                 want := hop
 191                 if !reflect.DeepEqual(got, want) {
 192                         t.Errorf("IPv6HopByHop packet processing failed:\ngot\n%#v\n\nwant:\n%#v\n\n", got, want)
 193                 }
 194         } else {
 195                 t.Error("No IPv6HopByHop layer type found in packet")
 196         }
 197 }
 198
 199 // testPacketIPv6Destination0 is the packet:
 200 //   12:40:14.429409595 IP6 2001:db8::1 > 2001:db8::2: DSTOPT no next header
 201 //      0x0000:  6000 0000 0008 3c40 2001 0db8 0000 0000  `.....<@........
 202 //      0x0010:  0000 0000 0000 0001 2001 0db8 0000 0000  ................
 203 //      0x0020:  0000 0000 0000 0002 3b00 0104 0000 0000  ........;.......
 204 var testPacketIPv6Destination0 = []byte{
 205         0x60, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3c, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 206         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 207         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3b, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00,
 208 }
 209
 210 func TestPacketIPv6Destination0Serialize(t *testing.T) {
 211         var serialize []gopacket.SerializableLayer = make([]gopacket.SerializableLayer, 0, 2)
 212         var err error
 213
 214         ip6 := &IPv6{}
 215         ip6.Version = 6
 216         ip6.NextHeader = IPProtocolIPv6Destination
 217         ip6.HopLimit = 64
 218         ip6.SrcIP = net.ParseIP("2001:db8::1")
 219         ip6.DstIP = net.ParseIP("2001:db8::2")
 220         serialize = append(serialize, ip6)
 221
 222         tlv := &IPv6DestinationOption{}
 223         tlv.OptionType = 0x01 //PadN
 224         tlv.OptionData = []byte{0x00, 0x00, 0x00, 0x00}
 225         dst := &IPv6Destination{}
 226         dst.Options = append(dst.Options, tlv)
 227         dst.NextHeader = IPProtocolNoNextHeader
 228         serialize = append(serialize, dst)
 229
 230         buf := gopacket.NewSerializeBuffer()
 231         opts := gopacket.SerializeOptions{FixLengths: true}
 232         err = gopacket.SerializeLayers(buf, opts, serialize...)
 233         if err != nil {
 234                 t.Fatal(err)
 235         }
 236
 237         got := buf.Bytes()
 238         want := testPacketIPv6Destination0
 239         if !bytes.Equal(got, want) {
 240                 t.Errorf("IPv6Destination serialize failed:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
 241         }
 242 }
 243
 244 func TestPacketIPv6Destination0Decode(t *testing.T) {
 245         ip6 := &IPv6{
 246                 BaseLayer: BaseLayer{
 247                         Contents: []byte{
 248                                 0x60, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3c, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 249                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 250                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 251                         },
 252                         Payload: []byte{0x3b, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00},
 253                 },
 254                 Version:      6,
 255                 TrafficClass: 0,
 256                 FlowLabel:    0,
 257                 Length:       8,
 258                 NextHeader:   IPProtocolIPv6Destination,
 259                 HopLimit:     64,
 260                 SrcIP:        net.IP{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
 261                 DstIP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 262                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
 263         }
 264
 265         dst := &IPv6Destination{}
 266         dst.BaseLayer = BaseLayer{
 267                 Contents: []byte{0x3b, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00},
 268                 Payload:  []byte{},
 269         }
 270         dst.NextHeader = IPProtocolNoNextHeader
 271         dst.HeaderLength = uint8(0)
 272         dst.ActualLength = 8
 273         opt := &IPv6DestinationOption{
 274                 OptionType:   uint8(0x01),
 275                 OptionLength: uint8(0x04),
 276                 ActualLength: 6,
 277                 OptionData:   []byte{0x00, 0x00, 0x00, 0x00},
 278         }
 279         dst.Options = append(dst.Options, opt)
 280
 281         p := gopacket.NewPacket(testPacketIPv6Destination0, LinkTypeRaw, gopacket.Default)
 282         if p.ErrorLayer() != nil {
 283                 t.Error("Failed to decode packet:", p.ErrorLayer().Error())
 284         }
 285         checkLayers(p, []gopacket.LayerType{LayerTypeIPv6, LayerTypeIPv6Destination}, t)
 286         if got, ok := p.Layer(LayerTypeIPv6).(*IPv6); ok {
 287                 want := ip6
 288                 if !reflect.DeepEqual(got, want) {
 289                         t.Errorf("IPv6 packet processing failed:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
 290                 }
 291         } else {
 292                 t.Error("No IPv6 layer type found in packet")
 293         }
 294         if got, ok := p.Layer(LayerTypeIPv6Destination).(*IPv6Destination); ok {
 295                 want := dst
 296                 if !reflect.DeepEqual(got, want) {
 297                         t.Errorf("IPv6Destination packet processing failed:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
 298                 }
 299         } else {
 300                 t.Error("No IPv6Destination layer type found in packet")
 301         }
 302 }
 303
 304 var testPacketIPv6JumbogramHeader = []byte{
 305         0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 306         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 307         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3b, 0x00, 0xc2, 0x04, 0x00, 0x01, 0x00, 0x08,
 308 }
 309
 310 func TestIPv6JumbogramSerialize(t *testing.T) {
 311         var serialize []gopacket.SerializableLayer = make([]gopacket.SerializableLayer, 0, 2)
 312         var err error
 313
 314         ip6 := &IPv6{}
 315         ip6.Version = 6
 316         ip6.NextHeader = IPProtocolNoNextHeader
 317         ip6.HopLimit = 64
 318         ip6.SrcIP = net.ParseIP("2001:db8::1")
 319         ip6.DstIP = net.ParseIP("2001:db8::2")
 320         serialize = append(serialize, ip6)
 321
 322         payload := make([]byte, ipv6MaxPayloadLength+1)
 323         for i := range payload {
 324                 payload[i] = 0xfe
 325         }
 326         serialize = append(serialize, gopacket.Payload(payload))
 327
 328         buf := gopacket.NewSerializeBuffer()
 329         opts := gopacket.SerializeOptions{FixLengths: true}
 330         err = gopacket.SerializeLayers(buf, opts, serialize...)
 331         if err != nil {
 332                 t.Fatal(err)
 333         }
 334
 335         got := buf.Bytes()
 336         w := new(bytes.Buffer)
 337         w.Write(testPacketIPv6JumbogramHeader)
 338         w.Write(payload)
 339         want := w.Bytes()
 340
 341         if !bytes.Equal(got, want) {
 342                 t.Errorf("IPv6 Jumbogram serialize failed:\ngot:\n%v\n\nwant:\n%v\n\n",
 343                         gopacket.LongBytesGoString(got), gopacket.LongBytesGoString(want))
 344         }
 345 }
 346
 347 func TestIPv6JumbogramDecode(t *testing.T) {
 348         payload := make([]byte, ipv6MaxPayloadLength+1)
 349         for i := range payload {
 350                 payload[i] = 0xfe
 351         }
 352
 353         ip6 := &IPv6{
 354                 BaseLayer: BaseLayer{
 355                         Contents: []byte{
 356                                 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 357                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 358                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 359                         },
 360                 },
 361                 Version:      6,
 362                 TrafficClass: 0,
 363                 FlowLabel:    0,
 364                 Length:       0,
 365                 NextHeader:   IPProtocolIPv6HopByHop,
 366                 HopLimit:     64,
 367                 SrcIP:        net.IP{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
 368                 DstIP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
 369                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
 370         }
 371         buf := new(bytes.Buffer)
 372         buf.Write([]byte{0x3b, 0x00, 0xc2, 0x04, 0x00, 0x01, 0x00, 0x08})
 373         buf.Write(payload)
 374         ip6.Payload = buf.Bytes()
 375
 376         hop := &ip6.hbh
 377         hop.Contents = []byte{0x3b, 0x00, 0xc2, 0x04, 0x00, 0x01, 0x00, 0x08}
 378         hop.Payload = payload
 379         hop.NextHeader = IPProtocolNoNextHeader
 380         hop.HeaderLength = uint8(0)
 381         hop.ActualLength = 8
 382         opt := &IPv6HopByHopOption{}
 383         opt.OptionType = uint8(0xc2)
 384         opt.OptionLength = uint8(0x04)
 385         opt.ActualLength = 6
 386         opt.OptionData = []byte{0x00, 0x01, 0x00, 0x08}
 387         hop.Options = append(hop.Options, opt)
 388         ip6.HopByHop = hop
 389
 390         pkt := new(bytes.Buffer)
 391         pkt.Write(testPacketIPv6JumbogramHeader)
 392         pkt.Write(payload)
 393
 394         p := gopacket.NewPacket(pkt.Bytes(), LinkTypeRaw, gopacket.Default)
 395         if p.ErrorLayer() != nil {
 396                 t.Error("Failed to decode packet:", p.ErrorLayer().Error())
 397         }
 398         checkLayers(p, []gopacket.LayerType{LayerTypeIPv6, LayerTypeIPv6HopByHop, gopacket.LayerTypePayload}, t)
 399
 400         if got, ok := p.Layer(LayerTypeIPv6).(*IPv6); ok {
 401                 want := ip6
 402                 want.HopByHop = got.HopByHop // Hack, avoid comparing pointers
 403                 if !reflect.DeepEqual(got, want) {
 404                         t.Errorf("IPv6 packet processing failed:\ngot:\n%v\n\nwant:\n%v\n\n",
 405                                 gopacket.LayerGoString(got), gopacket.LayerGoString(want))
 406                 }
 407         } else {
 408                 t.Error("No IPv6 layer type found in packet")
 409         }
 410
 411         if got, ok := p.Layer(LayerTypeIPv6HopByHop).(*IPv6HopByHop); ok {
 412                 want := hop
 413                 if !reflect.DeepEqual(got, want) {
 414                         t.Errorf("IPv6HopByHop packet processing failed:\ngot:\n%v\n\nwant:\n%v\n\n",
 415                                 gopacket.LayerGoString(got), gopacket.LayerGoString(want))
 416                 }
 417         } else {
 418                 t.Error("No IPv6HopByHop layer type found in packet")
 419         }
 420
 421         if got, ok := p.Layer(gopacket.LayerTypePayload).(*gopacket.Payload); ok {
 422                 want := (*gopacket.Payload)(&payload)
 423                 if !reflect.DeepEqual(got, want) {
 424                         t.Errorf("Payload packet processing failed:\ngot:\n%v\n\nwant:\n%v\n\n",
 425                                 gopacket.LayerGoString(got), gopacket.LayerGoString(want))
 426                 }
 427         } else {
 428                 t.Error("No Payload layer type found in packet")
 429         }
 430 }