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 }