mirror of
https://github.com/SagerNet/sing-box.git
synced 2026-11-16 21:17:41 +00:00
When ECH is enabled without a static config, the HTTPS record query for the ECH config list went through the DNS rules instead of the domain resolver, and the migration of outbound DNS rule items to the domain resolver left no way to select a DNS server for it. A rule rejecting HTTPS records refused the query, and a default DNS server detoured through the same outbound waited for its own connection until the query timed out. Send the query to the domain resolver of the dial fields, then the default domain resolver, then the only DNS server, and fail it when none of them is available. DNS servers must set their own domain resolver for it, as they do for a domain server address.
135 lines
4 KiB
Go
135 lines
4 KiB
Go
package httpclient
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/sagernet/sing-box/common/dialer"
|
|
"github.com/sagernet/sing-box/common/tls"
|
|
C "github.com/sagernet/sing-box/constant"
|
|
"github.com/sagernet/sing-box/option"
|
|
"github.com/sagernet/sing/common"
|
|
E "github.com/sagernet/sing/common/exceptions"
|
|
"github.com/sagernet/sing/common/logger"
|
|
N "github.com/sagernet/sing/common/network"
|
|
)
|
|
|
|
func NewTransport(ctx context.Context, logger logger.ContextLogger, tag string, options option.HTTPClientOptions) (*ManagedTransport, error) {
|
|
rawDialer, err := dialer.NewWithOptions(dialer.Options{
|
|
Context: ctx,
|
|
Options: options.DialerOptions,
|
|
RemoteIsDomain: true,
|
|
DirectResolver: options.DirectResolver,
|
|
ResolverOnDetour: options.ResolveOnDetour,
|
|
NewDialer: options.ResolveOnDetour,
|
|
DisableEmptyDirectCheck: options.DisableEmptyDirectCheck,
|
|
DefaultOutbound: options.DefaultOutbound,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
headers := options.Headers.Build()
|
|
host := headers.Get("Host")
|
|
headers.Del("Host")
|
|
|
|
var cheapRebuild bool
|
|
switch options.Engine {
|
|
case C.TLSEngineApple:
|
|
err = validateAppleTransport(ctx, options)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ManagedTransport{
|
|
dialer: rawDialer,
|
|
headers: headers,
|
|
host: host,
|
|
tag: tag,
|
|
detour: options.Detour,
|
|
defaultOutbound: options.DefaultOutbound,
|
|
factory: func() (innerTransport, error) {
|
|
return newAppleTransport(ctx, logger, rawDialer, options)
|
|
},
|
|
}, nil
|
|
case "", C.TLSEngineGo:
|
|
cheapRebuild = true
|
|
default:
|
|
return nil, E.New("unknown HTTP engine: ", options.Engine)
|
|
}
|
|
tlsOptions := common.PtrValueOrDefault(options.TLS)
|
|
tlsOptions.Enabled = true
|
|
baseTLSConfig, err := tls.NewClientWithOptions(tls.ClientOptions{
|
|
Context: ctx,
|
|
Logger: logger,
|
|
Options: tlsOptions,
|
|
AllowEmptyServerName: true,
|
|
DomainResolver: options.DomainResolver,
|
|
DirectResolver: options.DirectResolver,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
inner, err := newTransport(rawDialer, baseTLSConfig, options)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
managedTransport := &ManagedTransport{
|
|
cheapRebuild: cheapRebuild,
|
|
dialer: rawDialer,
|
|
headers: headers,
|
|
host: host,
|
|
tag: tag,
|
|
detour: options.Detour,
|
|
defaultOutbound: options.DefaultOutbound,
|
|
factory: func() (innerTransport, error) {
|
|
return newTransport(rawDialer, baseTLSConfig, options)
|
|
},
|
|
}
|
|
managedTransport.epoch.Store(&transportEpoch{transport: inner})
|
|
return managedTransport, nil
|
|
}
|
|
|
|
func newTransport(rawDialer N.Dialer, baseTLSConfig tls.Config, options option.HTTPClientOptions) (innerTransport, error) {
|
|
version := options.Version
|
|
if version == 0 {
|
|
version = 2
|
|
}
|
|
fallbackDelay := time.Duration(options.DialerOptions.FallbackDelay)
|
|
if fallbackDelay == 0 {
|
|
fallbackDelay = 300 * time.Millisecond
|
|
}
|
|
var transport innerTransport
|
|
var err error
|
|
switch version {
|
|
case 1:
|
|
transport = newHTTP1Transport(rawDialer, baseTLSConfig)
|
|
case 2:
|
|
if options.DisableVersionFallback {
|
|
transport, err = newHTTP2Transport(rawDialer, baseTLSConfig, options.HTTP2Options)
|
|
} else {
|
|
transport, err = newHTTP2FallbackTransport(rawDialer, baseTLSConfig, options.HTTP2Options)
|
|
}
|
|
case 3:
|
|
if baseTLSConfig != nil {
|
|
_, err = baseTLSConfig.STDConfig()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if options.DisableVersionFallback {
|
|
transport, err = newHTTP3Transport(rawDialer, baseTLSConfig, options.HTTP3Options)
|
|
} else {
|
|
var h2Fallback innerTransport
|
|
h2Fallback, err = newHTTP2FallbackTransport(rawDialer, baseTLSConfig, options.HTTP2Options)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
transport, err = newHTTP3FallbackTransport(rawDialer, baseTLSConfig, h2Fallback, options.HTTP3Options, fallbackDelay)
|
|
}
|
|
default:
|
|
return nil, E.New("unknown HTTP version: ", version)
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return transport, nil
|
|
}
|