Factor redundant code

Author: jedisct1

dnscrypt-proxy/common.go

@@ -4,11 +4,14 @@ import (
 	"bytes"
 	"encoding/binary"
 	"errors"
+	"fmt"
+	"io"
 	"net"
 	"os"
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 	"unicode"
 )
 
@@ -171,3 +174,110 @@ func ReadTextFile(filename string) (string, error) {
 }
 
 func isDigit(b byte) bool { return b >= '0' && b <= '9' }
+
+// ExtractClientIPStr extracts client IP string from pluginsState based on protocol
+func ExtractClientIPStr(pluginsState *PluginsState) (string, bool) {
+	switch pluginsState.clientProto {
+	case "udp":
+		return (*pluginsState.clientAddr).(*net.UDPAddr).IP.String(), true
+	case "tcp", "local_doh":
+		return (*pluginsState.clientAddr).(*net.TCPAddr).IP.String(), true
+	default:
+		return "", false
+	}
+}
+
+// FormatLogLine formats a log line based on the specified format (tsv or ltsv)
+func FormatLogLine(format, clientIP, qName, reason string, additionalFields ...string) (string, error) {
+	if format == "tsv" {
+		now := time.Now()
+		year, month, day := now.Date()
+		hour, minute, second := now.Clock()
+		tsStr := fmt.Sprintf("[%d-%02d-%02d %02d:%02d:%02d]", year, int(month), day, hour, minute, second)
+
+		line := fmt.Sprintf("%s\t%s\t%s\t%s", tsStr, clientIP, StringQuote(qName), StringQuote(reason))
+		for _, field := range additionalFields {
+			line += fmt.Sprintf("\t%s", StringQuote(field))
+		}
+		return line + "\n", nil
+	} else if format == "ltsv" {
+		line := fmt.Sprintf("time:%d\thost:%s\tqname:%s\tmessage:%s", time.Now().Unix(), clientIP, StringQuote(qName), StringQuote(reason))
+
+		// For LTSV format, additional fields are added with specific labels
+		for i, field := range additionalFields {
+			if i == 0 {
+				line += fmt.Sprintf("\tip:%s", StringQuote(field))
+			} else {
+				line += fmt.Sprintf("\tfield%d:%s", i, StringQuote(field))
+			}
+		}
+		return line + "\n", nil
+	}
+	return "", fmt.Errorf("unexpected log format: [%s]", format)
+}
+
+// WritePluginLog writes a log entry for plugin actions
+func WritePluginLog(logger io.Writer, format, clientIP, qName, reason string, additionalFields ...string) error {
+	if logger == nil {
+		return errors.New("Log file not initialized")
+	}
+
+	line, err := FormatLogLine(format, clientIP, qName, reason, additionalFields...)
+	if err != nil {
+		return err
+	}
+
+	_, err = logger.Write([]byte(line))
+	return err
+}
+
+// ParseTimeBasedRule parses a rule line that may contain time-based restrictions (@timerange)
+func ParseTimeBasedRule(line string, lineNo int, allWeeklyRanges *map[string]WeeklyRanges) (rulePart string, weeklyRanges *WeeklyRanges, err error) {
+	parts := strings.Split(line, "@")
+	timeRangeName := ""
+
+	if len(parts) == 2 {
+		rulePart = strings.TrimSpace(parts[0])
+		timeRangeName = strings.TrimSpace(parts[1])
+	} else if len(parts) > 2 {
+		return "", nil, fmt.Errorf("syntax error at line %d -- Unexpected @ character", 1+lineNo)
+	} else {
+		rulePart = line
+	}
+
+	if len(timeRangeName) > 0 {
+		if weeklyRangesX, ok := (*allWeeklyRanges)[timeRangeName]; ok {
+			weeklyRanges = &weeklyRangesX
+		} else {
+			return "", nil, fmt.Errorf("time range [%s] not found at line %d", timeRangeName, 1+lineNo)
+		}
+	}
+
+	return rulePart, weeklyRanges, nil
+}
+
+// ParseIPRule parses and validates an IP rule line
+func ParseIPRule(line string, lineNo int) (cleanLine string, trailingStar bool, err error) {
+	ip := net.ParseIP(line)
+	trailingStar = strings.HasSuffix(line, "*")
+
+	if len(line) < 2 || (ip != nil && trailingStar) {
+		return "", false, fmt.Errorf("suspicious IP rule [%s] at line %d", line, lineNo)
+	}
+
+	cleanLine = line
+	if trailingStar {
+		cleanLine = cleanLine[:len(cleanLine)-1]
+	}
+	if strings.HasSuffix(cleanLine, ":") || strings.HasSuffix(cleanLine, ".") {
+		cleanLine = cleanLine[:len(cleanLine)-1]
+	}
+	if len(cleanLine) == 0 {
+		return "", false, fmt.Errorf("empty IP rule at line %d", lineNo)
+	}
+	if strings.Contains(cleanLine, "*") {
+		return "", false, fmt.Errorf("invalid rule: [%s] - wildcards can only be used as a suffix at line %d", line, lineNo)
+	}
+
+	return strings.ToLower(cleanLine), trailingStar, nil
+}

