Add connect timeout and cookie jar support to HTTP client

Author: hmert

README.md

@@ -44,7 +44,7 @@ gURL is a modern HTTP client tool with support for HTTP/1.0, HTTP/1.1, HTTP/2, a
 | `--proxy-negotiate` | | Use HTTP Negotiate authentication on the proxy | ✅ |
 | **Cookie Management** |
 | `--cookie <data\|filename>` | `-b` | Send cookies from string/file | ✅ |
-| `--cookie-jar <filename>` | `-c` | Write cookies to filename after operation | ❌ |
+| `--cookie-jar <filename>` | `-c` | Write cookies to filename after operation | ✅ |
 | **Output Control** |
 | `--output <file>` | `-o` | Write to file instead of stdout | ✅ |
 | `--verbose` | `-v` | Make the operation more talkative | ✅ |
@@ -55,7 +55,7 @@ gURL is a modern HTTP client tool with support for HTTP/1.0, HTTP/1.1, HTTP/2, a
 | `--max-time <seconds>` | `-m` | Maximum time allowed for the transfer | ✅ |
 | `--max-redirs <num>` | | Maximum number of redirects allowed | ✅ |
 | `--location` | `-L` | Follow redirects | ✅ |
-| `--connect-timeout <seconds>` | | Maximum time allowed for connection | ❌ |
+| `--connect-timeout <seconds>` | | Maximum time allowed for connection | ✅ |
 | **SSL/TLS Options** |
 | `--cacert <file>` | | CA certificate to verify peer against | ❌ |
 | `--capath <dir>` | | CA directory to verify peer against | ❌ |

cmd/requests.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"fmt"
 	"io"
+	"net/url"
 	"os"
 	"strings"
 	"time"
