1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// Copyright (C) 2019-2024 Algorand, Inc.
// This file is part of go-algorand
//
// go-algorand is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// go-algorand is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
package network
import (
"net"
"time"
madns "github.com/multiformats/go-multiaddr-dns"
"github.com/algorand/go-algorand/logging"
"github.com/algorand/go-algorand/tools/network/dnssec"
)
// ResolverIf is re-import from dnssec.ResolverIf
type ResolverIf interface {
dnssec.ResolverIf
}
// compile-time check
var _ dnssec.ResolverIf = &net.Resolver{}
var _ dnssec.ResolverIf = &Resolver{}
var _ dnssec.ResolverIf = &dnssec.Resolver{}
// ResolveController provides a layer of abstaction for a regular, or DNSSEC-aware resolvers
type ResolveController struct {
secure bool
fallback string
log logging.Logger
}
// NewResolveController creates a new ResolveController
func NewResolveController(secure bool, fallbackDNSResolverAddress string, log logging.Logger) ResolveController {
return ResolveController{secure, fallbackDNSResolverAddress, log}
}
// SystemResolver returns a resolver that uses OS-defined DNS servers
func (c *ResolveController) SystemResolver() ResolverIf {
if c.secure {
servers, timeout, err := dnssec.SystemConfig()
if err != nil {
c.log.Debugf("retrieving system config failed with %s", err.Error())
servers = nil
timeout = time.Millisecond
}
return dnssec.MakeDnssecResolver(servers, timeout)
}
return net.DefaultResolver
}
// FallbackResolver returns a resolver that uses fallback DNS address
func (c *ResolveController) FallbackResolver() ResolverIf {
var dnsIPAddr *net.IPAddr
var err error
if dnsIPAddr, err = net.ResolveIPAddr("ip", c.fallback); err != nil {
c.log.Debugf("resolving fallback '%s' failed with %s", c.fallback, err.Error())
}
if c.secure {
address := dnssec.MakeResolverAddress(dnsIPAddr.String(), "53")
return dnssec.MakeDnssecResolver([]dnssec.ResolverAddress{address}, dnssec.DefaultTimeout)
}
r := Resolver{}
r.SetFallbackResolverAddress(*dnsIPAddr)
return &r
}
// DefaultResolver returns a resolver that uses fallback DNS address
func (c *ResolveController) DefaultResolver() ResolverIf {
if c.secure {
return dnssec.MakeDnssecResolver(dnssec.DefaultDnssecAwareNSServers, dnssec.DefaultTimeout)
}
return &Resolver{}
}
// SystemDnsaddrResolver returns the dnsaddr resolver that uses OS-defined DNS server
func (c *ResolveController) SystemDnsaddrResolver() *madns.Resolver {
resolver := c.SystemResolver()
// ignore errors here since we madns.WithDefaultResolver can't error
mResv, _ := madns.NewResolver(madns.WithDefaultResolver(resolver))
return mResv
}
// FallbackDnsaddrResolver returns the dnsaddr resolver w/ fallback DNS address
func (c *ResolveController) FallbackDnsaddrResolver() *madns.Resolver {
resolver := c.FallbackResolver()
// ignore errors here since we madns.WithDefaultResolver can't error
mResv, _ := madns.NewResolver(madns.WithDefaultResolver(resolver))
return mResv
}
// DefaultDnsaddrResolver returns the dnsaddr resolver w/ default DNS address
func (c *ResolveController) DefaultDnsaddrResolver() *madns.Resolver {
resolver := c.DefaultResolver()
mResv, _ := madns.NewResolver(madns.WithDefaultResolver(resolver))
return mResv
}
|
