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         setKernelSpecificSockopt(s, f)
  36
  37         if la != nil {
  38                 e = syscall.Bind(s, la)
  39                 if e != 0 {
  40                         closesocket(s)
  41                         return nil, os.Errno(e)
  42                 }
  43         }
  44
  45         if fd, err = newFD(s, f, p, net); err != nil {
  46                 closesocket(s)
  47                 return nil, err
  48         }
  49
  50         if ra != nil {
  51                 if err = fd.connect(ra); err != nil {
  52                         fd.sysfd = -1
  53                         closesocket(s)
  54                         return nil, err
  55                 }
  56         }
  57
  58         sa, _ := syscall.Getsockname(s)
  59         laddr := toAddr(sa)
  60         sa, _ = syscall.Getpeername(s)
  61         raddr := toAddr(sa)
  62
  63         fd.setAddr(laddr, raddr)
  64         return fd, nil
  65 }
  66
  67 func setsockoptInt(fd, level, opt int, value int) os.Error {
  68         return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, level, opt, value))
  69 }
  70
  71 func setsockoptNsec(fd, level, opt int, nsec int64) os.Error {
  72         var tv = syscall.NsecToTimeval(nsec)
  73         return os.NewSyscallError("setsockopt", syscall.SetsockoptTimeval(fd, level, opt, &tv))
  74 }
  75
  76 func setReadBuffer(fd *netFD, bytes int) os.Error {
  77         fd.incref()
  78         defer fd.decref()
  79         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bytes)
  80 }
  81
  82 func setWriteBuffer(fd *netFD, bytes int) os.Error {
  83         fd.incref()
  84         defer fd.decref()
  85         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, bytes)
  86 }
  87
  88 func setReadTimeout(fd *netFD, nsec int64) os.Error {
  89         fd.rdeadline_delta = nsec
  90         return nil
  91 }
  92
  93 func setWriteTimeout(fd *netFD, nsec int64) os.Error {
  94         fd.wdeadline_delta = nsec
  95         return nil
  96 }
  97
  98 func setTimeout(fd *netFD, nsec int64) os.Error {
  99         if e := setReadTimeout(fd, nsec); e != nil {
 100                 return e
 101         }
 102         return setWriteTimeout(fd, nsec)
 103 }
 104
 105 func setReuseAddr(fd *netFD, reuse bool) os.Error {
 106         fd.incref()
 107         defer fd.decref()
 108         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, boolint(reuse))
 109 }
 110
 111 func bindToDevice(fd *netFD, dev string) os.Error {
 112         // TODO(rsc): call setsockopt with null-terminated string pointer
 113         return os.EINVAL
 114 }
 115
 116 func setDontRoute(fd *netFD, dontroute bool) os.Error {
 117         fd.incref()
 118         defer fd.decref()
 119         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_DONTROUTE, boolint(dontroute))
 120 }
 121
 122 func setKeepAlive(fd *netFD, keepalive bool) os.Error {
 123         fd.incref()
 124         defer fd.decref()
 125         return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, boolint(keepalive))
 126 }
 127
 128 func setNoDelay(fd *netFD, noDelay bool) os.Error {
 129         fd.incref()
 130         defer fd.decref()
 131         return setsockoptInt(fd.sysfd, syscall.IPPROTO_TCP, syscall.TCP_NODELAY, boolint(noDelay))
 132 }
 133
 134 func setLinger(fd *netFD, sec int) os.Error {
 135         var l syscall.Linger
 136         if sec >= 0 {
 137                 l.Onoff = 1
 138                 l.Linger = int32(sec)
 139         } else {
 140                 l.Onoff = 0
 141                 l.Linger = 0
 142         }
 143         fd.incref()
 144         defer fd.decref()
 145         e := syscall.SetsockoptLinger(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_LINGER, &l)
 146         return os.NewSyscallError("setsockopt", e)
 147 }
 148
 149 type UnknownSocketError struct {
 150         sa syscall.Sockaddr
 151 }
 152
 153 func (e *UnknownSocketError) String() string {
 154         return "unknown socket address type " + reflect.TypeOf(e.sa).String()
 155 }
 156
 157 func sockaddrToString(sa syscall.Sockaddr) (name string, err os.Error) {
 158         switch a := sa.(type) {
 159         case *syscall.SockaddrInet4:
 160                 return JoinHostPort(IP(a.Addr[0:]).String(), itoa(a.Port)), nil
 161         case *syscall.SockaddrInet6:
 162                 return JoinHostPort(IP(a.Addr[0:]).String(), itoa(a.Port)), nil
 163         case *syscall.SockaddrUnix:
 164                 return a.Name, nil
 165         }
 166
 167         return "", &UnknownSocketError{sa}
 168 }