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.). type DNSZone struct { Domain string PdsURL string } // dnsServer answers DNS for a market network's account domains: _atproto. 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 } } }