3c645b4f54
1.allow maybe empty group 2.use COMPATIBLE(DIRECT alias) when proxy group is empty 3.http provider pass through tunnel
118 lines
2.8 KiB
Go
118 lines
2.8 KiB
Go
package outboundgroup
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
"github.com/Dreamacro/clash/adapter/outbound"
|
|
"github.com/Dreamacro/clash/common/singledo"
|
|
"github.com/Dreamacro/clash/component/dialer"
|
|
C "github.com/Dreamacro/clash/constant"
|
|
"github.com/Dreamacro/clash/constant/provider"
|
|
)
|
|
|
|
type Relay struct {
|
|
*outbound.Base
|
|
single *singledo.Single
|
|
providers []provider.ProxyProvider
|
|
filter string
|
|
}
|
|
|
|
// DialContext implements C.ProxyAdapter
|
|
func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
|
|
var proxies []C.Proxy
|
|
for _, proxy := range r.proxies(metadata, true) {
|
|
if proxy.Type() != C.Direct && proxy.Type() != C.Compatible {
|
|
proxies = append(proxies, proxy)
|
|
}
|
|
}
|
|
|
|
switch len(proxies) {
|
|
case 0:
|
|
return outbound.NewDirect().DialContext(ctx, metadata, r.Base.DialOptions(opts...)...)
|
|
case 1:
|
|
return proxies[0].DialContext(ctx, metadata, r.Base.DialOptions(opts...)...)
|
|
}
|
|
|
|
first := proxies[0]
|
|
last := proxies[len(proxies)-1]
|
|
|
|
c, err := dialer.DialContext(ctx, "tcp", first.Addr(), r.Base.DialOptions(opts...)...)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s connect error: %w", first.Addr(), err)
|
|
}
|
|
tcpKeepAlive(c)
|
|
|
|
var currentMeta *C.Metadata
|
|
for _, proxy := range proxies[1:] {
|
|
currentMeta, err = addrToMetadata(proxy.Addr())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c, err = first.StreamConn(c, currentMeta)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s connect error: %w", first.Addr(), err)
|
|
}
|
|
|
|
first = proxy
|
|
}
|
|
|
|
c, err = last.StreamConn(c, metadata)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s connect error: %w", last.Addr(), err)
|
|
}
|
|
|
|
return outbound.NewConn(c, r), nil
|
|
}
|
|
|
|
// MarshalJSON implements C.ProxyAdapter
|
|
func (r *Relay) MarshalJSON() ([]byte, error) {
|
|
all := make([]string, 0)
|
|
|
|
for _, proxy := range r.rawProxies(false) {
|
|
all = append(all, proxy.Name())
|
|
}
|
|
|
|
return json.Marshal(map[string]interface{}{
|
|
"type": r.Type().String(),
|
|
"all": all,
|
|
})
|
|
}
|
|
|
|
func (r *Relay) rawProxies(touch bool) []C.Proxy {
|
|
elm, _, _ := r.single.Do(func() (interface{}, error) {
|
|
return getProvidersProxies(r.providers, touch, r.filter), nil
|
|
})
|
|
|
|
return elm.([]C.Proxy)
|
|
}
|
|
|
|
func (r *Relay) proxies(metadata *C.Metadata, touch bool) []C.Proxy {
|
|
proxies := r.rawProxies(touch)
|
|
|
|
for n, proxy := range proxies {
|
|
subproxy := proxy.Unwrap(metadata)
|
|
for subproxy != nil {
|
|
proxies[n] = subproxy
|
|
subproxy = subproxy.Unwrap(metadata)
|
|
}
|
|
}
|
|
|
|
return proxies
|
|
}
|
|
|
|
func NewRelay(option *GroupCommonOption, providers []provider.ProxyProvider) *Relay {
|
|
return &Relay{
|
|
Base: outbound.NewBase(outbound.BaseOption{
|
|
Name: option.Name,
|
|
Type: C.Relay,
|
|
Interface: option.Interface,
|
|
RoutingMark: option.RoutingMark,
|
|
}),
|
|
single: singledo.NewSingle(defaultGetProxiesDuration),
|
|
providers: providers,
|
|
filter: option.Filter,
|
|
}
|
|
}
|