Source file src/net/udpsock_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 net
     6  
     7  import (
     8  	"errors"
     9  	"fmt"
    10  	"internal/testenv"
    11  	"net/netip"
    12  	"os"
    13  	"reflect"
    14  	"runtime"
    15  	"testing"
    16  	"time"
    17  )
    18  
    19  func BenchmarkUDP6LinkLocalUnicast(b *testing.B) {
    20  	testHookUninstaller.Do(uninstallTestHooks)
    21  
    22  	if !supportsIPv6() {
    23  		b.Skip("IPv6 is not supported")
    24  	}
    25  	ifi := loopbackInterface()
    26  	if ifi == nil {
    27  		b.Skip("loopback interface not found")
    28  	}
    29  	lla := ipv6LinkLocalUnicastAddr(ifi)
    30  	if lla == "" {
    31  		b.Skip("IPv6 link-local unicast address not found")
    32  	}
    33  
    34  	c1, err := ListenPacket("udp6", JoinHostPort(lla+"%"+ifi.Name, "0"))
    35  	if err != nil {
    36  		b.Fatal(err)
    37  	}
    38  	defer c1.Close()
    39  	c2, err := ListenPacket("udp6", JoinHostPort(lla+"%"+ifi.Name, "0"))
    40  	if err != nil {
    41  		b.Fatal(err)
    42  	}
    43  	defer c2.Close()
    44  
    45  	var buf [1]byte
    46  	for i := 0; i < b.N; i++ {
    47  		if _, err := c1.WriteTo(buf[:], c2.LocalAddr()); err != nil {
    48  			b.Fatal(err)
    49  		}
    50  		if _, _, err := c2.ReadFrom(buf[:]); err != nil {
    51  			b.Fatal(err)
    52  		}
    53  	}
    54  }
    55  
    56  type resolveUDPAddrTest struct {
    57  	network       string
    58  	litAddrOrName string
    59  	addr          *UDPAddr
    60  	err           error
    61  }
    62  
    63  var resolveUDPAddrTests = []resolveUDPAddrTest{
    64  	{"udp", "127.0.0.1:0", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil},
    65  	{"udp4", "127.0.0.1:65535", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 65535}, nil},
    66  
    67  	{"udp", "[::1]:0", &UDPAddr{IP: ParseIP("::1"), Port: 0}, nil},
    68  	{"udp6", "[::1]:65535", &UDPAddr{IP: ParseIP("::1"), Port: 65535}, nil},
    69  
    70  	{"udp", "[::1%en0]:1", &UDPAddr{IP: ParseIP("::1"), Port: 1, Zone: "en0"}, nil},
    71  	{"udp6", "[::1%911]:2", &UDPAddr{IP: ParseIP("::1"), Port: 2, Zone: "911"}, nil},
    72  
    73  	{"", "127.0.0.1:0", &UDPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil}, // Go 1.0 behavior
    74  	{"", "[::1]:0", &UDPAddr{IP: ParseIP("::1"), Port: 0}, nil},         // Go 1.0 behavior
    75  
    76  	{"udp", ":12345", &UDPAddr{Port: 12345}, nil},
    77  
    78  	{"http", "127.0.0.1:0", nil, UnknownNetworkError("http")},
    79  
    80  	{"udp", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
    81  	{"udp", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("::ffff:127.0.0.1"), Port: 53}, nil},
    82  	{"udp", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
    83  	{"udp4", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
    84  	{"udp4", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
    85  	{"udp6", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
    86  
    87  	{"udp4", "[2001:db8::1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
    88  	{"udp6", "127.0.0.1:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
    89  	{"udp6", "[::ffff:127.0.0.1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
    90  }
    91  
    92  func TestResolveUDPAddr(t *testing.T) {
    93  	origTestHookLookupIP := testHookLookupIP
    94  	defer func() { testHookLookupIP = origTestHookLookupIP }()
    95  	testHookLookupIP = lookupLocalhost
    96  
    97  	for _, tt := range resolveUDPAddrTests {
    98  		addr, err := ResolveUDPAddr(tt.network, tt.litAddrOrName)
    99  		if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
   100  			t.Errorf("ResolveUDPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
   101  			continue
   102  		}
   103  		if err == nil {
   104  			addr2, err := ResolveUDPAddr(addr.Network(), addr.String())
   105  			if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
   106  				t.Errorf("(%q, %q): ResolveUDPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
   107  			}
   108  		}
   109  	}
   110  }
   111  
   112  func TestWriteToUDP(t *testing.T) {
   113  	switch runtime.GOOS {
   114  	case "plan9":
   115  		t.Skipf("not supported on %s", runtime.GOOS)
   116  	}
   117  
   118  	if !testableNetwork("udp") {
   119  		t.Skipf("skipping: udp not supported")
   120  	}
   121  
   122  	c, err := ListenPacket("udp", "127.0.0.1:0")
   123  	if err != nil {
   124  		t.Fatal(err)
   125  	}
   126  	defer c.Close()
   127  
   128  	testWriteToConn(t, c.LocalAddr().String())
   129  	testWriteToPacketConn(t, c.LocalAddr().String())
   130  }
   131  
   132  func testWriteToConn(t *testing.T, raddr string) {
   133  	c, err := Dial("udp", raddr)
   134  	if err != nil {
   135  		t.Fatal(err)
   136  	}
   137  	defer c.Close()
   138  
   139  	ra, err := ResolveUDPAddr("udp", raddr)
   140  	if err != nil {
   141  		t.Fatal(err)
   142  	}
   143  
   144  	b := []byte("CONNECTED-MODE SOCKET")
   145  	_, err = c.(*UDPConn).WriteToUDP(b, ra)
   146  	if err == nil {
   147  		t.Fatal("should fail")
   148  	}
   149  	if err != nil && err.(*OpError).Err != ErrWriteToConnected {
   150  		t.Fatalf("should fail as ErrWriteToConnected: %v", err)
   151  	}
   152  	_, err = c.(*UDPConn).WriteTo(b, ra)
   153  	if err == nil {
   154  		t.Fatal("should fail")
   155  	}
   156  	if err != nil && err.(*OpError).Err != ErrWriteToConnected {
   157  		t.Fatalf("should fail as ErrWriteToConnected: %v", err)
   158  	}
   159  	_, err = c.Write(b)
   160  	if err != nil {
   161  		t.Fatal(err)
   162  	}
   163  	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
   164  	if err == nil {
   165  		t.Fatal("should fail")
   166  	}
   167  	if err != nil && err.(*OpError).Err != ErrWriteToConnected {
   168  		t.Fatalf("should fail as ErrWriteToConnected: %v", err)
   169  	}
   170  	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
   171  	if err != nil {
   172  		t.Fatal(err)
   173  	}
   174  }
   175  
   176  func testWriteToPacketConn(t *testing.T, raddr string) {
   177  	c, err := ListenPacket("udp", "127.0.0.1:0")
   178  	if err != nil {
   179  		t.Fatal(err)
   180  	}
   181  	defer c.Close()
   182  
   183  	ra, err := ResolveUDPAddr("udp", raddr)
   184  	if err != nil {
   185  		t.Fatal(err)
   186  	}
   187  
   188  	b := []byte("UNCONNECTED-MODE SOCKET")
   189  	_, err = c.(*UDPConn).WriteToUDP(b, ra)
   190  	if err != nil {
   191  		t.Fatal(err)
   192  	}
   193  	_, err = c.WriteTo(b, ra)
   194  	if err != nil {
   195  		t.Fatal(err)
   196  	}
   197  	_, err = c.(*UDPConn).Write(b)
   198  	if err == nil {
   199  		t.Fatal("should fail")
   200  	}
   201  	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, nil)
   202  	if err == nil {
   203  		t.Fatal("should fail")
   204  	}
   205  	if err != nil && err.(*OpError).Err != errMissingAddress {
   206  		t.Fatalf("should fail as errMissingAddress: %v", err)
   207  	}
   208  	_, _, err = c.(*UDPConn).WriteMsgUDP(b, nil, ra)
   209  	if err != nil {
   210  		t.Fatal(err)
   211  	}
   212  }
   213  
   214  var udpConnLocalNameTests = []struct {
   215  	net   string
   216  	laddr *UDPAddr
   217  }{
   218  	{"udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)}},
   219  	{"udp4", &UDPAddr{}},
   220  	{"udp4", nil},
   221  }
   222  
   223  func TestUDPConnLocalName(t *testing.T) {
   224  	testenv.MustHaveExternalNetwork(t)
   225  
   226  	for _, tt := range udpConnLocalNameTests {
   227  		t.Run(fmt.Sprint(tt.laddr), func(t *testing.T) {
   228  			if !testableNetwork(tt.net) {
   229  				t.Skipf("skipping: %s not available", tt.net)
   230  			}
   231  
   232  			c, err := ListenUDP(tt.net, tt.laddr)
   233  			if err != nil {
   234  				t.Fatal(err)
   235  			}
   236  			defer c.Close()
   237  			la := c.LocalAddr()
   238  			if a, ok := la.(*UDPAddr); !ok || a.Port == 0 {
   239  				t.Fatalf("got %v; expected a proper address with non-zero port number", la)
   240  			}
   241  		})
   242  	}
   243  }
   244  
   245  func TestUDPConnLocalAndRemoteNames(t *testing.T) {
   246  	if !testableNetwork("udp") {
   247  		t.Skipf("skipping: udp not available")
   248  	}
   249  
   250  	for _, laddr := range []string{"", "127.0.0.1:0"} {
   251  		c1, err := ListenPacket("udp", "127.0.0.1:0")
   252  		if err != nil {
   253  			t.Fatal(err)
   254  		}
   255  		defer c1.Close()
   256  
   257  		var la *UDPAddr
   258  		if laddr != "" {
   259  			var err error
   260  			if la, err = ResolveUDPAddr("udp", laddr); err != nil {
   261  				t.Fatal(err)
   262  			}
   263  		}
   264  		c2, err := DialUDP("udp", la, c1.LocalAddr().(*UDPAddr))
   265  		if err != nil {
   266  			t.Fatal(err)
   267  		}
   268  		defer c2.Close()
   269  
   270  		var connAddrs = [4]struct {
   271  			got Addr
   272  			ok  bool
   273  		}{
   274  			{c1.LocalAddr(), true},
   275  			{c1.(*UDPConn).RemoteAddr(), false},
   276  			{c2.LocalAddr(), true},
   277  			{c2.RemoteAddr(), true},
   278  		}
   279  		for _, ca := range connAddrs {
   280  			if a, ok := ca.got.(*UDPAddr); ok != ca.ok || ok && a.Port == 0 {
   281  				t.Fatalf("got %v; expected a proper address with non-zero port number", ca.got)
   282  			}
   283  		}
   284  	}
   285  }
   286  
   287  func TestIPv6LinkLocalUnicastUDP(t *testing.T) {
   288  	testenv.MustHaveExternalNetwork(t)
   289  
   290  	if !supportsIPv6() {
   291  		t.Skip("IPv6 is not supported")
   292  	}
   293  
   294  	for i, tt := range ipv6LinkLocalUnicastUDPTests {
   295  		c1, err := ListenPacket(tt.network, tt.address)
   296  		if err != nil {
   297  			// It might return "LookupHost returned no
   298  			// suitable address" error on some platforms.
   299  			t.Log(err)
   300  			continue
   301  		}
   302  		ls := (&packetListener{PacketConn: c1}).newLocalServer()
   303  		defer ls.teardown()
   304  		ch := make(chan error, 1)
   305  		handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, ch) }
   306  		if err := ls.buildup(handler); err != nil {
   307  			t.Fatal(err)
   308  		}
   309  		if la, ok := c1.LocalAddr().(*UDPAddr); !ok || !tt.nameLookup && la.Zone == "" {
   310  			t.Fatalf("got %v; expected a proper address with zone identifier", la)
   311  		}
   312  
   313  		c2, err := Dial(tt.network, ls.PacketConn.LocalAddr().String())
   314  		if err != nil {
   315  			t.Fatal(err)
   316  		}
   317  		defer c2.Close()
   318  		if la, ok := c2.LocalAddr().(*UDPAddr); !ok || !tt.nameLookup && la.Zone == "" {
   319  			t.Fatalf("got %v; expected a proper address with zone identifier", la)
   320  		}
   321  		if ra, ok := c2.RemoteAddr().(*UDPAddr); !ok || !tt.nameLookup && ra.Zone == "" {
   322  			t.Fatalf("got %v; expected a proper address with zone identifier", ra)
   323  		}
   324  
   325  		if _, err := c2.Write([]byte("UDP OVER IPV6 LINKLOCAL TEST")); err != nil {
   326  			t.Fatal(err)
   327  		}
   328  		b := make([]byte, 32)
   329  		if _, err := c2.Read(b); err != nil {
   330  			t.Fatal(err)
   331  		}
   332  
   333  		for err := range ch {
   334  			t.Errorf("#%d: %v", i, err)
   335  		}
   336  	}
   337  }
   338  
   339  func TestUDPZeroBytePayload(t *testing.T) {
   340  	switch runtime.GOOS {
   341  	case "plan9":
   342  		t.Skipf("not supported on %s", runtime.GOOS)
   343  	case "darwin", "ios":
   344  		testenv.SkipFlaky(t, 29225)
   345  	}
   346  	if !testableNetwork("udp") {
   347  		t.Skipf("skipping: udp not available")
   348  	}
   349  
   350  	c := newLocalPacketListener(t, "udp")
   351  	defer c.Close()
   352  
   353  	for _, genericRead := range []bool{false, true} {
   354  		n, err := c.WriteTo(nil, c.LocalAddr())
   355  		if err != nil {
   356  			t.Fatal(err)
   357  		}
   358  		if n != 0 {
   359  			t.Errorf("got %d; want 0", n)
   360  		}
   361  		c.SetReadDeadline(time.Now().Add(30 * time.Second))
   362  		var b [1]byte
   363  		var name string
   364  		if genericRead {
   365  			_, err = c.(Conn).Read(b[:])
   366  			name = "Read"
   367  		} else {
   368  			_, _, err = c.ReadFrom(b[:])
   369  			name = "ReadFrom"
   370  		}
   371  		if err != nil {
   372  			t.Errorf("%s of zero byte packet failed: %v", name, err)
   373  		}
   374  	}
   375  }
   376  
   377  func TestUDPZeroByteBuffer(t *testing.T) {
   378  	switch runtime.GOOS {
   379  	case "plan9":
   380  		t.Skipf("not supported on %s", runtime.GOOS)
   381  	}
   382  	if !testableNetwork("udp") {
   383  		t.Skipf("skipping: udp not available")
   384  	}
   385  
   386  	c := newLocalPacketListener(t, "udp")
   387  	defer c.Close()
   388  
   389  	b := []byte("UDP ZERO BYTE BUFFER TEST")
   390  	for _, genericRead := range []bool{false, true} {
   391  		n, err := c.WriteTo(b, c.LocalAddr())
   392  		if err != nil {
   393  			t.Fatal(err)
   394  		}
   395  		if n != len(b) {
   396  			t.Errorf("got %d; want %d", n, len(b))
   397  		}
   398  		c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
   399  		if genericRead {
   400  			_, err = c.(Conn).Read(nil)
   401  		} else {
   402  			_, _, err = c.ReadFrom(nil)
   403  		}
   404  		switch err {
   405  		case nil: // ReadFrom succeeds
   406  		default: // Read may timeout, it depends on the platform
   407  			if nerr, ok := err.(Error); (!ok || !nerr.Timeout()) && runtime.GOOS != "windows" { // Windows returns WSAEMSGSIZE
   408  				t.Fatal(err)
   409  			}
   410  		}
   411  	}
   412  }
   413  
   414  func TestUDPReadSizeError(t *testing.T) {
   415  	switch runtime.GOOS {
   416  	case "plan9":
   417  		t.Skipf("not supported on %s", runtime.GOOS)
   418  	}
   419  	if !testableNetwork("udp") {
   420  		t.Skipf("skipping: udp not available")
   421  	}
   422  
   423  	c1 := newLocalPacketListener(t, "udp")
   424  	defer c1.Close()
   425  
   426  	c2, err := Dial("udp", c1.LocalAddr().String())
   427  	if err != nil {
   428  		t.Fatal(err)
   429  	}
   430  	defer c2.Close()
   431  
   432  	b1 := []byte("READ SIZE ERROR TEST")
   433  	for _, genericRead := range []bool{false, true} {
   434  		n, err := c2.Write(b1)
   435  		if err != nil {
   436  			t.Fatal(err)
   437  		}
   438  		if n != len(b1) {
   439  			t.Errorf("got %d; want %d", n, len(b1))
   440  		}
   441  		b2 := make([]byte, len(b1)-1)
   442  		if genericRead {
   443  			n, err = c1.(Conn).Read(b2)
   444  		} else {
   445  			n, _, err = c1.ReadFrom(b2)
   446  		}
   447  		if err != nil && runtime.GOOS != "windows" { // Windows returns WSAEMSGSIZE
   448  			t.Fatal(err)
   449  		}
   450  		if n != len(b1)-1 {
   451  			t.Fatalf("got %d; want %d", n, len(b1)-1)
   452  		}
   453  	}
   454  }
   455  
   456  // TestUDPReadTimeout verifies that ReadFromUDP with timeout returns an error
   457  // without data or an address.
   458  func TestUDPReadTimeout(t *testing.T) {
   459  	if !testableNetwork("udp4") {
   460  		t.Skipf("skipping: udp4 not available")
   461  	}
   462  
   463  	la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
   464  	if err != nil {
   465  		t.Fatal(err)
   466  	}
   467  	c, err := ListenUDP("udp4", la)
   468  	if err != nil {
   469  		t.Fatal(err)
   470  	}
   471  	defer c.Close()
   472  
   473  	c.SetDeadline(time.Now())
   474  	b := make([]byte, 1)
   475  	n, addr, err := c.ReadFromUDP(b)
   476  	if !errors.Is(err, os.ErrDeadlineExceeded) {
   477  		t.Errorf("ReadFromUDP got err %v want os.ErrDeadlineExceeded", err)
   478  	}
   479  	if n != 0 {
   480  		t.Errorf("ReadFromUDP got n %d want 0", n)
   481  	}
   482  	if addr != nil {
   483  		t.Errorf("ReadFromUDP got addr %+#v want nil", addr)
   484  	}
   485  }
   486  
   487  func TestAllocs(t *testing.T) {
   488  	switch runtime.GOOS {
   489  	case "plan9", "js", "wasip1":
   490  		// These implementations have not been optimized.
   491  		t.Skipf("skipping on %v", runtime.GOOS)
   492  	}
   493  	if !testableNetwork("udp4") {
   494  		t.Skipf("skipping: udp4 not available")
   495  	}
   496  
   497  	// Optimizations are required to remove the allocs.
   498  	testenv.SkipIfOptimizationOff(t)
   499  
   500  	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
   501  	if err != nil {
   502  		t.Fatal(err)
   503  	}
   504  	defer conn.Close()
   505  	addr := conn.LocalAddr()
   506  	addrPort := addr.(*UDPAddr).AddrPort()
   507  	buf := make([]byte, 8)
   508  
   509  	allocs := testing.AllocsPerRun(1000, func() {
   510  		_, _, err := conn.WriteMsgUDPAddrPort(buf, nil, addrPort)
   511  		if err != nil {
   512  			t.Fatal(err)
   513  		}
   514  		_, _, _, _, err = conn.ReadMsgUDPAddrPort(buf, nil)
   515  		if err != nil {
   516  			t.Fatal(err)
   517  		}
   518  	})
   519  	if got := int(allocs); got != 0 {
   520  		t.Errorf("WriteMsgUDPAddrPort/ReadMsgUDPAddrPort allocated %d objects", got)
   521  	}
   522  
   523  	allocs = testing.AllocsPerRun(1000, func() {
   524  		_, err := conn.WriteToUDPAddrPort(buf, addrPort)
   525  		if err != nil {
   526  			t.Fatal(err)
   527  		}
   528  		_, _, err = conn.ReadFromUDPAddrPort(buf)
   529  		if err != nil {
   530  			t.Fatal(err)
   531  		}
   532  	})
   533  	if got := int(allocs); got != 0 {
   534  		t.Errorf("WriteToUDPAddrPort/ReadFromUDPAddrPort allocated %d objects", got)
   535  	}
   536  
   537  	allocs = testing.AllocsPerRun(1000, func() {
   538  		_, err := conn.WriteTo(buf, addr)
   539  		if err != nil {
   540  			t.Fatal(err)
   541  		}
   542  		_, _, err = conn.ReadFromUDP(buf)
   543  		if err != nil {
   544  			t.Fatal(err)
   545  		}
   546  	})
   547  	if got := int(allocs); got != 1 {
   548  		t.Errorf("WriteTo/ReadFromUDP allocated %d objects", got)
   549  	}
   550  }
   551  
   552  func BenchmarkReadWriteMsgUDPAddrPort(b *testing.B) {
   553  	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
   554  	if err != nil {
   555  		b.Fatal(err)
   556  	}
   557  	defer conn.Close()
   558  	addr := conn.LocalAddr().(*UDPAddr).AddrPort()
   559  	buf := make([]byte, 8)
   560  	b.ResetTimer()
   561  	b.ReportAllocs()
   562  	for i := 0; i < b.N; i++ {
   563  		_, _, err := conn.WriteMsgUDPAddrPort(buf, nil, addr)
   564  		if err != nil {
   565  			b.Fatal(err)
   566  		}
   567  		_, _, _, _, err = conn.ReadMsgUDPAddrPort(buf, nil)
   568  		if err != nil {
   569  			b.Fatal(err)
   570  		}
   571  	}
   572  }
   573  
   574  func BenchmarkWriteToReadFromUDP(b *testing.B) {
   575  	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
   576  	if err != nil {
   577  		b.Fatal(err)
   578  	}
   579  	defer conn.Close()
   580  	addr := conn.LocalAddr()
   581  	buf := make([]byte, 8)
   582  	b.ResetTimer()
   583  	b.ReportAllocs()
   584  	for i := 0; i < b.N; i++ {
   585  		_, err := conn.WriteTo(buf, addr)
   586  		if err != nil {
   587  			b.Fatal(err)
   588  		}
   589  		_, _, err = conn.ReadFromUDP(buf)
   590  		if err != nil {
   591  			b.Fatal(err)
   592  		}
   593  	}
   594  }
   595  
   596  func BenchmarkWriteToReadFromUDPAddrPort(b *testing.B) {
   597  	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
   598  	if err != nil {
   599  		b.Fatal(err)
   600  	}
   601  	defer conn.Close()
   602  	addr := conn.LocalAddr().(*UDPAddr).AddrPort()
   603  	buf := make([]byte, 8)
   604  	b.ResetTimer()
   605  	b.ReportAllocs()
   606  	for i := 0; i < b.N; i++ {
   607  		_, err := conn.WriteToUDPAddrPort(buf, addr)
   608  		if err != nil {
   609  			b.Fatal(err)
   610  		}
   611  		_, _, err = conn.ReadFromUDPAddrPort(buf)
   612  		if err != nil {
   613  			b.Fatal(err)
   614  		}
   615  	}
   616  }
   617  
   618  func TestUDPIPVersionReadMsg(t *testing.T) {
   619  	switch runtime.GOOS {
   620  	case "plan9":
   621  		t.Skipf("skipping on %v", runtime.GOOS)
   622  	}
   623  	if !testableNetwork("udp4") {
   624  		t.Skipf("skipping: udp4 not available")
   625  	}
   626  
   627  	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
   628  	if err != nil {
   629  		t.Fatal(err)
   630  	}
   631  	defer conn.Close()
   632  	daddr := conn.LocalAddr().(*UDPAddr).AddrPort()
   633  	buf := make([]byte, 8)
   634  	_, err = conn.WriteToUDPAddrPort(buf, daddr)
   635  	if err != nil {
   636  		t.Fatal(err)
   637  	}
   638  	_, _, _, saddr, err := conn.ReadMsgUDPAddrPort(buf, nil)
   639  	if err != nil {
   640  		t.Fatal(err)
   641  	}
   642  	if !saddr.Addr().Is4() {
   643  		t.Error("returned AddrPort is not IPv4")
   644  	}
   645  	_, err = conn.WriteToUDPAddrPort(buf, daddr)
   646  	if err != nil {
   647  		t.Fatal(err)
   648  	}
   649  	_, _, _, soldaddr, err := conn.ReadMsgUDP(buf, nil)
   650  	if err != nil {
   651  		t.Fatal(err)
   652  	}
   653  	if len(soldaddr.IP) != 4 {
   654  		t.Error("returned UDPAddr is not IPv4")
   655  	}
   656  }
   657  
   658  // TestIPv6WriteMsgUDPAddrPortTargetAddrIPVersion verifies that
   659  // WriteMsgUDPAddrPort accepts IPv4, IPv4-mapped IPv6, and IPv6 target addresses
   660  // on a UDPConn listening on "::".
   661  func TestIPv6WriteMsgUDPAddrPortTargetAddrIPVersion(t *testing.T) {
   662  	if !testableNetwork("udp4") {
   663  		t.Skipf("skipping: udp4 not available")
   664  	}
   665  	if !testableNetwork("udp6") {
   666  		t.Skipf("skipping: udp6 not available")
   667  	}
   668  
   669  	switch runtime.GOOS {
   670  	case "dragonfly", "openbsd":
   671  		// DragonflyBSD's IPv6 sockets are always IPv6-only, according to the man page:
   672  		// https://www.dragonflybsd.org/cgi/web-man?command=ip6 (search for IPV6_V6ONLY).
   673  		// OpenBSD's IPv6 sockets are always IPv6-only, according to the man page:
   674  		// https://man.openbsd.org/ip6#IPV6_V6ONLY
   675  		t.Skipf("skipping on %v", runtime.GOOS)
   676  	}
   677  
   678  	conn, err := ListenUDP("udp", nil)
   679  	if err != nil {
   680  		t.Fatal(err)
   681  	}
   682  	defer conn.Close()
   683  
   684  	daddr4 := netip.AddrPortFrom(netip.MustParseAddr("127.0.0.1"), 12345)
   685  	daddr4in6 := netip.AddrPortFrom(netip.MustParseAddr("::ffff:127.0.0.1"), 12345)
   686  	daddr6 := netip.AddrPortFrom(netip.MustParseAddr("::1"), 12345)
   687  	buf := make([]byte, 8)
   688  
   689  	_, _, err = conn.WriteMsgUDPAddrPort(buf, nil, daddr4)
   690  	if err != nil {
   691  		t.Fatal(err)
   692  	}
   693  
   694  	_, _, err = conn.WriteMsgUDPAddrPort(buf, nil, daddr4in6)
   695  	if err != nil {
   696  		t.Fatal(err)
   697  	}
   698  
   699  	_, _, err = conn.WriteMsgUDPAddrPort(buf, nil, daddr6)
   700  	if err != nil {
   701  		t.Fatal(err)
   702  	}
   703  }
   704  

View as plain text