1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-10-31 00:08:08 -04:00
v2fly/proxy/vmess/vmessin.go

161 lines
4.5 KiB
Go
Raw Normal View History

2015-09-10 18:24:18 -04:00
package vmess
import (
"crypto/md5"
"io"
"net"
2015-09-23 08:14:53 -04:00
"sync"
2015-09-10 18:24:18 -04:00
2015-10-14 08:51:19 -04:00
"github.com/v2ray/v2ray-core/app"
"github.com/v2ray/v2ray-core/common/alloc"
v2io "github.com/v2ray/v2ray-core/common/io"
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-15 07:42:43 -04:00
"github.com/v2ray/v2ray-core/common/retry"
"github.com/v2ray/v2ray-core/proxy/common/connhandler"
2015-10-16 06:03:22 -04:00
"github.com/v2ray/v2ray-core/proxy/vmess/config"
2015-09-19 18:11:14 -04:00
"github.com/v2ray/v2ray-core/proxy/vmess/protocol"
2015-09-19 18:50:21 -04:00
"github.com/v2ray/v2ray-core/proxy/vmess/protocol/user"
2015-09-10 18:24:18 -04:00
)
type VMessInboundHandler struct {
2015-10-14 08:51:19 -04:00
dispatcher app.PacketDispatcher
2015-10-03 05:34:01 -04:00
clients user.UserSet
accepting bool
udpEnabled bool
2015-09-10 18:24:18 -04:00
}
2015-10-14 08:51:19 -04:00
func NewVMessInboundHandler(dispatcher app.PacketDispatcher, clients user.UserSet, udpEnabled bool) *VMessInboundHandler {
2015-09-16 10:27:36 -04:00
return &VMessInboundHandler{
2015-10-14 08:51:19 -04:00
dispatcher: dispatcher,
2015-10-03 05:34:01 -04:00
clients: clients,
udpEnabled: udpEnabled,
2015-09-16 10:27:36 -04:00
}
2015-09-10 18:24:18 -04:00
}
2015-09-12 14:36:21 -04:00
func (handler *VMessInboundHandler) Listen(port uint16) error {
2015-10-07 19:39:50 -04:00
listener, err := net.ListenTCP("tcp", &net.TCPAddr{
IP: []byte{0, 0, 0, 0},
Port: int(port),
Zone: "",
})
2015-09-10 18:24:18 -04:00
if err != nil {
log.Error("Unable to listen tcp port %d: %v", port, err)
return err
2015-09-10 18:24:18 -04:00
}
handler.accepting = true
go handler.AcceptConnections(listener)
2015-10-03 05:34:01 -04:00
if handler.udpEnabled {
handler.ListenUDP(port)
}
2015-09-10 18:24:18 -04:00
return nil
}
2015-10-07 19:39:50 -04:00
func (handler *VMessInboundHandler) AcceptConnections(listener *net.TCPListener) error {
2015-09-10 18:24:18 -04:00
for handler.accepting {
2015-10-15 07:42:43 -04:00
retry.Timed(100 /* times */, 100 /* ms */).On(func() error {
connection, err := listener.AcceptTCP()
if err != nil {
log.Error("Failed to accpet connection: %s", err.Error())
return err
}
go handler.HandleConnection(connection)
return nil
})
2015-09-10 18:24:18 -04:00
}
return nil
}
2015-10-07 19:39:50 -04:00
func (handler *VMessInboundHandler) HandleConnection(connection *net.TCPConn) error {
2015-09-10 18:24:18 -04:00
defer connection.Close()
2015-09-14 12:19:17 -04:00
connReader := v2net.NewTimeOutReader(16, connection)
2015-09-24 08:51:19 -04:00
requestReader := protocol.NewVMessRequestReader(handler.clients)
2015-09-10 18:24:18 -04:00
2015-09-24 08:51:19 -04:00
request, err := requestReader.Read(connReader)
2015-09-10 18:24:18 -04:00
if err != nil {
2015-10-09 11:49:59 -04:00
log.Access(connection.RemoteAddr().String(), "", log.AccessRejected, err.Error())
2015-09-18 07:19:12 -04:00
log.Warning("VMessIn: Invalid request from (%s): %v", connection.RemoteAddr().String(), err)
2015-09-10 18:24:18 -04:00
return err
}
2015-10-09 11:43:27 -04:00
log.Access(connection.RemoteAddr().String(), request.Address.String(), log.AccessAccepted, "")
2015-09-18 07:19:12 -04:00
log.Debug("VMessIn: Received request for %s", request.Address.String())
2015-09-10 18:24:18 -04:00
2015-10-14 08:51:19 -04:00
ray := handler.dispatcher.DispatchToOutbound(v2net.NewPacket(request.Destination(), nil, true))
input := ray.InboundInput()
output := ray.InboundOutput()
2015-09-23 08:14:53 -04:00
var readFinish, writeFinish sync.Mutex
readFinish.Lock()
writeFinish.Lock()
2015-09-10 18:24:18 -04:00
2015-10-31 04:39:45 -04:00
userSettings := config.GetUserSettings(request.User.Level())
connReader.SetTimeOut(userSettings.PayloadReadTimeout)
2015-09-24 08:51:19 -04:00
go handleInput(request, connReader, input, &readFinish)
2015-10-07 08:58:31 -04:00
responseKey := md5.Sum(request.RequestKey)
responseIV := md5.Sum(request.RequestIV)
2015-09-10 18:24:18 -04:00
responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection)
if err != nil {
log.Error("VMessIn: Failed to create encrypt writer: %v", err)
return err
2015-09-10 18:24:18 -04:00
}
// Optimize for small response packet
2015-10-10 10:50:19 -04:00
buffer := alloc.NewLargeBuffer().Clear()
2015-10-08 11:41:38 -04:00
buffer.Append(request.ResponseHeader)
2015-09-18 06:31:42 -04:00
if data, open := <-output; open {
2015-10-08 11:41:38 -04:00
buffer.Append(data.Value)
data.Release()
responseWriter.Write(buffer.Value)
buffer.Release()
2015-09-23 11:13:50 -04:00
go handleOutput(request, responseWriter, output, &writeFinish)
2015-09-23 08:14:53 -04:00
writeFinish.Lock()
}
2015-09-18 06:31:42 -04:00
2015-10-07 19:39:50 -04:00
connection.CloseWrite()
2015-09-23 08:14:53 -04:00
readFinish.Lock()
2015-09-10 18:24:18 -04:00
return nil
}
func handleInput(request *protocol.VMessRequest, reader io.Reader, input chan<- *alloc.Buffer, finish *sync.Mutex) {
defer close(input)
2015-09-23 08:14:53 -04:00
defer finish.Unlock()
2015-10-07 08:58:31 -04:00
requestReader, err := v2io.NewAesDecryptReader(request.RequestKey, request.RequestIV, reader)
if err != nil {
2015-09-18 07:19:12 -04:00
log.Error("VMessIn: Failed to create decrypt reader: %v", err)
return
}
v2net.ReaderToChan(input, requestReader)
2015-09-10 18:24:18 -04:00
}
func handleOutput(request *protocol.VMessRequest, writer io.Writer, output <-chan *alloc.Buffer, finish *sync.Mutex) {
2015-09-13 14:01:50 -04:00
v2net.ChanToWriter(writer, output)
2015-09-23 08:14:53 -04:00
finish.Unlock()
2015-09-10 18:24:18 -04:00
}
type VMessInboundHandlerFactory struct {
}
func (factory *VMessInboundHandlerFactory) Create(dispatcher app.PacketDispatcher, rawConfig interface{}) (connhandler.InboundConnectionHandler, error) {
2015-10-16 06:03:22 -04:00
config := rawConfig.(config.Inbound)
2015-10-06 17:11:08 -04:00
2015-09-19 18:11:14 -04:00
allowedClients := user.NewTimedUserSet()
2015-10-16 06:03:22 -04:00
for _, user := range config.AllowedUsers() {
2015-09-12 05:51:42 -04:00
allowedClients.AddUser(user)
}
2015-10-03 05:34:01 -04:00
2015-10-16 06:03:22 -04:00
return NewVMessInboundHandler(dispatcher, allowedClients, config.UDPEnabled()), nil
2015-09-12 14:36:21 -04:00
}
func init() {
connhandler.RegisterInboundConnectionHandlerFactory("vmess", &VMessInboundHandlerFactory{})
2015-09-10 18:24:18 -04:00
}