github.com/code-reading/golang@v0.0.0-20220303082512-ba5bc0e589a3/go/src/net/interface_bsd.go (about)

     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  //go:build darwin || dragonfly || freebsd || netbsd || openbsd
     6  // +build darwin dragonfly freebsd netbsd openbsd
     7  
     8  package net
     9  
    10  import (
    11  	"syscall"
    12  
    13  	"golang.org/x/net/route"
    14  )
    15  
    16  // If the ifindex is zero, interfaceTable returns mappings of all
    17  // network interfaces. Otherwise it returns a mapping of a specific
    18  // interface.
    19  func interfaceTable(ifindex int) ([]Interface, error) {
    20  	msgs, err := interfaceMessages(ifindex)
    21  	if err != nil {
    22  		return nil, err
    23  	}
    24  	n := len(msgs)
    25  	if ifindex != 0 {
    26  		n = 1
    27  	}
    28  	ift := make([]Interface, n)
    29  	n = 0
    30  	for _, m := range msgs {
    31  		switch m := m.(type) {
    32  		case *route.InterfaceMessage:
    33  			if ifindex != 0 && ifindex != m.Index {
    34  				continue
    35  			}
    36  			ift[n].Index = m.Index
    37  			ift[n].Name = m.Name
    38  			ift[n].Flags = linkFlags(m.Flags)
    39  			if sa, ok := m.Addrs[syscall.RTAX_IFP].(*route.LinkAddr); ok && len(sa.Addr) > 0 {
    40  				ift[n].HardwareAddr = make([]byte, len(sa.Addr))
    41  				copy(ift[n].HardwareAddr, sa.Addr)
    42  			}
    43  			for _, sys := range m.Sys() {
    44  				if imx, ok := sys.(*route.InterfaceMetrics); ok {
    45  					ift[n].MTU = imx.MTU
    46  					break
    47  				}
    48  			}
    49  			n++
    50  			if ifindex == m.Index {
    51  				return ift[:n], nil
    52  			}
    53  		}
    54  	}
    55  	return ift[:n], nil
    56  }
    57  
    58  func linkFlags(rawFlags int) Flags {
    59  	var f Flags
    60  	if rawFlags&syscall.IFF_UP != 0 {
    61  		f |= FlagUp
    62  	}
    63  	if rawFlags&syscall.IFF_BROADCAST != 0 {
    64  		f |= FlagBroadcast
    65  	}
    66  	if rawFlags&syscall.IFF_LOOPBACK != 0 {
    67  		f |= FlagLoopback
    68  	}
    69  	if rawFlags&syscall.IFF_POINTOPOINT != 0 {
    70  		f |= FlagPointToPoint
    71  	}
    72  	if rawFlags&syscall.IFF_MULTICAST != 0 {
    73  		f |= FlagMulticast
    74  	}
    75  	return f
    76  }
    77  
    78  // If the ifi is nil, interfaceAddrTable returns addresses for all
    79  // network interfaces. Otherwise it returns addresses for a specific
    80  // interface.
    81  func interfaceAddrTable(ifi *Interface) ([]Addr, error) {
    82  	index := 0
    83  	if ifi != nil {
    84  		index = ifi.Index
    85  	}
    86  	msgs, err := interfaceMessages(index)
    87  	if err != nil {
    88  		return nil, err
    89  	}
    90  	ifat := make([]Addr, 0, len(msgs))
    91  	for _, m := range msgs {
    92  		switch m := m.(type) {
    93  		case *route.InterfaceAddrMessage:
    94  			if index != 0 && index != m.Index {
    95  				continue
    96  			}
    97  			var mask IPMask
    98  			switch sa := m.Addrs[syscall.RTAX_NETMASK].(type) {
    99  			case *route.Inet4Addr:
   100  				mask = IPv4Mask(sa.IP[0], sa.IP[1], sa.IP[2], sa.IP[3])
   101  			case *route.Inet6Addr:
   102  				mask = make(IPMask, IPv6len)
   103  				copy(mask, sa.IP[:])
   104  			}
   105  			var ip IP
   106  			switch sa := m.Addrs[syscall.RTAX_IFA].(type) {
   107  			case *route.Inet4Addr:
   108  				ip = IPv4(sa.IP[0], sa.IP[1], sa.IP[2], sa.IP[3])
   109  			case *route.Inet6Addr:
   110  				ip = make(IP, IPv6len)
   111  				copy(ip, sa.IP[:])
   112  			}
   113  			if ip != nil && mask != nil { // NetBSD may contain route.LinkAddr
   114  				ifat = append(ifat, &IPNet{IP: ip, Mask: mask})
   115  			}
   116  		}
   117  	}
   118  	return ifat, nil
   119  }