mirror of
https://github.com/vishvananda/netlink
synced 2024-12-27 00:52:11 +00:00
916f9685fa
When listening for IPv6 address changes, I found that subscribe is not returning when there is message in the socket. After some researching, I found that libnl suggest setting socket to non-blocking when subscribing to groups. (Ref)[https://www.infradead.org/~tgr/libnl/doc/core.html#:~:text=best%20to%20put%20the%20socket%20in%20non-blocking%20mode] Also fixed test related to BareUDP, which requires "bareudp" kmod. (Ref)[https://www.kernelconfig.io/config_bareudp]
106 lines
1.9 KiB
Go
106 lines
1.9 KiB
Go
package netlink
|
|
|
|
import (
|
|
"fmt"
|
|
"syscall"
|
|
|
|
"github.com/vishvananda/netlink/nl"
|
|
"github.com/vishvananda/netns"
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
type XfrmMsg interface {
|
|
Type() nl.XfrmMsgType
|
|
}
|
|
|
|
type XfrmMsgExpire struct {
|
|
XfrmState *XfrmState
|
|
Hard bool
|
|
}
|
|
|
|
func (ue *XfrmMsgExpire) Type() nl.XfrmMsgType {
|
|
return nl.XFRM_MSG_EXPIRE
|
|
}
|
|
|
|
func parseXfrmMsgExpire(b []byte) *XfrmMsgExpire {
|
|
var e XfrmMsgExpire
|
|
|
|
msg := nl.DeserializeXfrmUserExpire(b)
|
|
e.XfrmState = xfrmStateFromXfrmUsersaInfo(&msg.XfrmUsersaInfo)
|
|
e.Hard = msg.Hard == 1
|
|
|
|
return &e
|
|
}
|
|
|
|
func XfrmMonitor(ch chan<- XfrmMsg, done <-chan struct{}, errorChan chan<- error,
|
|
types ...nl.XfrmMsgType) error {
|
|
|
|
groups, err := xfrmMcastGroups(types)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
s, err := nl.SubscribeAt(netns.None(), netns.None(), unix.NETLINK_XFRM, groups...)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if done != nil {
|
|
go func() {
|
|
<-done
|
|
s.Close()
|
|
}()
|
|
|
|
}
|
|
|
|
go func() {
|
|
defer close(ch)
|
|
for {
|
|
msgs, from, err := s.Receive()
|
|
if err != nil {
|
|
if err == syscall.EAGAIN {
|
|
continue
|
|
}
|
|
errorChan <- err
|
|
return
|
|
}
|
|
if from.Pid != nl.PidKernel {
|
|
errorChan <- fmt.Errorf("Wrong sender portid %d, expected %d", from.Pid, nl.PidKernel)
|
|
return
|
|
}
|
|
for _, m := range msgs {
|
|
switch m.Header.Type {
|
|
case nl.XFRM_MSG_EXPIRE:
|
|
ch <- parseXfrmMsgExpire(m.Data)
|
|
default:
|
|
errorChan <- fmt.Errorf("unsupported msg type: %x", m.Header.Type)
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
func xfrmMcastGroups(types []nl.XfrmMsgType) ([]uint, error) {
|
|
groups := make([]uint, 0)
|
|
|
|
if len(types) == 0 {
|
|
return nil, fmt.Errorf("no xfrm msg type specified")
|
|
}
|
|
|
|
for _, t := range types {
|
|
var group uint
|
|
|
|
switch t {
|
|
case nl.XFRM_MSG_EXPIRE:
|
|
group = nl.XFRMNLGRP_EXPIRE
|
|
default:
|
|
return nil, fmt.Errorf("unsupported group: %x", t)
|
|
}
|
|
|
|
groups = append(groups, group)
|
|
}
|
|
|
|
return groups, nil
|
|
}
|