1 // Copyright 2009 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 "context" 9 "os" 10 "syscall" 11 ) 12 13 // Probe probes IPv4, IPv6 and IPv4-mapped IPv6 communication 14 // capabilities. 15 // 16 // Plan 9 uses IPv6 natively, see ip(3). 17 func (p *ipStackCapabilities) probe() { 18 p.ipv4Enabled = probe(netdir+"/iproute", "4i") 19 p.ipv6Enabled = probe(netdir+"/iproute", "6i") 20 if p.ipv4Enabled && p.ipv6Enabled { 21 p.ipv4MappedIPv6Enabled = true 22 } 23 } 24 25 func probe(filename, query string) bool { 26 var file *file 27 var err error 28 if file, err = open(filename); err != nil { 29 return false 30 } 31 defer file.close() 32 33 r := false 34 for line, ok := file.readLine(); ok && !r; line, ok = file.readLine() { 35 f := getFields(line) 36 if len(f) < 3 { 37 continue 38 } 39 for i := 0; i < len(f); i++ { 40 if query == f[i] { 41 r = true 42 break 43 } 44 } 45 } 46 return r 47 } 48 49 // parsePlan9Addr parses address of the form [ip!]port (e.g. 127.0.0.1!80). 50 func parsePlan9Addr(s string) (ip IP, iport int, err error) { 51 addr := IPv4zero // address contains port only 52 i := byteIndex(s, '!') 53 if i >= 0 { 54 addr = ParseIP(s[:i]) 55 if addr == nil { 56 return nil, 0, &ParseError{Type: "IP address", Text: s} 57 } 58 } 59 p, _, ok := dtoi(s[i+1:]) 60 if !ok { 61 return nil, 0, &ParseError{Type: "port", Text: s} 62 } 63 if p < 0 || p > 0xFFFF { 64 return nil, 0, &AddrError{Err: "invalid port", Addr: string(p)} 65 } 66 return addr, p, nil 67 } 68 69 func readPlan9Addr(proto, filename string) (addr Addr, err error) { 70 var buf [128]byte 71 72 f, err := os.Open(filename) 73 if err != nil { 74 return 75 } 76 defer f.Close() 77 n, err := f.Read(buf[:]) 78 if err != nil { 79 return 80 } 81 ip, port, err := parsePlan9Addr(string(buf[:n])) 82 if err != nil { 83 return 84 } 85 switch proto { 86 case "tcp": 87 addr = &TCPAddr{IP: ip, Port: port} 88 case "udp": 89 addr = &UDPAddr{IP: ip, Port: port} 90 default: 91 return nil, UnknownNetworkError(proto) 92 } 93 return addr, nil 94 } 95 96 func startPlan9(ctx context.Context, net string, addr Addr) (ctl *os.File, dest, proto, name string, err error) { 97 var ( 98 ip IP 99 port int 100 ) 101 switch a := addr.(type) { 102 case *TCPAddr: 103 proto = "tcp" 104 ip = a.IP 105 port = a.Port 106 case *UDPAddr: 107 proto = "udp" 108 ip = a.IP 109 port = a.Port 110 default: 111 err = UnknownNetworkError(net) 112 return 113 } 114 115 if port > 65535 { 116 err = InvalidAddrError("port should be < 65536") 117 return 118 } 119 120 clone, dest, err := queryCS1(ctx, proto, ip, port) 121 if err != nil { 122 return 123 } 124 f, err := os.OpenFile(clone, os.O_RDWR, 0) 125 if err != nil { 126 return 127 } 128 var buf [16]byte 129 n, err := f.Read(buf[:]) 130 if err != nil { 131 f.Close() 132 return 133 } 134 return f, dest, proto, string(buf[:n]), nil 135 } 136 137 func fixErr(err error) { 138 oe, ok := err.(*OpError) 139 if !ok { 140 return 141 } 142 nonNilInterface := func(a Addr) bool { 143 switch a := a.(type) { 144 case *TCPAddr: 145 return a == nil 146 case *UDPAddr: 147 return a == nil 148 case *IPAddr: 149 return a == nil 150 default: 151 return false 152 } 153 } 154 if nonNilInterface(oe.Source) { 155 oe.Source = nil 156 } 157 if nonNilInterface(oe.Addr) { 158 oe.Addr = nil 159 } 160 if pe, ok := oe.Err.(*os.PathError); ok { 161 if _, ok = pe.Err.(syscall.ErrorString); ok { 162 oe.Err = pe.Err 163 } 164 } 165 } 166 167 func dialPlan9(ctx context.Context, net string, laddr, raddr Addr) (fd *netFD, err error) { 168 defer func() { fixErr(err) }() 169 type res struct { 170 fd *netFD 171 err error 172 } 173 resc := make(chan res) 174 go func() { 175 testHookDialChannel() 176 fd, err := dialPlan9Blocking(ctx, net, laddr, raddr) 177 select { 178 case resc <- res{fd, err}: 179 case <-ctx.Done(): 180 if fd != nil { 181 fd.Close() 182 } 183 } 184 }() 185 select { 186 case res := <-resc: 187 return res.fd, res.err 188 case <-ctx.Done(): 189 return nil, mapErr(ctx.Err()) 190 } 191 } 192 193 func dialPlan9Blocking(ctx context.Context, net string, laddr, raddr Addr) (fd *netFD, err error) { 194 if isWildcard(raddr) { 195 raddr = toLocal(raddr, net) 196 } 197 f, dest, proto, name, err := startPlan9(ctx, net, raddr) 198 if err != nil { 199 return nil, err 200 } 201 _, err = f.WriteString("connect " + dest) 202 if err != nil { 203 f.Close() 204 return nil, err 205 } 206 data, err := os.OpenFile(netdir+"/"+proto+"/"+name+"/data", os.O_RDWR, 0) 207 if err != nil { 208 f.Close() 209 return nil, err 210 } 211 laddr, err = readPlan9Addr(proto, netdir+"/"+proto+"/"+name+"/local") 212 if err != nil { 213 data.Close() 214 f.Close() 215 return nil, err 216 } 217 return newFD(proto, name, nil, f, data, laddr, raddr) 218 } 219 220 func listenPlan9(ctx context.Context, net string, laddr Addr) (fd *netFD, err error) { 221 defer func() { fixErr(err) }() 222 f, dest, proto, name, err := startPlan9(ctx, net, laddr) 223 if err != nil { 224 return nil, err 225 } 226 _, err = f.WriteString("announce " + dest) 227 if err != nil { 228 f.Close() 229 return nil, err 230 } 231 laddr, err = readPlan9Addr(proto, netdir+"/"+proto+"/"+name+"/local") 232 if err != nil { 233 f.Close() 234 return nil, err 235 } 236 return newFD(proto, name, nil, f, nil, laddr, nil) 237 } 238 239 func (fd *netFD) netFD() (*netFD, error) { 240 return newFD(fd.net, fd.n, fd.listen, fd.ctl, fd.data, fd.laddr, fd.raddr) 241 } 242 243 func (fd *netFD) acceptPlan9() (nfd *netFD, err error) { 244 defer func() { fixErr(err) }() 245 if err := fd.pfd.ReadLock(); err != nil { 246 return nil, err 247 } 248 defer fd.pfd.ReadUnlock() 249 listen, err := os.Open(fd.dir + "/listen") 250 if err != nil { 251 return nil, err 252 } 253 var buf [16]byte 254 n, err := listen.Read(buf[:]) 255 if err != nil { 256 listen.Close() 257 return nil, err 258 } 259 name := string(buf[:n]) 260 ctl, err := os.OpenFile(netdir+"/"+fd.net+"/"+name+"/ctl", os.O_RDWR, 0) 261 if err != nil { 262 listen.Close() 263 return nil, err 264 } 265 data, err := os.OpenFile(netdir+"/"+fd.net+"/"+name+"/data", os.O_RDWR, 0) 266 if err != nil { 267 listen.Close() 268 ctl.Close() 269 return nil, err 270 } 271 raddr, err := readPlan9Addr(fd.net, netdir+"/"+fd.net+"/"+name+"/remote") 272 if err != nil { 273 listen.Close() 274 ctl.Close() 275 data.Close() 276 return nil, err 277 } 278 return newFD(fd.net, name, listen, ctl, data, fd.laddr, raddr) 279 } 280 281 func isWildcard(a Addr) bool { 282 var wildcard bool 283 switch a := a.(type) { 284 case *TCPAddr: 285 wildcard = a.isWildcard() 286 case *UDPAddr: 287 wildcard = a.isWildcard() 288 case *IPAddr: 289 wildcard = a.isWildcard() 290 } 291 return wildcard 292 } 293 294 func toLocal(a Addr, net string) Addr { 295 switch a := a.(type) { 296 case *TCPAddr: 297 a.IP = loopbackIP(net) 298 case *UDPAddr: 299 a.IP = loopbackIP(net) 300 case *IPAddr: 301 a.IP = loopbackIP(net) 302 } 303 return a 304 } 305
