modified the customhttp package to address an issue with:

 DialContext field on ClientConfig
Access to the underlying net.Conn after connection

Author: xkilldash9x

pkg/customhttp/client.go

@@ -106,6 +106,69 @@ func (c *CustomClient) ConnectionCount() int {
 	return len(c.h1Clients) + len(c.h2Clients) + len(c.h3Clients)
 }
 
+// GetH1Connection returns the underlying net.Conn for an H1 connection to the specified host.
+// The host should be in "host:port" format (e.g., "example.com:443").
+// Returns nil if no H1 connection exists for the host or if the client is not connected.
+// This method is thread-safe.
+func (c *CustomClient) GetH1Connection(host string) net.Conn {
+	c.mu.RLock()
+	client, exists := c.h1Clients[host]
+	c.mu.RUnlock()
+
+	if !exists || client == nil {
+		return nil
+	}
+	return client.Conn
+}
+
+// GetH2Connection returns the underlying net.Conn for an H2 connection to the specified host.
+// The host should be in "host:port" format (e.g., "example.com:443").
+// Returns nil if no H2 connection exists for the host or if the client is not connected.
+// This method is thread-safe.
+func (c *CustomClient) GetH2Connection(host string) net.Conn {
+	c.mu.RLock()
+	client, exists := c.h2Clients[host]
+	c.mu.RUnlock()
+
+	if !exists || client == nil {
+		return nil
+	}
+	return client.Conn
+}
+
+// GetH3Connection returns the underlying net.Conn for an H3 connection to the specified host.
+// Note: HTTP/3 uses QUIC which manages connections differently. The underlying QUIC
+// connection is managed by the http3.Transport and is not directly exposed as a net.Conn.
+// This method always returns nil for H3 connections.
+// This method is thread-safe.
+func (c *CustomClient) GetH3Connection(host string) net.Conn {
+	// H3 uses QUIC which doesn't expose a traditional net.Conn.
+	// The connection is managed internally by quic-go's http3.Transport.
+	return nil
+}
+
+// GetConnection returns the underlying net.Conn for any active connection to the specified host.
+// It checks H2 and H1 connections in that order and returns the first one found.
+// The host should be in "host:port" format (e.g., "example.com:443").
+// Returns nil if no connection exists for the host.
+// Note: H3/QUIC connections are not included as they don't expose a traditional net.Conn.
+// This method is thread-safe.
+func (c *CustomClient) GetConnection(host string) net.Conn {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	// Check H2 first (most common for modern HTTPS)
+	if client, exists := c.h2Clients[host]; exists && client != nil && client.Conn != nil {
+		return client.Conn
+	}
+	// Check H1
+	if client, exists := c.h1Clients[host]; exists && client != nil && client.Conn != nil {
+		return client.Conn
+	}
+	// H3/QUIC connections don't expose a traditional net.Conn
+	return nil
+}
+
 // Do executes a single HTTP request and returns the response. This is the main
 // entry point for the client. It orchestrates the entire request lifecycle,
 // including:
@@ -853,17 +916,19 @@ func isSameOrigin(u1, u2 *url.URL) bool {
 	}
 	p1 := u1.Port()
 	if p1 == "" {
-		if u1.Scheme == "https" {
+		switch u1.Scheme {
+		case "https":
 			p1 = "443"
-		} else if u1.Scheme == "http" {
+		case "http":
 			p1 = "80"
 		}
 	}
 	p2 := u2.Port()
 	if p2 == "" {
-		if u2.Scheme == "https" {
+		switch u2.Scheme {
+		case "https":
 			p2 = "443"
-		} else if u2.Scheme == "http" {
+		case "http":
 			p2 = "80"
 		}
 	}

pkg/customhttp/h2client.go

@@ -1175,7 +1175,7 @@ func (c *H2Client) processHeadersFrame(stream *h2StreamState, f *http2.MetaHeade
 				stream.StatusCode = status
 			}
 		} else {
-			stream.Headers.Add(http.CanonicalHeaderKey(hf.Name), hf.Value)
+			stream.Headers.Add(hf.Name, hf.Value)
 		}
 	}
 

