CalvinBackup/ctrld
1
0
Fork 0
mirror of https://github.com/Control-D-Inc/ctrld.git synced 2026-05-15 00:50:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

feat: capitalize all log messages for better readability

Browse Source 
Capitalize the first letter of all log messages throughout the codebase
to improve readability and consistency in logging output.

Key improvements:
- All log messages now start with capital letters
- Consistent formatting across all logging statements
- Improved readability for debugging and monitoring
- Enhanced user experience with better formatted messages

Files updated:
- CLI commands and service management
- Internal client information discovery
- Network operations and configuration
- DNS resolver and proxy operations
- Platform-specific implementations

This completes the final phase of the logging improvement project,
ensuring all log messages follow consistent capitalization standards
for better readability and professional appearance.
This commit is contained in:
Cuong Manh Le
2025-09-04 15:46:37 +07:00
committed by Cuong Manh Le
parent eb8c5bc3fa
commit 54f58cc2e5
45 changed files with 391 additions and 389 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmd/cli/ad_windows.go
+4 -4
View File
@@ -16,11 +16,11 @@ import (
func addExtraSplitDnsRule(cfg *ctrld.Config) bool {
domain, err := getActiveDirectoryDomain()
if err != nil {
mainLog.Load().Debug().Msgf("unable to get active directory domain: %v", err)
mainLog.Load().Debug().Msgf("Unable to get active directory domain: %v", err)
return false
}
if domain == "" {
mainLog.Load().Debug().Msg("no active directory domain found")
mainLog.Load().Debug().Msg("No active directory domain found")
return false
}
// Network rules are lowercase during toml config marshaling,
@@ -40,11 +40,11 @@ func addSplitDnsRule(cfg *ctrld.Config, domain string) bool {
}
for _, rule := range lc.Policy.Rules {
if _, ok := rule[domain]; ok {
mainLog.Load().Debug().Msgf("split-rule %q already existed for listener.%s", domain, n)
mainLog.Load().Debug().Msgf("Split-rule %q already existed for listener.%s", domain, n)
return false
}
}
mainLog.Load().Debug().Msgf("adding split-rule %q for listener.%s", domain, n)
mainLog.Load().Debug().Msgf("Adding split-rule %q for listener.%s", domain, n)
lc.Policy.Rules = append(lc.Policy.Rules, ctrld.Rule{domain: []string{}})
}
return true
cmd/cli/cli.go
+68 -67
View File
@@ -241,11 +241,11 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
p.logConn = lc
} else {
if !errors.Is(err, os.ErrNotExist) {
p.Warn().Err(err).Msg("unable to create log ipc connection")
p.Warn().Err(err).Msg("Unable to create log ipc connection")
}
}
} else {
p.Warn().Err(err).Msgf("unable to resolve socket address: %s", sockPath)
p.Warn().Err(err).Msgf("Unable to resolve socket address: %s", sockPath)
}
notifyExitToLogServer := func() {
if p.logConn != nil {
@@ -265,10 +265,10 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
svcConfig := svcCmd.createServiceConfig()
s, err := svcCmd.newService(p, svcConfig)
if err != nil {
p.Fatal().Err(err).Msg("failed create new service")
p.Fatal().Err(err).Msg("Failed to create new service")
}
if err := s.Run(); err != nil {
p.Error().Err(err).Msg("failed to start service")
p.Error().Err(err).Msg("Failed to start service")
}
}()
}
@@ -276,7 +276,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
tryReadingConfig(writeDefaultConfig)
if err := readBase64Config(configBase64); err != nil {
p.Fatal().Err(err).Msg("failed to read base64 config")
p.Fatal().Err(err).Msg("Failed to read base64 config")
}
processNoConfigFlags(noConfigStart)
@@ -285,7 +285,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
p.mu.Lock()
if err := v.Unmarshal(&cfg); err != nil {
notifyExitToLogServer()
p.Fatal().Msgf("failed to unmarshal config: %v", err)
p.Fatal().Msgf("Failed to unmarshal config: %v", err)
}
p.mu.Unlock()
@@ -295,18 +295,18 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
// so it's able to log information in processCDFlags.
p.initLogging(true)
p.Info().Msgf("starting ctrld %s", curVersion())
p.Info().Msgf("os: %s", osVersion())
p.Info().Msgf("Starting ctrld %s", curVersion())
p.Info().Msgf("OS: %s", osVersion())
// Wait for network up.
if !ctrldnet.Up() {
notifyExitToLogServer()
p.Fatal().Msg("network is not up yet")
p.Fatal().Msg("Network is not up yet")
}
cs, err := newControlServer(filepath.Join(sockDir, ControlSocketName()))
if err != nil {
p.Warn().Err(err).Msg("could not create control server")
p.Warn().Err(err).Msg("Could not create control server")
}
p.cs = cs
@@ -329,7 +329,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
_ = uninstallInvalidCdUID(p, cdLogger, false)
}
notifyExitToLogServer()
cdLogger.Fatal().Err(err).Msg("failed to fetch resolver config")
cdLogger.Fatal().Err(err).Msg("Failed to fetch resolver config")
} else {
p.mu.Lock()
p.rc = rc
@@ -346,9 +346,9 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
if updated {
if err := writeConfigFile(&cfg); err != nil {
notifyExitToLogServer()
p.Fatal().Err(err).Msg("failed to write config file")
p.Fatal().Err(err).Msg("Failed to write config file")
} else {
p.Info().Msg("writing config file to: " + defaultConfigFile)
p.Info().Msg("Writing config file to: " + defaultConfigFile)
}
}
@@ -360,7 +360,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
// Copy logs written so far to new log file if possible.
if buf, err := os.ReadFile(oldLogPath); err == nil {
if err := os.WriteFile(newLogPath, buf, os.FileMode(0o600)); err != nil {
p.Warn().Err(err).Msg("could not copy old log file")
p.Warn().Err(err).Msg("Could not copy old log file")
}
}
initLoggingWithBackup(false)
@@ -376,13 +376,13 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
if daemon {
exe, err := os.Executable()
if err != nil {
p.Error().Err(err).Msg("failed to find the binary")
p.Error().Err(err).Msg("Failed to find the binary")
notifyExitToLogServer()
os.Exit(1)
}
curDir, err := os.Getwd()
if err != nil {
p.Error().Err(err).Msg("failed to get current working directory")
p.Error().Err(err).Msg("Failed to get current working directory")
notifyExitToLogServer()
os.Exit(1)
}
@@ -390,7 +390,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
cmd := exec.Command(exe, append(os.Args[1:], "-d=false")...)
cmd.Dir = curDir
if err := cmd.Start(); err != nil {
p.Error().Err(err).Msg("failed to start process as daemon")
p.Error().Err(err).Msg("Failed to start process as daemon")
notifyExitToLogServer()
os.Exit(1)
}
@@ -402,7 +402,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
for _, lc := range p.cfg.Listener {
if shouldAllocateLoopbackIP(lc.IP) {
if err := allocateIP(lc.IP); err != nil {
p.Error().Err(err).Msgf("could not allocate IP: %s", lc.IP)
p.Error().Err(err).Msgf("Could not allocate ip: %s", lc.IP)
}
}
}
@@ -413,7 +413,7 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
for _, lc := range p.cfg.Listener {
if shouldAllocateLoopbackIP(lc.IP) {
if err := deAllocateIP(lc.IP); err != nil {
p.Error().Err(err).Msgf("could not de-allocate IP: %s", lc.IP)
p.Error().Err(err).Msgf("Could not de-allocate ip: %s", lc.IP)
}
}
}
@@ -426,9 +426,9 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
file := ctrld.SavedStaticDnsSettingsFilePath(i)
if _, err := os.Stat(file); err == nil {
if err := restoreDNS(i); err != nil {
p.Error().Err(err).Msgf("Could not restore static DNS on interface %s", i.Name)
p.Error().Err(err).Msgf("Could not restore static dns on interface %s", i.Name)
} else {
p.Debug().Msgf("Restored static DNS on interface %s successfully", i.Name)
p.Debug().Msgf("Restored static dns on interface %s successfully", i.Name)
}
}
return nil
@@ -488,7 +488,7 @@ func readConfigFile(writeDefaultConfig, notice bool) bool {
if notice {
mainLog.Load().Notice().Msg("Reading config: " + v.ConfigFileUsed())
}
mainLog.Load().Info().Msg("loading config file from: " + v.ConfigFileUsed())
mainLog.Load().Info().Msg("Loading config file from: " + v.ConfigFileUsed())
defaultConfigFile = v.ConfigFileUsed()
return true
}
@@ -500,21 +500,21 @@ func readConfigFile(writeDefaultConfig, notice bool) bool {
// If error is viper.ConfigFileNotFoundError, write default config.
if errors.As(err, &viper.ConfigFileNotFoundError{}) {
if err := v.Unmarshal(&cfg); err != nil {
mainLog.Load().Fatal().Msgf("failed to unmarshal default config: %v", err)
mainLog.Load().Fatal().Msgf("Failed to unmarshal default config: %v", err)
}
_, _ = tryUpdateListenerConfig(&cfg, func() {}, true)
addExtraSplitDnsRule(&cfg)
if err := writeConfigFile(&cfg); err != nil {
mainLog.Load().Fatal().Msgf("failed to write default config file: %v", err)
mainLog.Load().Fatal().Msgf("Failed to write default config file: %v", err)
} else {
fp, err := filepath.Abs(defaultConfigFile)
if err != nil {
mainLog.Load().Fatal().Msgf("failed to get default config file path: %v", err)
mainLog.Load().Fatal().Msgf("Failed to get default config file path: %v", err)
}
if cdUID == "" && nextdns == "" {
mainLog.Load().Notice().Msg("Generating controld default config: " + fp)
}
mainLog.Load().Info().Msg("writing default config file to: " + fp)
mainLog.Load().Info().Msg("Writing default config file to: " + fp)
}
return false
}
@@ -523,12 +523,12 @@ func readConfigFile(writeDefaultConfig, notice bool) bool {
if errors.As(err, &viper.ConfigParseError{}) {
if de := decoderErrorFromTomlFile(v.ConfigFileUsed()); de != nil {
row, col := de.Position()
mainLog.Load().Fatal().Msgf("failed to decode config file at line: %d, column: %d, error: %v", row, col, err)
mainLog.Load().Fatal().Msgf("Failed to decode config file at line: %d, column: %d, error: %v", row, col, err)
}
}
// Otherwise, report fatal error and exit.
mainLog.Load().Fatal().Msgf("failed to decode config file: %v", err)
mainLog.Load().Fatal().Msgf("Failed to decode config file: %v", err)
return false
}
@@ -653,7 +653,7 @@ func deactivationPinSet() bool {
// processCDFlags processes Control D related flags
func processCDFlags(cfg *ctrld.Config) (*controld.ResolverConfig, error) {
logger := mainLog.Load().With().Str("mode", "cd")
logger.Info().Msgf("fetching Controld D configuration from API: %s", cdUID)
logger.Info().Msgf("Fetching Controld D configuration from API: %s", cdUID)
bo := backoff.NewBackoff("processCDFlags", logf, 30*time.Second)
bo.LogLongerThan = 30 * time.Second
ctx := ctrld.LoggerCtx(context.Background(), logger)
@@ -665,7 +665,7 @@ func processCDFlags(cfg *ctrld.Config) (*controld.ResolverConfig, error) {
for {
if errUrlNetworkError(err) {
bo.BackOff(ctx, err)
logger.Warn().Msg("could not fetch resolver using bootstrap DNS, retrying...")
logger.Warn().Msg("Could not fetch resolver using bootstrap DNS, retrying...")
resolverConfig, err = controld.FetchResolverConfig(ctx, cdUID, appVersion, cdDev)
continue
}
@@ -675,23 +675,23 @@ func processCDFlags(cfg *ctrld.Config) (*controld.ResolverConfig, error) {
if isMobile() {
return nil, err
}
logger.Warn().Err(err).Msg("could not fetch resolver config")
logger.Warn().Err(err).Msg("Could not fetch resolver config")
return nil, err
}
if resolverConfig.DeactivationPin != nil {
logger.Debug().Msg("saving deactivation pin")
logger.Debug().Msg("Saving deactivation pin")
cdDeactivationPin.Store(*resolverConfig.DeactivationPin)
}
logger.Info().Msg("generating ctrld config from Control-D configuration")
logger.Info().Msg("Generating ctrld config from Control-D configuration")
// Reset config to ensure clean state before applying Control-D settings
// This prevents mixing of old configuration with new Control-D settings
*cfg = ctrld.Config{}
// Fetch config, unmarshal to cfg.
if resolverConfig.Ctrld.CustomConfig != "" {
logger.Info().Msg("using defined custom config of Control-D resolver")
logger.Info().Msg("Using defined custom config of Control-D resolver")
var cfgErr error
if cfgErr = validateCdRemoteConfig(resolverConfig, cfg); cfgErr == nil {
setListenerDefaultValue(cfg)
@@ -700,13 +700,13 @@ func processCDFlags(cfg *ctrld.Config) (*controld.ResolverConfig, error) {
return resolverConfig, nil
}
}
mainLog.Load().Warn().Err(err).Msg("disregarding invalid custom config")
mainLog.Load().Warn().Err(err).Msg("Disregarding invalid custom config")
}
bootstrapIP := func(endpoint string) string {
u, err := url.Parse(endpoint)
if err != nil {
logger.Warn().Err(err).Msgf("no bootstrap IP for invalid endpoint: %s", endpoint)
logger.Warn().Err(err).Msgf("No bootstrap ip for invalid endpoint: %s", endpoint)
return ""
}
switch {
@@ -796,11 +796,11 @@ func processListenFlag() {
host, portStr, err := net.SplitHostPort(listenAddress)
if err != nil {
mainLog.Load().Fatal().Msgf("invalid listener address: %v", err)
mainLog.Load().Fatal().Msgf("Invalid listener address: %v", err)
}
port, err := strconv.Atoi(portStr)
if err != nil {
mainLog.Load().Fatal().Msgf("invalid port number: %v", err)
mainLog.Load().Fatal().Msgf("Invalid port number: %v", err)
}
lc := &ctrld.ListenerConfig{
IP: host,
@@ -870,7 +870,7 @@ func defaultIfaceName() string {
if runtime.GOOS == "linux" {
return "lo"
}
mainLog.Load().Debug().Err(err).Msg("no default route interface found")
mainLog.Load().Debug().Err(err).Msg("No default route interface found")
return ""
}
return dri
@@ -889,7 +889,7 @@ func defaultIfaceName() string {
func selfCheckStatus(ctx context.Context, s service.Service, sockDir string) (bool, service.Status, error) {
status, err := s.Status()
if err != nil {
mainLog.Load().Warn().Err(err).Msg("could not get service status")
mainLog.Load().Warn().Err(err).Msg("Could not get service status")
return false, service.StatusUnknown, err
}
// If ctrld is not running, do nothing, just return the status as-is.
@@ -901,7 +901,7 @@ func selfCheckStatus(ctx context.Context, s service.Service, sockDir string) (bo
return true, status, nil
}
mainLog.Load().Debug().Msg("waiting for ctrld listener to be ready")
mainLog.Load().Debug().Msg("Waiting for ctrld listener to be ready")
cc := newSocketControlClient(ctx, s, sockDir)
if cc == nil {
return false, status, errors.New("could not connect to control server")
@@ -914,13 +914,13 @@ func selfCheckStatus(ctx context.Context, s service.Service, sockDir string) (bo
v.SetConfigFile(defaultConfigFile)
}
if err := v.ReadInConfig(); err != nil {
mainLog.Load().Error().Err(err).Msgf("failed to re-read configuration file: %s", v.ConfigFileUsed())
mainLog.Load().Error().Err(err).Msgf("Failed to re-read configuration file: %s", v.ConfigFileUsed())
return false, status, err
}
cfg = ctrld.Config{}
if err := v.Unmarshal(&cfg); err != nil {
mainLog.Load().Error().Err(err).Msg("failed to update new config")
mainLog.Load().Error().Err(err).Msg("Failed to update new config")
return false, status, err
}
@@ -930,12 +930,12 @@ func selfCheckStatus(ctx context.Context, s service.Service, sockDir string) (bo
return true, status, nil
}
mainLog.Load().Debug().Msg("ctrld listener is ready")
mainLog.Load().Debug().Msg("Ctrld listener is ready")
lc := cfg.FirstListener()
addr := net.JoinHostPort(lc.IP, strconv.Itoa(lc.Port))
mainLog.Load().Debug().Msgf("performing listener test, sending queries to %s", addr)
mainLog.Load().Debug().Msgf("Performing listener test, sending queries to %s", addr)
if err := selfCheckResolveDomain(context.TODO(), addr, "internal", selfCheckInternalTestDomain); err != nil {
return false, status, err
@@ -985,20 +985,21 @@ func selfCheckResolveDomain(ctx context.Context, addr, scope string, domain stri
lastErr = exErr
bo.BackOff(ctx, fmt.Errorf("ExchangeContext: %w", exErr))
}
mainLog.Load().Debug().Msgf("self-check against %q failed", domain)
mainLog.Load().Debug().Msgf("Self-check against %q failed", domain)
loggerCtx := ctrld.LoggerCtx(ctx, mainLog.Load())
// Ping all upstreams to provide better error message to users.
for name, uc := range cfg.Upstream {
if err := uc.ErrorPing(loggerCtx); err != nil {
mainLog.Load().Err(err).Msgf("failed to connect to upstream.%s, endpoint: %s", name, uc.Endpoint)
mainLog.Load().Err(err).Msgf("Failed to connect to upstream.%s, endpoint: %s", name, uc.Endpoint)
}
}
marker := strings.Repeat("=", 32)
mainLog.Load().Debug().Msg(marker)
mainLog.Load().Debug().Msgf("listener address : %s", addr)
mainLog.Load().Debug().Msgf("last error : %v", lastErr)
mainLog.Load().Debug().Msgf("Listener address : %s", addr)
mainLog.Load().Debug().Msgf("Last error : %v", lastErr)
if lastAnswer != nil {
mainLog.Load().Debug().Msgf("last answer from ctrld :")
mainLog.Load().Debug().Msgf("Last answer from ctrld :")
mainLog.Load().Debug().Msg(marker)
for _, s := range strings.Split(lastAnswer.String(), "\n") {
mainLog.Load().Debug().Msgf("%s", s)
@@ -1069,7 +1070,7 @@ func readConfigWithNotice(writeDefaultConfig, notice bool) {
dir, err := userHomeDir()
if err != nil {
mainLog.Load().Fatal().Msgf("failed to get user home dir: %v", err)
mainLog.Load().Fatal().Msgf("Failed to get user home dir: %v", err)
}
for _, config := range configs {
ctrld.SetConfigNameWithPath(v, config.name, dir)
@@ -1099,12 +1100,12 @@ func uninstall(p *prog, s service.Service) {
file := ctrld.SavedStaticDnsSettingsFilePath(i)
if _, err := os.Stat(file); err == nil {
if err := restoreDNS(i); err != nil {
mainLog.Load().Error().Err(err).Msgf("Could not restore static DNS on interface %s", i.Name)
mainLog.Load().Error().Err(err).Msgf("Could not restore static dns on interface %s", i.Name)
} else {
mainLog.Load().Debug().Msgf("Restored static DNS on interface %s successfully", i.Name)
mainLog.Load().Debug().Msgf("Restored static dns on interface %s successfully", i.Name)
err = os.Remove(file)
if err != nil {
mainLog.Load().Debug().Err(err).Msgf("Could not remove saved static DNS file for interface %s", i.Name)
mainLog.Load().Debug().Err(err).Msgf("Could not remove saved static dns file for interface %s", i.Name)
}
}
}
@@ -1123,7 +1124,7 @@ func validateConfig(cfg *ctrld.Config) error {
var ve validator.ValidationErrors
if errors.As(err, &ve) {
for _, fe := range ve {
mainLog.Load().Error().Msgf("invalid config: %s: %s", fe.Namespace(), fieldErrorMsg(fe))
mainLog.Load().Error().Msgf("Invalid config: %s: %s", fe.Namespace(), fieldErrorMsg(fe))
}
}
mainLog.Load().Error().Err(err).Msg("Configuration validation failed")
@@ -1492,14 +1493,14 @@ func cdUIDFromProvToken() string {
}
// Validate custom hostname if provided.
if customHostname != "" && !validHostname(customHostname) {
mainLog.Load().Fatal().Msgf("invalid custom hostname: %q", customHostname)
mainLog.Load().Fatal().Msgf("Invalid custom hostname: %q", customHostname)
}
req := &controld.UtilityOrgRequest{ProvToken: cdOrg, Hostname: customHostname}
// Process provision token if provided.
loggerCtx := ctrld.LoggerCtx(context.Background(), mainLog.Load())
resolverConfig, err := controld.FetchResolverUID(loggerCtx, req, appVersion, cdDev)
if err != nil {
mainLog.Load().Fatal().Err(err).Msgf("failed to fetch resolver uid with provision token: %s", cdOrg)
mainLog.Load().Fatal().Err(err).Msgf("Failed to fetch resolver uid with provision token: %s", cdOrg)
}
return resolverConfig.UID
}
@@ -1619,7 +1620,7 @@ func validateCdUpstreamProtocol() {
switch cdUpstreamProto {
case ctrld.ResolverTypeDOH, ctrld.ResolverTypeDOH3:
default:
mainLog.Load().Fatal().Msg(`flag "--protocol" must be "doh" or "doh3"`)
mainLog.Load().Fatal().Msg(`Flag "--protocol" must be "doh" or "doh3"`)
}
}
@@ -1686,7 +1687,7 @@ func checkDeactivationPin(s service.Service, stopCh chan struct{}) error {
mainLog.Load().Debug().Msg("Checking deactivation pin")
dir, err := socketDir()
if err != nil {
mainLog.Load().Err(err).Msg("could not check deactivation pin")
mainLog.Load().Err(err).Msg("Could not check deactivation pin")
return err
}
mainLog.Load().Debug().Msg("Creating control client")
@@ -1751,7 +1752,7 @@ func curCdUID() string {
if s, _, _ := svcCmd.initializeServiceManager(); s != nil {
// Configure Windows service failure actions
if err := ConfigureWindowsServiceFailureActions(ctrldServiceName); err != nil {
mainLog.Load().Debug().Err(err).Msgf("failed to configure Windows service %s failure actions", ctrldServiceName)
mainLog.Load().Debug().Err(err).Msgf("Failed to configure windows service %s failure actions", ctrldServiceName)
}
if dir, _ := socketDir(); dir != "" {
cc := newSocketControlClient(context.TODO(), s, dir)
@@ -1830,7 +1831,7 @@ func doValidateCdRemoteConfig(cdUID string, fatal bool) error {
if !fatal {
logger = mainLog.Load().Warn()
}
logger.Err(err).Err(err).Msgf("failed to fetch resolver uid: %s", cdUID)
logger.Err(err).Err(err).Msgf("Failed to fetch resolver uid: %s", cdUID)
if !fatal {
return err
}
@@ -1859,22 +1860,22 @@ func doValidateCdRemoteConfig(cdUID string, fatal bool) error {
if we := os.WriteFile(tmpConfFile, configStr, 0600); we == nil {
if de := decoderErrorFromTomlFile(tmpConfFile); de != nil {
row, col := de.Position()
mainLog.Load().Error().Msgf("failed to parse custom config at line: %d, column: %d, error: %s", row, col, de.Error())
mainLog.Load().Error().Msgf("Failed to parse custom config at line: %d, column: %d, error: %s", row, col, de.Error())
errorLogged = true
}
_ = os.Remove(tmpConfFile)
}
// If we could not log details error, emit what we have already got.
if !errorLogged {
mainLog.Load().Error().Msgf("failed to parse custom config: %v", cfgErr)
mainLog.Load().Error().Msgf("Failed to parse custom config: %v", cfgErr)
}
}
} else {
mainLog.Load().Error().Msgf("failed to unmarshal custom config: %v", err)
mainLog.Load().Error().Msgf("Failed to unmarshal custom config: %v", err)
}
}
if cfgErr != nil {
mainLog.Load().Warn().Msg("disregarding invalid custom config")
mainLog.Load().Warn().Msg("Disregarding invalid custom config")
}
v = oldV
return nil
@@ -1885,7 +1886,7 @@ func uninstallInvalidCdUID(p *prog, logger *ctrld.Logger, doStop bool) bool {
svcCmd := NewServiceCommand()
s, _, err := svcCmd.initializeServiceManager()
if err != nil {
logger.Warn().Err(err).Msg("failed to create new service")
logger.Warn().Err(err).Msg("Failed to create new service")
return false
}
// restore static DNS settings or DHCP
@@ -1893,7 +1894,7 @@ func uninstallInvalidCdUID(p *prog, logger *ctrld.Logger, doStop bool) bool {
tasks := []task{{s.Uninstall, true, "Uninstall"}}
if doTasks(tasks) {
logger.Info().Msg("uninstalled service")
logger.Info().Msg("Uninstalled service")
if doStop {
_ = s.Stop()
}
cmd/cli/commands_clients.go
+2 -2
View File
@@ -46,11 +46,11 @@ func (cc *ClientsCommand) ListClients(cmd *cobra.Command, args []string) error {
status, err := s.Status()
if errors.Is(err, service.ErrNotInstalled) {
mainLog.Load().Warn().Msg("service not installed")
mainLog.Load().Warn().Msg("Service not installed")
return nil
}
if status == service.StatusStopped {
mainLog.Load().Warn().Msg("service is not running")
mainLog.Load().Warn().Msg("Service is not running")
return nil
}
cmd/cli/commands_interfaces.go
+1 -1
View File
@@ -37,7 +37,7 @@ func (ic *InterfacesCommand) ListInterfaces(cmd *cobra.Command, args []string) e
}
nss, err := currentStaticDNS(i)
if err != nil {
mainLog.Load().Warn().Err(err).Msg("failed to get DNS")
mainLog.Load().Warn().Err(err).Msg("Failed to get DNS")
}
if len(nss) == 0 {
nss = currentDNS(i)
cmd/cli/commands_log.go
+8 -8
View File
@@ -33,7 +33,7 @@ func NewLogCommand() (*LogCommand, error) {
// warnRuntimeLoggingNotEnabled logs a warning about runtime logging not being enabled
func (lc *LogCommand) warnRuntimeLoggingNotEnabled() {
mainLog.Load().Warn().Msg("runtime debug logging is not enabled")
mainLog.Load().Warn().Msg("Runtime debug logging is not enabled")
mainLog.Load().Warn().Msg(`ctrld may be running without "--cd" flag or logging is already enabled`)
}
@@ -47,11 +47,11 @@ func (lc *LogCommand) SendLogs(cmd *cobra.Command, args []string) error {
status, err := s.Status()
if errors.Is(err, service.ErrNotInstalled) {
mainLog.Load().Warn().Msg("service not installed")
mainLog.Load().Warn().Msg("Service not installed")
return nil
}
if status == service.StatusStopped {
mainLog.Load().Warn().Msg("service is not running")
mainLog.Load().Warn().Msg("Service is not running")
return nil
}
@@ -63,7 +63,7 @@ func (lc *LogCommand) SendLogs(cmd *cobra.Command, args []string) error {
switch resp.StatusCode {
case http.StatusServiceUnavailable:
mainLog.Load().Warn().Msg("runtime logs could only be sent once per minute")
mainLog.Load().Warn().Msg("Runtime logs could only be sent once per minute")
return nil
case http.StatusMovedPermanently:
lc.warnRuntimeLoggingNotEnabled()
@@ -93,11 +93,11 @@ func (lc *LogCommand) ViewLogs(cmd *cobra.Command, args []string) error {
status, err := s.Status()
if errors.Is(err, service.ErrNotInstalled) {
mainLog.Load().Warn().Msg("service not installed")
mainLog.Load().Warn().Msg("Service not installed")
return nil
}
if status == service.StatusStopped {
mainLog.Load().Warn().Msg("service is not running")
mainLog.Load().Warn().Msg("Service is not running")
return nil
}
@@ -112,10 +112,10 @@ func (lc *LogCommand) ViewLogs(cmd *cobra.Command, args []string) error {
lc.warnRuntimeLoggingNotEnabled()
return nil
case http.StatusBadRequest:
mainLog.Load().Warn().Msg("runtime debugs log is not available")
mainLog.Load().Warn().Msg("Runtime debug logs are not available")
buf, err := io.ReadAll(resp.Body)
if err != nil {
mainLog.Load().Fatal().Err(err).Msg("failed to read response body")
mainLog.Load().Fatal().Err(err).Msg("Failed to read response body")
}
mainLog.Load().Warn().Msgf("ctrld process response:\n\n%s\n", string(buf))
return nil
cmd/cli/commands_upgrade.go
+8 -8
View File
@@ -42,7 +42,7 @@ func (uc *UpgradeCommand) Upgrade(cmd *cobra.Command, args []string) error {
bin, err := os.Executable()
if err != nil {
mainLog.Load().Fatal().Err(err).Msg("failed to get current ctrld binary path")
mainLog.Load().Fatal().Err(err).Msg("Failed to get current ctrld binary path")
}
readConfig(false)
@@ -75,7 +75,7 @@ func (uc *UpgradeCommand) Upgrade(cmd *cobra.Command, args []string) error {
switch channel {
case upgradeChannelProd, upgradeChannelDev: // ok
default:
mainLog.Load().Fatal().Msgf("uprade argument must be either %q or %q", upgradeChannelProd, upgradeChannelDev)
mainLog.Load().Fatal().Msgf("Upgrade argument must be either %q or %q", upgradeChannelProd, upgradeChannelDev)
}
baseUrl = upgradeChannel[channel]
}
@@ -85,20 +85,20 @@ func (uc *UpgradeCommand) Upgrade(cmd *cobra.Command, args []string) error {
resp, err := getWithRetry(dlUrl, downloadServerIp)
if err != nil {
mainLog.Load().Fatal().Err(err).Msg("failed to download binary")
mainLog.Load().Fatal().Err(err).Msg("Failed to download binary")
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
mainLog.Load().Fatal().Msgf("could not download binary: %s", http.StatusText(resp.StatusCode))
mainLog.Load().Fatal().Msgf("Could not download binary: %s", http.StatusText(resp.StatusCode))
}
mainLog.Load().Debug().Msg("Updating current binary")
if err := selfupdate.Apply(resp.Body, selfupdate.Options{OldSavePath: oldBin}); err != nil {
if rerr := selfupdate.RollbackError(err); rerr != nil {
mainLog.Load().Error().Err(rerr).Msg("could not rollback old binary")
mainLog.Load().Error().Err(rerr).Msg("Could not rollback old binary")
}
mainLog.Load().Fatal().Err(err).Msg("failed to update current binary")
mainLog.Load().Fatal().Err(err).Msg("Failed to update current binary")
}
doRestart := func() bool {
@@ -154,10 +154,10 @@ func (uc *UpgradeCommand) Upgrade(cmd *cobra.Command, args []string) error {
mainLog.Load().Warn().Msgf("Upgrade failed, restoring previous binary: %s", oldBin)
if err := os.Remove(bin); err != nil {
mainLog.Load().Fatal().Err(err).Msg("failed to remove new binary")
mainLog.Load().Fatal().Err(err).Msg("Failed to remove new binary")
}
if err := os.Rename(oldBin, bin); err != nil {
mainLog.Load().Fatal().Err(err).Msg("failed to restore old binary")
mainLog.Load().Fatal().Err(err).Msg("Failed to restore old binary")
}
if doRestart() {
mainLog.Load().Notice().Msg("Restored previous binary successfully")
cmd/cli/control_server.go
+19 -19
View File
@@ -81,18 +81,18 @@ func (s *controlServer) register(pattern string, handler http.Handler) {
func (p *prog) registerControlServerHandler() {
p.cs.register(listClientsPath, http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
p.Debug().Msg("handling list clients request")
p.Debug().Msg("Handling list clients request")
clients := p.ciTable.ListClients()
p.Debug().Int("client_count", len(clients)).Msg("retrieved clients list")
p.Debug().Int("client_count", len(clients)).Msg("Retrieved clients list")
sort.Slice(clients, func(i, j int) bool {
return clients[i].IP.Less(clients[j].IP)
})
p.Debug().Msg("sorted clients by IP address")
p.Debug().Msg("Sorted clients by IP address")
if p.metricsQueryStats.Load() {
p.Debug().Msg("metrics query stats enabled, collecting query counts")
p.Debug().Msg("Metrics query stats enabled, collecting query counts")
for idx, client := range clients {
p.Debug().
@@ -100,7 +100,7 @@ func (p *prog) registerControlServerHandler() {
Str("ip", client.IP.String()).
Str("mac", client.Mac).
Str("hostname", client.Hostname).
Msg("processing client metrics")
Msg("Processing client metrics")
client.IncludeQueryCount = true
dm := &dto.Metric{}
@@ -108,7 +108,7 @@ func (p *prog) registerControlServerHandler() {
if statsClientQueriesCount.MetricVec == nil {
p.Debug().
Str("client_ip", client.IP.String()).
Msg("skipping metrics collection: MetricVec is nil")
Msg("Skipping metrics collection: MetricVec is nil")
continue
}
@@ -123,7 +123,7 @@ func (p *prog) registerControlServerHandler() {
Str("client_ip", client.IP.String()).
Str("mac", client.Mac).
Str("hostname", client.Hostname).
Msg("failed to get metrics for client")
Msg("Failed to get metrics for client")
continue
}
@@ -132,30 +132,30 @@ func (p *prog) registerControlServerHandler() {
p.Debug().
Str("client_ip", client.IP.String()).
Int64("query_count", client.QueryCount).
Msg("successfully collected query count")
Msg("Successfully collected query count")
} else if err != nil {
p.Debug().
Err(err).
Str("client_ip", client.IP.String()).
Msg("failed to write metric")
Msg("Failed to write metric")
}
}
} else {
p.Debug().Msg("metrics query stats disabled, skipping query counts")
p.Debug().Msg("Metrics query stats disabled, skipping query counts")
}
if err := json.NewEncoder(w).Encode(&clients); err != nil {
p.Error().
Err(err).
Int("client_count", len(clients)).
Msg("failed to encode clients response")
Msg("Failed to encode clients response")
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
p.Debug().
Int("client_count", len(clients)).
Msg("successfully sent clients list response")
Msg("Successfully sent clients list response")
}))
p.cs.register(startedPath, http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
select {
@@ -177,14 +177,14 @@ func (p *prog) registerControlServerHandler() {
oldSvc := p.cfg.Service
p.mu.Unlock()
if err := p.sendReloadSignal(); err != nil {
p.Error().Err(err).Msg("could not send reload signal")
p.Error().Err(err).Msg("Could not send reload signal")
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
select {
case <-p.reloadDoneCh:
case <-time.After(5 * time.Second):
http.Error(w, "timeout waiting for ctrld reload", http.StatusInternalServerError)
http.Error(w, "Timeout waiting for ctrld reload", http.StatusInternalServerError)
return
}
@@ -227,7 +227,7 @@ func (p *prog) registerControlServerHandler() {
cdDeactivationPin.Store(defaultDeactivationPin)
}
} else {
p.Warn().Err(err).Msg("could not re-fetch deactivation pin code")
p.Warn().Err(err).Msg("Could not re-fetch deactivation pin code")
}
// If pin code not set, allowing deactivation.
@@ -239,7 +239,7 @@ func (p *prog) registerControlServerHandler() {
var req deactivationRequest
if err := json.NewDecoder(request.Body).Decode(&req); err != nil {
w.WriteHeader(http.StatusPreconditionFailed)
p.Error().Err(err).Msg("invalid deactivation request")
p.Error().Err(err).Msg("Invalid deactivation request")
return
}
@@ -322,15 +322,15 @@ func (p *prog) registerControlServerHandler() {
UID: cdUID,
Data: r.r,
}
p.Debug().Msg("sending log file to ControlD server")
p.Debug().Msg("Sending log file to ControlD server")
resp := logSentResponse{Size: r.size}
loggerCtx := ctrld.LoggerCtx(context.Background(), p.logger.Load())
if err := controld.SendLogs(loggerCtx, req, cdDev); err != nil {
p.Error().Msgf("could not send log file to ControlD server: %v", err)
p.Error().Msgf("Could not send log file to ControlD server: %v", err)
resp.Error = err.Error()
w.WriteHeader(http.StatusInternalServerError)
} else {
p.Debug().Msg("sending log file successfully")
p.Debug().Msg("Sending log file successfully")
w.WriteHeader(http.StatusOK)
}
if err := json.NewEncoder(w).Encode(&resp); err != nil {
cmd/cli/dns_proxy.go
+20 -20
View File
@@ -105,7 +105,7 @@ func (p *prog) serveDNS(ctx context.Context, listenerNum string) error {
listenerConfig := p.cfg.Listener[listenerNum]
if allocErr := p.allocateIP(listenerConfig.IP); allocErr != nil {
p.Error().Err(allocErr).Str("ip", listenerConfig.IP).Msg("serveUDP: failed to allocate listen ip")
p.Error().Err(allocErr).Str("ip", listenerConfig.IP).Msg("serveUDP: Failed to allocate listen IP")
return allocErr
}
@@ -136,7 +136,7 @@ func (p *prog) startListeners(ctx context.Context, cfg *ctrld.ListenerConfig, ha
case <-p.stopCh:
case <-gctx.Done():
case err := <-errCh:
p.Warn().Err(err).Msg("local ipv6 listener failed")
p.Warn().Err(err).Msg("Local IPv6 listener failed")
}
return nil
})
@@ -154,7 +154,7 @@ func (p *prog) startListeners(ctx context.Context, cfg *ctrld.ListenerConfig, ha
case <-p.stopCh:
case <-gctx.Done():
case err := <-errCh:
p.Warn().Err(err).Msgf("could not listen on %s: %s", proto, listenAddr)
p.Warn().Err(err).Msgf("Could not listen on %s: %s", proto, listenAddr)
}
}()
}
@@ -476,8 +476,8 @@ func (p *prog) proxyPrivatePtrLookup(ctx context.Context, msg *dns.Msg) *dns.Msg
},
Ptr: dns.Fqdn(name),
}}
ctrld.Log(ctx, p.Info(), "private PTR lookup, using client info table")
ctrld.Log(ctx, p.Debug(), "client info: %v", ctrld.ClientInfo{
ctrld.Log(ctx, p.Info(), "Private PTR lookup, using client info table")
ctrld.Log(ctx, p.Debug(), "Client info: %v", ctrld.ClientInfo{
Mac: p.ciTable.LookupMac(ip.String()),
IP: ip.String(),
Hostname: name,
@@ -525,8 +525,8 @@ func (p *prog) proxyLanHostnameQuery(ctx context.Context, msg *dns.Msg) *dns.Msg
AAAA: ip.AsSlice(),
}}
}
ctrld.Log(ctx, p.Info(), "lan hostname lookup, using client info table")
ctrld.Log(ctx, p.Debug(), "client info: %v", ctrld.ClientInfo{
ctrld.Log(ctx, p.Info(), "Lan hostname lookup, using client info table")
ctrld.Log(ctx, p.Debug(), "Client info: %v", ctrld.ClientInfo{
Mac: p.ciTable.LookupMac(ip.String()),
IP: ip.String(),
Hostname: hostname,
@@ -560,7 +560,7 @@ func (p *prog) handleSpecialQueryTypes(ctx *context.Context, req *proxyRequest,
}
*upstreams, *upstreamConfigs = p.upstreamsAndUpstreamConfigForPtr(*upstreams, *upstreamConfigs)
*ctx = ctrld.LanQueryCtx(*ctx)
ctrld.Log(*ctx, p.Debug(), "private PTR lookup, using upstreams: %v", *upstreams)
ctrld.Log(*ctx, p.Debug(), "Private PTR lookup, using upstreams: %v", *upstreams)
return nil
case isLanHostnameQuery(req.msg):
req.isLanOrPtrQuery = true
@@ -570,10 +570,10 @@ func (p *prog) handleSpecialQueryTypes(ctx *context.Context, req *proxyRequest,
*upstreams = []string{upstreamOS}
*upstreamConfigs = []*ctrld.UpstreamConfig{osUpstreamConfig}
*ctx = ctrld.LanQueryCtx(*ctx)
ctrld.Log(*ctx, p.Debug(), "lan hostname lookup, using upstreams: %v", *upstreams)
ctrld.Log(*ctx, p.Debug(), "Lan hostname lookup, using upstreams: %v", *upstreams)
return nil
default:
ctrld.Log(*ctx, p.Debug(), "no explicit policy matched, using default routing -> %v", *upstreams)
ctrld.Log(*ctx, p.Debug(), "No explicit policy matched, using default routing -> %v", *upstreams)
return nil
}
}
@@ -1093,7 +1093,7 @@ func runDNSServer(addr, network string, handler dns.Handler) (*dns.Server, <-cha
defer close(errCh)
if err := s.ListenAndServe(); err != nil {
s.NotifyStartedFunc()
mainLog.Load().Error().Err(err).Msgf("could not listen and serve on: %s", s.Addr)
mainLog.Load().Error().Err(err).Msgf("Could not listen and serve on: %s", s.Addr)
errCh <- err
}
}()
@@ -1195,11 +1195,11 @@ func (p *prog) doSelfUninstall(pr *proxyResponse) {
p.checkingSelfUninstall = true
loggerCtx := ctrld.LoggerCtx(context.Background(), p.logger.Load())
_, err := controld.FetchResolverConfig(loggerCtx, cdUID, appVersion, cdDev)
logger.Debug().Msg("maximum number of refused queries reached, checking device status")
logger.Debug().Msg("Maximum number of refused queries reached, checking device status")
selfUninstallCheck(err, p, logger)
if err != nil {
logger.Warn().Err(err).Msg("could not fetch resolver config")
logger.Warn().Err(err).Msg("Could not fetch resolver config")
}
// Cool-of period to prevent abusing the API.
go p.selfUninstallCoolOfPeriod()
@@ -1263,7 +1263,7 @@ func (p *prog) queryFromSelf(ip string) bool {
netIP := netip.MustParseAddr(ip)
regularIPs, loopbackIPs, err := netmon.LocalAddresses()
if err != nil {
p.Warn().Err(err).Msg("could not get local addresses")
p.Warn().Err(err).Msg("Could not get local addresses")
return false
}
for _, localIP := range slices.Concat(regularIPs, loopbackIPs) {
@@ -1384,7 +1384,7 @@ func isWanClient(na net.Addr) bool {
// resolveInternalDomainTestQuery resolves internal test domain query, returning the answer to the caller.
func resolveInternalDomainTestQuery(ctx context.Context, domain string, m *dns.Msg) *dns.Msg {
logger := ctrld.LoggerFromCtx(ctx)
ctrld.Log(ctx, logger.Debug(), "internal domain test query")
ctrld.Log(ctx, logger.Debug(), "Internal domain test query")
q := m.Question[0]
answer := new(dns.Msg)
@@ -1521,18 +1521,18 @@ func (p *prog) monitorNetworkChanges(ctx context.Context) error {
// Ensure that selfIP is an IPv4 address.
// If defaultRouteIP mistakenly returns an IPv6 (such as a ULA), clear it
if ip := net.ParseIP(selfIP); ip != nil && ip.To4() == nil {
p.Debug().Msgf("defaultRouteIP returned a non-IPv4 address: %s, ignoring it", selfIP)
p.Debug().Msgf("DefaultRouteIP returned a non-ipv4 address: %s, ignoring it", selfIP)
selfIP = ""
}
var ipv6 string
if delta.New.DefaultRouteInterface != "" {
p.Debug().Msgf("default route interface: %s, IPs: %v", delta.New.DefaultRouteInterface, delta.New.InterfaceIPs[delta.New.DefaultRouteInterface])
p.Debug().Msgf("Default route interface: %s, ips: %v", delta.New.DefaultRouteInterface, delta.New.InterfaceIPs[delta.New.DefaultRouteInterface])
for _, ip := range delta.New.InterfaceIPs[delta.New.DefaultRouteInterface] {
ipAddr, _ := netip.ParsePrefix(ip.String())
addr := ipAddr.Addr()
if selfIP == "" && addr.Is4() {
p.Debug().Msgf("checking IP: %s", addr.String())
p.Debug().Msgf("Checking ip: %s", addr.String())
if !addr.IsLoopback() && !addr.IsLinkLocalUnicast() {
selfIP = addr.String()
}
@@ -1543,12 +1543,12 @@ func (p *prog) monitorNetworkChanges(ctx context.Context) error {
}
} else {
// If no default route interface is set yet, use the changed IPs
p.Debug().Msgf("no default route interface found, using changed IPs: %v", changeIPs)
p.Debug().Msgf("No default route interface found, using changed ips: %v", changeIPs)
for _, ip := range changeIPs {
ipAddr, _ := netip.ParsePrefix(ip.String())
addr := ipAddr.Addr()
if selfIP == "" && addr.Is4() {
p.Debug().Msgf("checking IP: %s", addr.String())
p.Debug().Msgf("Checking ip: %s", addr.String())
if !addr.IsLoopback() && !addr.IsLinkLocalUnicast() {
selfIP = addr.String()
}
cmd/cli/library.go
+2 -2
View File
@@ -83,8 +83,8 @@ func doWithRetry(req *http.Request, maxRetries int, ip string) (*http.Response,
return resp, nil
}
if ipReq != nil {
mainLog.Load().Warn().Err(err).Msgf("dial to %q failed", req.Host)
mainLog.Load().Warn().Msgf("fallback to direct IP to download prod version: %q", ip)
mainLog.Load().Warn().Err(err).Msgf("Dial to %q failed", req.Host)
mainLog.Load().Warn().Msgf("Fallback to direct ip to download prod version: %q", ip)
resp, err = client.Do(ipReq)
if err == nil {
return resp, nil
cmd/cli/log_writer.go
+6 -6
View File
@@ -20,19 +20,19 @@ import (
const (
// logWriterSize is the default buffer size for log writers
// This provides sufficient space for runtime logs without excessive memory usage
logWriterSize = 1024 * 1024 * 5 // 5 MB
logWriterSize = 1024 * 1024 * 5 // 5 MB
// logWriterSmallSize is used for memory-constrained environments
// This reduces memory footprint while still maintaining log functionality
logWriterSmallSize = 1024 * 1024 * 1 // 1 MB
logWriterSmallSize = 1024 * 1024 * 1 // 1 MB
// logWriterInitialSize is the initial buffer allocation
// This provides immediate space for early log entries
logWriterInitialSize = 32 * 1024 // 32 KB
logWriterInitialSize = 32 * 1024 // 32 KB
// logWriterSentInterval controls how often logs are sent to external systems
// This balances real-time logging with system performance
logWriterSentInterval = time.Minute
logWriterSentInterval = time.Minute
// logWriterInitEndMarker marks the end of initialization logs
// This helps separate startup logs from runtime logs
@@ -40,7 +40,7 @@ const (
// logWriterLogEndMarker marks the end of log sections
// This provides clear boundaries for log parsing and analysis
logWriterLogEndMarker = "\n\n=== LOG_END ===\n\n"
logWriterLogEndMarker = "\n\n=== LOG_END ===\n\n"
)
// Custom level encoders that handle NOTICE level
@@ -169,7 +169,7 @@ func (p *prog) initInternalLogging(externalCores []zapcore.Core) {
return
}
p.initInternalLogWriterOnce.Do(func() {
p.Notice().Msg("internal logging enabled")
p.Notice().Msg("Internal logging enabled")
p.internalLogWriter = newLogWriter()
p.internalLogSent = time.Now().Add(-logWriterSentInterval)
p.internalWarnLogWriter = newSmallLogWriter()
cmd/cli/loop.go
+5 -5
View File
@@ -84,7 +84,7 @@ func (p *prog) detectLoop(msg *dns.Msg) {
//
// See: https://thekelleys.org.uk/dnsmasq/docs/dnsmasq-man.html
func (p *prog) checkDnsLoop() {
p.Debug().Msg("start checking DNS loop")
p.Debug().Msg("Start checking DNS loop")
upstream := make(map[string]*ctrld.UpstreamConfig)
p.loopMu.Lock()
for n, uc := range p.cfg.Upstream {
@@ -93,7 +93,7 @@ func (p *prog) checkDnsLoop() {
}
// Do not send test query to external upstream.
if !canBeLocalUpstream(uc.Domain) {
p.Debug().Msgf("skipping external: upstream.%s", n)
p.Debug().Msgf("Skipping external: upstream.%s", n)
continue
}
uid := uc.UID()
@@ -112,14 +112,14 @@ func (p *prog) checkDnsLoop() {
}
resolver, err := ctrld.NewResolver(loggerCtx, uc)
if err != nil {
p.Warn().Err(err).Msgf("could not perform loop check for upstream: %q, endpoint: %q", uc.Name, uc.Endpoint)
p.Warn().Err(err).Msgf("Could not perform loop check for upstream: %q, endpoint: %q", uc.Name, uc.Endpoint)
continue
}
if _, err := resolver.Resolve(context.Background(), msg); err != nil {
p.Warn().Err(err).Msgf("could not send DNS loop check query for upstream: %q, endpoint: %q", uc.Name, uc.Endpoint)
p.Warn().Err(err).Msgf("Could not send DNS loop check query for upstream: %q, endpoint: %q", uc.Name, uc.Endpoint)
}
}
p.Debug().Msg("end checking DNS loop")
p.Debug().Msg("End checking DNS loop")
}
// checkDnsLoopTicker performs p.checkDnsLoop every minute.
cmd/cli/main.go
+3 -3
View File
@@ -136,7 +136,7 @@ func initLoggingWithBackup(doBackup bool) []zapcore.Core {
// Create parent directory if necessary.
// This ensures log files can be created even if the directory doesn't exist
if err := os.MkdirAll(filepath.Dir(logFilePath), 0750); err != nil {
mainLog.Load().Error().Msgf("failed to create log path: %v", err)
mainLog.Load().Error().Msgf("Failed to create log path: %v", err)
os.Exit(1)
}
@@ -147,7 +147,7 @@ func initLoggingWithBackup(doBackup bool) []zapcore.Core {
// Backup old log file with .1 suffix.
// This prevents log file corruption during rotation
if err := os.Rename(logFilePath, logFilePath+oldLogSuffix); err != nil && !os.IsNotExist(err) {
mainLog.Load().Error().Msgf("could not backup old log file: %v", err)
mainLog.Load().Error().Msgf("Could not backup old log file: %v", err)
} else {
// Backup was created, set flags for truncating old log file.
// This ensures a clean start for the new log file
@@ -156,7 +156,7 @@ func initLoggingWithBackup(doBackup bool) []zapcore.Core {
}
logFile, err := openLogFile(logFilePath, flags)
if err != nil {
mainLog.Load().Error().Msgf("failed to create log file: %v", err)
mainLog.Load().Error().Msgf("Failed to create log file: %v", err)
os.Exit(1)
}
writers = append(writers, logFile)
cmd/cli/metrics.go
+4 -4
View File
@@ -122,7 +122,7 @@ func (p *prog) runMetricsServer(ctx context.Context, reloadCh chan struct{}) {
addr := p.cfg.Service.MetricsListener
ms, err := newMetricsServer(addr, reg)
if err != nil {
mainLog.Load().Warn().Err(err).Msg("could not create new metrics server")
mainLog.Load().Warn().Err(err).Msg("Could not create new metrics server")
return
}
// Only start listener address if defined.
@@ -137,9 +137,9 @@ func (p *prog) runMetricsServer(ctx context.Context, reloadCh chan struct{}) {
statsVersion.WithLabelValues(commit, runtime.Version(), curVersion()).Inc()
reg.MustRegister(statsTimeStart)
statsTimeStart.Set(float64(time.Now().Unix()))
mainLog.Load().Debug().Msgf("starting metrics server on: %s", addr)
mainLog.Load().Debug().Msgf("Starting metrics server on: %s", addr)
if err := ms.start(); err != nil {
mainLog.Load().Warn().Err(err).Msg("could not start metrics server")
mainLog.Load().Warn().Err(err).Msg("Could not start metrics server")
return
}
}
@@ -151,7 +151,7 @@ func (p *prog) runMetricsServer(ctx context.Context, reloadCh chan struct{}) {
}
if err := ms.stop(); err != nil {
mainLog.Load().Warn().Err(err).Msg("could not stop metrics server")
mainLog.Load().Warn().Err(err).Msg("Could not stop metrics server")
return
}
}
cmd/cli/net_linux.go
+1 -1
View File
@@ -55,7 +55,7 @@ func virtualInterfaces(ctx context.Context) map[string]struct{} {
s := make(map[string]struct{})
entries, err := os.ReadDir("/sys/devices/virtual/net")
if err != nil {
logger.Error().Err(err).Msg("failed to read /sys/devices/virtual/net")
logger.Error().Err(err).Msg("Failed to read /sys/devices/virtual/net")
return nil
}
for _, entry := range entries {
cmd/cli/netlink_linux.go
+2 -2
View File
@@ -14,7 +14,7 @@ func (p *prog) watchLinkState(ctx context.Context) {
done := make(chan struct{})
defer close(done)
if err := netlink.LinkSubscribe(ch, done); err != nil {
p.Warn().Err(err).Msg("could not subscribe link")
p.Warn().Err(err).Msg("Could not subscribe link")
return
}
for {
@@ -26,7 +26,7 @@ func (p *prog) watchLinkState(ctx context.Context) {
continue
}
if lu.Change&unix.IFF_UP != 0 {
p.Debug().Msgf("link state changed, re-bootstrapping")
p.Debug().Msgf("Link state changed, re-bootstrapping")
for _, uc := range p.cfg.Upstream {
uc.ReBootstrap(ctrld.LoggerCtx(ctx, p.logger.Load()))
}
cmd/cli/network_manager_linux.go
+6 -6
View File
@@ -43,12 +43,12 @@ func (p *prog) setupNetworkManager() error {
return nil
}
if err != nil {
p.Debug().Err(err).Msg("could not write NetworkManager ctrld config file")
p.Debug().Err(err).Msg("Could not write NetworkManager ctrld config file")
return err
}
p.reloadNetworkManager()
p.Debug().Msg("setup NetworkManager done")
p.Debug().Msg("Setup NetworkManager done")
return nil
}
@@ -62,12 +62,12 @@ func (p *prog) restoreNetworkManager() error {
return nil
}
if err != nil {
p.Debug().Err(err).Msg("could not remove NetworkManager ctrld config file")
p.Debug().Err(err).Msg("Could not remove NetworkManager ctrld config file")
return err
}
p.reloadNetworkManager()
p.Debug().Msg("restore NetworkManager done")
p.Debug().Msg("Restore NetworkManager done")
return nil
}
@@ -76,14 +76,14 @@ func (p *prog) reloadNetworkManager() {
defer cancel()
conn, err := dbus.NewSystemConnectionContext(ctx)
if err != nil {
p.Error().Err(err).Msg("could not create new system connection")
p.Error().Err(err).Msg("Could not create new system connection")
return
}
defer conn.Close()
waitCh := make(chan string)
if _, err := conn.ReloadUnitContext(ctx, nmSystemdUnitName, "ignore-dependencies", waitCh); err != nil {
p.Debug().Err(err).Msg("could not reload NetworkManager")
p.Debug().Err(err).Msg("Could not reload NetworkManager")
return
}
<-waitCh
cmd/cli/nextdns.go
+1 -1
View File
@@ -13,7 +13,7 @@ func generateNextDNSConfig(uid string) {
if uid == "" {
return
}
mainLog.Load().Info().Msg("generating ctrld config for NextDNS resolver")
mainLog.Load().Info().Msg("Generating ctrld config for NextDNS resolver")
cfg = ctrld.Config{
Listener: map[string]*ctrld.ListenerConfig{
"0": {
cmd/cli/os_darwin.go
+2 -2
View File
@@ -17,7 +17,7 @@ func allocateIP(ip string) error {
mainLog.Load().Debug().Str("ip", ip).Msg("Allocating IP address")
cmd := exec.Command("ifconfig", "lo0", "alias", ip, "up")
if err := cmd.Run(); err != nil {
mainLog.Load().Error().Err(err).Msg("allocateIP failed")
mainLog.Load().Error().Err(err).Msg("AllocateIP failed")
return err
}
mainLog.Load().Debug().Str("ip", ip).Msg("IP address allocated successfully")
@@ -29,7 +29,7 @@ func deAllocateIP(ip string) error {
mainLog.Load().Debug().Str("ip", ip).Msg("Deallocating IP address")
cmd := exec.Command("ifconfig", "lo0", "-alias", ip)
if err := cmd.Run(); err != nil {
mainLog.Load().Error().Err(err).Msg("deAllocateIP failed")
mainLog.Load().Error().Err(err).Msg("DeAllocateIP failed")
return err
}
mainLog.Load().Debug().Str("ip", ip).Msg("IP address deallocated successfully")
cmd/cli/os_freebsd.go
+5 -5
View File
@@ -49,7 +49,7 @@ func setDNS(iface *net.Interface, nameservers []string) error {
r, err := dns.NewOSConfigurator(logf, &health.Tracker{}, &controlknobs.Knobs{}, iface.Name)
if err != nil {
mainLog.Load().Error().Err(err).Msg("failed to create DNS OS configurator")
mainLog.Load().Error().Err(err).Msg("Failed to create DNS OS configurator")
return err
}
@@ -65,11 +65,11 @@ func setDNS(iface *net.Interface, nameservers []string) error {
if sds, err := searchDomains(); err == nil {
osConfig.SearchDomains = sds
} else {
mainLog.Load().Debug().Err(err).Msg("failed to get search domains list")
mainLog.Load().Debug().Err(err).Msg("Failed to get search domains list")
}
if err := r.SetDNS(osConfig); err != nil {
mainLog.Load().Error().Err(err).Msg("failed to set DNS")
mainLog.Load().Error().Err(err).Msg("Failed to set DNS")
return err
}
@@ -88,12 +88,12 @@ func resetDNS(iface *net.Interface) error {
r, err := dns.NewOSConfigurator(logf, &health.Tracker{}, &controlknobs.Knobs{}, iface.Name)
if err != nil {
mainLog.Load().Error().Err(err).Msg("failed to create DNS OS configurator")
mainLog.Load().Error().Err(err).Msg("Failed to create DNS OS configurator")
return err
}
if err := r.Close(); err != nil {
mainLog.Load().Error().Err(err).Msg("failed to rollback DNS setting")
mainLog.Load().Error().Err(err).Msg("Failed to rollback DNS setting")
return err
}
cmd/cli/os_linux.go
+8 -8
View File
@@ -36,7 +36,7 @@ func allocateIP(ip string) error {
mainLog.Load().Debug().Str("ip", ip).Msg("Allocating IP address")
cmd := exec.Command("ip", "a", "add", ip+"/24", "dev", "lo")
if out, err := cmd.CombinedOutput(); err != nil {
mainLog.Load().Error().Err(err).Msgf("allocateIP failed: %s", string(out))
mainLog.Load().Error().Err(err).Msgf("AllocateIP failed: %s", string(out))
return err
}
mainLog.Load().Debug().Str("ip", ip).Msg("IP address allocated successfully")
@@ -47,7 +47,7 @@ func deAllocateIP(ip string) error {
mainLog.Load().Debug().Str("ip", ip).Msg("Deallocating IP address")
cmd := exec.Command("ip", "a", "del", ip+"/24", "dev", "lo")
if err := cmd.Run(); err != nil {
mainLog.Load().Error().Err(err).Msg("deAllocateIP failed")
mainLog.Load().Error().Err(err).Msg("DeAllocateIP failed")
return err
}
mainLog.Load().Debug().Str("ip", ip).Msg("IP address deallocated successfully")
@@ -66,7 +66,7 @@ func setDNS(iface *net.Interface, nameservers []string) error {
r, err := dns.NewOSConfigurator(logf, &health.Tracker{}, &controlknobs.Knobs{}, iface.Name)
if err != nil {
mainLog.Load().Error().Err(err).Msg("failed to create DNS OS configurator")
mainLog.Load().Error().Err(err).Msg("Failed to create dns os configurator")
return err
}
@@ -82,7 +82,7 @@ func setDNS(iface *net.Interface, nameservers []string) error {
if sds, err := searchDomains(); err == nil {
osConfig.SearchDomains = sds
} else {
mainLog.Load().Debug().Err(err).Msg("failed to get search domains list")
mainLog.Load().Debug().Err(err).Msg("Failed to get search domains list")
}
trySystemdResolve := false
if err := r.SetDNS(osConfig); err != nil {
@@ -149,7 +149,7 @@ func resetDNS(iface *net.Interface) (err error) {
if r, oerr := dns.NewOSConfigurator(logf, &health.Tracker{}, &controlknobs.Knobs{}, iface.Name); oerr == nil {
_ = r.SetDNS(dns.OSConfig{})
if err := r.Close(); err != nil {
mainLog.Load().Error().Err(err).Msg("failed to rollback DNS setting")
mainLog.Load().Error().Err(err).Msg("Failed to rollback dns setting")
return
}
err = nil
@@ -177,18 +177,18 @@ func resetDNS(iface *net.Interface) (err error) {
}
// TODO(cuonglm): handle DHCPv6 properly.
mainLog.Load().Debug().Msg("checking for IPv6 availability")
mainLog.Load().Debug().Msg("Checking for ipv6 availability")
if ctrldnet.IPv6Available(ctx) {
c := client6.NewClient()
conversation, err := c.Exchange(iface.Name)
if err != nil && !errAddrInUse(err) {
mainLog.Load().Debug().Err(err).Msg("could not exchange DHCPv6")
mainLog.Load().Debug().Err(err).Msg("Could not exchange dhcpv6")
}
for _, packet := range conversation {
if packet.Type() == dhcpv6.MessageTypeReply {
msg, err := packet.GetInnerMessage()
if err != nil {
mainLog.Load().Debug().Err(err).Msg("could not get inner DHCPv6 message")
mainLog.Load().Debug().Err(err).Msg("Could not get inner dhcpv6 message")
return nil
}
nameservers := msg.Options.DNS()
cmd/cli/os_windows.go
+10 -10
View File
@@ -111,24 +111,24 @@ func restoreDNS(iface *net.Interface) (err error) {
}
if len(v4ns) > 0 {
mainLog.Load().Debug().Msgf("restoring IPv4 static DNS for interface %q: %v", iface.Name, v4ns)
mainLog.Load().Debug().Msgf("Restoring IPv4 static DNS for interface %q: %v", iface.Name, v4ns)
if err := setDNS(iface, v4ns); err != nil {
return fmt.Errorf("restoreDNS (IPv4): %w", err)
}
} else {
mainLog.Load().Debug().Msgf("restoring IPv4 DHCP for interface %q", iface.Name)
mainLog.Load().Debug().Msgf("Restoring IPv4 DHCP for interface %q", iface.Name)
if err := luid.SetDNS(windows.AF_INET, nil, nil); err != nil {
return fmt.Errorf("restoreDNS (IPv4 clear): %w", err)
}
}
if len(v6ns) > 0 {
mainLog.Load().Debug().Msgf("restoring IPv6 static DNS for interface %q: %v", iface.Name, v6ns)
mainLog.Load().Debug().Msgf("Restoring IPv6 static DNS for interface %q: %v", iface.Name, v6ns)
if err := setDNS(iface, v6ns); err != nil {
return fmt.Errorf("restoreDNS (IPv6): %w", err)
}
} else {
mainLog.Load().Debug().Msgf("restoring IPv6 DHCP for interface %q", iface.Name)
mainLog.Load().Debug().Msgf("Restoring IPv6 DHCP for interface %q", iface.Name)
if err := luid.SetDNS(windows.AF_INET6, nil, nil); err != nil {
return fmt.Errorf("restoreDNS (IPv6 clear): %w", err)
}
@@ -141,12 +141,12 @@ func restoreDNS(iface *net.Interface) (err error) {
func currentDNS(iface *net.Interface) []string {
luid, err := winipcfg.LUIDFromIndex(uint32(iface.Index))
if err != nil {
mainLog.Load().Error().Err(err).Msg("failed to get interface LUID")
mainLog.Load().Error().Err(err).Msg("Failed to get interface LUID")
return nil
}
nameservers, err := luid.DNS()
if err != nil {
mainLog.Load().Error().Err(err).Msg("failed to get interface DNS")
mainLog.Load().Error().Err(err).Msg("Failed to get interface DNS")
return nil
}
ns := make([]string, 0, len(nameservers))
@@ -174,7 +174,7 @@ func currentStaticDNS(iface *net.Interface) ([]string, error) {
interfaceKeyPath := path + guid.String()
k, err := registry.OpenKey(registry.LOCAL_MACHINE, interfaceKeyPath, registry.QUERY_VALUE)
if err != nil {
mainLog.Load().Debug().Err(err).Msgf("failed to open registry key %q for interface %q; trying next key", interfaceKeyPath, iface.Name)
mainLog.Load().Debug().Err(err).Msgf("Failed to open registry key %q for interface %q; trying next key", interfaceKeyPath, iface.Name)
continue
}
func() {
@@ -182,11 +182,11 @@ func currentStaticDNS(iface *net.Interface) ([]string, error) {
for _, keyName := range []string{"NameServer", "ProfileNameServer"} {
value, _, err := k.GetStringValue(keyName)
if err != nil && !errors.Is(err, registry.ErrNotExist) {
mainLog.Load().Debug().Err(err).Msgf("error reading %s registry key", keyName)
mainLog.Load().Debug().Err(err).Msgf("Error reading %s registry key", keyName)
continue
}
if len(value) > 0 {
mainLog.Load().Debug().Msgf("found static DNS for interface %q: %s", iface.Name, value)
mainLog.Load().Debug().Msgf("Found static DNS for interface %q: %s", iface.Name, value)
parsed := parseDNSServers(value)
for _, pns := range parsed {
if !slices.Contains(ns, pns) {
@@ -198,7 +198,7 @@ func currentStaticDNS(iface *net.Interface) ([]string, error) {
}()
}
if len(ns) == 0 {
mainLog.Load().Debug().Msgf("no static DNS values found for interface %q", iface.Name)
mainLog.Load().Debug().Msgf("No static DNS values found for interface %q", iface.Name)
}
return ns, nil
}
cmd/cli/prog.go
+88 -88
View File
@@ -165,9 +165,9 @@ func (p *prog) runWait() {
var newCfg *ctrld.Config
select {
case sig := <-reloadSigCh:
p.Notice().Msgf("got signal: %s, reloading...", sig.String())
p.Notice().Msgf("Got signal: %s, reloading...", sig.String())
case <-p.reloadCh:
p.Notice().Msg("reloading...")
p.Notice().Msg("Reloading...")
case apiCfg := <-p.apiReloadCh:
newCfg = apiCfg
case <-p.stopCh:
@@ -190,18 +190,18 @@ func (p *prog) runWait() {
}
v.SetConfigFile(confFile)
if err := v.ReadInConfig(); err != nil {
p.Error().Err(err).Msg("could not read new config")
p.Error().Err(err).Msg("Could not read new config")
waitOldRunDone()
continue
}
if err := v.Unmarshal(&newCfg); err != nil {
p.Error().Err(err).Msg("could not unmarshal new config")
p.Error().Err(err).Msg("Could not unmarshal new config")
waitOldRunDone()
continue
}
if cdUID != "" {
if rc, err := processCDFlags(newCfg); err != nil {
p.Error().Err(err).Msg("could not fetch ControlD config")
p.Error().Err(err).Msg("Could not fetch controld config")
waitOldRunDone()
continue
} else {
@@ -231,29 +231,29 @@ func (p *prog) runWait() {
}
}
if err := validateConfig(newCfg); err != nil {
p.Error().Err(err).Msg("invalid config")
p.Error().Err(err).Msg("Invalid config")
continue
}
addExtraSplitDnsRule(newCfg)
if err := writeConfigFile(newCfg); err != nil {
p.Error().Err(err).Msg("could not write new config")
p.Error().Err(err).Msg("Could not write new config")
}
// This needs to be done here, otherwise, the DNS handler may observe an invalid
// upstream config because its initialization function have not been called yet.
p.Debug().Msg("setup upstream with new config")
p.Debug().Msg("Setup upstream with new config")
p.setupUpstream(newCfg)
p.mu.Lock()
*p.cfg = *newCfg
p.mu.Unlock()
p.Notice().Msg("reloading config successfully")
p.Notice().Msg("Reloading config successfully")
select {
case p.reloadDoneCh <- struct{}{}:
p.Debug().Msg("reload done signal sent")
p.Debug().Msg("Reload done signal sent")
default:
}
}
@@ -272,7 +272,7 @@ func (p *prog) postRun() {
if !service.Interactive() {
p.resetDNS(false, false)
ns := ctrld.InitializeOsResolver(ctrld.LoggerCtx(context.Background(), p.logger.Load()), false)
p.Debug().Msgf("initialized OS resolver with nameservers: %v", ns)
p.Debug().Msgf("Initialized os resolver with nameservers: %v", ns)
p.setDNS()
p.csSetDnsDone <- struct{}{}
close(p.csSetDnsDone)
@@ -290,7 +290,7 @@ func (p *prog) apiConfigReload() {
defer ticker.Stop()
logger := p.logger.Load().With().Str("mode", "api-reload")
logger.Debug().Msg("starting custom config reload timer")
logger.Debug().Msg("Starting custom config reload timer")
lastUpdated := time.Now().Unix()
curVerStr := curVersion()
curVer, err := semver.NewVersion(curVerStr)
@@ -300,7 +300,7 @@ func (p *prog) apiConfigReload() {
if err != nil {
l = l.Err(err)
}
l.Msgf("current version is not stable, skipping self-upgrade: %s", curVerStr)
l.Msgf("Current version is not stable, skipping self-upgrade: %s", curVerStr)
}
doReloadApiConfig := func(forced bool, logger *ctrld.Logger) {
@@ -308,7 +308,7 @@ func (p *prog) apiConfigReload() {
resolverConfig, err := controld.FetchResolverConfig(loggerCtx, cdUID, appVersion, cdDev)
selfUninstallCheck(err, p, logger)
if err != nil {
logger.Warn().Err(err).Msg("could not fetch resolver config")
logger.Warn().Err(err).Msg("Could not fetch resolver config")
return
}
@@ -322,9 +322,9 @@ func (p *prog) apiConfigReload() {
curDeactivationPin := cdDeactivationPin.Load()
switch {
case curDeactivationPin != defaultDeactivationPin:
logger.Debug().Msg("saving deactivation pin")
logger.Debug().Msg("Saving deactivation pin")
case curDeactivationPin != newDeactivationPin:
logger.Debug().Msg("update deactivation pin")
logger.Debug().Msg("Update deactivation pin")
}
cdDeactivationPin.Store(newDeactivationPin)
} else {
@@ -347,7 +347,7 @@ func (p *prog) apiConfigReload() {
}
if noCustomConfig && !noExcludeListChanged {
logger.Debug().Msg("exclude list changes detected, reloading...")
logger.Debug().Msg("Exclude list changes detected, reloading...")
p.apiReloadCh <- nil
return
}
@@ -362,16 +362,16 @@ func (p *prog) apiConfigReload() {
cfgErr = validateConfig(cfg)
}
if cfgErr != nil {
logger.Warn().Err(err).Msg("skipping invalid custom config")
logger.Warn().Err(err).Msg("Skipping invalid custom config")
if _, err := controld.UpdateCustomLastFailed(loggerCtx, cdUID, appVersion, cdDev, true); err != nil {
logger.Error().Err(err).Msg("could not mark custom last update failed")
logger.Error().Err(err).Msg("Could not mark custom last update failed")
}
return
}
logger.Debug().Msg("custom config changes detected, reloading...")
logger.Debug().Msg("Custom config changes detected, reloading...")
p.apiReloadCh <- cfg
} else {
logger.Debug().Msg("custom config does not change")
logger.Debug().Msg("Custom config does not change")
}
}
for {
@@ -396,14 +396,14 @@ func (p *prog) setupUpstream(cfg *ctrld.Config) {
sdns := uc.Type == ctrld.ResolverTypeSDNS
uc.Init(loggerCtx)
if sdns {
p.Debug().Msgf("initialized DNS Stamps with endpoint: %s, type: %s", uc.Endpoint, uc.Type)
p.Debug().Msgf("Initialized dns stamps with endpoint: %s, type: %s", uc.Endpoint, uc.Type)
}
isControlDUpstream = isControlDUpstream || uc.IsControlD()
if uc.BootstrapIP == "" {
uc.SetupBootstrapIP(ctrld.LoggerCtx(context.Background(), p.logger.Load()))
p.Info().Msgf("bootstrap IPs for upstream.%s: %q", n, uc.BootstrapIPs())
p.Info().Msgf("Bootstrap ips for upstream.%s: %q", n, uc.BootstrapIPs())
} else {
p.Info().Str("bootstrap_ip", uc.BootstrapIP).Msgf("using bootstrap IP for upstream.%s", n)
p.Info().Str("bootstrap_ip", uc.BootstrapIP).Msgf("Using bootstrap ip for upstream.%s", n)
}
uc.SetCertPool(rootCertPool)
go uc.Ping(loggerCtx)
@@ -444,9 +444,9 @@ func (p *prog) run(reload bool, reloadCh chan struct{}) {
p.csSetDnsDone = make(chan struct{}, 1)
p.registerControlServerHandler()
if err := p.cs.start(); err != nil {
p.Warn().Err(err).Msg("could not start control server")
p.Warn().Err(err).Msg("Could not start control server")
}
p.Debug().Msgf("control server started: %s", p.cs.addr)
p.Debug().Msgf("Control server started: %s", p.cs.addr)
}
}
p.onStartedDone = make(chan struct{})
@@ -458,7 +458,7 @@ func (p *prog) run(reload bool, reloadCh chan struct{}) {
if p.cfg.Service.CacheEnable {
cacher, err := dnscache.NewLRUCache(p.cfg.Service.CacheSize)
if err != nil {
p.Error().Err(err).Msg("failed to create cacher, caching is disabled")
p.Error().Err(err).Msg("Failed to create cacher, caching is disabled")
} else {
p.cache = cacher
p.cacheFlushDomainsMap = make(map[string]struct{}, 256)
@@ -475,7 +475,7 @@ func (p *prog) run(reload bool, reloadCh chan struct{}) {
for _, cidr := range nc.Cidrs {
_, ipNet, err := net.ParseCIDR(cidr)
if err != nil {
p.Error().Err(err).Str("network", nc.Name).Str("cidr", cidr).Msg("invalid cidr")
p.Error().Err(err).Str("network", nc.Name).Str("cidr", cidr).Msg("Invalid cidr")
continue
}
nc.IPNets = append(nc.IPNets, ipNet)
@@ -528,17 +528,17 @@ func (p *prog) run(reload bool, reloadCh chan struct{}) {
listenerConfig := p.cfg.Listener[listenerNum]
upstreamConfig := p.cfg.Upstream[listenerNum]
if upstreamConfig == nil {
p.Warn().Msgf("no default upstream for: [listener.%s]", listenerNum)
p.Warn().Msgf("No default upstream for: [listener.%s]", listenerNum)
}
addr := net.JoinHostPort(listenerConfig.IP, strconv.Itoa(listenerConfig.Port))
p.Info().Msgf("starting DNS server on listener.%s: %s", listenerNum, addr)
p.Info().Msgf("Starting dns server on listener.%s: %s", listenerNum, addr)
// serveCtx uses Background() context so listeners survive between reloads.
// Changes to listeners config require a service restart, not just reload.
serveCtx := context.Background()
if err := p.serveDNS(serveCtx, listenerNum); err != nil {
p.Fatal().Err(err).Msgf("unable to start dns proxy on listener.%s", listenerNum)
p.Fatal().Err(err).Msgf("Unable to start dns proxy on listener.%s", listenerNum)
}
p.Debug().Msgf("end of serveDNS listener.%s: %s", listenerNum, addr)
p.Debug().Msgf("End of serveDNS listener.%s: %s", listenerNum, addr)
}(listenerNum)
}
go func() {
@@ -599,7 +599,7 @@ func (p *prog) setupClientInfoDiscover() {
selfIP := p.defaultRouteIP()
p.ciTable = clientinfo.NewTable(&cfg, selfIP, cdUID, p.ptrNameservers, p.logger.Load())
if leaseFile := p.cfg.Service.DHCPLeaseFile; leaseFile != "" {
p.Debug().Msgf("watching custom lease file: %s", leaseFile)
p.Debug().Msgf("Watching custom lease file: %s", leaseFile)
format := ctrld.LeaseFileFormat(p.cfg.Service.DHCPLeaseFileFormat)
p.ciTable.AddLeaseFile(leaseFile, format)
}
@@ -618,16 +618,16 @@ func (p *prog) metricsEnabled() bool {
func (p *prog) Stop(_ service.Service) error {
p.stopDnsWatchers()
p.Debug().Msg("dns watchers stopped")
p.Debug().Msg("Dns watchers stopped")
for _, f := range p.onStopped {
f()
}
p.Debug().Msg("finish running onStopped functions")
p.Debug().Msg("Finish running onStopped functions")
defer func() {
p.Info().Msg("Service stopped")
}()
if err := p.deAllocateIP(); err != nil {
p.Error().Err(err).Msg("de-allocate ip failed")
p.Error().Err(err).Msg("De-allocate ip failed")
return err
}
if deactivationPinSet() {
@@ -639,16 +639,16 @@ func (p *prog) Stop(_ service.Service) error {
// No valid pin code was checked, that mean we are stopping
// because of OS signal sent directly from someone else.
// In this case, restarting ctrld service by ourselves.
p.Debug().Msgf("receiving stopping signal without valid pin code")
p.Debug().Msgf("self restarting ctrld service")
p.Debug().Msgf("Receiving stopping signal without valid pin code")
p.Debug().Msgf("Self restarting ctrld service")
if exe, err := os.Executable(); err == nil {
cmd := exec.Command(exe, "restart")
cmd.SysProcAttr = sysProcAttrForDetachedChildProcess()
if err := cmd.Start(); err != nil {
p.Error().Err(err).Msg("failed to run self restart command")
p.Error().Err(err).Msg("Failed to run self restart command")
}
} else {
p.Error().Err(err).Msg("failed to self restart ctrld service")
p.Error().Err(err).Msg("Failed to self restart ctrld service")
}
os.Exit(deactivationPinInvalidExitCode)
}
@@ -780,29 +780,29 @@ func (p *prog) setDnsForRunningIface(nameservers []string) (runningIface *net.In
if newIface != p.runningIface {
p.runningIface = newIface
logger = p.logger.Load().With().Str("iface", p.runningIface)
logger.Info().Msg("switched to new interface")
logger.Info().Msg("Switched to new interface")
continue
}
logger.Warn().Err(err).Int("attempt", attempt).Msg("could not get interface, retrying...")
logger.Warn().Err(err).Int("attempt", attempt).Msg("Could not get interface, retrying...")
time.Sleep(retryDelay)
continue
}
logger.Error().Err(err).Msg("could not get interface after all attempts")
logger.Error().Err(err).Msg("Could not get interface after all attempts")
return
}
if err := p.setupNetworkManager(); err != nil {
logger.Error().Err(err).Msg("could not patch NetworkManager")
logger.Error().Err(err).Msg("Could not patch networkmanager")
return
}
runningIface = netIface
logger.Debug().Msg("setting DNS for interface")
logger.Debug().Msg("Setting dns for interface")
if err := setDNS(netIface, nameservers); err != nil {
logger.Error().Err(err).Msgf("could not set DNS for interface")
logger.Error().Err(err).Msgf("Could not set dns for interface")
return
}
logger.Debug().Msg("setting DNS successfully")
logger.Debug().Msg("Setting dns successfully")
return
}
@@ -831,7 +831,7 @@ func (p *prog) dnsWatchdog(iface *net.Interface, nameservers []string) {
return
}
p.Debug().Msg("start DNS settings watchdog")
p.Debug().Msg("Start dns settings watchdog")
ns := nameservers
slices.Sort(ns)
@@ -842,7 +842,7 @@ func (p *prog) dnsWatchdog(iface *net.Interface, nameservers []string) {
case <-p.dnsWatcherStopCh:
return
case <-p.stopCh:
p.Debug().Msg("stop dns watchdog")
p.Debug().Msg("Stop dns watchdog")
return
case <-ticker.C:
if p.recoveryRunning.Load() {
@@ -854,7 +854,7 @@ func (p *prog) dnsWatchdog(iface *net.Interface, nameservers []string) {
// currentStaticDNS is an OS-dependent helper that returns the current static DNS.
staticDNS, err := currentStaticDNS(iface)
if err != nil {
p.Debug().Err(err).Msgf("failed to get static DNS for interface %s", iface.Name)
p.Debug().Err(err).Msgf("Failed to get static DNS for interface %s", iface.Name)
} else if len(staticDNS) > 0 {
//filter out loopback addresses
staticDNS = slices.DeleteFunc(staticDNS, func(s string) bool {
@@ -864,12 +864,12 @@ func (p *prog) dnsWatchdog(iface *net.Interface, nameservers []string) {
if len(staticDNS) > 0 && len(ctrld.SavedStaticNameservers(iface)) == 0 {
// Save these static DNS values so that they can be restored later.
if err := saveCurrentStaticDNS(iface); err != nil {
p.Debug().Err(err).Msgf("failed to save static DNS for interface %s", iface.Name)
p.Debug().Err(err).Msgf("Failed to save static DNS for interface %s", iface.Name)
}
}
}
if err := setDNS(iface, ns); err != nil {
p.Error().Err(err).Str("iface", iface.Name).Msgf("could not re-apply DNS settings")
p.Error().Err(err).Str("iface", iface.Name).Msgf("Could not re-apply DNS settings")
}
}
if p.requiredMultiNICsConfig {
@@ -884,7 +884,7 @@ func (p *prog) dnsWatchdog(iface *net.Interface, nameservers []string) {
// currentStaticDNS is an OS-dependent helper that returns the current static DNS.
staticDNS, err := currentStaticDNS(i)
if err != nil {
p.Debug().Err(err).Msgf("failed to get static DNS for interface %s", i.Name)
p.Debug().Err(err).Msgf("Failed to get static DNS for interface %s", i.Name)
} else if len(staticDNS) > 0 {
//filter out loopback addresses
staticDNS = slices.DeleteFunc(staticDNS, func(s string) bool {
@@ -894,15 +894,15 @@ func (p *prog) dnsWatchdog(iface *net.Interface, nameservers []string) {
if len(staticDNS) > 0 && len(ctrld.SavedStaticNameservers(i)) == 0 {
// Save these static DNS values so that they can be restored later.
if err := saveCurrentStaticDNS(i); err != nil {
p.Debug().Err(err).Msgf("failed to save static DNS for interface %s", i.Name)
p.Debug().Err(err).Msgf("Failed to save static DNS for interface %s", i.Name)
}
}
}
if err := setDnsIgnoreUnusableInterface(i, nameservers); err != nil {
p.Error().Err(err).Str("iface", i.Name).Msgf("could not re-apply DNS settings")
p.Error().Err(err).Str("iface", i.Name).Msgf("Could not re-apply DNS settings")
} else {
p.Debug().Msgf("re-applying DNS for interface %q successfully", i.Name)
p.Debug().Msgf("Re-applying DNS for interface %q successfully", i.Name)
}
}
return nil
@@ -932,18 +932,18 @@ func (p *prog) resetDNS(isStart bool, restoreStatic bool) {
// Otherwise, we restore the saved configuration (if any) or reset to DHCP.
func (p *prog) resetDNSForRunningIface(isStart bool, restoreStatic bool) (runningIface *net.Interface) {
if p.runningIface == "" {
p.Debug().Msg("no running interface, skipping resetDNS")
p.Debug().Msg("No running interface, skipping resetDNS")
return
}
logger := p.logger.Load().With().Str("iface", p.runningIface)
netIface, err := netInterface(p.runningIface)
if err != nil {
logger.Error().Err(err).Msg("could not get interface")
logger.Error().Err(err).Msg("Could not get interface")
return
}
runningIface = netIface
if err := p.restoreNetworkManager(); err != nil {
logger.Error().Err(err).Msg("could not restore NetworkManager")
logger.Error().Err(err).Msg("Could not restore NetworkManager")
return
}
@@ -951,7 +951,7 @@ func (p *prog) resetDNSForRunningIface(isStart bool, restoreStatic bool) (runnin
if isStart {
current, err := currentStaticDNS(netIface)
if err != nil {
logger.Warn().Err(err).Msg("unable to obtain current static DNS configuration; proceeding to restore saved config")
logger.Warn().Err(err).Msg("Unable to obtain current static DNS configuration; proceeding to restore saved config")
} else if len(current) > 0 {
// If any static DNS value is not our own listener, assume an admin override.
hasManualConfig := false
@@ -973,13 +973,13 @@ func (p *prog) resetDNSForRunningIface(isStart bool, restoreStatic bool) (runnin
if len(saved) > 0 && restoreStatic {
logger.Debug().Msgf("Restoring interface %q from saved static config: %v", netIface.Name, saved)
if err := setDNS(netIface, saved); err != nil {
logger.Error().Err(err).Msgf("failed to restore static DNS config on interface %q", netIface.Name)
logger.Error().Err(err).Msgf("Failed to restore static DNS config on interface %q", netIface.Name)
return
}
} else {
logger.Debug().Msgf("No saved static DNS config for interface %q; resetting to DHCP", netIface.Name)
if err := resetDNS(netIface); err != nil {
logger.Error().Err(err).Msgf("failed to reset DNS to DHCP on interface %q", netIface.Name)
logger.Error().Err(err).Msgf("Failed to reset DNS to DHCP on interface %q", netIface.Name)
return
}
}
@@ -990,11 +990,11 @@ func (p *prog) logInterfacesState() {
withEachPhysicalInterfaces("", "", func(i *net.Interface) error {
addrs, err := i.Addrs()
if err != nil {
p.Warn().Str("interface", i.Name).Err(err).Msg("failed to get addresses")
p.Warn().Str("interface", i.Name).Err(err).Msg("Failed to get addresses")
}
nss, err := currentStaticDNS(i)
if err != nil {
p.Warn().Str("interface", i.Name).Err(err).Msg("failed to get DNS")
p.Warn().Str("interface", i.Name).Err(err).Msg("Failed to get DNS")
}
if len(nss) == 0 {
nss = currentDNS(i)
@@ -1063,7 +1063,7 @@ func (p *prog) findWorkingInterface() string {
// Get all interfaces
ifaces, err := net.Interfaces()
if err != nil {
p.Error().Err(err).Msg("failed to list network interfaces")
p.Error().Err(err).Msg("Failed to list network interfaces")
return currentIface // Return current interface as fallback
}
@@ -1132,7 +1132,7 @@ func (p *prog) findWorkingInterface() string {
// 3. Fall back to current interface if nothing else works
p.Warn().
Str("current_iface", currentIface).
Msg("no working physical interface found, keeping current")
Msg("No working physical interface found, keeping current")
return currentIface
}
@@ -1152,19 +1152,19 @@ func randomPort() int {
func runLogServer(sockPath string) net.Conn {
addr, err := net.ResolveUnixAddr("unix", sockPath)
if err != nil {
mainLog.Load().Warn().Err(err).Msg("invalid log sock path")
mainLog.Load().Warn().Err(err).Msg("Invalid log sock path")
return nil
}
ln, err := net.ListenUnix("unix", addr)
if err != nil {
mainLog.Load().Warn().Err(err).Msg("could not listen log socket")
mainLog.Load().Warn().Err(err).Msg("Could not listen log socket")
return nil
}
defer ln.Close()
server, err := ln.Accept()
if err != nil {
mainLog.Load().Warn().Err(err).Msg("could not accept connection")
mainLog.Load().Warn().Err(err).Msg("Could not accept connection")
return nil
}
return server
@@ -1261,9 +1261,9 @@ func (p *prog) defaultRouteIP() string {
if err != nil {
return ""
}
p.Debug().Str("iface", drNetIface.Name).Msg("checking default route interface")
p.Debug().Str("iface", drNetIface.Name).Msg("Checking default route interface")
if ip := ifaceFirstPrivateIP(drNetIface); ip != "" {
p.Debug().Str("ip", ip).Msg("found ip with default route interface")
p.Debug().Str("ip", ip).Msg("Found ip with default route interface")
return ip
}
@@ -1288,7 +1288,7 @@ func (p *prog) defaultRouteIP() string {
})
if len(addrs) == 0 {
p.Warn().Msg("no default route IP found")
p.Warn().Msg("No default route IP found")
return ""
}
sort.Slice(addrs, func(i, j int) bool {
@@ -1296,7 +1296,7 @@ func (p *prog) defaultRouteIP() string {
})
ip := addrs[0].String()
p.Debug().Str("ip", ip).Msg("found LAN interface IP")
p.Debug().Str("ip", ip).Msg("Found LAN interface IP")
return ip
}
@@ -1324,7 +1324,7 @@ func withEachPhysicalInterfaces(excludeIfaceName, contextStr string, f func(i *n
}
netIface := i.Interface
if patched, err := patchNetIfaceName(netIface); err != nil {
mainLog.Load().Debug().Err(err).Msg("failed to patch net interface name")
mainLog.Load().Debug().Err(err).Msg("Failed to patch net interface name")
return
} else if !patched {
// The interface is not functional, skipping.
@@ -1361,7 +1361,7 @@ var errSaveCurrentStaticDNSNotSupported = errors.New("saving current DNS is not
// Only works on Windows and Mac.
func saveCurrentStaticDNS(iface *net.Interface) error {
if iface == nil {
mainLog.Load().Debug().Msg("could not save current static DNS settings for nil interface")
mainLog.Load().Debug().Msg("Could not save current static DNS settings for nil interface")
return nil
}
switch runtime.GOOS {
@@ -1372,11 +1372,11 @@ func saveCurrentStaticDNS(iface *net.Interface) error {
file := ctrld.SavedStaticDnsSettingsFilePath(iface)
ns, err := currentStaticDNS(iface)
if err != nil {
mainLog.Load().Warn().Err(err).Msgf("could not get current static DNS settings for %q", iface.Name)
mainLog.Load().Warn().Err(err).Msgf("Could not get current static DNS settings for %q", iface.Name)
return err
}
if len(ns) == 0 {
mainLog.Load().Debug().Msgf("no static DNS settings for %q, removing old static DNS settings file", iface.Name)
mainLog.Load().Debug().Msgf("No static DNS settings for %q, removing old static DNS settings file", iface.Name)
_ = os.Remove(file) // removing old static DNS settings
return nil
}
@@ -1391,15 +1391,15 @@ func saveCurrentStaticDNS(iface *net.Interface) error {
return nil
}
if err := os.Remove(file); err != nil && !errors.Is(err, fs.ErrNotExist) {
mainLog.Load().Warn().Err(err).Msgf("could not remove old static DNS settings file: %s", file)
mainLog.Load().Warn().Err(err).Msgf("Could not remove old static DNS settings file: %s", file)
}
nss := strings.Join(ns, ",")
mainLog.Load().Debug().Msgf("DNS settings for %q is static: %v, saving ...", iface.Name, nss)
if err := os.WriteFile(file, []byte(nss), 0600); err != nil {
mainLog.Load().Err(err).Msgf("could not save DNS settings for iface: %s", iface.Name)
mainLog.Load().Err(err).Msgf("Could not save DNS settings for iface: %s", iface.Name)
return err
}
mainLog.Load().Debug().Msgf("save DNS settings for interface %q successfully", iface.Name)
mainLog.Load().Debug().Msgf("Save DNS settings for interface %q successfully", iface.Name)
return nil
}
@@ -1414,7 +1414,7 @@ func (p *prog) dnsChanged(iface *net.Interface, nameservers []string) bool {
curNameservers, _ := currentStaticDNS(iface)
slices.Sort(curNameservers)
if !slices.Equal(curNameservers, nameservers) {
p.Debug().Msgf("interface %q current DNS settings: %v, expected: %v", iface.Name, curNameservers, nameservers)
p.Debug().Msgf("Interface %q current DNS settings: %v, expected: %v", iface.Name, curNameservers, nameservers)
return true
}
return false
@@ -1438,7 +1438,7 @@ func selfUninstallCheck(uninstallErr error, p *prog, logger *ctrld.Logger) {
// Returns true if upgrade is allowed, false otherwise.
func shouldUpgrade(vt string, cv *semver.Version, logger *ctrld.Logger) bool {
if vt == "" {
logger.Debug().Msg("no version target set, skipped checking self-upgrade")
logger.Debug().Msg("No version target set, skipped checking self-upgrade")
return false
}
vts := vt
@@ -1447,7 +1447,7 @@ func shouldUpgrade(vt string, cv *semver.Version, logger *ctrld.Logger) bool {
}
targetVer, err := semver.NewVersion(vts)
if err != nil {
logger.Warn().Err(err).Msgf("invalid target version, skipped self-upgrade: %s", vt)
logger.Warn().Err(err).Msgf("Invalid target version, skipped self-upgrade: %s", vt)
return false
}
@@ -1456,7 +1456,7 @@ func shouldUpgrade(vt string, cv *semver.Version, logger *ctrld.Logger) bool {
logger.Warn().
Str("target", vt).
Str("current", cv.String()).
Msgf("major version upgrade not allowed (target: %d, current: %d), skipped self-upgrade", targetVer.Major(), cv.Major())
Msgf("Major version upgrade not allowed (target: %d, current: %d), skipped self-upgrade", targetVer.Major(), cv.Major())
return false
}
@@ -1464,7 +1464,7 @@ func shouldUpgrade(vt string, cv *semver.Version, logger *ctrld.Logger) bool {
logger.Debug().
Str("target", vt).
Str("current", cv.String()).
Msgf("target version is not greater than current one, skipped self-upgrade")
Msgf("Target version is not greater than current one, skipped self-upgrade")
return false
}
@@ -1476,16 +1476,16 @@ func shouldUpgrade(vt string, cv *semver.Version, logger *ctrld.Logger) bool {
func performUpgrade(vt string, logger *ctrld.Logger) bool {
exe, err := os.Executable()
if err != nil {
logger.Error().Err(err).Msg("failed to get executable path, skipped self-upgrade")
logger.Error().Err(err).Msg("Failed to get executable path, skipped self-upgrade")
return false
}
cmd := exec.Command(exe, "upgrade", "prod", "-vv")
cmd.SysProcAttr = sysProcAttrForDetachedChildProcess()
if err := cmd.Start(); err != nil {
logger.Error().Err(err).Msg("failed to start self-upgrade")
logger.Error().Err(err).Msg("Failed to start self-upgrade")
return false
}
mainLog.Load().Debug().Msgf("self-upgrade triggered, version target: %s", vt)
logger.Debug().Msgf("Self-upgrade triggered, version target: %s", vt)
return true
}
cmd/cli/resolvconf.go
+9 -9
View File
@@ -28,10 +28,10 @@ func (p *prog) watchResolvConf(iface *net.Interface, ns []netip.Addr, setDnsFn f
if rp, _ := filepath.EvalSymlinks(resolvConfPath); rp != "" {
resolvConfPath = rp
}
p.Debug().Msgf("start watching %s file", resolvConfPath)
p.Debug().Msgf("Start watching %s file", resolvConfPath)
watcher, err := fsnotify.NewWatcher()
if err != nil {
p.Warn().Err(err).Msg("could not create watcher for /etc/resolv.conf")
p.Warn().Err(err).Msg("Could not create watcher for /etc/resolv.conf")
return
}
defer watcher.Close()
@@ -41,7 +41,7 @@ func (p *prog) watchResolvConf(iface *net.Interface, ns []netip.Addr, setDnsFn f
// This is necessary because some systems don't properly notify on file changes
watchDir := filepath.Dir(resolvConfPath)
if err := watcher.Add(watchDir); err != nil {
p.Warn().Err(err).Msgf("could not add %s to watcher list", watchDir)
p.Warn().Err(err).Msgf("Could not add %s to watcher list", watchDir)
return
}
@@ -50,7 +50,7 @@ func (p *prog) watchResolvConf(iface *net.Interface, ns []netip.Addr, setDnsFn f
case <-p.dnsWatcherStopCh:
return
case <-p.stopCh:
p.Debug().Msgf("stopping watcher for %s", resolvConfPath)
p.Debug().Msgf("Stopping watcher for %s", resolvConfPath)
return
case event, ok := <-watcher.Events:
if p.recoveryRunning.Load() {
@@ -79,7 +79,7 @@ func (p *prog) watchResolvConf(iface *net.Interface, ns []netip.Addr, setDnsFn f
for retry := 0; retry < maxRetries; retry++ {
foundNS, err = p.parseResolvConfNameservers(resolvConfPath)
if err != nil {
p.Error().Err(err).Msg("failed to read resolv.conf content")
p.Error().Err(err).Msg("Failed to read resolv.conf content")
break
}
@@ -128,16 +128,16 @@ func (p *prog) watchResolvConf(iface *net.Interface, ns []netip.Addr, setDnsFn f
// Only revert if the nameservers don't match
if !matches {
if err := watcher.Remove(watchDir); err != nil {
p.Error().Err(err).Msg("failed to pause watcher")
p.Error().Err(err).Msg("Failed to pause watcher")
continue
}
if err := setDnsFn(iface, ns); err != nil {
p.Error().Err(err).Msg("failed to revert /etc/resolv.conf changes")
p.Error().Err(err).Msg("Failed to revert /etc/resolv.conf changes")
}
if err := watcher.Add(watchDir); err != nil {
p.Error().Err(err).Msg("failed to continue running watcher")
p.Error().Err(err).Msg("Failed to continue running watcher")
return
}
}
@@ -147,7 +147,7 @@ func (p *prog) watchResolvConf(iface *net.Interface, ns []netip.Addr, setDnsFn f
if !ok {
return
}
p.Error().Err(err).Msg("could not get event for /etc/resolv.conf")
p.Error().Err(err).Msg("Could not get event for /etc/resolv.conf")
}
}
}
cmd/cli/resolvconf_not_darwin_unix.go
+1 -1
View File
@@ -27,7 +27,7 @@ func (p *prog) setResolvConf(iface *net.Interface, ns []netip.Addr) error {
if sds, err := searchDomains(); err == nil {
oc.SearchDomains = sds
} else {
p.Debug().Err(err).Msg("failed to get search domains list when reverting resolv.conf file")
p.Debug().Err(err).Msg("Failed to get search domains list when reverting resolv.conf file")
}
return r.SetDNS(oc)
}
cmd/cli/search_domains_windows.go
+1 -1
View File
@@ -33,7 +33,7 @@ func searchDomains() ([]dnsname.FQDN, error) {
for a := aa.FirstDNSSuffix; a != nil; a = a.Next {
d, err := dnsname.ToFQDN(a.String())
if err != nil {
mainLog.Load().Debug().Err(err).Msgf("failed to parse domain: %s", a.String())
mainLog.Load().Debug().Err(err).Msgf("Failed to parse domain: %s", a.String())
continue
}
sds = append(sds, d)
cmd/cli/self_kill_others.go
+1 -1
View File
@@ -11,7 +11,7 @@ import (
// selfUninstall performs self-uninstallation on non-Unix platforms
func selfUninstall(p *prog, logger *ctrld.Logger) {
if uninstallInvalidCdUID(p, logger, false) {
logger.Warn().Msgf("service was uninstalled because device %q does not exist", cdUID)
logger.Warn().Msgf("Service was uninstalled because device %q does not exist", cdUID)
os.Exit(0)
}
}
cmd/cli/self_kill_unix.go
+4 -4
View File
@@ -20,7 +20,7 @@ func selfUninstall(p *prog, logger *ctrld.Logger) {
bin, err := os.Executable()
if err != nil {
logger.Fatal().Err(err).Msg("could not determine executable")
logger.Fatal().Err(err).Msg("Could not determine executable")
}
args := []string{"uninstall"}
if deactivationPinSet() {
@@ -29,11 +29,11 @@ func selfUninstall(p *prog, logger *ctrld.Logger) {
cmd := exec.Command(bin, args...)
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
if err := cmd.Start(); err != nil {
logger.Fatal().Err(err).Msg("could not start self uninstall command")
logger.Fatal().Err(err).Msg("Could not start self uninstall command")
}
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
logger.Warn().Msgf("service was uninstalled because device %q does not exist", cdUID)
logger.Warn().Msgf("Service was uninstalled because device %q does not exist", cdUID)
_ = cmd.Wait()
os.Exit(0)
}
@@ -41,7 +41,7 @@ func selfUninstall(p *prog, logger *ctrld.Logger) {
// selfUninstallLinux performs self-uninstallation on Linux platforms
func selfUninstallLinux(p *prog, logger *ctrld.Logger) {
if uninstallInvalidCdUID(p, logger, true) {
logger.Warn().Msgf("service was uninstalled because device %q does not exist", cdUID)
logger.Warn().Msgf("Service was uninstalled because device %q does not exist", cdUID)
os.Exit(0)
}
}
cmd/cli/service.go
+5 -5
View File
@@ -115,7 +115,7 @@ func (s *systemd) Start() error {
if out, err := exec.Command("systemctl", "daemon-reload").CombinedOutput(); err != nil {
return fmt.Errorf("systemctl daemon-reload failed: %w\n%s", err, string(out))
}
mainLog.Load().Debug().Msg("set KillMode=process successfully")
mainLog.Load().Debug().Msg("Set KillMode=process successfully")
}
return s.Service.Start()
}
@@ -125,7 +125,7 @@ func (s *systemd) Start() error {
func ensureSystemdKillMode(r io.Reader) (opts []*unit.UnitOption, change bool) {
opts, err := unit.DeserializeOptions(r)
if err != nil {
mainLog.Load().Error().Err(err).Msg("failed to deserialize options")
mainLog.Load().Error().Err(err).Msg("Failed to deserialize options")
return
}
change = true
@@ -185,13 +185,13 @@ func doTasks(tasks []task) bool {
mainLog.Load().Debug().Msgf("Running task %s", task.Name)
if err := task.f(); err != nil {
if task.abortOnError {
mainLog.Load().Error().Msgf("error running task %s: %v", task.Name, err)
mainLog.Load().Error().Msgf("Error running task %s: %v", task.Name, err)
return false
}
// if this is darwin stop command, dont print debug
// since launchctl complains on every start
if runtime.GOOS != "darwin" || task.Name != "Stop" {
mainLog.Load().Debug().Msgf("error running task %s: %v", task.Name, err)
mainLog.Load().Debug().Msgf("Error running task %s: %v", task.Name, err)
}
}
}
@@ -202,7 +202,7 @@ func doTasks(tasks []task) bool {
func checkHasElevatedPrivilege() {
ok, err := hasElevatedPrivilege()
if err != nil {
mainLog.Load().Error().Msgf("could not detect user privilege: %v", err)
mainLog.Load().Error().Msgf("Could not detect user privilege: %v", err)
return
}
if !ok {
cmd/cli/upstream_monitor.go
+4 -4
View File
@@ -57,7 +57,7 @@ func (um *upstreamMonitor) increaseFailureCount(upstream string) {
defer um.mu.Unlock()
if um.recovered[upstream] {
um.logger.Load().Debug().Msgf("upstream %q is recovered, skipping failure count increase", upstream)
um.logger.Load().Debug().Msgf("Upstream %q is recovered, skipping failure count increase", upstream)
return
}
@@ -65,7 +65,7 @@ func (um *upstreamMonitor) increaseFailureCount(upstream string) {
failedCount := um.failureReq[upstream]
// Log the updated failure count.
um.logger.Load().Debug().Msgf("upstream %q failure count updated to %d", upstream, failedCount)
um.logger.Load().Debug().Msgf("Upstream %q failure count updated to %d", upstream, failedCount)
// If this is the first failure and no timer is running, start a 10-second timer.
if failedCount == 1 && !um.failureTimerActive[upstream] {
@@ -78,7 +78,7 @@ func (um *upstreamMonitor) increaseFailureCount(upstream string) {
// and the upstream is not in a recovered state, mark it as down.
if um.failureReq[upstream] > 0 && !um.recovered[upstream] {
um.down[upstream] = true
um.logger.Load().Warn().Msgf("upstream %q marked as down after 10 seconds (failure count: %d)", upstream, um.failureReq[upstream])
um.logger.Load().Warn().Msgf("Upstream %q marked as down after 10 seconds (failure count: %d)", upstream, um.failureReq[upstream])
}
// Reset the timer flag so that a new timer can be spawned if needed.
um.failureTimerActive[upstream] = false
@@ -88,7 +88,7 @@ func (um *upstreamMonitor) increaseFailureCount(upstream string) {
// If the failure count quickly reaches the threshold, mark the upstream as down immediately.
if failedCount >= maxFailureRequest {
um.down[upstream] = true
um.logger.Load().Warn().Msgf("upstream %q marked as down immediately (failure count: %d)", upstream, failedCount)
um.logger.Load().Warn().Msgf("Upstream %q marked as down immediately (failure count: %d)", upstream, failedCount)
}
}
config.go
+12 -11
View File
@@ -114,8 +114,9 @@ func SetConfigNameWithPath(v *viper.Viper, name, configPath string) {
// InitConfig initializes default config values for given *viper.Viper instance.
func InitConfig(v *viper.Viper, name string) {
logger := LoggerFromCtx(context.Background())
Log(context.Background(), logger.Debug(), "Config initialization started")
ctx := context.Background()
logger := LoggerFromCtx(ctx)
Log(ctx, logger.Debug(), "Config initialization started")
v.SetDefault("listener", map[string]*ListenerConfig{
"0": {
@@ -156,7 +157,7 @@ func InitConfig(v *viper.Viper, name string) {
},
})
Log(context.Background(), logger.Debug(), "Config initialization completed")
Log(ctx, logger.Debug(), "Config initialization completed")
}
// Config represents ctrld supported configuration.
@@ -333,7 +334,7 @@ type Rule map[string][]string
func (uc *UpstreamConfig) Init(ctx context.Context) {
logger := LoggerFromCtx(ctx)
if err := uc.initDnsStamps(); err != nil {
logger.Fatal().Err(err).Msg("invalid DNS Stamps")
logger.Fatal().Err(err).Msg("Invalid dns stamps")
}
uc.initDoHScheme()
uc.uid = upstreamUID(ctx)
@@ -469,7 +470,7 @@ func (uc *UpstreamConfig) SetupBootstrapIP(ctx context.Context) {
uc.bootstrapIPs = uc.bootstrapIPs[:n]
if len(uc.bootstrapIPs) == 0 {
uc.bootstrapIPs = bootstrapIPsFromControlDDomain(uc.Domain)
logger.Warn().Msgf("No record found for %q, lookup from direct IP table", uc.Domain)
logger.Warn().Msgf("No record found for %q, lookup from direct ip table", uc.Domain)
}
}
if len(uc.bootstrapIPs) == 0 {
@@ -480,7 +481,7 @@ func (uc *UpstreamConfig) SetupBootstrapIP(ctx context.Context) {
if len(uc.bootstrapIPs) > 0 {
break
}
logger.Warn().Msg("Could not resolve bootstrap IPs, retrying...")
logger.Warn().Msg("Could not resolve bootstrap ips, retrying...")
b.BackOff(context.Background(), errors.New("no bootstrap IPs"))
}
for _, ip := range uc.bootstrapIPs {
@@ -490,7 +491,7 @@ func (uc *UpstreamConfig) SetupBootstrapIP(ctx context.Context) {
uc.bootstrapIPs4 = append(uc.bootstrapIPs4, ip)
}
}
logger.Debug().Msgf("Bootstrap IPs: %v", uc.bootstrapIPs)
logger.Debug().Msgf("Bootstrap ips: %v", uc.bootstrapIPs)
Log(ctx, logger.Debug(), "Bootstrap IP setup completed for upstream: %s", uc.Name)
}
@@ -566,7 +567,7 @@ func (uc *UpstreamConfig) newDOHTransport(ctx context.Context, addrs []string) *
if uc.BootstrapIP != "" {
dialer := net.Dialer{Timeout: dialerTimeout, KeepAlive: dialerTimeout}
addr := net.JoinHostPort(uc.BootstrapIP, port)
Log(ctx, logger.Debug(), "sending doh request to: %s", addr)
Log(ctx, logger.Debug(), "Sending doh request to: %s", addr)
return dialer.DialContext(ctx, network, addr)
}
pd := &ctrldnet.ParallelDialer{}
@@ -580,7 +581,7 @@ func (uc *UpstreamConfig) newDOHTransport(ctx context.Context, addrs []string) *
if err != nil {
return nil, err
}
Log(ctx, logger.Debug(), "sending doh request to: %s", conn.RemoteAddr())
Log(ctx, logger.Debug(), "Sending doh request to: %s", conn.RemoteAddr())
return conn, nil
}
runtime.SetFinalizer(transport, func(transport *http.Transport) {
@@ -593,7 +594,7 @@ func (uc *UpstreamConfig) newDOHTransport(ctx context.Context, addrs []string) *
func (uc *UpstreamConfig) Ping(ctx context.Context) {
if err := uc.ping(ctx); err != nil {
logger := LoggerFromCtx(ctx)
logger.Debug().Err(err).Msgf("upstream ping failed: %s", uc.Endpoint)
logger.Debug().Err(err).Msgf("Upstream ping failed: %s", uc.Endpoint)
_ = uc.FallbackToDirectIP(ctx)
}
}
@@ -973,7 +974,7 @@ func upstreamUID(ctx context.Context) string {
b := make([]byte, 4)
for {
if _, err := crand.Read(b); err != nil {
logger.Warn().Err(err).Msg("could not generate uid for upstream, retrying...")
logger.Warn().Err(err).Msg("Could not generate uid for upstream, retrying...")
continue
}
return hex.EncodeToString(b)
config_quic.go
+2 -2
View File
@@ -42,7 +42,7 @@ func (uc *UpstreamConfig) newDOH3Transport(ctx context.Context, addrs []string)
// if we have a bootstrap ip set, use it to avoid DNS lookup
if uc.BootstrapIP != "" {
addr = net.JoinHostPort(uc.BootstrapIP, port)
Log(ctx, logger.Debug(), "sending doh3 request to: %s", addr)
Log(ctx, logger.Debug(), "Sending doh3 request to: %s", addr)
udpConn, err := net.ListenUDP("udp", nil)
if err != nil {
return nil, err
@@ -62,7 +62,7 @@ func (uc *UpstreamConfig) newDOH3Transport(ctx context.Context, addrs []string)
if err != nil {
return nil, err
}
Log(ctx, logger.Debug(), "sending doh3 request to: %s", conn.RemoteAddr())
Log(ctx, logger.Debug(), "Sending doh3 request to: %s", conn.RemoteAddr())
return conn, err
}
runtime.SetFinalizer(rt, func(rt *http3.Transport) {
internal/clientinfo/client_info.go
+14 -14
View File
@@ -196,14 +196,14 @@ func (t *Table) initSelfDiscover() {
func (t *Table) init() {
// Custom client ID presents, use it as the only source.
if _, clientID := controld.ParseRawUID(t.cdUID); clientID != "" {
t.logger.Debug().Msg("start self discovery with custom client id")
t.logger.Debug().Msg("Start self discovery with custom client id")
t.initSelfDiscover()
return
}
// If we are running on platforms that should only do self discover, use it as the only source, too.
if ctrld.SelfDiscover() {
t.logger.Debug().Msg("start self discovery on desktop platforms")
t.logger.Debug().Msg("Start self discovery on desktop platforms")
t.initSelfDiscover()
return
}
@@ -211,9 +211,9 @@ func (t *Table) init() {
// Hosts file mapping.
if t.discoverHosts() {
t.hf = &hostsFile{logger: t.logger}
t.logger.Debug().Msg("start hosts file discovery")
t.logger.Debug().Msg("Start hosts file discovery")
if err := t.hf.init(); err != nil {
t.logger.Error().Err(err).Msg("could not init hosts file discover")
t.logger.Error().Err(err).Msg("Could not init hosts file discover")
} else {
t.hostnameResolvers = append(t.hostnameResolvers, t.hf)
t.refreshers = append(t.refreshers, t.hf)
@@ -223,9 +223,9 @@ func (t *Table) init() {
// DHCP lease files.
if t.discoverDHCP() {
t.dhcp = &dhcp{selfIP: t.selfIP, logger: t.logger}
t.logger.Debug().Msg("start dhcp discovery")
t.logger.Debug().Msg("Start dhcp discovery")
if err := t.dhcp.init(); err != nil {
t.logger.Error().Err(err).Msg("could not init DHCP discover")
t.logger.Error().Err(err).Msg("Could not init dhcp discover")
} else {
t.ipResolvers = append(t.ipResolvers, t.dhcp)
t.macResolvers = append(t.macResolvers, t.dhcp)
@@ -237,7 +237,7 @@ func (t *Table) init() {
if t.discoverARP() {
t.arp = &arpDiscover{}
t.ndp = &ndpDiscover{logger: t.logger}
t.logger.Debug().Msg("start arp discovery")
t.logger.Debug().Msg("Start arp discovery")
discovers := map[string]interface {
refresher
IpResolver
@@ -249,7 +249,7 @@ func (t *Table) init() {
for protocol, discover := range discovers {
if err := discover.refresh(); err != nil {
t.logger.Error().Err(err).Msgf("could not init %s discover", protocol)
t.logger.Error().Err(err).Msgf("Could not init %s discover", protocol)
} else {
t.ipResolvers = append(t.ipResolvers, discover)
t.macResolvers = append(t.macResolvers, discover)
@@ -282,18 +282,18 @@ func (t *Table) init() {
if _, portErr := strconv.Atoi(port); portErr == nil && port != "0" && net.ParseIP(host) != nil {
nss = append(nss, net.JoinHostPort(host, port))
} else {
t.logger.Warn().Msgf("ignoring invalid nameserver for ptr discover: %q", ns)
t.logger.Warn().Msgf("Ignoring invalid nameserver for ptr discover: %q", ns)
}
}
if len(nss) > 0 {
t.ptr.resolver = ctrld.NewResolverWithNameserver(nss)
t.logger.Debug().Msgf("using nameservers %v for ptr discovery", nss)
t.logger.Debug().Msgf("Using nameservers %v for ptr discovery", nss)
}
}
t.logger.Debug().Msg("start ptr discovery")
t.logger.Debug().Msg("Start ptr discovery")
if err := t.ptr.refresh(); err != nil {
t.logger.Error().Err(err).Msg("could not init PTR discover")
t.logger.Error().Err(err).Msg("Could not init ptr discover")
} else {
t.hostnameResolvers = append(t.hostnameResolvers, t.ptr)
t.refreshers = append(t.refreshers, t.ptr)
@@ -302,9 +302,9 @@ func (t *Table) init() {
// mdns.
if t.discoverMDNS() {
t.mdns = &mdns{logger: t.logger}
t.logger.Debug().Msg("start mdns discovery")
t.logger.Debug().Msg("Start mdns discovery")
if err := t.mdns.init(t.quitCh); err != nil {
t.logger.Error().Err(err).Msg("could not init mDNS discover")
t.logger.Error().Err(err).Msg("Could not init mdns discover")
} else {
t.hostnameResolvers = append(t.hostnameResolvers, t.mdns)
}
internal/clientinfo/dhcp.go
+7 -7
View File
@@ -55,7 +55,7 @@ func (d *dhcp) watchChanges() {
if event.Has(fsnotify.Create) {
if format, ok := clientInfoFiles[event.Name]; ok {
if err := d.addLeaseFile(event.Name, format); err != nil {
d.logger.Err(err).Str("file", event.Name).Msg("could not add lease file")
d.logger.Err(err).Str("file", event.Name).Msg("Could not add lease file")
}
}
continue
@@ -63,14 +63,14 @@ func (d *dhcp) watchChanges() {
if event.Has(fsnotify.Write) || event.Has(fsnotify.Rename) || event.Has(fsnotify.Chmod) || event.Has(fsnotify.Remove) {
format := clientInfoFiles[event.Name]
if err := d.readLeaseFile(event.Name, format); err != nil && !os.IsNotExist(err) {
d.logger.Err(err).Str("file", event.Name).Msg("leases file changed but failed to update client info")
d.logger.Err(err).Str("file", event.Name).Msg("Leases file changed but failed to update client info")
}
}
case err, ok := <-d.watcher.Errors:
if !ok {
return
}
d.logger.Err(err).Msg("could not watch client info file")
d.logger.Err(err).Msg("Could not watch client info file")
}
}
@@ -216,7 +216,7 @@ func (d *dhcp) dnsmasqReadClientInfoReader(reader io.Reader) error {
}
ip := normalizeIP(string(fields[2]))
if net.ParseIP(ip) == nil {
d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
d.logger.Warn().Msgf("Invalid ip address entry: %q", ip)
ip = ""
}
@@ -271,7 +271,7 @@ func (d *dhcp) iscDHCPReadClientInfoReader(reader io.Reader) error {
// DHCP lease files may contain mixed-case IP addresses
ip = normalizeIP(strings.ToLower(fields[1]))
if net.ParseIP(ip) == nil {
d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
d.logger.Warn().Msgf("Invalid ip address entry: %q", ip)
ip = ""
}
case "hardware":
@@ -328,7 +328,7 @@ func (d *dhcp) keaDhcp4ReadClientInfoReader(r io.Reader) error {
}
ip := normalizeIP(record[0])
if net.ParseIP(ip) == nil {
d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
d.logger.Warn().Msgf("Invalid ip address entry: %q", ip)
ip = ""
}
@@ -350,7 +350,7 @@ func (d *dhcp) keaDhcp4ReadClientInfoReader(r io.Reader) error {
func (d *dhcp) addSelf() {
hostname, err := os.Hostname()
if err != nil {
d.logger.Err(err).Msg("could not get hostname")
d.logger.Err(err).Msg("Could not get hostname")
return
}
hostname = normalizeHostname(hostname)
internal/clientinfo/hostsfile.go
+3 -3
View File
@@ -56,7 +56,7 @@ func (hf *hostsFile) refresh() error {
// override hosts file with host_entries.conf content if present.
hem, err := parseHostEntriesConf(hostEntriesConfPath)
if err != nil && !os.IsNotExist(err) {
hf.logger.Debug().Err(err).Msg("could not read host_entries.conf file")
hf.logger.Debug().Err(err).Msg("Could not read host_entries.conf file")
}
for k, v := range hem {
hf.m[k] = v
@@ -78,14 +78,14 @@ func (hf *hostsFile) watchChanges() {
}
if event.Has(fsnotify.Write) || event.Has(fsnotify.Rename) || event.Has(fsnotify.Chmod) || event.Has(fsnotify.Remove) {
if err := hf.refresh(); err != nil && !os.IsNotExist(err) {
hf.logger.Err(err).Msg("hosts file changed but failed to update client info")
hf.logger.Err(err).Msg("Hosts file changed but Failed to update client info")
}
}
case err, ok := <-hf.watcher.Errors:
if !ok {
return
}
hf.logger.Err(err).Msg("could not watch client info file")
hf.logger.Err(err).Msg("Could not watch client info file")
}
}
internal/clientinfo/mdns.go
+10 -10
View File
@@ -94,9 +94,9 @@ func (m *mdns) init(quitCh chan struct{}) error {
}
// Check if IPv6 is available once and use the result for the rest of the function.
m.logger.Debug().Msgf("checking for IPv6 availability in mdns init")
m.logger.Debug().Msgf("Checking for ipv6 availability in mdns init")
ipv6 := ctrldnet.IPv6Available(context.Background())
m.logger.Debug().Msgf("IPv6 is %v in mdns init", ipv6)
m.logger.Debug().Msgf("ipv6 is %v in mdns init", ipv6)
v4ConnList := make([]*net.UDPConn, 0, len(ifaces))
v6ConnList := make([]*net.UDPConn, 0, len(ifaces))
@@ -130,11 +130,11 @@ func (m *mdns) probeLoop(conns []*net.UDPConn, remoteAddr net.Addr, quitCh chan
for {
err := m.probe(conns, remoteAddr)
if shouldStopProbing(err) {
m.logger.Warn().Msgf("stop probing %q: %v", remoteAddr, err)
m.logger.Warn().Msgf("Stop probing %q: %v", remoteAddr, err)
break
}
if err != nil {
m.logger.Warn().Err(err).Msg("error while probing mdns")
m.logger.Warn().Err(err).Msg("Error while probing mdns")
bo.BackOff(context.Background(), errors.New("mdns probe backoff"))
continue
}
@@ -162,7 +162,7 @@ func (m *mdns) readLoop(conn *net.UDPConn) {
if errors.Is(err, net.ErrClosed) {
return
}
m.logger.Debug().Err(err).Msg("mdns readLoop error")
m.logger.Debug().Err(err).Msg("Mdns readLoop error")
return
}
@@ -185,11 +185,11 @@ func (m *mdns) readLoop(conn *net.UDPConn) {
if ip != "" && name != "" {
name = normalizeHostname(name)
if val, loaded := m.name.LoadOrStore(ip, name); !loaded {
m.logger.Debug().Msgf("found hostname: %q, ip: %q via mdns", name, ip)
m.logger.Debug().Msgf("Found hostname: %q, ip: %q via mdns", name, ip)
} else {
old := val.(string)
if old != name {
m.logger.Debug().Msgf("update hostname: %q, ip: %q, old: %q via mdns", name, ip, old)
m.logger.Debug().Msgf("Update hostname: %q, ip: %q, old: %q via mdns", name, ip, old)
m.name.Store(ip, name)
}
}
@@ -230,7 +230,7 @@ func (m *mdns) probe(conns []*net.UDPConn, remoteAddr net.Addr) error {
// getDataFromAvahiDaemonCache reads entries from avahi-daemon cache to update mdns data.
func (m *mdns) getDataFromAvahiDaemonCache() {
if _, err := exec.LookPath("avahi-browse"); err != nil {
m.logger.Debug().Err(err).Msg("could not find avahi-browse binary, skipping.")
m.logger.Debug().Err(err).Msg("Could not find avahi-browse binary, skipping.")
return
}
// Run avahi-browse to discover services from cache:
@@ -240,7 +240,7 @@ func (m *mdns) getDataFromAvahiDaemonCache() {
// - "-c" -> read from cache.
out, err := exec.Command("avahi-browse", "-a", "-r", "-p", "-c").Output()
if err != nil {
m.logger.Debug().Err(err).Msg("could not browse services from avahi cache")
m.logger.Debug().Err(err).Msg("Could not browse services from avahi cache")
return
}
m.storeDataFromAvahiBrowseOutput(bytes.NewReader(out))
@@ -260,7 +260,7 @@ func (m *mdns) storeDataFromAvahiBrowseOutput(r io.Reader) {
name := normalizeHostname(fields[6])
// Only using cache value if we don't have existed one.
if _, loaded := m.name.LoadOrStore(ip, name); !loaded {
m.logger.Debug().Msgf("found hostname: %q, ip: %q via avahi cache", name, ip)
m.logger.Debug().Msgf("Found hostname: %q, ip: %q via avahi cache", name, ip)
}
}
}
internal/clientinfo/ndp.go
+4 -4
View File
@@ -98,7 +98,7 @@ func (nd *ndpDiscover) saveInfo(ip, mac string) {
func (nd *ndpDiscover) listen(ctx context.Context) {
ifis, err := allInterfacesWithV6LinkLocal()
if err != nil {
nd.logger.Debug().Err(err).Msg("failed to find valid ipv6 interfaces")
nd.logger.Debug().Err(err).Msg("Failed to find valid ipv6 interfaces")
return
}
for _, ifi := range ifis {
@@ -111,11 +111,11 @@ func (nd *ndpDiscover) listen(ctx context.Context) {
func (nd *ndpDiscover) listenOnInterface(ctx context.Context, ifi *net.Interface) {
c, ip, err := ndp.Listen(ifi, ndp.Unspecified)
if err != nil {
nd.logger.Debug().Err(err).Msg("ndp listen failed")
nd.logger.Debug().Err(err).Msg("Ndp listen failed")
return
}
defer c.Close()
nd.logger.Debug().Msgf("listening ndp on: %s", ip.String())
nd.logger.Debug().Msgf("Listening ndp on: %s", ip.String())
for {
select {
case <-ctx.Done():
@@ -129,7 +129,7 @@ func (nd *ndpDiscover) listenOnInterface(ctx context.Context, ifi *net.Interface
if errors.As(readErr, &opErr) && (opErr.Timeout() || opErr.Temporary()) {
continue
}
nd.logger.Debug().Err(readErr).Msg("ndp read loop error")
nd.logger.Debug().Err(readErr).Msg("Ndp read loop error")
return
}
internal/clientinfo/ndp_linux.go
+4 -4
View File
@@ -11,7 +11,7 @@ import (
func (nd *ndpDiscover) scan() {
neighs, err := netlink.NeighList(0, netlink.FAMILY_V6)
if err != nil {
nd.logger.Warn().Err(err).Msg("could not get neigh list")
nd.logger.Warn().Err(err).Msg("Could not get neighbor list")
return
}
@@ -32,7 +32,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
done := make(chan struct{})
defer close(done)
if err := netlink.NeighSubscribe(ch, done); err != nil {
nd.logger.Err(err).Msg("could not perform neighbor subscribing")
nd.logger.Err(err).Msg("Could not perform neighbor subscribing")
return
}
for {
@@ -45,7 +45,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
}
ip := normalizeIP(nu.IP.String())
if nu.Type == unix.RTM_DELNEIGH {
nd.logger.Debug().Msgf("removing NDP neighbor: %s", ip)
nd.logger.Debug().Msgf("Removing ndp neighbor: %s", ip)
nd.mac.Delete(ip)
continue
}
@@ -54,7 +54,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
case netlink.NUD_REACHABLE:
nd.saveInfo(ip, mac)
case netlink.NUD_FAILED:
nd.logger.Debug().Msgf("removing NDP neighbor with failed state: %s", ip)
nd.logger.Debug().Msgf("Removing ndp neighbor with failed state: %s", ip)
nd.mac.Delete(ip)
}
}
internal/clientinfo/ndp_others.go
+2 -2
View File
@@ -15,14 +15,14 @@ func (nd *ndpDiscover) scan() {
case "windows":
data, err := exec.Command("netsh", "interface", "ipv6", "show", "neighbors").Output()
if err != nil {
nd.logger.Warn().Err(err).Msg("could not query ndp table")
nd.logger.Warn().Err(err).Msg("Could not query ndp table")
return
}
nd.scanWindows(bytes.NewReader(data))
default:
data, err := exec.Command("ndp", "-an").Output()
if err != nil {
nd.logger.Warn().Err(err).Msg("could not query ndp table")
nd.logger.Warn().Err(err).Msg("Could not query ndp table")
return
}
nd.scanUnix(bytes.NewReader(data))
internal/clientinfo/ptr_lookup.go
+2 -2
View File
@@ -74,14 +74,14 @@ func (p *ptrDiscover) lookupHostname(ip string) string {
msg := new(dns.Msg)
addr, err := dns.ReverseAddr(ip)
if err != nil {
p.logger.Info().Str("discovery", "ptr").Err(err).Msg("invalid ip address")
p.logger.Info().Str("discovery", "ptr").Err(err).Msg("Invalid ip address")
return ""
}
msg.SetQuestion(addr, dns.TypePTR)
ans, err := p.resolver.Resolve(ctx, msg)
if err != nil {
if p.serverDown.CompareAndSwap(false, true) {
p.logger.Info().Str("discovery", "ptr").Err(err).Msg("could not perform PTR lookup")
p.logger.Info().Str("discovery", "ptr").Err(err).Msg("Could not perform ptr lookup")
go p.checkServer()
}
return ""
internal/controld/config.go
+2 -2
View File
@@ -287,7 +287,7 @@ func apiTransport(loggerCtx context.Context, cdDev bool) *http.Transport {
ips := ctrld.LookupIP(loggerCtx, apiDomain)
if len(ips) == 0 {
logger := ctrld.LoggerFromCtx(loggerCtx)
logger.Warn().Msgf("No IPs found for %s, use direct IPs: %v", apiDomain, apiIPs)
logger.Warn().Msgf("No ips found for %s, use direct ips: %v", apiDomain, apiIPs)
ips = apiIPs
}
@@ -348,7 +348,7 @@ func doWithFallback(ctx context.Context, client *http.Client, req *http.Request,
resp, err := client.Do(req)
if err != nil {
logger := ctrld.LoggerFromCtx(ctx)
logger.Warn().Err(err).Msgf("failed to send request, fallback to direct IP: %s", apiIp)
logger.Warn().Err(err).Msgf("Failed to send request, fallback to direct ip: %s", apiIp)
ipReq := req.Clone(req.Context())
ipReq.Host = apiIp
ipReq.URL.Host = apiIp
internal/net/net.go
+4 -4
View File
@@ -180,16 +180,16 @@ func (d *ParallelDialer) DialContext(ctx context.Context, network string, addrs
for _, addr := range addrs {
go func(addr string) {
defer wg.Done()
logger.Debug("dialing to", zap.String("address", addr))
logger.Debug("Dialing to", zap.String("address", addr))
conn, err := d.Dialer.DialContext(ctx, network, addr)
if err != nil {
logger.Debug("failed to dial", zap.String("address", addr), zap.Error(err))
logger.Debug("Failed to dial", zap.String("address", addr), zap.Error(err))
}
select {
case ch <- &parallelDialerResult{conn: conn, err: err}:
case <-done:
if conn != nil {
logger.Debug("connection closed", zap.String("remote_address", conn.RemoteAddr().String()))
logger.Debug("Connection closed", zap.String("remote_address", conn.RemoteAddr().String()))
conn.Close()
}
}
@@ -200,7 +200,7 @@ func (d *ParallelDialer) DialContext(ctx context.Context, network string, addrs
for res := range ch {
if res.err == nil {
cancel()
logger.Debug("connected to", zap.String("remote_address", res.conn.RemoteAddr().String()))
logger.Debug("Connected to", zap.String("remote_address", res.conn.RemoteAddr().String()))
return res.conn, res.err
}
errs = append(errs, res.err)
nameservers_darwin.go
+3 -3
View File
@@ -41,7 +41,7 @@ func getDNSFromScutil(ctx context.Context) []string {
cmd := exec.Command("scutil", "--dns")
output, err := cmd.Output()
if err != nil {
Log(context.Background(), logger.Error(), "failed to execute scutil --dns (attempt %d/%d): %v", attempt+1, maxRetries, err)
Log(context.Background(), logger.Error(), "Failed to execute scutil --dns (attempt %d/%d): %v", attempt+1, maxRetries, err)
continue
}
@@ -75,7 +75,7 @@ func getDNSFromScutil(ctx context.Context) []string {
}
if err := scanner.Err(); err != nil {
Log(context.Background(), logger.Error(), "error scanning scutil output (attempt %d/%d): %v", attempt+1, maxRetries, err)
Log(context.Background(), logger.Error(), "Error scanning scutil output (attempt %d/%d): %v", attempt+1, maxRetries, err)
continue
}
@@ -172,7 +172,7 @@ func getAllDHCPNameservers(ctx context.Context) []string {
// if we have static DNS servers saved for the current default route, we should add them to the list
drIfaceName, err := netmon.DefaultRouteInterface()
Log(context.Background(), logger.Debug(), "checking for static DNS servers for default route interface: %s", drIfaceName)
Log(context.Background(), logger.Debug(), "Checking for static DNS servers for default route interface: %s", drIfaceName)
if err != nil {
Log(context.Background(), logger.Debug(),
"Failed to get default route interface: %v", err)
nameservers_windows.go
+8 -8
View File
@@ -281,7 +281,7 @@ func getDNSServers(ctx context.Context) ([]string, error) {
logger.Debug().Msgf("Failed to get interface by name %s: %v", drIfaceName, err)
} else {
staticNs, file := SavedStaticNameserversAndPath(drIface)
logger.Debug().Msgf("static dns servers from %s: %v", file, staticNs)
logger.Debug().Msgf("Static dns servers from %s: %v", file, staticNs)
if len(staticNs) > 0 {
logger.Debug().Msgf("Adding static DNS servers from %s: %v", drIfaceName, staticNs)
ns = append(ns, staticNs...)
@@ -392,20 +392,20 @@ func ValidInterfaces(ctx context.Context) map[string]struct{} {
defer instances.Close()
}
if err != nil {
logger.Warn().Msgf("failed to get wmi network adapter: %v", err)
logger.Warn().Msgf("Failed to get wmi network adapter: %v", err)
return nil
}
var adapters []string
for _, i := range instances {
adapter, err := netadapter.NewNetworkAdapter(i)
if err != nil {
logger.Warn().Msgf("failed to get network adapter: %v", err)
logger.Warn().Msgf("Failed to get network adapter: %v", err)
continue
}
name, err := adapter.GetPropertyName()
if err != nil {
logger.Warn().Msgf("failed to get interface name: %v", err)
logger.Warn().Msgf("Failed to get interface name: %v", err)
continue
}
@@ -415,11 +415,11 @@ func ValidInterfaces(ctx context.Context) map[string]struct{} {
// if this is a physical adapter or FALSE if this is not a physical adapter."
physical, err := adapter.GetPropertyConnectorPresent()
if err != nil {
logger.Debug().Msgf("failed to get network adapter connector present property: %v", err)
logger.Debug().Msgf("Failed to get network adapter connector present property: %v", err)
continue
}
if !physical {
logger.Debug().Msgf("skipping non-physical adapter: %s", name)
logger.Debug().Msgf("Skipping non-physical adapter: %s", name)
continue
}
@@ -427,11 +427,11 @@ func ValidInterfaces(ctx context.Context) map[string]struct{} {
// because some interfaces are not physical but have a connector.
hardware, err := adapter.GetPropertyHardwareInterface()
if err != nil {
logger.Debug().Msgf("failed to get network adapter hardware interface property: %v", err)
logger.Debug().Msgf("Failed to get network adapter hardware interface property: %v", err)
continue
}
if !hardware {
logger.Debug().Msgf("skipping non-hardware interface: %s", name)
logger.Debug().Msgf("Skipping non-hardware interface: %s", name)
continue
}
net.go
+4 -4
View File
@@ -20,7 +20,7 @@ var (
func HasIPv6(ctx context.Context) bool {
hasIPv6Once.Do(func() {
logger := LoggerFromCtx(ctx)
logger.Debug().Msg("checking for IPv6 availability once")
logger.Debug().Msg("Checking for ipv6 availability once")
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
val := ctrldnet.IPv6Available(ctx)
@@ -28,7 +28,7 @@ func HasIPv6(ctx context.Context) bool {
logger.Debug().Msgf("ipv6 availability: %v", val)
mon, err := netmon.New(func(format string, args ...any) {})
if err != nil {
logger.Debug().Err(err).Msg("failed to monitor IPv6 state")
logger.Debug().Err(err).Msg("Failed to monitor ipv6 state")
return
}
mon.RegisterChangeCallback(func(delta *netmon.ChangeDelta) {
@@ -37,7 +37,7 @@ func HasIPv6(ctx context.Context) bool {
if old != cur {
logger.Warn().Msgf("ipv6 availability changed, old: %v, new: %v", old, cur)
} else {
logger.Debug().Msg("ipv6 availability does not changed")
logger.Debug().Msg("ipv6 availability does not Changed")
}
ipv6Available.Store(cur)
})
@@ -50,6 +50,6 @@ func HasIPv6(ctx context.Context) bool {
func DisableIPv6(ctx context.Context) {
if ipv6Available.CompareAndSwap(true, false) {
logger := LoggerFromCtx(ctx)
logger.Debug().Msg("turned off IPv6 availability")
logger.Debug().Msg("Turned off ipv6 availability")
}
}
resolver.go
+12 -12
View File
@@ -427,7 +427,7 @@ func (o *osResolver) resolve(ctx context.Context, msg *dns.Msg) (*dns.Msg, error
switch {
case res.lan:
// Always prefer LAN responses immediately
Log(ctx, logger.Debug(), "using LAN answer from: %s", res.server)
Log(ctx, logger.Debug(), "Using LAN answer from: %s", res.server)
cancel()
logAnswer(res.server)
return res.answer, nil
@@ -437,7 +437,7 @@ func (o *osResolver) resolve(ctx context.Context, msg *dns.Msg) (*dns.Msg, error
// if there are no LAN nameservers, we should not wait
// just use the first response
if len(nss) == 0 {
Log(ctx, logger.Debug(), "using public answer from: %s", res.server)
Log(ctx, logger.Debug(), "Using public answer from: %s", res.server)
cancel()
logAnswer(res.server)
return res.answer, nil
@@ -448,12 +448,12 @@ func (o *osResolver) resolve(ctx context.Context, msg *dns.Msg) (*dns.Msg, error
})
}
case res.answer != nil:
Log(ctx, logger.Debug(), "got non-success answer from: %s with code: %d",
Log(ctx, logger.Debug(), "Got non-success answer from: %s with code: %d",
res.server, res.answer.Rcode)
// When there are no LAN nameservers, we should not wait
// for other nameservers to respond.
if len(nss) == 0 {
Log(ctx, logger.Debug(), "no lan nameservers using public non success answer")
Log(ctx, logger.Debug(), "No lan nameservers using public non success answer")
cancel()
logAnswer(res.server)
return res.answer, nil
@@ -466,17 +466,17 @@ func (o *osResolver) resolve(ctx context.Context, msg *dns.Msg) (*dns.Msg, error
if len(publicResponses) > 0 {
resp := publicResponses[0]
Log(ctx, logger.Debug(), "using public answer from: %s", resp.server)
Log(ctx, logger.Debug(), "Using public answer from: %s", resp.server)
logAnswer(resp.server)
return resp.answer, nil
}
if controldSuccessAnswer != nil {
Log(ctx, logger.Debug(), "using ControlD answer from: %s", controldPublicDnsWithPort)
Log(ctx, logger.Debug(), "Using ControlD answer from: %s", controldPublicDnsWithPort)
logAnswer(controldPublicDnsWithPort)
return controldSuccessAnswer, nil
}
if nonSuccessAnswer != nil {
Log(ctx, logger.Debug(), "using non-success answer from: %s", nonSuccessServer)
Log(ctx, logger.Debug(), "Using non-success answer from: %s", nonSuccessServer)
logAnswer(nonSuccessServer)
return nonSuccessAnswer, nil
}
@@ -563,12 +563,12 @@ func lookupIP(ctx context.Context, domain string, timeout int, bootstrapDNS []st
}
logger := LoggerFromCtx(ctx)
if bootstrapDNS == nil {
logger.Debug().Msgf("empty bootstrap DNS")
logger.Debug().Msgf("Empty bootstrap dns")
return nil
}
resolver := newResolverWithNameserver(bootstrapDNS)
logger.Debug().Msgf("resolving %q using bootstrap DNS %q", domain, bootstrapDNS)
logger.Debug().Msgf("Resolving %q using bootstrap dns %q", domain, bootstrapDNS)
timeoutMs := 2000
if timeout > 0 && timeout < timeoutMs {
@@ -612,15 +612,15 @@ func lookupIP(ctx context.Context, domain string, timeout int, bootstrapDNS []st
r, err := resolver.Resolve(ctx, m)
if err != nil {
logger.Error().Err(err).Msgf("could not lookup %q record for domain %q", dns.TypeToString[dnsType], domain)
logger.Error().Err(err).Msgf("Could not lookup %q record for domain %q", dns.TypeToString[dnsType], domain)
return
}
if r.Rcode != dns.RcodeSuccess {
logger.Error().Msgf("could not resolve domain %q, return code: %s", domain, dns.RcodeToString[r.Rcode])
logger.Error().Msgf("Could not resolve domain %q, return code: %s", domain, dns.RcodeToString[r.Rcode])
return
}
if len(r.Answer) == 0 {
logger.Error().Msg("no answer from OS resolver")
logger.Error().Msg("No answer from os resolver")
return
}
target := targetDomain(r.Answer)