github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/net/ipv6/unicast_test.go (about) 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 "bytes" 9 "net" 10 "os" 11 "runtime" 12 "testing" 13 "time" 14 15 "golang.org/x/net/icmp" 16 "golang.org/x/net/internal/iana" 17 "golang.org/x/net/internal/nettest" 18 "golang.org/x/net/ipv6" 19 ) 20 21 func TestPacketConnReadWriteUnicastUDP(t *testing.T) { 22 switch runtime.GOOS { 23 case "nacl", "plan9", "solaris", "windows": 24 t.Skipf("not supported on %s", runtime.GOOS) 25 } 26 if !supportsIPv6 { 27 t.Skip("ipv6 is not supported") 28 } 29 30 c, err := net.ListenPacket("udp6", "[::1]:0") 31 if err != nil { 32 t.Fatal(err) 33 } 34 defer c.Close() 35 p := ipv6.NewPacketConn(c) 36 defer p.Close() 37 38 dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String()) 39 if err != nil { 40 t.Fatal(err) 41 } 42 43 cm := ipv6.ControlMessage{ 44 TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced, 45 Src: net.IPv6loopback, 46 } 47 cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU 48 ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback) 49 if ifi != nil { 50 cm.IfIndex = ifi.Index 51 } 52 wb := []byte("HELLO-R-U-THERE") 53 54 for i, toggle := range []bool{true, false, true} { 55 if err := p.SetControlMessage(cf, toggle); err != nil { 56 if nettest.ProtocolNotSupported(err) { 57 t.Skipf("not supported on %s", runtime.GOOS) 58 } 59 t.Fatal(err) 60 } 61 cm.HopLimit = i + 1 62 if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil { 63 t.Fatal(err) 64 } 65 if n, err := p.WriteTo(wb, &cm, dst); err != nil { 66 t.Fatal(err) 67 } else if n != len(wb) { 68 t.Fatalf("got %v; want %v", n, len(wb)) 69 } 70 rb := make([]byte, 128) 71 if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil { 72 t.Fatal(err) 73 } 74 if n, _, _, err := p.ReadFrom(rb); err != nil { 75 t.Fatal(err) 76 } else if !bytes.Equal(rb[:n], wb) { 77 t.Fatalf("got %v; want %v", rb[:n], wb) 78 } 79 } 80 } 81 82 func TestPacketConnReadWriteUnicastICMP(t *testing.T) { 83 switch runtime.GOOS { 84 case "nacl", "plan9", "solaris", "windows": 85 t.Skipf("not supported on %s", runtime.GOOS) 86 } 87 if !supportsIPv6 { 88 t.Skip("ipv6 is not supported") 89 } 90 if m, ok := nettest.SupportsRawIPSocket(); !ok { 91 t.Skip(m) 92 } 93 94 c, err := net.ListenPacket("ip6:ipv6-icmp", "::1") 95 if err != nil { 96 t.Fatal(err) 97 } 98 defer c.Close() 99 p := ipv6.NewPacketConn(c) 100 defer p.Close() 101 102 dst, err := net.ResolveIPAddr("ip6", "::1") 103 if err != nil { 104 t.Fatal(err) 105 } 106 107 pshicmp := icmp.IPv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, dst.IP) 108 cm := ipv6.ControlMessage{ 109 TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced, 110 Src: net.IPv6loopback, 111 } 112 cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU 113 ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback) 114 if ifi != nil { 115 cm.IfIndex = ifi.Index 116 } 117 118 var f ipv6.ICMPFilter 119 f.SetAll(true) 120 f.Accept(ipv6.ICMPTypeEchoReply) 121 if err := p.SetICMPFilter(&f); err != nil { 122 t.Fatal(err) 123 } 124 125 var psh []byte 126 for i, toggle := range []bool{true, false, true} { 127 if toggle { 128 psh = nil 129 if err := p.SetChecksum(true, 2); err != nil { 130 t.Fatal(err) 131 } 132 } else { 133 psh = pshicmp 134 // Some platforms never allow to disable the 135 // kernel checksum processing. 136 p.SetChecksum(false, -1) 137 } 138 wb, err := (&icmp.Message{ 139 Type: ipv6.ICMPTypeEchoRequest, Code: 0, 140 Body: &icmp.Echo{ 141 ID: os.Getpid() & 0xffff, Seq: i + 1, 142 Data: []byte("HELLO-R-U-THERE"), 143 }, 144 }).Marshal(psh) 145 if err != nil { 146 t.Fatal(err) 147 } 148 if err := p.SetControlMessage(cf, toggle); err != nil { 149 if nettest.ProtocolNotSupported(err) { 150 t.Skipf("not supported on %s", runtime.GOOS) 151 } 152 t.Fatal(err) 153 } 154 cm.HopLimit = i + 1 155 if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil { 156 t.Fatal(err) 157 } 158 if n, err := p.WriteTo(wb, &cm, dst); err != nil { 159 t.Fatal(err) 160 } else if n != len(wb) { 161 t.Fatalf("got %v; want %v", n, len(wb)) 162 } 163 rb := make([]byte, 128) 164 if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil { 165 t.Fatal(err) 166 } 167 if n, _, _, err := p.ReadFrom(rb); err != nil { 168 switch runtime.GOOS { 169 case "darwin": // older darwin kernels have some limitation on receiving icmp packet through raw socket 170 t.Logf("not supported on %s", runtime.GOOS) 171 continue 172 } 173 t.Fatal(err) 174 } else { 175 if m, err := icmp.ParseMessage(iana.ProtocolIPv6ICMP, rb[:n]); err != nil { 176 t.Fatal(err) 177 } else if m.Type != ipv6.ICMPTypeEchoReply || m.Code != 0 { 178 t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0) 179 } 180 } 181 } 182 }