nanomsg.org/go/mangos/v2@v2.0.9-0.20200203084354-8a092611e461/transport/ipc/ipc_unix_test.go (about) 1 // Copyright 2019 The Mangos Authors 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use file except in compliance with the License. 5 // You may obtain a copy of the license at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 // +build !plan9,!windows,!js 16 17 package ipc 18 19 import ( 20 "errors" 21 "nanomsg.org/go/mangos/v2" 22 "net" 23 "os" 24 "syscall" 25 "testing" 26 "time" 27 28 . "nanomsg.org/go/mangos/v2/internal/test" 29 ) 30 31 func TestIsSyscallError(t *testing.T) { 32 33 MustBeFalse(t, isSyscallError(errors.New("nope"), syscall.ENOENT)) 34 MustBeFalse(t, isSyscallError(&net.OpError{ 35 Op: "test", 36 Net: "none", 37 Source: nil, 38 Addr: nil, 39 Err: mangos.ErrClosed, 40 }, syscall.ENOENT)) 41 MustBeFalse(t, isSyscallError(&net.OpError{ 42 Op: "test", 43 Net: "none", 44 Source: nil, 45 Addr: nil, 46 Err: &os.SyscallError{ 47 Syscall: "none", 48 Err: syscall.EINVAL, 49 }, 50 }, syscall.ENOENT)) 51 MustBeFalse(t, isSyscallError(&net.OpError{ 52 Op: "test", 53 Net: "none", 54 Source: nil, 55 Addr: nil, 56 Err: &os.SyscallError{ 57 Syscall: "none", 58 Err: mangos.ErrNotRaw, 59 }, 60 }, syscall.ENOENT)) 61 MustBeTrue(t, isSyscallError(&net.OpError{ 62 Op: "test", 63 Net: "none", 64 Source: nil, 65 Addr: nil, 66 Err: &os.SyscallError{ 67 Syscall: "none", 68 Err: syscall.ENOENT, 69 }, 70 }, syscall.ENOENT)) 71 } 72 73 func TestIpcStaleListen(t *testing.T) { 74 addr1 := AddrTestIPC() 75 name := addr1[len("ipc://"):] 76 defer func() { 77 _ = os.Remove(name) 78 _ = os.Remove(name + ".hold") 79 }() 80 81 uaddr, _ := net.ResolveUnixAddr("unix", name) 82 sock, err := net.ListenUnix("unix", uaddr) 83 84 MustSucceed(t, err) 85 86 // We rename it so that closing won't unlink the socket. 87 // This lets us leave a stale socket behind. 88 MustSucceed(t, os.Rename(name, name+".hold")) 89 MustSucceed(t, sock.Close()) 90 MustSucceed(t, os.Rename(name+".hold", name)) 91 92 // Clean up the stale link. 93 self := GetMockSocket() 94 95 MustSucceed(t, self.Listen(addr1)) 96 defer MustClose(t, self) 97 } 98 99 func TestIpcBusyListen(t *testing.T) { 100 addr1 := AddrTestIPC() 101 name := addr1[len("ipc://"):] 102 103 uaddr, _ := net.ResolveUnixAddr("unix", name) 104 sock, err := net.ListenUnix("unix", uaddr) 105 defer func() { 106 _ = sock.Close() 107 }() 108 109 MustSucceed(t, err) 110 111 self := GetMockSocket() 112 113 MustBeError(t, self.Listen(addr1), mangos.ErrAddrInUse) 114 defer MustClose(t, self) 115 } 116 117 func TestIpcFileConflictListen(t *testing.T) { 118 addr1 := AddrTestIPC() 119 name := addr1[len("ipc://"):] 120 121 file, err := os.Create(name) 122 MustSucceed(t, err) 123 _, _ = file.WriteString("abc") 124 _ = file.Close() 125 defer func() { 126 MustSucceed(t, os.Remove(name)) 127 }() 128 129 self := GetMockSocket() 130 131 MustBeError(t, self.Listen(addr1), mangos.ErrAddrInUse) 132 defer MustClose(t, self) 133 } 134 135 type testAddr string 136 137 func (a testAddr) testDial() (net.Conn, error) { 138 return net.Dial("unix", string(a)[len("ipc://"):]) 139 } 140 141 func TestIpcAbortHandshake(t *testing.T) { 142 sock := GetMockSocket() 143 defer MustClose(t, sock) 144 addr := AddrTestIPC() 145 l, e := sock.NewListener(addr, nil) 146 MustSucceed(t, e) 147 MustSucceed(t, l.Listen()) 148 c, e := testAddr(addr).testDial() 149 MustSucceed(t, e) 150 MustSucceed(t, c.Close()) 151 } 152 153 func TestIpcBadHandshake(t *testing.T) { 154 sock := GetMockSocket() 155 defer MustClose(t, sock) 156 addr := AddrTestIPC() 157 l, e := sock.NewListener(addr, nil) 158 MustSucceed(t, e) 159 MustSucceed(t, l.Listen()) 160 TranSendConnBadHandshakes(t, testAddr(addr).testDial) 161 } 162 163 func TestIpcBadRecv(t *testing.T) { 164 sock := GetMockSocket() 165 defer MustClose(t, sock) 166 addr := AddrTestIPC() 167 l, e := sock.NewListener(addr, nil) 168 MustSucceed(t, e) 169 MustSucceed(t, l.Listen()) 170 TranSendBadMessages(t, sock.Info().Peer, true, testAddr(addr).testDial) 171 } 172 173 func TestIpcSendAbort(t *testing.T) { 174 sock := GetMockSocket() 175 defer MustClose(t, sock) 176 addr := AddrTestIPC() 177 l, e := sock.NewListener(addr, nil) 178 MustSucceed(t, e) 179 MustSucceed(t, l.Listen()) 180 c, e := testAddr(addr).testDial() 181 MustSucceed(t, e) 182 TranConnHandshake(t, c, sock.Info().Peer) 183 MustSend(t, sock, make([]byte, 1024*1024)) // TCP window size is 64k 184 time.Sleep(time.Millisecond * 100) 185 MustSucceed(t, c.Close()) 186 }