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

202 lines
5.1 KiB
Go
Raw Normal View History

package socks
2015-09-07 08:49:40 -04:00
import (
"context"
2015-09-15 18:06:22 -04:00
"io"
2017-01-31 06:42:05 -05:00
"runtime"
2015-10-06 11:24:57 -04:00
"time"
2015-09-09 06:13:52 -04:00
2016-08-20 14:55:45 -04:00
"v2ray.com/core/app"
"v2ray.com/core/app/dispatcher"
"v2ray.com/core/app/log"
"v2ray.com/core/common"
2016-12-09 07:17:34 -05:00
"v2ray.com/core/common/buf"
2017-01-13 17:42:39 -05:00
"v2ray.com/core/common/net"
2017-01-07 15:57:24 -05:00
"v2ray.com/core/common/protocol"
2016-12-29 18:32:20 -05:00
"v2ray.com/core/common/signal"
2016-08-20 14:55:45 -04:00
"v2ray.com/core/proxy"
"v2ray.com/core/transport/internet"
"v2ray.com/core/transport/internet/udp"
2015-09-09 06:13:52 -04:00
)
2016-04-25 18:33:16 -04:00
// Server is a SOCKS 5 proxy server
type Server struct {
config *ServerConfig
2015-09-10 18:24:18 -04:00
}
2016-04-25 18:33:16 -04:00
// NewServer creates a new Server object.
func NewServer(ctx context.Context, config *ServerConfig) (*Server, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
2017-04-08 19:43:25 -04:00
return nil, newError("no space in context").AtWarning()
}
2016-07-23 05:09:49 -04:00
s := &Server{
config: config,
2015-09-16 10:27:36 -04:00
}
return s, nil
2015-09-07 08:49:40 -04:00
}
func (s *Server) Network() net.NetworkList {
2017-01-14 18:57:06 -05:00
list := net.NetworkList{
Network: []net.Network{net.Network_TCP},
}
if s.config.UdpEnabled {
2017-01-14 18:57:06 -05:00
list.Network = append(list.Network, net.Network_UDP)
}
return list
}
func (s *Server) Process(ctx context.Context, network net.Network, conn internet.Connection, dispatcher dispatcher.Interface) error {
switch network {
case net.Network_TCP:
return s.processTCP(ctx, conn, dispatcher)
case net.Network_UDP:
return s.handleUDPPayload(ctx, conn, dispatcher)
default:
2017-04-08 19:43:25 -04:00
return newError("unknown network: ", network)
}
}
func (s *Server) processTCP(ctx context.Context, conn internet.Connection, dispatcher dispatcher.Interface) error {
2017-01-31 10:49:59 -05:00
conn.SetReadDeadline(time.Now().Add(time.Second * 8))
2017-02-15 16:51:01 -05:00
reader := buf.NewBufferedReader(conn)
2017-02-09 16:49:38 -05:00
inboundDest, ok := proxy.InboundEntryPointFromContext(ctx)
if !ok {
2017-04-08 19:43:25 -04:00
return newError("inbound entry point not specified")
2017-02-09 16:49:38 -05:00
}
2017-01-03 18:43:13 -05:00
session := &ServerSession{
config: s.config,
port: inboundDest.Port,
2015-09-09 06:13:52 -04:00
}
request, err := session.Handshake(reader, conn)
2015-10-03 15:42:03 -04:00
if err != nil {
2017-02-09 16:49:38 -05:00
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Access(source, "", log.AccessRejected, err)
}
2017-04-08 19:43:25 -04:00
log.Trace(newError("failed to read request").Base(err))
return err
2015-10-03 18:21:06 -04:00
}
2017-01-31 10:49:59 -05:00
conn.SetReadDeadline(time.Time{})
2015-10-03 18:21:06 -04:00
2017-01-07 15:57:24 -05:00
if request.Command == protocol.RequestCommandTCP {
2017-01-03 18:43:13 -05:00
dest := request.Destination()
2017-04-08 19:43:25 -04:00
log.Trace(newError("TCP Connect request to ", dest))
2017-02-09 16:49:38 -05:00
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Access(source, dest, log.AccessAccepted, "")
}
2015-10-03 18:21:06 -04:00
return s.transport(ctx, reader, conn, dest, dispatcher)
2015-10-03 15:42:03 -04:00
}
2017-01-07 15:57:24 -05:00
if request.Command == protocol.RequestCommandUDP {
return s.handleUDP()
2016-08-14 11:08:01 -04:00
}
return nil
2015-10-03 15:42:03 -04:00
}
func (*Server) handleUDP() error {
2016-11-27 15:39:09 -05:00
// The TCP connection closes after v method returns. We need to wait until
2015-10-06 11:24:57 -04:00
// the client closes it.
// TODO: get notified from UDP part
2015-10-06 05:57:26 -04:00
<-time.After(5 * time.Minute)
return nil
2015-10-03 18:21:06 -04:00
}
func (v *Server) transport(ctx context.Context, reader io.Reader, writer io.Writer, dest net.Destination, dispatcher dispatcher.Interface) error {
2017-01-31 10:49:59 -05:00
timeout := time.Second * time.Duration(v.config.Timeout)
if timeout == 0 {
timeout = time.Minute * 2
}
2017-03-31 15:45:43 -04:00
ctx, timer := signal.CancelAfterInactivity(ctx, timeout)
2017-01-31 06:42:05 -05:00
ray, err := dispatcher.Dispatch(ctx, dest)
if err != nil {
return err
}
2015-09-10 18:24:18 -04:00
input := ray.InboundInput()
output := ray.InboundOutput()
2016-12-29 18:32:20 -05:00
requestDone := signal.ExecuteAsync(func() error {
defer input.Close()
2015-09-09 06:13:52 -04:00
2016-12-09 07:17:34 -05:00
v2reader := buf.NewReader(reader)
2017-01-31 06:42:05 -05:00
if err := buf.PipeUntilEOF(timer, v2reader, input); err != nil {
2017-04-08 19:43:25 -04:00
return newError("failed to transport all TCP request").Base(err)
2016-12-29 18:32:20 -05:00
}
return nil
})
responseDone := signal.ExecuteAsync(func() error {
v2writer := buf.NewWriter(writer)
2017-01-31 06:42:05 -05:00
if err := buf.PipeUntilEOF(timer, output, v2writer); err != nil {
2017-04-08 19:43:25 -04:00
return newError("failed to transport all TCP response").Base(err)
2016-11-21 18:17:49 -05:00
}
2016-12-29 18:32:20 -05:00
return nil
})
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
2017-01-10 08:22:42 -05:00
input.CloseError()
output.CloseError()
2017-04-08 19:43:25 -04:00
return newError("connection ends").Base(err)
}
2017-01-31 06:42:05 -05:00
runtime.KeepAlive(timer)
return nil
}
func (v *Server) handleUDPPayload(ctx context.Context, conn internet.Connection, dispatcher dispatcher.Interface) error {
udpServer := udp.NewDispatcher(dispatcher)
2017-02-09 16:49:38 -05:00
if source, ok := proxy.SourceFromContext(ctx); ok {
2017-04-08 19:43:25 -04:00
log.Trace(newError("client UDP connection from ", source))
2017-02-09 16:49:38 -05:00
}
reader := buf.NewReader(conn)
for {
payload, err := reader.Read()
if err != nil {
return err
}
request, data, err := DecodeUDPPacket(payload.Bytes())
if err != nil {
2017-04-08 19:43:25 -04:00
log.Trace(newError("failed to parse UDP request").Base(err))
continue
}
if len(data) == 0 {
continue
}
2017-04-08 19:43:25 -04:00
log.Trace(newError("send packet to ", request.Destination(), " with ", len(data), " bytes").AtDebug())
2017-02-09 16:49:38 -05:00
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Access(source, request.Destination, log.AccessAccepted, "")
}
dataBuf := buf.NewSmall()
dataBuf.Append(data)
udpServer.Dispatch(ctx, request.Destination(), dataBuf, func(payload *buf.Buffer) {
defer payload.Release()
2017-04-08 19:43:25 -04:00
log.Trace(newError("writing back UDP response with ", payload.Len(), " bytes").AtDebug())
udpMessage := EncodeUDPPacket(request, payload.Bytes())
defer udpMessage.Release()
conn.Write(udpMessage.Bytes())
})
2016-11-21 18:17:49 -05:00
}
2015-09-10 18:24:18 -04:00
}
2016-04-25 18:35:42 -04:00
func init() {
common.Must(common.RegisterConfig((*ServerConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return NewServer(ctx, config.(*ServerConfig))
}))
2016-06-14 16:54:08 -04:00
}