requests/client.go

package requests

import (
	"context"
	"net"
	"net/url"
	"time"

	"net/http"

	"github.com/gospider007/gtls"
	"github.com/gospider007/ja3"
)

type ClientOption struct {
	ForceHttp1            bool                                                       //force  use http1 send requests
	OrderHeaders          []string                                                   //order headers with http1
	Ja3                   bool                                                       //enable ja3 fingerprint
	Ja3Spec               ja3.Ja3Spec                                                //custom ja3Spec,use ja3.CreateSpecWithStr or ja3.CreateSpecWithId create
	H2Ja3Spec             ja3.H2Ja3Spec                                              //h2 fingerprint
	Proxy                 string                                                     //proxy,support https,http,socks5
	DisCookie             bool                                                       //disable cookies
	DisDecode             bool                                                       //disable auto decode
	DisUnZip              bool                                                       //disable auto zip decode
	DisAlive              bool                                                       //disable  keepalive
	Bar                   bool                                                       ////enable bar display
	Timeout               time.Duration                                              //request timeout
	OptionCallBack        func(context.Context, *Client, *RequestOption) error       //option callback,if error is returnd, break request
	ResultCallBack        func(context.Context, *Client, *Response) error            //result callback,if error is returnd,next errCallback
	ErrCallBack           func(context.Context, *Client, error) error                //error callback,if error is returnd,break request
	RequestCallBack       func(context.Context, *http.Request, *http.Response) error //request and response callback,if error is returnd,reponse is error
	TryNum                int                                                        //try num
	RedirectNum           int                                                        //redirect num ,<0 no redirect,==0 no limit
	Headers               any                                                        //default headers
	ResponseHeaderTimeout time.Duration                                              //ResponseHeaderTimeout ,default:30

	GetProxy            func(ctx context.Context, url *url.URL) (string, error) //proxy callback:support https,http,socks5 proxy
	LocalAddr           *net.TCPAddr                                            //network card ip
	DialTimeout         time.Duration                                           //dial tcp timeout,default:15
	TlsHandshakeTimeout time.Duration                                           //tls timeout,default:15
	KeepAlive           time.Duration                                           //keepalive,default:30
	AddrType            AddrType                                                //dns parse addr type
	GetAddrType         func(string) AddrType
	Dns                 net.IP //dns
}
type Client struct {
	forceHttp1   bool
	orderHeaders []string

	jar         *Jar
	redirectNum int
	disDecode   bool
	disUnZip    bool
	disAlive    bool

	tryNum int

	requestCallBack func(context.Context, *http.Request, *http.Response) error

	optionCallBack func(context.Context, *Client, *RequestOption) error
	resultCallBack func(context.Context, *Client, *Response) error
	errCallBack    func(context.Context, *Client, error) error

	timeout               time.Duration
	responseHeaderTimeout time.Duration

	headers any
	bar     bool

	disCookie bool
	client    *http.Client
	proxy     *url.URL

	ctx       context.Context
	cnl       context.CancelFunc
	transport *RoundTripper

	ja3Spec   ja3.Ja3Spec
	h2Ja3Spec ja3.H2Ja3Spec
}

