a4d61a4be4
Noticed when working on https://github.com/ooni/probe/issues/1505. Justification for this diff: 1. [DialEarlyContext calls dialContext with the last argument set to false](https://github.com/lucas-clemente/quic-go/blob/v0.21.1/client.go#L153); 2. [the semantics of the last argument is whether we own the connection](https://github.com/lucas-clemente/quic-go/blob/v0.21.1/client.go#L187); 3. [this value is propagated to the client data structure](https://github.com/lucas-clemente/quic-go/blob/v0.21.1/client.go#L269); 4. [client.dial](https://github.com/lucas-clemente/quic-go/blob/v0.21.1/client.go#L302) runs the session in a background goroutine and only destroys the `packetHandlers` when the connection is owned; 5. [packetHandlerMap.Destroy](https://github.com/lucas-clemente/quic-go/blob/v0.21.1/packet_handler_map.go#L293) closes the underlying PacketConn. 6. also, the documentation clearly states that when you use `DialEarlyContext` you can use the same packet conn multiple times, so it does not take ownership.
103 lines
3.0 KiB
Go
103 lines
3.0 KiB
Go
package netxlite
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"errors"
|
|
"net"
|
|
"strconv"
|
|
|
|
"github.com/lucas-clemente/quic-go"
|
|
)
|
|
|
|
// QUICDialerContext is a dialer for QUIC using Context.
|
|
type QUICContextDialer interface {
|
|
// DialContext establishes a new QUIC session using the given
|
|
// network and address. The tlsConfig and the quicConfig arguments
|
|
// MUST NOT be nil. Returns either the session or an error.
|
|
DialContext(ctx context.Context, network, address string,
|
|
tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlySession, error)
|
|
}
|
|
|
|
// QUICDialer dials QUIC connections.
|
|
type QUICDialer interface {
|
|
// DialContext establishes a new QUIC session using the given
|
|
// network and address. The tlsConfig and the quicConfig arguments
|
|
// MUST NOT be nil. Returns either the session or an error.
|
|
Dial(network, address string, tlsConfig *tls.Config,
|
|
quicConfig *quic.Config) (quic.EarlySession, error)
|
|
}
|
|
|
|
// QUICListener listens for QUIC connections.
|
|
type QUICListener interface {
|
|
// Listen creates a new listening PacketConn.
|
|
Listen(addr *net.UDPAddr) (net.PacketConn, error)
|
|
}
|
|
|
|
// QUICListenerStdlib is a QUICListener using the standard library.
|
|
type QUICListenerStdlib struct{}
|
|
|
|
var _ QUICListener = &QUICListenerStdlib{}
|
|
|
|
// Listen implements QUICListener.Listen.
|
|
func (qls *QUICListenerStdlib) Listen(addr *net.UDPAddr) (net.PacketConn, error) {
|
|
return net.ListenUDP("udp", addr)
|
|
}
|
|
|
|
// QUICDialerQUICGo dials using the lucas-clemente/quic-go library.
|
|
type QUICDialerQUICGo struct {
|
|
// QUICListener is the underlying QUICListener to use.
|
|
QUICListener QUICListener
|
|
}
|
|
|
|
var _ QUICContextDialer = &QUICDialerQUICGo{}
|
|
|
|
// errInvalidIP indicates that a string is not a valid IP.
|
|
var errInvalidIP = errors.New("netxlite: invalid IP")
|
|
|
|
// DialContext implements ContextDialer.DialContext
|
|
func (d *QUICDialerQUICGo) DialContext(ctx context.Context, network string,
|
|
address string, tlsConfig *tls.Config, quicConfig *quic.Config) (
|
|
quic.EarlySession, error) {
|
|
onlyhost, onlyport, err := net.SplitHostPort(address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
port, err := strconv.Atoi(onlyport)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ip := net.ParseIP(onlyhost)
|
|
if ip == nil {
|
|
return nil, errInvalidIP
|
|
}
|
|
pconn, err := d.QUICListener.Listen(&net.UDPAddr{IP: net.IPv4zero, Port: 0})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
udpAddr := &net.UDPAddr{IP: ip, Port: port, Zone: ""}
|
|
sess, err := quic.DialEarlyContext(
|
|
ctx, pconn, udpAddr, address, tlsConfig, quicConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &quicSessionOwnsConn{EarlySession: sess, conn: pconn}, nil
|
|
}
|
|
|
|
// quicSessionOwnsConn ensures that we close the PacketConn.
|
|
type quicSessionOwnsConn struct {
|
|
// EarlySession is the embedded early session
|
|
quic.EarlySession
|
|
|
|
// conn is the connection we own
|
|
conn net.PacketConn
|
|
}
|
|
|
|
// CloseWithError implements quic.EarlySession.CloseWithError.
|
|
func (sess *quicSessionOwnsConn) CloseWithError(
|
|
code quic.ApplicationErrorCode, reason string) error {
|
|
err := sess.EarlySession.CloseWithError(code, reason)
|
|
sess.conn.Close()
|
|
return err
|
|
}
|