refactor: DNSTransport I/Os DNS messages (#760)

This diff refactors the DNSTransport model to receive in input a DNSQuery and return in output a DNSResponse.

The design of DNSQuery and DNSResponse takes into account the use case of a transport using getaddrinfo, meaning that we don't need to serialize and deserialize messages when using getaddrinfo.

The current codebase does not use a getaddrinfo transport, but I wrote one such a transport in the Websteps Winter 2021 prototype (https://github.com/bassosimone/websteps-illustrated/).

The design conversation that lead to producing this diff is https://github.com/ooni/probe/issues/2099

internal/netxlite/dnsovertcp.go

@@ -20,9 +20,12 @@ type DialContextFunc func(context.Context, string, string) (net.Conn, error)
 
 // DNSOverTCPTransport is a DNS-over-{TCP,TLS} DNSTransport.
 //
-// Bug: this implementation always creates a new connection for each query.
+// Note: this implementation always creates a new connection for each query. This
+// strategy is less efficient but MAY be more robust for cleartext TCP connections
+// when querying for a blocked domain name causes endpoint blocking.
 type DNSOverTCPTransport struct {
 	dial            DialContextFunc
+	decoder         model.DNSDecoder
 	address         string
 	network         string
 	requiresPadding bool
@@ -36,47 +39,58 @@ type DNSOverTCPTransport struct {
 //
 // - address is the endpoint address (e.g., 8.8.8.8:53).
 func NewDNSOverTCPTransport(dial DialContextFunc, address string) *DNSOverTCPTransport {
-	return &DNSOverTCPTransport{
-		dial:            dial,
-		address:         address,
-		network:         "tcp",
-		requiresPadding: false,
-	}
+	return newDNSOverTCPOrTLSTransport(dial, "tcp", address, false)
 }
 
-// NewDNSOverTLS creates a new DNSOverTLS transport.
+// NewDNSOverTLSTransport creates a new DNSOverTLS transport.
 //
 // Arguments:
 //
 // - dial is a function with the net.Dialer.DialContext's signature;
 //
 // - address is the endpoint address (e.g., 8.8.8.8:853).
-func NewDNSOverTLS(dial DialContextFunc, address string) *DNSOverTCPTransport {
+func NewDNSOverTLSTransport(dial DialContextFunc, address string) *DNSOverTCPTransport {
+	return newDNSOverTCPOrTLSTransport(dial, "dot", address, true)
+}
+
+// newDNSOverTCPOrTLSTransport is the common factory for creating a transport
+func newDNSOverTCPOrTLSTransport(
+	dial DialContextFunc, network, address string, padding bool) *DNSOverTCPTransport {
 	return &DNSOverTCPTransport{
 		dial:            dial,
+		decoder:         &DNSDecoderMiekg{},
 		address:         address,
-		network:         "dot",
-		requiresPadding: true,
+		network:         network,
+		requiresPadding: padding,
 	}
 }
 
+// errQueryTooLarge indicates the query is too large for the transport.
+var errQueryTooLarge = errors.New("oodns: query too large for this transport")
+
 // RoundTrip sends a query and receives a reply.
-func (t *DNSOverTCPTransport) RoundTrip(ctx context.Context, query []byte) ([]byte, error) {
-	if len(query) > math.MaxUint16 {
-		return nil, errors.New("query too long")
+func (t *DNSOverTCPTransport) RoundTrip(
+	ctx context.Context, query model.DNSQuery) (model.DNSResponse, error) {
+	// TODO(bassosimone): this method should more strictly honour the context, which
+	// currently is only used to bound the dial operation
+	rawQuery, err := query.Bytes()
+	if err != nil {
+		return nil, err
+	}
+	if len(rawQuery) > math.MaxUint16 {
+		return nil, errQueryTooLarge
 	}
 	conn, err := t.dial(ctx, "tcp", t.address)
 	if err != nil {
 		return nil, err
 	}
 	defer conn.Close()
-	if err = conn.SetDeadline(time.Now().Add(10 * time.Second)); err != nil {
-		return nil, err
-	}
+	const iotimeout = 10 * time.Second
+	conn.SetDeadline(time.Now().Add(iotimeout))
 	// Write request
-	buf := []byte{byte(len(query) >> 8)}
-	buf = append(buf, byte(len(query)))
-	buf = append(buf, query...)
+	buf := []byte{byte(len(rawQuery) >> 8)}
+	buf = append(buf, byte(len(rawQuery)))
+	buf = append(buf, rawQuery...)
 	if _, err = conn.Write(buf); err != nil {
 		return nil, err
 	}
@@ -86,11 +100,11 @@ func (t *DNSOverTCPTransport) RoundTrip(ctx context.Context, query []byte) ([]by
 		return nil, err
 	}
 	length := int(header[0])<<8 | int(header[1])
-	reply := make([]byte, length)
-	if _, err = io.ReadFull(conn, reply); err != nil {
+	rawResponse := make([]byte, length)
+	if _, err = io.ReadFull(conn, rawResponse); err != nil {
 		return nil, err
 	}
-	return reply, nil
+	return t.decoder.DecodeResponse(rawResponse, query)
 }
 
 // RequiresPadding returns true for DoT and false for TCP