Compare commits

..
7 Commits
94 changed files with 2151 additions and 8020 deletions

No files matched your search

+9 -3
View File
@@ -7,10 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased] ## [Unreleased]
### Added ### Changed
- A control socket that provides access to all of the ssh debug server's commands along with support - A tunnel whose remote becomes unreachable, such as an IPv6 remote after moving to a network without IPv6, now
for running `nebula ctl <command>` as a client from the CLI. moves to another of the peer's addresses within a round trip or two instead of waiting 20-35s to be torn down
and rehandshaked. When a send fails because there is no route to the remote, the tunnel sends a test packet to
every other address it knows for the peer and asks the lighthouse to have the peer punch its new address.
Whichever path answers carries the tunnel. With `punchy.punch` enabled, idle tunnels notice on their next
keepalive punch. An idle tunnel whose remote is unreachable and none of whose other addresses answer is now
torn down by the connection manager rather than left in place. Not yet effective for relayed traffic or on
Windows with the default RIO backend.
### Removed ### Removed
-420
View File
@@ -1,420 +0,0 @@
package ctl
import (
"bytes"
"encoding/json"
"errors"
"flag"
"fmt"
"io"
"log/slog"
"os"
"strings"
"github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/localapi"
)
// Word is the argument that selects the control client instead of the daemon.
const Word = "ctl"
// Subcommand handles the one bare word a daemon binary accepts before its flags. `nebula
// ctl <command>` runs the client. Any other first argument that is not a flag is a
// mistyped subcommand, reported with a usage line: the daemon's flag parser would ignore
// the stray word and start nebula, so `nebula clt` would bring up a second daemon
// instead of reporting a typo. It returns the exit code and true when the process is
// done, and false when argv is the daemon's to parse. Both daemon binaries, cmd/nebula
// and cmd/nebula-service, call it before anything else, so each has a nebula ctl and
// neither has the hazard. A word that follows the daemon's flags instead is Trailing's.
func Subcommand(argv []string) (code int, done bool) {
if len(argv) < 2 || strings.HasPrefix(argv[1], "-") {
return 0, false
}
if argv[1] == Word {
return Run(argv[2:]), true
}
return unknownCommand(argv[1]), true
}
// Trailing handles the words the daemon's flag parser leaves unparsed: flag.Parse stops
// at the first argument that is not a flag and hands the rest back. rest is flag.Args()
// after the daemon has parsed, and configPath is the config the daemon's -config named,
// "" when it did not. Both daemon binaries call it right after flag.Parse, so that
// `nebula -config x ctl identity` runs the client and `nebula -config x clt` reports a
// typo, as Subcommand does for a word at the front of the line; a daemon that ignored
// the words would start in their place.
//
// A leading ctl word runs the client on what follows, with the daemon's -config carried
// over: an operator who typed it meant the daemon running on that config, and the client
// derives the same socket from it. Any other word is a mistake, reported as Subcommand
// reports one.
func Trailing(rest []string, configPath string) (code int, done bool) {
if len(rest) == 0 {
return 0, false
}
if rest[0] != Word {
return unknownCommand(rest[0]), true
}
args := rest[1:]
if configPath != "" {
// First, so a -config on the ctl side of the line still wins: Parse applies
// flags in order and the last value set is the one read.
args = append([]string{"-" + commands.FlagConfig, configPath}, args...)
}
return Run(args), true
}
// unknownCommand reports a bare word that is neither a flag nor ctl, with the one usage
// line that says what the two forms of the command line are.
func unknownCommand(word string) int {
fmt.Fprintf(os.Stderr, "nebula: unknown command %q\n\n", word)
fmt.Fprintf(os.Stderr, "Run nebula with flags to start it, or `nebula %s <command>` to control one that is already running.\n", Word)
return 1
}
// Run implements `nebula ctl <command> [args]`
//
// args is everything after the `ctl` word.
func Run(args []string) int {
fs := flag.NewFlagSet("nebula ctl", flag.ContinueOnError)
fs.SetOutput(os.Stderr)
configPath := fs.String(commands.FlagConfig, "", "Path to the config of the running nebula, used to locate its control socket")
socketPath := fs.String(commands.FlagSocket, "", "Path to the control socket, instead of the one the config implies")
fs.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: nebula ctl [flags] <command> [command flags]\n\n")
fmt.Fprintf(os.Stderr, "Inspects and controls a nebula already running on this machine.\n")
fmt.Fprintf(os.Stderr, "Run it as the user who ran nebula, or as a member of the group %s names.\n\n", localapi.CtlGroupKey)
fmt.Fprintf(os.Stderr, "Flags, which may come before or after the command:\n")
fs.PrintDefaults()
fmt.Fprintf(os.Stderr, "\nRun `nebula ctl help` for the available commands.\n")
}
own, cmdArgs := splitLine(fs, args)
if err := fs.Parse(own); err != nil {
// fs has already printed the usage, or the problem. Asking for help is not a
// failure, and a script that chains on `nebula ctl -h` should not see one.
if errors.Is(err, flag.ErrHelp) {
return 0
}
return 1
}
if len(cmdArgs) == 0 {
cmdArgs = []string{"help"}
}
path, err := resolveSocket(*socketPath, *configPath)
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
return 1
}
client := &localapi.Client{Path: path}
// Ask the daemon what it serves before parsing anything. The flags belong to the
// command, which lives over there, so this is what lets the CLI keep its usual shape
// while the wire protocol stays a named-parameter API rather than a shipped argv.
schema, err := client.Describe()
if err != nil {
// A daemon that answered was reached, and what it said, or that it could not be
// read, is the whole message.
var refused *localapi.DaemonError
var unread *localapi.ReplyError
if errors.As(err, &refused) || errors.As(err, &unread) {
fmt.Fprintf(os.Stderr, "nebula: %s\n", err)
return 1
}
// Otherwise the operating system said why, and it is passed on as it came: a
// permission denied or a missing socket says more about what to do than a
// guess at the operator's setup would.
fmt.Fprintf(os.Stderr, "nebula: could not reach the control socket at %s: %s\n", path, err)
return 1
}
req, printedHelp, err := parseCommand(schema, cmdArgs)
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
return 1
}
if printedHelp {
return 0
}
res, err := client.Invoke(string(req.name), req.Params, req.Args, wireFormat(req.Format))
if err != nil {
fmt.Fprintf(os.Stderr, "nebula: %s\n", err)
return 1
}
out := output(res, req.Format)
if out != "" {
fmt.Fprint(os.Stdout, out)
if !strings.HasSuffix(out, "\n") {
fmt.Fprintln(os.Stdout)
}
}
// Error set is the one failure signal, whether the request never ran or the command
// ran and refused. A refusal asked for in JSON has already gone to stdout as the
// {ok, reason} object, and is not said again on stderr; the exit status carries it.
if res.Error == "" {
return 0
}
if len(res.Result) == 0 && len(res.Text) == 0 {
msg := res.Error
if !strings.HasSuffix(msg, "\n") {
msg += "\n"
}
fmt.Fprint(os.Stderr, msg)
}
return 1
}
// output renders what the daemon answered for the format the line asked for. A text
// request is answered in Text with the bytes the command wrote, printed as they are; a
// JSON request is answered in Result with the value itself, printed as it came, since a
// value that happens to be a string is still JSON to the script reading it. Indentation
// is the client's business: whitespace does not survive a JSON envelope, and the daemon
// has no reason to care how its answer is laid out. The bytes are re-indented rather
// than decoded and encoded again, which would sort the keys and round the numbers.
func output(res *localapi.Response, format commands.Format) string {
switch format {
case commands.FormatJSON:
return string(res.Result)
case commands.FormatPrettyJSON:
var buf bytes.Buffer
if err := json.Indent(&buf, res.Result, "", " "); err != nil {
return string(res.Result)
}
return buf.String()
default:
return string(res.Text)
}
}
// ctlRequest is one parsed nebula ctl command line: the command's name, which only the
// daemon can resolve, and the line as every surface parses it. The Request's Command is
// nil here, since the CLI holds a schema rather than the command, and its Format is
// FormatUnset when the line named none, which to nebula ctl means text: its default
// differs from the API's.
type ctlRequest struct {
name commands.Name
commands.Request
}
// wireFormat is what a request asks the daemon for. Pretty is the client's business,
// since whitespace does not survive a JSON envelope, so it travels as json. No
// preference is text, nebula ctl's default: a person gets the human rendering wherever
// one exists.
func wireFormat(f commands.Format) string {
switch f {
case commands.FormatJSON, commands.FormatPrettyJSON:
return "json"
default:
return "text"
}
}
// parseCommand turns the user's command line into a ctlRequest, using the schema the
// daemon supplied. The line is parsed with the same rules the daemon applies to an ssh
// line, through ParseArgs, and ParseLine reads what was set into the Request to send, so
// a line means the same on both.
//
// printedHelp reports that help was written for the command instead, and there is
// nothing to send.
func parseCommand(schema []commands.CommandSchema, argv []string) (req ctlRequest, printedHelp bool, err error) {
name := commands.Name(argv[0])
var found *commands.CommandSchema
for i := range schema {
if schema[i].Name == name {
found = &schema[i]
break
}
}
if found == nil {
// Let the daemon answer. It knows whether this is a typo or a command it holds
// back, and its message for the second case is better than anything guessable
// from the schema alone.
return ctlRequest{name: name, Request: commands.Request{Args: argv[1:]}}, false, nil
}
// The flag package's own report is a bare message followed by a usage dump in a layout
// that does not match WriteCommandHelp, so it is silenced and the error is reported
// once, below, with a pointer at the help this command actually prints.
fs := flag.NewFlagSet(string(name), flag.ContinueOnError)
fs.SetOutput(io.Discard)
for _, f := range found.Flags {
if f.Bool {
fs.Bool(f.Name, f.Default == "true", f.Usage)
continue
}
fs.String(f.Name, f.Default, f.Usage)
}
operands, err := commands.ParseArgs(fs, argv[1:])
if err != nil {
if errors.Is(err, flag.ErrHelp) {
// The same rendering the daemon uses for `help <command>`, so -h and help agree.
_ = commands.WriteCommandHelp(*found, os.Stdout)
return ctlRequest{}, true, nil
}
// Say what flag did: an unknown flag, a missing value and a malformed value are
// different mistakes, and "does not take" would be wrong for two of them.
return ctlRequest{}, false, fmt.Errorf("nebula: %s: %s (see 'nebula ctl %s -h')", name, err, name)
}
// Only what the user actually set travels. A parameter left alone is the daemon's
// default to apply, not the client's to assert, and the presentation flags are the
// client's to interpret, never sent.
//
// Where the command has no human form the daemon says so, and only once the command
// has run: a refusal ("No vpn address was provided") always has a human form, so
// telling the user to pass -json before finding out whether the command would even
// accept the line sends them to fix the wrong thing. That is why the schema does not
// say which commands have a human form: nothing should decide on it before running.
return ctlRequest{name: name, Request: commands.ParseLine(fs, operands)}, false, nil
}
// splitLine divides a nebula ctl line into the client's own flags, for fs to parse, and
// the command line to send, which begins with the command word. The client's flags may
// come before the command or after it: `nebula ctl -config x identity` and
// `nebula ctl identity -config x` mean the same, so an operator who has typed a command
// and then remembers which daemon they meant does not have to retype the line.
//
// Before the command word every flag is the client's, whatever it is, so an unknown one
// is reported by fs, and -h is the client's usage. After it only the
// flags fs defines are lifted out, and only those: the command's own flags are unknown
// here, since they come from the daemon the line has yet to name, and -h after the
// command asks for that command's help. Which command flags take a value is unknown too,
// so the client's names are reserved in the commands package and no command can give
// one a value that would be lifted from here. A "--" before the command is consumed, as
// fs.Parse would have; one after it belongs to the command line and ends the lifting,
// so an operand spelled like a client flag can still be passed.
func splitLine(fs *flag.FlagSet, args []string) (own, cmd []string) {
seenCommand := false
for i := 0; i < len(args); i++ {
a := args[i]
if a == "--" {
if seenCommand {
return own, append(cmd, args[i:]...)
}
seenCommand = true
continue
}
if !seenCommand {
if len(a) < 2 || a[0] != '-' {
seenCommand = true
cmd = append(cmd, a)
continue
}
own = append(own, a)
if f, hasValue := commands.LookupArg(fs, a); f != nil && !hasValue && !commands.IsBoolFlag(f) && i+1 < len(args) {
i++
own = append(own, args[i])
}
continue
}
if len(a) >= 2 && a[0] == '-' {
// The same reading of the argument ParseArgs makes, so a word this lifts as a
// client flag's value is one the daemon's parser would have read the same way.
if f, hasValue := commands.LookupArg(fs, a); f != nil {
own = append(own, a)
if !hasValue && !commands.IsBoolFlag(f) && i+1 < len(args) {
i++
own = append(own, args[i])
}
continue
}
}
cmd = append(cmd, a)
}
return own, cmd
}
// resolveSocket decides which socket to talk to. It never searches: the answer is the
// socket the operator named, or the one the config implies, and nothing else.
//
// An explicit flag wins. Otherwise the config is read, the one the operator named or the
// one found next to the executable, and the path is the socket that config implies: its
// local_api.control.socket if set, else the same derivation the daemon applies.
func resolveSocket(socketFlag, configFlag string) (string, error) {
if socketFlag != "" {
return socketFlag, nil
}
return pathFromConfig(configFlag)
}
// pathFromConfig returns the socket path the daemon would be serving: the one
// local_api.control.socket names in the config, so an operator who moved the socket does
// not have to repeat themselves on every invocation, else the default.
//
// A config the operator did not name is a guess: config.DefaultPath looks next to the
// executable, and a package that installs a default config there while systemd starts
// the daemon with another will make it the wrong guess. It is still the only answer
// that involves no searching. A guess that cannot be read is not an error, it is no
// guess: a member of the socket's group cannot read a root daemon's config, and is
// answered by the default path, where the daemon serves unless that config moved it.
// A config the operator named is theirs to make readable.
func pathFromConfig(configFlag string) (string, error) {
return socketFromConfigFile(configFlag, configFlag != "")
}
func socketFromConfigFile(configPath string, named bool) (string, error) {
if !named {
p, err := config.DefaultPath()
if err != nil {
return localapi.DefaultSocketPath, nil
}
configPath = p
}
// The config is loaded only to find the socket path. Loading logs lines that belong
// to the daemon, not to someone running a read only command, and mixing them into
// the CLI's output would corrupt a -json result, so they are discarded.
c := config.NewC(slog.New(slog.DiscardHandler))
if err := c.Load(configPath); err != nil {
if !named {
return localapi.DefaultSocketPath, nil
}
// The operating system's error, as it came: permission denied on a root daemon's
// config says what to do.
return "", fmt.Errorf("nebula: could not read %s: %w", configPath, err)
}
// A daemon running this config serves no socket; dialing the path would only say
// that nothing is there.
if !localapi.ControlEnabled(c) {
return "", fmt.Errorf("nebula: the control socket is disabled in %s by %s", configPath, localapi.CtlEnabledKey)
}
// The same call the daemon makes, so the two agree on the path and on what makes a
// path unusable.
p, err := localapi.SocketPathFromConfig(c)
if err != nil {
return "", fmt.Errorf("nebula: %w", err)
}
return p, nil
}
-294
View File
@@ -1,294 +0,0 @@
package ctl
import (
"encoding/json"
"flag"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/localapi"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestResolveSocketReportsAnUnreadableConfig: an operator who named a config must hear
// that it could not be read, rather than have the command steered anywhere else.
func TestResolveSocketReportsAnUnreadableConfig(t *testing.T) {
missing := filepath.Join(t.TempDir(), "typo.yml")
_, err := resolveSocket("", missing)
require.Error(t, err)
assert.Contains(t, err.Error(), missing)
}
// TestResolveSocketGuessedConfigNeedNotBeReadable: a config nobody named is a guess, and
// one that cannot be read, a root daemon's config read by a member of the socket's
// group, means the default path rather than an error.
func TestResolveSocketGuessedConfigNeedNotBeReadable(t *testing.T) {
missing := filepath.Join(t.TempDir(), "config.yml")
p, err := socketFromConfigFile(missing, false)
require.NoError(t, err)
assert.Equal(t, localapi.DefaultSocketPath, p)
_, err = socketFromConfigFile(missing, true)
require.ErrorContains(t, err, missing)
}
// nowhereSocket is a socket name nothing listens on, spelled the way the platform
// requires: a full pipe name on windows, an absolute path elsewhere.
var nowhereSocket = map[bool]string{true: `\\.\pipe\nebula-nowhere`, false: "/nowhere/ctl.sock"}[runtime.GOOS == "windows"]
// namedSocketConfig is a config that names nowhereSocket as the control socket. Single
// quotes keep a pipe name's backslashes literal in YAML.
var namedSocketConfig = "local_api:\n control:\n socket: '" + nowhereSocket + "'\n"
// TestResolveSocketTrustsANamedConfig: a config the operator named yields the socket it
// implies even when nothing is listening there, so a dial failure names that socket.
func TestResolveSocketTrustsANamedConfig(t *testing.T) {
cfg := filepath.Join(t.TempDir(), "config.yml")
require.NoError(t, os.WriteFile(cfg, []byte(namedSocketConfig), 0600))
p, err := resolveSocket("", cfg)
require.NoError(t, err)
assert.Equal(t, nowhereSocket, p)
}
// TestResolveSocketSaysTheSocketIsDisabled: a config that turns the control socket off
// is answered with that, not with a dial to a path nothing serves. -socket still wins.
func TestResolveSocketSaysTheSocketIsDisabled(t *testing.T) {
cfg := filepath.Join(t.TempDir(), "config.yml")
require.NoError(t, os.WriteFile(cfg, []byte("local_api:\n control:\n enabled: false\n"), 0600))
_, err := resolveSocket("", cfg)
require.ErrorContains(t, err, "the control socket is disabled in "+cfg+" by local_api.control.enabled")
p, err := resolveSocket("/explicit.sock", cfg)
require.NoError(t, err)
assert.Equal(t, "/explicit.sock", p)
}
// TestResolveSocketUsesTheDefaultWithoutAnOverride: a config that does not name the
// socket means the default path, the same one the daemon serves with that config, and
// no config at all means the default too, since that is where a daemon started without
// an override serves. Nothing is searched for.
func TestResolveSocketUsesTheDefaultWithoutAnOverride(t *testing.T) {
cfg := filepath.Join(t.TempDir(), "config.yml")
require.NoError(t, os.WriteFile(cfg, []byte("static_host_map: {}\n"), 0600))
p, err := resolveSocket("", cfg)
require.NoError(t, err)
assert.Equal(t, localapi.DefaultSocketPath, p)
// The test binary has no config next to it.
p, err = resolveSocket("", "")
require.NoError(t, err)
assert.Equal(t, localapi.DefaultSocketPath, p)
}
func TestResolveSocketFlagWins(t *testing.T) {
p, err := resolveSocket("/explicit.sock", "/does/not/matter.yml")
require.NoError(t, err)
assert.Equal(t, "/explicit.sock", p)
}
// TestParseCommandReportsWhatFlagSaid covers the three ways a flag line goes wrong, which
// are different mistakes: an unknown flag, a valid flag with a missing value, and a
// valid flag with a value it cannot parse.
func TestParseCommandReportsWhatFlagSaid(t *testing.T) {
schema := []commands.CommandSchema{{
Name: "change-remote",
Flags: []commands.FlagSchema{
{Name: "address"},
{Name: "by-index", Bool: true},
},
}}
cases := map[string]struct {
argv []string
want string
}{
"missing value": {[]string{"change-remote", "-address"}, "flag needs an argument: -address"},
"bad bool": {[]string{"change-remote", "-by-index=maybe"}, "invalid boolean value \"maybe\" for -by-index"},
"unknown flag": {[]string{"change-remote", "-nope"}, "flag provided but not defined: -nope"},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
_, _, err := parseCommand(schema, tc.argv)
require.Error(t, err)
require.ErrorContains(t, err, "nebula: change-remote: "+tc.want)
require.ErrorContains(t, err, "see 'nebula ctl change-remote -h'")
assert.NotContains(t, err.Error(), "does not take")
})
}
}
// TestParseCommandOffPresentationFlagIsNoPreference: the daemon treats -json=false as
// no preference, so nebula ctl must too, or the same line renders differently on the
// two surfaces. Only a true value asks for JSON, and -pretty implies it.
func TestParseCommandOffPresentationFlagIsNoPreference(t *testing.T) {
schema := []commands.CommandSchema{{
Name: "device-info",
Flags: []commands.FlagSchema{
{Name: commands.FlagJSON, Bool: true, Default: "false"},
{Name: commands.FlagPretty, Bool: true, Default: "false"},
},
}}
for _, tc := range []struct {
argv []string
want commands.Format
wire string
}{
{[]string{"device-info"}, commands.FormatUnset, "text"},
{[]string{"device-info", "-json=false"}, commands.FormatUnset, "text"},
{[]string{"device-info", "-json"}, commands.FormatJSON, "json"},
{[]string{"device-info", "-pretty"}, commands.FormatPrettyJSON, "json"},
} {
t.Run(strings.Join(tc.argv[1:], " "), func(t *testing.T) {
req, printedHelp, err := parseCommand(schema, tc.argv)
require.NoError(t, err)
assert.False(t, printedHelp)
assert.Equal(t, tc.want, req.Format)
assert.Equal(t, tc.wire, wireFormat(req.Format))
assert.Nil(t, req.Params, "presentation flags are never sent as parameters")
})
}
}
// TestParseCommandReadsTheLineAsTheDaemonDoes: nebula ctl parses the line with the same
// rules as the daemon, so an operand after "--" reaches the command on both and a
// negative number before it is the flag it would be at an ssh prompt.
func TestParseCommandReadsTheLineAsTheDaemonDoes(t *testing.T) {
schema := []commands.CommandSchema{{Name: "set"}}
req, printedHelp, err := parseCommand(schema, []string{"set", "--", "-1"})
require.NoError(t, err)
assert.False(t, printedHelp)
assert.Equal(t, commands.Name("set"), req.name)
assert.Nil(t, req.Params)
assert.Equal(t, []string{"-1"}, req.Args)
_, _, err = parseCommand(schema, []string{"set", "-1"})
require.ErrorContains(t, err, "flag provided but not defined: -1")
}
// TestOutputRendersForTheFormatAsked: what the daemon answered is read by the format the
// line asked for, never by sniffing the bytes. A text answer is the command's rendering,
// printed as it came; a JSON answer whose value is a string stays quoted, since to the
// script reading it that string is the JSON.
func TestOutputRendersForTheFormatAsked(t *testing.T) {
text := &localapi.Response{Text: []byte("Log level is: info\n")}
assert.Equal(t, "Log level is: info\n", output(text, commands.FormatUnset))
assert.Equal(t, "Log level is: info\n", output(text, commands.FormatText))
str := &localapi.Response{Result: json.RawMessage(`"some string"`)}
assert.Equal(t, `"some string"`, output(str, commands.FormatJSON))
assert.Equal(t, `"some string"`, output(str, commands.FormatPrettyJSON))
// Keys stay in the order the daemon wrote them and a uint64 past 2^53 is not rounded,
// which decoding into `any` and encoding again would do.
obj := &localapi.Response{Result: json.RawMessage(`{"z":18446744073709551615,"a":{"y":[1,2],"b":true}}`)}
//nolint:testifylint // the layout is what is under test, which JSONEq would not see
assert.Equal(t, `{"z":18446744073709551615,"a":{"y":[1,2],"b":true}}`, output(obj, commands.FormatJSON))
//nolint:testifylint // as above
assert.Equal(t, "{\n \"z\": 18446744073709551615,\n \"a\": {\n \"y\": [\n 1,\n 2\n ],\n \"b\": true\n }\n}", output(obj, commands.FormatPrettyJSON))
bad := &localapi.Response{Result: json.RawMessage(`{"a":`)}
assert.Equal(t, `{"a":`, output(bad, commands.FormatPrettyJSON), "what cannot be indented is printed as it came")
none := &localapi.Response{}
assert.Empty(t, output(none, commands.FormatJSON))
assert.Empty(t, output(none, commands.FormatUnset))
}
// TestSplitLineLiftsOwnFlagsFromAnywhere: -config and -socket are the client's wherever
// they appear, before the command or after it, in either spelling, so the two orders
// mean the same line. Everything else after the command word stays in order for the
// command's own parse, including flags and operands that happen to look like values.
func TestSplitLineLiftsOwnFlagsFromAnywhere(t *testing.T) {
newFS := func() *flag.FlagSet {
fs := flag.NewFlagSet("nebula ctl", flag.ContinueOnError)
fs.String(commands.FlagConfig, "", "")
fs.String(commands.FlagSocket, "", "")
return fs
}
for _, tc := range []struct {
args []string
wantOwn []string
wantCmd []string
}{
{nil, nil, nil},
{[]string{"identity"}, nil, []string{"identity"}},
{[]string{"-config", "x", "identity"}, []string{"-config", "x"}, []string{"identity"}},
{[]string{"identity", "-config", "x"}, []string{"-config", "x"}, []string{"identity"}},
{[]string{"identity", "-config=x"}, []string{"-config=x"}, []string{"identity"}},
{[]string{"identity", "--socket", "s"}, []string{"--socket", "s"}, []string{"identity"}},
{[]string{"-socket", "s", "identity", "-config", "x"}, []string{"-socket", "s", "-config", "x"}, []string{"identity"}},
// The command's flags and operands are left where they are, around the lifted ones.
{[]string{"print-tunnel", "10.0.0.1", "-config", "x", "-json"}, []string{"-config", "x"}, []string{"print-tunnel", "10.0.0.1", "-json"}},
{[]string{"change-remote", "-address", "1.2.3.4:5", "-socket", "s", "10.0.0.1"}, []string{"-socket", "s"}, []string{"change-remote", "-address", "1.2.3.4:5", "10.0.0.1"}},
// -h before the command is the client's usage; after it, the command's help.
{[]string{"-h"}, []string{"-h"}, nil},
{[]string{"identity", "-h"}, nil, []string{"identity", "-h"}},
// An unknown flag before the command is the client's to report, and does not
// swallow the command word as its value.
{[]string{"-nope", "identity"}, []string{"-nope"}, []string{"identity"}},
// A -config with nothing after it is left for fs.Parse to report.
{[]string{"identity", "-config"}, []string{"-config"}, []string{"identity"}},
// "--" before the command is consumed, as fs.Parse consumed it; after the command
// it belongs to the line and ends the lifting.
{[]string{"--", "identity", "-config", "x"}, []string{"-config", "x"}, []string{"identity"}},
{[]string{"identity", "--", "-config", "x"}, nil, []string{"identity", "--", "-config", "x"}},
} {
t.Run(strings.Join(tc.args, " "), func(t *testing.T) {
own, cmd := splitLine(newFS(), tc.args)
assert.Equal(t, tc.wantOwn, own)
assert.Equal(t, tc.wantCmd, cmd)
})
}
}
// TestTrailingHandlesWordsAfterTheDaemonsFlags: what flag.Parse leaves behind is never
// a daemon to start. A leading ctl runs the client on the rest, with the daemon's
// -config carried over; anything else is a mistyped subcommand. Only -h is run here,
// since the client's help needs no daemon: it proves the words reach Run and that a
// carried -config is accepted by it.
func TestTrailingHandlesWordsAfterTheDaemonsFlags(t *testing.T) {
code, done := Trailing(nil, "")
assert.False(t, done)
assert.Equal(t, 0, code)
code, done = Trailing([]string{"clt"}, "")
assert.True(t, done)
assert.Equal(t, 1, code)
code, done = Trailing([]string{Word, "-h"}, "")
assert.True(t, done)
assert.Equal(t, 0, code)
code, done = Trailing([]string{Word, "-h"}, "/etc/nebula/config.yml")
assert.True(t, done)
assert.Equal(t, 0, code)
}
// TestSubcommandOnlyReadsTheFirstWord: a flag first means the line is the daemon's to
// parse, and whatever follows the flags is Trailing's to judge.
func TestSubcommandOnlyReadsTheFirstWord(t *testing.T) {
_, done := Subcommand([]string{"nebula", "-config", "x", Word})
assert.False(t, done)
code, done := Subcommand([]string{"nebula", "clt"})
assert.True(t, done)
assert.Equal(t, 1, code)
code, done = Subcommand([]string{"nebula", Word, "-h"})
assert.True(t, done)
assert.Equal(t, 0, code)
}
-42
View File
@@ -1,42 +0,0 @@
//go:build !windows
package ctl
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/slackhq/nebula/localapi"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestResolveSocketDiagnosesAnOverlongOverride: the CLI applies the daemon's own rule to
// the override, so it says what the daemon's log says rather than dialing a path the
// kernel would truncate and reporting the generic failure. The rule is sun_path's, which
// a named pipe does not have, so this is a unix test.
func TestResolveSocketDiagnosesAnOverlongOverride(t *testing.T) {
cfg := filepath.Join(t.TempDir(), "config.yml")
long := "/" + strings.Repeat("x", 120)
require.NoError(t, os.WriteFile(cfg, []byte("local_api:\n control:\n socket: "+long+"\n"), 0600))
_, err := resolveSocket("", cfg)
require.Error(t, err)
require.ErrorContains(t, err, "too long for this platform")
assert.ErrorContains(t, err, localapi.CtlSocketKey)
}
// TestResolveSocketRefusesARelativeOverride: the CLI applies the daemon's rule here too,
// so a relative path in the config is reported as the daemon's log reports it rather
// than resolved against wherever nebula ctl happened to be run from.
func TestResolveSocketRefusesARelativeOverride(t *testing.T) {
cfg := filepath.Join(t.TempDir(), "config.yml")
require.NoError(t, os.WriteFile(cfg, []byte("local_api:\n control:\n socket: run/ctl.sock\n"), 0600))
_, err := resolveSocket("", cfg)
require.Error(t, err)
require.ErrorContains(t, err, "must be an absolute path")
assert.ErrorContains(t, err, localapi.CtlSocketKey)
}
+1 -22
View File
@@ -8,9 +8,7 @@ import (
"strings" "strings"
"github.com/slackhq/nebula" "github.com/slackhq/nebula"
"github.com/slackhq/nebula/cmd/internal/ctl"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/localapi"
"github.com/slackhq/nebula/logging" "github.com/slackhq/nebula/logging"
"github.com/slackhq/nebula/util" "github.com/slackhq/nebula/util"
) )
@@ -34,11 +32,6 @@ func init() {
} }
func main() { func main() {
// commands are either `nebula ctl ...` or `nebula -<flag> ...`
if code, done := ctl.Subcommand(os.Args); done {
os.Exit(code)
}
serviceFlag := flag.String("service", "", "Control the system service.") serviceFlag := flag.String("service", "", "Control the system service.")
configPath := flag.String("config", "", "Path to either a file or directory to load configuration from") configPath := flag.String("config", "", "Path to either a file or directory to load configuration from")
configTest := flag.Bool("test", false, "Test the config and print the end result. Non zero exit indicates a faulty config") configTest := flag.Bool("test", false, "Test the config and print the end result. Non zero exit indicates a faulty config")
@@ -47,12 +40,6 @@ func main() {
flag.Parse() flag.Parse()
// A word after the daemon's flags is `ctl` in the other place an operator puts it,
// or a mistyped subcommand, and either way not a daemon to start; see Trailing.
if code, done := ctl.Trailing(flag.Args(), *configPath); done {
os.Exit(code)
}
if *printVersion { if *printVersion {
fmt.Printf("Version: %s\n", Build) fmt.Printf("Version: %s\n", Build)
os.Exit(0) os.Exit(0)
@@ -117,17 +104,9 @@ func main() {
os.Exit(1) os.Exit(1)
} }
ctl := localapi.Wire(ctrl.Context(), l, c, ctrl.Commands())
go ctrl.ShutdownBlock() go ctrl.ShutdownBlock()
err := ctrl.Wait() if err := ctrl.Wait(); err != nil {
// os.Exit skips deferred calls, so the socket is removed here, before either exit
// below, rather than left to a deferred Stop that would never run.
ctl.Stop()
if err != nil {
l.Error("Nebula stopped due to fatal error", "error", err) l.Error("Nebula stopped due to fatal error", "error", err)
os.Exit(2) os.Exit(2)
} }
-13
View File
@@ -8,7 +8,6 @@ import (
"github.com/kardianos/service" "github.com/kardianos/service"
"github.com/slackhq/nebula" "github.com/slackhq/nebula"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/localapi"
"github.com/slackhq/nebula/logging" "github.com/slackhq/nebula/logging"
) )
@@ -18,7 +17,6 @@ type program struct {
configPath *string configPath *string
build string build string
control *nebula.Control control *nebula.Control
ctl *localapi.Server
} }
func (p *program) Start(s service.Service) error { func (p *program) Start(s service.Service) error {
@@ -52,16 +50,10 @@ func (p *program) Start(s service.Service) error {
return err return err
} }
// Now that we're started, stand up the local control socket.
p.ctl = localapi.Wire(p.control.Context(), l, c, p.control.Commands())
// Nebula can stop itself on a fatal packet reader error, make sure to log it if it happens. // Nebula can stop itself on a fatal packet reader error, make sure to log it if it happens.
go func() { go func() {
if err := p.control.Wait(); err != nil { if err := p.control.Wait(); err != nil {
logger.Error(fmt.Sprintf("Nebula stopped due to fatal error: %v", err)) logger.Error(fmt.Sprintf("Nebula stopped due to fatal error: %v", err))
// os.Exit skips deferred calls and races the socket's own context watcher,
// so the socket is removed here, as cmd/nebula does.
p.ctl.Stop()
os.Exit(2) os.Exit(2)
} }
}() }()
@@ -71,11 +63,6 @@ func (p *program) Start(s service.Service) error {
func (p *program) Stop(s service.Service) error { func (p *program) Stop(s service.Service) error {
logger.Info("Nebula service stopping.") logger.Info("Nebula service stopping.")
if p.ctl != nil {
p.ctl.Stop()
}
if p.control == nil { if p.control == nil {
return nil return nil
} }
+1 -22
View File
@@ -8,9 +8,7 @@ import (
"strings" "strings"
"github.com/slackhq/nebula" "github.com/slackhq/nebula"
"github.com/slackhq/nebula/cmd/internal/ctl"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/localapi"
"github.com/slackhq/nebula/logging" "github.com/slackhq/nebula/logging"
"github.com/slackhq/nebula/util" "github.com/slackhq/nebula/util"
) )
@@ -34,11 +32,6 @@ func init() {
} }
func main() { func main() {
// commands are either `nebula ctl ...` or `nebula -<flag> ...`
if code, done := ctl.Subcommand(os.Args); done {
os.Exit(code)
}
configPath := flag.String("config", "", "Path to either a file or directory to load configuration from") configPath := flag.String("config", "", "Path to either a file or directory to load configuration from")
configTest := flag.Bool("test", false, "Test the config and print the end result. Non zero exit indicates a faulty config") configTest := flag.Bool("test", false, "Test the config and print the end result. Non zero exit indicates a faulty config")
printVersion := flag.Bool("version", false, "Print version") printVersion := flag.Bool("version", false, "Print version")
@@ -46,12 +39,6 @@ func main() {
flag.Parse() flag.Parse()
// A word after the daemon's flags is `ctl` in the other place an operator puts it,
// or a mistyped subcommand, and either way not a daemon to start; see Trailing.
if code, done := ctl.Trailing(flag.Args(), *configPath); done {
os.Exit(code)
}
if *printVersion { if *printVersion {
fmt.Printf("Version: %s\n", Build) fmt.Printf("Version: %s\n", Build)
os.Exit(0) os.Exit(0)
@@ -103,18 +90,10 @@ func main() {
os.Exit(1) os.Exit(1)
} }
ctl := localapi.Wire(ctrl.Context(), l, c, ctrl.Commands())
go ctrl.ShutdownBlock() go ctrl.ShutdownBlock()
notifyReady(l) notifyReady(l)
err := ctrl.Wait() if err := ctrl.Wait(); err != nil {
// os.Exit skips deferred calls, so the socket is removed here, before either exit
// below, rather than left to a deferred Stop that would never run.
ctl.Stop()
if err != nil {
l.Error("Nebula stopped due to fatal error", "error", err) l.Error("Nebula stopped due to fatal error", "error", err)
os.Exit(2) os.Exit(2)
} }
+382 -296
View File
@@ -1,33 +1,48 @@
package nebula package nebula
import ( import (
"bytes"
"encoding/json" "encoding/json"
"flag" "flag"
"fmt" "fmt"
"io"
"log/slog" "log/slog"
"maps" "maps"
"net/netip" "net/netip"
"sort" "sort"
"strings" "strings"
"github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/commands" "github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/header"
"github.com/slackhq/nebula/logging" "github.com/slackhq/nebula/logging"
) )
// The commands nebula serves. attachCommands builds the one registry every surface // The commands nebula serves. attachCommands builds the one registry every surface
// reads; the ssh debug server is a consumer of it, not its owner, which is why this // reads. See the commands package for what a Command is.
// is not ssh.go. See the commands package for what a Command is.
type listHostMapFlags struct { type listHostMapFlags struct {
Json bool
Pretty bool
ByIndex bool ByIndex bool
} }
// listHostMapFlagSet is the flag set list-hostmap and list-pending-hostmap share.
func listHostMapFlagSet() (*flag.FlagSet, any) {
fl := flag.NewFlagSet("", flag.ContinueOnError)
s := listHostMapFlags{}
fl.BoolVar(&s.Json, "json", false, "outputs as json with more information")
fl.BoolVar(&s.Pretty, "pretty", false, "pretty prints json, assumes -json")
fl.BoolVar(&s.ByIndex, "by-index", false, "gets all hosts in the hostmap from the index table")
return fl, &s
}
type printCertFlags struct { type printCertFlags struct {
Raw bool Json bool
Pretty bool
Raw bool
}
type printTunnelFlags struct {
Pretty bool
} }
type changeRemoteFlags struct { type changeRemoteFlags struct {
@@ -42,210 +57,195 @@ type createTunnelFlags struct {
Address string Address string
} }
// lighthouseInfo is one entry of list-lighthouse-addrmap. type deviceInfoFlags struct {
type lighthouseInfo struct { Json bool
VpnAddr string `json:"vpnAddr"` Pretty bool
Addrs *CacheMap `json:"addrs"`
}
// deviceInfo is the result of device-info.
type deviceInfo struct {
Name string `json:"name"`
Cidr []netip.Prefix `json:"cidr"`
}
// certPEM is the result of print-cert -raw. The PEM form is a different thing to emit,
// not a different formatting of the certificate, so it is its own shape.
type certPEM struct {
PEM string `json:"pem"`
}
// Result shapes for print-relays. Field names are the JSON keys; changing them would
// change the output.
type relayFor struct {
Error string `json:",omitempty"`
Type string
State string
PeerAddr netip.Addr
LocalIndex uint32
RemoteIndex uint32
RelayedThrough []netip.Addr
}
type relayOutput struct {
NebulaAddr netip.Addr
RelayForAddrs []relayFor
}
type relaysOutput struct {
Relays []*relayOutput
}
type versionInfo struct {
Version string `json:"version"`
}
type logLevelInfo struct {
Level string `json:"level"`
}
type logFormatInfo struct {
Format string `json:"format"`
}
// defineListHostMapFlags declares the flags list-hostmap and list-pending-hostmap share.
func defineListHostMapFlags(fl *flag.FlagSet, s *listHostMapFlags) {
fl.BoolVar(&s.ByIndex, "by-index", false, "gets all hosts in the hostmap from the index table")
} }
func attachCommands(l *slog.Logger, c *config.C, reg *commands.Registry, f *Interface) { func attachCommands(l *slog.Logger, c *config.C, reg *commands.Registry, f *Interface) {
reg.Register(commands.Flagged(&commands.Command{ reg.Register(&commands.Command{
Name: commands.ListHostmap, Name: commands.ListHostmap,
ShortDescription: "List all known previously connected hosts", ShortDescription: "List all known previously connected hosts",
Text: commands.Typed(textListHostMap), Flags: listHostMapFlagSet,
}, defineListHostMapFlags, func(s *listHostMapFlags, a []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
return runListHostMap(f.hostMap, s) return listHostMapCommand(f.hostMap, fs, w)
})) },
})
reg.Register(commands.Flagged(&commands.Command{ reg.Register(&commands.Command{
Name: commands.ListPendingHostmap, Name: commands.ListPendingHostmap,
ShortDescription: "List all handshaking hosts", ShortDescription: "List all handshaking hosts",
Text: commands.Typed(textListHostMap), Flags: listHostMapFlagSet,
}, defineListHostMapFlags, func(s *listHostMapFlags, a []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
return runListHostMap(f.handshakeManager, s) return listHostMapCommand(f.handshakeManager, fs, w)
})) },
})
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.ListLighthouseAddrmap, Name: commands.ListLighthouseAddrmap,
ShortDescription: "List all lighthouse map entries", ShortDescription: "List all lighthouse map entries",
Run: func(fs any, a []string) (commands.Result, error) { Flags: func() (*flag.FlagSet, any) {
return runListLighthouseMap(f.lightHouse) fl := flag.NewFlagSet("", flag.ContinueOnError)
s := listHostMapFlags{}
fl.BoolVar(&s.Json, "json", false, "outputs as json with more information")
fl.BoolVar(&s.Pretty, "pretty", false, "pretty prints json, assumes -json")
return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return listLighthouseAddrmapCommand(f.lightHouse, fs, w)
}, },
Text: commands.Typed(textListLighthouseMap),
}) })
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.Reload, Name: commands.Reload,
ShortDescription: "Reloads configuration from disk, same as sending HUP to the process", ShortDescription: "Reloads configuration from disk, same as sending HUP to the process",
// The line goes out before the reload: a reload that restarts the ssh server ends Callback: func(fs any, a []string, w commands.StringWriter) error {
// the session that asked, and this is what it sees. return reloadCommand(l, c, w)
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Did("Reloading config"), nil
},
Then: func() commands.Result {
return runReload(l, c)
}, },
}) })
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.LogLevel, Name: commands.LogLevel,
ShortDescription: "Gets or sets the current log level", ShortDescription: "Gets or sets the current log level",
Run: func(fs any, a []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
return runLogLevel(l, a) return logLevelCommand(l, fs, a, w)
}, },
Text: commands.Typed(textLogLevel),
}) })
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.LogFormat, Name: commands.LogFormat,
ShortDescription: "Gets or sets the current log format", ShortDescription: "Gets or sets the current log format",
Run: func(fs any, a []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
return runLogFormat(l, a) return logFormatCommand(l, fs, a, w)
}, },
Text: commands.Typed(textLogFormat),
}) })
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.Version, Name: commands.Version,
ShortDescription: "Prints the currently running version of nebula", ShortDescription: "Prints the currently running version of nebula",
Run: func(fs any, a []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
return commands.Value(versionInfo{Version: f.version}), nil return versionCommand(f, fs, a, w)
}, },
Text: commands.Typed(textVersion),
}) })
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.DeviceInfo, Name: commands.DeviceInfo,
ShortDescription: "Prints information about the network device.", ShortDescription: "Prints information about the network device.",
Run: func(fs any, a []string) (commands.Result, error) { Flags: func() (*flag.FlagSet, any) {
return commands.Value(runDeviceInfo(f)), nil fl := flag.NewFlagSet("", flag.ContinueOnError)
s := deviceInfoFlags{}
fl.BoolVar(&s.Json, "json", false, "outputs as json with more information")
fl.BoolVar(&s.Pretty, "pretty", false, "pretty prints json, assumes -json")
return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return deviceInfoCommand(f, fs, w)
}, },
Text: commands.Typed(textDeviceInfo),
}) })
reg.Register(commands.Flagged(&commands.Command{ reg.Register(&commands.Command{
Name: commands.PrintCert, Name: commands.PrintCert,
ShortDescription: "Prints the current certificate being used or the certificate for the provided vpn addr", ShortDescription: "Prints the current certificate being used or the certificate for the provided vpn addr",
Text: textPrintCert, Flags: func() (*flag.FlagSet, any) {
}, func(fl *flag.FlagSet, s *printCertFlags) { fl := flag.NewFlagSet("", flag.ContinueOnError)
fl.BoolVar(&s.Raw, "raw", false, "prints the PEM encoded certificate; with -json, an object holding it") s := printCertFlags{}
}, func(s *printCertFlags, a []string) (commands.Result, error) { fl.BoolVar(&s.Json, "json", false, "outputs as json")
return runPrintCert(f, s, a) fl.BoolVar(&s.Pretty, "pretty", false, "pretty prints json, assumes -json")
})) fl.BoolVar(&s.Raw, "raw", false, "raw prints the PEM encoded certificate, not compatible with -json or -pretty")
return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return printCertCommand(f, fs, a, w)
},
})
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.PrintTunnel, Name: commands.PrintTunnel,
ShortDescription: "Prints json details about a tunnel for the provided vpn addr", ShortDescription: "Prints json details about a tunnel for the provided vpn addr",
Run: func(fs any, a []string) (commands.Result, error) { Flags: func() (*flag.FlagSet, any) {
return runPrintTunnel(f, a) fl := flag.NewFlagSet("", flag.ContinueOnError)
s := printTunnelFlags{}
fl.BoolVar(&s.Pretty, "pretty", false, "pretty prints json")
return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return printTunnelCommand(f, fs, a, w)
}, },
// No Text on purpose: nothing human readable exists yet, and shipping an interim
// form would invite scripts against it. ssh defaults these to JSON; ctl asks.
JSONOnly: true,
}) })
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.PrintRelays, Name: commands.PrintRelays,
ShortDescription: "Prints json details about all relay info", ShortDescription: "Prints json details about all relay info",
Run: func(fs any, a []string) (commands.Result, error) { Flags: func() (*flag.FlagSet, any) {
return commands.Value(runPrintRelays(f)), nil fl := flag.NewFlagSet("", flag.ContinueOnError)
s := printTunnelFlags{}
fl.BoolVar(&s.Pretty, "pretty", false, "pretty prints json")
return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return printRelaysCommand(f, fs, a, w)
}, },
// No Text on purpose; see print-tunnel.
JSONOnly: true,
}) })
reg.Register(commands.Flagged(&commands.Command{ reg.Register(&commands.Command{
Name: commands.ChangeRemote, Name: commands.ChangeRemote,
ShortDescription: "Changes the remote address used in the tunnel for the provided vpn addr", ShortDescription: "Changes the remote address used in the tunnel for the provided vpn addr",
}, func(fl *flag.FlagSet, s *changeRemoteFlags) { Flags: func() (*flag.FlagSet, any) {
fl.StringVar(&s.Address, "address", "", "The new remote address, ip:port") fl := flag.NewFlagSet("", flag.ContinueOnError)
}, func(s *changeRemoteFlags, a []string) (commands.Result, error) { s := changeRemoteFlags{}
return runChangeRemote(f, s, a) fl.StringVar(&s.Address, "address", "", "The new remote address, ip:port")
})) return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return changeRemoteCommand(f, fs, a, w)
},
})
reg.Register(commands.Flagged(&commands.Command{ reg.Register(&commands.Command{
Name: commands.CloseTunnel, Name: commands.CloseTunnel,
ShortDescription: "Closes a tunnel for the provided vpn addr", ShortDescription: "Closes a tunnel for the provided vpn addr",
}, func(fl *flag.FlagSet, s *closeTunnelFlags) { Flags: func() (*flag.FlagSet, any) {
fl.BoolVar(&s.LocalOnly, "local-only", false, "Disables notifying the remote that the tunnel is shutting down") fl := flag.NewFlagSet("", flag.ContinueOnError)
}, func(s *closeTunnelFlags, a []string) (commands.Result, error) { s := closeTunnelFlags{}
return runCloseTunnel(f, s, a) fl.BoolVar(&s.LocalOnly, "local-only", false, "Disables notifying the remote that the tunnel is shutting down")
})) return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return closeTunnelCommand(f, fs, a, w)
},
})
reg.Register(commands.Flagged(&commands.Command{ reg.Register(&commands.Command{
Name: commands.CreateTunnel, Name: commands.CreateTunnel,
ShortDescription: "Creates a tunnel for the provided vpn address", ShortDescription: "Creates a tunnel for the provided vpn address",
Help: "The lighthouses will be queried for real addresses but you can provide one as well.", Help: "The lighthouses will be queried for real addresses but you can provide one as well.",
}, func(fl *flag.FlagSet, s *createTunnelFlags) { Flags: func() (*flag.FlagSet, any) {
fl.StringVar(&s.Address, "address", "", "Optionally provide a real remote address, ip:port ") fl := flag.NewFlagSet("", flag.ContinueOnError)
}, func(s *createTunnelFlags, a []string) (commands.Result, error) { s := createTunnelFlags{}
return runCreateTunnel(f, s, a) fl.StringVar(&s.Address, "address", "", "Optionally provide a real remote address, ip:port ")
})) return fl, &s
},
Callback: func(fs any, a []string, w commands.StringWriter) error {
return createTunnelCommand(f, fs, a, w)
},
})
reg.Register(&commands.Command{ reg.Register(&commands.Command{
Name: commands.QueryLighthouse, Name: commands.QueryLighthouse,
ShortDescription: "Query the lighthouses for the provided vpn address", ShortDescription: "Query the lighthouses for the provided vpn address",
Help: "This command is asynchronous. Only currently known udp addresses will be printed.", Help: "This command is asynchronous. Only currently known udp addresses will be printed.",
Run: func(fs any, a []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
return runQueryLighthouse(f, a) return queryLighthouseCommand(f, fs, a, w)
}, },
// No Text on purpose; see print-tunnel.
JSONOnly: true,
}) })
} }
// runListHostMap computes the hostmap listing. Presentation is Render's job. func listHostMapCommand(hl controlHostLister, a any, w commands.StringWriter) error {
func runListHostMap(hl controlHostLister, fs *listHostMapFlags) (commands.Result, error) { fs, ok := a.(*listHostMapFlags)
if !ok {
return fmt.Errorf("internal error: expected *listHostMapFlags but was %T", a)
}
var hm []ControlHostInfo var hm []ControlHostInfo
if fs.ByIndex { if fs.ByIndex {
hm = listHostMapIndexes(hl) hm = listHostMapIndexes(hl)
@@ -257,21 +257,39 @@ func runListHostMap(hl controlHostLister, fs *listHostMapFlags) (commands.Result
return hm[i].VpnAddrs[0].Compare(hm[j].VpnAddrs[0]) < 0 return hm[i].VpnAddrs[0].Compare(hm[j].VpnAddrs[0]) < 0
}) })
return commands.Value(hm), nil if fs.Json || fs.Pretty {
} js := json.NewEncoder(w.GetWriter())
if fs.Pretty {
js.SetIndent("", " ")
}
// textListHostMap is the human rendering, shared by every surface. if err := js.Encode(hm); err != nil {
func textListHostMap(hm []ControlHostInfo, w io.Writer) error {
for _, h := range hm {
if _, err := fmt.Fprintf(w, "%s: %s\n", h.VpnAddrs, h.RemoteAddrs); err != nil {
return err return err
} }
} else {
for _, v := range hm {
err := w.WriteLine(fmt.Sprintf("%s: %s", v.VpnAddrs, v.RemoteAddrs))
if err != nil {
return err
}
}
} }
return nil return nil
} }
func runListLighthouseMap(lightHouse *LightHouse) (commands.Result, error) { func listLighthouseAddrmapCommand(lightHouse *LightHouse, a any, w commands.StringWriter) error {
fs, ok := a.(*listHostMapFlags)
if !ok {
return fmt.Errorf("internal error: expected *listHostMapFlags but was %T", a)
}
type lighthouseInfo struct {
VpnAddr string `json:"vpnAddr"`
Addrs *CacheMap `json:"addrs"`
}
lightHouse.RLock() lightHouse.RLock()
addrMap := make([]lighthouseInfo, len(lightHouse.addrMap)) addrMap := make([]lighthouseInfo, len(lightHouse.addrMap))
x := 0 x := 0
@@ -288,64 +306,56 @@ func runListLighthouseMap(lightHouse *LightHouse) (commands.Result, error) {
return strings.Compare(addrMap[i].VpnAddr, addrMap[j].VpnAddr) < 0 return strings.Compare(addrMap[i].VpnAddr, addrMap[j].VpnAddr) < 0
}) })
return commands.Value(addrMap), nil if fs.Json || fs.Pretty {
} js := json.NewEncoder(w.GetWriter())
if fs.Pretty {
js.SetIndent("", " ")
}
func textListLighthouseMap(addrMap []lighthouseInfo, w io.Writer) error { if err := js.Encode(addrMap); err != nil {
for _, e := range addrMap {
b, err := json.Marshal(e.Addrs)
if err != nil {
return err return err
} }
if _, err := fmt.Fprintf(w, "%s: %s\n", e.VpnAddr, string(b)); err != nil {
return err } else {
for _, v := range addrMap {
b, err := json.Marshal(v.Addrs)
if err != nil {
return err
}
err = w.WriteLine(fmt.Sprintf("%s: %s", v.VpnAddr, string(b)))
if err != nil {
return err
}
} }
} }
return nil return nil
} }
func textVersion(vi versionInfo, w io.Writer) error { // parseVpnAddr parses the vpn address a command takes as its first operand, failing to w
_, err := fmt.Fprintf(w, "%s\n", vi.Version) // when there is none or it does not parse. noun is how the command's messages name it,
return err // "vpn address" or "vpn addr", which the output golden pins per command.
} func parseVpnAddr(a []string, noun string, w commands.StringWriter) (netip.Addr, error) {
// vpnAddrOperand parses the vpn address a command takes as its first operand. noun is
// how the command's messages name it, "vpn address" or "vpn addr", which the output
// golden pins per command. With no operand, or one that does not parse, ok is false and
// res is the refusal to return.
func vpnAddrOperand(a []string, noun string) (vpnAddr netip.Addr, res commands.Result, ok bool) {
if len(a) == 0 { if len(a) == 0 {
return netip.Addr{}, commands.Failed("No vpn address was provided"), false return netip.Addr{}, commands.Fail(w, "No vpn address was provided")
} }
vpnAddr, err := netip.ParseAddr(a[0]) vpnAddr, err := netip.ParseAddr(a[0])
if err != nil { if err != nil {
return netip.Addr{}, commands.Failed("The provided %s could not be parsed: %s", noun, a[0]), false return netip.Addr{}, commands.Fail(w, fmt.Sprintf("The provided %s could not be parsed: %s", noun, a[0]))
} }
return vpnAddr, commands.Result{}, true return vpnAddr, nil
} }
// tunnelOperand is vpnAddrOperand followed by the lookup of the tunnel it names. func versionCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
func tunnelOperand(ifce *Interface, a []string, noun string) (*HostInfo, commands.Result, bool) { return w.WriteLine(ifce.version)
vpnAddr, res, ok := vpnAddrOperand(a, noun)
if !ok {
return nil, res, false
}
hostInfo := ifce.hostMap.QueryVpnAddr(vpnAddr)
if hostInfo == nil {
return nil, commands.Failed("Could not find tunnel for %s: %v", noun, a[0]), false
}
return hostInfo, commands.Result{}, true
} }
func runQueryLighthouse(ifce *Interface, a []string) (commands.Result, error) { func queryLighthouseCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
vpnAddr, res, ok := vpnAddrOperand(a, "vpn address") vpnAddr, err := parseVpnAddr(a, "vpn address", w)
if !ok { if err != nil {
return res, nil return err
} }
var cm *CacheMap var cm *CacheMap
@@ -353,52 +363,59 @@ func runQueryLighthouse(ifce *Interface, a []string) (commands.Result, error) {
if rl != nil { if rl != nil {
cm = rl.CopyCache() cm = rl.CopyCache()
} }
return commands.Value(cm), nil return json.NewEncoder(w.GetWriter()).Encode(cm)
} }
func runCloseTunnel(ifce *Interface, flags *closeTunnelFlags, a []string) (commands.Result, error) { func closeTunnelCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
hostInfo, res, ok := tunnelOperand(ifce, a, "vpn address") flags, ok := fs.(*closeTunnelFlags)
if !ok { if !ok {
return res, nil return fmt.Errorf("internal error: expected *closeTunnelFlags but was %T", fs)
}
vpnAddr, err := parseVpnAddr(a, "vpn address", w)
if err != nil {
return err
}
hostInfo := ifce.hostMap.QueryVpnAddr(vpnAddr)
if hostInfo == nil {
return commands.Fail(w, fmt.Sprintf("Could not find tunnel for vpn address: %v", a[0]))
} }
if !flags.LocalOnly { if !flags.LocalOnly {
ifce.send( ifce.sendCloseTunnel(hostInfo)
header.CloseTunnel,
0,
hostInfo.ConnectionState,
hostInfo,
[]byte{},
make([]byte, 12, 12),
make([]byte, mtu),
)
} }
ifce.closeTunnel(hostInfo) ifce.closeTunnel(hostInfo)
return commands.Did("Closed"), nil return w.WriteLine("Closed")
} }
func runCreateTunnel(ifce *Interface, flags *createTunnelFlags, a []string) (commands.Result, error) { func createTunnelCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
flags, ok := fs.(*createTunnelFlags)
vpnAddr, res, ok := vpnAddrOperand(a, "vpn address")
if !ok { if !ok {
return res, nil return fmt.Errorf("internal error: expected *createTunnelFlags but was %T", fs)
} }
if hostInfo := ifce.hostMap.QueryVpnAddr(vpnAddr); hostInfo != nil { vpnAddr, err := parseVpnAddr(a, "vpn address", w)
return commands.Failed("Tunnel already exists"), nil if err != nil {
return err
} }
if hostInfo := ifce.handshakeManager.QueryVpnAddr(vpnAddr); hostInfo != nil { hostInfo := ifce.hostMap.QueryVpnAddr(vpnAddr)
return commands.Failed("Tunnel already handshaking"), nil if hostInfo != nil {
return commands.Fail(w, "Tunnel already exists")
}
hostInfo = ifce.handshakeManager.QueryVpnAddr(vpnAddr)
if hostInfo != nil {
return commands.Fail(w, "Tunnel already handshaking")
} }
var addr netip.AddrPort var addr netip.AddrPort
if flags.Address != "" { if flags.Address != "" {
var err error
addr, err = netip.ParseAddrPort(flags.Address) addr, err = netip.ParseAddrPort(flags.Address)
if err != nil { if err != nil {
return commands.Failed("Address could not be parsed"), nil return commands.Fail(w, "Address could not be parsed")
} }
} }
@@ -411,141 +428,176 @@ func runCreateTunnel(ifce *Interface, flags *createTunnelFlags, a []string) (com
} }
}) })
return commands.Did("Created"), nil return w.WriteLine("Created")
} }
func runChangeRemote(ifce *Interface, flags *changeRemoteFlags, a []string) (commands.Result, error) { func changeRemoteCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
flags, ok := fs.(*changeRemoteFlags)
if !ok {
return fmt.Errorf("internal error: expected *changeRemoteFlags but was %T", fs)
}
if len(a) == 0 { vpnAddr, err := parseVpnAddr(a, "vpn address", w)
return commands.Failed("No vpn address was provided"), nil if err != nil {
return err
} }
if flags.Address == "" { if flags.Address == "" {
return commands.Failed("No address was provided"), nil return commands.Fail(w, "No address was provided")
} }
addr, err := netip.ParseAddrPort(flags.Address) addr, err := netip.ParseAddrPort(flags.Address)
if err != nil { if err != nil {
return commands.Failed("Address could not be parsed"), nil return commands.Fail(w, "Address could not be parsed")
} }
hostInfo, res, ok := tunnelOperand(ifce, a, "vpn address") hostInfo := ifce.hostMap.QueryVpnAddr(vpnAddr)
if !ok { if hostInfo == nil {
return res, nil return commands.Fail(w, fmt.Sprintf("Could not find tunnel for vpn address: %v", a[0]))
} }
hostInfo.SetRemote(addr) hostInfo.SetRemote(addr)
return commands.Did("Changed"), nil return w.WriteLine("Changed")
} }
func runLogLevel(l *slog.Logger, a []string) (commands.Result, error) { func logLevelCommand(l *slog.Logger, fs any, a []string, w commands.StringWriter) error {
ctrl, ok := l.Handler().(interface { ctrl, ok := l.Handler().(interface {
GetLevel() slog.Level GetLevel() slog.Level
SetLevel(slog.Level) SetLevel(slog.Level)
}) })
if !ok { if !ok {
return commands.Failed("Log level is not reconfigurable on this logger"), nil return commands.Fail(w, "Log level is not reconfigurable on this logger")
} }
if len(a) > 0 { if len(a) == 0 {
level, err := logging.ParseLevel(strings.ToLower(a[0])) return w.WriteLine(fmt.Sprintf("Log level is: %s", logging.LevelName(ctrl.GetLevel())))
if err != nil {
return commands.Failed("Unknown log level %s. Possible log levels: trace, debug, info, warn, error", a), nil
}
ctrl.SetLevel(level)
} }
return commands.Value(logLevelInfo{Level: logging.LevelName(ctrl.GetLevel())}), nil level, err := logging.ParseLevel(strings.ToLower(a[0]))
if err != nil {
return commands.Fail(w, fmt.Sprintf("Unknown log level %s. Possible log levels: trace, debug, info, warn, error", a))
}
ctrl.SetLevel(level)
return w.WriteLine(fmt.Sprintf("Log level is: %s", logging.LevelName(ctrl.GetLevel())))
} }
func textLogLevel(li logLevelInfo, w io.Writer) error { func logFormatCommand(l *slog.Logger, fs any, a []string, w commands.StringWriter) error {
_, err := fmt.Fprintf(w, "Log level is: %s\n", li.Level)
return err
}
func runLogFormat(l *slog.Logger, a []string) (commands.Result, error) {
ctrl, ok := l.Handler().(interface { ctrl, ok := l.Handler().(interface {
GetFormat() string GetFormat() string
SetFormat(string) error SetFormat(string) error
}) })
if !ok { if !ok {
return commands.Failed("Log format is not reconfigurable on this logger"), nil return commands.Fail(w, "Log format is not reconfigurable on this logger")
} }
if len(a) > 0 { if len(a) == 0 {
if err := ctrl.SetFormat(strings.ToLower(a[0])); err != nil { return w.WriteLine(fmt.Sprintf("Log format is: %s", ctrl.GetFormat()))
return commands.Failed("Unable to set log format: %s", err), nil
}
} }
return commands.Value(logFormatInfo{Format: ctrl.GetFormat()}), nil if err := ctrl.SetFormat(strings.ToLower(a[0])); err != nil {
return commands.Fail(w, fmt.Sprintf("Unable to set log format: %s", err))
}
return w.WriteLine(fmt.Sprintf("Log format is: %s", ctrl.GetFormat()))
} }
func textLogFormat(fi logFormatInfo, w io.Writer) error { func printCertCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
_, err := fmt.Fprintf(w, "Log format is: %s\n", fi.Format) args, ok := fs.(*printCertFlags)
return err if !ok {
} return fmt.Errorf("internal error: expected *printCertFlags but was %T", fs)
}
func runPrintCert(ifce *Interface, args *printCertFlags, a []string) (commands.Result, error) { cert := ifce.pki.getCertState().GetDefaultCertificate()
c := ifce.pki.getCertState().GetDefaultCertificate()
if len(a) > 0 { if len(a) > 0 {
hostInfo, res, ok := tunnelOperand(ifce, a, "vpn addr") vpnAddr, err := parseVpnAddr(a, "vpn addr", w)
if !ok { if err != nil {
return res, nil return err
} }
// A tunnel still handshaking, or one being torn down, has no certificate.
cc := hostInfo.GetCert() hostInfo := ifce.hostMap.QueryVpnAddr(vpnAddr)
if cc == nil { if hostInfo == nil {
return commands.Failed("Could not find tunnel for vpn addr: %v", a[0]), nil return commands.Fail(w, fmt.Sprintf("Could not find tunnel for vpn addr: %v", a[0]))
} }
c = cc.Certificate
cert = hostInfo.GetCert().Certificate
}
if args.Json || args.Pretty {
b, err := cert.MarshalJSON()
if err != nil {
return commands.Fail(w, fmt.Sprintf("Unable to marshal the certificate: %s", err))
}
if args.Pretty {
buf := new(bytes.Buffer)
if err := json.Indent(buf, b, "", " "); err != nil {
return commands.Fail(w, fmt.Sprintf("Unable to marshal the certificate: %s", err))
}
b = buf.Bytes()
}
return w.WriteBytes(b)
} }
if args.Raw { if args.Raw {
b, err := c.MarshalPEM() b, err := cert.MarshalPEM()
if err != nil { if err != nil {
return commands.Failed("Unable to marshal the certificate: %s", err), nil return commands.Fail(w, fmt.Sprintf("Unable to marshal the certificate: %s", err))
} }
return commands.Value(certPEM{PEM: string(b)}), nil
return w.WriteBytes(b)
} }
return commands.Value(c), nil return w.WriteLine(cert.String())
} }
// textPrintCert takes the value untyped: print-cert returns a certificate or, with -raw, func printRelaysCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
// its PEM, and those are two things to emit rather than two renderings of one. args, ok := fs.(*printTunnelFlags)
func textPrintCert(v any, w io.Writer) error { if !ok {
switch c := v.(type) { return fmt.Errorf("internal error: expected *printTunnelFlags but was %T", fs)
case certPEM:
_, err := io.WriteString(w, c.PEM)
return err
case cert.Certificate:
_, err := io.WriteString(w, c.String()+"\n")
return err
default:
return fmt.Errorf("expected a certificate, got %T", v)
} }
}
func runPrintRelays(ifce *Interface) any {
ifce.hostMap.RLock() ifce.hostMap.RLock()
relays := maps.Clone(ifce.hostMap.Relays) relays := maps.Clone(ifce.hostMap.Relays)
ifce.hostMap.RUnlock() ifce.hostMap.RUnlock()
co := relaysOutput{} type RelayFor struct {
Error string `json:",omitempty"`
Type string
State string
PeerAddr netip.Addr
LocalIndex uint32
RemoteIndex uint32
RelayedThrough []netip.Addr
}
type RelayOutput struct {
NebulaAddr netip.Addr
RelayForAddrs []RelayFor
}
type CmdOutput struct {
Relays []*RelayOutput
}
co := CmdOutput{}
enc := json.NewEncoder(w.GetWriter())
if args.Pretty {
enc.SetIndent("", " ")
}
for k, v := range relays { for k, v := range relays {
ro := relayOutput{NebulaAddr: v.vpnAddrs[0]} ro := RelayOutput{NebulaAddr: v.vpnAddrs[0]}
co.Relays = append(co.Relays, &ro) co.Relays = append(co.Relays, &ro)
relayHI := ifce.hostMap.QueryVpnAddr(v.vpnAddrs[0]) relayHI := ifce.hostMap.QueryVpnAddr(v.vpnAddrs[0])
if relayHI == nil { if relayHI == nil {
ro.RelayForAddrs = append(ro.RelayForAddrs, relayFor{Error: "could not find hostinfo"}) ro.RelayForAddrs = append(ro.RelayForAddrs, RelayFor{Error: "could not find hostinfo"})
continue continue
} }
for _, vpnAddr := range relayHI.relayState.CopyRelayForIps() { for _, vpnAddr := range relayHI.relayState.CopyRelayForIps() {
rf := relayFor{} rf := RelayFor{}
r, ok := relayHI.relayState.GetRelayForByAddr(vpnAddr) r, ok := relayHI.relayState.GetRelayForByAddr(vpnAddr)
if ok { if ok {
t := "" t := ""
@@ -558,21 +610,21 @@ func runPrintRelays(ifce *Interface) any {
t = "unknown" t = "unknown"
} }
st := "" s := ""
switch r.State { switch r.State {
case Requested: case Requested:
st = "requested" s = "requested"
case Established: case Established:
st = "established" s = "established"
default: default:
st = "unknown" s = "unknown"
} }
rf.LocalIndex = r.LocalIndex rf.LocalIndex = r.LocalIndex
rf.RemoteIndex = r.RemoteIndex rf.RemoteIndex = r.RemoteIndex
rf.PeerAddr = r.PeerAddr rf.PeerAddr = r.PeerAddr
rf.Type = t rf.Type = t
rf.State = st rf.State = s
if rf.LocalIndex != k { if rf.LocalIndex != k {
rf.Error = fmt.Sprintf("hostmap LocalIndex '%v' does not match RelayState LocalIndex", k) rf.Error = fmt.Sprintf("hostmap LocalIndex '%v' does not match RelayState LocalIndex", k)
} }
@@ -585,40 +637,74 @@ func runPrintRelays(ifce *Interface) any {
ro.RelayForAddrs = append(ro.RelayForAddrs, rf) ro.RelayForAddrs = append(ro.RelayForAddrs, rf)
} }
} }
return enc.Encode(co)
return co
} }
func runPrintTunnel(ifce *Interface, a []string) (commands.Result, error) { func printTunnelCommand(ifce *Interface, fs any, a []string, w commands.StringWriter) error {
hostInfo, res, ok := tunnelOperand(ifce, a, "vpn addr") args, ok := fs.(*printTunnelFlags)
if !ok { if !ok {
return res, nil return fmt.Errorf("internal error: expected *printTunnelFlags but was %T", fs)
} }
return commands.Value(copyHostInfo(hostInfo, ifce.hostMap.GetPreferredRanges())), nil vpnAddr, err := parseVpnAddr(a, "vpn addr", w)
if err != nil {
return err
}
hostInfo := ifce.hostMap.QueryVpnAddr(vpnAddr)
if hostInfo == nil {
return commands.Fail(w, fmt.Sprintf("Could not find tunnel for vpn addr: %v", a[0]))
}
enc := json.NewEncoder(w.GetWriter())
if args.Pretty {
enc.SetIndent("", " ")
}
return enc.Encode(copyHostInfo(hostInfo, ifce.hostMap.GetPreferredRanges()))
} }
func runDeviceInfo(ifce *Interface) deviceInfo { func deviceInfoCommand(ifce *Interface, fs any, w commands.StringWriter) error {
d := deviceInfo{ flags, ok := fs.(*deviceInfoFlags)
if !ok {
return fmt.Errorf("internal error: expected flags to be deviceInfoFlags but was %+v", fs)
}
data := struct {
Name string `json:"name"`
Cidr []netip.Prefix `json:"cidr"`
}{
Name: ifce.inside.Name(), Name: ifce.inside.Name(),
Cidr: make([]netip.Prefix, len(ifce.inside.Networks())), Cidr: make([]netip.Prefix, len(ifce.inside.Networks())),
} }
copy(d.Cidr, ifce.inside.Networks())
return d copy(data.Cidr, ifce.inside.Networks())
if flags.Json || flags.Pretty {
js := json.NewEncoder(w.GetWriter())
if flags.Pretty {
js.SetIndent("", " ")
}
return js.Encode(data)
} else {
return w.WriteLine(fmt.Sprintf("name=%v cidr=%v", data.Name, data.Cidr))
}
} }
func textDeviceInfo(d deviceInfo, w io.Writer) error { // reloadCommand reloads the config and writes the result to the client. It reloads even if the client has gone away
_, err := fmt.Fprintf(w, "name=%v cidr=%v\n", d.Name, d.Cidr) func reloadCommand(l *slog.Logger, c *config.C, w commands.StringWriter) error {
return err writeErr := w.WriteLine("Reloading config")
}
// runReload reloads the config and reports how it went. A reload that failed is a
// refusal, exit 1 over ssh; one that merely needs a restart is not.
func runReload(l *slog.Logger, c *config.C) commands.Result {
res := c.ReloadConfig() res := c.ReloadConfig()
res.Log(l) res.Log(l)
if res.Err != nil || res.Failed { if err := w.WriteLine(res.String()); writeErr == nil {
return commands.Failed("%s", res.String()) writeErr = err
} }
return commands.Did("%s", res.String()) if writeErr != nil {
return writeErr
}
if res.Err != nil || res.Failed {
return &commands.Failure{Msg: res.String()}
}
return nil
} }
+46 -263
View File
@@ -1,73 +1,36 @@
package commands package commands
import ( import (
"errors"
"flag" "flag"
"fmt"
"io"
"strings"
) )
// CommandFlags is called before help or command execution to parse command line flags. // CommandFlags is called before help or command execution to parse command line flags.
// It should return a flag.FlagSet instance and a pointer to the struct that will contain parsed flags // It should return a flag.FlagSet instance and a pointer to the struct that will contain parsed flags
//
// Every call must build a fresh FlagSet and a fresh struct. Nothing may be shared between
// calls: a command runs on more than one surface and on more than one goroutine.
type CommandFlags func() (*flag.FlagSet, any) type CommandFlags func() (*flag.FlagSet, any)
// RunFunc computes a command's Result. // CommandCallback is called when your command should execute.
// // fs will be a pointer to the struct provided by Command.Flags callback, if there was one. -h and -help are reserved
// fs is the pointer returned by Command.Flags, if there was one; -h, -help, -json and // and handled automatically for you.
// -pretty are reserved and handled before Run is called. a is the operands: whatever // a will be any unconsumed arguments, if no Command.Flags was available this will be all the flags passed in.
// was not consumed as a flag. The Result is rendered by whichever surface asked: Value // w is the writer to use when sending messages back to the client.
// for a command that reports, Did or Failed for one that acts, Nothing for one with // An error returned by the callback is handed back to whoever dispatched the command, which reports a failure: exit
// nothing to say. An error is for a failure of the command itself; a bad argument is // status 1 over ssh. The error is not shown to the user. For a failure the user caused or can act on, write the
// Failed, so the caller hears why in its own format. // message and return it as a *Failure, which Fail does in one step; the surface then reports the failure without
type RunFunc func(fs any, a []string) (Result, error) // logging what the user was already told. Any other error is logged by the surface as well.
type CommandCallback func(fs any, a []string, w StringWriter) error
// TextFunc renders a Result's Value for a person. See Typed for declaring one against
// the type the command actually returns.
type TextFunc func(v any, w io.Writer) error
type Command struct { type Command struct {
Name Name Name Name
ShortDescription string ShortDescription string
Help string Help string
Flags CommandFlags Flags CommandFlags
Callback CommandCallback
// Run produces the command's Result, leaving presentation to Render.
Run RunFunc
// Text renders a Result's Value for a person. Both surfaces call it, so a command
// reads the same over ssh as it does through the control socket. It never sees an
// outcome: Render prints those itself, the same way for every command. Leaving it
// nil declares that no human rendering of the Value exists yet, which JSONOnly says
// up front; Render then refuses text rather than inventing an interim form for
// people to script against.
Text TextFunc
// JSONOnly declares that the command's Value has no human rendering yet, so a surface
// whose default is text asks for JSON instead, and the schema says so to a client. It
// is a statement that no such form exists, not a fallback. A refusal is still
// rendered as a sentence, since that always has a human form.
JSONOnly bool
// Then, when set, is the second half of a command that acts: Run says what is about
// to happen and Then does it and says how it went, with its Result rendered after
// Run's and deciding the outcome. A Run that refused is the outcome, and Then does
// not run. It exists for a command whose action can cut off
// its own reply: reload restarts the ssh server when the sshd keys changed, which
// ends the session that asked, so Run's line has to be on the wire before the reload
// begins. A surface that answers in one piece, the control socket, runs Then before
// it answers and carries both.
Then func() Result
} }
// Failure is the error a surface gets for a refusal the person has already been shown: // Failure is the error a command returns for a failure it has already explained to the user:
// a Run that returned Failed, a command that is not there, a line that would not parse. // the message it wrote is the whole story. A surface reports it as a failure and does not
// The message it rendered is the whole story, so the surface reports the failure, exit // log it.
// status 1 over ssh, and does not log it.
type Failure struct { type Failure struct {
Msg string Msg string
} }
@@ -76,225 +39,45 @@ func (f *Failure) Error() string {
return f.Msg return f.Msg
} }
// commandFlags returns the FlagSet a command is driven through, on any surface: the // Fail writes msg to w and returns it as a *Failure, so a command reports a failure to the
// command's own flags, if it declares any, with the two presentation flags added. own // user and to its surface in one line. If the write itself fails, that error is returned
// reports whether the command declared any of its own, which is what tells a caller // instead: the user was not told anything.
// whether to say a parameter is unknown or that the command takes none at all. func Fail(w StringWriter, msg string) error {
// if err := w.WriteLine(msg); err != nil {
// The presentation flags are defined here rather than by each command, because how a return err
// result is displayed is not a property of the command that produced it. This is also }
// the one definition of them: the ssh line parses into it, nebula ctl parses its line return &Failure{Msg: msg}
// against the schema derived from it, and help renders from that schema. They are }
// command line flags only: a socket request chooses its rendering with the envelope's
// format field, and Invoke refuses them as parameters. func execCommand(c *Command, args []string, w StringWriter) error {
func commandFlags(c *Command) (fl *flag.FlagSet, fs any, own bool) { var (
fl *flag.FlagSet
fs any
)
if c.Flags != nil { if c.Flags != nil {
fl, fs = c.Flags() fl, fs = c.Flags()
} if fl != nil {
own = fl != nil // SetOutput() here in case fl.Parse dumps usage.
if fl == nil { fl.SetOutput(w.GetWriter())
fl = flag.NewFlagSet(string(c.Name), flag.ContinueOnError) err := fl.Parse(args)
} if err != nil {
// fl.Parse has dumped error information to the user via the w writer.
addPresentationFlags(fl) return err
// What Parse prints after a bad flag, and for -h: the command's usage as help renders
// it, so a line that went wrong is answered with the same text as `help <command>`.
fl.Usage = func() { _ = WriteCommandHelp(schemaOf(c, fl), fl.Output()) }
return fl, fs, own
}
// addPresentationFlags defines the two presentation flags on fl.
func addPresentationFlags(fl *flag.FlagSet) {
fl.Bool(FlagJSON, false, "outputs as json")
fl.Bool(FlagPretty, false, "pretty prints json, assumes -json")
}
// Flagged fills in c's Flags and Run as a pair: define declares the flags on a fresh F,
// and run is handed that F. The struct the flags fill is the struct Run reads by
// construction, so no Run has to assert the type it was given or decide what to do
// when the assertion fails.
func Flagged[F any](c *Command, define func(*flag.FlagSet, *F), run func(*F, []string) (Result, error)) *Command {
c.Flags = func() (*flag.FlagSet, any) {
fl := flag.NewFlagSet("", flag.ContinueOnError)
s := new(F)
define(fl, s)
return fl, s
}
c.Run = func(fs any, a []string) (Result, error) {
s, ok := fs.(*F)
if !ok {
return Result{}, fmt.Errorf("%s was handed %T for its flags, not %T", c.Name, fs, s)
}
return run(s, a)
}
return c
}
// isPresentationFlag reports whether name is one of the two flags commandFlags adds.
func isPresentationFlag(name string) bool {
return name == FlagJSON || name == FlagPretty
}
// execLine runs an ssh command line against c, reporting problems to w. The line is
// parsed into the command's own FlagSet and Run reads it directly, so a flag.Value whose
// String does not re-parse, flag.Func above all, arrives as the line said. Invoke fills
// the same FlagSet through Set.
func (r *Registry) execLine(c *Command, args []string, w Output) error {
fl, fs, _ := commandFlags(c)
// Parse reports a bad flag to this writer, with the command's usage after it. -h,
// -help and --help take the same path with nothing wrong: the usage is the whole
// answer, and Parse says so with ErrHelp. A -h that is a flag's value or follows --
// is read as the operand it is, since ParseArgs is the one reading of the line.
fl.SetOutput(w.Err)
operands, err := ParseArgs(fl, args)
if err != nil {
if errors.Is(err, flag.ErrHelp) {
return nil
}
return err
}
format := presentationFormat(fl)
// An error from Run is something the command could not do rather than a refusal it
// chose, but the person at the prompt still hears it; the surface logs it too.
res, err := c.Run(fs, operands)
if err != nil {
_, _ = fmt.Fprintln(w.Err, err.Error())
return err
}
// Run's reply goes out first, and then the action, if the command has one and Run
// did not refuse, whose Result is the outcome. In JSON only the outcome travels:
// the promise is for a person to read, and a program expects one document.
if c.Then == nil || !res.OK || r.formatFor(c, res, format) == FormatText {
if err := r.renderLine(c, res, format, w); err != nil {
return err
}
}
if c.Then != nil && res.OK {
res = c.Then()
if err := r.renderLine(c, res, format, w); err != nil {
return err
}
}
if !res.OK {
return &Failure{Msg: res.Reason}
}
return nil
}
// formatFor is the format a Result is rendered in. The line wins when it asked for one;
// otherwise the surface that owns the registry decides, from the command and its
// Result, so each surface can keep its own default.
func (r *Registry) formatFor(c *Command, res Result, format Format) Format {
if format == FormatUnset {
return r.defaultFormatFor(c, res)
}
return format
}
// renderLine writes one Result of a command line to w; see formatFor. An empty Result
// writes nothing.
func (r *Registry) renderLine(c *Command, res Result, format Format, w Output) error {
if res.Empty() {
return nil
}
if err := Render(c, res, r.formatFor(c, res, format), w.Out); err != nil {
if errors.Is(err, ErrNoTextRendering) {
_, _ = fmt.Fprintln(w.Err, err.Error())
}
return err
}
return nil
}
// ParseArgs parses args with fl and returns the operands.
//
// It differs from fl.Parse in two ways, and both surfaces parse through here so a line
// means the same typed at an ssh prompt or to nebula ctl.
//
// Flags and operands may come in any order, which is the one way it differs from
// fl.Parse. Parse stops at the first operand, so `print-tunnel 10.0.0.1 -json` would
// reach the command with "-json" as a second operand and the flag silently dropped. Here
// an operand ends nothing: parsing resumes after it, and only "--" ends the flags, with
// everything after it an operand. What counts as a flag is Parse's rule: every argument
// that starts with "-", a negative number included, so one that is meant as an operand
// goes after "--".
func ParseArgs(fl *flag.FlagSet, args []string) ([]string, error) {
operands := make([]string, 0, len(args))
for len(args) > 0 {
// Walk the flags the way Parse will, to the first argument it would not read as a
// flag: an operand or the terminator. Everything before it is Parse's.
end := len(args)
for i := 0; i < len(args); {
a := args[i]
if a == "--" {
if err := fl.Parse(args[:i]); err != nil {
return nil, err
}
return append(operands, args[i+1:]...), nil
}
if len(a) < 2 || a[0] != '-' {
end = i
break
}
f, hasValue := LookupArg(fl, a)
if f == nil {
// An undefined flag: leave it for Parse to report.
i++
continue
}
if hasValue || IsBoolFlag(f) {
i++
} else {
// The flag's value is the next argument, whatever it looks like.
i += 2
} }
args = fl.Args()
} }
if err := fl.Parse(args[:end]); err != nil {
return nil, err
}
if end == len(args) {
break
}
operands = append(operands, args[end])
args = args[end+1:]
} }
return operands, nil return c.Callback(fs, args, w)
} }
// LookupArg reads arg the way Parse does: one or two leading dashes, the flag's name, and func checkHelpArgs(args []string) bool {
// an optional "=value". f is the flag of fl by that name, nil when fl has none, and for _, a := range args {
// hasValue reports that the value came with the argument rather than in the one after it. if a == "-h" || a == "-help" {
// It is the one reading of an argument's shape: ParseArgs walks a line with it, and return true
// nebula ctl lifts its own flags out of a line with it, so the two cannot disagree about }
// which word is a flag's value.
func LookupArg(fl *flag.FlagSet, arg string) (f *flag.Flag, hasValue bool) {
name := strings.TrimPrefix(strings.TrimPrefix(arg, "-"), "-")
if eq := strings.IndexByte(name, '='); eq >= 0 {
name, hasValue = name[:eq], true
} }
return fl.Lookup(name), hasValue
}
// IsBoolFlag reports whether f is satisfied by its presence alone and never reads the return false
// argument after it as its value. The flag package marks these with an unexported
// interface, which is the only way to tell.
func IsBoolFlag(f *flag.Flag) bool {
bf, ok := f.Value.(interface{ IsBoolFlag() bool })
return ok && bf.IsBoolFlag()
} }
-101
View File
@@ -1,101 +0,0 @@
package commands
import (
"bytes"
"flag"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestParseArgsAllowsFlagsAfterOperands pins the one way ParseArgs departs from fl.Parse,
// that a flag may follow an operand, and that it departs in no other: a negative number
// is a flag, as Parse reads it, and goes after "--" when it is meant as an operand.
func TestParseArgsAllowsFlagsAfterOperands(t *testing.T) {
cases := map[string]struct {
args []string
wantOps []string
wantN string
wantV bool
wantJSON bool
wantErr string
}{
"flag after operand": {args: []string{"x", "-json"}, wantOps: []string{"x"}, wantJSON: true},
"flags around": {args: []string{"-v", "x", "-n", "1", "y"}, wantOps: []string{"x", "y"}, wantV: true, wantN: "1"},
"value after operand": {args: []string{"x", "-n", "-1"}, wantOps: []string{"x"}, wantN: "-1"},
"equals value": {args: []string{"-n=-1", "x"}, wantOps: []string{"x"}, wantN: "-1"},
"terminator after": {args: []string{"x", "--", "-json", "-1"}, wantOps: []string{"x", "-json", "-1"}},
"terminator": {args: []string{"--", "-json"}, wantOps: []string{"-json"}},
"defined numeric": {args: []string{"-2", "x"}, wantOps: []string{"x"}, wantV: true},
"negative number": {args: []string{"-1"}, wantErr: "flag provided but not defined: -1"},
"bad flag after": {args: []string{"x", "-nope"}, wantErr: "flag provided but not defined: -nope"},
"undefined flag": {args: []string{"-nope", "x"}, wantErr: "flag provided but not defined: -nope"},
"missing value": {args: []string{"-n"}, wantErr: "flag needs an argument: -n"},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
fl := flag.NewFlagSet("t", flag.ContinueOnError)
fl.SetOutput(&bytes.Buffer{})
n := fl.String("n", "", "")
v := fl.Bool("v", false, "")
two := fl.Bool("2", false, "a flag that happens to be a number")
asJSON := fl.Bool(FlagJSON, false, "")
ops, err := ParseArgs(fl, tc.args)
if tc.wantErr != "" {
require.ErrorContains(t, err, tc.wantErr)
return
}
require.NoError(t, err)
assert.Equal(t, tc.wantOps, ops)
assert.Equal(t, tc.wantN, *n)
assert.Equal(t, tc.wantV, *v || *two)
assert.Equal(t, tc.wantJSON, *asJSON)
})
}
}
// TestDispatchFlagAfterOperand: the same through a registered command with no Flags of
// its own, which only has the presentation flags to find.
func TestDispatchFlagAfterOperand(t *testing.T) {
out := &bytes.Buffer{}
require.NoError(t, testRegistry().DispatchArgs([]string{"served", "x", "-json"}, MergedOutput(out)))
assert.Equal(t, "\"read x\"\n", out.String())
}
// TestLookupArg pins the reading of an argument's shape that ParseArgs and nebula ctl
// share.
func TestLookupArg(t *testing.T) {
fl := flag.NewFlagSet("t", flag.ContinueOnError)
fl.String("n", "", "")
fl.Bool("v", false, "")
for _, tc := range []struct {
arg string
name string
hasValue bool
}{
{"-n", "n", false},
{"--n", "n", false},
{"-n=1", "n", true},
{"--n=", "n", true},
{"-v", "v", false},
{"-nope", "", false},
{"-1", "", false},
} {
f, hasValue := LookupArg(fl, tc.arg)
if tc.name == "" {
assert.Nil(t, f, tc.arg)
} else {
require.NotNil(t, f, tc.arg)
assert.Equal(t, tc.name, f.Name, tc.arg)
}
assert.Equal(t, tc.hasValue, hasValue, tc.arg)
}
assert.True(t, IsBoolFlag(fl.Lookup("v")))
assert.False(t, IsBoolFlag(fl.Lookup("n")))
}
+67 -314
View File
@@ -2,9 +2,7 @@ package commands
import ( import (
"cmp" "cmp"
"flag"
"fmt" "fmt"
"io"
"maps" "maps"
"slices" "slices"
"strings" "strings"
@@ -13,38 +11,14 @@ import (
"github.com/anmitsu/go-shlex" "github.com/anmitsu/go-shlex"
) )
// Registry holds a set of commands. // Registry holds a set of commands. New is the only way to make one.
// //
// It is safe for concurrent use. Commands may be registered while surfaces are serving // It is safe for concurrent use. Commands may be registered while a surface is serving
// from the registry: the ssh server clones it per session and the control socket filters // from the registry: the ssh server clones it per session, and a clone may overlap a
// it per request, and either may overlap a Register. // Register.
type Registry struct { type Registry struct {
mu sync.RWMutex mu sync.RWMutex
commands map[Name]*Command commands map[Name]*Command
// full is set on a filtered registry and points at the registry it was filtered
// from, so a command that's filtered can be reported as such.
full *Registry
// reason explains, in the terms an operator cares about, why this registry withholds
// a command they can name. It is supplied by whoever built the filter, because why a
// surface declines a command is that surface's business, not the registry's.
reason string
// DefaultFormat decides how a result is rendered when the command line named no
// format. It sees the command and its Result, and applies to values and refusals
// alike: the registry does not special-case either. The renderer is shared between
// surfaces; what each asks for by default is not, so the surface that owns this
// registry sets it. Nil means text.
DefaultFormat func(c *Command, r Result) Format
}
// defaultFormatFor resolves the surface's default for c's Result.
func (r *Registry) defaultFormatFor(c *Command, res Result) Format {
if r.DefaultFormat == nil {
return FormatText
}
return r.DefaultFormat(c, res)
} }
// New returns an empty Registry with only `help` available. // New returns an empty Registry with only `help` available.
@@ -58,111 +32,15 @@ func (r *Registry) registerHelp() {
r.Register(&Command{ r.Register(&Command{
Name: Help, Name: Help,
ShortDescription: "prints available commands or help <command> for specific usage info", ShortDescription: "prints available commands or help <command> for specific usage info",
Run: func(a any, args []string) (Result, error) { Callback: func(a any, args []string, w StringWriter) error {
if len(args) == 0 { return r.help(args, w)
return Value(r.Schema()), nil
}
if c := r.Get(Name(args[0])); c != nil {
return Value(r.schemaFor(c)), nil
}
if err := r.unavailable(Name(args[0])); err != nil {
return Failed("%s", err), nil
}
return Failed("Command not available %s", args[0]), nil
}, },
Text: renderHelp,
}) })
} }
// renderHelp is help's human rendering: the command list, or one command's usage. // Register adds a command that can be run by a user. A command registered under a name
func renderHelp(v any, w io.Writer) error { // already held replaces it; see Clone for what that means for Help.
switch h := v.(type) {
case []CommandSchema:
return writeCommandList(h, w)
case CommandSchema:
return WriteCommandHelp(h, w)
default:
return fmt.Errorf("expected a command schema, got %T", v)
}
}
func writeCommandList(cmds []CommandSchema, w io.Writer) error {
if _, err := io.WriteString(w, "Available commands:\n"); err != nil {
return err
}
// In the order the schema came, which is the display order; see Registry.All.
lines := make([]string, 0, len(cmds))
for _, c := range cmds {
lines = append(lines, fmt.Sprintf("%s - %s", c.Name, c.Short))
}
_, err := io.WriteString(w, strings.Join(lines, "\n")+"\n\n")
return err
}
// WriteCommandHelp renders one command's usage. It is the single rendering of a
// CommandSchema for a person: the daemon uses it for `help <command>` on both surfaces,
// and a client that already holds the schema uses it for `-h`, so the two cannot drift.
func WriteCommandHelp(c CommandSchema, w io.Writer) error {
if _, err := fmt.Fprintf(w, "%s - %s\n", c.Name, c.Short); err != nil {
return err
}
if c.Help != "" {
if _, err := fmt.Fprintf(w, " %s\n", c.Help); err != nil {
return err
}
}
// Same layout as flag.PrintDefaults, including its habit of leaving out a default
// that is the zero value.
for _, f := range c.Flags {
kind := ""
if !f.Bool {
kind = " string"
}
def := ""
if f.Default != "" && f.Default != "false" {
def = fmt.Sprintf(" (default %s)", f.Default)
}
if _, err := fmt.Fprintf(w, " -%s%s\n \t%s%s\n", f.Name, kind, f.Usage, def); err != nil {
return err
}
}
return nil
}
// Register adds a command that can be run by a user.
//
// It panics if the command declares a reserved flag. That is a programming error, and
// surfacing it here, at startup, is better than at the moment an operator first types
// the command.
func (r *Registry) Register(c *Command) { func (r *Registry) Register(c *Command) {
if c.Run == nil {
panic(fmt.Sprintf("commands: %s has no Run", c.Name))
}
if c.Flags != nil {
if fl, _ := c.Flags(); fl != nil {
for _, name := range reservedFlags {
if fl.Lookup(name) != nil {
panic(fmt.Sprintf("commands: %s declares reserved flag -%s", c.Name, name))
}
}
}
}
r.insert(c)
}
// insert adds c without the reserved flag check, for commands that have already passed
// it on another registry.
func (r *Registry) insert(c *Command) {
r.mu.Lock() r.mu.Lock()
defer r.mu.Unlock() defer r.mu.Unlock()
r.commands[c.Name] = c r.commands[c.Name] = c
@@ -190,8 +68,7 @@ func (r *Registry) Match(prefix string) []string {
return cmds return cmds
} }
// All returns every registered command sorted by name, which is the order help lists // All returns every registered command sorted by name, which is the order help lists them.
// them and the schema describes them.
func (r *Registry) All() []*Command { func (r *Registry) All() []*Command {
r.mu.RLock() r.mu.RLock()
defer r.mu.RUnlock() defer r.mu.RUnlock()
@@ -201,228 +78,104 @@ func (r *Registry) All() []*Command {
return cmds return cmds
} }
// Clone returns a copy holding the same commands. // Clone returns a copy holding the same commands, with help bound to the copy: a
// // command registered on the clone alone is listed and described there, and one the
// help is re-registered on the copy rather than carried over, because the source's help // clone withholds is not. That rebinding replaces whatever was registered under Help on
// is bound to the source and would list its commands, not the copy's, once a caller // the source, built-in or not.
// registers something on the copy.
func (r *Registry) Clone() *Registry { func (r *Registry) Clone() *Registry {
r.mu.RLock() r.mu.RLock()
out := &Registry{ c := &Registry{commands: maps.Clone(r.commands)}
commands: maps.Clone(r.commands),
full: r.full,
reason: r.reason,
DefaultFormat: r.DefaultFormat,
}
r.mu.RUnlock() r.mu.RUnlock()
c.registerHelp()
out.registerHelp() return c
return out
}
// Filter returns a filtered copy of the registry.
//
// Keep should return true for commands that should be included in the copy.
//
// reason says, to an operator who names a command the copy left out, why this surface
// does not serve it; "" leaves the registry to say only that it does not.
func (r *Registry) Filter(keep func(*Command) bool, reason string) *Registry {
out := &Registry{commands: map[Name]*Command{}, full: r, reason: reason, DefaultFormat: r.DefaultFormat}
for _, cmd := range r.All() {
if keep(cmd) {
out.insert(cmd)
}
}
// Bind help to the filtered set so it only advertises what this surface serves.
out.registerHelp()
return out
} }
// Dispatch parses a command line and runs it, reporting problems to w. The error is for // Dispatch parses a command line and runs it, reporting problems to w. The error is for
// the caller to log, not to show; see RunFunc and Failure. // the caller to log, not to show; see CommandCallback.
func (r *Registry) Dispatch(line string, w Output) error { func (r *Registry) Dispatch(line string, w StringWriter) error {
// A line shlex cannot split, an unbalanced quote. Reported on Err so the output // A line shlex cannot split, an unbalanced quote.
// stream stays parseable.
args, err := shlex.Split(line, true) args, err := shlex.Split(line, true)
if err != nil { if err != nil {
msg := "could not parse the command line: " + err.Error() return Fail(w, "could not parse the command line: "+err.Error())
if _, err := fmt.Fprintln(w.Err, msg); err != nil {
return err
}
return &Failure{Msg: msg}
} }
return r.DispatchArgs(args, w) return r.DispatchArgs(args, w)
} }
// DispatchArgs runs an already tokenized command line. The error is as for Dispatch. // DispatchArgs runs an already tokenized command line. The error is as for Dispatch.
// func (r *Registry) DispatchArgs(args []string, w StringWriter) error {
// An empty line and an unknown command both end up running `help`, the first with the
// arguments help itself would take; `<command> -h` is answered by the command's own
// FlagSet, with the same rendering, in execLine.
func (r *Registry) DispatchArgs(args []string, w Output) error {
if len(args) == 0 { if len(args) == 0 {
args = []string{"help"} r.dumpCommands(w)
return nil
} }
c := r.Get(Name(args[0])) c := r.Get(Name(args[0]))
if c == nil { if c == nil {
if err := r.unavailable(Name(args[0])); err != nil {
// Saying why, rather than "did not understand", keeps the rule legible and
// points at a surface that will actually run the command.
_, _ = fmt.Fprintln(w.Err, err)
return err
}
// Only the first word was looked up, so only it is named. // Only the first word was looked up, so only it is named.
msg := fmt.Sprintf("did not understand: %s", args[0]) msg := fmt.Sprintf("did not understand: %s", args[0])
if _, err := fmt.Fprintln(w.Out, msg); err != nil { if err := w.WriteLine(msg); err != nil {
return err return err
} }
if err := r.DispatchArgs([]string{"help"}, w); err != nil { r.dumpCommands(w)
return err
}
return &Failure{Msg: msg} return &Failure{Msg: msg}
} }
return r.execLine(c, args[1:], w) if checkHelpArgs(args) {
// Through the registered help command, so -h and `help <name>` are one path.
return execCommand(r.Get(Help), []string{string(c.Name)}, w)
}
return execCommand(c, args[1:], w)
} }
// unavailable explains why name cannot be run here when this registry was filtered from // dumpCommands writes the list of available commands to w.
// one that holds it: the command exists, and this surface withholds it, for the reason func (r *Registry) dumpCommands(w StringWriter) {
// whoever built the filter gave. It is nil when name is simply unknown, so the two cases err := w.WriteLine("Available commands:")
// read differently to an operator. if err != nil {
func (r *Registry) unavailable(name Name) error { return
if r.full == nil { }
// In the order All gives, which is the display order.
cmds := make([]string, 0)
for _, l := range r.All() {
cmds = append(cmds, fmt.Sprintf("%s - %s", l.Name, l.ShortDescription))
}
_ = w.Write(strings.Join(cmds, "\n") + "\n\n")
}
// help writes the command list, or usage for the single command named in a.
func (r *Registry) help(a []string, w StringWriter) error {
// Just typed help
if len(a) == 0 {
r.dumpCommands(w)
return nil return nil
} }
c := r.full.Get(name) // We are printing a specific commands help text
if c == nil { cmd := r.Get(Name(a[0]))
return nil if cmd == nil {
return Fail(w, "Command not available "+a[0])
} }
reason := r.reason if err := w.WriteLine(fmt.Sprintf("%s - %s", cmd.Name, cmd.ShortDescription)); err != nil {
if reason == "" { return err
reason = "this surface does not serve it"
} }
return fmt.Errorf("%s is not available on this surface: %s", c.Name, reason) if cmd.Help != "" {
} if err := w.WriteLine(fmt.Sprintf(" %s", cmd.Help)); err != nil {
return err
// Resolve returns the command registered under name, or says why there is none: the
// filter's reason for one this surface withholds, or unknown for a name that does not
// exist.
func (r *Registry) Resolve(name Name) (*Command, error) {
if c := r.Get(name); c != nil {
return c, nil
}
if err := r.unavailable(name); err != nil {
return nil, err
}
return nil, fmt.Errorf("unknown command %q", name)
}
// setParams sets each named parameter on fl, in the order of names, and stops at the
// first that is unknown or does not parse. own says whether the command declared flags
// of its own, which decides between "takes no parameters" and "has no parameter".
//
// The presentation flags are on fl, since commandFlags put them there, but they are not
// parameters: a request has one place to choose its rendering, the envelope's format
// field, and a client that sends them here is told where that is rather than having a
// second, weaker way to say the same thing.
func setParams(fl *flag.FlagSet, name string, names []string, params map[string]string, own bool) error {
for _, k := range names {
if isPresentationFlag(k) {
return fmt.Errorf("%s is a command line flag, not a parameter; choose the rendering with the request's format field", k)
} }
}
f := fl.Lookup(k) if cmd.Flags != nil {
if f == nil { fs, _ := cmd.Flags()
if !own { if fs != nil {
return fmt.Errorf("%s takes no parameters", name) fs.SetOutput(w.GetWriter())
} fs.PrintDefaults()
return fmt.Errorf("%s has no parameter %q", name, k)
}
v := params[k]
if err := fl.Set(k, v); err != nil {
if IsBoolFlag(f) {
// The flag package's own words for this are "parse error".
return fmt.Errorf("%s: expected a boolean, got %q", k, v)
}
return fmt.Errorf("%s: %w", k, err)
} }
} }
return nil return nil
} }
// Schema describes every command in the registry, so a client can offer them without
// having been built against this daemon.
func (r *Registry) Schema() []CommandSchema {
all := r.All()
out := make([]CommandSchema, 0, len(all))
for _, c := range all {
out = append(out, r.schemaFor(c))
}
return out
}
// schemaFor describes one command. It is the one derivation, for the whole schema and
// for `help <command>` alike.
func (r *Registry) schemaFor(c *Command) CommandSchema {
fl, _, _ := commandFlags(c)
return schemaOf(c, fl)
}
// schemaOf describes c as driven through fl, the FlagSet commandFlags built for it. The
// presentation flags are included because a command line client parses its line
// against this and help renders from it; they are listed after the command's own,
// which is where readers expect them. Invoke refuses them as parameters.
func schemaOf(c *Command, fl *flag.FlagSet) CommandSchema {
cs := CommandSchema{Name: c.Name, Short: c.ShortDescription, Help: c.Help}
var own, shared []FlagSchema
fl.VisitAll(func(f *flag.Flag) {
fs := FlagSchema{
Name: f.Name,
Bool: IsBoolFlag(f),
Default: f.DefValue,
Usage: f.Usage,
}
if isPresentationFlag(f.Name) {
shared = append(shared, fs)
return
}
own = append(own, fs)
})
cs.Flags = append(own, shared...)
return cs
}
// CommandSchema describes one command well enough for a client to offer it.
type CommandSchema struct {
Name Name `json:"name"`
Short string `json:"short,omitempty"`
Help string `json:"help,omitempty"`
Flags []FlagSchema `json:"flags,omitempty"`
}
// FlagSchema describes one of a command's named parameters.
type FlagSchema struct {
Name string `json:"name"`
// Bool reports a parameter that takes no value, which is what tells a command line
// client whether `-pretty` swallows the word after it.
Bool bool `json:"bool,omitempty"`
Default string `json:"default,omitempty"`
Usage string `json:"usage,omitempty"`
}
+109 -353
View File
@@ -4,417 +4,173 @@ import (
"bytes" "bytes"
"errors" "errors"
"flag" "flag"
"io"
"strings" "strings"
"sync"
"testing" "testing"
"time"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
// notWithheld is a stand in for a surface's own policy, which the registry knows nothing
// of; see Command.Identity for the one the info API applies.
func notWithheld(c *Command) bool { return c.Name != "withheld" }
const testReason = "this surface does not run commands that write"
// textLine is a Text renderer for test commands whose result is one string.
func textLine(v any, w io.Writer) error {
_, err := io.WriteString(w, v.(string)+"\n")
return err
}
func testRegistry() *Registry { func testRegistry() *Registry {
r := New() r := New()
r.Register(&Command{ r.Register(&Command{
Name: "served", Name: "served",
ShortDescription: "a command this surface serves", ShortDescription: "a command this surface serves",
Run: func(fs any, a []string) (Result, error) { Callback: func(fs any, a []string, w StringWriter) error {
return Value("read " + strings.Join(a, ",")), nil return w.WriteLine("read " + strings.Join(a, ","))
}, },
Text: textLine,
}) })
r.Register(&Command{ r.Register(&Command{
Name: "withheld", Name: "withheld",
ShortDescription: "a command this surface withholds", ShortDescription: "a command this surface withholds",
Run: func(fs any, a []string) (Result, error) { Callback: func(fs any, a []string, w StringWriter) error {
return Value("wrote"), nil return w.WriteLine("wrote")
}, },
Text: textLine,
}) })
return r return r
} }
// TestFilterKeepsWhatKeepSays: the copy holds the commands keep accepted, and help. // TestFlagUsageGoesToTheWriter pins that a parse failure's usage lands on the command's
func TestFilterKeepsWhatKeepSays(t *testing.T) { // writer.
ro := testRegistry().Filter(notWithheld, testReason) func TestFlagUsageGoesToTheWriter(t *testing.T) {
names := make([]string, 0)
for _, c := range ro.All() {
names = append(names, string(c.Name))
}
assert.ElementsMatch(t, []string{"help", "served"}, names)
}
// TestRefusesWithheldByName covers a client that knows a command exists and asks for it
// anyway. The filter lives on the serving side, so the answer must not depend on what
// the client was told was available.
func TestRefusesWithheldByName(t *testing.T) {
out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
w := Output{Out: out, Err: errOut}
err := testRegistry().Filter(notWithheld, testReason).DispatchArgs([]string{"withheld"}, w)
require.Error(t, err)
assert.Contains(t, err.Error(), "withheld is not available on this surface")
assert.Empty(t, out.String(), "a withheld command must produce no output")
assert.Contains(t, errOut.String(), "withheld is not available on this surface")
assert.Contains(t, errOut.String(), testReason,
"the registry should render the explanation the filter supplied, not one of its own")
}
// TestWithheldIsNotReportedAsUnknown keeps the two cases distinct: an operator who
// mistypes and one who asked for a real command should not get the same answer.
func TestWithheldIsNotReportedAsUnknown(t *testing.T) {
out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
err := testRegistry().Filter(notWithheld, testReason).DispatchArgs([]string{"no-such-command"}, Output{Out: out, Err: errOut})
var f *Failure
require.ErrorAs(t, err, &f, "an unknown command is a failure to the surface")
assert.Contains(t, out.String(), "did not understand: no-such-command")
}
// paramRegistry holds one command with a bool flag and a duration flag, and reports what
// the command saw when it ran.
func paramRegistry(t *testing.T) (*Registry, *[]paramsSeen) {
t.Helper()
var seen []paramsSeen
r := New() r := New()
r.Register(&Command{ r.Register(&Command{
Name: "set", Name: "emit",
ShortDescription: "sets things", ShortDescription: "emits",
Flags: func() (*flag.FlagSet, any) { Flags: func() (*flag.FlagSet, any) {
fl := flag.NewFlagSet("", flag.ContinueOnError) fl := flag.NewFlagSet("", flag.ContinueOnError)
s := paramsSeen{} fl.Bool("json", false, "emit json")
fl.BoolVar(&s.Verbose, "verbose", false, "say more") return fl, nil
fl.DurationVar(&s.Wait, "wait", 0, "how long")
return fl, &s
},
Run: func(fs any, a []string) (Result, error) {
seen = append(seen, *fs.(*paramsSeen))
return Value("ok"), nil
}, },
Callback: func(fs any, a []string, w StringWriter) error { return nil },
}) })
return r, &seen merged := &bytes.Buffer{}
require.Error(t, r.DispatchArgs([]string{"emit", "-nope"}, NewStringWriter(merged)))
assert.Contains(t, merged.String(), "flag provided but not defined")
} }
type paramsSeen struct { // TestDispatchReportsUnparseableLine: a line shlex rejects, an unbalanced quote, is a
Verbose bool // failure the user is told about.
Wait time.Duration
}
// TestInvokeReportsParametersInNameOrder: parameters arrive as an unordered object, so
// with two bad ones the error must not depend on map iteration. Name order decides.
func TestInvokeReportsParametersInNameOrder(t *testing.T) {
r, _ := paramRegistry(t)
cases := map[string]struct {
params map[string]string
want string
}{
"two unknown": {map[string]string{"zed": "1", "alpha": "1"}, `set has no parameter "alpha"`},
"unknown before bad bool": {map[string]string{"aaa": "1", "verbose": "maybe"}, `set has no parameter "aaa"`},
"bad bool before unknown": {map[string]string{"verbose": "maybe", "zzz": "1"}, `verbose: expected a boolean, got "maybe"`},
"bad value before bad bool": {map[string]string{"wait": "soon", "verbose": "maybe"}, `verbose: expected a boolean`},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
// Enough runs that a map-order dependence would show.
for i := 0; i < 50; i++ {
_, err := Invoke(Request{Command: r.Get("set"), Params: tc.params})
require.Error(t, err)
assert.ErrorContains(t, err, tc.want)
}
})
}
}
// TestInvokeWithABadParameterSetsNothing: a request with any bad parameter must not run
// the command, and must leave nothing behind for the next request to see. The good
// parameter sorts before the bad one, so a one-pass Invoke would have applied it.
func TestInvokeWithABadParameterSetsNothing(t *testing.T) {
r, seen := paramRegistry(t)
_, err := Invoke(Request{Command: r.Get("set"), Params: map[string]string{"verbose": "true", "wait": "soon"}})
require.ErrorContains(t, err, "wait:")
assert.Empty(t, *seen, "the command must not run with a partial parameter set")
v, err := Invoke(Request{Command: r.Get("set")})
require.NoError(t, err)
assert.Equal(t, "ok", v.Value)
require.Len(t, *seen, 1)
assert.Equal(t, paramsSeen{}, (*seen)[0], "nothing from the failed request carried over")
_, err = Invoke(Request{Command: r.Get("set"), Params: map[string]string{"verbose": "true", "wait": "2s"}})
require.NoError(t, err)
require.Len(t, *seen, 2)
assert.Equal(t, paramsSeen{Verbose: true, Wait: 2 * time.Second}, (*seen)[1])
}
func TestHelpListsOnlyServedCommands(t *testing.T) {
out := &bytes.Buffer{}
require.NoError(t, testRegistry().Filter(notWithheld, testReason).DispatchArgs(nil, MergedOutput(out)))
assert.Contains(t, out.String(), "served")
assert.NotContains(t, out.String(), "withheld")
}
// TestDispatchReportsUnparseableLine pins that a line shlex rejects says so on Err rather
// than coming back silent, so an operator with an unbalanced quote learns the quote is the
// problem instead of assuming the command is broken.
func TestDispatchReportsUnparseableLine(t *testing.T) { func TestDispatchReportsUnparseableLine(t *testing.T) {
out, errOut := &bytes.Buffer{}, &bytes.Buffer{} out := &bytes.Buffer{}
testRegistry().Dispatch(`served "unterminated`, Output{Out: out, Err: errOut}) err := testRegistry().Dispatch(`served "unterminated`, NewStringWriter(out))
assert.Empty(t, out.String())
assert.Contains(t, errOut.String(), "could not parse the command line") var f *Failure
require.ErrorAs(t, err, &f)
assert.Equal(t, f.Msg+"\n", out.String())
assert.Contains(t, out.String(), "could not parse the command line: ")
} }
// TestRegisterRejectsReservedFlags: a command that declares a reserved flag is refused // TestFailTellsTheUserAndTheSurface: Fail writes the message and returns it as a Failure;
// at Register rather than when an operator first runs it; see reservedFlags. // when the write fails, the user heard nothing, so the write error is what comes back.
func TestRegisterRejectsReservedFlags(t *testing.T) { func TestFailTellsTheUserAndTheSurface(t *testing.T) {
for _, name := range []string{"json", "pretty", "h", "help", "config", "socket"} { out := &bytes.Buffer{}
t.Run(name, func(t *testing.T) { err := Fail(NewStringWriter(out), "no such tunnel")
r := New() var f *Failure
assert.PanicsWithValue(t, "commands: clash declares reserved flag -"+name, func() { require.ErrorAs(t, err, &f)
r.Register(&Command{ assert.Equal(t, "no such tunnel", f.Msg)
Name: "clash", assert.Equal(t, "no such tunnel\n", out.String())
Flags: func() (*flag.FlagSet, any) {
fl := flag.NewFlagSet("clash", flag.ContinueOnError) err = Fail(NewStringWriter(failingWriter{}), "no such tunnel")
fl.Bool(name, false, "") require.EqualError(t, err, "gone")
return fl, nil assert.NotErrorAs(t, err, &f)
},
Run: func(fs any, a []string) (Result, error) { return Nothing(), nil },
})
})
})
}
} }
// TestRegistryIsSafeForConcurrentUse runs the operations the surfaces perform, filtering type failingWriter struct{}
// and cloning per request or session, against a stream of registrations. It exists to
// be run under the race detector: the map underneath is not goroutine safe.
func TestRegistryIsSafeForConcurrentUse(t *testing.T) {
r := testRegistry()
var wg sync.WaitGroup func (failingWriter) Write([]byte) (int, error) { return 0, errors.New("gone") }
for i := 0; i < 8; i++ {
wg.Add(1) // TestAllSortsByName: registration order does not matter.
go func(i int) { func TestAllSortsByName(t *testing.T) {
defer wg.Done() r := New()
for j := 0; j < 50; j++ { for _, n := range []Name{"zz", Version, "aa", ChangeRemote} {
r.Register(&Command{ r.Register(&Command{Name: n})
Name: Name("late-" + strings.Repeat("a", i) + "-" + strings.Repeat("b", j)),
ShortDescription: "registered after the surfaces started",
Run: func(fs any, a []string) (Result, error) { return Nothing(), nil },
})
}
}(i)
} }
for i := 0; i < 8; i++ { var got []Name
wg.Add(1) for _, c := range r.All() {
go func() { got = append(got, c.Name)
defer wg.Done()
for j := 0; j < 50; j++ {
f := r.Filter(notWithheld, testReason)
_ = f.Get("served")
_ = f.Schema()
_ = r.Clone().Match("late-")
}
}()
} }
assert.Equal(t, []Name{"aa", ChangeRemote, Help, Version, "zz"}, got)
wg.Wait()
f := r.Filter(notWithheld, testReason)
assert.Len(t, f.Match("late-"), 8*50, "every late registration is visible once the writers finish")
} }
// TestCloneHelpSeesCloneCommands: the ssh session registers logout on its clone, and // TestHelpFlagAgreesWithHelpCommand pins that -h answers through the registered help
// the source does not learn of it. Help on the clone answers for the clone, and -h on a // command, and that help on a clone describes the clone: a command registered only there
// command prints what `help <name>` does, on a clone as on the source: both render // is known to both -h and `help <name>`, and one withheld from it is known to neither.
// through WriteCommandHelp, and Clone rebinds help to the copy. func TestHelpFlagAgreesWithHelpCommand(t *testing.T) {
func TestCloneHelpSeesCloneCommands(t *testing.T) {
r := testRegistry() r := testRegistry()
c := r.Clone() c := r.Clone()
c.Register(&Command{ c.Register(&Command{
Name: Logout, Name: Logout,
ShortDescription: "ends the session", ShortDescription: "ends the session",
Run: func(fs any, a []string) (Result, error) { return Nothing(), nil }, Callback: func(fs any, a []string, w StringWriter) error { return nil },
}) })
assert.Nil(t, r.Get(Logout), "the source is not affected")
out := &bytes.Buffer{} flag := &bytes.Buffer{}
require.NoError(t, c.DispatchArgs([]string{"help"}, MergedOutput(out))) c.Dispatch("logout -h", NewStringWriter(flag))
assert.Contains(t, out.String(), "logout") cmd := &bytes.Buffer{}
c.Dispatch("help logout", NewStringWriter(cmd))
assert.Equal(t, cmd.String(), flag.String())
assert.Equal(t, "logout - ends the session\n", flag.String())
for _, name := range []string{"logout", "served"} { // The source never learns of it.
flag := &bytes.Buffer{} src := &bytes.Buffer{}
c.Dispatch(name+" -h", MergedOutput(flag)) r.Dispatch("help logout", NewStringWriter(src))
cmd := &bytes.Buffer{} assert.Equal(t, "Command not available logout\n", src.String())
c.Dispatch("help "+name, MergedOutput(cmd))
assert.Equal(t, cmd.String(), flag.String(), name) // And a command both hold is described either way.
assert.Contains(t, flag.String(), name+" - ", name) flag.Reset()
} c.Dispatch("served -h", NewStringWriter(flag))
assert.Equal(t, "served - a command this surface serves\n", flag.String())
} }
// TestThenRunsAfterTheReply pins the order Then exists for: Run's line is on the writer // TestCloneHelpListsTheClone: the command list help prints is the clone's, so a clone
// before the action begins, Then's Result follows it, and Then's outcome is the // that withholds a command does not name it, and the source still does.
// command's. func TestCloneHelpListsTheClone(t *testing.T) {
func TestThenRunsAfterTheReply(t *testing.T) { r := testRegistry()
out := &bytes.Buffer{} c := New()
seen := "never ran" c.Register(r.Get("served"))
outcome := Did("acted") c = c.Clone()
out := &bytes.Buffer{}
c.Dispatch("help", NewStringWriter(out))
assert.Equal(t, "Available commands:\n"+
"help - prints available commands or help <command> for specific usage info\n"+
"served - a command this surface serves\n\n", out.String())
out.Reset()
c.Dispatch("help withheld", NewStringWriter(out))
assert.Equal(t, "Command not available withheld\n", out.String())
out.Reset()
r.Dispatch("help withheld", NewStringWriter(out))
assert.Equal(t, "withheld - a command this surface withholds\n", out.String())
}
// TestDispatchReturnsTheCommandsError: what the callback returns reaches the caller, so
// a surface can log it.
func TestDispatchReturnsTheCommandsError(t *testing.T) {
r := New() r := New()
r.Register(&Command{ r.Register(&Command{
Name: "act", Name: "fails",
ShortDescription: "replies, then acts", Callback: func(fs any, a []string, w StringWriter) error {
Run: func(fs any, a []string) (Result, error) { return errors.New("boom")
return Did("about to act"), nil
},
Then: func() Result {
seen = out.String()
return outcome
}, },
}) })
require.NoError(t, r.DispatchArgs([]string{"act"}, MergedOutput(out))) out := &bytes.Buffer{}
assert.Equal(t, "about to act\n", seen, "the line was written before the action") require.EqualError(t, r.Dispatch("fails", NewStringWriter(out)), "boom")
assert.Equal(t, "about to act\nacted\n", out.String()) assert.Empty(t, out.String(), "a command's own error is not shown; the command speaks for itself")
}
out.Reset() // TestUnknownCommandNamesTheWord: only the first word is looked up, so only it is
outcome = Failed("could not act") // reported, followed by the command list, and the line is a failure to the surface.
func TestUnknownCommandNamesTheWord(t *testing.T) {
out := &bytes.Buffer{}
err := testRegistry().Dispatch(`nope "with args"`, NewStringWriter(out))
var f *Failure var f *Failure
require.ErrorAs(t, r.DispatchArgs([]string{"act"}, MergedOutput(out)), &f) require.ErrorAs(t, err, &f)
assert.Equal(t, "about to act\ncould not act\n", out.String()) assert.Equal(t, "did not understand: nope", f.Msg)
assert.True(t, strings.HasPrefix(out.String(), "did not understand: nope\nAvailable commands:\n"), out.String())
// In JSON only the outcome travels: one document for the program that asked.
out.Reset()
require.ErrorAs(t, r.DispatchArgs([]string{"act", "-json"}, MergedOutput(out)), &f)
assert.JSONEq(t, `{"ok":false,"reason":"could not act"}`, out.String())
// A Run that refused is the outcome; the action does not happen.
ran := false
r.Register(&Command{
Name: "refuse",
ShortDescription: "refuses, so never acts",
Run: func(fs any, a []string) (Result, error) {
return Failed("not like that"), nil
},
Then: func() Result {
ran = true
return Did("acted anyway")
},
})
out.Reset()
require.ErrorAs(t, r.DispatchArgs([]string{"refuse"}, MergedOutput(out)), &f)
assert.Equal(t, "not like that\n", out.String())
assert.False(t, ran)
out.Reset()
require.ErrorAs(t, r.DispatchArgs([]string{"refuse", "-json"}, MergedOutput(out)), &f)
assert.JSONEq(t, `{"ok":false,"reason":"not like that"}`, out.String())
assert.False(t, ran)
}
// TestWriteCommandHelpIsTheOneRendering pins the layout both `help <command>` on the
// daemon and `-h` in the client print, so the two cannot drift apart again.
func TestWriteCommandHelpIsTheOneRendering(t *testing.T) {
cs := CommandSchema{
Name: "change-remote",
Short: "changes a remote",
Help: "Give it an address.",
Flags: []FlagSchema{
{Name: "address", Usage: "the new remote", Default: "1.2.3.4:4242"},
{Name: "by-index", Bool: true, Usage: "match by index"},
{Name: "json", Bool: true, Usage: "outputs as json"},
},
}
out := &bytes.Buffer{}
require.NoError(t, WriteCommandHelp(cs, out))
assert.Equal(t, "change-remote - changes a remote\n"+
" Give it an address.\n"+
" -address string\n \tthe new remote (default 1.2.3.4:4242)\n"+
" -by-index\n \tmatch by index\n"+
" -json\n \toutputs as json\n", out.String())
}
// addrFlags is the flag struct of a test command that takes -address.
type addrFlags struct{ Address string }
// TestHelpFlagIsReadWhereParseReadsIt: -h asks for help only where the line's parser
// reads it as a flag. As a flag's value or after -- it reaches the command as the
// operand it is, and help is rendered by the same function `help <command>` uses.
func TestHelpFlagIsReadWhereParseReadsIt(t *testing.T) {
var seen []string
r := New()
r.Register(Flagged(&Command{Name: "x", ShortDescription: "takes an address"},
func(fl *flag.FlagSet, s *addrFlags) { fl.StringVar(&s.Address, "address", "", "an address") },
func(s *addrFlags, a []string) (Result, error) {
seen = append(seen, s.Address+"|"+strings.Join(a, ","))
return Nothing(), nil
}))
for _, line := range []string{"x -h", "x -help", "x --help", "x 10.0.0.1 -h", "x -address=1 -h"} {
out := &bytes.Buffer{}
r.Dispatch(line, MergedOutput(out))
assert.Contains(t, out.String(), "x - takes an address\n", line)
assert.Contains(t, out.String(), "-address string", line)
}
assert.Empty(t, seen, "asking for help must not run the command")
for _, line := range []string{"x -address -h", "x -- -h"} {
out := &bytes.Buffer{}
r.Dispatch(line, MergedOutput(out))
assert.Empty(t, out.String(), line)
}
assert.Equal(t, []string{"-h|", "|-h"}, seen)
}
// TestBadFlagIsAnsweredWithTheCommandsHelp: a flag the command does not have is reported
// on the error stream followed by the command's usage, in the rendering help uses.
func TestBadFlagIsAnsweredWithTheCommandsHelp(t *testing.T) {
out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
r := New()
r.Register(&Command{Name: "x", ShortDescription: "has no flags", Run: func(fs any, a []string) (Result, error) { return Nothing(), nil }})
require.Error(t, r.DispatchArgs([]string{"x", "-nope"}, Output{Out: out, Err: errOut}))
assert.Empty(t, out.String())
assert.Equal(t, "flag provided but not defined: -nope\nx - has no flags\n -json\n \toutputs as json\n -pretty\n \tpretty prints json, assumes -json\n", errOut.String())
}
// TestRunErrorIsShown: an error Run returns reaches the person at the prompt on the
// error stream, as well as the surface that logs it.
func TestRunErrorIsShown(t *testing.T) {
r := New()
r.Register(&Command{
Name: "broken",
ShortDescription: "cannot do what it is asked",
Run: func(fs any, a []string) (Result, error) {
return Result{}, errors.New("no certificate is loaded")
},
})
out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
require.EqualError(t, r.DispatchArgs([]string{"broken"}, Output{Out: out, Err: errOut}), "no certificate is loaded")
assert.Empty(t, out.String())
assert.Equal(t, "no certificate is loaded\n", errOut.String())
} }
-179
View File
@@ -1,179 +0,0 @@
package commands
import (
"encoding/json"
"errors"
"fmt"
"io"
)
// ErrNoTextRendering is returned by Render when a command's Value has no human rendering
// and text was asked for anyway. A command declares this by leaving Text nil and saying
// so with JSONOnly; it is not a fallback situation but a statement that no such form
// exists yet, so nobody builds a script around an interim one. Each surface's default
// policy avoids ever asking.
var ErrNoTextRendering = errors.New("no human readable output yet; pass -json or -pretty")
// Format is how a result should be presented.
type Format int
const (
// FormatUnset is a request that expressed no preference. A surface resolves it with
// its own default before rendering; Render itself treats it as FormatText.
FormatUnset Format = iota
// FormatText renders for a person. It is what an operator gets by default on every
// surface with a human at the other end.
FormatText
// FormatJSON renders the result as compact JSON.
FormatJSON
// FormatPrettyJSON renders the result as indented JSON.
FormatPrettyJSON
)
// Flag names for the two presentation flags. They are offered on every command rather
// than declared by each one, because how a result is displayed is not a property of the
// command that produced it.
const (
FlagJSON = "json"
FlagPretty = "pretty"
)
// Flag names nebula ctl takes for itself, anywhere on its line, to say which daemon to
// talk to; see reservedFlags.
const (
FlagConfig = "config"
FlagSocket = "socket"
)
// reservedFlags are handled before a command's Run is called, so a command may not
// declare them itself. -h and -help are intercepted as a request for usage; -json and
// -pretty are added to every command's FlagSet by commandFlags, on every surface, so a
// command that defined either would make that definition panic with "flag redefined"
// on whichever goroutine ran the command; and -config and -socket are nebula ctl's own,
// taken off the line before the client knows which command it names, so a command
// that declared either would never receive it there.
var reservedFlags = []string{"h", "help", FlagJSON, FlagPretty, FlagConfig, FlagSocket}
// Render writes r in the requested format. Every surface calls it, so a hostmap looks
// the same over ssh as it does through the control socket, and a change to either
// rendering happens once.
func Render(c *Command, r Result, f Format, w io.Writer) error {
switch f {
case FormatJSON:
return renderJSON(r.Payload(), w, false)
case FormatPrettyJSON:
return renderJSON(r.Payload(), w, true)
default:
// An outcome reads the same for every command: its reason, as a sentence. Only a
// Value needs the command's own rendering, so Text never sees anything else.
if r.Value == nil {
_, err := io.WriteString(w, r.Reason+"\n")
return err
}
if c != nil && c.Text != nil {
return c.Text(r.Value, w)
}
name := "this command"
if c != nil {
name = string(c.Name)
}
return fmt.Errorf("%s has %w", name, ErrNoTextRendering)
}
}
func renderJSON(v any, w io.Writer, indent bool) error {
enc := json.NewEncoder(w)
if indent {
enc.SetIndent("", " ")
}
return enc.Encode(v)
}
// Result is what every Run returns: whether the command worked, a sentence saying so,
// and, for a command that reports rather than acts, the value it produced.
//
// Value and Reason are alternatives. A command that reports returns Value(v), and the
// surfaces render v, as JSON or through the command's Text. A command that acts, or any
// command refusing its arguments, returns Did or Failed, and the surfaces render the
// Outcome: its Reason is the sentence these commands have always printed. Nothing is for
// a command with nothing to say.
//
// The envelope itself never reaches a caller. Payload is what JSON carries, and Render
// hands Text only the Value, so a command's renderer sees the one type it returns on
// success and is never asked to recognise an Outcome.
type Result struct {
Outcome
Value any
}
// Outcome is the part of a Result that says whether the command worked and, in words a
// caller can show someone, why. It is what a program receives from a command that acts
// rather than reports: closing a tunnel, changing a remote, reloading config.
//
// One shape serves all of them. Designing a payload per outcome would be work without a
// reader. Reason is set either way, so a success says what it did rather than leaving
// the caller to infer it from a bare true.
type Outcome struct {
OK bool `json:"ok"`
Reason string `json:"reason"`
}
// Value is the Result of a command that reports: v is what it has to show, and it must
// marshal to JSON.
func Value(v any) Result {
return Result{Outcome: Outcome{OK: true}, Value: v}
}
// Failed is a convenience for the common "it did not work, here is why" case.
func Failed(format string, args ...any) Result {
return Result{Outcome: Outcome{Reason: fmt.Sprintf(format, args...)}}
}
// Did is a convenience for the common "it worked, here is what happened" case.
func Did(format string, args ...any) Result {
return Result{Outcome: Outcome{OK: true, Reason: fmt.Sprintf(format, args...)}}
}
// Nothing is the Result of a command with nothing to say: it did its work, and the
// surface sends an empty, successful reply without rendering anything.
func Nothing() Result {
return Result{Outcome: Outcome{OK: true}}
}
// Empty reports a Result with nothing to render: no Value and no Reason. The zero Result
// counts, so a Run that returns Result{} says nothing rather than failing silently.
func (r Result) Empty() bool {
return r.Value == nil && r.Reason == ""
}
// Payload is what a program receives: the Value when there is one, otherwise the
// Outcome. No surface sends the envelope itself, so print-tunnel -json emits the tunnel
// and close-tunnel -json emits {ok, reason}.
func (r Result) Payload() any {
if r.Value != nil {
return r.Value
}
return r.Outcome
}
// Typed adapts a renderer for one result type to the TextFunc a Command declares. The
// value Render passes is the command's own, see Result, so all that is left is to name
// its type once here instead of asserting it at the top of every renderer. A renderer
// paired with a command that returns something else fails here, saying what arrived.
func Typed[T any](render func(T, io.Writer) error) TextFunc {
return func(v any, w io.Writer) error {
t, ok := v.(T)
if !ok {
return fmt.Errorf("expected %T, got %T", t, v)
}
return render(t, w)
}
}
-105
View File
@@ -1,105 +0,0 @@
package commands
import (
"bytes"
"io"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestRenderPrintsAnOutcomeWithoutText: a command that acts declares no Text. Its
// outcome renders as the reason, the same for every command, and as {ok, reason} in
// JSON, which is the shape these commands have always emitted.
func TestRenderPrintsAnOutcomeWithoutText(t *testing.T) {
c := &Command{Name: "act"}
out := &bytes.Buffer{}
require.NoError(t, Render(c, Did("Closed"), FormatText, out))
assert.Equal(t, "Closed\n", out.String())
out.Reset()
require.NoError(t, Render(c, Failed("No vpn address was provided"), FormatText, out))
assert.Equal(t, "No vpn address was provided\n", out.String())
out.Reset()
require.NoError(t, Render(c, Failed("nope"), FormatJSON, out))
assert.JSONEq(t, `{"ok":false,"reason":"nope"}`, out.String())
}
// TestRenderHandsTextOnlyTheValue pins the guarantee Result exists for: a command's
// renderer sees the type it returns on success and never the envelope or an outcome, so
// a report command that refuses its arguments needs nothing in its Text to cope.
func TestRenderHandsTextOnlyTheValue(t *testing.T) {
var got any
c := &Command{
Name: "report",
Text: func(v any, w io.Writer) error {
got = v
_, err := io.WriteString(w, "rendered\n")
return err
},
}
out := &bytes.Buffer{}
require.NoError(t, Render(c, Value("data"), FormatText, out))
assert.Equal(t, "data", got)
assert.Equal(t, "rendered\n", out.String())
got, out = nil, &bytes.Buffer{}
require.NoError(t, Render(c, Failed("refused"), FormatText, out))
assert.Nil(t, got, "Text must not be called for an outcome")
assert.Equal(t, "refused\n", out.String())
out.Reset()
require.NoError(t, Render(c, Value("data"), FormatJSON, out))
assert.JSONEq(t, `"data"`, out.String(), "JSON carries the value, never the envelope")
}
// TestRenderRefusesTextForAValueWithoutText: leaving Text nil is a statement that no
// human form of the value exists yet, and asking for one is an error that says so.
func TestRenderRefusesTextForAValueWithoutText(t *testing.T) {
out := &bytes.Buffer{}
err := Render(&Command{Name: "print-tunnel"}, Value(map[string]int{"index": 7}), FormatText, out)
require.ErrorIs(t, err, ErrNoTextRendering)
require.ErrorContains(t, err, "print-tunnel has no human readable output yet")
assert.Empty(t, out.String())
}
// TestTypedNamesTheTypeOnce: Typed replaces the assertion at the top of every renderer.
// The right type reaches the renderer; the wrong one is reported, naming both.
func TestTypedNamesTheTypeOnce(t *testing.T) {
type info struct{ Name string }
render := Typed(func(i info, w io.Writer) error {
_, err := io.WriteString(w, i.Name+"\n")
return err
})
out := &bytes.Buffer{}
require.NoError(t, render(info{Name: "tun0"}, out))
assert.Equal(t, "tun0\n", out.String())
err := render("not an info", out)
require.Error(t, err)
assert.ErrorContains(t, err, "expected commands.info, got string")
}
// TestResultShapes pins what each constructor means to a surface: Empty is the one that
// renders nothing, Payload is what a program receives, and OK is set wherever a reason
// or value says the command worked.
func TestResultShapes(t *testing.T) {
assert.True(t, Nothing().Empty())
assert.True(t, Result{}.Empty(), "the zero Result says nothing rather than failing silently")
assert.False(t, Did("done").Empty())
assert.False(t, Failed("no").Empty())
assert.False(t, Value("x").Empty())
assert.True(t, Value("x").OK)
assert.True(t, Did("done").OK)
assert.False(t, Failed("no").OK)
assert.Equal(t, "x", Value("x").Payload())
assert.Equal(t, Outcome{OK: true, Reason: "done"}, Did("done").Payload())
assert.Equal(t, Outcome{Reason: "no"}, Failed("no").Payload())
}
-119
View File
@@ -1,119 +0,0 @@
package commands
import (
"flag"
"maps"
"slices"
)
// Request is one command to run, as every surface hands it to Invoke: the command, its
// options by name in the form their flags parse, its operands, and the rendering the
// line asked for, if any.
//
// nebula ctl builds one with ParseLine and it travels as a JSON object to the control
// socket. An ssh line never becomes one: it is parsed straight into the command's own
// FlagSet; see execLine.
type Request struct {
// Command is the command to run, resolved by the surface at its edge. See
// Registry.Resolve for the one that tells an unknown name from a withheld one.
Command *Command
// Params carries the options the line set, by flag name, each in the form its flag
// parses from. An option left alone is absent, so the command's default applies.
Params map[string]string
// Args carries the operands: whatever the line did not consume as a flag.
Args []string
// Format is the rendering the line asked for with -json or -pretty, or FormatUnset
// when it expressed no preference. It is ParseLine's reading of the line for the
// client that sends the Request; Invoke does not read it, since the surface that
// runs a Request renders with the format it agreed with its caller.
Format Format
}
// ParseLine reads a FlagSet that ParseArgs has filled, and the operands it returned,
// into a Request to send over the wire. Command is left for the caller to set.
//
// Every flag the line set other than the presentation flags travels by name, as its
// flag's String, which is what the daemon's Set parses. That round trip is exact for
// the bool and string flags a client builds from the schema; it is the client's to make,
// and the ssh path does not make it, since it runs the FlagSet it parsed.
func ParseLine(fl *flag.FlagSet, operands []string) Request {
req := Request{Args: operands, Format: presentationFormat(fl)}
fl.Visit(func(f *flag.Flag) {
if isPresentationFlag(f.Name) {
return
}
if req.Params == nil {
req.Params = map[string]string{}
}
req.Params[f.Name] = f.Value.String()
})
return req
}
// presentationFormat is the one reading of -json and -pretty from a parsed line, so a
// line means the same on every surface: only a flag set to true asks for JSON, since one
// set to false expresses no preference, and -pretty implies -json. FormatUnset means the
// line expressed no preference and the surface's own default applies.
func presentationFormat(fl *flag.FlagSet) Format {
var asJSON, pretty bool
fl.Visit(func(f *flag.Flag) {
switch f.Name {
case FlagJSON:
asJSON = flagIsTrue(f)
case FlagPretty:
pretty = flagIsTrue(f)
}
})
switch {
case pretty:
return FormatPrettyJSON
case asJSON:
return FormatJSON
default:
return FormatUnset
}
}
// flagIsTrue reports whether a bool flag was set to true. The flag package's bool value
// is a flag.Getter whose Get returns the bool, so this never falls back to parsing text.
func flagIsTrue(f *flag.Flag) bool {
g, ok := f.Value.(flag.Getter)
if !ok {
return false
}
b, _ := g.Get().(bool)
return b
}
// Invoke runs one Request and returns the command's Result, unrendered.
//
// The parameters are applied by flag name, in name order: a request from the wire is a
// JSON object with no order of its own, and which of two bad parameters is reported must
// not change from one request to the next. An unknown parameter is an error rather than
// something quietly ignored, because a caller that misspells one deserves to hear about
// it instead of getting a default. A bad parameter means Run is never called, and the
// FlagSet is fresh for this call, so nothing set before it is seen by anyone.
//
// Nothing here writes anywhere and nothing here renders. What a surface does with the
// Result, marshal its Payload or run the command's own text rendering through Render,
// is the surface's decision, and keeping that out of here is what lets a caller tell a
// refusal from a success after the text has been produced. The presentation flags are
// not parameters: a Request says how it wants rendering in Format, and sending them as
// parameters is refused rather than read as a preference.
func Invoke(req Request) (Result, error) {
c := req.Command
names := slices.Sorted(maps.Keys(req.Params))
fl, fs, own := commandFlags(c)
if err := setParams(fl, string(c.Name), names, req.Params, own); err != nil {
return Result{}, err
}
return c.Run(fs, req.Args)
}
-115
View File
@@ -1,115 +0,0 @@
package commands
import (
"flag"
"strings"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func lineFlags() *flag.FlagSet {
fl := flag.NewFlagSet("set", flag.ContinueOnError)
fl.Bool("verbose", false, "")
fl.Duration("wait", 0, "")
fl.String("label", "none", "")
fl.Bool(FlagJSON, false, "")
fl.Bool(FlagPretty, false, "")
return fl
}
// TestParseLineReadsThePresentationFlagsOnce: presentationFormat is the one reading of
// -json and -pretty, for every surface, and ParseLine carries its answer. A flag set to
// false expresses no preference, and neither flag ever travels as a parameter.
func TestParseLineReadsThePresentationFlagsOnce(t *testing.T) {
for _, tc := range []struct {
args []string
want Format
}{
{nil, FormatUnset},
{[]string{"-json=false"}, FormatUnset},
{[]string{"-pretty=false"}, FormatUnset},
{[]string{"-json"}, FormatJSON},
{[]string{"-pretty"}, FormatPrettyJSON},
{[]string{"-pretty", "-json=false"}, FormatPrettyJSON},
} {
fl := lineFlags()
operands, err := ParseArgs(fl, tc.args)
require.NoError(t, err)
req := ParseLine(fl, operands)
assert.Equal(t, tc.want, req.Format, "%v", tc.args)
assert.Nil(t, req.Params, "%v: presentation flags are not parameters", tc.args)
}
}
// TestParseLineCarriesWhatWasSetInParseableForm: only the flags the line set travel,
// each as the string its flag parses from, so the daemon's Invoke can apply them to a
// fresh FlagSet and get the same values back. Operands come through untouched, those
// after "--" included.
func TestParseLineCarriesWhatWasSetInParseableForm(t *testing.T) {
fl := lineFlags()
operands, err := ParseArgs(fl, []string{"-verbose", "-wait", "2s", "x", "--", "-1"})
require.NoError(t, err)
req := ParseLine(fl, operands)
assert.Equal(t, map[string]string{"verbose": "true", "wait": "2s"}, req.Params, "label was left alone and must be absent")
assert.Equal(t, []string{"x", "-1"}, req.Args)
assert.Equal(t, FormatUnset, req.Format)
// The round trip a client makes: what ParseLine produced is what Invoke applies.
r, seen := paramRegistry(t)
req.Command = r.Get("set")
_, err = Invoke(req)
require.NoError(t, err)
require.Len(t, *seen, 1)
assert.Equal(t, paramsSeen{Verbose: true, Wait: 2 * time.Second}, (*seen)[0])
}
// TestResolveTellsUnknownFromWithheld: the two cases read differently to an operator,
// and Resolve is the edge that decides which one a name from the wire is.
func TestResolveTellsUnknownFromWithheld(t *testing.T) {
r := testRegistry().Filter(notWithheld, testReason)
c, err := r.Resolve("served")
require.NoError(t, err)
assert.Equal(t, Name("served"), c.Name)
_, err = r.Resolve("withheld")
require.ErrorContains(t, err, "withheld is not available on this surface")
_, err = r.Resolve("no-such-command")
require.ErrorContains(t, err, `unknown command "no-such-command"`)
}
// TestLineRunsTheFlagSetItParsed: the ssh path hands Run the FlagSet the line was parsed
// into, with no trip through a Request. A flag.Func has no String worth re-parsing, so a
// round trip would hand Run an empty value and no error; the line's value must arrive.
func TestLineRunsTheFlagSetItParsed(t *testing.T) {
var seen []string
r := New()
r.Register(&Command{
Name: "mode",
Flags: func() (*flag.FlagSet, any) {
fl := flag.NewFlagSet("", flag.ContinueOnError)
s := new(string)
fl.Func("mode", "the mode", func(v string) error {
*s = "set:" + v
return nil
})
return fl, s
},
Run: func(fs any, a []string) (Result, error) {
seen = append(seen, *fs.(*string))
return Value("ok"), nil
},
})
var out, errw strings.Builder
r.Dispatch("mode -json -mode fast", Output{Out: &out, Err: &errw})
require.Equal(t, []string{"set:fast"}, seen)
assert.Empty(t, errw.String())
assert.Equal(t, "\"ok\"\n", out.String(), "-json was read from the same FlagSet")
}
+32 -16
View File
@@ -2,22 +2,38 @@ package commands
import "io" import "io"
// Output is where a command line surface's text goes. // StringWriter is how a command talks back to whoever invoked it: one stream, which the
// // ssh surface points at its channel.
// Out and Err are distinct so a command's primary output can stay machine readable on type StringWriter interface {
// a surface that separates the two. The ssh surface points both at the same channel and WriteLine(string) error
// sees a single merged stream. The local Write(string) error
// control socket does not use one at all: it invokes by named parameter and carries the WriteBytes([]byte) error
// returned value, so there is no stream for a command to write to. GetWriter() io.Writer
type Output struct {
// Out receives what a command produces.
Out io.Writer
// Err receives usage text, refusals and errors.
Err io.Writer
} }
// MergedOutput sends output and errors to the same writer. type stringWriter struct {
func MergedOutput(w io.Writer) Output { w io.Writer
return Output{Out: w, Err: w} }
// NewStringWriter returns a StringWriter that writes to w.
func NewStringWriter(w io.Writer) StringWriter {
return &stringWriter{w: w}
}
func (w *stringWriter) WriteLine(s string) error {
return w.Write(s + "\n")
}
func (w *stringWriter) Write(s string) error {
_, err := w.w.Write([]byte(s))
return err
}
func (w *stringWriter) WriteBytes(b []byte) error {
_, err := w.w.Write(b)
return err
}
func (w *stringWriter) GetWriter() io.Writer {
return w.w
} }
+20 -64
View File
@@ -2,14 +2,10 @@ package nebula
import ( import (
"bytes" "bytes"
"encoding/json"
"io" "io"
"net/netip" "net/netip"
"testing" "testing"
"time"
"github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/cert_test"
"github.com/slackhq/nebula/commands" "github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/logging" "github.com/slackhq/nebula/logging"
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
@@ -17,20 +13,19 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
// TestLogFormatRefusalIsShown: a format the logger does not know is a refusal the user // TestLogFormatRefusalIsShown: a format the logger does not know is reported to the user
// sees, rather than a bare error, which over ssh was silence. // as a failure, rather than returned bare, which over ssh was silence.
func TestLogFormatRefusalIsShown(t *testing.T) { func TestLogFormatRefusalIsShown(t *testing.T) {
l := logging.NewLogger(io.Discard) l := logging.NewLogger(io.Discard)
res, err := runLogFormat(l, []string{"bogus"})
require.NoError(t, err)
assert.False(t, res.OK)
assert.Equal(t, "Unable to set log format: unknown log format `bogus`. possible formats: [text json]", res.Reason)
res, err = runLogFormat(l, []string{"JSON"})
require.NoError(t, err)
out := &bytes.Buffer{} out := &bytes.Buffer{}
require.NoError(t, commands.Typed(textLogFormat)(res.Value, out)) w := commands.NewStringWriter(out)
var f *commands.Failure
require.ErrorAs(t, logFormatCommand(l, nil, []string{"bogus"}, w), &f)
assert.Equal(t, "Unable to set log format: unknown log format `bogus`. possible formats: [text json]\n", out.String())
out.Reset()
require.NoError(t, logFormatCommand(l, nil, []string{"JSON"}, w))
assert.Equal(t, "Log format is: json\n", out.String()) assert.Equal(t, "Log format is: json\n", out.String())
} }
@@ -46,12 +41,9 @@ func TestPrintRelaysReportsErrorsAsText(t *testing.T) {
hm.Relays[1] = &HostInfo{vpnAddrs: []netip.Addr{relay}} hm.Relays[1] = &HostInfo{vpnAddrs: []netip.Addr{relay}}
ifce := &Interface{hostMap: hm} ifce := &Interface{hostMap: hm}
marshal := func() string { out := &bytes.Buffer{}
b, err := json.Marshal(runPrintRelays(ifce)) require.NoError(t, printRelaysCommand(ifce, &printTunnelFlags{}, nil, commands.NewStringWriter(out)))
require.NoError(t, err) assert.JSONEq(t, `{"Relays":[{"NebulaAddr":"10.0.0.1","RelayForAddrs":[{"Error":"could not find hostinfo","Type":"","State":"","PeerAddr":"","LocalIndex":0,"RemoteIndex":0,"RelayedThrough":null}]}]}`, out.String())
return string(b)
}
assert.JSONEq(t, `{"Relays":[{"NebulaAddr":"10.0.0.1","RelayForAddrs":[{"Error":"could not find hostinfo","Type":"","State":"","PeerAddr":"","LocalIndex":0,"RemoteIndex":0,"RelayedThrough":null}]}]}`, marshal())
// The same relay host, found, relaying for a peer whose index matches: no Error key. // The same relay host, found, relaying for a peer whose index matches: no Error key.
hi := hm.Relays[1] hi := hm.Relays[1]
@@ -61,51 +53,15 @@ func TestPrintRelaysReportsErrorsAsText(t *testing.T) {
relayForByIdx: map[uint32]*Relay{r.LocalIndex: r}, relayForByIdx: map[uint32]*Relay{r.LocalIndex: r},
} }
hm.Hosts[relay] = hi hm.Hosts[relay] = hi
assert.JSONEq(t, `{"Relays":[{"NebulaAddr":"10.0.0.1","RelayForAddrs":[{"Type":"forwarding","State":"established","PeerAddr":"10.0.0.2","LocalIndex":1,"RemoteIndex":2,"RelayedThrough":null}]}]}`, marshal())
out.Reset()
require.NoError(t, printRelaysCommand(ifce, &printTunnelFlags{}, nil, commands.NewStringWriter(out)))
assert.JSONEq(t, `{"Relays":[{"NebulaAddr":"10.0.0.1","RelayForAddrs":[{"Type":"forwarding","State":"established","PeerAddr":"10.0.0.2","LocalIndex":1,"RemoteIndex":2,"RelayedThrough":null}]}]}`, out.String())
// And an index mismatch names it. // And an index mismatch names it.
hm.Relays[7] = hi hm.Relays[7] = hi
delete(hm.Relays, 1) delete(hm.Relays, 1)
assert.Contains(t, marshal(), `"Error":"hostmap LocalIndex '7' does not match RelayState LocalIndex"`) out.Reset()
} require.NoError(t, printRelaysCommand(ifce, &printTunnelFlags{}, nil, commands.NewStringWriter(out)))
assert.Contains(t, out.String(), `"Error":"hostmap LocalIndex '7' does not match RelayState LocalIndex"`)
// tunnelFixture is an Interface with our own certificate loaded, one peer behind an
// established tunnel and one still handshaking, which has no certificate yet.
func tunnelFixture(t *testing.T) *Interface {
t.Helper()
l := test.NewLogger()
me := netip.MustParseAddr("10.0.0.1")
peer := netip.MustParsePrefix("10.0.0.2/24")
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, time.Time{}, time.Time{}, nil, nil, nil)
peerCert, _, _, _ := cert_test.NewTestCert(cert.Version2, cert.Curve_CURVE25519, ca, caKey, "peer", time.Time{}, time.Time{},
[]netip.Prefix{peer}, nil, []string{"web", "db"})
hm := newHostMap(l)
hm.Hosts[peer.Addr()] = &HostInfo{
vpnAddrs: []netip.Addr{peer.Addr()},
ConnectionState: &ConnectionState{peerCert: &cert.CachedCertificate{Certificate: peerCert}},
}
hm.Hosts[netip.MustParseAddr("10.0.0.3")] = &HostInfo{
vpnAddrs: []netip.Addr{netip.MustParseAddr("10.0.0.3")},
ConnectionState: &ConnectionState{},
}
return &Interface{pki: newTestPKI(t, "me", []netip.Addr{me}), hostMap: hm}
}
// TestPrintCertOfATunnelWithoutACertificate: a tunnel still handshaking, or one being
// torn down, has no certificate, and print-cert refuses rather than panicking.
func TestPrintCertOfATunnelWithoutACertificate(t *testing.T) {
f := tunnelFixture(t)
r, err := runPrintCert(f, &printCertFlags{}, []string{"10.0.0.3"})
require.NoError(t, err)
assert.False(t, r.OK)
assert.Equal(t, "Could not find tunnel for vpn addr: 10.0.0.3", r.Reason)
r, err = runPrintCert(f, &printCertFlags{}, []string{"10.0.0.2"})
require.NoError(t, err)
assert.True(t, r.OK, "a tunnel with a certificate is printed")
} }
+1 -19
View File
@@ -32,11 +32,6 @@ type C struct {
// Set by the first reload that needs a restart and never cleared. Guarded by reloadLock // Set by the first reload that needs a restart and never cleared. Guarded by reloadLock
needsRestart bool needsRestart bool
// callbackLock guards callbacks. Registration is not confined to startup: CatchHUP is
// running from inside Main, and anything wired up after Main returns registers while
// a HUP could already be reloading, so append and iteration have to be serialized.
callbackLock sync.Mutex
} }
func NewC(l *slog.Logger) *C { func NewC(l *slog.Logger) *C {
@@ -83,22 +78,9 @@ func (c *C) LoadString(raw string) error {
// These functions should return quickly or spawn their own go routine if they will take a while. // These functions should return quickly or spawn their own go routine if they will take a while.
// Use r to report anything that failed or needs a restart to apply. // Use r to report anything that failed or needs a restart to apply.
func (c *C) RegisterReloadCallback(f func(c *C, r *Reload)) { func (c *C) RegisterReloadCallback(f func(c *C, r *Reload)) {
c.callbackLock.Lock()
defer c.callbackLock.Unlock()
c.callbacks = append(c.callbacks, f) c.callbacks = append(c.callbacks, f)
} }
// reloadCallbacks returns a snapshot of the registered callbacks. Reloads iterate the
// snapshot rather than the live slice, so a registration from another goroutine cannot
// race the loop; a callback registered while a reload is in progress runs from the next
// reload on. callbackLock is not held during the calls themselves, so a callback that
// registers another callback does not deadlock.
func (c *C) reloadCallbacks() []func(*C, *Reload) {
c.callbackLock.Lock()
defer c.callbackLock.Unlock()
return append(make([]func(*C, *Reload), 0, len(c.callbacks)), c.callbacks...)
}
// InitialLoad returns true if this is the first load of the config, and ReloadConfig has not been called yet. // InitialLoad returns true if this is the first load of the config, and ReloadConfig has not been called yet.
func (c *C) InitialLoad() bool { func (c *C) InitialLoad() bool {
return c.oldSettings == nil return c.oldSettings == nil
@@ -222,7 +204,7 @@ func (c *C) ReloadConfigString(raw string) ReloadResult {
func (c *C) runCallbacks() ReloadResult { func (c *C) runCallbacks() ReloadResult {
r := &Reload{c: c} r := &Reload{c: c}
for _, v := range c.reloadCallbacks() { for _, v := range c.callbacks {
v(c, r) v(c, r)
} }
-39
View File
@@ -3,7 +3,6 @@ package config
import ( import (
"os" "os"
"path/filepath" "path/filepath"
"sync"
"testing" "testing"
"time" "time"
@@ -221,41 +220,3 @@ firewall:
} }
assert.Equal(t, expected, m) assert.Equal(t, expected, m)
} }
// TestRegisterReloadCallbackDuringReload: registration is not confined to startup. The
// HUP handler runs from inside nebula.Main, and anything wired after Main returns
// registers while a reload may already be iterating the callbacks. Under -race this is
// the data race on the slice; without it, it checks a callback registered mid-reload is
// picked up by the next one.
func TestRegisterReloadCallbackDuringReload(t *testing.T) {
l := test.NewLogger()
c := NewC(l)
require.NoError(t, c.LoadString("a: 1"))
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
for i := 0; i < 200; i++ {
c.RegisterReloadCallback(func(*C, *Reload) {})
}
}()
go func() {
defer wg.Done()
for i := 0; i < 200; i++ {
assert.NoError(t, c.ReloadConfigString("a: 1").Err)
}
}()
wg.Wait()
// A callback that registers another callback must not deadlock, and the new one
// runs from the following reload on.
var ran int
c.RegisterReloadCallback(func(c *C, _ *Reload) {
c.RegisterReloadCallback(func(*C, *Reload) { ran++ })
})
require.NoError(t, c.ReloadConfigString("a: 1").Err)
assert.Equal(t, 0, ran, "registered during this reload, so not run by it")
require.NoError(t, c.ReloadConfigString("a: 1").Err)
assert.Equal(t, 1, ran, "and run by the next")
}
+28 -12
View File
@@ -14,6 +14,7 @@ import (
"github.com/slackhq/nebula/cert" "github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/header" "github.com/slackhq/nebula/header"
"github.com/slackhq/nebula/udp"
) )
type trafficDecision int type trafficDecision int
@@ -171,7 +172,7 @@ func (cm *connectionManager) Start(ctx context.Context) {
} }
func (cm *connectionManager) doTrafficCheck(localIndex uint32, p, nb, out []byte, now time.Time) { func (cm *connectionManager) doTrafficCheck(localIndex uint32, p, nb, out []byte, now time.Time) {
decision, hostinfo, primary := cm.makeTrafficDecision(localIndex, now) decision, hostinfo, primary, punch := cm.makeTrafficDecision(localIndex, now)
switch decision { switch decision {
case deleteTunnel: case deleteTunnel:
@@ -196,6 +197,20 @@ func (cm *connectionManager) doTrafficCheck(localIndex uint32, p, nb, out []byte
} }
cm.resetRelayTrafficCheck(hostinfo) cm.resetRelayTrafficCheck(hostinfo)
if punch != nil {
cm.sendPunch(punch)
}
}
// sendPunch keeps a tunnel's NAT state alive when we are not sending on it. When we have no route to its remote any
// more, typically after moving to a network without that address family, the tunnel probes its other remotes so the
// peer roams over to us. Nothing else would notice, a tunnel we are not sending on has nothing else that could fail.
func (cm *connectionManager) sendPunch(hostinfo *HostInfo) {
remote, err := cm.punchy.SendPunch(hostinfo)
if udp.IsUnreachable(err) {
hostinfo.remoteUnreachable(cm.intf, remote)
}
} }
func (cm *connectionManager) resetRelayTrafficCheck(hostinfo *HostInfo) { func (cm *connectionManager) resetRelayTrafficCheck(hostinfo *HostInfo) {
@@ -313,7 +328,9 @@ func (cm *connectionManager) migrateRelayUsed(oldhostinfo, newhostinfo *HostInfo
} }
} }
func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Time) (trafficDecision, *HostInfo, *HostInfo) { // makeTrafficDecision decides what to do with a tunnel under the hostmap lock. It also returns the tunnel to punch when
// we are not sending on it, for the caller to send once the lock is released.
func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Time) (trafficDecision, *HostInfo, *HostInfo, *HostInfo) {
// Read lock the main hostmap to order decisions based on tunnels being the primary tunnel // Read lock the main hostmap to order decisions based on tunnels being the primary tunnel
cm.hostMap.RLock() cm.hostMap.RLock()
defer cm.hostMap.RUnlock() defer cm.hostMap.RUnlock()
@@ -321,17 +338,17 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
hostinfo := cm.hostMap.Indexes[localIndex] hostinfo := cm.hostMap.Indexes[localIndex]
if hostinfo == nil { if hostinfo == nil {
cm.l.Debug("Not found in hostmap", "localIndex", localIndex) cm.l.Debug("Not found in hostmap", "localIndex", localIndex)
return doNothing, nil, nil return doNothing, nil, nil, nil
} }
if cm.isInvalidCertificate(now, hostinfo) { if cm.isInvalidCertificate(now, hostinfo) {
return closeTunnel, hostinfo, nil return closeTunnel, hostinfo, nil, nil
} }
if hostinfo.ConnectionState != nil && hostinfo.ConnectionState.messageCounter.Load() >= RejectAfterMessages { if hostinfo.ConnectionState != nil && hostinfo.ConnectionState.messageCounter.Load() >= RejectAfterMessages {
// Send path can't encrypt a CloseTunnel notify, so just delete locally; the peer recovers via recv_error. // Send path can't encrypt a CloseTunnel notify, so just delete locally; the peer recovers via recv_error.
hostinfo.logger(cm.l).Error("Dropping tunnel, message counter is exhausted") hostinfo.logger(cm.l).Error("Dropping tunnel, message counter is exhausted")
return deleteTunnel, hostinfo, nil return deleteTunnel, hostinfo, nil, nil
} }
primary := cm.hostMap.Hosts[hostinfo.vpnAddrs[0]] primary := cm.hostMap.Hosts[hostinfo.vpnAddrs[0]]
@@ -368,10 +385,10 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
if !outTraffic { if !outTraffic {
// Send a punch packet to keep the NAT state alive // Send a punch packet to keep the NAT state alive
cm.punchy.SendPunch(hostinfo) return decision, hostinfo, primary, hostinfo
} }
return decision, hostinfo, primary return decision, hostinfo, primary, nil
} }
if hostinfo.isPendingDeletion() { if hostinfo.isPendingDeletion() {
@@ -380,7 +397,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
"tunnelCheck", m{"state": "dead", "method": "active"}, "tunnelCheck", m{"state": "dead", "method": "active"},
) )
return deleteTunnel, hostinfo, nil return deleteTunnel, hostinfo, nil, nil
} }
decision := doNothing decision := doNothing
@@ -394,14 +411,13 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
"primary", mainHostInfo, "primary", mainHostInfo,
) )
return closeTunnel, hostinfo, primary return closeTunnel, hostinfo, primary, nil
} }
// If we aren't sending or receiving traffic then its an unused tunnel and we don't to test the tunnel. // If we aren't sending or receiving traffic then its an unused tunnel and we don't to test the tunnel.
// Just maintain NAT state if configured to do so. // Just maintain NAT state if configured to do so.
cm.punchy.SendPunch(hostinfo)
cm.trafficTimer.Add(hostinfo.localIndexId, cm.checkInterval) cm.trafficTimer.Add(hostinfo.localIndexId, cm.checkInterval)
return doNothing, nil, nil return doNothing, nil, nil, hostinfo
} }
// We aren't receiving traffic but we are sending it. The outbound // We aren't receiving traffic but we are sending it. The outbound
@@ -427,7 +443,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
hostinfo.setPendingDeletion(true) hostinfo.setPendingDeletion(true)
cm.trafficTimer.Add(hostinfo.localIndexId, cm.pendingDeletionInterval) cm.trafficTimer.Add(hostinfo.localIndexId, cm.pendingDeletionInterval)
return decision, hostinfo, nil return decision, hostinfo, nil, nil
} }
func (cm *connectionManager) isInactive(hostinfo *HostInfo, now time.Time) (time.Duration, bool) { func (cm *connectionManager) isInactive(hostinfo *HostInfo, now time.Time) (time.Duration, bool) {
+247 -6
View File
@@ -3,13 +3,18 @@ package nebula
import ( import (
"crypto/ed25519" "crypto/ed25519"
"crypto/rand" "crypto/rand"
"io"
"net/netip" "net/netip"
"testing" "testing"
"time" "time"
"github.com/flynn/noise"
"github.com/rcrowley/go-metrics" "github.com/rcrowley/go-metrics"
"github.com/slackhq/nebula/cert" "github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/header"
"github.com/slackhq/nebula/noiseutil"
"github.com/slackhq/nebula/overlay/batch"
"github.com/slackhq/nebula/overlay/overlaytest" "github.com/slackhq/nebula/overlay/overlaytest"
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
"github.com/slackhq/nebula/udp" "github.com/slackhq/nebula/udp"
@@ -266,12 +271,12 @@ func Test_NewConnectionManager_CounterLimits(t *testing.T) {
// Still below the reject limit, the tunnel stays up // Still below the reject limit, the tunnel stays up
nc.In(hostinfo) nc.In(hostinfo)
decision, _, _ := nc.makeTrafficDecision(hostinfo.localIndexId, time.Now()) decision, _, _, _ := nc.makeTrafficDecision(hostinfo.localIndexId, time.Now())
assert.Equal(t, tryRehandshake, decision) assert.Equal(t, tryRehandshake, decision)
// At the reject limit, the tunnel is deleted locally without a doomed CloseTunnel notify // At the reject limit, the tunnel is deleted locally without a doomed CloseTunnel notify
hostinfo.ConnectionState.messageCounter.Store(RejectAfterMessages) hostinfo.ConnectionState.messageCounter.Store(RejectAfterMessages)
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, time.Now()) decision, _, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, time.Now())
assert.Equal(t, deleteTunnel, decision) assert.Equal(t, deleteTunnel, decision)
} }
@@ -333,14 +338,14 @@ func Test_NewConnectionManager_DisconnectInactive(t *testing.T) {
assert.True(t, (hostinfo.state.Load()&stateIn != 0)) assert.True(t, (hostinfo.state.Load()&stateIn != 0))
now := time.Now() now := time.Now()
decision, _, _ := nc.makeTrafficDecision(hostinfo.localIndexId, now) decision, _, _, _ := nc.makeTrafficDecision(hostinfo.localIndexId, now)
assert.Equal(t, tryRehandshake, decision) assert.Equal(t, tryRehandshake, decision)
assert.Equal(t, now, hostinfo.lastUsed) assert.Equal(t, now, hostinfo.lastUsed)
assert.False(t, hostinfo.isPendingDeletion()) assert.False(t, hostinfo.isPendingDeletion())
assert.False(t, hostinfo.sentSinceCheck()) assert.False(t, hostinfo.sentSinceCheck())
assert.False(t, (hostinfo.state.Load()&stateIn != 0)) assert.False(t, (hostinfo.state.Load()&stateIn != 0))
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*5)) decision, _, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*5))
assert.Equal(t, doNothing, decision) assert.Equal(t, doNothing, decision)
assert.Equal(t, now, hostinfo.lastUsed) assert.Equal(t, now, hostinfo.lastUsed)
assert.False(t, hostinfo.isPendingDeletion()) assert.False(t, hostinfo.isPendingDeletion())
@@ -348,7 +353,7 @@ func Test_NewConnectionManager_DisconnectInactive(t *testing.T) {
assert.False(t, (hostinfo.state.Load()&stateIn != 0)) assert.False(t, (hostinfo.state.Load()&stateIn != 0))
// Do another traffic check tick, should still not be pending deletion // Do another traffic check tick, should still not be pending deletion
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*10)) decision, _, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*10))
assert.Equal(t, doNothing, decision) assert.Equal(t, doNothing, decision)
assert.Equal(t, now, hostinfo.lastUsed) assert.Equal(t, now, hostinfo.lastUsed)
assert.False(t, hostinfo.isPendingDeletion()) assert.False(t, hostinfo.isPendingDeletion())
@@ -358,7 +363,7 @@ func Test_NewConnectionManager_DisconnectInactive(t *testing.T) {
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0]) assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
// Finally advance beyond the inactivity timeout // Finally advance beyond the inactivity timeout
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Minute*10)) decision, _, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Minute*10))
assert.Equal(t, closeTunnel, decision) assert.Equal(t, closeTunnel, decision)
assert.Equal(t, now, hostinfo.lastUsed) assert.Equal(t, now, hostinfo.lastUsed)
assert.False(t, hostinfo.isPendingDeletion()) assert.False(t, hostinfo.isPendingDeletion())
@@ -578,3 +583,239 @@ func (d *dummyCert) MarshalJSON() ([]byte, error) {
func (d *dummyCert) Copy() cert.Certificate { func (d *dummyCert) Copy() cert.Certificate {
return d return d
} }
// newPunchTestConnectionManager is a connection manager punching through conn, holding the tunnel from newPunchTarget
func newPunchTestConnectionManager(t *testing.T, conn udp.Conn) (*connectionManager, *HostInfo) {
l := test.NewLogger()
hostMap := newHostMap(l)
hostMap.preferredRanges.Store(&[]netip.Prefix{})
lh := newTestLighthouse()
ifce := &Interface{
hostMap: hostMap,
inside: &overlaytest.NoopTun{},
outside: &udp.NoopConn{},
firewall: &Firewall{},
lightHouse: lh,
pki: &PKI{},
handshakeManager: NewHandshakeManager(l, hostMap, lh, &udp.NoopConn{}, defaultHandshakeConfig),
l: l,
}
ifce.pki.cs.Store(&CertState{
initiatingVersion: cert.Version1,
privateKey: []byte{},
v1Cert: &dummyCert{version: cert.Version1},
})
punchy := newPunchyForTest(t, map[string]any{"punch": true}, conn)
nc := newConnectionManagerFromConfig(l, config.NewC(l), hostMap, punchy)
nc.intf = ifce
ifce.connectionManager = nc
// Tunnel sends go through conn too, though without a key from withTestKey they never get as far as writing
ifce.writers = []udp.Conn{conn}
ifce.metricTxDropped = metrics.NilCounter{}
hostinfo := newPunchTarget()
hostinfo.localIndexId = 1099
hostinfo.remoteIndexId = 9901
hostinfo.ConnectionState = &ConnectionState{myCert: &dummyCert{version: cert.Version1}}
nc.hostMap.unlockedAddHostInfo(hostinfo, ifce)
return nc, hostinfo
}
// A tunnel we are not sending on gets punched whether or not it is receiving, the punch is the only thing that
// would notice its remote has become unreachable.
func Test_makeTrafficDecision_punchesWhenNotSending(t *testing.T) {
nc, hostinfo := newPunchTestConnectionManager(t, &recordingConn{})
now := time.Now()
// Receiving but not sending
hostinfo.takeTraffic()
nc.In(hostinfo)
decision, _, _, punch := nc.makeTrafficDecision(hostinfo.localIndexId, now)
assert.Equal(t, tryRehandshake, decision)
assert.Same(t, hostinfo, punch)
// Sending and receiving, our own traffic keeps the NAT state alive
nc.Out(hostinfo)
nc.In(hostinfo)
decision, _, _, punch = nc.makeTrafficDecision(hostinfo.localIndexId, now)
assert.Equal(t, tryRehandshake, decision)
assert.Nil(t, punch)
// Unused
decision, decided, _, punch := nc.makeTrafficDecision(hostinfo.localIndexId, now)
assert.Equal(t, doNothing, decision)
assert.Nil(t, decided, "an unused tunnel has no relay usage to reset")
assert.Same(t, hostinfo, punch)
// Sending but not receiving gets a test packet instead, which finds an unreachable remote on its own
nc.Out(hostinfo)
decision, _, _, punch = nc.makeTrafficDecision(hostinfo.localIndexId, now)
assert.Equal(t, sendTestPacket, decision)
assert.Nil(t, punch)
}
func Test_sendPunch_probesWhenRemoteUnreachable(t *testing.T) {
t.Run("unreachable", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
nc.sendPunch(hostinfo)
assert.Equal(t, []netip.AddrPort{punchTargetV6}, conn.wrote)
assert.NotZero(t, hostinfo.nextUnreachableProbe.Load(), "the tunnel should have probed its other remotes")
assert.Equal(t, []netip.Addr{hostinfo.vpnAddrs[0]}, drainQueries(nc.intf.lightHouse),
"the probe should ask the lighthouse to have the peer punch us")
// Within the probe interval nothing more goes out, however many sends fail
nc.sendPunch(hostinfo)
nc.sendPunch(hostinfo)
assert.Empty(t, drainQueries(nc.intf.lightHouse))
})
t.Run("delivered", func(t *testing.T) {
conn := &recordingConn{}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
nc.sendPunch(hostinfo)
assert.Equal(t, []netip.AddrPort{punchTargetV6}, conn.wrote)
assert.Zero(t, hostinfo.nextUnreachableProbe.Load())
assert.Empty(t, drainQueries(nc.intf.lightHouse))
})
t.Run("other failure", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: io.ErrShortWrite}}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
nc.sendPunch(hostinfo)
assert.Zero(t, hostinfo.nextUnreachableProbe.Load(), "only a missing route says to look elsewhere")
assert.Empty(t, drainQueries(nc.intf.lightHouse))
})
}
// A packet the data path had no route for names its tunnel in its header, the peer's index for it
func Test_sendUnreachable_findsTunnelFromHeader(t *testing.T) {
head := func(st header.MessageSubType, remoteIndex uint32) []byte {
return header.Encode(make([]byte, header.Len), header.Version, header.Message, st, remoteIndex, 1)
}
t.Run("direct", func(t *testing.T) {
nc, hostinfo := newPunchTestConnectionManager(t, &recordingConn{})
nc.intf.sendUnreachable(head(header.MessageNone, hostinfo.remoteIndexId), punchTargetV6)
assert.NotZero(t, hostinfo.nextUnreachableProbe.Load(), "the tunnel should have probed its other remotes")
assert.Equal(t, []netip.Addr{hostinfo.vpnAddrs[0]}, drainQueries(nc.intf.lightHouse))
})
t.Run("not its remote", func(t *testing.T) {
nc, hostinfo := newPunchTestConnectionManager(t, &recordingConn{})
nc.intf.sendUnreachable(head(header.MessageNone, hostinfo.remoteIndexId), punchTargetV4)
assert.Zero(t, hostinfo.nextUnreachableProbe.Load(), "a failure on a remote the tunnel is not using is stale")
})
t.Run("relayed", func(t *testing.T) {
nc, hostinfo := newPunchTestConnectionManager(t, &recordingConn{})
// A relay header's index is the relay session's, it must not be taken for a tunnel's even when they collide
nc.intf.sendUnreachable(head(header.MessageRelay, hostinfo.remoteIndexId), punchTargetV6)
assert.Zero(t, hostinfo.nextUnreachableProbe.Load())
assert.Empty(t, drainQueries(nc.intf.lightHouse))
})
t.Run("unknown tunnel", func(t *testing.T) {
nc, hostinfo := newPunchTestConnectionManager(t, &recordingConn{})
nc.intf.sendUnreachable(head(header.MessageNone, hostinfo.remoteIndexId+1), punchTargetV6)
assert.Zero(t, hostinfo.nextUnreachableProbe.Load())
})
}
// withTestKey gives a tunnel a real key so its sends get encrypted and written instead of returning early
func withTestKey(hostinfo *HostInfo) {
cs := noise.NewCipherSuite(noise.DH25519, noise.CipherAESGCM, noise.HashSHA256)
hostinfo.ConnectionState.eKey = noiseutil.NewCipherState(noise.UnsafeNewCipherState(cs, [32]byte{}, 0), noise.CipherAESGCM)
}
// The probe itself, end to end from a failed send: a test packet to every remote but the one we cannot reach, and a
// lighthouse query, through both places a send can fail.
func Test_remoteUnreachable_probesOtherRemotes(t *testing.T) {
t.Run("control send", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
withTestKey(hostinfo)
nc.intf.SendMessageToHostInfo(header.Test, header.TestRequest, hostinfo, []byte{}, make([]byte, 12), make([]byte, mtu))
assert.Equal(t, []netip.AddrPort{punchTargetV6, punchTargetV4}, conn.wrote, "the failed send, then the probe")
assert.Equal(t, []header.MessageType{header.Test, header.Test}, conn.types)
assert.Equal(t, []netip.Addr{hostinfo.vpnAddrs[0]}, drainQueries(nc.intf.lightHouse))
})
t.Run("data path batch", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
withTestKey(hostinfo)
// Two of the tunnel's packets fail in one batch, they probe once
sb := batch.NewSendBatch(conn, 4, 4096)
for c := uint64(1); c <= 2; c++ {
pkt := header.Encode(sb.Reserve(64), header.Version, header.Message, header.MessageNone, hostinfo.remoteIndexId, c)
sb.Commit(append(pkt, make([]byte, 32)...), punchTargetV6)
}
nc.intf.flushSendBatch(sb, 0)
assert.Equal(t, []netip.AddrPort{punchTargetV6, punchTargetV6, punchTargetV4}, conn.wrote,
"the failed packets, then one probe")
assert.Equal(t, header.Test, conn.types[2])
assert.Equal(t, []netip.Addr{hostinfo.vpnAddrs[0]}, drainQueries(nc.intf.lightHouse))
})
t.Run("closing", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
withTestKey(hostinfo)
nc.intf.SendMessageToHostInfo(header.CloseTunnel, 0, hostinfo, []byte{}, make([]byte, 12), make([]byte, mtu))
assert.Equal(t, []netip.AddrPort{punchTargetV6}, conn.wrote, "a tunnel being torn down does not probe")
assert.Empty(t, drainQueries(nc.intf.lightHouse))
})
t.Run("lighthouse", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
withTestKey(hostinfo)
nc.intf.lightHouse.amLighthouse = true
nc.intf.SendMessageToHostInfo(header.Test, header.TestRequest, hostinfo, []byte{}, make([]byte, 12), make([]byte, mtu))
assert.Equal(t, []netip.AddrPort{punchTargetV6}, conn.wrote, "a lighthouse does not roam its clients")
})
t.Run("nothing else to probe", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
nc, hostinfo := newPunchTestConnectionManager(t, conn)
withTestKey(hostinfo)
nc.intf.reQueryWait.Store(int64(time.Minute))
// Forget the IPv4 remote, all the tunnel knows is the one it cannot reach
hostinfo.remotes = NewRemoteList(hostinfo.vpnAddrs, nil)
hostinfo.remotes.LearnRemote(hostinfo.vpnAddrs[0], punchTargetV6)
nc.intf.SendMessageToHostInfo(header.Test, header.TestRequest, hostinfo, []byte{}, make([]byte, 12), make([]byte, mtu))
assert.Equal(t, []netip.Addr{hostinfo.vpnAddrs[0]}, drainQueries(nc.intf.lightHouse),
"the lighthouse is the only way to learn of another remote")
// Past the probe interval, but the lighthouse is only asked again on the requery schedule
hostinfo.nextUnreachableProbe.Store(0)
nc.intf.SendMessageToHostInfo(header.Test, header.TestRequest, hostinfo, []byte{}, make([]byte, 12), make([]byte, mtu))
assert.Empty(t, drainQueries(nc.intf.lightHouse))
assert.Equal(t, []netip.AddrPort{punchTargetV6, punchTargetV6}, conn.wrote)
})
}
// drainQueries returns every lighthouse query waiting to go out
func drainQueries(lh *LightHouse) []netip.Addr {
var queries []netip.Addr
for {
select {
case addr := <-lh.queryChan:
queries = append(queries, addr)
default:
return queries
}
}
}
+1 -1
View File
@@ -148,7 +148,7 @@ func (c *fakeConn) Rebind() error { c.rebinds++; ret
func (c *fakeConn) LocalAddr() (netip.AddrPort, error) { return netip.AddrPort{}, nil } func (c *fakeConn) LocalAddr() (netip.AddrPort, error) { return netip.AddrPort{}, nil }
func (c *fakeConn) ListenOut(_ udp.EncReader, _ func()) error { return nil } func (c *fakeConn) ListenOut(_ udp.EncReader, _ func()) error { return nil }
func (c *fakeConn) WriteTo(_ []byte, _ netip.AddrPort) error { return nil } func (c *fakeConn) WriteTo(_ []byte, _ netip.AddrPort) error { return nil }
func (c *fakeConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) { func (c *fakeConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort, _ func(int, error)) (int, error) {
return len(bufs), nil return len(bufs), nil
} }
func (c *fakeConn) ReloadConfig(_ *config.C, _ *config.Reload) {} func (c *fakeConn) ReloadConfig(_ *config.C, _ *config.Reload) {}
+12
View File
@@ -117,6 +117,18 @@ func (c *Control) SetUDPAddr(addr netip.AddrPort) {
c.f.outside.(*udp.TesterConn).SetAddr(addr) c.f.outside.(*udp.TesterConn).SetAddr(addr)
} }
// GetUDPAddrFor returns the underlay address this node sends to dst from, which differs by family for a dual stack node
func (c *Control) GetUDPAddrFor(dst netip.AddrPort) netip.AddrPort {
return c.f.outside.(*udp.TesterConn).GetAddrFor(dst)
}
// SetDualStackUDPAddrs gives this node one underlay address per family, sending from whichever matches the
// destination. An invalid AddrPort leaves the node without that family, sends to it fail with ENETUNREACH. Register
// any address the node did not start on with the router as well or nothing will route back.
func (c *Control) SetDualStackUDPAddrs(v4, v6 netip.AddrPort) {
c.f.outside.(*udp.TesterConn).SetDualStackAddrs(v4, v6)
}
// SetLocalAddrsFn replaces underlay address discovery so a test can advertise its simulated address instead of // SetLocalAddrsFn replaces underlay address discovery so a test can advertise its simulated address instead of
// whatever this machine's NICs happen to be. Call it before Start, SendUpdate reads it from the update worker. // whatever this machine's NICs happen to be. Call it before Start, SendUpdate reads it from the update worker.
func (c *Control) SetLocalAddrsFn(fn func(*LocalAllowList) []netip.Addr) { func (c *Control) SetLocalAddrsFn(fn func(*LocalAllowList) []netip.Addr) {
+1 -6
View File
@@ -69,15 +69,12 @@ func TestCommandOutput(t *testing.T) {
// help on the clone lists and describes. There is no session to end here. // help on the clone lists and describes. There is no session to end here.
reg := control.Commands().Clone() reg := control.Commands().Clone()
reg.Register(sshd.LogoutCommand(func() {})) reg.Register(sshd.LogoutCommand(func() {}))
// Dispatch with ssh's default-format policy, so the no-flag column records what an
// operator at an ssh prompt sees.
reg.DefaultFormat = sshd.DefaultFormat
// run dispatches as the ssh exec path does and returns the output and the error, which // run dispatches as the ssh exec path does and returns the output and the error, which
// over ssh is exit status 1. // over ssh is exit status 1.
run := func(args ...string) (string, error) { run := func(args ...string) (string, error) {
buf := &bytes.Buffer{} buf := &bytes.Buffer{}
err := reg.DispatchArgs(args, commands.MergedOutput(buf)) err := reg.DispatchArgs(args, commands.NewStringWriter(buf))
return buf.String(), err return buf.String(), err
} }
@@ -97,8 +94,6 @@ func TestCommandOutput(t *testing.T) {
{"print-cert", nil}, {"print-cert", nil},
{"print-cert", []string{"-raw"}}, {"print-cert", []string{"-raw"}},
{"print-cert", []string{"10.222.0.9"}}, {"print-cert", []string{"10.222.0.9"}},
// A flag after the operand is still a flag, on both surfaces.
{"print-cert", []string{"10.222.0.9", "-json"}},
{"print-cert", []string{"10.222.0.250"}}, {"print-cert", []string{"10.222.0.250"}},
{"print-cert", []string{"not-an-address"}}, {"print-cert", []string{"not-an-address"}},
{"print-tunnel", nil}, {"print-tunnel", nil},
+305
View File
@@ -0,0 +1,305 @@
//go:build e2e_testing
package e2e
import (
"net/netip"
"sync/atomic"
"testing"
"time"
"github.com/slackhq/nebula"
"github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/cert_test"
"github.com/slackhq/nebula/e2e/router"
"github.com/slackhq/nebula/udp"
)
// TestDualStackRoamToV4Only measures how long a laptop's tunnels take to come back after it moves from a dual stack
// network, where its tunnels formed over IPv6, to one with no IPv6 service at all: the office to hotel wifi. Every
// peer still has an IPv4 address the laptop can reach, so nothing about the move should strand a tunnel.
//
// It is a measurement, not a pass/fail assertion, and it runs on the production connection manager timers.
//
// go test -tags e2e_testing -v -run TestDualStackRoamToV4Only ./e2e/
func TestDualStackRoamToV4Only(t *testing.T) {
for _, tc := range []dualStackRoamCase{
{name: "both send", meSends: true, themSends: true},
{name: "both send, rebind", meSends: true, themSends: true, rebind: true},
{name: "both send, two tunnels", meSends: true, themSends: true, simultaneous: true},
{name: "laptop sends", meSends: true},
{name: "peer sends", themSends: true},
{name: "peer sends, rebind", themSends: true, rebind: true},
{name: "peer sends, lh over v4", themSends: true, lhOverV4: true},
{name: "peer sends, punchy", themSends: true, punchy: true},
{name: "peer sends, punchy all", themSends: true, punchy: true, punchAll: true},
{name: "laptop sends, peer NAT", meSends: true, peerNAT: true},
{name: "laptop sends, peer NAT, lh v4", meSends: true, peerNAT: true, lhOverV4: true},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
fwd, rev := measureDualStackRoam(t, tc)
t.Logf("RESULT %-24s laptop->peer %-9v peer->laptop %-9v", tc.name, fmtRecovery(fwd), fmtRecovery(rev))
})
}
}
// TestDualStackRoamRecovers holds the line TestDualStackRoamToV4Only measures: a tunnel whose remote became unreachable
// moves to the peer's other address instead of waiting out the connection manager to rehandshake, which takes 20s.
func TestDualStackRoamRecovers(t *testing.T) {
for _, tc := range []struct {
dualStackRoamCase
// within bounds recovery in each direction that has traffic
within time.Duration
}{
// Measures 0.4s. Under the 5s connection manager check, so it fails if the data path stops probing.
{dualStackRoamCase{name: "both send", meSends: true, themSends: true}, 2 * time.Second},
// Measures 2.6s or 3.8s, depending on whether a probe beats the peer's punch. Half the 20s it used to take.
{dualStackRoamCase{name: "laptop sends, peer NAT", meSends: true, peerNAT: true}, 10 * time.Second},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
fwd, rev := measureDualStackRoam(t, tc.dualStackRoamCase)
if fwd == 0 || fwd > tc.within {
t.Errorf("laptop->peer recovered in %v, want within %v", fmtRecovery(fwd), tc.within)
}
if tc.themSends && (rev == 0 || rev > tc.within) {
t.Errorf("peer->laptop recovered in %v, want within %v", fmtRecovery(rev), tc.within)
}
})
}
}
type dualStackRoamCase struct {
name string
// meSends and themSends say who keeps traffic flowing after the move
meSends, themSends bool
// rebind fires RebindUDPServer on the move, as the darwin network change monitor would
rebind bool
// lhOverV4 forms the lighthouse tunnel over IPv4 at the office, so the move does not break it
lhOverV4 bool
// simultaneous has both sides initiate at once at the office, which can leave each side a different primary
// tunnel for the other
simultaneous bool
// punchy turns on punchy.punch everywhere, punchAll adds punchy.target_all_remotes
punchy, punchAll bool
// peerNAT puts the peer behind a NAT that, after the move, only lets in traffic from addresses the peer has sent to
peerNAT bool
}
func fmtRecovery(d time.Duration) string {
if d == 0 {
return "never"
}
return d.Round(time.Millisecond).String()
}
type dualStackNode struct {
c *nebula.Control
vpnAddr netip.Addr
v4, v6 netip.AddrPort
adv atomic.Pointer[[]netip.Addr]
}
// move puts the node on a new network, advertising only what it can be reached on there
func (n *dualStackNode) move(v4, v6 netip.AddrPort) {
n.v4, n.v6 = v4, v6
n.c.SetDualStackUDPAddrs(v4, v6)
var adv []netip.Addr
for _, a := range []netip.AddrPort{v4, v6} {
if a.IsValid() {
adv = append(adv, a.Addr())
}
}
n.adv.Store(&adv)
}
func newDualStackNode(ca cert.Certificate, caKey []byte, name, vpnNet string, v4, v6 netip.AddrPort, overrides m) *dualStackNode {
c, vpnNets, _, _ := newSimpleServerWithUdp(cert.Version2, ca, caKey, name, vpnNet, v4, overrides)
n := &dualStackNode{c: c, vpnAddr: vpnNets[0].Addr()}
n.move(v4, v6)
c.SetLocalAddrsFn(func(*nebula.LocalAllowList) []netip.Addr {
return *n.adv.Load()
})
return n
}
// measureDualStackRoam returns how long after the move the first packet made it laptop->peer and peer->laptop, zero
// for a direction that never recovered.
func measureDualStackRoam(t *testing.T, tc dualStackRoamCase) (time.Duration, time.Duration) {
t.Helper()
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, time.Now(), time.Now().Add(10*time.Minute), nil, nil, []string{})
ap := netip.MustParseAddrPort
lhV4, lhV6 := ap("10.0.0.1:4242"), ap("[fd00::1]:4242")
lh := newDualStackNode(ca, caKey, "lh", "10.128.0.1/24", lhV4, lhV6, m{
"lighthouse": m{"am_lighthouse": true},
})
// Production timers rather than the 2s the harness defaults to, this is about how long a real laptop waits
peerCfg := m{
"lighthouse": m{
"hosts": []any{lh.vpnAddr.String()},
"interval": 10,
},
"static_host_map": m{
lh.vpnAddr.String(): []any{lhV4.String(), lhV6.String()},
},
"timers": m{
"connection_alive_interval": 5,
"pending_deletion_interval": 10,
},
"punchy": m{
"punch": tc.punchy,
"target_all_remotes": tc.punchAll,
},
}
me := newDualStackNode(ca, caKey, "me", "10.128.0.2/24", ap("10.0.0.2:4242"), ap("[fd00::2]:4242"), peerCfg)
them := newDualStackNode(ca, caKey, "them", "10.128.0.3/24", ap("10.0.0.3:4242"), ap("[fd00::3]:4242"), peerCfg)
r := router.NewR(t, lh.c, me.c, them.c)
r.CancelFlowLogs()
for _, n := range []*dualStackNode{lh, me, them} {
r.AddRoute(n.v6.Addr(), n.v6.Port(), n.c)
}
defer func() {
lh.c.Stop()
me.c.Stop()
them.c.Stop()
}()
lh.c.Start()
me.c.Start()
them.c.Start()
// At the office IPv6 wins every race, so everything forms over it. The lighthouse tunnel optionally does not,
// for a static_host_map that only lists the lighthouse's IPv4 address.
officeV6 := func(p *udp.Packet, _ *nebula.Control) router.ExitType {
lhTraffic := p.To == lhV4 || p.To == lhV6 || p.From == lhV4 || p.From == lhV6
if p.To.Addr().Is4() == (tc.lhOverV4 && lhTraffic) {
return router.KeepRouting
}
return router.Drop
}
r.RouteForAllExitFuncOrTimeout(time.Second, officeV6)
// One side at a time, so both sides hold the same single tunnel, unless the case wants them racing
me.c.InjectTunPacket(BuildTunUDPPacket(them.vpnAddr, 80, me.vpnAddr, 80, []byte("establish")))
if !tc.simultaneous {
r.RouteForAllExitFuncOrTimeout(time.Second, officeV6)
}
them.c.InjectTunPacket(BuildTunUDPPacket(me.vpnAddr, 80, them.vpnAddr, 80, []byte("establish")))
r.RouteForAllExitFuncOrTimeout(time.Second, officeV6)
if tc.simultaneous && me.c.GetHostmapIndexCount() < 3 {
// A tunnel to the lighthouse and two to the peer, or the race did not happen
t.Logf("simultaneous handshakes settled on a single tunnel this run")
}
drainTun(me.c)
drainTun(them.c)
for _, want := range []struct {
name string
c *nebula.Control
vpnAddr netip.Addr
v6 bool
}{
{"laptop->peer", me.c, them.vpnAddr, true},
{"peer->laptop", them.c, me.vpnAddr, true},
{"laptop->lh", me.c, lh.vpnAddr, !tc.lhOverV4},
} {
hi := want.c.GetHostInfoByVpnAddr(want.vpnAddr, false)
if hi == nil {
t.Fatalf("%s: no tunnel at the office", want.name)
}
if hi.CurrentRemote.Addr().Is6() != want.v6 {
t.Fatalf("%s: tunnel formed over %v, the scenario wants v6=%v", want.name, hi.CurrentRemote, want.v6)
}
}
// Hotel wifi: a new NAT'd IPv4 address and no IPv6 at all. The office addresses are gone, nothing reaches them.
officeV4, officeV6Addr := me.v4, me.v6
hotel := ap("10.0.0.99:4242")
me.move(hotel, netip.AddrPort{})
r.AddRoute(hotel.Addr(), hotel.Port(), me.c)
start := time.Now()
if tc.rebind {
me.c.RebindUDPServer()
}
var fwd, rev atomic.Int64
stop := make(chan struct{})
defer close(stop)
watchTun(them.c, stop, start, &fwd)
watchTun(me.c, stop, start, &rev)
go func() {
tick := time.NewTicker(time.Millisecond * 200)
defer tick.Stop()
for {
select {
case <-stop:
return
case <-tick.C:
if tc.meSends {
me.c.InjectTunPacket(BuildTunUDPPacket(them.vpnAddr, 80, me.vpnAddr, 80, []byte("retry")))
}
if tc.themSends {
them.c.InjectTunPacket(BuildTunUDPPacket(me.vpnAddr, 80, them.vpnAddr, 80, []byte("retry")))
}
}
}
}()
// When only one side has traffic, the other direction recovering is a bonus we still report but do not wait for
done := func() bool {
return (!tc.meSends || fwd.Load() != 0) && (!tc.themSends || rev.Load() != 0)
}
// The peer's NAT has state for the lighthouse, which its own updates keep fresh, and for wherever it sends from here
natOpen := map[netip.AddrPort]bool{lhV4: true, lhV6: true}
isPeer := func(a netip.AddrPort) bool { return a == them.v4 || a == them.v6 }
r.RouteForAllExitFuncOrTimeout(time.Second*90, func(p *udp.Packet, _ *nebula.Control) router.ExitType {
if p.To == officeV4 || p.To == officeV6Addr {
return router.Drop
}
if tc.peerNAT {
if isPeer(p.From) {
natOpen[p.To] = true
} else if isPeer(p.To) && !natOpen[p.From] {
return router.Drop
}
}
if done() {
return router.ExitNow
}
return router.KeepRouting
})
return time.Duration(fwd.Load()), time.Duration(rev.Load())
}
func drainTun(c *nebula.Control) {
for {
select {
case <-c.GetTunTxChan():
default:
return
}
}
}
// watchTun records how long after start the first packet came out of c's tun, and keeps the tun drained after
func watchTun(c *nebula.Control, stop chan struct{}, start time.Time, first *atomic.Int64) {
go func() {
for {
select {
case <-stop:
return
case <-c.GetTunTxChan():
first.CompareAndSwap(0, int64(time.Since(start)))
}
}
}()
}
+14 -13
View File
@@ -497,11 +497,10 @@ func (r *R) RouteUntilTxTun(sender *nebula.Control, receiver *nebula.Control) []
// Nope, lets push the sender along // Nope, lets push the sender along
case p := <-udpTx: case p := <-udpTx:
r.Lock() r.Lock()
a := sender.GetUDPAddr() c := r.getControl(p)
c := r.getControl(a, p.To, p)
if c == nil { if c == nil {
r.Unlock() r.Unlock()
panic("No control for udp tx " + a.String()) panic("No control for udp tx " + p.To.String())
} }
fp := r.unlockedInjectFlow(sender, c, p, false) fp := r.unlockedInjectFlow(sender, c, p, false)
c.InjectUDPPacket(p) // copies internally; original is ours to release c.InjectUDPPacket(p) // copies internally; original is ours to release
@@ -622,8 +621,7 @@ func (r *R) stopFanInWorkers() {
func (r *R) routeUDP(from *nebula.Control, p *udp.Packet) { func (r *R) routeUDP(from *nebula.Control, p *udp.Packet) {
r.Lock() r.Lock()
defer r.Unlock() defer r.Unlock()
a := from.GetUDPAddr() c := r.getControl(p)
c := r.getControl(a, p.To, p)
if c == nil { if c == nil {
panic(fmt.Sprintf("No control for udp tx %s", p.To)) panic(fmt.Sprintf("No control for udp tx %s", p.To))
} }
@@ -671,7 +669,7 @@ func (r *R) RouteExitFunc(sender *nebula.Control, whatDo ExitFunc) {
panic(err) panic(err)
} }
receiver := r.getControl(sender.GetUDPAddr(), p.To, p) receiver := r.getControl(p)
if receiver == nil { if receiver == nil {
r.Unlock() r.Unlock()
panic("Can't RouteExitFunc for host: " + p.To.String()) panic("Can't RouteExitFunc for host: " + p.To.String())
@@ -767,7 +765,7 @@ func (r *R) RouteForAllExitFuncOrTimeout(timeout time.Duration, whatDo ExitFunc)
r.Lock() r.Lock()
p := rx.Interface().(*udp.Packet) p := rx.Interface().(*udp.Packet)
receiver := r.getControl(cm[x].GetUDPAddr(), p.To, p) receiver := r.getControl(p)
if receiver == nil { if receiver == nil {
r.Unlock() r.Unlock()
panic("Can't RouteForAllExitFuncOrTimeout for host: " + p.To.String()) panic("Can't RouteForAllExitFuncOrTimeout for host: " + p.To.String())
@@ -876,7 +874,7 @@ func (r *R) RouteForAllExitFunc(whatDo ExitFunc) {
r.Lock() r.Lock()
p := rx.Interface().(*udp.Packet) p := rx.Interface().(*udp.Packet)
receiver := r.getControl(cm[x].GetUDPAddr(), p.To, p) receiver := r.getControl(p)
if receiver == nil { if receiver == nil {
r.Unlock() r.Unlock()
panic("Can't RouteForAllExitFunc for host: " + p.To.String()) panic("Can't RouteForAllExitFunc for host: " + p.To.String())
@@ -939,7 +937,7 @@ func (r *R) FlushAll() {
}) })
for { for {
x, rx, ok := reflect.Select(sc) _, rx, ok := reflect.Select(sc)
if !ok { if !ok {
return return
} }
@@ -947,7 +945,7 @@ func (r *R) FlushAll() {
p := rx.Interface().(*udp.Packet) p := rx.Interface().(*udp.Packet)
receiver := r.getControl(cm[x].GetUDPAddr(), p.To, p) receiver := r.getControl(p)
if receiver == nil { if receiver == nil {
r.Unlock() r.Unlock()
panic("Can't FlushAll for host: " + p.To.String()) panic("Can't FlushAll for host: " + p.To.String())
@@ -958,16 +956,19 @@ func (r *R) FlushAll() {
} }
} }
// getControl performs or seeds NAT translation and returns the control for toAddr, p from fields may change // getControl performs or seeds NAT translation and returns the control for p.To, p from fields may change
// This is an internal router function, the caller must hold the lock // This is an internal router function, the caller must hold the lock
func (r *R) getControl(fromAddr, toAddr netip.AddrPort, p *udp.Packet) *nebula.Control { func (r *R) getControl(p *udp.Packet) *nebula.Control {
// Key on the address the packet actually left from, a dual stack sender has one per family
fromAddr, toAddr := p.From, p.To
if newAddr, ok := r.outNat[outNatKey{from: fromAddr, to: toAddr}]; ok { if newAddr, ok := r.outNat[outNatKey{from: fromAddr, to: toAddr}]; ok {
p.From = newAddr p.From = newAddr
} }
c, ok := r.inNat[toAddr] c, ok := r.inNat[toAddr]
if ok { if ok {
r.outNat[outNatKey{from: c.GetUDPAddr(), to: fromAddr}] = toAddr // Key the return path on the address the receiver will answer from, which is per family for a dual stack node
r.outNat[outNatKey{from: c.GetUDPAddrFor(fromAddr), to: fromAddr}] = toAddr
return c return c
} }
+177 -567
View File
File diff suppressed because it is too large. Load diff
-20
View File
@@ -234,26 +234,6 @@ punchy:
#trusted_cas: #trusted_cas:
#- "ssh public key string" #- "ssh public key string"
# Local APIs allow accessing running nebula state.
#local_api:
# There are two types of sockets available: a control socket intended for use on the
# local machine, primarily for debugging, and an info socket intended to make
# nebula's internal state available to other consumers.
#
# The control socket is made available by default, and can be accessed via
# `nebula ctl <command>`. It defaults to /var/run/nebula/ctl.sock on Linux, macOS and
# the BSDs; on Windows it is a named pipe under \\.\pipe\ProtectedPrefix\Administrators.
#control:
# Set to false to turn the control socket off. Reloadable.
#enabled: true
# The absolute path where the control socket should live, or a full pipe name on
# Windows. The last directory is created if missing, and must be owned by root or by
# the user running nebula. It must not be writable by anyone else.
#socket: /var/run/nebula/ctl.sock
# A group (or account/group/SID on Windows) that should be allowed to access the
# socket.
#group: nebula
# EXPERIMENTAL: relay support for networks that can't establish direct connections. # EXPERIMENTAL: relay support for networks that can't establish direct connections.
relay: relay:
# Relays are a list of Nebula IP's that peers can use to relay packets to me. # Relays are a list of Nebula IP's that peers can use to relay packets to me.
+3 -17
View File
@@ -206,25 +206,11 @@ func NewFirewallFromConfig(l *slog.Logger, cs *CertState, c *config.C) (*Firewal
panic("No certificate available to reconfigure the firewall") panic("No certificate available to reconfigure the firewall")
} }
tcpTimeout := c.GetDuration("firewall.conntrack.tcp_timeout", time.Minute*12)
udpTimeout := c.GetDuration("firewall.conntrack.udp_timeout", time.Minute*3)
defaultTimeout := c.GetDuration("firewall.conntrack.default_timeout", time.Minute*10)
if tcpTimeout <= 0 {
return nil, fmt.Errorf("firewall.conntrack.tcp_timeout must be greater than 0, got: %s", tcpTimeout)
}
if udpTimeout <= 0 {
return nil, fmt.Errorf("firewall.conntrack.udp_timeout must be greater than 0, got: %s", udpTimeout)
}
if defaultTimeout <= 0 {
return nil, fmt.Errorf("firewall.conntrack.default_timeout must be greater than 0, got: %s", defaultTimeout)
}
fw := NewFirewall( fw := NewFirewall(
l, l,
tcpTimeout, c.GetDuration("firewall.conntrack.tcp_timeout", time.Minute*12),
udpTimeout, c.GetDuration("firewall.conntrack.udp_timeout", time.Minute*3),
defaultTimeout, c.GetDuration("firewall.conntrack.default_timeout", time.Minute*10),
certificate, certificate,
//TODO: max_connections //TODO: max_connections
) )
-25
View File
@@ -58,31 +58,6 @@ func TestNewFirewall(t *testing.T) {
assert.Equal(t, 3602, conntrack.TimerWheel.wheelLen) assert.Equal(t, 3602, conntrack.TimerWheel.wheelLen)
} }
func TestNewFirewall_ZeroOrNegativeTimeout(t *testing.T) {
l := test.NewLogger()
c := &dummyCert{}
cs := &CertState{v2Cert: c, initiatingVersion: cert.Version2}
cases := map[string]string{
"tcp_timeout zero": "firewall:\n conntrack:\n tcp_timeout: 0s\n",
"tcp_timeout negative": "firewall:\n conntrack:\n tcp_timeout: -5s\n",
"udp_timeout zero": "firewall:\n conntrack:\n udp_timeout: 0s\n",
"udp_timeout negative": "firewall:\n conntrack:\n udp_timeout: -5s\n",
"default_timeout zero": "firewall:\n conntrack:\n default_timeout: 0s\n",
"default_timeout negative": "firewall:\n conntrack:\n default_timeout: -5s\n",
}
for name, cfgStr := range cases {
t.Run(name, func(t *testing.T) {
cfg := config.NewC(l)
require.NoError(t, cfg.LoadString(cfgStr))
_, err := NewFirewallFromConfig(l, cs, cfg)
require.Error(t, err, "expected error for non-positive timeout duration")
assert.ErrorContains(t, err, "must be greater than 0")
})
}
}
func TestFirewall_AddRule(t *testing.T) { func TestFirewall_AddRule(t *testing.T) {
ob := &bytes.Buffer{} ob := &bytes.Buffer{}
l := test.NewLoggerWithOutput(ob) l := test.NewLoggerWithOutput(ob)
-1
View File
@@ -6,7 +6,6 @@ require (
dario.cat/mergo v1.0.2 dario.cat/mergo v1.0.2
filippo.io/bigmod v0.1.0 filippo.io/bigmod v0.1.0
github.com/DefinedNet/netlink v1.3.2-dn.1 github.com/DefinedNet/netlink v1.3.2-dn.1
github.com/Microsoft/go-winio v0.6.2
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be
github.com/flynn/noise v1.1.0 github.com/flynn/noise v1.1.0
github.com/gaissmai/bart v0.29.0 github.com/gaissmai/bart v0.29.0
-2
View File
@@ -5,8 +5,6 @@ filippo.io/bigmod v0.1.0 h1:UNzDk7y9ADKST+axd9skUpBQeW7fG2KrTZyOE4uGQy8=
filippo.io/bigmod v0.1.0/go.mod h1:OjOXDNlClLblvXdwgFFOQFJEocLhhtai8vGLy0JCZlI= filippo.io/bigmod v0.1.0/go.mod h1:OjOXDNlClLblvXdwgFFOQFJEocLhhtai8vGLy0JCZlI=
github.com/DefinedNet/netlink v1.3.2-dn.1 h1:Md2PsUE1Xuy1Zxs/Bm6356n1kt5bq2HspXlPJ6pEspg= github.com/DefinedNet/netlink v1.3.2-dn.1 h1:Md2PsUE1Xuy1Zxs/Bm6356n1kt5bq2HspXlPJ6pEspg=
github.com/DefinedNet/netlink v1.3.2-dn.1/go.mod h1:o4YSn8Jw7zoDcYXDmV77TRd4eS5sSLuE+vu2zAN67C8= github.com/DefinedNet/netlink v1.3.2-dn.1/go.mod h1:o4YSn8Jw7zoDcYXDmV77TRd4eS5sSLuE+vu2zAN67C8=
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+62
View File
@@ -264,6 +264,9 @@ type HostInfo struct {
// This is used to limit lighthouse re-queries in chatty clients // This is used to limit lighthouse re-queries in chatty clients
nextLHQuery atomic.Int64 nextLHQuery atomic.Int64
// nextUnreachableProbe is the earliest we will probe our other remotes again after failing to reach the current one
nextUnreachableProbe atomic.Int64
// lastHandshakeTime records the time the remote side told us about at the stage when the handshake was completed locally // lastHandshakeTime records the time the remote side told us about at the stage when the handshake was completed locally
// Stage 1 packet will contain it if I am a responder, stage 2 packet if I am an initiator // Stage 1 packet will contain it if I am a responder, stage 2 packet if I am an initiator
// This is used to avoid an attack where a handshake packet is replayed after some time // This is used to avoid an attack where a handshake packet is replayed after some time
@@ -766,6 +769,65 @@ func (i *HostInfo) TryPromoteBest(preferredRanges []netip.Prefix, ifce *Interfac
} }
} }
// unreachableProbeInterval bounds how often a tunnel whose remote we cannot reach probes its other remotes
const unreachableProbeInterval = time.Second
// remoteUnreachable is called when a send to our current remote failed because we have no route to it, typically
// after moving to a network without that address family. Sends a test packet to every other remote we know for this
// host: the first one that arrives roams the peer over to wherever we are now, and its reply roams us onto that path.
//
// A peer behind a NAT drops a test from an address it has never sent to, so every probe also asks the lighthouse
// about the peer. The lighthouse tells the peer where we are now, the peer punches us, and the next probe gets in.
func (i *HostInfo) remoteUnreachable(ifce *Interface, dead netip.AddrPort) {
if i.remotes == nil || i.ConnectionState == nil || i.GetRemote() != dead {
// Nothing to probe with, or we already moved on from the remote that failed
return
}
if ifce.lightHouse == nil || ifce.lightHouse.amLighthouse {
// A lighthouse hands out the address it reaches a client on, it must not go roaming its clients itself
return
}
now := time.Now().UnixNano()
next := i.nextUnreachableProbe.Load()
if now < next || !i.nextUnreachableProbe.CompareAndSwap(next, now+int64(unreachableProbeInterval)) {
return
}
nb := make([]byte, 12)
out := make([]byte, mtu)
probed := 0
i.remotes.ForEach(ifce.hostMap.GetPreferredRanges(), func(addr netip.AddrPort, _ bool) {
if addr == dead {
return
}
probed++
ifce.sendTo(header.Test, header.TestRequest, i.ConnectionState, i, addr, []byte(""), nb, out)
})
if ifce.l.Enabled(context.Background(), slog.LevelDebug) {
i.logger(ifce.l).Debug("Remote unreachable, probing other remotes",
"udpAddr", dead,
"probed", probed,
)
}
if probed == 0 {
// With nothing else to try, the lighthouse is our only way to learn of another remote. The peer may not have
// one, so ask on the usual requery schedule rather than every probe for as long as the tunnel sits here.
if now < i.nextLHQuery.Load() {
return
}
i.nextLHQuery.Store(now + ifce.reQueryWait.Load())
}
// With other remotes to probe we ask on every probe, without backing off. A repeat re-sends the peer its punch
// notification in case the last one or its punches were lost. If the tunnel stays up on inbound traffic while
// our sends to its remote keep failing (only one direction broken), this continues once a second for as long as
// that lasts. That is a bounded cost for a rare state, and the probe that would clear it has to keep running.
ifce.lightHouse.QueryServer(i.vpnAddrs[0])
}
// Bits within HostInfo.state, everything above stateEpochShift is the epoch // Bits within HostInfo.state, everything above stateEpochShift is the epoch
const ( const (
stateIn uint32 = 1 << iota stateIn uint32 = 1 << iota
+5
View File
@@ -15,6 +15,7 @@ import (
"github.com/slackhq/nebula/overlay/batch" "github.com/slackhq/nebula/overlay/batch"
"github.com/slackhq/nebula/overlay/tio" "github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/routing" "github.com/slackhq/nebula/routing"
"github.com/slackhq/nebula/udp"
) )
func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.ParsedPacket, nb []byte, sendBatch *batch.SendBatch, rejectBuf []byte, q int, localCache firewall.ConntrackCache) { func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.ParsedPacket, nb []byte, sendBatch *batch.SendBatch, rejectBuf []byte, q int, localCache firewall.ConntrackCache) {
@@ -611,6 +612,10 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
"udpAddr", hr, "udpAddr", hr,
) )
} }
// A closing tunnel is about to be torn down, there is no point looking for another path for it
if t != header.CloseTunnel && udp.IsUnreachable(err) {
hostinfo.remoteUnreachable(f, hr)
}
} }
} else { } else {
// Try to send via a relay // Try to send via a relay
+50 -59
View File
@@ -1,6 +1,7 @@
package nebula package nebula
import ( import (
"bytes"
"context" "context"
"crypto/fips140" "crypto/fips140"
"errors" "errors"
@@ -124,8 +125,6 @@ type Interface struct {
// reused (every udp.Conn ListenOut guarantees that ordering). // reused (every udp.Conn ListenOut guarantees that ordering).
batchers []*batch.MultiCoalescer batchers []*batch.MultiCoalescer
wg sync.WaitGroup wg sync.WaitGroup
// readers covers just the listenIn and listenOut goroutines, wg also holds the construction token Close releases
readers sync.WaitGroup
udpTxErrLimiter *ratelimit.Limiter // udp direct transmit error log limiter udpTxErrLimiter *ratelimit.Limiter // udp direct transmit error log limiter
udpRelayTxErrLimiter *ratelimit.Limiter // udp relay transmit error log limiter udpRelayTxErrLimiter *ratelimit.Limiter // udp relay transmit error log limiter
@@ -343,18 +342,14 @@ func (f *Interface) activate() error {
func (f *Interface) run() { func (f *Interface) run() {
// Launch n queues to read packets from udp // Launch n queues to read packets from udp
for i := 0; i < f.routines; i++ { for i := 0; i < f.routines; i++ {
f.readers.Add(1)
f.wg.Go(func() { f.wg.Go(func() {
defer f.readers.Done()
f.listenOut(i) f.listenOut(i)
}) })
} }
// Launch n queues to read packets from tun dev // Launch n queues to read packets from tun dev
for i := 0; i < f.routines; i++ { for i := 0; i < f.routines; i++ {
f.readers.Add(1)
f.wg.Go(func() { f.wg.Go(func() {
defer f.readers.Done()
f.listenIn(f.queues[i], i) f.listenIn(f.queues[i], i)
}) })
} }
@@ -501,7 +496,8 @@ func (f *Interface) listenIn(queue tio.Queue, i int) {
// flushSendBatch drains sb to the underlay and accounts for anything it could not deliver. A shortfall means // flushSendBatch drains sb to the underlay and accounts for anything it could not deliver. A shortfall means
// specific destinations were undeliverable (a stale remote, a reject rule), which the backend logs per peer at // specific destinations were undeliverable (a stale remote, a reject rule), which the backend logs per peer at
// debug; here it is only a counter, so one unreachable peer cannot spam a log line per batch. // debug; here it is only a counter, so one unreachable peer cannot spam a log line per batch. Tunnels whose remote
// we no longer have a route to go looking for another path.
func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) { func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) {
queued := sb.Len() queued := sb.Len()
written, err := sb.Flush() written, err := sb.Flush()
@@ -511,6 +507,44 @@ func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) {
if dropped := queued - written; dropped > 0 { if dropped := queued - written; dropped > 0 {
f.metricTxDropped.Inc(int64(dropped)) f.metricTxDropped.Inc(int64(dropped))
} }
if f.lightHouse == nil || f.lightHouse.amLighthouse {
// Lighthouses never probe, see remoteUnreachable, so skip finding the tunnels
return
}
// A tunnel's packets tend to fail together, so skip straight past a repeat of the one before. The first 8 bytes
// of a header say whose packet it is, the counter after them changes with every packet.
var last batch.Failure
for i, fail := range sb.Failures() {
if i > 0 && fail.Dst == last.Dst && bytes.Equal(fail.Head[:8], last.Head[:8]) {
continue
}
last = fail
if udp.IsUnreachable(fail.Err) {
f.sendUnreachable(fail.Head[:], fail.Dst)
}
}
}
// sendUnreachable finds the tunnel a packet we had no route for was sent on, from the start of the packet, and has it
// look for another path to its peer.
func (f *Interface) sendUnreachable(head []byte, dst netip.AddrPort) {
var h header.H
if h.Parse(head) != nil {
return
}
if h.Type == header.Message && h.Subtype == header.MessageRelay {
// TODO: a relayed packet's header carries the relay session's index, not the relay tunnel's, so it does not
// lead us to the tunnel whose remote failed. The relay tunnel's own traffic finds out soon enough.
return
}
if hostinfo := f.hostMap.QueryReverseIndex(h.RemoteIndex); hostinfo != nil {
hostinfo.remoteUnreachable(f, dst)
}
} }
func (f *Interface) RegisterConfigChangeCallbacks(c *config.C) { func (f *Interface) RegisterConfigChangeCallbacks(c *config.C) {
@@ -689,14 +723,6 @@ func (f *Interface) GetCertState() *CertState {
return f.pki.getCertState() return f.pki.getCertState()
} }
// shutdowner is a udp.Conn or overlay.Device whose readers can be woken without releasing their fds
type shutdowner interface {
Shutdown() error
}
// readerShutdownTimeout bounds how long Close waits on woken readers before releasing their fds anyway
const readerShutdownTimeout = 5 * time.Second
// Close releases the interface's resources: the udp sockets and the tun device. // Close releases the interface's resources: the udp sockets and the tun device.
// It is idempotent and safe to call at any point in the lifecycle, including on an interface that never activated, // It is idempotent and safe to call at any point in the lifecycle, including on an interface that never activated,
// calls after the first return nil without doing anything. // calls after the first return nil without doing anything.
@@ -706,55 +732,20 @@ func (f *Interface) Close() error {
} }
var errs []error var errs []error
closeUdp := func(i int, u udp.Conn) {
if err := u.Close(); err != nil { // Release the udp readers
for i, u := range f.writers {
err := u.Close()
if err != nil {
f.l.Error("Error while closing udp socket", "error", err, "writer", i) f.l.Error("Error while closing udp socket", "error", err, "writer", i)
errs = append(errs, err) errs = append(errs, err)
} }
} }
closeTun := func() {
if err := f.inside.Close(); err != nil {
errs = append(errs, err)
}
}
// Wake every reader before releasing any fd, one that loops back into a syscall on a reused fd number never wakes. // Release the tun device (closing the tun also closes all readers)
// Anything without Shutdown is closed right away, as before. closeErr := f.inside.Close()
var deferred []func() if closeErr != nil {
for i, u := range f.writers { errs = append(errs, closeErr)
if s, ok := u.(shutdowner); ok {
if err := s.Shutdown(); err != nil {
f.l.Error("Error while shutting down udp socket", "error", err, "writer", i)
errs = append(errs, err)
}
deferred = append(deferred, func() { closeUdp(i, u) })
} else {
closeUdp(i, u)
}
}
if s, ok := f.inside.(shutdowner); ok {
if err := s.Shutdown(); err != nil {
errs = append(errs, err)
}
deferred = append(deferred, closeTun)
} else {
closeTun()
}
if len(deferred) > 0 {
readersDone := make(chan struct{})
go func() {
f.readers.Wait()
close(readersDone)
}()
select {
case <-readersDone:
case <-time.After(readerShutdownTimeout):
f.l.Warn("Readers did not stop, closing their fds anyway", "timeout", readerShutdownTimeout)
}
for _, closeFn := range deferred {
closeFn()
}
} }
// Release the construction token so waiters know the resources are gone // Release the construction token so waiters know the resources are gone
-79
View File
@@ -1,79 +0,0 @@
package localapi
import (
"errors"
"fmt"
"os"
)
// Access is who may reach a socket beyond the account nebula runs as: the node's mode,
// and the group that shares the socket when the config names one.
//
// It is the dockerd model (-G): the operator names a group, nebula hands the socket to
// it, and who is in the group is managed outside nebula. On unix the mode is the
// socket node's and the group becomes its owning group; on windows the group is an
// entry in the pipe's security descriptor and the mode means nothing to a pipe.
type Access struct {
Mode os.FileMode
Group Group
}
// Group is a group named in the config, resolved to what the platform checks. The zero
// Group is none.
type Group struct {
// Name is what the config said.
Name string
// ID is the platform's identifier for it: a gid on unix, a SID on windows.
ID string
}
const (
// ownerOnlyMode is a socket's mode when no group shares it: the account nebula runs
// as, and nobody else.
ownerOnlyMode os.FileMode = 0600
// groupSocketMode is the mode a socket takes when a group shares it and the config
// names no other: the account nebula runs as and the group, and nobody else.
groupSocketMode os.FileMode = 0660
)
// errReopenForAccess is returned by applyAccess on a platform whose access control is
// fixed when the endpoint is created, so a change means creating it again.
var errReopenForAccess = errors.New("access is fixed at listen time")
// ownerOnly is the control socket's access when no group is configured. The mode
// itself is not configurable there; what an operator can choose is a group,
// CtlGroupKey, which makes it groupSocketMode.
func ownerOnly() Access { return Access{Mode: ownerOnlyMode} }
// shared reports whether a group shares the socket.
func (a Access) shared() bool { return a.Group.ID != "" }
// String renders the access for a log line.
func (a Access) String() string {
if !a.shared() {
return modeString(a.Mode)
}
return fmt.Sprintf("%s group %s (%s)", modeString(a.Mode), a.Group.Name, a.Group.ID)
}
// groupFromConfig reads the group a key names, the zero Group when it names none. The
// name is resolved here, when the config is read, so a group that does not exist is a
// config error reported with the key rather than a bind that fails later.
func groupFromConfig(c interface{ GetString(string, string) string }, key string) (Group, error) {
name := c.GetString(key, "")
if name == "" {
return Group{}, nil
}
id, err := lookupGroupID(name)
if err != nil {
return Group{}, fmt.Errorf("%s: %w", key, err)
}
return Group{Name: name, ID: id}, nil
}
func modeString(m os.FileMode) string {
return fmt.Sprintf("%04o", m)
}
-176
View File
@@ -1,176 +0,0 @@
//go:build !windows
package localapi
import (
"context"
"os"
"os/user"
"strconv"
"syscall"
"testing"
"github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// ownGroup returns a group this process may hand a socket to: its own effective group,
// by name and by gid, which is the one chown accepts from an unprivileged user.
func ownGroup(t *testing.T) (name, gid string) {
t.Helper()
gid = strconv.Itoa(os.Getegid())
g, err := user.LookupGroupId(gid)
require.NoError(t, err)
return g.Name, gid
}
func socketGroup(t *testing.T, path string) uint32 {
t.Helper()
fi, err := os.Lstat(path)
require.NoError(t, err)
st, ok := fi.Sys().(*syscall.Stat_t)
require.True(t, ok)
return uint32(st.Gid)
}
// TestLookupGroupID: a group is named as the host names it or by its gid; a gid the
// host does not list is accepted as chown would accept it, and a name it does not list
// is a mistake to report.
func TestLookupGroupID(t *testing.T) {
name, gid := ownGroup(t)
got, err := lookupGroupID(name)
require.NoError(t, err)
assert.Equal(t, gid, got)
got, err = lookupGroupID(gid)
require.NoError(t, err)
assert.Equal(t, gid, got)
got, err = lookupGroupID("4000000000")
require.NoError(t, err)
assert.Equal(t, "4000000000", got)
_, err = lookupGroupID("no-such-group-nebula-test")
require.ErrorContains(t, err, "does not exist")
}
// TestControlAccessFromConfig: no group is the owner-only socket; a group is 0660 with
// that group; a group the host does not know is a config error naming the key.
func TestControlAccessFromConfig(t *testing.T) {
name, gid := ownGroup(t)
load := func(body string) (Access, error) {
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString(body))
return controlAccessFrom(c)
}
acc, err := load("local_api: {}\n")
require.NoError(t, err)
assert.Equal(t, ownerOnly(), acc)
acc, err = load("local_api:\n control:\n group: " + name + "\n")
require.NoError(t, err)
assert.Equal(t, os.FileMode(0660), acc.Mode)
assert.Equal(t, name, acc.Group.Name)
assert.Equal(t, gid, acc.Group.ID)
_, err = load("local_api:\n control:\n group: no-such-group-nebula-test\n")
require.ErrorContains(t, err, CtlGroupKey)
assert.ErrorContains(t, err, "does not exist")
}
// TestControlSocketIsHandedToTheGroup: the socket is created with the group's gid and
// 0660, whatever the umask, and a reload that takes the group away tightens the socket
// in place, without moving it.
func TestControlSocketIsHandedToTheGroup(t *testing.T) {
old := unix.Umask(0077)
defer unix.Umask(old)
name, gid := ownGroup(t)
want, err := strconv.ParseUint(gid, 10, 32)
require.NoError(t, err)
s := NewServer(test.NewLogger(), basicRegistry())
path := testSocket(t)
require.NoError(t, s.Rebind(context.Background(), path, Access{Mode: 0660, Group: Group{Name: name, ID: gid}}))
defer s.Stop()
fi, err := os.Lstat(path)
require.NoError(t, err)
assert.Equal(t, os.FileMode(0660), fi.Mode().Perm())
assert.Equal(t, uint32(want), socketGroup(t, path))
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
fi, err = os.Lstat(path)
require.NoError(t, err)
assert.Equal(t, os.FileMode(0600), fi.Mode().Perm())
assert.Equal(t, path, s.Path())
_, err = (&Client{Path: path}).Describe()
require.NoError(t, err, "the same listener is still serving")
}
// TestControlSocketWithAGroupTrustsTheKernel: with a group sharing the socket, the
// kernel's check on connect is the access control and the daemon's peer check stands
// aside, so a connection the peer check alone would refuse is served. Without a group
// the same connection is refused; see TestPeerCheckRefusesAnotherUser.
func TestControlSocketWithAGroupTrustsTheKernel(t *testing.T) {
if !peerCheckSupported {
t.Skip("no peer credentials on this platform")
}
name, gid := ownGroup(t)
me := currentUID()
asUID(t, me+1)
s := NewServer(test.NewLogger(), basicRegistry())
asUID(t, me)
path := testSocket(t)
require.NoError(t, s.Rebind(context.Background(), path, Access{Mode: 0660, Group: Group{Name: name, ID: gid}}))
defer s.Stop()
_, err := (&Client{Path: path}).Describe()
require.NoError(t, err, "the socket's group admitted us; the peer check must not refuse")
// Taking the group away on a reload puts the peer check back.
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
_, err = (&Client{Path: path}).Describe()
require.ErrorContains(t, err, "not permitted")
}
// TestRemovingTheGroupHandsTheSocketBack: a reload that drops the group key leaves the
// mode the operator set but returns the socket to the daemon's own group, so the old
// group's members are no longer admitted. The socket is first handed to a group this
// process belongs to other than its own, which not every host offers.
func TestRemovingTheGroupHandsTheSocketBack(t *testing.T) {
own := os.Getegid()
groups, err := os.Getgroups()
require.NoError(t, err)
other := -1
for _, g := range groups {
if g != own {
other = g
break
}
}
if other < 0 {
t.Skip("this process belongs to no group but its own")
}
gid := strconv.Itoa(other)
s := NewServer(test.NewLogger(), basicRegistry())
path := testSocket(t)
require.NoError(t, s.Rebind(context.Background(), path, Access{Mode: 0660, Group: Group{Name: gid, ID: gid}}))
defer s.Stop()
assert.Equal(t, uint32(other), socketGroup(t, path))
require.NoError(t, s.Rebind(context.Background(), path, Access{Mode: 0660}))
assert.Equal(t, uint32(own), socketGroup(t, path), "the daemon's own group again")
fi, err := os.Lstat(path)
require.NoError(t, err)
assert.Equal(t, os.FileMode(0660), fi.Mode().Perm(), "the mode is the operator's")
}
-44
View File
@@ -1,44 +0,0 @@
//go:build windows
package localapi
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/windows"
)
// TestLookupGroupIDOnWindows: an account name resolves to its SID, a SID written out
// is accepted as it is, and an account the host does not know is reported.
func TestLookupGroupIDOnWindows(t *testing.T) {
users, err := windows.CreateWellKnownSid(windows.WinBuiltinUsersSid)
require.NoError(t, err)
got, err := lookupGroupID("Users")
require.NoError(t, err)
assert.Equal(t, users.String(), got)
got, err = lookupGroupID(users.String())
require.NoError(t, err)
assert.Equal(t, users.String(), got)
_, err = lookupGroupID("no-such-account-nebula-test")
require.ErrorContains(t, err, "does not exist")
}
// TestSDDLAdmitsTheGroup: the descriptor is the owner, SYSTEM and Administrators with
// full access, plus the group with what a client needs and nothing generic, so a
// member cannot create an instance of the pipe; see pipeClientAccess.
func TestSDDLAdmitsTheGroup(t *testing.T) {
sddl, err := sddlFor(ownerOnly())
require.NoError(t, err)
assert.NotContains(t, sddl, "S-1-5-32-545")
sddl, err = sddlFor(Access{Mode: groupSocketMode, Group: Group{Name: "Users", ID: "S-1-5-32-545"}})
require.NoError(t, err)
assert.Contains(t, sddl, "(A;;GA;;;SY)(A;;GA;;;BA)(A;;0x120083;;;S-1-5-32-545)")
assert.Zero(t, pipeClientAccess&windows.FILE_APPEND_DATA, "FILE_APPEND_DATA is FILE_CREATE_PIPE_INSTANCE on a pipe")
assert.Zero(t, pipeClientAccess&(windows.GENERIC_READ|windows.GENERIC_WRITE|windows.GENERIC_ALL))
}
-163
View File
@@ -1,163 +0,0 @@
package localapi
import (
"encoding/json"
"errors"
"fmt"
"io"
"net"
"time"
"github.com/slackhq/nebula/commands"
)
// DialTimeout bounds the connect to a socket that exists but is not being served.
const DialTimeout = 5 * time.Second
// ResponseTimeout bounds the exchange once connected: sending the request and waiting
// for the daemon's answer. The daemon drops a client that is slow to send in 10s and one
// that is slow to read in 30s, so this is the other side of the same bargain, with room
// for the slowest command (a hostmap dump on a large network) before a stalled daemon is
// given up on. Client.Timeout overrides it.
const ResponseTimeout = 60 * time.Second
// MaxResponseBytes bounds what a client will read back. A response carries one command's
// output, and a hostmap dump on a large network is the realistic worst case.
const MaxResponseBytes = 64 << 20
// Client talks to a nebula listening at Path.
type Client struct {
Path string
// Timeout bounds the request and response once connected. Zero means
// ResponseTimeout.
Timeout time.Duration
}
// ReplyError is an answer the client could not read: the daemon was reached and wrote
// something back, but not a response this client understands. The daemon is not
// nebula, or not a version this client speaks to.
type ReplyError struct {
Err error
}
func (e *ReplyError) Error() string { return "the daemon's reply could not be read: " + e.Err.Error() }
func (e *ReplyError) Unwrap() error { return e.Err }
// DaemonError is a refusal the daemon answered with: the connection worked, the request
// was read, and the daemon said no. It is told apart from a failure to reach the daemon
// so that a client does not send its user after a socket path, or a sudo, when the daemon
// was right there and answered. A protocol version the daemon does not speak, a socket at
// its connection limit and a peer the daemon will not serve all arrive as one of these.
type DaemonError struct {
Msg string
}
func (e *DaemonError) Error() string { return e.Msg }
// Describe asks the daemon which commands it serves and what parameters they take, so a
// client can offer them without having been built against this daemon.
func (c *Client) Describe() ([]commands.CommandSchema, error) {
res, err := c.do(&Request{Version: ProtocolVersion, Describe: true})
if err != nil {
return nil, err
}
if res.Error != "" {
return nil, &DaemonError{Msg: res.Error}
}
schema := []commands.CommandSchema{}
if err := json.Unmarshal(res.Result, &schema); err != nil {
return nil, &ReplyError{Err: fmt.Errorf("could not parse the command schema: %w", err)}
}
return schema, nil
}
// Invoke runs one command and returns what the daemon said. params are the command's
// options by name, as the strings a command line parsed them from; a program speaking
// the protocol directly may send JSON's own types instead, see Request.Params. An empty
// format asks for JSON, which is the API's default; "text" asks the daemon to apply the
// command's own human rendering.
func (c *Client) Invoke(command string, params map[string]string, args []string, format string) (*Response, error) {
var wire map[string]any
if len(params) > 0 {
wire = make(map[string]any, len(params))
for k, v := range params {
wire[k] = v
}
}
return c.do(&Request{
Version: ProtocolVersion,
Command: command,
Params: wire,
Args: args,
Format: format,
})
}
// do sends one request and reads the one response.
//
// Nothing is checked about the socket before the connect: its mode is the kernel's to
// enforce, and a socket that is not ours to connect to is refused there with a
// permission error, which the caller turns into advice.
func (c *Client) do(req *Request) (*Response, error) {
conn, err := dial(c.Path, DialTimeout)
if err != nil {
return nil, err
}
defer conn.Close()
// Without this a daemon that accepts and then stalls, blocked inside a command or
// stopped with SIGSTOP, hangs the client for good, and a script wrapping it never
// completes. One deadline covers the write and the read: the answer is due within
// the budget, however the time is spent.
timeout := c.Timeout
if timeout <= 0 {
timeout = ResponseTimeout
}
_ = conn.SetDeadline(time.Now().Add(timeout))
// If we get a write error, save that fact but then look for a response from the server.
// Some error conditions manifest as the server accepting our connection, writing an
// error, and then closing the connection. Our write races against that close.
writeErr := error(nil)
if err := writeFrame(conn, req); err != nil {
writeErr = fmt.Errorf("could not send request: %w", err)
}
res, err := readResponse(conn)
if err != nil {
// Something answered and it was not a response: the daemon was reached, and
// that is the message even when it hung up before the request was written,
// which a daemon that is not nebula is likely to do.
var fe *frameError
if errors.As(err, &fe) {
return nil, &ReplyError{Err: err}
}
if writeErr != nil {
return nil, writeErr
}
var ne net.Error
if errors.As(err, &ne) && ne.Timeout() {
return nil, fmt.Errorf("the daemon did not answer within %s", timeout)
}
return nil, err
}
return res, nil
}
func readResponse(conn net.Conn) (*Response, error) {
res := &Response{}
if err := readFrame(conn, MaxResponseBytes, "response", res, false); err != nil {
if errors.Is(err, io.EOF) {
return nil, errors.New("the daemon closed the connection without answering")
}
return nil, err
}
return res, nil
}
-39
View File
@@ -1,39 +0,0 @@
//go:build !windows
package localapi
import (
"fmt"
"os"
"os/user"
"strconv"
)
// lookupGroupID resolves a group's name, or a numeric gid, to the gid as a string. A
// gid that the group database does not list is accepted as chown would accept it: the
// operator may be naming a group the host will learn about later, or one that only a
// directory service knows.
func lookupGroupID(name string) (string, error) {
if g, err := user.LookupGroup(name); err == nil {
return g.Gid, nil
}
if _, err := strconv.ParseUint(name, 10, 32); err == nil {
return name, nil
}
return "", fmt.Errorf("group %q does not exist on this host", name)
}
// gidFor returns the gid the socket is owned by under acc: the configured group's, or
// the daemon's own effective group when none is configured.
func gidFor(acc Access) (int, error) {
if !acc.shared() {
return os.Getegid(), nil
}
gid, err := strconv.ParseUint(acc.Group.ID, 10, 32)
if err != nil {
return 0, fmt.Errorf("group %q resolved to %q, which is not a gid", acc.Group.Name, acc.Group.ID)
}
return int(gid), nil
}
-30
View File
@@ -1,30 +0,0 @@
//go:build windows
package localapi
import (
"fmt"
"strings"
"golang.org/x/sys/windows"
)
// lookupGroupID resolves an account name, local or domain qualified, or a SID written
// out, to the SID as a string, which is how the pipe's security descriptor names it.
// Any account the host can resolve is accepted, as docker accepts any SID for its -G: a
// group is the natural thing to name, but the descriptor does not care.
func lookupGroupID(name string) (string, error) {
if strings.HasPrefix(strings.ToUpper(name), "S-1-") {
sid, err := windows.StringToSid(name)
if err != nil {
return "", fmt.Errorf("%q is not a SID: %w", name, err)
}
return sid.String(), nil
}
sid, _, _, err := windows.LookupSID("", name)
if err != nil {
return "", fmt.Errorf("account %q does not exist on this host: %w", name, err)
}
return sid.String(), nil
}
-58
View File
@@ -1,58 +0,0 @@
package localapi
// DirName is the directory under /var/run that holds nebula's sockets by default.
const DirName = "nebula"
// CtlEnabledKey is the optional config key that turns the control socket off. It is on
// unless the config says false, and reloadable: a reload that turns it off removes the
// socket, and one that turns it back on brings it up again.
const CtlEnabledKey = "local_api.control.enabled"
// ControlEnabled reports whether a config leaves the control socket on. nebula ctl reads
// it too, so a client pointed at a config that turned the socket off says so rather than
// failing to dial.
func ControlEnabled(c interface{ GetBool(string, bool) bool }) bool {
return c.GetBool(CtlEnabledKey, true)
}
// CtlSocketKey is the optional config key naming the control socket. Unset, the socket
// is DefaultSocketPath, one fixed path per platform that both the daemon and nebula ctl
// know, which is what lets the endpoint work with no configuration on either side. It
// suits a daemon running as root, which is what the tun device needs anyway. A daemon run as another user, or a second daemon on
// one host, names its own. The CLI reads the same key, so when both sides see the same
// config file they agree on the socket with nothing more said.
const CtlSocketKey = "local_api.control.socket"
// CtlGroupKey is the optional config key naming a group that shares the control socket.
// Unset, the socket admits the account nebula runs as and nobody else. Set, the socket
// is handed to the group, 0660 on unix and an entry in the pipe's security descriptor on
// windows; see Access and Server.trustSocket.
const CtlGroupKey = "local_api.control.group"
// controlAccessFrom returns the control socket's access a config implies: the group
// CtlGroupKey names, if any, and the mode that goes with having one or not.
func controlAccessFrom(c interface{ GetString(string, string) string }) (Access, error) {
group, err := groupFromConfig(c, CtlGroupKey)
if err != nil {
return Access{}, err
}
if group.ID == "" {
return ownerOnly(), nil
}
return Access{Mode: groupSocketMode, Group: group}, nil
}
// SocketPathFromConfig returns the control socket path a config implies: CtlSocketKey
// when it is set, else DefaultSocketPath. A configured path must be absolute, so that
// the daemon and nebula ctl, started from wherever the operator happens to be, name the
// same socket from one config, and one this platform can bind; see checkSocketPath.
func SocketPathFromConfig(c interface{ GetString(string, string) string }) (string, error) {
override := c.GetString(CtlSocketKey, "")
if override == "" {
return DefaultSocketPath, nil
}
if err := checkSocketPath(CtlSocketKey, override); err != nil {
return "", err
}
return override, nil
}
-52
View File
@@ -1,52 +0,0 @@
//go:build !windows
package localapi
import (
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type fakeConfig map[string]string
func (f fakeConfig) GetString(k, d string) string {
if v, ok := f[k]; ok {
return v
}
return d
}
// TestSocketPathFromConfigUsesTheDefault is what makes the endpoint work with no
// configuration: the daemon and the CLI both land on the one fixed path.
func TestSocketPathFromConfigUsesTheDefault(t *testing.T) {
p, err := SocketPathFromConfig(fakeConfig{})
require.NoError(t, err)
assert.Equal(t, "/var/run/nebula/ctl.sock", p)
assert.Equal(t, DefaultSocketPath, p)
}
func TestSocketPathFromConfigHonoursOverride(t *testing.T) {
p, err := SocketPathFromConfig(fakeConfig{CtlSocketKey: "/tmp/custom.sock"})
require.NoError(t, err)
assert.Equal(t, "/tmp/custom.sock", p, "the path is used as given")
}
// TestSocketPathFromConfigRefusesARelativeOverride: the daemon and the CLI are started
// from different directories, so a relative path would name two sockets from one config.
// It is refused rather than resolved against anything.
func TestSocketPathFromConfigRefusesARelativeOverride(t *testing.T) {
for _, rel := range []string{"run/ctl.sock", "./ctl.sock", "ctl.sock", "../ctl.sock"} {
_, err := SocketPathFromConfig(fakeConfig{CtlSocketKey: rel})
require.Error(t, err, rel)
require.ErrorContains(t, err, "must be an absolute path", rel)
assert.ErrorContains(t, err, CtlSocketKey, rel)
}
}
func TestSocketPathFromConfigRejectsOverlongOverride(t *testing.T) {
_, err := SocketPathFromConfig(fakeConfig{CtlSocketKey: "/" + strings.Repeat("x", sunPathMax)})
assert.ErrorContains(t, err, "too long for this platform")
}
-25
View File
@@ -1,25 +0,0 @@
//go:build darwin || freebsd
package localapi
import (
"net"
"golang.org/x/sys/unix"
)
// peerCheckSupported reports that this platform can identify a connecting process.
const peerCheckSupported = true
// peerUID returns the uid of the process on the other end of conn.
func peerUID(conn net.Conn) (uid uint32, err error) {
err = withPeerFD(conn, func(fd int) error {
xu, credErr := unix.GetsockoptXucred(fd, unix.SOL_LOCAL, unix.LOCAL_PEERCRED)
if credErr != nil {
return credErr
}
uid = xu.Uid
return nil
})
return uid, err
}
-25
View File
@@ -1,25 +0,0 @@
//go:build linux
package localapi
import (
"net"
"golang.org/x/sys/unix"
)
// peerCheckSupported reports that this platform can identify a connecting process.
const peerCheckSupported = true
// peerUID returns the uid of the process on the other end of conn.
func peerUID(conn net.Conn) (uid uint32, err error) {
err = withPeerFD(conn, func(fd int) error {
cred, credErr := unix.GetsockoptUcred(fd, unix.SOL_SOCKET, unix.SO_PEERCRED)
if credErr != nil {
return credErr
}
uid = cred.Uid
return nil
})
return uid, err
}
-62
View File
@@ -1,62 +0,0 @@
//go:build netbsd
package localapi
import (
"encoding/binary"
"fmt"
"net"
"unsafe"
"golang.org/x/sys/unix"
)
const peerCheckSupported = true
// NetBSD reports the peer's identity through LOCAL_PEEREID at the SOL_LOCAL level,
// filling a `struct unpcbid { pid_t unp_pid; uid_t unp_euid; gid_t unp_egid; }`.
// golang.org/x/sys/unix has no typed wrapper for it, so the getsockopt goes out by hand
// exactly the way that package's own generated wrappers do on this platform.
const (
solLocal = 0
localPeerEID = 0x0003
unpcbidSize = 12
unpcbidEUIDOffs = 4
)
// peerUID returns the uid of the process on the other end of conn.
//
// Anything unexpected here is an error rather than a default, so a wrong constant or an
// unsupported kernel refuses connections instead of silently admitting them.
func peerUID(conn net.Conn) (uid uint32, err error) {
err = withPeerFD(conn, func(fd int) error {
var (
buf [unpcbidSize]byte
size = uint32(unpcbidSize)
)
_, _, errno := unix.Syscall6(
unix.SYS_GETSOCKOPT,
uintptr(fd),
uintptr(solLocal),
uintptr(localPeerEID),
uintptr(unsafe.Pointer(&buf[0])),
uintptr(unsafe.Pointer(&size)),
0,
)
if errno != 0 {
return errno
}
if size != unpcbidSize {
return fmt.Errorf("LOCAL_PEEREID returned %d bytes, expected %d", size, unpcbidSize)
}
// Read, not cast: the buffer is bytes, and a cast would fault on an
// architecture that wants the uint32 aligned.
uid = binary.NativeEndian.Uint32(buf[unpcbidEUIDOffs:])
return nil
})
return uid, err
}
-34
View File
@@ -1,34 +0,0 @@
//go:build openbsd
package localapi
import (
"net"
"golang.org/x/sys/unix"
)
// peerCheckSupported reports that this platform can identify a connecting process.
const peerCheckSupported = true
// peerUID returns the uid of the process on the other end of conn.
//
// OpenBSD reports the peer through SO_PEERCRED at SOL_SOCKET, filling a
// `struct sockpeercred { uid_t uid; gid_t gid; pid_t pid; }`. System calls here have to
// go through libc, so the raw getsockopt netbsd uses is not an option, and
// golang.org/x/sys/unix has no typed wrapper for this struct. It does export
// GetsockoptInt, which goes through its libc trampoline with a 4 byte buffer, and the
// kernel copies out min(caller's length, option length): the first four bytes, which are
// the uid. That is a dependence on the field order, the same one netbsd's offset carries.
func peerUID(conn net.Conn) (uid uint32, err error) {
err = withPeerFD(conn, func(fd int) error {
v, credErr := unix.GetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_PEERCRED)
if credErr != nil {
return credErr
}
// A uid_t is 32 bits; GetsockoptInt read exactly that many and widened it.
uid = uint32(v)
return nil
})
return uid, err
}
-20
View File
@@ -1,20 +0,0 @@
//go:build windows
package localapi
import (
"errors"
"net"
)
// peerCheckSupported is false where the connecting process is not identified separately.
//
// On windows there is nothing to add: the pipe's security descriptor already admits
// only the account nebula runs as, which is the check, not a second opinion on it.
const peerCheckSupported = false
var errNoPeerCheck = errors.New("peer credentials are not available on this platform")
func peerUID(conn net.Conn) (uint32, error) {
return 0, errNoPeerCheck
}
-302
View File
@@ -1,302 +0,0 @@
//go:build !windows
package localapi
import (
"errors"
"fmt"
"net"
"os"
"os/user"
"path/filepath"
"strconv"
"sync"
"syscall"
"time"
)
const network = "unix"
// withPeerFD runs f on the descriptor behind conn, which must be a unix socket, and
// returns whichever error came first: not a unix socket, no raw access to it, or f's
// own. It is the scaffolding every platform's peerUID shares; only the getsockopt inside
// differs.
func withPeerFD(conn net.Conn, f func(fd int) error) error {
uc, ok := conn.(*net.UnixConn)
if !ok {
return fmt.Errorf("not a unix connection")
}
raw, err := uc.SyscallConn()
if err != nil {
return err
}
var inner error
if err := raw.Control(func(fd uintptr) { inner = f(int(fd)) }); err != nil {
return err
}
return inner
}
// currentUID is the user the owner checks are made for. A variable so a test can stand
// in for root, or for a stranger, without owning a second account on the host.
var currentUID = func() uint32 { return uint32(os.Geteuid()) }
// listen binds the socket at path with the given access.
//
// Access control is the socket's own mode and group, which the node is created no
// looser than and which are set after bind, together with the peer check the server
// applies on accept unless a group shares the socket, in which case the kernel's check
// is the whole of it: connect(2) needs write permission on the socket file on every
// unix we build for.
//
// The directory is not part of that, and is never chmoded: a directory a service
// manager made for us is served from at whatever mode it came with (systemd's
// RuntimeDirectoryMode= is 0755 by default), and one an operator pointed us into keeps
// whatever else it holds readable. The one we make ourselves is 0755, searchable by
// everyone, so that a nebula ctl run as another user reaches the socket and gets the
// kernel's answer, which for a member of the configured group is a connection and for
// anyone else is permission denied.
func listen(path string, acc Access) (net.Listener, error) {
// The kernel silently truncates an over long sun_path and bind then fails with
// "invalid argument", which tells an operator nothing. Say what is actually wrong.
if pathTooLong(path) {
return nil, fmt.Errorf("socket path is %d bytes, over the %d byte limit for a unix socket: %s", len(path), maxSocketPath, path)
}
dir := filepath.Dir(path)
// One level only. Every directory defaultPathFor offers sits directly under one that
// exists, and an operator who names a deeper path creates it; a missing parent is a
// mistake to report, not a tree to build. A directory made here stays when the
// socket goes: an empty one costs nothing, and the next start wants it again.
//
// The mode comes from the umask around the call, never from a chmod afterwards: a
// chmod by path could land on whatever somebody who can write the parent swapped in
// between the two calls, and a chmod through a descriptor on a root-owned directory
// they moved there, since root owns both. Born 0755 there is nothing to fix up.
// The umask is process wide and the window is one syscall; see umaskMu.
umaskMu.Lock()
old := syscall.Umask(0022)
err := os.Mkdir(dir, 0755)
syscall.Umask(old)
umaskMu.Unlock()
if err != nil && !errors.Is(err, os.ErrExist) {
return nil, fmt.Errorf("could not create %s: %w", dir, err)
}
// Whether it was made here or came with the environment, the directory has to be
// one nobody else could change; see checkSocketDir.
if err := checkSocketDir(dir); err != nil {
return nil, err
}
if err := clearStale(path); err != nil {
return nil, err
}
// bind creates the socket node at the process umask, and a connect(2) between that
// and a later chmod would be queued for accept. Tighten the umask around the bind so
// the node is never looser than 0600, however briefly; see umaskMu.
umaskMu.Lock()
old = syscall.Umask(0077)
ln, err := net.Listen(network, path)
syscall.Umask(old)
umaskMu.Unlock()
if err != nil {
return nil, err
}
// The node at path is given up by release, which unlinks it before the listener
// closes; see there for why the order matters. Go's listener would unlink on Close
// as well, and an unlink after the close could only be of whatever bound the path
// next, so that is turned off and release is the one place the node is removed.
if ul, ok := ln.(*net.UnixListener); ok {
ul.SetUnlinkOnClose(false)
}
// The umask only promises no looser than 0600; this pins the mode and the group
// exactly, and is the one place a failure to secure the socket is reported.
if err := applyAccess(path, acc); err != nil {
release(ln, path)
return nil, fmt.Errorf("could not secure %s: %w", path, err)
}
return ln, nil
}
// applyAccess sets the owning group and the mode of the socket node at path. With no
// group configured the socket is handed back to the daemon's own group, so taking the
// key out of the config on a reload takes the access away as surely as a restart would.
// The chown is Lchown, so a link at the path is not followed to its target.
func applyAccess(path string, acc Access) error {
gid, err := gidFor(acc)
if err != nil {
return err
}
if err := os.Lchown(path, -1, gid); err != nil {
return err
}
return os.Chmod(path, acc.Mode.Perm())
}
// checkSocketDir refuses to serve from a directory that somebody other than the user
// nebula runs as, or root, could change. The socket's mode and group say who may connect
// to it; what makes the path they connect to the daemon's is the directory, since
// whoever can write it can put a socket of their own at the path and answer the clients
// in the daemon's place. So the directory must be owned by the daemon's user or by root
// and writable by its owner alone; a sticky bit is not an exception. A runtime directory
// a service manager made for another user, or /var/run/nebula created ahead of a root
// daemon by a member of group daemon, where darwin lets that group write /var/run, are
// both refused with the owner named.
//
// A link where the directory should be is judged twice: whoever owns the link decides
// where the path leads, so the link must be ours or root's too, and the directory it
// resolves to is then held to the rule above. /var/run is such a link on linux, root's,
// to /run, and a socket named directly under it is served; a link somebody else planted
// is refused as theirs.
//
// Only this directory is checked, not the ones above it. /var/run itself is group
// writable on darwin by design, and the parents are the operator's to trust, as they are
// for every file nebula reads. The check is made at bind, so a directory loosened while
// the daemon runs is noticed at the next reload.
func checkSocketDir(dir string) error {
fi, err := os.Lstat(dir)
if err != nil {
return err
}
if fi.Mode()&os.ModeSymlink != 0 {
if uid, ok := owner(fi); ok && uid != currentUID() && uid != 0 {
return fmt.Errorf("%s is a symlink owned by %s, not by the user nebula runs as or by root, and its owner decides where the path leads; name a socket path that does not go through it", dir, describeUID(uid))
}
if fi, err = os.Stat(dir); err != nil {
return err
}
}
if !fi.IsDir() {
return fmt.Errorf("%s is not a directory", dir)
}
if uid, ok := owner(fi); ok && uid != currentUID() && uid != 0 {
return fmt.Errorf("%s is owned by %s, not by the user nebula runs as or by root, and its owner could replace the socket; make it ours or root's, or name a socket path in a directory that is", dir, describeUID(uid))
}
if perm := fi.Mode().Perm(); perm&0022 != 0 {
who := "its group"
if perm&0002 != 0 {
who = "everyone"
}
return fmt.Errorf("%s is writable by %s (mode %04o), who could replace the socket; make it writable by its owner alone, or name a socket path in a directory that is", dir, who, perm)
}
return nil
}
// owner returns the uid that owns the file fi describes.
func owner(fi os.FileInfo) (uint32, bool) {
st, ok := fi.Sys().(*syscall.Stat_t)
if !ok {
return 0, false
}
return uint32(st.Uid), true
}
// describeUID renders a uid with its account name when the host can say what it is, so
// a message about somebody else's socket tells the operator who that is.
func describeUID(uid uint32) string {
id := strconv.FormatUint(uint64(uid), 10)
if u, err := user.LookupId(id); err == nil && u.Username != "" {
return "uid " + id + " (" + u.Username + ")"
}
return "uid " + id
}
// clearStale removes a leftover socket file, but only after proving nothing is
// listening on it. An unclean restart leaves one behind every time, so this is a
// routine path; blindly unlinking would let a second daemon steal a live endpoint.
//
// Liveness is a plain connect. Only a refused connect proves there is nothing behind
// the file. Anything else, a timeout or a permission error, is a socket we cannot vouch
// for, and it is left alone with the reason in the error.
func clearStale(path string) error {
fi, err := os.Stat(path)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
if !isSocket(fi) {
return fmt.Errorf("%s exists and is not a socket", path)
}
conn, err := dial(path, 250*time.Millisecond)
if err == nil {
_ = conn.Close()
return fmt.Errorf("%s is already in use by another nebula instance", path)
}
if errors.Is(err, os.ErrNotExist) {
// Gone between the stat and the connect; nothing to clear.
return nil
}
if !errors.Is(err, syscall.ECONNREFUSED) {
return fmt.Errorf("%s exists and could not be shown to be stale, refusing to remove it: %w", path, err)
}
return os.Remove(path)
}
// removeSocket unlinks the socket node. Its directory stays, whoever made it; see
// listen.
func removeSocket(path string) {
_ = os.Remove(path)
}
func dial(path string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout(network, path, timeout)
}
// sunPathMax is the smallest sun_path any platform we build for offers (104 on darwin,
// 108 on linux). Overrunning it truncates the path rather than failing cleanly, so we
// check against the tighter bound everywhere.
const sunPathMax = 104
// maxSocketPath is the longest path that actually binds. sun_path holds the trailing
// NUL as well, and Go's syscall package refuses a path that fills the whole buffer
// with a bare EINVAL, so the usable limit is one byte short of the buffer.
const maxSocketPath = sunPathMax - 1
// umaskMu serialises the two places the process umask is set around one syscall: the
// umask is process wide, and two endpoints binding at once, a reload landing during
// startup, would otherwise interleave their save and restore and leave the daemon's
// umask at one of ours. It is held for the syscall alone. Another goroutine creating a
// file in that moment gets the umask of the window, 0022 or 0077, rather than the
// process's own; nothing creates files on a hot path.
var umaskMu sync.Mutex
func pathTooLong(path string) bool { return len(path) > maxSocketPath }
// DefaultSocketPath is the control socket when the config names none. It is root's to
// create, as the tun device is root's to open; a daemon run as anyone else names a path
// of its own with CtlSocketKey.
const DefaultSocketPath = "/var/run/" + DirName + "/ctl.sock"
// checkSocketPath refuses a configured socket path that is relative, or too long to
// bind. A relative path would mean a different socket to the daemon and to nebula ctl,
// each resolving it against the directory it happened to be started from.
func checkSocketPath(key, value string) error {
if !filepath.IsAbs(value) {
return fmt.Errorf("%s must be an absolute path, got %q", key, value)
}
if pathTooLong(value) {
return fmt.Errorf("%s is %d bytes, too long for this platform: %s", key, len(value), value)
}
return nil
}
func isSocket(fi os.FileInfo) bool { return fi.Mode()&os.ModeSocket != 0 }
-358
View File
@@ -1,358 +0,0 @@
//go:build !windows
package localapi
import (
"bufio"
"context"
"net"
"os"
"path/filepath"
"strings"
"syscall"
"testing"
"time"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// privateBase returns a short directory of our own, 0700, for tests to lay sockets out
// under, short enough that a path under it fits sun_path.
func privateBase(t *testing.T) string {
t.Helper()
return test.ShortTempDir(t)
}
// openDir returns a world writable directory under base, the shape of /tmp.
func openDir(t *testing.T, base string) string {
t.Helper()
open := filepath.Join(base, "open")
require.NoError(t, os.Mkdir(open, 0777))
require.NoError(t, os.Chmod(open, 0777|os.ModeSticky))
return open
}
// TestListenLeavesAServiceManagersDirectoryAlone covers the directory a service manager
// pre-creates: systemd's RuntimeDirectory is 0755 by default. The socket is 0600, which
// is what refuses other users, so the directory is served from as it came and nothing
// is chmoded that the operator did not set.
func TestListenLeavesAServiceManagersDirectoryAlone(t *testing.T) {
base := privateBase(t)
dir := filepath.Join(base, DirName)
require.NoError(t, os.Mkdir(dir, 0755))
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(context.Background(), filepath.Join(dir, "s.sock"), ownerOnly()))
t.Cleanup(s.Stop)
fi, err := os.Stat(dir)
require.NoError(t, err)
assert.Equal(t, os.FileMode(0755), fi.Mode().Perm(), "the directory is left exactly as it was")
fi, err = os.Stat(s.Path())
require.NoError(t, err)
assert.Equal(t, os.FileMode(0600), fi.Mode().Perm(), "the socket is what is private")
_, err = (&Client{Path: s.Path()}).Describe()
require.NoError(t, err)
}
// TestListenCreatesOneLevelOnly: the socket directory is created when it is missing,
// but nothing above it is. A runtime directory that does not exist is the operator's to
// provide, and the failure says which directory could not be created.
func TestListenCreatesOneLevelOnly(t *testing.T) {
base := privateBase(t)
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(context.Background(), filepath.Join(base, DirName, "s.sock"), ownerOnly()))
s.Stop()
dir := filepath.Join(base, "missing", DirName)
err := s.Rebind(context.Background(), filepath.Join(dir, "s.sock"), ownerOnly())
require.Error(t, err)
require.ErrorContains(t, err, "could not create "+dir)
assert.NoDirExists(t, filepath.Join(base, "missing"))
}
// TestListenRestoresTheUmask: listen tightens the process umask around bind so the socket
// node is never created looser than 0600. That is process wide state, so it must come
// back exactly as it was, on success and on failure alike.
func TestListenRestoresTheUmask(t *testing.T) {
old := syscall.Umask(0022)
t.Cleanup(func() { syscall.Umask(old) })
base := privateBase(t)
ln, err := listen(filepath.Join(base, DirName, "s.sock"), ownerOnly())
require.NoError(t, err)
t.Cleanup(func() { ln.Close() })
assert.Equal(t, 0022, syscall.Umask(0022), "umask after a successful listen")
_, err = listen(filepath.Join(base, DirName, "s.sock"), ownerOnly())
require.Error(t, err, "the path is already bound")
assert.Equal(t, 0022, syscall.Umask(0022), "umask after a failed listen")
}
// TestListenServesFromASharedDirectory: an operator who points local_api.control.socket
// into a directory holding other files, /etc/nebula say, gets a socket there and keeps
// the config and certs readable by everyone who could read them before.
func TestListenServesFromASharedDirectory(t *testing.T) {
base := privateBase(t)
dir := filepath.Join(base, "etc-nebula")
require.NoError(t, os.Mkdir(dir, 0755))
cfg := filepath.Join(dir, "config.yml")
require.NoError(t, os.WriteFile(cfg, []byte("{}\n"), 0644))
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(context.Background(), filepath.Join(dir, "ctl.sock"), ownerOnly()))
t.Cleanup(s.Stop)
fi, err := os.Stat(dir)
require.NoError(t, err)
assert.Equal(t, os.FileMode(0755), fi.Mode().Perm())
fi, err = os.Stat(cfg)
require.NoError(t, err)
assert.Equal(t, os.FileMode(0644), fi.Mode().Perm())
}
func TestOverlongPathIsDiagnosed(t *testing.T) {
long := filepath.Join(os.TempDir(), string(make([]byte, 0)))
for len(long) <= sunPathMax {
long = filepath.Join(long, "abcdefghij")
}
s := NewServer(test.NewLogger(), basicRegistry())
err := s.Rebind(context.Background(), filepath.Join(long, "s.sock"), ownerOnly())
require.Error(t, err)
assert.ErrorContains(t, err, "byte limit for a unix socket")
}
// TestPathLimitIsExact pins the boundary: sun_path has room for the NUL as well, and Go
// refuses a path that fills the whole buffer, so the last usable length is one short.
func TestPathLimitIsExact(t *testing.T) {
assert.False(t, pathTooLong(strings.Repeat("a", maxSocketPath)))
assert.True(t, pathTooLong(strings.Repeat("a", maxSocketPath+1)))
assert.True(t, pathTooLong(strings.Repeat("a", sunPathMax)))
}
// TestNamedPathIsUsedAsGiven: a path the operator named is served from, and dialed,
// wherever it is, a directory other users can write to included; the socket's own mode
// is what keeps them out.
func TestNamedPathIsUsedAsGiven(t *testing.T) {
base := privateBase(t)
path := filepath.Join(openDir(t, base), DirName, "s.sock")
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
t.Cleanup(s.Stop)
_, err := (&Client{Path: path}).Describe()
require.NoError(t, err)
}
// TestStaleSocketIsCleared: a dead socket in a good directory is the routine leftover of
// a hard kill, and the daemon's stale check must see it as free to replace.
func TestStaleSocketIsCleared(t *testing.T) {
path := testSocket(t)
require.NoError(t, os.Mkdir(filepath.Dir(path), 0700))
ln, err := net.Listen(network, path)
require.NoError(t, err)
require.NoError(t, os.Chmod(path, 0600))
// Close the listener but keep the file, the way a hard kill does.
ln.(*net.UnixListener).SetUnlinkOnClose(false)
require.NoError(t, ln.Close())
_, statErr := os.Stat(path)
require.NoError(t, statErr, "the socket file is still there")
require.NoError(t, clearStale(path), "a stale socket is cleared, not reported as in use")
_, statErr = os.Stat(path)
assert.True(t, os.IsNotExist(statErr))
}
// TestClientSaysWhenTheReplyCannotBeRead: something answered on the socket, but not
// with a response. That is reported as a reply that could not be read, which is what
// it is, and not as a failure to reach the daemon, whether the other side read the
// request first or hung up on it: a daemon that is not nebula may do either.
func TestClientSaysWhenTheReplyCannotBeRead(t *testing.T) {
for _, readsFirst := range []bool{true, false} {
path := testSocket(t)
require.NoError(t, os.Mkdir(filepath.Dir(path), 0700))
ln, err := net.Listen(network, path)
require.NoError(t, err)
require.NoError(t, os.Chmod(path, 0600))
go func() {
c, err := ln.Accept()
if err != nil {
return
}
if readsFirst {
_, _ = bufio.NewReader(c).ReadBytes('\n')
}
_, _ = c.Write([]byte("this is not a response\n"))
c.Close()
}()
_, err = (&Client{Path: path}).Describe()
var unread *ReplyError
require.ErrorAs(t, err, &unread, "reads first: %v", readsFirst)
assert.Contains(t, err.Error(), "the daemon's reply could not be read")
ln.Close()
}
}
// TestClientGivesUpOnASilentDaemon: a daemon that accepts and then never answers must
// not hang the client for good. A script wrapping nebula ctl has no other way out.
func TestClientGivesUpOnASilentDaemon(t *testing.T) {
path := testSocket(t)
require.NoError(t, os.Mkdir(filepath.Dir(path), 0700))
ln, err := net.Listen(network, path)
require.NoError(t, err)
defer ln.Close()
require.NoError(t, os.Chmod(path, 0600))
accepted := make(chan net.Conn, 1)
go func() {
c, err := ln.Accept()
if err == nil {
accepted <- c // held open, never written to
}
}()
start := time.Now()
_, err = (&Client{Path: path, Timeout: 200 * time.Millisecond}).Describe()
require.Error(t, err)
require.ErrorContains(t, err, "did not answer within")
assert.Less(t, time.Since(start), 5*time.Second)
select {
case c := <-accepted:
_ = c.Close()
default:
}
}
// asUID makes the owner checks run as uid for the rest of the test. The socket the test
// serves is still owned by the real user, so from uid's point of view it belongs to
// somebody else: the shape of a service account's daemon, and of an impostor's.
func asUID(t *testing.T, uid uint32) {
t.Helper()
real := currentUID
currentUID = func() uint32 { return uid }
t.Cleanup(func() { currentUID = real })
}
// TestPeerCheckRefusesAnotherUser: a server built as one user and serving as another
// refuses the real user at the peer check, and the refusal reaches the client as the
// daemon's answer rather than as a failure to reach it.
func TestPeerCheckRefusesAnotherUser(t *testing.T) {
if !peerCheckSupported {
t.Skip("no peer credentials on this platform")
}
me := currentUID()
asUID(t, me+1)
s := NewServer(test.NewLogger(), basicRegistry())
asUID(t, me)
path := testSocket(t)
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
defer s.Stop()
_, err := (&Client{Path: path}).Describe()
require.Error(t, err)
require.ErrorContains(t, err, "not permitted")
var refused *DaemonError
assert.ErrorAs(t, err, &refused, "the daemon answered; this is not a reachability failure")
}
// TestListenerDoesNotUnlinkOnClose: the server unlinks its socket node itself, before
// the listener closes, and the listener must not unlink again afterwards. By the time a
// close happens the path may belong to a newer daemon that found the node stale and
// bound its own, and a second unlink would take that daemon's socket from under it.
func TestListenerDoesNotUnlinkOnClose(t *testing.T) {
path := filepath.Join(privateBase(t), DirName, "s.sock")
old, err := listen(path, ownerOnly())
require.NoError(t, err)
// A newer daemon's start, with the old node gone and the path bound afresh.
require.NoError(t, os.Remove(path))
next, err := net.Listen(network, path)
require.NoError(t, err)
t.Cleanup(func() { next.Close() })
require.NoError(t, old.Close())
_, err = os.Stat(path)
assert.NoError(t, err, "closing the old listener left the newer daemon's socket in place")
}
// TestListenRefusesADirectoryOthersCanWrite: whoever can write the socket's directory
// can put a socket of their own at the path and answer the clients, who trust the path;
// so a directory writable by its group or by everyone is refused, and nothing is bound.
func TestListenRefusesADirectoryOthersCanWrite(t *testing.T) {
for _, mode := range []os.FileMode{0775, 0757, 0777, 01777} {
dir := filepath.Join(privateBase(t), "loose")
require.NoError(t, os.Mkdir(dir, mode))
require.NoError(t, os.Chmod(dir, mode))
_, err := listen(filepath.Join(dir, "s.sock"), ownerOnly())
require.ErrorContains(t, err, "writable by", "mode %04o", mode)
assert.NoFileExists(t, filepath.Join(dir, "s.sock"))
}
}
// TestListenRefusesADirectoryOwnedBySomebodyElse: a directory that is neither ours nor
// root's is refused, since its owner could replace the socket. The test's own directory
// stands in for somebody else's by the process pretending to be another user.
func TestListenRefusesADirectoryOwnedBySomebodyElse(t *testing.T) {
me := currentUID()
if me == 0 {
t.Skip("root's directories are accepted whoever is asking")
}
dir := filepath.Join(privateBase(t), "theirs")
require.NoError(t, os.Mkdir(dir, 0755))
asUID(t, me+1)
_, err := listen(filepath.Join(dir, "s.sock"), ownerOnly())
require.ErrorContains(t, err, "is owned by")
assert.NoFileExists(t, filepath.Join(dir, "s.sock"))
asUID(t, me)
ln, err := listen(filepath.Join(dir, "s.sock"), ownerOnly())
require.NoError(t, err, "the same directory, seen as our own, serves")
release(ln, filepath.Join(dir, "s.sock"))
}
// TestListenThroughASymlinkedDirectory: a link where the directory should be is judged
// by who owns it, since they decide where the path leads, and then by the directory it
// resolves to. Our own link to a proper directory serves, as /var/run on linux is root's
// link to /run; somebody else's link is refused, and so is a link of ours to a directory
// others can write.
func TestListenThroughASymlinkedDirectory(t *testing.T) {
me := currentUID()
if me == 0 {
t.Skip("root's links are accepted whoever is asking")
}
base := privateBase(t)
real := filepath.Join(base, "real")
require.NoError(t, os.Mkdir(real, 0755))
link := filepath.Join(base, "link")
require.NoError(t, os.Symlink(real, link))
path := filepath.Join(link, "s.sock")
ln, err := listen(path, ownerOnly())
require.NoError(t, err, "our link to our directory")
release(ln, path)
assert.NoFileExists(t, filepath.Join(real, "s.sock"))
asUID(t, me+1)
_, err = listen(path, ownerOnly())
require.ErrorContains(t, err, "is a symlink owned by")
asUID(t, me)
require.NoError(t, os.Chmod(real, 0777))
_, err = listen(path, ownerOnly())
require.ErrorContains(t, err, "writable by everyone")
}
-255
View File
@@ -1,255 +0,0 @@
//go:build windows
package localapi
import (
"context"
"errors"
"fmt"
"net"
"strings"
"time"
"github.com/Microsoft/go-winio"
"golang.org/x/sys/windows"
)
// pipePrefix is where windows named pipes live. The pipe's own security descriptor
// carries the access control that the socket's mode carries on unix.
const pipePrefix = `\\.\pipe\`
// protectedPrefix is the pipe namespace that only administrators and SYSTEM may create
// names under; the kernel refuses everyone else. The default name lives there, so the
// name itself says who could have created the pipe answering it: no ordinary user can
// have put anything under it ahead of the daemon. Tailscale, WireGuard and NetBird keep
// their daemon pipes there for the same reason. nebula on windows is already an
// administrator, since creating the tun adapter requires it.
const protectedPrefix = pipePrefix + `ProtectedPrefix\Administrators\`
const network = "pipe"
// currentUID is the identity the unix owner checks are made for. There is no uid here
// and no per-connection check that would read one, so the value is never consulted; it
// exists so a Server is built the same way on every platform.
var currentUID = func() uint32 { return 0 }
// listen creates the named pipe at path with a security descriptor that admits the user
// nebula runs as, SYSTEM and Administrators, and the group acc names, if any, for
// reading and writing, which is what connecting to a pipe takes. acc's mode means
// nothing to a pipe.
//
// The first instance is created, never opened, so a name some other process already
// holds is refused rather than joined: that process would otherwise answer clients in
// nebula's place. Under protectedPrefix only an administrator could hold it; anywhere
// else any account could. Either way the refusal is reported as errEndpointHeld for the
// caller to log as the event it is, except when the refusal is the namespace's own: a
// daemon that is not an administrator cannot create under protectedPrefix at all, and
// that is told apart so the operator is sent to elevate or to name a pipe elsewhere
// rather than to look for a process that is not there.
func listen(path string, acc Access) (net.Listener, error) {
sddl, err := sddlFor(acc)
if err != nil {
return nil, fmt.Errorf("could not build a security descriptor for %s: %w", path, err)
}
ln, err := winio.ListenPipe(path, &winio.PipeConfig{
SecurityDescriptor: sddl,
InputBufferSize: int32(MaxRequestBytes),
OutputBufferSize: 64 * 1024,
})
if err != nil {
return nil, listenRefused(path, isAdministrator(), err)
}
return ln, nil
}
// listenRefused turns a failure to create the pipe at path into the error the caller
// logs. admin says whether this process may create under protectedPrefix.
//
// ERROR_ACCESS_DENIED is ambiguous: it is what the kernel says to a non-administrator
// creating under protectedPrefix, and also what an existing instance whose DACL does
// not admit us says to a second create. A process that is an administrator cannot be
// getting the first, so for it, and for every name outside the prefix, access denied
// means held.
func listenRefused(path string, admin bool, err error) error {
if errors.Is(err, windows.ERROR_ACCESS_DENIED) && isProtectedPath(path) && !admin {
return fmt.Errorf("creating %s requires an administrator, as only administrators may create pipes under %s; run nebula elevated, or set %s to a pipe name outside it: %w", path, protectedPrefix, CtlSocketKey, err)
}
if errors.Is(err, windows.ERROR_ALREADY_EXISTS) || errors.Is(err, windows.ERROR_ACCESS_DENIED) {
return fmt.Errorf("%w: %s: %w", errEndpointHeld, path, err)
}
return err
}
// isProtectedPath says whether path is a name under protectedPrefix. Pipe names are
// case insensitive, so the comparison is too.
func isProtectedPath(path string) bool {
return len(path) > len(protectedPrefix) && strings.EqualFold(path[:len(protectedPrefix)], protectedPrefix)
}
// isAdministrator says whether this process holds Administrators as an enabled group,
// which is what creating under protectedPrefix takes. SYSTEM holds it; an elevated
// administrator holds it; an administrator's unelevated token carries it deny-only,
// which the membership check correctly reads as no. The membership is checked against
// the thread's own token: CheckTokenMembership wants an impersonation token and makes
// one from the primary token when handed none. A check that cannot be made is read as
// not an administrator, which only changes the wording of a failure that has already
// happened.
func isAdministrator() bool {
admins, err := windows.CreateWellKnownSid(windows.WinBuiltinAdministratorsSid)
if err != nil {
return false
}
member, err := windows.Token(0).IsMember(admins)
return err == nil && member
}
// sddlFor grants full access to the account nebula is running as, to SYSTEM and to
// Administrators, and pipeClientAccess to the group acc names, if any; nobody else. P
// makes the DACL protected, so it does not inherit entries that would widen it. It is
// dockerd's descriptor for its pipe, with its -G group in the same place, except for
// the group's mask; see pipeClientAccess.
//
// Administrators is the counterpart of the uid 0 allowance in the unix peer check. The
// service normally runs as LocalSystem, so without it an operator in an elevated shell
// could not reach the daemon at all; and an administrator can already stop the service,
// so this grants no authority they did not have.
func sddlFor(acc Access) (string, error) {
token := windows.GetCurrentProcessToken()
user, err := token.GetTokenUser()
if err != nil {
return "", err
}
sddl := fmt.Sprintf("D:P(A;;GA;;;%s)(A;;GA;;;SY)(A;;GA;;;BA)", user.User.Sid.String())
if acc.shared() {
sddl += fmt.Sprintf("(A;;0x%x;;;%s)", pipeClientAccess, acc.Group.ID)
}
return sddl, nil
}
// pipeClientAccess is what a client needs on the pipe to talk to the daemon, and all a
// configured group is granted: read and write the data, read the pipe's attributes
// and its security descriptor, which the owner check needs, and wait on it. Not the
// generic rights. On a named pipe GENERIC_WRITE carries FILE_CREATE_PIPE_INSTANCE, the
// right to put a second instance under the same name, and a group member with that
// could sit on the name and answer other clients in the daemon's place; the client's
// owner check would not catch it, since the instance it reached would be the
// member's. A client therefore has to ask for exactly this, as dial does, and a
// program that opens the info pipe with generic read and write is refused.
const pipeClientAccess uint32 = windows.FILE_READ_DATA | windows.FILE_WRITE_DATA |
windows.FILE_READ_ATTRIBUTES | windows.READ_CONTROL | windows.SYNCHRONIZE
// applyAccess cannot change a pipe's access in place: its security descriptor is fixed
// when it is created, so a change means creating it again, which the caller does.
func applyAccess(path string, acc Access) error { return errReopenForAccess }
// removeSocket is a no-op: a named pipe disappears when its last handle closes, so
// there is nothing to unlink and no stale instance to clean up.
func removeSocket(path string) {}
// dial connects to the pipe and, before the connection carries anything, checks who
// serves it. The request names a command and its arguments, so it must not reach a
// pipe that some other account put under nebula's name. For the default name the
// namespace already promises that, since only an administrator could have created it;
// the check is what covers a CtlSocketKey override outside protectedPrefix, and costs
// nothing to make on every name.
func dial(path string, timeout time.Duration) (net.Conn, error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
conn, err := winio.DialPipeAccess(ctx, path, pipeClientAccess)
if err != nil {
return nil, err
}
if err := checkPipeOwner(conn, path); err != nil {
conn.Close()
return nil, err
}
return conn, nil
}
// checkPipeOwner refuses a pipe whose owner is not an account that could be running
// nebula. It is the unix owner check made from the other side: the handle winio dialed
// exposes the pipe object, and the object's owner is whoever created it.
//
// The owner is what makes this sound. An account can only create an object owned by
// itself, or by a SID it holds with the owner flag, unless it has SeRestorePrivilege,
// which ordinary users do not; so a pipe owned by SYSTEM, Administrators or a service
// account was put there by one of them, and never by a user squatting the name. winio
// dials with SECURITY_ANONYMOUS, so the impostor could not have impersonated the client
// either, but it could have read the command and answered it with whatever it liked.
func checkPipeOwner(conn net.Conn, path string) error {
h, ok := conn.(interface{ Fd() uintptr })
if !ok {
return fmt.Errorf("%s: cannot identify who serves the pipe", path)
}
sd, err := windows.GetSecurityInfo(windows.Handle(h.Fd()), windows.SE_KERNEL_OBJECT, windows.OWNER_SECURITY_INFORMATION)
if err != nil {
return fmt.Errorf("%s: could not read the pipe's owner: %w", path, err)
}
owner, _, err := sd.Owner()
if err != nil {
return fmt.Errorf("%s: could not read the pipe's owner: %w", path, err)
}
if owner == nil {
return fmt.Errorf("%s has no owner; refusing to send to it", path)
}
me, err := windows.GetCurrentProcessToken().GetTokenUser()
if err != nil {
return fmt.Errorf("%s: could not read own identity: %w", path, err)
}
if ownerAccepted(owner, me.User.Sid) {
return nil
}
return fmt.Errorf("%s is served by %s, not by nebula; run nebula ctl as that user, or pass -config or -socket to name the daemon's pipe", path, describeSID(owner))
}
// ownerAccepted says whether a pipe owned by owner may be sent a request by a client
// running as me: the client's own account, and the two accounts a daemon runs under
// that no ordinary user can create an object as, SYSTEM and Administrators. Another
// account is refused, whoever the client is; the daemon's DACL decides who may connect,
// and this decides who may answer.
func ownerAccepted(owner, me *windows.SID) bool {
return owner.Equals(me) ||
owner.IsWellKnown(windows.WinLocalSystemSid) ||
owner.IsWellKnown(windows.WinBuiltinAdministratorsSid)
}
// describeSID renders a SID with its account name when the host can say what it is, so
// a message about somebody else's pipe tells the operator who that is.
func describeSID(sid *windows.SID) string {
account, domain, _, err := sid.LookupAccount("")
if err != nil || account == "" {
return sid.String()
}
if domain == "" {
return account
}
return domain + `\` + account
}
// DefaultSocketPath is the control pipe when the config names none. It is under
// protectedPrefix, so whatever answers it was created by an administrator or SYSTEM; see
// there.
const DefaultSocketPath = protectedPrefix + "nebula-ctl"
// checkSocketPath refuses a configured name that is not a full pipe name. A pipe lives
// under pipePrefix and nowhere else, so a bare name has no meaning here, and one under
// pipePrefix is used as given. An override outside protectedPrefix is a name any
// account could have created first; the owner check in dial is what protects a client
// of one.
func checkSocketPath(key, value string) error {
if len(value) <= len(pipePrefix) || !strings.EqualFold(value[:len(pipePrefix)], pipePrefix) {
return fmt.Errorf(`%s must be a full pipe name under %s, got %q`, key, pipePrefix, value)
}
return nil
}
-186
View File
@@ -1,186 +0,0 @@
//go:build windows
package localapi
import (
"errors"
"net"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/windows"
)
// TestOwnerAccepted pins which accounts may answer a nebula ctl request: the client's
// own, and the accounts a daemon runs as that an ordinary user cannot create an object
// owned by. Any other user is refused, since any user can create any pipe name.
func TestOwnerAccepted(t *testing.T) {
me, err := windows.GetCurrentProcessToken().GetTokenUser()
require.NoError(t, err)
wellKnown := func(typ windows.WELL_KNOWN_SID_TYPE) *windows.SID {
sid, err := windows.CreateWellKnownSid(typ)
require.NoError(t, err)
return sid
}
parse := func(s string) *windows.SID {
sid, err := windows.StringToSid(s)
require.NoError(t, err)
return sid
}
accepted := map[string]*windows.SID{
"self": me.User.Sid,
"SYSTEM": wellKnown(windows.WinLocalSystemSid),
"Administrators": wellKnown(windows.WinBuiltinAdministratorsSid),
}
for name, sid := range accepted {
assert.True(t, ownerAccepted(sid, me.User.Sid), name)
}
refused := map[string]*windows.SID{
"Everyone": wellKnown(windows.WinWorldSid),
"Users": wellKnown(windows.WinBuiltinUsersSid),
"another user": parse("S-1-5-21-1-2-3-1001"),
"a service's own account": parse("S-1-5-80-1-2-3-4-5"),
"LocalService": wellKnown(windows.WinLocalServiceSid),
}
for name, sid := range refused {
assert.False(t, ownerAccepted(sid, me.User.Sid), name)
}
}
// TestDefaultPathIsProtected pins the default name to the namespace only administrators
// and SYSTEM can create under, which is what lets nebula ctl trust the default name
// from its spelling alone.
func TestDefaultPathIsProtected(t *testing.T) {
p := DefaultSocketPath
assert.True(t, isProtectedPath(p), p)
assert.Equal(t, `\\.\pipe\ProtectedPrefix\Administrators\nebula-ctl`, p)
}
// TestConfiguredPipeNameMustBeFull: a configured name is used as given, and only a full
// pipe name means anything here.
func TestConfiguredPipeNameMustBeFull(t *testing.T) {
p, err := SocketPathFromConfig(fakeWinConfig{CtlSocketKey: `\\.\pipe\nebula-ctl`})
require.NoError(t, err)
assert.Equal(t, `\\.\pipe\nebula-ctl`, p)
for _, bad := range []string{"nebula-ctl", `C:\nebula\ctl.sock`, `\\.\pipe\`} {
_, err := SocketPathFromConfig(fakeWinConfig{CtlSocketKey: bad})
require.Error(t, err, bad)
assert.ErrorContains(t, err, "full pipe name", bad)
}
}
type fakeWinConfig map[string]string
func (f fakeWinConfig) GetString(k, d string) string {
if v, ok := f[k]; ok {
return v
}
return d
}
func TestIsProtectedPath(t *testing.T) {
assert.True(t, isProtectedPath(`\\.\pipe\ProtectedPrefix\Administrators\nebula-1`))
assert.True(t, isProtectedPath(`\\.\pipe\protectedprefix\administrators\nebula-1`), "pipe names are case insensitive")
assert.False(t, isProtectedPath(`\\.\pipe\ProtectedPrefix\Administrators\`), "the prefix alone names nothing")
assert.False(t, isProtectedPath(`\\.\pipe\nebula-1`))
assert.False(t, isProtectedPath(`\\.\pipe\ProtectedPrefix\Users\nebula-1`))
}
// TestListenRefused pins how a failed create is reported. Access denied under the
// protected prefix is the namespace refusing a non-administrator, and says so; the same
// error for an administrator, or for any name outside the prefix, is a name some other
// process holds, and is errEndpointHeld so the daemon logs it as an error.
func TestListenRefused(t *testing.T) {
protected := `\\.\pipe\ProtectedPrefix\Administrators\nebula-1`
plain := `\\.\pipe\nebula-1`
err := listenRefused(protected, false, windows.ERROR_ACCESS_DENIED)
assert.NotErrorIs(t, err, errEndpointHeld)
assert.ErrorIs(t, err, windows.ERROR_ACCESS_DENIED)
assert.Contains(t, err.Error(), "requires an administrator")
assert.Contains(t, err.Error(), CtlSocketKey)
assert.ErrorIs(t, listenRefused(protected, true, windows.ERROR_ACCESS_DENIED), errEndpointHeld)
assert.ErrorIs(t, listenRefused(plain, false, windows.ERROR_ACCESS_DENIED), errEndpointHeld)
assert.ErrorIs(t, listenRefused(protected, false, windows.ERROR_ALREADY_EXISTS), errEndpointHeld)
assert.ErrorIs(t, listenRefused(plain, true, windows.ERROR_ALREADY_EXISTS), errEndpointHeld)
other := errors.New("something else")
assert.Same(t, other, listenRefused(protected, false, other))
}
// TestListenProtectedName creates and dials a name under the protected prefix. It needs
// an administrator, and otherwise checks only that the refusal is the one listen
// promises a non-administrator.
func TestListenProtectedName(t *testing.T) {
path := protectedPrefix + "nebula-test-" + t.Name()
ln, err := listen(path, ownerOnly())
if !isAdministrator() {
require.Error(t, err)
assert.Contains(t, err.Error(), "requires an administrator")
t.Skip("not an administrator; the protected namespace refused the create as it should")
}
require.NoError(t, err)
t.Cleanup(func() { ln.Close() })
accepted := make(chan error, 1)
go func() {
conn, err := ln.Accept()
if err == nil {
conn.Close()
}
accepted <- err
}()
conn, err := dial(path, time.Second)
require.NoError(t, err)
conn.Close()
require.NoError(t, <-accepted)
}
// TestDialAcceptsOwnPipe dials a pipe this process created outside the protected
// prefix, as an override might name, which the owner check must pass: the pipe's owner
// is this account, or Administrators when the test is elevated.
func TestDialAcceptsOwnPipe(t *testing.T) {
path := pipePrefix + "nebula-test-" + t.Name()
ln, err := listen(path, ownerOnly())
require.NoError(t, err)
t.Cleanup(func() { ln.Close() })
accepted := make(chan error, 1)
go func() {
conn, err := ln.Accept()
if err == nil {
conn.Close()
}
accepted <- err
}()
conn, err := dial(path, time.Second)
require.NoError(t, err)
conn.Close()
require.NoError(t, <-accepted)
}
// TestListenRefusesHeldName pins that a name another listener already holds is refused
// with errEndpointHeld rather than joined, which is what keeps an impostor from being
// served alongside, or in place of, the daemon.
func TestListenRefusesHeldName(t *testing.T) {
path := pipePrefix + "nebula-test-" + t.Name()
first, err := listen(path, ownerOnly())
require.NoError(t, err)
t.Cleanup(func() { first.Close() })
var second net.Listener
second, err = listen(path, ownerOnly())
if second != nil {
second.Close()
}
require.ErrorIs(t, err, errEndpointHeld)
}
-167
View File
@@ -1,167 +0,0 @@
// Package localapi serves the nebula command registry over a local IPC endpoint so the
// user who ran nebula can inspect and control it from a CLI on the same machine.
//
// Access is the socket's own: without a group it is 0600 to the user who ran nebula,
// and the server checks the peer's credentials on every connection besides; with a
// group configured it is 0660 to that group, and the kernel's check on connect is the
// whole of it, so a member has the same control of the daemon as its user. Every
// command in the registry is served; nothing is filtered on either side.
//
// # Protocol
//
// One JSON object in, one JSON object out, both newline terminated. It is an API, not a
// command line: a request names a command and passes its options as named parameters,
// rather than shipping an argv the daemon has to parse. A client that is itself a CLI
// asks for the schema first (Request.Describe) and turns the user's flags into those
// parameters; a client that is not need never think in flags at all.
package localapi
import (
"bufio"
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
)
// ProtocolVersion is the version of the request and response envelopes. A client sending
// a version this server does not know gets a sentence back rather than a parse error,
// which matters because the daemon and the CLI are upgraded independently.
const ProtocolVersion = 1
// MaxRequestBytes bounds the request. A request names a command and its parameters, so it
// has no business being large, and an unbounded read is a way for a local process to
// consume memory the packet path needs.
const MaxRequestBytes = 64 * 1024
// Request is the single JSON object a client sends.
type Request struct {
Version int `json:"version"`
// Describe asks for the schema of every command this surface serves, in place of
// running one. Command, Params and Args are ignored.
Describe bool `json:"describe,omitempty"`
// Command names the command to run.
Command string `json:"command,omitempty"`
// Params carries the command's options by name, with JSON's own types, true rather
// than "true", 3 rather than "3", or as the strings a command line parsed them from,
// which is what nebula ctl sends. Unknown names are an error, so a typo is reported
// instead of ignored. The schema lists json and pretty on every command because the
// command lines take them; here they are refused, since Format is how a request
// chooses its rendering.
Params map[string]any `json:"params,omitempty"`
// Args carries the command's operands, the values that are not options: the vpn
// address `print-tunnel` prints, for instance. They stay positional because the
// commands do not name them.
Args []string `json:"args,omitempty"`
// Format asks for a rendering other than the default. "" and "json" return the
// command's result as a JSON value, which is what a program wants. "text" asks the
// daemon to run the command's own human rendering and return it as a string, which is
// how `nebula ctl` shows an operator the same output the ssh server would.
Format string `json:"format,omitempty"`
}
// Response is the single JSON object a server sends back.
type Response struct {
Version int `json:"version"`
// Result is what a request for JSON produced: the command's value, or the schema
// when the request was a Describe, as a JSON value, so a caller reads it directly
// instead of parsing a string that happens to contain JSON.
//
// Whitespace inside a JSON result is not preserved: an envelope normalises it, and
// in an API it carries no meaning anyway. Formatting a result for a human to read is
// the client's job.
Result json.RawMessage `json:"result,omitempty"`
// Text is what a request for text produced: the command's own human rendering, the
// bytes it wrote and nothing else. They travel as bytes, base64 in the envelope,
// rather than as a JSON string, because a string is UTF-8 and the rendering need
// not be: a name from a certificate is whatever the certificate holds, and the ssh
// server passes it through, so this does too.
Text []byte `json:"text,omitempty"`
// Error explains a failure in a sentence, and is absent on success. It is the only
// signal a caller needs: there is no separate status field, because a command that
// failed always says why and one that succeeded never does. A command line client
// turns its presence into a non-zero exit.
//
// A command that ran and refused sets Error too, alongside its Result when the
// caller asked for JSON. That is how a refusal and a request that never ran are
// told apart: the first has both, the second has Error alone.
Error string `json:"error,omitempty"`
}
// frameError is a frame that arrived and was not one: oversized, or not the JSON object
// the protocol defines. It is told from a failed read so the client can say the daemon
// answered with something it could not read, rather than that it could not be reached.
type frameError struct{ err error }
func (e *frameError) Error() string { return e.err.Error() }
func (e *frameError) Unwrap() error { return e.err }
// readFrame reads one frame, a newline terminated JSON object, from r into v. With
// writeFrame it is where the framing rule lives, for both directions: a frame is a
// single line, a line over max bytes is refused rather than buffered, and a final line
// with no newline before EOF still counts. what names the frame in errors ("request", "response"); a
// read failure is returned wrapped, so a caller can still see io.EOF or a timeout in it.
// strict refuses a field v does not declare, which is the daemon's reading of a request:
// a client that misspells one deserves to hear about it, as it does for a parameter.
// The client reads a response leniently, so a field a newer daemon adds is passed over
// rather than fatal.
func readFrame(r io.Reader, max int, what string, v any, strict bool) error {
br := bufio.NewReader(io.LimitReader(r, int64(max)+1))
line, err := br.ReadBytes('\n')
if err != nil && (len(line) == 0 || !errors.Is(err, io.EOF)) {
// EOF after a partial line is the unterminated final line the rule allows, and
// an oversized line looks the same once the LimitReader cuts it off, so both go
// on to be judged by their length. Anything else is a failed read, whatever was
// buffered first: a deadline that lands mid frame is a timeout, not a parse
// error in half a document.
return fmt.Errorf("could not read %s: %w", what, err)
}
// The limit is on the body, not the frame, so the terminator does not count
// against it. A body that exceeds max is cut off by the LimitReader before its
// newline, so a missing terminator is also what an oversized line looks like.
body := bytes.TrimSuffix(line, []byte{'\n'})
if len(body) > max {
return &frameError{fmt.Errorf("%s exceeded %d bytes", what, max)}
}
dec := json.NewDecoder(bytes.NewReader(body))
if strict {
dec.DisallowUnknownFields()
}
if err := dec.Decode(v); err != nil {
return &frameError{fmt.Errorf("could not parse %s: %w", what, err)}
}
// Strict is one object and nothing after it: a second object, or stray bytes, on
// the line would be read as part of a request that happened to decode, and is
// refused the way an unknown field is.
if strict {
if _, err := dec.Token(); err != io.EOF {
return fmt.Errorf("could not parse %s: unexpected data after the object", what)
}
}
return nil
}
// writeFrame writes v to w as one frame: the JSON object and the newline that ends it.
func writeFrame(w io.Writer, v any) error {
body, err := json.Marshal(v)
if err != nil {
return fmt.Errorf("could not encode frame: %w", err)
}
_, err = w.Write(append(body, '\n'))
return err
}
-102
View File
@@ -1,102 +0,0 @@
package localapi
import (
"bytes"
"fmt"
"io"
"net"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestReadFrameLimitIsOnTheBody pins the framing rule at its edge: the limit bounds the
// JSON body, so the newline that terminates the frame must not count against it.
func TestReadFrameLimitIsOnTheBody(t *testing.T) {
// A JSON string whose encoded form is exactly n bytes, with or without a terminator.
body := func(n int) string {
return fmt.Sprintf(`"%s"`, strings.Repeat("a", n-2))
}
var v string
// Exactly at the limit, terminated: accepted.
v = ""
require.NoError(t, readFrame(bytes.NewReader([]byte(body(64)+"\n")), 64, "request", &v, true))
assert.Len(t, v, 62)
// Exactly at the limit, EOF instead of a newline: still accepted.
v = ""
require.NoError(t, readFrame(bytes.NewReader([]byte(body(64))), 64, "request", &v, true))
assert.Len(t, v, 62)
// One byte over: refused as oversized, not as a parse failure.
err := readFrame(bytes.NewReader([]byte(body(65)+"\n")), 64, "request", &v, true)
require.Error(t, err)
assert.Contains(t, err.Error(), "exceeded 64 bytes")
}
// stallingReader hands out its bytes and then fails with err, the shape of a peer that
// sends part of a frame and then stops, until the deadline on the connection lands.
type stallingReader struct {
data []byte
err error
}
func (r *stallingReader) Read(p []byte) (int, error) {
if len(r.data) == 0 {
return 0, r.err
}
n := copy(p, r.data)
r.data = r.data[n:]
return n, nil
}
type timeoutError struct{}
func (timeoutError) Error() string { return "i/o timeout" }
func (timeoutError) Timeout() bool { return true }
func (timeoutError) Temporary() bool { return true }
// TestReadFramePartialLineThenReadErrorIsTheError: a read that fails after part of a
// frame has arrived is a failed read, and the caller sees that error. The old behaviour
// treated the fragment as the whole frame and reported a parse failure, so a client
// that stalled mid request was told its JSON was malformed, and a daemon that stalled
// mid response hid the timeout the client's error path looks for.
func TestReadFramePartialLineThenReadErrorIsTheError(t *testing.T) {
var v map[string]any
err := readFrame(&stallingReader{data: []byte(`{"command": "hel`), err: timeoutError{}}, 1024, "request", &v, true)
require.Error(t, err)
var ne net.Error
require.ErrorAs(t, err, &ne, "the timeout is still visible through the wrapping: %v", err)
assert.True(t, ne.Timeout())
assert.NotContains(t, err.Error(), "parse", "a stalled peer is not a parse failure")
// EOF after an unterminated line is the one exception: a final line with no newline
// is still a frame.
v = nil
require.NoError(t, readFrame(&stallingReader{data: []byte(`{"command": "help"}`), err: io.EOF}, 1024, "request", &v, true))
assert.Equal(t, "help", v["command"])
// And an unterminated line that is EOF only because the limit cut it off is still
// reported as oversized.
err = readFrame(bytes.NewReader([]byte(strings.Repeat("a", 70)+"\n")), 64, "request", &v, true)
require.Error(t, err)
assert.Contains(t, err.Error(), "exceeded 64 bytes")
}
// TestReadFrameUnknownFieldIsRefusedWhenStrict: the daemon refuses a request field it
// does not know, as it refuses an unknown parameter, so a misspelling is reported rather
// than ignored; the client, reading leniently, passes over a field a newer daemon sends.
func TestReadFrameUnknownFieldIsRefusedWhenStrict(t *testing.T) {
var req Request
err := readFrame(bytes.NewReader([]byte(`{"version":1,"comand":"help"}`+"\n")), 1024, "request", &req, true)
require.ErrorContains(t, err, `unknown field "comand"`)
var res Response
require.NoError(t, readFrame(bytes.NewReader([]byte(`{"version":1,"later":true}`+"\n")), 1024, "response", &res, false))
assert.Equal(t, 1, res.Version)
}
-570
View File
@@ -1,570 +0,0 @@
package localapi
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"log/slog"
"math"
"net"
"runtime/debug"
"strconv"
"sync"
"sync/atomic"
"time"
"github.com/slackhq/nebula/commands"
)
const (
// defaultMaxConns caps concurrent connections. Exceeding it is rejected rather than
// queued: a queue turns a load problem into a latency problem and hides it.
defaultMaxConns = 8
// readTimeout bounds how long a client may take to send its request line.
readTimeout = 10 * time.Second
// writeTimeout bounds a single write. A client that stops reading is dropped rather
// than waited on, so a paused terminal cannot pin daemon resources.
writeTimeout = 30 * time.Second
// defaultSlowAfter is how long a command may run before the daemon says so. A
// command holds a connection slot until it returns, and one that never returns
// holds it for good; after enough of those the socket answers only "busy". The
// warning is what tells an operator that from load, and names the command.
defaultSlowAfter = 30 * time.Second
)
// Server serves a command registry over a local socket to the user who ran nebula.
type Server struct {
l *slog.Logger
src *commands.Registry
maxConns int
slowAfter time.Duration
mu sync.Mutex
ln net.Listener
path string
running bool
unwatch func() bool
sem chan struct{}
euid uint32
// access is what the socket at path was bound with, so a reload that changes only
// the group or the mode is applied without moving the socket.
access Access
// trustSocket is set while a group shares the socket. The kernel admitted the peer
// through the socket's mode and group, which is the whole access control then, and
// the peer check in serve stands aside: on unix it sees the peer's uid and primary
// gid only, so it could not tell a member of the group from anyone else.
trustSocket atomic.Bool
}
// NewServer returns a Server that will serve every command in reg, including one
// registered on it after the server is built.
func NewServer(l *slog.Logger, reg *commands.Registry) *Server {
return &Server{
l: l,
src: reg,
maxConns: defaultMaxConns,
slowAfter: defaultSlowAfter,
// The same identity the client's owner check is made for, so the peer check
// cannot disagree with it, and so a test can stand in for it the same way.
euid: currentUID(),
}
}
// Rebind brings the server up at path, moves a running server there, and serves it until
// Stop or ctx cancellation. It is the one way the server comes up, so Wire's first
// attempt and its reload callback are the same call, and a server already serving path
// is left as it is: Wire registers the callback before the first attempt, so a HUP that
// lands between the two has the callback do the first bind, and the first attempt then
// finds the socket it was about to create already up.
//
// The new socket is bound before the old one is given up: a bad path in a reloaded
// config leaves the operator with the endpoint they already had rather than none.
//
// s.mu is held for the whole operation, bind included. Releasing it around listen would
// let a Stop land in between, and this would then install a fresh listener on a server
// that had just shut down, leaving a live socket on disk until the process exits. listen
// does not take s.mu, so holding it costs the other methods one bind's wait, at most the
// stale socket probe, once per reload.
//
// An error here is never fatal to the caller: nebula keeps forwarding packets without a
// control endpoint, and the caller is expected to log and carry on.
func (s *Server) Rebind(ctx context.Context, path string, acc Access) error {
s.mu.Lock()
defer s.mu.Unlock()
// Set before the access is applied, not after, so no connection the new access
// admits is checked against the old setting. Early is safe either way: a member
// arriving before a group's mode is set is refused by the kernel, and with a group
// being taken away the peer check applies a moment before the mode tightens.
prev := s.trustSocket.Swap(acc.shared())
err := s.rebindLocked(ctx, path, acc)
if err != nil {
// Whatever was serving still is, with the access it had.
s.trustSocket.Store(prev)
}
return err
}
func (s *Server) rebindLocked(ctx context.Context, path string, acc Access) error {
reopening := false
if s.running && s.path == path {
if s.access == acc {
return nil
}
// Only the access changed. On unix it is set on the socket in place; on windows
// the descriptor is fixed when the pipe is created, so the pipe is created again.
// The name cannot be held twice, so the old one goes first, and a bind that then
// fails leaves the server down rather than on the access the operator asked to
// change; that is reported.
err := applyAccess(path, acc)
if err == nil {
s.access = acc
s.l.Info("Changed the local control socket's access", "path", path, "access", acc.String())
return nil
}
if !errors.Is(err, errReopenForAccess) {
return fmt.Errorf("could not change the access of %s: %w", path, err)
}
reopening = true
release(s.ln, s.path)
s.ln, s.path, s.running, s.access = nil, "", false, Access{}
}
ln, err := listen(path, acc)
if err != nil {
if reopening {
return fmt.Errorf("the local control socket was closed to change its access and could not be created again: %w", err)
}
return err
}
// A reload that arrives during shutdown must not bring the endpoint back. Stop is
// not terminal (Rebind after Stop is allowed, and is how a server whose first bind
// failed comes up), so running is no guide; the context is what shutdown cancels,
// and it is checked here, while nothing else can change the server's state.
if err := ctx.Err(); err != nil {
release(ln, path)
return fmt.Errorf("not starting the local control socket, nebula is shutting down: %w", err)
}
oldLn, oldPath := s.ln, s.path
s.ln = ln
s.path = path
s.access = acc
s.running = true
sem := s.semaphore()
s.watchLocked(ctx)
// Stop accepting on the old listener. In flight commands keep their connections,
// which stay usable until they finish. Its accept loop exits on the closed-listener
// error, so it is gone as soon as this returns. oldPath differs from path whenever
// oldLn is set: a running server on the same path returned above.
if oldLn != nil {
release(oldLn, oldPath)
}
s.l.Info("Local control socket listening", "path", path, "access", acc.String())
go func() {
s.accept(ln, sem)
}()
return nil
}
// watchLocked stops the server when ctx is cancelled. One watcher covers a run of the
// server, from the first bind that succeeds until Stop: a daemon whose initial listen
// failed and which later Rebinds onto a good path from a reloaded config still needs its
// socket removed on shutdown, and a Rebind on a running server must not stack a second
// watcher on the same ctx. Stop detaches the watcher, so a server started again
// afterwards is watched on the ctx that started it, and the ctx of an earlier run no
// longer reaches it whenever that one ends. Callers hold s.mu.
func (s *Server) watchLocked(ctx context.Context) {
if s.unwatch != nil {
return
}
s.unwatch = context.AfterFunc(ctx, s.Stop)
}
// Path returns the socket path currently being served, or "" when stopped.
func (s *Server) Path() string {
s.mu.Lock()
defer s.mu.Unlock()
return s.path
}
// Stop closes the listener and removes the socket. In flight commands are allowed to
// finish; Stop does not wait for them.
//
// The whole of it runs under s.mu, listener and socket included, so a Rebind cannot land
// between the state change and the close and find a path that is still bound by the
// listener it is replacing.
func (s *Server) Stop() {
s.mu.Lock()
defer s.mu.Unlock()
if !s.running {
return
}
release(s.ln, s.path)
s.running = false
s.access = Access{}
s.ln = nil
s.path = ""
// Set whenever running is. When this Stop is the watcher's own, stopping a watcher
// that has already fired is a no-op.
s.unwatch()
s.unwatch = nil
}
// release gives up a listener and the socket node at its path. The node goes first,
// while the listener is still open: for as long as it is, the node is this server's,
// since a starting daemon's stale check refuses to remove a socket that answers. The
// other order opens a window between the close and the unlink in which a new daemon can
// find the node stale, clear it and bind its own at the same path, which the unlink
// then takes from under it, leaving that daemon serving a socket nothing can reach.
// listen turns off the listener's own unlink on close so this is the only unlink.
func release(ln net.Listener, path string) {
removeSocket(path)
_ = ln.Close()
}
// semaphore returns the connection limiter, creating it on first use. It is made once
// and never replaced: a handler releases into the channel it acquired from, so swapping
// in a fresh one across a Stop and Start would leave any handler still in flight
// blocked forever on a channel nothing had filled. Callers hold s.mu.
func (s *Server) semaphore() chan struct{} {
if s.sem == nil {
s.sem = make(chan struct{}, s.maxConns)
}
return s.sem
}
// Accept failures that are not the listener closing are retried after a pause that
// doubles from acceptRetryMin up to acceptRetryMax, the same shape as net/http.Serve.
const (
acceptRetryMin = 5 * time.Millisecond
acceptRetryMax = time.Second
)
// accept serves connections from ln until it is closed. sem is the limiter to acquire
// from and release into; it is passed rather than read from s so the handlers spawned
// here never touch s.sem without the lock.
//
// Only a closed listener ends the loop; Stop and Rebind are the two things that close
// it. Every other error is retried: the process being out of descriptors (EMFILE,
// ENFILE) or a client that hung up between the kernel's queue and us (ECONNABORTED)
// are passing conditions, and giving up on them would leave a socket on disk that
// nothing answers, with the reason buried in a log line from minutes or days earlier.
func (s *Server) accept(ln net.Listener, sem chan struct{}) {
var delay time.Duration
for {
conn, err := ln.Accept()
if err != nil {
if errors.Is(err, net.ErrClosed) {
return
}
if ne, ok := err.(net.Error); ok && ne.Timeout() {
continue
}
if delay == 0 {
delay = acceptRetryMin
} else {
delay = min(delay*2, acceptRetryMax)
}
s.l.Warn("Local control socket could not accept a connection, retrying", "error", err, "retry_in", delay)
time.Sleep(delay)
continue
}
delay = 0
select {
case sem <- struct{}{}:
default:
// At capacity. Say so and hang up rather than holding the connection open.
// Logged too: a slot is held for as long as a command runs, and the slow
// command warning in serve says which ones are still running.
s.l.Warn("Local control socket is at capacity, refusing a connection", "max", s.maxConns)
s.reply(conn, &Response{Version: ProtocolVersion, Error: "local control socket is busy, try again"})
_ = conn.Close()
continue
}
go func() {
defer func() { <-sem }()
s.handle(conn)
}()
}
}
// handle serves one request. It recovers from panics in command callbacks: this
// surface is present on every install and reachable by any local process running as
// the daemon's user, so a malformed argument must cost a connection rather than the
// overlay.
func (s *Server) handle(conn net.Conn) {
defer conn.Close()
var args []string
defer func() {
if r := recover(); r != nil {
s.l.Error("Recovered from panic serving a local control command",
"panic", r,
"args", args,
"stack", string(debug.Stack()),
)
s.reply(conn, &Response{Version: ProtocolVersion, Error: "command failed"})
}
}()
// Where the platform can identify the caller, check it, unless a group shares the
// socket; see trustSocket. Otherwise listen's mode or security descriptor stands.
if peerCheckSupported && !s.trustSocket.Load() {
uid, err := peerUID(conn)
if err != nil {
s.l.Warn("Refusing local control connection with unreadable credentials", "error", err)
return
}
// Access is restricted to the user who ran nebula. Root is allowed through
// because it can reach the daemon's memory regardless of what this check says.
if uid != s.euid && uid != 0 {
s.l.Warn("Refusing local control connection from another user", "peerUid", uid)
s.reply(conn, &Response{Version: ProtocolVersion, Error: "not permitted"})
return
}
}
_ = conn.SetReadDeadline(time.Now().Add(readTimeout))
req, err := readRequest(conn)
if err != nil {
s.reply(conn, &Response{Version: ProtocolVersion, Error: err.Error()})
return
}
args = req.Args
// No deadline while a command runs; the write deadline below is what bounds a client
// that stops reading.
_ = conn.SetReadDeadline(time.Time{})
_ = conn.SetWriteDeadline(time.Now().Add(writeTimeout))
s.reply(conn, s.serve(req))
}
// serve runs one request and describes the outcome.
//
// Nothing bounds a command's run; a context would have to reach every Run. What is
// bounded is the silence: a command still running at slowAfter is named in the log, with
// the slot it is holding, so a socket that has gone "busy" can be traced to the commands
// that wedged it. The timer is stopped however the command ends, a panic included, so
// the line is only ever written about a command that is still running.
func (s *Server) serve(req *Request) *Response {
slow := time.AfterFunc(s.slowAfter, func() {
s.l.Warn("Local control command is still running and holding a connection slot",
"command", req.Command,
"args", req.Args,
"after", s.slowAfter,
"max", s.maxConns,
)
})
defer slow.Stop()
res := &Response{Version: ProtocolVersion}
reg := s.src
if req.Describe {
schema, err := json.Marshal(reg.Schema())
if err != nil {
res.Error = err.Error()
return res
}
res.Result = schema
return res
}
if req.Command == "" {
res.Error = "no command given"
return res
}
params, err := stringParams(req.Params)
if err != nil {
res.Error = err.Error()
return res
}
format, err := parseFormat(req.Format)
if err != nil {
res.Error = err.Error()
return res
}
cmd, err := reg.Resolve(commands.Name(req.Command))
if err != nil {
s.l.Debug("Local control command refused", "command", req.Command, "error", err)
res.Error = err.Error()
return res
}
r, err := commands.Invoke(commands.Request{Command: cmd, Params: params, Args: req.Args})
if err != nil {
s.l.Debug("Local control command failed", "command", req.Command, "error", err)
res.Error = err.Error()
return res
}
// A command that acts does so now, before the one reply this surface gives, and the
// reply carries both halves: the line Run promised and the outcome Then produced.
// In JSON only the outcome travels, since the promise is for a person to read.
var preface []byte
if cmd.Then != nil && r.OK {
if format == commands.FormatText && !r.Empty() {
buf := &bytes.Buffer{}
if err := commands.Render(cmd, r, format, buf); err == nil {
preface = buf.Bytes()
}
}
r = cmd.Then()
}
// A command with nothing to say gets an empty, successful reply.
if r.Empty() {
res.Text = preface
return res
}
return render(res, cmd, r, format, preface)
}
// render turns a command's Result into the response, in the format the caller asked for,
// through commands.Render, so the JSON is byte for byte what -json prints over ssh.
func render(res *Response, cmd *commands.Command, r commands.Result, format commands.Format, preface []byte) *Response {
buf := &bytes.Buffer{}
if err := commands.Render(cmd, r, format, buf); err != nil {
res.Error = err.Error()
return res
}
if format != commands.FormatText {
// The caller is a program. Carry the payload as JSON rather than as a string that
// happens to contain some; the newline Render ends a line with is not the value's.
res.Result = bytes.TrimSuffix(buf.Bytes(), []byte("\n"))
// A command that ran and refused is a failure to whoever asked, in either format.
// The structured outcome still travels in Result for a program to read; Error
// carries the reason so the one rule, Error set means failed, holds here too and
// a client never has to guess from the payload.
if !r.OK {
res.Error = r.Reason
}
return res
}
// A command that ran and refused reads as an error to whoever asked for text: they
// are a person or a script, and both expect a refusal on the error stream.
if !r.OK {
res.Error = string(append(preface, buf.Bytes()...))
return res
}
// The bytes the command wrote, as they are; see Response.Text.
res.Text = append(preface, buf.Bytes()...)
return res
}
// parseFormat turns the request's format into the one the registry understands. An
// unknown value is an error rather than a silent default, so a client that asks for
// something this daemon cannot do hears about it.
func parseFormat(s string) (commands.Format, error) {
switch s {
case "", "json":
return commands.FormatJSON, nil
case "text":
return commands.FormatText, nil
default:
return commands.FormatJSON, fmt.Errorf("unknown format %q, expected \"json\" or \"text\"", s)
}
}
// reply writes one response frame.
func (s *Server) reply(conn net.Conn, res *Response) {
_ = conn.SetWriteDeadline(time.Now().Add(writeTimeout))
if err := writeFrame(conn, res); err != nil {
s.l.Debug("Could not send a local control response", "error", err)
}
}
// stringParams converts JSON's types into the strings flag.Value.Set expects, so a
// caller writes true and 3 rather than "true" and "3".
func stringParams(in map[string]any) (map[string]string, error) {
if len(in) == 0 {
return nil, nil
}
out := make(map[string]string, len(in))
for k, v := range in {
switch t := v.(type) {
case bool:
out[k] = strconv.FormatBool(t)
case string:
out[k] = t
case float64:
// encoding/json gives every number as a float64; render whole ones without
// a decimal point so an int flag accepts them.
if t != math.Trunc(t) {
out[k] = strconv.FormatFloat(t, 'f', -1, 64)
continue
}
// A whole float64 can be far outside int64, and Go's conversion of one that is
// gives an unspecified value rather than an error, so the bounds are checked
// first. MinInt64 is exactly representable and is in range. MaxInt64 is not:
// as a float64 it rounds up to 2^63, which is the first value out of range,
// hence the >= on that side.
if t < math.MinInt64 || t >= math.MaxInt64 {
return nil, fmt.Errorf("parameter %q is %s, outside the range of a 64-bit integer",
k, strconv.FormatFloat(t, 'g', -1, 64))
}
out[k] = strconv.FormatInt(int64(t), 10)
case nil:
return nil, fmt.Errorf("parameter %q has no value", k)
default:
return nil, fmt.Errorf("parameter %q is not a string, number or boolean", k)
}
}
return out, nil
}
func readRequest(conn net.Conn) (*Request, error) {
req := &Request{}
if err := readFrame(conn, MaxRequestBytes, "request", req, true); err != nil {
return nil, err
}
if req.Version != ProtocolVersion {
return nil, fmt.Errorf(
"this nebula speaks local control protocol v%d, the client sent v%d; the two binaries are different versions",
ProtocolVersion, req.Version,
)
}
return req, nil
}
-950
View File
@@ -1,950 +0,0 @@
//go:build !windows
package localapi
import (
"bytes"
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"io"
"math"
"net"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"time"
"github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// testSocket returns a short socket path whose directory does not exist yet and whose
// parent is private: one level below the test's own directory, so that listen has a
// directory of its own to create.
func testSocket(t *testing.T) string {
t.Helper()
return filepath.Join(test.ShortTempDir(t), "n", "s.sock")
}
func serve(t *testing.T, reg *commands.Registry) (*Server, string) {
t.Helper()
path := testSocket(t)
s := NewServer(test.NewLogger(), reg)
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
t.Cleanup(s.Stop)
return s, path
}
// serveAt starts a server on an exact path, for tests that care where the socket is.
func serveAt(t *testing.T, path string) (*Server, func()) {
t.Helper()
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
return s, s.Stop
}
// echoCommand reports its operands, for tests on either surface.
func echoCommand() *commands.Command {
return &commands.Command{
Name: "echo",
ShortDescription: "echoes its arguments",
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Value(fmt.Sprintf("%v", a)), nil
},
}
}
func basicRegistry() *commands.Registry {
reg := commands.New()
reg.Register(echoCommand())
reg.Register(&commands.Command{
Name: "boom",
ShortDescription: "panics",
Run: func(fs any, a []string) (commands.Result, error) {
panic("this command is broken")
},
})
return reg
}
// run invokes one command and returns its output and its error text. An empty error is
// success: the protocol has no separate status field.
func run(t *testing.T, path, command string, args ...string) (string, string) {
t.Helper()
res, err := (&Client{Path: path}).Invoke(command, nil, args, "")
require.NoError(t, err)
return textOf(res), res.Error
}
// textOf is what a test reads as a command's output: the text when text was asked for,
// else the JSON result, unquoted when it is a JSON string so a test can compare words.
func textOf(res *Response) string {
if len(res.Text) > 0 {
return string(res.Text)
}
if len(res.Result) > 0 && res.Result[0] == '"' {
var s string
if err := json.Unmarshal(res.Result, &s); err == nil {
return s
}
}
return string(res.Result)
}
func TestServeAllowedCommand(t *testing.T) {
_, path := serve(t, basicRegistry())
out, errOut := run(t, path, "echo", "a", "b")
assert.Equal(t, "[a b]", out)
assert.Empty(t, errOut, "a command that worked reports no error")
}
// TestPanicInCommandDoesNotKillTheDaemon: a broken command costs a connection, not the
// overlay.
func TestPanicInCommandDoesNotKillTheDaemon(t *testing.T) {
_, path := serve(t, basicRegistry())
out, errOut := run(t, path, "boom")
assert.Empty(t, out)
assert.Contains(t, errOut, "command failed")
// The server is still serving, which is the point of the test.
out, errOut = run(t, path, "echo", "still", "here")
assert.Equal(t, "[still here]", out)
assert.Empty(t, errOut)
}
// TestSocketPermissions: the modes are pinned, not left to the umask. A 077 umask would
// make the directory 0700 and hide a root daemon's socket from an unprivileged nebula
// ctl.
func TestSocketPermissions(t *testing.T) {
for _, umask := range []int{0, 0077} {
t.Run(fmt.Sprintf("umask %04o", umask), func(t *testing.T) {
old := unix.Umask(umask)
defer unix.Umask(old)
_, path := serve(t, basicRegistry())
fi, err := os.Stat(path)
require.NoError(t, err)
assert.Equal(t, os.FileMode(0600), fi.Mode().Perm(), "socket must not be reachable by other users")
di, err := os.Stat(filepath.Dir(path))
require.NoError(t, err)
assert.Equal(t, os.FileMode(0755), di.Mode().Perm(), "a directory we create ourselves is searchable, so ServedByRoot can see into it")
})
}
}
func TestLiveSocketIsNotStolen(t *testing.T) {
first, path := serve(t, basicRegistry())
require.NotNil(t, first)
second := NewServer(test.NewLogger(), basicRegistry())
err := second.Rebind(context.Background(), path, ownerOnly())
assert.ErrorContains(t, err, "already in use", "a live endpoint must not be unlinked by a second instance")
}
// TestLiveSocketIsNotStolenBeforeItsChmod: between an instance's bind and its chmod the
// socket is at whatever mode the umask left. A second instance starting in that window
// must still see it as live, not stale: only a refused connect proves nothing is behind
// the file.
func TestLiveSocketIsNotStolenBeforeItsChmod(t *testing.T) {
first, path := serve(t, basicRegistry())
require.NotNil(t, first)
require.NoError(t, os.Chmod(path, 0666))
second := NewServer(test.NewLogger(), basicRegistry())
err := second.Rebind(context.Background(), path, ownerOnly())
require.ErrorContains(t, err, "already in use", "a live socket at any mode is not thereby dead")
_, err = os.Stat(path)
require.NoError(t, err, "the first instance's socket is still there")
require.NoError(t, os.Chmod(path, 0600))
out, _ := run(t, path, "echo", "ok")
assert.Equal(t, "[ok]", out, "and still served")
}
func TestRebindMovesTheSocket(t *testing.T) {
s, path := serve(t, basicRegistry())
next := filepath.Join(filepath.Dir(path), "n.sock")
require.NoError(t, s.Rebind(context.Background(), next, ownerOnly()))
assert.Equal(t, next, s.Path())
out, _ := run(t, next, "echo", "moved")
assert.Equal(t, "[moved]", out)
_, err := os.Stat(path)
assert.True(t, os.IsNotExist(err), "the old socket should be unlinked")
}
func TestRebindFailureKeepsTheOldSocket(t *testing.T) {
s, path := serve(t, basicRegistry())
err := s.Rebind(context.Background(), "/nonexistent-dir-for-tests/x.sock", ownerOnly())
require.Error(t, err)
assert.Equal(t, path, s.Path(), "a bad path must leave the working endpoint alone")
out, _ := run(t, path, "echo", "ok")
assert.Equal(t, "[ok]", out)
}
// TestSemaphoreSurvivesRestart pins the rule that the connection limiter is made once. A
// handler releases into the channel it acquired from, so if Rebind replaced it after a
// Stop, a command still running across the restart would block forever on the new,
// empty channel and leak its goroutine and connection.
func TestSemaphoreSurvivesRestart(t *testing.T) {
s := NewServer(test.NewLogger(), basicRegistry())
path := testSocket(t)
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
first := s.sem
require.NotNil(t, first)
s.Stop()
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
defer s.Stop()
assert.Equal(t, first, s.sem, "Rebind after Stop must keep the same semaphore")
require.NoError(t, s.Rebind(context.Background(), testSocket(t), ownerOnly()))
assert.Equal(t, first, s.sem, "Rebind must keep the same semaphore")
}
// TestRestartIsWatchedOnItsOwnContext: the ctx watcher is installed by the first bind of
// a run and cleared by Stop, so a server stopped by one context's cancellation and
// started again under another is stopped when that second context is cancelled, not
// left serving until the process exits.
func TestRestartIsWatchedOnItsOwnContext(t *testing.T) {
s := NewServer(test.NewLogger(), basicRegistry())
path := testSocket(t)
ctxA, cancelA := context.WithCancel(context.Background())
require.NoError(t, s.Rebind(ctxA, path, ownerOnly()))
cancelA()
require.Eventually(t, func() bool { return s.Path() == "" }, time.Second, 10*time.Millisecond, "the first context must stop the server")
ctxB, cancelB := context.WithCancel(context.Background())
require.NoError(t, s.Rebind(ctxB, path, ownerOnly()))
defer s.Stop()
assert.Equal(t, path, s.Path())
cancelB()
require.Eventually(t, func() bool { return s.Path() == "" }, time.Second, 10*time.Millisecond, "the second context must stop the server too")
_, err := os.Stat(path)
assert.True(t, os.IsNotExist(err), "the socket must be removed when the second context stops the server")
}
// TestStopDetachesTheWatcher: a server stopped by Stop and started again under another
// context belongs to that context alone. The one that started the earlier run, ending
// later, must not take the new run down with it.
func TestStopDetachesTheWatcher(t *testing.T) {
s := NewServer(test.NewLogger(), basicRegistry())
path := testSocket(t)
ctxA, cancelA := context.WithCancel(context.Background())
t.Cleanup(cancelA)
require.NoError(t, s.Rebind(ctxA, path, ownerOnly()))
s.Stop()
ctxB, cancelB := context.WithCancel(context.Background())
t.Cleanup(cancelB)
require.NoError(t, s.Rebind(ctxB, path, ownerOnly()))
t.Cleanup(s.Stop)
cancelA()
time.Sleep(50 * time.Millisecond)
assert.Equal(t, path, s.Path(), "the first run's context has nothing to do with the second run")
_, err := (&Client{Path: path}).Describe()
require.NoError(t, err)
cancelB()
require.Eventually(t, func() bool { return s.Path() == "" }, time.Second, 10*time.Millisecond, "the second run's context stops it")
}
func TestVersionMismatchIsExplained(t *testing.T) {
_, path := serve(t, basicRegistry())
conn, err := net.Dial("unix", path)
require.NoError(t, err)
defer conn.Close()
body, _ := json.Marshal(Request{Version: ProtocolVersion + 1, Command: "echo"})
_, err = conn.Write(append(body, '\n'))
require.NoError(t, err)
res, err := readResponse(conn)
require.NoError(t, err)
assert.Contains(t, res.Error, "different versions")
}
func TestOversizedRequestIsRejected(t *testing.T) {
_, path := serve(t, basicRegistry())
conn, err := net.Dial("unix", path)
require.NoError(t, err)
defer conn.Close()
_, err = conn.Write(append(bytes.Repeat([]byte("a"), MaxRequestBytes+10), '\n'))
if err == nil {
res, rerr := readResponse(conn)
require.NoError(t, rerr)
assert.NotEmpty(t, res.Error)
}
}
// TestConcurrentClientsAreBounded checks that going over the connection cap is answered
// rather than queued, so a burst of clients cannot pile up against the packet path.
// TestSlowCommandIsNamedInTheLog: a command that does not return holds its slot for
// good, and enough of them leave the socket answering only "busy". Both are logged, the
// command by name once it has run past slowAfter and each refused connection as it
// happens, so a busy socket can be traced to what wedged it.
func TestSlowCommandIsNamedInTheLog(t *testing.T) {
reg := commands.New()
release := make(chan struct{})
reg.Register(&commands.Command{
Name: "block",
ShortDescription: "blocks until released",
Run: func(fs any, a []string) (commands.Result, error) {
<-release
return commands.Value("done"), nil
},
})
var logs lockedBuffer
s := NewServer(test.NewLoggerWithOutput(&logs), reg)
s.maxConns = 1
s.slowAfter = 20 * time.Millisecond
path := testSocket(t)
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
defer s.Stop()
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
_, _ = (&Client{Path: path}).Invoke("block", nil, []string{"x"}, "")
}()
require.Eventually(t, func() bool {
return strings.Contains(logs.String(), "still running")
}, 2*time.Second, 10*time.Millisecond)
assert.Contains(t, logs.String(), "command=block")
assert.Contains(t, logs.String(), "args=[x]")
res, err := (&Client{Path: path}).Invoke("block", nil, nil, "")
require.NoError(t, err)
assert.Contains(t, res.Error, "busy")
assert.Contains(t, logs.String(), "at capacity")
close(release)
wg.Wait()
}
// TestPanickedCommandIsNotReportedAsStillRunning: the slow command line is about a slot
// that is still held. A command that panicked has given its slot back, and the client
// its answer, so no line must claim otherwise after the fact.
func TestPanickedCommandIsNotReportedAsStillRunning(t *testing.T) {
reg := commands.New()
reg.Register(&commands.Command{
Name: "boom",
ShortDescription: "panics",
Run: func(fs any, a []string) (commands.Result, error) {
panic("this command is broken")
},
})
var logs lockedBuffer
s := NewServer(test.NewLoggerWithOutput(&logs), reg)
s.slowAfter = 20 * time.Millisecond
path := testSocket(t)
require.NoError(t, s.Rebind(context.Background(), path, ownerOnly()))
defer s.Stop()
res, err := (&Client{Path: path}).Invoke("boom", nil, nil, "")
require.NoError(t, err)
assert.Equal(t, "command failed", res.Error)
time.Sleep(100 * time.Millisecond)
assert.Contains(t, logs.String(), "Recovered from panic")
assert.NotContains(t, logs.String(), "still running")
}
// lockedBuffer is a strings.Builder the server's goroutines and the test can share.
type lockedBuffer struct {
mu sync.Mutex
b strings.Builder
}
func (l *lockedBuffer) Write(p []byte) (int, error) {
l.mu.Lock()
defer l.mu.Unlock()
return l.b.Write(p)
}
func (l *lockedBuffer) String() string {
l.mu.Lock()
defer l.mu.Unlock()
return l.b.String()
}
// flakyListener fails its first few Accepts the way a process that is out of file
// descriptors does, then behaves.
type flakyListener struct {
net.Listener
failures int
}
func (f *flakyListener) Accept() (net.Conn, error) {
if f.failures > 0 {
f.failures--
return nil, &net.OpError{Op: "accept", Net: "unix", Err: errors.New("too many open files")}
}
return f.Listener.Accept()
}
// TestAcceptSurvivesTransientErrors: an Accept that fails for a reason other than the
// listener being closed is retried, so a moment at the descriptor limit does not take
// the control socket down for the rest of the process. Closing the listener is still
// what ends the loop.
func TestAcceptSurvivesTransientErrors(t *testing.T) {
path := testSocket(t)
require.NoError(t, os.Mkdir(filepath.Dir(path), 0700))
ln, err := listen(path, ownerOnly())
require.NoError(t, err)
s := NewServer(test.NewLogger(), basicRegistry())
done := make(chan struct{})
go func() {
defer close(done)
s.accept(&flakyListener{Listener: ln, failures: 3}, make(chan struct{}, 1))
}()
out, errText := run(t, path, "echo", "still", "here")
assert.Empty(t, errText)
assert.Equal(t, "[still here]", out)
require.NoError(t, ln.Close())
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("accept loop did not exit when the listener was closed")
}
}
func TestStopRemovesTheSocket(t *testing.T) {
s, path := serve(t, basicRegistry())
s.Stop()
_, err := os.Stat(path)
assert.True(t, os.IsNotExist(err))
}
func TestContextCancellationStops(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
path := testSocket(t)
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(ctx, path, ownerOnly()))
cancel()
assert.Eventually(t, func() bool {
_, err := os.Stat(path)
return os.IsNotExist(err)
}, 2*time.Second, 20*time.Millisecond)
}
// TestNamedParametersDriveFlags is the point of the protocol: a caller passes options by
// name, with JSON's own types, and never assembles a command line.
// TestStringParamsNumbers: JSON numbers arrive as float64. Whole ones render as integers
// so int flags accept them, and a whole one outside int64 is refused rather than
// converted, since Go's float-to-int conversion of an out-of-range value is unspecified
// and would set a number the caller never sent.
func TestStringParamsNumbers(t *testing.T) {
cases := map[string]struct {
in float64
want string
wantErr bool
}{
"whole": {in: 3, want: "3"},
"negative whole": {in: -1, want: "-1"},
"fraction": {in: 1.5, want: "1.5"},
"min int64": {in: math.MinInt64, want: "-9223372036854775808"},
"largest in range": {in: 9223372036854774784, want: "9223372036854774784"},
"2^63": {in: 9223372036854775808, wantErr: true},
"1e19": {in: 1e19, wantErr: true},
"below min int64": {in: -9.3e18, wantErr: true},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
out, err := stringParams(map[string]any{"n": tc.in})
if tc.wantErr {
require.Error(t, err)
require.ErrorContains(t, err, `parameter "n" is `)
assert.ErrorContains(t, err, "outside the range of a 64-bit integer")
return
}
require.NoError(t, err)
assert.Equal(t, tc.want, out["n"])
})
}
}
func TestNamedParametersDriveFlags(t *testing.T) {
reg := commands.New()
reg.Register(&commands.Command{
Name: "report",
ShortDescription: "reports its flags",
Flags: func() (*flag.FlagSet, any) {
fl := flag.NewFlagSet("", flag.ContinueOnError)
s := struct {
Verbose bool
Label string
}{}
fl.BoolVar(&s.Verbose, "verbose", false, "say more")
fl.StringVar(&s.Label, "label", "none", "a label")
return fl, &s
},
Run: func(fs any, a []string) (commands.Result, error) {
s := fs.(*struct {
Verbose bool
Label string
})
return commands.Value(fmt.Sprintf("verbose=%v label=%s args=%v", s.Verbose, s.Label, a)), nil
},
})
_, path := serve(t, reg)
res, err := (&Client{Path: path}).Invoke("report",
map[string]string{"verbose": "true", "label": "here"},
[]string{"an-operand"},
"",
)
require.NoError(t, err)
assert.Empty(t, res.Error)
assert.Equal(t, "verbose=true label=here args=[an-operand]", textOf(res))
}
// TestUnknownParameterIsReported: a misspelled parameter is an error rather than a
// silently applied default, which is the difference between an API and a guess.
func TestUnknownParameterIsReported(t *testing.T) {
reg := commands.New()
reg.Register(&commands.Command{
Name: "report",
ShortDescription: "takes a flag",
Flags: func() (*flag.FlagSet, any) {
fl := flag.NewFlagSet("", flag.ContinueOnError)
fl.Bool("verbose", false, "say more")
return fl, nil
},
Run: func(fs any, a []string) (commands.Result, error) { return commands.Nothing(), nil },
})
_, path := serve(t, reg)
res, err := (&Client{Path: path}).Invoke("report", map[string]string{"verbos": "true"}, nil, "")
require.NoError(t, err)
assert.Contains(t, res.Error, `report has no parameter "verbos"`)
}
func TestParametersOnACommandThatTakesNoneAreReported(t *testing.T) {
_, path := serve(t, basicRegistry())
res, err := (&Client{Path: path}).Invoke("echo", map[string]string{"nope": "true"}, nil, "")
require.NoError(t, err)
assert.Contains(t, res.Error, "echo takes no parameters")
}
// TestJSONOutputIsAJSONValue: a command that emits JSON lands in the response as JSON,
// not as a string a caller has to parse a second time.
func TestJSONOutputIsAJSONValue(t *testing.T) {
reg := commands.New()
reg.Register(&commands.Command{
Name: "emit",
ShortDescription: "emits json",
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Value(map[string]any{"hosts": []int{1, 2, 3}}), nil
},
})
_, path := serve(t, reg)
res, err := (&Client{Path: path}).Invoke("emit", nil, nil, "")
require.NoError(t, err)
var decoded struct {
Hosts []int `json:"hosts"`
}
require.NoError(t, json.Unmarshal(res.Result, &decoded))
assert.Equal(t, []int{1, 2, 3}, decoded.Hosts)
}
// TestStringValueIsAJSONString: a command whose value is a string answers a JSON request
// with a JSON string, quotes and all.
func TestStringValueIsAJSONString(t *testing.T) {
_, path := serve(t, basicRegistry())
res, err := (&Client{Path: path}).Invoke("echo", nil, []string{"hi"}, "")
require.NoError(t, err)
var s string
require.NoError(t, json.Unmarshal(res.Result, &s))
assert.Equal(t, "[hi]", s)
}
func TestDescribeListsTheCommands(t *testing.T) {
_, path := serve(t, basicRegistry())
schema, err := (&Client{Path: path}).Describe()
require.NoError(t, err)
names := make([]string, 0, len(schema))
for _, c := range schema {
names = append(names, string(c.Name))
}
assert.ElementsMatch(t, []string{"help", "echo", "boom"}, names)
}
// TestPresentationParametersAreRefused: the schema lists json and pretty on every
// command, because the command lines take them, but a request has one way to choose its
// rendering, the format field. A client that sends them as parameters is pointed there
// rather than given a second, weaker way to say the same thing.
func TestPresentationParametersAreRefused(t *testing.T) {
reg := commands.New()
reg.Register(&commands.Command{
Name: "pair",
ShortDescription: "returns a pair",
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Value(map[string]int{"a": 1}), nil
},
Text: func(v any, w io.Writer) error {
_, err := fmt.Fprintln(w, "a is one")
return err
},
})
_, path := serve(t, reg)
c := &Client{Path: path}
for _, name := range []string{"json", "pretty"} {
res, err := c.Invoke("pair", map[string]string{name: "true"}, nil, "text")
require.NoError(t, err)
assert.Contains(t, res.Error, name+" is a command line flag, not a parameter")
assert.Contains(t, res.Error, "format")
assert.Empty(t, res.Result, "a refused request runs nothing")
}
// The format field is the one that counts.
res, err := c.Invoke("pair", nil, nil, "text")
require.NoError(t, err)
require.Empty(t, res.Error)
assert.Equal(t, "a is one\n", textOf(res))
res, err = c.Invoke("pair", nil, nil, "")
require.NoError(t, err)
require.Empty(t, res.Error)
assert.JSONEq(t, `{"a":1}`, string(res.Result), "the API default is JSON")
}
// TestTextRequestToATextlessCommand: a command with no human rendering still answers a
// text request when the answer is a refusal, since a refusal always has one. Only a
// successful result has nothing to say in text, and that is reported then, by the daemon.
func TestTextRequestToATextlessCommand(t *testing.T) {
reg := commands.New()
reg.Register(&commands.Command{
Name: "tunnel",
ShortDescription: "data on success, a refusal without an operand",
Run: func(fs any, a []string) (commands.Result, error) {
if len(a) == 0 {
return commands.Failed("No vpn address was provided"), nil
}
return commands.Value(map[string]int{"index": 7}), nil
},
JSONOnly: true,
})
_, path := serve(t, reg)
c := &Client{Path: path}
res, err := c.Invoke("tunnel", nil, nil, "text")
require.NoError(t, err)
assert.Equal(t, "No vpn address was provided\n", res.Error, "the refusal is rendered, not the missing text form")
res, err = c.Invoke("tunnel", nil, []string{"10.0.0.1"}, "text")
require.NoError(t, err)
assert.Contains(t, res.Error, "tunnel has no human readable output yet; pass -json or -pretty")
assert.Empty(t, res.Result)
res, err = c.Invoke("tunnel", nil, []string{"10.0.0.1"}, "json")
require.NoError(t, err)
require.Empty(t, res.Error)
assert.JSONEq(t, `{"index":7}`, string(res.Result))
// A refusal asked for as JSON carries the outcome for a program and the reason in
// Error, so a client exits non-zero on the envelope alone, never by sniffing the
// payload for an ok field some unrelated result might also have.
res, err = c.Invoke("tunnel", nil, nil, "json")
require.NoError(t, err)
assert.Equal(t, "No vpn address was provided", res.Error)
assert.JSONEq(t, `{"ok":false,"reason":"No vpn address was provided"}`, string(res.Result))
}
// TestRebindAfterFailedBindStillStopsOnCancel covers a daemon whose initial listen
// failed and which later Rebinds onto a good path from a reloaded config. The context
// watcher has to be installed by that Rebind, or the socket outlives the daemon.
func TestRebindAfterFailedBindStillStopsOnCancel(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
base := test.ShortTempDir(t)
// listen creates one level only, so a socket directory under a parent that is not
// there yet fails to bind, the shape of a runtime directory that does not exist.
s := NewServer(test.NewLogger(), basicRegistry())
require.Error(t, s.Rebind(ctx, filepath.Join(base, "missing", "n", "s.sock"), ownerOnly()))
good := filepath.Join(base, "n", "s.sock")
require.NoError(t, s.Rebind(ctx, good, ownerOnly()))
t.Cleanup(s.Stop)
_, err := (&Client{Path: good}).Describe()
require.NoError(t, err)
cancel()
assert.Eventually(t, func() bool {
_, err := os.Stat(good)
return os.IsNotExist(err)
}, 2*time.Second, 20*time.Millisecond)
}
// TestCommandRegisteredAfterStartIsServed: the server filters the registry per request,
// so a command an embedder registers after wiring the socket is served, and described,
// just as it would be over ssh.
func TestCommandRegisteredAfterStartIsServed(t *testing.T) {
reg := basicRegistry()
_, path := serve(t, reg)
reg.Register(&commands.Command{
Name: "late",
ShortDescription: "registered after the server started",
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Value("late"), nil
},
})
c := &Client{Path: path}
schema, err := c.Describe()
require.NoError(t, err)
names := make([]string, 0, len(schema))
for _, cs := range schema {
names = append(names, string(cs.Name))
}
assert.Contains(t, names, "late")
res, err := c.Invoke("late", nil, nil, "")
require.NoError(t, err)
require.Empty(t, res.Error)
assert.JSONEq(t, `"late"`, string(res.Result))
}
// TestThenIsAnsweredInTheOneReply: this surface answers in one piece, so a command that
// acts does so before the reply, and the reply carries Run's line and Then's outcome in
// text, and the outcome alone in JSON.
func TestThenIsAnsweredInTheOneReply(t *testing.T) {
reg := commands.New()
acted := false
reg.Register(&commands.Command{
Name: "act",
ShortDescription: "replies, then acts",
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Did("about to act"), nil
},
Then: func() commands.Result {
acted = true
return commands.Did("acted")
},
})
_, path := serve(t, reg)
res, err := (&Client{Path: path}).Invoke("act", nil, nil, "text")
require.NoError(t, err)
assert.True(t, acted)
assert.Empty(t, res.Error)
assert.Equal(t, "about to act\nacted\n", string(res.Text))
res, err = (&Client{Path: path}).Invoke("act", nil, nil, "")
require.NoError(t, err)
assert.JSONEq(t, `{"ok":true,"reason":"acted"}`, string(res.Result))
// A refusal from Then still carries Run's line ahead of it in text, as ssh prints it.
acted = false
reg.Register(&commands.Command{
Name: "fail",
ShortDescription: "replies, then fails to act",
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Did("about to act"), nil
},
Then: func() commands.Result {
return commands.Failed("could not act")
},
})
res, err = (&Client{Path: path}).Invoke("fail", nil, nil, "text")
require.NoError(t, err)
assert.Equal(t, "about to act\ncould not act\n", res.Error)
assert.Empty(t, res.Text)
// A Run that refused is the outcome, and Then does not run.
acted = false
reg.Register(&commands.Command{
Name: "refuse",
ShortDescription: "refuses, so never acts",
Run: func(fs any, a []string) (commands.Result, error) {
return commands.Failed("not like that"), nil
},
Then: func() commands.Result {
acted = true
return commands.Did("acted anyway")
},
})
res, err = (&Client{Path: path}).Invoke("refuse", nil, nil, "text")
require.NoError(t, err)
assert.Equal(t, "not like that\n", res.Error)
assert.False(t, acted)
}
// TestRebindRefusesDuringShutdown: a reload that lands after the daemon's context is
// cancelled must not bring the endpoint back. Stop is not terminal, so Rebind has to
// take the answer from the context rather than from the running flag.
func TestRebindRefusesDuringShutdown(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Built by hand rather than through serve: the context watcher is installed once,
// by the first bind, and this test needs it on a context it can cancel.
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(ctx, testSocket(t), ownerOnly()))
t.Cleanup(s.Stop)
cancel()
assert.Eventually(t, func() bool { return s.Path() == "" }, 2*time.Second, 20*time.Millisecond, "the watcher stops the server")
next := testSocket(t)
err := s.Rebind(ctx, next, ownerOnly())
require.Error(t, err)
require.ErrorContains(t, err, "shutting down")
assert.Empty(t, s.Path(), "the server stays stopped")
_, statErr := os.Stat(next)
assert.True(t, os.IsNotExist(statErr), "and the refused socket is not left on disk")
}
// TestRebindAndStopSerialize hammers Rebind against Stop. Whichever runs last decides
// the final state, so after the dust settles a Stop must leave nothing listening and no
// socket file behind, on either path.
func TestRebindAndStopSerialize(t *testing.T) {
a := testSocket(t)
b := testSocket(t)
for i := 0; i < 50; i++ {
s := NewServer(test.NewLogger(), basicRegistry())
require.NoError(t, s.Rebind(context.Background(), a, ownerOnly()))
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
_ = s.Rebind(context.Background(), b, ownerOnly())
}()
go func() {
defer wg.Done()
s.Stop()
}()
wg.Wait()
// The Rebind may have run after the Stop, which restarts the server by design.
// A final Stop then has to take everything down.
s.Stop()
assert.Empty(t, s.Path())
for _, p := range []string{a, b} {
_, err := os.Stat(p)
assert.True(t, os.IsNotExist(err), "iteration %d: %s left behind", i, p)
}
}
}
// TestUnknownRequestFieldIsRefused: a request with a field the protocol does not define
// is answered with the field named, the way an unknown parameter is, and not run.
func TestUnknownRequestFieldIsRefused(t *testing.T) {
_, path := serve(t, basicRegistry())
conn, err := dial(path, time.Second)
require.NoError(t, err)
defer conn.Close()
require.NoError(t, writeFrame(conn, map[string]any{"version": ProtocolVersion, "command": "echo", "arguments": []string{"x"}}))
var res Response
require.NoError(t, readFrame(conn, MaxResponseBytes, "response", &res, false))
assert.Contains(t, res.Error, `unknown field "arguments"`)
assert.Empty(t, res.Result)
}
// TestTrailingBytesOnARequestAreRefused: a request line is one object and nothing
// more; a second object or stray bytes after it are refused rather than ignored.
func TestTrailingBytesOnARequestAreRefused(t *testing.T) {
_, path := serve(t, basicRegistry())
for _, line := range []string{
`{"version":1,"command":"echo"} junk` + "\n",
`{"version":1,"command":"echo"}{"version":1,"command":"boom"}` + "\n",
} {
conn, err := dial(path, time.Second)
require.NoError(t, err)
_, err = conn.Write([]byte(line))
require.NoError(t, err)
var res Response
require.NoError(t, readFrame(conn, MaxResponseBytes, "response", &res, false))
assert.Contains(t, res.Error, "unexpected data after the object", line)
conn.Close()
}
}
// TestTextOutputKeepsTheBytes: a text rendering travels as the bytes the command wrote.
// A JSON string would have had to be UTF-8, and a byte that is not would have come out
// as U+FFFD, where the ssh server passes it through.
func TestTextOutputKeepsTheBytes(t *testing.T) {
reg := commands.New()
raw := []byte{'n', 'a', 'm', 'e', ' ', 0xff, 0xfe, '\n'}
reg.Register(&commands.Command{
Name: "raw",
ShortDescription: "writes what a certificate held",
Run: func(fs any, a []string) (commands.Result, error) { return commands.Value("raw"), nil },
Text: func(v any, w io.Writer) error {
_, err := w.Write(raw)
return err
},
})
_, path := serve(t, reg)
res, err := (&Client{Path: path}).Invoke("raw", nil, nil, "text")
require.NoError(t, err)
assert.Empty(t, res.Error)
assert.Equal(t, raw, res.Text)
assert.Empty(t, res.Result, "text is not also carried as JSON")
}
-144
View File
@@ -1,144 +0,0 @@
package localapi
import (
"context"
"errors"
"log/slog"
"github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/config"
)
// Wire brings up the local control socket for a running nebula, unless the config turns
// it off, and keeps it following the config across reloads.
//
// Every entry point that runs nebula as a daemon calls this, so the endpoint behaves the
// same whether nebula was started from a shell or by a service manager. It deliberately
// does not live in nebula.Main: the endpoint is on by default, so an embedder inside an
// app sandbox would have to know to turn off a socket it cannot use. Wiring it at the
// daemon entry points means embedders get the command registry and no listener.
//
// Every failure below is a warning, bar one. Nebula is expected to keep forwarding
// packets whether or not anyone can reach it; but a name that another process holds is
// not a misconfiguration, it is a process that will be answering nebula ctl in the
// daemon's place, and that is logged as an error.
//
// Call it after Control.Start, so the listener only exists once the interface is up.
func Wire(ctx context.Context, l *slog.Logger, c *config.C, reg *commands.Registry) *Server {
l = l.With("subsystem", "localapi")
srv := NewServer(l, reg)
// Registered before the first attempt, so that a path or bind that is bad at startup
// can be fixed with a config edit and a reload, the same as one that goes bad later,
// and so that a HUP landing in between is harmless: Rebind on a server already at
// the path is a no-op.
reconcile := followControlConfig(ctx, l, c, srv)
reconcile(c)
if !ControlEnabled(c) {
l.Info("Local control socket is disabled", "key", CtlEnabledKey)
}
return srv
}
// followControlConfig registers the reload callback that keeps the socket where
// local_api.control.socket says it is, moving it when the key changes and bringing one
// up while there is none, and returns it for the first attempt to call.
//
// The key is reloadable because the client finds the socket by reading the config: if the
// two could disagree, the file on disk would name a socket that is not there.
//
// Every reload is reconciled rather than gated on the key having changed. Rebind on a
// server already at the path is a no-op, so that costs nothing; and a bind that failed
// for a reason outside the config, a runtime directory that was not there yet, is fixed
// outside the config too, so the reload that follows the fix is a plain one. That holds
// for a move as much as for the first bind: a daemon left on its old path by a move that
// could not bind is one the client, reading the new path from the same file, cannot
// reach, and the operator's fix is the directory and a reload, not an edit to an
// unrelated line to make the key read as changed.
//
// The callback recovers from its own panics rather than relying on the config package,
// whose callback loop has no isolation of its own. A panic there would take the daemon
// down and skip every callback queued behind this one.
func followControlConfig(ctx context.Context, l *slog.Logger, c *config.C, srv *Server) func(*config.C) {
reconcile := func(c *config.C) {
if !ControlEnabled(c) {
if srv.Path() != "" {
srv.Stop()
l.Info("Stopped the local control socket, it is disabled in the reloaded config")
}
return
}
want, err := SocketPathFromConfig(c)
if err != nil {
warnUnusable(l, "local control socket", srv.Path(), err)
return
}
acc, err := controlAccessFrom(c)
if err != nil {
warnUnusable(l, "local control socket", srv.Path(), err)
return
}
old := srv.Path()
err = srv.Rebind(ctx, want, acc)
reportRebind(l, old, want, err, srv.Path())
}
c.RegisterReloadCallback(func(c *config.C, _ *config.Reload) {
defer func() {
if r := recover(); r != nil {
l.Error("Recovered from panic reloading the local control socket", "panic", r)
}
}()
reconcile(c)
})
return reconcile
}
// warnUnusable logs a config the endpoint cannot follow: with nothing serving, the
// endpoint is not available; with something serving, it is kept as it is.
func warnUnusable(l *slog.Logger, what, current string, err error) {
if current == "" {
l.Warn("The "+what+" is not available, its config is unusable", "error", err)
return
}
l.Warn("Ignoring unusable "+what+" config from the reload, keeping the current endpoint", "error", err, "current", current)
}
// reportRebind logs what a Rebind did beyond the listening line the bind itself writes:
// nothing for a server left where it was, a move with both paths, and a failure with
// what the operator is left with. old is the path served before the call, "" for none,
// want the one asked for, and now the path served after it: on unix a failed move keeps
// the old socket, and now is old; on windows a change of access closes the pipe before
// creating it again, and a failure there leaves nothing serving, so now is "".
//
// Nearly every failure is the operator's environment, a missing runtime directory or a
// bad path, and a warning; a name held by another process is an error, since nothing
// else will say that something is sitting where the daemon should be.
func reportRebind(l *slog.Logger, old, want string, err error, now string) {
level := l.Warn
if errors.Is(err, errEndpointHeld) {
level = l.Error
}
switch {
case err == nil:
if old != "" && old != want {
l.Info("Moved the local control socket", "from", old, "to", want)
}
case old == "":
level("Could not start the local control socket, control commands will not be available until a reload binds it", "error", err, "path", want)
default:
level("Could not bind the local control socket at the requested path", "error", err, "requested", want, "serving", now)
}
}
// errEndpointHeld is returned by listen when the endpoint's name is already held by
// some other process, which nebula will not serve alongside: whoever holds it would be
// answering nebula ctl. It is only raised on windows, where the default name can be
// held by another administrator's process and an override outside the protected
// namespace by any account's; on unix a path that is still being served is an earlier
// nebula, which clearStale reports as in use.
var errEndpointHeld = errors.New("the local control socket's name is held by another process")
-175
View File
@@ -1,175 +0,0 @@
//go:build !windows
package localapi
import (
"context"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestWireRecoversFromBadPathAtStartup covers a socket path that is unusable when nebula
// starts. The operator's fix is a config edit and a reload, so the reload has to be able
// to bring up a socket that never existed, not only move one that does.
func TestWireRecoversFromBadPathAtStartup(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString(fmt.Sprintf("local_api:\n control:\n socket: /%s\n", strings.Repeat("x", sunPathMax))))
srv := Wire(ctx, test.NewLogger(), c, basicRegistry())
t.Cleanup(srv.Stop)
assert.Empty(t, srv.Path(), "an over-long path must not produce a socket")
good := testSocket(t)
require.NoError(t, c.ReloadConfigString(fmt.Sprintf("local_api:\n control:\n socket: %s\n", good)).Err)
assert.Equal(t, good, srv.Path())
out, errText := run(t, good, "echo", "hi")
assert.Empty(t, errText)
assert.Equal(t, "[hi]", out)
}
// TestRebindAfterReloadBoundTheSocket covers a HUP that lands inside Wire, after the
// reload callback is registered and before the first attempt runs. The callback does the
// first bind; the attempt must then find the socket it was about to create already up
// and leave it, not fail or rebind it, which would have Wire warn that commands are
// unavailable while they are.
func TestRebindAfterReloadBoundTheSocket(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
path := testSocket(t)
cfg := fmt.Sprintf("local_api:\n control:\n socket: %s\n", path)
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString(cfg))
srv := NewServer(test.NewLogger(), basicRegistry())
t.Cleanup(srv.Stop)
// Wire's first half, then the HUP.
followControlConfig(ctx, test.NewLogger(), c, srv)
require.NoError(t, c.ReloadConfigString(cfg).Err)
require.Equal(t, path, srv.Path(), "the reload callback does the first bind")
// Wire's second half.
require.NoError(t, srv.Rebind(ctx, path, ownerOnly()))
assert.Equal(t, path, srv.Path())
out, errText := run(t, path, "echo", "hi")
assert.Empty(t, errText)
assert.Equal(t, "[hi]", out)
}
// TestWireRetriesAFailedMoveOnPlainReload covers a move whose bind fails for a reason
// outside the config: the key names a path under a runtime directory that is not there
// yet. The daemon keeps the old socket, but the client reads the new path from the same
// file and cannot reach it, so the operator creates the directory and reloads. The key
// has not changed since the move was asked for, and the reload still has to make it.
func TestWireRetriesAFailedMoveOnPlainReload(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
section := func(path string) string {
return fmt.Sprintf("local_api:\n control:\n socket: %s\n", path)
}
first := testSocket(t)
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString(section(first)))
srv := Wire(ctx, test.NewLogger(), c, basicRegistry())
t.Cleanup(srv.Stop)
require.Equal(t, first, srv.Path())
runtimeDir := filepath.Join(privateBase(t), "run")
moved := filepath.Join(runtimeDir, DirName, "s.sock")
require.NoError(t, c.ReloadConfigString(section(moved)).Err)
assert.Equal(t, first, srv.Path(), "a move that cannot bind keeps the socket it had")
require.NoError(t, os.Mkdir(runtimeDir, 0700))
require.NoError(t, c.ReloadConfigString(section(moved)).Err)
require.False(t, c.HasChanged(CtlSocketKey), "the config is the same; the fix was on disk")
assert.Equal(t, moved, srv.Path())
_, err := os.Stat(first)
assert.True(t, os.IsNotExist(err), "the old socket is given up once the move binds")
out, errText := run(t, moved, "echo", "hi")
assert.Empty(t, errText)
assert.Equal(t, "[hi]", out)
}
// TestWireRecoversOnPlainReloadAfterBadBind covers a path that is fine but a bind that
// is not: the runtime directory is missing when nebula starts. The fix is made outside
// the config, so the config does not change; a plain reload still has to bring the
// socket up.
func TestWireRecoversOnPlainReloadAfterBadBind(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
base := privateBase(t)
runtimeDir := filepath.Join(base, "run")
path := filepath.Join(runtimeDir, DirName, "s.sock")
cfg := fmt.Sprintf("local_api:\n control:\n socket: %s\n", path)
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString(cfg))
srv := Wire(ctx, test.NewLogger(), c, basicRegistry())
t.Cleanup(srv.Stop)
assert.Empty(t, srv.Path(), "listen creates one level only, so a missing runtime dir fails the bind")
require.NoError(t, os.Mkdir(runtimeDir, 0700))
require.NoError(t, c.ReloadConfigString(cfg).Err)
require.False(t, c.HasChanged(CtlSocketKey), "the config is the same; the fix was on disk")
assert.Equal(t, path, srv.Path())
out, errText := run(t, path, "echo", "hi")
assert.Empty(t, errText)
assert.Equal(t, "[hi]", out)
// And a reload with a socket up and no change in the key is still a no-op.
require.NoError(t, c.ReloadConfigString(cfg).Err)
assert.Equal(t, path, srv.Path())
out, errText = run(t, path, "echo", "still")
assert.Empty(t, errText)
assert.Equal(t, "[still]", out)
}
// TestWireControlCanBeDisabled: local_api.control.enabled false serves no socket, and
// the key follows reloads both ways.
func TestWireControlCanBeDisabled(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
path := testSocket(t)
section := func(enabled bool) string {
return fmt.Sprintf("local_api:\n control:\n enabled: %t\n socket: %s\n", enabled, path)
}
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString(section(false)))
srv := Wire(ctx, test.NewLogger(), c, basicRegistry())
t.Cleanup(srv.Stop)
assert.Empty(t, srv.Path())
_, err := os.Lstat(path)
assert.True(t, os.IsNotExist(err), "no socket is bound")
require.NoError(t, c.ReloadConfigString(section(true)).Err)
assert.Equal(t, path, srv.Path())
out, errText := run(t, path, "echo", "on")
assert.Empty(t, errText)
assert.Equal(t, "[on]", out)
require.NoError(t, c.ReloadConfigString(section(false)).Err)
assert.Empty(t, srv.Path())
_, err = os.Lstat(path)
assert.True(t, os.IsNotExist(err), "the socket is removed")
}
+41 -5
View File
@@ -1,12 +1,27 @@
package batch package batch
import "net/netip" import (
"net/netip"
"github.com/slackhq/nebula/header"
)
const SendBatchCap = 128 const SendBatchCap = 128
// FailureHeadLen is how much of a refused packet a Failure keeps, nebula's header, which says whose packet it was
const FailureHeadLen = header.Len
// batchWriter is the minimal subset of udp.Conn needed by SendBatch to flush. // batchWriter is the minimal subset of udp.Conn needed by SendBatch to flush.
type batchWriter interface { type batchWriter interface {
WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error)
}
// Failure is a packet the underlay would not send
type Failure struct {
// Head is the start of the packet, zero padded if the packet was shorter
Head [FailureHeadLen]byte
Dst netip.AddrPort
Err error
} }
// SendBatch accumulates encrypted UDP packets and flushes them via WriteBatch. // SendBatch accumulates encrypted UDP packets and flushes them via WriteBatch.
@@ -17,16 +32,28 @@ type SendBatch struct {
bufs [][]byte bufs [][]byte
dsts []netip.AddrPort dsts []netip.AddrPort
arena *Arena arena *Arena
failures []Failure
// recordFailure is bound once so handing it to WriteBatch does not allocate on every Flush
recordFailure func(i int, err error)
} }
// NewSendBatch makes a SendBatch with batchCap slots and an arenaSize byte buffer for slices to back those slots // NewSendBatch makes a SendBatch with batchCap slots and an arenaSize byte buffer for slices to back those slots
func NewSendBatch(out batchWriter, batchCap, arenaSize int) *SendBatch { func NewSendBatch(out batchWriter, batchCap, arenaSize int) *SendBatch {
return &SendBatch{ b := &SendBatch{
out: out, out: out,
bufs: make([][]byte, 0, batchCap), bufs: make([][]byte, 0, batchCap),
dsts: make([]netip.AddrPort, 0, batchCap), dsts: make([]netip.AddrPort, 0, batchCap),
arena: NewArena(arenaSize), arena: NewArena(arenaSize),
} }
b.recordFailure = b.failed
return b
}
func (b *SendBatch) failed(i int, err error) {
f := Failure{Dst: b.dsts[i], Err: err}
copy(f.Head[:], b.bufs[i])
b.failures = append(b.failures, f)
} }
func (b *SendBatch) Reserve(sz int) []byte { func (b *SendBatch) Reserve(sz int) []byte {
@@ -44,12 +71,15 @@ func (b *SendBatch) Commit(pkt []byte, dst netip.AddrPort) {
} }
// Flush writes every queued packet and reports how many actually went out. A short count means some destinations // Flush writes every queued packet and reports how many actually went out. A short count means some destinations
// were undeliverable; the batch is drained either way. // were undeliverable, Failures says which; the batch is drained either way.
func (b *SendBatch) Flush() (int, error) { func (b *SendBatch) Flush() (int, error) {
clear(b.failures)
b.failures = b.failures[:0]
var err error var err error
written := 0 written := 0
if len(b.bufs) > 0 { if len(b.bufs) > 0 {
written, err = b.out.WriteBatch(b.bufs, b.dsts) written, err = b.out.WriteBatch(b.bufs, b.dsts, b.recordFailure)
} }
clear(b.bufs) clear(b.bufs)
b.bufs = b.bufs[:0] b.bufs = b.bufs[:0]
@@ -57,3 +87,9 @@ func (b *SendBatch) Flush() (int, error) {
b.arena.Reset() b.arena.Reset()
return written, err return written, err
} }
// Failures returns every packet the last Flush could not send, in the order they were committed. Valid until the
// next Flush.
func (b *SendBatch) Failures() []Failure {
return b.failures
}
+84 -1
View File
@@ -1,7 +1,9 @@
package batch package batch
import ( import (
"errors"
"net/netip" "net/netip"
"slices"
"testing" "testing"
) )
@@ -10,7 +12,7 @@ type fakeBatchWriter struct {
addrs []netip.AddrPort addrs []netip.AddrPort
} }
func (w *fakeBatchWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (w *fakeBatchWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, _ func(int, error)) (int, error) {
// Snapshot — SendBatch.Flush nils its slot pointers right after WriteBatch // Snapshot — SendBatch.Flush nils its slot pointers right after WriteBatch
// returns, so tests must capture data before that happens. // returns, so tests must capture data before that happens.
w.bufs = make([][]byte, len(bufs)) w.bufs = make([][]byte, len(bufs))
@@ -120,3 +122,84 @@ func TestSendBatchGrowPreservesCommitted(t *testing.T) {
t.Errorf("second packet on the wire: %x", fw.bufs[1]) t.Errorf("second packet on the wire: %x", fw.bufs[1])
} }
} }
// failingBatchWriter refuses every packet whose first byte is in refuse
type failingBatchWriter struct {
refuse map[byte]error
}
func (w *failingBatchWriter) WriteBatch(bufs [][]byte, _ []netip.AddrPort, failed func(int, error)) (int, error) {
written := 0
for i, b := range bufs {
if err, ok := w.refuse[b[0]]; ok {
failed(i, err)
continue
}
written++
}
return written, nil
}
func TestSendBatchReportsFailures(t *testing.T) {
errNoRoute := errors.New("no route")
fw := &failingBatchWriter{refuse: map[byte]error{2: errNoRoute, 3: errNoRoute}}
b := NewSendBatch(fw, 4, 128)
// pkt is n bytes starting with the refuse key, each later byte its offset plus 0x10 so the head is recognizable
pkt := func(key byte, n int) []byte {
p := b.Reserve(n)[:n]
p[0] = key
for i := 1; i < n; i++ {
p[i] = byte(0x10 + i)
}
return p
}
head := func(p []byte) (h [FailureHeadLen]byte) {
copy(h[:], p)
return h
}
dsts := []netip.AddrPort{
netip.MustParseAddrPort("10.0.0.1:4242"),
netip.MustParseAddrPort("[fd00::2]:4242"),
netip.MustParseAddrPort("[fd00::3]:4242"),
netip.MustParseAddrPort("10.0.0.4:4242"),
}
long := pkt(2, FailureHeadLen+8) // only its head is kept
short := pkt(3, 4) // zero padded
b.Commit(pkt(1, 20), dsts[0])
b.Commit(long, dsts[1])
b.Commit(short, dsts[2])
b.Commit(pkt(1, 20), dsts[3])
written, err := b.Flush()
if err != nil {
t.Fatalf("Flush: %v", err)
}
if written != 2 {
t.Errorf("written = %d, want 2", written)
}
want := []Failure{{head(long), dsts[1], errNoRoute}, {head(short), dsts[2], errNoRoute}}
if got := b.Failures(); !slices.Equal(got, want) {
t.Errorf("failures = %v, want %v", got, want)
}
// Failures do not leak into the next flush
again := pkt(2, 20)
b.Commit(again, dsts[0])
if _, err := b.Flush(); err != nil {
t.Fatalf("Flush: %v", err)
}
if want := []Failure{{head(again), dsts[0], errNoRoute}}; !slices.Equal(b.Failures(), want) {
t.Errorf("second flush failures = %v, want %v", b.Failures(), want)
}
// A clean flush forgets the last one's failures
b.Commit(pkt(1, 20), dsts[0])
if _, err := b.Flush(); err != nil {
t.Fatalf("Flush: %v", err)
}
if got := b.Failures(); len(got) != 0 {
t.Errorf("clean flush failures = %v, want none", got)
}
}
+3 -13
View File
@@ -20,7 +20,6 @@ type offloadQueueSet struct {
// usoEnabled is true when newTun successfully negotiated TUN_F_USO4|6 with the kernel. // usoEnabled is true when newTun successfully negotiated TUN_F_USO4|6 with the kernel.
// Queues created by Add inherit this and surface it via Offload.USOSupported so coalescers can gate USO emission. // Queues created by Add inherit this and surface it via Offload.USOSupported so coalescers can gate USO emission.
usoEnabled bool usoEnabled bool
shutdown atomic.Bool
closed atomic.Bool closed atomic.Bool
// l is handed to each queue for its bad-vnet-header drop logging. // l is handed to each queue for its bad-vnet-header drop logging.
l *slog.Logger l *slog.Logger
@@ -70,17 +69,6 @@ func (c *offloadQueueSet) wakeForShutdown() error {
return err return err
} }
// Shutdown wakes every reader without releasing any fds, they see POLLIN on the eventfd and return os.ErrClosed
func (c *offloadQueueSet) Shutdown() error {
if c.shutdown.Swap(true) {
return nil
}
for _, x := range c.pq {
x.shutdown.Store(true)
}
return c.wakeForShutdown()
}
func (c *offloadQueueSet) Close() error { func (c *offloadQueueSet) Close() error {
if c.closed.Swap(true) { if c.closed.Swap(true) {
return nil return nil
@@ -88,7 +76,9 @@ func (c *offloadQueueSet) Close() error {
errs := []error{} errs := []error{}
if err := c.Shutdown(); err != nil { // Signal all readers blocked in poll to wake up and exit.
// They observe POLLIN on the shutdown eventfd and return os.ErrClosed.
if err := c.wakeForShutdown(); err != nil {
errs = append(errs, err) errs = append(errs, err)
} }
+3 -13
View File
@@ -16,7 +16,6 @@ type pollQueueSet struct {
// pqi is exactly the same as pq, but stored as the interface type // pqi is exactly the same as pq, but stored as the interface type
pqi []Queue pqi []Queue
shutdownFd int shutdownFd int
shutdown atomic.Bool
closed atomic.Bool closed atomic.Bool
} }
@@ -60,17 +59,6 @@ func (c *pollQueueSet) wakeForShutdown() error {
return err return err
} }
// Shutdown wakes every reader without releasing any fds, they see POLLIN on the eventfd and return os.ErrClosed
func (c *pollQueueSet) Shutdown() error {
if c.shutdown.Swap(true) {
return nil
}
for _, x := range c.pq {
x.shutdown.Store(true)
}
return c.wakeForShutdown()
}
func (c *pollQueueSet) Close() error { func (c *pollQueueSet) Close() error {
if c.closed.Swap(true) { if c.closed.Swap(true) {
return nil return nil
@@ -78,7 +66,9 @@ func (c *pollQueueSet) Close() error {
errs := []error{} errs := []error{}
if err := c.Shutdown(); err != nil { // Signal all readers blocked in poll to wake up and exit.
// They observe POLLIN on the shutdown eventfd and return os.ErrClosed.
if err := c.wakeForShutdown(); err != nil {
errs = append(errs, err) errs = append(errs, err)
} }
-2
View File
@@ -7,8 +7,6 @@ import (
// QueueSet holds one or many Queue objects and helps close them in an orderly way. // QueueSet holds one or many Queue objects and helps close them in an orderly way.
type QueueSet interface { type QueueSet interface {
io.Closer io.Closer
// Shutdown wakes every reader without releasing any fds, Close only once they have exited
Shutdown() error
Queues() []Queue Queues() []Queue
// Add takes a tun fd, adds it to the set, and prepares it for use as a Queue. // Add takes a tun fd, adds it to the set, and prepares it for use as a Queue.
+1 -6
View File
@@ -66,9 +66,7 @@ type Offload struct {
// usoEnabled records whether the kernel agreed to TUN_F_USO* on this FD, // usoEnabled records whether the kernel agreed to TUN_F_USO* on this FD,
// so writers can decide whether emitting GSO_UDP_L4 superpackets is safe. // so writers can decide whether emitting GSO_UDP_L4 superpackets is safe.
usoEnabled bool usoEnabled bool
// shutdown is set before shutdownFd is signaled, a busy reader never polls to see that closed atomic.Bool
shutdown atomic.Bool
closed atomic.Bool
// gsoHdrBuf is a per-queue 10-byte scratch for the virtio_net_hdr emitted // gsoHdrBuf is a per-queue 10-byte scratch for the virtio_net_hdr emitted
// by WriteGSO. Kept separate from the read-only package-level validVnetHdr // by WriteGSO. Kept separate from the read-only package-level validVnetHdr
@@ -178,9 +176,6 @@ func (r *Offload) readPacket(block bool) (int, error) {
// This amortizes the poll wake over bursts of small packets (e.g. TCP ACKs). // This amortizes the poll wake over bursts of small packets (e.g. TCP ACKs).
// Packet.Bytes slices point into the Offload's internal buffer and are only valid until the next Read or Close on this Queue. // Packet.Bytes slices point into the Offload's internal buffer and are only valid until the next Read or Close on this Queue.
func (r *Offload) Read() ([]Packet, error) { func (r *Offload) Read() ([]Packet, error) {
if r.shutdown.Load() {
return nil, os.ErrClosed
}
r.pending = r.pending[:0] r.pending = r.pending[:0]
r.rxOff = 0 r.rxOff = 0
+1 -6
View File
@@ -13,9 +13,7 @@ import (
type Poll struct { type Poll struct {
fd int fd int
shutdownFd int shutdownFd int
// shutdown is set before shutdownFd is signaled, a busy reader never polls to see that closed atomic.Bool
shutdown atomic.Bool
closed atomic.Bool
readBuf []byte readBuf []byte
batchRet [1]Packet batchRet [1]Packet
@@ -54,9 +52,6 @@ func (t *Poll) blockOnWrite() error {
// config currently lose that batching. blockOn and the EAGAIN plumbing are // config currently lose that batching. blockOn and the EAGAIN plumbing are
// already shared; kept one-packet-per-Read for now to preserve behavior. // already shared; kept one-packet-per-Read for now to preserve behavior.
func (t *Poll) Read() ([]Packet, error) { func (t *Poll) Read() ([]Packet, error) {
if t.shutdown.Load() {
return nil, os.ErrClosed
}
n, err := t.readOne(t.readBuf) n, err := t.readOne(t.readBuf)
if err != nil { if err != nil {
return nil, err return nil, err
-27
View File
@@ -223,30 +223,3 @@ func TestOffloadQueueSet_Close_ClosesShutdownFd(t *testing.T) {
// Second Close must not touch fds (shutdownFd is now -1) and must return nil. // Second Close must not touch fds (shutdownFd is now -1) and must return nil.
require.NoError(t, qs.Close()) require.NoError(t, qs.Close())
} }
// A busy reader never polls the shutdown eventfd, so Read has to stop on its own with data still waiting
func TestQueueSet_ShutdownStopsReaderWithDataWaiting(t *testing.T) {
sets := map[string]func() (QueueSet, error){
"poll": NewPollQueueSet,
"offload": func() (QueueSet, error) { return NewOffloadQueueSet(false, slog.New(slog.DiscardHandler)) },
}
for name, newSet := range sets {
t.Run(name, func(t *testing.T) {
var fds [2]int
require.NoError(t, unix.Pipe2(fds[:], unix.O_CLOEXEC))
t.Cleanup(func() { _ = unix.Close(fds[1]) })
qs, err := newSet()
require.NoError(t, err)
require.NoError(t, qs.Add(fds[0]))
t.Cleanup(func() { _ = qs.Close() })
_, err = unix.Write(fds[1], make([]byte, 64))
require.NoError(t, err)
require.NoError(t, qs.Shutdown())
_, err = qs.Queues()[0].Read()
require.ErrorIs(t, err, os.ErrClosed)
})
}
}
-5
View File
@@ -832,11 +832,6 @@ func (t *tun) updateRoutes(r netlink.RouteUpdate) {
t.routeTree.Store(newTree) t.routeTree.Store(newTree)
} }
// Shutdown wakes the tun readers without releasing their fds, Close releases them
func (t *tun) Shutdown() error {
return t.readers.Shutdown()
}
func (t *tun) Close() error { func (t *tun) Close() error {
t.closeLock.Lock() t.closeLock.Lock()
defer t.closeLock.Unlock() defer t.closeLock.Unlock()
+19 -10
View File
@@ -165,20 +165,24 @@ func (p *Punchy) scheduleJob(job holepunchJob, delay time.Duration) {
// SendPunch sends an immediate keepalive punch for an idle hostinfo. // SendPunch sends an immediate keepalive punch for an idle hostinfo.
// The configured punchy.target_all_remotes mode picks the targets. Gated on punchy.punch and the lighthouse-skip rule // The configured punchy.target_all_remotes mode picks the targets. Gated on punchy.punch and the lighthouse-skip rule
// (lighthouses don't get keepalive punches because the regular update interval keeps their NAT state warm). // (lighthouses don't get keepalive punches because the regular update interval keeps their NAT state warm).
func (p *Punchy) SendPunch(hostinfo *HostInfo) { // Returns the hostinfo's current remote and the error from punching it, an invalid remote if it was not punched.
func (p *Punchy) SendPunch(hostinfo *HostInfo) (netip.AddrPort, error) {
if !p.punch.Load() { if !p.punch.Load() {
return return netip.AddrPort{}, nil
} }
if p.lh.IsAnyLighthouseAddr(hostinfo.vpnAddrs) { if p.lh.IsAnyLighthouseAddr(hostinfo.vpnAddrs) {
return return netip.AddrPort{}, nil
} }
hr := hostinfo.GetRemote()
if p.punchEverything.Load() { if p.punchEverything.Load() {
p.sendPunchToAllRemotes(hostinfo) return hr, p.sendPunchToAllRemotes(hostinfo, hr)
} else if hr := hostinfo.GetRemote(); hr.IsValid() {
p.metricPunchyTx.Inc(1)
p.punchConn.WriteTo([]byte{1}, hr)
} }
if !hr.IsValid() {
return hr, nil
}
p.metricPunchyTx.Inc(1)
return hr, p.punchConn.WriteTo([]byte{1}, hr)
} }
// SendPunchToAll punches every known remote for hostinfo, but only when punchy.target_all_remotes is enabled. // SendPunchToAll punches every known remote for hostinfo, but only when punchy.target_all_remotes is enabled.
@@ -195,14 +199,19 @@ func (p *Punchy) SendPunchToAll(hostinfo *HostInfo) {
if p.lh.IsAnyLighthouseAddr(hostinfo.vpnAddrs) { if p.lh.IsAnyLighthouseAddr(hostinfo.vpnAddrs) {
return return
} }
p.sendPunchToAllRemotes(hostinfo) p.sendPunchToAllRemotes(hostinfo, netip.AddrPort{})
} }
func (p *Punchy) sendPunchToAllRemotes(hostinfo *HostInfo) { // sendPunchToAllRemotes punches every known remote for hostinfo and returns the error from punching current
func (p *Punchy) sendPunchToAllRemotes(hostinfo *HostInfo, current netip.AddrPort) error {
var currentErr error
hostinfo.remotes.ForEach(p.hm.GetPreferredRanges(), func(addr netip.AddrPort, preferred bool) { hostinfo.remotes.ForEach(p.hm.GetPreferredRanges(), func(addr netip.AddrPort, preferred bool) {
p.metricPunchyTx.Inc(1) p.metricPunchyTx.Inc(1)
p.punchConn.WriteTo([]byte{1}, addr) if err := p.punchConn.WriteTo([]byte{1}, addr); addr == current {
currentErr = err
}
}) })
return currentErr
} }
// Start wires the runtime dependencies and spawns the scheduler worker. // Start wires the runtime dependencies and spawns the scheduler worker.
+112
View File
@@ -3,11 +3,14 @@ package nebula
import ( import (
"context" "context"
"log/slog" "log/slog"
"net/netip"
"testing" "testing"
"time" "time"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/header"
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
"github.com/slackhq/nebula/udp"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
@@ -242,3 +245,112 @@ func TestPunchyReloadRestartRequired(t *testing.T) {
require.NoError(t, res.Err) require.NoError(t, res.Err)
assert.True(t, res.RestartRequired) assert.True(t, res.RestartRequired)
} }
// errNoRoute is the unreachable error every platform classifies the same way
var errNoRoute = udp.ErrInvalidIPv6RemoteForSocket
// recordingConn records where every write went and what kind of message it was, and fails the ones to an address in
// fail
type recordingConn struct {
udp.NoopConn
fail map[netip.AddrPort]error
wrote []netip.AddrPort
// types is the message type of each write, a punch has none
types []header.MessageType
}
func (c *recordingConn) WriteTo(b []byte, addr netip.AddrPort) error {
c.wrote = append(c.wrote, addr)
var h header.H
if h.Parse(b) == nil {
c.types = append(c.types, h.Type)
}
return c.fail[addr]
}
func (c *recordingConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(int, error)) (int, error) {
written := 0
for i := range bufs {
if err := c.WriteTo(bufs[i], addrs[i]); err != nil {
failed(i, err)
continue
}
written++
}
return written, nil
}
type noLighthouses struct{}
func (noLighthouses) IsAnyLighthouseAddr([]netip.Addr) bool { return false }
var (
punchTargetV4 = netip.MustParseAddrPort("10.0.0.3:4242")
punchTargetV6 = netip.MustParseAddrPort("[fd00::3]:4242")
)
// newPunchTarget is a tunnel on its IPv6 remote that also knows the peer's IPv4 one
func newPunchTarget() *HostInfo {
vpnAddr := netip.MustParseAddr("10.128.0.3")
hostinfo := &HostInfo{
vpnAddrs: []netip.Addr{vpnAddr},
remotes: NewRemoteList([]netip.Addr{vpnAddr}, nil),
}
hostinfo.remotes.LearnRemote(vpnAddr, punchTargetV4)
hostinfo.SetRemote(punchTargetV6)
return hostinfo
}
func newPunchyForTest(t *testing.T, settings map[string]any, conn udp.Conn) *Punchy {
c := config.NewC(test.NewLogger())
c.Settings["punchy"] = settings
p := NewPunchyFromConfig(test.NewLogger(), c, conn)
hm := newHostMap(test.NewLogger())
hm.preferredRanges.Store(&[]netip.Prefix{})
p.hm = hm
p.lh = noLighthouses{}
return p
}
func TestPunchy_SendPunchReportsCurrentRemote(t *testing.T) {
t.Run("disabled", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
p := newPunchyForTest(t, map[string]any{"punch": false}, conn)
remote, err := p.SendPunch(newPunchTarget())
assert.False(t, remote.IsValid())
require.NoError(t, err)
assert.Empty(t, conn.wrote)
})
t.Run("current remote", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
p := newPunchyForTest(t, map[string]any{"punch": true}, conn)
remote, err := p.SendPunch(newPunchTarget())
assert.Equal(t, punchTargetV6, remote)
require.ErrorIs(t, err, errNoRoute)
assert.Equal(t, []netip.AddrPort{punchTargetV6}, conn.wrote)
})
t.Run("all remotes, current fails", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV6: errNoRoute}}
p := newPunchyForTest(t, map[string]any{"punch": true, "target_all_remotes": true}, conn)
remote, err := p.SendPunch(newPunchTarget())
assert.Equal(t, punchTargetV6, remote)
require.ErrorIs(t, err, errNoRoute)
assert.ElementsMatch(t, []netip.AddrPort{punchTargetV4, punchTargetV6}, conn.wrote)
})
t.Run("all remotes, only another fails", func(t *testing.T) {
conn := &recordingConn{fail: map[netip.AddrPort]error{punchTargetV4: errNoRoute}}
p := newPunchyForTest(t, map[string]any{"punch": true, "target_all_remotes": true}, conn)
remote, err := p.SendPunch(newPunchTarget())
assert.Equal(t, punchTargetV6, remote)
require.NoError(t, err, "a failure on a remote we are not using says nothing about the current one")
assert.ElementsMatch(t, []netip.AddrPort{punchTargetV4, punchTargetV6}, conn.wrote)
})
}
-4
View File
@@ -528,10 +528,6 @@ func (rm *relayManager) handleCreateRelayRequest(v cert.Version, h *HostInfo, f
if !rm.GetAmRelay() { if !rm.GetAmRelay() {
return return
} }
if !slices.Contains(h.vpnAddrs, from) {
logMsg.Info("Discarding relay request where relayFrom is not the sending peer")
return
}
peer := rm.hostmap.QueryVpnAddr(target) peer := rm.hostmap.QueryVpnAddr(target)
if peer == nil { if peer == nil {
// Try to establish a connection to this host. If we get a future relay request, // Try to establish a connection to this host. If we get a future relay request,
-57
View File
@@ -7,10 +7,8 @@ import (
"testing" "testing"
"github.com/gaissmai/bart" "github.com/gaissmai/bart"
"github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
// TestStartRelaysLogDedupe verifies that repeated attempts with the same relay set drop the log // TestStartRelaysLogDedupe verifies that repeated attempts with the same relay set drop the log
@@ -97,58 +95,3 @@ func TestStartRelaysLogDedupe(t *testing.T) {
assert.NotContains(t, buf.String(), msg, "should not log when we shortcut out") assert.NotContains(t, buf.String(), msg, "should not log when we shortcut out")
}) })
} }
// TestHandleCreateRelayRequestRejectsSpoofedFrom verifies that a relay only forwards a CreateRelayRequest
// when relayFrom is the peer that sent it. Otherwise any peer could reset another host's established
// relay back to Requested, or allocate unbounded relay entries on the target's hostinfo.
func TestHandleCreateRelayRequestRejectsSpoofedFrom(t *testing.T) {
l := test.NewLogger()
relayAddr := netip.MustParseAddr("10.128.0.128")
malloryAddr := netip.MustParseAddr("10.128.0.3")
victimAddr := netip.MustParseAddr("10.128.0.1")
targetAddr := netip.MustParseAddr("10.128.0.2")
addrTable := new(bart.Lite)
addrTable.Insert(netip.PrefixFrom(relayAddr, relayAddr.BitLen()))
hm := newHostMap(l)
f := &Interface{myVpnAddrsTable: addrTable, hostMap: hm}
rm := &relayManager{l: l, hostmap: hm}
rm.amRelay.Store(true)
newRelayState := func() RelayState {
return RelayState{relayForByAddr: map[netip.Addr]*Relay{}, relayForByIdx: map[uint32]*Relay{}}
}
mallory := &HostInfo{vpnAddrs: []netip.Addr{malloryAddr}, localIndexId: 1, relayState: newRelayState()}
target := &HostInfo{
vpnAddrs: []netip.Addr{targetAddr},
localIndexId: 2,
remotes: NewRemoteList([]netip.Addr{targetAddr}, nil),
relayState: newRelayState(),
}
target.SetRemote(netip.MustParseAddrPort("192.0.2.2:4242"))
hm.unlockedAddHostInfo(mallory, f)
hm.unlockedAddHostInfo(target, f)
// The victim already has a working relay to the target through us.
_, err := AddRelay(l, target, hm, victimAddr, nil, ForwardingType, Established)
require.NoError(t, err)
relaysBefore := len(hm.Relays)
for i := range 10 {
spoofed := netip.AddrFrom4([4]byte{10, 128, 1, byte(i)})
for _, from := range []netip.Addr{victimAddr, spoofed} {
rm.handleCreateRelayRequest(cert.Version2, mallory, f, &NebulaControl{
Type: NebulaControl_CreateRelayRequest,
InitiatorRelayIndex: uint32(100 + i),
RelayFromAddr: netAddrToProtoAddr(from),
RelayToAddr: netAddrToProtoAddr(targetAddr),
})
}
}
r, ok := target.relayState.QueryRelayForByIp(victimAddr)
require.True(t, ok)
assert.Equal(t, Established, r.State, "victim's relay must not be reset by a request from another peer")
assert.Len(t, hm.Relays, relaysBefore, "spoofed requests must not allocate relay entries")
assert.Empty(t, mallory.relayState.CopyAllRelayFor(), "spoofed requests must not create state on the sender")
}
+4 -12
View File
@@ -460,14 +460,10 @@ func (r *RemoteList) unlockedSetV4(ownerVpnIp, vpnIp netip.Addr, to []*V4AddrPor
// Reset the slice // Reset the slice
c.reported = c.reported[:0] c.reported = c.reported[:0]
// We can't take their array but we can take their pointers. // We can't take their array but we can take their pointers
// Filter before capping so denied addrs do not crowd out allowed ones reported later in the list. for _, v := range to[:minInt(len(to), MaxRemotes)] {
for _, v := range to {
if check(vpnIp, v) { if check(vpnIp, v) {
c.reported = append(c.reported, v) c.reported = append(c.reported, v)
if len(c.reported) == MaxRemotes {
break
}
} }
} }
} }
@@ -512,14 +508,10 @@ func (r *RemoteList) unlockedSetV6(ownerVpnIp, vpnIp netip.Addr, to []*V6AddrPor
// Reset the slice // Reset the slice
c.reported = c.reported[:0] c.reported = c.reported[:0]
// We can't take their array but we can take their pointers. // We can't take their array but we can take their pointers
// Filter before capping so denied addrs do not crowd out allowed ones reported later in the list. for _, v := range to[:minInt(len(to), MaxRemotes)] {
for _, v := range to {
if check(vpnIp, v) { if check(vpnIp, v) {
c.reported = append(c.reported, v) c.reported = append(c.reported, v)
if len(c.reported) == MaxRemotes {
break
}
} }
} }
} }
-36
View File
@@ -2,7 +2,6 @@ package nebula
import ( import (
"encoding/binary" "encoding/binary"
"fmt"
"net/netip" "net/netip"
"testing" "testing"
@@ -347,38 +346,3 @@ func newIp6AndPortFromString(s string) *V6AddrPort {
Port: uint32(a.Port()), Port: uint32(a.Port()),
} }
} }
func TestRemoteList_SetFiltersBeforeCap(t *testing.T) {
owner := netip.MustParseAddr("0.0.0.0")
rl := NewRemoteList([]netip.Addr{owner}, nil)
// MaxRemotes denied addrs first, then the only allowed one, then enough allowed to exceed the cap
var v4 []*V4AddrPort
for i := 0; i < MaxRemotes; i++ {
v4 = append(v4, newIp4AndPortFromString(fmt.Sprintf("172.17.0.%d:4242", i+1)))
}
for i := 0; i < MaxRemotes+1; i++ {
v4 = append(v4, newIp4AndPortFromString(fmt.Sprintf("70.199.182.%d:4242", i+1)))
}
rl.unlockedSetV4(owner, owner, v4, func(_ netip.Addr, a *V4AddrPort) bool {
return protoV4AddrPortToNetAddrPort(a).Addr().As4()[0] != 172
})
var v6 []*V6AddrPort
for i := 0; i < MaxRemotes; i++ {
v6 = append(v6, newIp6AndPortFromString(fmt.Sprintf("[fd00::%d]:4242", i+1)))
}
for i := 0; i < MaxRemotes+1; i++ {
v6 = append(v6, newIp6AndPortFromString(fmt.Sprintf("[2001:db8::%d]:4242", i+1)))
}
rl.unlockedSetV6(owner, owner, v6, func(_ netip.Addr, a *V6AddrPort) bool {
return protoV6AddrPortToNetAddrPort(a).Addr().As16()[0] != 0xfd
})
rl.Rebuild([]netip.Prefix{})
assert.Len(t, rl.addrs, MaxRemotes*2)
for _, a := range rl.addrs {
assert.NotEqual(t, byte(172), a.Addr().As16()[12], "denied v4 addr %v was kept", a)
assert.NotEqual(t, byte(0xfd), a.Addr().As16()[0], "denied v6 addr %v was kept", a)
}
}
+13 -56
View File
@@ -4,22 +4,20 @@ import (
"bytes" "bytes"
"fmt" "fmt"
"path/filepath" "path/filepath"
"sort" "strings"
"testing" "testing"
"github.com/slackhq/nebula/commands" "github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
) )
// TestSSHCommandSurface is a characterization test for the ssh command surface. // TestSSHCommandSurface is a characterization test for the ssh command surface.
// It pins the registered command set, their descriptions, help text and flag definitions // It pins the registered command set, their descriptions, help text and flag definitions
// so that moving the registry to a transport neutral package is provably a relocation // so that moving the registry to a transport neutral package is provably a relocation
// rather than a rewrite. Regenerate with `go test . -run TestSSHCommandSurface -update`. // rather than a rewrite. Regenerate with `go test . -run TestSSHCommandSurface -update`.
func TestSSHCommandSurface(t *testing.T) { func TestSSHCommandSurface(t *testing.T) {
got := renderCommandSurface(registeredCommands(t).Schema()) got := renderCommandSurface(registeredCommands(t).All())
test.Golden(t, filepath.Join("testdata", "ssh_commands.golden"), got) test.Golden(t, filepath.Join("testdata", "ssh_commands.golden"), got)
} }
@@ -33,68 +31,27 @@ func registeredCommands(t *testing.T) *commands.Registry {
return reg return reg
} }
// renderCommandSurface prints what a client actually sees, which is the schema rather func renderCommandSurface(cmds []*commands.Command) string {
// than the Command structs: the presentation flags are offered on every command that
// returns a value, so reading Command.Flags alone would under-report the surface.
func renderCommandSurface(cmds []commands.CommandSchema) string {
lines := make([]string, 0, len(cmds)) lines := make([]string, 0, len(cmds))
for _, cmd := range cmds { for _, cmd := range cmds {
b := &bytes.Buffer{} b := &bytes.Buffer{}
fmt.Fprintf(b, "%s\n", cmd.Name) fmt.Fprintf(b, "%s\n", cmd.Name)
fmt.Fprintf(b, " short: %s\n", cmd.Short) fmt.Fprintf(b, " short: %s\n", cmd.ShortDescription)
fmt.Fprintf(b, " help: %s\n", cmd.Help) fmt.Fprintf(b, " help: %s\n", cmd.Help)
if len(cmd.Flags) > 0 { if cmd.Flags != nil {
fmt.Fprintf(b, " flags:\n") fl, _ := cmd.Flags()
for _, f := range cmd.Flags { if fl != nil {
kind := " string" fb := &bytes.Buffer{}
if f.Bool { fl.SetOutput(fb)
kind = "" fl.PrintDefaults()
} fmt.Fprintf(b, " flags:\n%s", fb.String())
fmt.Fprintf(b, " -%s%s\n \t%s\n", f.Name, kind, f.Usage)
} }
} }
lines = append(lines, b.String()) lines = append(lines, b.String())
} }
sort.Strings(lines) // In the order All gives, so the golden pins display order too.
return joinLines(lines) return strings.Join(lines, "")
}
func joinLines(in []string) string {
b := &bytes.Buffer{}
for _, l := range in {
b.WriteString(l)
}
return b.String()
}
// TestLocalSocketSurface pins which of nebula's commands the always-on local socket
// serves: every one registered. Adding a command fails here until the list below says
// so, which turns "somebody forgot to think about it" into a visible decision.
func TestLocalSocketSurface(t *testing.T) {
var served []commands.Name
for _, c := range registeredCommands(t).All() {
served = append(served, c.Name)
}
assert.ElementsMatch(t, []commands.Name{
commands.Help,
commands.ListHostmap,
commands.ListPendingHostmap,
commands.ListLighthouseAddrmap,
commands.PrintCert,
commands.PrintTunnel,
commands.PrintRelays,
commands.DeviceInfo,
commands.Version,
commands.QueryLighthouse,
commands.Reload,
commands.LogLevel,
commands.LogFormat,
commands.ChangeRemote,
commands.CloseTunnel,
commands.CreateTunnel,
}, served)
} }
+52 -12
View File
@@ -1,16 +1,32 @@
package nebula package nebula
import ( import (
"errors"
"io"
"os" "os"
"path/filepath" "path/filepath"
"testing" "testing"
"github.com/slackhq/nebula/commands"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
type lineWriter struct {
lines []string
err error
}
func (w *lineWriter) WriteLine(s string) error {
w.lines = append(w.lines, s)
return w.err
}
func (w *lineWriter) Write(s string) error { return w.WriteLine(s) }
func (w *lineWriter) WriteBytes(b []byte) error { return w.WriteLine(string(b)) }
func (w *lineWriter) GetWriter() io.Writer { return io.Discard }
func TestReloadCommandReportsTheResult(t *testing.T) { func TestReloadCommandReportsTheResult(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
write := func(body string) { write := func(body string) {
@@ -28,27 +44,51 @@ func TestReloadCommandReportsTheResult(t *testing.T) {
} }
}) })
// reload reports what happened. A reload that failed is a refusal, exit 1 over ssh; // reload returns what the client was told. A reload that failed is a commands.Failure
// one that merely needs a restart is not. // to the surface, exit 1 over ssh, with the result line as its message; one that
reload := func(failed bool) string { // merely needs a restart is not.
res := runReload(l, c) reload := func(failed bool) []string {
assert.Equal(t, !failed, res.OK) w := &lineWriter{}
return res.Reason err := reloadCommand(l, c, w)
if failed {
var f *commands.Failure
require.ErrorAs(t, err, &f)
assert.Equal(t, w.lines[len(w.lines)-1], f.Msg)
} else {
require.NoError(t, err)
}
return w.lines
} }
write("a: 2\nb: 1") write("a: 2\nb: 1")
assert.Equal(t, "Config reload complete", reload(false)) assert.Equal(t, []string{"Reloading config", "Config reload complete"}, reload(false))
fail = true fail = true
write("a: 3\nb: 1") write("a: 3\nb: 1")
assert.Equal(t, "Config reload completed with errors, review the logs", reload(true)) assert.Equal(t, []string{"Reloading config", "Config reload completed with errors, review the logs"}, reload(true))
fail = false fail = false
write("a: 3\nb: 2") write("a: 3\nb: 2")
assert.Equal(t, "Config reload was completed but requires a restart to fully apply, keys [b]", reload(false)) assert.Equal(t, []string{"Reloading config", "Config reload was completed but requires a restart to fully apply, keys [b]"}, reload(false))
write("a: [") write("a: [")
reason := reload(true) lines := reload(true)
assert.Contains(t, reason, "Config reload failed, the new config did not load") require.Len(t, lines, 2)
assert.Contains(t, reason, dir, "names the config that did not load") assert.Contains(t, lines[1], "Config reload failed, the new config did not load")
assert.Contains(t, lines[1], dir, "names the config that did not load")
}
// A client that went away still gets the reload it asked for
func TestReloadCommandReloadsWhenTheClientIsGone(t *testing.T) {
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yml"), []byte("a: 1"), 0o600))
l := test.NewLogger()
c := config.NewC(l)
require.NoError(t, c.Load(dir))
reloaded := false
c.RegisterReloadCallback(func(*config.C, *config.Reload) { reloaded = true })
gone := errors.New("client is gone")
require.ErrorIs(t, reloadCommand(l, c, &lineWriter{err: gone}), gone)
assert.True(t, reloaded)
} }
+5 -26
View File
@@ -3,7 +3,6 @@ package sshd
import ( import (
"errors" "errors"
"log/slog" "log/slog"
"sort"
"strings" "strings"
"github.com/slackhq/nebula/commands" "github.com/slackhq/nebula/commands"
@@ -26,7 +25,6 @@ func NewSession(reg *commands.Registry, conn *ssh.ServerConn, chans <-chan ssh.N
c: conn, c: conn,
cancel: cancel, cancel: cancel,
} }
s.commands.DefaultFormat = DefaultFormat
s.commands.Register(LogoutCommand(s.Close)) s.commands.Register(LogoutCommand(s.Close))
@@ -40,31 +38,13 @@ func LogoutCommand(end func()) *commands.Command {
return &commands.Command{ return &commands.Command{
Name: commands.Logout, Name: commands.Logout,
ShortDescription: "Ends the current session", ShortDescription: "Ends the current session",
Run: func(a any, args []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
end() end()
return commands.Nothing(), nil return nil
}, },
} }
} }
// DefaultFormat is what an ssh session renders when the operator gave neither -json nor
// -pretty: text where a command has a human form, and compact JSON for the ones that
// have none (print-tunnel, print-relays, query-lighthouse). It is ssh's policy, exported so a test
// can dispatch through the same choice, and ssh's to change.
func DefaultFormat(c *commands.Command, r commands.Result) commands.Format {
if !c.JSONOnly {
return commands.FormatText
}
// A JSON-only command's refusal ("No vpn address was provided") is a sentence for a
// person, so an outcome renders as text here; ssh users and scripts expect it.
if r.Value == nil {
return commands.FormatText
}
return commands.FormatJSON
}
func (s *session) handleChannels(chans <-chan ssh.NewChannel) { func (s *session) handleChannels(chans <-chan ssh.NewChannel) {
defer s.Close() defer s.Close()
for newChannel := range chans { for newChannel := range chans {
@@ -111,7 +91,7 @@ func (s *session) handleRequests(in <-chan *ssh.Request, channel ssh.Channel) {
} }
req.Reply(true, nil) req.Reply(true, nil)
err := s.dispatchCommand(payload.Value, commands.MergedOutput(channel)) err := s.dispatchCommand(payload.Value, commands.NewStringWriter(channel))
// A command that failed exits 1, so `ssh host cmd` callers can tell. // A command that failed exits 1, so `ssh host cmd` callers can tell.
status := struct{ Status uint32 }{uint32(0)} status := struct{ Status uint32 }{uint32(0)}
@@ -144,7 +124,6 @@ func (s *session) createTerm(channel ssh.Channel) *term.Terminal {
return cmds[0] + " ", len(cmds[0]) + 1, true return cmds[0] + " ", len(cmds[0]) + 1, true
} }
sort.Strings(cmds)
term.Write([]byte(strings.Join(cmds, "\n") + "\n\n")) term.Write([]byte(strings.Join(cmds, "\n") + "\n\n"))
} }
@@ -156,7 +135,7 @@ func (s *session) createTerm(channel ssh.Channel) *term.Terminal {
} }
func (s *session) handleInput() { func (s *session) handleInput() {
w := commands.MergedOutput(s.term) w := commands.NewStringWriter(s.term)
for { for {
line, err := s.term.ReadLine() line, err := s.term.ReadLine()
if err != nil { if err != nil {
@@ -170,7 +149,7 @@ func (s *session) handleInput() {
// dispatchCommand runs line and returns the command's error, which it has logged unless // dispatchCommand runs line and returns the command's error, which it has logged unless
// the command already told the user everything: the log line is for the operator reading // the command already told the user everything: the log line is for the operator reading
// the daemon's log, who learns nothing from a failure the user caused. // the daemon's log, who learns nothing from a failure the user caused.
func (s *session) dispatchCommand(line string, w commands.Output) error { func (s *session) dispatchCommand(line string, w commands.StringWriter) error {
err := s.commands.Dispatch(line, w) err := s.commands.Dispatch(line, w)
if err == nil { if err == nil {
return nil return nil
+5 -3
View File
@@ -6,6 +6,7 @@ import (
"crypto/rand" "crypto/rand"
"crypto/rsa" "crypto/rsa"
"encoding/pem" "encoding/pem"
"errors"
"fmt" "fmt"
"net" "net"
"os" "os"
@@ -249,8 +250,9 @@ func TestSSHExecExitStatusReflectsTheCommand(t *testing.T) {
h := newSSHDReloadHarness(t) h := newSSHDReloadHarness(t)
h.reg.Register(&commands.Command{ h.reg.Register(&commands.Command{
Name: "fails", Name: "fails",
Run: func(fs any, a []string) (commands.Result, error) { Callback: func(fs any, a []string, w commands.StringWriter) error {
return commands.Failed("nope"), nil _ = w.WriteLine("nope")
return errors.New("failed")
}, },
}) })
client, _ := h.connect(t) client, _ := h.connect(t)
@@ -267,7 +269,7 @@ func TestSSHExecExitStatusReflectsTheCommand(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
out, err = sess.CombinedOutput("help fails") out, err = sess.CombinedOutput("help fails")
require.NoError(t, err) require.NoError(t, err)
assert.Contains(t, string(out), "fails - \n") assert.Equal(t, "fails - \n", string(out))
// A word that is not a command is a failure too, with the command list as before. // A word that is not a command is a failure too, with the command list as before.
sess, err = client.NewSession() sess, err = client.NewSession()
-12
View File
@@ -10,18 +10,6 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
// ShortTempDir returns a short private directory of the test's own, removed when the
// test ends. t.TempDir embeds the test name, which on darwin routinely pushes a unix
// socket path laid out under it past the 104 byte sun_path limit.
func ShortTempDir(t *testing.T) string {
t.Helper()
dir, err := os.MkdirTemp("", "la")
require.NoError(t, err)
t.Cleanup(func() { _ = os.RemoveAll(dir) })
return dir
}
// Update is the -update flag: Golden rewrites its file instead of comparing against it. // Update is the -update flag: Golden rewrites its file instead of comparing against it.
var Update = flag.Bool("update", false, "rewrite golden files instead of comparing against them") var Update = flag.Bool("update", false, "rewrite golden files instead of comparing against them")
+8 -54
View File
@@ -4,46 +4,29 @@ change-remote
flags: flags:
-address string -address string
The new remote address, ip:port The new remote address, ip:port
-json
outputs as json
-pretty
pretty prints json, assumes -json
close-tunnel close-tunnel
short: Closes a tunnel for the provided vpn addr short: Closes a tunnel for the provided vpn addr
help: help:
flags: flags:
-local-only -local-only
Disables notifying the remote that the tunnel is shutting down Disables notifying the remote that the tunnel is shutting down
-json
outputs as json
-pretty
pretty prints json, assumes -json
create-tunnel create-tunnel
short: Creates a tunnel for the provided vpn address short: Creates a tunnel for the provided vpn address
help: The lighthouses will be queried for real addresses but you can provide one as well. help: The lighthouses will be queried for real addresses but you can provide one as well.
flags: flags:
-address string -address string
Optionally provide a real remote address, ip:port Optionally provide a real remote address, ip:port
-json
outputs as json
-pretty
pretty prints json, assumes -json
device-info device-info
short: Prints information about the network device. short: Prints information about the network device.
help: help:
flags: flags:
-json -json
outputs as json outputs as json with more information
-pretty -pretty
pretty prints json, assumes -json pretty prints json, assumes -json
help help
short: prints available commands or help <command> for specific usage info short: prints available commands or help <command> for specific usage info
help: help:
flags:
-json
outputs as json
-pretty
pretty prints json, assumes -json
list-hostmap list-hostmap
short: List all known previously connected hosts short: List all known previously connected hosts
help: help:
@@ -51,7 +34,7 @@ list-hostmap
-by-index -by-index
gets all hosts in the hostmap from the index table gets all hosts in the hostmap from the index table
-json -json
outputs as json outputs as json with more information
-pretty -pretty
pretty prints json, assumes -json pretty prints json, assumes -json
list-lighthouse-addrmap list-lighthouse-addrmap
@@ -59,7 +42,7 @@ list-lighthouse-addrmap
help: help:
flags: flags:
-json -json
outputs as json outputs as json with more information
-pretty -pretty
pretty prints json, assumes -json pretty prints json, assumes -json
list-pending-hostmap list-pending-hostmap
@@ -69,72 +52,43 @@ list-pending-hostmap
-by-index -by-index
gets all hosts in the hostmap from the index table gets all hosts in the hostmap from the index table
-json -json
outputs as json outputs as json with more information
-pretty -pretty
pretty prints json, assumes -json pretty prints json, assumes -json
log-format log-format
short: Gets or sets the current log format short: Gets or sets the current log format
help: help:
flags:
-json
outputs as json
-pretty
pretty prints json, assumes -json
log-level log-level
short: Gets or sets the current log level short: Gets or sets the current log level
help: help:
flags:
-json
outputs as json
-pretty
pretty prints json, assumes -json
print-cert print-cert
short: Prints the current certificate being used or the certificate for the provided vpn addr short: Prints the current certificate being used or the certificate for the provided vpn addr
help: help:
flags: flags:
-raw
prints the PEM encoded certificate; with -json, an object holding it
-json -json
outputs as json outputs as json
-pretty -pretty
pretty prints json, assumes -json pretty prints json, assumes -json
-raw
raw prints the PEM encoded certificate, not compatible with -json or -pretty
print-relays print-relays
short: Prints json details about all relay info short: Prints json details about all relay info
help: help:
flags: flags:
-json
outputs as json
-pretty -pretty
pretty prints json, assumes -json pretty prints json
print-tunnel print-tunnel
short: Prints json details about a tunnel for the provided vpn addr short: Prints json details about a tunnel for the provided vpn addr
help: help:
flags: flags:
-json
outputs as json
-pretty -pretty
pretty prints json, assumes -json pretty prints json
query-lighthouse query-lighthouse
short: Query the lighthouses for the provided vpn address short: Query the lighthouses for the provided vpn address
help: This command is asynchronous. Only currently known udp addresses will be printed. help: This command is asynchronous. Only currently known udp addresses will be printed.
flags:
-json
outputs as json
-pretty
pretty prints json, assumes -json
reload reload
short: Reloads configuration from disk, same as sending HUP to the process short: Reloads configuration from disk, same as sending HUP to the process
help: help:
flags:
-json
outputs as json
-pretty
pretty prints json, assumes -json
version version
short: Prints the currently running version of nebula short: Prints the currently running version of nebula
help: help:
flags:
-json
outputs as json
-pretty
pretty prints json, assumes -json
+3 -2
View File
@@ -41,8 +41,9 @@ type Conn interface {
// //
// Returns the number of packets successfully written. A destination the kernel rejects costs only // Returns the number of packets successfully written. A destination the kernel rejects costs only
// its own packet, so a short count means some peers were undeliverable, not that the batch failed. // its own packet, so a short count means some peers were undeliverable, not that the batch failed.
// failed, when not nil, is called with the index of every packet a destination cost us and why.
// Not safe for concurrent use on the same Conn. // Not safe for concurrent use on the same Conn.
WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error)
// ReloadConfig applies the listen settings that can change, r is nil at startup // ReloadConfig applies the listen settings that can change, r is nil at startup
ReloadConfig(c *config.C, r *config.Reload) ReloadConfig(c *config.C, r *config.Reload)
SupportsMultipleReaders() bool SupportsMultipleReaders() bool
@@ -66,7 +67,7 @@ func (NoopConn) SupportsMultipleReaders() bool {
func (NoopConn) WriteTo(_ []byte, _ netip.AddrPort) error { func (NoopConn) WriteTo(_ []byte, _ netip.AddrPort) error {
return nil return nil
} }
func (NoopConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) { func (NoopConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort, _ func(int, error)) (int, error) {
return len(bufs), nil return len(bufs), nil
} }
func (NoopConn) ReloadConfig(_ *config.C, _ *config.Reload) { func (NoopConn) ReloadConfig(_ *config.C, _ *config.Reload) {
+4 -1
View File
@@ -139,7 +139,7 @@ func (u *StdConn) WriteTo(b []byte, ap netip.AddrPort) error {
} }
} }
func (u *StdConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (u *StdConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error) {
// An un-sendable destination costs its own packet, never the ones behind it in the batch. // An un-sendable destination costs its own packet, never the ones behind it in the batch.
// TODO: WriteTo maps EWOULDBLOCK to an error, so a full send buffer // TODO: WriteTo maps EWOULDBLOCK to an error, so a full send buffer
// silently drops the rest of a burst (linux blocks instead). Poll for // silently drops the rest of a burst (linux blocks instead). Poll for
@@ -150,6 +150,9 @@ func (u *StdConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error)
written++ written++
} else { } else {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err) u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err)
if failed != nil {
failed(i, err)
}
} }
} }
return written, nil return written, nil
+4 -1
View File
@@ -44,7 +44,7 @@ func (u *GenericConn) WriteTo(b []byte, addr netip.AddrPort) error {
return err return err
} }
func (u *GenericConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (u *GenericConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error) {
// An un-sendable destination costs its own packet, never the ones behind it in the batch. // An un-sendable destination costs its own packet, never the ones behind it in the batch.
written := 0 written := 0
for i, b := range bufs { for i, b := range bufs {
@@ -52,6 +52,9 @@ func (u *GenericConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, er
written++ written++
} else { } else {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err) u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err)
if failed != nil {
failed(i, err)
}
} }
} }
return written, nil return written, nil
+7 -15
View File
@@ -255,10 +255,6 @@ func (u *StdConn) ListenOut(r EncReader, flush func()) error {
msgs, buffers, names, _ := prepareRawMessages(u.batch, bufSize, cmsgSpace) msgs, buffers, names, _ := prepareRawMessages(u.batch, bufSize, cmsgSpace)
for { for {
// A shut down socket still queues and returns datagrams, a busy reader would never see an empty read
if u.closed.Load() {
return net.ErrClosed
}
if cmsgSpace > 0 { if cmsgSpace > 0 {
for i := range msgs { for i := range msgs {
setMsgControllen(&msgs[i].Hdr, cmsgSpace) setMsgControllen(&msgs[i].Hdr, cmsgSpace)
@@ -362,8 +358,8 @@ func sendto(fd int, b []byte, addr netip.AddrPort, isV4 bool) error {
// WriteBatch sends bufs via sendmmsg(2), coalescing same-destination runs into UDP-GSO superpackets when supported. // WriteBatch sends bufs via sendmmsg(2), coalescing same-destination runs into UDP-GSO superpackets when supported.
// See batchWriter in udp_linux_writebatch.go for the mechanics. // See batchWriter in udp_linux_writebatch.go for the mechanics.
func (u *StdConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (u *StdConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error) {
return u.bw.WriteBatch(bufs, addrs) return u.bw.WriteBatch(bufs, addrs, failed)
} }
// writeSockaddr encodes addr into buf (which must be at least SizeofSockaddrInet6 bytes). // writeSockaddr encodes addr into buf (which must be at least SizeofSockaddrInet6 bytes).
@@ -450,16 +446,12 @@ func (u *StdConn) getMemInfo(meminfo *[unix.SK_MEMINFO_VARS]uint32) error {
return nil return nil
} }
// Shutdown wakes the reader without releasing the fd, Close only once it has exited
func (u *StdConn) Shutdown() error {
u.closed.Store(true)
// shutdown(2) on an unconnected socket returns ENOTCONN but still wakes the reader, so ignore the error
_ = unix.Shutdown(u.sysFd, unix.SHUT_RDWR)
return nil
}
func (u *StdConn) Close() error { func (u *StdConn) Close() error {
_ = u.Shutdown() u.closed.Store(true)
// Wake the reader parked in recvmmsg. shutdown(2) on an unconnected socket
// returns ENOTCONN but still wakes it, so ignore the error.
// The reader then sees closed and stops touching the fd, making the Close below safe.
_ = unix.Shutdown(u.sysFd, unix.SHUT_RDWR)
return unix.Close(u.sysFd) return unix.Close(u.sysFd)
} }
+38 -9
View File
@@ -3,6 +3,7 @@
package udp package udp
import ( import (
"errors"
"fmt" "fmt"
"log/slog" "log/slog"
"net" "net"
@@ -96,13 +97,22 @@ func TestWriteBatchBadFamilyDeliversOthers(t *testing.T) {
bufs := [][]byte{[]byte("AAA"), []byte("BBB"), []byte("CCC")} bufs := [][]byte{[]byte("AAA"), []byte("BBB"), []byte("CCC")}
addrs := []netip.AddrPort{good, bad, good} addrs := []netip.AddrPort{good, bad, good}
n, err := sender.WriteBatch(bufs, addrs) var failed []int
n, err := sender.WriteBatch(bufs, addrs, func(i int, err error) {
if !IsUnreachable(err) {
t.Errorf("packet %d failed with %v, want an unreachable error", i, err)
}
failed = append(failed, i)
})
if err != nil { if err != nil {
t.Fatalf("WriteBatch returned error, want nil (bad dest should be isolated): %v", err) t.Fatalf("WriteBatch returned error, want nil (bad dest should be isolated): %v", err)
} }
if n != 2 { if n != 2 {
t.Errorf("WriteBatch wrote %d packets, want 2 of 3 (the bad-family dest is the only casualty)", n) t.Errorf("WriteBatch wrote %d packets, want 2 of 3 (the bad-family dest is the only casualty)", n)
} }
if want := []int{1}; !slices.Equal(failed, want) {
t.Errorf("failed reported %v, want %v", failed, want)
}
got := map[string]bool{} got := map[string]bool{}
rx.SetReadDeadline(time.Now().Add(2 * time.Second)) rx.SetReadDeadline(time.Now().Add(2 * time.Second))
@@ -154,7 +164,7 @@ func TestWriteBatchUnreachableDestDeliversOthers(t *testing.T) {
addrs := []netip.AddrPort{good, good, bad, good, good} addrs := []netip.AddrPort{good, good, bad, good, good}
// The bad destination is reported, but only after every other packet has been attempted. // The bad destination is reported, but only after every other packet has been attempted.
if _, err := sender.WriteBatch(bufs, addrs); err == nil { if _, err := sender.WriteBatch(bufs, addrs, nil); err == nil {
t.Log("WriteBatch returned nil; kernel accepted the reserved address, delivery assertions still apply") t.Log("WriteBatch returned nil; kernel accepted the reserved address, delivery assertions still apply")
} }
@@ -376,7 +386,7 @@ func TestWriteBatchPartialSendRewind(t *testing.T) {
return accept, nil return accept, nil
} }
written, err := w.WriteBatch(bufs, addrs) written, err := w.WriteBatch(bufs, addrs, nil)
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
@@ -429,13 +439,22 @@ func TestWriteBatchSkipUnroutableRunAccounting(t *testing.T) {
return accept, nil return accept, nil
} }
written, err := w.WriteBatch(bufs, addrs) var failed []int
written, err := w.WriteBatch(bufs, addrs, func(i int, err error) {
if !IsUnreachable(err) {
t.Errorf("packet %d failed with %v, want an unreachable error", i, err)
}
failed = append(failed, i)
})
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
if written != 4 { if written != 4 {
t.Errorf("written = %d, want 4 (the unroutable run is the only casualty)", written) t.Errorf("written = %d, want 4 (the unroutable run is the only casualty)", written)
} }
if want := []int{2}; !slices.Equal(failed, want) {
t.Errorf("failed reported %v, want %v", failed, want)
}
wantTags := []byte{1, 2, 4, 5} wantTags := []byte{1, 2, 4, 5}
if len(wire) != len(wantTags) { if len(wire) != len(wantTags) {
t.Fatalf("wire got %d packets, want %d (dup or loss around the skip)", len(wire), len(wantTags)) t.Fatalf("wire got %d packets, want %d (dup or loss around the skip)", len(wire), len(wantTags))
@@ -486,13 +505,23 @@ func TestWriteBatchMidChunkRejectResumes(t *testing.T) {
} }
} }
written, err := w.WriteBatch(bufs, addrs) var failed []int
written, err := w.WriteBatch(bufs, addrs, func(i int, err error) {
if !errors.Is(err, unix.EPERM) {
t.Errorf("packet %d failed with %v, want EPERM", i, err)
}
failed = append(failed, i)
})
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
if written != 3 { if written != 3 {
t.Errorf("written = %d, want 3 (B's rejected run is the only casualty)", written) t.Errorf("written = %d, want 3 (B's rejected run is the only casualty)", written)
} }
// Every packet in B's run is reported, not just the entry
if want := []int{2, 3}; !slices.Equal(failed, want) {
t.Errorf("failed reported %v, want %v", failed, want)
}
wantTags := []byte{1, 2, 5} wantTags := []byte{1, 2, 5}
if len(wire) != len(wantTags) { if len(wire) != len(wantTags) {
t.Fatalf("wire got %d packets, want %d (dup or loss around the mid-chunk reject)", len(wire), len(wantTags)) t.Fatalf("wire got %d packets, want %d (dup or loss around the mid-chunk reject)", len(wire), len(wantTags))
@@ -543,7 +572,7 @@ func TestWriteBatchMidChunkEIODisablesGSOWithoutDup(t *testing.T) {
} }
} }
written, err := w.WriteBatch(bufs, addrs) written, err := w.WriteBatch(bufs, addrs, nil)
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
@@ -571,7 +600,7 @@ func TestWriteBatchZeroProgress(t *testing.T) {
w.sendFn = func(start, n int) (int, error) { return 0, nil } w.sendFn = func(start, n int) (int, error) { return 0, nil }
bufs := [][]byte{make([]byte, 100)} bufs := [][]byte{make([]byte, 100)}
addrs := []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:4242")} addrs := []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:4242")}
if _, err := w.WriteBatch(bufs, addrs); err == nil { if _, err := w.WriteBatch(bufs, addrs, nil); err == nil {
t.Fatal("WriteBatch = nil error on zero progress, want error") t.Fatal("WriteBatch = nil error on zero progress, want error")
} }
} }
@@ -597,7 +626,7 @@ func TestWriteBatchEIODisablesGSOAndReplays(t *testing.T) {
return n, nil return n, nil
} }
written, err := w.WriteBatch(bufs, addrs) written, err := w.WriteBatch(bufs, addrs, nil)
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
@@ -674,7 +703,7 @@ func TestGSOEngagesOnLoopback(t *testing.T) {
addrs[i] = dst addrs[i] = dst
} }
written, err := sc.WriteBatch(bufs, addrs) written, err := sc.WriteBatch(bufs, addrs, nil)
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
+2 -2
View File
@@ -86,7 +86,7 @@ func TestWriteBatchOffloadsDisabledScripted(t *testing.T) {
addrs[i] = dst addrs[i] = dst
} }
written, err := w.WriteBatch(bufs, addrs) written, err := w.WriteBatch(bufs, addrs, nil)
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
@@ -163,7 +163,7 @@ func TestOffloadsDisabledOnLoopback(t *testing.T) {
addrs[i] = dst addrs[i] = dst
} }
written, err := sc.WriteBatch(bufs, addrs) written, err := sc.WriteBatch(bufs, addrs, nil)
if err != nil { if err != nil {
t.Fatalf("WriteBatch: %v", err) t.Fatalf("WriteBatch: %v", err)
} }
+5 -74
View File
@@ -76,7 +76,7 @@ func TestShutdownWakesAfterRx_Mechanism(t *testing.T) {
} }
// TestListenOutTeardown_TrafficPatterns reproduces the field report: a blocking // TestListenOutTeardown_TrafficPatterns reproduces the field report: a blocking
// reader must tear down cleanly on Shutdown() regardless of what the socket has // reader must tear down cleanly on Close() regardless of what the socket has
// carried. The three cases the report called out: // carried. The three cases the report called out:
// //
// no traffic ever -> works (shutdown wakes recvmmsg with n==0) // no traffic ever -> works (shutdown wakes recvmmsg with n==0)
@@ -162,12 +162,11 @@ func runTeardownCase(t *testing.T, batch int, name string, traffic func(send net
// empty queue with the socket already having received a packet. // empty queue with the socket already having received a packet.
time.Sleep(500 * time.Millisecond) time.Sleep(500 * time.Millisecond)
// Tear down the way Interface.Close does, the fd stays open until the reader is gone
start := time.Now() start := time.Now()
if err := sc.Shutdown(); err != nil { if err := sc.Close(); err != nil {
t.Fatalf("Shutdown: %v", err) t.Fatalf("Close: %v", err)
} }
defer func() { _ = sc.Close() }() close(stop)
select { select {
case err := <-loopDone: case err := <-loopDone:
@@ -180,75 +179,7 @@ func runTeardownCase(t *testing.T, batch int, name string, traffic func(send net
case <-time.After(3 * time.Second): case <-time.After(3 * time.Second):
buf := make([]byte, 1<<20) buf := make([]byte, 1<<20)
n := runtime.Stack(buf, true) n := runtime.Stack(buf, true)
t.Fatalf("%s: HANG, ListenOut did not return within 3s of Shutdown\n%s", name, buf[:n]) t.Fatalf("%s: HANG, ListenOut did not return within 3s of Close\n%s", name, buf[:n])
} }
close(stop)
<-trafficDone <-trafficDone
} }
// A shut down socket still returns queued datagrams, so a reader that is behind has to stop on its own within the
// batch it was working on
func TestListenOutShutdown_BusyReader(t *testing.T) {
const batch = 64
udpSettings := Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0"), Multi: true, Batch: batch}
c, err := NewListener(testLogger(), udpSettings)
if err != nil {
t.Fatalf("NewListener: %v", err)
}
sc := c.(*StdConn)
defer sc.Close()
addr, err := sc.LocalAddr()
if err != nil {
t.Fatalf("LocalAddr: %v", err)
}
stop := make(chan struct{})
defer close(stop)
for range 8 {
send, err := net.Dial("udp", addr.String())
if err != nil {
t.Fatalf("dial: %v", err)
}
defer send.Close()
go func() {
b := make([]byte, 1200)
for {
select {
case <-stop:
return
default:
_, _ = send.Write(b)
}
}
}()
}
var afterShutdown atomic.Int64
loopDone := make(chan error, 1)
go func() {
loopDone <- sc.ListenOut(func(netip.AddrPort, []byte) {
if sc.closed.Load() {
afterShutdown.Add(1)
}
// Slower than the senders so the queue never drains
for start := time.Now(); time.Since(start) < 200*time.Microsecond; {
}
}, func() {})
}()
time.Sleep(200 * time.Millisecond)
if err := sc.Shutdown(); err != nil {
t.Fatalf("Shutdown: %v", err)
}
select {
case err := <-loopDone:
if !errors.Is(err, net.ErrClosed) {
t.Fatalf("ListenOut returned %v, want net.ErrClosed", err)
}
case <-time.After(3 * time.Second):
t.Fatalf("ListenOut still running 3s after Shutdown, delivered %d packets since", afterShutdown.Load())
}
if n := afterShutdown.Load(); n > batch {
t.Fatalf("delivered %d packets after Shutdown, more than the one batch in flight", n)
}
}
+14 -2
View File
@@ -190,8 +190,8 @@ func parseRelease(r string) (major, minor int) {
// its packets are dropped and the rest of the chunk resumes in place. // its packets are dropped and the rest of the chunk resumes in place.
// //
// Returns the number of packets sent. An error means the call itself failed. // Returns the number of packets sent. An error means the call itself failed.
// A short count means some destinations were undeliverable. // A short count means some destinations were undeliverable, failed hears about each of their packets.
func (w *batchWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (w *batchWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error) {
if len(bufs) != len(addrs) { if len(bufs) != len(addrs) {
return 0, fmt.Errorf("WriteBatch: len(bufs)=%d != len(addrs)=%d", len(bufs), len(addrs)) return 0, fmt.Errorf("WriteBatch: len(bufs)=%d != len(addrs)=%d", len(bufs), len(addrs))
} }
@@ -233,6 +233,7 @@ func (w *batchWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, er
if w.l.Enabled(context.Background(), slog.LevelDebug) { if w.l.Enabled(context.Background(), slog.LevelDebug) {
w.l.Debug("skipping unroutable batch destination", "udpAddr", addrs[i], "packets", runLen, "error", err) w.l.Debug("skipping unroutable batch destination", "udpAddr", addrs[i], "packets", runLen, "error", err)
} }
reportFailed(failed, i, i+runLen, err)
i += runLen i += runLen
continue continue
} }
@@ -300,12 +301,23 @@ func (w *batchWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, er
"gso", w.gsoSupported, "gso", w.gsoSupported,
) )
} }
reportFailed(failed, w.entryEnd[done]-w.entryPkts[done], w.entryEnd[done], serr)
done++ done++
} }
} }
return written, nil return written, nil
} }
// reportFailed tells failed, if anyone is listening, that every packet in bufs[start:end] was lost to err
func reportFailed(failed func(i int, err error), start, end int, err error) {
if failed == nil {
return
}
for i := start; i < end; i++ {
failed(i, err)
}
}
// planRun returns the length of the run starting at start and its segment // planRun returns the length of the run starting at start and its segment
// size (len(bufs[start])). A run of length 1 carries no UDP_SEGMENT cmsg // size (len(bufs[start])). A run of length 1 carries no UDP_SEGMENT cmsg
// and is sent as a plain datagram; without GSO support planRun always returns 1. // and is sent as a plain datagram; without GSO support planRun always returns 1.
+2 -2
View File
@@ -80,11 +80,11 @@ func TestWriteBatchNoAllocs(t *testing.T) {
var werr error var werr error
// Warm-up outside the measured runs. // Warm-up outside the measured runs.
if _, err := tx.WriteBatch(bufs, addrs); err != nil { if _, err := tx.WriteBatch(bufs, addrs, nil); err != nil {
t.Fatalf("WriteBatch warm-up: %v", err) t.Fatalf("WriteBatch warm-up: %v", err)
} }
allocs := testing.AllocsPerRun(100, func() { allocs := testing.AllocsPerRun(100, func() {
if _, err := tx.WriteBatch(bufs, addrs); err != nil { if _, err := tx.WriteBatch(bufs, addrs, nil); err != nil {
werr = err werr = err
} }
}) })
+4 -1
View File
@@ -319,7 +319,7 @@ func (u *RIOConn) WriteTo(buf []byte, ip netip.AddrPort) error {
return winrio.SendEx(u.rq, dataBuffer, 1, nil, addressBuffer, nil, nil, 0, 0) return winrio.SendEx(u.rq, dataBuffer, 1, nil, addressBuffer, nil, nil, 0, 0)
} }
func (u *RIOConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (u *RIOConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error) {
// An un-sendable destination costs its own packet, never the ones behind it in the batch. // An un-sendable destination costs its own packet, never the ones behind it in the batch.
written := 0 written := 0
for i, b := range bufs { for i, b := range bufs {
@@ -327,6 +327,9 @@ func (u *RIOConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error)
written++ written++
} else { } else {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err) u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err)
if failed != nil {
failed(i, err)
}
} }
} }
return written, nil return written, nil
+64 -7
View File
@@ -6,6 +6,7 @@ import (
"context" "context"
"io" "io"
"log/slog" "log/slog"
"net"
"net/netip" "net/netip"
"os" "os"
"sync" "sync"
@@ -63,10 +64,19 @@ func acquirePacket() *Packet {
} }
} }
// testerAddrs is where a TesterConn sends from. A single address host sends everything from addr, whatever the
// destination. A dual stack host sends from the address matching the destination's family and has no route at all
// for a family it holds no address in.
type testerAddrs struct {
addr netip.AddrPort
v4, v6 netip.AddrPort
dual bool
}
type TesterConn struct { type TesterConn struct {
// addr is read by nebula's own goroutines on every send and by the router's flow renderer, and a test can // addrs is read by nebula's own goroutines on every send and by the router's flow renderer, and a test can
// move it mid-run to simulate roaming, so it is atomic rather than a plain field. // move it mid-run to simulate roaming, so it is atomic rather than a plain field.
addr atomic.Pointer[netip.AddrPort] addrs atomic.Pointer[testerAddrs]
RxPackets chan *Packet // Packets to receive into nebula RxPackets chan *Packet // Packets to receive into nebula
TxPackets chan *Packet // Packets transmitted outside by nebula TxPackets chan *Packet // Packets transmitted outside by nebula
@@ -94,14 +104,53 @@ func NewListener(l *slog.Logger, s Settings) (Conn, error) {
return c, nil return c, nil
} }
// GetAddr returns the underlay address this conn currently sends from. // GetAddr returns the underlay address this conn currently sends from. For a dual stack conn that is the IPv4
// address, or the IPv6 one when there is no IPv4 service.
func (u *TesterConn) GetAddr() netip.AddrPort { func (u *TesterConn) GetAddr() netip.AddrPort {
return *u.addr.Load() return u.addrs.Load().addr
} }
// SetAddr moves this conn to a new underlay address, standing in for a host waking up on a different network. // SetAddr moves this conn to a new underlay address, standing in for a host waking up on a different network.
func (u *TesterConn) SetAddr(addr netip.AddrPort) { func (u *TesterConn) SetAddr(addr netip.AddrPort) {
u.addr.Store(&addr) u.addrs.Store(&testerAddrs{addr: addr})
}
// SetDualStackAddrs gives this conn one underlay address per family, standing in for a host whose routing table picks
// the source by destination. Pass an invalid AddrPort for a family the network does not offer, sends to that family
// then fail like they would on a host with no route for it.
func (u *TesterConn) SetDualStackAddrs(v4, v6 netip.AddrPort) {
a := &testerAddrs{v4: v4, v6: v6, dual: true}
if v4.IsValid() {
a.addr = v4
} else {
a.addr = v6
}
u.addrs.Store(a)
}
// GetAddrFor returns the underlay address a send to dst leaves from, GetAddr when there is no route to dst
func (u *TesterConn) GetAddrFor(dst netip.AddrPort) netip.AddrPort {
if src, err := u.sourceFor(dst); err == nil {
return src
}
return u.GetAddr()
}
// sourceFor returns the address a send to dst leaves from
func (u *TesterConn) sourceFor(dst netip.AddrPort) (netip.AddrPort, error) {
a := u.addrs.Load()
if !a.dual {
return a.addr, nil
}
src := a.v6
if dst.Addr().Unmap().Is4() {
src = a.v4
}
if !src.IsValid() {
return netip.AddrPort{}, &net.OpError{Op: "write", Net: "udp", Addr: net.UDPAddrFromAddrPort(dst), Err: errNetUnreachable}
}
return src, nil
} }
// Send will place a UdpPacket onto the receive queue for nebula to consume // Send will place a UdpPacket onto the receive queue for nebula to consume
@@ -153,6 +202,11 @@ func (u *TesterConn) Get(block bool) *Packet {
//********************************************************************************************************************// //********************************************************************************************************************//
func (u *TesterConn) WriteTo(b []byte, addr netip.AddrPort) error { func (u *TesterConn) WriteTo(b []byte, addr netip.AddrPort) error {
from, err := u.sourceFor(addr)
if err != nil {
return err
}
p := acquirePacket() p := acquirePacket()
if cap(p.Data) < len(b) { if cap(p.Data) < len(b) {
p.Data = make([]byte, len(b)) p.Data = make([]byte, len(b))
@@ -160,7 +214,7 @@ func (u *TesterConn) WriteTo(b []byte, addr netip.AddrPort) error {
p.Data = p.Data[:len(b)] p.Data = p.Data[:len(b)]
} }
copy(p.Data, b) copy(p.Data, b)
p.From = u.GetAddr() p.From = from
p.To = addr p.To = addr
select { select {
case <-u.done: case <-u.done:
@@ -170,13 +224,16 @@ func (u *TesterConn) WriteTo(b []byte, addr netip.AddrPort) error {
return nil return nil
} }
} }
func (u *TesterConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (u *TesterConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort, failed func(i int, err error)) (int, error) {
written := 0 written := 0
for i, b := range bufs { for i, b := range bufs {
if err := u.WriteTo(b, addrs[i]); err == nil { if err := u.WriteTo(b, addrs[i]); err == nil {
written++ written++
} else { } else {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err) u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err)
if failed != nil {
failed(i, err)
}
} }
} }
return written, nil return written, nil
+22
View File
@@ -0,0 +1,22 @@
//go:build !windows
package udp
import (
"errors"
"syscall"
)
// errNetUnreachable is the error this platform's sockets give for a destination with no route
var errNetUnreachable error = syscall.ENETUNREACH
// IsUnreachable reports whether a send failed because this host has no way to reach the destination from where it
// is now, rather than for something transient. Moving from a dual stack network to one without IPv6 turns every send
// to an IPv6 remote into one of these.
func IsUnreachable(err error) bool {
return errors.Is(err, syscall.ENETUNREACH) ||
errors.Is(err, syscall.EHOSTUNREACH) ||
errors.Is(err, syscall.EADDRNOTAVAIL) ||
errors.Is(err, syscall.EAFNOSUPPORT) ||
errors.Is(err, ErrInvalidIPv6RemoteForSocket)
}
+37
View File
@@ -0,0 +1,37 @@
//go:build !windows
package udp
import (
"net"
"syscall"
"testing"
)
func TestIsUnreachable(t *testing.T) {
wrap := func(err error) error { return &net.OpError{Op: "write", Net: "udp", Err: err} }
for _, err := range []error{
wrap(syscall.ENETUNREACH),
wrap(syscall.EHOSTUNREACH),
wrap(syscall.EADDRNOTAVAIL),
wrap(syscall.EAFNOSUPPORT),
ErrInvalidIPv6RemoteForSocket,
} {
if !IsUnreachable(err) {
t.Errorf("IsUnreachable(%v) = false, want true", err)
}
}
for _, err := range []error{
nil,
wrap(syscall.EPERM),
wrap(syscall.ENOBUFS),
wrap(syscall.EMSGSIZE),
net.ErrClosed,
} {
if IsUnreachable(err) {
t.Errorf("IsUnreachable(%v) = true, want false", err)
}
}
}
+21
View File
@@ -0,0 +1,21 @@
package udp
import (
"errors"
"golang.org/x/sys/windows"
)
// errNetUnreachable is the error this platform's sockets give for a destination with no route
var errNetUnreachable error = windows.WSAENETUNREACH
// IsUnreachable reports whether a send failed because this host has no way to reach the destination from where it
// is now, rather than for something transient. Moving from a dual stack network to one without IPv6 turns every send
// to an IPv6 remote into one of these.
func IsUnreachable(err error) bool {
return errors.Is(err, windows.WSAENETUNREACH) ||
errors.Is(err, windows.WSAEHOSTUNREACH) ||
errors.Is(err, windows.WSAEADDRNOTAVAIL) ||
errors.Is(err, windows.WSAEAFNOSUPPORT) ||
errors.Is(err, ErrInvalidIPv6RemoteForSocket)
}