Xray-core/transport/internet/http/dialer.go

237 lines
6.4 KiB
Go
Raw Normal View History

2020-11-25 11:01:53 +00:00
package http
import (
"context"
gotls "crypto/tls"
"io"
2020-11-25 11:01:53 +00:00
"net/http"
"net/url"
"sync"
2021-07-03 08:01:59 +00:00
"time"
2020-11-25 11:01:53 +00:00
2020-12-04 01:36:16 +00:00
"github.com/xtls/xray-core/common"
"github.com/xtls/xray-core/common/buf"
"github.com/xtls/xray-core/common/net"
"github.com/xtls/xray-core/common/net/cnc"
"github.com/xtls/xray-core/common/session"
2020-12-04 01:36:16 +00:00
"github.com/xtls/xray-core/transport/internet"
"github.com/xtls/xray-core/transport/internet/reality"
"github.com/xtls/xray-core/transport/internet/stat"
2020-12-04 01:36:16 +00:00
"github.com/xtls/xray-core/transport/internet/tls"
"github.com/xtls/xray-core/transport/pipe"
2022-05-18 07:29:01 +00:00
"golang.org/x/net/http2"
2020-11-25 11:01:53 +00:00
)
type dialerConf struct {
net.Destination
2021-07-03 08:01:59 +00:00
*internet.MemoryStreamConfig
}
2020-11-25 11:01:53 +00:00
var (
globalDialerMap map[dialerConf]*http.Client
2020-11-25 11:01:53 +00:00
globalDialerAccess sync.Mutex
)
2021-07-03 08:01:59 +00:00
func getHTTPClient(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (*http.Client, error) {
2020-11-25 11:01:53 +00:00
globalDialerAccess.Lock()
defer globalDialerAccess.Unlock()
if globalDialerMap == nil {
globalDialerMap = make(map[dialerConf]*http.Client)
2020-11-25 11:01:53 +00:00
}
2021-07-03 08:01:59 +00:00
httpSettings := streamSettings.ProtocolSettings.(*Config)
2022-10-13 12:04:00 +00:00
tlsConfigs := tls.ConfigFromStreamSettings(streamSettings)
realityConfigs := reality.ConfigFromStreamSettings(streamSettings)
if tlsConfigs == nil && realityConfigs == nil {
return nil, newError("TLS or REALITY must be enabled for http transport.").AtWarning()
2021-07-03 08:01:59 +00:00
}
sockopt := streamSettings.SocketSettings
if client, found := globalDialerMap[dialerConf{dest, streamSettings}]; found {
2020-11-25 11:01:53 +00:00
return client, nil
}
transport := &http2.Transport{
DialTLS: func(network string, addr string, tlsConfig *gotls.Config) (net.Conn, error) {
rawHost, rawPort, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
if len(rawPort) == 0 {
rawPort = "443"
}
port, err := net.PortFromString(rawPort)
if err != nil {
return nil, err
}
address := net.ParseAddress(rawHost)
dctx := context.Background()
dctx = session.ContextWithID(dctx, session.IDFromContext(ctx))
dctx = session.ContextWithOutbound(dctx, session.OutboundFromContext(ctx))
pconn, err := internet.DialSystem(dctx, net.TCPDestination(address, port), sockopt)
2020-11-25 11:01:53 +00:00
if err != nil {
newError("failed to dial to " + addr).Base(err).AtError().WriteToLog()
2020-11-25 11:01:53 +00:00
return nil, err
}
if realityConfigs != nil {
return reality.UClient(pconn, realityConfigs, ctx, dest)
}
2022-10-13 12:04:00 +00:00
var cn tls.Interface
if fingerprint := tls.GetFingerprint(tlsConfigs.Fingerprint); fingerprint != nil {
2022-10-13 12:04:00 +00:00
cn = tls.UClient(pconn, tlsConfig, fingerprint).(*tls.UConn)
} else {
cn = tls.Client(pconn, tlsConfig).(*tls.Conn)
}
2020-11-25 11:01:53 +00:00
if err := cn.Handshake(); err != nil {
newError("failed to dial to " + addr).Base(err).AtError().WriteToLog()
2020-11-25 11:01:53 +00:00
return nil, err
}
if !tlsConfig.InsecureSkipVerify {
if err := cn.VerifyHostname(tlsConfig.ServerName); err != nil {
newError("failed to dial to " + addr).Base(err).AtError().WriteToLog()
2020-11-25 11:01:53 +00:00
return nil, err
}
}
2022-10-13 12:04:00 +00:00
negotiatedProtocol, negotiatedProtocolIsMutual := cn.NegotiatedProtocol()
if negotiatedProtocol != http2.NextProtoTLS {
return nil, newError("http2: unexpected ALPN protocol " + negotiatedProtocol + "; want q" + http2.NextProtoTLS).AtError()
2020-11-25 11:01:53 +00:00
}
2022-10-13 12:04:00 +00:00
if !negotiatedProtocolIsMutual {
2020-11-25 11:01:53 +00:00
return nil, newError("http2: could not negotiate protocol mutually").AtError()
}
return cn, nil
},
}
if tlsConfigs != nil {
transport.TLSClientConfig = tlsConfigs.GetTLSConfig(tls.WithDestination(dest))
2021-07-03 08:01:59 +00:00
}
if httpSettings.IdleTimeout > 0 || httpSettings.HealthCheckTimeout > 0 {
transport.ReadIdleTimeout = time.Second * time.Duration(httpSettings.IdleTimeout)
transport.PingTimeout = time.Second * time.Duration(httpSettings.HealthCheckTimeout)
2020-11-25 11:01:53 +00:00
}
client := &http.Client{
Transport: transport,
}
2021-07-03 08:01:59 +00:00
globalDialerMap[dialerConf{dest, streamSettings}] = client
2020-11-25 11:01:53 +00:00
return client, nil
}
// Dial dials a new TCP connection to the given destination.
func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (stat.Connection, error) {
2020-11-25 11:01:53 +00:00
httpSettings := streamSettings.ProtocolSettings.(*Config)
2021-07-03 08:01:59 +00:00
client, err := getHTTPClient(ctx, dest, streamSettings)
2020-11-25 11:01:53 +00:00
if err != nil {
return nil, err
}
opts := pipe.OptionsFromContext(ctx)
preader, pwriter := pipe.New(opts...)
breader := &buf.BufferedReader{Reader: preader}
httpMethod := "PUT"
if httpSettings.Method != "" {
httpMethod = httpSettings.Method
}
httpHeaders := make(http.Header)
for _, httpHeader := range httpSettings.Header {
for _, httpHeaderValue := range httpHeader.Value {
httpHeaders.Set(httpHeader.Name, httpHeaderValue)
}
}
2020-11-25 11:01:53 +00:00
request := &http.Request{
Method: httpMethod,
2020-11-25 11:01:53 +00:00
Host: httpSettings.getRandomHost(),
Body: breader,
URL: &url.URL{
Scheme: "https",
Host: dest.NetAddr(),
Path: httpSettings.getNormalizedPath(),
},
Proto: "HTTP/2",
ProtoMajor: 2,
ProtoMinor: 0,
Header: httpHeaders,
2020-11-25 11:01:53 +00:00
}
// Disable any compression method from server.
request.Header.Set("Accept-Encoding", "identity")
wrc := &WaitReadCloser{Wait: make(chan struct{})}
go func() {
response, err := client.Do(request)
if err != nil {
newError("failed to dial to ", dest).Base(err).AtWarning().WriteToLog(session.ExportIDToError(ctx))
wrc.Close()
return
}
if response.StatusCode != 200 {
newError("unexpected status", response.StatusCode).AtWarning().WriteToLog(session.ExportIDToError(ctx))
wrc.Close()
return
}
wrc.Set(response.Body)
}()
2020-11-25 11:01:53 +00:00
bwriter := buf.NewBufferedWriter(pwriter)
common.Must(bwriter.SetBuffered(false))
return cnc.NewConnection(
cnc.ConnectionOutput(wrc),
cnc.ConnectionInput(bwriter),
cnc.ConnectionOnClose(common.ChainedClosable{breader, bwriter, wrc}),
2020-11-25 11:01:53 +00:00
), nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, Dial))
}
type WaitReadCloser struct {
Wait chan struct{}
io.ReadCloser
}
func (w *WaitReadCloser) Set(rc io.ReadCloser) {
w.ReadCloser = rc
defer func() {
if err := recover(); err != nil {
rc.Close()
}
}()
close(w.Wait)
}
func (w *WaitReadCloser) Read(b []byte) (int, error) {
if w.ReadCloser == nil {
if <-w.Wait; w.ReadCloser == nil {
return 0, io.ErrClosedPipe
}
}
return w.ReadCloser.Read(b)
}
func (w *WaitReadCloser) Close() error {
if w.ReadCloser != nil {
return w.ReadCloser.Close()
}
defer func() {
if err := recover(); err != nil {
if w.ReadCloser != nil {
w.ReadCloser.Close()
}
}
}()
close(w.Wait)
return nil
}