2025-08-19 23:01:26

Author: mohanson

protocol/etch/cmd/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"flag"
+	"log"
+	"net"
+	"net/url"
+
+	"github.com/mohanson/daze"
+	"github.com/mohanson/daze/lib/doa"
+	"github.com/mohanson/daze/protocol/etch"
+)
+
+func ResolverDoe(addr string) *net.Resolver {
+	urls := doa.Try(url.Parse(addr))
+	host := doa.Try(net.LookupHost(urls.Hostname()))[0]
+	port := urls.Port()
+	urls.Host = host
+	if port != "" {
+		urls.Host = host + ":" + port
+	}
+	return &net.Resolver{
+		PreferGo: true,
+		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
+			conn := &daze.WireConn{
+				Call: func(b []byte) ([]byte, error) {
+					return etch.NewClient(addr).Call("Dns.Wire", b)
+				},
+				Data: bytes.NewBuffer([]byte{}),
+			}
+			return conn, nil
+		},
+	}
+}
+
+func main() {
+	flag.Parse()
+	switch flag.Arg(0) {
+	case "server":
+		server := etch.NewServer("127.0.0.1:8080")
+		server.Run()
+		select {}
+	case "client":
+		dns := ResolverDoe("http://127.0.0.1:8080")
+		log.Println(dns.LookupHost(context.Background(), "google.com"))
+	}
+}

protocol/etch/engine.go

@@ -0,0 +1,129 @@
+package etch
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"net/rpc"
+	"net/rpc/jsonrpc"
+
+	"github.com/mohanson/daze"
+	"github.com/mohanson/daze/lib/doa"
+)
+
+// Dns represents a DNS resolver that communicates with a DNS server.
+type Dns struct {
+	Server string // URL of the DNS server (e.g., "https://1.1.1.1/dns-query")
+}
+
+// Wire processes a DNS query by sending it to the configured DNS server and returning the response.
+func (d *Dns) Wire(args string, reply *string) error {
+	params, err := base64.StdEncoding.DecodeString(args)
+	if err != nil {
+		return err
+	}
+	r, err := http.Post(d.Server, "application/dns-message", bytes.NewReader(params))
+	if err != nil {
+		return err
+	}
+	b, err := io.ReadAll(r.Body)
+	if err != nil {
+		return err
+	}
+	*reply = base64.StdEncoding.EncodeToString(b)
+	return nil
+}
+
+// Server implemented the etch protocol.
+type Server struct {
+	Closer io.Closer
+	Listen string
+}
+
+// Close listener. Established connections will not be closed.
+func (s *Server) Close() error {
+	if s.Closer != nil {
+		return s.Closer.Close()
+	}
+	return nil
+}
+
+// Run it.
+func (s *Server) Run() error {
+	rpc.Register(&Dns{
+		Server: "https://1.1.1.1/dns-query",
+	})
+	l, err := net.Listen("tcp", s.Listen)
+	if err != nil {
+		return err
+	}
+	log.Println("main: listen and serve on", s.Listen)
+	srv := &http.Server{Handler: s}
+	s.Closer = srv
+	go srv.Serve(l)
+	return nil
+}
+
+// ServeHTTP implements http.Handler.
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	rwc := daze.ReadWriteCloser{
+		Reader: r.Body,
+		Writer: w,
+		Closer: r.Body,
+	}
+	codec := jsonrpc.NewServerCodec(rwc)
+	rpc.ServeRequest(codec)
+}
+
+// NewServer returns a new Server.
+func NewServer(listen string) *Server {
+	return &Server{
+		Closer: nil,
+		Listen: listen,
+	}
+}
+
+// Client implemented the etch protocol.
+type Client struct {
+	Server string
+}
+
+func (c *Client) Call(method string, args []byte) ([]byte, error) {
+	sendJson := map[string]any{
+		"jsonrpc": "2.0",
+		"id":      1,
+		"method":  method,
+		"params":  []string{base64.StdEncoding.EncodeToString(args)},
+	}
+	sendData := doa.Try(json.Marshal(sendJson))
+	r, err := http.Post(c.Server, "application/json", bytes.NewBuffer(sendData))
+	if err != nil {
+		return nil, err
+	}
+	defer r.Body.Close()
+
+	recvJson := map[string]any{}
+	if err := json.NewDecoder(r.Body).Decode(&recvJson); err != nil {
+		return nil, err
+	}
+	if recvJson["error"] != nil {
+		return nil, fmt.Errorf("%s", recvJson["error"])
+	}
+	recvData, err := base64.StdEncoding.DecodeString(recvJson["result"].(string))
+	if err != nil {
+		return nil, err
+	}
+	return recvData, nil
+}
+
+// NewClient returns a new Client.
+func NewClient(server string) *Client {
+	return &Client{
+		Server: server,
+	}
+}

protocol/etch/main.sh

@@ -0,0 +1,4 @@
+set -ex
+curl -X POST http://localhost:8080 \
+    -H "Content-Type: application/json" \
+    -d '{"jsonrpc": "2.0", "method": "Dns.Wire", "params": ["uygBIAABAAAAAAABBmdvb2dsZQNjb20AABwAAQAAKQTQAAAAAAAA"], "id": 1}'