@@ -22,6 +23,8 @@ var (
 	followRedirects bool
 	maxRedirects    int
 	timeout         int
+	connectTimeout  int
+	cookieJar       string
 	userAgent       string
 	referer         string
 	insecure        bool
@@ -127,6 +130,11 @@ func executeRequest(httpMethod, url string) {
 		c.SetTimeout(time.Duration(timeout) * time.Second)
 	}
 
+	// Apply connect timeout if specified
+	if connectTimeout > 0 {
+		c.SetConnectTimeout(time.Duration(connectTimeout) * time.Second)
+	}
+
 	// Set HTTP version
 	if http10 {
 		c.SetHTTPVersion("1.0")
@@ -256,10 +264,10 @@ func executeRequest(httpMethod, url string) {
 		os.Exit(1)
 	}
 
-	handleResponse(response, httpMethod)
+	handleResponse(response, httpMethod, url)
 }
 
-func handleResponse(response *src.Response, httpMethod string) {
+func handleResponse(response *src.Response, httpMethod string, requestURL string) {
 	var output io.Writer = os.Stdout
 
 	// Handle output file
@@ -304,4 +312,48 @@ func handleResponse(response *src.Response, httpMethod string) {
 	if verbose && !silent && outputFile == "" {
 		fmt.Fprintf(os.Stderr, "HTTP Status: %d\n", response.StatusCode)
 	}
+
+	// Write cookies to cookie jar file if specified
+	if cookieJar != "" {
+		saveCookiesToFile(response, cookieJar, requestURL)
+	}
+}
+
+// saveCookiesToFile writes response cookies to the specified file
+func saveCookiesToFile(response *src.Response, filename, requestURL string) {
+	if len(response.Cookie.Mapper) == 0 {
+		return // No cookies to save
+	}
+
+	file, err := os.Create(filename)
+	if err != nil {
+		if !silent {
+			fmt.Fprintf(os.Stderr, "Error creating cookie jar file: %v\n", err)
+		}
+		return
+	}
+	defer file.Close()
+
+	// Extract domain from URL
+	parsedURL, err := url.Parse(requestURL)
+	domain := ".example.com" // fallback
+	if err == nil && parsedURL.Host != "" {
+		domain = parsedURL.Host
+		// Add leading dot for domain cookies
+		if !strings.HasPrefix(domain, ".") {
+			domain = "." + domain
+		}
+	}
+
+	// Write Netscape cookie file format header
+	fmt.Fprintln(file, "# Netscape HTTP Cookie File")
+	fmt.Fprintln(file, "# This is a generated file! Do not edit.")
+	fmt.Fprintln(file, "")
+
+	// Write cookies in Netscape format:
+	// domain	flag	path	secure	expiration	name	value
+	for name, value := range response.Cookie.Mapper {
+		// Use Netscape format: domain, flag, path, secure, expiration, name, value
+		fmt.Fprintf(file, "%s\tTRUE\t/\tFALSE\t0\t%s\t%s\n", domain, name, value)
+	}
 }

cmd/root.go

@@ -122,6 +122,7 @@ func Execute() {
 
 	// Cookie flags
 	rootCmd.PersistentFlags().StringSliceVarP(&cookies, "cookie", "b", []string{}, "Pass the data to the HTTP server in the Cookie header")
+	rootCmd.PersistentFlags().StringVarP(&cookieJar, "cookie-jar", "c", "", "Write cookies to filename after operation")
 
 	// HTTP request flags
 	rootCmd.PersistentFlags().StringSliceVarP(&headers, "header", "H", []string{}, "Pass custom header(s) to server")
@@ -133,6 +134,7 @@ func Execute() {
 	rootCmd.PersistentFlags().BoolVarP(&followRedirects, "location", "L", false, "Follow redirects")
 	rootCmd.PersistentFlags().IntVarP(&maxRedirects, "max-redirs", "", 50, "Maximum number of redirects allowed")
 	rootCmd.PersistentFlags().IntVarP(&timeout, "max-time", "m", 0, "Maximum time allowed for the transfer")
+	rootCmd.PersistentFlags().IntVar(&connectTimeout, "connect-timeout", 0, "Maximum time allowed for connection")
 	rootCmd.PersistentFlags().StringVarP(&userAgent, "user-agent", "A", "", "Send User-Agent <name> to server")
 	rootCmd.PersistentFlags().StringVarP(&referer, "referer", "e", "", "Referrer URL")
 	rootCmd.PersistentFlags().BoolVarP(&insecure, "insecure", "k", false, "Allow insecure server connections when using SSL")

src/client.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"io"
 	"mime/multipart"
+	"net"
 	"net/http"
 	"net/url"
 	"os"
@@ -41,12 +42,13 @@ var (
 )
 
 type Client struct {
-	proxy       string // set to all requests
-	timeout     time.Duration
-	crt         *tls.Certificate
-	opts        *requestOptions
-	httpVersion string // "1.0", "1.1", "2", "3"
-	insecure    bool   // allow insecure SSL
+	proxy          string // set to all requests
+	timeout        time.Duration
+	connectTimeout time.Duration // connection timeout separate from request timeout
+	crt            *tls.Certificate
+	opts           *requestOptions
+	httpVersion    string // "1.0", "1.1", "2", "3"
+	insecure       bool   // allow insecure SSL
 	// Authentication fields
 	authType string // "basic", "digest", "ntlm", "negotiate"
 	username string
@@ -85,6 +87,11 @@ func (c *Client) SetTimeout(duration time.Duration) *Client {
 	return c
 }
 
+func (c *Client) SetConnectTimeout(duration time.Duration) *Client {
+	c.connectTimeout = duration
+	return c
+}
+
 func (c *Client) SetHTTPVersion(version string) *Client {
 	c.httpVersion = version
 	return c
@@ -464,6 +471,28 @@ func (c *Client) callFastHTTP(url, method string, headers requestHeaders, body [
 	client := &fasthttp.Client{
 		ReadTimeout: c.timeout,
 	}
+
+	// Set connect timeout if specified
+	if c.connectTimeout > 0 {
+		client.WriteTimeout = c.connectTimeout
+		client.ReadTimeout = c.timeout
+		// Create a custom dialer with connect timeout
+		if c.proxy != "" {
+			// Use proxy dialer with connect timeout
+			client.Dial = func(addr string) (net.Conn, error) {
+				proxyDialer := fasthttpproxy.FasthttpHTTPDialer(c.proxy)
+				return proxyDialer(addr)
+			}
+		} else {
+			// Use direct dialer with connect timeout
+			client.Dial = func(addr string) (net.Conn, error) {
+				return net.DialTimeout("tcp", addr, c.connectTimeout)
+			}
+		}
+	} else if c.proxy != "" {
+		client.Dial = fasthttpproxy.FasthttpHTTPDialer(c.proxy)
+	}
+
 	if c.crt != nil {
 		client.TLSConfig = &tls.Config{
 			InsecureSkipVerify: c.insecure,
@@ -474,9 +503,6 @@ func (c *Client) callFastHTTP(url, method string, headers requestHeaders, body [
 			InsecureSkipVerify: true,
 		}
 	}
-	if c.proxy != "" {
-		client.Dial = fasthttpproxy.FasthttpHTTPDialer(c.proxy)
-	}
 
 	if err := client.Do(req, resp); err != nil {
 		return nil, err
@@ -490,13 +516,28 @@ func (c *Client) callFastHTTP(url, method string, headers requestHeaders, body [
 	}
 	resp.Header.VisitAll(func(key, value []byte) {
 		ret.Header.Set(string(key), string(value))
-	})
-	resp.Header.VisitAllCookie(func(key, value []byte) {
-		ret.Cookie.Set(string(key), string(value))
+		// Parse Set-Cookie headers manually
+		if strings.ToLower(string(key)) == "set-cookie" {
+			parseCookieFromSetCookie(string(value), ret.Cookie)
+		}
 	})
 	return ret, nil
 }
 
+// parseCookieFromSetCookie parses a Set-Cookie header value and extracts the cookie name and value
+func parseCookieFromSetCookie(setCookieValue string, cookies RequestCookies) {
+	// Simple parsing: extract name=value from "name=value; Path=/; ..."
+	parts := strings.Split(setCookieValue, ";")
+	if len(parts) > 0 {
+		nameValue := strings.TrimSpace(parts[0])
+		if idx := strings.Index(nameValue, "="); idx > 0 {
+			name := strings.TrimSpace(nameValue[:idx])
+			value := strings.TrimSpace(nameValue[idx+1:])
+			cookies.Set(name, value)
+		}
+	}
+}
+
 func (c *Client) callHTTP2OrHTTP3(url, method string, headers requestHeaders, body []byte) (*Response, error) {
 	var client *http.Client
 
@@ -523,6 +564,16 @@ func (c *Client) callHTTP2OrHTTP3(url, method string, headers requestHeaders, bo
 			TLSClientConfig: tlsConfig,
 		}
 
+		// Set dial timeout if connectTimeout is specified
+		if c.connectTimeout > 0 {
+			transport.DialTLS = func(network, addr string, cfg *tls.Config) (net.Conn, error) {
+				dialer := &net.Dialer{
+					Timeout: c.connectTimeout,
+				}
+				return tls.DialWithDialer(dialer, network, addr, cfg)
+			}
+		}
+
 		client = &http.Client{
 			Transport: transport,
 			Timeout:   c.timeout,