package quicreuse

Import Path
	github.com/libp2p/go-libp2p/p2p/transport/quicreuse (on go.dev)

Dependency Relation
	imports 25 packages, and imported by 4 packages

Involved Source Files

	    config.go
	  d connmgr.go
		Package quicreuse provides `quicreuse.ConnManager`, which provides functionality
		for reusing QUIC transports for various purposes, like listening & dialing, having
		multiple QUIC listeners on the same address with different ALPNs, and sharing the
		same address with non QUIC transports like WebRTC.

	    listener.go
	    nonquic_packetconn.go
	    options.go
	    quic_multiaddr.go
	    reuse.go
	    tracer.go
Package-Level Type Names (total 7)

	/* sort by: alphabet | popularity */
	 type ConnManager (struct)
		ConnManager enables QUIC and WebTransport transports to listen on the same port, reusing
		listen addresses for dialing, and provides a PacketConn for sharing the listen address
		with other protocols like WebRTC.
		Reusing the listen address for dialing helps with address discovery and hole punching. For details
		of the reuse logic see `ListenQUICAndAssociate` and `DialQUIC`.
		If reuseport is disabled using the `DisableReuseport` option, listen addresses are not used for
		dialing.

		Methods (total 10)
			(*ConnManager) ClientConfig() *quic.Config
			(*ConnManager) Close() error
			(*ConnManager) DialQUIC(ctx context.Context, raddr ma.Multiaddr, tlsConf *tls.Config, allowWindowIncrease func(conn quic.Connection, delta uint64) bool) (quic.Connection, error)
				DialQUIC dials `raddr`. Use `WithAssociation` to select a specific transport that was previously used for listening.
				see the documentation for `ListenQUICAndAssociate` for details on associate.
				The priority order for reusing the transport is as follows:
				- Listening transport with the same association
				- Any other listening transport
				- Any transport previously used for dialing
				If none of these are available, it'll create a new transport.

			(*ConnManager) LendTransport(network string, tr QUICTransport, conn net.PacketConn) (<-chan struct{}, error)
				LendTransport is an advanced method used to lend an existing QUICTransport
				to the ConnManager. The ConnManager will close the returned channel when it
				is done with the transport, so that the owner may safely close the transport.

			(*ConnManager) ListenQUIC(addr ma.Multiaddr, tlsConf *tls.Config, allowWindowIncrease func(conn quic.Connection, delta uint64) bool) (Listener, error)
				ListenQUIC listens for quic connections with the provided `tlsConf.NextProtos` ALPNs on `addr`. The same addr can be shared between
				different ALPNs.

			(*ConnManager) ListenQUICAndAssociate(association any, addr ma.Multiaddr, tlsConf *tls.Config, allowWindowIncrease func(conn quic.Connection, delta uint64) bool) (Listener, error)
				ListenQUICAndAssociate listens for quic connections with the provided `tlsConf.NextProtos` ALPNs on `addr`. The same addr can be shared between
				different ALPNs.
				The QUIC Transport used for listening is tagged with the `association`. Any subsequent `TransportWithAssociationForDial`,
				or `DialQUIC` calls with the same `association` will reuse the QUIC Transport used by this method.
				A common use of associations is to ensure /quic dials use the quic listening address and /webtransport dials use the
				WebTransport listening address.

			(*ConnManager) Protocols() []int
				Protocols returns the supported QUIC protocols. The only supported protocol at the moment is /quic-v1.

			(*ConnManager) SharedNonQUICPacketConn(_ string, laddr *net.UDPAddr) (net.PacketConn, error)
				SharedNonQUICPacketConn returns a `net.PacketConn` for `laddr` for non QUIC uses.

			(*ConnManager) TransportForDial(network string, raddr *net.UDPAddr) (RefCountedQUICTransport, error)
				TransportForDial returns a transport for dialing `raddr`.
				If reuseport is enabled, it attempts to reuse the QUIC Transport used for
				previous listens or dials.

			(*ConnManager) TransportWithAssociationForDial(association any, network string, raddr *net.UDPAddr) (RefCountedQUICTransport, error)
				TransportWithAssociationForDial returns a transport for dialing `raddr`.
				If reuseport is enabled, it attempts to reuse the QUIC Transport previously used for listening with `ListenQuicAndAssociate`
				with the same `association`. If it fails to do so, it uses any other previously used transport.

		Implements (at least 2)
			*ConnManager : github.com/prometheus/common/expfmt.Closer
			*ConnManager : io.Closer
		As Outputs Of (at least one exported)
			func NewConnManager(statelessResetKey quic.StatelessResetKey, tokenKey quic.TokenGeneratorKey, opts ...Option) (*ConnManager, error)
		As Inputs Of (at least 2)
			func github.com/libp2p/go-libp2p/p2p/transport/quic.NewTransport(key ic.PrivKey, connManager *ConnManager, psk pnet.PSK, gater connmgr.ConnectionGater, rcmgr network.ResourceManager) (tpt.Transport, error)
			func github.com/libp2p/go-libp2p/p2p/transport/webtransport.New(key ic.PrivKey, psk pnet.PSK, connManager *ConnManager, gater connmgr.ConnectionGater, rcmgr network.ResourceManager, opts ...libp2pwebtransport.Option) (tpt.Transport, error)

	 type Listener (interface)

		Methods (total 4)
			( Listener) Accept(context.Context) (quic.Connection, error)
			( Listener) Addr() net.Addr
			( Listener) Close() error
			( Listener) Multiaddrs() []ma.Multiaddr
		Implements (at least 3)
			 Listener : QUICListener
			 Listener : github.com/prometheus/common/expfmt.Closer
			 Listener : io.Closer
		As Outputs Of (at least 2)
			func (*ConnManager).ListenQUIC(addr ma.Multiaddr, tlsConf *tls.Config, allowWindowIncrease func(conn quic.Connection, delta uint64) bool) (Listener, error)
			func (*ConnManager).ListenQUICAndAssociate(association any, addr ma.Multiaddr, tlsConf *tls.Config, allowWindowIncrease func(conn quic.Connection, delta uint64) bool) (Listener, error)

	 type Option (func)

		As Outputs Of (at least 6)
			func ConnContext(f func(ctx context.Context, clientInfo *quic.ClientInfo) (context.Context, error)) Option
			func DisableReuseport() Option
			func EnableMetrics(reg prometheus.Registerer) Option
			func OverrideListenUDP(f listenUDP) Option
			func OverrideSourceIPSelector(f func() (SourceIPSelector, error)) Option
			func VerifySourceAddress(f func(addr net.Addr) bool) Option
		As Inputs Of (at least 2)
			func NewConnManager(statelessResetKey quic.StatelessResetKey, tokenKey quic.TokenGeneratorKey, opts ...Option) (*ConnManager, error)
			func github.com/libp2p/go-libp2p.QUICReuse(constructor interface{}, opts ...Option) libp2p.Option

	 type QUICListener (interface)

		Methods (total 3)
			( QUICListener) Accept(ctx context.Context) (quic.Connection, error)
			( QUICListener) Addr() net.Addr
			( QUICListener) Close() error
		Implemented By (at least 2)
			 Listener (interface)
			*github.com/quic-go/quic-go.Listener
		Implements (at least 2)
			 QUICListener : github.com/prometheus/common/expfmt.Closer
			 QUICListener : io.Closer
		As Outputs Of (at least 2)
			func QUICTransport.Listen(tlsConf *tls.Config, conf *quic.Config) (QUICListener, error)
			func RefCountedQUICTransport.Listen(tlsConf *tls.Config, conf *quic.Config) (QUICListener, error)

	 type QUICTransport (interface)

		Methods (total 5)
			( QUICTransport) Close() error
			( QUICTransport) Dial(ctx context.Context, addr net.Addr, tlsConf *tls.Config, conf *quic.Config) (quic.Connection, error)
			( QUICTransport) Listen(tlsConf *tls.Config, conf *quic.Config) (QUICListener, error)
			( QUICTransport) ReadNonQUICPacket(ctx context.Context, b []byte) (int, net.Addr, error)
			( QUICTransport) WriteTo(b []byte, addr net.Addr) (int, error)
		Implements (at least 2)
			 QUICTransport : github.com/prometheus/common/expfmt.Closer
			 QUICTransport : io.Closer
		As Inputs Of (at least one exported)
			func (*ConnManager).LendTransport(network string, tr QUICTransport, conn net.PacketConn) (<-chan struct{}, error)

	 type RefCountedQUICTransport (interface)

		Methods (total 7)
			( RefCountedQUICTransport) Close() error
			( RefCountedQUICTransport) DecreaseCount()
				count transport reference

			( RefCountedQUICTransport) Dial(ctx context.Context, addr net.Addr, tlsConf *tls.Config, conf *quic.Config) (quic.Connection, error)
			( RefCountedQUICTransport) IncreaseCount()
			( RefCountedQUICTransport) Listen(tlsConf *tls.Config, conf *quic.Config) (QUICListener, error)
			( RefCountedQUICTransport) LocalAddr() net.Addr
			( RefCountedQUICTransport) WriteTo([]byte, net.Addr) (int, error)
				Used to send packets directly around QUIC. Useful for hole punching.

		Implements (at least 2)
			 RefCountedQUICTransport : github.com/prometheus/common/expfmt.Closer
			 RefCountedQUICTransport : io.Closer
		As Outputs Of (at least 2)
			func (*ConnManager).TransportForDial(network string, raddr *net.UDPAddr) (RefCountedQUICTransport, error)
			func (*ConnManager).TransportWithAssociationForDial(association any, network string, raddr *net.UDPAddr) (RefCountedQUICTransport, error)

	 type SourceIPSelector (interface)

		Methods (only one)
			( SourceIPSelector) PreferredSourceIPForDestination(dst *net.UDPAddr) (net.IP, error)


