0
0
package plc
import (
"context"
"encoding/binary"
"encoding/json"
"errors"
"io"
"log/slog"
"net"
"net/http"
"net/netip"
"net/url"
"strings"
"sync"
"time"
"golang.org/x/net/dns/dnsmessage"
)
// DNSZone is an account domain of a market network and the PDS that holds its accounts (plan 0045: in-network handles
// resolve the prod way, by DNS TXT _atproto.<handle>).
type DNSZone struct {
Domain string
PdsURL string
}
// dnsServer answers DNS for a market network's account domains: _atproto.<handle> TXT from the zone's PDS
// (com.atproto.identity.resolveHandle), NXDOMAIN for any other name.
type dnsServer struct {
zones []DNSZone
address netip.Addr
client *http.Client
log *slog.Logger
}
const dnsTTL = 30
func (d *dnsServer) zoneOf(name string) (DNSZone, bool) {
name = strings.ToLower(strings.TrimSuffix(name, "."))
for _, z := range d.zones {
dom := strings.ToLower(strings.TrimSuffix(z.Domain, "."))
if name == dom || strings.HasSuffix(name, "."+dom) {
return z, true
}
}
return DNSZone{}, false
}
func (d *dnsServer) resolveHandle(ctx context.Context, z DNSZone, handle string) (string, error) {
u := strings.TrimRight(z.PdsURL, "/") + "/xrpc/com.atproto.identity.resolveHandle?handle=" + url.QueryEscape(handle)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
if err != nil {
return "", err
}
resp, err := d.client.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusBadRequest || resp.StatusCode == http.StatusNotFound {
return "", nil
}
if resp.StatusCode != http.StatusOK {
return "", errors.New(resp.Status)
}
var out struct {
DID string `json:"did"`
}
if err := json.NewDecoder(io.LimitReader(resp.Body, 1<<16)).Decode(&out); err != nil {
return "", err
}
return out.DID, nil
}
// answer builds the reply to one query message.
func (d *dnsServer) answer(ctx context.Context, query []byte) ([]byte, error) {
var p dnsmessage.Parser
h, err := p.Start(query)
if err != nil {
return nil, err
}
q, err := p.Question()
if err != nil {
return nil, err
}
reply := dnsmessage.Header{ID: h.ID, Response: true, Authoritative: true, RecursionDesired: h.RecursionDesired, RecursionAvailable: h.RecursionDesired}
name := q.Name.String()
zone, ok := d.zoneOf(name)
var txt []string
var a netip.Addr
switch {
case !ok:
// a name outside the zones has no record here; NXDOMAIN, not REFUSED: a resolver walking its search list after
// an NXDOMAIN reports a REFUSED as a misbehaving server instead of not found
reply.RCode = dnsmessage.RCodeNameError
case q.Type == dnsmessage.TypeTXT && strings.HasPrefix(strings.ToLower(name), "_atproto.") && zone.PdsURL != "":
handle := strings.TrimSuffix(strings.TrimPrefix(strings.ToLower(name), "_atproto."), ".")
did, err := d.resolveHandle(ctx, zone, handle)
switch {
case err != nil:
d.log.Warn("network_dns_resolve_failed", "handle", handle, "err", err.Error())
reply.RCode = dnsmessage.RCodeServerFailure
case did == "":
reply.RCode = dnsmessage.RCodeNameError
default:
txt = []string{"did=" + did}
}
case q.Type == dnsmessage.TypeA && d.address.Is4():
a = d.address
default:
}
b := dnsmessage.NewBuilder(nil, reply)
b.EnableCompression()
if err := b.StartQuestions(); err != nil {
return nil, err
}
if err := b.Question(q); err != nil {
return nil, err
}
if err := b.StartAnswers(); err != nil {
return nil, err
}
if a.IsValid() {
if err := b.AResource(dnsmessage.ResourceHeader{Name: q.Name, Class: dnsmessage.ClassINET, TTL: dnsTTL}, dnsmessage.AResource{A: a.As4()}); err != nil {
return nil, err
}
}
if txt != nil {
if err := b.TXTResource(dnsmessage.ResourceHeader{Name: q.Name, Class: dnsmessage.ClassINET, TTL: dnsTTL}, dnsmessage.TXTResource{TXT: txt}); err != nil {
return nil, err
}
}
return b.Finish()
}
// serveDNS answers on addr over UDP and TCP until ctx ends. A port still held (the previous instance of the component
// closing its sockets, a fixed port 53 on a bound network) is bound again every half second until ctx ends.
func (d *dnsServer) serveDNS(ctx context.Context, addr string) error {
var pc net.PacketConn
var ln net.Listener
for warned := false; ; {
var err error
if pc, err = net.ListenPacket("udp", addr); err == nil {
if ln, err = net.Listen("tcp", addr); err == nil {
break
}
pc.Close()
}
if !warned {
d.log.Warn("network_dns_bind_retry", "address", addr, "err", err.Error())
warned = true
}
select {
case <-ctx.Done():
return err
case <-time.After(500 * time.Millisecond):
}
}
var wg sync.WaitGroup
wg.Go(func() {
<-ctx.Done()
pc.Close()
ln.Close()
})
wg.Go(func() {
buf := make([]byte, 1500)
for {
n, from, err := pc.ReadFrom(buf)
if err != nil {
return
}
q := append([]byte(nil), buf[:n]...)
go func() {
qctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if out, err := d.answer(qctx, q); err == nil {
_, _ = pc.WriteTo(out, from)
}
}()
}
})
wg.Go(func() {
for {
c, err := ln.Accept()
if err != nil {
return
}
go d.serveTCP(ctx, c)
}
})
d.log.Info("network_dns_serving", "address", addr, "zones", len(d.zones))
wg.Wait()
return nil
}
func (d *dnsServer) serveTCP(ctx context.Context, c net.Conn) {
defer c.Close()
for {
_ = c.SetDeadline(time.Now().Add(10 * time.Second))
var l [2]byte
if _, err := io.ReadFull(c, l[:]); err != nil {
return
}
q := make([]byte, binary.BigEndian.Uint16(l[:]))
if _, err := io.ReadFull(c, q); err != nil {
return
}
qctx, cancel := context.WithTimeout(ctx, 5*time.Second)
out, err := d.answer(qctx, q)
cancel()
if err != nil {
return
}
binary.BigEndian.PutUint16(l[:], uint16(len(out)))
if _, err := c.Write(append(l[:], out...)); err != nil {
return
}
}
}