init_core.go

/*
File:    init_core.go
Version: 1.105.0
Updated: 11-May-2026 08:37 CEST

Description:
  High-level initialization orchestrator and general IO helpers for sdproxy.
  Dispatches specific tasks to init_routing, init_policy, and init_upstreams.

Changes:
  1.105.0 - [LOGGING] Orchestrated baseline Global Block, DGA, and Bootstrap 
            diagnostic messages organically using `logSystem`.
  1.104.0 - [REFACTOR] Large-scale decomposition. Logic for routing, policies, 
            and upstreams moved to dedicated init_*.go sub-files.
*/

package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"net"
	"net/http"
	"net/netip"
	"os"
	"strings"

	"github.com/miekg/dns"
)

// readConfigListFile reads a file line by line, stripping whitespace and inline comments.
func readConfigListFile(filePath string) ([]string, error) {
	f, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	var lines []string
	scanner := bufio.NewScanner(f)
	buf := make([]byte, 64*1024)
	scanner.Buffer(buf, 2*1024*1024)

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if idx := strings.IndexByte(line, '#'); idx >= 0 {
			line = strings.TrimSpace(line[:idx])
		}
		if line != "" {
			lines = append(lines, line)
		}
	}
	return lines, scanner.Err()
}

// readConfigListURL fetches a list of strings from a remote HTTP/HTTPS endpoint securely.
func readConfigListURL(urlStr string) ([]string, error) {
	req, err := http.NewRequest(http.MethodGet, urlStr, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("User-Agent", cfg.Server.UserAgent)

	resp, err := catHTTPClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("bad HTTP status code: %d", resp.StatusCode)
	}

	var lines []string
	lr := io.LimitReader(resp.Body, 10*1024*1024)
	scanner := bufio.NewScanner(lr)
	buf := make([]byte, 64*1024)
	scanner.Buffer(buf, 2*1024*1024)
	
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if idx := strings.IndexByte(line, '#'); idx >= 0 {
			line = strings.TrimSpace(line[:idx])
		}
		if line != "" {
			lines = append(lines, line)
		}
	}
	return lines, scanner.Err()
}

// initBlockAction parses the global 'BLOCK' definition.
func initBlockAction() {
	action := strings.ToUpper(strings.TrimSpace(cfg.Server.BlockAction))
	if action == "" || action == "NULL" {
		globalBlockAction = BlockActionNull
	} else if action == "DROP" {
		globalBlockAction = BlockActionDrop
	} else if action == "LOG" {
		globalBlockAction = BlockActionLog
	} else if action == "IP" {
		globalBlockAction = BlockActionIP
		for _, ipStr := range cfg.Server.BlockIPs {
			if ip := net.ParseIP(strings.TrimSpace(ipStr)); ip != nil {
				if ip.To4() != nil { globalBlockIPv4 = append(globalBlockIPv4, ip.To4()) } else { globalBlockIPv6 = append(globalBlockIPv6, ip.To16()) }
			}
		}
		if len(globalBlockIPv4) == 0 && len(globalBlockIPv6) == 0 { globalBlockAction = BlockActionNull }
	} else if rcode, ok := dns.StringToRcode[action]; ok {
		globalBlockAction = BlockActionRcode
		globalBlockRcode = rcode
	} else {
		globalBlockAction = BlockActionNull
	}
	if logSystem {
		log.Printf("[INIT] Global Block Action: %s", action)
	}
}

// initDGA parses the ML classification definitions for Domain Generation Algorithms.
func initDGA() {
	if cfg.Server.DGA.Enabled {
		hasDGA = true
		if cfg.Server.DGA.Threshold <= 0 { cfg.Server.DGA.Threshold = 80.0 }
		if cfg.Server.DGA.Action == "" { cfg.Server.DGA.Action = "BLOCK" }
		if logSystem {
			log.Printf("[INIT] DGA ML Detection enabled (Threshold: %.1f, Action: %s)", cfg.Server.DGA.Threshold, cfg.Server.DGA.Action)
		}
	}
}

