// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//! Provides a generic implementation of a PPP control protocol.

use {
    fuchsia_async::futures::future::BoxFuture,
    packet::{Buf, BufferMut, Serializer},
    ppp_packet::{
        CodeRejectPacketBuilder, ConfigurationPacketBuilder, ControlProtocolPacketBuilder,
        PppPacketBuilder, TerminationPacketBuilder,
    },
    std::fmt::Debug,
    thiserror::Error,
};

/// The protocol byte pattern used in IPCP packets.
pub const PROTOCOL_IPV4_CONTROL: u16 = 0x8021;
/// The protocol byte pattern used in IPV6CP packets.
pub const PROTOCOL_IPV6_CONTROL: u16 = 0x8057;
/// The protocol byte pattern used in LCP packets.
pub const PROTOCOL_LINK_CONTROL: u16 = 0xc021;

/// The default LCP MRU, and currently the only supported value by this implementation.
pub const DEFAULT_MRU: u16 = 1500;
/// The default maximum size of a PPP packet, taking into account the default MRU and PPP header
/// bytes.
pub const DEFAULT_MAX_FRAME: u16 = DEFAULT_MRU + 2; // 2 bytes for protocol

/// The code byte pattern used in a Configure-Request packet.
pub const CODE_CONFIGURE_REQUEST: u8 = 1;
/// The code byte pattern used in a Configure-Ack packet.
pub const CODE_CONFIGURE_ACK: u8 = 2;
/// The code byte pattern used in a Configure-Nak packet.
pub const CODE_CONFIGURE_NAK: u8 = 3;
/// The code byte pattern used in a Configure-Rej packet.
pub const CODE_CONFIGURE_REJECT: u8 = 4;
/// The code byte pattern used in a Terminate-Request packet.
pub const CODE_TERMINATE_REQUEST: u8 = 5;
/// The code byte pattern used in a Terminate-Ack packet.
pub const CODE_TERMINATE_ACK: u8 = 6;
/// The code byte pattern used in a Code-Rej packet.
pub const CODE_CODE_REJECT: u8 = 7;

/// Abstraction over the specialized operations of each LCP-like control protocol. The main
/// differences in each protocol deal with parsing and serialization of options.
pub trait ControlProtocol: 'static + Debug + Clone {
    /// A type which can represent any option of the control protocol.
    type Option: Clone + PartialEq + Send + Sync + Debug;
    /// The protocol byte pattern used in this control protocol's packets.
    const PROTOCOL_IDENTIFIER: u16;

    /// Filter out only the unacceptable options from some received options.
    fn unacceptable_options(received: &[Self::Option]) -> Vec<Self::Option>;
    /// Attempt to parse options from a byte buffer.
    fn parse_options(buf: &[u8]) -> Option<Vec<Self::Option>>;
    /// Serialize options into a byte buffer.
    fn serialize_options(options: &[Self::Option]) -> Buf<Vec<u8>>;
}

/// Abstraction over something which can receive PPP packets from something like a driver.
pub trait FrameReceiver: Send + Sync + Debug + 'static {
    /// Asynchronously receive a frame.
    fn rx_frame<'a>(&'a self) -> BoxFuture<'a, Result<Vec<u8>, FrameError>>;
}

/// Abstraction over something which can transmit PPP packets to something like a driver.
pub trait FrameTransmitter: Send + Sync + Debug + 'static {
    /// Asynchronously transmit a frame.
    fn tx_frame<'a>(&'a self, frame: &'a [u8]) -> BoxFuture<'a, Result<(), FrameError>>;
}

/// Possible failures that can result from transitions in the control protocol state machine.
#[derive(Clone, Debug, Error)]
pub enum ProtocolError<P: ControlProtocol> {
    /// Link was terminated.
    #[error("Link was terminated.")]
    Terminated,
    /// Link configuration timed out.
    #[error("Link configuration timed out.")]
    Timeout,
    /// Fatal frame error.
    #[error("Fatal frame error: {:?}.", _0)]
    FatalFrameError(FrameError),
    /// Peer rejected options.
    #[error("Peer rejected options: {:?}.", _0)]
    FatalConfigureRej(Vec<<P as ControlProtocol>::Option>),
    /// Peer rejected code.
    #[error("Peer rejected code in packet: {:x?}.", _0)]
    FatalCodeRej(Vec<u8>),
    /// Peer rejected protocol.
    #[error("Peer rejected protocol: {:x}.", _0)]
    FatalProtocolRej(u16),
    /// Peer sent an invalid configure acknowledge.
    #[error("Peer sent an invalid configure acknowledge.")]
    InvalidAck(ProtocolState<P>),
    /// Peer sent an unacceptable configure request.
    #[error("Peer sent an unacceptable configure request.")]
    UnacceptableReq(ProtocolState<P>),
}

