func Dial(src v2net.Address, dest v2net.Destination, options internet.DialerOptions) (internet.Connection, error) { log.Info("Internet|TCP: Dailing TCP to ", dest) if src == nil { src = v2net.AnyIP } networkSettings, err := options.Stream.GetEffectiveNetworkSettings() if err != nil { return nil, err } tcpSettings := networkSettings.(*Config) id := internal.NewConnectionId(src, dest) var conn net.Conn if dest.Network == v2net.Network_TCP && tcpSettings.ConnectionReuse.IsEnabled() { conn = globalCache.Get(id) } if conn == nil { var err error conn, err = internet.DialToDest(src, dest) if err != nil { return nil, err } if options.Stream != nil && options.Stream.HasSecuritySettings() { securitySettings, err := options.Stream.GetEffectiveSecuritySettings() if err != nil { log.Error("TCP: Failed to get security settings: ", err) return nil, err } tlsConfig, ok := securitySettings.(*v2tls.Config) if ok { config := tlsConfig.GetTLSConfig() if dest.Address.Family().IsDomain() { config.ServerName = dest.Address.Domain() } conn = tls.Client(conn, config) } } if tcpSettings.HeaderSettings != nil { headerConfig, err := tcpSettings.HeaderSettings.GetInstance() if err != nil { return nil, errors.Base(err).Message("Interent|TCP: Failed to get header settings.") } auth, err := internet.CreateConnectionAuthenticator(tcpSettings.HeaderSettings.Type, headerConfig) if err != nil { return nil, errors.Base(err).Message("Internet|TCP: Failed to create header authenticator.") } conn = auth.Client(conn) } } return NewConnection(id, conn, globalCache, tcpSettings), nil }
func DialKCP(src v2net.Address, dest v2net.Destination, options internet.DialerOptions) (internet.Connection, error) { dest.Network = v2net.Network_UDP log.Info("KCP|Dialer: Dialing KCP to ", dest) id := internal.NewConnectionId(src, dest) conn := globalPool.Get(id) if conn == nil { rawConn, err := internet.DialToDest(src, dest) if err != nil { log.Error("KCP|Dialer: Failed to dial to dest: ", err) return nil, err } c := &ClientConnection{ Conn: rawConn, id: id, } go c.Run() conn = c } networkSettings, err := options.Stream.GetEffectiveNetworkSettings() if err != nil { log.Error("KCP|Dialer: Failed to get KCP settings: ", err) return nil, err } kcpSettings := networkSettings.(*Config) clientConn := conn.(*ClientConnection) header, err := kcpSettings.GetPackerHeader() if err != nil { return nil, errors.Base(err).Message("KCP|Dialer: Failed to create packet header.") } security, err := kcpSettings.GetSecurity() if err != nil { return nil, errors.Base(err).Message("KCP|Dialer: Failed to create security.") } clientConn.ResetSecurity(header, security) conv := uint16(atomic.AddUint32(&globalConv, 1)) session := NewConnection(conv, clientConn, globalPool, kcpSettings) var iConn internet.Connection iConn = session if options.Stream != nil && options.Stream.HasSecuritySettings() { securitySettings, err := options.Stream.GetEffectiveSecuritySettings() if err != nil { log.Error("KCP|Dialer: Failed to get security settings: ", err) return nil, err } switch securitySettings := securitySettings.(type) { case *v2tls.Config: config := securitySettings.GetTLSConfig() if dest.Address.Family().IsDomain() { config.ServerName = dest.Address.Domain() } tlsConn := tls.Client(conn, config) iConn = v2tls.NewConnection(tlsConn) } } return iConn, nil }
func (v *Listener) OnReceive(payload *buf.Buffer, session *proxy.SessionInfo) { defer payload.Release() src := session.Source segments := v.reader.Read(payload.Bytes()) if len(segments) == 0 { log.Info("KCP|Listener: discarding invalid payload from ", src) return } if !v.running { return } v.Lock() defer v.Unlock() if !v.running { return } if payload.Len() < 4 { return } conv := segments[0].Conversation() cmd := segments[0].Command() id := ConnectionId{ Remote: src.Address, Port: src.Port, Conv: conv, } conn, found := v.sessions[id] if !found { if cmd == CommandTerminate { return } writer := &Writer{ id: id, hub: v.hub, dest: src, listener: v, } remoteAddr := &net.UDPAddr{ IP: src.Address.IP(), Port: int(src.Port), } localAddr := v.hub.Addr() sConn := &ServerConnection{ id: internal.NewConnectionId(v2net.LocalHostIP, src), local: localAddr, remote: remoteAddr, writer: &KCPPacketWriter{ Header: v.header, Writer: writer, Security: v.security, }, closer: writer, } conn = NewConnection(conv, sConn, v, v.config) select { case v.awaitingConns <- conn: case <-time.After(time.Second * 5): conn.Close() return } v.sessions[id] = conn } conn.Input(segments) }