- links: short names mapped to host selectors, validated against chains and static host names - dns.suggest / dns.save_link: ask, always or never - dns.domains: domain rules per name pattern (mx* -> easysahre.de) - the wizard edits the dns settings under Resolver & cache and keeps links; setup.SaveTo reports to a chosen writer Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
97 lines
2.9 KiB
Go
97 lines
2.9 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"path"
|
|
"strings"
|
|
)
|
|
|
|
// DNSConfig controls what netssh does with names that are neither in NetBox
|
|
// nor in the cache: resolve them through DNS and suggest the owning host.
|
|
type DNSConfig struct {
|
|
// Suggest is ask (default), always (take the first suggestion without
|
|
// asking, also in scripts) or never (no DNS lookup, plain "not found").
|
|
Suggest string `mapstructure:"suggest"`
|
|
// SaveLink is ask (default), always (save the shortcut without asking)
|
|
// or never, for the link offered after a suggestion.
|
|
SaveLink string `mapstructure:"save_link"`
|
|
// Domains are appended to names without a dot that match the rule.
|
|
Domains []DNSDomain `mapstructure:"domains"`
|
|
}
|
|
|
|
// DNSDomain appends Domain to names matching Match (a shell glob such as
|
|
// "mx*"; empty matches every name).
|
|
type DNSDomain struct {
|
|
Match string `mapstructure:"match"`
|
|
Domain string `mapstructure:"domain"`
|
|
}
|
|
|
|
// DNS modes for dns.suggest and dns.save_link.
|
|
const (
|
|
DNSAsk = "ask"
|
|
DNSAlways = "always"
|
|
DNSNever = "never"
|
|
)
|
|
|
|
// SuggestMode returns dns.suggest, ask by default.
|
|
func (d DNSConfig) SuggestMode() string { return dnsMode(d.Suggest) }
|
|
|
|
// SaveLinkMode returns dns.save_link, ask by default.
|
|
func (d DNSConfig) SaveLinkMode() string { return dnsMode(d.SaveLink) }
|
|
|
|
func dnsMode(mode string) string {
|
|
if mode == "" {
|
|
return DNSAsk
|
|
}
|
|
return strings.ToLower(mode)
|
|
}
|
|
|
|
// Names lists the DNS names to try for what the user typed. A name with a
|
|
// dot is used as is. A name without a dot gets the domain of every rule it
|
|
// matches, in order; only when no rule matches is the bare name looked up.
|
|
func (d DNSConfig) Names(query string) []string {
|
|
if strings.Contains(query, ".") {
|
|
return []string{query}
|
|
}
|
|
var names []string
|
|
seen := map[string]bool{}
|
|
lower := strings.ToLower(query)
|
|
for _, rule := range d.Domains {
|
|
if rule.Match != "" {
|
|
if ok, _ := path.Match(strings.ToLower(rule.Match), lower); !ok {
|
|
continue
|
|
}
|
|
}
|
|
name := query + "." + strings.Trim(strings.TrimSpace(rule.Domain), ".")
|
|
if !seen[strings.ToLower(name)] {
|
|
seen[strings.ToLower(name)] = true
|
|
names = append(names, name)
|
|
}
|
|
}
|
|
if len(names) == 0 {
|
|
return []string{query}
|
|
}
|
|
return names
|
|
}
|
|
|
|
// ValidateDNS rejects unknown modes, broken patterns and empty domains.
|
|
func (c *Config) ValidateDNS() error {
|
|
for key, mode := range map[string]string{"dns.suggest": c.DNS.Suggest, "dns.save_link": c.DNS.SaveLink} {
|
|
switch dnsMode(mode) {
|
|
case DNSAsk, DNSAlways, DNSNever:
|
|
default:
|
|
return fmt.Errorf("%s must be ask, always, or never", key)
|
|
}
|
|
}
|
|
for i, rule := range c.DNS.Domains {
|
|
if _, err := path.Match(rule.Match, ""); err != nil {
|
|
return fmt.Errorf("dns.domains[%d]: invalid match pattern %q", i, rule.Match)
|
|
}
|
|
domain := strings.Trim(strings.TrimSpace(rule.Domain), ".")
|
|
if domain == "" || strings.ContainsAny(domain, " \t/@*?") || strings.HasPrefix(domain, "-") {
|
|
return fmt.Errorf("dns.domains[%d]: invalid domain %q", i, rule.Domain)
|
|
}
|
|
}
|
|
return nil
|
|
}
|