libgo/go/net/sockopt_posix.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 // +build darwin freebsd linux netbsd openbsd windows
   6
   7 // Socket options
   8
   9 package net
  10
  11 import (
  12         "os"
  13         "syscall"
  14 )
  15
  16 // Boolean to int.
  17 func boolint(b bool) int {
  18         if b {
  19                 return 1
  20         }
  21         return 0
  22 }
  23
  24 func ipv4AddrToInterface(ip IP) (*Interface, error) {
  25         ift, err := Interfaces()
  26         if err != nil {
  27                 return nil, err
  28         }
  29         for _, ifi := range ift {
  30                 ifat, err := ifi.Addrs()
  31                 if err != nil {
  32                         return nil, err
  33                 }
  34                 for _, ifa := range ifat {
  35                         switch v := ifa.(type) {
  36                         case *IPAddr:
  37                                 if ip.Equal(v.IP) {
  38                                         return &ifi, nil
  39                                 }
  40                         case *IPNet:
  41                                 if ip.Equal(v.IP) {
  42                                         return &ifi, nil
  43                                 }
  44                         }
  45                 }
  46         }
  47         if ip.Equal(IPv4zero) {
  48                 return nil, nil
  49         }
  50         return nil, errNoSuchInterface
  51 }
  52
  53 func interfaceToIPv4Addr(ifi *Interface) (IP, error) {
  54         if ifi == nil {
  55                 return IPv4zero, nil
  56         }
  57         ifat, err := ifi.Addrs()
  58         if err != nil {
  59                 return nil, err
  60         }
  61         for _, ifa := range ifat {
  62                 switch v := ifa.(type) {
  63                 case *IPAddr:
  64                         if v.IP.To4() != nil {
  65                                 return v.IP, nil
  66                         }
  67                 case *IPNet:
  68                         if v.IP.To4() != nil {
  69                                 return v.IP, nil
  70                         }
  71                 }
  72         }
  73         return nil, errNoSuchInterface
  74 }
  75
  76 func setIPv4MreqToInterface(mreq *syscall.IPMreq, ifi *Interface) error {
  77         if ifi == nil {
  78                 return nil
  79         }
  80         ifat, err := ifi.Addrs()
  81         if err != nil {
  82                 return err
  83         }
  84         for _, ifa := range ifat {
  85                 switch v := ifa.(type) {
  86                 case *IPAddr:
  87                         if a := v.IP.To4(); a != nil {
  88                                 copy(mreq.Interface[:], a)
  89                                 goto done
  90                         }
  91                 case *IPNet:
  92                         if a := v.IP.To4(); a != nil {
  93                                 copy(mreq.Interface[:], a)
  94                                 goto done
  95                         }
  96                 }
  97         }
  98 done:
  99         if bytesEqual(mreq.Multiaddr[:], IPv4zero.To4()) {
 100                 return errNoSuchMulticastInterface
 101         }
 102         return nil
 103 }
 104
 105 func setReadBuffer(fd *netFD, bytes int) error {
 106         if err := fd.incref(false); err != nil {
 107                 return err
 108         }
 109         defer fd.decref()
 110         return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bytes))
 111 }
 112
 113 func setWriteBuffer(fd *netFD, bytes int) error {
 114         if err := fd.incref(false); err != nil {
 115                 return err
 116         }
 117         defer fd.decref()
 118         return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, bytes))
 119 }
 120
 121 func setKeepAlive(fd *netFD, keepalive bool) error {
 122         if err := fd.incref(false); err != nil {
 123                 return err
 124         }
 125         defer fd.decref()
 126         return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, boolint(keepalive)))
 127 }
 128
 129 func setNoDelay(fd *netFD, noDelay bool) error {
 130         if err := fd.incref(false); err != nil {
 131                 return err
 132         }
 133         defer fd.decref()
 134         return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd.sysfd, syscall.IPPROTO_TCP, syscall.TCP_NODELAY, boolint(noDelay)))
 135 }
 136
 137 func setLinger(fd *netFD, sec int) error {
 138         var l syscall.Linger
 139         if sec >= 0 {
 140                 l.Onoff = 1
 141                 l.Linger = int32(sec)
 142         } else {
 143                 l.Onoff = 0
 144                 l.Linger = 0
 145         }
 146         if err := fd.incref(false); err != nil {
 147                 return err
 148         }
 149         defer fd.decref()
 150         return os.NewSyscallError("setsockopt", syscall.SetsockoptLinger(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_LINGER, &l))
 151 }