mirror of
https://github.com/tailscale/tailscale.git
synced 2026-11-09 02:53:09 -05:00
Brad Fitzpatrick
2ee809d10d
The ts_omit_<name> build tags omit a feature at build time; there has
been no way to do the same at runtime. Some users (either proactively
or in response to a security announcement) might like a way to disable
a feature that's linked-in in their binaries that they're not using.
Then a mitigation announcement can say "set this env var" without
asking users to rebuild or wait for a new release.
This adds env var TS_DISABLE_FEATURE, a comma-separated list of
feature names to disable, and the listed set is reported by the
debug-optional-features LocalAPI endpoint next to the registered set.
The legacy per-feature knobs such as TS_DISABLE_SSH_SERVER and
TS_DISABLE_TAILDROP keep working independently.
A disabled feature behaves as if it had not been linked: it is absent
from feature.IsRegistered, its hooks are unset, and its extensions and
handlers are not registered. Three pieces make that happen:
* feature.Register now returns bool, false when disabled, and
feature packages gate their registration init on it. It was added
to the feature packages that never called it (including taildrop
and ssh), which also completes the picture reported by
debug-optional-features. taildrop, routecheck, favorites, and
serviceclientprefs had registration split across several inits and
now register from one gated init.
* ipnext.RegisterExtension ignores a disabled feature's extension.
* feature.Hook.Set and feature.Hooks.Add walk the call stack and
silently skip when the calling package under feature/<name> is
disabled. This covers sub-packages such as
feature/captiveportal/netcheckhook, which cannot call Register
themselves without colliding with their parent, and future
packages whose authors forget the gate.
ssh/tailssh's registrations moved from its inits into tailssh.Register,
called from feature/ssh's gated init. The aws and kube state stores and
syspolicy's Windows store registration are gated too.
feature/register_disable_test.go runs this test binary as a child
process (it links condregister, as tailscaled does) with
TS_DISABLE_FEATURE set to every registered feature at once, and fails
if any of them register anyway, so a feature that ignores the variable
cannot land.
Updates #12614
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
Change-Id: I720af6ccab844ae060a9dfd1539fee577fd483e3
110 lines
3.2 KiB
Go
110 lines
3.2 KiB
Go
// Copyright (c) Tailscale Inc & contributors
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
// Package bird integrates Tailscale with the BIRD Internet Routing
|
|
// Daemon: it enables the "tailscale" protocol in BIRD while this node
|
|
// is a primary subnet router and disables it otherwise. The BIRD
|
|
// client implementation lives in tailscale.com/chirp.
|
|
package bird
|
|
|
|
import (
|
|
"net/netip"
|
|
|
|
"tailscale.com/chirp"
|
|
"tailscale.com/feature"
|
|
"tailscale.com/tailcfg"
|
|
"tailscale.com/types/logger"
|
|
"tailscale.com/types/views"
|
|
"tailscale.com/wgengine"
|
|
)
|
|
|
|
func init() {
|
|
if !feature.Register("bird") {
|
|
return
|
|
}
|
|
wgengine.HookNewBird.Set(newBird)
|
|
}
|
|
|
|
// protocolName is the name of the BIRD protocol that Tailscale enables
|
|
// while this node is a primary subnet router.
|
|
const protocolName = "tailscale"
|
|
|
|
// bird implements [wgengine.Bird] on top of [chirp.BIRDClient],
|
|
// tracking the primary subnet router state across engine
|
|
// reconfigurations. One bird exists per engine.
|
|
type bird struct {
|
|
logf logger.Logf
|
|
client *chirp.BIRDClient
|
|
|
|
// The fields below are only accessed from Reconfig and
|
|
// ReconfigDone, which the engine serializes under its internal
|
|
// lock.
|
|
|
|
// isSubnetRouter is whether the last Reconfig found this node to
|
|
// be a primary subnet router.
|
|
isSubnetRouter bool
|
|
// lastIsSubnetRouter is the primary subnet router state last
|
|
// successfully applied to BIRD. ReconfigDone compares it against
|
|
// isSubnetRouter to decide whether to toggle the protocol.
|
|
lastIsSubnetRouter bool
|
|
}
|
|
|
|
func newBird(logf logger.Logf, socketPath string) (wgengine.Bird, error) {
|
|
logf("wgengine: connecting to BIRD at %s ...", socketPath)
|
|
client, err := chirp.New(socketPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Disable the protocol at start time; ReconfigDone enables it only
|
|
// once this node becomes a primary subnet router.
|
|
if err := client.DisableProtocol(protocolName); err != nil {
|
|
return nil, err
|
|
}
|
|
return &bird{logf: logf, client: client}, nil
|
|
}
|
|
|
|
func (b *bird) Reconfig(self tailcfg.NodeView) (changed bool) {
|
|
b.isSubnetRouter = false
|
|
if self.Valid() {
|
|
b.isSubnetRouter = hasOverlap(self.PrimaryRoutes(), self.Hostinfo().RoutableIPs())
|
|
b.logf("[v1] Reconfig: hasOverlap(%v, %v) = %v; isSubnetRouter=%v lastIsSubnetRouter=%v",
|
|
self.PrimaryRoutes(), self.Hostinfo().RoutableIPs(),
|
|
b.isSubnetRouter, b.isSubnetRouter, b.lastIsSubnetRouter)
|
|
}
|
|
return b.isSubnetRouter != b.lastIsSubnetRouter
|
|
}
|
|
|
|
func (b *bird) ReconfigDone() {
|
|
if b.isSubnetRouter == b.lastIsSubnetRouter {
|
|
return
|
|
}
|
|
b.logf("wgengine: Reconfig: configuring BIRD")
|
|
var err error
|
|
if b.isSubnetRouter {
|
|
err = b.client.EnableProtocol(protocolName)
|
|
} else {
|
|
err = b.client.DisableProtocol(protocolName)
|
|
}
|
|
if err != nil {
|
|
// Log but don't fail here; a later Reconfig will retry.
|
|
b.logf("wgengine: error configuring BIRD: %v", err)
|
|
return
|
|
}
|
|
b.lastIsSubnetRouter = b.isSubnetRouter
|
|
}
|
|
|
|
func (b *bird) Close() {
|
|
b.client.DisableProtocol(protocolName)
|
|
b.client.Close()
|
|
}
|
|
|
|
// hasOverlap reports whether any prefix in rips is also present in aips.
|
|
func hasOverlap(aips, rips views.Slice[netip.Prefix]) bool {
|
|
for _, aip := range aips.All() {
|
|
if views.SliceContains(rips, aip) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|