fix(pdu)!: remove unused legacy error types (Devolutions#1268)

Remove GccError, McsError, RdpError, SecurityDataError,
ClusterDataError, NetworkDataError, CoreDataError, InputEventError,
ClientInfoError, CapabilitySetsError, SessionError, and ChannelError.
All encode/decode functions had already been migrated to use
DecodeResult/EncodeResult from ironrdp-core, leaving these error types
as dead code.

Author: CBenoit

crates/ironrdp-pdu/src/gcc/cluster_data.rs

@@ -1,6 +1,3 @@
-use core::fmt;
-use std::io;
-
 use bitflags::bitflags;
 use ironrdp_core::{
     Decode, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor, ensure_fixed_part_size, invalid_field_err,
@@ -96,33 +93,3 @@ impl RedirectionVersion {
         self as u32
     }
 }
-
-#[derive(Debug)]
-pub enum ClusterDataError {
-    IOError(io::Error),
-    InvalidRedirectionFlags,
-}
-
-impl fmt::Display for ClusterDataError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::IOError(_) => f.write_str("IO error"),
-            Self::InvalidRedirectionFlags => f.write_str("invalid redirection flags field"),
-        }
-    }
-}
-
-impl core::error::Error for ClusterDataError {
-    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
-        match self {
-            Self::IOError(e) => Some(e),
-            Self::InvalidRedirectionFlags => None,
-        }
-    }
-}
-
-impl From<io::Error> for ClusterDataError {
-    fn from(e: io::Error) -> Self {
-        Self::IOError(e)
-    }
-}

crates/ironrdp-pdu/src/gcc/core_data/mod.rs

@@ -1,11 +1,6 @@
 pub(crate) mod client;
 pub(crate) mod server;
 
-use core::fmt;
-use std::io;
-
-use crate::PduError;
-
 const VERSION_SIZE: usize = 4;
 
 #[repr(transparent)]
@@ -41,69 +36,3 @@ impl RdpVersion {
     pub const V10_11: Self = Self(0x0008_0010);
     pub const V10_12: Self = Self(0x0008_0011);
 }
-
-#[derive(Debug)]
-pub enum CoreDataError {
-    IOError(io::Error),
-    InvalidVersion,
-    InvalidColorDepth,
-    InvalidPostBetaColorDepth,
-    InvalidHighColorDepth,
-    InvalidSupportedColorDepths,
-    InvalidSecureAccessSequence,
-    InvalidKeyboardType,
-    InvalidEarlyCapabilityFlags,
-    InvalidConnectionType,
-    InvalidServerSecurityProtocol,
-    Pdu(PduError),
-}
-
-impl fmt::Display for CoreDataError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::IOError(_) => f.write_str("IO error"),
-            Self::InvalidVersion => f.write_str("invalid version field"),
-            Self::InvalidColorDepth => f.write_str("invalid color depth field"),
-            Self::InvalidPostBetaColorDepth => f.write_str("invalid post beta color depth field"),
-            Self::InvalidHighColorDepth => f.write_str("invalid high color depth field"),
-            Self::InvalidSupportedColorDepths => f.write_str("invalid supported color depths field"),
-            Self::InvalidSecureAccessSequence => f.write_str("invalid secure access sequence field"),
-            Self::InvalidKeyboardType => f.write_str("invalid keyboard type field"),
-            Self::InvalidEarlyCapabilityFlags => f.write_str("invalid early capability flags field"),
-            Self::InvalidConnectionType => f.write_str("invalid connection type field"),
-            Self::InvalidServerSecurityProtocol => f.write_str("invalid server security protocol field"),
-            Self::Pdu(e) => write!(f, "PDU error: {e}"),
-        }
-    }
-}
-
-impl core::error::Error for CoreDataError {
-    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
-        match self {
-            Self::IOError(e) => Some(e),
-            Self::InvalidVersion
-            | Self::InvalidColorDepth
-            | Self::InvalidPostBetaColorDepth
-            | Self::InvalidHighColorDepth
-            | Self::InvalidSupportedColorDepths
-            | Self::InvalidSecureAccessSequence
-            | Self::InvalidKeyboardType
-            | Self::InvalidEarlyCapabilityFlags
-            | Self::InvalidConnectionType
-            | Self::InvalidServerSecurityProtocol
-            | Self::Pdu(_) => None,
-        }
-    }
-}
-
-impl From<io::Error> for CoreDataError {
-    fn from(e: io::Error) -> Self {
-        Self::IOError(e)
-    }
-}
-
-impl From<PduError> for CoreDataError {
-    fn from(e: PduError) -> Self {
-        Self::Pdu(e)
-    }
-}

crates/ironrdp-pdu/src/gcc/mod.rs

