//! Handler for CREATE* cells.

use crate::FlowCtrlParameters;

use crate::ccparams::{

    Algorithm, AlgorithmDiscriminants, CongestionControlParams, CongestionWindowParams,

    FixedWindowParams, RoundTripEstimatorParams, VegasParams,

};

use crate::channel::Channel;

use crate::circuit::CircuitRxSender;

use crate::circuit::UniqId;

use crate::circuit::celltypes::{CreateRequest, CreateResponse};

use crate::circuit::circhop::{HopNegotiationType, HopSettings};

use crate::client::circuit::CircParameters;

use crate::client::circuit::padding::PaddingController;

use crate::crypto::cell::CryptInit as _;

use crate::crypto::cell::RelayLayer as _;

use crate::crypto::cell::{InboundRelayLayer, OutboundRelayLayer, tor1};

use crate::crypto::handshake::RelayHandshakeError;

use crate::crypto::handshake::ServerHandshake as _;

use crate::crypto::handshake::fast::CreateFastServer;

use crate::memquota::SpecificAccount as _;

use crate::memquota::{ChannelAccount, CircuitAccount};

use crate::relay::RelayCirc;

use crate::relay::channel_provider::ChannelProvider;

use crate::relay::reactor::Reactor;

use std::sync::{Arc, RwLock, Weak};

use tor_cell::chancell::ChanMsg as _;

use tor_cell::chancell::CircId;

use tor_cell::chancell::msg::{CreateFast, CreatedFast, Destroy, DestroyReason};

use tor_error::{Bug, ErrorKind, HasKind, debug_report, internal, into_internal};

use tor_linkspec::OwnedChanTarget;

use tor_llcrypto::cipher::aes::Aes128Ctr;

use tor_llcrypto::d::Sha1;

use tor_llcrypto::pk::ed25519::Ed25519Identity;

use tor_llcrypto::pk::rsa::RsaIdentity;

use tor_memquota::mq_queue::ChannelSpec as _;

use tor_memquota::mq_queue::MpscSpec;

use tor_relay_crypto::pk::RelayNtorKeys;

use tor_rtcompat::SpawnExt as _;

use tor_rtcompat::{DynTimeProvider, Runtime};

use tracing::warn;

/// Everything needed to handle CREATE* messages on channels.

#[derive(derive_more::Debug)]

pub struct CreateRequestHandler {

    /// Something that can launch channels. Typically the `ChanMgr`.

    chan_provider: Weak<dyn ChannelProvider<BuildSpec = OwnedChanTarget> + Send + Sync>,

    /// Circuit-related network parameters.

    circ_net_params: RwLock<CircNetParameters>,

    /// The circuit extension keys.

    #[debug(skip)]

    ntor_keys: RwLock<RelayNtorKeys>,

}

impl CreateRequestHandler {

    /// Build a new [`CreateRequestHandler`].

    /// Update the circuit parameters from a network consensus.

    /// Update the handler with a new set of circuit extension keys.

    ///

    /// This is called periodically by the relay key rotation task.

    /// Handle a CREATE* cell.

    ///

    /// This intentionally does not return a [`crate::Error`] so that we don't accidentally shut

    /// down the channel reactor when we really should be returning a DESTROY. Shutting down a

    /// channel may cause us to leak information about paths of circuits travelling through this

    /// relay. This is especially important here since we're handling data that is controllable from

    /// the other end of the circuit.

    #[allow(clippy::too_many_arguments)]

        );

                // TODO(relay): The log messages throughout could be very noisy, so should have rate limiting.

            }

        }

    /// See [`Self::handle_create`].

    #[allow(clippy::too_many_arguments)]

        // Perform the handshake crypto and build the response.

            CreateRequest::Create2(_) => {

                // TODO(relay): We might want to offload this to a CPU worker in the future.

                // TODO(relay): Implement this.

            }

        };

        // We use a large mpsc queue here since a circuit should never block the channel,

        // and we hope that memquota will help us if an attacker intentionally fills this buffer.

        // We use `10_000_000` since `usize::MAX` causes `futures::channel::mpsc` to panic.

        // TODO(relay): We should switch to an unbounded queue, but the circuit reactor is expecting

        // a bounded queue.

        // TODO(relay): Do we really want a client padding machine here?

        // Upgrade the channel provider, which in practice is the `ChanMgr` so this should not fail.

        };

        // Build the relay circuit reactor.

        )

        // Start the reactor in a task.

                }

            }

    /// The handshake code for a CREATE_FAST request.

        // TODO(relay): We might want to offload this to a CPU worker in the future.

        // TODO(relay): I think we might want to get these from the consensus instead?

        // TODO(relay): I'm not sure if this is the right way to do this. It works for

        // CREATE_FAST, but we might want to rethink it for CREATE2.

}

