[+] fix: http closed connections now handled

connection.go

@@ -317,7 +317,8 @@ func (s *Session) initConn(req *Request) (conn *Conn, err error) {
 			}
 		} else {
 			if conn.Conn, err = (&net.Dialer{
-				Timeout: conn.TimeOut,
+				Timeout:   conn.TimeOut,
+				KeepAlive: 30 * time.Second,
 			}).DialContext(s.ctx, "tcp", host); err != nil {
 				return nil, err
 			}

connection_proxy.go

@@ -250,7 +250,7 @@ func (c *proxyDialer) connect(req *http.Request, conn net.Conn, negotiatedProtoc
 				c.H2Conn = h2clientConn
 				c.conn = conn
 				c.h2Mu.Unlock()
-				return proxyConn, err
+				return proxyConn, nil
 			}
 		}
 	}

profiles.go

@@ -88,9 +88,9 @@ func GetLastChromeVersion() *tls.ClientHelloSpec {
 	return &tls.ClientHelloSpec{
 		CipherSuites: []uint16{
 			tls.GREASE_PLACEHOLDER,
-			tls.TLS_CHACHA20_POLY1305_SHA256,
 			tls.TLS_AES_128_GCM_SHA256,
 			tls.TLS_AES_256_GCM_SHA384,
+			tls.TLS_CHACHA20_POLY1305_SHA256,
 			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
 			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
 			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,

response.go

@@ -12,6 +12,7 @@ import (
 func (s *Session) buildResponse(response *Response, httpResponse *http.Response) (err error) {
 	response.RawBody = httpResponse.Body
 	response.HttpResponse = httpResponse
+	response.Session = s
 
 	var (
 		wg      sync.WaitGroup
@@ -60,7 +61,12 @@ func (s *Session) buildResponse(response *Response, httpResponse *http.Response)
 }
 
 func (r *Response) ReadBody() (body []byte, err error) {
-	defer r.HttpResponse.Body.Close()
+	defer func() {
+		_ = r.HttpResponse.Body.Close()
+		if r.HttpResponse.Close {
+			r.Session.Connections.Remove(r.HttpResponse.Request.URL)
+		}
+	}()
 	return io.ReadAll(r.HttpResponse.Body)
 }
 

session.go

@@ -198,6 +198,10 @@ func (s *Session) send(request *Request) (response *Response, err error) {
 					err = fmt.Errorf("timeout")
 				}
 
+				if strings.Contains(err.Error(), "use of closed network connection") {
+					s.Connections.Remove(request.parsedUrl)
+				}
+
 				s.dumpRequest(request, response, err)
 				s.logResponse(response, err)
 
@@ -344,7 +348,6 @@ func (s *Session) do(req *Request, args ...any) (resp *Response, err error) {
 						}
 					}
 				}
-
 			}
 
 			err = s.checkRedirect(req, reqs)

structs.go

@@ -211,6 +211,8 @@ type Response struct {
 	Request *Request
 	// Length of content in the response.
 	ContentLength int64
+
+	Session *Session
 }
 
 // Context represents the context of a request. It holds the session, request,

test/connection_proxy_test.go

@@ -5,7 +5,6 @@ import (
 	"github.com/Noooste/azuretls-client"
 	"os"
 	"testing"
-	"time"
 )
 
 var skipProxy bool
@@ -46,8 +45,6 @@ func TestProxyDialer(t *testing.T) {
 }
 
 func TestProxy(t *testing.T) {
-	t.SkipNow()
-
 	session := azuretls.NewSession()
 
 	if err := session.SetProxy(""); err == nil {
@@ -99,28 +96,8 @@ func TestProxy(t *testing.T) {
 	}
 }
 
-func TestProxy2(t *testing.T) {
-	t.SkipNow()
-
-	session := azuretls.NewSession()
-
-	session.H2Proxy = true
-	if err := session.SetProxy(os.Getenv("NON_SECURE_PROXY")); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := session.Get("https://tls.peet.ws/api/all")
-
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
 func TestProxy3(t *testing.T) {
-	t.SkipNow()
-
 	session := azuretls.NewSession()
-	session.H2Proxy = true
 
 	if err := session.SetProxy(os.Getenv("SECURE_PROXY")); err != nil {
 		t.Fatal(err)
@@ -201,21 +178,3 @@ func TestProxy4(t *testing.T) {
 		t.Fatal("TestProxy failed, IP is not changed")
 	}
 }
-
-func TestBadProxy(t *testing.T) {
-	session := azuretls.NewSession()
-	defer session.Close()
-
-	session.SetTimeout(1 * time.Second)
-
-	if err := session.SetProxy("https://test.com"); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := session.Get("https://ipinfo.io/ip")
-
-	if err == nil || err.Error() != "proxy connection timeout" {
-		t.Fatal("TestBadProxy failed, expected error, got", err)
-	}
-
-}

test/connection_test.go

@@ -84,14 +84,10 @@ func concurrency(session *azuretls.Session, wg *sync.WaitGroup, ok *int64) bool
 	defer wg.Done()
 
 	for i := 0; i < 10; i++ {
-		_, err2 := session.Get("https://example.com/")
-
-		if err2 != nil {
-			fmt.Println(err2)
-			return false
-		}
-
-		_, err2 = session.Get("http://example.com/")
+		_, err2 := session.Do(&azuretls.Request{
+			Method: "GET",
+			Url:    "http://example.com/",
+		})
 
 		if err2 != nil {
 			fmt.Println(err2)
@@ -125,6 +121,6 @@ func TestHighConcurrency(t *testing.T) {
 	wait.Wait()
 
 	if atomic.LoadInt64(ok) < count-1 { //~1 request can fail
-		t.Fatal("TestHighConcurrency failed, expected: ", count, ", got: ", *ok)
+		t.Fatal("TestHighConcurrency failed, expected: ", count, ", got: ", ok)
 	}
 }

transport.go

@@ -1,9 +1,12 @@
 package azuretls
 
 import (
+	"context"
 	http "github.com/Noooste/fhttp"
 	"github.com/Noooste/fhttp/http2"
+	"net"
 	"net/url"
+	"time"
 )
 
 func (s *Session) initTransport(browser string) (err error) {
@@ -27,12 +30,23 @@ func (s *Session) initHTTP1() {
 	s.Transport = &http.Transport{
 		TLSHandshakeTimeout:   s.TimeOut,
 		ResponseHeaderTimeout: s.TimeOut,
-		Proxy: func(req *http.Request) (*url.URL, error) {
-			if s.ProxyDialer == nil {
+		DialTLSContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+			s.Connections.mu.RLock()
+			defer s.Connections.mu.RUnlock()
+			rc := s.Connections.hosts[addr]
+			return rc.TLS, nil
+		},
+		Proxy: func(*http.Request) (*url.URL, error) {
+			if s.Proxy == "" {
 				return nil, nil
 			}
-			return s.ProxyDialer.ProxyURL, nil
+
+			return url.Parse(s.Proxy)
 		},
+		ForceAttemptHTTP2:     true,
+		MaxIdleConns:          100,
+		IdleConnTimeout:       90 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
 	}
 }