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  }