libgo/go/net/sock.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 // Sockets
   6
   7 package net
   8
   9 import (
  10         "os"
  11         "reflect"
  12         "syscall"
  13 )
  14
  15 // Boolean to int.
  16 func boolint(b bool) int {
  17         if b {
  18                 return 1
  19         }
  20         return 0
  21 }
  22
  23 // Generic socket creation.
  24 func socket(net string, f, p, t int, la, ra syscall.Sockaddr, toAddr func(syscall.Sockaddr) Addr) (fd *netFD, err os.Error) {
  25         // See ../syscall/exec.go for description of ForkLock.
  26         syscall.ForkLock.RLock()
  27         s, e := syscall.Socket(f, p, t)
  28         if e != 0 {
  29                 syscall.ForkLock.RUnlock()
  30                 return nil, os.Errno(e)
  31         }
  32         syscall.CloseOnExec(s)
  33         syscall.ForkLock.RUnlock()
  34
  35         // Allow reuse of recently-used addresses.
  36         syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
  37
  38         // Allow broadcast.
  39         syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1)
  40
  41         if f == syscall.AF_INET6 {
  42                 // using ip, tcp, udp, etc.
  43                 // allow both protocols even if the OS default is otherwise.
  44                 syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, 0)
  45         }
  46
  47         if la != nil {
  48                 e = syscall.Bind(s, la)
  49                 if e != 0 {
  50                         syscall.Close(s)
  51                         return nil, os.Errno(e)
  52                 }
  53         }
  54
  55         if ra != nil {
  56                 e = syscall.Connect(s, ra)
  57                 if e != 0 {
  58                         syscall.Close(s)
  59                         return nil, os.Errno(e)
  60                 }
  61         }
  62
  63         sa, _ := syscall.Getsockname(s)
  64         laddr := toAddr(sa)
  65         sa, _ = syscall.Getpeername(s)
  66         raddr := toAddr(sa)
  67
  68         fd, err = newFD(s, f, p, net, laddr, raddr)
  69         if err != nil {
  70                 syscall.Close(s)
  71                 return nil, err
  72         }
  73
  74         return fd, nil
  75 }
  76
  77 func setsockoptInt(fd, level, opt int, value int) os.Error {
  78         return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, level, opt, value))
  79 }
  80
  81 func setsockoptNsec(fd, level, opt int, nsec int64) os.Error {
  82         var tv = syscall.NsecToTimeval(nsec)
  83         return os.NewSyscallError("setsockopt", syscall.SetsockoptTimeval(fd, level, opt, &tv))
  84 }
  85
  86 func setReadBuffer(fd *netFD, bytes int) os.Error {
  87         fd.incref()
  88         defer fd.decref()
  89         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bytes)
  90 }
  91
  92 func setWriteBuffer(fd *netFD, bytes int) os.Error {
  93         fd.incref()
  94         defer fd.decref()
  95         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, bytes)
  96 }
  97
  98 func setReadTimeout(fd *netFD, nsec int64) os.Error {
  99         fd.rdeadline_delta = nsec
 100         return nil
 101 }
 102
 103 func setWriteTimeout(fd *netFD, nsec int64) os.Error {
 104         fd.wdeadline_delta = nsec
 105         return nil
 106 }
 107
 108 func setTimeout(fd *netFD, nsec int64) os.Error {
 109         if e := setReadTimeout(fd, nsec); e != nil {
 110                 return e
 111         }
 112         return setWriteTimeout(fd, nsec)
 113 }
 114
 115 func setReuseAddr(fd *netFD, reuse bool) os.Error {
 116         fd.incref()
 117         defer fd.decref()
 118         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, boolint(reuse))
 119 }
 120
 121 func bindToDevice(fd *netFD, dev string) os.Error {
 122         // TODO(rsc): call setsockopt with null-terminated string pointer
 123         return os.EINVAL
 124 }
 125
 126 func setDontRoute(fd *netFD, dontroute bool) os.Error {
 127         fd.incref()
 128         defer fd.decref()
 129         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_DONTROUTE, boolint(dontroute))
 130 }
 131
 132 func setKeepAlive(fd *netFD, keepalive bool) os.Error {
 133         fd.incref()
 134         defer fd.decref()
 135         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, boolint(keepalive))
 136 }
 137
 138 func setNoDelay(fd *netFD, noDelay bool) os.Error {
 139         fd.incref()
 140         defer fd.decref()
 141         return setsockoptInt(fd.sysfd, syscall.IPPROTO_TCP, syscall.TCP_NODELAY, boolint(noDelay))
 142 }
 143
 144 func setLinger(fd *netFD, sec int) os.Error {
 145         var l syscall.Linger
 146         if sec >= 0 {
 147                 l.Onoff = 1
 148                 l.Linger = int32(sec)
 149         } else {
 150                 l.Onoff = 0
 151                 l.Linger = 0
 152         }
 153         fd.incref()
 154         defer fd.decref()
 155         e := syscall.SetsockoptLinger(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_LINGER, &l)
 156         return os.NewSyscallError("setsockopt", e)
 157 }
 158
 159 type UnknownSocketError struct {
 160         sa syscall.Sockaddr
 161 }
 162
 163 func (e *UnknownSocketError) String() string {
 164         return "unknown socket address type " + reflect.Typeof(e.sa).String()
 165 }
 166
 167 func sockaddrToString(sa syscall.Sockaddr) (name string, err os.Error) {
 168         switch a := sa.(type) {
 169         case *syscall.SockaddrInet4:
 170                 return joinHostPort(IP(a.Addr[0:]).String(), itoa(a.Port)), nil
 171         case *syscall.SockaddrInet6:
 172                 return joinHostPort(IP(a.Addr[0:]).String(), itoa(a.Port)), nil
 173         case *syscall.SockaddrUnix:
 174                 return a.Name, nil
 175         }
 176
 177         return "", &UnknownSocketError{sa}
 178 }