1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
package fasthttpproxy
import (
"bufio"
"encoding/base64"
"fmt"
"net"
"net/url"
"sync/atomic"
"time"
"github.com/valyala/fasthttp"
"golang.org/x/net/http/httpproxy"
)
const (
httpsScheme = "https"
httpScheme = "http"
tlsPort = "443"
)
// FasthttpProxyHTTPDialer returns a fasthttp.DialFunc that dials using
// the env(HTTP_PROXY, HTTPS_PROXY and NO_PROXY) configured HTTP proxy.
//
// Example usage:
//
// c := &fasthttp.Client{
// Dial: fasthttpproxy.FasthttpProxyHTTPDialer(),
// }
func FasthttpProxyHTTPDialer() fasthttp.DialFunc {
return FasthttpProxyHTTPDialerTimeout(0)
}
// FasthttpProxyHTTPDialerTimeout returns a fasthttp.DialFunc that dials using
// the env(HTTP_PROXY, HTTPS_PROXY and NO_PROXY) configured HTTP proxy using the given timeout.
//
// Example usage:
//
// c := &fasthttp.Client{
// Dial: fasthttpproxy.FasthttpProxyHTTPDialerTimeout(time.Second * 2),
// }
func FasthttpProxyHTTPDialerTimeout(timeout time.Duration) fasthttp.DialFunc {
proxier := httpproxy.FromEnvironment().ProxyFunc()
// encoded auth barrier for http and https proxy.
authHTTPStorage := &atomic.Value{}
authHTTPSStorage := &atomic.Value{}
return func(addr string) (net.Conn, error) {
port, _, err := net.SplitHostPort(addr)
if err != nil {
return nil, fmt.Errorf("unexpected addr format: %w", err)
}
reqURL := &url.URL{Host: addr, Scheme: httpScheme}
if port == tlsPort {
reqURL.Scheme = httpsScheme
}
proxyURL, err := proxier(reqURL)
if err != nil {
return nil, err
}
if proxyURL == nil {
if timeout == 0 {
return fasthttp.Dial(addr)
}
return fasthttp.DialTimeout(addr, timeout)
}
var conn net.Conn
if timeout == 0 {
conn, err = fasthttp.Dial(proxyURL.Host)
} else {
conn, err = fasthttp.DialTimeout(proxyURL.Host, timeout)
}
if err != nil {
return nil, err
}
req := "CONNECT " + addr + " HTTP/1.1\r\n"
if proxyURL.User != nil {
authBarrierStorage := authHTTPStorage
if port == tlsPort {
authBarrierStorage = authHTTPSStorage
}
auth := authBarrierStorage.Load()
if auth == nil {
authBarrier := base64.StdEncoding.EncodeToString([]byte(proxyURL.User.String()))
auth = &authBarrier
authBarrierStorage.Store(auth)
}
req += "Proxy-Authorization: Basic " + *auth.(*string) + "\r\n"
}
req += "\r\n"
if _, err := conn.Write([]byte(req)); err != nil {
return nil, err
}
res := fasthttp.AcquireResponse()
defer fasthttp.ReleaseResponse(res)
res.SkipBody = true
if err := res.Read(bufio.NewReader(conn)); err != nil {
if connErr := conn.Close(); connErr != nil {
return nil, fmt.Errorf("conn close err %v precede by read conn err %w", connErr, err)
}
return nil, err
}
if res.Header.StatusCode() != 200 {
if connErr := conn.Close(); connErr != nil {
return nil, fmt.Errorf(
"conn close err %w precede by connect to proxy: code: %d body %q",
connErr, res.StatusCode(), string(res.Body()))
}
return nil, fmt.Errorf("could not connect to proxy: code: %d body %q", res.StatusCode(), string(res.Body()))
}
return conn, nil
}
}
|
