sys_posix.go

Documentation: golang.org/x/net/internal/socket

     1  // Copyright 2017 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  //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows || zos
     6  
     7  package socket
     8  
     9  import (
    10  	"encoding/binary"
    11  	"errors"
    12  	"net"
    13  	"runtime"
    14  	"strconv"
    15  	"sync"
    16  	"time"
    17  )
    18  
    19  // marshalInetAddr writes a in sockaddr format into the buffer b.
    20  // The buffer must be sufficiently large (sizeofSockaddrInet4/6).
    21  // Returns the number of bytes written.
    22  func marshalInetAddr(a net.Addr, b []byte) int {
    23  	switch a := a.(type) {
    24  	case *net.TCPAddr:
    25  		return marshalSockaddr(a.IP, a.Port, a.Zone, b)
    26  	case *net.UDPAddr:
    27  		return marshalSockaddr(a.IP, a.Port, a.Zone, b)
    28  	case *net.IPAddr:
    29  		return marshalSockaddr(a.IP, 0, a.Zone, b)
    30  	default:
    31  		return 0
    32  	}
    33  }
    34  
    35  func marshalSockaddr(ip net.IP, port int, zone string, b []byte) int {
    36  	if ip4 := ip.To4(); ip4 != nil {
    37  		switch runtime.GOOS {
    38  		case "android", "illumos", "linux", "solaris", "windows":
    39  			NativeEndian.PutUint16(b[:2], uint16(sysAF_INET))
    40  		default:
    41  			b[0] = sizeofSockaddrInet4
    42  			b[1] = sysAF_INET
    43  		}
    44  		binary.BigEndian.PutUint16(b[2:4], uint16(port))
    45  		copy(b[4:8], ip4)
    46  		return sizeofSockaddrInet4
    47  	}
    48  	if ip6 := ip.To16(); ip6 != nil && ip.To4() == nil {
    49  		switch runtime.GOOS {
    50  		case "android", "illumos", "linux", "solaris", "windows":
    51  			NativeEndian.PutUint16(b[:2], uint16(sysAF_INET6))
    52  		default:
    53  			b[0] = sizeofSockaddrInet6
    54  			b[1] = sysAF_INET6
    55  		}
    56  		binary.BigEndian.PutUint16(b[2:4], uint16(port))
    57  		copy(b[8:24], ip6)
    58  		if zone != "" {
    59  			NativeEndian.PutUint32(b[24:28], uint32(zoneCache.index(zone)))
    60  		}
    61  		return sizeofSockaddrInet6
    62  	}
    63  	return 0
    64  }
    65  
    66  func parseInetAddr(b []byte, network string) (net.Addr, error) {
    67  	if len(b) < 2 {
    68  		return nil, errors.New("invalid address")
    69  	}
    70  	var af int
    71  	switch runtime.GOOS {
    72  	case "android", "illumos", "linux", "solaris", "windows":
    73  		af = int(NativeEndian.Uint16(b[:2]))
    74  	default:
    75  		af = int(b[1])
    76  	}
    77  	var ip net.IP
    78  	var zone string
    79  	if af == sysAF_INET {
    80  		if len(b) < sizeofSockaddrInet4 {
    81  			return nil, errors.New("short address")
    82  		}
    83  		ip = make(net.IP, net.IPv4len)
    84  		copy(ip, b[4:8])
    85  	}
    86  	if af == sysAF_INET6 {
    87  		if len(b) < sizeofSockaddrInet6 {
    88  			return nil, errors.New("short address")
    89  		}
    90  		ip = make(net.IP, net.IPv6len)
    91  		copy(ip, b[8:24])
    92  		if id := int(NativeEndian.Uint32(b[24:28])); id > 0 {
    93  			zone = zoneCache.name(id)
    94  		}
    95  	}
    96  	switch network {
    97  	case "tcp", "tcp4", "tcp6":
    98  		return &net.TCPAddr{IP: ip, Port: int(binary.BigEndian.Uint16(b[2:4])), Zone: zone}, nil
    99  	case "udp", "udp4", "udp6":
   100  		return &net.UDPAddr{IP: ip, Port: int(binary.BigEndian.Uint16(b[2:4])), Zone: zone}, nil
   101  	default:
   102  		return &net.IPAddr{IP: ip, Zone: zone}, nil
   103  	}
   104  }
   105  
   106  // An ipv6ZoneCache represents a cache holding partial network
   107  // interface information. It is used for reducing the cost of IPv6
   108  // addressing scope zone resolution.
   109  //
   110  // Multiple names sharing the index are managed by first-come
   111  // first-served basis for consistency.
   112  type ipv6ZoneCache struct {
   113  	sync.RWMutex                // guard the following
   114  	lastFetched  time.Time      // last time routing information was fetched
   115  	toIndex      map[string]int // interface name to its index
   116  	toName       map[int]string // interface index to its name
   117  }
   118  
   119  var zoneCache = ipv6ZoneCache{
   120  	toIndex: make(map[string]int),
   121  	toName:  make(map[int]string),
   122  }
   123  
   124  // update refreshes the network interface information if the cache was last
   125  // updated more than 1 minute ago, or if force is set. It returns whether the
   126  // cache was updated.
   127  func (zc *ipv6ZoneCache) update(ift []net.Interface, force bool) (updated bool) {
   128  	zc.Lock()
   129  	defer zc.Unlock()
   130  	now := time.Now()
   131  	if !force && zc.lastFetched.After(now.Add(-60*time.Second)) {
   132  		return false
   133  	}
   134  	zc.lastFetched = now
   135  	if len(ift) == 0 {
   136  		var err error
   137  		if ift, err = net.Interfaces(); err != nil {
   138  			return false
   139  		}
   140  	}
   141  	zc.toIndex = make(map[string]int, len(ift))
   142  	zc.toName = make(map[int]string, len(ift))
   143  	for _, ifi := range ift {
   144  		zc.toIndex[ifi.Name] = ifi.Index
   145  		if _, ok := zc.toName[ifi.Index]; !ok {
   146  			zc.toName[ifi.Index] = ifi.Name
   147  		}
   148  	}
   149  	return true
   150  }
   151  
   152  func (zc *ipv6ZoneCache) name(zone int) string {
   153  	updated := zoneCache.update(nil, false)
   154  	zoneCache.RLock()
   155  	name, ok := zoneCache.toName[zone]
   156  	zoneCache.RUnlock()
   157  	if !ok && !updated {
   158  		zoneCache.update(nil, true)
   159  		zoneCache.RLock()
   160  		name, ok = zoneCache.toName[zone]
   161  		zoneCache.RUnlock()
   162  	}
   163  	if !ok { // last resort
   164  		name = strconv.Itoa(zone)
   165  	}
   166  	return name
   167  }
   168  
   169  func (zc *ipv6ZoneCache) index(zone string) int {
   170  	updated := zoneCache.update(nil, false)
   171  	zoneCache.RLock()
   172  	index, ok := zoneCache.toIndex[zone]
   173  	zoneCache.RUnlock()
   174  	if !ok && !updated {
   175  		zoneCache.update(nil, true)
   176  		zoneCache.RLock()
   177  		index, ok = zoneCache.toIndex[zone]
   178  		zoneCache.RUnlock()
   179  	}
   180  	if !ok { // last resort
   181  		index, _ = strconv.Atoi(zone)
   182  	}
   183  	return index
   184  }
   185
View as plain text