Source file src/net/interface.go

     1	// Copyright 2011 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		"sync"
    10		"time"
    11	)
    12	
    13	// BUG(mikio): On JS and NaCl, methods and functions related to
    14	// Interface are not implemented.
    15	
    16	// BUG(mikio): On AIX, DragonFly BSD, NetBSD, OpenBSD, Plan 9 and
    17	// Solaris, the MulticastAddrs method of Interface is not implemented.
    18	
    19	var (
    20		errInvalidInterface         = errors.New("invalid network interface")
    21		errInvalidInterfaceIndex    = errors.New("invalid network interface index")
    22		errInvalidInterfaceName     = errors.New("invalid network interface name")
    23		errNoSuchInterface          = errors.New("no such network interface")
    24		errNoSuchMulticastInterface = errors.New("no such multicast network interface")
    25	)
    26	
    27	// Interface represents a mapping between network interface name
    28	// and index. It also represents network interface facility
    29	// information.
    30	type Interface struct {
    31		Index        int          // positive integer that starts at one, zero is never used
    32		MTU          int          // maximum transmission unit
    33		Name         string       // e.g., "en0", "lo0", "eth0.100"
    34		HardwareAddr HardwareAddr // IEEE MAC-48, EUI-48 and EUI-64 form
    35		Flags        Flags        // e.g., FlagUp, FlagLoopback, FlagMulticast
    36	}
    37	
    38	type Flags uint
    39	
    40	const (
    41		FlagUp           Flags = 1 << iota // interface is up
    42		FlagBroadcast                      // interface supports broadcast access capability
    43		FlagLoopback                       // interface is a loopback interface
    44		FlagPointToPoint                   // interface belongs to a point-to-point link
    45		FlagMulticast                      // interface supports multicast access capability
    46	)
    47	
    48	var flagNames = []string{
    49		"up",
    50		"broadcast",
    51		"loopback",
    52		"pointtopoint",
    53		"multicast",
    54	}
    55	
    56	func (f Flags) String() string {
    57		s := ""
    58		for i, name := range flagNames {
    59			if f&(1<<uint(i)) != 0 {
    60				if s != "" {
    61					s += "|"
    62				}
    63				s += name
    64			}
    65		}
    66		if s == "" {
    67			s = "0"
    68		}
    69		return s
    70	}
    71	
    72	// Addrs returns a list of unicast interface addresses for a specific
    73	// interface.
    74	func (ifi *Interface) Addrs() ([]Addr, error) {
    75		if ifi == nil {
    76			return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: errInvalidInterface}
    77		}
    78		ifat, err := interfaceAddrTable(ifi)
    79		if err != nil {
    80			err = &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
    81		}
    82		return ifat, err
    83	}
    84	
    85	// MulticastAddrs returns a list of multicast, joined group addresses
    86	// for a specific interface.
    87	func (ifi *Interface) MulticastAddrs() ([]Addr, error) {
    88		if ifi == nil {
    89			return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: errInvalidInterface}
    90		}
    91		ifat, err := interfaceMulticastAddrTable(ifi)
    92		if err != nil {
    93			err = &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
    94		}
    95		return ifat, err
    96	}
    97	
    98	// Interfaces returns a list of the system's network interfaces.
    99	func Interfaces() ([]Interface, error) {
   100		ift, err := interfaceTable(0)
   101		if err != nil {
   102			return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
   103		}
   104		if len(ift) != 0 {
   105			zoneCache.update(ift, false)
   106		}
   107		return ift, nil
   108	}
   109	
   110	// InterfaceAddrs returns a list of the system's unicast interface
   111	// addresses.
   112	//
   113	// The returned list does not identify the associated interface; use
   114	// Interfaces and Interface.Addrs for more detail.
   115	func InterfaceAddrs() ([]Addr, error) {
   116		ifat, err := interfaceAddrTable(nil)
   117		if err != nil {
   118			err = &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
   119		}
   120		return ifat, err
   121	}
   122	
   123	// InterfaceByIndex returns the interface specified by index.
   124	//
   125	// On Solaris, it returns one of the logical network interfaces
   126	// sharing the logical data link; for more precision use
   127	// InterfaceByName.
   128	func InterfaceByIndex(index int) (*Interface, error) {
   129		if index <= 0 {
   130			return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: errInvalidInterfaceIndex}
   131		}
   132		ift, err := interfaceTable(index)
   133		if err != nil {
   134			return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
   135		}
   136		ifi, err := interfaceByIndex(ift, index)
   137		if err != nil {
   138			err = &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
   139		}
   140		return ifi, err
   141	}
   142	
   143	func interfaceByIndex(ift []Interface, index int) (*Interface, error) {
   144		for _, ifi := range ift {
   145			if index == ifi.Index {
   146				return &ifi, nil
   147			}
   148		}
   149		return nil, errNoSuchInterface
   150	}
   151	
   152	// InterfaceByName returns the interface specified by name.
   153	func InterfaceByName(name string) (*Interface, error) {
   154		if name == "" {
   155			return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: errInvalidInterfaceName}
   156		}
   157		ift, err := interfaceTable(0)
   158		if err != nil {
   159			return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
   160		}
   161		if len(ift) != 0 {
   162			zoneCache.update(ift, false)
   163		}
   164		for _, ifi := range ift {
   165			if name == ifi.Name {
   166				return &ifi, nil
   167			}
   168		}
   169		return nil, &OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: errNoSuchInterface}
   170	}
   171	
   172	// An ipv6ZoneCache represents a cache holding partial network
   173	// interface information. It is used for reducing the cost of IPv6
   174	// addressing scope zone resolution.
   175	//
   176	// Multiple names sharing the index are managed by first-come
   177	// first-served basis for consistency.
   178	type ipv6ZoneCache struct {
   179		sync.RWMutex                // guard the following
   180		lastFetched  time.Time      // last time routing information was fetched
   181		toIndex      map[string]int // interface name to its index
   182		toName       map[int]string // interface index to its name
   183	}
   184	
   185	var zoneCache = ipv6ZoneCache{
   186		toIndex: make(map[string]int),
   187		toName:  make(map[int]string),
   188	}
   189	
   190	// update refreshes the network interface information if the cache was last
   191	// updated more than 1 minute ago, or if force is set. It reports whether the
   192	// cache was updated.
   193	func (zc *ipv6ZoneCache) update(ift []Interface, force bool) (updated bool) {
   194		zc.Lock()
   195		defer zc.Unlock()
   196		now := time.Now()
   197		if !force && zc.lastFetched.After(now.Add(-60*time.Second)) {
   198			return false
   199		}
   200		zc.lastFetched = now
   201		if len(ift) == 0 {
   202			var err error
   203			if ift, err = interfaceTable(0); err != nil {
   204				return false
   205			}
   206		}
   207		zc.toIndex = make(map[string]int, len(ift))
   208		zc.toName = make(map[int]string, len(ift))
   209		for _, ifi := range ift {
   210			zc.toIndex[ifi.Name] = ifi.Index
   211			if _, ok := zc.toName[ifi.Index]; !ok {
   212				zc.toName[ifi.Index] = ifi.Name
   213			}
   214		}
   215		return true
   216	}
   217	
   218	func (zc *ipv6ZoneCache) name(index int) string {
   219		if index == 0 {
   220			return ""
   221		}
   222		updated := zoneCache.update(nil, false)
   223		zoneCache.RLock()
   224		name, ok := zoneCache.toName[index]
   225		zoneCache.RUnlock()
   226		if !ok && !updated {
   227			zoneCache.update(nil, true)
   228			zoneCache.RLock()
   229			name, ok = zoneCache.toName[index]
   230			zoneCache.RUnlock()
   231		}
   232		if !ok { // last resort
   233			name = uitoa(uint(index))
   234		}
   235		return name
   236	}
   237	
   238	func (zc *ipv6ZoneCache) index(name string) int {
   239		if name == "" {
   240			return 0
   241		}
   242		updated := zoneCache.update(nil, false)
   243		zoneCache.RLock()
   244		index, ok := zoneCache.toIndex[name]
   245		zoneCache.RUnlock()
   246		if !ok && !updated {
   247			zoneCache.update(nil, true)
   248			zoneCache.RLock()
   249			index, ok = zoneCache.toIndex[name]
   250			zoneCache.RUnlock()
   251		}
   252		if !ok { // last resort
   253			index, _, _ = dtoi(name)
   254		}
   255		return index
   256	}
   257	

View as plain text