libgo/go/net/ipsock_plan9.go

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