Enum CtrlMsg 

pub(crate) enum CtrlMsg {
    Create {
        recv_created: Receiver<CreateResponse>,
        handshake: CircuitHandshake,
        settings: HopSettings,
        done: Sender<Result<()>>,
    },
    ExtendNtor {
        peer_id: OwnedChanTarget,
        public_key: NtorPublicKey,
        linkspecs: Vec<EncodedLinkSpec>,
        settings: HopSettings,
        done: Sender<Result<()>>,
    },
    ExtendNtorV3 {
        peer_id: OwnedChanTarget,
        public_key: NtorV3PublicKey,
        linkspecs: Vec<EncodedLinkSpec>,
        settings: HopSettings,
        done: Sender<Result<()>>,
    },
    BeginStream {
        hop: TargetHop,
        message: AnyRelayMsg,
        sender: StreamQueueSender,
        rx: Receiver<AnyRelayMsg, MpscSpec>,
        rate_limit_notifier: Sender<StreamRateLimit>,
        drain_rate_requester: NotifySender<DrainRateRequest>,
        done: Sender<Result<(StreamId, HopLocation, RelayCellFormat)>>,
        cmd_checker: Box<dyn CmdChecker + Send + 'static>,
    },
    ClosePendingStream {
        hop: HopLocation,
        stream_id: StreamId,
        message: CloseStreamBehavior,
        done: Sender<Result<()>>,
    },
    SendMsg {
        hop: TargetHop,
        msg: AnyRelayMsg,
        sender: Sender<Result<()>>,
    },
    SendMsgAndInstallHandler {
        msg: Option<AnyRelayMsgOuter>,
        handler: Option<Box<dyn MetaCellHandler + Send + 'static>>,
        sender: Sender<Result<()>>,
    },
    FlowCtrlUpdate {
        msg: FlowCtrlMsg,
        stream_id: StreamId,
        hop: HopLocation,
    },
    FirstHopClockSkew {
        answer: Sender<Result<ClockSkew, Bug>>,
    },
    LinkCircuits {
        circuits: Vec<Circuit>,
        answer: Sender<Result<Vec<Result<(), ConfluxHandshakeError>>>>,
    },
}

A message telling the reactor to do something.

For each CtrlMsg, the reactor will send a cell on the underlying channel.

The difference between this and CtrlCmd is that CtrlMsgs cause the reactor to send cells on the reactor’s chan_sender, whereas CtrlCmd do not.

Variants

Create

Create the first hop of this circuit.

Fields

recv_created: Receiver<CreateResponse>

A oneshot channel on which we’ll receive the creation response.

handshake: CircuitHandshake

The handshake type to use for the first hop.

settings: HopSettings

Other parameters relevant for circuit creation.

done: Sender<Result<()>>

Oneshot channel to notify on completion.

ExtendNtor

Extend a circuit by one hop, using the ntor handshake.

Fields

peer_id: OwnedChanTarget

The peer that we’re extending to.

Used to extend our record of the circuit’s path.

public_key: NtorPublicKey

The handshake type to use for this hop.

linkspecs: Vec<EncodedLinkSpec>

Information about how to connect to the relay we’re extending to.

settings: HopSettings

Other parameters we are negotiating.

done: Sender<Result<()>>

Oneshot channel to notify on completion.

ExtendNtorV3

Extend a circuit by one hop, using the ntorv3 handshake.

Fields

peer_id: OwnedChanTarget

The peer that we’re extending to.

Used to extend our record of the circuit’s path.

public_key: NtorV3PublicKey

The handshake type to use for this hop.

linkspecs: Vec<EncodedLinkSpec>

Information about how to connect to the relay we’re extending to.

settings: HopSettings

Other parameters we are negotiating.

done: Sender<Result<()>>

Oneshot channel to notify on completion.

BeginStream

Begin a stream with the provided hop in this circuit.

Allocates a stream ID, and sends the provided message to that hop.

Fields

hop: TargetHop

The hop number to begin the stream with.

message: AnyRelayMsg

The message to send.

sender: StreamQueueSender

A channel to send messages on this stream down.

This sender shouldn’t ever block, because we use congestion control and only send SENDME cells once we’ve read enough out of the other end. If it does block, we can assume someone is trying to send us more cells than they should, and abort the stream.

rx: Receiver<AnyRelayMsg, MpscSpec>

A channel to receive messages to send on this stream from.

rate_limit_notifier: Sender<StreamRateLimit>

A Stream that provides updates to the rate limit for sending data.

drain_rate_requester: NotifySender<DrainRateRequest>

Notifies the stream reader when it should send a new drain rate.

done: Sender<Result<(StreamId, HopLocation, RelayCellFormat)>>

Oneshot channel to notify on completion, with the allocated stream ID.

cmd_checker: Box<dyn CmdChecker + Send + 'static>

A CmdChecker to keep track of which message types are acceptable.

ClosePendingStream

Close the specified pending incoming stream, sending the provided END message.

A stream is said to be pending if the message for initiating the stream was received but not has not been responded to yet.

This should be used by responders for closing pending incoming streams initiated by the other party on the circuit.

Fields

hop: HopLocation

The hop number the stream is on.

stream_id: StreamId

The stream ID to send the END for.

message: CloseStreamBehavior

The END message to send, if any.

done: Sender<Result<()>>

Oneshot channel to notify on completion.

SendMsg

Send a given control message on this circuit.

Fields

hop: TargetHop

The hop to receive this message.

msg: AnyRelayMsg

The message to send.

sender: Sender<Result<()>>

A sender that we use to tell the caller that the message was sent and the handler installed.

SendMsgAndInstallHandler

Send a given control message on this circuit, and install a control-message handler to receive responses.

Fields

msg: Option<AnyRelayMsgOuter>

The message to send, if any

handler: Option<Box<dyn MetaCellHandler + Send + 'static>>

A message handler to install.

If this is None, there must already be a message handler installed

sender: Sender<Result<()>>

A sender that we use to tell the caller that the message was sent and the handler installed.

FlowCtrlUpdate

Inform the reactor that there’s a flow control update for a given stream.

The reactor will decide how to handle this update depending on the type of flow control and the current state of the stream.

Fields

msg: FlowCtrlMsg

The type of flow control update, and any associated metadata.

stream_id: StreamId

The stream ID that the update is for.

hop: HopLocation

The hop that the stream is on.

FirstHopClockSkew

Get the clock skew claimed by the first hop of the circuit.

Fields

answer: Sender<Result<ClockSkew, Bug>>

Oneshot channel to return the clock skew.

LinkCircuits

Link the specified circuits into the current tunnel, to form a multi-path tunnel.

Fields

circuits: Vec<Circuit>

The circuits to link into the tunnel,

answer: Sender<Result<Vec<Result<(), ConfluxHandshakeError>>>>

Oneshot channel to notify sender when all the specified circuits have finished linking, or have failed to link.

A client circuit is said to be fully linked once the RELAY_CONFLUX_LINKED_ACK is sent (see set construction).

Trait Implementations

impl Debug for CtrlMsg

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<CtrlMsg> for CircuitEvent

fn from(value: CtrlMsg) -> Self

Converts to this type from the input type.