2015-12-04 16:53:31 -05:00
|
|
|
// Package point is a shell of V2Ray to run on various of systems.
|
|
|
|
// Point server is a full functionality proxying system. It consists of an inbound and an outbound
|
|
|
|
// connection, as well as any number of inbound and outbound detours. It provides a way internally
|
|
|
|
// to route network packets.
|
2015-10-14 08:51:19 -04:00
|
|
|
package point
|
2015-09-05 11:48:38 -04:00
|
|
|
|
|
|
|
import (
|
2015-12-05 16:55:45 -05:00
|
|
|
"github.com/v2ray/v2ray-core/app"
|
2016-01-31 11:01:28 -05:00
|
|
|
"github.com/v2ray/v2ray-core/app/dispatcher"
|
2016-05-18 02:05:52 -04:00
|
|
|
dispatchers "github.com/v2ray/v2ray-core/app/dispatcher/impl"
|
2016-05-16 03:25:34 -04:00
|
|
|
"github.com/v2ray/v2ray-core/app/dns"
|
2016-01-31 11:01:28 -05:00
|
|
|
"github.com/v2ray/v2ray-core/app/proxyman"
|
2015-11-22 11:41:52 -05:00
|
|
|
"github.com/v2ray/v2ray-core/app/router"
|
2015-09-19 18:50:21 -04:00
|
|
|
"github.com/v2ray/v2ray-core/common/log"
|
2015-09-19 17:54:36 -04:00
|
|
|
v2net "github.com/v2ray/v2ray-core/common/net"
|
2015-10-13 06:27:50 -04:00
|
|
|
"github.com/v2ray/v2ray-core/common/retry"
|
2016-01-01 17:44:11 -05:00
|
|
|
"github.com/v2ray/v2ray-core/proxy"
|
2016-01-02 17:32:18 -05:00
|
|
|
proxyrepo "github.com/v2ray/v2ray-core/proxy/repo"
|
2015-09-05 11:48:38 -04:00
|
|
|
)
|
|
|
|
|
2015-12-04 16:53:31 -05:00
|
|
|
// Point shell of V2Ray.
|
2015-09-12 16:11:54 -04:00
|
|
|
type Point struct {
|
2016-01-20 19:40:52 -05:00
|
|
|
port v2net.Port
|
2016-05-29 10:37:52 -04:00
|
|
|
listen v2net.Address
|
2016-01-25 11:18:24 -05:00
|
|
|
ich proxy.InboundHandler
|
|
|
|
och proxy.OutboundHandler
|
2016-01-20 19:40:52 -05:00
|
|
|
idh []InboundDetourHandler
|
|
|
|
taggedIdh map[string]InboundDetourHandler
|
2016-01-25 11:18:24 -05:00
|
|
|
odh map[string]proxy.OutboundHandler
|
2016-01-20 19:40:52 -05:00
|
|
|
router router.Router
|
2016-05-18 02:05:52 -04:00
|
|
|
space app.Space
|
2015-09-05 11:48:38 -04:00
|
|
|
}
|
|
|
|
|
2015-09-12 16:11:54 -04:00
|
|
|
// NewPoint returns a new Point server based on given configuration.
|
2015-09-07 06:00:46 -04:00
|
|
|
// The server is not started at this point.
|
2016-01-17 15:43:10 -05:00
|
|
|
func NewPoint(pConfig *Config) (*Point, error) {
|
2015-09-12 16:11:54 -04:00
|
|
|
var vpoint = new(Point)
|
2016-06-03 18:38:22 -04:00
|
|
|
vpoint.port = pConfig.InboundConfig.Port
|
|
|
|
if vpoint.port == 0 {
|
|
|
|
vpoint.port = pConfig.Port // Backward compatibility
|
|
|
|
}
|
|
|
|
|
|
|
|
vpoint.listen = pConfig.InboundConfig.ListenOn
|
2015-09-12 05:51:42 -04:00
|
|
|
|
2016-06-01 19:49:25 -04:00
|
|
|
if pConfig.TransportConfig != nil {
|
2016-06-02 14:52:52 -04:00
|
|
|
pConfig.TransportConfig.Apply()
|
2016-06-01 19:49:25 -04:00
|
|
|
}
|
|
|
|
|
2016-01-17 15:43:10 -05:00
|
|
|
if pConfig.LogConfig != nil {
|
|
|
|
logConfig := pConfig.LogConfig
|
|
|
|
if len(logConfig.AccessLog) > 0 {
|
|
|
|
err := log.InitAccessLogger(logConfig.AccessLog)
|
2015-12-05 15:10:14 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-17 15:43:10 -05:00
|
|
|
if len(logConfig.ErrorLog) > 0 {
|
|
|
|
err := log.InitErrorLogger(logConfig.ErrorLog)
|
2015-12-05 15:10:14 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-17 15:43:10 -05:00
|
|
|
log.SetLogLevel(logConfig.LogLevel)
|
2015-12-05 15:10:14 -05:00
|
|
|
}
|
|
|
|
|
2016-05-18 02:05:52 -04:00
|
|
|
vpoint.space = app.NewSpace()
|
|
|
|
vpoint.space.BindApp(proxyman.APP_ID_INBOUND_MANAGER, vpoint)
|
|
|
|
|
2016-05-18 11:12:04 -04:00
|
|
|
outboundHandlerManager := proxyman.NewDefaultOutboundHandlerManager()
|
2016-05-18 02:05:52 -04:00
|
|
|
vpoint.space.BindApp(proxyman.APP_ID_OUTBOUND_MANAGER, outboundHandlerManager)
|
|
|
|
|
|
|
|
dnsConfig := pConfig.DNSConfig
|
|
|
|
if dnsConfig != nil {
|
|
|
|
dnsServer := dns.NewCacheServer(vpoint.space, dnsConfig)
|
|
|
|
vpoint.space.BindApp(dns.APP_ID, dnsServer)
|
|
|
|
}
|
|
|
|
|
|
|
|
routerConfig := pConfig.RouterConfig
|
|
|
|
if routerConfig != nil {
|
|
|
|
r, err := router.CreateRouter(routerConfig.Strategy, routerConfig.Settings, vpoint.space)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Failed to create router: ", err)
|
|
|
|
return nil, ErrorBadConfiguration
|
|
|
|
}
|
|
|
|
vpoint.space.BindApp(router.APP_ID, r)
|
|
|
|
vpoint.router = r
|
|
|
|
}
|
|
|
|
|
|
|
|
vpoint.space.BindApp(dispatcher.APP_ID, dispatchers.NewDefaultDispatcher(vpoint.space))
|
2015-12-05 16:55:45 -05:00
|
|
|
|
2016-01-17 15:43:10 -05:00
|
|
|
ichConfig := pConfig.InboundConfig.Settings
|
2016-06-04 08:25:13 -04:00
|
|
|
ich, err := proxyrepo.CreateInboundHandler(
|
|
|
|
pConfig.InboundConfig.Protocol, vpoint.space, ichConfig, &proxy.InboundHandlerMeta{
|
|
|
|
Tag: "system.inbound",
|
|
|
|
Address: pConfig.InboundConfig.ListenOn,
|
|
|
|
Port: vpoint.port})
|
2015-10-06 18:30:44 -04:00
|
|
|
if err != nil {
|
2016-01-18 06:24:33 -05:00
|
|
|
log.Error("Failed to create inbound connection handler: ", err)
|
2015-10-06 18:30:44 -04:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
vpoint.ich = ich
|
2015-09-12 05:51:42 -04:00
|
|
|
|
2016-01-17 15:43:10 -05:00
|
|
|
ochConfig := pConfig.OutboundConfig.Settings
|
2016-06-04 08:25:13 -04:00
|
|
|
och, err := proxyrepo.CreateOutboundHandler(
|
|
|
|
pConfig.OutboundConfig.Protocol, vpoint.space, ochConfig, &proxy.OutboundHandlerMeta{
|
|
|
|
Tag: "system.outbound",
|
|
|
|
Address: pConfig.OutboundConfig.SendThrough})
|
2015-10-06 18:30:44 -04:00
|
|
|
if err != nil {
|
2016-01-18 06:24:33 -05:00
|
|
|
log.Error("Failed to create outbound connection handler: ", err)
|
2015-10-06 18:30:44 -04:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
vpoint.och = och
|
2016-05-18 02:05:52 -04:00
|
|
|
outboundHandlerManager.SetDefaultHandler(och)
|
2015-09-10 18:24:18 -04:00
|
|
|
|
2016-01-20 19:40:52 -05:00
|
|
|
vpoint.taggedIdh = make(map[string]InboundDetourHandler)
|
2016-01-17 15:43:10 -05:00
|
|
|
detours := pConfig.InboundDetours
|
2015-10-31 19:11:41 -04:00
|
|
|
if len(detours) > 0 {
|
2016-01-20 19:40:52 -05:00
|
|
|
vpoint.idh = make([]InboundDetourHandler, len(detours))
|
2015-10-31 19:11:41 -04:00
|
|
|
for idx, detourConfig := range detours {
|
2016-01-20 19:40:52 -05:00
|
|
|
allocConfig := detourConfig.Allocation
|
|
|
|
var detourHandler InboundDetourHandler
|
|
|
|
switch allocConfig.Strategy {
|
|
|
|
case AllocationStrategyAlways:
|
2016-05-18 02:05:52 -04:00
|
|
|
dh, err := NewInboundDetourHandlerAlways(vpoint.space, detourConfig)
|
2016-01-20 19:40:52 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("Point: Failed to create detour handler: ", err)
|
2016-01-30 06:12:57 -05:00
|
|
|
return nil, ErrorBadConfiguration
|
2016-01-20 19:40:52 -05:00
|
|
|
}
|
|
|
|
detourHandler = dh
|
2016-01-22 10:25:01 -05:00
|
|
|
case AllocationStrategyRandom:
|
2016-05-18 02:05:52 -04:00
|
|
|
dh, err := NewInboundDetourHandlerDynamic(vpoint.space, detourConfig)
|
2016-01-22 10:25:01 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("Point: Failed to create detour handler: ", err)
|
2016-01-30 06:12:57 -05:00
|
|
|
return nil, ErrorBadConfiguration
|
2016-01-22 10:25:01 -05:00
|
|
|
}
|
|
|
|
detourHandler = dh
|
2016-01-20 19:40:52 -05:00
|
|
|
default:
|
|
|
|
log.Error("Point: Unknown allocation strategy: ", allocConfig.Strategy)
|
2016-01-30 06:12:57 -05:00
|
|
|
return nil, ErrorBadConfiguration
|
2015-10-31 19:11:41 -04:00
|
|
|
}
|
|
|
|
vpoint.idh[idx] = detourHandler
|
2016-01-20 19:40:52 -05:00
|
|
|
if len(detourConfig.Tag) > 0 {
|
|
|
|
vpoint.taggedIdh[detourConfig.Tag] = detourHandler
|
|
|
|
}
|
2015-10-31 19:11:41 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-17 15:43:10 -05:00
|
|
|
outboundDetours := pConfig.OutboundDetours
|
2015-11-22 11:41:52 -05:00
|
|
|
if len(outboundDetours) > 0 {
|
2016-01-25 11:18:24 -05:00
|
|
|
vpoint.odh = make(map[string]proxy.OutboundHandler)
|
2015-11-22 11:41:52 -05:00
|
|
|
for _, detourConfig := range outboundDetours {
|
2016-06-04 08:25:13 -04:00
|
|
|
detourHandler, err := proxyrepo.CreateOutboundHandler(
|
|
|
|
detourConfig.Protocol, vpoint.space, detourConfig.Settings, &proxy.OutboundHandlerMeta{
|
|
|
|
Tag: detourConfig.Tag,
|
|
|
|
Address: detourConfig.SendThrough})
|
2015-11-22 11:41:52 -05:00
|
|
|
if err != nil {
|
2016-06-01 16:45:12 -04:00
|
|
|
log.Error("Point: Failed to create detour outbound connection handler: ", err)
|
2015-11-22 11:41:52 -05:00
|
|
|
return nil, err
|
|
|
|
}
|
2016-01-17 15:43:10 -05:00
|
|
|
vpoint.odh[detourConfig.Tag] = detourHandler
|
2016-05-18 02:05:52 -04:00
|
|
|
outboundHandlerManager.SetHandler(detourConfig.Tag, detourHandler)
|
2015-11-22 11:41:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-18 11:12:04 -04:00
|
|
|
if err := vpoint.space.Initialize(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-09-06 16:10:42 -04:00
|
|
|
return vpoint, nil
|
2015-09-05 11:48:38 -04:00
|
|
|
}
|
|
|
|
|
2016-01-03 18:33:25 -05:00
|
|
|
func (this *Point) Close() {
|
|
|
|
this.ich.Close()
|
|
|
|
for _, idh := range this.idh {
|
|
|
|
idh.Close()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-12 16:11:54 -04:00
|
|
|
// Start starts the Point server, and return any error during the process.
|
2015-09-07 06:00:46 -04:00
|
|
|
// In the case of any errors, the state of the server is unpredicatable.
|
2015-11-27 06:29:20 -05:00
|
|
|
func (this *Point) Start() error {
|
|
|
|
if this.port <= 0 {
|
2016-06-01 16:45:12 -04:00
|
|
|
log.Error("Point: Invalid port ", this.port)
|
2016-01-30 06:12:57 -05:00
|
|
|
return ErrorBadConfiguration
|
2015-09-06 16:10:42 -04:00
|
|
|
}
|
2015-09-22 12:11:55 -04:00
|
|
|
|
2015-10-31 19:11:41 -04:00
|
|
|
err := retry.Timed(100 /* times */, 100 /* ms */).On(func() error {
|
2016-06-03 18:38:22 -04:00
|
|
|
err := this.ich.Start()
|
2015-10-31 19:11:41 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2015-10-13 19:15:29 -04:00
|
|
|
}
|
2016-06-01 16:45:12 -04:00
|
|
|
log.Warning("Point: started on port ", this.port)
|
2015-10-31 19:11:41 -04:00
|
|
|
return nil
|
2015-10-13 06:27:50 -04:00
|
|
|
})
|
2015-10-31 19:11:41 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-11-27 06:29:20 -05:00
|
|
|
for _, detourHandler := range this.idh {
|
2015-10-31 19:11:41 -04:00
|
|
|
err := detourHandler.Start()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2015-09-06 16:10:42 -04:00
|
|
|
}
|
2015-09-10 18:24:18 -04:00
|
|
|
|
2016-05-18 02:05:52 -04:00
|
|
|
func (this *Point) GetHandler(tag string) (proxy.InboundHandler, int) {
|
2016-01-21 11:22:56 -05:00
|
|
|
handler, found := this.taggedIdh[tag]
|
|
|
|
if !found {
|
2016-01-30 05:45:33 -05:00
|
|
|
log.Warning("Point: Unable to find an inbound handler with tag: ", tag)
|
2016-01-21 11:22:56 -05:00
|
|
|
return nil, 0
|
|
|
|
}
|
|
|
|
return handler.GetConnectionHandler()
|
2016-01-20 19:40:52 -05:00
|
|
|
}
|
2016-05-18 11:12:04 -04:00
|
|
|
|
|
|
|
func (this *Point) Release() {
|
|
|
|
|
|
|
|
}
|