/// Possible failures that can result from sending or receiving frames.
#[derive(Clone, Copy, Debug, Error)]
pub enum FrameError {
    /// Device was down.
    #[error("Device was down.")]
    DeviceDown,
}

impl<P: ControlProtocol> From<FrameError> for ProtocolError<P> {
    fn from(error: FrameError) -> Self {
        ProtocolError::FatalFrameError(error)
    }
}

/// The possible states that the control protocol state machine can be in.
#[derive(Clone, Debug)]
pub enum ProtocolState<P: ControlProtocol> {
    /// No Configure-Request has been sent. This is the initial state.
    Closed(Closed<P>),
    /// A Configure-Request has been sent, but no Configure-Ack has been sent or received.
    RequestSent(RequestSent<P>),
    /// A Configure-Request has been sent, and a Configure-Ack has been sent but not received.
    AckSent(AckSent<P>),
    /// A Configure-Request has been sent, and a Configure-Ack has been received but not sent.
    AckReceived(AckReceived<P>),
    /// A Configure-Request has been sent, and a Configure-Ack has been sent and received.
    Opened(Opened<P>),
}

/// No Configure-Request has been sent. This is the initial state.
#[derive(Clone, Debug)]
pub struct Closed<P: ControlProtocol> {
    desired_options: Vec<<P as ControlProtocol>::Option>,
}

/// A Configure-Request has been sent, but no Configure-Ack has been sent or received.
#[derive(Clone, Debug)]
pub struct RequestSent<P: ControlProtocol> {
    sent_options: Vec<<P as ControlProtocol>::Option>,
    sent_identifier: u8,
    restart_counter: u8,
    restart_time: std::time::Instant,
}

/// A Configure-Request has been sent, and a Configure-Ack has been sent but not received.
#[derive(Clone, Debug)]
pub struct AckReceived<P: ControlProtocol> {
    local_options: Vec<<P as ControlProtocol>::Option>,
    sent_identifier: u8,
}

/// A Configure-Request has been sent, and a Configure-Ack has been received but not sent.
#[derive(Clone, Debug)]
pub struct AckSent<P: ControlProtocol> {
    remote_options: Vec<<P as ControlProtocol>::Option>,
    sent_options: Vec<<P as ControlProtocol>::Option>,
    sent_identifier: u8,
    restart_counter: u8,
    restart_time: std::time::Instant,
}

/// A Configure-Request has been sent, and a Configure-Ack has been sent and received.
#[derive(Clone, Debug)]
pub struct Opened<P: ControlProtocol> {
    local_options: Vec<<P as ControlProtocol>::Option>,
    remote_options: Vec<<P as ControlProtocol>::Option>,
    sent_identifier: u8,
}

impl<P: ControlProtocol> ProtocolState<P> {
    /// Initialize the protocol into a closed state with some desired local options.
    pub fn new(desired_options: Vec<<P as ControlProtocol>::Option>) -> Self {
        ProtocolState::Closed(Closed { desired_options })
    }

    /// If a restart timer is running and the provided time causes the timer to expire, restart the
    /// connection.
    pub async fn restart<T>(
        self,
        transmitter: &T,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        Ok(match self {
            ProtocolState::Closed(closed) => {
                ProtocolState::RequestSent(closed.request(transmitter, time).await?)
            }
            ProtocolState::RequestSent(req_sent) => {
                ProtocolState::RequestSent(req_sent.restart(transmitter, time).await?)
            }
            ProtocolState::AckSent(ack_sent) => {
                ProtocolState::AckSent(ack_sent.restart(transmitter, time).await?)
            }
            _ => self,
        })
    }

