yanistyle/sing-box-extended
1
0
Fork 0
mirror of https://github.com/shtorm-7/sing-box-extended.git synced 2026-06-21 18:29:13 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add MTProxy, MASQUE, VPN, Link parser. Update AmneziaWG. Remove Tunneling

Browse Source
This commit is contained in:
Sergei Maklagin
2026-04-29 22:11:30 +03:00
parent 09f9f114aa
commit 04908a6a67
158 changed files with 7994 additions and 2277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
protocol/group/urltest.go
View File

@@ -3,6 +3,7 @@ package group
import (
"context"
"net"
"regexp"
"sync"
"sync/atomic"
"time"
@@ -45,6 +46,16 @@ type URLTest struct {
idleTimeout time.Duration
group *URLTestGroup
interruptExternalConnections bool
provider adapter.ProviderManager
providers map[string]adapter.Provider
outboundsCache map[string][]adapter.Outbound
cancel context.CancelFunc
providerTags []string
exclude *regexp.Regexp
include *regexp.Regexp
useAllProviders bool
}
func NewURLTest(ctx context.Context, router adapter.Router, logger log.ContextLogger, tag string, options option.URLTestOutboundOptions) (adapter.Outbound, error) {
@@ -61,14 +72,42 @@ func NewURLTest(ctx context.Context, router adapter.Router, logger log.ContextLo
tolerance: options.Tolerance,
idleTimeout: time.Duration(options.IdleTimeout),
interruptExternalConnections: options.InterruptExistConnections,
}
if len(outbound.tags) == 0 {
return nil, E.New("missing tags")
provider: service.FromContext[adapter.ProviderManager](ctx),
providers: make(map[string]adapter.Provider),
outboundsCache: make(map[string][]adapter.Outbound),
providerTags: options.Providers,
exclude: (*regexp.Regexp)(options.Exclude),
include: (*regexp.Regexp)(options.Include),
useAllProviders: options.UseAllProviders,
}
return outbound, nil
}
func (s *URLTest) Start() error {
if s.useAllProviders {
var providerTags []string
for _, provider := range s.provider.Providers() {
providerTags = append(providerTags, provider.Tag())
s.providers[provider.Tag()] = provider
provider.RegisterCallback(s.onProviderUpdated)
}
s.providerTags = providerTags
} else {
for i, tag := range s.providerTags {
provider, loaded := s.provider.Get(tag)
if !loaded {
return E.New("outbound provider ", i, " not found: ", tag)
}
s.providers[tag] = provider
provider.RegisterCallback(s.onProviderUpdated)
}
}
if len(s.tags)+len(s.providerTags) == 0 {
return E.New("missing outbound and provider tags")
}
outbounds := make([]adapter.Outbound, 0, len(s.tags))
for i, tag := range s.tags {
detour, loaded := s.outbound.Outbound(tag)
@@ -77,6 +116,11 @@ func (s *URLTest) Start() error {
}
outbounds = append(outbounds, detour)
}
if len(s.tags) == 0 {
detour, _ := s.outbound.Outbound("Compatible")
s.tags = append(s.tags, detour.Tag())
outbounds = append(outbounds, detour)
}
group, err := NewURLTestGroup(s.ctx, s.outbound, s.logger, outbounds, s.link, s.interval, s.tolerance, s.idleTimeout, s.interruptExternalConnections)
if err != nil {
return err
@@ -136,7 +180,7 @@ func (s *URLTest) DialContext(ctx context.Context, network string, destination M
}
conn, err := outbound.DialContext(ctx, network, destination)
if err == nil {
return s.group.interruptGroup.NewConn(conn, interrupt.IsExternalConnectionFromContext(ctx)), nil
return s.group.interruptGroup.NewConn(conn, interrupt.IsExternalConnectionFromContext(ctx), interrupt.IsProviderConnectionFromContext(ctx)), nil
}
s.logger.ErrorContext(ctx, err)
s.group.history.DeleteURLTestHistory(outbound.Tag())
@@ -154,7 +198,7 @@ func (s *URLTest) ListenPacket(ctx context.Context, destination M.Socksaddr) (ne
}
conn, err := outbound.ListenPacket(ctx, destination)
if err == nil {
return s.group.interruptGroup.NewPacketConn(conn, interrupt.IsExternalConnectionFromContext(ctx)), nil
return s.group.interruptGroup.NewPacketConn(conn, interrupt.IsExternalConnectionFromContext(ctx), interrupt.IsProviderConnectionFromContext(ctx)), nil
}
s.logger.ErrorContext(ctx, err)
s.group.history.DeleteURLTestHistory(outbound.Tag())
@@ -163,13 +207,13 @@ func (s *URLTest) ListenPacket(ctx context.Context, destination M.Socksaddr) (ne
func (s *URLTest) NewConnectionEx(ctx context.Context, conn net.Conn, metadata adapter.InboundContext, onClose N.CloseHandlerFunc) {
ctx = interrupt.ContextWithIsExternalConnection(ctx)
conn = s.group.interruptGroup.NewConn(conn, interrupt.IsExternalConnectionFromContext(ctx))
conn = s.group.interruptGroup.NewConn(conn, interrupt.IsExternalConnectionFromContext(ctx), interrupt.IsProviderConnectionFromContext(ctx))
s.connection.NewConnection(ctx, s, conn, metadata, onClose)
}
func (s *URLTest) NewPacketConnectionEx(ctx context.Context, conn N.PacketConn, metadata adapter.InboundContext, onClose N.CloseHandlerFunc) {
ctx = interrupt.ContextWithIsExternalConnection(ctx)
conn = s.group.interruptGroup.NewSingPacketConn(conn, interrupt.IsExternalConnectionFromContext(ctx))
conn = s.group.interruptGroup.NewSingPacketConn(conn, interrupt.IsExternalConnectionFromContext(ctx), interrupt.IsProviderConnectionFromContext(ctx))
s.connection.NewPacketConnection(ctx, s, conn, metadata, onClose)
}
@@ -188,6 +232,63 @@ func (s *URLTest) NewDirectRouteConnection(metadata adapter.InboundContext, rout
return selected.(adapter.DirectRouteOutbound).NewDirectRouteConnection(metadata, routeContext, timeout)
}
func (s *URLTest) onProviderUpdated(tag string) error {
_, loaded := s.providers[tag]
if !loaded {
return E.New("outbound provider not found: ", tag)
}
var (
tags = s.Dependencies()
outbounds []adapter.Outbound
)
for _, tag := range tags {
detour, _ := s.outbound.Outbound(tag)
outbounds = append(outbounds, detour)
}
for _, providerTag := range s.providerTags {
if providerTag != tag && s.outboundsCache[providerTag] != nil {
for _, detour := range s.outboundsCache[providerTag] {
tags = append(tags, detour.Tag())
outbounds = append(outbounds, detour)
}
continue
}
provider := s.providers[providerTag]
var cache []adapter.Outbound
for _, detour := range provider.Outbounds() {
tag := detour.Tag()
if s.exclude != nil && s.exclude.MatchString(tag) {
continue
}
if s.include != nil && !s.include.MatchString(tag) {
continue
}
tags = append(tags, tag)
cache = append(cache, detour)
}
outbounds = append(outbounds, cache...)
s.outboundsCache[providerTag] = cache
}
if len(tags) == 0 {
detour, _ := s.outbound.Outbound("Compatible")
tags = append(tags, detour.Tag())
outbounds = append(outbounds, detour)
}
s.tags, s.group.outbounds = tags, outbounds
s.group.access.Lock()
if s.group.ticker != nil {
s.group.ticker.Reset(s.group.interval)
}
s.group.access.Unlock()
ctx, cancel := context.WithCancel(s.ctx)
if s.cancel != nil {
s.cancel()
}
s.cancel = cancel
s.URLTest(ctx)
return nil
}
type URLTestGroup struct {
ctx context.Context
router adapter.Router
@@ -407,7 +508,11 @@ func (g *URLTestGroup) urlTest(ctx context.Context, force bool) (map[string]uint
})
}
b.Wait()
g.performUpdateCheck()
select {
case <-ctx.Done():
default:
g.performUpdateCheck()
}
return result, nil
}