~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
220 lines · 5.8 KB Raw History
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
		}
	}
}