libgo/go/net/udpsock_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         "errors"
   9         "os"
  10         "syscall"
  11         "time"
  12 )
  13
  14 // UDPConn is the implementation of the Conn and PacketConn interfaces
  15 // for UDP network connections.
  16 type UDPConn struct {
  17         conn
  18 }
  19
  20 func newUDPConn(fd *netFD) *UDPConn { return &UDPConn{conn{fd}} }
  21
  22 // ReadFromUDP reads a UDP packet from c, copying the payload into b.
  23 // It returns the number of bytes copied into b and the return address
  24 // that was on the packet.
  25 //
  26 // ReadFromUDP can be made to time out and return an error with
  27 // Timeout() == true after a fixed time limit; see SetDeadline and
  28 // SetReadDeadline.
  29 func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error) {
  30         if !c.ok() || c.fd.data == nil {
  31                 return 0, nil, syscall.EINVAL
  32         }
  33         buf := make([]byte, udpHeaderSize+len(b))
  34         m, err := c.fd.data.Read(buf)
  35         if err != nil {
  36                 return
  37         }
  38         if m < udpHeaderSize {
  39                 return 0, nil, errors.New("short read reading UDP header")
  40         }
  41         buf = buf[:m]
  42
  43         h, buf := unmarshalUDPHeader(buf)
  44         n = copy(b, buf)
  45         return n, &UDPAddr{IP: h.raddr, Port: int(h.rport)}, nil
  46 }
  47
  48 // ReadFrom implements the PacketConn ReadFrom method.
  49 func (c *UDPConn) ReadFrom(b []byte) (int, Addr, error) {
  50         if !c.ok() {
  51                 return 0, nil, syscall.EINVAL
  52         }
  53         return c.ReadFromUDP(b)
  54 }
  55
  56 // ReadMsgUDP reads a packet from c, copying the payload into b and
  57 // the associated out-of-band data into oob.  It returns the number
  58 // of bytes copied into b, the number of bytes copied into oob, the
  59 // flags that were set on the packet and the source address of the
  60 // packet.
  61 func (c *UDPConn) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error) {
  62         return 0, 0, 0, nil, syscall.EPLAN9
  63 }
  64
  65 // WriteToUDP writes a UDP packet to addr via c, copying the payload
  66 // from b.
  67 //
  68 // WriteToUDP can be made to time out and return an error with
  69 // Timeout() == true after a fixed time limit; see SetDeadline and
  70 // SetWriteDeadline.  On packet-oriented connections, write timeouts
  71 // are rare.
  72 func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error) {
  73         if !c.ok() || c.fd.data == nil {
  74                 return 0, syscall.EINVAL
  75         }
  76         h := new(udpHeader)
  77         h.raddr = addr.IP.To16()
  78         h.laddr = c.fd.laddr.(*UDPAddr).IP.To16()
  79         h.ifcaddr = IPv6zero // ignored (receive only)
  80         h.rport = uint16(addr.Port)
  81         h.lport = uint16(c.fd.laddr.(*UDPAddr).Port)
  82
  83         buf := make([]byte, udpHeaderSize+len(b))
  84         i := copy(buf, h.Bytes())
  85         copy(buf[i:], b)
  86         return c.fd.data.Write(buf)
  87 }
  88
  89 // WriteTo implements the PacketConn WriteTo method.
  90 func (c *UDPConn) WriteTo(b []byte, addr Addr) (int, error) {
  91         if !c.ok() {
  92                 return 0, syscall.EINVAL
  93         }
  94         a, ok := addr.(*UDPAddr)
  95         if !ok {
  96                 return 0, &OpError{"write", c.fd.dir, addr, syscall.EINVAL}
  97         }
  98         return c.WriteToUDP(b, a)
  99 }
 100
 101 // WriteMsgUDP writes a packet to addr via c, copying the payload from
 102 // b and the associated out-of-band data from oob.  It returns the
 103 // number of payload and out-of-band bytes written.
 104 func (c *UDPConn) WriteMsgUDP(b, oob []byte, addr *UDPAddr) (n, oobn int, err error) {
 105         return 0, 0, syscall.EPLAN9
 106 }
 107
 108 // DialUDP connects to the remote address raddr on the network net,
 109 // which must be "udp", "udp4", or "udp6".  If laddr is not nil, it is
 110 // used as the local address for the connection.
 111 func DialUDP(net string, laddr, raddr *UDPAddr) (*UDPConn, error) {
 112         return dialUDP(net, laddr, raddr, noDeadline)
 113 }
 114
 115 func dialUDP(net string, laddr, raddr *UDPAddr, deadline time.Time) (*UDPConn, error) {
 116         if !deadline.IsZero() {
 117                 panic("net.dialUDP: deadline not implemented on Plan 9")
 118         }
 119         switch net {
 120         case "udp", "udp4", "udp6":
 121         default:
 122                 return nil, UnknownNetworkError(net)
 123         }
 124         if raddr == nil {
 125                 return nil, &OpError{"dial", net, nil, errMissingAddress}
 126         }
 127         fd, err := dialPlan9(net, laddr, raddr)
 128         if err != nil {
 129                 return nil, err
 130         }
 131         return newUDPConn(fd), nil
 132 }
 133
 134 const udpHeaderSize = 16*3 + 2*2
 135
 136 type udpHeader struct {
 137         raddr, laddr, ifcaddr IP
 138         rport, lport          uint16
 139 }
 140
 141 func (h *udpHeader) Bytes() []byte {
 142         b := make([]byte, udpHeaderSize)
 143         i := 0
 144         i += copy(b[i:i+16], h.raddr)
 145         i += copy(b[i:i+16], h.laddr)
 146         i += copy(b[i:i+16], h.ifcaddr)
 147         b[i], b[i+1], i = byte(h.rport>>8), byte(h.rport), i+2
 148         b[i], b[i+1], i = byte(h.lport>>8), byte(h.lport), i+2
 149         return b
 150 }
 151
 152 func unmarshalUDPHeader(b []byte) (*udpHeader, []byte) {
 153         h := new(udpHeader)
 154         h.raddr, b = IP(b[:16]), b[16:]
 155         h.laddr, b = IP(b[:16]), b[16:]
 156         h.ifcaddr, b = IP(b[:16]), b[16:]
 157         h.rport, b = uint16(b[0])<<8|uint16(b[1]), b[2:]
 158         h.lport, b = uint16(b[0])<<8|uint16(b[1]), b[2:]
 159         return h, b
 160 }
 161
 162 // ListenUDP listens for incoming UDP packets addressed to the local
 163 // address laddr.  Net must be "udp", "udp4", or "udp6".  If laddr has
 164 // a port of 0, ListenUDP will choose an available port.
 165 // The LocalAddr method of the returned UDPConn can be used to
 166 // discover the port.  The returned connection's ReadFrom and WriteTo
 167 // methods can be used to receive and send UDP packets with per-packet
 168 // addressing.
 169 func ListenUDP(net string, laddr *UDPAddr) (*UDPConn, error) {
 170         switch net {
 171         case "udp", "udp4", "udp6":
 172         default:
 173                 return nil, UnknownNetworkError(net)
 174         }
 175         if laddr == nil {
 176                 laddr = &UDPAddr{}
 177         }
 178         l, err := listenPlan9(net, laddr)
 179         if err != nil {
 180                 return nil, err
 181         }
 182         _, err = l.ctl.WriteString("headers")
 183         if err != nil {
 184                 return nil, err
 185         }
 186         l.data, err = os.OpenFile(l.dir+"/data", os.O_RDWR, 0)
 187         if err != nil {
 188                 return nil, err
 189         }
 190         return newUDPConn(l.netFD()), nil
 191 }
 192
 193 // ListenMulticastUDP listens for incoming multicast UDP packets
 194 // addressed to the group address gaddr on ifi, which specifies the
 195 // interface to join.  ListenMulticastUDP uses default multicast
 196 // interface if ifi is nil.
 197 func ListenMulticastUDP(net string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error) {
 198         return nil, syscall.EPLAN9
 199 }