src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

ifreq_linux.go (4339B)

      1 // Copyright 2021 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 linux
      6 
      7 package unix
      8 
      9 import (
     10 	"unsafe"
     11 )
     12 
     13 // Helpers for dealing with ifreq since it contains a union and thus requires a
     14 // lot of unsafe.Pointer casts to use properly.
     15 
     16 // An Ifreq is a type-safe wrapper around the raw ifreq struct. An Ifreq
     17 // contains an interface name and a union of arbitrary data which can be
     18 // accessed using the Ifreq's methods. To create an Ifreq, use the NewIfreq
     19 // function.
     20 //
     21 // Use the Name method to access the stored interface name. The union data
     22 // fields can be get and set using the following methods:
     23 //   - Uint16/SetUint16: flags
     24 //   - Uint32/SetUint32: ifindex, metric, mtu
     25 type Ifreq struct{ raw ifreq }
     26 
     27 // NewIfreq creates an Ifreq with the input network interface name after
     28 // validating the name does not exceed IFNAMSIZ-1 (trailing NULL required)
     29 // bytes.
     30 func NewIfreq(name string) (*Ifreq, error) {
     31 	// Leave room for terminating NULL byte.
     32 	if len(name) >= IFNAMSIZ {
     33 		return nil, EINVAL
     34 	}
     35 
     36 	var ifr ifreq
     37 	copy(ifr.Ifrn[:], name)
     38 
     39 	return &Ifreq{raw: ifr}, nil
     40 }
     41 
     42 // TODO(mdlayher): get/set methods for hardware address sockaddr, char array, etc.
     43 
     44 // Name returns the interface name associated with the Ifreq.
     45 func (ifr *Ifreq) Name() string {
     46 	return ByteSliceToString(ifr.raw.Ifrn[:])
     47 }
     48 
     49 // According to netdevice(7), only AF_INET addresses are returned for numerous
     50 // sockaddr ioctls. For convenience, we expose these as Inet4Addr since the Port
     51 // field and other data is always empty.
     52 
     53 // Inet4Addr returns the Ifreq union data from an embedded sockaddr as a C
     54 // in_addr/Go []byte (4-byte IPv4 address) value. If the sockaddr family is not
     55 // AF_INET, an error is returned.
     56 func (ifr *Ifreq) Inet4Addr() ([]byte, error) {
     57 	raw := *(*RawSockaddrInet4)(unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]))
     58 	if raw.Family != AF_INET {
     59 		// Cannot safely interpret raw.Addr bytes as an IPv4 address.
     60 		return nil, EINVAL
     61 	}
     62 
     63 	return raw.Addr[:], nil
     64 }
     65 
     66 // SetInet4Addr sets a C in_addr/Go []byte (4-byte IPv4 address) value in an
     67 // embedded sockaddr within the Ifreq's union data. v must be 4 bytes in length
     68 // or an error will be returned.
     69 func (ifr *Ifreq) SetInet4Addr(v []byte) error {
     70 	if len(v) != 4 {
     71 		return EINVAL
     72 	}
     73 
     74 	var addr [4]byte
     75 	copy(addr[:], v)
     76 
     77 	ifr.clear()
     78 	*(*RawSockaddrInet4)(
     79 		unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]),
     80 	) = RawSockaddrInet4{
     81 		// Always set IP family as ioctls would require it anyway.
     82 		Family: AF_INET,
     83 		Addr:   addr,
     84 	}
     85 
     86 	return nil
     87 }
     88 
     89 // Uint16 returns the Ifreq union data as a C short/Go uint16 value.
     90 func (ifr *Ifreq) Uint16() uint16 {
     91 	return *(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0]))
     92 }
     93 
     94 // SetUint16 sets a C short/Go uint16 value as the Ifreq's union data.
     95 func (ifr *Ifreq) SetUint16(v uint16) {
     96 	ifr.clear()
     97 	*(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0])) = v
     98 }
     99 
    100 // Uint32 returns the Ifreq union data as a C int/Go uint32 value.
    101 func (ifr *Ifreq) Uint32() uint32 {
    102 	return *(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0]))
    103 }
    104 
    105 // SetUint32 sets a C int/Go uint32 value as the Ifreq's union data.
    106 func (ifr *Ifreq) SetUint32(v uint32) {
    107 	ifr.clear()
    108 	*(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0])) = v
    109 }
    110 
    111 // clear zeroes the ifreq's union field to prevent trailing garbage data from
    112 // being sent to the kernel if an ifreq is reused.
    113 func (ifr *Ifreq) clear() {
    114 	clear(ifr.raw.Ifru[:])
    115 }
    116 
    117 // TODO(mdlayher): export as IfreqData? For now we can provide helpers such as
    118 // IoctlGetEthtoolDrvinfo which use these APIs under the hood.
    119 
    120 // An ifreqData is an Ifreq which carries pointer data. To produce an ifreqData,
    121 // use the Ifreq.withData method.
    122 type ifreqData struct {
    123 	name [IFNAMSIZ]byte
    124 	// A type separate from ifreq is required in order to comply with the
    125 	// unsafe.Pointer rules since the "pointer-ness" of data would not be
    126 	// preserved if it were cast into the byte array of a raw ifreq.
    127 	data unsafe.Pointer
    128 	// Pad to the same size as ifreq.
    129 	_ [len(ifreq{}.Ifru) - SizeofPtr]byte
    130 }
    131 
    132 // withData produces an ifreqData with the pointer p set for ioctls which require
    133 // arbitrary pointer data.
    134 func (ifr Ifreq) withData(p unsafe.Pointer) ifreqData {
    135 	return ifreqData{
    136 		name: ifr.raw.Ifrn,
    137 		data: p,
    138 	}
    139 }