Package-Level Functions (total 10)

	 func ConnContext(f func(ctx context.Context, clientInfo *quic.ClientInfo) (context.Context, error)) Option
		ConnContext sets the context for all connections accepted by listeners. This doesn't affect the
		context for dialed connections. To reject a connection, return a non nil error.

	 func DisableReuseport() Option
	 func EnableMetrics(reg prometheus.Registerer) Option
		EnableMetrics enables Prometheus metrics collection. If reg is nil,
		prometheus.DefaultRegisterer will be used as the registerer.

	 func FromQuicMultiaddr(addr ma.Multiaddr) (*net.UDPAddr, quic.Version, error)
	 func NewConnManager(statelessResetKey quic.StatelessResetKey, tokenKey quic.TokenGeneratorKey, opts ...Option) (*ConnManager, error)
		NewConnManager returns a new ConnManager

	 func OverrideListenUDP(f listenUDP) Option
	 func OverrideSourceIPSelector(f func() (SourceIPSelector, error)) Option
	 func ToQuicMultiaddr(na net.Addr, version quic.Version) (ma.Multiaddr, error)
	 func VerifySourceAddress(f func(addr net.Addr) bool) Option
		VerifySourceAddress returns whether to verify the source address for incoming connection requests.
		For more details see: `quic.Transport.VerifySourceAddress`

	 func WithAssociation(ctx context.Context, association any) context.Context
		WithAssociation returns a new context with the given association. Used in
		DialQUIC to prefer a transport that has the given association.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.