mirror of
https://github.com/tailscale/tailscale.git
synced 2024-12-01 22:15:51 +00:00
117 lines
2.7 KiB
Go
117 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.
|
|
|
|
// +build !windows
|
|
|
|
// 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):
|
|
}
|
|
}
|
|
}
|