proxy.go

// Package proxy fetches free HTTP, SOCKS4, and SOCKS5 proxy lists
// from the ProxyScrape API with automatic gzip decompression.
package proxy

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"

	"github.com/klauspost/compress/gzhttp"
)

// Proxy describes a single proxy server with its connection details and health metrics.
type Proxy struct {
	Host       string  `json:"host"`
	Port       int     `json:"port"`
	Country    string  `json:"country"`
	Timeout    float64 `json:"timeout"`
	LastSeen   float64 `json:"last_seen"`
	Uptime     float64 `json:"uptime"`
	AliveSince float64 `json:"alive_since"`
}

// Address returns the host:port string for this proxy.
func (p *Proxy) Address() string {
	return fmt.Sprintf("%s:%d", p.Host, p.Port)
}

type entry map[string]*Proxy

// Proxies holds proxy lists grouped by protocol type.
type Proxies struct {
	HTTP   entry `json:"http"`
	SOCKS4 entry `json:"socks4"`
	SOCKS5 entry `json:"socks5"`
}

// Len returns the total number of proxies across all protocols.
func (receiver *Proxies) Len() int {
	return len(receiver.HTTP) + len(receiver.SOCKS4) + len(receiver.SOCKS5)
}

// List returns all HTTP proxies as a flat slice with host and port populated.
func (receiver *Proxies) List() (l []*Proxy, err error) {
	for k, v := range receiver.HTTP {
		a := strings.Split(k, ":")
		v.Port, err = strconv.Atoi(a[1])
		if err != nil {
			return
		}
		v.Host = a[0]
		l = append(l, v)
	}
	return
}

// Fetch retrieves the current proxy list from the ProxyScrape API.
func Fetch() (l *Proxies, err error) {
	client := &http.Client{
		Transport: gzhttp.Transport(http.DefaultTransport),
	}
	req, err := http.NewRequest("GET", "https://api.proxyscrape.com/proxytable.php?nf=true&country=all", nil)
	if err != nil {
		return nil, fmt.Errorf("proxy: failed to create request: %w", err)
	}
	req.Header.Set("accept", "*/*")
	req.Header.Set("origin", "https://www.proxyscrape.com")
	req.Header.Set("referer", "https://www.proxyscrape.com/")
	req.Header.Set("user-agent", "Mozilla/5.0 (compatible; go-proxy/1.0)")

	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("proxy: request failed: %w", err)
	}
	defer resp.Body.Close()

	if err = json.NewDecoder(resp.Body).Decode(&l); err != nil {
		return nil, fmt.Errorf("proxy: failed to decode response: %w", err)
	}

	return
}

// List is a convenience function that fetches and returns all HTTP proxies.
// Deprecated: Use Fetch() and Proxies.List() for more control.
func List() (l *Proxies, err error) {
	return Fetch()
}