From 80e7ded4fb01bf2da27e9d443527cfc2d2365a05 Mon Sep 17 00:00:00 2001 From: grumbulon Date: Fri, 16 Sep 2022 19:20:00 -0400 Subject: [PATCH] resolver receiever consistency --- pkg/resolvers/DNSCrypt.go | 16 ++++++++-------- pkg/resolvers/HTTPS.go | 12 ++++++------ pkg/resolvers/QUIC.go | 26 +++++++++++++------------- pkg/resolvers/general.go | 30 +++++++++++++++--------------- 4 files changed, 42 insertions(+), 42 deletions(-) diff --git a/pkg/resolvers/DNSCrypt.go b/pkg/resolvers/DNSCrypt.go index 18927ef..dca3531 100644 --- a/pkg/resolvers/DNSCrypt.go +++ b/pkg/resolvers/DNSCrypt.go @@ -19,28 +19,28 @@ type DNSCryptResolver struct { var _ Resolver = (*DNSCryptResolver)(nil) // LookUp performs a DNS query. -func (r *DNSCryptResolver) LookUp(msg *dns.Msg) (util.Response, error) { +func (resolver *DNSCryptResolver) LookUp(msg *dns.Msg) (util.Response, error) { client := dnscrypt.Client{ - Timeout: r.opts.Request.Timeout, + Timeout: resolver.opts.Request.Timeout, UDPSize: 1232, } - if r.opts.TCP || r.opts.TLS { + if resolver.opts.TCP || resolver.opts.TLS { client.Net = tcp } else { client.Net = udp } switch { - case r.opts.IPv4: + case resolver.opts.IPv4: client.Net += "4" - case r.opts.IPv6: + case resolver.opts.IPv6: client.Net += "6" } - r.opts.Logger.Debug("Using", client.Net, "for making the request") + resolver.opts.Logger.Debug("Using", client.Net, "for making the request") - resolverInf, err := client.Dial(r.opts.Request.Server) + resolverInf, err := client.Dial(resolver.opts.Request.Server) if err != nil { return util.Response{}, fmt.Errorf("dnscrypt: dial: %w", err) } @@ -53,7 +53,7 @@ func (r *DNSCryptResolver) LookUp(msg *dns.Msg) (util.Response, error) { return util.Response{}, fmt.Errorf("dnscrypt: exchange: %w", err) } - r.opts.Logger.Info("Request successful") + resolver.opts.Logger.Info("Request successful") return util.Response{ DNS: res, diff --git a/pkg/resolvers/HTTPS.go b/pkg/resolvers/HTTPS.go index d090a18..e4c4388 100644 --- a/pkg/resolvers/HTTPS.go +++ b/pkg/resolvers/HTTPS.go @@ -21,11 +21,11 @@ type HTTPSResolver struct { var _ Resolver = (*HTTPSResolver)(nil) // LookUp performs a DNS query. -func (r *HTTPSResolver) LookUp(msg *dns.Msg) (util.Response, error) { +func (resolver *HTTPSResolver) LookUp(msg *dns.Msg) (util.Response, error) { var resp util.Response httpR := &http.Client{ - Timeout: r.opts.Request.Timeout, + Timeout: resolver.opts.Request.Timeout, } buf, err := msg.Pack() @@ -33,9 +33,9 @@ func (r *HTTPSResolver) LookUp(msg *dns.Msg) (util.Response, error) { return util.Response{}, fmt.Errorf("doh: packing: %w", err) } - r.opts.Logger.Debug("https: sending HTTPS request") + resolver.opts.Logger.Debug("https: sending HTTPS request") - req, err := http.NewRequest("POST", r.opts.Request.Server, bytes.NewBuffer(buf)) + req, err := http.NewRequest("POST", resolver.opts.Request.Server, bytes.NewBuffer(buf)) if err != nil { return util.Response{}, fmt.Errorf("doh: request creation: %w", err) } @@ -55,7 +55,7 @@ func (r *HTTPSResolver) LookUp(msg *dns.Msg) (util.Response, error) { return util.Response{}, &errHTTPStatus{res.StatusCode} } - r.opts.Logger.Debug("https: reading response") + resolver.opts.Logger.Debug("https: reading response") fullRes, err := io.ReadAll(res.Body) if err != nil { @@ -67,7 +67,7 @@ func (r *HTTPSResolver) LookUp(msg *dns.Msg) (util.Response, error) { return util.Response{}, fmt.Errorf("doh: body close: %w", err) } - r.opts.Logger.Debug("https: unpacking response") + resolver.opts.Logger.Debug("https: unpacking response") resp.DNS = &dns.Msg{} diff --git a/pkg/resolvers/QUIC.go b/pkg/resolvers/QUIC.go index 94df961..60999be 100644 --- a/pkg/resolvers/QUIC.go +++ b/pkg/resolvers/QUIC.go @@ -21,28 +21,28 @@ type QUICResolver struct { var _ Resolver = (*QUICResolver)(nil) // LookUp performs a DNS query. -func (r *QUICResolver) LookUp(msg *dns.Msg) (util.Response, error) { +func (resolver *QUICResolver) LookUp(msg *dns.Msg) (util.Response, error) { var resp util.Response tls := &tls.Config{ //nolint:gosec // This is intentional if the user requests it - InsecureSkipVerify: r.opts.TLSNoVerify, - ServerName: r.opts.TLSHost, + InsecureSkipVerify: resolver.opts.TLSNoVerify, + ServerName: resolver.opts.TLSHost, MinVersion: tls.VersionTLS12, NextProtos: []string{"doq"}, } conf := new(quic.Config) - conf.HandshakeIdleTimeout = r.opts.Request.Timeout + conf.HandshakeIdleTimeout = resolver.opts.Request.Timeout - r.opts.Logger.Debug("quic: making query") + resolver.opts.Logger.Debug("quic: making query") - connection, err := quic.DialAddr(r.opts.Request.Server, tls, conf) + connection, err := quic.DialAddr(resolver.opts.Request.Server, tls, conf) if err != nil { return util.Response{}, fmt.Errorf("doq: dial: %w", err) } - r.opts.Logger.Debug("quic: packing query") + resolver.opts.Logger.Debug("quic: packing query") // Compress request to over-the-wire buf, err := msg.Pack() @@ -52,21 +52,21 @@ func (r *QUICResolver) LookUp(msg *dns.Msg) (util.Response, error) { t := time.Now() - r.opts.Logger.Debug("quic: creating stream") + resolver.opts.Logger.Debug("quic: creating stream") stream, err := connection.OpenStream() if err != nil { return util.Response{}, fmt.Errorf("doq: quic stream creation: %w", err) } - r.opts.Logger.Debug("quic: writing to stream") + resolver.opts.Logger.Debug("quic: writing to stream") _, err = stream.Write(buf) if err != nil { return util.Response{}, fmt.Errorf("doq: quic stream write: %w", err) } - r.opts.Logger.Debug("quic: reading stream") + resolver.opts.Logger.Debug("quic: reading stream") fullRes, err := io.ReadAll(stream) if err != nil { @@ -75,14 +75,14 @@ func (r *QUICResolver) LookUp(msg *dns.Msg) (util.Response, error) { resp.RTT = time.Since(t) - r.opts.Logger.Debug("quic: closing connection") + resolver.opts.Logger.Debug("quic: closing connection") // Close with error: no error err = connection.CloseWithError(0, "") if err != nil { return util.Response{}, fmt.Errorf("doq: quic connection close: %w", err) } - r.opts.Logger.Debug("quic: closing stream") + resolver.opts.Logger.Debug("quic: closing stream") err = stream.Close() if err != nil { @@ -91,7 +91,7 @@ func (r *QUICResolver) LookUp(msg *dns.Msg) (util.Response, error) { resp.DNS = &dns.Msg{} - r.opts.Logger.Debug("quic: unpacking response") + resolver.opts.Logger.Debug("quic: unpacking response") err = resp.DNS.Unpack(fullRes) if err != nil { diff --git a/pkg/resolvers/general.go b/pkg/resolvers/general.go index 907e6d3..88353af 100644 --- a/pkg/resolvers/general.go +++ b/pkg/resolvers/general.go @@ -19,7 +19,7 @@ type StandardResolver struct { var _ Resolver = (*StandardResolver)(nil) // LookUp performs a DNS query. -func (r *StandardResolver) LookUp(msg *dns.Msg) (util.Response, error) { +func (resolver *StandardResolver) LookUp(msg *dns.Msg) (util.Response, error) { var ( resp util.Response err error @@ -27,53 +27,53 @@ func (r *StandardResolver) LookUp(msg *dns.Msg) (util.Response, error) { dnsClient := new(dns.Client) dnsClient.Dialer = &net.Dialer{ - Timeout: r.opts.Request.Timeout, + Timeout: resolver.opts.Request.Timeout, } - if r.opts.TCP || r.opts.TLS { + if resolver.opts.TCP || resolver.opts.TLS { dnsClient.Net = tcp } else { dnsClient.Net = udp } switch { - case r.opts.IPv4: + case resolver.opts.IPv4: dnsClient.Net += "4" - case r.opts.IPv6: + case resolver.opts.IPv6: dnsClient.Net += "6" } - if r.opts.TLS { + if resolver.opts.TLS { dnsClient.Net += "-tls" dnsClient.TLSConfig = &tls.Config{ //nolint:gosec // This is intentional if the user requests it - InsecureSkipVerify: r.opts.TLSNoVerify, - ServerName: r.opts.TLSHost, + InsecureSkipVerify: resolver.opts.TLSNoVerify, + ServerName: resolver.opts.TLSHost, } } - r.opts.Logger.Debug("Using", dnsClient.Net, "for making the request") + resolver.opts.Logger.Debug("Using", dnsClient.Net, "for making the request") - resp.DNS, resp.RTT, err = dnsClient.Exchange(msg, r.opts.Request.Server) + resp.DNS, resp.RTT, err = dnsClient.Exchange(msg, resolver.opts.Request.Server) if err != nil { return util.Response{}, fmt.Errorf("standard: DNS exchange: %w", err) } - r.opts.Logger.Info("Request successful") + resolver.opts.Logger.Info("Request successful") - if resp.DNS.MsgHdr.Truncated && !r.opts.Truncate { + if resp.DNS.MsgHdr.Truncated && !resolver.opts.Truncate { fmt.Printf(";; Truncated, retrying with TCP\n\n") dnsClient.Net = tcp switch { - case r.opts.IPv4: + case resolver.opts.IPv4: dnsClient.Net += "4" - case r.opts.IPv6: + case resolver.opts.IPv6: dnsClient.Net += "6" } - resp.DNS, resp.RTT, err = dnsClient.Exchange(msg, r.opts.Request.Server) + resp.DNS, resp.RTT, err = dnsClient.Exchange(msg, resolver.opts.Request.Server) } if err != nil {