@@ -1,15 +1,10 @@
-use core::fmt;
-use std::io;
-
 use ironrdp_core::{
     Decode, DecodeErrorKind, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor, cast_length, decode,
     ensure_fixed_part_size, ensure_size, invalid_field_err,
 };
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
 
-use crate::PduError;
-
 pub mod conference_create;
 
 mod cluster_data;
@@ -21,26 +16,22 @@ mod multi_transport_channel_data;
 mod network_data;
 mod security_data;
 
-pub use self::cluster_data::{ClientClusterData, ClusterDataError, RedirectionFlags, RedirectionVersion};
+pub use self::cluster_data::{ClientClusterData, RedirectionFlags, RedirectionVersion};
 pub use self::conference_create::{ConferenceCreateRequest, ConferenceCreateResponse};
+pub use self::core_data::RdpVersion;
 pub use self::core_data::client::{
     ClientColorDepth, ClientCoreData, ClientCoreOptionalData, ClientEarlyCapabilityFlags, ColorDepth, ConnectionType,
     HighColorDepth, IME_FILE_NAME_SIZE, KeyboardType, SecureAccessSequence, SupportedColorDepths,
 };
 pub use self::core_data::server::{ServerCoreData, ServerCoreOptionalData, ServerEarlyCapabilityFlags};
-pub use self::core_data::{CoreDataError, RdpVersion};
 pub use self::message_channel_data::{ClientMessageChannelData, ServerMessageChannelData};
 pub use self::monitor_data::{
     ClientMonitorData, MONITOR_COUNT_SIZE, MONITOR_FLAGS_SIZE, MONITOR_SIZE, Monitor, MonitorFlags,
 };
 pub use self::monitor_extended_data::{ClientMonitorExtendedData, ExtendedMonitorInfo, MonitorOrientation};
 pub use self::multi_transport_channel_data::{MultiTransportChannelData, MultiTransportFlags};
-pub use self::network_data::{
-    ChannelDef, ChannelName, ChannelOptions, ClientNetworkData, NetworkDataError, ServerNetworkData,
-};
-pub use self::security_data::{
-    ClientSecurityData, EncryptionLevel, EncryptionMethod, SecurityDataError, ServerSecurityData,
-};
+pub use self::network_data::{ChannelDef, ChannelName, ChannelOptions, ClientNetworkData, ServerNetworkData};
+pub use self::security_data::{ClientSecurityData, EncryptionLevel, EncryptionMethod, ServerSecurityData};
 
 macro_rules! user_header_try {
     ($e:expr) => {
@@ -355,94 +346,3 @@ impl UserDataHeader {
         Ok((block_type, src.read_slice(len)))
     }
 }
-
-#[derive(Debug)]
-pub enum GccError {
-    IOError(io::Error),
-    CoreError(CoreDataError),
-    SecurityError(SecurityDataError),
-    NetworkError(NetworkDataError),
-    ClusterError(ClusterDataError),
-    InvalidGccType,
-    InvalidConferenceCreateRequest(String),
-    InvalidConferenceCreateResponse(String),
-    RequiredClientDataBlockIsAbsent(ClientGccType),
-    RequiredServerDataBlockIsAbsent(ServerGccType),
-    Pdu(PduError),
-}
-
-impl fmt::Display for GccError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::IOError(_) => f.write_str("IO error"),
-            Self::CoreError(_) => f.write_str("core data block error"),
-            Self::SecurityError(_) => f.write_str("security data block error"),
-            Self::NetworkError(_) => f.write_str("network data block error"),
-            Self::ClusterError(_) => f.write_str("cluster data block error"),
-            Self::InvalidGccType => f.write_str("invalid GCC block type"),
-            Self::InvalidConferenceCreateRequest(s) => write!(f, "invalid conference create request: {s}"),
-            Self::InvalidConferenceCreateResponse(s) => write!(f, "invalid Conference create response: {s}"),
-            Self::RequiredClientDataBlockIsAbsent(ty) => {
-                write!(f, "a server did not send the required GCC data block: {ty:?}")
-            }
-            Self::RequiredServerDataBlockIsAbsent(ty) => {
-                write!(f, "a client did not send the required GCC data block: {ty:?}")
-            }
-            Self::Pdu(e) => write!(f, "PDU error: {e}"),
-        }
-    }
-}
-
-impl core::error::Error for GccError {
-    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
-        match self {
-            Self::IOError(e) => Some(e),
-            Self::CoreError(e) => Some(e),
-            Self::SecurityError(e) => Some(e),
-            Self::NetworkError(e) => Some(e),
-            Self::ClusterError(e) => Some(e),
-            Self::InvalidGccType
-            | Self::InvalidConferenceCreateRequest(_)
-            | Self::InvalidConferenceCreateResponse(_)
-            | Self::RequiredClientDataBlockIsAbsent(_)
-            | Self::RequiredServerDataBlockIsAbsent(_)
-            | Self::Pdu(_) => None,
-        }
-    }
-}
-
-impl From<io::Error> for GccError {
-    fn from(e: io::Error) -> Self {
-        Self::IOError(e)
-    }
-}
-
-impl From<CoreDataError> for GccError {
-    fn from(e: CoreDataError) -> Self {
-        Self::CoreError(e)
-    }
-}
-
-impl From<SecurityDataError> for GccError {
-    fn from(e: SecurityDataError) -> Self {
-        Self::SecurityError(e)
-    }
-}
-
-impl From<NetworkDataError> for GccError {
-    fn from(e: NetworkDataError) -> Self {
-        Self::NetworkError(e)
-    }
-}
-
-impl From<ClusterDataError> for GccError {
-    fn from(e: ClusterDataError) -> Self {
-        Self::ClusterError(e)
-    }
-}
-
-impl From<PduError> for GccError {
-    fn from(e: PduError) -> Self {
-        Self::Pdu(e)
-    }
-}

