func (v *VMessOutboundHandler) handleResponse(session *encoding.ClientSession, conn internet.Connection, request *protocol.RequestHeader, dest v2net.Destination, output buf.Writer, finish *sync.Mutex) { defer finish.Unlock() reader := bufio.NewReader(conn) defer reader.Release() header, err := session.DecodeResponseHeader(reader) if err != nil { conn.SetReusable(false) log.Warning("VMess|Outbound: Failed to read response from ", request.Destination(), ": ", err) return } v.handleCommand(dest, header.Command) conn.SetReusable(header.Option.Has(protocol.ResponseOptionConnectionReuse)) reader.SetCached(false) bodyReader := session.DecodeResponseBody(request, reader) defer bodyReader.Release() if err := buf.PipeUntilEOF(bodyReader, output); err != nil { conn.SetReusable(false) } return }
func (v *Server) handleConnection(connection internet.Connection) { defer connection.Close() timedReader := v2net.NewTimeOutReader(v.config.Timeout, connection) reader := bufio.NewReader(timedReader) defer reader.Release() writer := bufio.NewWriter(connection) defer writer.Release() auth, auth4, err := protocol.ReadAuthentication(reader) if err != nil && errors.Cause(err) != protocol.Socks4Downgrade { if errors.Cause(err) != io.EOF { log.Warning("Socks: failed to read authentication: ", err) } return } clientAddr := v2net.DestinationFromAddr(connection.RemoteAddr()) if err != nil && err == protocol.Socks4Downgrade { v.handleSocks4(clientAddr, reader, writer, auth4) } else { v.handleSocks5(clientAddr, reader, writer, auth) } }
func (s *Server) processTCP(ctx context.Context, conn internet.Connection) error { conn.SetReusable(false) timedReader := net.NewTimeOutReader(16 /* seconds, for handshake */, conn) reader := bufio.NewReader(timedReader) inboundDest := proxy.InboundDestinationFromContext(ctx) session := &ServerSession{ config: s.config, port: inboundDest.Port, } source := proxy.SourceFromContext(ctx) request, err := session.Handshake(reader, conn) if err != nil { log.Access(source, "", log.AccessRejected, err) log.Info("Socks|Server: Failed to read request: ", err) return err } if request.Command == protocol.RequestCommandTCP { dest := request.Destination() log.Info("Socks|Server: TCP Connect request to ", dest) log.Access(source, dest, log.AccessAccepted, "") timedReader.SetTimeOut(s.config.Timeout) ctx = proxy.ContextWithDestination(ctx, dest) return s.transport(ctx, reader, conn) } if request.Command == protocol.RequestCommandUDP { return s.handleUDP() } return nil }
func (v *VMessInboundHandler) Process(ctx context.Context, network net.Network, connection internet.Connection) error { connReader := net.NewTimeOutReader(8, connection) reader := bufio.NewReader(connReader) session := encoding.NewServerSession(v.clients) request, err := session.DecodeRequestHeader(reader) if err != nil { if errors.Cause(err) != io.EOF { log.Access(connection.RemoteAddr(), "", log.AccessRejected, err) log.Info("VMess|Inbound: Invalid request from ", connection.RemoteAddr(), ": ", err) } connection.SetReusable(false) return err } log.Access(connection.RemoteAddr(), request.Destination(), log.AccessAccepted, "") log.Info("VMess|Inbound: Received request for ", request.Destination()) connection.SetReusable(request.Option.Has(protocol.RequestOptionConnectionReuse)) ctx = proxy.ContextWithDestination(ctx, request.Destination()) ctx = protocol.ContextWithUser(ctx, request.User) ray := v.packetDispatcher.DispatchToOutbound(ctx) input := ray.InboundInput() output := ray.InboundOutput() userSettings := request.User.GetSettings() connReader.SetTimeOut(userSettings.PayloadReadTimeout) reader.SetBuffered(false) requestDone := signal.ExecuteAsync(func() error { return transferRequest(session, request, reader, input) }) writer := bufio.NewWriter(connection) response := &protocol.ResponseHeader{ Command: v.generateCommand(ctx, request), } if connection.Reusable() { response.Option.Set(protocol.ResponseOptionConnectionReuse) } responseDone := signal.ExecuteAsync(func() error { return transferResponse(session, request, response, output, writer) }) if err := signal.ErrorOrFinish2(requestDone, responseDone); err != nil { log.Info("VMess|Inbound: Connection ending with ", err) connection.SetReusable(false) input.CloseError() output.CloseError() return err } if err := writer.Flush(); err != nil { log.Info("VMess|Inbound: Failed to flush remain data: ", err) connection.SetReusable(false) return err } return nil }
func (s *Server) handleConnection(ctx context.Context, conn internet.Connection) error { conn.SetReusable(false) timedReader := net.NewTimeOutReader(16, conn) bufferedReader := bufio.NewReader(timedReader) request, bodyReader, err := ReadTCPSession(s.user, bufferedReader) if err != nil { log.Access(conn.RemoteAddr(), "", log.AccessRejected, err) log.Info("Shadowsocks|Server: Failed to create request from: ", conn.RemoteAddr(), ": ", err) return err } bufferedReader.SetBuffered(false) userSettings := s.user.GetSettings() timedReader.SetTimeOut(userSettings.PayloadReadTimeout) dest := request.Destination() log.Access(conn.RemoteAddr(), dest, log.AccessAccepted, "") log.Info("Shadowsocks|Server: Tunnelling request to ", dest) ctx = proxy.ContextWithDestination(ctx, dest) ctx = protocol.ContextWithUser(ctx, request.User) ray := s.packetDispatcher.DispatchToOutbound(ctx) requestDone := signal.ExecuteAsync(func() error { bufferedWriter := bufio.NewWriter(conn) responseWriter, err := WriteTCPResponse(request, bufferedWriter) if err != nil { log.Warning("Shadowsocks|Server: Failed to write response: ", err) return err } payload, err := ray.InboundOutput().Read() if err != nil { return err } if err := responseWriter.Write(payload); err != nil { return err } payload.Release() if err := bufferedWriter.SetBuffered(false); err != nil { return err } if err := buf.PipeUntilEOF(ray.InboundOutput(), responseWriter); err != nil { log.Info("Shadowsocks|Server: Failed to transport all TCP response: ", err) return err } return nil }) responseDone := signal.ExecuteAsync(func() error { defer ray.InboundInput().Close() if err := buf.PipeUntilEOF(bodyReader, ray.InboundInput()); err != nil { log.Info("Shadowsocks|Server: Failed to transport all TCP request: ", err) return err } return nil }) if err := signal.ErrorOrFinish2(requestDone, responseDone); err != nil { log.Info("Shadowsocks|Server: Connection ends with ", err) ray.InboundInput().CloseError() ray.InboundOutput().CloseError() return err } return nil }
// Dispatch implements OutboundHandler.Dispatch(). func (v *VMessOutboundHandler) Process(ctx context.Context, outboundRay ray.OutboundRay) error { var rec *protocol.ServerSpec var conn internet.Connection dialer := proxy.DialerFromContext(ctx) err := retry.ExponentialBackoff(5, 100).On(func() error { rec = v.serverPicker.PickServer() rawConn, err := dialer.Dial(ctx, rec.Destination()) if err != nil { return err } conn = rawConn return nil }) if err != nil { log.Warning("VMess|Outbound: Failed to find an available destination:", err) return err } defer conn.Close() target := proxy.DestinationFromContext(ctx) log.Info("VMess|Outbound: Tunneling request to ", target, " via ", rec.Destination()) command := protocol.RequestCommandTCP if target.Network == net.Network_UDP { command = protocol.RequestCommandUDP } request := &protocol.RequestHeader{ Version: encoding.Version, User: rec.PickUser(), Command: command, Address: target.Address, Port: target.Port, Option: protocol.RequestOptionChunkStream, } rawAccount, err := request.User.GetTypedAccount() if err != nil { log.Warning("VMess|Outbound: Failed to get user account: ", err) return err } account := rawAccount.(*vmess.InternalAccount) request.Security = account.Security conn.SetReusable(true) if conn.Reusable() { // Conn reuse may be disabled on transportation layer request.Option.Set(protocol.RequestOptionConnectionReuse) } input := outboundRay.OutboundInput() output := outboundRay.OutboundOutput() session := encoding.NewClientSession(protocol.DefaultIDHash) requestDone := signal.ExecuteAsync(func() error { writer := bufio.NewWriter(conn) session.EncodeRequestHeader(request, writer) bodyWriter := session.EncodeRequestBody(request, writer) firstPayload, err := input.ReadTimeout(time.Millisecond * 500) if err != nil && err != ray.ErrReadTimeout { return errors.Base(err).Message("VMess|Outbound: Failed to get first payload.") } if !firstPayload.IsEmpty() { if err := bodyWriter.Write(firstPayload); err != nil { return errors.Base(err).Message("VMess|Outbound: Failed to write first payload.") } firstPayload.Release() } writer.SetBuffered(false) if err := buf.PipeUntilEOF(input, bodyWriter); err != nil { return err } if request.Option.Has(protocol.RequestOptionChunkStream) { if err := bodyWriter.Write(buf.NewLocal(8)); err != nil { return err } } return nil }) responseDone := signal.ExecuteAsync(func() error { defer output.Close() reader := bufio.NewReader(conn) header, err := session.DecodeResponseHeader(reader) if err != nil { return err } v.handleCommand(rec.Destination(), header.Command) conn.SetReusable(header.Option.Has(protocol.ResponseOptionConnectionReuse)) reader.SetBuffered(false) bodyReader := session.DecodeResponseBody(request, reader) if err := buf.PipeUntilEOF(bodyReader, output); err != nil { return err } return nil }) if err := signal.ErrorOrFinish2(requestDone, responseDone); err != nil { log.Info("VMess|Outbound: Connection ending with ", err) conn.SetReusable(false) input.CloseError() output.CloseError() return err } return nil }
func (v *Server) handleConnection(conn internet.Connection) { defer conn.Close() conn.SetReusable(false) timedReader := v2net.NewTimeOutReader(16, conn) defer timedReader.Release() bufferedReader := bufio.NewReader(timedReader) defer bufferedReader.Release() request, bodyReader, err := ReadTCPSession(v.user, bufferedReader) if err != nil { log.Access(conn.RemoteAddr(), "", log.AccessRejected, err) log.Info("Shadowsocks|Server: Failed to create request from: ", conn.RemoteAddr(), ": ", err) return } defer bodyReader.Release() bufferedReader.SetCached(false) userSettings := v.user.GetSettings() timedReader.SetTimeOut(userSettings.PayloadReadTimeout) dest := request.Destination() log.Access(conn.RemoteAddr(), dest, log.AccessAccepted, "") log.Info("Shadowsocks|Server: Tunnelling request to ", dest) ray := v.packetDispatcher.DispatchToOutbound(&proxy.SessionInfo{ Source: v2net.DestinationFromAddr(conn.RemoteAddr()), Destination: dest, User: request.User, Inbound: v.meta, }) defer ray.InboundOutput().Release() var writeFinish sync.Mutex writeFinish.Lock() go func() { defer writeFinish.Unlock() bufferedWriter := bufio.NewWriter(conn) defer bufferedWriter.Release() responseWriter, err := WriteTCPResponse(request, bufferedWriter) if err != nil { log.Warning("Shadowsocks|Server: Failed to write response: ", err) return } defer responseWriter.Release() if payload, err := ray.InboundOutput().Read(); err == nil { responseWriter.Write(payload) bufferedWriter.SetCached(false) if err := buf.PipeUntilEOF(ray.InboundOutput(), responseWriter); err != nil { log.Info("Shadowsocks|Server: Failed to transport all TCP response: ", err) } } }() if err := buf.PipeUntilEOF(bodyReader, ray.InboundInput()); err != nil { log.Info("Shadowsocks|Server: Failed to transport all TCP request: ", err) } ray.InboundInput().Close() writeFinish.Lock() }