dnscrypt-proxy/plugin_allow_ip.go

@@ -2,12 +2,9 @@ package main
 
 import (
 	"errors"
-	"fmt"
 	"io"
-	"net"
 	"strings"
 	"sync"
-	"time"
 
 	iradix "github.com/hashicorp/go-immutable-radix"
 	"github.com/jedisct1/dlog"
@@ -69,33 +66,16 @@ func (plugin *PluginAllowedIP) loadRules(lines string, prefixes *iradix.Tree, ip
 			continue
 		}
 
-		ip := net.ParseIP(line)
-		trailingStar := strings.HasSuffix(line, "*")
-		if len(line) < 2 || (ip != nil && trailingStar) {
-			dlog.Errorf("Suspicious allowed IP rule [%s] at line %d", line, lineNo)
+		cleanLine, trailingStar, err := ParseIPRule(line, lineNo)
+		if err != nil {
+			dlog.Error(err)
 			continue
 		}
 
 		if trailingStar {
-			line = line[:len(line)-1]
-		}
-		if strings.HasSuffix(line, ":") || strings.HasSuffix(line, ".") {
-			line = line[:len(line)-1]
-		}
-		if len(line) == 0 {
-			dlog.Errorf("Empty allowed IP rule at line %d", lineNo)
-			continue
-		}
-		if strings.Contains(line, "*") {
-			dlog.Errorf("Invalid rule: [%s] - wildcards can only be used as a suffix at line %d", line, lineNo)
-			continue
-		}
-
-		line = strings.ToLower(line)
-		if trailingStar {
-			prefixes, _, _ = prefixes.Insert([]byte(line), 0)
+			prefixes, _, _ = prefixes.Insert([]byte(cleanLine), 0)
 		} else {
-			ips[line] = true
+			ips[cleanLine] = true
 		}
 	}
 
@@ -111,41 +91,35 @@ func (plugin *PluginAllowedIP) Drop() error {
 
 // PrepareReload loads new rules into staging structures but doesn't apply them yet
 func (plugin *PluginAllowedIP) PrepareReload() error {
-	// Read the configuration file
-	lines, err := SafeReadTextFile(plugin.configFile)
-	if err != nil {
-		return fmt.Errorf("error reading config file during reload preparation: %w", err)
-	}
-
-	// Create staging structures
-	plugin.stagingPrefixes = iradix.New()
-	plugin.stagingIPs = make(map[string]interface{})
-
-	// Load rules into staging structures
-	plugin.stagingPrefixes, err = plugin.loadRules(lines, plugin.stagingPrefixes, plugin.stagingIPs)
-	if err != nil {
-		return fmt.Errorf("error parsing config during reload preparation: %w", err)
-	}
-
-	return nil
+	return StandardPrepareReloadPattern(plugin.Name(), plugin.configFile, func(lines string) error {
+		// Create staging structures
+		plugin.stagingPrefixes = iradix.New()
+		plugin.stagingIPs = make(map[string]interface{})
+
+		// Load rules into staging structures
+		var err error
+		plugin.stagingPrefixes, err = plugin.loadRules(lines, plugin.stagingPrefixes, plugin.stagingIPs)
+		return err
+	})
 }
 
 // ApplyReload atomically replaces the active rules with the staging ones
 func (plugin *PluginAllowedIP) ApplyReload() error {
-	if plugin.stagingPrefixes == nil || plugin.stagingIPs == nil {
-		return errors.New("no staged configuration to apply")
-	}
+	return StandardApplyReloadPattern(plugin.Name(), func() error {
+		if plugin.stagingPrefixes == nil || plugin.stagingIPs == nil {
+			return errors.New("no staged configuration to apply")
+		}
 
-	// Use write lock to swap rule structures
-	plugin.rwLock.Lock()
-	plugin.allowedPrefixes = plugin.stagingPrefixes
-	plugin.allowedIPs = plugin.stagingIPs
-	plugin.stagingPrefixes = nil
-	plugin.stagingIPs = nil
-	plugin.rwLock.Unlock()
+		// Use write lock to swap rule structures
+		plugin.rwLock.Lock()
+		plugin.allowedPrefixes = plugin.stagingPrefixes
+		plugin.allowedIPs = plugin.stagingIPs
+		plugin.stagingPrefixes = nil
+		plugin.stagingIPs = nil
+		plugin.rwLock.Unlock()
 
-	dlog.Noticef("Applied new configuration for plugin [%s]", plugin.Name())
-	return nil
+		return nil
+	})
 }
 
 // CancelReload cleans up any staging resources
@@ -156,16 +130,16 @@ func (plugin *PluginAllowedIP) CancelReload() {
 
 // Reload implements hot-reloading for the plugin
 func (plugin *PluginAllowedIP) Reload() error {
-	dlog.Noticef("Reloading configuration for plugin [%s]", plugin.Name())
-
-	// Prepare the new configuration
-	if err := plugin.PrepareReload(); err != nil {
-		plugin.CancelReload()
-		return err
-	}
+	return StandardReloadPattern(plugin.Name(), func() error {
+		// Prepare the new configuration
+		if err := plugin.PrepareReload(); err != nil {
+			plugin.CancelReload()
+			return err
+		}
 
-	// Apply the new configuration
-	return plugin.ApplyReload()
+		// Apply the new configuration
+		return plugin.ApplyReload()
+	})
 }
 
 // GetConfigPath returns the path to the plugin's configuration file
@@ -218,39 +192,15 @@ func (plugin *PluginAllowedIP) Eval(pluginsState *PluginsState, msg *dns.Msg) er
 		pluginsState.sessionData["whitelisted"] = true
 		if plugin.logger != nil {
 			qName := pluginsState.qName
-			var clientIPStr string
-			switch pluginsState.clientProto {
-			case "udp":
-				clientIPStr = (*pluginsState.clientAddr).(*net.UDPAddr).IP.String()
-			case "tcp", "local_doh":
-				clientIPStr = (*pluginsState.clientAddr).(*net.TCPAddr).IP.String()
-			default:
+			clientIPStr, ok := ExtractClientIPStr(pluginsState)
+			if !ok {
 				// Ignore internal flow.
 				return nil
 			}
-			var line string
-			if plugin.format == "tsv" {
-				now := time.Now()
-				year, month, day := now.Date()
-				hour, minute, second := now.Clock()
-				tsStr := fmt.Sprintf("[%d-%02d-%02d %02d:%02d:%02d]", year, int(month), day, hour, minute, second)
-				line = fmt.Sprintf(
-					"%s\t%s\t%s\t%s\t%s\n",
-					tsStr,
-					clientIPStr,
-					StringQuote(qName),
-					StringQuote(ipStr),
-					StringQuote(reason),
-				)
-			} else if plugin.format == "ltsv" {
-				line = fmt.Sprintf("time:%d\thost:%s\tqname:%s\tip:%s\tmessage:%s\n", time.Now().Unix(), clientIPStr, StringQuote(qName), StringQuote(ipStr), StringQuote(reason))
-			} else {
-				dlog.Fatalf("Unexpected log format: [%s]", plugin.format)
-			}
-			if plugin.logger == nil {
-				return errors.New("Log file not initialized")
+
+			if err := WritePluginLog(plugin.logger, plugin.format, clientIPStr, qName, reason, ipStr); err != nil {
+				return err
 			}
-			_, _ = plugin.logger.Write([]byte(line))
 		}
 	}
 	return nil