    /// Move from the current state into a closed state, preserving local options that may have been
    /// negotiated as the new desired options.
    pub fn reset(self) -> Self {
        ProtocolState::Closed(match self {
            ProtocolState::Closed(closed) => closed,
            ProtocolState::RequestSent(req_sent) => req_sent.reset(),
            ProtocolState::AckSent(ack_sent) => ack_sent.reset(),
            ProtocolState::AckReceived(ack_received) => ack_received.reset(),
            ProtocolState::Opened(opened) => opened.reset(),
        })
    }

    /// Process an incoming Configure-Request packet, send a reply if appropriate, and produce the
    /// new connection state.
    pub async fn rx_configure_req<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        Ok(match self {
            ProtocolState::RequestSent(req_sent) => ProtocolState::AckSent(
                req_sent.rx_configure_req(transmitter, options, identifier).await?,
            ),
            ProtocolState::AckSent(ack_sent) => ProtocolState::AckSent(
                ack_sent.rx_configure_req(transmitter, options, identifier, time).await?,
            ),
            ProtocolState::AckReceived(ack_received) => ProtocolState::Opened(
                ack_received.rx_configure_req(transmitter, options, identifier).await?,
            ),
            ProtocolState::Opened(opened) => ProtocolState::AckSent(
                opened.rx_configure_req(transmitter, options, identifier, time).await?,
            ),
            _ => self,
        })
    }

    /// Process an incoming Configure-Ack packet, send a reply if appropriate, and produce the
    /// new connection state.
    pub async fn rx_configure_ack<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        Ok(match self {
            ProtocolState::RequestSent(req_sent) => ProtocolState::AckReceived(
                req_sent.rx_configure_ack(transmitter, &options, identifier).await?,
            ),
            ProtocolState::AckSent(ack_sent) => ProtocolState::Opened(
                ack_sent.rx_configure_ack(transmitter, &options, identifier).await?,
            ),
            ProtocolState::AckReceived(ack_received) => ProtocolState::AckReceived(
                ack_received.rx_configure_ack(transmitter, &options, identifier, time).await?,
            ),

            ProtocolState::Opened(opened) => ProtocolState::Opened(
                opened.rx_configure_ack(transmitter, &options, identifier, time).await?,
            ),
            _ => self,
        })
    }

    /// Process an incoming Configure-Nak/Configure-Rej packet, send a reply if appropriate, and
    /// produce the new connection state.
    ///
    /// Currently all desired configuration is strict and any nak/reject results in a protocol
    /// error.
    pub async fn rx_configure_rej<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        Ok(match self {
            ProtocolState::RequestSent(req_sent) => ProtocolState::RequestSent(
                req_sent.rx_configure_rej(transmitter, &options, identifier).await?,
            ),
            ProtocolState::AckSent(ack_sent) => ProtocolState::RequestSent(
                ack_sent.rx_configure_rej(transmitter, &options, identifier, time).await?,
            ),
            ProtocolState::AckReceived(ack_received) => ProtocolState::RequestSent(
                ack_received.rx_configure_rej(transmitter, &options, identifier, time).await?,
            ),
            ProtocolState::Opened(opened) => ProtocolState::RequestSent(
                opened.rx_configure_rej(transmitter, &options, identifier, time).await?,
            ),
            _ => self,
        })
    }

    /// Process an incoming Terminate-Request packet, send a reply if appropriate, and produce the
    /// new connection state.
    pub async fn rx_terminate_req<T>(
        self,
        transmitter: &T,
        identifier: u8,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        tx_terminate_ack::<P, _>(transmitter, identifier).await?;
        Err(ProtocolError::Terminated)
    }
}

/// Serialize and transmit a Configure-Request packet with the provided options and identifier.
pub async fn tx_configure_req<'a, P, T>(
    transmitter: &'a T,
    options: &'a [<P as ControlProtocol>::Option],
    identifier: u8,
) -> Result<(), FrameError>
where
    T: FrameTransmitter,
    P: ControlProtocol,
{
    let frame = P::serialize_options(options)
        .encapsulate(ConfigurationPacketBuilder::new())
        .encapsulate(ControlProtocolPacketBuilder::new(CODE_CONFIGURE_REQUEST, identifier))
        .encapsulate(PppPacketBuilder::new(P::PROTOCOL_IDENTIFIER))
        .serialize_vec_outer()
        .ok()
        .unwrap();
    transmitter.tx_frame(frame.as_ref()).await
}