/// An error that occurred while handling a CREATE* request.

#[derive(Debug, thiserror::Error)]

enum HandleCreateError {

    /// Circuit relay handshake failed.

    #[error("Circuit relay handshake failed")]

    Handshake(#[from] RelayHandshakeError),

    /// A memquota error.

    #[error("Memquota error")]

    Memquota(#[from] tor_memquota::Error),

    /// Error when spawning a task.

    #[error("Runtime task spawn error")]

    Spawn(#[from] futures::task::SpawnError),

    /// An internal error.

    ///

    /// Note that other variants (such as `Handshake` containing a [`RelayHandshakeError`])

    /// may themselves contain internal errors.

    #[error("Internal error")]

    Internal(#[from] tor_error::Bug),

}

impl HandleCreateError {

    /// The reason to use in a DESTROY message for this failure.

        // Note that this may return an INTERNAL destroy reason even when

        // the inner error is not `ErrorKind::Internal`.

        }

}

impl HasKind for HandleCreateError {

        }

}

/// The components of a completed CREATE* handshake.

struct CompletedHandshakeComponents {

    /// The message to send in response.

    response: CreateResponse,

    /// The negotiated hop settings.

    hop_settings: HopSettings,

    /// Outbound onion crypto.

    crypto_out: Box<dyn OutboundRelayLayer + Send>,

    /// Inbound onion crypto.

    crypto_in: Box<dyn InboundRelayLayer + Send>,

}

/// A collection of objects built for a new relay circuit.

pub(crate) struct RelayCircComponents {

    /// The relay circuit handle.

    pub(crate) circ: Arc<RelayCirc>,

    /// Used to send data from the channel to the circuit reactor.

    pub(crate) sender: CircuitRxSender,

    /// The circuit's padding controller.

    pub(crate) padding_ctrl: PaddingController,

}

/// Congestion control network parameters.

#[derive(Debug, Clone)]

#[allow(clippy::exhaustive_structs)]

pub struct CongestionControlNetParams {

    /// Fixed-window algorithm parameters.

    pub fixed_window: FixedWindowParams,

    /// Vegas algorithm parameters for exit circuits.

    // NOTE: In this module we are handling CREATE* cells,

    // which only happens for non-hs circuits.

    // So we don't need to store the vegas hs parameters here.

    pub vegas_exit: VegasParams,

    /// Congestion window parameters.

    pub cwnd: CongestionWindowParams,

    /// RTT calculation parameters.

    pub rtt: RoundTripEstimatorParams,

    /// Flow control parameters to use for all streams on this circuit.

    pub flow_ctrl: FlowCtrlParameters,

}

impl CongestionControlNetParams {

    #[cfg(test)]

    // These have been copied from C-tor.

}

/// Network consensus parameters for handling incoming circuits.

///

/// Unlike `CircParameters`,

/// this is unopinionated and contains all relevant consensus parameters,

/// which is needed when handling an incoming CREATE* request where the

/// circuit origin chooses the type/settings

/// (for example congestion control type) of the circuit.

#[derive(Debug, Clone)]

#[allow(clippy::exhaustive_structs)]

pub struct CircNetParameters {

    /// Whether we should include ed25519 identities when we send EXTEND2 cells.

    pub extend_by_ed25519_id: bool,

    /// Congestion control network parameters.

    pub cc: CongestionControlNetParams,

}

impl CircNetParameters {

    /// Convert the [`CircNetParameters`] into a [`CircParameters`].

    ///

    /// We expect the circuit creation handshake to know what congestion control algorithm was

    /// negotiated, and provide that as `algorithm`.

    //

    // We disable `unused` warnings at the root of tor-proto,

    // but it's nice to have here so we re-enable it.

    #[warn(unused)]

        // Unpack everything to make sure that we aren't missing anything

        // (otherwise clippy would warn).

        let Self {

            cc:

                CongestionControlNetParams {

                },

        };

        // TODO(arti#2442): The builder pattern here seems like a footgun.

}