mirror of
https://github.com/go-gost/x.git
synced 2026-10-19 16:16:32 +00:00
ginuerzh
bc06c7f5da
Tunnel connectors send record.mode via MetadataFeature in relay requests. The handler parses MetadataFeature, stores on tunnel during bind, and propagates to entrypoint services where recorder context applies it (per-request Gost-Record header still takes precedence). - connector/tunnel: send record.mode MetadataFeature in Connect/Bind - connector/tunnel: parse record.mode from metadata config - handler/tunnel: parse MetadataFeature from relay request features - handler/tunnel: pass connMetadata through handleBind → pool.SetMetadata - handler/tunnel: SetMetadata/GetMetadata on ConnectorPool + Tunnel - handler/tunnel/entrypointsvc: apply pool metadata to recorder context - deps: bump relay v0.6.2 → v0.7.0 - sniffer_sse.go: whitespace gofmt fixes
120 lines
2.6 KiB
Go
120 lines
2.6 KiB
Go
package tunnel
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"time"
|
|
|
|
"github.com/go-gost/core/connector"
|
|
md "github.com/go-gost/core/metadata"
|
|
"github.com/go-gost/relay"
|
|
xctx "github.com/go-gost/x/ctx"
|
|
"github.com/go-gost/x/registry"
|
|
)
|
|
|
|
func init() {
|
|
registry.ConnectorRegistry().Register("tunnel", NewConnector)
|
|
}
|
|
|
|
type tunnelConnector struct {
|
|
md metadata
|
|
options connector.Options
|
|
}
|
|
|
|
func NewConnector(opts ...connector.Option) connector.Connector {
|
|
options := connector.Options{}
|
|
for _, opt := range opts {
|
|
opt(&options)
|
|
}
|
|
|
|
return &tunnelConnector{
|
|
options: options,
|
|
}
|
|
}
|
|
|
|
func (c *tunnelConnector) Init(md md.Metadata) (err error) {
|
|
return c.parseMetadata(md)
|
|
}
|
|
|
|
func (c *tunnelConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
|
|
log := c.options.Logger.WithFields(map[string]any{
|
|
"network": network,
|
|
"address": address,
|
|
"remote": conn.RemoteAddr().String(),
|
|
"local": conn.LocalAddr().String(),
|
|
"sid": xctx.SidFromContext(ctx).String(),
|
|
})
|
|
log.Debugf("connect %s/%s", address, network)
|
|
|
|
if c.md.connectTimeout > 0 {
|
|
conn.SetDeadline(time.Now().Add(c.md.connectTimeout))
|
|
defer conn.SetDeadline(time.Time{})
|
|
}
|
|
|
|
req := relay.Request{
|
|
Version: relay.Version1,
|
|
Cmd: relay.CmdConnect,
|
|
}
|
|
|
|
switch network {
|
|
case "udp", "udp4", "udp6":
|
|
req.Cmd |= relay.FUDP
|
|
req.Features = append(req.Features, &relay.NetworkFeature{
|
|
Network: relay.NetworkUDP,
|
|
})
|
|
}
|
|
|
|
if c.options.Auth != nil {
|
|
pwd, _ := c.options.Auth.Password()
|
|
req.Features = append(req.Features, &relay.UserAuthFeature{
|
|
Username: c.options.Auth.Username(),
|
|
Password: pwd,
|
|
})
|
|
}
|
|
|
|
srcAddr := conn.RemoteAddr().String()
|
|
if v := xctx.SrcAddrFromContext(ctx); v != nil {
|
|
srcAddr = v.String()
|
|
}
|
|
|
|
af := &relay.AddrFeature{}
|
|
af.ParseFrom(srcAddr)
|
|
req.Features = append(req.Features, af) // src address
|
|
|
|
af = &relay.AddrFeature{}
|
|
af.ParseFrom(address)
|
|
req.Features = append(req.Features, af) // dst address
|
|
|
|
req.Features = append(req.Features, &relay.TunnelFeature{
|
|
ID: c.md.tunnelID,
|
|
})
|
|
if c.md.recordMode != "" {
|
|
req.Features = append(req.Features, &relay.MetadataFeature{
|
|
KVs: map[string]string{"record.mode": c.md.recordMode},
|
|
})
|
|
}
|
|
|
|
if _, err := req.WriteTo(conn); err != nil {
|
|
return nil, err
|
|
}
|
|
// drain the response
|
|
if err := readResponse(conn); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch network {
|
|
case "tcp", "tcp4", "tcp6":
|
|
case "udp", "udp4", "udp6":
|
|
conn = &udpConn{
|
|
Conn: conn,
|
|
}
|
|
default:
|
|
err := fmt.Errorf("network %s is unsupported", network)
|
|
log.Error(err)
|
|
return nil, err
|
|
}
|
|
|
|
return conn, nil
|
|
}
|