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 }