Merge pull request #10 from Daniel-Ric/feature/2026-02-03/enhance-tool-with-ip-lookup-options-mh6iqt

Load IANA TLDs for lookup pool, add per-host timeouts and graceful Ctrl+C

Author: Daniel-Ric

internal/cli/cli.go

@@ -18,23 +18,32 @@ type App struct {
 func NewApp() *App {
 	return &App{
 		inputTimeout:  3 * time.Second,
-		lookupTimeout: 12 * time.Second,
+		lookupTimeout: 45 * time.Second,
 	}
 }
 
 func (a *App) Run() error {
 	for {
 		config, err := a.collectConfig()
 		if err != nil {
+			if errors.Is(err, errAborted) {
+				return nil
+			}
 			return err
 		}
 
 		if err := a.execute(config); err != nil {
+			if errors.Is(err, errAborted) {
+				return nil
+			}
 			return err
 		}
 
 		again, err := a.askAgain()
 		if err != nil {
+			if errors.Is(err, errAborted) {
+				return nil
+			}
 			return err
 		}
 		if !again {
@@ -225,7 +234,11 @@ func (a *App) askDomainEndings() ([]string, error) {
 		return nil, err
 	}
 	if index == 1 {
-		return domainEndingPool, nil
+		endings, err := loadDomainEndings()
+		if err != nil {
+			return endings, nil
+		}
+		return endings, nil
 	}
 	var errMsg string
 	for {
@@ -300,12 +313,13 @@ func (a *App) executeLookup(config LookupConfig) error {
 
 	resultText, err := withSpinner("IP Lookup", "Domains werden überprüft", 120*time.Millisecond, func() (string, error) {
 		result, lookupErr := ping.LookupDomains(ctx, ping.LookupConfig{
-			Edition:       config.Edition,
-			Port:          config.Port,
-			BaseHost:      config.BaseHost,
-			Subdomains:    config.Subdomains,
-			DomainEndings: config.Endings,
-			Concurrency:   24,
+			Edition:        config.Edition,
+			Port:           config.Port,
+			BaseHost:       config.BaseHost,
+			Subdomains:     config.Subdomains,
+			DomainEndings:  config.Endings,
+			Concurrency:    24,
+			PerHostTimeout: 2 * time.Second,
 		})
 		if lookupErr != nil && !errors.Is(lookupErr, context.DeadlineExceeded) {
 			return "", lookupErr

internal/cli/lookup_endings.go

@@ -0,0 +1,99 @@
+package cli
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+const ianaTLDSource = "https://data.iana.org/TLD/tlds-alpha-by-domain.txt"
+
+var (
+	domainEndingsOnce  sync.Once
+	domainEndingsCache []string
+	domainEndingsErr   error
+)
+
+func loadDomainEndings() ([]string, error) {
+	domainEndingsOnce.Do(func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		iana, err := fetchIANATLDs(ctx)
+		if err != nil {
+			domainEndingsErr = fmt.Errorf("konnte endungs-pool nicht laden: %w", err)
+			domainEndingsCache = domainEndingPool
+			return
+		}
+		domainEndingsCache = mergeUniqueEndings(iana, domainEndingPool)
+	})
+
+	if domainEndingsErr != nil {
+		return domainEndingsCache, domainEndingsErr
+	}
+	return domainEndingsCache, nil
+}
+
+func fetchIANATLDs(ctx context.Context) ([]string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ianaTLDSource, nil)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("iana antwort: %s", resp.Status)
+	}
+
+	scanner := bufio.NewScanner(resp.Body)
+	list := make([]string, 0, 2000)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		list = append(list, strings.ToLower(line))
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+	if len(list) == 0 {
+		return nil, fmt.Errorf("keine endungen gefunden")
+	}
+	return list, nil
+}
+
+func mergeUniqueEndings(primary, secondary []string) []string {
+	seen := make(map[string]struct{}, len(primary)+len(secondary))
+	list := make([]string, 0, len(primary)+len(secondary))
+	for _, value := range primary {
+		value = normalizeEnding(value)
+		if value == "" {
+			continue
+		}
+		if _, ok := seen[value]; ok {
+			continue
+		}
+		seen[value] = struct{}{}
+		list = append(list, value)
+	}
+	for _, value := range secondary {
+		value = normalizeEnding(value)
+		if value == "" {
+			continue
+		}
+		if _, ok := seen[value]; ok {
+			continue
+		}
+		seen[value] = struct{}{}
+		list = append(list, value)
+	}
+	return list
+}

internal/cli/ui.go

@@ -17,6 +17,8 @@ const (
 	colorBold   = "\033[1m"
 )
 
+var errAborted = errors.New("abgebrochen")
+
 func supportsColor() bool {
 	if os.Getenv("NO_COLOR") != "" {
 		return false
@@ -74,7 +76,7 @@ func selectOption(title string, options []string) (int, error) {
 
 		switch b {
 		case 3:
-			return 0, errors.New("abgebrochen")
+			return 0, errAborted
 		case 'w', 'k':
 			if selected > 0 {
 				selected--

internal/ping/lookup.go

@@ -6,15 +6,17 @@ import (
 	"strings"
 	"sync"
 	"sync/atomic"
+	"time"
 )
 
 type LookupConfig struct {
-	Edition       Edition
-	Port          int
-	BaseHost      string
-	Subdomains    []string
-	DomainEndings []string
-	Concurrency   int
+	Edition        Edition
+	Port           int
+	BaseHost       string
+	Subdomains     []string
+	DomainEndings  []string
+	Concurrency    int
+	PerHostTimeout time.Duration
 }
 
 type LookupMatch struct {
@@ -47,6 +49,10 @@ func LookupDomains(ctx context.Context, config LookupConfig) (LookupResult, erro
 	if concurrency <= 0 {
 		concurrency = 16
 	}
+	perHostTimeout := config.PerHostTimeout
+	if perHostTimeout <= 0 {
+		perHostTimeout = 2 * time.Second
+	}
 
 	total := len(subdomains) * len(endings)
 	if total == 0 {
@@ -67,7 +73,9 @@ func LookupDomains(ctx context.Context, config LookupConfig) (LookupResult, erro
 			default:
 			}
 
-			res, err := Execute(ctx, config.Edition, host, config.Port)
+			hostCtx, cancel := context.WithTimeout(ctx, perHostTimeout)
+			res, err := Execute(hostCtx, config.Edition, host, config.Port)
+			cancel()
 			atomic.AddInt64(&completed, 1)
 			if err != nil {
 				continue