Source file
src/net/conf_test.go
1
2
3
4
5
6
7 package net
8
9 import (
10 "io/fs"
11 "os"
12 "testing"
13 "time"
14 )
15
16 type nssHostTest struct {
17 host string
18 localhost string
19 want hostLookupOrder
20 }
21
22 func nssStr(t *testing.T, s string) *nssConf {
23 f, err := os.CreateTemp(t.TempDir(), "nss")
24 if err != nil {
25 t.Fatal(err)
26 }
27 if _, err := f.WriteString(s); err != nil {
28 t.Fatal(err)
29 }
30 if err := f.Close(); err != nil {
31 t.Fatal(err)
32 }
33 return parseNSSConfFile(f.Name())
34 }
35
36
37 var defaultResolvConf = &dnsConfig{
38 servers: defaultNS,
39 ndots: 1,
40 timeout: 5,
41 attempts: 2,
42 err: fs.ErrNotExist,
43 }
44
45 func TestConfHostLookupOrder(t *testing.T) {
46
47
48 if netGoBuildTag {
49 t.Skip("skipping test because net package built with netgo tag")
50 }
51 if !cgoAvailable {
52 t.Skip("skipping test because cgo resolver not available")
53 }
54
55 tests := []struct {
56 name string
57 c *conf
58 nss *nssConf
59 resolver *Resolver
60 resolv *dnsConfig
61 hostTests []nssHostTest
62 }{
63 {
64 name: "force",
65 c: &conf{
66 preferCgo: true,
67 netCgo: true,
68 },
69 resolv: defaultResolvConf,
70 nss: nssStr(t, "foo: bar"),
71 hostTests: []nssHostTest{
72 {"foo.local", "myhostname", hostLookupCgo},
73 {"google.com", "myhostname", hostLookupCgo},
74 },
75 },
76 {
77 name: "netgo_dns_before_files",
78 c: &conf{
79 netGo: true,
80 },
81 resolv: defaultResolvConf,
82 nss: nssStr(t, "hosts: dns files"),
83 hostTests: []nssHostTest{
84 {"x.com", "myhostname", hostLookupDNSFiles},
85 },
86 },
87 {
88 name: "netgo_fallback_on_cgo",
89 c: &conf{
90 netGo: true,
91 },
92 resolv: defaultResolvConf,
93 nss: nssStr(t, "hosts: dns files something_custom"),
94 hostTests: []nssHostTest{
95 {"x.com", "myhostname", hostLookupDNSFiles},
96 },
97 },
98 {
99 name: "ubuntu_trusty_avahi",
100 c: &conf{
101 mdnsTest: mdnsAssumeDoesNotExist,
102 },
103 resolv: defaultResolvConf,
104 nss: nssStr(t, "hosts: files mdns4_minimal [NOTFOUND=return] dns mdns4"),
105 hostTests: []nssHostTest{
106 {"foo.local", "myhostname", hostLookupCgo},
107 {"foo.local.", "myhostname", hostLookupCgo},
108 {"foo.LOCAL", "myhostname", hostLookupCgo},
109 {"foo.LOCAL.", "myhostname", hostLookupCgo},
110 {"google.com", "myhostname", hostLookupFilesDNS},
111 },
112 },
113 {
114 name: "freebsdlinux_no_resolv_conf",
115 c: &conf{
116 goos: "freebsd",
117 },
118 resolv: defaultResolvConf,
119 nss: nssStr(t, "foo: bar"),
120 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupFilesDNS}},
121 },
122
123 {
124 name: "openbsd_no_resolv_conf",
125 c: &conf{
126 goos: "openbsd",
127 },
128 resolv: defaultResolvConf,
129 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupFiles}},
130 },
131 {
132 name: "solaris_no_nsswitch",
133 c: &conf{
134 goos: "solaris",
135 },
136 resolv: defaultResolvConf,
137 nss: &nssConf{err: fs.ErrNotExist},
138 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupCgo}},
139 },
140 {
141 name: "openbsd_lookup_bind_file",
142 c: &conf{
143 goos: "openbsd",
144 },
145 resolv: &dnsConfig{lookup: []string{"bind", "file"}},
146 hostTests: []nssHostTest{
147 {"google.com", "myhostname", hostLookupDNSFiles},
148 {"foo.local", "myhostname", hostLookupDNSFiles},
149 },
150 },
151 {
152 name: "openbsd_lookup_file_bind",
153 c: &conf{
154 goos: "openbsd",
155 },
156 resolv: &dnsConfig{lookup: []string{"file", "bind"}},
157 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupFilesDNS}},
158 },
159 {
160 name: "openbsd_lookup_bind",
161 c: &conf{
162 goos: "openbsd",
163 },
164 resolv: &dnsConfig{lookup: []string{"bind"}},
165 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupDNS}},
166 },
167 {
168 name: "openbsd_lookup_file",
169 c: &conf{
170 goos: "openbsd",
171 },
172 resolv: &dnsConfig{lookup: []string{"file"}},
173 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupFiles}},
174 },
175 {
176 name: "openbsd_lookup_yp",
177 c: &conf{
178 goos: "openbsd",
179 },
180 resolv: &dnsConfig{lookup: []string{"file", "bind", "yp"}},
181 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupCgo}},
182 },
183 {
184 name: "openbsd_lookup_two",
185 c: &conf{
186 goos: "openbsd",
187 },
188 resolv: &dnsConfig{lookup: []string{"file", "foo"}},
189 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupCgo}},
190 },
191 {
192 name: "openbsd_lookup_empty",
193 c: &conf{
194 goos: "openbsd",
195 },
196 resolv: &dnsConfig{lookup: nil},
197 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupDNSFiles}},
198 },
199 {
200 name: "linux_no_nsswitch.conf",
201 c: &conf{
202 goos: "linux",
203 },
204 resolv: defaultResolvConf,
205 nss: &nssConf{err: fs.ErrNotExist},
206 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupFilesDNS}},
207 },
208 {
209 name: "linux_empty_nsswitch.conf",
210 c: &conf{
211 goos: "linux",
212 },
213 resolv: defaultResolvConf,
214 nss: nssStr(t, ""),
215 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupFilesDNS}},
216 },
217 {
218 name: "files_mdns_dns",
219 c: &conf{
220 mdnsTest: mdnsAssumeDoesNotExist,
221 },
222 resolv: defaultResolvConf,
223 nss: nssStr(t, "hosts: files mdns dns"),
224 hostTests: []nssHostTest{
225 {"x.com", "myhostname", hostLookupFilesDNS},
226 {"x.local", "myhostname", hostLookupCgo},
227 },
228 },
229 {
230 name: "dns_special_hostnames",
231 c: &conf{},
232 resolv: defaultResolvConf,
233 nss: nssStr(t, "hosts: dns"),
234 hostTests: []nssHostTest{
235 {"x.com", "myhostname", hostLookupDNS},
236 {"x\\.com", "myhostname", hostLookupCgo},
237 {"foo.com%en0", "myhostname", hostLookupCgo},
238 },
239 },
240 {
241 name: "mdns_allow",
242 c: &conf{
243 mdnsTest: mdnsAssumeExists,
244 },
245 resolv: defaultResolvConf,
246 nss: nssStr(t, "hosts: files mdns dns"),
247 hostTests: []nssHostTest{
248 {"x.com", "myhostname", hostLookupCgo},
249 {"x.local", "myhostname", hostLookupCgo},
250 },
251 },
252 {
253 name: "files_dns",
254 c: &conf{},
255 resolv: defaultResolvConf,
256 nss: nssStr(t, "hosts: files dns"),
257 hostTests: []nssHostTest{
258 {"x.com", "myhostname", hostLookupFilesDNS},
259 {"x", "myhostname", hostLookupFilesDNS},
260 {"x.local", "myhostname", hostLookupFilesDNS},
261 },
262 },
263 {
264 name: "dns_files",
265 c: &conf{},
266 resolv: defaultResolvConf,
267 nss: nssStr(t, "hosts: dns files"),
268 hostTests: []nssHostTest{
269 {"x.com", "myhostname", hostLookupDNSFiles},
270 {"x", "myhostname", hostLookupDNSFiles},
271 {"x.local", "myhostname", hostLookupDNSFiles},
272 },
273 },
274 {
275 name: "something_custom",
276 c: &conf{},
277 resolv: defaultResolvConf,
278 nss: nssStr(t, "hosts: dns files something_custom"),
279 hostTests: []nssHostTest{
280 {"x.com", "myhostname", hostLookupCgo},
281 },
282 },
283 {
284 name: "myhostname",
285 c: &conf{},
286 resolv: defaultResolvConf,
287 nss: nssStr(t, "hosts: files dns myhostname"),
288 hostTests: []nssHostTest{
289 {"x.com", "myhostname", hostLookupFilesDNS},
290 {"myhostname", "myhostname", hostLookupCgo},
291 {"myHostname", "myhostname", hostLookupCgo},
292 {"myhostname.dot", "myhostname.dot", hostLookupCgo},
293 {"myHostname.dot", "myhostname.dot", hostLookupCgo},
294 {"_gateway", "myhostname", hostLookupCgo},
295 {"_Gateway", "myhostname", hostLookupCgo},
296 {"_outbound", "myhostname", hostLookupCgo},
297 {"_Outbound", "myhostname", hostLookupCgo},
298 {"localhost", "myhostname", hostLookupCgo},
299 {"Localhost", "myhostname", hostLookupCgo},
300 {"anything.localhost", "myhostname", hostLookupCgo},
301 {"Anything.localhost", "myhostname", hostLookupCgo},
302 {"localhost.localdomain", "myhostname", hostLookupCgo},
303 {"Localhost.Localdomain", "myhostname", hostLookupCgo},
304 {"anything.localhost.localdomain", "myhostname", hostLookupCgo},
305 {"Anything.Localhost.Localdomain", "myhostname", hostLookupCgo},
306 {"somehostname", "myhostname", hostLookupFilesDNS},
307 },
308 },
309 {
310 name: "ubuntu14.04.02",
311 c: &conf{
312 mdnsTest: mdnsAssumeDoesNotExist,
313 },
314 resolv: defaultResolvConf,
315 nss: nssStr(t, "hosts: files myhostname mdns4_minimal [NOTFOUND=return] dns mdns4"),
316 hostTests: []nssHostTest{
317 {"x.com", "myhostname", hostLookupFilesDNS},
318 {"somehostname", "myhostname", hostLookupFilesDNS},
319 {"myhostname", "myhostname", hostLookupCgo},
320 },
321 },
322
323
324
325
326 {
327 name: "debian_squeeze",
328 c: &conf{},
329 resolv: defaultResolvConf,
330 nss: nssStr(t, "hosts: dns [success=return notfound=continue unavail=continue tryagain=continue] files [notfound=return]"),
331 hostTests: []nssHostTest{
332 {"x.com", "myhostname", hostLookupDNSFiles},
333 {"somehostname", "myhostname", hostLookupDNSFiles},
334 },
335 },
336 {
337 name: "resolv.conf-unknown",
338 c: &conf{},
339 resolv: &dnsConfig{servers: defaultNS, ndots: 1, timeout: 5, attempts: 2, unknownOpt: true},
340 nss: nssStr(t, "foo: bar"),
341 hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupCgo}},
342 },
343
344 {
345 name: "resolver-prefergo",
346 resolver: &Resolver{PreferGo: true},
347 c: &conf{
348 preferCgo: true,
349 netCgo: true,
350 },
351 resolv: defaultResolvConf,
352 nss: nssStr(t, ""),
353 hostTests: []nssHostTest{
354 {"localhost", "myhostname", hostLookupFilesDNS},
355 },
356 },
357 {
358 name: "unknown-source",
359 resolver: &Resolver{PreferGo: true},
360 c: &conf{},
361 resolv: defaultResolvConf,
362 nss: nssStr(t, "hosts: resolve files"),
363 hostTests: []nssHostTest{
364 {"x.com", "myhostname", hostLookupDNSFiles},
365 },
366 },
367 {
368 name: "dns-among-unknown-sources",
369 resolver: &Resolver{PreferGo: true},
370 c: &conf{},
371 resolv: defaultResolvConf,
372 nss: nssStr(t, "hosts: mymachines files dns"),
373 hostTests: []nssHostTest{
374 {"x.com", "myhostname", hostLookupFilesDNS},
375 },
376 },
377 {
378 name: "dns-among-unknown-sources-2",
379 resolver: &Resolver{PreferGo: true},
380 c: &conf{},
381 resolv: defaultResolvConf,
382 nss: nssStr(t, "hosts: dns mymachines files"),
383 hostTests: []nssHostTest{
384 {"x.com", "myhostname", hostLookupDNSFiles},
385 },
386 },
387 }
388
389 origGetHostname := getHostname
390 defer func() { getHostname = origGetHostname }()
391 defer setSystemNSS(getSystemNSS(), 0)
392 conf, err := newResolvConfTest()
393 if err != nil {
394 t.Fatal(err)
395 }
396 defer conf.teardown()
397
398 for _, tt := range tests {
399 if !conf.forceUpdateConf(tt.resolv, time.Now().Add(time.Hour)) {
400 t.Errorf("%s: failed to change resolv config", tt.name)
401 }
402 for _, ht := range tt.hostTests {
403 getHostname = func() (string, error) { return ht.localhost, nil }
404 setSystemNSS(tt.nss, time.Hour)
405
406 gotOrder, _ := tt.c.hostLookupOrder(tt.resolver, ht.host)
407 if gotOrder != ht.want {
408 t.Errorf("%s: hostLookupOrder(%q) = %v; want %v", tt.name, ht.host, gotOrder, ht.want)
409 }
410 }
411 }
412 }
413
414 func TestAddrLookupOrder(t *testing.T) {
415
416
417 if netGoBuildTag {
418 t.Skip("skipping test because net package built with netgo tag")
419 }
420 if !cgoAvailable {
421 t.Skip("skipping test because cgo resolver not available")
422 }
423
424 defer setSystemNSS(getSystemNSS(), 0)
425 c, err := newResolvConfTest()
426 if err != nil {
427 t.Fatal(err)
428 }
429 defer c.teardown()
430
431 if !c.forceUpdateConf(defaultResolvConf, time.Now().Add(time.Hour)) {
432 t.Fatal("failed to change resolv config")
433 }
434
435 setSystemNSS(nssStr(t, "hosts: files myhostname dns"), time.Hour)
436 cnf := &conf{}
437 order, _ := cnf.addrLookupOrder(nil, "192.0.2.1")
438 if order != hostLookupCgo {
439 t.Errorf("addrLookupOrder returned: %v, want cgo", order)
440 }
441
442 setSystemNSS(nssStr(t, "hosts: files mdns4 dns"), time.Hour)
443 order, _ = cnf.addrLookupOrder(nil, "192.0.2.1")
444 if order != hostLookupCgo {
445 t.Errorf("addrLookupOrder returned: %v, want cgo", order)
446 }
447
448 }
449
450 func setSystemNSS(nss *nssConf, addDur time.Duration) {
451 nssConfig.mu.Lock()
452 nssConfig.nssConf = nss
453 nssConfig.mu.Unlock()
454 nssConfig.acquireSema()
455 nssConfig.lastChecked = time.Now().Add(addDur)
456 nssConfig.releaseSema()
457 }
458
459 func TestSystemConf(t *testing.T) {
460 systemConf()
461 }
462
View as plain text