☎️ conn: improve dialer API

- Add TFO method to expose actual TFO state.
- Add DialUDPMmsgConn.
- Return SocketInfo like the listen methods do.

Author: database64128

conn/conn.go

@@ -250,25 +250,38 @@ var (
 	DefaultUDPClientListenConfig = DefaultUDPClientSocketOptions.ListenConfig()
 )
 
-// Dialer is [tfo.Dialer] but provides a subjectively nicer API.
-type Dialer tfo.Dialer
+// Dialer wraps a [tfo.Dialer] and provides a subjectively nicer API.
+type Dialer struct {
+	td  tfo.Dialer
+	fns setFuncSlice
+}
+
+// TFO returns true if the next DialTCP call will attempt to enable TFO.
+func (d *Dialer) TFO() bool {
+	return d.td.TFO()
+}
 
 // DialTCP wraps [tfo.Dialer.DialContext] and returns a [*net.TCPConn] directly.
-func (d *Dialer) DialTCP(ctx context.Context, network, address string, b []byte) (*net.TCPConn, error) {
-	c, err := (*tfo.Dialer)(d).DialContext(ctx, network, address, b)
+func (d *Dialer) DialTCP(ctx context.Context, network, address string, b []byte) (tc *net.TCPConn, info SocketInfo, err error) {
+	td := d.td
+	td.ControlContext = d.fns.controlContextFunc(&info)
+	c, err := td.DialContext(ctx, network, address, b)
 	if err != nil {
-		return nil, err
+		return nil, info, err
 	}
-	return c.(*net.TCPConn), nil
+	return c.(*net.TCPConn), info, nil
 }
 
 // DialUDP wraps [net.Dialer.DialContext] and returns a [*net.UDPConn] directly.
-func (d *Dialer) DialUDP(ctx context.Context, network, address string) (*net.UDPConn, error) {
-	c, err := d.Dialer.DialContext(ctx, network, address)
+func (d *Dialer) DialUDP(ctx context.Context, network, address string) (uc *net.UDPConn, info SocketInfo, err error) {
+	info.MaxUDPGSOSegments = 1
+	nd := d.td.Dialer
+	nd.ControlContext = d.fns.controlContextFunc(&info)
+	c, err := nd.DialContext(ctx, network, address)
 	if err != nil {
-		return nil, err
+		return nil, info, err
 	}
-	return c.(*net.UDPConn), nil
+	return c.(*net.UDPConn), info, nil
 }
 
 // DialerSocketOptions contains dialer-specific socket options.
@@ -311,13 +324,13 @@ type DialerSocketOptions struct {
 // Dialer returns a [Dialer] with a control function that sets the socket options.
 func (dso DialerSocketOptions) Dialer() Dialer {
 	d := Dialer{
-		Dialer: net.Dialer{
-			ControlContext: dso.buildSetFns().controlContextFunc(nil),
+		td: tfo.Dialer{
+			DisableTFO: !dso.TCPFastOpen,
+			Fallback:   dso.TCPFastOpenFallback,
 		},
-		DisableTFO: !dso.TCPFastOpen,
-		Fallback:   dso.TCPFastOpenFallback,
+		fns: dso.buildSetFns(),
 	}
-	d.SetMultipathTCP(dso.MultipathTCP)
+	d.td.SetMultipathTCP(dso.MultipathTCP)
 	return d
 }
 

conn/conn_mmsg.go

@@ -20,3 +20,17 @@ func (lc *ListenConfig) ListenUDPMmsgConn(ctx context.Context, network, address
 	c, err = NewMmsgConn(pc.(*net.UDPConn))
 	return c, info, err
 }
+
+// DialUDPMmsgConn is like [DialUDP] but wraps the [*net.UDPConn] in a [MmsgConn] for
+// reading and writing multiple messages using the recvmmsg(2) and sendmmsg(2) system calls.
+func (d *Dialer) DialUDPMmsgConn(ctx context.Context, network, address string) (c MmsgConn, info SocketInfo, err error) {
+	info.MaxUDPGSOSegments = 1
+	nd := d.td.Dialer
+	nd.ControlContext = d.fns.controlContextFunc(&info)
+	nc, err := nd.DialContext(ctx, network, address)
+	if err != nil {
+		return MmsgConn{}, info, err
+	}
+	c, err = NewMmsgConn(nc.(*net.UDPConn))
+	return c, info, err
+}

direct/udp.go

@@ -184,7 +184,7 @@ func (c *Socks5UDPClient) Info() zerocopy.UDPClientInfo {
 
 // NewSession implements [zerocopy.UDPClient.NewSession].
 func (c *Socks5UDPClient) NewSession(ctx context.Context) (zerocopy.UDPClientSessionInfo, zerocopy.UDPClientSession, error) {
-	tc, err := c.dialer.DialTCP(ctx, c.networkTCP, c.address, nil)
+	tc, _, err := c.dialer.DialTCP(ctx, c.networkTCP, c.address, nil)
 	if err != nil {
 		return c.info, zerocopy.UDPClientSession{}, fmt.Errorf("failed to dial SOCKS5 server: %w", err)
 	}
@@ -244,7 +244,7 @@ func (c *Socks5AuthUDPClient) Info() zerocopy.UDPClientInfo {
 
 // NewSession implements [zerocopy.UDPClient.NewSession].
 func (c *Socks5AuthUDPClient) NewSession(ctx context.Context) (zerocopy.UDPClientSessionInfo, zerocopy.UDPClientSession, error) {
-	tc, err := c.plainClient.dialer.DialTCP(ctx, c.plainClient.networkTCP, c.plainClient.address, nil)
+	tc, _, err := c.plainClient.dialer.DialTCP(ctx, c.plainClient.networkTCP, c.plainClient.address, nil)
 	if err != nil {
 		return c.plainClient.info, zerocopy.UDPClientSession{}, fmt.Errorf("failed to dial SOCKS5 server: %w", err)
 	}

netio/tcp.go

@@ -49,13 +49,17 @@ var (
 func (c *TCPClient) NewStreamDialer() (StreamDialer, StreamDialerInfo) {
 	return c, StreamDialerInfo{
 		Name:                 c.name,
-		NativeInitialPayload: !c.dialer.DisableTFO,
+		NativeInitialPayload: c.dialer.TFO(),
 	}
 }
 
 // DialStream implements [StreamDialer.DialStream].
 func (c *TCPClient) DialStream(ctx context.Context, addr conn.Addr, payload []byte) (Conn, error) {
-	return c.dialer.DialTCP(ctx, c.network, addr.String(), payload)
+	tc, _, err := c.dialer.DialTCP(ctx, c.network, addr.String(), payload)
+	if err != nil {
+		return nil, err
+	}
+	return tc, nil
 }
 
 // NewTCPTransparentProxyServer returns a new TCP transparent proxy server.