vendor/golang.org/x/net/ipv6/sockopt_test.go

   1 // Copyright 2013 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 ipv6_test
   6
   7 import (
   8         "fmt"
   9         "net"
  10         "runtime"
  11         "testing"
  12
  13         "golang.org/x/net/internal/iana"
  14         "golang.org/x/net/internal/nettest"
  15         "golang.org/x/net/ipv6"
  16 )
  17
  18 var supportsIPv6 bool = nettest.SupportsIPv6()
  19
  20 func TestConnInitiatorPathMTU(t *testing.T) {
  21         switch runtime.GOOS {
  22         case "nacl", "plan9", "windows":
  23                 t.Skipf("not supported on %s", runtime.GOOS)
  24         }
  25         if !supportsIPv6 {
  26                 t.Skip("ipv6 is not supported")
  27         }
  28
  29         ln, err := net.Listen("tcp6", "[::1]:0")
  30         if err != nil {
  31                 t.Fatal(err)
  32         }
  33         defer ln.Close()
  34
  35         done := make(chan bool)
  36         go acceptor(t, ln, done)
  37
  38         c, err := net.Dial("tcp6", ln.Addr().String())
  39         if err != nil {
  40                 t.Fatal(err)
  41         }
  42         defer c.Close()
  43
  44         if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
  45                 switch runtime.GOOS {
  46                 case "darwin": // older darwin kernels don't support IPV6_PATHMTU option
  47                         t.Logf("not supported on %s", runtime.GOOS)
  48                 default:
  49                         t.Fatal(err)
  50                 }
  51         } else {
  52                 t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
  53         }
  54
  55         <-done
  56 }
  57
  58 func TestConnResponderPathMTU(t *testing.T) {
  59         switch runtime.GOOS {
  60         case "nacl", "plan9", "windows":
  61                 t.Skipf("not supported on %s", runtime.GOOS)
  62         }
  63         if !supportsIPv6 {
  64                 t.Skip("ipv6 is not supported")
  65         }
  66
  67         ln, err := net.Listen("tcp6", "[::1]:0")
  68         if err != nil {
  69                 t.Fatal(err)
  70         }
  71         defer ln.Close()
  72
  73         done := make(chan bool)
  74         go connector(t, "tcp6", ln.Addr().String(), done)
  75
  76         c, err := ln.Accept()
  77         if err != nil {
  78                 t.Fatal(err)
  79         }
  80         defer c.Close()
  81
  82         if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
  83                 switch runtime.GOOS {
  84                 case "darwin": // older darwin kernels don't support IPV6_PATHMTU option
  85                         t.Logf("not supported on %s", runtime.GOOS)
  86                 default:
  87                         t.Fatal(err)
  88                 }
  89         } else {
  90                 t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
  91         }
  92
  93         <-done
  94 }
  95
  96 func TestPacketConnChecksum(t *testing.T) {
  97         switch runtime.GOOS {
  98         case "nacl", "plan9", "windows":
  99                 t.Skipf("not supported on %s", runtime.GOOS)
 100         }
 101         if !supportsIPv6 {
 102                 t.Skip("ipv6 is not supported")
 103         }
 104         if m, ok := nettest.SupportsRawIPSocket(); !ok {
 105                 t.Skip(m)
 106         }
 107
 108         c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolOSPFIGP), "::") // OSPF for IPv6
 109         if err != nil {
 110                 t.Fatal(err)
 111         }
 112         defer c.Close()
 113
 114         p := ipv6.NewPacketConn(c)
 115         offset := 12 // see RFC 5340
 116
 117         for _, toggle := range []bool{false, true} {
 118                 if err := p.SetChecksum(toggle, offset); err != nil {
 119                         if toggle {
 120                                 t.Fatalf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
 121                         } else {
 122                                 // Some platforms never allow to disable the kernel
 123                                 // checksum processing.
 124                                 t.Logf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
 125                         }
 126                 }
 127                 if on, offset, err := p.Checksum(); err != nil {
 128                         t.Fatal(err)
 129                 } else {
 130                         t.Logf("kernel checksum processing enabled=%v, offset=%v", on, offset)
 131                 }
 132         }
 133 }