initial commit

dialer/http3/dialer.go

@@ -0,0 +1,107 @@
+package http3
+
+import (
+	"context"
+	"crypto/tls"
+	"net"
+	"net/http"
+	"sync"
+
+	"github.com/go-gost/gost/v3/pkg/dialer"
+	md "github.com/go-gost/gost/v3/pkg/metadata"
+	"github.com/go-gost/gost/v3/pkg/registry"
+	pht_util "github.com/go-gost/x/internal/util/pht"
+	"github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/http3"
+)
+
+func init() {
+	registry.DialerRegistry().Register("http3", NewDialer)
+	registry.DialerRegistry().Register("h3", NewDialer)
+}
+
+type http3Dialer struct {
+	clients     map[string]*pht_util.Client
+	clientMutex sync.Mutex
+	md          metadata
+	options     dialer.Options
+}
+
+func NewDialer(opts ...dialer.Option) dialer.Dialer {
+	options := dialer.Options{}
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	return &http3Dialer{
+		clients: make(map[string]*pht_util.Client),
+		options: options,
+	}
+}
+
+func (d *http3Dialer) Init(md md.Metadata) (err error) {
+	if err = d.parseMetadata(md); err != nil {
+		return
+	}
+
+	return nil
+}
+
+func (d *http3Dialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (net.Conn, error) {
+	d.clientMutex.Lock()
+	defer d.clientMutex.Unlock()
+
+	client, ok := d.clients[addr]
+	if !ok {
+		var options dialer.DialOptions
+		for _, opt := range opts {
+			opt(&options)
+		}
+
+		host := d.md.host
+		if host == "" {
+			host = options.Host
+		}
+		if h, _, _ := net.SplitHostPort(host); h != "" {
+			host = h
+		}
+
+		client = &pht_util.Client{
+			Host: host,
+			Client: &http.Client{
+				// Timeout:   60 * time.Second,
+				Transport: &http3.RoundTripper{
+					TLSClientConfig: d.options.TLSConfig,
+					Dial: func(network, adr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.EarlySession, error) {
+						// d.options.Logger.Infof("dial: %s/%s, %s", addr, network, host)
+						udpAddr, err := net.ResolveUDPAddr("udp", addr)
+						if err != nil {
+							return nil, err
+						}
+
+						udpConn, err := options.NetDialer.Dial(context.Background(), "udp", "")
+						if err != nil {
+							return nil, err
+						}
+
+						return quic.DialEarly(udpConn.(net.PacketConn), udpAddr, host, tlsCfg, cfg)
+					},
+				},
+			},
+			AuthorizePath: d.md.authorizePath,
+			PushPath:      d.md.pushPath,
+			PullPath:      d.md.pullPath,
+			TLSEnabled:    true,
+			Logger:        d.options.Logger,
+		}
+
+		d.clients[addr] = client
+	}
+
+	return client.Dial(ctx, addr)
+}
+
+// Multiplex implements dialer.Multiplexer interface.
+func (d *http3Dialer) Multiplex() bool {
+	return true
+}

dialer/http3/metadata.go

@@ -0,0 +1,52 @@
+package http3
+
+import (
+	"strings"
+	"time"
+
+	mdata "github.com/go-gost/gost/v3/pkg/metadata"
+)
+
+const (
+	dialTimeout          = "dialTimeout"
+	defaultAuthorizePath = "/authorize"
+	defaultPushPath      = "/push"
+	defaultPullPath      = "/pull"
+)
+
+const (
+	defaultDialTimeout = 5 * time.Second
+)
+
+type metadata struct {
+	dialTimeout   time.Duration
+	authorizePath string
+	pushPath      string
+	pullPath      string
+	host          string
+}
+
+func (d *http3Dialer) parseMetadata(md mdata.Metadata) (err error) {
+	const (
+		authorizePath = "authorizePath"
+		pushPath      = "pushPath"
+		pullPath      = "pullPath"
+		host          = "host"
+	)
+
+	d.md.authorizePath = mdata.GetString(md, authorizePath)
+	if !strings.HasPrefix(d.md.authorizePath, "/") {
+		d.md.authorizePath = defaultAuthorizePath
+	}
+	d.md.pushPath = mdata.GetString(md, pushPath)
+	if !strings.HasPrefix(d.md.pushPath, "/") {
+		d.md.pushPath = defaultPushPath
+	}
+	d.md.pullPath = mdata.GetString(md, pullPath)
+	if !strings.HasPrefix(d.md.pullPath, "/") {
+		d.md.pullPath = defaultPullPath
+	}
+
+	d.md.host = mdata.GetString(md, host)
+	return
+}