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 // IP sockets stubs for Plan 9
   6
   7 package net
   8
   9 import (
  10         "errors"
  11         "io"
  12         "os"
  13         "syscall"
  14         "time"
  15 )
  16
  17 // probeIPv6Stack returns two boolean values.  If the first boolean value is
  18 // true, kernel supports basic IPv6 functionality.  If the second
  19 // boolean value is true, kernel supports IPv6 IPv4-mapping.
  20 func probeIPv6Stack() (supportsIPv6, supportsIPv4map bool) {
  21         return false, false
  22 }
  23
  24 // parsePlan9Addr parses address of the form [ip!]port (e.g. 127.0.0.1!80).
  25 func parsePlan9Addr(s string) (ip IP, iport int, err error) {
  26         addr := IPv4zero // address contains port only
  27         i := byteIndex(s, '!')
  28         if i >= 0 {
  29                 addr = ParseIP(s[:i])
  30                 if addr == nil {
  31                         return nil, 0, errors.New("net: parsing IP failed")
  32                 }
  33         }
  34         p, _, ok := dtoi(s[i+1:], 0)
  35         if !ok {
  36                 return nil, 0, errors.New("net: parsing port failed")
  37         }
  38         if p < 0 || p > 0xFFFF {
  39                 return nil, 0, &AddrError{"invalid port", string(p)}
  40         }
  41         return addr, p, nil
  42 }
  43
  44 func readPlan9Addr(proto, filename string) (addr Addr, err error) {
  45         var buf [128]byte
  46
  47         f, err := os.Open(filename)
  48         if err != nil {
  49                 return
  50         }
  51         n, err := f.Read(buf[:])
  52         if err != nil {
  53                 return
  54         }
  55         ip, port, err := parsePlan9Addr(string(buf[:n]))
  56         if err != nil {
  57                 return
  58         }
  59         switch proto {
  60         case "tcp":
  61                 addr = &TCPAddr{ip, port}
  62         case "udp":
  63                 addr = &UDPAddr{ip, port}
  64         default:
  65                 return nil, errors.New("unknown protocol " + proto)
  66         }
  67         return addr, nil
  68 }
  69
  70 type plan9Conn struct {
  71         proto, name, dir string
  72         ctl, data        *os.File
  73         laddr, raddr     Addr
  74 }
  75
  76 func newPlan9Conn(proto, name string, ctl *os.File, laddr, raddr Addr) *plan9Conn {
  77         return &plan9Conn{proto, name, "/net/" + proto + "/" + name, ctl, nil, laddr, raddr}
  78 }
  79
  80 func (c *plan9Conn) ok() bool { return c != nil && c.ctl != nil }
  81
  82 // Implementation of the Conn interface - see Conn for documentation.
  83
  84 // Read implements the Conn Read method.
  85 func (c *plan9Conn) Read(b []byte) (n int, err error) {
  86         if !c.ok() {
  87                 return 0, syscall.EINVAL
  88         }
  89         if c.data == nil {
  90                 c.data, err = os.OpenFile(c.dir+"/data", os.O_RDWR, 0)
  91                 if err != nil {
  92                         return 0, err
  93                 }
  94         }
  95         n, err = c.data.Read(b)
  96         if c.proto == "udp" && err == io.EOF {
  97                 n = 0
  98                 err = nil
  99         }
 100         return
 101 }
 102
 103 // Write implements the Conn Write method.
 104 func (c *plan9Conn) Write(b []byte) (n int, err error) {
 105         if !c.ok() {
 106                 return 0, syscall.EINVAL
 107         }
 108         if c.data == nil {
 109                 c.data, err = os.OpenFile(c.dir+"/data", os.O_RDWR, 0)
 110                 if err != nil {
 111                         return 0, err
 112                 }
 113         }
 114         return c.data.Write(b)
 115 }
 116
 117 // Close closes the connection.
 118 func (c *plan9Conn) Close() error {
 119         if !c.ok() {
 120                 return syscall.EINVAL
 121         }
 122         err := c.ctl.Close()
 123         if err != nil {
 124                 return err
 125         }
 126         if c.data != nil {
 127                 err = c.data.Close()
 128         }
 129         c.ctl = nil
 130         c.data = nil
 131         return err
 132 }
 133
 134 // LocalAddr returns the local network address.
 135 func (c *plan9Conn) LocalAddr() Addr {
 136         if !c.ok() {
 137                 return nil
 138         }
 139         return c.laddr
 140 }
 141
 142 // RemoteAddr returns the remote network address.
 143 func (c *plan9Conn) RemoteAddr() Addr {
 144         if !c.ok() {
 145                 return nil
 146         }
 147         return c.raddr
 148 }
 149
 150 // SetDeadline implements the Conn SetDeadline method.
 151 func (c *plan9Conn) SetDeadline(t time.Time) error {
 152         return syscall.EPLAN9
 153 }
 154
 155 // SetReadDeadline implements the Conn SetReadDeadline method.
 156 func (c *plan9Conn) SetReadDeadline(t time.Time) error {
 157         return syscall.EPLAN9
 158 }
 159
 160 // SetWriteDeadline implements the Conn SetWriteDeadline method.
 161 func (c *plan9Conn) SetWriteDeadline(t time.Time) error {
 162         return syscall.EPLAN9
 163 }
 164
 165 func startPlan9(net string, addr Addr) (ctl *os.File, dest, proto, name string, err error) {
 166         var (
 167                 ip   IP
 168                 port int
 169         )
 170         switch a := addr.(type) {
 171         case *TCPAddr:
 172                 proto = "tcp"
 173                 ip = a.IP
 174                 port = a.Port
 175         case *UDPAddr:
 176                 proto = "udp"
 177                 ip = a.IP
 178                 port = a.Port
 179         default:
 180                 err = UnknownNetworkError(net)
 181                 return
 182         }
 183
 184         clone, dest, err := queryCS1(proto, ip, port)
 185         if err != nil {
 186                 return
 187         }
 188         f, err := os.OpenFile(clone, os.O_RDWR, 0)
 189         if err != nil {
 190                 return
 191         }
 192         var buf [16]byte
 193         n, err := f.Read(buf[:])
 194         if err != nil {
 195                 return
 196         }
 197         return f, dest, proto, string(buf[:n]), nil
 198 }
 199
 200 func dialPlan9(net string, laddr, raddr Addr) (c *plan9Conn, err error) {
 201         f, dest, proto, name, err := startPlan9(net, raddr)
 202         if err != nil {
 203                 return
 204         }
 205         _, err = f.WriteString("connect " + dest)
 206         if err != nil {
 207                 return
 208         }
 209         laddr, err = readPlan9Addr(proto, "/net/"+proto+"/"+name+"/local")
 210         if err != nil {
 211                 return
 212         }
 213         raddr, err = readPlan9Addr(proto, "/net/"+proto+"/"+name+"/remote")
 214         if err != nil {
 215                 return
 216         }
 217         return newPlan9Conn(proto, name, f, laddr, raddr), nil
 218 }
 219
 220 type plan9Listener struct {
 221         proto, name, dir string
 222         ctl              *os.File
 223         laddr            Addr
 224 }
 225
 226 func listenPlan9(net string, laddr Addr) (l *plan9Listener, err error) {
 227         f, dest, proto, name, err := startPlan9(net, laddr)
 228         if err != nil {
 229                 return
 230         }
 231         _, err = f.WriteString("announce " + dest)
 232         if err != nil {
 233                 return
 234         }
 235         laddr, err = readPlan9Addr(proto, "/net/"+proto+"/"+name+"/local")
 236         if err != nil {
 237                 return
 238         }
 239         l = new(plan9Listener)
 240         l.proto = proto
 241         l.name = name
 242         l.dir = "/net/" + proto + "/" + name
 243         l.ctl = f
 244         l.laddr = laddr
 245         return l, nil
 246 }
 247
 248 func (l *plan9Listener) plan9Conn() *plan9Conn {
 249         return newPlan9Conn(l.proto, l.name, l.ctl, l.laddr, nil)
 250 }
 251
 252 func (l *plan9Listener) acceptPlan9() (c *plan9Conn, err error) {
 253         f, err := os.Open(l.dir + "/listen")
 254         if err != nil {
 255                 return
 256         }
 257         var buf [16]byte
 258         n, err := f.Read(buf[:])
 259         if err != nil {
 260                 return
 261         }
 262         name := string(buf[:n])
 263         laddr, err := readPlan9Addr(l.proto, l.dir+"/local")
 264         if err != nil {
 265                 return
 266         }
 267         raddr, err := readPlan9Addr(l.proto, l.dir+"/remote")
 268         if err != nil {
 269                 return
 270         }
 271         return newPlan9Conn(l.proto, name, f, laddr, raddr), nil
 272 }
 273
 274 func (l *plan9Listener) Accept() (c Conn, err error) {
 275         c1, err := l.acceptPlan9()
 276         if err != nil {
 277                 return
 278         }
 279         return c1, nil
 280 }
 281
 282 func (l *plan9Listener) Close() error {
 283         if l == nil || l.ctl == nil {
 284                 return syscall.EINVAL
 285         }
 286         return l.ctl.Close()
 287 }
 288
 289 func (l *plan9Listener) Addr() Addr { return l.laddr }