mirror of
https://github.com/v2fly/v2ray-core.git
synced 2024-09-07 20:45:19 -04:00
346 lines
8.3 KiB
Go
346 lines
8.3 KiB
Go
// +build !confonly
|
|
|
|
package core
|
|
|
|
import (
|
|
"context"
|
|
"reflect"
|
|
"sync"
|
|
|
|
"v2ray.com/core/common"
|
|
"v2ray.com/core/common/serial"
|
|
"v2ray.com/core/features"
|
|
"v2ray.com/core/features/dns"
|
|
"v2ray.com/core/features/dns/localdns"
|
|
"v2ray.com/core/features/inbound"
|
|
"v2ray.com/core/features/outbound"
|
|
"v2ray.com/core/features/policy"
|
|
"v2ray.com/core/features/routing"
|
|
"v2ray.com/core/features/stats"
|
|
)
|
|
|
|
// Server is an instance of V2Ray. At any time, there must be at most one Server instance running.
|
|
type Server interface {
|
|
common.Runnable
|
|
}
|
|
|
|
// ServerType returns the type of the server.
|
|
func ServerType() interface{} {
|
|
return (*Instance)(nil)
|
|
}
|
|
|
|
type resolution struct {
|
|
deps []reflect.Type
|
|
callback interface{}
|
|
}
|
|
|
|
func getFeature(allFeatures []features.Feature, t reflect.Type) features.Feature {
|
|
for _, f := range allFeatures {
|
|
if reflect.TypeOf(f.Type()) == t {
|
|
return f
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *resolution) resolve(allFeatures []features.Feature) (bool, error) {
|
|
var fs []features.Feature
|
|
for _, d := range r.deps {
|
|
f := getFeature(allFeatures, d)
|
|
if f == nil {
|
|
return false, nil
|
|
}
|
|
fs = append(fs, f)
|
|
}
|
|
|
|
callback := reflect.ValueOf(r.callback)
|
|
var input []reflect.Value
|
|
callbackType := callback.Type()
|
|
for i := 0; i < callbackType.NumIn(); i++ {
|
|
pt := callbackType.In(i)
|
|
for _, f := range fs {
|
|
if reflect.TypeOf(f).AssignableTo(pt) {
|
|
input = append(input, reflect.ValueOf(f))
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(input) != callbackType.NumIn() {
|
|
panic("Can't get all input parameters")
|
|
}
|
|
|
|
var err error
|
|
ret := callback.Call(input)
|
|
errInterface := reflect.TypeOf((*error)(nil)).Elem()
|
|
for i := len(ret) - 1; i >= 0; i-- {
|
|
if ret[i].Type() == errInterface {
|
|
v := ret[i].Interface()
|
|
if v != nil {
|
|
err = v.(error)
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
return true, err
|
|
}
|
|
|
|
// Instance combines all functionalities in V2Ray.
|
|
type Instance struct {
|
|
access sync.Mutex
|
|
features []features.Feature
|
|
featureResolutions []resolution
|
|
running bool
|
|
|
|
ctx context.Context
|
|
}
|
|
|
|
func AddInboundHandler(server *Instance, config *InboundHandlerConfig) error {
|
|
inboundManager := server.GetFeature(inbound.ManagerType()).(inbound.Manager)
|
|
rawHandler, err := CreateObject(server, config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handler, ok := rawHandler.(inbound.Handler)
|
|
if !ok {
|
|
return newError("not an InboundHandler")
|
|
}
|
|
if err := inboundManager.AddHandler(server.ctx, handler); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addInboundHandlers(server *Instance, configs []*InboundHandlerConfig) error {
|
|
for _, inboundConfig := range configs {
|
|
if err := AddInboundHandler(server, inboundConfig); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func AddOutboundHandler(server *Instance, config *OutboundHandlerConfig) error {
|
|
outboundManager := server.GetFeature(outbound.ManagerType()).(outbound.Manager)
|
|
rawHandler, err := CreateObject(server, config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handler, ok := rawHandler.(outbound.Handler)
|
|
if !ok {
|
|
return newError("not an OutboundHandler")
|
|
}
|
|
if err := outboundManager.AddHandler(server.ctx, handler); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addOutboundHandlers(server *Instance, configs []*OutboundHandlerConfig) error {
|
|
for _, outboundConfig := range configs {
|
|
if err := AddOutboundHandler(server, outboundConfig); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// RequireFeatures is a helper function to require features from Instance in context.
|
|
// See Instance.RequireFeatures for more information.
|
|
func RequireFeatures(ctx context.Context, callback interface{}) error {
|
|
v := MustFromContext(ctx)
|
|
return v.RequireFeatures(callback)
|
|
}
|
|
|
|
// New returns a new V2Ray instance based on given configuration.
|
|
// The instance is not started at this point.
|
|
// To ensure V2Ray instance works properly, the config must contain one Dispatcher, one InboundHandlerManager and one OutboundHandlerManager. Other features are optional.
|
|
func New(config *Config) (*Instance, error) {
|
|
var server = &Instance{ctx: context.Background()}
|
|
|
|
err, done := initInstanceWithConfig(config, server)
|
|
if done {
|
|
return nil, err
|
|
}
|
|
|
|
return server, nil
|
|
}
|
|
|
|
func NewWithContext(config *Config, ctx context.Context) (*Instance, error) {
|
|
var server = &Instance{ctx: ctx}
|
|
|
|
err, done := initInstanceWithConfig(config, server)
|
|
if done {
|
|
return nil, err
|
|
}
|
|
|
|
return server, nil
|
|
}
|
|
|
|
func initInstanceWithConfig(config *Config, server *Instance) (error, bool) {
|
|
if config.Transport != nil {
|
|
features.PrintDeprecatedFeatureWarning("global transport settings")
|
|
}
|
|
if err := config.Transport.Apply(); err != nil {
|
|
return err, true
|
|
}
|
|
|
|
for _, appSettings := range config.App {
|
|
settings, err := appSettings.GetInstance()
|
|
if err != nil {
|
|
return err, true
|
|
}
|
|
obj, err := CreateObject(server, settings)
|
|
if err != nil {
|
|
return err, true
|
|
}
|
|
if feature, ok := obj.(features.Feature); ok {
|
|
if err := server.AddFeature(feature); err != nil {
|
|
return err, true
|
|
}
|
|
}
|
|
}
|
|
|
|
essentialFeatures := []struct {
|
|
Type interface{}
|
|
Instance features.Feature
|
|
}{
|
|
{dns.ClientType(), localdns.New()},
|
|
{policy.ManagerType(), policy.DefaultManager{}},
|
|
{routing.RouterType(), routing.DefaultRouter{}},
|
|
{stats.ManagerType(), stats.NoopManager{}},
|
|
}
|
|
|
|
for _, f := range essentialFeatures {
|
|
if server.GetFeature(f.Type) == nil {
|
|
if err := server.AddFeature(f.Instance); err != nil {
|
|
return err, true
|
|
}
|
|
}
|
|
}
|
|
|
|
if server.featureResolutions != nil {
|
|
return newError("not all dependency are resolved."), true
|
|
}
|
|
|
|
if err := addInboundHandlers(server, config.Inbound); err != nil {
|
|
return err, true
|
|
}
|
|
|
|
if err := addOutboundHandlers(server, config.Outbound); err != nil {
|
|
return err, true
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// Type implements common.HasType.
|
|
func (s *Instance) Type() interface{} {
|
|
return ServerType()
|
|
}
|
|
|
|
// Close shutdown the V2Ray instance.
|
|
func (s *Instance) Close() error {
|
|
s.access.Lock()
|
|
defer s.access.Unlock()
|
|
|
|
s.running = false
|
|
|
|
var errors []interface{}
|
|
for _, f := range s.features {
|
|
if err := f.Close(); err != nil {
|
|
errors = append(errors, err)
|
|
}
|
|
}
|
|
if len(errors) > 0 {
|
|
return newError("failed to close all features").Base(newError(serial.Concat(errors...)))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// RequireFeatures registers a callback, which will be called when all dependent features are registered.
|
|
// The callback must be a func(). All its parameters must be features.Feature.
|
|
func (s *Instance) RequireFeatures(callback interface{}) error {
|
|
callbackType := reflect.TypeOf(callback)
|
|
if callbackType.Kind() != reflect.Func {
|
|
panic("not a function")
|
|
}
|
|
|
|
var featureTypes []reflect.Type
|
|
for i := 0; i < callbackType.NumIn(); i++ {
|
|
featureTypes = append(featureTypes, reflect.PtrTo(callbackType.In(i)))
|
|
}
|
|
|
|
r := resolution{
|
|
deps: featureTypes,
|
|
callback: callback,
|
|
}
|
|
if finished, err := r.resolve(s.features); finished {
|
|
return err
|
|
}
|
|
s.featureResolutions = append(s.featureResolutions, r)
|
|
return nil
|
|
}
|
|
|
|
// AddFeature registers a feature into current Instance.
|
|
func (s *Instance) AddFeature(feature features.Feature) error {
|
|
s.features = append(s.features, feature)
|
|
|
|
if s.running {
|
|
if err := feature.Start(); err != nil {
|
|
newError("failed to start feature").Base(err).WriteToLog()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
if s.featureResolutions == nil {
|
|
return nil
|
|
}
|
|
|
|
var pendingResolutions []resolution
|
|
for _, r := range s.featureResolutions {
|
|
finished, err := r.resolve(s.features)
|
|
if finished && err != nil {
|
|
return err
|
|
}
|
|
if !finished {
|
|
pendingResolutions = append(pendingResolutions, r)
|
|
}
|
|
}
|
|
if len(pendingResolutions) == 0 {
|
|
s.featureResolutions = nil
|
|
} else if len(pendingResolutions) < len(s.featureResolutions) {
|
|
s.featureResolutions = pendingResolutions
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetFeature returns a feature of the given type, or nil if such feature is not registered.
|
|
func (s *Instance) GetFeature(featureType interface{}) features.Feature {
|
|
return getFeature(s.features, reflect.TypeOf(featureType))
|
|
}
|
|
|
|
// Start starts the V2Ray instance, including all registered features. When Start returns error, the state of the instance is unknown.
|
|
// A V2Ray instance can be started only once. Upon closing, the instance is not guaranteed to start again.
|
|
//
|
|
// v2ray:api:stable
|
|
func (s *Instance) Start() error {
|
|
s.access.Lock()
|
|
defer s.access.Unlock()
|
|
|
|
s.running = true
|
|
for _, f := range s.features {
|
|
if err := f.Start(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
newError("V2Ray ", Version(), " started").AtWarning().WriteToLog()
|
|
|
|
return nil
|
|
}
|