crates/ironrdp-pdu/src/gcc/network_data.rs

@@ -1,6 +1,5 @@
-use core::fmt;
 use std::borrow::Cow;
-use std::{io, str};
+use std::str;
 
 use bitflags::bitflags;
 use ironrdp_core::{
@@ -288,44 +287,3 @@ bitflags! {
         const REMOTE_CONTROL_PERSISTENT = 0x0010_0000;
     }
 }
-
-#[derive(Debug)]
-pub enum NetworkDataError {
-    IOError(io::Error),
-    Utf8Error(str::Utf8Error),
-    InvalidChannelOptions,
-    InvalidChannelCount,
-}
-
-impl fmt::Display for NetworkDataError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::IOError(_) => f.write_str("IO error"),
-            Self::Utf8Error(_) => f.write_str("UTF-8 error"),
-            Self::InvalidChannelOptions => f.write_str("invalid channel options field"),
-            Self::InvalidChannelCount => f.write_str("invalid channel count field"),
-        }
-    }
-}
-
-impl core::error::Error for NetworkDataError {
-    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
-        match self {
-            Self::IOError(e) => Some(e),
-            Self::Utf8Error(e) => Some(e),
-            Self::InvalidChannelOptions | Self::InvalidChannelCount => None,
-        }
-    }
-}
-
-impl From<io::Error> for NetworkDataError {
-    fn from(e: io::Error) -> Self {
-        Self::IOError(e)
-    }
-}
-
-impl From<str::Utf8Error> for NetworkDataError {
-    fn from(e: str::Utf8Error) -> Self {
-        Self::Utf8Error(e)
-    }
-}

crates/ironrdp-pdu/src/gcc/security_data.rs

@@ -1,6 +1,3 @@
-use core::fmt;
-use std::io;
-
 use bitflags::bitflags;
 use ironrdp_core::{
     Decode, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor, cast_length, ensure_fixed_part_size,
@@ -218,45 +215,3 @@ impl EncryptionLevel {
         self as u32
     }
 }
-
-#[derive(Debug)]
-pub enum SecurityDataError {
-    IOError(io::Error),
-    InvalidEncryptionMethod,
-    InvalidEncryptionLevel,
-    InvalidServerRandomLen(u32),
-    InvalidInput(String),
-    InvalidServerCertificateLen(u32),
-}
-
-impl fmt::Display for SecurityDataError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::IOError(_) => f.write_str("IO error"),
-            Self::InvalidEncryptionMethod => f.write_str("invalid encryption methods field"),
-            Self::InvalidEncryptionLevel => f.write_str("invalid encryption level field"),
-            Self::InvalidServerRandomLen(n) => write!(f, "invalid server random length field: {n}"),
-            Self::InvalidInput(s) => write!(f, "invalid input: {s}"),
-            Self::InvalidServerCertificateLen(n) => write!(f, "invalid server certificate length: {n}"),
-        }
-    }
-}
-
-impl core::error::Error for SecurityDataError {
-    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
-        match self {
-            Self::IOError(e) => Some(e),
-            Self::InvalidEncryptionMethod
-            | Self::InvalidEncryptionLevel
-            | Self::InvalidServerRandomLen(_)
-            | Self::InvalidInput(_)
-            | Self::InvalidServerCertificateLen(_) => None,
-        }
-    }
-}
-
-impl From<io::Error> for SecurityDataError {
-    fn from(e: io::Error) -> Self {
-        Self::IOError(e)
-    }
-}