2025-08-19 23:01:26

Author: mohanson

protocol/etch/cmd/main.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"flag"
+	"log"
+	"net"
+	"net/url"
+	"time"
+
+	"github.com/mohanson/daze/lib/doa"
+	"github.com/mohanson/daze/protocol/etch"
+)
+
+func main() {
+	flag.Parse()
+	switch flag.Arg(0) {
+	case "server":
+		server := etch.Server{}
+		server.Run()
+		select {}
+	case "client":
+		// client := etch.NewClient()
+		// log.Println(client.DnsQuery())
+		r := ResolverDoh("http://127.0.0.1:8080")
+		log.Println(r.LookupHost(context.Background(), "baidu.com"))
+	}
+}
+
+// Cdoh structure can be used for DoH protocol processing.
+type Cdoh struct {
+	Server string
+	Buffer *bytes.Buffer
+}
+
+func (c Cdoh) Read(b []byte) (n int, err error)   { return c.Buffer.Read(b) }
+func (c Cdoh) Close() error                       { return nil }
+func (c Cdoh) LocalAddr() net.Addr                { return nil }
+func (c Cdoh) RemoteAddr() net.Addr               { return nil }
+func (c Cdoh) SetDeadline(t time.Time) error      { return nil }
+func (c Cdoh) SetReadDeadline(t time.Time) error  { return nil }
+func (c Cdoh) SetWriteDeadline(t time.Time) error { return nil }
+func (c Cdoh) Write(b []byte) (n int, err error) {
+	size := int(binary.BigEndian.Uint16(b[:2]))
+	doa.Doa(size == len(b)-2)
+
+	client := etch.NewClient("127.0.0.1:8080")
+	body := client.DnsQuery(b[2:])
+
+	// resp, err := http.Post(c.Server, "application/dns-message", bytes.NewReader(b[2:]))
+	// if err != nil {
+	// 	log.Println("cdoh:", err)
+	// 	return len(b), nil
+	// }
+	// body, err := io.ReadAll(resp.Body)
+	// if err != nil {
+	// 	log.Println("cdoh:", err)
+	// 	return len(b), nil
+	// }
+	data := make([]byte, 2+len(body))
+	binary.BigEndian.PutUint16(data[:2], uint16(len(body)))
+	copy(data[2:], body)
+	c.Buffer.Write(data)
+	return len(b), nil
+}
+
+// ResolverDoh returns a DoH resolver. For further information, see https://datatracker.ietf.org/doc/html/rfc8484.
+func ResolverDoh(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 := &Cdoh{
+				Server: urls.String(),
+				Buffer: bytes.NewBuffer([]byte{}),
+			}
+			return conn, nil
+		},
+	}
+}

protocol/etch/engine.go

@@ -0,0 +1,85 @@
+package etch
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/rpc"
+
+	"github.com/mohanson/daze/lib/doa"
+)
+
+type Etch struct{}
+
+func (m *Etch) DnsQuery(arg []byte, ret *[]byte) error {
+	r, err := http.Post("https://1.1.1.1/dns-query", "application/dns-message", bytes.NewReader(arg))
+	if err != nil {
+		return err
+	}
+	b, err := io.ReadAll(r.Body)
+	if err != nil {
+		return err
+	}
+	*ret = b
+	return nil
+}
+
+type Server struct{}
+
+func (s *Server) Run() error {
+	doa.Nil(rpc.Register(&Etch{}))
+	rpc.HandleHTTP()
+	doa.Nil(http.ListenAndServe("127.0.0.1:8080", nil))
+
+	// l, err := net.Listen("tcp", "127.0.0.1:8080")
+	// if err != nil {
+	// 	log.Fatal("listen error:", err)
+	// }
+
+	// // 设置 JSON-RPC 处理
+	// http.HandleFunc("/rpc", func(w http.ResponseWriter, r *http.Request) {
+	// 	// 设置响应头
+	// 	w.Header().Set("Content-Type", "application/json")
+
+	// 	// 创建 JSON-RPC 编解码器
+	// 	conn, _, err := w.(http.Hijacker).Hijack()
+	// 	if err != nil {
+	// 		log.Println("Hijacking failed:", err)
+	// 		return
+	// 	}
+	// 	defer conn.Close()
+
+	// 	// 处理 JSON-RPC 请求
+	// 	codec := jsonrpc.NewServerCodec(conn)
+	// 	err = rpc.ServeRequest(codec)
+	// 	if err != nil {
+	// 		log.Println("ServeRequest error:", err)
+	// 		return
+	// 	}
+	// })
+
+	// // 启动 HTTP 服务器
+	// fmt.Println("JSON-RPC server starting on :8080...")
+	// err = http.ListenAndServe(":8080", nil)
+	// if err != nil {
+	// 	log.Fatal("ListenAndServe error:", err)
+	// }
+
+	return nil
+}
+
+type Client struct {
+	cli *rpc.Client
+}
+
+func (c *Client) DnsQuery(arg []byte) []byte {
+	r := []byte{}
+	doa.Nil(c.cli.Call("Etch.DnsQuery", arg, &r))
+	return r
+}
+
+func NewClient(server string) *Client {
+	c := doa.Try(rpc.DialHTTP("tcp", server))
+	client := &Client{cli: c}
+	return client
+}