func handlerToAnswer(w dns.ResponseWriter, r *dns.Msg) {
db, err := sql.Open("mysql", "inserter:qwerty@/dnsServerCache") //Handler for database
if err != nil {
panic(err.Error()) // Just for example purpose. You should use proper error handling instead of panic
}
answer := new(dns.Msg) //Set answer to client
answer.SetReply(r) //Set reply flag and start collecting data for reply
var answersAll []dns.RR
answersAll = dbRespond(db, r.Question[0].String())
if len(answersAll) != 0 {
for _, answers := range answersAll {
answer.Answer = append(answer.Answer, answers)
}
} else {
client := new(dns.Client)
var err1 error
config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
answer, _, err1 = client.Exchange(r, config.Servers[0]+":"+config.Port)
if err1 != nil {
panic(err1.Error())
}
if r.Rcode != dns.RcodeSuccess {
return
}
go dbWriter(answer.Answer, db, r.Question[0].String())
}
w.WriteMsg(answer)
}
func main() {
if len(os.Args) <= 1 {
log.Printf("Usage: %s domain", os.Args[0])
os.Exit(1)
}
config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
c := new(dns.Client)
m := new(dns.Msg)
m.SetQuestion(dns.Fqdn(os.Args[1]), dns.TypeMX)
m.RecursionDesired = true
r, _, err := c.Exchange(m, net.JoinHostPort(config.Servers[0], config.Port))
if r == nil {
log.Fatalf("*** error: %s\n", err.Error())
}
if r.Rcode != dns.RcodeSuccess {
log.Fatalf(" *** invalid answer name %s after MX query for %s\n", os.Args[1], os.Args[1])
}
// Stuff must be in the answer section
for _, a := range r.Answer {
fmt.Printf("%v\n", a)
}
}
func lookupSRV(name string) (*dns.Msg, error) {
conf, err := dns.ClientConfigFromFile(resolvConf)
if err != nil {
return nil, fmt.Errorf("Couldn't load resolv.conf: %s", err)
}
client := &dns.Client{}
response := &dns.Msg{}
for _, server := range conf.Servers {
servAddr := net.JoinHostPort(server, conf.Port)
for _, suffix := range conf.Search {
response, err = lookup(name, dns.TypeSRV, client, servAddr, suffix, false)
if err == nil {
if len(response.Answer) > 0 {
return response, nil
}
} else {
glog.Warningf("Resolving %s.%s failed: %s", name, suffix, err)
}
}
response, err = lookup(name, dns.TypeSRV, client, servAddr, "", false)
if err == nil {
return response, nil
}
}
return response, fmt.Errorf("Couldn't resolve %s: No server responded", name)
}
func (u *upstream) Config() (*dns.ClientConfig, error) {
u.Lock()
defer u.Unlock()
// If we checked less than five seconds ago return what we already have
now := time.Now()
if now.Sub(u.lastStat) < 5*time.Second {
return u.cachedConfig, nil
}
u.lastStat = now
// Reread file if it has changed
if fi, err := os.Stat(u.resolvConf); err != nil {
return u.cachedConfig, err
} else if fi.ModTime() != u.lastModified {
if config, err := dns.ClientConfigFromFile(u.resolvConf); err == nil {
config.Servers = filter(config.Servers, u.filterAddress)
u.lastModified = fi.ModTime()
u.cachedConfig = config
} else {
return u.cachedConfig, err
}
}
return u.cachedConfig, nil
}
func init() {
conf, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil || len(conf.Servers) == 0 {
return
}
DefaultResolve = strings.Join(conf.Servers, ",")
}
func loadRootConfig() (err error) {
rootConfig, err = dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
return err
}
return nil
}
func NewDefaultLookupLib() *LookupLib {
config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
serverString := config.Servers[0] + ":" + config.Port
l := new(LookupLib)
l.serverString = serverString
return l
}
// localNameservers returns list of local nameservers.
func localNameservers() ([]string, error) {
c, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
return nil, err
}
return c.Servers, nil
}
func ResolvConf(config *Config, ctx *cli.Context) error {
// Get host resolv config
resolvConf, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
return err
}
if len(config.Nameservers) == 0 {
for _, s := range resolvConf.Servers {
config.Nameservers = append(config.Nameservers, net.JoinHostPort(s, resolvConf.Port))
}
}
if !ctx.IsSet("ndots") && resolvConf.Ndots != 1 {
log.Debugf("Setting ndots from resolv.conf: %d", resolvConf.Ndots)
config.Ndots = resolvConf.Ndots
}
if config.EnableSearch && len(config.SearchDomains) == 0 {
for _, s := range resolvConf.Search {
s = dns.Fqdn(strings.ToLower(s))
config.SearchDomains = append(config.SearchDomains, s)
}
}
return nil
}
func NewDefaultResolver() *Resolver {
config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
serverString := config.Servers[0] + ":" + config.Port
l := new(Resolver)
l.serverString = serverString
return l
}
func Init() {
var el error
cf, el = dns.ClientConfigFromFile(DEFAULT_RESOLV_FILE)
if el != nil {
fmt.Println("DEFAULT_RESOLV_FILE ERR")
}
}
func lookupAll(name string, qtype uint16) (*dns.Msg, error) {
conf, err := dns.ClientConfigFromFile(resolvConf)
if err != nil {
return nil, fmt.Errorf("could not load resolv.conf: %s", err)
}
client := &dns.Client{}
response := &dns.Msg{}
for _, server := range conf.Servers {
servAddr := net.JoinHostPort(server, conf.Port)
for _, suffix := range conf.Search {
response, err = lookup(name, qtype, client, servAddr, suffix, false)
if err != nil {
log.Warnf("resolving %s.%s failed: %s", name, suffix, err)
continue
}
if len(response.Answer) > 0 {
return response, nil
}
}
response, err = lookup(name, qtype, client, servAddr, "", false)
if err == nil {
return response, nil
}
}
return response, fmt.Errorf("could not resolve %s: No server responded", name)
}
func main() {
if len(os.Args) != 2 {
fmt.Printf("%s NAMESERVER\n", os.Args[0])
os.Exit(1)
}
conf, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
m := new(dns.Msg)
m.Question = make([]dns.Question, 1)
c := new(dns.Client)
addr := addresses(conf, c, os.Args[1])
if len(addr) == 0 {
fmt.Printf("No address found for %s\n", os.Args[1])
os.Exit(1)
}
for _, a := range addr {
m.Question[0] = dns.Question{"version.bind.", dns.TypeTXT, dns.ClassCHAOS}
in, rtt, _ := c.ExchangeRtt(m, a)
if in != nil && len(in.Answer) > 0 {
fmt.Printf("(time %.3d µs) %v\n", rtt/1e3, in.Answer[0])
}
m.Question[0] = dns.Question{"hostname.bind.", dns.TypeTXT, dns.ClassCHAOS}
in, rtt, _ = c.ExchangeRtt(m, a)
if in != nil && len(in.Answer) > 0 {
fmt.Printf("(time %.3d µs) %v\n", rtt/1e3, in.Answer[0])
}
}
}
func loadConfig() error {
loadConfigOnce.Do(func() {
clientConfig, configLoadError = dns.ClientConfigFromFile("/etc/resolv.conf")
})
return configLoadError
}
func getDNSServerAddress() (string, error) {
conf, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
return "", fmt.Errorf("failed to load DNS config from /etc/resolv.conf: %v", err)
}
return net.JoinHostPort(conf.Servers[0], conf.Port), nil
}
// GetLocalDNS returns the first nameserver in /etc/resolv.conf
// Used for non-Mesos queries.
func GetLocalDNS() []string {
conf, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
logging.Error.Fatalf("%v", err)
}
return nonLocalAddies(conf.Servers)
}
func init() {
lookup.Register("dns", new(dnsResolver))
var err error
config, err = dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
log.Fatal(err)
}
}
/*
* getSysResolver() - obtain (1st) system default resolver address
*/
func getSysResolver() (resolver string, err error) {
config, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err == nil {
resolver = config.Servers[0]
} else {
fmt.Println("Error processing /etc/resolv.conf: " + err.Error())
}
return
}
func findDnsServerAddr() (string, error) {
// Find a DNS server using the OS resolv.conf
config, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
log.Error("Failure finding DNS server address from /etc/resolv.conf, err = %s", err)
return "", err
} else {
return config.Servers[0] + ":" + config.Port, nil
}
}
func setDefaults(config *Config) error {
if config.ReadTimeout == 0 {
config.ReadTimeout = 2 * time.Second
}
if config.DnsAddr == "" {
config.DnsAddr = "127.0.0.1:53"
}
if config.Domain == "" {
config.Domain = "skydns.local."
}
if config.Hostmaster == "" {
config.Hostmaster = "hostmaster." + config.Domain
}
// People probably don't know that SOA's email addresses cannot
// contain @-signs, replace them with dots
config.Hostmaster = dns.Fqdn(strings.Replace(config.Hostmaster, "@", ".", -1))
if config.MinTtl == 0 {
config.MinTtl = 60
}
if config.Ttl == 0 {
config.Ttl = 3600
}
if config.Priority == 0 {
config.Priority = 10
}
if len(config.Nameservers) == 0 {
c, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
return err
}
for _, s := range c.Servers {
config.Nameservers = append(config.Nameservers, net.JoinHostPort(s, c.Port))
}
}
config.Domain = dns.Fqdn(strings.ToLower(config.Domain))
config.DomainLabels = dns.CountLabel(config.Domain)
if config.DNSSEC != "" {
// For some reason the + are replaces by spaces in etcd. Re-replace them
keyfile := strings.Replace(config.DNSSEC, " ", "+", -1)
k, p, err := ParseKeyFile(keyfile)
if err != nil {
return err
}
if k.Header().Name != dns.Fqdn(config.Domain) {
return fmt.Errorf("ownername of DNSKEY must match SkyDNS domain")
}
k.Header().Ttl = config.Ttl
config.PubKey = k
config.KeyTag = k.KeyTag()
config.PrivKey = p
config.ClosestEncloser, config.DenyWildcard = newNSEC3CEandWildcard(config.Domain, config.Domain, config.MinTtl)
}
return nil
}
// tcpLookupIP is a helper to initiate a TCP-based DNS lookup for the given host.
// The built-in Go resolver will do a UDP lookup first, and will only use TCP if
// the response has the truncate bit set, which isn't common on DNS servers like
// Consul's. By doing the TCP lookup directly, we get the best chance for the
// largest list of hosts to join. Since joins are relatively rare events, it's ok
// to do this rather expensive operation.
func (m *Memberlist) tcpLookupIP(host string, defaultPort uint16) ([]ipPort, error) {
// Don't attempt any TCP lookups against non-fully qualified domain
// names, since those will likely come from the resolv.conf file.
if !strings.Contains(host, ".") {
return nil, nil
}
// Make sure the domain name is terminated with a dot (we know there's
// at least one character at this point).
dn := host
if dn[len(dn)-1] != '.' {
dn = dn + "."
}
// See if we can find a server to try.
cc, err := dns.ClientConfigFromFile(m.config.DNSConfigPath)
if err != nil {
return nil, err
}
if len(cc.Servers) > 0 {
// We support host:port in the DNS config, but need to add the
// default port if one is not supplied.
server := cc.Servers[0]
if !hasPort(server) {
server = net.JoinHostPort(server, cc.Port)
}
// Do the lookup.
c := new(dns.Client)
c.Net = "tcp"
msg := new(dns.Msg)
msg.SetQuestion(dn, dns.TypeANY)
in, _, err := c.Exchange(msg, server)
if err != nil {
return nil, err
}
// Handle any IPs we get back that we can attempt to join.
var ips []ipPort
for _, r := range in.Answer {
switch rr := r.(type) {
case (*dns.A):
ips = append(ips, ipPort{rr.A, defaultPort})
case (*dns.AAAA):
ips = append(ips, ipPort{rr.AAAA, defaultPort})
case (*dns.CNAME):
m.logger.Printf("[DEBUG] memberlist: Ignoring CNAME RR in TCP-first answer for '%s'", host)
}
}
return ips, nil
}
return nil, nil
}
// NewFromResolvConf initializes DnsResolver from resolv.conf like file.
func NewFromResolvConf(path string) (*DnsResolver, error) {
if _, err := os.Stat(path); os.IsNotExist(err) {
return &DnsResolver{}, errors.New("no such file or directory: " + path)
}
config, err := dns.ClientConfigFromFile(path)
servers := []string{}
for _, ipAddress := range config.Servers {
servers = append(servers, ipAddress+":53")
}
return &DnsResolver{servers, len(servers) * 2, rand.New(rand.NewSource(time.Now().UnixNano()))}, err
}
func LookupHost(host string) (addrs []string, err error) {
config, err := dns.ClientConfigFromFile(ConfigurationFile)
if err != nil {
return nil, e.Forward(err)
}
config.Timeout = Timeout
addrs, err = lookupHost(host, config)
if err != nil {
return nil, e.Forward(err)
}
return
}
func NewHandler() *GODNSHandler {
var (
clientConfig *dns.ClientConfig
cacheConfig CacheSettings
resolver *Resolver
cache, negCache Cache
)
resolvConfig := settings.ResolvConfig
clientConfig, err := dns.ClientConfigFromFile(resolvConfig.ResolvFile)
if err != nil {
logger.Warn(":%s is not a valid resolv.conf file\n", resolvConfig.ResolvFile)
logger.Error(err.Error())
panic(err)
}
clientConfig.Timeout = resolvConfig.Timeout
resolver = &Resolver{clientConfig}
cacheConfig = settings.Cache
switch cacheConfig.Backend {
case "memory":
cache = &MemoryCache{
Backend: make(map[string]Mesg, cacheConfig.Maxcount),
Expire: time.Duration(cacheConfig.Expire) * time.Second,
Maxcount: cacheConfig.Maxcount,
}
negCache = &MemoryCache{
Backend: make(map[string]Mesg),
Expire: time.Duration(cacheConfig.Expire) * time.Second / 2,
Maxcount: cacheConfig.Maxcount,
}
case "redis":
// cache = &MemoryCache{
// Backend: make(map[string]*dns.Msg),
// Expire: time.Duration(cacheConfig.Expire) * time.Second,
// Serializer: new(JsonSerializer),
// Maxcount: cacheConfig.Maxcount,
// }
panic("Redis cache backend not implement yet")
default:
logger.Error("Invalid cache backend %s", cacheConfig.Backend)
panic("Invalid cache backend")
}
var hosts Hosts
if settings.Hosts.Enable {
hosts = NewHosts(settings.Hosts, settings.Redis)
}
return &GODNSHandler{resolver, cache, negCache, hosts}
}
func init() {
conf, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
return
}
var addrs []string
for _, srv := range conf.Servers {
addrs = append(addrs, net.JoinHostPort(srv, conf.Port))
}
DefaultLookuper = NewDnsLookup(addrs, "")
}
func main() {
members := make([]string, 0)
raft.SetLogLevel(0)
flag.Parse()
nameservers := strings.Split(nameserver, ",")
// empty argument given
if len(nameservers) == 1 && nameservers[0] == "" {
nameservers = make([]string, 0)
config, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err == nil {
for _, s := range config.Servers {
nameservers = append(nameservers, net.JoinHostPort(s, config.Port))
}
} else {
log.Fatal(err)
return
}
}
if discover {
ns, err := net.LookupNS(domain)
if err != nil {
log.Fatal(err)
return
}
if len(ns) < 1 {
log.Fatal("No NS records found for ", domain)
return
}
for _, n := range ns {
members = append(members, strings.TrimPrefix(n.Host, "."))
}
} else if join != "" {
members = strings.Split(join, ",")
}
s := server.NewServer(members, domain, ldns, lhttp, dataDir, rtimeout, wtimeout, secret, nameservers)
stats.Collect()
waiter, err := s.Start()
if err != nil {
log.Fatal(err)
return
}
waiter.Wait()
}
func setDefaults(config *Config) error {
if config.ReadTimeout == 0 {
config.ReadTimeout = 2 * time.Second
}
if config.DnsAddr == "" {
config.DnsAddr = "127.0.0.1:53"
}
if config.Domain == "" {
config.Domain = "skydns.local"
}
if config.MinTtl == 0 {
config.MinTtl = 60
}
if config.Ttl == 0 {
config.Ttl = 3600
}
if config.Priority == 0 {
config.Priority = 10
}
if len(config.Nameservers) == 0 {
c, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
return err
}
for _, s := range c.Servers {
config.Nameservers = append(config.Nameservers, net.JoinHostPort(s, c.Port))
}
}
config.Domain = dns.Fqdn(strings.ToLower(config.Domain))
config.DomainLabels = dns.CountLabel(config.Domain)
if config.DNSSEC != "" {
// For some reason the + are replaces by spaces in etcd. Re-replace them
keyfile := strings.Replace(config.DNSSEC, " ", "+", -1)
k, p, err := ParseKeyFile(keyfile)
if err != nil {
return err
}
if k.Header().Name != dns.Fqdn(config.Domain) {
return fmt.Errorf("ownername of DNSKEY must match SkyDNS domain")
}
k.Header().Ttl = config.Ttl
config.PubKey = k
config.KeyTag = k.KeyTag()
config.PrivKey = p
}
return nil
}
// getNameservers attempts to get systems nameservers before falling back to the defaults
func getNameservers(path string, defaults []string) []string {
config, err := dns.ClientConfigFromFile(path)
if err != nil || len(config.Servers) == 0 {
return defaults
}
systemNameservers := []string{}
for _, server := range config.Servers {
// ensure all servers have a port number
if _, _, err := net.SplitHostPort(server); err != nil {
systemNameservers = append(systemNameservers, net.JoinHostPort(server, "53"))
} else {
systemNameservers = append(systemNameservers, server)
}
}
return systemNameservers
}
// getResolvConf reads a clientConfig from resolv.conf and complains about any errors
func getResolvConf(r types.DiagnosticResult) (*dns.ClientConfig, error) {
resolvConf, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
r.Error("DP3001", err, fmt.Sprintf("could not load/parse resolver file /etc/resolv.conf: %v", err))
return nil, err
}
if len(resolvConf.Servers) == 0 {
r.Error("DP3002", nil, "could not find any nameservers defined in /etc/resolv.conf")
return nil, err
}
if len(resolvConf.Search) == 0 {
r.Warn("DP3011", nil, "could not find any search domains defined in /etc/resolv.conf")
resolvConf.Search = nil
}
r.Debug("DP3012", fmt.Sprintf("Pod /etc/resolv.conf contains:\nnameservers: %v\nsearch domains: %v", resolvConf.Servers, resolvConf.Search))
return resolvConf, nil
}
func LookupIp(ip string) (host string, err error) {
if !utilNet.IsValidIpv4(ip) && !utilNet.IsValidIpv6(ip) {
return "", e.New("not a valid ip address")
}
if ip == "127.0.0.1" || ip == "::1" {
return "localhost", nil
}
config, err := dns.ClientConfigFromFile(ConfigurationFile)
if err != nil {
return "", e.Forward(err)
}
config.Timeout = Timeout
c := new(dns.Client)
c.DialTimeout = DialTimeout
c.ReadTimeout = ReadTimeout
c.WriteTimeout = WriteTimeout
m := new(dns.Msg)
rev, err := dns.ReverseAddr(ip)
if err != nil {
return "", e.Forward(err)
}
m.SetQuestion(rev, dns.TypePTR)
var r *dns.Msg
for i := 0; i < len(config.Servers); i++ {
r, _, err = c.Exchange(m, config.Servers[i]+":"+config.Port)
if err != nil {
continue
}
err = nil
}
if err != nil {
return "", e.Forward(err)
}
if r.Rcode != dns.RcodeSuccess {
return "", e.New("can't resolve %v", ip)
}
for _, a := range r.Answer {
if ptr, ok := a.(*dns.PTR); ok {
return strings.TrimSuffix(ptr.Ptr, "."), nil
}
}
return "", e.New("no ptr available")
}