ipnlocal, resolver, etc: add peer API DoHcrawshaw/peerdoh

3 files changed, 54 insertions, 16 deletions

diff --git a/net/dns/manager.go b/net/dns/manager.go
index 121ee1732..786be41e4 100644
--- a/net/dns/manager.go
+++ b/net/dns/manager.go
@@ -6,6 +6,7 @@ package dns
 
 import (
 	"bufio"
+	"context"
 	"runtime"
 	"time"
 
@@ -195,6 +196,10 @@ func (m *Manager) NextResponse() ([]byte, netaddr.IPPort, error) {
 	return m.resolver.NextResponse()
 }
 
+func (m *Manager) Request(ctx context.Context, bs []byte) ([]byte, error) {
+	return m.resolver.Request(ctx, bs)
+}
+
 func (m *Manager) Down() error {
 	if err := m.os.Close(); err != nil {
 		return err
diff --git a/net/dns/resolver/forwarder.go b/net/dns/resolver/forwarder.go
index 5d1904468..8f4e641f9 100644
--- a/net/dns/resolver/forwarder.go
+++ b/net/dns/resolver/forwarder.go
@@ -529,28 +529,56 @@ type forwardQuery struct {
 
 // forward forwards the query to all upstream nameservers and returns the first response.
 func (f *forwarder) forward(query packet) error {
-	domain, err := nameFromQuery(query.bs)
+	ctx, cancel := context.WithTimeout(f.ctx, responseTimeout)
+	defer cancel()
+
+	v, err := f.forwardQuery(ctx, query.bs)
 	if err != nil {
 		return err
 	}
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case f.responses <- packet{v, query.addr}:
+		return nil
+	}
+}
 
-	clampEDNSSize(query.bs, maxResponseBytes)
+func (f *forwarder) Forward(ctx context.Context, bs []byte) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(ctx, responseTimeout)
+	defer cancel()
+
+	go func() {
+		select {
+		case <-f.ctx.Done():
+			cancel()
+		case <-ctx.Done():
+		}
+	}()
+
+	return f.forwardQuery(ctx, bs)
+}
+
+func (f *forwarder) forwardQuery(ctx context.Context, bs []byte) ([]byte, error) {
+	domain, err := nameFromQuery(bs)
+	if err != nil {
+		return nil, err
+	}
+
+	clampEDNSSize(bs, maxResponseBytes)
 
 	resolvers := f.resolvers(domain)
 	if len(resolvers) == 0 {
-		return errNoUpstreams
+		return nil, errNoUpstreams
 	}
 
 	fq := &forwardQuery{
-		txid:           getTxID(query.bs),
-		packet:         query.bs,
+		txid:           getTxID(bs),
+		packet:         bs,
 		closeOnCtxDone: new(closePool),
 	}
 	defer fq.closeOnCtxDone.Close()
 
-	ctx, cancel := context.WithTimeout(f.ctx, responseTimeout)
-	defer cancel()
-
 	resc := make(chan []byte, 1)
 	var (
 		mu       sync.Mutex
@@ -586,19 +614,14 @@ func (f *forwarder) forward(query packet) error {
 
 	select {
 	case v := <-resc:
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case f.responses <- packet{v, query.addr}:
-			return nil
-		}
+		return v, nil
 	case <-ctx.Done():
 		mu.Lock()
 		defer mu.Unlock()
 		if firstErr != nil {
-			return firstErr
+			return nil, firstErr
 		}
-		return ctx.Err()
+		return nil, ctx.Err()
 	}
 }
 
diff --git a/net/dns/resolver/tsdns.go b/net/dns/resolver/tsdns.go
index bdd7b6318..04136ce46 100644
--- a/net/dns/resolver/tsdns.go
+++ b/net/dns/resolver/tsdns.go
@@ -8,6 +8,7 @@ package resolver
 
 import (
 	"bufio"
+	"context"
 	"encoding/hex"
 	"errors"
 	"fmt"
@@ -270,6 +271,15 @@ func (r *Resolver) NextResponse() (packet []byte, to netaddr.IPPort, err error)
 	}
 }
 
+// Request issues a DNS request and returns the result.
+func (r *Resolver) Request(ctx context.Context, bs []byte) ([]byte, error) {
+	out, err := r.respond(bs)
+	if err == errNotOurName {
+		return r.forwarder.Forward(ctx, bs)
+	}
+	return out, err
+}
+
 // resolveLocal returns an IP for the given domain, if domain is in
 // the local hosts map and has an IP corresponding to the requested
 // typ (A, AAAA, ALL).