/// Serialize and transmit a Configure-Ack packet with the provided options and identifier.
pub async fn tx_configure_ack<'a, P, T>(
    transmitter: &'a T,
    options: &'a [<P as ControlProtocol>::Option],
    identifier: u8,
) -> Result<(), FrameError>
where
    T: FrameTransmitter,
    P: ControlProtocol,
{
    let frame = P::serialize_options(options)
        .encapsulate(ConfigurationPacketBuilder::new())
        .encapsulate(ControlProtocolPacketBuilder::new(CODE_CONFIGURE_ACK, identifier))
        .encapsulate(PppPacketBuilder::new(P::PROTOCOL_IDENTIFIER))
        .serialize_vec_outer()
        .ok()
        .unwrap();
    transmitter.tx_frame(frame.as_ref()).await
}

/// Serialize and transmit a Configure-Rej packet with the provided options and identifier.
pub async fn tx_configure_rej<'a, P, T>(
    transmitter: &'a T,
    options: &'a [<P as ControlProtocol>::Option],
    identifier: u8,
) -> Result<(), FrameError>
where
    T: FrameTransmitter,
    P: ControlProtocol,
{
    let frame = P::serialize_options(options)
        .encapsulate(ConfigurationPacketBuilder::new())
        .encapsulate(ControlProtocolPacketBuilder::new(CODE_CONFIGURE_REJECT, identifier))
        .encapsulate(PppPacketBuilder::new(P::PROTOCOL_IDENTIFIER))
        .serialize_vec_outer()
        .ok()
        .unwrap();
    transmitter.tx_frame(frame.as_ref()).await
}

/// Serialize and transmit a Terminate-Request packet with the provided identifier.
pub async fn tx_terminate_req<P, T>(transmitter: &T, identifier: u8) -> Result<(), FrameError>
where
    T: FrameTransmitter,
    P: ControlProtocol,
{
    let frame = Buf::new(&mut [], ..)
        .encapsulate(TerminationPacketBuilder::new())
        .encapsulate(ControlProtocolPacketBuilder::new(CODE_TERMINATE_REQUEST, identifier))
        .encapsulate(PppPacketBuilder::new(P::PROTOCOL_IDENTIFIER))
        .serialize_vec_outer()
        .ok()
        .unwrap();
    transmitter.tx_frame(frame.as_ref()).await
}

/// Serialize and transmit a Terminate-Ack packet with the provided identifier.
pub async fn tx_terminate_ack<P, T>(transmitter: &T, identifier: u8) -> Result<(), FrameError>
where
    T: FrameTransmitter,
    P: ControlProtocol,
{
    let frame = Buf::new(&mut [], ..)
        .encapsulate(TerminationPacketBuilder::new())
        .encapsulate(ControlProtocolPacketBuilder::new(CODE_TERMINATE_ACK, identifier))
        .encapsulate(PppPacketBuilder::new(P::PROTOCOL_IDENTIFIER))
        .serialize_vec_outer()
        .ok()
        .unwrap();
    transmitter.tx_frame(frame.as_ref()).await
}

/// Serialize and transmit a Code-Rej packet with the provided identifier.
pub async fn tx_code_rej<P, T, B>(
    transmitter: &T,
    mut buf: B,
    identifier: u8,
) -> Result<(), FrameError>
where
    T: FrameTransmitter,
    P: ControlProtocol,
    B: BufferMut,
{
    buf.shrink_front_to(0);
    let frame = buf
        .encapsulate(CodeRejectPacketBuilder::new())
        .encapsulate(ControlProtocolPacketBuilder::new(CODE_CODE_REJECT, identifier))
        .encapsulate(PppPacketBuilder::new(P::PROTOCOL_IDENTIFIER))
        .serialize_vec_outer()
        .ok()
        .unwrap();
    // truncate the end bytes
    let frame: &[u8] = frame.as_ref();
    let bound = std::cmp::min(frame.len(), DEFAULT_MAX_FRAME as usize);
    transmitter.tx_frame(&frame[..bound]).await
}

