omarandClaude Opus 5
0a6689b29e
DialEarly with a packet conn the caller made sets a flag that means quic-go does not own it: closing the transport only stops reading from the socket. Neither DNS transport closed it. On the QUIC one it was closed on a failed handshake and never on success, so every redial — idle timeout, retry error, engine reload — left a UDP socket for the life of the process. On the HTTP/3 one the library drives its own reconnects, so the leak compounds without anything in our code looking wrong. That is the same shape as v2rayquic's, where offerNew overwrote the raw conn on every reconnect without closing the previous one. Both are now owned by a watcher tied to the connection's own context, so the socket lives exactly as long as the connection does. This matters more than it did last week: the shipped resolvers are DoH, and DNS is intercepted by default now, so the whole network's query stream rides this path on a router with 512 MB. The same upstream commit fixes both halves. We had taken the v2ray half and not the DNS one — the third time this session a paired fix arrived half-applied, and the first of those cost a day of debugging. These two files are now byte-identical to upstream so a rebase cannot reopen it. Also from that family: websocket and httpupgrade leaked their conn on failed handshakes, and a QUIC stream's Close did not release a blocked write. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
46 lines
922 B
Go
46 lines
922 B
Go
package v2rayquic
|
|
|
|
import (
|
|
"net"
|
|
"time"
|
|
|
|
"github.com/sagernet/quic-go"
|
|
qtls "github.com/sagernet/sing-quic"
|
|
)
|
|
|
|
type StreamWrapper struct {
|
|
Conn *quic.Conn
|
|
*quic.Stream
|
|
}
|
|
|
|
func (s *StreamWrapper) Read(p []byte) (n int, err error) {
|
|
n, err = s.Stream.Read(p)
|
|
return n, qtls.WrapError(err)
|
|
}
|
|
|
|
func (s *StreamWrapper) Write(p []byte) (n int, err error) {
|
|
n, err = s.Stream.Write(p)
|
|
return n, qtls.WrapError(err)
|
|
}
|
|
|
|
func (s *StreamWrapper) LocalAddr() net.Addr {
|
|
return s.Conn.LocalAddr()
|
|
}
|
|
|
|
func (s *StreamWrapper) RemoteAddr() net.Addr {
|
|
return s.Conn.RemoteAddr()
|
|
}
|
|
|
|
func (s *StreamWrapper) Upstream() any {
|
|
return s.Stream
|
|
}
|
|
|
|
func (s *StreamWrapper) Close() error {
|
|
s.CancelRead(0)
|
|
s.Stream.Close()
|
|
// quic-go's Stream.Close does not unblock a Write blocked on flow control,
|
|
// but a past write deadline does; buffered data and the FIN are unaffected.
|
|
s.Stream.SetWriteDeadline(time.Now())
|
|
return nil
|
|
}
|