github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/sys/unix/bpf_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  // +build darwin dragonfly freebsd netbsd openbsd
     6  
     7  // Berkeley packet filter for BSD variants
     8  
     9  package unix
    10  
    11  import (
    12  	"syscall"
    13  	"unsafe"
    14  )
    15  
    16  func BpfStmt(code, k int) *BpfInsn {
    17  	return &BpfInsn{Code: uint16(code), K: uint32(k)}
    18  }
    19  
    20  func BpfJump(code, k, jt, jf int) *BpfInsn {
    21  	return &BpfInsn{Code: uint16(code), Jt: uint8(jt), Jf: uint8(jf), K: uint32(k)}
    22  }
    23  
    24  func BpfBuflen(fd int) (int, error) {
    25  	var l int
    26  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCGBLEN, uintptr(unsafe.Pointer(&l)))
    27  	if err != 0 {
    28  		return 0, syscall.Errno(err)
    29  	}
    30  	return l, nil
    31  }
    32  
    33  func SetBpfBuflen(fd, l int) (int, error) {
    34  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCSBLEN, uintptr(unsafe.Pointer(&l)))
    35  	if err != 0 {
    36  		return 0, syscall.Errno(err)
    37  	}
    38  	return l, nil
    39  }
    40  
    41  func BpfDatalink(fd int) (int, error) {
    42  	var t int
    43  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCGDLT, uintptr(unsafe.Pointer(&t)))
    44  	if err != 0 {
    45  		return 0, syscall.Errno(err)
    46  	}
    47  	return t, nil
    48  }
    49  
    50  func SetBpfDatalink(fd, t int) (int, error) {
    51  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCSDLT, uintptr(unsafe.Pointer(&t)))
    52  	if err != 0 {
    53  		return 0, syscall.Errno(err)
    54  	}
    55  	return t, nil
    56  }
    57  
    58  func SetBpfPromisc(fd, m int) error {
    59  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCPROMISC, uintptr(unsafe.Pointer(&m)))
    60  	if err != 0 {
    61  		return syscall.Errno(err)
    62  	}
    63  	return nil
    64  }
    65  
    66  func FlushBpf(fd int) error {
    67  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCFLUSH, 0)
    68  	if err != 0 {
    69  		return syscall.Errno(err)
    70  	}
    71  	return nil
    72  }
    73  
    74  type ivalue struct {
    75  	name  [IFNAMSIZ]byte
    76  	value int16
    77  }
    78  
    79  func BpfInterface(fd int, name string) (string, error) {
    80  	var iv ivalue
    81  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCGETIF, uintptr(unsafe.Pointer(&iv)))
    82  	if err != 0 {
    83  		return "", syscall.Errno(err)
    84  	}
    85  	return name, nil
    86  }
    87  
    88  func SetBpfInterface(fd int, name string) error {
    89  	var iv ivalue
    90  	copy(iv.name[:], []byte(name))
    91  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCSETIF, uintptr(unsafe.Pointer(&iv)))
    92  	if err != 0 {
    93  		return syscall.Errno(err)
    94  	}
    95  	return nil
    96  }
    97  
    98  func BpfTimeout(fd int) (*Timeval, error) {
    99  	var tv Timeval
   100  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCGRTIMEOUT, uintptr(unsafe.Pointer(&tv)))
   101  	if err != 0 {
   102  		return nil, syscall.Errno(err)
   103  	}
   104  	return &tv, nil
   105  }
   106  
   107  func SetBpfTimeout(fd int, tv *Timeval) error {
   108  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCSRTIMEOUT, uintptr(unsafe.Pointer(tv)))
   109  	if err != 0 {
   110  		return syscall.Errno(err)
   111  	}
   112  	return nil
   113  }
   114  
   115  func BpfStats(fd int) (*BpfStat, error) {
   116  	var s BpfStat
   117  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCGSTATS, uintptr(unsafe.Pointer(&s)))
   118  	if err != 0 {
   119  		return nil, syscall.Errno(err)
   120  	}
   121  	return &s, nil
   122  }
   123  
   124  func SetBpfImmediate(fd, m int) error {
   125  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCIMMEDIATE, uintptr(unsafe.Pointer(&m)))
   126  	if err != 0 {
   127  		return syscall.Errno(err)
   128  	}
   129  	return nil
   130  }
   131  
   132  func SetBpf(fd int, i []BpfInsn) error {
   133  	var p BpfProgram
   134  	p.Len = uint32(len(i))
   135  	p.Insns = (*BpfInsn)(unsafe.Pointer(&i[0]))
   136  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCSETF, uintptr(unsafe.Pointer(&p)))
   137  	if err != 0 {
   138  		return syscall.Errno(err)
   139  	}
   140  	return nil
   141  }
   142  
   143  func CheckBpfVersion(fd int) error {
   144  	var v BpfVersion
   145  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCVERSION, uintptr(unsafe.Pointer(&v)))
   146  	if err != 0 {
   147  		return syscall.Errno(err)
   148  	}
   149  	if v.Major != BPF_MAJOR_VERSION || v.Minor != BPF_MINOR_VERSION {
   150  		return EINVAL
   151  	}
   152  	return nil
   153  }
   154  
   155  func BpfHeadercmpl(fd int) (int, error) {
   156  	var f int
   157  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCGHDRCMPLT, uintptr(unsafe.Pointer(&f)))
   158  	if err != 0 {
   159  		return 0, syscall.Errno(err)
   160  	}
   161  	return f, nil
   162  }
   163  
   164  func SetBpfHeadercmpl(fd, f int) error {
   165  	_, _, err := Syscall(SYS_IOCTL, uintptr(fd), BIOCSHDRCMPLT, uintptr(unsafe.Pointer(&f)))
   166  	if err != 0 {
   167  		return syscall.Errno(err)
   168  	}
   169  	return nil
   170  }