fix(connector)!: introduce sspi-free SequenceError

crates/ironrdp-acceptor/src/channel_connection.rs

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 
 use ironrdp_connector::{
-    ConnectorError, ConnectorErrorExt as _, ConnectorResult, MonotonicInstant, Sequence, State, Written, reason_err,
+    MonotonicInstant, Sequence, SequenceError, SequenceErrorExt as _, SequenceResult, State, Written, reason_err,
 };
 use ironrdp_core::WriteBuf;
 use ironrdp_pdu::mcs;
@@ -77,11 +77,11 @@ impl Sequence for ChannelConnectionSequence {
         input: &[u8],
         _received_at: Option<MonotonicInstant>,
         output: &mut WriteBuf,
-    ) -> ConnectorResult<Written> {
+    ) -> SequenceResult<Written> {
         let (written, next_state) = match core::mem::take(&mut self.state) {
             ChannelConnectionState::WaitErectDomainRequest => {
                 let erect_domain_request = ironrdp_core::decode::<X224<mcs::ErectDomainPdu>>(input)
-                    .map_err(ConnectorError::decode)
+                    .map_err(SequenceError::decode)
                     .map(|p| p.0)?;
 
                 debug!(message = ?erect_domain_request, "Received");
@@ -91,7 +91,7 @@ impl Sequence for ChannelConnectionSequence {
 
             ChannelConnectionState::WaitAttachUserRequest => {
                 let attach_user_request = ironrdp_core::decode::<X224<mcs::AttachUserRequest>>(input)
-                    .map_err(ConnectorError::decode)
+                    .map_err(SequenceError::decode)
                     .map(|p| p.0)?;
 
                 debug!(message = ?attach_user_request, "Received");
@@ -108,7 +108,7 @@ impl Sequence for ChannelConnectionSequence {
                 debug!(message = ?attach_user_confirm, "Send");
 
                 let written =
-                    ironrdp_core::encode_buf(&X224(attach_user_confirm), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(attach_user_confirm), output).map_err(SequenceError::encode)?;
 
                 let next_state = match self.channel_ids.take() {
                     Some(channel_ids) => ChannelConnectionState::WaitChannelJoinRequest { remaining: channel_ids },
@@ -120,7 +120,7 @@ impl Sequence for ChannelConnectionSequence {
 
             ChannelConnectionState::WaitChannelJoinRequest { mut remaining } => {
                 let channel_request = ironrdp_core::decode::<X224<mcs::ChannelJoinRequest>>(input)
-                    .map_err(ConnectorError::decode)
+                    .map_err(SequenceError::decode)
                     .map(|p| p.0)?;
 
                 debug!(message = ?channel_request, "Received");
@@ -156,7 +156,7 @@ impl Sequence for ChannelConnectionSequence {
                 debug!(message = ?channel_confirm, "Send");
 
                 let written =
-                    ironrdp_core::encode_buf(&X224(channel_confirm), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(channel_confirm), output).map_err(SequenceError::encode)?;
 
                 let next_state = if remaining.is_empty() {
                     ChannelConnectionState::AllJoined

crates/ironrdp-acceptor/src/connection.rs

@@ -2,7 +2,7 @@ use core::any::TypeId;
 use core::mem;
 
 use ironrdp_connector::{
-    ConnectorError, ConnectorErrorExt as _, ConnectorResult, DesktopSize, MonotonicInstant, Sequence, State, Written,
+    DesktopSize, MonotonicInstant, Sequence, SequenceError, SequenceErrorExt as _, SequenceResult, State, Written,
     encode_x224_packet, general_err, reason_err,
 };
 use ironrdp_core::{WriteBuf, decode};
@@ -215,7 +215,7 @@ impl Acceptor {
         mut consumed: Acceptor,
         static_channels: StaticChannelSet,
         desktop_size: DesktopSize,
-    ) -> ConnectorResult<Self> {
+    ) -> SequenceResult<Self> {
         let AcceptorState::CapabilitiesSendServer {
             early_capability,
             channels,
@@ -486,13 +486,13 @@ impl Sequence for Acceptor {
         input: &[u8],
         received_at: Option<MonotonicInstant>,
         output: &mut WriteBuf,
-    ) -> ConnectorResult<Written> {
+    ) -> SequenceResult<Written> {
         let prev_state = mem::take(&mut self.state);
 
         let (written, next_state) = match prev_state {
             AcceptorState::InitiationWaitRequest => {
                 let connection_request = decode::<X224<nego::ConnectionRequest>>(input)
-                    .map_err(ConnectorError::decode)
+                    .map_err(SequenceError::decode)
                     .map(|p| p.0)?;
 
                 debug!(message = ?connection_request, "Received");
@@ -533,7 +533,7 @@ impl Sequence for Acceptor {
 
                     debug!(message = ?failure, "Send");
 
-                    ironrdp_core::encode_buf(&X224(failure), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(failure), output).map_err(SequenceError::encode)?;
 
                     return Err(reason_err!(
                         "security protocol mismatch",
@@ -550,7 +550,7 @@ impl Sequence for Acceptor {
                 debug!(message = ?connection_confirm, "Send");
 
                 let written =
-                    ironrdp_core::encode_buf(&X224(connection_confirm), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(connection_confirm), output).map_err(SequenceError::encode)?;
 
                 (
                     Written::from_size(written)?,
@@ -596,10 +596,10 @@ impl Sequence for Acceptor {
                 protocol,
             } => {
                 let x224_payload = decode::<X224<pdu::x224::X224Data<'_>>>(input)
-                    .map_err(ConnectorError::decode)
+                    .map_err(SequenceError::decode)
                     .map(|p| p.0)?;
                 let settings_initial =
-                    decode::<mcs::ConnectInitial>(x224_payload.data.as_ref()).map_err(ConnectorError::decode)?;
+                    decode::<mcs::ConnectInitial>(x224_payload.data.as_ref()).map_err(SequenceError::decode)?;
 
                 debug!(message = ?settings_initial, "Received");
 
@@ -721,7 +721,7 @@ impl Sequence for Acceptor {
 
                 let settings_response = mcs::ConnectResponse {
                     conference_create_response: gcc::ConferenceCreateResponse::new(self.user_channel_id, server_blocks)
-                        .map_err(ConnectorError::decode)?,
+                        .map_err(SequenceError::decode)?,
                     called_connect_id: 1,
                     domain_parameters: mcs::DomainParameters::target(),
                 };
@@ -792,10 +792,9 @@ impl Sequence for Acceptor {
                 early_capability,
                 channels,
             } => {
-                let data: X224<mcs::SendDataRequest<'_>> = decode(input).map_err(ConnectorError::decode)?;
+                let data: X224<mcs::SendDataRequest<'_>> = decode(input).map_err(SequenceError::decode)?;
                 let data = data.0;
-                let client_info: rdp::ClientInfoPdu =
-                    decode(data.user_data.as_ref()).map_err(ConnectorError::decode)?;
+                let client_info: rdp::ClientInfoPdu = decode(data.user_data.as_ref()).map_err(SequenceError::decode)?;
 
                 let auto_reconnect = client_info
                     .client_info
@@ -824,7 +823,7 @@ impl Sequence for Acceptor {
 
                             util::encode_send_data_indication(self.user_channel_id, self.io_channel_id, &info, output)?;
 
-                            return Err(ConnectorError::general("invalid credentials"));
+                            return Err(general_err!("invalid credentials"));
                         }
                     }
 
@@ -846,7 +845,7 @@ impl Sequence for Acceptor {
                 channels,
             } => {
                 let license: LicensePdu = LicensingErrorMessage::new_valid_client()
-                    .map_err(ConnectorError::encode)?
+                    .map_err(SequenceError::encode)?
                     .into();
 
                 debug!(message = ?license, "Send");
@@ -929,7 +928,7 @@ impl Sequence for Acceptor {
 
             AcceptorState::CapabilitiesWaitConfirm { ref channels } => {
                 let message = decode::<X224<mcs::McsMessage<'_>>>(input)
-                    .map_err(ConnectorError::decode)
+                    .map_err(SequenceError::decode)
                     .map(|p| p.0);
                 let message = match message {
                     Ok(msg) => msg,
@@ -946,7 +945,7 @@ impl Sequence for Acceptor {
                 match message {
                     mcs::McsMessage::SendDataRequest(data) => {
                         let capabilities_confirm = decode::<rdp::headers::ShareControlHeader>(data.user_data.as_ref())
-                            .map_err(ConnectorError::decode);
+                            .map_err(SequenceError::decode);
                         let capabilities_confirm = match capabilities_confirm {
                             Ok(capabilities_confirm) => capabilities_confirm,
                             Err(e) => {
@@ -964,7 +963,7 @@ impl Sequence for Acceptor {
 
                         let ShareControlPdu::ClientConfirmActive(confirm) = capabilities_confirm.share_control_pdu
                         else {
-                            return Err(ConnectorError::general("expected client confirm active"));
+                            return Err(general_err!("expected client confirm active"));
                         };
 
                         (

crates/ironrdp-acceptor/src/credssp.rs

@@ -5,7 +5,7 @@ use ironrdp_connector::sspi::credssp::{
 use ironrdp_connector::sspi::generator::{Generator, GeneratorState};
 use ironrdp_connector::sspi::{self, AuthIdentity, KerberosServerConfig, NegotiateConfig, NetworkRequest, Username};
 use ironrdp_connector::{
-    ConnectorError, ConnectorErrorKind, ConnectorResult, ServerName, Written, custom_err, general_err,
+    ConnectorError, ConnectorErrorKind, ConnectorResult, ResultExt as _, ServerName, Written, custom_err, general_err,
 };
 use ironrdp_core::{WriteBuf, other_err};
 use ironrdp_pdu::PduHint;
@@ -97,7 +97,9 @@ impl<'a> CredsspSequence<'a> {
         match &self.state {
             CredsspState::Ongoing => Ok(Some(&CREDSSP_TS_REQUEST_HINT)),
             CredsspState::Finished => Ok(None),
-            CredsspState::ServerError(err) => Err(custom_err!("Credssp server error", err.clone())),
+            CredsspState::ServerError(err) => {
+                Err(custom_err!("Credssp server error", err.clone())).map_err_as::<ConnectorErrorKind>()
+            }
         }
     }
 
@@ -135,13 +137,16 @@ impl<'a> CredsspSequence<'a> {
     pub fn decode_client_message(&mut self, input: &[u8]) -> ConnectorResult<Option<TsRequest>> {
         match self.state {
             CredsspState::Ongoing => {
-                let message = TsRequest::from_buffer(input).map_err(|e| custom_err!("TsRequest", e))?;
+                let message = TsRequest::from_buffer(input)
+                    .map_err(|e| custom_err!("TsRequest", e))
+                    .map_err_as::<ConnectorErrorKind>()?;
                 debug!(?message, "Received");
                 Ok(Some(message))
             }
             _ => Err(general_err!(
                 "attempted to feed client request to CredSSP sequence in an unexpected state"
-            )),
+            ))
+            .map_err_as::<ConnectorErrorKind>(),
         }
     }
 
@@ -171,11 +176,12 @@ impl<'a> CredsspSequence<'a> {
 
             ts_request
                 .encode_ts_request(unfilled_buffer)
-                .map_err(|e| custom_err!("TsRequest", e))?;
+                .map_err(|e| custom_err!("TsRequest", e))
+                .map_err_as::<ConnectorErrorKind>()?;
 
             output.advance(length);
 
-            Ok(Written::from_size(length)?)
+            Ok(Written::from_size(length).map_err_as::<ConnectorErrorKind>()?)
         } else {
             Ok(Written::Nothing)
         }

crates/ironrdp-acceptor/src/finalization.rs

@@ -1,5 +1,5 @@
 use ironrdp_connector::{
-    ConnectorError, ConnectorErrorExt as _, ConnectorResult, MonotonicInstant, Sequence, State, Written,
+    MonotonicInstant, Sequence, SequenceError, SequenceErrorExt as _, SequenceResult, State, Written,
 };
 use ironrdp_core::WriteBuf;
 use ironrdp_pdu::rdp;
@@ -85,7 +85,7 @@ impl Sequence for FinalizationSequence {
         input: &[u8],
         _received_at: Option<MonotonicInstant>,
         output: &mut WriteBuf,
-    ) -> ConnectorResult<Written> {
+    ) -> SequenceResult<Written> {
         let (written, next_state) = match core::mem::take(&mut self.state) {
             FinalizationState::WaitSynchronize => {
                 let synchronize = decode_share_control(input);
@@ -230,12 +230,12 @@ fn create_font_map() -> rdp::headers::ShareDataPdu {
     rdp::headers::ShareDataPdu::FontMap(rdp::finalization_messages::FontPdu::default())
 }
 
-fn decode_share_control(input: &[u8]) -> ConnectorResult<rdp::headers::ShareControlHeader> {
+fn decode_share_control(input: &[u8]) -> SequenceResult<rdp::headers::ShareControlHeader> {
     let data_request = ironrdp_core::decode::<X224<ironrdp_pdu::mcs::SendDataRequest<'_>>>(input)
-        .map_err(ConnectorError::decode)
+        .map_err(SequenceError::decode)
         .map(|p| p.0)?;
     let share_control = ironrdp_core::decode::<rdp::headers::ShareControlHeader>(data_request.user_data.as_ref())
-        .map_err(ConnectorError::decode)?;
+        .map_err(SequenceError::decode)?;
     Ok(share_control)
 }
 

crates/ironrdp-acceptor/src/lib.rs

@@ -4,7 +4,7 @@
 use ironrdp_async::{Framed, FramedRead, FramedWrite, NetworkClient, StreamWrapper, single_sequence_step};
 use ironrdp_connector::sspi::credssp::EarlyUserAuthResult;
 use ironrdp_connector::sspi::{AuthIdentity, KerberosServerConfig, Username};
-use ironrdp_connector::{ConnectorResult, ServerName, custom_err, general_err};
+use ironrdp_connector::{ConnectorErrorKind, ConnectorResult, ResultExt as _, ServerName, custom_err, general_err};
 use ironrdp_core::WriteBuf;
 use tracing::{debug, instrument, trace};
 
@@ -47,7 +47,9 @@ where
             return Ok(result);
         }
 
-        single_sequence_step(&mut framed, acceptor, &mut buf).await?;
+        single_sequence_step(&mut framed, acceptor, &mut buf)
+            .await
+            .map_err_as::<ConnectorErrorKind>()?;
     }
 }
 
@@ -94,7 +96,9 @@ where
         if let Some(result) = acceptor.get_result() {
             return Ok((framed, result));
         }
-        single_sequence_step(&mut framed, acceptor, &mut buf).await?;
+        single_sequence_step(&mut framed, acceptor, &mut buf)
+            .await
+            .map_err_as::<ConnectorErrorKind>()?;
     }
 }
 
@@ -140,12 +144,14 @@ where
         buf.clear();
         result
             .to_buffer(&mut *buf)
-            .map_err(|e| ironrdp_connector::custom_err!("to_buffer", e))?;
+            .map_err(|e| ironrdp_connector::custom_err!("to_buffer", e))
+            .map_err_as::<ConnectorErrorKind>()?;
         let response = &buf[..result.buffer_len()];
         framed
             .write_all(response)
             .await
-            .map_err(|e| ironrdp_connector::custom_err!("write all", e))?;
+            .map_err(|e| ironrdp_connector::custom_err!("write all", e))
+            .map_err_as::<ConnectorErrorKind>()?;
     }
 
     result?;
@@ -170,8 +176,11 @@ where
         let creds = acceptor
             .creds
             .as_ref()
-            .ok_or_else(|| general_err!("no credentials while doing credssp"))?;
-        let username = Username::new(&creds.username, None).map_err(|e| custom_err!("invalid username", e))?;
+            .ok_or_else(|| general_err!("no credentials while doing credssp"))
+            .map_err_as::<ConnectorErrorKind>()?;
+        let username = Username::new(&creds.username, None)
+            .map_err(|e| custom_err!("invalid username", e))
+            .map_err_as::<ConnectorErrorKind>()?;
         let identity = AuthIdentity {
             username,
             password: creds.password.clone().into(),
@@ -194,7 +203,8 @@ where
             let pdu = framed
                 .read_by_hint(next_pdu_hint)
                 .await
-                .map_err(|e| ironrdp_connector::custom_err!("read frame by hint", e))?;
+                .map_err(|e| ironrdp_connector::custom_err!("read frame by hint", e))
+                .map_err_as::<ConnectorErrorKind>()?;
 
             trace!(length = pdu.len(), "PDU received");
 
@@ -216,7 +226,8 @@ where
                 framed
                     .write_all(response)
                     .await
-                    .map_err(|e| ironrdp_connector::custom_err!("write all", e))?;
+                    .map_err(|e| ironrdp_connector::custom_err!("write all", e))
+                    .map_err_as::<ConnectorErrorKind>()?;
             }
         }
 

crates/ironrdp-acceptor/src/util.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use ironrdp_connector::{ConnectorError, ConnectorErrorExt as _, ConnectorResult};
+use ironrdp_connector::{SequenceError, SequenceErrorExt as _, SequenceResult};
 use ironrdp_core::{Encode, WriteBuf, encode_vec};
 use ironrdp_pdu::rdp;
 use ironrdp_pdu::x224::X224;
@@ -10,19 +10,19 @@ pub(crate) fn encode_send_data_indication<T>(
     channel_id: u16,
     user_msg: &T,
     buf: &mut WriteBuf,
-) -> ConnectorResult<usize>
+) -> SequenceResult<usize>
 where
     T: Encode,
 {
-    let user_data = encode_vec(user_msg).map_err(ConnectorError::encode)?;
+    let user_data = encode_vec(user_msg).map_err(SequenceError::encode)?;
 
     let pdu = ironrdp_pdu::mcs::SendDataIndication {
         initiator_id,
         channel_id,
         user_data: Cow::Owned(user_data),
     };
 
-    let written = ironrdp_core::encode_buf(&X224(pdu), buf).map_err(ConnectorError::encode)?;
+    let written = ironrdp_core::encode_buf(&X224(pdu), buf).map_err(SequenceError::encode)?;
 
     Ok(written)
 }