func (this *VMessOutboundHandler) Dispatch(target v2net.Destination, payload *alloc.Buffer, ray ray.OutboundRay) error { defer ray.OutboundInput().Release() defer ray.OutboundOutput().Close() var rec *protocol.ServerSpec var conn internet.Connection err := retry.Timed(5, 100).On(func() error { rec = this.serverPicker.PickServer() rawConn, err := internet.Dial(this.meta.Address, rec.Destination(), this.meta.StreamSettings) if err != nil { return err } conn = rawConn return nil }) if err != nil { log.Error("VMess|Outbound: Failed to find an available destination:", err) return err } log.Info("VMess|Outbound: Tunneling request to ", target, " via ", rec.Destination()) command := protocol.RequestCommandTCP if target.IsUDP() { command = protocol.RequestCommandUDP } request := &protocol.RequestHeader{ Version: encoding.Version, User: rec.PickUser(), Command: command, Address: target.Address(), Port: target.Port(), Option: protocol.RequestOptionChunkStream, } defer conn.Close() conn.SetReusable(true) if conn.Reusable() { // Conn reuse may be disabled on transportation layer request.Option.Set(protocol.RequestOptionConnectionReuse) } input := ray.OutboundInput() output := ray.OutboundOutput() var requestFinish, responseFinish sync.Mutex requestFinish.Lock() responseFinish.Lock() session := encoding.NewClientSession(protocol.DefaultIDHash) go this.handleRequest(session, conn, request, payload, input, &requestFinish) go this.handleResponse(session, conn, request, rec.Destination(), output, &responseFinish) requestFinish.Lock() responseFinish.Lock() return nil }
func (v *VMessOutboundHandler) Dispatch(target v2net.Destination, payload *buf.Buffer, ray ray.OutboundRay) { defer ray.OutboundInput().Release() defer ray.OutboundOutput().Close() var rec *protocol.ServerSpec var conn internet.Connection err := retry.ExponentialBackoff(5, 100).On(func() error { rec = v.serverPicker.PickServer() rawConn, err := internet.Dial(v.meta.Address, rec.Destination(), v.meta.GetDialerOptions()) if err != nil { return err } conn = rawConn return nil }) if err != nil { log.Warning("VMess|Outbound: Failed to find an available destination:", err) return } log.Info("VMess|Outbound: Tunneling request to ", target, " via ", rec.Destination()) command := protocol.RequestCommandTCP if target.Network == v2net.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) } account := rawAccount.(*vmess.InternalAccount) request.Security = account.Security defer conn.Close() conn.SetReusable(true) if conn.Reusable() { // Conn reuse may be disabled on transportation layer request.Option.Set(protocol.RequestOptionConnectionReuse) } input := ray.OutboundInput() output := ray.OutboundOutput() var requestFinish, responseFinish sync.Mutex requestFinish.Lock() responseFinish.Lock() session := encoding.NewClientSession(protocol.DefaultIDHash) go v.handleRequest(session, conn, request, payload, input, &requestFinish) go v.handleResponse(session, conn, request, rec.Destination(), output, &responseFinish) requestFinish.Lock() responseFinish.Lock() return }
// 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 }