libgo/go/net/fd_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 package net
   6
   7 import (
   8         "io"
   9         "os"
  10         "syscall"
  11         "time"
  12 )
  13
  14 // Network file descritor.
  15 type netFD struct {
  16         proto, name, dir string
  17         ctl, data        *os.File
  18         laddr, raddr     Addr
  19 }
  20
  21 var canCancelIO = true // used for testing current package
  22
  23 func sysInit() {
  24 }
  25
  26 func dialTimeout(net, addr string, timeout time.Duration) (Conn, error) {
  27         // On plan9, use the relatively inefficient
  28         // goroutine-racing implementation.
  29         return dialTimeoutRace(net, addr, timeout)
  30 }
  31
  32 func newFD(proto, name string, ctl *os.File, laddr, raddr Addr) *netFD {
  33         return &netFD{proto, name, "/net/" + proto + "/" + name, ctl, nil, laddr, raddr}
  34 }
  35
  36 func (fd *netFD) ok() bool { return fd != nil && fd.ctl != nil }
  37
  38 func (fd *netFD) Read(b []byte) (n int, err error) {
  39         if !fd.ok() {
  40                 return 0, syscall.EINVAL
  41         }
  42         if fd.data == nil {
  43                 fd.data, err = os.OpenFile(fd.dir+"/data", os.O_RDWR, 0)
  44                 if err != nil {
  45                         return 0, err
  46                 }
  47         }
  48         n, err = fd.data.Read(b)
  49         if fd.proto == "udp" && err == io.EOF {
  50                 n = 0
  51                 err = nil
  52         }
  53         return
  54 }
  55
  56 func (fd *netFD) Write(b []byte) (n int, err error) {
  57         if !fd.ok() {
  58                 return 0, syscall.EINVAL
  59         }
  60         if fd.data == nil {
  61                 fd.data, err = os.OpenFile(fd.dir+"/data", os.O_RDWR, 0)
  62                 if err != nil {
  63                         return 0, err
  64                 }
  65         }
  66         return fd.data.Write(b)
  67 }
  68
  69 func (fd *netFD) CloseRead() error {
  70         if !fd.ok() {
  71                 return syscall.EINVAL
  72         }
  73         return syscall.EPLAN9
  74 }
  75
  76 func (fd *netFD) CloseWrite() error {
  77         if !fd.ok() {
  78                 return syscall.EINVAL
  79         }
  80         return syscall.EPLAN9
  81 }
  82
  83 func (fd *netFD) Close() error {
  84         if !fd.ok() {
  85                 return syscall.EINVAL
  86         }
  87         err := fd.ctl.Close()
  88         if err != nil {
  89                 return err
  90         }
  91         if fd.data != nil {
  92                 err = fd.data.Close()
  93         }
  94         fd.ctl = nil
  95         fd.data = nil
  96         return err
  97 }
  98
  99 func (fd *netFD) dup() (*os.File, error) {
 100         return nil, syscall.EPLAN9
 101 }
 102
 103 func setDeadline(fd *netFD, t time.Time) error {
 104         return syscall.EPLAN9
 105 }
 106
 107 func setReadDeadline(fd *netFD, t time.Time) error {
 108         return syscall.EPLAN9
 109 }
 110
 111 func setWriteDeadline(fd *netFD, t time.Time) error {
 112         return syscall.EPLAN9
 113 }
 114
 115 func setReadBuffer(fd *netFD, bytes int) error {
 116         return syscall.EPLAN9
 117 }
 118
 119 func setWriteBuffer(fd *netFD, bytes int) error {
 120         return syscall.EPLAN9
 121 }