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

app/dns/nameserver_quic.go

@@ -34,13 +34,13 @@ const handshakeIdleTimeout = time.Second * 8
 // QUICNameServer implemented DNS over QUIC
 type QUICNameServer struct {
 	sync.RWMutex
-	ips         map[string]*record
+	ips         map[string]record
 	pub         *pubsub.Service
 	cleanup     *task.Periodic
 	reqID       uint32
 	name        string
-	destination *net.Destination
-	session     quic.Session
+	destination net.Destination
+	connection  quic.Connection
 }
 
 // NewQUICNameServer creates DNS-over-QUIC client object for local resolving
@@ -58,10 +58,10 @@ func NewQUICNameServer(url *url.URL) (*QUICNameServer, error) {
 	dest := net.UDPDestination(net.ParseAddress(url.Hostname()), port)
 
 	s := &QUICNameServer{
-		ips:         make(map[string]*record),
+		ips:         make(map[string]record),
 		pub:         pubsub.NewService(),
 		name:        url.String(),
-		destination: &dest,
+		destination: dest,
 	}
 	s.cleanup = &task.Periodic{
 		Interval: time.Minute,
@@ -103,7 +103,7 @@ func (s *QUICNameServer) Cleanup() error {
 	}
 
 	if len(s.ips) == 0 {
-		s.ips = make(map[string]*record)
+		s.ips = make(map[string]record)
 	}
 
 	return nil
@@ -113,10 +113,7 @@ func (s *QUICNameServer) updateIP(req *dnsRequest, ipRec *IPRecord) {
 	elapsed := time.Since(req.start)
 
 	s.Lock()
-	rec, found := s.ips[req.domain]
-	if !found {
-		rec = &record{}
-	}
+	rec := s.ips[req.domain]
 	updated := false
 
 	switch req.reqType {
@@ -197,7 +194,7 @@ func (s *QUICNameServer) sendQuery(ctx context.Context, domain string, clientIP
 
 			conn, err := s.openStream(dnsCtx)
 			if err != nil {
-				newError("failed to open quic session").Base(err).AtError().WriteToLog()
+				newError("failed to open quic connection").Base(err).AtError().WriteToLog()
 				return
 			}
 
@@ -325,7 +322,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 {
 	case <-s.Context().Done():
 		return false
@@ -334,17 +331,17 @@ func isActive(s quic.Session) bool {
 	}
 }
 
-func (s *QUICNameServer) getSession(ctx context.Context) (quic.Session, error) {
-	var session quic.Session
+func (s *QUICNameServer) getConnection(ctx context.Context) (quic.Connection, error) {
+	var conn quic.Connection
 	s.RLock()
-	session = s.session
-	if session != nil && isActive(session) {
+	conn = s.connection
+	if conn != nil && isActive(conn) {
 		s.RUnlock()
-		return session, nil
+		return conn, nil
 	}
-	if session != nil {
-		// we're recreating the session, let's create a new one
-		_ = session.CloseWithError(0, "")
+	if conn != nil {
+		// we're recreating the connection, let's create a new one
+		_ = conn.CloseWithError(0, "")
 	}
 	s.RUnlock()
 
@@ -352,42 +349,42 @@ func (s *QUICNameServer) getSession(ctx context.Context) (quic.Session, error) {
 	defer s.Unlock()
 
 	var err error
-	session, err = s.openSession(ctx)
+	conn, err = s.openConnection(ctx)
 	if err != nil {
 		// This does not look too nice, but QUIC (or maybe quic-go)
 		// doesn't seem stable enough.
 		// Maybe retransmissions aren't fully implemented in quic-go?
 		// Anyways, the simple solution is to make a second try when
-		// it fails to open the QUIC session.
-		session, err = s.openSession(ctx)
+		// it fails to open the QUIC connection.
+		conn, err = s.openConnection(ctx)
 		if err != nil {
 			return nil, err
 		}
 	}
-	s.session = session
-	return session, nil
+	s.connection = conn
+	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{}
 	quicConfig := &quic.Config{
 		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 {
 		return nil, err
 	}
 
-	return session, nil
+	return conn, nil
 }
 
 func (s *QUICNameServer) openStream(ctx context.Context) (quic.Stream, error) {
-	session, err := s.getSession(ctx)
+	conn, err := s.getConnection(ctx)
 	if err != nil {
 		return nil, err
 	}
 
 	// open a new stream
-	return session.OpenStreamSync(ctx)
+	return conn.OpenStreamSync(ctx)
 }

go.mod

@@ -43,8 +43,8 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/riobard/go-bloom v0.0.0-20200614022211-cdc8013cb5b3 // indirect
 	github.com/xtaci/smux v1.5.15 // indirect
-	go4.org/intern v0.0.0-20210108033219-3eb7198706b2 // indirect
-	go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222180813-1025295fd063 // indirect
+	go4.org/intern v0.0.0-20220301175310-a089fc204883 // indirect
+	go4.org/unsafe/assume-no-moving-gc v0.0.0-20211027215541-db492cf91b37
 	golang.org/x/mod v0.4.2 // indirect
 	golang.org/x/text v0.3.6 // indirect
 	golang.org/x/tools v0.1.1 // indirect

go.sum

@@ -354,9 +354,13 @@ go4.org v0.0.0-20180809161055-417644f6feb5 h1:+hE86LblG4AyDgwMCLTE6FOlM9+qjHSYS+
 go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
 go4.org/intern v0.0.0-20210108033219-3eb7198706b2 h1:VFTf+jjIgsldaz/Mr00VaCSswHJrI2hIjQygE/W4IMg=
 go4.org/intern v0.0.0-20210108033219-3eb7198706b2/go.mod h1:vLqJ+12kCw61iCWsPto0EOHhBS+o4rO5VIucbc9g2Cc=
+go4.org/intern v0.0.0-20220301175310-a089fc204883 h1:pq5gAii+wMY+DsJ5r9I6T7CHjHxHlb4d45gChzX2SsI=
+go4.org/intern v0.0.0-20220301175310-a089fc204883/go.mod h1:cS2ma+47FKrLPdXFpr7CuxiTW3eyJbWew4qx0qtQWDA=
 go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222175341-b30ae309168e/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E=
 go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222180813-1025295fd063 h1:1tk03FUNpulq2cuWpXZWj649rwJpk0d20rxWiopKRmc=
 go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222180813-1025295fd063/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E=
+go4.org/unsafe/assume-no-moving-gc v0.0.0-20211027215541-db492cf91b37 h1:Tx9kY6yUkLge/pFG7IEMwDZy6CS2ajFc9TvQdPCW0uA=
+go4.org/unsafe/assume-no-moving-gc v0.0.0-20211027215541-db492cf91b37/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E=
 golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=

transport/internet/quic/dialer.go

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

transport/internet/quic/hub.go

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