add icmp tunnel

pkg/dialer/quic/dialer.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"net"
 	"sync"
-	"time"
 
 	"github.com/go-gost/gost/pkg/dialer"
 	quic_util "github.com/go-gost/gost/pkg/internal/util/quic"
@@ -48,12 +47,16 @@ func (d *quicDialer) Init(md md.Metadata) (err error) {
 	return nil
 }
 
-// Multiplex implements dialer.Multiplexer interface.
-func (d *quicDialer) Multiplex() bool {
-	return true
-}
-
 func (d *quicDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (conn net.Conn, err error) {
+	if _, _, err := net.SplitHostPort(addr); err != nil {
+		addr = net.JoinHostPort(addr, "0")
+	}
+
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+
 	d.sessionMutex.Lock()
 	defer d.sessionMutex.Unlock()
 
@@ -64,80 +67,41 @@ func (d *quicDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO
 			opt(options)
 		}
 
-		host := d.md.host
-		if host == "" {
-			host = options.Host
-		}
-		if h, _, _ := net.SplitHostPort(host); h != "" {
-			host = h
-		}
-		conn, err = options.NetDialer.Dial(ctx, "udp", "")
+		c, err := options.NetDialer.Dial(ctx, "udp", "")
 		if err != nil {
 			return nil, err
 		}
+		pc, ok := c.(net.PacketConn)
+		if !ok {
+			c.Close()
+			return nil, errors.New("quic: wrong connection type")
+		}
 
 		if d.md.cipherKey != nil {
-			conn = quic_util.CipherConn(conn.(*net.UDPConn), d.md.cipherKey)
+			pc = quic_util.CipherPacketConn(pc, d.md.cipherKey)
+		}
+
+		session, err = d.initSession(ctx, udpAddr, pc)
+		if err != nil {
+			d.logger.Error(err)
+			pc.Close()
+			return nil, err
 		}
 
-		session = &quicSession{conn: conn}
 		d.sessions[addr] = session
 	}
 
-	return session.conn, err
-}
-
-// Handshake implements dialer.Handshaker
-func (d *quicDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) {
-	opts := &dialer.HandshakeOptions{}
-	for _, option := range options {
-		option(opts)
-	}
-
-	d.sessionMutex.Lock()
-	defer d.sessionMutex.Unlock()
-
-	if d.md.handshakeTimeout > 0 {
-		conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout))
-		defer conn.SetDeadline(time.Time{})
-	}
-
-	session, ok := d.sessions[opts.Addr]
-	if session != nil && session.conn != conn {
-		conn.Close()
-		return nil, errors.New("quic: unrecognized connection")
-	}
-	if !ok || session.session == nil {
-		s, err := d.initSession(ctx, opts.Addr, conn)
-		if err != nil {
-			d.logger.Error(err)
-			conn.Close()
-			delete(d.sessions, opts.Addr)
-			return nil, err
-		}
-		session = s
-		d.sessions[opts.Addr] = session
-	}
-	cc, err := session.GetConn()
+	conn, err = session.GetConn()
 	if err != nil {
 		session.Close()
-		delete(d.sessions, opts.Addr)
+		delete(d.sessions, addr)
 		return nil, err
 	}
 
-	return cc, nil
+	return
 }
 
-func (d *quicDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*quicSession, error) {
-	pc, ok := conn.(net.PacketConn)
-	if !ok {
-		return nil, errors.New("quic: wrong connection type")
-	}
-
-	udpAddr, err := net.ResolveUDPAddr("udp", addr)
-	if err != nil {
-		return nil, err
-	}
+func (d *quicDialer) initSession(ctx context.Context, addr net.Addr, conn net.PacketConn) (*quicSession, error) {
 	quicConfig := &quic.Config{
 		KeepAlive:            d.md.keepAlive,
 		HandshakeIdleTimeout: d.md.handshakeTimeout,
@@ -151,10 +115,14 @@ func (d *quicDialer) initSession(ctx context.Context, addr string, conn net.Conn
 	tlsCfg := d.options.TLSConfig
 	tlsCfg.NextProtos = []string{"http/3", "quic/v1"}
 
-	session, err := quic.DialContext(ctx, pc, udpAddr, addr, tlsCfg, quicConfig)
+	session, err := quic.DialContext(ctx, conn, addr, addr.String(), tlsCfg, quicConfig)
 	if err != nil {
-		d.logger.Error(err)
 		return nil, err
 	}
-	return &quicSession{conn: conn, session: session}, nil
+	return &quicSession{session: session}, nil
+}
+
+// Multiplex implements dialer.Multiplexer interface.
+func (d *quicDialer) Multiplex() bool {
+	return true
 }