-
Notifications
You must be signed in to change notification settings - Fork 0
/
dns.go
143 lines (120 loc) · 3.29 KB
/
dns.go
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package namesys
import (
"context"
"errors"
"net"
"strings"
opts "github.com/ipfs/go-ipfs/namesys/opts"
path "gx/ipfs/QmT3rzed1ppXefourpmoZ7tyVQfsGPQZ1pHDngLmCvXxd3/go-path"
isd "gx/ipfs/QmZmmuAXgX73UQmX1jRKjTGmjzq24Jinqkq8vzkBtno4uX/go-is-domain"
)
type LookupTXTFunc func(name string) (txt []string, err error)
// DNSResolver implements a Resolver on DNS domains
type DNSResolver struct {
lookupTXT LookupTXTFunc
// TODO: maybe some sort of caching?
// cache would need a timeout
}
// NewDNSResolver constructs a name resolver using DNS TXT records.
func NewDNSResolver() *DNSResolver {
return &DNSResolver{lookupTXT: net.LookupTXT}
}
// Resolve implements Resolver.
func (r *DNSResolver) Resolve(ctx context.Context, name string, options ...opts.ResolveOpt) (path.Path, error) {
return resolve(ctx, r, name, opts.ProcessOpts(options))
}
// ResolveAsync implements Resolver.
func (r *DNSResolver) ResolveAsync(ctx context.Context, name string, options ...opts.ResolveOpt) <-chan Result {
return resolveAsync(ctx, r, name, opts.ProcessOpts(options))
}
type lookupRes struct {
path path.Path
error error
}
// resolveOnce implements resolver.
// TXT records for a given domain name should contain a b58
// encoded multihash.
func (r *DNSResolver) resolveOnceAsync(ctx context.Context, name string, options opts.ResolveOpts) <-chan onceResult {
out := make(chan onceResult, 1)
segments := strings.SplitN(name, "/", 2)
domain := segments[0]
if !isd.IsDomain(domain) {
out <- onceResult{err: errors.New("not a valid domain name")}
close(out)
return out
}
log.Debugf("DNSResolver resolving %s", domain)
rootChan := make(chan lookupRes, 1)
go workDomain(r, domain, rootChan)
subChan := make(chan lookupRes, 1)
go workDomain(r, "_dnslink."+domain, subChan)
appendPath := func(p path.Path) (path.Path, error) {
if len(segments) > 1 {
return path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[1])
}
return p, nil
}
go func() {
defer close(out)
for {
select {
case subRes, ok := <-subChan:
if !ok {
subChan = nil
break
}
if subRes.error == nil {
p, err := appendPath(subRes.path)
emitOnceResult(ctx, out, onceResult{value: p, err: err})
return
}
case rootRes, ok := <-rootChan:
if !ok {
rootChan = nil
break
}
if rootRes.error == nil {
p, err := appendPath(rootRes.path)
emitOnceResult(ctx, out, onceResult{value: p, err: err})
}
case <-ctx.Done():
return
}
if subChan == nil && rootChan == nil {
return
}
}
}()
return out
}
func workDomain(r *DNSResolver, name string, res chan lookupRes) {
defer close(res)
txt, err := r.lookupTXT(name)
if err != nil {
// Error is != nil
res <- lookupRes{"", err}
return
}
for _, t := range txt {
p, err := parseEntry(t)
if err == nil {
res <- lookupRes{p, nil}
return
}
}
res <- lookupRes{"", ErrResolveFailed}
}
func parseEntry(txt string) (path.Path, error) {
p, err := path.ParseCidToPath(txt) // bare IPFS multihashes
if err == nil {
return p, nil
}
return tryParseDnsLink(txt)
}
func tryParseDnsLink(txt string) (path.Path, error) {
parts := strings.SplitN(txt, "=", 2)
if len(parts) == 2 && parts[0] == "dnslink" {
return path.ParsePath(parts[1])
}
return "", errors.New("not a valid dnslink entry")
}