add icmp tunnel

pkg/listener/icmp/conn.go

@@ -0,0 +1,21 @@
+package quic
+
+import (
+	"net"
+
+	"github.com/lucas-clemente/quic-go"
+)
+
+type quicConn struct {
+	quic.Stream
+	laddr net.Addr
+	raddr net.Addr
+}
+
+func (c *quicConn) LocalAddr() net.Addr {
+	return c.laddr
+}
+
+func (c *quicConn) RemoteAddr() net.Addr {
+	return c.raddr
+}

pkg/listener/icmp/listener.go

@@ -0,0 +1,145 @@
+package quic
+
+import (
+	"context"
+	"net"
+
+	"github.com/go-gost/gost/pkg/common/metrics"
+	icmp_pkg "github.com/go-gost/gost/pkg/common/util/icmp"
+	"github.com/go-gost/gost/pkg/listener"
+	"github.com/go-gost/gost/pkg/logger"
+	md "github.com/go-gost/gost/pkg/metadata"
+	"github.com/go-gost/gost/pkg/registry"
+	"github.com/lucas-clemente/quic-go"
+	"golang.org/x/net/icmp"
+)
+
+func init() {
+	registry.ListenerRegistry().Register("icmp", NewListener)
+}
+
+type icmpListener struct {
+	ln      quic.Listener
+	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 &icmpListener{
+		logger:  options.Logger,
+		options: options,
+	}
+}
+
+func (l *icmpListener) Init(md md.Metadata) (err error) {
+	if err = l.parseMetadata(md); err != nil {
+		return
+	}
+
+	addr := l.options.Addr
+	if host, _, err := net.SplitHostPort(addr); err == nil {
+		addr = host
+	}
+
+	var conn net.PacketConn
+	conn, err = icmp.ListenPacket("ip4:icmp", addr)
+	if err != nil {
+		return
+	}
+	conn = icmp_pkg.ServerConn(conn)
+	conn = metrics.WrapPacketConn(l.options.Service, conn)
+
+	config := &quic.Config{
+		KeepAlive:            l.md.keepAlive,
+		HandshakeIdleTimeout: l.md.handshakeTimeout,
+		MaxIdleTimeout:       l.md.maxIdleTimeout,
+		Versions: []quic.VersionNumber{
+			quic.Version1,
+			quic.VersionDraft29,
+		},
+	}
+
+	tlsCfg := l.options.TLSConfig
+	tlsCfg.NextProtos = []string{"http/3", "quic/v1"}
+
+	ln, err := quic.Listen(conn, tlsCfg, config)
+	if err != nil {
+		return
+	}
+
+	l.ln = ln
+	l.cqueue = make(chan net.Conn, l.md.backlog)
+	l.errChan = make(chan error, 1)
+
+	go l.listenLoop()
+
+	return
+}
+
+func (l *icmpListener) 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 *icmpListener) Close() error {
+	return l.ln.Close()
+}
+
+func (l *icmpListener) Addr() net.Addr {
+	return l.ln.Addr()
+}
+
+func (l *icmpListener) listenLoop() {
+	for {
+		ctx := context.Background()
+		session, err := l.ln.Accept(ctx)
+		if err != nil {
+			l.logger.Error("accept: ", err)
+			l.errChan <- err
+			close(l.errChan)
+			return
+		}
+		l.logger.Infof("new client session: %v", session.RemoteAddr())
+		go l.mux(ctx, session)
+	}
+}
+
+func (l *icmpListener) mux(ctx context.Context, session quic.Session) {
+	defer session.CloseWithError(0, "closed")
+
+	for {
+		stream, err := session.AcceptStream(ctx)
+		if err != nil {
+			l.logger.Error("accept stream: ", err)
+			return
+		}
+
+		conn := &quicConn{
+			Stream: stream,
+			laddr:  session.LocalAddr(),
+			raddr:  session.RemoteAddr(),
+		}
+		select {
+		case l.cqueue <- conn:
+		case <-stream.Context().Done():
+			stream.Close()
+		default:
+			stream.Close()
+			l.logger.Warnf("connection queue is full, client %s discarded", session.RemoteAddr())
+		}
+	}
+}

pkg/listener/icmp/metadata.go

@@ -0,0 +1,41 @@
+package quic
+
+import (
+	"time"
+
+	mdata "github.com/go-gost/gost/pkg/metadata"
+)
+
+const (
+	defaultBacklog = 128
+)
+
+type metadata struct {
+	keepAlive        bool
+	handshakeTimeout time.Duration
+	maxIdleTimeout   time.Duration
+
+	cipherKey []byte
+	backlog   int
+}
+
+func (l *icmpListener) parseMetadata(md mdata.Metadata) (err error) {
+	const (
+		keepAlive        = "keepAlive"
+		handshakeTimeout = "handshakeTimeout"
+		maxIdleTimeout   = "maxIdleTimeout"
+
+		backlog = "backlog"
+	)
+
+	l.md.backlog = mdata.GetInt(md, backlog)
+	if l.md.backlog <= 0 {
+		l.md.backlog = defaultBacklog
+	}
+
+	l.md.keepAlive = mdata.GetBool(md, keepAlive)
+	l.md.handshakeTimeout = mdata.GetDuration(md, handshakeTimeout)
+	l.md.maxIdleTimeout = mdata.GetDuration(md, maxIdleTimeout)
+
+	return
+}

pkg/listener/kcp/listener.go

@@ -49,7 +49,6 @@ func (l *kcpListener) Init(md md.Metadata) (err error) {
 	config.Init()
 
 	var conn net.PacketConn
-
 	if config.TCP {
 		conn, err = tcpraw.Listen("tcp", l.options.Addr)
 	} else {

pkg/listener/quic/listener.go

@@ -42,21 +42,24 @@ func (l *quicListener) Init(md md.Metadata) (err error) {
 		return
 	}
 
-	laddr, err := net.ResolveUDPAddr("udp", l.options.Addr)
+	addr := l.options.Addr
+	if _, _, err := net.SplitHostPort(addr); err != nil {
+		addr = net.JoinHostPort(addr, "0")
+	}
+
+	var laddr *net.UDPAddr
+	laddr, err = net.ResolveUDPAddr("udp", addr)
 	if err != nil {
 		return
 	}
 
-	uc, err := net.ListenUDP("udp", laddr)
+	var conn net.PacketConn
+	conn, err = net.ListenUDP("udp", laddr)
 	if err != nil {
 		return
 	}
-
-	var conn net.PacketConn = uc
-	// conn = metrics.WrapPacketConn(l.options.Service, conn)
-
 	if l.md.cipherKey != nil {
-		conn = quic_util.CipherPacketConn(uc, l.md.cipherKey)
+		conn = quic_util.CipherPacketConn(conn, l.md.cipherKey)
 	}
 
 	config := &quic.Config{