vendor/golang.org/x/net/ipv4/header_test.go

   1 // Copyright 2012 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package ipv4
   6
   7 import (
   8         "bytes"
   9         "encoding/binary"
  10         "net"
  11         "reflect"
  12         "runtime"
  13         "strings"
  14         "testing"
  15
  16         "golang.org/x/net/internal/socket"
  17 )
  18
  19 type headerTest struct {
  20         wireHeaderFromKernel          []byte
  21         wireHeaderToKernel            []byte
  22         wireHeaderFromTradBSDKernel   []byte
  23         wireHeaderToTradBSDKernel     []byte
  24         wireHeaderFromFreeBSD10Kernel []byte
  25         wireHeaderToFreeBSD10Kernel   []byte
  26         *Header
  27 }
  28
  29 var headerLittleEndianTests = []headerTest{
  30         // TODO(mikio): Add platform dependent wire header formats when
  31         // we support new platforms.
  32         {
  33                 wireHeaderFromKernel: []byte{
  34                         0x45, 0x01, 0xbe, 0xef,
  35                         0xca, 0xfe, 0x45, 0xdc,
  36                         0xff, 0x01, 0xde, 0xad,
  37                         172, 16, 254, 254,
  38                         192, 168, 0, 1,
  39                 },
  40                 wireHeaderToKernel: []byte{
  41                         0x45, 0x01, 0xbe, 0xef,
  42                         0xca, 0xfe, 0x45, 0xdc,
  43                         0xff, 0x01, 0xde, 0xad,
  44                         172, 16, 254, 254,
  45                         192, 168, 0, 1,
  46                 },
  47                 wireHeaderFromTradBSDKernel: []byte{
  48                         0x45, 0x01, 0xdb, 0xbe,
  49                         0xca, 0xfe, 0xdc, 0x45,
  50                         0xff, 0x01, 0xde, 0xad,
  51                         172, 16, 254, 254,
  52                         192, 168, 0, 1,
  53                 },
  54                 wireHeaderToTradBSDKernel: []byte{
  55                         0x45, 0x01, 0xef, 0xbe,
  56                         0xca, 0xfe, 0xdc, 0x45,
  57                         0xff, 0x01, 0xde, 0xad,
  58                         172, 16, 254, 254,
  59                         192, 168, 0, 1,
  60                 },
  61                 wireHeaderFromFreeBSD10Kernel: []byte{
  62                         0x45, 0x01, 0xef, 0xbe,
  63                         0xca, 0xfe, 0xdc, 0x45,
  64                         0xff, 0x01, 0xde, 0xad,
  65                         172, 16, 254, 254,
  66                         192, 168, 0, 1,
  67                 },
  68                 wireHeaderToFreeBSD10Kernel: []byte{
  69                         0x45, 0x01, 0xef, 0xbe,
  70                         0xca, 0xfe, 0xdc, 0x45,
  71                         0xff, 0x01, 0xde, 0xad,
  72                         172, 16, 254, 254,
  73                         192, 168, 0, 1,
  74                 },
  75                 Header: &Header{
  76                         Version:  Version,
  77                         Len:      HeaderLen,
  78                         TOS:      1,
  79                         TotalLen: 0xbeef,
  80                         ID:       0xcafe,
  81                         Flags:    DontFragment,
  82                         FragOff:  1500,
  83                         TTL:      255,
  84                         Protocol: 1,
  85                         Checksum: 0xdead,
  86                         Src:      net.IPv4(172, 16, 254, 254),
  87                         Dst:      net.IPv4(192, 168, 0, 1),
  88                 },
  89         },
  90
  91         // with option headers
  92         {
  93                 wireHeaderFromKernel: []byte{
  94                         0x46, 0x01, 0xbe, 0xf3,
  95                         0xca, 0xfe, 0x45, 0xdc,
  96                         0xff, 0x01, 0xde, 0xad,
  97                         172, 16, 254, 254,
  98                         192, 168, 0, 1,
  99                         0xff, 0xfe, 0xfe, 0xff,
 100                 },
 101                 wireHeaderToKernel: []byte{
 102                         0x46, 0x01, 0xbe, 0xf3,
 103                         0xca, 0xfe, 0x45, 0xdc,
 104                         0xff, 0x01, 0xde, 0xad,
 105                         172, 16, 254, 254,
 106                         192, 168, 0, 1,
 107                         0xff, 0xfe, 0xfe, 0xff,
 108                 },
 109                 wireHeaderFromTradBSDKernel: []byte{
 110                         0x46, 0x01, 0xdb, 0xbe,
 111                         0xca, 0xfe, 0xdc, 0x45,
 112                         0xff, 0x01, 0xde, 0xad,
 113                         172, 16, 254, 254,
 114                         192, 168, 0, 1,
 115                         0xff, 0xfe, 0xfe, 0xff,
 116                 },
 117                 wireHeaderToTradBSDKernel: []byte{
 118                         0x46, 0x01, 0xf3, 0xbe,
 119                         0xca, 0xfe, 0xdc, 0x45,
 120                         0xff, 0x01, 0xde, 0xad,
 121                         172, 16, 254, 254,
 122                         192, 168, 0, 1,
 123                         0xff, 0xfe, 0xfe, 0xff,
 124                 },
 125                 wireHeaderFromFreeBSD10Kernel: []byte{
 126                         0x46, 0x01, 0xf3, 0xbe,
 127                         0xca, 0xfe, 0xdc, 0x45,
 128                         0xff, 0x01, 0xde, 0xad,
 129                         172, 16, 254, 254,
 130                         192, 168, 0, 1,
 131                         0xff, 0xfe, 0xfe, 0xff,
 132                 },
 133                 wireHeaderToFreeBSD10Kernel: []byte{
 134                         0x46, 0x01, 0xf3, 0xbe,
 135                         0xca, 0xfe, 0xdc, 0x45,
 136                         0xff, 0x01, 0xde, 0xad,
 137                         172, 16, 254, 254,
 138                         192, 168, 0, 1,
 139                         0xff, 0xfe, 0xfe, 0xff,
 140                 },
 141                 Header: &Header{
 142                         Version:  Version,
 143                         Len:      HeaderLen + 4,
 144                         TOS:      1,
 145                         TotalLen: 0xbef3,
 146                         ID:       0xcafe,
 147                         Flags:    DontFragment,
 148                         FragOff:  1500,
 149                         TTL:      255,
 150                         Protocol: 1,
 151                         Checksum: 0xdead,
 152                         Src:      net.IPv4(172, 16, 254, 254),
 153                         Dst:      net.IPv4(192, 168, 0, 1),
 154                         Options:  []byte{0xff, 0xfe, 0xfe, 0xff},
 155                 },
 156         },
 157 }
 158
 159 func TestMarshalHeader(t *testing.T) {
 160         if socket.NativeEndian != binary.LittleEndian {
 161                 t.Skip("no test for non-little endian machine yet")
 162         }
 163
 164         for _, tt := range headerLittleEndianTests {
 165                 b, err := tt.Header.Marshal()
 166                 if err != nil {
 167                         t.Fatal(err)
 168                 }
 169                 var wh []byte
 170                 switch runtime.GOOS {
 171                 case "darwin", "dragonfly", "netbsd":
 172                         wh = tt.wireHeaderToTradBSDKernel
 173                 case "freebsd":
 174                         switch {
 175                         case freebsdVersion < 1000000:
 176                                 wh = tt.wireHeaderToTradBSDKernel
 177                         case 1000000 <= freebsdVersion && freebsdVersion < 1100000:
 178                                 wh = tt.wireHeaderToFreeBSD10Kernel
 179                         default:
 180                                 wh = tt.wireHeaderToKernel
 181                         }
 182                 default:
 183                         wh = tt.wireHeaderToKernel
 184                 }
 185                 if !bytes.Equal(b, wh) {
 186                         t.Fatalf("got %#v; want %#v", b, wh)
 187                 }
 188         }
 189 }
 190
 191 func TestParseHeader(t *testing.T) {
 192         if socket.NativeEndian != binary.LittleEndian {
 193                 t.Skip("no test for big endian machine yet")
 194         }
 195
 196         for _, tt := range headerLittleEndianTests {
 197                 var wh []byte
 198                 switch runtime.GOOS {
 199                 case "darwin", "dragonfly", "netbsd":
 200                         wh = tt.wireHeaderFromTradBSDKernel
 201                 case "freebsd":
 202                         switch {
 203                         case freebsdVersion < 1000000:
 204                                 wh = tt.wireHeaderFromTradBSDKernel
 205                         case 1000000 <= freebsdVersion && freebsdVersion < 1100000:
 206                                 wh = tt.wireHeaderFromFreeBSD10Kernel
 207                         default:
 208                                 wh = tt.wireHeaderFromKernel
 209                         }
 210                 default:
 211                         wh = tt.wireHeaderFromKernel
 212                 }
 213                 h, err := ParseHeader(wh)
 214                 if err != nil {
 215                         t.Fatal(err)
 216                 }
 217                 if err := h.Parse(wh); err != nil {
 218                         t.Fatal(err)
 219                 }
 220                 if !reflect.DeepEqual(h, tt.Header) {
 221                         t.Fatalf("got %#v; want %#v", h, tt.Header)
 222                 }
 223                 s := h.String()
 224                 if strings.Contains(s, ",") {
 225                         t.Fatalf("should be space-separated values: %s", s)
 226                 }
 227         }
 228 }