285 lines
7.6 KiB
Go
Raw Normal View History

package inbound
2015-09-11 00:24:18 +02:00
import (
2017-01-13 23:42:39 +01:00
"context"
2016-05-31 00:21:41 +02:00
"io"
2015-09-23 14:14:53 +02:00
"sync"
2015-09-11 00:24:18 +02:00
2017-01-31 12:42:05 +01:00
"runtime"
"time"
2016-08-20 20:55:45 +02:00
"v2ray.com/core/app"
"v2ray.com/core/app/dispatcher"
"v2ray.com/core/app/log"
2016-08-20 20:55:45 +02:00
"v2ray.com/core/app/proxyman"
"v2ray.com/core/common"
2016-12-09 11:35:27 +01:00
"v2ray.com/core/common/buf"
2016-12-09 13:17:34 +01:00
"v2ray.com/core/common/bufio"
2016-12-04 09:10:47 +01:00
"v2ray.com/core/common/errors"
2017-01-13 23:42:39 +01:00
"v2ray.com/core/common/net"
2016-08-20 20:55:45 +02:00
"v2ray.com/core/common/protocol"
2016-12-15 11:51:09 +01:00
"v2ray.com/core/common/serial"
2016-12-29 22:17:12 +01:00
"v2ray.com/core/common/signal"
2016-08-20 20:55:45 +02:00
"v2ray.com/core/common/uuid"
"v2ray.com/core/proxy/vmess"
"v2ray.com/core/proxy/vmess/encoding"
"v2ray.com/core/transport/internet"
2016-12-28 23:42:32 +01:00
"v2ray.com/core/transport/ray"
2015-09-11 00:24:18 +02:00
)
2016-02-25 14:38:41 +01:00
type userByEmail struct {
sync.RWMutex
2016-05-07 20:26:29 +02:00
cache map[string]*protocol.User
2016-09-18 00:41:21 +02:00
defaultLevel uint32
2016-02-25 14:38:41 +01:00
defaultAlterIDs uint16
}
2016-05-07 20:26:29 +02:00
func NewUserByEmail(users []*protocol.User, config *DefaultConfig) *userByEmail {
cache := make(map[string]*protocol.User)
2016-02-25 14:38:41 +01:00
for _, user := range users {
cache[user.Email] = user
}
return &userByEmail{
cache: cache,
defaultLevel: config.Level,
2016-09-24 23:11:58 +02:00
defaultAlterIDs: uint16(config.AlterId),
2016-02-25 14:38:41 +01:00
}
}
2016-11-27 21:39:09 +01:00
func (v *userByEmail) Get(email string) (*protocol.User, bool) {
2016-05-07 20:26:29 +02:00
var user *protocol.User
2016-02-25 14:38:41 +01:00
var found bool
2016-11-27 21:39:09 +01:00
v.RLock()
user, found = v.cache[email]
v.RUnlock()
2016-02-25 14:38:41 +01:00
if !found {
2016-11-27 21:39:09 +01:00
v.Lock()
user, found = v.cache[email]
2016-02-25 14:38:41 +01:00
if !found {
2016-10-12 18:43:55 +02:00
account := &vmess.Account{
2016-09-18 00:41:21 +02:00
Id: uuid.New().String(),
2016-11-27 21:39:09 +01:00
AlterId: uint32(v.defaultAlterIDs),
2016-09-18 00:41:21 +02:00
}
user = &protocol.User{
2016-11-27 21:39:09 +01:00
Level: v.defaultLevel,
2016-09-18 00:41:21 +02:00
Email: email,
2016-12-15 11:51:09 +01:00
Account: serial.ToTypedMessage(account),
2016-05-28 13:44:11 +02:00
}
2016-11-27 21:39:09 +01:00
v.cache[email] = user
2016-02-25 14:38:41 +01:00
}
2016-11-27 21:39:09 +01:00
v.Unlock()
2016-02-25 14:38:41 +01:00
}
return user, found
}
// Inbound connection handler that handles messages in VMess format.
2015-09-11 00:24:18 +02:00
type VMessInboundHandler struct {
2016-01-31 17:01:28 +01:00
inboundHandlerManager proxyman.InboundHandlerManager
2016-05-07 20:26:29 +02:00
clients protocol.UserValidator
2016-02-25 14:38:41 +01:00
usersByEmail *userByEmail
2016-06-01 22:45:12 +02:00
detours *DetourConfig
2017-02-12 16:53:23 +01:00
sessionHistory *encoding.SessionHistory
2015-09-11 00:24:18 +02:00
}
func New(ctx context.Context, config *Config) (*VMessInboundHandler, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("VMess|Inbound: No space in context.")
}
2017-01-29 12:58:52 +01:00
allowedClients := vmess.NewTimedUserValidator(ctx, protocol.DefaultIDHash)
for _, user := range config.User {
allowedClients.Add(user)
}
handler := &VMessInboundHandler{
2017-02-12 16:53:23 +01:00
clients: allowedClients,
detours: config.Detour,
usersByEmail: NewUserByEmail(config.User, config.GetDefaultValue()),
sessionHistory: encoding.NewSessionHistory(ctx),
}
space.OnInitialize(func() error {
handler.inboundHandlerManager = proxyman.InboundHandlerManagerFromSpace(space)
if handler.inboundHandlerManager == nil {
return errors.New("VMess|Inbound: InboundHandlerManager is not found is space.")
}
return nil
})
return handler, nil
}
func (*VMessInboundHandler) Network() net.NetworkList {
2017-01-15 00:57:06 +01:00
return net.NetworkList{
Network: []net.Network{net.Network_TCP},
}
}
2016-11-27 21:39:09 +01:00
func (v *VMessInboundHandler) GetUser(email string) *protocol.User {
user, existing := v.usersByEmail.Get(email)
2016-02-25 14:38:41 +01:00
if !existing {
2016-11-27 21:39:09 +01:00
v.clients.Add(user)
2016-02-25 14:38:41 +01:00
}
return user
2016-01-09 00:10:57 +01:00
}
2017-01-31 12:42:05 +01:00
func transferRequest(timer *signal.ActivityTimer, session *encoding.ServerSession, request *protocol.RequestHeader, input io.Reader, output ray.OutputStream) error {
2016-12-29 22:17:12 +01:00
defer output.Close()
bodyReader := session.DecodeRequestBody(request, input)
2017-01-31 12:42:05 +01:00
if err := buf.PipeUntilEOF(timer, bodyReader, output); err != nil {
2016-12-29 22:17:12 +01:00
return err
}
return nil
}
2017-01-31 12:42:05 +01:00
func transferResponse(timer *signal.ActivityTimer, session *encoding.ServerSession, request *protocol.RequestHeader, response *protocol.ResponseHeader, input ray.InputStream, output io.Writer) error {
2016-12-29 22:17:12 +01:00
session.EncodeResponseHeader(response, output)
bodyWriter := session.EncodeResponseBody(request, output)
// Optimize for small response packet
2017-01-06 11:59:51 +01:00
data, err := input.Read()
if err != nil {
return err
}
2016-12-29 22:17:12 +01:00
2017-01-06 11:59:51 +01:00
if err := bodyWriter.Write(data); err != nil {
return err
}
data.Release()
2016-12-29 22:17:12 +01:00
2017-01-06 11:59:51 +01:00
if bufferedWriter, ok := output.(*bufio.BufferedWriter); ok {
if err := bufferedWriter.SetBuffered(false); err != nil {
2016-12-29 22:17:12 +01:00
return err
}
}
2017-01-31 12:42:05 +01:00
if err := buf.PipeUntilEOF(timer, input, bodyWriter); err != nil {
2017-01-06 11:59:51 +01:00
return err
}
2016-12-29 22:17:12 +01:00
if request.Option.Has(protocol.RequestOptionChunkStream) {
if err := bodyWriter.Write(buf.NewLocal(8)); err != nil {
return err
}
}
return nil
}
func (v *VMessInboundHandler) Process(ctx context.Context, network net.Network, connection internet.Connection, dispatcher dispatcher.Interface) error {
2017-01-31 16:49:59 +01:00
connection.SetReadDeadline(time.Now().Add(time.Second * 8))
reader := bufio.NewReader(connection)
2017-02-12 16:53:23 +01:00
session := encoding.NewServerSession(v.clients, v.sessionHistory)
2016-02-27 17:28:21 +01:00
request, err := session.DecodeRequestHeader(reader)
2015-09-11 00:24:18 +02:00
if err != nil {
2016-12-04 09:10:47 +01:00
if errors.Cause(err) != io.EOF {
2016-05-31 00:21:41 +02:00
log.Access(connection.RemoteAddr(), "", log.AccessRejected, err)
2016-12-30 00:32:20 +01:00
log.Info("VMess|Inbound: Invalid request from ", connection.RemoteAddr(), ": ", err)
2016-05-31 00:21:41 +02:00
}
2016-06-06 01:20:20 +02:00
connection.SetReusable(false)
return err
2015-09-11 00:24:18 +02:00
}
2016-05-24 22:41:51 +02:00
log.Access(connection.RemoteAddr(), request.Destination(), log.AccessAccepted, "")
2016-12-30 00:32:20 +01:00
log.Info("VMess|Inbound: Received request for ", request.Destination())
2015-09-11 00:24:18 +02:00
2017-01-31 16:49:59 +01:00
connection.SetReadDeadline(time.Time{})
2016-06-14 22:54:08 +02:00
connection.SetReusable(request.Option.Has(protocol.RequestOptionConnectionReuse))
2017-01-31 16:49:59 +01:00
userSettings := request.User.GetSettings()
2016-05-31 00:21:41 +02:00
ctx = protocol.ContextWithUser(ctx, request.User)
2017-01-31 12:42:05 +01:00
ctx, cancel := context.WithCancel(ctx)
2017-01-31 17:46:39 +01:00
timer := signal.CancelAfterInactivity(ctx, cancel, userSettings.PayloadTimeout)
ray, err := dispatcher.Dispatch(ctx, request.Destination())
if err != nil {
return err
}
input := ray.InboundInput()
output := ray.InboundOutput()
2016-05-07 09:53:15 +02:00
2016-12-27 21:41:44 +01:00
reader.SetBuffered(false)
2016-06-02 21:34:25 +02:00
2016-12-29 22:17:12 +01:00
requestDone := signal.ExecuteAsync(func() error {
2017-01-31 12:42:05 +01:00
return transferRequest(timer, session, request, reader, input)
2016-12-28 23:42:32 +01:00
})
2016-12-09 13:17:34 +01:00
writer := bufio.NewWriter(connection)
2016-05-07 20:26:29 +02:00
response := &protocol.ResponseHeader{
Command: v.generateCommand(ctx, request),
2016-02-27 17:28:21 +01:00
}
2015-11-03 21:26:16 +01:00
2016-06-14 22:54:08 +02:00
if connection.Reusable() {
2016-06-02 21:34:25 +02:00
response.Option.Set(protocol.ResponseOptionConnectionReuse)
}
2016-12-29 22:17:12 +01:00
responseDone := signal.ExecuteAsync(func() error {
2017-01-31 12:42:05 +01:00
return transferResponse(timer, session, request, response, output, writer)
2016-12-28 23:42:32 +01:00
})
2016-05-12 17:20:07 -07:00
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
2016-12-30 00:32:20 +01:00
log.Info("VMess|Inbound: Connection ending with ", err)
2016-12-28 23:42:32 +01:00
connection.SetReusable(false)
2017-01-10 14:22:42 +01:00
input.CloseError()
output.CloseError()
return err
2016-06-11 01:37:33 +02:00
}
2015-09-18 12:31:42 +02:00
2016-12-29 22:17:12 +01:00
if err := writer.Flush(); err != nil {
2016-12-30 00:32:20 +01:00
log.Info("VMess|Inbound: Failed to flush remain data: ", err)
2016-12-28 23:42:32 +01:00
connection.SetReusable(false)
return err
2016-12-28 23:42:32 +01:00
}
2017-01-31 12:42:05 +01:00
runtime.KeepAlive(timer)
return nil
}
func (v *VMessInboundHandler) generateCommand(ctx context.Context, request *protocol.RequestHeader) protocol.ResponseCommand {
if v.detours != nil {
tag := v.detours.To
if v.inboundHandlerManager != nil {
handler, err := v.inboundHandlerManager.GetHandler(ctx, tag)
if err != nil {
log.Warning("VMess|Inbound: Failed to get detour handler: ", tag, err)
return nil
}
proxyHandler, port, availableMin := handler.GetRandomInboundProxy()
inboundHandler, ok := proxyHandler.(*VMessInboundHandler)
if ok && inboundHandler != nil {
if availableMin > 255 {
availableMin = 255
}
log.Info("VMessIn: Pick detour handler for port ", port, " for ", availableMin, " minutes.")
user := inboundHandler.GetUser(request.User.Email)
if user == nil {
return nil
}
account, _ := user.GetTypedAccount()
return &protocol.CommandSwitchAccount{
Port: port,
ID: account.(*vmess.InternalAccount).ID.UUID(),
AlterIds: uint16(len(account.(*vmess.InternalAccount).AlterIDs)),
Level: user.Level,
ValidMin: byte(availableMin),
}
}
}
}
return nil
2015-09-11 00:24:18 +02:00
}
2016-06-14 22:54:08 +02:00
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return New(ctx, config.(*Config))
}))
2015-09-11 00:24:18 +02:00
}