...
Run Format

Source file src/net/unixsock_test.go

Documentation: net

     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  // +build !nacl,!plan9,!windows
     6  
     7  package net
     8  
     9  import (
    10  	"bytes"
    11  	"internal/testenv"
    12  	"io/ioutil"
    13  	"os"
    14  	"reflect"
    15  	"runtime"
    16  	"syscall"
    17  	"testing"
    18  	"time"
    19  )
    20  
    21  func TestReadUnixgramWithUnnamedSocket(t *testing.T) {
    22  	if !testableNetwork("unixgram") {
    23  		t.Skip("unixgram test")
    24  	}
    25  	if runtime.GOOS == "openbsd" {
    26  		testenv.SkipFlaky(t, 15157)
    27  	}
    28  
    29  	addr := testUnixAddr()
    30  	la, err := ResolveUnixAddr("unixgram", addr)
    31  	if err != nil {
    32  		t.Fatal(err)
    33  	}
    34  	c, err := ListenUnixgram("unixgram", la)
    35  	if err != nil {
    36  		t.Fatal(err)
    37  	}
    38  	defer func() {
    39  		c.Close()
    40  		os.Remove(addr)
    41  	}()
    42  
    43  	off := make(chan bool)
    44  	data := [5]byte{1, 2, 3, 4, 5}
    45  	go func() {
    46  		defer func() { off <- true }()
    47  		s, err := syscall.Socket(syscall.AF_UNIX, syscall.SOCK_DGRAM, 0)
    48  		if err != nil {
    49  			t.Error(err)
    50  			return
    51  		}
    52  		defer syscall.Close(s)
    53  		rsa := &syscall.SockaddrUnix{Name: addr}
    54  		if err := syscall.Sendto(s, data[:], 0, rsa); err != nil {
    55  			t.Error(err)
    56  			return
    57  		}
    58  	}()
    59  
    60  	<-off
    61  	b := make([]byte, 64)
    62  	c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
    63  	n, from, err := c.ReadFrom(b)
    64  	if err != nil {
    65  		t.Fatal(err)
    66  	}
    67  	if from != nil {
    68  		t.Fatalf("unexpected peer address: %v", from)
    69  	}
    70  	if !bytes.Equal(b[:n], data[:]) {
    71  		t.Fatalf("got %v; want %v", b[:n], data[:])
    72  	}
    73  }
    74  
    75  func TestUnixgramZeroBytePayload(t *testing.T) {
    76  	if !testableNetwork("unixgram") {
    77  		t.Skip("unixgram test")
    78  	}
    79  
    80  	c1, err := newLocalPacketListener("unixgram")
    81  	if err != nil {
    82  		t.Fatal(err)
    83  	}
    84  	defer os.Remove(c1.LocalAddr().String())
    85  	defer c1.Close()
    86  
    87  	c2, err := Dial("unixgram", c1.LocalAddr().String())
    88  	if err != nil {
    89  		t.Fatal(err)
    90  	}
    91  	defer os.Remove(c2.LocalAddr().String())
    92  	defer c2.Close()
    93  
    94  	for _, genericRead := range []bool{false, true} {
    95  		n, err := c2.Write(nil)
    96  		if err != nil {
    97  			t.Fatal(err)
    98  		}
    99  		if n != 0 {
   100  			t.Errorf("got %d; want 0", n)
   101  		}
   102  		c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
   103  		var b [1]byte
   104  		var peer Addr
   105  		if genericRead {
   106  			_, err = c1.(Conn).Read(b[:])
   107  		} else {
   108  			_, peer, err = c1.ReadFrom(b[:])
   109  		}
   110  		switch err {
   111  		case nil: // ReadFrom succeeds
   112  			if peer != nil { // peer is connected-mode
   113  				t.Fatalf("unexpected peer address: %v", peer)
   114  			}
   115  		default: // Read may timeout, it depends on the platform
   116  			if nerr, ok := err.(Error); !ok || !nerr.Timeout() {
   117  				t.Fatal(err)
   118  			}
   119  		}
   120  	}
   121  }
   122  
   123  func TestUnixgramZeroByteBuffer(t *testing.T) {
   124  	if !testableNetwork("unixgram") {
   125  		t.Skip("unixgram test")
   126  	}
   127  	// issue 4352: Recvfrom failed with "address family not
   128  	// supported by protocol family" if zero-length buffer provided
   129  
   130  	c1, err := newLocalPacketListener("unixgram")
   131  	if err != nil {
   132  		t.Fatal(err)
   133  	}
   134  	defer os.Remove(c1.LocalAddr().String())
   135  	defer c1.Close()
   136  
   137  	c2, err := Dial("unixgram", c1.LocalAddr().String())
   138  	if err != nil {
   139  		t.Fatal(err)
   140  	}
   141  	defer os.Remove(c2.LocalAddr().String())
   142  	defer c2.Close()
   143  
   144  	b := []byte("UNIXGRAM ZERO BYTE BUFFER TEST")
   145  	for _, genericRead := range []bool{false, true} {
   146  		n, err := c2.Write(b)
   147  		if err != nil {
   148  			t.Fatal(err)
   149  		}
   150  		if n != len(b) {
   151  			t.Errorf("got %d; want %d", n, len(b))
   152  		}
   153  		c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
   154  		var peer Addr
   155  		if genericRead {
   156  			_, err = c1.(Conn).Read(nil)
   157  		} else {
   158  			_, peer, err = c1.ReadFrom(nil)
   159  		}
   160  		switch err {
   161  		case nil: // ReadFrom succeeds
   162  			if peer != nil { // peer is connected-mode
   163  				t.Fatalf("unexpected peer address: %v", peer)
   164  			}
   165  		default: // Read may timeout, it depends on the platform
   166  			if nerr, ok := err.(Error); !ok || !nerr.Timeout() {
   167  				t.Fatal(err)
   168  			}
   169  		}
   170  	}
   171  }
   172  
   173  func TestUnixgramWrite(t *testing.T) {
   174  	if !testableNetwork("unixgram") {
   175  		t.Skip("unixgram test")
   176  	}
   177  
   178  	addr := testUnixAddr()
   179  	laddr, err := ResolveUnixAddr("unixgram", addr)
   180  	if err != nil {
   181  		t.Fatal(err)
   182  	}
   183  	c, err := ListenPacket("unixgram", addr)
   184  	if err != nil {
   185  		t.Fatal(err)
   186  	}
   187  	defer os.Remove(addr)
   188  	defer c.Close()
   189  
   190  	testUnixgramWriteConn(t, laddr)
   191  	testUnixgramWritePacketConn(t, laddr)
   192  }
   193  
   194  func testUnixgramWriteConn(t *testing.T, raddr *UnixAddr) {
   195  	c, err := Dial("unixgram", raddr.String())
   196  	if err != nil {
   197  		t.Fatal(err)
   198  	}
   199  	defer c.Close()
   200  
   201  	b := []byte("CONNECTED-MODE SOCKET")
   202  	if _, err := c.(*UnixConn).WriteToUnix(b, raddr); err == nil {
   203  		t.Fatal("should fail")
   204  	} else if err.(*OpError).Err != ErrWriteToConnected {
   205  		t.Fatalf("should fail as ErrWriteToConnected: %v", err)
   206  	}
   207  	if _, err = c.(*UnixConn).WriteTo(b, raddr); err == nil {
   208  		t.Fatal("should fail")
   209  	} else if err.(*OpError).Err != ErrWriteToConnected {
   210  		t.Fatalf("should fail as ErrWriteToConnected: %v", err)
   211  	}
   212  	if _, _, err = c.(*UnixConn).WriteMsgUnix(b, nil, raddr); err == nil {
   213  		t.Fatal("should fail")
   214  	} else if err.(*OpError).Err != ErrWriteToConnected {
   215  		t.Fatalf("should fail as ErrWriteToConnected: %v", err)
   216  	}
   217  	if _, err := c.Write(b); err != nil {
   218  		t.Fatal(err)
   219  	}
   220  }
   221  
   222  func testUnixgramWritePacketConn(t *testing.T, raddr *UnixAddr) {
   223  	addr := testUnixAddr()
   224  	c, err := ListenPacket("unixgram", addr)
   225  	if err != nil {
   226  		t.Fatal(err)
   227  	}
   228  	defer os.Remove(addr)
   229  	defer c.Close()
   230  
   231  	b := []byte("UNCONNECTED-MODE SOCKET")
   232  	if _, err := c.(*UnixConn).WriteToUnix(b, raddr); err != nil {
   233  		t.Fatal(err)
   234  	}
   235  	if _, err := c.WriteTo(b, raddr); err != nil {
   236  		t.Fatal(err)
   237  	}
   238  	if _, _, err := c.(*UnixConn).WriteMsgUnix(b, nil, raddr); err != nil {
   239  		t.Fatal(err)
   240  	}
   241  	if _, err := c.(*UnixConn).Write(b); err == nil {
   242  		t.Fatal("should fail")
   243  	}
   244  }
   245  
   246  func TestUnixConnLocalAndRemoteNames(t *testing.T) {
   247  	if !testableNetwork("unix") {
   248  		t.Skip("unix test")
   249  	}
   250  
   251  	handler := func(ls *localServer, ln Listener) {}
   252  	for _, laddr := range []string{"", testUnixAddr()} {
   253  		laddr := laddr
   254  		taddr := testUnixAddr()
   255  		ta, err := ResolveUnixAddr("unix", taddr)
   256  		if err != nil {
   257  			t.Fatal(err)
   258  		}
   259  		ln, err := ListenUnix("unix", ta)
   260  		if err != nil {
   261  			t.Fatal(err)
   262  		}
   263  		ls, err := (&streamListener{Listener: ln}).newLocalServer()
   264  		if err != nil {
   265  			t.Fatal(err)
   266  		}
   267  		defer ls.teardown()
   268  		if err := ls.buildup(handler); err != nil {
   269  			t.Fatal(err)
   270  		}
   271  
   272  		la, err := ResolveUnixAddr("unix", laddr)
   273  		if err != nil {
   274  			t.Fatal(err)
   275  		}
   276  		c, err := DialUnix("unix", la, ta)
   277  		if err != nil {
   278  			t.Fatal(err)
   279  		}
   280  		defer func() {
   281  			c.Close()
   282  			if la != nil {
   283  				defer os.Remove(laddr)
   284  			}
   285  		}()
   286  		if _, err := c.Write([]byte("UNIXCONN LOCAL AND REMOTE NAME TEST")); err != nil {
   287  			t.Fatal(err)
   288  		}
   289  
   290  		switch runtime.GOOS {
   291  		case "android", "linux":
   292  			if laddr == "" {
   293  				laddr = "@" // autobind feature
   294  			}
   295  		}
   296  		var connAddrs = [3]struct{ got, want Addr }{
   297  			{ln.Addr(), ta},
   298  			{c.LocalAddr(), &UnixAddr{Name: laddr, Net: "unix"}},
   299  			{c.RemoteAddr(), ta},
   300  		}
   301  		for _, ca := range connAddrs {
   302  			if !reflect.DeepEqual(ca.got, ca.want) {
   303  				t.Fatalf("got %#v, expected %#v", ca.got, ca.want)
   304  			}
   305  		}
   306  	}
   307  }
   308  
   309  func TestUnixgramConnLocalAndRemoteNames(t *testing.T) {
   310  	if !testableNetwork("unixgram") {
   311  		t.Skip("unixgram test")
   312  	}
   313  
   314  	for _, laddr := range []string{"", testUnixAddr()} {
   315  		laddr := laddr
   316  		taddr := testUnixAddr()
   317  		ta, err := ResolveUnixAddr("unixgram", taddr)
   318  		if err != nil {
   319  			t.Fatal(err)
   320  		}
   321  		c1, err := ListenUnixgram("unixgram", ta)
   322  		if err != nil {
   323  			t.Fatal(err)
   324  		}
   325  		defer func() {
   326  			c1.Close()
   327  			os.Remove(taddr)
   328  		}()
   329  
   330  		var la *UnixAddr
   331  		if laddr != "" {
   332  			if la, err = ResolveUnixAddr("unixgram", laddr); err != nil {
   333  				t.Fatal(err)
   334  			}
   335  		}
   336  		c2, err := DialUnix("unixgram", la, ta)
   337  		if err != nil {
   338  			t.Fatal(err)
   339  		}
   340  		defer func() {
   341  			c2.Close()
   342  			if la != nil {
   343  				defer os.Remove(laddr)
   344  			}
   345  		}()
   346  
   347  		switch runtime.GOOS {
   348  		case "android", "linux":
   349  			if laddr == "" {
   350  				laddr = "@" // autobind feature
   351  			}
   352  		}
   353  
   354  		var connAddrs = [4]struct{ got, want Addr }{
   355  			{c1.LocalAddr(), ta},
   356  			{c1.RemoteAddr(), nil},
   357  			{c2.LocalAddr(), &UnixAddr{Name: laddr, Net: "unixgram"}},
   358  			{c2.RemoteAddr(), ta},
   359  		}
   360  		for _, ca := range connAddrs {
   361  			if !reflect.DeepEqual(ca.got, ca.want) {
   362  				t.Fatalf("got %#v; want %#v", ca.got, ca.want)
   363  			}
   364  		}
   365  	}
   366  }
   367  
   368  func TestUnixUnlink(t *testing.T) {
   369  	if !testableNetwork("unix") {
   370  		t.Skip("unix test")
   371  	}
   372  	name := testUnixAddr()
   373  
   374  	listen := func(t *testing.T) *UnixListener {
   375  		l, err := Listen("unix", name)
   376  		if err != nil {
   377  			t.Fatal(err)
   378  		}
   379  		return l.(*UnixListener)
   380  	}
   381  	checkExists := func(t *testing.T, desc string) {
   382  		if _, err := os.Stat(name); err != nil {
   383  			t.Fatalf("unix socket does not exist %s: %v", desc, err)
   384  		}
   385  	}
   386  	checkNotExists := func(t *testing.T, desc string) {
   387  		if _, err := os.Stat(name); err == nil {
   388  			t.Fatalf("unix socket does exist %s: %v", desc, err)
   389  		}
   390  	}
   391  
   392  	// Listener should remove on close.
   393  	t.Run("Listen", func(t *testing.T) {
   394  		l := listen(t)
   395  		checkExists(t, "after Listen")
   396  		l.Close()
   397  		checkNotExists(t, "after Listener close")
   398  	})
   399  
   400  	// FileListener should not.
   401  	t.Run("FileListener", func(t *testing.T) {
   402  		l := listen(t)
   403  		f, _ := l.File()
   404  		l1, _ := FileListener(f)
   405  		checkExists(t, "after FileListener")
   406  		f.Close()
   407  		checkExists(t, "after File close")
   408  		l1.Close()
   409  		checkExists(t, "after FileListener close")
   410  		l.Close()
   411  		checkNotExists(t, "after Listener close")
   412  	})
   413  
   414  	// Only first call to l.Close should remove.
   415  	t.Run("SecondClose", func(t *testing.T) {
   416  		l := listen(t)
   417  		checkExists(t, "after Listen")
   418  		l.Close()
   419  		checkNotExists(t, "after Listener close")
   420  		if err := ioutil.WriteFile(name, []byte("hello world"), 0666); err != nil {
   421  			t.Fatalf("cannot recreate socket file: %v", err)
   422  		}
   423  		checkExists(t, "after writing temp file")
   424  		l.Close()
   425  		checkExists(t, "after second Listener close")
   426  		os.Remove(name)
   427  	})
   428  
   429  	// SetUnlinkOnClose should do what it says.
   430  
   431  	t.Run("Listen/SetUnlinkOnClose(true)", func(t *testing.T) {
   432  		l := listen(t)
   433  		checkExists(t, "after Listen")
   434  		l.SetUnlinkOnClose(true)
   435  		l.Close()
   436  		checkNotExists(t, "after Listener close")
   437  	})
   438  
   439  	t.Run("Listen/SetUnlinkOnClose(false)", func(t *testing.T) {
   440  		l := listen(t)
   441  		checkExists(t, "after Listen")
   442  		l.SetUnlinkOnClose(false)
   443  		l.Close()
   444  		checkExists(t, "after Listener close")
   445  		os.Remove(name)
   446  	})
   447  
   448  	t.Run("FileListener/SetUnlinkOnClose(true)", func(t *testing.T) {
   449  		l := listen(t)
   450  		f, _ := l.File()
   451  		l1, _ := FileListener(f)
   452  		checkExists(t, "after FileListener")
   453  		l1.(*UnixListener).SetUnlinkOnClose(true)
   454  		f.Close()
   455  		checkExists(t, "after File close")
   456  		l1.Close()
   457  		checkNotExists(t, "after FileListener close")
   458  		l.Close()
   459  	})
   460  
   461  	t.Run("FileListener/SetUnlinkOnClose(false)", func(t *testing.T) {
   462  		l := listen(t)
   463  		f, _ := l.File()
   464  		l1, _ := FileListener(f)
   465  		checkExists(t, "after FileListener")
   466  		l1.(*UnixListener).SetUnlinkOnClose(false)
   467  		f.Close()
   468  		checkExists(t, "after File close")
   469  		l1.Close()
   470  		checkExists(t, "after FileListener close")
   471  		l.Close()
   472  	})
   473  }
   474  

View as plain text