lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-06-09 09:20:45 +00:00
Code Issues Releases Wiki Activity

Chore: bump github.com/lucas-clemente/quic-go from 0.26.0 to 0.27.0 (#1716)

Browse Source
This commit is contained in:
秋のかえで 2022-04-06 12:59:25 +08:00 committed by GitHub
parent 5ce71e0652
commit 84c31ba87f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 85 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
app/dns/nameserver_quic.go
View File

@ -37,7 +37,7 @@ type QUICNameServer struct {
reqID uint32 reqID uint32
name string name string
destination net.Destination destination net.Destination
session quic.Session connection quic.Connection
} }
// NewQUICNameServer creates DNS-over-QUIC client object for local resolving // NewQUICNameServer creates DNS-over-QUIC client object for local resolving
@ -191,7 +191,7 @@ func (s *QUICNameServer) sendQuery(ctx context.Context, domain string, clientIP
conn, err := s.openStream(dnsCtx) conn, err := s.openStream(dnsCtx)
if err != nil { if err != nil {
newError("failed to open quic session").Base(err).AtError().WriteToLog() newError("failed to open quic connection").Base(err).AtError().WriteToLog()
return return
} }
@ -315,7 +315,7 @@ func (s *QUICNameServer) QueryIP(ctx context.Context, domain string, clientIP ne
} }
} }
func isActive(s quic.Session) bool { func isActive(s quic.Connection) bool {
select { select {
case <-s.Context().Done(): case <-s.Context().Done():
return false return false
@ -324,17 +324,17 @@ func isActive(s quic.Session) bool {
} }
} }
func (s *QUICNameServer) getSession(ctx context.Context) (quic.Session, error) { func (s *QUICNameServer) getConnection(ctx context.Context) (quic.Connection, error) {
var session quic.Session var conn quic.Connection
s.RLock() s.RLock()
session = s.session conn = s.connection
if session != nil && isActive(session) { if conn != nil && isActive(conn) {
s.RUnlock() s.RUnlock()
return session, nil return conn, nil
} }
if session != nil { if conn != nil {
// we're recreating the session, let's create a new one // we're recreating the connection, let's create a new one
_ = session.CloseWithError(0, "") _ = conn.CloseWithError(0, "")
} }
s.RUnlock() s.RUnlock()
@ -342,42 +342,42 @@ func (s *QUICNameServer) getSession(ctx context.Context) (quic.Session, error) {
defer s.Unlock() defer s.Unlock()
var err error var err error
session, err = s.openSession(ctx) conn, err = s.openConnection(ctx)
if err != nil { if err != nil {
// This does not look too nice, but QUIC (or maybe quic-go) // This does not look too nice, but QUIC (or maybe quic-go)
// doesn't seem stable enough. // doesn't seem stable enough.
// Maybe retransmissions aren't fully implemented in quic-go? // Maybe retransmissions aren't fully implemented in quic-go?
// Anyways, the simple solution is to make a second try when // Anyways, the simple solution is to make a second try when
// it fails to open the QUIC session. // it fails to open the QUIC connection.
session, err = s.openSession(ctx) conn, err = s.openConnection(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} }
s.session = session s.connection = conn
return session, nil return conn, nil
} }
func (s *QUICNameServer) openSession(ctx context.Context) (quic.Session, error) { func (s *QUICNameServer) openConnection(ctx context.Context) (quic.Connection, error) {
tlsConfig := tls.Config{} tlsConfig := tls.Config{}
quicConfig := &quic.Config{ quicConfig := &quic.Config{
HandshakeIdleTimeout: handshakeIdleTimeout, HandshakeIdleTimeout: handshakeIdleTimeout,
} }
session, err := quic.DialAddrContext(ctx, s.destination.NetAddr(), tlsConfig.GetTLSConfig(tls.WithNextProto("http/1.1", http2.NextProtoTLS, NextProtoDQ)), quicConfig) conn, err := quic.DialAddrContext(ctx, s.destination.NetAddr(), tlsConfig.GetTLSConfig(tls.WithNextProto("http/1.1", http2.NextProtoTLS, NextProtoDQ)), quicConfig)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return session, nil return conn, nil
} }
func (s *QUICNameServer) openStream(ctx context.Context) (quic.Stream, error) { func (s *QUICNameServer) openStream(ctx context.Context) (quic.Stream, error) {
session, err := s.getSession(ctx) conn, err := s.getConnection(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// open a new stream // open a new stream
return session.OpenStreamSync(ctx) return conn.OpenStreamSync(ctx)
} }

2
go.mod
View File

@ -12,7 +12,7 @@ require (
github.com/google/go-cmp v0.5.7 github.com/google/go-cmp v0.5.7
github.com/gorilla/websocket v1.5.0 github.com/gorilla/websocket v1.5.0
github.com/jhump/protoreflect v1.12.0 github.com/jhump/protoreflect v1.12.0
github.com/lucas-clemente/quic-go v0.26.0 github.com/lucas-clemente/quic-go v0.27.0
github.com/marten-seemann/qtls-go1-16 v0.1.5 github.com/marten-seemann/qtls-go1-16 v0.1.5
github.com/marten-seemann/qtls-go1-17 v0.1.1 github.com/marten-seemann/qtls-go1-17 v0.1.1
github.com/marten-seemann/qtls-go1-18 v0.1.1 github.com/marten-seemann/qtls-go1-18 v0.1.1

4
go.sum
View File

@ -216,8 +216,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w= github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w=
github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY= github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
github.com/lucas-clemente/quic-go v0.26.0 h1:ALBQXr9UJ8A1LyzvceX4jd9QFsHvlI0RR6BkV16o00A= github.com/lucas-clemente/quic-go v0.27.0 h1:v6WY87q9zD4dKASbG8hy/LpzAVNzEQzw8sEIeloJsc4=
github.com/lucas-clemente/quic-go v0.26.0/go.mod h1:AzgQoPda7N+3IqMMMkywBKggIFo2KT6pfnlrQ2QieeI= github.com/lucas-clemente/quic-go v0.27.0/go.mod h1:AzgQoPda7N+3IqMMMkywBKggIFo2KT6pfnlrQ2QieeI=
github.com/lunixbochs/struc v0.0.0-20200707160740-784aaebc1d40 h1:EnfXoSqDfSNJv0VBNqY/88RNnhSGYkrHaO0mmFGbVsc= github.com/lunixbochs/struc v0.0.0-20200707160740-784aaebc1d40 h1:EnfXoSqDfSNJv0VBNqY/88RNnhSGYkrHaO0mmFGbVsc=
github.com/lunixbochs/struc v0.0.0-20200707160740-784aaebc1d40/go.mod h1:vy1vK6wD6j7xX6O6hXe621WabdtNkou2h7uRtTfRMyg= github.com/lunixbochs/struc v0.0.0-20200707160740-784aaebc1d40/go.mod h1:vy1vK6wD6j7xX6O6hXe621WabdtNkou2h7uRtTfRMyg=
github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI= github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI=

106
transport/internet/quic/dialer.go
View File

@ -14,39 +14,39 @@ import (
"github.com/v2fly/v2ray-core/v5/transport/internet/tls" "github.com/v2fly/v2ray-core/v5/transport/internet/tls"
) )
type sessionContext struct { type connectionContext struct {
rawConn *sysConn rawConn *sysConn
session quic.Session conn quic.Connection
} }
var errSessionClosed = newError("session closed") var errConnectionClosed = newError("connection closed")
func (c *sessionContext) openStream(destAddr net.Addr) (*interConn, error) { func (c *connectionContext) openStream(destAddr net.Addr) (*interConn, error) {
if !isActive(c.session) { if !isActive(c.conn) {
return nil, errSessionClosed return nil, errConnectionClosed
} }
stream, err := c.session.OpenStream() stream, err := c.conn.OpenStream()
if err != nil { if err != nil {
return nil, err return nil, err
} }
conn := &interConn{ conn := &interConn{
stream: stream, stream: stream,
local: c.session.LocalAddr(), local: c.conn.LocalAddr(),
remote: destAddr, remote: destAddr,
} }
return conn, nil return conn, nil
} }
type clientSessions struct { type clientConnections struct {
access sync.Mutex access sync.Mutex
sessions map[net.Destination][]*sessionContext conns map[net.Destination][]*connectionContext
cleanup *task.Periodic cleanup *task.Periodic
} }
func isActive(s quic.Session) bool { func isActive(s quic.Connection) bool {
select { select {
case <-s.Context().Done(): case <-s.Context().Done():
return false return false
@ -55,31 +55,31 @@ func isActive(s quic.Session) bool {
} }
} }
func removeInactiveSessions(sessions []*sessionContext) []*sessionContext { func removeInactiveConnections(conns []*connectionContext) []*connectionContext {
activeSessions := make([]*sessionContext, 0, len(sessions)) activeConnections := make([]*connectionContext, 0, len(conns))
for _, s := range sessions { for _, s := range conns {
if isActive(s.session) { if isActive(s.conn) {
activeSessions = append(activeSessions, s) activeConnections = append(activeConnections, s)
continue continue
} }
if err := s.session.CloseWithError(0, ""); err != nil { if err := s.conn.CloseWithError(0, ""); err != nil {
newError("failed to close session").Base(err).WriteToLog() newError("failed to close connection").Base(err).WriteToLog()
} }
if err := s.rawConn.Close(); err != nil { if err := s.rawConn.Close(); err != nil {
newError("failed to close raw connection").Base(err).WriteToLog() newError("failed to close raw connection").Base(err).WriteToLog()
} }
} }
if len(activeSessions) < len(sessions) { if len(activeConnections) < len(conns) {
return activeSessions return activeConnections
} }
return sessions return conns
} }
func openStream(sessions []*sessionContext, destAddr net.Addr) *interConn { func openStream(conns []*connectionContext, destAddr net.Addr) *interConn {
for _, s := range sessions { for _, s := range conns {
if !isActive(s.session) { if !isActive(s.conn) {
continue continue
} }
@ -94,50 +94,50 @@ func openStream(sessions []*sessionContext, destAddr net.Addr) *interConn {
return nil return nil
} }
func (s *clientSessions) cleanSessions() error { func (s *clientConnections) cleanConnections() error {
s.access.Lock() s.access.Lock()
defer s.access.Unlock() defer s.access.Unlock()
if len(s.sessions) == 0 { if len(s.conns) == 0 {
return nil return nil
} }
newSessionMap := make(map[net.Destination][]*sessionContext) newConnMap := make(map[net.Destination][]*connectionContext)
for dest, sessions := range s.sessions { for dest, conns := range s.conns {
sessions = removeInactiveSessions(sessions) conns = removeInactiveConnections(conns)
if len(sessions) > 0 { if len(conns) > 0 {
newSessionMap[dest] = sessions newConnMap[dest] = conns
} }
} }
s.sessions = newSessionMap s.conns = newConnMap
return nil return nil
} }
func (s *clientSessions) openConnection(destAddr net.Addr, config *Config, tlsConfig *tls.Config, sockopt *internet.SocketConfig) (internet.Connection, error) { func (s *clientConnections) openConnection(destAddr net.Addr, config *Config, tlsConfig *tls.Config, sockopt *internet.SocketConfig) (internet.Connection, error) {
s.access.Lock() s.access.Lock()
defer s.access.Unlock() defer s.access.Unlock()
if s.sessions == nil { if s.conns == nil {
s.sessions = make(map[net.Destination][]*sessionContext) s.conns = make(map[net.Destination][]*connectionContext)
} }
dest := net.DestinationFromAddr(destAddr) dest := net.DestinationFromAddr(destAddr)
var sessions []*sessionContext var conns []*connectionContext
if s, found := s.sessions[dest]; found { if s, found := s.conns[dest]; found {
sessions = s conns = s
} }
if true { {
conn := openStream(sessions, destAddr) conn := openStream(conns, destAddr)
if conn != nil { if conn != nil {
return conn, nil return conn, nil
} }
} }
sessions = removeInactiveSessions(sessions) conns = removeInactiveConnections(conns)
rawConn, err := internet.ListenSystemPacket(context.Background(), &net.UDPAddr{ rawConn, err := internet.ListenSystemPacket(context.Background(), &net.UDPAddr{
IP: []byte{0, 0, 0, 0}, IP: []byte{0, 0, 0, 0},
@ -154,33 +154,33 @@ func (s *clientSessions) openConnection(destAddr net.Addr, config *Config, tlsCo
KeepAlive: true, KeepAlive: true,
} }
conn, err := wrapSysConn(rawConn.(*net.UDPConn), config) sysConn, err := wrapSysConn(rawConn.(*net.UDPConn), config)
if err != nil { if err != nil {
rawConn.Close() rawConn.Close()
return nil, err return nil, err
} }
session, err := quic.DialContext(context.Background(), conn, destAddr, "", tlsConfig.GetTLSConfig(tls.WithDestination(dest)), quicConfig) conn, err := quic.DialContext(context.Background(), sysConn, destAddr, "", tlsConfig.GetTLSConfig(tls.WithDestination(dest)), quicConfig)
if err != nil { if err != nil {
conn.Close() sysConn.Close()
return nil, err return nil, err
} }
context := &sessionContext{ context := &connectionContext{
session: session, conn: conn,
rawConn: conn, rawConn: sysConn,
} }
s.sessions[dest] = append(sessions, context) s.conns[dest] = append(conns, context)
return context.openStream(destAddr) return context.openStream(destAddr)
} }
var client clientSessions var client clientConnections
func init() { func init() {
client.sessions = make(map[net.Destination][]*sessionContext) client.conns = make(map[net.Destination][]*connectionContext)
client.cleanup = &task.Periodic{ client.cleanup = &task.Periodic{
Interval: time.Minute, Interval: time.Minute,
Execute: client.cleanSessions, Execute: client.cleanConnections,
} }
common.Must(client.cleanup.Start()) common.Must(client.cleanup.Start())
} }

16
transport/internet/quic/hub.go
View File

@ -22,17 +22,17 @@ type Listener struct {
addConn internet.ConnHandler addConn internet.ConnHandler
} }
func (l *Listener) acceptStreams(session quic.Session) { func (l *Listener) acceptStreams(conn quic.Connection) {
for { for {
stream, err := session.AcceptStream(context.Background()) stream, err := conn.AcceptStream(context.Background())
if err != nil { if err != nil {
newError("failed to accept stream").Base(err).WriteToLog() newError("failed to accept stream").Base(err).WriteToLog()
select { select {
case <-session.Context().Done(): case <-conn.Context().Done():
return return
case <-l.done.Wait(): case <-l.done.Wait():
if err := session.CloseWithError(0, ""); err != nil { if err := conn.CloseWithError(0, ""); err != nil {
newError("failed to close session").Base(err).WriteToLog() newError("failed to close connection").Base(err).WriteToLog()
} }
return return
default: default:
@ -43,8 +43,8 @@ func (l *Listener) acceptStreams(session quic.Session) {
conn := &interConn{ conn := &interConn{
stream: stream, stream: stream,
local: session.LocalAddr(), local: conn.LocalAddr(),
remote: session.RemoteAddr(), remote: conn.RemoteAddr(),
} }
l.addConn(conn) l.addConn(conn)
@ -55,7 +55,7 @@ func (l *Listener) keepAccepting() {
for { for {
conn, err := l.listener.Accept(context.Background()) conn, err := l.listener.Accept(context.Background())
if err != nil { if err != nil {
newError("failed to accept QUIC sessions").Base(err).WriteToLog() newError("failed to accept QUIC connections").Base(err).WriteToLog()
if l.done.Done() { if l.done.Done() {
break break
} }