vendor/github.com/google/gopacket/layers/tcpip_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         "github.com/google/gopacket"
  11         "net"
  12         "testing"
  13 )
  14
  15 const (
  16         ipv4UDPChecksum                = uint16(0xbc5f) // Wireshark
  17         ipv6UDPChecksumWithIPv6DstOpts = uint16(0x4d21) // Wireshark
  18         ipv6UDPChecksumJumbogram       = uint16(0xcda8)
  19 )
  20
  21 func createIPv4ChecksumTestLayer() (ip4 *IPv4) {
  22         ip4 = &IPv4{}
  23         ip4.Version = 4
  24         ip4.TTL = 64
  25         ip4.SrcIP = net.ParseIP("192.0.2.1")
  26         ip4.DstIP = net.ParseIP("198.51.100.1")
  27         return
  28 }
  29
  30 func createIPv6ChecksumTestLayer() (ip6 *IPv6) {
  31         ip6 = &IPv6{}
  32         ip6.Version = 6
  33         ip6.NextHeader = IPProtocolNoNextHeader
  34         ip6.HopLimit = 64
  35         ip6.SrcIP = net.ParseIP("2001:db8::1")
  36         ip6.DstIP = net.ParseIP("2001:db8::2")
  37         return
  38 }
  39
  40 func createIPv6DestinationChecksumTestLayer() (dst *IPv6Destination) {
  41         tlv := &IPv6DestinationOption{}
  42         tlv.OptionType = 0x01 //PadN
  43         tlv.OptionData = []byte{0x00, 0x00, 0x00, 0x00}
  44         dst = &IPv6Destination{}
  45         dst.Options = append(dst.Options, tlv)
  46         dst.NextHeader = IPProtocolNoNextHeader
  47         return
  48 }
  49
  50 func createUDPChecksumTestLayer() (udp *UDP) {
  51         udp = &UDP{}
  52         udp.SrcPort = UDPPort(12345)
  53         udp.DstPort = UDPPort(9999)
  54         return
  55 }
  56
  57 func TestIPv4UDPChecksum(t *testing.T) {
  58         var serialize []gopacket.SerializableLayer = make([]gopacket.SerializableLayer, 0, 2)
  59         var u *UDP
  60         var err error
  61
  62         ip4 := createIPv4ChecksumTestLayer()
  63         ip4.Protocol = IPProtocolUDP
  64         serialize = append(serialize, ip4)
  65
  66         udp := createUDPChecksumTestLayer()
  67         udp.SetNetworkLayerForChecksum(ip4)
  68         serialize = append(serialize, udp)
  69
  70         buf := gopacket.NewSerializeBuffer()
  71         opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
  72         err = gopacket.SerializeLayers(buf, opts, serialize...)
  73         if err != nil {
  74                 t.Fatal(err)
  75         }
  76
  77         p := gopacket.NewPacket(buf.Bytes(), LinkTypeRaw, gopacket.Default)
  78         if p.ErrorLayer() != nil {
  79                 t.Fatal("Failed to decode packet:", p.ErrorLayer().Error())
  80         }
  81         checkLayers(p, []gopacket.LayerType{LayerTypeIPv4, LayerTypeUDP}, t)
  82
  83         if l, ok := p.Layer(LayerTypeUDP).(*UDP); !ok {
  84                 t.Fatal("No UDP layer type found in packet")
  85         } else {
  86                 u = l
  87         }
  88         got := u.Checksum
  89         want := ipv4UDPChecksum
  90         if got != want {
  91                 t.Errorf("Bad checksum:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
  92         }
  93 }
  94
  95 func TestIPv6UDPChecksumWithIPv6DstOpts(t *testing.T) {
  96         var serialize []gopacket.SerializableLayer = make([]gopacket.SerializableLayer, 0, 3)
  97         var u *UDP
  98         var err error
  99
 100         ip6 := createIPv6ChecksumTestLayer()
 101         ip6.NextHeader = IPProtocolIPv6Destination
 102         serialize = append(serialize, ip6)
 103
 104         dst := createIPv6DestinationChecksumTestLayer()
 105         dst.NextHeader = IPProtocolUDP
 106         serialize = append(serialize, dst)
 107
 108         udp := createUDPChecksumTestLayer()
 109         udp.SetNetworkLayerForChecksum(ip6)
 110         serialize = append(serialize, udp)
 111
 112         buf := gopacket.NewSerializeBuffer()
 113         opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
 114         err = gopacket.SerializeLayers(buf, opts, serialize...)
 115         if err != nil {
 116                 t.Fatal(err)
 117         }
 118
 119         p := gopacket.NewPacket(buf.Bytes(), LinkTypeRaw, gopacket.Default)
 120         if p.ErrorLayer() != nil {
 121                 t.Fatal("Failed to decode packet:", p.ErrorLayer().Error())
 122         }
 123         checkLayers(p, []gopacket.LayerType{LayerTypeIPv6, LayerTypeIPv6Destination, LayerTypeUDP}, t)
 124
 125         if l, ok := p.Layer(LayerTypeUDP).(*UDP); !ok {
 126                 t.Fatal("No UDP layer type found in packet")
 127         } else {
 128                 u = l
 129         }
 130         got := u.Checksum
 131         want := ipv6UDPChecksumWithIPv6DstOpts
 132         if got != want {
 133                 t.Errorf("Bad checksum:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
 134         }
 135 }
 136
 137 func TestIPv6JumbogramUDPChecksum(t *testing.T) {
 138         var serialize []gopacket.SerializableLayer = make([]gopacket.SerializableLayer, 0, 4)
 139         var u *UDP
 140         var err error
 141
 142         ip6 := &IPv6{}
 143         ip6.Version = 6
 144         ip6.NextHeader = IPProtocolUDP
 145         ip6.HopLimit = 64
 146         ip6.SrcIP = net.ParseIP("2001:db8::1")
 147         ip6.DstIP = net.ParseIP("2001:db8::2")
 148         serialize = append(serialize, ip6)
 149
 150         udp := &UDP{}
 151         udp.SrcPort = UDPPort(12345)
 152         udp.DstPort = UDPPort(9999)
 153         udp.SetNetworkLayerForChecksum(ip6)
 154         serialize = append(serialize, udp)
 155
 156         payload := make([]byte, ipv6MaxPayloadLength+1)
 157         for i := range payload {
 158                 payload[i] = 0xfe
 159         }
 160         serialize = append(serialize, gopacket.Payload(payload))
 161
 162         buf := gopacket.NewSerializeBuffer()
 163         opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
 164         err = gopacket.SerializeLayers(buf, opts, serialize...)
 165         if err != nil {
 166                 t.Fatal(err)
 167         }
 168
 169         p := gopacket.NewPacket(buf.Bytes(), LinkTypeRaw, gopacket.Default)
 170         if p.ErrorLayer() != nil {
 171                 t.Fatal("Failed to decode packet:", p.ErrorLayer().Error())
 172         }
 173         checkLayers(p, []gopacket.LayerType{LayerTypeIPv6, LayerTypeIPv6HopByHop, LayerTypeUDP, gopacket.LayerTypePayload}, t)
 174
 175         if l, ok := p.Layer(LayerTypeUDP).(*UDP); !ok {
 176                 t.Fatal("No UDP layer type found in packet")
 177         } else {
 178                 u = l
 179         }
 180         got := u.Checksum
 181         want := ipv6UDPChecksumJumbogram
 182         if got != want {
 183                 t.Errorf("Bad checksum:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
 184         }
 185 }