Trait libp2p_core::upgrade::InboundUpgrade

pub trait InboundUpgrade<C>: UpgradeInfo {
    type Output;
    type Error;
    type Future: Future<Output = Result<Self::Output, Self::Error>>;

    fn upgrade_inbound(self, socket: C, info: Self::Info) -> Self::Future;
}

Possible upgrade on an inbound connection or substream.

Required Associated Types

type Output

Output after the upgrade has been successfully negotiated and the handshake performed.

type Error

Possible error during the handshake.

type Future: Future<Output = Result<Self::Output, Self::Error>>

Future that performs the handshake with the remote.

Required Methods

fn upgrade_inbound(self, socket: C, info: Self::Info) -> Self::Future

After we have determined that the remote supports one of the protocols we support, this method is called to start the handshake.

The info is the identifier of the protocol, as produced by protocol_info.

Implementors

impl<C> InboundUpgrade<C> for DeniedUpgrade

type Output = Void

type Error = Void

type Future = Pending<Result<<DeniedUpgrade as InboundUpgrade<C>>::Output, <DeniedUpgrade as InboundUpgrade<C>>::Error>>

impl<C, A, B, TA, TB, EA, EB> InboundUpgrade<C> for EitherUpgrade<A, B>where
    A: InboundUpgrade<C, Output = TA, Error = EA>,
    B: InboundUpgrade<C, Output = TB, Error = EB>,

type Output = EitherOutput<TA, TB>

type Error = EitherError<EA, EB>

type Future = EitherFuture2<<A as InboundUpgrade<C>>::Future, <B as InboundUpgrade<C>>::Future>

impl<C, A, B, TA, TB, EA, EB> InboundUpgrade<C> for SelectUpgrade<A, B>where
    A: InboundUpgrade<C, Output = TA, Error = EA>,
    B: InboundUpgrade<C, Output = TB, Error = EB>,

type Output = EitherOutput<TA, TB>

type Error = EitherError<EA, EB>

type Future = EitherFuture2<<A as InboundUpgrade<C>>::Future, <B as InboundUpgrade<C>>::Future>

impl<C, P, F, Fut, Err, Out> InboundUpgrade<C> for FromFnUpgrade<P, F>where
    P: ProtocolName + Clone,
    F: FnOnce(C, Endpoint) -> Fut,
    Fut: Future<Output = Result<Out, Err>>,

type Output = Out

type Error = Err

type Future = Fut

impl<C, T> InboundUpgrade<C> for OptionalUpgrade<T>where
    T: InboundUpgrade<C>,

type Output = <T as InboundUpgrade<C>>::Output

type Error = <T as InboundUpgrade<C>>::Error

type Future = <T as InboundUpgrade<C>>::Future

impl<C, U, F> InboundUpgrade<C> for MapOutboundUpgrade<U, F>where
    U: InboundUpgrade<C>,

type Output = <U as InboundUpgrade<C>>::Output

type Error = <U as InboundUpgrade<C>>::Error

type Future = <U as InboundUpgrade<C>>::Future

impl<C, U, F> InboundUpgrade<C> for MapOutboundUpgradeErr<U, F>where
    U: InboundUpgrade<C>,

type Output = <U as InboundUpgrade<C>>::Output

type Error = <U as InboundUpgrade<C>>::Error

type Future = <U as InboundUpgrade<C>>::Future

impl<C, U, F, T> InboundUpgrade<C> for MapInboundUpgrade<U, F>where
    U: InboundUpgrade<C>,
    F: FnOnce(U::Output) -> T,

type Output = T

type Error = <U as InboundUpgrade<C>>::Error

type Future = MapFuture<<U as InboundUpgrade<C>>::Future, F>

impl<C, U, F, T> InboundUpgrade<C> for MapInboundUpgradeErr<U, F>where
    U: InboundUpgrade<C>,
    F: FnOnce(U::Error) -> T,

type Output = <U as InboundUpgrade<C>>::Output

type Error = T

type Future = MapErrFuture<<U as InboundUpgrade<C>>::Future, F>

impl<C, F, O, A, E> InboundUpgrade<C> for SimpleProtocol<F>where
    C: AsyncRead + AsyncWrite,
    F: Fn(C) -> O,
    O: Future<Output = Result<A, E>>,

impl<C> InboundUpgrade<C> for DeflateConfigwhere
    C: AsyncRead + AsyncWrite,

impl<TSocket> InboundUpgrade<TSocket> for FloodsubProtocolwhere
    TSocket: AsyncRead + AsyncWrite + Send + Unpin + 'static,

impl<TSocket> InboundUpgrade<TSocket> for ProtocolConfigwhere
    TSocket: AsyncRead + AsyncWrite + Unpin + Send + 'static,

impl<C> InboundUpgrade<C> for KademliaProtocolConfigwhere
    C: AsyncRead + AsyncWrite + Unpin,

impl<C> InboundUpgrade<C> for MplexConfigwhere
    C: AsyncRead + AsyncWrite + Unpin,

impl<T, C> InboundUpgrade<T> for NoiseConfig<IX, C>where
    NoiseConfig<IX, C>: UpgradeInfo,
    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,

impl<T, C> InboundUpgrade<T> for NoiseConfig<XX, C>where
    NoiseConfig<XX, C>: UpgradeInfo,
    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,

impl<T, C, R> InboundUpgrade<T> for NoiseConfig<IK, C, R>where
    NoiseConfig<IK, C, R>: UpgradeInfo,
    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,

impl<T, P, C, R> InboundUpgrade<T> for NoiseAuthenticated<P, C, R>where
    NoiseConfig<P, C, R>: UpgradeInfo + InboundUpgrade<T, Output = (RemoteIdentity<C>, NoiseOutput<T>), Error = NoiseError> + 'static,
    <NoiseConfig<P, C, R> as InboundUpgrade<T>>::Future: Send,
    T: AsyncRead + AsyncWrite + Send + 'static,
    C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,

impl<C> InboundUpgrade<C> for PlainText1Config

impl<C> InboundUpgrade<C> for PlainText2Configwhere
    C: AsyncRead + AsyncWrite + Send + Unpin + 'static,

impl<TCodec> InboundUpgrade<Negotiated<SubstreamBox>> for ResponseProtocol<TCodec>where
    TCodec: RequestResponseCodec + Send + 'static,

impl<T: InboundUpgradeSend> InboundUpgrade<Negotiated<SubstreamBox>> for SendWrapper<T>

impl<C> InboundUpgrade<C> for YamuxConfigwhere
    C: AsyncRead + AsyncWrite + Send + Unpin + 'static,

impl<C> InboundUpgrade<C> for YamuxLocalConfigwhere
    C: AsyncRead + AsyncWrite + Unpin + 'static,

impl<TSocket> InboundUpgrade<TSocket> for BitswapConfigwhere
    TSocket: AsyncRead + AsyncWrite + Send + Unpin + 'static,