// initRouteIndex constructs the numerical lookup map required by the cache architecture.
func initRouteIndex() {
	routeIdxByName = make(map[string]uint16, len(cfg.Upstreams)+4)
	routeIdxByName["local"] = routeIdxLocal
	nextIdx := uint16(1)
	assignIdx := func(name string) {
		if _, exists := routeIdxByName[name]; !exists {
			routeIdxByName[name] = nextIdx
			nextIdx++
		}
	}
	for groupName := range cfg.Upstreams { assignIdx(groupName) }
	for _, dr := range cfg.DomainRoutes { assignIdx(dr.Upstream) }
	for _, route := range cfg.Routes {
		u := route.Upstream
		if u == "" && route.Group != "" {
			if grp, ok := cfg.Groups[route.Group]; ok { u = grp.Upstream }
		}
		if u != "" { assignIdx(u) }
	}
	routeIdxDefault = routeIdxByName["default"]
}

// initRRs parses global and per-group spoofed records natively
func initRRs() {
	globalRRs = make(map[string]spoofRecord)
	groupRRs = make(map[string]map[string]spoofRecord)

	parseRRMap := func(source map[string]interface{}, dest map[string]spoofRecord) {
		for k, v := range source {
			domain := lowerTrimDot(k)
			var rec spoofRecord
			switch val := v.(type) {
			case string:
				if ip, err := netip.ParseAddr(strings.TrimSpace(val)); err == nil { rec.IPs = append(rec.IPs, ip.Unmap()) } else { rec.CNAME = lowerTrimDot(val) }
			case []interface{}:
				for _, item := range val {
					if str, ok := item.(string); ok {
						if ip, err := netip.ParseAddr(strings.TrimSpace(str)); err == nil { rec.IPs = append(rec.IPs, ip.Unmap()) }
					}
				}
			}
			dest[domain] = rec
		}
	}
	parseRRMap(cfg.RRs, globalRRs)
	for grpName, grpCfg := range cfg.Groups {
		if len(grpCfg.RRs) > 0 {
			gm := make(map[string]spoofRecord)
			parseRRMap(grpCfg.RRs, gm)
			groupRRs[grpName] = gm
		}
	}
	hasRRs = len(globalRRs) > 0 || len(groupRRs) > 0
}

// initDDR maps RFC 9462 Discovery of Designated Resolvers endpoints.
func initDDR() {
	if cfg.Server.ECHConfigList != "" {
		if b, err := os.ReadFile(cfg.Server.ECHConfigList); err == nil { ddrECHConfig = b }
	}
	if cfg.Server.DDR.Enabled {
		ddrHostnames = make(map[string]bool)
		source := cfg.Server.DDR.HostnameSource
		if source == "" { source = "strict" }
		var raw []string
		if source == "strict" || source == "both" { raw = append(raw, cfg.Server.DDR.Hostnames...) }
		if source == "tls" || source == "both" { raw = append(raw, tlsAuthorizedNames...) }
		for _, h := range raw {
			clean := strings.ToLower(strings.TrimSuffix(h, "."))
			if clean != "" && !strings.Contains(clean, "*") && net.ParseIP(clean) == nil {
				if !ddrHostnames[clean] { ddrHostnames[clean] = true; ddrHostnamesList = append(ddrHostnamesList, clean) }
			}
		}
		for _, s := range cfg.Server.DDR.IPv4 { if ip := net.ParseIP(s); ip != nil { ddrIPv4 = append(ddrIPv4, ip) } }
		for _, s := range cfg.Server.DDR.IPv6 { if ip := net.ParseIP(s); ip != nil { ddrIPv6 = append(ddrIPv6, ip) } }
		ddrDoHPort, ddrDoTPort, ddrDoQPort = 0, 0, 0
		for _, addr := range cfg.Server.ListenDoH { ddrDoHPort = extractPort(addr, 443) }
		for _, addr := range cfg.Server.ListenDoT { ddrDoTPort = extractPort(addr, 853) }
		for _, addr := range cfg.Server.ListenDoQ { ddrDoQPort = extractPort(addr, 853) }
	}
}