111 lines
3.3 KiB
Go
111 lines
3.3 KiB
Go
package netlink
|
|
|
|
import (
|
|
"fmt"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/vishvananda/netlink/nl"
|
|
"github.com/vishvananda/netns"
|
|
)
|
|
|
|
// Empty handle used by the netlink package methods
|
|
var pkgHandle = &Handle{}
|
|
|
|
// Handle is an handle for the netlink requests on a
|
|
// specific network namespace. All the requests on the
|
|
// same netlink family share the same netlink socket,
|
|
// which gets released when the handle is deleted.
|
|
type Handle struct {
|
|
sockets map[int]*nl.SocketHandle
|
|
lookupByDump bool
|
|
}
|
|
|
|
// SupportsNetlinkFamily reports whether the passed netlink family is supported by this Handle
|
|
func (h *Handle) SupportsNetlinkFamily(nlFamily int) bool {
|
|
_, ok := h.sockets[nlFamily]
|
|
return ok
|
|
}
|
|
|
|
// NewHandle returns a netlink handle on the current network namespace.
|
|
// Caller may specify the netlink families the handle should support.
|
|
// If no families are specified, all the families the netlink package
|
|
// supports will be automatically added.
|
|
func NewHandle(nlFamilies ...int) (*Handle, error) {
|
|
return newHandle(netns.None(), netns.None(), nlFamilies...)
|
|
}
|
|
|
|
// SetSocketTimeout sets the send and receive timeout for each socket in the
|
|
// netlink handle. Although the socket timeout has granularity of one
|
|
// microsecond, the effective granularity is floored by the kernel timer tick,
|
|
// which default value is four milliseconds.
|
|
func (h *Handle) SetSocketTimeout(to time.Duration) error {
|
|
if to < time.Microsecond {
|
|
return fmt.Errorf("invalid timeout, minimul value is %s", time.Microsecond)
|
|
}
|
|
tv := syscall.NsecToTimeval(to.Nanoseconds())
|
|
for _, sh := range h.sockets {
|
|
fd := sh.Socket.GetFd()
|
|
err := syscall.SetsockoptTimeval(fd, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &tv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = syscall.SetsockoptTimeval(fd, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &tv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// NewHandle returns a netlink handle on the network namespace
|
|
// specified by ns. If ns=netns.None(), current network namespace
|
|
// will be assumed
|
|
func NewHandleAt(ns netns.NsHandle, nlFamilies ...int) (*Handle, error) {
|
|
return newHandle(ns, netns.None(), nlFamilies...)
|
|
}
|
|
|
|
// NewHandleAtFrom works as NewHandle but allows client to specify the
|
|
// new and the origin netns Handle.
|
|
func NewHandleAtFrom(newNs, curNs netns.NsHandle) (*Handle, error) {
|
|
return newHandle(newNs, curNs)
|
|
}
|
|
|
|
func newHandle(newNs, curNs netns.NsHandle, nlFamilies ...int) (*Handle, error) {
|
|
h := &Handle{sockets: map[int]*nl.SocketHandle{}}
|
|
fams := nl.SupportedNlFamilies
|
|
if len(nlFamilies) != 0 {
|
|
fams = nlFamilies
|
|
}
|
|
for _, f := range fams {
|
|
s, err := nl.GetNetlinkSocketAt(newNs, curNs, f)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
h.sockets[f] = &nl.SocketHandle{Socket: s}
|
|
}
|
|
return h, nil
|
|
}
|
|
|
|
// Delete releases the resources allocated to this handle
|
|
func (h *Handle) Delete() {
|
|
for _, sh := range h.sockets {
|
|
sh.Close()
|
|
}
|
|
h.sockets = nil
|
|
}
|
|
|
|
func (h *Handle) newNetlinkRequest(proto, flags int) *nl.NetlinkRequest {
|
|
// Do this so that package API still use nl package variable nextSeqNr
|
|
if h.sockets == nil {
|
|
return nl.NewNetlinkRequest(proto, flags)
|
|
}
|
|
return &nl.NetlinkRequest{
|
|
NlMsghdr: syscall.NlMsghdr{
|
|
Len: uint32(syscall.SizeofNlMsghdr),
|
|
Type: uint16(proto),
|
|
Flags: syscall.NLM_F_REQUEST | uint16(flags),
|
|
},
|
|
Sockets: h.sockets,
|
|
}
|
|
}
|