1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-22 18:17:52 -05:00
v2fly/shell/point/point.go

215 lines
6.1 KiB
Go
Raw Normal View History

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"
"github.com/v2ray/v2ray-core/app/controller"
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"
v2net "github.com/v2ray/v2ray-core/common/net"
2015-10-13 06:27:50 -04:00
"github.com/v2ray/v2ray-core/common/retry"
"github.com/v2ray/v2ray-core/proxy"
2016-01-02 17:32:18 -05:00
proxyrepo "github.com/v2ray/v2ray-core/proxy/repo"
2015-10-14 08:51:19 -04:00
"github.com/v2ray/v2ray-core/transport/ray"
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 {
port v2net.Port
ich proxy.InboundConnectionHandler
och proxy.OutboundConnectionHandler
idh []InboundDetourHandler
taggedIdh map[string]InboundDetourHandler
odh map[string]proxy.OutboundConnectionHandler
router router.Router
space *controller.SpaceController
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-01-17 15:43:10 -05:00
vpoint.port = pConfig.Port
2015-09-12 05:51:42 -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
}
vpoint.space = controller.New()
2015-12-05 16:55:45 -05:00
vpoint.space.Bind(vpoint)
2016-01-17 15:43:10 -05:00
ichConfig := pConfig.InboundConfig.Settings
ich, err := proxyrepo.CreateInboundConnectionHandler(pConfig.InboundConfig.Protocol, vpoint.space.ForContext("vpoint-default-inbound"), ichConfig)
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
och, err := proxyrepo.CreateOutboundConnectionHandler(pConfig.OutboundConfig.Protocol, vpoint.space.ForContext("vpoint-default-outbound"), ochConfig)
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
2015-09-10 18:24:18 -04: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 {
vpoint.idh = make([]InboundDetourHandler, len(detours))
2015-10-31 19:11:41 -04:00
for idx, detourConfig := range detours {
allocConfig := detourConfig.Allocation
var detourHandler InboundDetourHandler
switch allocConfig.Strategy {
case AllocationStrategyAlways:
dh, err := NewInboundDetourHandlerAlways(vpoint.space.ForContext(detourConfig.Tag), detourConfig)
if err != nil {
log.Error("Point: Failed to create detour handler: ", err)
return nil, BadConfiguration
}
detourHandler = dh
default:
log.Error("Point: Unknown allocation strategy: ", allocConfig.Strategy)
return nil, BadConfiguration
2015-10-31 19:11:41 -04:00
}
vpoint.idh[idx] = detourHandler
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-02 17:32:18 -05:00
vpoint.odh = make(map[string]proxy.OutboundConnectionHandler)
2015-11-22 11:41:52 -05:00
for _, detourConfig := range outboundDetours {
2016-01-17 15:43:10 -05:00
detourHandler, err := proxyrepo.CreateOutboundConnectionHandler(detourConfig.Protocol, vpoint.space.ForContext(detourConfig.Tag), detourConfig.Settings)
2015-11-22 11:41:52 -05:00
if err != nil {
2016-01-18 06:24:33 -05:00
log.Error("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
2015-11-22 11:41:52 -05:00
}
}
2016-01-17 15:43:10 -05:00
routerConfig := pConfig.RouterConfig
2015-11-22 11:41:52 -05:00
if routerConfig != nil {
2016-01-17 10:20:49 -05:00
r, err := router.CreateRouter(routerConfig.Strategy, routerConfig.Settings)
2015-11-22 11:41:52 -05:00
if err != nil {
2016-01-18 06:24:33 -05:00
log.Error("Failed to create router: ", err)
2015-12-06 10:41:41 -05:00
return nil, BadConfiguration
2015-11-22 11:41:52 -05:00
}
vpoint.router = r
}
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-01-18 06:24:33 -05:00
log.Error("Invalid port ", this.port)
2015-12-06 10:41:41 -05:00
return BadConfiguration
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 {
2015-11-27 06:29:20 -05:00
err := this.ich.Listen(this.port)
2015-10-31 19:11:41 -04:00
if err != nil {
return err
2015-10-13 19:15:29 -04:00
}
2016-01-18 06:24:33 -05:00
log.Warning("Point server 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
2015-12-03 09:12:47 -05:00
// Dispatches a Packet to an OutboundConnection.
// The packet will be passed through the router (if configured), and then sent to an outbound
// connection with matching tag.
2015-12-10 17:55:39 -05:00
func (this *Point) DispatchToOutbound(context app.Context, packet v2net.Packet) ray.InboundRay {
2015-10-14 08:51:19 -04:00
direct := ray.NewRay()
2015-11-22 11:41:52 -05:00
dest := packet.Destination()
2016-01-05 15:54:23 -05:00
dispatcher := this.och
2015-11-27 06:29:20 -05:00
if this.router != nil {
2016-01-11 06:35:36 -05:00
if tag, err := this.router.TakeDetour(dest); err == nil {
if handler, found := this.odh[tag]; found {
2016-01-18 06:24:33 -05:00
log.Info("Point: Taking detour [", tag, "] for [", dest, "]", tag, dest)
2016-01-05 15:54:23 -05:00
dispatcher = handler
2015-11-22 11:41:52 -05:00
}
}
}
2016-01-05 15:54:23 -05:00
go this.FilterPacketAndDispatch(packet, direct, dispatcher)
2015-10-14 08:51:19 -04:00
return direct
2015-09-10 18:24:18 -04:00
}
2016-01-05 06:08:16 -05:00
func (this *Point) FilterPacketAndDispatch(packet v2net.Packet, link ray.OutboundRay, dispatcher proxy.OutboundConnectionHandler) {
// Filter empty packets
chunk := packet.Chunk()
moreChunks := packet.MoreChunks()
changed := false
for chunk == nil && moreChunks {
changed = true
chunk, moreChunks = <-link.OutboundInput()
}
if chunk == nil && !moreChunks {
2016-01-18 05:41:02 -05:00
log.Info("Point: No payload to dispatch, stopping dispatching now.")
2016-01-05 06:08:16 -05:00
close(link.OutboundOutput())
return
}
if changed {
packet = v2net.NewPacket(packet.Destination(), chunk, moreChunks)
}
dispatcher.Dispatch(packet, link)
}
2016-01-21 11:22:56 -05:00
func (this *Point) GetHandler(context app.Context, tag string) (proxy.InboundConnectionHandler, int) {
handler, found := this.taggedIdh[tag]
if !found {
return nil, 0
}
return handler.GetConnectionHandler()
}