const MAX_RESTART: u8 = 10;
const TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3);

impl<P: ControlProtocol> Closed<P> {
    async fn request<T>(
        self,
        transmitter: &T,
        time: std::time::Instant,
    ) -> Result<RequestSent<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        tx_configure_req::<P, _>(transmitter, &self.desired_options, 0).await?;
        Ok(RequestSent {
            sent_options: self.desired_options,
            sent_identifier: 0,
            restart_counter: 1,
            restart_time: time,
        })
    }
}

impl<P: ControlProtocol> RequestSent<P> {
    fn reset(self) -> Closed<P> {
        Closed { desired_options: self.sent_options }
    }

    async fn restart<T>(
        self,
        transmitter: &T,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        if self.restart_counter < MAX_RESTART {
            if time.duration_since(self.restart_time) >= TIMEOUT {
                tx_configure_req::<P, _>(transmitter, &self.sent_options, self.sent_identifier)
                    .await?;
                Ok(Self { restart_counter: self.restart_counter + 1, restart_time: time, ..self })
            } else {
                Ok(self)
            }
        } else {
            Err(ProtocolError::Timeout)
        }
    }

    async fn rx_configure_req<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
    ) -> Result<AckSent<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        let unacceptable_options = P::unacceptable_options(options);
        if unacceptable_options.is_empty() {
            tx_configure_ack::<P, _>(transmitter, options, identifier).await?;
            Ok(AckSent {
                remote_options: options.to_vec(),
                sent_options: self.sent_options,
                sent_identifier: self.sent_identifier,
                restart_counter: self.restart_counter,
                restart_time: self.restart_time,
            })
        } else {
            tx_configure_rej::<P, _>(transmitter, &unacceptable_options, identifier).await?;
            Err(ProtocolError::UnacceptableReq(ProtocolState::RequestSent(self)))
        }
    }

    async fn rx_configure_ack<'a, T>(
        self,
        _transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
    ) -> Result<AckReceived<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        if options == self.sent_options.as_slice() && identifier == self.sent_identifier {
            Ok(AckReceived {
                local_options: self.sent_options,
                sent_identifier: self.sent_identifier,
            })
        } else {
            Err(ProtocolError::InvalidAck(ProtocolState::RequestSent(self)))
        }
    }

    async fn rx_configure_rej<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        _identifier: u8,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        tx_terminate_req::<P, _>(transmitter, self.sent_identifier + 1).await?;
        Err(ProtocolError::FatalConfigureRej(options.to_vec()))
    }
}

impl<P: ControlProtocol> AckReceived<P> {
    fn reset(self) -> Closed<P> {
        Closed { desired_options: self.local_options }
    }

    async fn rx_configure_req<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
    ) -> Result<Opened<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        let unacceptable_options = P::unacceptable_options(options);
        if unacceptable_options.is_empty() {
            tx_configure_ack::<P, _>(transmitter, options, identifier).await?;
            Ok(Opened {
                local_options: self.local_options,
                remote_options: options.to_vec(),
                sent_identifier: self.sent_identifier,
            })
        } else {
            tx_configure_rej::<P, _>(transmitter, &unacceptable_options, identifier).await?;
            Err(ProtocolError::UnacceptableReq(ProtocolState::AckReceived(self)))
        }
    }

    async fn rx_configure_ack<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        if options == self.local_options.as_slice() && identifier == self.sent_identifier {
            Ok(self)
        } else {
            tx_configure_req::<P, _>(transmitter, &self.local_options, self.sent_identifier)
                .await?;
            Err(ProtocolError::InvalidAck(ProtocolState::RequestSent(RequestSent {
                sent_options: self.local_options,
                sent_identifier: self.sent_identifier,
                restart_counter: 1,
                restart_time: time,
            })))
        }
    }

    async fn rx_configure_rej<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        _identifier: u8,
        _time: std::time::Instant,
    ) -> Result<RequestSent<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        tx_terminate_req::<P, _>(transmitter, self.sent_identifier + 1).await?;
        Err(ProtocolError::FatalConfigureRej(options.to_vec()))
    }
}

impl<P: ControlProtocol> AckSent<P> {
    fn reset(self) -> Closed<P> {
        Closed { desired_options: self.sent_options }
    }