func NewClient(preCtx context.Context, options ...ClientOption) (*Client, error) {
	if preCtx == nil {
		preCtx = context.TODO()
	}
	ctx, cnl := context.WithCancel(preCtx)
	var option ClientOption

	if len(options) > 0 {
		option = options[0]
	}
	if option.KeepAlive == 0 {
		option.KeepAlive = time.Second * 30
	}
	if option.DialTimeout == 0 {
		option.DialTimeout = time.Second * 15
	}
	if option.TlsHandshakeTimeout == 0 {
		option.TlsHandshakeTimeout = time.Second * 15
	}
	//cookiesjar
	var jar *Jar
	if !option.DisCookie {
		jar = NewJar()
	}
	// var http3Transport *http3.RoundTripper
	// if option.Http3 {
	// 	http3Transport = &http3.RoundTripper{
	// 		TLSClientConfig: tlsConfig,
	// 		QuicConfig: &quic.Config{
	// 			EnableDatagrams:      true,
	// 			HandshakeIdleTimeout: option.TLSHandshakeTimeout,
	// 			MaxIdleTimeout:       option.IdleConnTimeout,
	// 			KeepAlivePeriod:      option.KeepAlive,
	// 		},
	// 		EnableDatagrams: true,
	// 	}
	// }
	transport := newRoundTripper(ctx, RoundTripperOption{
		TlsHandshakeTimeout: option.TlsHandshakeTimeout,
		DialTimeout:         option.DialTimeout,
		KeepAlive:           option.KeepAlive,

		LocalAddr:   option.LocalAddr,
		AddrType:    option.AddrType,
		GetAddrType: option.GetAddrType,
		Dns:         option.Dns,
		GetProxy:    option.GetProxy,
	})
	client := &http.Client{
		Transport: transport,
		CheckRedirect: func(req *http.Request, via []*http.Request) error {
			ctxData := req.Context().Value(keyPrincipalID).(*reqCtxData)
			if ctxData.redirectNum == 0 || ctxData.redirectNum >= len(via) {
				return nil
			}
			return http.ErrUseLastResponse
		},
	}
	if jar != nil {
		client.Jar = jar.jar
	}
	result := &Client{
		jar:                   jar,
		ctx:                   ctx,
		cnl:                   cnl,
		client:                client,
		transport:             transport,
		forceHttp1:            option.ForceHttp1,
		requestCallBack:       option.RequestCallBack,
		orderHeaders:          option.OrderHeaders,
		disCookie:             option.DisCookie,
		redirectNum:           option.RedirectNum,
		disDecode:             option.DisDecode,
		disUnZip:              option.DisUnZip,
		disAlive:              option.DisAlive,
		tryNum:                option.TryNum,
		optionCallBack:        option.OptionCallBack,
		resultCallBack:        option.ResultCallBack,
		errCallBack:           option.ErrCallBack,
		timeout:               option.Timeout,
		responseHeaderTimeout: option.ResponseHeaderTimeout,
		headers:               option.Headers,
		bar:                   option.Bar,
	}
	var err error
	if option.Proxy != "" {
		result.proxy, err = gtls.VerifyProxy(option.Proxy)
	}

	if option.Ja3Spec.IsSet() {
		result.ja3Spec = option.Ja3Spec
	} else if option.Ja3 {
		result.ja3Spec = ja3.DefaultJa3Spec()
	}
	result.h2Ja3Spec = option.H2Ja3Spec
	return result, err
}
func (obj *Client) HttpClient() *http.Client {
	return obj.client
}
func (obj *Client) SetProxy(proxyUrl string) (err error) {
	obj.proxy, err = gtls.VerifyProxy(proxyUrl)
	return
}
func (obj *Client) SetGetProxy(getProxy func(ctx context.Context, url *url.URL) (string, error)) {
	obj.transport.SetGetProxy(getProxy)
}

func (obj *Client) CloseIdleConnections() {
	obj.transport.CloseIdleConnections()
}
func (obj *Client) CloseConnections() {
	obj.transport.CloseConnections()
}

func (obj *Client) Close() {
	obj.CloseConnections()
	obj.cnl()
}

func (obj *Client) getClient(option *RequestOption) *http.Client {
	if option.DisCookie {
		return &http.Client{
			Transport:     obj.client.Transport,
			CheckRedirect: obj.client.CheckRedirect,
			Timeout:       obj.client.Timeout,
		}
	}
	if option.Jar != nil {
		return &http.Client{
			Transport:     obj.client.Transport,
			CheckRedirect: obj.client.CheckRedirect,
			Timeout:       obj.client.Timeout,
			Jar:           option.Jar.jar,
		}
	}
	return obj.client
}