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.
5 // +build !js,!nacl,!plan9,!windows
21 func TestReadUnixgramWithUnnamedSocket(t *testing.T) {
22 if !testableNetwork("unixgram") {
23 t.Skip("unixgram test")
25 if runtime.GOOS == "openbsd" {
26 testenv.SkipFlaky(t, 15157)
29 addr := testUnixAddr()
30 la, err := ResolveUnixAddr("unixgram", addr)
34 c, err := ListenUnixgram("unixgram", la)
43 off := make(chan bool)
44 data := [5]byte{1, 2, 3, 4, 5}
46 defer func() { off <- true }()
47 s, err := syscall.Socket(syscall.AF_UNIX, syscall.SOCK_DGRAM, 0)
52 defer syscall.Close(s)
53 rsa := &syscall.SockaddrUnix{Name: addr}
54 if err := syscall.Sendto(s, data[:], 0, rsa); err != nil {
62 c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
63 n, from, err := c.ReadFrom(b)
68 t.Fatalf("unexpected peer address: %v", from)
70 if !bytes.Equal(b[:n], data[:]) {
71 t.Fatalf("got %v; want %v", b[:n], data[:])
75 func TestUnixgramZeroBytePayload(t *testing.T) {
76 if !testableNetwork("unixgram") {
77 t.Skip("unixgram test")
80 c1, err := newLocalPacketListener("unixgram")
84 defer os.Remove(c1.LocalAddr().String())
87 c2, err := Dial("unixgram", c1.LocalAddr().String())
91 defer os.Remove(c2.LocalAddr().String())
94 for _, genericRead := range []bool{false, true} {
95 n, err := c2.Write(nil)
100 t.Errorf("got %d; want 0", n)
102 c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
106 _, err = c1.(Conn).Read(b[:])
108 _, peer, err = c1.ReadFrom(b[:])
111 case nil: // ReadFrom succeeds
112 if peer != nil { // peer is connected-mode
113 t.Fatalf("unexpected peer address: %v", peer)
115 default: // Read may timeout, it depends on the platform
116 if nerr, ok := err.(Error); !ok || !nerr.Timeout() {
123 func TestUnixgramZeroByteBuffer(t *testing.T) {
124 if !testableNetwork("unixgram") {
125 t.Skip("unixgram test")
127 // issue 4352: Recvfrom failed with "address family not
128 // supported by protocol family" if zero-length buffer provided
130 c1, err := newLocalPacketListener("unixgram")
134 defer os.Remove(c1.LocalAddr().String())
137 c2, err := Dial("unixgram", c1.LocalAddr().String())
141 defer os.Remove(c2.LocalAddr().String())
144 b := []byte("UNIXGRAM ZERO BYTE BUFFER TEST")
145 for _, genericRead := range []bool{false, true} {
146 n, err := c2.Write(b)
151 t.Errorf("got %d; want %d", n, len(b))
153 c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
156 _, err = c1.(Conn).Read(nil)
158 _, peer, err = c1.ReadFrom(nil)
161 case nil: // ReadFrom succeeds
162 if peer != nil { // peer is connected-mode
163 t.Fatalf("unexpected peer address: %v", peer)
165 default: // Read may timeout, it depends on the platform
166 if nerr, ok := err.(Error); !ok || !nerr.Timeout() {
173 func TestUnixgramWrite(t *testing.T) {
174 if !testableNetwork("unixgram") {
175 t.Skip("unixgram test")
178 addr := testUnixAddr()
179 laddr, err := ResolveUnixAddr("unixgram", addr)
183 c, err := ListenPacket("unixgram", addr)
187 defer os.Remove(addr)
190 testUnixgramWriteConn(t, laddr)
191 testUnixgramWritePacketConn(t, laddr)
194 func testUnixgramWriteConn(t *testing.T, raddr *UnixAddr) {
195 c, err := Dial("unixgram", raddr.String())
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)
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)
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)
217 if _, err := c.Write(b); err != nil {
222 func testUnixgramWritePacketConn(t *testing.T, raddr *UnixAddr) {
223 addr := testUnixAddr()
224 c, err := ListenPacket("unixgram", addr)
228 defer os.Remove(addr)
231 b := []byte("UNCONNECTED-MODE SOCKET")
232 if _, err := c.(*UnixConn).WriteToUnix(b, raddr); err != nil {
235 if _, err := c.WriteTo(b, raddr); err != nil {
238 if _, _, err := c.(*UnixConn).WriteMsgUnix(b, nil, raddr); err != nil {
241 if _, err := c.(*UnixConn).Write(b); err == nil {
242 t.Fatal("should fail")
246 func TestUnixConnLocalAndRemoteNames(t *testing.T) {
247 if !testableNetwork("unix") {
251 handler := func(ls *localServer, ln Listener) {}
252 for _, laddr := range []string{"", testUnixAddr()} {
254 taddr := testUnixAddr()
255 ta, err := ResolveUnixAddr("unix", taddr)
259 ln, err := ListenUnix("unix", ta)
263 ls, err := (&streamListener{Listener: ln}).newLocalServer()
268 if err := ls.buildup(handler); err != nil {
272 la, err := ResolveUnixAddr("unix", laddr)
276 c, err := DialUnix("unix", la, ta)
283 defer os.Remove(laddr)
286 if _, err := c.Write([]byte("UNIXCONN LOCAL AND REMOTE NAME TEST")); err != nil {
290 switch runtime.GOOS {
291 case "android", "linux":
293 laddr = "@" // autobind feature
296 var connAddrs = [3]struct{ got, want Addr }{
298 {c.LocalAddr(), &UnixAddr{Name: laddr, Net: "unix"}},
299 {c.RemoteAddr(), ta},
301 for _, ca := range connAddrs {
302 if !reflect.DeepEqual(ca.got, ca.want) {
303 t.Fatalf("got %#v, expected %#v", ca.got, ca.want)
309 func TestUnixgramConnLocalAndRemoteNames(t *testing.T) {
310 if !testableNetwork("unixgram") {
311 t.Skip("unixgram test")
314 for _, laddr := range []string{"", testUnixAddr()} {
316 taddr := testUnixAddr()
317 ta, err := ResolveUnixAddr("unixgram", taddr)
321 c1, err := ListenUnixgram("unixgram", ta)
332 if la, err = ResolveUnixAddr("unixgram", laddr); err != nil {
336 c2, err := DialUnix("unixgram", la, ta)
343 defer os.Remove(laddr)
347 switch runtime.GOOS {
348 case "android", "linux":
350 laddr = "@" // autobind feature
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},
360 for _, ca := range connAddrs {
361 if !reflect.DeepEqual(ca.got, ca.want) {
362 t.Fatalf("got %#v; want %#v", ca.got, ca.want)
368 func TestUnixUnlink(t *testing.T) {
369 if !testableNetwork("unix") {
372 name := testUnixAddr()
374 listen := func(t *testing.T) *UnixListener {
375 l, err := Listen("unix", name)
379 return l.(*UnixListener)
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)
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)
392 // Listener should remove on close.
393 t.Run("Listen", func(t *testing.T) {
395 checkExists(t, "after Listen")
397 checkNotExists(t, "after Listener close")
400 // FileListener should not.
401 t.Run("FileListener", func(t *testing.T) {
404 l1, _ := FileListener(f)
405 checkExists(t, "after FileListener")
407 checkExists(t, "after File close")
409 checkExists(t, "after FileListener close")
411 checkNotExists(t, "after Listener close")
414 // Only first call to l.Close should remove.
415 t.Run("SecondClose", func(t *testing.T) {
417 checkExists(t, "after Listen")
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)
423 checkExists(t, "after writing temp file")
425 checkExists(t, "after second Listener close")
429 // SetUnlinkOnClose should do what it says.
431 t.Run("Listen/SetUnlinkOnClose(true)", func(t *testing.T) {
433 checkExists(t, "after Listen")
434 l.SetUnlinkOnClose(true)
436 checkNotExists(t, "after Listener close")
439 t.Run("Listen/SetUnlinkOnClose(false)", func(t *testing.T) {
441 checkExists(t, "after Listen")
442 l.SetUnlinkOnClose(false)
444 checkExists(t, "after Listener close")
448 t.Run("FileListener/SetUnlinkOnClose(true)", func(t *testing.T) {
451 l1, _ := FileListener(f)
452 checkExists(t, "after FileListener")
453 l1.(*UnixListener).SetUnlinkOnClose(true)
455 checkExists(t, "after File close")
457 checkNotExists(t, "after FileListener close")
461 t.Run("FileListener/SetUnlinkOnClose(false)", func(t *testing.T) {
464 l1, _ := FileListener(f)
465 checkExists(t, "after FileListener")
466 l1.(*UnixListener).SetUnlinkOnClose(false)
468 checkExists(t, "after File close")
470 checkExists(t, "after FileListener close")