From 565aaf7e4903d31f184cdc8d7ee4f56fdd5bf40d Mon Sep 17 00:00:00 2001 From: Kristoffer Dalby Date: Sat, 7 Nov 2026 23:48:48 +0000 Subject: [PATCH] types: compute derived config values where they are used Updates #1926 --- cmd/headscale/headscale_test.go | 4 +- hscontrol/api/v1/policy.go | 3 +- hscontrol/api/v2/acl.go | 3 +- hscontrol/app.go | 109 ++- hscontrol/app_test.go | 98 +++ hscontrol/config/files.go | 11 +- hscontrol/db/db.go | 24 +- hscontrol/db/db_test.go | 3 +- hscontrol/db/policy.go | 3 +- hscontrol/derp/derp.go | 7 +- hscontrol/derp/derp_merge_test.go | 4 +- hscontrol/derp/derp_test.go | 6 +- hscontrol/dns/provider.go | 19 +- hscontrol/dns/provider_test.go | 7 + hscontrol/mapper/batcher.go | 2 +- hscontrol/mapper/batcher_test.go | 8 +- .../mapper/dns_extrarecords_race_test.go | 11 +- hscontrol/mapper/initialmap_storm_test.go | 2 +- hscontrol/mapper/mapper.go | 3 - hscontrol/mapper/mapper_test.go | 71 +- hscontrol/mapper/tail_test.go | 9 +- hscontrol/servertest/server.go | 25 +- hscontrol/state/node_store_hostname_test.go | 8 +- hscontrol/state/persist_test.go | 4 +- hscontrol/state/rename_test.go | 5 +- hscontrol/types/config.go | 409 +++++++----- hscontrol/types/config_source.go | 44 +- hscontrol/types/config_source_test.go | 101 +++ hscontrol/types/config_test.go | 625 +++++++++++++++++- hscontrol/types/derp_config_test.go | 2 +- hscontrol/types/node.go | 2 +- hscontrol/types/secret.go | 4 +- hscontrol/types/secret_test.go | 2 +- 33 files changed, 1251 insertions(+), 387 deletions(-) diff --git a/cmd/headscale/headscale_test.go b/cmd/headscale/headscale_test.go index 5be393027..9341211c0 100644 --- a/cmd/headscale/headscale_test.go +++ b/cmd/headscale/headscale_test.go @@ -64,8 +64,8 @@ func assertExampleConfig(t *testing.T) { assert.Equal(t, "http://127.0.0.1:8080", cfg.ServerURL) assert.Equal(t, "127.0.0.1:8080", cfg.Addr) assert.Equal(t, "127.0.0.1:9090", cfg.MetricsAddr) - assert.Equal(t, types.DatabaseSqlite, cfg.Database.Type) - assert.Equal(t, "/var/lib/headscale/db.sqlite", cfg.Database.Sqlite.Path) + assert.True(t, cfg.Database.IsSQLite(), cfg.Database.Type) + assert.Equal(t, "/var/lib/headscale/db.sqlite", cfg.SQLitePath()) assert.Empty(t, cfg.TLS.ACME.Hostname) assert.Equal(t, ":http", cfg.TLS.ACME.HTTPListen) assert.Equal(t, "HTTP-01", cfg.TLS.ACME.ChallengeType) diff --git a/hscontrol/api/v1/policy.go b/hscontrol/api/v1/policy.go index 1235d8e22..8eee75695 100644 --- a/hscontrol/api/v1/policy.go +++ b/hscontrol/api/v1/policy.go @@ -10,7 +10,6 @@ import ( "github.com/danielgtaylor/huma/v2" "github.com/juanfont/headscale/hscontrol/types" - "github.com/juanfont/headscale/hscontrol/util" ) func init() { @@ -73,7 +72,7 @@ func registerPolicy(api huma.API, b Backend) { return out, nil case types.PolicyModeFile: - absPath := util.AbsolutePath(b.Cfg.ConfigDir, b.Cfg.Policy.Path) + absPath := b.Cfg.AbsPath(b.Cfg.Policy.Path) f, err := os.Open(absPath) if err != nil { diff --git a/hscontrol/api/v2/acl.go b/hscontrol/api/v2/acl.go index 6e835ce03..742ab29f1 100644 --- a/hscontrol/api/v2/acl.go +++ b/hscontrol/api/v2/acl.go @@ -16,7 +16,6 @@ import ( "github.com/juanfont/headscale/hscontrol/scope" "github.com/juanfont/headscale/hscontrol/state" "github.com/juanfont/headscale/hscontrol/types" - "github.com/juanfont/headscale/hscontrol/util" "github.com/tailscale/hujson" ) @@ -221,7 +220,7 @@ func currentPolicy(b Backend) ([]byte, error) { return []byte(p.Data), nil case types.PolicyModeFile: - path := util.AbsolutePath(b.Cfg.ConfigDir, b.Cfg.Policy.Path) + path := b.Cfg.AbsPath(b.Cfg.Policy.Path) if path == "" { return []byte(defaultPolicy), nil } diff --git a/hscontrol/app.go b/hscontrol/app.go index ad351cc79..e71333bd6 100644 --- a/hscontrol/app.go +++ b/hscontrol/app.go @@ -1,6 +1,7 @@ package hscontrol import ( + "cmp" "context" "crypto/ecdsa" "crypto/elliptic" @@ -13,7 +14,6 @@ import ( "math/big" "net" "net/http" - "net/netip" "os" "os/signal" "path/filepath" @@ -52,11 +52,8 @@ import ( "github.com/sasha-s/go-deadlock" "golang.org/x/sync/errgroup" "tailscale.com/envknob" - "tailscale.com/net/tsaddr" "tailscale.com/tailcfg" - "tailscale.com/types/dnstype" "tailscale.com/types/key" - "tailscale.com/util/dnsname" ) var ( @@ -131,11 +128,33 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { runtime.SetBlockProfileRate(1) } - noisePrivateKey, err := readOrCreatePrivateKey(cfg.NoisePrivateKeyPath) + noisePrivateKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.NoisePrivateKeyPath)) if err != nil { return nil, fmt.Errorf("reading or creating Noise protocol private key: %w", err) } + provider := cfg.DNSChallenge.Provider + if provider == nil && cfg.DNSChallenge.ProviderName() != "" { + provider, err = cfg.DNSChallenge.NewProvider(types.ResolveSecret) + if err != nil { + return nil, fmt.Errorf("building dns.challenge.provider: %w", err) + } + } + + // Only node certificates let a client pick what is published; a record + // shared by headscale's own certificate alone is harmless. + if iso, ok := provider.(dns.Isolator); ok && cfg.DNSConfig.Certificates.Enabled { + err = iso.CheckIsolation() + if err != nil { + // A Go-only provider may have no name. + name := cmp.Or(cfg.DNSChallenge.ProviderName(), fmt.Sprintf("%T", provider)) + + return nil, fmt.Errorf("%w for %s: %w", dns.ErrProviderConfig, name, err) + } + } + + cfg.StartDNS(provider) + s, err := state.NewState(cfg) if err != nil { return nil, fmt.Errorf("init state: %w", err) @@ -150,9 +169,9 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { if cfg.DNSConfig.Certificates.Enabled { app.challenges = dns.NewChallenges( - cfg.DNSChallenge.Provider, - cfg.DNSConfig.Certificates.Zone, - cfg.DNSChallenge.Resolvers, + provider, + cfg.DNSConfig.CertificateZone(), + cfg.DNSChallenge.ResolverAddrs(), cfg.DNSChallenge.PropagationTimeout, ) } @@ -235,53 +254,8 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { app.authProvider = authProvider - if app.cfg.TailcfgDNSConfig != nil && app.cfg.TailcfgDNSConfig.Proxied { // if MagicDNS - // Clients route reverse lookups for the Tailscale ranges themselves - // (magicDNSRootDomains in tailscale.com/ipn/ipnlocal) and SaaS sends - // no reverse routes, so only a prefix outside those ranges needs them. - outside := func(p, r netip.Prefix) bool { - return p.Bits() < r.Bits() || !r.Contains(p.Addr()) - } - - // TODO(kradalby): revisit why this takes a list. - var magicDNSDomains []dnsname.FQDN - if cfg.PrefixV4 != nil && outside(*cfg.PrefixV4, tsaddr.CGNATRange()) { - magicDNSDomains = append( - magicDNSDomains, - util.GenerateIPv4DNSRootDomain(*cfg.PrefixV4)..., - ) - } - - if cfg.PrefixV6 != nil && outside(*cfg.PrefixV6, tsaddr.TailscaleULARange()) { - magicDNSDomains = append( - magicDNSDomains, - util.GenerateIPv6DNSRootDomain(*cfg.PrefixV6)..., - ) - } - - // we might have routes already from Split DNS - if app.cfg.TailcfgDNSConfig.Routes == nil { - app.cfg.TailcfgDNSConfig.Routes = make(map[string][]*dnstype.Resolver) - } - - for _, d := range magicDNSDomains { - // Empty non-nil slice rather than nil: tailcfg.DNSConfig.Clone - // and dns.Config.Clone in tailscale drop map entries whose - // value is nil (see tailscale.com/tailcfg/tailcfg_clone.go and - // tailscale.com/net/dns/dns_clone.go: `if sv == nil { continue }`). - // Sending nil here caused the client's wgengine LinkChange:major - // handler to clobber /etc/resolv.conf on every tunnel-IP rebind - // — the handler reapplies a Clone of lastDNSConfig and the magic - // DNS routes vanish, taking the resolver with them for ~6 min - // until the next route-changing netmap. Empty slice survives - // Clone and carries the same "resolve locally" semantics - // ([tailcfg.DNSConfig.Routes] documents the empty-resolver form). - app.cfg.TailcfgDNSConfig.Routes[d.WithoutTrailingDot()] = []*dnstype.Resolver{} - } - } - if cfg.DERP.ServerEnabled { - derpServerKey, err := readOrCreatePrivateKey(cfg.DERP.ServerPrivateKeyPath) + derpServerKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath)) if err != nil { return nil, fmt.Errorf("reading or creating DERP server private key: %w", err) } @@ -421,7 +395,7 @@ func (h *Headscale) scheduledTasks(ctx context.Context) { log.Info().Msg("fetching DERPMap updates") derpMap, err := backoff.Retry(ctx, func() (*tailcfg.DERPMap, error) { //nolint:contextcheck - derpMap, err := derp.GetDERPMap(h.cfg.DERP) + derpMap, err := derp.GetDERPMap(h.cfg.DERP, h.cfg.BaseDomain) if err != nil { return nil, err } @@ -615,7 +589,7 @@ func (h *Headscale) Serve() error { // Start on the sources that loaded; only a map with no region at all, // after the embedded region and the policy's derpMap, is fatal. - derpMap, derpErr := derp.GetDERPMap(h.cfg.DERP) + derpMap, derpErr := derp.GetDERPMap(h.cfg.DERP, h.cfg.BaseDomain) if derpErr != nil { log.Warn().Err(derpErr).Msg("skipping DERP map sources that failed to load") } @@ -875,7 +849,7 @@ func (h *Headscale) Serve() error { var tailsqlCancel context.CancelFunc if tailsqlEnabled { - if h.cfg.Database.Type != types.DatabaseSqlite { + if !h.cfg.Database.IsSQLite() { //nolint:gocritic // exitAfterDefer: Fatal exits during initialization before servers start log.Fatal(). Str("type", h.cfg.Database.Type). @@ -892,7 +866,7 @@ func (h *Headscale) Serve() error { tailsqlCtx, tailsqlCancel = context.WithCancel(ctx) errorGroup.Go(func() error { - return runTailSQLService(tailsqlCtx, util.TSLogfWrapper(), tailsqlStateDir, h.cfg.Database.Sqlite.Path) + return runTailSQLService(tailsqlCtx, util.TSLogfWrapper(), tailsqlStateDir, h.cfg.SQLitePath()) }) } @@ -1106,14 +1080,15 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) { switch acmeCfg.ChallengeType { case types.DNS01ChallengeType: + resolvers := h.cfg.DNSChallenge.ResolverAddrs() issuer.DNS01Solver = dns01Solver{ DNS01Solver: &certmagic.DNS01Solver{ - DNSProvider: h.cfg.DNSChallenge.Provider, + DNSProvider: h.cfg.DNSProvider(), TTL: dns.ChallengeTTL, - Resolvers: h.cfg.DNSChallenge.Resolvers, + Resolvers: resolvers, Logger: logger, }, - wait: dns.AwaitTXT(h.cfg.DNSChallenge.Resolvers, h.cfg.DNSChallenge.PropagationTimeout), + wait: dns.AwaitTXT(resolvers, h.cfg.DNSChallenge.PropagationTimeout), } case types.TLSALPN01ChallengeType: @@ -1152,7 +1127,7 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) { Logger: logger, }) magic = certmagic.New(cache, certmagic.Config{ - Storage: &certmagic.FileStorage{Path: acmeCfg.CacheDir}, + Storage: &certmagic.FileStorage{Path: h.cfg.AbsPath(acmeCfg.CacheDir)}, Logger: logger, }) @@ -1225,11 +1200,13 @@ func (h *Headscale) getTLSSettings(ctx context.Context) (*tlsBundle, error) { return &tlsBundle{}, nil } + certPath, keyPath := h.cfg.AbsPath(h.cfg.TLS.CertPath), h.cfg.AbsPath(h.cfg.TLS.KeyPath) + load := func() (*tls.Certificate, error) { - cert, err := tls.LoadX509KeyPair(h.cfg.TLS.CertPath, h.cfg.TLS.KeyPath) + cert, err := tls.LoadX509KeyPair(certPath, keyPath) if err != nil { return nil, fmt.Errorf("loading TLS keypair (tls.cert_path=%q, tls.key_path=%q): %w", - h.cfg.TLS.CertPath, h.cfg.TLS.KeyPath, err) + certPath, keyPath, err) } return &cert, nil @@ -1263,14 +1240,14 @@ func (h *Headscale) getTLSSettings(ctx context.Context) (*tlsBundle, error) { now, leaf := time.Now(), cert.Leaf if now.Before(leaf.NotBefore) || now.After(leaf.NotAfter) { return fmt.Errorf("%w (tls.cert_path=%q): valid from %s until %s", - errTLSCertificateNotValidNow, h.cfg.TLS.CertPath, + errTLSCertificateNotValidNow, certPath, leaf.NotBefore.Format(time.RFC3339), leaf.NotAfter.Format(time.RFC3339)) } current.Store(cert) log.Info(). - Str("cert_path", h.cfg.TLS.CertPath). + Str("cert_path", certPath). Str("not_after", leaf.NotAfter.Format(time.RFC3339)). Msg("TLS certificate reloaded") diff --git a/hscontrol/app_test.go b/hscontrol/app_test.go index 6b0379884..b0d180cbd 100644 --- a/hscontrol/app_test.go +++ b/hscontrol/app_test.go @@ -4,9 +4,15 @@ import ( "context" "net/http" "net/http/httptest" + "os" + "path/filepath" "testing" + "github.com/juanfont/headscale/hscontrol/dns" + "github.com/juanfont/headscale/hscontrol/types" + "github.com/libdns/cloudflare" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestSecurityHeaders(t *testing.T) { @@ -79,3 +85,95 @@ func TestDebugHostGuard(t *testing.T) { }) } } + +// TestNewHeadscaleDNSProvider pins that startup builds the provider +// dns.challenge.provider names, reading its secrets, unless Go set one, and +// refuses one that cannot keep node certificates apart. +func TestNewHeadscaleDNSProvider(t *testing.T) { + token := filepath.Join(t.TempDir(), "token") + require.NoError(t, os.WriteFile(token, []byte("from-file\n"), 0o600)) + + oneAccount := map[string]any{ + "name": "acmedns", "username": "u", "password": "p", + "subdomain": "s", "server_url": "https://auth.acme-dns.io", + } + goOnly := &cloudflare.Provider{APIToken: "go-only"} + goOnlyAcmeDNS, err := dns.NewProvider("acmedns", oneAccount, + func(string) (any, bool) { return nil, false }, + func(_, v string) (string, error) { return v, nil }) + require.NoError(t, err) + + tests := []struct { + name string + challenge types.DNSChallengeConfig + certificates bool + wantToken string + wantErr string + }{ + { + name: "built from settings", + challenge: types.DNSChallengeConfig{ProviderSettings: map[string]any{"name": "cloudflare", "api_token": "file:" + token}}, + wantToken: "from-file", + }, + { + name: "go-only provider wins", + challenge: types.DNSChallengeConfig{ + ProviderSettings: map[string]any{"name": "cloudflare", "api_token": "settings"}, + Provider: goOnly, + }, + wantToken: "go-only", + }, + { + name: "unreadable secret", + challenge: types.DNSChallengeConfig{ProviderSettings: map[string]any{"name": "cloudflare", "api_token": "file:/nonexistent"}}, //nolint:gosec // a missing file, not a credential + wantErr: "dns.challenge.provider.api_token: ", + }, + { + name: "one acme-dns account for node certificates", + challenge: types.DNSChallengeConfig{ProviderSettings: oneAccount}, + certificates: true, + wantErr: "for acmedns: ", + }, + { + name: "go-only provider named by its type", + challenge: types.DNSChallengeConfig{Provider: goOnlyAcmeDNS}, + certificates: true, + wantErr: "for *dns.acmeDNS: ", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tmpDir := t.TempDir() + cfg := types.Config{ + ServerURL: "http://localhost:8080", + NoisePrivateKeyPath: tmpDir + "/noise_private.key", + Database: types.DatabaseConfig{ + Type: "sqlite3", + Sqlite: types.SqliteConfig{Path: tmpDir + "/headscale_test.db"}, + }, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + DNSConfig: types.DNSConfig{ + MagicDNS: true, + BaseDomain: "ts.example.com", + Certificates: types.CertificatesConfig{Enabled: tt.certificates}, + }, + DNSChallenge: tt.challenge, + } + + app, err := NewHeadscale(&cfg) + if tt.wantErr != "" { + require.ErrorContains(t, err, tt.wantErr) + + return + } + + require.NoError(t, err) + t.Cleanup(func() { _ = app.state.Close() }) + + provider, ok := cfg.DNSProvider().(*cloudflare.Provider) + require.True(t, ok, "provider is %T", cfg.DNSProvider()) + assert.Equal(t, tt.wantToken, provider.APIToken) + }) + } +} diff --git a/hscontrol/config/files.go b/hscontrol/config/files.go index 73d053625..b3bee537e 100644 --- a/hscontrol/config/files.go +++ b/hscontrol/config/files.go @@ -13,7 +13,6 @@ import ( "github.com/juanfont/headscale/hscontrol/dns" policyv2 "github.com/juanfont/headscale/hscontrol/policy/v2" "github.com/juanfont/headscale/hscontrol/types" - "github.com/juanfont/headscale/hscontrol/util" "tailscale.com/types/key" ) @@ -43,7 +42,7 @@ func Files(cfg *types.Config) []File { var files []File if cfg.Policy.Mode == types.PolicyModeFile && cfg.Policy.Path != "" { - p := util.AbsolutePath(cfg.ConfigDir, cfg.Policy.Path) + p := cfg.AbsPath(cfg.Policy.Path) files = append(files, File{Key: "policy.path", Path: p, Check: func() error { return CheckPolicyFile(p) }}) } @@ -55,7 +54,7 @@ func Files(cfg *types.Config) []File { files = append(files, File{Key: "dns.extra_records_path", Path: p, Check: func() error { return CheckExtraRecordsFile(p) }}) } - if c, k := cfg.TLS.CertPath, cfg.TLS.KeyPath; c != "" { + if c, k := cfg.AbsPath(cfg.TLS.CertPath), cfg.AbsPath(cfg.TLS.KeyPath); c != "" { files = append(files, File{ Key: "tls.cert_path, tls.key_path", Path: c + ", " + k, @@ -63,7 +62,7 @@ func Files(cfg *types.Config) []File { }) } - noise := cfg.NoisePrivateKeyPath + noise := cfg.AbsPath(cfg.NoisePrivateKeyPath) if noise != "" { files = append(files, File{ Key: "noise.private_key_path", Path: noise, CreatedAtStartup: true, @@ -71,7 +70,7 @@ func Files(cfg *types.Config) []File { }) } - if d := cfg.DERP.ServerPrivateKeyPath; cfg.DERP.ServerEnabled && d != "" { + if d := cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath); cfg.DERP.ServerEnabled && d != "" { files = append(files, File{ Key: "derp.server.private_key_path", Path: d, CreatedAtStartup: true, Check: func() error { return checkDERPKey(d, noise) }, @@ -101,7 +100,7 @@ func CheckPolicyFile(path string) error { // CheckDERPMapFile parses a DERP map file as startup loads derp.paths. func CheckDERPMapFile(path string) error { - _, err := derp.GetDERPMap(types.DERPConfig{Paths: []string{path}}) + _, err := derp.GetDERPMap(types.DERPConfig{Paths: []string{path}}, "") return err } diff --git a/hscontrol/db/db.go b/hscontrol/db/db.go index 3c55e3110..fef18228a 100644 --- a/hscontrol/db/db.go +++ b/hscontrol/db/db.go @@ -48,7 +48,7 @@ type HSDatabase struct { // //nolint:gocyclo // migration closures inflate the count; each is linear func NewHeadscaleDatabase(cfg *types.Config) (*HSDatabase, error) { - dbConn, err := openDB(cfg.Database) + dbConn, err := openDB(cfg.Database, cfg.SQLitePath()) if err != nil { return nil, err } @@ -457,7 +457,7 @@ WHERE auth_key_id IN ( // This is currently only done on sqlite as squibble does not // support Postgres and we use our sqlite schema as our source of // truth. - if cfg.Database.Type == types.DatabaseSqlite { + if cfg.Database.IsSQLite() { sqlConn, err := dbConn.DB() if err != nil { return nil, fmt.Errorf("getting DB from gorm: %w", err) @@ -496,7 +496,9 @@ WHERE auth_key_id IN ( return &db, err } -func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) { +// openDB opens the database cfg names; sqlitePath is database.sqlite.path +// resolved. +func openDB(cfg types.DatabaseConfig, sqlitePath string) (*gorm.DB, error) { // TODO(kradalby): Integrate this with zerolog var dbLogger logger.Interface if cfg.Debug { @@ -505,9 +507,9 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) { dbLogger = logger.Default.LogMode(logger.Silent) } - switch cfg.Type { - case types.DatabaseSqlite: - dir := filepath.Dir(cfg.Sqlite.Path) + switch { + case cfg.IsSQLite(): + dir := filepath.Dir(sqlitePath) err := util.EnsureDir(dir) if err != nil { @@ -516,11 +518,11 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) { log.Info(). Str("database", types.DatabaseSqlite). - Str("path", cfg.Sqlite.Path). + Str("path", sqlitePath). Msg("Opening database") // Build SQLite configuration with pragmas set at connection time - sqliteConfig := sqliteconfig.Default(cfg.Sqlite.Path) + sqliteConfig := sqliteconfig.Default(sqlitePath) if cfg.Sqlite.WriteAheadLog { sqliteConfig.JournalMode = sqliteconfig.JournalModeWAL sqliteConfig.WALAutocheckpoint = cfg.Sqlite.WALAutoCheckPoint @@ -560,7 +562,7 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) { return db, nil - case types.DatabasePostgres: + case cfg.Type == types.DatabasePostgres: // Log the DSN without the password. redacted := cfg.Postgres redacted.Pass = "" @@ -599,7 +601,7 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) { } func runMigrations(cfg types.DatabaseConfig, dbConn *gorm.DB, migrations *gormigrate.Gormigrate) error { - if cfg.Type == types.DatabaseSqlite { + if cfg.IsSQLite() { if err := migrations.Migrate(); err != nil { //nolint:noinlineerr return err } @@ -675,7 +677,7 @@ func (hsdb *HSDatabase) Close() error { return err } - if hsdb.cfg.Database.Type == types.DatabaseSqlite && hsdb.cfg.Database.Sqlite.WriteAheadLog { + if hsdb.cfg.Database.IsSQLite() && hsdb.cfg.Database.Sqlite.WriteAheadLog { db.Exec("VACUUM") //nolint:errcheck,noctx } diff --git a/hscontrol/db/db_test.go b/hscontrol/db/db_test.go index d2a43b7a3..0b4016560 100644 --- a/hscontrol/db/db_test.go +++ b/hscontrol/db/db_test.go @@ -1117,7 +1117,8 @@ func TestOpenDBReturnsOpenError(t *testing.T) { ) require.NotPanics(t, func() { - db, err = openDB(tt.cfg(t)) + cfg := tt.cfg(t) + db, err = openDB(cfg, cfg.Sqlite.Path) }) require.Error(t, err) assert.Nil(t, db) diff --git a/hscontrol/db/policy.go b/hscontrol/db/policy.go index c7ba091cf..5a2e42ee9 100644 --- a/hscontrol/db/policy.go +++ b/hscontrol/db/policy.go @@ -5,7 +5,6 @@ import ( "os" "github.com/juanfont/headscale/hscontrol/types" - "github.com/juanfont/headscale/hscontrol/util" "gorm.io/gorm" "gorm.io/gorm/clause" ) @@ -76,7 +75,7 @@ func PolicyBytes(tx *gorm.DB, cfg *types.Config) ([]byte, error) { return nil, nil } - absPath := util.AbsolutePath(cfg.ConfigDir, path) + absPath := cfg.AbsPath(path) return os.ReadFile(absPath) diff --git a/hscontrol/derp/derp.go b/hscontrol/derp/derp.go index 709311574..dd6e494ce 100644 --- a/hscontrol/derp/derp.go +++ b/hscontrol/derp/derp.go @@ -237,8 +237,9 @@ func ApplyPolicy(base, pol *tailcfg.DERPMap) *tailcfg.DERPMap { // GetDERPMap merges every configured DERP map source. A source that fails to // load is skipped rather than failing the rest, as a derp.urls server is often // a third party's: the map always holds what did load, and the error joins -// every failure for the caller to judge. -func GetDERPMap(cfg types.DERPConfig) (*tailcfg.DERPMap, error) { +// every failure for the caller to judge. shuffleSeed orders DERP nodes the +// same on every server of a tailnet. +func GetDERPMap(cfg types.DERPConfig, shuffleSeed string) (*tailcfg.DERPMap, error) { var ( derpMaps []*tailcfg.DERPMap errs []error @@ -269,7 +270,7 @@ func GetDERPMap(cfg types.DERPConfig) (*tailcfg.DERPMap, error) { } derpMap := mergeDERPMaps(derpMaps) - shuffleDERPMap(derpMap, cfg.ShuffleSeed) + shuffleDERPMap(derpMap, shuffleSeed) return derpMap, errors.Join(errs...) } diff --git a/hscontrol/derp/derp_merge_test.go b/hscontrol/derp/derp_merge_test.go index 5755de17b..3462af59d 100644 --- a/hscontrol/derp/derp_merge_test.go +++ b/hscontrol/derp/derp_merge_test.go @@ -68,11 +68,11 @@ func TestGetDERPMapCarriesHomeParams(t *testing.T) { 999: 0.5 `), 0o600)) - got, err := GetDERPMap(types.DERPConfig{DERPMap: base}) + got, err := GetDERPMap(types.DERPConfig{DERPMap: base}, "") require.NoError(t, err) assert.Nil(t, got.HomeParams) - got, err = GetDERPMap(types.DERPConfig{DERPMap: base, Paths: []string{path}}) + got, err = GetDERPMap(types.DERPConfig{DERPMap: base, Paths: []string{path}}, "") require.NoError(t, err) require.NotNil(t, got.HomeParams) assert.Equal(t, diff --git a/hscontrol/derp/derp_test.go b/hscontrol/derp/derp_test.go index 82b4a6f2a..10f937795 100644 --- a/hscontrol/derp/derp_test.go +++ b/hscontrol/derp/derp_test.go @@ -277,11 +277,11 @@ func TestGetDERPMapKeepsOrderAcrossRefreshes(t *testing.T) { source.Regions[id+1] = region } - first, err := GetDERPMap(types.DERPConfig{DERPMap: source, ShuffleSeed: "stable.example.com"}) + first, err := GetDERPMap(types.DERPConfig{DERPMap: source}, "stable.example.com") require.NoError(t, err) for range 5 { - next, err := GetDERPMap(types.DERPConfig{DERPMap: source, ShuffleSeed: "stable.example.com"}) + next, err := GetDERPMap(types.DERPConfig{DERPMap: source}, "stable.example.com") require.NoError(t, err) if diff := cmp.Diff(first, next); diff != "" { @@ -524,7 +524,7 @@ regions: dm, err := GetDERPMap(types.DERPConfig{ URLs: []url.URL{*goodURL, *downURL}, Paths: []string{goodPath, brokenPath, filepath.Join(t.TempDir(), "missing.yaml")}, - }) + }, "") require.ErrorIs(t, err, errDERPMapStatus) require.ErrorContains(t, err, down.URL) require.ErrorContains(t, err, brokenPath) diff --git a/hscontrol/dns/provider.go b/hscontrol/dns/provider.go index 6b49f9c15..5b7458a92 100644 --- a/hscontrol/dns/provider.go +++ b/hscontrol/dns/provider.go @@ -94,12 +94,23 @@ func ProviderNames() []string { return slices.Sorted(maps.Keys(providers)) } +// SettingNames returns the names of the named provider's settings, or nil +// for an unknown provider. +func SettingNames(provider string) []string { + entry, ok := providers[strings.ToLower(provider)] + if !ok { + return nil + } + + return slices.Sorted(maps.Keys(jsonFields(entry.build()))) +} + // NewProvider builds the named provider from its settings. // -// settings holds the provider's keys as written in the configuration -// file. get looks up a single key and is consulted for every field of -// the provider, because environment variables only reach individual -// keys, never a map. secret resolves every string setting, nested ones +// settings holds the provider's keys as written, in any case. get looks up +// a single key as the provider spells it and is consulted for every field +// of the provider, so it wins over a differently cased spelling in +// settings. secret resolves every string setting, nested ones // included, so any of them can be read from a file. Unknown keys are an // error so a typo does not silently leave a credential empty. func NewProvider( diff --git a/hscontrol/dns/provider_test.go b/hscontrol/dns/provider_test.go index 180c6eb25..d7a462bb4 100644 --- a/hscontrol/dns/provider_test.go +++ b/hscontrol/dns/provider_test.go @@ -47,6 +47,13 @@ func TestIsProviderSetting(t *testing.T) { assert.False(t, IsProviderSetting("api_token_path")) } +func TestSettingNames(t *testing.T) { + assert.Subset(t, SettingNames("cloudflare"), []string{"api_token", "zone_token"}) + assert.Subset(t, SettingNames("CloudFlare"), []string{"api_token"}, "named as NewProvider names it") + assert.Nil(t, SettingNames("route53")) + assert.Nil(t, SettingNames("")) +} + // unreadSecret stands in for a caller that checks without reading files. func unreadSecret(_, value string) (string, error) { if strings.HasPrefix(value, "file:") { diff --git a/hscontrol/mapper/batcher.go b/hscontrol/mapper/batcher.go index 593ed43d7..0f1b09045 100644 --- a/hscontrol/mapper/batcher.go +++ b/hscontrol/mapper/batcher.go @@ -62,7 +62,7 @@ func NewBatcher(batchTime time.Duration, workers int, mapper *mapper) *Batcher { // NewBatcherAndMapper creates a new [Batcher] with its [mapper]. func NewBatcherAndMapper(cfg *types.Config, state *state.State) *Batcher { m := newMapper(cfg, state) - b := NewBatcher(cfg.Tuning.BatchChangeDelay, cfg.Tuning.BatcherWorkers, m) + b := NewBatcher(cfg.Tuning.BatchChangeDelay, cfg.Tuning.BatcherWorkerCount(), m) m.batcher = b return b diff --git a/hscontrol/mapper/batcher_test.go b/hscontrol/mapper/batcher_test.go index 9bdd9a6b5..d74078229 100644 --- a/hscontrol/mapper/batcher_test.go +++ b/hscontrol/mapper/batcher_test.go @@ -201,7 +201,6 @@ func setupBatcherWithTestData( }, Tuning: types.Tuning{ BatchChangeDelay: 10 * time.Millisecond, - BatcherWorkers: types.DefaultBatcherWorkers(), // Use same logic as config.go NodeStoreBatchSize: state.TestBatchSize, NodeStoreBatchTimeout: state.TestBatchTimeout, }, @@ -233,7 +232,7 @@ func setupBatcherWithTestData( tb.Fatalf("Failed to create state: %v", err) } - derpMap, err := derp.GetDERPMap(cfg.DERP) + derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.BaseDomain) require.NoError(tb, err) require.NotNil(tb, derpMap) @@ -3143,11 +3142,6 @@ func TestDNSConfigOnlyWithSelfRefresh(t *testing.T) { testData, cleanup := setupBatcherWithTestData(t, NewBatcherAndMapper, 1, 2, normalBufferSize) defer cleanup() - testData.Config.TailcfgDNSConfig = &tailcfg.DNSConfig{ - Proxied: true, - Domains: []string{"headscale.test"}, - } - self := testData.Nodes[0].n.ID mc := newMockNodeConnection(self) diff --git a/hscontrol/mapper/dns_extrarecords_race_test.go b/hscontrol/mapper/dns_extrarecords_race_test.go index 424f7fde1..39f7c033a 100644 --- a/hscontrol/mapper/dns_extrarecords_race_test.go +++ b/hscontrol/mapper/dns_extrarecords_race_test.go @@ -14,13 +14,10 @@ import ( // through the shared lock so the run is race-free under -race. func TestExtraRecordsConcurrentUpdateNoRace(t *testing.T) { uid := uint(1) - cfg := &types.Config{ - TailcfgDNSConfig: &tailcfg.DNSConfig{ - ExtraRecords: []tailcfg.DNSRecord{ - {Name: "initial.example.com", Type: "A", Value: "100.64.0.1"}, - }, - }, - } + cfg := &types.Config{DNSConfig: types.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{ + {Name: "initial.example.com", Type: "A", Value: "100.64.0.1"}, + }}} + cfg.StartDNS(nil) node := (&types.Node{ Hostname: "race-node", diff --git a/hscontrol/mapper/initialmap_storm_test.go b/hscontrol/mapper/initialmap_storm_test.go index 698ee1da3..8c00786f7 100644 --- a/hscontrol/mapper/initialmap_storm_test.go +++ b/hscontrol/mapper/initialmap_storm_test.go @@ -79,7 +79,7 @@ func setupStormBatcher(tb testing.TB, nodeCount, workers int, policy string) (*T st, err := state.NewState(cfg) require.NoError(tb, err) - derpMap, err := derp.GetDERPMap(cfg.DERP) + derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.BaseDomain) require.NoError(tb, err) st.SetDERPMap(derpMap) diff --git a/hscontrol/mapper/mapper.go b/hscontrol/mapper/mapper.go index a6704f366..a10cc862a 100644 --- a/hscontrol/mapper/mapper.go +++ b/hscontrol/mapper/mapper.go @@ -106,9 +106,6 @@ func generateDNSConfig( capMap tailcfg.NodeCapMap, ) *tailcfg.DNSConfig { dnsConfig := cfg.CloneTailcfgDNSConfig() - if dnsConfig == nil { - return nil - } profile := nextDNSProfileFromCapMap(capMap) if profile != "" { diff --git a/hscontrol/mapper/mapper_test.go b/hscontrol/mapper/mapper_test.go index 9957be4b1..96e84696d 100644 --- a/hscontrol/mapper/mapper_test.go +++ b/hscontrol/mapper/mapper_test.go @@ -58,8 +58,8 @@ func TestExitNodeFilteredSet(t *testing.T) { t.Run(tt.name, func(t *testing.T) { got := generateDNSConfig( &types.Config{ - BaseDomain: tt.baseDomain, - TailcfgDNSConfig: &tailcfg.DNSConfig{Proxied: tt.magicDNS}, + BaseDomain: tt.baseDomain, + DNSConfig: types.DNSConfig{MagicDNS: tt.magicDNS, BaseDomain: tt.baseDomain}, }, (&types.Node{}).View(), nil, @@ -86,11 +86,9 @@ func TestDNSConfigMapResponse(t *testing.T) { }, }, { + // Only MagicDNS answers for the base domain. magicDNS: false, - want: &tailcfg.DNSConfig{ - Domains: []string{"foobar.headscale.net"}, - Proxied: false, - }, + want: &tailcfg.DNSConfig{}, }, } @@ -106,19 +104,11 @@ func TestDNSConfigMapResponse(t *testing.T) { } } - baseDomain := "foobar.headscale.net" - - dnsConfigOrig := tailcfg.DNSConfig{ - Routes: make(map[string][]*dnstype.Resolver), - Domains: []string{baseDomain}, - Proxied: tt.magicDNS, - } - nodeInShared1 := mach("test_get_shared_nodes_1", "shared1", 1) got := generateDNSConfig( &types.Config{ - TailcfgDNSConfig: &dnsConfigOrig, + DNSConfig: types.DNSConfig{MagicDNS: tt.magicDNS, BaseDomain: "foobar.headscale.net"}, }, nodeInShared1.View(), nil, @@ -135,15 +125,8 @@ func TestNextDNSCapMapRendering(t *testing.T) { t.Parallel() mkConfig := func(addrs ...string) *types.Config { - resolvers := make([]*dnstype.Resolver, len(addrs)) - for i, a := range addrs { - resolvers[i] = &dnstype.Resolver{Addr: a} - } - return &types.Config{ - TailcfgDNSConfig: &tailcfg.DNSConfig{ - Resolvers: resolvers, - }, + DNSConfig: types.DNSConfig{OverrideLocalDNS: true, Nameservers: types.Nameservers{Global: addrs}}, } } @@ -274,12 +257,10 @@ func TestNextDNSResolverCompat(t *testing.T) { )) require.NoError(t, err) - resolvers := make([]*dnstype.Resolver, 0, len(c.Input.Tailnet.DNS.Nameservers)) - for _, ns := range c.Input.Tailnet.DNS.Nameservers { - resolvers = append(resolvers, &dnstype.Resolver{Addr: ns}) - } - - cfg := &types.Config{TailcfgDNSConfig: &tailcfg.DNSConfig{Resolvers: resolvers}} + cfg := &types.Config{DNSConfig: types.DNSConfig{ + OverrideLocalDNS: true, + Nameservers: types.Nameservers{Global: c.Input.Tailnet.DNS.Nameservers}, + }} // Mismatches by check, one entry per node. diffs := map[string][]string{} @@ -849,11 +830,10 @@ func TestGenerateDNSConfigNilHostinfoNoPanic(t *testing.T) { // Hostinfo intentionally nil, as a legacy NULL host_info row loads. }).View() - cfg := &types.Config{ - TailcfgDNSConfig: &tailcfg.DNSConfig{ - Resolvers: []*dnstype.Resolver{{Addr: "https://dns.nextdns.io/abc"}}, - }, - } + cfg := &types.Config{DNSConfig: types.DNSConfig{ + OverrideLocalDNS: true, + Nameservers: types.Nameservers{Global: []string{"https://dns.nextdns.io/abc"}}, + }} require.NotPanics(t, func() { generateDNSConfig(cfg, node, nil) @@ -1215,7 +1195,7 @@ func TestGenerateMapResponseDebugOnlyOnFullMaps(t *testing.T) { }, // Without these the DERP map and DNS config renders carry // nothing and no frame is generated at all. - TailcfgDNSConfig: &tailcfg.DNSConfig{Proxied: true}, + DNSConfig: types.DNSConfig{MagicDNS: true}, Tuning: types.Tuning{ NodeStoreBatchSize: state.TestBatchSize, NodeStoreBatchTimeout: state.TestBatchTimeout, @@ -1376,22 +1356,19 @@ func TestCertDomains(t *testing.T) { baseDomain = "ts.example.com" } - cfg := &types.Config{ - BaseDomain: baseDomain, - DNSConfig: tt.dns, - DNSChallenge: types.DNSChallengeConfig{Provider: tt.provider}, - TailcfgDNSConfig: &tailcfg.DNSConfig{ - Proxied: true, - ExtraRecords: []tailcfg.DNSRecord{ - {Name: "Grafana.ts.example.com", Type: "A", Value: "100.64.0.3"}, - {Name: "grafana.svc.ts.example.com.", Type: "A", Value: "100.64.0.4"}, - }, - }, + dnsCfg := tt.dns + dnsCfg.MagicDNS = true + dnsCfg.ExtraRecords = []tailcfg.DNSRecord{ + {Name: "Grafana.ts.example.com", Type: "A", Value: "100.64.0.3"}, + {Name: "grafana.svc.ts.example.com.", Type: "A", Value: "100.64.0.4"}, } + cfg := &types.Config{BaseDomain: baseDomain, DNSConfig: dnsCfg} + cfg.StartDNS(tt.provider) + got := generateDNSConfig(cfg, tt.node.View(), nil) assert.Equal(t, tt.want, got.CertDomains) - assert.Nil(t, cfg.TailcfgDNSConfig.CertDomains, "global DNS config must stay untouched") + assert.Nil(t, cfg.CloneTailcfgDNSConfig().CertDomains, "global DNS config must stay untouched") }) } } diff --git a/hscontrol/mapper/tail_test.go b/hscontrol/mapper/tail_test.go index 0a702c81b..a2cf9be71 100644 --- a/hscontrol/mapper/tail_test.go +++ b/hscontrol/mapper/tail_test.go @@ -54,7 +54,6 @@ func TestTailNode(t *testing.T) { tests := []struct { name string node *types.Node - dnsConfig *tailcfg.DNSConfig baseDomain string want *tailcfg.Node wantErr bool @@ -65,7 +64,6 @@ func TestTailNode(t *testing.T) { GivenName: "empty", Hostinfo: &tailcfg.Hostinfo{}, }, - dnsConfig: &tailcfg.DNSConfig{}, baseDomain: "", want: &tailcfg.Node{ Name: "empty", @@ -118,7 +116,6 @@ func TestTailNode(t *testing.T) { ApprovedRoutes: []netip.Prefix{tsaddr.AllIPv4(), tsaddr.AllIPv6(), netip.MustParsePrefix("192.168.0.0/24")}, CreatedAt: created, }, - dnsConfig: &tailcfg.DNSConfig{}, baseDomain: "", want: &tailcfg.Node{ ID: 0, @@ -174,7 +171,6 @@ func TestTailNode(t *testing.T) { GivenName: "minimal", Hostinfo: &tailcfg.Hostinfo{}, }, - dnsConfig: &tailcfg.DNSConfig{}, baseDomain: "example.com", want: &tailcfg.Node{ // a node name should have a dot appended @@ -203,9 +199,8 @@ func TestTailNode(t *testing.T) { t.Parallel() cfg := &types.Config{ - BaseDomain: tt.baseDomain, - TailcfgDNSConfig: tt.dnsConfig, - Taildrop: types.TaildropConfig{Enabled: true}, + BaseDomain: tt.baseDomain, + Taildrop: types.TaildropConfig{Enabled: true}, } // Stub primary-route lookup: tt.node owns its SubnetRoutes, diff --git a/hscontrol/servertest/server.go b/hscontrol/servertest/server.go index 11bd7ae26..36bed748d 100644 --- a/hscontrol/servertest/server.go +++ b/hscontrol/servertest/server.go @@ -23,7 +23,6 @@ import ( "github.com/juanfont/headscale/hscontrol/types/change" "tailscale.com/net/memnet" "tailscale.com/tailcfg" - "tailscale.com/types/dnstype" ) // TestServer is an in-process Headscale control server suitable for @@ -121,8 +120,7 @@ func WithTaildropEnabled(enabled bool) ServerOption { return func(c *serverConfig) { c.taildropEnabled = enabled } } -// WithMagicDNS enables MagicDNS under domain, so map responses carry a -// [tailcfg.DNSConfig]. +// WithMagicDNS enables MagicDNS under domain. func WithMagicDNS(domain string) ServerOption { return func(c *serverConfig) { c.magicDNSDomain = domain } } @@ -139,8 +137,8 @@ func WithCertificates(provider hsdns.Provider) ServerOption { return func(c *serverConfig) { c.certProvider = provider } } -// WithDNSResolvers sets the global DNS resolvers, so map responses carry a -// [tailcfg.DNSConfig]. +// WithDNSResolvers sets the global DNS resolvers, overriding the nodes' +// local DNS. func WithDNSResolvers(addrs ...string) ServerOption { return func(c *serverConfig) { c.dnsResolvers = addrs } } @@ -199,14 +197,10 @@ func NewServer(tb testing.TB, opts ...ServerOption) *TestServer { }, } - if sc.magicDNSDomain != "" || len(sc.dnsResolvers) > 0 { - cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{} - } - if sc.magicDNSDomain != "" { cfg.BaseDomain = sc.magicDNSDomain - cfg.TailcfgDNSConfig.Proxied = true - cfg.TailcfgDNSConfig.Domains = []string{sc.magicDNSDomain} + cfg.DNSConfig.MagicDNS = true + cfg.DNSConfig.BaseDomain = sc.magicDNSDomain } if sc.certProvider != nil { @@ -214,8 +208,9 @@ func NewServer(tb testing.TB, opts ...ServerOption) *TestServer { cfg.DNSChallenge.Provider = sc.certProvider } - for _, addr := range sc.dnsResolvers { - cfg.TailcfgDNSConfig.Resolvers = append(cfg.TailcfgDNSConfig.Resolvers, &dnstype.Resolver{Addr: addr}) + if len(sc.dnsResolvers) > 0 { + cfg.DNSConfig.OverrideLocalDNS = true + cfg.DNSConfig.Nameservers.Global = sc.dnsResolvers } app, err := hscontrol.NewHeadscale(&cfg) @@ -323,9 +318,7 @@ func (s *TestServer) MemNet() *memnet.Network { } // SetExtraRecords replaces the extra DNS records and sends them to every -// node, as a reload of dns.extra_records_path does. The server needs -// [WithMagicDNS] or [WithDNSResolvers], which give it a DNS config to hold -// them. +// node, as a reload of dns.extra_records_path does. func (s *TestServer) SetExtraRecords(records []tailcfg.DNSRecord) { s.cfg.SetExtraRecords(records) s.App.Change(change.ExtraRecords()) diff --git a/hscontrol/state/node_store_hostname_test.go b/hscontrol/state/node_store_hostname_test.go index d8e8b8b68..2a5effa55 100644 --- a/hscontrol/state/node_store_hostname_test.go +++ b/hscontrol/state/node_store_hostname_test.go @@ -41,10 +41,10 @@ func TestNewNodeStoreBumpsDuplicateNames(t *testing.T) { func TestPutNodeBumpsPastReservedLabel(t *testing.T) { cfg := persistTestConfig(t.TempDir() + "/headscale.db") - cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{ + cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ {Name: "laptop." + cfg.BaseDomain}, {Name: "laptop-1." + cfg.BaseDomain}, - }} + } s, err := NewState(cfg) require.NoError(t, err) t.Cleanup(func() { _ = s.Close() }) @@ -55,9 +55,9 @@ func TestPutNodeBumpsPastReservedLabel(t *testing.T) { func TestSetGivenNameRejectsReservedLabel(t *testing.T) { cfg := persistTestConfig(t.TempDir() + "/headscale.db") - cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{ + cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ {Name: "laptop." + cfg.BaseDomain}, - }} + } s, err := NewState(cfg) require.NoError(t, err) t.Cleanup(func() { _ = s.Close() }) diff --git a/hscontrol/state/persist_test.go b/hscontrol/state/persist_test.go index 90a3fc4f0..cca605ebe 100644 --- a/hscontrol/state/persist_test.go +++ b/hscontrol/state/persist_test.go @@ -103,9 +103,9 @@ func persistTestConfig(dbPath string) *types.Config { func TestLoadedDuplicateNamesAreResolvedInMemory(t *testing.T) { dbPath := t.TempDir() + "/headscale.db" cfg := persistTestConfig(dbPath) - cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{ + cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ {Name: "grafana." + cfg.BaseDomain, Type: "A", Value: "100.64.0.100"}, - }} + } database, err := db.NewHeadscaleDatabase(cfg) require.NoError(t, err) diff --git a/hscontrol/state/rename_test.go b/hscontrol/state/rename_test.go index 336154746..ebe935556 100644 --- a/hscontrol/state/rename_test.go +++ b/hscontrol/state/rename_test.go @@ -14,9 +14,10 @@ import ( func TestNodeNameCannotShadowExtraRecord(t *testing.T) { cfg := persistTestConfig(t.TempDir() + "/headscale.db") - cfg.TailcfgDNSConfig = &tailcfg.DNSConfig{ExtraRecords: []tailcfg.DNSRecord{ + cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ {Name: "grafana." + cfg.BaseDomain, Type: "A", Value: "100.64.0.100"}, - }} + } + cfg.StartDNS(nil) // as NewHeadscale does, so SetExtraRecords takes s, err := NewState(cfg) require.NoError(t, err) t.Cleanup(func() { _ = s.Close() }) diff --git a/hscontrol/types/config.go b/hscontrol/types/config.go index 819305015..7f976a042 100644 --- a/hscontrol/types/config.go +++ b/hscontrol/types/config.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "io/fs" + "maps" "net" "net/netip" "net/url" @@ -22,6 +23,7 @@ import ( "github.com/prometheus/common/model" "github.com/rs/zerolog" "github.com/rs/zerolog/log" + "github.com/spf13/cast" "go4.org/netipx" "tailscale.com/net/tsaddr" "tailscale.com/tailcfg" @@ -145,10 +147,6 @@ type Config struct { // not directly converted into a [tailcfg.DNSConfig]. DNSConfig DNSConfig - // TailcfgDNSConfig is the tailcfg representation of the DNS configuration, - // it can be used directly when sending Netmaps to clients. - TailcfgDNSConfig *tailcfg.DNSConfig - DNSChallenge DNSChallengeConfig UnixSocket string @@ -166,12 +164,24 @@ type Config struct { Tuning Tuning - // ConfigDir resolves relative paths such as policy.path. + // ConfigDir is where [Config.AbsPath] resolves relative paths. ConfigDir string `json:"-"` // UnreadSecrets are the file: secrets [CheckServerConfig] left unread, // each as key and path. UnreadSecrets []KV `json:"-"` + + // dns is nil until [Config.StartDNS]. + dns *liveDNS +} + +// liveDNS is the DNS state of a running server: the tailcfg form, whose +// extra records the extra-records watcher replaces while map builds clone +// it, and the provider startup built. +type liveDNS struct { + mu sync.RWMutex + dns *tailcfg.DNSConfig + provider hsdns.Provider } type DNSConfig struct { @@ -190,23 +200,72 @@ type DNSConfig struct { // publishes its DNS-01 challenge through [DNSChallengeConfig]. type CertificatesConfig struct { Enabled bool - // Zone is the public DNS zone challenge records are written to. It is - // base_domain unless base_domain sits below the zone apex. + // Zone is the public DNS zone challenge records are written to, when + // base_domain sits below the zone apex. See [DNSConfig.CertificateZone]. Zone string } +// CertificateZone is the zone challenge records are written to: +// Certificates.Zone, else BaseDomain. +func (d DNSConfig) CertificateZone() string { + return cmp.Or(d.Certificates.Zone, d.BaseDomain) +} + // DNSChallengeConfig is the DNS provider answering ACME DNS-01 // challenges for node certificates and headscale's own certificate. type DNSChallengeConfig struct { PropagationTimeout time.Duration Resolvers []string - ProviderName string - // Provider is nil when no provider is configured. It is built while - // loading so `headscale check config` reports bad provider settings, - // and never serialised because it holds credentials. + // ProviderSettings is dns.challenge.provider, name included. Never + // serialised: its settings are credentials. + ProviderSettings map[string]any `json:"-"` + // Provider is set only from Go, by an embedder or a test, and wins + // over ProviderSettings. The loader never sets it. Provider hsdns.Provider `json:"-"` } +// ProviderName is the provider ProviderSettings names, or "". +func (c DNSChallengeConfig) ProviderName() string { + return cast.ToString(c.ProviderSettings["name"]) +} + +// NewProvider builds the provider ProviderSettings names, handing secret +// each string setting under its full config key. +func (c DNSChallengeConfig) NewProvider(secret func(key, value string) (string, error)) (hsdns.Provider, error) { + return hsdns.NewProvider( + c.ProviderName(), + c.ProviderSettings, + func(key string) (any, bool) { + v, ok := c.ProviderSettings[key] + + return v, ok + }, + func(key, value string) (string, error) { + return secret(providerKey+"."+key, value) + }, + ) +} + +// ResolverAddrs returns Resolvers as host:port, or the defaults when none +// are set. Like dns.nameservers, a resolver may be a bare IP. +func (c DNSChallengeConfig) ResolverAddrs() []string { + if len(c.Resolvers) == 0 { + return slices.Clone(defaultChallengeResolvers) + } + + addrs := make([]string, len(c.Resolvers)) + for i, r := range c.Resolvers { + addrs[i] = r + + _, _, err := net.SplitHostPort(r) + if err != nil { + addrs[i] = net.JoinHostPort(r, "53") + } + } + + return addrs +} + type Nameservers struct { Global []string Split map[string][]string @@ -293,7 +352,7 @@ type GormConfig struct { } type DatabaseConfig struct { - // Type sets the database type, either "sqlite3" or "postgres" + // Type sets the database type: "sqlite", "sqlite3" or "postgres". Type string Debug bool @@ -304,6 +363,11 @@ type DatabaseConfig struct { Postgres PostgresConfig } +// IsSQLite reports whether Type names SQLite, in either spelling. +func (d DatabaseConfig) IsSQLite() bool { + return d.Type == DatabaseSqlite || d.Type == "sqlite" +} + type TLSConfig struct { CertPath string KeyPath string @@ -358,8 +422,6 @@ type DERPConfig struct { UpdateFrequency time.Duration IPv4 string IPv6 string - // ShuffleSeed orders DERP nodes the same on every server of a tailnet. - ShuffleSeed string `json:"-"` } type LogTailConfig struct { @@ -419,7 +481,7 @@ type Tuning struct { NodeMapSessionBufferedChanSize int // BatcherWorkers controls the number of parallel workers processing map - // updates for connected clients. + // updates for connected clients. See [Tuning.BatcherWorkerCount]. BatcherWorkers int // RegisterCacheExpiration is how long registration cache entries remain @@ -461,6 +523,15 @@ type Tuning struct { NodeStoreBatchTimeout time.Duration } +// BatcherWorkerCount is BatcherWorkers, or [DefaultBatcherWorkers] when unset. +func (t Tuning) BatcherWorkerCount() int { + if t.BatcherWorkers > 0 { + return t.BatcherWorkers + } + + return DefaultBatcherWorkers() +} + func validatePKCEMethod(method string) error { if method != PKCEMethodPlain && method != PKCEMethodS256 { return errInvalidPKCEMethod @@ -509,6 +580,21 @@ func (c *Config) Domain() string { return u.Hostname() } +// AbsPath resolves a path from the configuration against [Config.ConfigDir]. +func (c *Config) AbsPath(p string) string { + return util.AbsolutePath(c.ConfigDir, p) +} + +// SQLitePath is database.sqlite.path resolved, keeping SQLite's in-memory +// name, which is not a file. +func (c *Config) SQLitePath() string { + if c.Database.Sqlite.Path == ":memory:" { + return c.Database.Sqlite.Path + } + + return c.AbsPath(c.Database.Sqlite.Path) +} + // ServesRoute reports whether an approved route is handed to clients. A // single address inside the node ranges, in either spelling, names a node // rather than a subnet, so it stays approved but is never served. 4via6 @@ -999,49 +1085,20 @@ func validateCertificatesConfig(v *configValidator) { } } -// dnsChallengeConfig builds the DNS-01 provider. Provider keys are read -// one by one, because environment variables never reach into a map. +// dnsChallengeConfig reads dns.challenge and builds the provider it names +// only to report bad settings; startup builds the one it uses. func dnsChallengeConfig(secret func(key, value string) (string, error)) (DNSChallengeConfig, error) { cfg := DNSChallengeConfig{ PropagationTimeout: src.Duration("dns.challenge.propagation_timeout"), Resolvers: src.StringSlice("dns.challenge.resolvers"), - ProviderName: src.String("dns.challenge.provider.name"), + ProviderSettings: src.StringMap("dns.challenge.provider"), } - if len(cfg.Resolvers) == 0 { - cfg.Resolvers = slices.Clone(defaultChallengeResolvers) - } - - // Like dns.nameservers, a resolver may be a bare IP. - for i, r := range cfg.Resolvers { - _, _, err := net.SplitHostPort(r) - if err != nil { - cfg.Resolvers[i] = net.JoinHostPort(r, "53") - } - } - - if cfg.ProviderName == "" { + if cfg.ProviderName() == "" { return cfg, nil } - provider, err := hsdns.NewProvider( - cfg.ProviderName, - src.StringMap("dns.challenge.provider"), - func(key string) (any, bool) { - key = "dns.challenge.provider." + key - - // Provider fields are not in configKeys, so the source never - // maps their variables. - if v := os.Getenv(configEnvName(key)); v != "" { - return v, true - } - - return src.Get(key), src.IsSet(key) - }, - func(key, value string) (string, error) { - return secret("dns.challenge.provider."+key, value) - }, - ) + provider, err := cfg.NewProvider(secret) if err != nil { return cfg, err } @@ -1051,38 +1108,36 @@ func dnsChallengeConfig(secret func(key, value string) (string, error)) (DNSChal if iso, ok := provider.(hsdns.Isolator); ok && src.Bool("dns.certificates.enabled") { err = iso.CheckIsolation() if err != nil { - return cfg, fmt.Errorf("%w for %s: %w", hsdns.ErrProviderConfig, cfg.ProviderName, err) + return cfg, fmt.Errorf("%w for %s: %w", hsdns.ErrProviderConfig, cfg.ProviderName(), err) } } - cfg.Provider = provider - return cfg, nil } -func tlsConfig(dir string) TLSConfig { +func tlsConfig() TLSConfig { return TLSConfig{ - CertPath: util.AbsolutePath(dir, src.String("tls.cert_path")), - KeyPath: util.AbsolutePath(dir, src.String("tls.key_path")), + CertPath: src.String("tls.cert_path"), + KeyPath: src.String("tls.key_path"), ACME: ACMEConfig{ Hostname: src.String("tls.acme.hostname"), ChallengeType: src.String("tls.acme.challenge_type"), HTTPListen: src.String("tls.acme.http_listen"), URL: src.String("tls.acme.url"), Email: src.String("tls.acme.email"), - CacheDir: util.AbsolutePath(dir, src.String("tls.acme.cache_dir")), + CacheDir: src.String("tls.acme.cache_dir"), }, } } -func derpConfig(dir string) DERPConfig { +func derpConfig() DERPConfig { serverEnabled := src.Bool("derp.server.enabled") serverRegionID := src.Int64("derp.server.region_id") serverRegionCode := src.String("derp.server.region_code") serverRegionName := src.String("derp.server.region_name") serverVerifyClients := src.Bool("derp.server.verify_clients") stunAddr := src.String("derp.server.stun_listen_addr") - privateKeyPath := util.AbsolutePath(dir, src.String("derp.server.private_key_path")) + privateKeyPath := src.String("derp.server.private_key_path") ipv4 := src.String("derp.server.ipv4") ipv6 := src.String("derp.server.ipv6") automaticallyAddEmbeddedDerpRegion := src.Bool( @@ -1127,7 +1182,6 @@ func derpConfig(dir string) DERPConfig { IPv4: ipv4, IPv6: ipv6, AutomaticallyAddEmbeddedDerpRegion: automaticallyAddEmbeddedDerpRegion, - ShuffleSeed: src.String("dns.base_domain"), } } @@ -1181,18 +1235,7 @@ func logConfig() LogConfig { } } -// sqlitePath resolves database.sqlite.path, keeping SQLite's in-memory -// name, which is not a file. -func sqlitePath(dir string) string { - path := src.String("database.sqlite.path") - if path == ":memory:" { - return path - } - - return util.AbsolutePath(dir, path) -} - -func databaseConfig(v *configValidator, secret func(key, value string) (string, error), dir string) DatabaseConfig { +func databaseConfig(v *configValidator, secret func(key, value string) (string, error)) DatabaseConfig { debug := src.Bool("database.debug") type_ := src.String("database.type") @@ -1201,13 +1244,6 @@ func databaseConfig(v *configValidator, secret func(key, value string) (string, slowThreshold := time.Duration(src.Int64("database.gorm.slow_threshold")) * time.Millisecond parameterizedQueries := src.Bool("database.gorm.parameterized_queries") - switch type_ { - case DatabaseSqlite, DatabasePostgres: - break - case "sqlite": - type_ = "sqlite3" - } - pass := src.String("database.postgres.pass") if type_ == DatabasePostgres { pass = configSecret(v, secret, "database.postgres.pass", pass) @@ -1223,7 +1259,7 @@ func databaseConfig(v *configValidator, secret func(key, value string) (string, ParameterizedQueries: parameterizedQueries, }, Sqlite: SqliteConfig{ - Path: sqlitePath(dir), + Path: src.String("database.sqlite.path"), WriteAheadLog: src.Bool("database.sqlite.write_ahead_log"), WALAutoCheckPoint: src.Int("database.sqlite.wal_autocheckpoint"), }, @@ -1261,7 +1297,7 @@ func dns() (DNSConfig, error) { dns.SearchDomains = src.StringSlice("dns.search_domains") dns.ExtraRecordsPath = src.String("dns.extra_records_path") dns.Certificates.Enabled = src.Bool("dns.certificates.enabled") - dns.Certificates.Zone = cmp.Or(src.String("dns.certificates.zone"), dns.BaseDomain) + dns.Certificates.Zone = src.String("dns.certificates.zone") if src.IsSet("dns.extra_records") { var extraRecords []tailcfg.DNSRecord @@ -1277,54 +1313,62 @@ func dns() (DNSConfig, error) { return dns, nil } -// parseResolvers converts nameserver strings into DNS resolvers. -// If a nameserver is a valid IP, it will be used as a regular resolver. -// If a nameserver is a valid URL, it will be used as a DoH resolver. -// If a nameserver is neither a valid URL nor a valid IP, it will be ignored. -// When domain is non-empty, it is included in the warning for invalid entries. -func parseResolvers(nameservers []string, domain string) []*dnstype.Resolver { +// parseResolvers converts nameserver strings into DNS resolvers: an IP is a +// plain resolver, a URL a DoH one. Anything else is skipped; the loader +// warns about it, see [DNSConfig.nameserverWarnings]. +func parseResolvers(nameservers []string) []*dnstype.Resolver { var resolvers []*dnstype.Resolver - for _, nsStr := range nameservers { - if _, err := netip.ParseAddr(nsStr); err == nil { //nolint:noinlineerr - resolvers = append(resolvers, &dnstype.Resolver{ - Addr: nsStr, - }) - - continue + for _, ns := range nameservers { + if validNameserver(ns) { + resolvers = append(resolvers, &dnstype.Resolver{Addr: ns}) } - - if _, err := url.Parse(nsStr); err == nil { //nolint:noinlineerr - resolvers = append(resolvers, &dnstype.Resolver{ - Addr: nsStr, - }) - - continue - } - - e := log.Warn().Str("nameserver", nsStr) - if domain != "" { - e = e.Str("domain", domain) - } - - e.Msg("invalid nameserver, ignoring") } return resolvers } +func validNameserver(ns string) bool { + _, addrErr := netip.ParseAddr(ns) + _, urlErr := url.Parse(ns) + + return addrErr == nil || urlErr == nil +} + +// nameserverWarnings lists each nameserver parseResolvers skips, so the +// load that reads the config reports it rather than each build of it. +func (d DNSConfig) nameserverWarnings() []string { + var warnings []string + + check := func(key string, nameservers []string) { + for _, ns := range nameservers { + if !validNameserver(ns) { + warnings = append(warnings, fmt.Sprintf("invalid nameserver %q in %s, ignoring", ns, key)) + } + } + } + + check("dns.nameservers.global", d.Nameservers.Global) + + for _, domain := range slices.Sorted(maps.Keys(d.Nameservers.Split)) { + check("dns.nameservers.split."+domain, d.Nameservers.Split[domain]) + } + + return warnings +} + // globalResolvers returns the global DNS resolvers // defined in the config file. -func (d *DNSConfig) globalResolvers() []*dnstype.Resolver { - return parseResolvers(d.Nameservers.Global, "") +func (d DNSConfig) globalResolvers() []*dnstype.Resolver { + return parseResolvers(d.Nameservers.Global) } // splitResolvers returns a map of domain to DNS resolvers. -func (d *DNSConfig) splitResolvers() map[string][]*dnstype.Resolver { +func (d DNSConfig) splitResolvers() map[string][]*dnstype.Resolver { routes := make(map[string][]*dnstype.Resolver) for domain, nameservers := range d.Nameservers.Split { - routes[domain] = parseResolvers(nameservers, domain) + routes[domain] = parseResolvers(nameservers) } return routes @@ -1357,6 +1401,48 @@ func dnsToTailcfgDNS(dns DNSConfig) *tailcfg.DNSConfig { return &cfg } +// TailcfgDNSConfig builds the DNS config clients get from DNSConfig and the +// IP prefixes. It is never nil. +func (c *Config) TailcfgDNSConfig() *tailcfg.DNSConfig { + cfg := dnsToTailcfgDNS(c.DNSConfig) + if !cfg.Proxied { + return cfg + } + + // Clients route reverse lookups for the Tailscale ranges themselves + // (magicDNSRootDomains in tailscale.com/ipn/ipnlocal) and SaaS sends + // no reverse routes, so only a prefix outside those ranges needs them. + outside := func(p, r netip.Prefix) bool { + return p.Bits() < r.Bits() || !r.Contains(p.Addr()) + } + + var reverse []dnsname.FQDN + if c.PrefixV4 != nil && outside(*c.PrefixV4, tsaddr.CGNATRange()) { + reverse = append(reverse, util.GenerateIPv4DNSRootDomain(*c.PrefixV4)...) + } + + if c.PrefixV6 != nil && outside(*c.PrefixV6, tsaddr.TailscaleULARange()) { + reverse = append(reverse, util.GenerateIPv6DNSRootDomain(*c.PrefixV6)...) + } + + for _, d := range reverse { + // Empty non-nil slice rather than nil: tailcfg.DNSConfig.Clone + // and dns.Config.Clone in tailscale drop map entries whose + // value is nil (see tailscale.com/tailcfg/tailcfg_clone.go and + // tailscale.com/net/dns/dns_clone.go: `if sv == nil { continue }`). + // Sending nil here caused the client's wgengine LinkChange:major + // handler to clobber /etc/resolv.conf on every tunnel-IP rebind + // — the handler reapplies a Clone of lastDNSConfig and the magic + // DNS routes vanish, taking the resolver with them for ~6 min + // until the next route-changing netmap. Empty slice survives + // Clone and carries the same "resolve locally" semantics + // ([tailcfg.DNSConfig.Routes] documents the empty-resolver form). + cfg.Routes[d.WithoutTrailingDot()] = []*dnstype.Resolver{} + } + + return cfg +} + // warnBanner prints a highly visible warning banner to the log output. // It wraps the provided lines in an ASCII-art box with a "Warning!" header. // This is intended for critical configuration issues that users must not ignore. @@ -1443,7 +1529,7 @@ func LoadCLIConfig() (*Config, error) { // Over the unix socket the CLI needs no key, so it is not read. cliAPIKey := src.String("cli.api_key") if src.String("cli.address") != "" { - cliAPIKey = configSecret(v, resolveSecret, "cli.api_key", cliAPIKey) + cliAPIKey = configSecret(v, ResolveSecret, "cli.api_key", cliAPIKey) } err := v.Err() @@ -1470,7 +1556,7 @@ func LoadCLIConfig() (*Config, error) { // LoadServerConfig returns the full Headscale configuration to // host a Headscale server. This is called as part of `headscale serve`. func LoadServerConfig() (*Config, error) { - return loadServerConfig(resolveSecret) + return loadServerConfig(ResolveSecret) } // CheckServerConfig validates the server configuration as @@ -1622,8 +1708,12 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, }) } + for _, w := range dnsConfig.nameserverWarnings() { + log.Warn().Msg(w) + } + dir := configDir() - derpConfig := derpConfig(dir) + derpConfig := derpConfig() logTailConfig := logtailConfig() dnsChallenge, err := dnsChallengeConfig(secret) @@ -1636,7 +1726,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, v.Add(&ConfigError{ Reason: "dns.challenge.provider is invalid", - Current: []KV{{"dns.challenge.provider.name", dnsChallenge.ProviderName}}, + Current: []KV{{"dns.challenge.provider.name", dnsChallenge.ProviderName()}}, Detail: err.Error(), Allowed: allowed, Hint: `check the provider name and its settings; any string setting can be read from a file with "file:"`, @@ -1651,7 +1741,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, oidcClientSecret = configSecret(v, secret, "oidc.client_secret", oidcClientSecret) } - database := databaseConfig(v, secret, dir) + database := databaseConfig(v, secret) serverURL := strings.TrimRight(src.String("server_url"), "/") @@ -1686,7 +1776,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, PrefixV6: prefix6, IPAllocation: alloc, - NoisePrivateKeyPath: util.AbsolutePath(dir, src.String("noise.private_key_path")), + NoisePrivateKeyPath: src.String("noise.private_key_path"), BaseDomain: dnsConfig.BaseDomain, DERP: derpConfig, @@ -1710,11 +1800,10 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, Database: database, - TLS: tlsConfig(dir), + TLS: tlsConfig(), - DNSConfig: dnsConfig, - TailcfgDNSConfig: dnsToTailcfgDNS(dnsConfig), - DNSChallenge: dnsChallenge, + DNSConfig: dnsConfig, + DNSChallenge: dnsChallenge, UnixSocket: src.String("unix_socket"), UnixSocketPermission: socketPerm, @@ -1765,13 +1854,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, NodeMapSessionBufferedChanSize: src.Int( "tuning.node_mapsession_buffered_chan_size", ), - BatcherWorkers: func() int { - if workers := src.Int("tuning.batcher_workers"); workers > 0 { - return workers - } - - return DefaultBatcherWorkers() - }(), + BatcherWorkers: src.Int("tuning.batcher_workers"), RegisterCacheExpiration: src.Duration("tuning.register_cache_expiration"), RegisterCacheMaxEntries: src.Int("tuning.register_cache_max_entries"), NodeStoreBatchSize: src.Int("tuning.node_store_batch_size"), @@ -1843,23 +1926,35 @@ func isSafeServerURL(serverURL, baseDomain string) error { return nil } -// tailcfgDNSMu guards concurrent access to the mutable ExtraRecords of -// [Config.TailcfgDNSConfig] between the extra-records file watcher (writer) -// and the per-client map builds that clone it (readers). It is a package-level -// lock so [Config] stays freely copyable during construction. -var tailcfgDNSMu sync.RWMutex +// StartDNS builds the DNS config clients get, from here on changed only by +// [Config.SetExtraRecords], and keeps provider for [Config.DNSProvider]. +// Call it before the config is shared. +func (c *Config) StartDNS(provider hsdns.Provider) { + c.dns = &liveDNS{dns: c.TailcfgDNSConfig(), provider: provider} +} -// CloneTailcfgDNSConfig returns a deep copy of [Config.TailcfgDNSConfig], or -// nil if none is set. Safe for concurrent use with [Config.SetExtraRecords]. -func (c *Config) CloneTailcfgDNSConfig() *tailcfg.DNSConfig { - tailcfgDNSMu.RLock() - defer tailcfgDNSMu.RUnlock() - - if c.TailcfgDNSConfig == nil { - return nil +// DNSProvider returns the provider [Config.StartDNS] was given, else the +// Go-only DNSChallenge.Provider. +func (c *Config) DNSProvider() hsdns.Provider { + if c.dns != nil { + return c.dns.provider } - return c.TailcfgDNSConfig.Clone() + return c.DNSChallenge.Provider +} + +// CloneTailcfgDNSConfig returns a deep copy of the started DNS config, or a +// fresh [Config.TailcfgDNSConfig] before [Config.StartDNS]. Safe for +// concurrent use with [Config.SetExtraRecords]. +func (c *Config) CloneTailcfgDNSConfig() *tailcfg.DNSConfig { + if c.dns == nil { + return c.TailcfgDNSConfig() + } + + c.dns.mu.RLock() + defer c.dns.mu.RUnlock() + + return c.dns.dns.Clone() } // HasExtraRecord reports whether an extra DNS record is exactly name, @@ -1873,14 +1968,15 @@ func (c *Config) HasExtraRecord(name string) bool { // a subdomain of it. Case is ignored, as in TLS name matching; name is // lowercase. func (c *Config) extraRecordAt(name string, orBelow bool) bool { - tailcfgDNSMu.RLock() - defer tailcfgDNSMu.RUnlock() + records := c.DNSConfig.ExtraRecords + if c.dns != nil { + c.dns.mu.RLock() + defer c.dns.mu.RUnlock() - if c.TailcfgDNSConfig == nil { - return false + records = c.dns.dns.ExtraRecords } - for _, r := range c.TailcfgDNSConfig.ExtraRecords { + for _, r := range records { rn := strings.ToLower(strings.TrimSuffix(r.Name, ".")) if rn == name || (orBelow && strings.HasSuffix(rn, "."+name)) { return true @@ -1901,15 +1997,18 @@ func (c *Config) TailcfgDebug() *tailcfg.Debug { return &tailcfg.Debug{DisableLogTail: true} } -// SetExtraRecords replaces the ExtraRecords of [Config.TailcfgDNSConfig]. Safe -// for concurrent use with [Config.CloneTailcfgDNSConfig]. +// SetExtraRecords replaces the extra records of the started DNS config; it +// does nothing before [Config.StartDNS]. Safe for concurrent use with +// [Config.CloneTailcfgDNSConfig]. func (c *Config) SetExtraRecords(records []tailcfg.DNSRecord) { - tailcfgDNSMu.Lock() - defer tailcfgDNSMu.Unlock() - - if c.TailcfgDNSConfig != nil { - c.TailcfgDNSConfig.ExtraRecords = lowercaseRecordNames(records) + if c.dns == nil { + return } + + c.dns.mu.Lock() + defer c.dns.mu.Unlock() + + c.dns.dns.ExtraRecords = lowercaseRecordNames(records) } // lowercaseRecordNames normalizes DNS record names to lowercase, as DNS names diff --git a/hscontrol/types/config_source.go b/hscontrol/types/config_source.go index d58919ee1..53b97a16b 100644 --- a/hscontrol/types/config_source.go +++ b/hscontrol/types/config_source.go @@ -22,7 +22,10 @@ import ( "github.com/tailscale/hujson" ) -const configEnvPrefix = "HEADSCALE_" +const ( + configEnvPrefix = "HEADSCALE_" + providerKey = "dns.challenge.provider" +) // configFileNames is the per-directory search order. TOML and .env are not // read, but still found, so an old file is rejected by name, not skipped. @@ -586,7 +589,9 @@ func (s *configSource) loadEnv(environ []string) error { // into it. The value stays a raw string, which the cast accessors parse as // JSON, unless the JSON object held a removed form, dropped here, or a // per-field variable (HEADSCALE_DNS_CHALLENGE_PROVIDER_NAME) has to be - // layered on top: then the parsed object is set. + // layered on top: then the parsed object is set. The provider's is always + // parsed, as its name is looked up inside it; one that does not decode is + // no provider. for _, key := range slices.Sorted(maps.Keys(openLayer)) { val := openLayer[key] s.k.Delete(key) @@ -611,8 +616,12 @@ func (s *configSource) loadEnv(environ []string) error { }) var v any = val - if decoded && (dropped || shared) { + + switch { + case decoded && (dropped || shared || key == providerKey): v = parsed + case key == providerKey: + continue } err := s.k.Set(key, v) @@ -621,7 +630,34 @@ func (s *configSource) loadEnv(environ []string) error { } } - return s.k.Load(confmap.Provider(layer, "."), nil) + err := s.k.Load(confmap.Provider(layer, "."), nil) + if err != nil { + return err + } + + return s.foldProviderEnv(env) +} + +// foldProviderEnv sets each HEADSCALE_DNS_CHALLENGE_PROVIDER_ of +// the provider named once the rest is loaded. Settings depend on the +// provider, so configKeys cannot list them; a variable no setting of it has +// is ignored, as the prefix is reserved. +func (s *configSource) foldProviderEnv(env map[string]string) error { + settings := cast.ToStringMap(s.k.Get(providerKey)) + folded := false + + for _, setting := range hsdns.SettingNames(cast.ToString(settings["name"])) { + if v := env[configEnvName(providerKey+"."+setting)]; v != "" { + settings[setting] = v + folded = true + } + } + + if !folded { + return nil + } + + return s.k.Set(providerKey, settings) } func reservedEnv(name string) bool { diff --git a/hscontrol/types/config_source_test.go b/hscontrol/types/config_source_test.go index 1229fcb31..0e348f92f 100644 --- a/hscontrol/types/config_source_test.go +++ b/hscontrol/types/config_source_test.go @@ -597,3 +597,104 @@ func TestConfigSourceProviderEnv(t *testing.T) { assert.Equal(t, "x", got["api_token"]) assert.NotContains(t, got, "other") } + +// TestProviderEnvFold pins that HEADSCALE_DNS_CHALLENGE_PROVIDER_ +// reaches the settings of the provider named anywhere, and that a variable +// no provider setting has is ignored without a word. +func TestProviderEnvFold(t *testing.T) { + base := `--- +server_url: https://headscale.example.com +noise: + private_key_path: noise_private.key +prefixes: + v4: 100.64.0.0/10 +database: + type: sqlite +dns: + magic_dns: true + override_local_dns: false + base_domain: ts.example.com +` + + tests := []struct { + name string + yaml string + env map[string]string + want map[string]any + }{ + { + name: "named in the file", + yaml: base + " challenge:\n provider:\n name: cloudflare\n", + env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "x"}, + want: map[string]any{"name": "cloudflare", "api_token": "x"}, + }, + { + name: "named by its variable", + yaml: base, + env: map[string]string{ + "HEADSCALE_DNS_CHALLENGE_PROVIDER_NAME": "cloudflare", + "HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "x", + }, + want: map[string]any{"name": "cloudflare", "api_token": "x"}, + }, + { + name: "named in the json variable", + yaml: base, + env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER": `{"name":"cloudflare","api_token":"json"}`}, + want: map[string]any{"name": "cloudflare", "api_token": "json"}, + }, + { + name: "setting variable beats the json variable", + yaml: base, + env: map[string]string{ + "HEADSCALE_DNS_CHALLENGE_PROVIDER": `{"name":"cloudflare","api_token":"json"}`, + "HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "env", + }, + want: map[string]any{"name": "cloudflare", "api_token": "env"}, + }, + { + name: "name variable beats the json variable", + yaml: base + " challenge:\n provider:\n name: powerdns\n", + env: map[string]string{ + "HEADSCALE_DNS_CHALLENGE_PROVIDER": `{"name":"rfc2136","api_token":"json"}`, + "HEADSCALE_DNS_CHALLENGE_PROVIDER_NAME": "cloudflare", + }, + want: map[string]any{"name": "cloudflare", "api_token": "json"}, + }, + { + name: "variable for no setting of the provider", + yaml: base + " challenge:\n provider:\n name: cloudflare\n api_token: tok\n", + env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER_BOGUS": "1"}, + want: map[string]any{"name": "cloudflare", "api_token": "tok"}, + }, + { + name: "setting variable without a provider", + yaml: base, + env: map[string]string{"HEADSCALE_DNS_CHALLENGE_PROVIDER_API_TOKEN": "x"}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + for k, v := range tt.env { + t.Setenv(k, v) + } + + dir := t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yaml"), []byte(tt.yaml), 0o600)) + require.NoError(t, LoadConfig(dir, false)) + assert.Empty(t, src.Warnings()) + + cfg, err := CheckServerConfig() + require.NoError(t, err) + + if len(tt.want) == 0 { + assert.Empty(t, cfg.DNSChallenge.ProviderSettings) + + return + } + + assert.Equal(t, tt.want, cfg.DNSChallenge.ProviderSettings) + }) + } +} diff --git a/hscontrol/types/config_test.go b/hscontrol/types/config_test.go index 1dfa0a3a2..43a456085 100644 --- a/hscontrol/types/config_test.go +++ b/hscontrol/types/config_test.go @@ -16,6 +16,7 @@ import ( "strconv" "strings" "testing" + "time" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" @@ -74,7 +75,6 @@ func TestReadConfig(t *testing.T) { {Name: "prometheus.myvpn.example.com", Type: "A", Value: "100.64.0.4"}, }, SearchDomains: []string{"test.com", "bar.com"}, - Certificates: CertificatesConfig{Zone: "example.com"}, }, }, { @@ -141,7 +141,6 @@ func TestReadConfig(t *testing.T) { {Name: "prometheus.myvpn.example.com", Type: "A", Value: "100.64.0.4"}, }, SearchDomains: []string{"test.com", "bar.com"}, - Certificates: CertificatesConfig{Zone: "example.com"}, }, }, { @@ -340,7 +339,6 @@ func TestReadConfigFromEnv(t *testing.T) { // {Name: "prometheus.myvpn.example.com", Type: "A", Value: "100.64.0.4"}, // }, SearchDomains: []string{"test.com", "bar.com"}, - Certificates: CertificatesConfig{Zone: "example.com"}, }, }, } @@ -1273,8 +1271,8 @@ func TestConfigJSONOmitsSecrets(t *testing.T) { APIKey: secretAPIKey, }, DNSChallenge: DNSChallengeConfig{ - ProviderName: "cloudflare", - Provider: &cloudflare.Provider{APIToken: secretDNSToken}, + ProviderSettings: map[string]any{"name": "cloudflare", "api_token": secretDNSToken}, + Provider: &cloudflare.Provider{APIToken: secretDNSToken}, }, } @@ -1400,14 +1398,212 @@ func TestExtraRecordsAreLowercased(t *testing.T) { t.Errorf("dnsToTailcfgDNS extra records mismatch (-want +got):\n%s", diff) } - cfg := &Config{TailcfgDNSConfig: &tailcfg.DNSConfig{}} + cfg := &Config{} + cfg.StartDNS(nil) cfg.SetExtraRecords(mixed) - if diff := cmp.Diff(want, cfg.TailcfgDNSConfig.ExtraRecords); diff != "" { + if diff := cmp.Diff(want, cfg.CloneTailcfgDNSConfig().ExtraRecords); diff != "" { t.Errorf("SetExtraRecords mismatch (-want +got):\n%s", diff) } } +func TestTailcfgDNSConfig(t *testing.T) { + cgnat := netip.MustParsePrefix("100.64.0.0/10") + ten := netip.MustParsePrefix("10.0.0.0/8") + ula := netip.MustParsePrefix("fd7a:115c:a1e0::/48") + fd00 := netip.MustParsePrefix("fd00::/48") + + tests := []struct { + name string + cfg Config + want *tailcfg.DNSConfig + }{ + { + name: "empty", + want: &tailcfg.DNSConfig{Routes: map[string][]*dnstype.Resolver{}}, + }, + { + name: "magic dns with base domain", + cfg: Config{DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com", SearchDomains: []string{"corp.com"}}}, + want: &tailcfg.DNSConfig{ + Proxied: true, + Domains: []string{"example.com", "corp.com"}, + Routes: map[string][]*dnstype.Resolver{}, + }, + }, + { + name: "override local dns", + cfg: Config{DNSConfig: DNSConfig{OverrideLocalDNS: true, Nameservers: Nameservers{Global: []string{"1.1.1.1"}}}}, + want: &tailcfg.DNSConfig{ + Resolvers: []*dnstype.Resolver{{Addr: "1.1.1.1"}}, + Routes: map[string][]*dnstype.Resolver{}, + }, + }, + { + name: "fallback resolvers", + cfg: Config{DNSConfig: DNSConfig{Nameservers: Nameservers{Global: []string{"1.1.1.1"}}}}, + want: &tailcfg.DNSConfig{ + FallbackResolvers: []*dnstype.Resolver{{Addr: "1.1.1.1"}}, + Routes: map[string][]*dnstype.Resolver{}, + }, + }, + { + name: "split dns", + cfg: Config{DNSConfig: DNSConfig{Nameservers: Nameservers{Split: map[string][]string{"corp.com": {"10.0.0.1"}}}}}, + want: &tailcfg.DNSConfig{ + Routes: map[string][]*dnstype.Resolver{"corp.com": {{Addr: "10.0.0.1"}}}, + }, + }, + { + name: "magic dns reverse routes outside cgnat", + cfg: Config{ + PrefixV4: &ten, + DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"}, + }, + want: &tailcfg.DNSConfig{ + Proxied: true, + Domains: []string{"example.com"}, + Routes: map[string][]*dnstype.Resolver{"10.in-addr.arpa": {}}, + }, + }, + { + name: "magic dns reverse routes outside ula", + cfg: Config{ + PrefixV6: &fd00, + DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"}, + }, + want: &tailcfg.DNSConfig{ + Proxied: true, + Domains: []string{"example.com"}, + Routes: map[string][]*dnstype.Resolver{"0.0.0.0.0.0.0.0.0.0.d.f.ip6.arpa": {}}, + }, + }, + { + name: "magic dns inside cgnat and ula", + cfg: Config{ + PrefixV4: &cgnat, + PrefixV6: &ula, + DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"}, + }, + want: &tailcfg.DNSConfig{ + Proxied: true, + Domains: []string{"example.com"}, + Routes: map[string][]*dnstype.Resolver{}, + }, + }, + { + name: "no reverse routes without magic dns", + cfg: Config{PrefixV4: &ten}, + want: &tailcfg.DNSConfig{Routes: map[string][]*dnstype.Resolver{}}, + }, + { + name: "extra record names lowercased", + cfg: Config{DNSConfig: DNSConfig{ExtraRecords: []tailcfg.DNSRecord{ + {Name: "Grafana.Example.com", Type: "A", Value: "100.64.0.3"}, + }}}, + want: &tailcfg.DNSConfig{ + Routes: map[string][]*dnstype.Resolver{}, + ExtraRecords: []tailcfg.DNSRecord{{Name: "grafana.example.com", Type: "A", Value: "100.64.0.3"}}, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // No EquateEmpty: a reverse route must be an empty, non-nil slice. + if diff := cmp.Diff(tt.want, tt.cfg.TailcfgDNSConfig()); diff != "" { + t.Errorf("TailcfgDNSConfig() mismatch (-want +got):\n%s", diff) + } + }) + } +} + +func TestLiveDNS(t *testing.T) { + goOnly := &cloudflare.Provider{APIToken: "go-only"} + cfg := &Config{ + DNSConfig: DNSConfig{ + MagicDNS: true, + BaseDomain: "example.com", + ExtraRecords: []tailcfg.DNSRecord{{Name: "Old.example.com", Type: "A", Value: "100.64.0.1"}}, + }, + DNSChallenge: DNSChallengeConfig{Provider: goOnly}, + } + + assert.Equal(t, cfg.TailcfgDNSConfig(), cfg.CloneTailcfgDNSConfig()) + assert.Same(t, goOnly, cfg.DNSProvider()) + assert.True(t, cfg.HasExtraRecord("old.example.com.")) + + // Nothing holds the records before StartDNS. + cfg.SetExtraRecords([]tailcfg.DNSRecord{{Name: "early.example.com", Type: "A", Value: "100.64.0.9"}}) + assert.False(t, cfg.HasExtraRecord("early.example.com")) + assert.Equal(t, cfg.DNSConfig.ExtraRecords[0].Value, cfg.CloneTailcfgDNSConfig().ExtraRecords[0].Value) + + started := &cloudflare.Provider{APIToken: "started"} + cfg.StartDNS(started) + cfg.SetExtraRecords([]tailcfg.DNSRecord{{Name: "A.Example.com", Type: "A", Value: "100.64.0.2"}}) + + clone := cfg.CloneTailcfgDNSConfig() + assert.Equal(t, []tailcfg.DNSRecord{{Name: "a.example.com", Type: "A", Value: "100.64.0.2"}}, clone.ExtraRecords) + assert.True(t, cfg.HasExtraRecord("A.Example.com.")) + assert.False(t, cfg.HasExtraRecord("old.example.com")) + assert.Same(t, started, cfg.DNSProvider()) + + clone.ExtraRecords = nil + + assert.Len(t, cfg.CloneTailcfgDNSConfig().ExtraRecords, 1, "a clone is a copy") +} + +// TestNameserverWarnings pins that the config check reports a nameserver +// clients will not get, and that building the DNS config does not report it +// again. +func TestNameserverWarnings(t *testing.T) { + yaml := `--- +server_url: https://headscale.example.com +noise: + private_key_path: noise_private.key +prefixes: + v4: 100.64.0.0/10 +database: + type: sqlite +dns: + magic_dns: true + base_domain: ts.example.com + override_local_dns: true + nameservers: + global: ["1.1.1.1", "1.1.1.1:53"] + split: + corp.example.com: ["[2606:4700::1111]:53"] +` + dir := t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yaml"), []byte(yaml), 0o600)) + require.NoError(t, LoadConfig(dir, false)) + + var buf bytes.Buffer + + oldLogger, oldLevel := log.Logger, zerolog.GlobalLevel() + log.Logger = zerolog.New(&buf) + + t.Cleanup(func() { + log.Logger = oldLogger + + zerolog.SetGlobalLevel(oldLevel) + }) + + cfg, err := CheckServerConfig() + require.NoError(t, err) + + logged := buf.String() + assert.Contains(t, logged, `invalid nameserver \"1.1.1.1:53\" in dns.nameservers.global, ignoring`) + assert.Contains(t, logged, `invalid nameserver \"[2606:4700::1111]:53\" in dns.nameservers.split.corp.example.com, ignoring`) + assert.NotContains(t, logged, `\"1.1.1.1\" in`) + + buf.Reset() + cfg.StartDNS(nil) + + assert.Equal(t, []*dnstype.Resolver{{Addr: "1.1.1.1"}}, cfg.CloneTailcfgDNSConfig().Resolvers) + assert.Empty(t, buf.String(), "built once, reported once: by the load") +} + func TestDNSChallengeConfig(t *testing.T) { secret := filepath.Join(t.TempDir(), "token") require.NoError(t, os.WriteFile(secret, []byte("file-token\n"), 0o600)) @@ -1443,7 +1639,7 @@ dns: { name: "disabled by default", yaml: base, - // Zone follows base_domain even when unused, so it is never empty. + // CertificateZone follows base_domain even when unused, so it is never empty. wantZone: "ts.example.com", wantNoProv: true, wantResolvers: []string{"1.1.1.1:53", "8.8.8.8:53"}, @@ -1877,25 +2073,31 @@ tls: } require.NoError(t, err) - assert.Equal(t, tt.wantZone, cfg.DNSConfig.Certificates.Zone) + assert.Equal(t, tt.wantZone, cfg.DNSConfig.CertificateZone()) if tt.wantResolvers != nil { - assert.Equal(t, tt.wantResolvers, cfg.DNSChallenge.Resolvers) + assert.Equal(t, tt.wantResolvers, cfg.DNSChallenge.ResolverAddrs()) } + // The loader only validates the provider; startup builds it. + assert.Nil(t, cfg.DNSChallenge.Provider) + if tt.wantNoProv { - assert.Nil(t, cfg.DNSChallenge.Provider) + assert.Empty(t, cfg.DNSChallenge.ProviderName()) return } + built, err := cfg.DNSChallenge.NewProvider(ResolveSecret) + require.NoError(t, err) + if tt.wantProvider != "" { - assert.Equal(t, tt.wantProvider, fmt.Sprintf("%T", cfg.DNSChallenge.Provider)) + assert.Equal(t, tt.wantProvider, fmt.Sprintf("%T", built)) return } - if iso, ok := cfg.DNSChallenge.Provider.(hsdns.Isolator); ok { + if iso, ok := built.(hsdns.Isolator); ok { if tt.wantIsolates != "" { assert.True(t, iso.Isolates(tt.wantIsolates)) } @@ -1903,8 +2105,8 @@ tls: return } - provider, ok := cfg.DNSChallenge.Provider.(*cloudflare.Provider) - require.True(t, ok, "provider is %T", cfg.DNSChallenge.Provider) + provider, ok := built.(*cloudflare.Provider) + require.True(t, ok, "provider is %T", built) assert.Equal(t, tt.wantToken, provider.APIToken) }) } @@ -2455,6 +2657,328 @@ func TestConfigCompat(t *testing.T) { } } +// compatConfig is the JSON shape of Config the goldens were written in, +// frozen so Config can change without a golden diff; compatView renders +// into it. +type compatConfig struct { + ServerURL string + Addr string + MetricsAddr string + TrustedProxies []netip.Prefix + Node compatNodeConfig + PreAuthKeys compatPreAuthKeysConfig + PrefixV4 *netip.Prefix + PrefixV6 *netip.Prefix + IPAllocation string + NoisePrivateKeyPath string + BaseDomain string + Log compatLogConfig + DisableUpdateCheck bool + Database compatDatabaseConfig + DERP compatDERPConfig + TLS compatTLSConfig + DNSConfig compatDNSConfig + TailcfgDNSConfig *tailcfg.DNSConfig + DNSChallenge compatDNSChallengeConfig + UnixSocket string + UnixSocketPermission fs.FileMode + OIDC compatOIDCConfig + LogTail compatLogTailConfig + Taildrop compatTaildropConfig + AutoUpdate compatAutoUpdateConfig + CLI compatCLIConfig + Policy compatPolicyConfig + Tuning compatTuning +} + +type compatNodeConfig struct { + Expiry time.Duration + Ephemeral compatEphemeralConfig + Routes compatRouteConfig +} + +type compatEphemeralConfig struct{ InactivityTimeout time.Duration } + +type compatRouteConfig struct{ HA compatHARouteConfig } + +type compatHARouteConfig struct{ ProbeInterval, ProbeTimeout time.Duration } + +type compatPreAuthKeysConfig struct{ RevokedRetention time.Duration } + +type compatLogConfig struct { + Format string + Level zerolog.Level +} + +type compatDatabaseConfig struct { + Type string + Debug bool + Gorm compatGormConfig + Sqlite compatSqliteConfig + Postgres compatPostgresConfig +} + +type compatGormConfig struct { + Debug bool + SlowThreshold time.Duration + SkipErrRecordNotFound bool + ParameterizedQueries bool +} + +type compatSqliteConfig struct { + Path string + WriteAheadLog bool + WALAutoCheckPoint int +} + +type compatPostgresConfig struct { + Host string + Port int + Name string + User string + Ssl string + MaxOpenConnections int + MaxIdleConnections int + ConnMaxIdleTimeSecs int +} + +type compatDERPConfig struct { + ServerEnabled bool + AutomaticallyAddEmbeddedDerpRegion bool + ServerRegionID tailcfg.DERPRegionID + ServerRegionCode string + ServerRegionName string + ServerPrivateKeyPath string + ServerVerifyClients bool + STUNAddr string + URLs []url.URL + Paths []string + DERPMap *tailcfg.DERPMap + AutoUpdate bool + UpdateFrequency time.Duration + IPv4 string + IPv6 string +} + +type compatTLSConfig struct { + CertPath string + KeyPath string + ACME compatACMEConfig +} + +type compatACMEConfig struct { + Hostname string + ChallengeType string + HTTPListen string + URL string + Email string + CacheDir string +} + +type compatDNSConfig struct { + MagicDNS bool + BaseDomain string + OverrideLocalDNS bool + Nameservers compatNameservers + SearchDomains []string + ExtraRecords []tailcfg.DNSRecord + ExtraRecordsPath string + Certificates compatCertificatesConfig +} + +type compatNameservers struct { + Global []string + Split map[string][]string +} + +type compatCertificatesConfig struct { + Enabled bool + Zone string +} + +type compatDNSChallengeConfig struct { + PropagationTimeout time.Duration + Resolvers []string + ProviderName string +} + +type compatOIDCConfig struct { + OnlyStartIfOIDCIsAvailable bool + Issuer string + ClientID string + Scope []string + ExtraParams map[string]string + AllowedDomains []string + AllowedUsers []string + AllowedGroups []string + EmailVerifiedRequired bool + UseExpiryFromToken bool + PKCE compatPKCEConfig +} + +type compatPKCEConfig struct { + Enabled bool + Method string +} + +type compatLogTailConfig struct{ Enabled bool } + +type compatTaildropConfig struct{ Enabled bool } + +type compatAutoUpdateConfig struct{ Enabled bool } + +type compatCLIConfig struct { + Address string + Timeout time.Duration + Insecure bool +} + +type compatPolicyConfig struct { + Path string + Mode string +} + +type compatTuning struct { + NotifierSendTimeout time.Duration + BatchChangeDelay time.Duration + NodeMapSessionBufferedChanSize int + BatcherWorkers int + RegisterCacheExpiration time.Duration + RegisterCacheMaxEntries int + NodeStoreBatchSize int + NodeStoreBatchTimeout time.Duration +} + +// compatView renders cfg in the golden shape, deriving the values the +// loader used to store resolved. +func compatView(cfg *Config) compatConfig { + pg := cfg.Database.Postgres + oidc := cfg.OIDC + ch := cfg.DNSChallenge + acme := cfg.TLS.ACME + + dbType := cfg.Database.Type + if cfg.Database.IsSQLite() { + dbType = DatabaseSqlite + } + + tuning := compatTuning(cfg.Tuning) + tuning.BatcherWorkers = cfg.Tuning.BatcherWorkerCount() + + return compatConfig{ + ServerURL: cfg.ServerURL, + Addr: cfg.Addr, + MetricsAddr: cfg.MetricsAddr, + TrustedProxies: cfg.TrustedProxies, + Node: compatNodeConfig{ + Expiry: cfg.Node.Expiry, + Ephemeral: compatEphemeralConfig(cfg.Node.Ephemeral), + Routes: compatRouteConfig{HA: compatHARouteConfig(cfg.Node.Routes.HA)}, + }, + PreAuthKeys: compatPreAuthKeysConfig(cfg.PreAuthKeys), + PrefixV4: cfg.PrefixV4, + PrefixV6: cfg.PrefixV6, + IPAllocation: string(cfg.IPAllocation), + NoisePrivateKeyPath: cfg.AbsPath(cfg.NoisePrivateKeyPath), + BaseDomain: cfg.BaseDomain, + Log: compatLogConfig(cfg.Log), + DisableUpdateCheck: cfg.DisableUpdateCheck, + Database: compatDatabaseConfig{ + Type: dbType, + Debug: cfg.Database.Debug, + Gorm: compatGormConfig(cfg.Database.Gorm), + Sqlite: compatSqliteConfig{ + Path: cfg.SQLitePath(), + WriteAheadLog: cfg.Database.Sqlite.WriteAheadLog, + WALAutoCheckPoint: cfg.Database.Sqlite.WALAutoCheckPoint, + }, + Postgres: compatPostgresConfig{ + Host: pg.Host, + Port: pg.Port, + Name: pg.Name, + User: pg.User, + Ssl: pg.Ssl, + MaxOpenConnections: pg.MaxOpenConnections, + MaxIdleConnections: pg.MaxIdleConnections, + ConnMaxIdleTimeSecs: pg.ConnMaxIdleTimeSecs, + }, + }, + DERP: compatDERPConfig{ + ServerEnabled: cfg.DERP.ServerEnabled, + AutomaticallyAddEmbeddedDerpRegion: cfg.DERP.AutomaticallyAddEmbeddedDerpRegion, + ServerRegionID: cfg.DERP.ServerRegionID, + ServerRegionCode: cfg.DERP.ServerRegionCode, + ServerRegionName: cfg.DERP.ServerRegionName, + ServerPrivateKeyPath: cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath), + ServerVerifyClients: cfg.DERP.ServerVerifyClients, + STUNAddr: cfg.DERP.STUNAddr, + URLs: cfg.DERP.URLs, + Paths: cfg.DERP.Paths, + DERPMap: cfg.DERP.DERPMap, + AutoUpdate: cfg.DERP.AutoUpdate, + UpdateFrequency: cfg.DERP.UpdateFrequency, + IPv4: cfg.DERP.IPv4, + IPv6: cfg.DERP.IPv6, + }, + TLS: compatTLSConfig{ + CertPath: cfg.AbsPath(cfg.TLS.CertPath), + KeyPath: cfg.AbsPath(cfg.TLS.KeyPath), + ACME: compatACMEConfig{ + Hostname: acme.Hostname, + ChallengeType: acme.ChallengeType, + HTTPListen: acme.HTTPListen, + URL: acme.URL, + Email: acme.Email, + CacheDir: cfg.AbsPath(acme.CacheDir), + }, + }, + DNSConfig: compatDNSConfig{ + MagicDNS: cfg.DNSConfig.MagicDNS, + BaseDomain: cfg.DNSConfig.BaseDomain, + OverrideLocalDNS: cfg.DNSConfig.OverrideLocalDNS, + Nameservers: compatNameservers(cfg.DNSConfig.Nameservers), + SearchDomains: cfg.DNSConfig.SearchDomains, + ExtraRecords: cfg.DNSConfig.ExtraRecords, + ExtraRecordsPath: cfg.DNSConfig.ExtraRecordsPath, + Certificates: compatCertificatesConfig{ + Enabled: cfg.DNSConfig.Certificates.Enabled, + Zone: cfg.DNSConfig.CertificateZone(), + }, + }, + TailcfgDNSConfig: cfg.TailcfgDNSConfig(), + DNSChallenge: compatDNSChallengeConfig{ + PropagationTimeout: ch.PropagationTimeout, + Resolvers: ch.ResolverAddrs(), + ProviderName: ch.ProviderName(), + }, + UnixSocket: cfg.UnixSocket, + UnixSocketPermission: cfg.UnixSocketPermission, + OIDC: compatOIDCConfig{ + OnlyStartIfOIDCIsAvailable: oidc.OnlyStartIfOIDCIsAvailable, + Issuer: oidc.Issuer, + ClientID: oidc.ClientID, + Scope: oidc.Scope, + ExtraParams: oidc.ExtraParams, + AllowedDomains: oidc.AllowedDomains, + AllowedUsers: oidc.AllowedUsers, + AllowedGroups: oidc.AllowedGroups, + EmailVerifiedRequired: oidc.EmailVerifiedRequired, + UseExpiryFromToken: oidc.UseExpiryFromToken, + PKCE: compatPKCEConfig(oidc.PKCE), + }, + LogTail: compatLogTailConfig(cfg.LogTail), + Taildrop: compatTaildropConfig(cfg.Taildrop), + AutoUpdate: compatAutoUpdateConfig(cfg.AutoUpdate), + CLI: compatCLIConfig{ + Address: cfg.CLI.Address, + Timeout: cfg.CLI.Timeout, + Insecure: cfg.CLI.Insecure, + }, + Policy: compatPolicyConfig{Path: cfg.Policy.Path, Mode: string(cfg.Policy.Mode)}, + Tuning: tuning, + } +} + // loadCompat loads one fixture set the way headscale does, from a temp dir // so relative paths and the error text do not depend on the checkout. func loadCompat(t *testing.T, file, envFile string, cli bool) compatRecord { @@ -2513,11 +3037,23 @@ func loadCompat(t *testing.T, file, envFile string, cli bool) compatRecord { } if cfg != nil { - if cfg.Tuning.BatcherWorkers == DefaultBatcherWorkers() { - cfg.Tuning.BatcherWorkers = 0 // depends on runtime.NumCPU + view := compatView(cfg) + if cli { + // The CLI loader sets only what client commands read; compatView + // would derive server values from the zero rest. + view = compatConfig{ + Log: view.Log, + DisableUpdateCheck: view.DisableUpdateCheck, + UnixSocket: view.UnixSocket, + CLI: view.CLI, + } } - raw, err := json.Marshal(cfg) + if view.Tuning.BatcherWorkers == DefaultBatcherWorkers() { + view.Tuning.BatcherWorkers = 0 // depends on runtime.NumCPU + } + + raw, err := json.Marshal(view) require.NoError(t, err) rec.Config = json.RawMessage(norm(string(raw))) @@ -2708,9 +3244,10 @@ dns: cfg, err := LoadServerConfig() require.NoError(t, err) - assert.Equal(t, filepath.Join(dir, "noise.key"), cfg.NoisePrivateKeyPath) + assert.Equal(t, "./noise.key", cfg.NoisePrivateKeyPath) + assert.Equal(t, filepath.Join(dir, "noise.key"), cfg.AbsPath(cfg.NoisePrivateKeyPath)) assert.Equal(t, "./policy.hujson", cfg.Policy.Path) - assert.Equal(t, filepath.Join(dir, "policy.hujson"), util.AbsolutePath(cfg.ConfigDir, cfg.Policy.Path)) + assert.Equal(t, filepath.Join(dir, "policy.hujson"), cfg.AbsPath(cfg.Policy.Path)) } // TestSQLiteMemoryPath: ":memory:" names SQLite's in-memory database, not a @@ -2739,8 +3276,52 @@ func TestSQLiteMemoryPath(t *testing.T) { cfg, err := LoadServerConfig() require.NoError(t, err) - assert.Equal(t, ":memory:", cfg.Database.Sqlite.Path) - assert.True(t, filepath.IsAbs(cfg.NoisePrivateKeyPath), cfg.NoisePrivateKeyPath) + assert.Equal(t, ":memory:", cfg.SQLitePath()) + assert.True(t, filepath.IsAbs(cfg.AbsPath(cfg.NoisePrivateKeyPath)), cfg.AbsPath(cfg.NoisePrivateKeyPath)) }) } } + +// TestDerivedValues pins the values computed from what the configuration +// says, which the loader stores as written. +func TestDerivedValues(t *testing.T) { + etc := &Config{ConfigDir: "/etc/hs"} + sqlite := func(path string) *Config { + return &Config{ConfigDir: "/etc/hs", Database: DatabaseConfig{Sqlite: SqliteConfig{Path: path}}} + } + resolvers := func(r ...string) DNSChallengeConfig { return DNSChallengeConfig{Resolvers: r} } + + tests := []struct { + name string + got, want any + }{ + {"relative path", etc.AbsPath("./noise.key"), "/etc/hs/noise.key"}, + {"absolute path", etc.AbsPath("/var/lib/hs/noise.key"), "/var/lib/hs/noise.key"}, + {"no config dir", (&Config{}).AbsPath("./noise.key"), "./noise.key"}, + {"empty path", etc.AbsPath(""), ""}, + {"sqlite relative", sqlite("db.sqlite").SQLitePath(), "/etc/hs/db.sqlite"}, + {"sqlite memory", sqlite(":memory:").SQLitePath(), ":memory:"}, + {"sqlite", DatabaseConfig{Type: "sqlite"}.IsSQLite(), true}, + {"sqlite3", DatabaseConfig{Type: "sqlite3"}.IsSQLite(), true}, + {"postgres", DatabaseConfig{Type: "postgres"}.IsSQLite(), false}, + {"workers unset", Tuning{}.BatcherWorkerCount(), DefaultBatcherWorkers()}, + {"workers set", Tuning{BatcherWorkers: 7}.BatcherWorkerCount(), 7}, + {"zone unset", DNSConfig{BaseDomain: "ts.example.com"}.CertificateZone(), "ts.example.com"}, + {"zone set", DNSConfig{BaseDomain: "ts.example.com", Certificates: CertificatesConfig{Zone: "example.com"}}.CertificateZone(), "example.com"}, + {"resolvers unset", resolvers().ResolverAddrs(), []string{"1.1.1.1:53", "8.8.8.8:53"}}, + {"resolver bare IPv4", resolvers("9.9.9.9").ResolverAddrs(), []string{"9.9.9.9:53"}}, + {"resolver bare IPv6", resolvers("2620:fe::fe").ResolverAddrs(), []string{"[2620:fe::fe]:53"}}, + {"resolver with port", resolvers("[::1]:5353").ResolverAddrs(), []string{"[::1]:5353"}}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.want, tt.got) + }) + } + + // Callers share the config, so deriving must not write to it. + written := []string{"9.9.9.9"} + resolvers(written...).ResolverAddrs() + assert.Equal(t, []string{"9.9.9.9"}, written) +} diff --git a/hscontrol/types/derp_config_test.go b/hscontrol/types/derp_config_test.go index fd77e0bc6..a797d309d 100644 --- a/hscontrol/types/derp_config_test.go +++ b/hscontrol/types/derp_config_test.go @@ -14,7 +14,7 @@ func TestDerpConfigSkipsMalformedURL(t *testing.T) { "://bad", }}) - cfg := derpConfig("") + cfg := derpConfig() if len(cfg.URLs) != 1 { t.Fatalf("expected the malformed derp.urls entry to be skipped, got %d urls: %v", diff --git a/hscontrol/types/node.go b/hscontrol/types/node.go index 773d6e9da..c03d1ba5c 100644 --- a/hscontrol/types/node.go +++ b/hscontrol/types/node.go @@ -944,7 +944,7 @@ func (nv NodeView) CertDomain(cfg *Config) (string, bool) { // A node may publish only its own name's challenge, which keeps it from // other names' certificates only where the provider answers each name's // challenge apart. - if iso, ok := cfg.DNSChallenge.Provider.(hsdns.Isolator); ok && !iso.Isolates(domain) { + if iso, ok := cfg.DNSProvider().(hsdns.Isolator); ok && !iso.Isolates(domain) { return "", false } diff --git a/hscontrol/types/secret.go b/hscontrol/types/secret.go index 6a410f1dd..916053428 100644 --- a/hscontrol/types/secret.go +++ b/hscontrol/types/secret.go @@ -11,11 +11,11 @@ import ( var errSecretEmpty = errors.New("file is empty") -// resolveSecret returns value, or the trimmed contents of the file named +// ResolveSecret returns value, or the trimmed contents of the file named // by "file:" (Tailscale's form), which keeps the secret out of the // config and the environment. Variables in the path are expanded so a // systemd credential can be named by ${CREDENTIALS_DIRECTORY}. -func resolveSecret(key, value string) (string, error) { +func ResolveSecret(key, value string) (string, error) { path, ok := strings.CutPrefix(value, "file:") if !ok { return value, nil diff --git a/hscontrol/types/secret_test.go b/hscontrol/types/secret_test.go index 2ada62b4e..fc78a23e2 100644 --- a/hscontrol/types/secret_test.go +++ b/hscontrol/types/secret_test.go @@ -31,7 +31,7 @@ func TestResolveSecret(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got, err := resolveSecret("oidc.client_secret", tt.value) + got, err := ResolveSecret("oidc.client_secret", tt.value) if tt.wantErr != "" { require.ErrorContains(t, err, tt.wantErr) require.ErrorContains(t, err, "oidc.client_secret: ")