pkg/network/dialer.go

@@ -14,6 +14,10 @@ import (
 	"time"
 )
 
+// DialContextFunc is a function type that matches the signature of net.Dialer.DialContext.
+// It can be used to provide custom connection establishment logic.
+type DialContextFunc func(ctx context.Context, network, address string) (net.Conn, error)
+
 // DialerConfig holds the complete configuration for establishing network connections,
 // including timeouts, keep-alive settings, TLS parameters, TCP options, custom DNS
 // resolvers, and proxy settings.
@@ -34,6 +38,11 @@ type DialerConfig struct {
 	// ProxyURL specifies the URL of an HTTP/HTTPS proxy server. If set, connections
 	// will be established through the proxy using the CONNECT method.
 	ProxyURL *url.URL
+	// DialContext allows providing a custom dial function for establishing TCP connections.
+	// If set, this function will be used instead of the default net.Dialer for direct connections.
+	// Note: When ProxyURL is set, this function is used to connect to the proxy server.
+	// The function should return a raw TCP connection; TLS wrapping is handled separately.
+	DialContext DialContextFunc
 }
 
 // Clone creates a deep copy of the DialerConfig, ensuring that mutable fields
@@ -54,6 +63,8 @@ func (c *DialerConfig) Clone() *DialerConfig {
 		proxyURLCopy := *c.ProxyURL
 		clone.ProxyURL = &proxyURLCopy
 	}
+	// DialContext is a function, safe to copy by value (shallow copy).
+	// The caller is responsible for ensuring their custom DialContext is thread-safe.
 	return &clone
 }
 
@@ -127,16 +138,23 @@ func DialTCPContext(ctx context.Context, network, address string, config *Dialer
 
 // dialDirect establishes a direct TCP connection to the target address.
 func dialDirect(ctx context.Context, network, address string, config *DialerConfig) (net.Conn, error) {
-	dialer := &net.Dialer{
-		Timeout:   config.Timeout,
-		KeepAlive: config.KeepAlive,
-		// Enable Happy Eyeballs (RFC 8305) for faster IPv4/IPv6 fallback.
-		FallbackDelay: 300 * time.Millisecond,
-		Resolver:      config.Resolver,
-	}
+	var rawConn net.Conn
+	var err error
 
 	// Step 1: Establish the raw TCP connection.
-	rawConn, err := dialer.DialContext(ctx, network, address)
+	// Use custom DialContext if provided, otherwise use the default net.Dialer.
+	if config.DialContext != nil {
+		rawConn, err = config.DialContext(ctx, network, address)
+	} else {
+		dialer := &net.Dialer{
+			Timeout:   config.Timeout,
+			KeepAlive: config.KeepAlive,
+			// Enable Happy Eyeballs (RFC 8305) for faster IPv4/IPv6 fallback.
+			FallbackDelay: 300 * time.Millisecond,
+			Resolver:      config.Resolver,
+		}
+		rawConn, err = dialer.DialContext(ctx, network, address)
+	}
 	if err != nil {
 		return nil, fmt.Errorf("tcp dial failed: %w", err)
 	}
@@ -276,9 +294,9 @@ func (c *prefixedConn) Read(p []byte) (int, error) {
 // both direct and proxied connections transparently.
 //
 // This function orchestrates the entire connection process:
-// 1. Establishes a raw TCP connection (or a proxy tunnel) via DialTCPContext.
-// 2. If `config.TLSConfig` is not nil, it performs a TLS handshake over the
-//    established connection to upgrade it to a secure `tls.Conn`.
+//  1. Establishes a raw TCP connection (or a proxy tunnel) via DialTCPContext.
+//  2. If `config.TLSConfig` is not nil, it performs a TLS handshake over the
+//     established connection to upgrade it to a secure `tls.Conn`.
 //
 // It is suitable for creating connections for protocols that handle their own
 // application layer logic, such as WebSockets.