You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tailscale/wgengine/rtnlmon/mon.go

115 lines
2.7 KiB
Go

// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package rtnlmon watches for "interesting" changes to the network
// stack and fires a callback.
package rtnlmon
import (
"fmt"
"time"
"github.com/mdlayher/netlink"
"golang.org/x/sys/unix"
"tailscale.com/logger"
)
// Netlink is not a great protocol for *knowing* things. The protocol
// design makes it impossible to track changes precisely. You can see
// this by looking at things like Quagga or Bird, which all include
// keeping a local impression of what they think is in the kernel, and
// periodically doing a full state dump to find errors. They do use
// events, but explicitly only as an optimization, because they can't
// be trusted.
//
// Fortunately, we don't really need to know what exactly changed. We
// just want to know that network conditions may have changed, and we
// should re-explore connectivity. This is why we subscribe to events,
// and then blindly fire our callback without looking at the content
// of the notifications.
type ChangeFunc func()
type Mon struct {
logf logger.Logf
cb ChangeFunc
nl *netlink.Conn
change chan struct{}
stop chan struct{}
}
func New(logf logger.Logf, callback ChangeFunc) (*Mon, error) {
conn, err := netlink.Dial(unix.NETLINK_ROUTE, &netlink.Config{
// IPv4 address and route changes. Routes get us most of the
// events of interest, but we need address as well to cover
// things like DHCP deciding to give us a new address upon
// renewal - routing wouldn't change, but all reachability
// would.
//
// Why magic numbers? These aren't exposed in x/sys/unix
// yet. The values come from rtnetlink.h, RTMGRP_IPV4_IFADDR
// and RTMGRP_IPV4_ROUTE.
Groups: 0x10 | 0x40,
})
if err != nil {
return nil, fmt.Errorf("dialing netlink socket: %v", err)
}
ret := &Mon{
logf: logf,
cb: callback,
nl: conn,
change: make(chan struct{}, 1),
stop: make(chan struct{}),
}
go ret.pump()
go ret.debounce()
return ret, nil
}
func (m *Mon) Close() error {
close(m.stop)
return m.nl.Close()
}
func (m *Mon) pump() {
for {
_, err := m.nl.Receive()
if err != nil {
select {
case <-m.stop:
return
default:
}
// Keep retrying while we're not closed.
m.logf("Error receiving from netlink: %v", err)
time.Sleep(time.Second)
continue
}
select {
case m.change <- struct{}{}:
default:
}
}
}
func (m *Mon) debounce() {
for {
select {
case <-m.stop:
return
case <-m.change:
}
m.cb()
select {
case <-m.stop:
return
case <-time.After(100 * time.Millisecond):
}
}
}