add webtransport tunnel

listener/http3/h3/metadata.go

@@ -30,11 +30,7 @@ type metadata struct {
 
 func (l *http3Listener) parseMetadata(md mdata.Metadata) (err error) {
 	const (
-		authorizePath = "authorizePath"
-		pushPath      = "pushPath"
-		pullPath      = "pullPath"
-
-		keepAlive        = "keepAlive"
+		keepAlive        = "keepalive"
 		keepAlivePeriod  = "ttl"
 		handshakeTimeout = "handshakeTimeout"
 		maxIdleTimeout   = "maxIdleTimeout"
@@ -43,15 +39,15 @@ func (l *http3Listener) parseMetadata(md mdata.Metadata) (err error) {
 		backlog = "backlog"
 	)
 
-	l.md.authorizePath = mdutil.GetString(md, authorizePath)
+	l.md.authorizePath = mdutil.GetString(md, "pht.authorizePath", "authorizePath")
 	if !strings.HasPrefix(l.md.authorizePath, "/") {
 		l.md.authorizePath = defaultAuthorizePath
 	}
-	l.md.pushPath = mdutil.GetString(md, pushPath)
+	l.md.pushPath = mdutil.GetString(md, "pht.pushPath", "pushPath")
 	if !strings.HasPrefix(l.md.pushPath, "/") {
 		l.md.pushPath = defaultPushPath
 	}
-	l.md.pullPath = mdutil.GetString(md, pullPath)
+	l.md.pullPath = mdutil.GetString(md, "pht.pullPath", "pullPath")
 	if !strings.HasPrefix(l.md.pullPath, "/") {
 		l.md.pullPath = defaultPullPath
 	}

listener/http3/wt/listener.go

@@ -0,0 +1,158 @@
+package wt
+
+import (
+	"net"
+	"net/http"
+	"net/http/httputil"
+
+	"github.com/go-gost/core/listener"
+	"github.com/go-gost/core/logger"
+	md "github.com/go-gost/core/metadata"
+	xnet "github.com/go-gost/x/internal/net"
+	wt_util "github.com/go-gost/x/internal/util/wt"
+	"github.com/go-gost/x/registry"
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/http3"
+	wt "github.com/quic-go/webtransport-go"
+)
+
+func init() {
+	registry.ListenerRegistry().Register("wt", NewListener)
+}
+
+type wtListener struct {
+	addr    net.Addr
+	srv     *wt.Server
+	cqueue  chan net.Conn
+	errChan chan error
+	logger  logger.Logger
+	md      metadata
+	options listener.Options
+}
+
+func NewListener(opts ...listener.Option) listener.Listener {
+	options := listener.Options{}
+	for _, opt := range opts {
+		opt(&options)
+	}
+	return &wtListener{
+		logger:  options.Logger,
+		options: options,
+	}
+}
+
+func (l *wtListener) Init(md md.Metadata) (err error) {
+	if err = l.parseMetadata(md); err != nil {
+		return
+	}
+
+	network := "udp"
+	if xnet.IsIPv4(l.options.Addr) {
+		network = "udp4"
+	}
+	l.addr, err = net.ResolveUDPAddr(network, l.options.Addr)
+	if err != nil {
+		return
+	}
+
+	mux := http.NewServeMux()
+	mux.Handle(l.md.path, http.HandlerFunc(l.upgrade))
+
+	l.srv = &wt.Server{
+		H3: http3.Server{
+			Addr:      l.options.Addr,
+			TLSConfig: l.options.TLSConfig,
+			QuicConfig: &quic.Config{
+				KeepAlivePeriod:      l.md.keepAlivePeriod,
+				HandshakeIdleTimeout: l.md.handshakeTimeout,
+				MaxIdleTimeout:       l.md.maxIdleTimeout,
+				/*
+					Versions: []quic.VersionNumber{
+						quic.Version1,
+						quic.Version2,
+					},
+				*/
+				MaxIncomingStreams: int64(l.md.maxStreams),
+			},
+			Handler: mux,
+		},
+		CheckOrigin: func(r *http.Request) bool { return true },
+	}
+
+	l.cqueue = make(chan net.Conn, l.md.backlog)
+	l.errChan = make(chan error, 1)
+
+	go func() {
+		if err := l.srv.ListenAndServe(); err != nil {
+			l.logger.Error(err)
+		}
+	}()
+
+	return
+}
+
+func (l *wtListener) Accept() (conn net.Conn, err error) {
+	var ok bool
+	select {
+	case conn = <-l.cqueue:
+	case err, ok = <-l.errChan:
+		if !ok {
+			err = listener.ErrClosed
+		}
+	}
+	return
+}
+
+func (l *wtListener) Addr() net.Addr {
+	return l.addr
+}
+
+func (l *wtListener) Close() (err error) {
+	return l.srv.Close()
+}
+
+func (l *wtListener) upgrade(w http.ResponseWriter, r *http.Request) {
+	log := l.logger.WithFields(map[string]any{
+		"local":  l.addr.String(),
+		"remote": r.RemoteAddr,
+	})
+	if l.logger.IsLevelEnabled(logger.TraceLevel) {
+		dump, _ := httputil.DumpRequest(r, false)
+		log.Trace(string(dump))
+	}
+
+	s, err := l.srv.Upgrade(w, r)
+	if err != nil {
+		l.logger.Error(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	l.mux(s, log)
+}
+
+func (l *wtListener) mux(s *wt.Session, log logger.Logger) (err error) {
+	defer func() {
+		if err != nil {
+			s.CloseWithError(1, err.Error())
+		} else {
+			s.CloseWithError(0, "")
+		}
+	}()
+
+	for {
+		var stream wt.Stream
+		stream, err = s.AcceptStream(s.Context())
+		if err != nil {
+			log.Errorf("accept stream: %v", err)
+			return
+		}
+
+		select {
+		case l.cqueue <- wt_util.Conn(s, stream):
+		default:
+			stream.Close()
+			l.logger.Warnf("connection queue is full, stream %v discarded", stream.StreamID())
+		}
+	}
+}

listener/http3/wt/metadata.go

@@ -0,0 +1,58 @@
+package wt
+
+import (
+	"time"
+
+	mdata "github.com/go-gost/core/metadata"
+	mdutil "github.com/go-gost/core/metadata/util"
+)
+
+const (
+	defaultPath    = "/wt"
+	defaultBacklog = 128
+)
+
+type metadata struct {
+	path    string
+	backlog int
+
+	// QUIC config options
+	keepAlivePeriod  time.Duration
+	maxIdleTimeout   time.Duration
+	handshakeTimeout time.Duration
+	maxStreams       int
+}
+
+func (l *wtListener) parseMetadata(md mdata.Metadata) (err error) {
+	const (
+		keepAlive        = "keepalive"
+		keepAlivePeriod  = "ttl"
+		handshakeTimeout = "handshakeTimeout"
+		maxIdleTimeout   = "maxIdleTimeout"
+		maxStreams       = "maxStreams"
+
+		backlog = "backlog"
+	)
+
+	l.md.path = mdutil.GetString(md, "wt.path", "path")
+	if l.md.path == "" {
+		l.md.path = defaultPath
+	}
+
+	l.md.backlog = mdutil.GetInt(md, backlog)
+	if l.md.backlog <= 0 {
+		l.md.backlog = defaultBacklog
+	}
+
+	if mdutil.GetBool(md, keepAlive) {
+		l.md.keepAlivePeriod = mdutil.GetDuration(md, keepAlivePeriod)
+		if l.md.keepAlivePeriod <= 0 {
+			l.md.keepAlivePeriod = 10 * time.Second
+		}
+	}
+	l.md.handshakeTimeout = mdutil.GetDuration(md, handshakeTimeout)
+	l.md.maxIdleTimeout = mdutil.GetDuration(md, maxIdleTimeout)
+	l.md.maxStreams = mdutil.GetInt(md, maxStreams)
+
+	return
+}

listener/mws/listener.go

@@ -160,6 +160,7 @@ func (l *mwsListener) upgrade(w http.ResponseWriter, r *http.Request) {
 
 	conn, err := l.upgrader.Upgrade(w, r, l.md.header)
 	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
 		log.Error(err)
 		return
 	}

listener/ws/listener.go

@@ -156,6 +156,7 @@ func (l *wsListener) upgrade(w http.ResponseWriter, r *http.Request) {
 	conn, err := l.upgrader.Upgrade(w, r, l.md.header)
 	if err != nil {
 		l.logger.Error(err)
+		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}