    async fn restart<T>(
        self,
        transmitter: &T,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        if self.restart_counter < MAX_RESTART {
            if time.duration_since(self.restart_time) >= TIMEOUT {
                tx_configure_req::<P, _>(transmitter, &self.sent_options, self.sent_identifier)
                    .await?;
                Ok(Self { restart_counter: self.restart_counter + 1, restart_time: time, ..self })
            } else {
                Ok(self)
            }
        } else {
            Err(ProtocolError::Timeout)
        }
    }

    async fn rx_configure_req<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        let unacceptable_options = P::unacceptable_options(options);
        if unacceptable_options.is_empty() {
            tx_configure_ack::<P, _>(transmitter, options, identifier).await?;
            Ok(Self { remote_options: options.to_vec(), ..self })
        } else {
            tx_configure_rej::<P, _>(transmitter, &unacceptable_options, identifier).await?;
            Err(ProtocolError::UnacceptableReq(ProtocolState::RequestSent(RequestSent {
                sent_options: self.sent_options,
                sent_identifier: self.sent_identifier,
                restart_counter: 0,
                restart_time: time,
            })))
        }
    }

    async fn rx_configure_ack<'a, T>(
        self,
        _transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
    ) -> Result<Opened<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        if options == self.sent_options.as_slice() && identifier == self.sent_identifier {
            Ok(Opened {
                local_options: self.sent_options,
                remote_options: self.remote_options,
                sent_identifier: self.sent_identifier,
            })
        } else {
            Err(ProtocolError::InvalidAck(ProtocolState::AckSent(self)))
        }
    }

    async fn rx_configure_rej<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        _identifier: u8,
        _time: std::time::Instant,
    ) -> Result<RequestSent<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        tx_terminate_req::<P, _>(transmitter, self.sent_identifier + 1).await?;
        Err(ProtocolError::FatalConfigureRej(options.to_vec()))
    }
}

impl<P: ControlProtocol> Opened<P> {
    /// Obtain a slice over the local options.
    pub fn local_options(&self) -> &[<P as ControlProtocol>::Option] {
        &self.local_options
    }

    fn reset(self) -> Closed<P> {
        Closed { desired_options: self.local_options }
    }

    async fn rx_configure_req<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
        time: std::time::Instant,
    ) -> Result<AckSent<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        let unacceptable_options = P::unacceptable_options(options);
        if unacceptable_options.is_empty() {
            tx_configure_req::<P, _>(transmitter, &self.local_options, self.sent_identifier)
                .await?;
            tx_configure_ack::<P, _>(transmitter, options, identifier).await?;
            Ok(AckSent {
                remote_options: options.to_vec(),
                sent_options: self.local_options,
                sent_identifier: self.sent_identifier,
                restart_counter: 1,
                restart_time: time,
            })
        } else {
            tx_configure_rej::<P, _>(transmitter, &unacceptable_options, identifier).await?;
            Err(ProtocolError::UnacceptableReq(ProtocolState::AckReceived(AckReceived {
                local_options: self.local_options,
                sent_identifier: self.sent_identifier,
            })))
        }
    }

    async fn rx_configure_ack<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        identifier: u8,
        time: std::time::Instant,
    ) -> Result<Self, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        if options == self.local_options.as_slice() && identifier == self.sent_identifier {
            Ok(self)
        } else {
            tx_configure_req::<P, _>(transmitter, &self.local_options, self.sent_identifier)
                .await?;
            Err(ProtocolError::InvalidAck(ProtocolState::RequestSent(RequestSent {
                sent_options: self.local_options,
                sent_identifier: self.sent_identifier,
                restart_counter: 1,
                restart_time: time,
            })))
        }
    }

    async fn rx_configure_rej<'a, T>(
        self,
        transmitter: &'a T,
        options: &'a [<P as ControlProtocol>::Option],
        _identifier: u8,
        _time: std::time::Instant,
    ) -> Result<RequestSent<P>, ProtocolError<P>>
    where
        T: FrameTransmitter,
    {
        tx_terminate_req::<P, _>(transmitter, self.sent_identifier + 1).await?;
        Err(ProtocolError::FatalConfigureRej(options.to_vec()))
    }
}