mirror of
https://github.com/SagerNet/sing-box.git
synced 2024-12-24 11:26:09 +08:00
401 lines
11 KiB
Go
401 lines
11 KiB
Go
package box
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"runtime/debug"
|
|
"time"
|
|
|
|
"github.com/sagernet/sing-box/adapter"
|
|
"github.com/sagernet/sing-box/adapter/inbound"
|
|
"github.com/sagernet/sing-box/adapter/outbound"
|
|
"github.com/sagernet/sing-box/common/dialer"
|
|
"github.com/sagernet/sing-box/common/taskmonitor"
|
|
C "github.com/sagernet/sing-box/constant"
|
|
"github.com/sagernet/sing-box/experimental"
|
|
"github.com/sagernet/sing-box/experimental/cachefile"
|
|
"github.com/sagernet/sing-box/experimental/libbox/platform"
|
|
"github.com/sagernet/sing-box/log"
|
|
"github.com/sagernet/sing-box/option"
|
|
"github.com/sagernet/sing-box/protocol/direct"
|
|
"github.com/sagernet/sing-box/route"
|
|
"github.com/sagernet/sing/common"
|
|
E "github.com/sagernet/sing/common/exceptions"
|
|
F "github.com/sagernet/sing/common/format"
|
|
"github.com/sagernet/sing/common/ntp"
|
|
"github.com/sagernet/sing/service"
|
|
"github.com/sagernet/sing/service/pause"
|
|
)
|
|
|
|
var _ adapter.Service = (*Box)(nil)
|
|
|
|
type Box struct {
|
|
createdAt time.Time
|
|
logFactory log.Factory
|
|
logger log.ContextLogger
|
|
network *route.NetworkManager
|
|
router *route.Router
|
|
inbound *inbound.Manager
|
|
outbound *outbound.Manager
|
|
services []adapter.LifecycleService
|
|
done chan struct{}
|
|
}
|
|
|
|
type Options struct {
|
|
option.Options
|
|
Context context.Context
|
|
PlatformLogWriter log.PlatformWriter
|
|
}
|
|
|
|
func Context(
|
|
ctx context.Context,
|
|
inboundRegistry adapter.InboundRegistry,
|
|
outboundRegistry adapter.OutboundRegistry,
|
|
) context.Context {
|
|
if service.FromContext[option.InboundOptionsRegistry](ctx) == nil ||
|
|
service.FromContext[adapter.InboundRegistry](ctx) == nil {
|
|
ctx = service.ContextWith[option.InboundOptionsRegistry](ctx, inboundRegistry)
|
|
ctx = service.ContextWith[adapter.InboundRegistry](ctx, inboundRegistry)
|
|
}
|
|
if service.FromContext[option.OutboundOptionsRegistry](ctx) == nil ||
|
|
service.FromContext[adapter.OutboundRegistry](ctx) == nil {
|
|
ctx = service.ContextWith[option.OutboundOptionsRegistry](ctx, outboundRegistry)
|
|
ctx = service.ContextWith[adapter.OutboundRegistry](ctx, outboundRegistry)
|
|
}
|
|
return ctx
|
|
}
|
|
|
|
func New(options Options) (*Box, error) {
|
|
createdAt := time.Now()
|
|
ctx := options.Context
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
ctx = service.ContextWithDefaultRegistry(ctx)
|
|
|
|
inboundRegistry := service.FromContext[adapter.InboundRegistry](ctx)
|
|
if inboundRegistry == nil {
|
|
return nil, E.New("missing inbound registry in context")
|
|
}
|
|
|
|
outboundRegistry := service.FromContext[adapter.OutboundRegistry](ctx)
|
|
if outboundRegistry == nil {
|
|
return nil, E.New("missing outbound registry in context")
|
|
}
|
|
|
|
ctx = pause.WithDefaultManager(ctx)
|
|
experimentalOptions := common.PtrValueOrDefault(options.Experimental)
|
|
applyDebugOptions(common.PtrValueOrDefault(experimentalOptions.Debug))
|
|
var needCacheFile bool
|
|
var needClashAPI bool
|
|
var needV2RayAPI bool
|
|
if experimentalOptions.CacheFile != nil && experimentalOptions.CacheFile.Enabled || options.PlatformLogWriter != nil {
|
|
needCacheFile = true
|
|
}
|
|
if experimentalOptions.ClashAPI != nil || options.PlatformLogWriter != nil {
|
|
needClashAPI = true
|
|
}
|
|
if experimentalOptions.V2RayAPI != nil && experimentalOptions.V2RayAPI.Listen != "" {
|
|
needV2RayAPI = true
|
|
}
|
|
platformInterface := service.FromContext[platform.Interface](ctx)
|
|
var defaultLogWriter io.Writer
|
|
if platformInterface != nil {
|
|
defaultLogWriter = io.Discard
|
|
}
|
|
logFactory, err := log.New(log.Options{
|
|
Context: ctx,
|
|
Options: common.PtrValueOrDefault(options.Log),
|
|
Observable: needClashAPI,
|
|
DefaultWriter: defaultLogWriter,
|
|
BaseTime: createdAt,
|
|
PlatformWriter: options.PlatformLogWriter,
|
|
})
|
|
if err != nil {
|
|
return nil, E.Cause(err, "create log factory")
|
|
}
|
|
|
|
routeOptions := common.PtrValueOrDefault(options.Route)
|
|
inboundManager := inbound.NewManager(logFactory.NewLogger("inbound"), inboundRegistry)
|
|
outboundManager := outbound.NewManager(logFactory.NewLogger("outbound"), outboundRegistry, routeOptions.Final)
|
|
service.MustRegister[adapter.InboundManager](ctx, inboundManager)
|
|
service.MustRegister[adapter.OutboundManager](ctx, outboundManager)
|
|
|
|
networkManager, err := route.NewNetworkManager(ctx, logFactory.NewLogger("network"), routeOptions)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "initialize network manager")
|
|
}
|
|
service.MustRegister[adapter.NetworkManager](ctx, networkManager)
|
|
router, err := route.NewRouter(ctx, logFactory, routeOptions, common.PtrValueOrDefault(options.DNS))
|
|
if err != nil {
|
|
return nil, E.Cause(err, "initialize router")
|
|
}
|
|
//nolint:staticcheck
|
|
if len(options.LegacyInbounds) > 0 {
|
|
for _, legacyInbound := range options.LegacyInbounds {
|
|
options.Inbounds = append(options.Inbounds, option.Inbound{
|
|
Type: legacyInbound.Type,
|
|
Tag: legacyInbound.Tag,
|
|
Options: common.Must1(legacyInbound.RawOptions()),
|
|
})
|
|
}
|
|
}
|
|
//nolint:staticcheck
|
|
if len(options.LegacyOutbounds) > 0 {
|
|
for _, legacyOutbound := range options.LegacyOutbounds {
|
|
options.Outbounds = append(options.Outbounds, option.Outbound{
|
|
Type: legacyOutbound.Type,
|
|
Tag: legacyOutbound.Tag,
|
|
Options: common.Must1(legacyOutbound.RawOptions()),
|
|
})
|
|
}
|
|
}
|
|
for i, inboundOptions := range options.Inbounds {
|
|
var tag string
|
|
if inboundOptions.Tag != "" {
|
|
tag = inboundOptions.Tag
|
|
} else {
|
|
tag = F.ToString(i)
|
|
}
|
|
err = inboundManager.Create(ctx,
|
|
router,
|
|
logFactory.NewLogger(F.ToString("inbound/", inboundOptions.Type, "[", tag, "]")),
|
|
tag,
|
|
inboundOptions.Type,
|
|
inboundOptions.Options,
|
|
)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "initialize inbound[", i, "]")
|
|
}
|
|
}
|
|
for i, outboundOptions := range options.Outbounds {
|
|
var tag string
|
|
if outboundOptions.Tag != "" {
|
|
tag = outboundOptions.Tag
|
|
} else {
|
|
tag = F.ToString(i)
|
|
}
|
|
outboundCtx := ctx
|
|
if tag != "" {
|
|
// TODO: remove this
|
|
outboundCtx = adapter.WithContext(outboundCtx, &adapter.InboundContext{
|
|
Outbound: tag,
|
|
})
|
|
}
|
|
err = outboundManager.Create(
|
|
outboundCtx,
|
|
router,
|
|
logFactory.NewLogger(F.ToString("outbound/", outboundOptions.Type, "[", tag, "]")),
|
|
tag,
|
|
outboundOptions.Type,
|
|
outboundOptions.Options,
|
|
)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "initialize outbound[", i, "]")
|
|
}
|
|
}
|
|
outboundManager.Initialize(common.Must1(
|
|
direct.NewOutbound(
|
|
ctx,
|
|
router,
|
|
logFactory.NewLogger("outbound/direct"),
|
|
"direct",
|
|
option.DirectOutboundOptions{},
|
|
),
|
|
))
|
|
if platformInterface != nil {
|
|
err = platformInterface.Initialize(networkManager)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "initialize platform interface")
|
|
}
|
|
}
|
|
var services []adapter.LifecycleService
|
|
if needCacheFile {
|
|
cacheFile := cachefile.New(ctx, common.PtrValueOrDefault(experimentalOptions.CacheFile))
|
|
service.MustRegister[adapter.CacheFile](ctx, cacheFile)
|
|
services = append(services, cacheFile)
|
|
}
|
|
if needClashAPI {
|
|
clashAPIOptions := common.PtrValueOrDefault(experimentalOptions.ClashAPI)
|
|
clashAPIOptions.ModeList = experimental.CalculateClashModeList(options.Options)
|
|
clashServer, err := experimental.NewClashServer(ctx, logFactory.(log.ObservableFactory), clashAPIOptions)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "create clash-server")
|
|
}
|
|
router.SetTracker(clashServer)
|
|
service.MustRegister[adapter.ClashServer](ctx, clashServer)
|
|
services = append(services, clashServer)
|
|
}
|
|
if needV2RayAPI {
|
|
v2rayServer, err := experimental.NewV2RayServer(logFactory.NewLogger("v2ray-api"), common.PtrValueOrDefault(experimentalOptions.V2RayAPI))
|
|
if err != nil {
|
|
return nil, E.Cause(err, "create v2ray-server")
|
|
}
|
|
if v2rayServer.StatsService() != nil {
|
|
router.SetTracker(v2rayServer.StatsService())
|
|
services = append(services, v2rayServer)
|
|
service.MustRegister[adapter.V2RayServer](ctx, v2rayServer)
|
|
}
|
|
}
|
|
ntpOptions := common.PtrValueOrDefault(options.NTP)
|
|
if ntpOptions.Enabled {
|
|
ntpDialer, err := dialer.New(ctx, ntpOptions.DialerOptions)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "create NTP service")
|
|
}
|
|
timeService := ntp.NewService(ntp.Options{
|
|
Context: ctx,
|
|
Dialer: ntpDialer,
|
|
Logger: logFactory.NewLogger("ntp"),
|
|
Server: ntpOptions.ServerOptions.Build(),
|
|
Interval: time.Duration(ntpOptions.Interval),
|
|
WriteToSystem: ntpOptions.WriteToSystem,
|
|
})
|
|
service.MustRegister[ntp.TimeService](ctx, timeService)
|
|
services = append(services, adapter.NewLifecycleService(timeService, "ntp service"))
|
|
}
|
|
return &Box{
|
|
network: networkManager,
|
|
router: router,
|
|
inbound: inboundManager,
|
|
outbound: outboundManager,
|
|
createdAt: createdAt,
|
|
logFactory: logFactory,
|
|
logger: logFactory.Logger(),
|
|
services: services,
|
|
done: make(chan struct{}),
|
|
}, nil
|
|
}
|
|
|
|
func (s *Box) PreStart() error {
|
|
err := s.preStart()
|
|
if err != nil {
|
|
// TODO: remove catch error
|
|
defer func() {
|
|
v := recover()
|
|
if v != nil {
|
|
println(err.Error())
|
|
debug.PrintStack()
|
|
panic("panic on early close: " + fmt.Sprint(v))
|
|
}
|
|
}()
|
|
s.Close()
|
|
return err
|
|
}
|
|
s.logger.Info("sing-box pre-started (", F.Seconds(time.Since(s.createdAt).Seconds()), "s)")
|
|
return nil
|
|
}
|
|
|
|
func (s *Box) Start() error {
|
|
err := s.start()
|
|
if err != nil {
|
|
// TODO: remove catch error
|
|
defer func() {
|
|
v := recover()
|
|
if v != nil {
|
|
println(err.Error())
|
|
debug.PrintStack()
|
|
println("panic on early start: " + fmt.Sprint(v))
|
|
}
|
|
}()
|
|
s.Close()
|
|
return err
|
|
}
|
|
s.logger.Info("sing-box started (", F.Seconds(time.Since(s.createdAt).Seconds()), "s)")
|
|
return nil
|
|
}
|
|
|
|
func (s *Box) preStart() error {
|
|
monitor := taskmonitor.New(s.logger, C.StartTimeout)
|
|
monitor.Start("start logger")
|
|
err := s.logFactory.Start()
|
|
monitor.Finish()
|
|
if err != nil {
|
|
return E.Cause(err, "start logger")
|
|
}
|
|
err = adapter.StartNamed(adapter.StartStateInitialize, s.services) // cache-file clash-api v2ray-api
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = adapter.Start(adapter.StartStateInitialize, s.network, s.router, s.outbound, s.inbound)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = adapter.Start(adapter.StartStateStart, s.outbound, s.network, s.router)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Box) start() error {
|
|
err := s.preStart()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = adapter.StartNamed(adapter.StartStateStart, s.services)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = s.inbound.Start(adapter.StartStateStart)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = adapter.Start(adapter.StartStatePostStart, s.outbound, s.network, s.router, s.inbound)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = adapter.StartNamed(adapter.StartStatePostStart, s.services)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = adapter.Start(adapter.StartStateStarted, s.network, s.router, s.outbound, s.inbound)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = adapter.StartNamed(adapter.StartStateStarted, s.services)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Box) Close() error {
|
|
select {
|
|
case <-s.done:
|
|
return os.ErrClosed
|
|
default:
|
|
close(s.done)
|
|
}
|
|
err := common.Close(
|
|
s.inbound, s.outbound, s.router, s.network,
|
|
)
|
|
for _, lifecycleService := range s.services {
|
|
err = E.Append(err, lifecycleService.Close(), func(err error) error {
|
|
return E.Cause(err, "close ", lifecycleService.Name())
|
|
})
|
|
}
|
|
err = E.Append(err, s.logFactory.Close(), func(err error) error {
|
|
return E.Cause(err, "close logger")
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (s *Box) Network() adapter.NetworkManager {
|
|
return s.network
|
|
}
|
|
|
|
func (s *Box) Router() adapter.Router {
|
|
return s.router
|
|
}
|
|
|
|
func (s *Box) Inbound() adapter.InboundManager {
|
|
return s.inbound
|
|
}
|
|
|
|
func (s *Box) Outbound() adapter.OutboundManager {
|
|
return s.outbound
|
|
}
|