refactor(core): move Encode/Decode to core

ironrdp-pdu contains lots of code that we don’t actually need in other crates such as the virtual channels.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Cargo.lock

@@ -2185,6 +2185,7 @@ dependencies = [
  "arbitrary",
  "ironrdp-cliprdr",
  "ironrdp-cliprdr-format",
+ "ironrdp-core",
  "ironrdp-displaycontrol",
  "ironrdp-graphics",
  "ironrdp-pdu",

crates/ironrdp-acceptor/src/channel_connection.rs

@@ -72,7 +72,7 @@ impl Sequence for ChannelConnectionSequence {
     fn step(&mut self, input: &[u8], output: &mut WriteBuf) -> ConnectorResult<Written> {
         let (written, next_state) = match std::mem::take(&mut self.state) {
             ChannelConnectionState::WaitErectDomainRequest => {
-                let erect_domain_request = ironrdp_pdu::decode::<X224<mcs::ErectDomainPdu>>(input)
+                let erect_domain_request = ironrdp_core::decode::<X224<mcs::ErectDomainPdu>>(input)
                     .map_err(ConnectorError::decode)
                     .map(|p| p.0)?;
 
@@ -82,7 +82,7 @@ impl Sequence for ChannelConnectionSequence {
             }
 
             ChannelConnectionState::WaitAttachUserRequest => {
-                let attach_user_request = ironrdp_pdu::decode::<X224<mcs::AttachUserRequest>>(input)
+                let attach_user_request = ironrdp_core::decode::<X224<mcs::AttachUserRequest>>(input)
                     .map_err(ConnectorError::decode)
                     .map(|p| p.0)?;
 
@@ -100,7 +100,7 @@ impl Sequence for ChannelConnectionSequence {
                 debug!(message = ?attach_user_confirm, "Send");
 
                 let written =
-                    ironrdp_pdu::encode_buf(&X224(attach_user_confirm), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(attach_user_confirm), output).map_err(ConnectorError::encode)?;
 
                 let next_state = match self.channel_ids.take() {
                     Some(channel_ids) => ChannelConnectionState::WaitChannelJoinRequest { remaining: channel_ids },
@@ -111,7 +111,7 @@ impl Sequence for ChannelConnectionSequence {
             }
 
             ChannelConnectionState::WaitChannelJoinRequest { mut remaining } => {
-                let channel_request = ironrdp_pdu::decode::<X224<mcs::ChannelJoinRequest>>(input)
+                let channel_request = ironrdp_core::decode::<X224<mcs::ChannelJoinRequest>>(input)
                     .map_err(ConnectorError::decode)
                     .map(|p| p.0)?;
 
@@ -148,7 +148,7 @@ impl Sequence for ChannelConnectionSequence {
                 debug!(message = ?channel_confirm, "Send");
 
                 let written =
-                    ironrdp_pdu::encode_buf(&X224(channel_confirm), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(channel_confirm), output).map_err(ConnectorError::encode)?;
 
                 let next_state = if remaining.is_empty() {
                     ChannelConnectionState::AllJoined

crates/ironrdp-acceptor/src/connection.rs

@@ -5,6 +5,7 @@ use ironrdp_connector::{
     encode_x224_packet, reason_err, ConnectorError, ConnectorErrorExt, ConnectorResult, DesktopSize, Sequence, State,
     Written,
 };
+use ironrdp_core::decode;
 use ironrdp_core::WriteBuf;
 use ironrdp_pdu as pdu;
 use ironrdp_pdu::x224::X224;
@@ -12,7 +13,7 @@ use ironrdp_svc::{StaticChannelSet, SvcServerProcessor};
 use pdu::rdp::capability_sets::CapabilitySet;
 use pdu::rdp::headers::ShareControlPdu;
 use pdu::rdp::server_license::{LicensePdu, LicensingErrorMessage};
-use pdu::{decode, gcc, mcs, nego, rdp};
+use pdu::{gcc, mcs, nego, rdp};
 
 use super::channel_connection::ChannelConnectionSequence;
 use super::finalization::FinalizationSequence;
@@ -276,7 +277,7 @@ impl Sequence for Acceptor {
                 debug!(message = ?connection_confirm, "Send");
 
                 let written =
-                    ironrdp_pdu::encode_buf(&X224(connection_confirm), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(connection_confirm), output).map_err(ConnectorError::encode)?;
 
                 (
                     Written::from_size(written)?,

crates/ironrdp-acceptor/src/finalization.rs

@@ -219,10 +219,10 @@ fn create_font_map() -> rdp::headers::ShareDataPdu {
 }
 
 fn decode_share_control(input: &[u8]) -> ConnectorResult<rdp::headers::ShareControlHeader> {
-    let data_request = pdu::decode::<X224<pdu::mcs::SendDataRequest<'_>>>(input)
+    let data_request = ironrdp_core::decode::<X224<pdu::mcs::SendDataRequest<'_>>>(input)
         .map_err(ConnectorError::decode)
         .map(|p| p.0)?;
-    let share_control = pdu::decode::<rdp::headers::ShareControlHeader>(data_request.user_data.as_ref())
+    let share_control = ironrdp_core::decode::<rdp::headers::ShareControlHeader>(data_request.user_data.as_ref())
         .map_err(ConnectorError::decode)?;
     Ok(share_control)
 }

crates/ironrdp-acceptor/src/util.rs

@@ -1,8 +1,8 @@
 use std::borrow::Cow;
 
 use ironrdp_connector::{ConnectorError, ConnectorErrorExt, ConnectorResult};
-use ironrdp_core::WriteBuf;
-use ironrdp_pdu::{encode_vec, rdp, x224::X224, Encode};
+use ironrdp_core::{encode_vec, Encode, WriteBuf};
+use ironrdp_pdu::{rdp, x224::X224};
 
 pub(crate) fn encode_send_data_indication<T>(
     initiator_id: u16,
@@ -21,7 +21,7 @@ where
         user_data: Cow::Owned(user_data),
     };
 
-    let written = ironrdp_pdu::encode_buf(&X224(pdu), buf).map_err(ConnectorError::encode)?;
+    let written = ironrdp_core::encode_buf(&X224(pdu), buf).map_err(ConnectorError::encode)?;
 
     Ok(written)
 }

crates/ironrdp-ainput/src/lib.rs

@@ -4,7 +4,7 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive as _, ToPrimitive as _};
 
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, DecodeResult, EncodeResult, ReadCursor, WriteCursor};
-use ironrdp_pdu::{Decode, Encode};
+use ironrdp_core::{Decode, Encode};
 // Advanced Input channel as defined from Freerdp, [here]:
 //
 // [here]: https://github.com/FreeRDP/FreeRDP/blob/master/include/freerdp/channels/ainput.h

crates/ironrdp-cliprdr-format/src/bitmap.rs

@@ -1,7 +1,7 @@
 use ironrdp_core::{
     cast_int, ensure_fixed_part_size, invalid_field_err, DecodeResult, EncodeResult, ReadCursor, WriteCursor,
 };
-use ironrdp_pdu::{Decode, Encode};
+use ironrdp_core::{Decode, Encode};
 use thiserror::Error;
 
 /// Maximum size of PNG image that could be placed on the clipboard.

crates/ironrdp-cliprdr/src/lib.rs

@@ -9,9 +9,10 @@ pub mod backend;
 pub mod pdu;
 
 use backend::CliprdrBackend;
-use ironrdp_core::{AsAny, EncodeResult};
+use ironrdp_core::{decode, AsAny, EncodeResult};
 use ironrdp_pdu::gcc::ChannelName;
-use ironrdp_pdu::{decode, decode_err, encode_err, PduResult};
+use ironrdp_pdu::PduResult;
+use ironrdp_pdu::{decode_err, encode_err};
 use ironrdp_svc::{
     ChannelFlags, CompressionCondition, SvcClientProcessor, SvcMessage, SvcProcessor, SvcProcessorMessages,
     SvcServerProcessor,

crates/ironrdp-cliprdr/src/pdu/capabilities.rs

@@ -3,7 +3,8 @@ use ironrdp_core::{
     cast_int, cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, DecodeError, DecodeResult,
     EncodeResult, ReadCursor, WriteCursor,
 };
-use ironrdp_pdu::{impl_pdu_pod, read_padding, write_padding, Decode, Encode};
+use ironrdp_core::{Decode, Encode};
+use ironrdp_pdu::{impl_pdu_pod, read_padding, write_padding};
 
 use crate::pdu::PartialHeader;
 

crates/ironrdp-cliprdr/src/pdu/client_temporary_directory.rs

@@ -3,8 +3,9 @@ use std::borrow::Cow;
 use ironrdp_core::{
     cast_int, ensure_size, invalid_field_err, DecodeResult, EncodeResult, IntoOwned, ReadCursor, WriteCursor,
 };
+use ironrdp_core::{Decode, Encode};
+use ironrdp_pdu::impl_pdu_borrowing;
 use ironrdp_pdu::utils::{read_string_from_cursor, write_string_to_cursor, CharacterSet};
-use ironrdp_pdu::{impl_pdu_borrowing, Decode, Encode};
 
 use crate::pdu::PartialHeader;
 

crates/ironrdp-cliprdr/src/pdu/file_contents.rs

@@ -4,8 +4,9 @@ use bitflags::bitflags;
 use ironrdp_core::{
     cast_int, ensure_size, invalid_field_err, DecodeResult, EncodeResult, IntoOwned, ReadCursor, WriteCursor,
 };
+use ironrdp_core::{Decode, Encode};
+use ironrdp_pdu::impl_pdu_borrowing;
 use ironrdp_pdu::utils::{combine_u64, split_u64};
-use ironrdp_pdu::{impl_pdu_borrowing, Decode, Encode};
 
 use crate::pdu::{ClipboardPduFlags, PartialHeader};
 

crates/ironrdp-cliprdr/src/pdu/format_data/file_list.rs

@@ -1,7 +1,9 @@
 use bitflags::bitflags;
-use ironrdp_core::{cast_length, ensure_fixed_part_size, DecodeResult, EncodeResult, ReadCursor, WriteCursor};
+use ironrdp_core::{
+    cast_length, ensure_fixed_part_size, Decode, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor,
+};
 use ironrdp_pdu::utils::{combine_u64, decode_string, encode_string, split_u64, CharacterSet};
-use ironrdp_pdu::{impl_pdu_pod, write_padding, Decode, Encode};
+use ironrdp_pdu::{impl_pdu_pod, write_padding};
 
 const NAME_LENGTH: usize = 520;
 

crates/ironrdp-cliprdr/src/pdu/format_data/metafile.rs

@@ -1,8 +1,9 @@
 use std::borrow::Cow;
 
 use bitflags::bitflags;
-use ironrdp_core::{ensure_fixed_part_size, ensure_size, DecodeResult, EncodeResult, ReadCursor, WriteCursor};
-use ironrdp_pdu::{Decode, Encode};
+use ironrdp_core::{
+    ensure_fixed_part_size, ensure_size, Decode, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor,
+};
 
 bitflags! {
     /// Represents `mappingMode` fields of `CLIPRDR_MFPICT` structure.

crates/ironrdp-cliprdr/src/pdu/format_data/mod.rs

@@ -15,9 +15,9 @@ use ironrdp_core::ensure_size;
 use ironrdp_core::DecodeResult;
 use ironrdp_core::EncodeResult;
 use ironrdp_core::IntoOwned;
-use ironrdp_core::{ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, Encode, ReadCursor, WriteCursor};
+use ironrdp_pdu::impl_pdu_borrowing;
 use ironrdp_pdu::utils::{read_string_from_cursor, to_utf16_bytes, CharacterSet};
-use ironrdp_pdu::{impl_pdu_borrowing, Decode, Encode};
 
 use super::ClipboardFormatId;
 use crate::pdu::{ClipboardPduFlags, PartialHeader};

crates/ironrdp-cliprdr/src/pdu/format_data/palette.rs

@@ -1,5 +1,5 @@
-use ironrdp_core::{DecodeResult, EncodeResult, ReadCursor, WriteCursor};
-use ironrdp_pdu::{impl_pdu_pod, Decode, Encode};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor};
+use ironrdp_pdu::impl_pdu_pod;
 
 /// Represents `PALETTEENTRY`
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/ironrdp-cliprdr/src/pdu/format_list.rs

@@ -1,10 +1,11 @@
 use std::borrow::Cow;
 
 use ironrdp_core::{
-    cast_int, ensure_size, invalid_field_err, DecodeResult, EncodeResult, IntoOwned, ReadCursor, WriteCursor,
+    cast_int, ensure_size, invalid_field_err, Decode, DecodeResult, Encode, EncodeResult, IntoOwned, ReadCursor,
+    WriteCursor,
 };
 use ironrdp_pdu::utils::{read_string_from_cursor, to_utf16_bytes, write_string_to_cursor, CharacterSet};
-use ironrdp_pdu::{decode_err, impl_pdu_borrowing, impl_pdu_pod, Decode, Encode, PduResult};
+use ironrdp_pdu::{decode_err, impl_pdu_borrowing, impl_pdu_pod, PduResult};
 
 use crate::pdu::{ClipboardPduFlags, PartialHeader};
 

crates/ironrdp-cliprdr/src/pdu/lock.rs

@@ -1,5 +1,7 @@
-use ironrdp_core::{cast_int, ensure_fixed_part_size, DecodeResult, EncodeResult, ReadCursor, WriteCursor};
-use ironrdp_pdu::{impl_pdu_pod, Decode, Encode};
+use ironrdp_core::{
+    cast_int, ensure_fixed_part_size, Decode, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor,
+};
+use ironrdp_pdu::impl_pdu_pod;
 
 use crate::pdu::PartialHeader;
 

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

@@ -21,8 +21,7 @@ use ironrdp_core::ensure_fixed_part_size;
 use ironrdp_core::invalid_field_err;
 use ironrdp_core::DecodeResult;
 use ironrdp_core::EncodeResult;
-use ironrdp_core::{ReadCursor, WriteCursor};
-use ironrdp_pdu::{Decode, Encode};
+use ironrdp_core::{Decode, Encode, ReadCursor, WriteCursor};
 use ironrdp_svc::SvcEncode;
 
 const MSG_TYPE_MONITOR_READY: u16 = 0x0001;

crates/ironrdp-connector/src/channel_connection.rs

@@ -109,7 +109,7 @@ impl Sequence for ChannelConnectionSequence {
                 debug!(message = ?erect_domain_request, "Send");
 
                 let written =
-                    ironrdp_pdu::encode_buf(&X224(erect_domain_request), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(erect_domain_request), output).map_err(ConnectorError::encode)?;
 
                 (
                     Written::from_size(written)?,
@@ -123,7 +123,7 @@ impl Sequence for ChannelConnectionSequence {
                 debug!(message = ?attach_user_request, "Send");
 
                 let written =
-                    ironrdp_pdu::encode_buf(&X224(attach_user_request), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(attach_user_request), output).map_err(ConnectorError::encode)?;
 
                 (
                     Written::from_size(written)?,
@@ -132,7 +132,7 @@ impl Sequence for ChannelConnectionSequence {
             }
 
             ChannelConnectionState::WaitAttachUserConfirm => {
-                let attach_user_confirm = ironrdp_pdu::decode::<X224<mcs::AttachUserConfirm>>(input)
+                let attach_user_confirm = ironrdp_core::decode::<X224<mcs::AttachUserConfirm>>(input)
                     .map_err(ConnectorError::decode)
                     .map(|p| p.0)?;
 
@@ -179,8 +179,8 @@ impl Sequence for ChannelConnectionSequence {
 
                     debug!(message = ?channel_join_request, "Send");
 
-                    let written =
-                        ironrdp_pdu::encode_buf(&X224(channel_join_request), output).map_err(ConnectorError::encode)?;
+                    let written = ironrdp_core::encode_buf(&X224(channel_join_request), output)
+                        .map_err(ConnectorError::encode)?;
 
                     total_written = total_written.checked_add(written).expect("small join request PDUs");
                 }
@@ -198,7 +198,7 @@ impl Sequence for ChannelConnectionSequence {
                 user_channel_id,
                 mut remaining_channel_ids,
             } => {
-                let channel_join_confirm = ironrdp_pdu::decode::<X224<mcs::ChannelJoinConfirm>>(input)
+                let channel_join_confirm = ironrdp_core::decode::<X224<mcs::ChannelJoinConfirm>>(input)
                     .map_err(ConnectorError::decode)
                     .map(|p| p.0)?;
 

crates/ironrdp-connector/src/connection.rs

@@ -2,10 +2,10 @@ use std::borrow::Cow;
 use std::mem;
 use std::net::SocketAddr;
 
-use ironrdp_core::WriteBuf;
+use ironrdp_core::{decode, encode_vec, Encode, WriteBuf};
 use ironrdp_pdu::rdp::client_info::{OptionalSystemTime, TimezoneInfo};
 use ironrdp_pdu::x224::X224;
-use ironrdp_pdu::{decode, encode_vec, gcc, mcs, nego, rdp, Encode, PduHint};
+use ironrdp_pdu::{gcc, mcs, nego, rdp, PduHint};
 use ironrdp_svc::{StaticChannelSet, StaticVirtualChannel, SvcClientProcessor};
 
 use crate::channel_connection::{ChannelConnectionSequence, ChannelConnectionState};
@@ -261,7 +261,7 @@ impl Sequence for ClientConnector {
                 debug!(message = ?connection_request, "Send");
 
                 let written =
-                    ironrdp_pdu::encode_buf(&X224(connection_request), output).map_err(ConnectorError::encode)?;
+                    ironrdp_core::encode_buf(&X224(connection_request), output).map_err(ConnectorError::encode)?;
 
                 (
                     Written::from_size(written)?,
@@ -602,7 +602,7 @@ pub fn encode_send_data_request<T: Encode>(
         user_data: Cow::Owned(user_data),
     };
 
-    let written = ironrdp_pdu::encode_buf(&X224(pdu), buf).map_err(ConnectorError::encode)?;
+    let written = ironrdp_core::encode_buf(&X224(pdu), buf).map_err(ConnectorError::encode)?;
 
     Ok(written)
 }

crates/ironrdp-connector/src/legacy.rs

@@ -1,9 +1,10 @@
 use std::borrow::Cow;
 
 use ironrdp_core::WriteBuf;
+use ironrdp_core::{decode, encode_vec, Decode, Encode};
+use ironrdp_pdu::rdp;
 use ironrdp_pdu::rdp::headers::ServerDeactivateAll;
 use ironrdp_pdu::x224::X224;
-use ironrdp_pdu::{decode, encode_vec, rdp, Decode, Encode};
 
 use crate::{ConnectorError, ConnectorErrorExt as _, ConnectorResult};
 
@@ -24,7 +25,7 @@ where
         user_data: Cow::Owned(user_data),
     };
 
-    let written = ironrdp_pdu::encode_buf(&X224(pdu), buf).map_err(ConnectorError::encode)?;
+    let written = ironrdp_core::encode_buf(&X224(pdu), buf).map_err(ConnectorError::encode)?;
 
     Ok(written)
 }
@@ -72,7 +73,7 @@ pub fn decode_send_data_indication(src: &[u8]) -> ConnectorResult<SendDataIndica
         _ => Err(reason_err!(
             "decode_send_data_indication",
             "unexpected MCS message: {}",
-            ironrdp_pdu::name(&mcs_msg)
+            ironrdp_core::name(&mcs_msg)
         )),
     }
 }

crates/ironrdp-connector/src/lib.rs

@@ -24,10 +24,11 @@ pub use channel_connection::{ChannelConnectionSequence, ChannelConnectionState};
 pub use connection::{encode_send_data_request, ClientConnector, ClientConnectorState, ConnectionResult};
 pub use connection_finalization::{ConnectionFinalizationSequence, ConnectionFinalizationState};
 use ironrdp_core::WriteBuf;
+use ironrdp_core::{encode_buf, encode_vec, Encode};
 use ironrdp_pdu::rdp::capability_sets;
 use ironrdp_pdu::rdp::client_info::PerformanceFlags;
 use ironrdp_pdu::x224::X224;
-use ironrdp_pdu::{encode_buf, encode_vec, gcc, x224, Encode, PduHint};
+use ironrdp_pdu::{gcc, x224, PduHint};
 pub use license_exchange::{LicenseExchangeSequence, LicenseExchangeState};
 pub use server_name::ServerName;
 pub use sspi;

crates/ironrdp-core/src/decode.rs

@@ -3,13 +3,15 @@ use alloc::string::String;
 use core::fmt;
 
 use crate::{
-    InvalidFieldErr, NotEnoughBytesErr, OtherErr, UnexpectedMessageTypeErr, UnsupportedValueErr, UnsupportedVersionErr,
+    InvalidFieldErr, NotEnoughBytesErr, OtherErr, ReadCursor, UnexpectedMessageTypeErr, UnsupportedValueErr,
+    UnsupportedVersionErr,
 };
 
-/// Result type for decode operations, wrapping a value or a DecodeError.
+/// A result type for decoding operations, which can either succeed with a value of type `T`
+/// or fail with an [`DecodeError`].
 pub type DecodeResult<T> = Result<T, DecodeError>;
 
-/// Custom error type for decode operations.
+/// An error type specifically for encoding operations, wrapping an [`DecodeErrorKind`].
 pub type DecodeError = ironrdp_error::Error<DecodeErrorKind>;
 
 /// Enum representing different kinds of decode errors.
@@ -135,3 +137,111 @@ impl OtherErr for DecodeError {
         Self::new(context, DecodeErrorKind::Other { description })
     }
 }
+
+/// Trait for types that can be decoded from a byte stream.
+///
+/// This trait is implemented by types that can be deserialized from a sequence of bytes.
+pub trait Decode<'de>: Sized {
+    /// Decodes an instance of `Self` from the given byte stream.
+    ///
+    /// # Arguments
+    ///
+    /// * `src` - A mutable reference to a `ReadCursor` containing the bytes to decode.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `DecodeResult<Self>`, which is either the successfully decoded instance
+    /// or a `DecodeError` if decoding fails.
+    fn decode(src: &mut ReadCursor<'de>) -> DecodeResult<Self>;
+}
+
+/// Decodes a value of type `T` from a byte slice.
+///
+/// This function creates a `ReadCursor` from the input byte slice and uses it to decode
+/// a value of type `T` that implements the `Decode` trait.
+///
+/// # Arguments
+///
+/// * `src` - A byte slice containing the data to be decoded.
+///
+/// # Returns
+///
+/// Returns a `DecodeResult<T>`, which is either the successfully decoded value
+/// or a `DecodeError` if decoding fails.
+pub fn decode<'de, T>(src: &'de [u8]) -> DecodeResult<T>
+where
+    T: Decode<'de>,
+{
+    let mut cursor = ReadCursor::new(src);
+    T::decode(&mut cursor)
+}
+
+/// Decodes a value of type `T` from a `ReadCursor`.
+///
+/// This function uses the provided `ReadCursor` to decode a value of type `T`
+/// that implements the `Decode` trait.
+///
+/// # Arguments
+///
+/// * `src` - A mutable reference to a `ReadCursor` containing the bytes to be decoded.
+///
+/// # Returns
+///
+/// Returns a `DecodeResult<T>`, which is either the successfully decoded value
+/// or a `DecodeError` if decoding fails.
+pub fn decode_cursor<'de, T>(src: &mut ReadCursor<'de>) -> DecodeResult<T>
+where
+    T: Decode<'de>,
+{
+    T::decode(src)
+}
+
+/// Similar to `Decode` but unconditionally returns an owned type.
+pub trait DecodeOwned: Sized {
+    /// Decodes an instance of `Self` from the given byte stream.
+    ///
+    /// # Arguments
+    ///
+    /// * `src` - A mutable reference to a `ReadCursor` containing the bytes to decode.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `DecodeResult<Self>`, which is either the successfully decoded instance
+    /// or a `DecodeError` if decoding fails.
+    fn decode_owned(src: &mut ReadCursor<'_>) -> DecodeResult<Self>;
+}
+
+/// Decodes an owned value of type `T` from a byte slice.
+///
+/// This function creates a `ReadCursor` from the input byte slice and uses it to decode
+/// an owned value of type `T` that implements the `DecodeOwned` trait.
+///
+/// # Arguments
+///
+/// * `src` - A byte slice containing the data to be decoded.
+///
+/// # Returns
+///
+/// Returns a `DecodeResult<T>`, which is either the successfully decoded owned value
+/// or a `DecodeError` if decoding fails.
+pub fn decode_owned<T: DecodeOwned>(src: &[u8]) -> DecodeResult<T> {
+    let mut cursor = ReadCursor::new(src);
+    T::decode_owned(&mut cursor)
+}
+
+/// Decodes an owned value of type `T` from a `ReadCursor`.
+///
+/// This function uses the provided `ReadCursor` to decode an owned value of type `T`
+/// that implements the `DecodeOwned` trait.
+///
+/// # Arguments
+///
+/// * `src` - A mutable reference to a `ReadCursor` containing the bytes to be decoded.
+///
+/// # Returns
+///
+/// Returns a `DecodeResult<T>`, which is either the successfully decoded owned value
+/// or a `DecodeError` if decoding fails.
+pub fn decode_owned_cursor<T: DecodeOwned>(src: &mut ReadCursor<'_>) -> DecodeResult<T> {
+    T::decode_owned(src)
+}

crates/ironrdp-core/src/encode.rs

@@ -1,16 +1,21 @@
 #[cfg(feature = "alloc")]
+use crate::WriteBuf;
+#[cfg(feature = "alloc")]
 use alloc::string::String;
+#[cfg(feature = "alloc")]
+use alloc::{vec, vec::Vec};
 use core::fmt;
 
 use crate::{
     InvalidFieldErr, NotEnoughBytesErr, OtherErr, UnexpectedMessageTypeErr, UnsupportedValueErr, UnsupportedVersionErr,
+    WriteCursor,
 };
 
 /// A result type for encoding operations, which can either succeed with a value of type `T`
-/// or fail with an `EncodeError`.
+/// or fail with an [`EncodeError`].
 pub type EncodeResult<T> = Result<T, EncodeError>;
 
-/// An error type specifically for encoding operations, wrapping an `EncodeErrorKind`.
+/// An error type specifically for encoding operations, wrapping an [`EncodeErrorKind`].
 pub type EncodeError = ironrdp_error::Error<EncodeErrorKind>;
 
 /// Represents the different kinds of errors that can occur during encoding operations.
@@ -136,3 +141,106 @@ impl OtherErr for EncodeError {
         Self::new(context, EncodeErrorKind::Other { description })
     }
 }
+
+/// PDU that can be encoded into its binary form.
+///
+/// The resulting binary payload is a fully encoded PDU that may be sent to the peer.
+///
+/// This trait is object-safe and may be used in a dynamic context.
+pub trait Encode {
+    /// Encodes this PDU in-place using the provided `WriteCursor`.
+    fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()>;
+
+    /// Returns the associated PDU name associated.
+    fn name(&self) -> &'static str;
+
+    /// Computes the size in bytes for this PDU.
+    fn size(&self) -> usize;
+}
+
+crate::assert_obj_safe!(Encode);
+
+/// Encodes the given PDU in-place into the provided buffer and returns the number of bytes written.
+pub fn encode<T>(pdu: &T, dst: &mut [u8]) -> EncodeResult<usize>
+where
+    T: Encode + ?Sized,
+{
+    let mut cursor = WriteCursor::new(dst);
+    encode_cursor(pdu, &mut cursor)?;
+    Ok(cursor.pos())
+}
+
+/// Encodes the given PDU in-place using the provided `WriteCursor`.
+pub fn encode_cursor<T>(pdu: &T, dst: &mut WriteCursor<'_>) -> EncodeResult<()>
+where
+    T: Encode + ?Sized,
+{
+    pdu.encode(dst)
+}
+
+/// Same as `encode` but resizes the buffer when it is too small to fit the PDU.
+#[cfg(feature = "alloc")]
+pub fn encode_buf<T>(pdu: &T, buf: &mut WriteBuf) -> EncodeResult<usize>
+where
+    T: Encode + ?Sized,
+{
+    let pdu_size = pdu.size();
+    let dst = buf.unfilled_to(pdu_size);
+    let written = encode(pdu, dst)?;
+    debug_assert_eq!(written, pdu_size);
+    buf.advance(written);
+    Ok(written)
+}
+
+/// Same as `encode` but allocates and returns a new buffer each time.
+///
+/// This is a convenience function, but it’s not very resource efficient.
+#[cfg(any(feature = "alloc", test))]
+pub fn encode_vec<T>(pdu: &T) -> EncodeResult<Vec<u8>>
+where
+    T: Encode + ?Sized,
+{
+    let pdu_size = pdu.size();
+    let mut buf = vec![0; pdu_size];
+    let written = encode(pdu, buf.as_mut_slice())?;
+    debug_assert_eq!(written, pdu_size);
+    Ok(buf)
+}
+
+/// Gets the name of this PDU.
+pub fn name<T: Encode>(pdu: &T) -> &'static str {
+    pdu.name()
+}
+
+/// Computes the size in bytes for this PDU.
+pub fn size<T: Encode>(pdu: &T) -> usize {
+    pdu.size()
+}
+
+#[cfg(feature = "alloc")]
+pub use legacy::*;
+
+#[cfg(feature = "alloc")]
+mod legacy {
+    use super::{Encode, EncodeResult};
+    use crate::WriteCursor;
+
+    impl Encode for alloc::vec::Vec<u8> {
+        fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()> {
+            ensure_size!(in: dst, size: self.len());
+
+            dst.write_slice(self);
+            Ok(())
+        }
+
+        /// Returns the associated PDU name associated.
+        fn name(&self) -> &'static str {
+            "legacy-pdu-encode"
+        }
+
+        /// Computes the size in bytes for this PDU.
+        fn size(&self) -> usize {
+            self.len()
+        }
+    }
+}

crates/ironrdp-displaycontrol/src/client.rs

@@ -2,9 +2,9 @@ use crate::{
     pdu::{DisplayControlCapabilities, DisplayControlMonitorLayout, DisplayControlPdu},
     CHANNEL_NAME,
 };
-use ironrdp_core::{impl_as_any, EncodeResult, ReadCursor};
+use ironrdp_core::{impl_as_any, Decode, EncodeResult, ReadCursor};
 use ironrdp_dvc::{encode_dvc_messages, DvcClientProcessor, DvcMessage, DvcProcessor};
-use ironrdp_pdu::{decode_err, Decode, PduResult};
+use ironrdp_pdu::{decode_err, PduResult};
 use ironrdp_svc::{ChannelFlags, SvcMessage};
 use tracing::debug;
 

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

@@ -2,9 +2,10 @@
 //!
 //! [1]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpedisp/d2954508-f487-48bc-8731-39743e0854a9
 
-use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, DecodeResult, EncodeResult, ReadCursor, WriteCursor};
+use ironrdp_core::{
+    ensure_fixed_part_size, invalid_field_err, Decode, DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor,
+};
 use ironrdp_dvc::DvcEncode;
-use ironrdp_pdu::{Decode, Encode};
 use tracing::warn;
 
 const DISPLAYCONTROL_PDU_TYPE_CAPS: u32 = 0x00000005;

crates/ironrdp-displaycontrol/src/server.rs

@@ -1,6 +1,6 @@
-use ironrdp_core::impl_as_any;
+use ironrdp_core::{decode, impl_as_any};
 use ironrdp_dvc::{DvcMessage, DvcProcessor, DvcServerProcessor};
-use ironrdp_pdu::{decode, decode_err, PduResult};
+use ironrdp_pdu::{decode_err, PduResult};
 use tracing::debug;
 
 use crate::{

crates/ironrdp-dvc/src/client.rs

@@ -6,12 +6,12 @@ use crate::{encode_dvc_messages, DvcProcessor, DynamicChannelSet, DynamicVirtual
 use alloc::vec::Vec;
 use core::any::TypeId;
 use core::fmt;
+use ironrdp_core::Decode as _;
 use ironrdp_core::ReadCursor;
 use ironrdp_core::{impl_as_any, DecodeResult};
 use ironrdp_pdu::{self as pdu, decode_err, encode_err, pdu_other_err};
 use ironrdp_svc::{ChannelFlags, CompressionCondition, SvcClientProcessor, SvcMessage, SvcProcessor};
 use pdu::gcc::ChannelName;
-use pdu::Decode as _;
 use pdu::PduResult;
 
 pub trait DvcClientProcessor: DvcProcessor {}

crates/ironrdp-dvc/src/lib.rs

@@ -16,8 +16,8 @@ use alloc::vec::Vec;
 // Re-export ironrdp_pdu crate for convenience
 #[rustfmt::skip] // do not re-order this pub use
 pub use ironrdp_pdu;
-use ironrdp_core::{assert_obj_safe, cast_length, other_err, AsAny, EncodeResult};
-use ironrdp_pdu::{decode_err, encode_vec, pdu_other_err, Encode, PduResult};
+use ironrdp_core::{assert_obj_safe, cast_length, encode_vec, other_err, AsAny, Encode, EncodeResult};
+use ironrdp_pdu::{decode_err, pdu_other_err, PduResult};
 use ironrdp_svc::{self, SvcMessage};
 
 mod complete_data;

crates/ironrdp-dvc/src/pdu.rs

@@ -3,12 +3,11 @@ use core::fmt;
 
 use crate::{DynamicChannelId, String, Vec};
 use ironrdp_core::{
-    cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, unsupported_value_err, DecodeError,
-    DecodeResult, EncodeResult, ReadCursor, WriteCursor,
+    cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, unsupported_value_err, Decode, DecodeError,
+    DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor,
 };
-use ironrdp_pdu::{
-    utils::{checked_sum, encoded_str_len, read_string_from_cursor, strict_sum, write_string_to_cursor, CharacterSet},
-    Decode, Encode,
+use ironrdp_pdu::utils::{
+    checked_sum, encoded_str_len, read_string_from_cursor, strict_sum, write_string_to_cursor, CharacterSet,
 };
 use ironrdp_svc::SvcEncode;
 

crates/ironrdp-dvc/src/server.rs

@@ -5,12 +5,12 @@ use crate::{encode_dvc_messages, CompleteData, DvcProcessor};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 use core::fmt;
+use ironrdp_core::Decode as _;
 use ironrdp_core::{cast_length, impl_as_any, DecodeResult};
 use ironrdp_core::{invalid_field_err, ReadCursor};
 use ironrdp_pdu::{self as pdu, decode_err, encode_err, pdu_other_err};
 use ironrdp_svc::{ChannelFlags, CompressionCondition, SvcMessage, SvcProcessor, SvcServerProcessor};
 use pdu::gcc::ChannelName;
-use pdu::Decode as _;
 use pdu::PduResult;
 use slab::Slab;
 

crates/ironrdp-fuzzing/Cargo.toml

@@ -11,6 +11,7 @@ test = false
 
 [dependencies]
 arbitrary = { version = "1", features = ["derive"] }
+ironrdp-core.workspace = true
 ironrdp-graphics.workspace = true
 ironrdp-pdu.workspace = true
 ironrdp-cliprdr.workspace = true

crates/ironrdp-fuzzing/src/oracles/mod.rs

@@ -13,6 +13,7 @@
 use crate::generators::BitmapInput;
 
 pub fn pdu_decode(data: &[u8]) {
+    use ironrdp_core::*;
     use ironrdp_pdu::mcs::*;
     use ironrdp_pdu::nego::*;
     use ironrdp_pdu::rdp::*;

crates/ironrdp-graphics/src/rdp6/bitmap_stream/decoder.rs

@@ -1,6 +1,6 @@
+use ironrdp_core::decode;
 use ironrdp_core::DecodeError;
 use ironrdp_pdu::bitmap::rdp6::{BitmapStream as BitmapStreamPdu, ColorPlaneDefinition};
-use ironrdp_pdu::decode;
 use thiserror::Error;
 
 use crate::color_conversion::Rgb;

crates/ironrdp-graphics/src/rdp6/bitmap_stream/encoder.rs

@@ -160,7 +160,7 @@ impl BitmapStreamEncoder {
             color_plane_definition: ColorPlaneDefinition::Argb,
         };
 
-        ironrdp_pdu::encode_cursor(&header, &mut cursor).map_err(BitmapEncodeError::Encode)?;
+        ironrdp_core::encode_cursor(&header, &mut cursor).map_err(BitmapEncodeError::Encode)?;
 
         if rle {
             compress_8bpp_plane(r, &mut cursor, self.width, self.height).map_err(BitmapEncodeError::Rle)?;
@@ -236,7 +236,7 @@ impl BitmapStreamEncoder {
             color_plane_definition: ColorPlaneDefinition::Argb,
         };
 
-        ironrdp_pdu::encode_cursor(&header, &mut cursor).map_err(BitmapEncodeError::Encode)?;
+        ironrdp_core::encode_cursor(&header, &mut cursor).map_err(BitmapEncodeError::Encode)?;
 
         if rle {
             compress_8bpp_plane(a, &mut cursor, self.width, self.height).map_err(BitmapEncodeError::rle)?;

crates/ironrdp-pdu/src/basic_output/bitmap.rs

@@ -8,8 +8,8 @@ use std::fmt::{self, Debug};
 use bitflags::bitflags;
 
 use crate::geometry::InclusiveRectangle;
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const FIRST_ROW_SIZE_VALUE: u16 = 0;
 

crates/ironrdp-pdu/src/basic_output/bitmap/rdp6.rs

@@ -1,5 +1,5 @@
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const NON_RLE_PADDING_SIZE: usize = 1;
 
@@ -117,7 +117,7 @@ impl<'a> BitmapStream<'a> {
 impl<'a> Decode<'a> for BitmapStream<'a> {
     fn decode(src: &mut ReadCursor<'a>) -> DecodeResult<Self> {
         ensure_fixed_part_size!(in: src);
-        let header = crate::decode_cursor::<BitmapStreamHeader>(src)?;
+        let header = ironrdp_core::decode_cursor::<BitmapStreamHeader>(src)?;
 
         let color_planes_size = if !header.enable_rle_compression {
             // Cut padding field if RLE flags is set to 0
@@ -142,7 +142,7 @@ impl Encode for BitmapStream<'_> {
     fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()> {
         ensure_size!(in: dst, size: self.size());
 
-        crate::encode_cursor(&self.header, dst)?;
+        ironrdp_core::encode_cursor(&self.header, dst)?;
         dst.write_slice(self.color_panes_data());
 
         // Write padding
@@ -170,15 +170,15 @@ mod tests {
     use super::*;
 
     fn assert_roundtrip(buffer: &[u8], expected: Expect) {
-        let pdu = crate::decode::<BitmapStream<'_>>(buffer).unwrap();
+        let pdu = ironrdp_core::decode::<BitmapStream<'_>>(buffer).unwrap();
         expected.assert_debug_eq(&pdu);
         assert_eq!(pdu.size(), buffer.len());
-        let reencoded = crate::encode_vec(&pdu).unwrap();
+        let reencoded = ironrdp_core::encode_vec(&pdu).unwrap();
         assert_eq!(reencoded.as_slice(), buffer);
     }
 
     fn assert_parsing_failure(buffer: &[u8], expected: Expect) {
-        let error = crate::decode::<BitmapStream<'_>>(buffer).err().unwrap();
+        let error = ironrdp_core::decode::<BitmapStream<'_>>(buffer).err().unwrap();
         expected.assert_debug_eq(&error);
     }
 
@@ -284,7 +284,7 @@ mod tests {
             &[],
             expect![[r#"
                 Error {
-                    context: "<ironrdp_pdu::basic_output::bitmap::rdp6::BitmapStream as ironrdp_pdu::Decode>::decode",
+                    context: "<ironrdp_pdu::basic_output::bitmap::rdp6::BitmapStream as ironrdp_core::decode::Decode>::decode",
                     kind: NotEnoughBytes {
                         received: 0,
                         expected: 1,
@@ -299,7 +299,7 @@ mod tests {
             &[0x20],
             expect![[r#"
                 Error {
-                    context: "<ironrdp_pdu::basic_output::bitmap::rdp6::BitmapStream as ironrdp_pdu::Decode>::decode",
+                    context: "<ironrdp_pdu::basic_output::bitmap::rdp6::BitmapStream as ironrdp_core::decode::Decode>::decode",
                     kind: InvalidField {
                         field: "padding",
                         reason: "missing padding byte from zero-sized non-RLE bitmap data",

crates/ironrdp-pdu/src/basic_output/bitmap/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode};
+use ironrdp_core::{decode, encode};
 
 const BITMAP_BUFFER: [u8; 114] = [
     0x01, 0x00, // Bitmap update type = must be PDATETYPE_BITMAP (0x0001)

crates/ironrdp-pdu/src/basic_output/fast_path.rs

@@ -9,9 +9,10 @@ use num_traits::{FromPrimitive, ToPrimitive};
 use super::bitmap::BitmapUpdateData;
 use super::pointer::PointerUpdateData;
 use super::surface_commands::{SurfaceCommand, SURFACE_COMMAND_HEADER_SIZE};
+use crate::per;
 use crate::rdp::client_info::CompressionType;
 use crate::rdp::headers::{CompressionFlags, SHARE_DATA_HEADER_COMPRESSION_MASK};
-use crate::{decode_cursor, per, Decode, Encode};
+use ironrdp_core::{decode_cursor, Decode, Encode};
 use ironrdp_core::{
     ensure_fixed_part_size, ensure_size, invalid_field_err, DecodeError, DecodeResult, EncodeResult, InvalidFieldErr,
     ReadCursor, WriteCursor,

crates/ironrdp-pdu/src/basic_output/fast_path/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode};
+use ironrdp_core::{decode, encode};
 
 const FAST_PATH_HEADER_WITH_SHORT_LEN_BUFFER: [u8; 2] = [0x80, 0x08];
 const FAST_PATH_HEADER_WITH_LONG_LEN_BUFFER: [u8; 3] = [0x80, 0x81, 0xE7];

crates/ironrdp-pdu/src/basic_output/pointer.rs

@@ -1,5 +1,5 @@
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 // Represents `TS_POINT16` described in [MS-RDPBCGR] 2.2.9.1.1.4.1
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/ironrdp-pdu/src/basic_output/surface_commands.rs

@@ -6,8 +6,8 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive as _, ToPrimitive as _};
 
 use crate::geometry::ExclusiveRectangle;
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 pub const SURFACE_COMMAND_HEADER_SIZE: usize = 2;
 

crates/ironrdp-pdu/src/basic_output/surface_commands/tests.rs

@@ -2,7 +2,7 @@ use lazy_static::lazy_static;
 
 use super::*;
 use crate::geometry::ExclusiveRectangle;
-use crate::{decode, encode};
+use ironrdp_core::{decode, encode};
 
 const FRAME_MARKER_BUFFER: [u8; 8] = [0x4, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0];
 

crates/ironrdp-pdu/src/codecs/rfx.rs

@@ -8,8 +8,9 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive as _, ToPrimitive as _};
 use thiserror::Error;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult, PduBufferParsing};
+use crate::PduBufferParsing;
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[rustfmt::skip]
 pub use self::data_messages::{

crates/ironrdp-pdu/src/gcc.rs

@@ -4,11 +4,12 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 use thiserror::Error;
 
-use crate::{decode, Decode, Encode, PduError};
+use crate::PduError;
 use ironrdp_core::{
     cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, DecodeErrorKind, DecodeResult, EncodeResult,
     ReadCursor, WriteCursor,
 };
+use ironrdp_core::{decode, Decode, Encode};
 
 pub mod conference_create;
 

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

@@ -5,8 +5,8 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive as _, ToPrimitive as _};
 use thiserror::Error;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const REDIRECTION_VERSION_MASK: u32 = 0x0000_003C;
 

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

@@ -1,6 +1,7 @@
 use super::{ClientGccBlocks, ServerGccBlocks};
-use crate::{mcs, per, Decode, DecodeResult, Encode, EncodeResult};
+use crate::{mcs, per};
 use ironrdp_core::{cast_length, ensure_size, invalid_field_err, other_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const CONFERENCE_REQUEST_OBJECT_ID: [u8; 6] = [0, 0, 20, 124, 0, 1];
 const CONFERENCE_REQUEST_CLIENT_TO_SERVER_H221_NON_STANDARD: &[u8; 4] = b"Duca";

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

@@ -5,8 +5,9 @@ use tap::Pipe as _;
 
 use super::{RdpVersion, VERSION_SIZE};
 use crate::nego::SecurityProtocol;
-use crate::{utils, Decode, DecodeResult, Encode, EncodeResult};
+use crate::utils;
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 pub const IME_FILE_NAME_SIZE: usize = 64;
 

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

@@ -3,8 +3,8 @@ use tap::Pipe as _;
 
 use super::RdpVersion;
 use crate::nego::SecurityProtocol;
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const CLIENT_REQUESTED_PROTOCOL_SIZE: usize = 4;
 const EARLY_CAPABILITY_FLAGS_SIZE: usize = 4;

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

@@ -1,5 +1,5 @@
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const CLIENT_FLAGS_SIZE: usize = 4;
 const SERVER_MCS_MESSAGE_CHANNEL_ID_SIZE: usize = 2;

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

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 use ironrdp_core::{cast_length, ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 pub const MONITOR_COUNT_SIZE: usize = 4;
 pub const MONITOR_SIZE: usize = 20;

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

@@ -2,7 +2,7 @@ use ironrdp_core::{cast_length, ensure_fixed_part_size, ensure_size, invalid_fie
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const MONITOR_COUNT_MAX: usize = 16;
 const MONITOR_ATTRIBUTE_SIZE: u32 = 20;

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

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MultiTransportChannelData {

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

@@ -6,7 +6,7 @@ use bitflags::bitflags;
 use num_integer::Integer;
 use thiserror::Error;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const CHANNELS_MAX: usize = 31;
 

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

@@ -5,8 +5,8 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 use thiserror::Error;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const CLIENT_ENCRYPTION_METHODS_SIZE: usize = 4;
 const CLIENT_EXT_ENCRYPTION_METHODS_SIZE: usize = 4;

crates/ironrdp-pdu/src/geometry.rs

@@ -1,7 +1,7 @@
 use std::cmp::{max, min};
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 pub(crate) mod private {
     pub struct BaseRectangle {

crates/ironrdp-pdu/src/input/fast_path.rs

@@ -5,10 +5,11 @@ use num_traits::{FromPrimitive, ToPrimitive};
 
 use crate::fast_path::EncryptionFlags;
 use crate::input::{MousePdu, MouseRelPdu, MouseXPdu};
-use crate::{per, Decode, DecodeResult, Encode, EncodeResult};
+use crate::per;
 use ironrdp_core::{
     cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, other_err, ReadCursor, WriteCursor,
 };
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 /// Implements the Fast-Path RDP message header PDU.
 #[derive(Debug, Clone, PartialEq, Eq)]

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

@@ -4,8 +4,8 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 use thiserror::Error;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 pub mod fast_path;
 pub mod mouse;

crates/ironrdp-pdu/src/input/mouse.rs

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MousePdu {

crates/ironrdp-pdu/src/input/mouse_rel.rs

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MouseRelPdu {

crates/ironrdp-pdu/src/input/mouse_x.rs

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MouseXPdu {

crates/ironrdp-pdu/src/input/scan_code.rs

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ScanCodePdu {

crates/ironrdp-pdu/src/input/sync.rs

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SyncPdu {

crates/ironrdp-pdu/src/input/unicode.rs

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UnicodePdu {

crates/ironrdp-pdu/src/input/unused.rs

@@ -1,5 +1,5 @@
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UnusedPdu;

crates/ironrdp-pdu/src/lib.rs

@@ -5,10 +5,8 @@
 #![allow(clippy::cast_sign_loss)] // FIXME: remove
 
 use core::fmt;
-use ironrdp_core::{unexpected_message_type_err, DecodeResult, EncodeResult, ReadCursor, WriteCursor};
+use ironrdp_core::{unexpected_message_type_err, DecodeResult, EncodeResult, ReadCursor};
 
-#[cfg(feature = "alloc")]
-use ironrdp_core::WriteBuf;
 use ironrdp_error::Source;
 
 #[macro_use]
@@ -89,117 +87,6 @@ pub trait Pdu {
     const NAME: &'static str;
 }
 
-/// PDU that can be encoded into its binary form.
-///
-/// The resulting binary payload is a fully encoded PDU that may be sent to the peer.
-///
-/// This trait is object-safe and may be used in a dynamic context.
-pub trait Encode {
-    /// Encodes this PDU in-place using the provided `WriteCursor`.
-    fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()>;
-
-    /// Returns the associated PDU name associated.
-    fn name(&self) -> &'static str;
-
-    /// Computes the size in bytes for this PDU.
-    fn size(&self) -> usize;
-}
-
-ironrdp_core::assert_obj_safe!(Encode);
-
-/// Encodes the given PDU in-place into the provided buffer and returns the number of bytes written.
-pub fn encode<T>(pdu: &T, dst: &mut [u8]) -> EncodeResult<usize>
-where
-    T: Encode + ?Sized,
-{
-    let mut cursor = WriteCursor::new(dst);
-    encode_cursor(pdu, &mut cursor)?;
-    Ok(cursor.pos())
-}
-
-/// Encodes the given PDU in-place using the provided `WriteCursor`.
-pub fn encode_cursor<T>(pdu: &T, dst: &mut WriteCursor<'_>) -> EncodeResult<()>
-where
-    T: Encode + ?Sized,
-{
-    pdu.encode(dst)
-}
-
-/// Same as `encode` but resizes the buffer when it is too small to fit the PDU.
-#[cfg(feature = "alloc")]
-pub fn encode_buf<T>(pdu: &T, buf: &mut WriteBuf) -> EncodeResult<usize>
-where
-    T: Encode + ?Sized,
-{
-    let pdu_size = pdu.size();
-    let dst = buf.unfilled_to(pdu_size);
-    let written = encode(pdu, dst)?;
-    debug_assert_eq!(written, pdu_size);
-    buf.advance(written);
-    Ok(written)
-}
-
-/// Same as `encode` but allocates and returns a new buffer each time.
-///
-/// This is a convenience function, but it’s not very resource efficient.
-#[cfg(any(feature = "alloc", test))]
-pub fn encode_vec<T>(pdu: &T) -> EncodeResult<Vec<u8>>
-where
-    T: Encode + ?Sized,
-{
-    let pdu_size = pdu.size();
-    let mut buf = vec![0; pdu_size];
-    let written = encode(pdu, buf.as_mut_slice())?;
-    debug_assert_eq!(written, pdu_size);
-    Ok(buf)
-}
-
-/// Gets the name of this PDU.
-pub fn name<T: Encode>(pdu: &T) -> &'static str {
-    pdu.name()
-}
-
-/// Computes the size in bytes for this PDU.
-pub fn size<T: Encode>(pdu: &T) -> usize {
-    pdu.size()
-}
-
-/// PDU that can be decoded from a binary input.
-///
-/// The binary payload must be a full PDU, not some subset of it.
-pub trait Decode<'de>: Sized {
-    fn decode(src: &mut ReadCursor<'de>) -> DecodeResult<Self>;
-}
-
-pub fn decode<'de, T>(src: &'de [u8]) -> DecodeResult<T>
-where
-    T: Decode<'de>,
-{
-    let mut cursor = ReadCursor::new(src);
-    T::decode(&mut cursor)
-}
-
-pub fn decode_cursor<'de, T>(src: &mut ReadCursor<'de>) -> DecodeResult<T>
-where
-    T: Decode<'de>,
-{
-    T::decode(src)
-}
-
-/// Similar to `Decode` but unconditionally returns an owned type.
-pub trait DecodeOwned: Sized {
-    fn decode_owned(src: &mut ReadCursor<'_>) -> DecodeResult<Self>;
-}
-
-pub fn decode_owned<T: DecodeOwned>(src: &[u8]) -> DecodeResult<T> {
-    let mut cursor = ReadCursor::new(src);
-    T::decode_owned(&mut cursor)
-}
-
-pub fn decode_owned_cursor<T: DecodeOwned>(src: &mut ReadCursor<'_>) -> DecodeResult<T> {
-    T::decode_owned(src)
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum Action {
@@ -333,10 +220,6 @@ pub use legacy::*;
 // TODO: Delete these traits at some point
 mod legacy {
 
-    use ironrdp_core::ensure_size;
-
-    use crate::{Encode, EncodeResult, WriteCursor};
-
     pub trait PduBufferParsing<'a>: Sized {
         type Error;
 
@@ -347,23 +230,4 @@ mod legacy {
         fn to_buffer_consume(&self, buffer: &mut &mut [u8]) -> Result<(), Self::Error>;
         fn buffer_length(&self) -> usize;
     }
-
-    impl Encode for Vec<u8> {
-        fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()> {
-            ensure_size!(in: dst, size: self.len());
-
-            dst.write_slice(self);
-            Ok(())
-        }
-
-        /// Returns the associated PDU name associated.
-        fn name(&self) -> &'static str {
-            "legacy-pdu-encode"
-        }
-
-        /// Computes the size in bytes for this PDU.
-        fn size(&self) -> usize {
-            self.len()
-        }
-    }
 }

crates/ironrdp-pdu/src/macros.rs

@@ -58,9 +58,9 @@ macro_rules! impl_pdu_pod {
             }
         }
 
-        impl $crate::DecodeOwned for $pdu_ty {
+        impl ironrdp_core::DecodeOwned for $pdu_ty {
             fn decode_owned(src: &mut ReadCursor<'_>) -> DecodeResult<Self> {
-                <Self as $crate::Decode>::decode(src)
+                <Self as ironrdp_core::Decode>::decode(src)
             }
         }
     };
@@ -78,9 +78,9 @@ macro_rules! impl_x224_pdu_pod {
             }
         }
 
-        impl $crate::DecodeOwned for $pdu_ty {
+        impl ::ironrdp_core::DecodeOwned for $pdu_ty {
             fn decode_owned(src: &mut ReadCursor<'_>) -> DecodeResult<Self> {
-                <$crate::x224::X224<Self> as $crate::Decode>::decode(src).map(|p| p.0)
+                <$crate::x224::X224<Self> as ::ironrdp_core::Decode>::decode(src).map(|p| p.0)
             }
         }
     };
@@ -92,9 +92,9 @@ macro_rules! impl_pdu_borrowing {
     ($pdu_ty:ident $(<$($lt:lifetime),+>)?, $owned_ty:ident) => {
         pub type $owned_ty = $pdu_ty<'static>;
 
-        impl $crate::DecodeOwned for $owned_ty {
+        impl ironrdp_core::DecodeOwned for $owned_ty {
             fn decode_owned(src: &mut ReadCursor<'_>) -> DecodeResult<Self> {
-                let pdu = <$pdu_ty $(<$($lt),+>)? as $crate::Decode>::decode(src)?;
+                let pdu = <$pdu_ty $(<$($lt),+>)? as ::ironrdp_core::Decode>::decode(src)?;
                 Ok(::ironrdp_core::IntoOwned::into_owned(pdu))
             }
         }
@@ -107,9 +107,9 @@ macro_rules! impl_x224_pdu_borrowing {
     ($pdu_ty:ident $(<$($lt:lifetime),+>)?, $owned_ty:ident) => {
         pub type $owned_ty = $pdu_ty<'static>;
 
-        impl $crate::DecodeOwned for $owned_ty {
+        impl ::ironrdp_core::DecodeOwned for $owned_ty {
             fn decode_owned(src: &mut ReadCursor<'_>) -> DecodeResult<Self> {
-                let pdu = <$crate::x224::X224<$pdu_ty $(<$($lt),+>)?> as $crate::Decode>::decode(src).map(|r| r.0)?;
+                let pdu = <$crate::x224::X224<$pdu_ty $(<$($lt),+>)?> as ::ironrdp_core::Decode>::decode(src).map(|r| r.0)?;
                 Ok(::ironrdp_core::IntoOwned::into_owned(pdu))
             }
         }

crates/ironrdp-pdu/src/mcs.rs

@@ -941,9 +941,10 @@ mod legacy {
     use thiserror::Error;
 
     use super::*;
+    use crate::ber;
     use crate::gcc::conference_create::{ConferenceCreateRequest, ConferenceCreateResponse};
     use crate::gcc::GccError;
-    use crate::{ber, Decode, DecodeResult, Encode, EncodeResult};
+    use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
     // impl<'de> McsPdu<'de> for ConnectInitial {
     //     const MCS_NAME: &'static str = "DisconnectProviderUltimatum";

crates/ironrdp-pdu/src/pcb.rs

@@ -1,10 +1,11 @@
 //! This module contains the RDP_PRECONNECTION_PDU_V1 and RDP_PRECONNECTION_PDU_V2 structures.
 
-use crate::{Decode, Encode, Pdu};
+use crate::Pdu;
 use ironrdp_core::{
     cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, invalid_field_err_with_source, DecodeResult,
     EncodeResult, ReadCursor, WriteCursor,
 };
+use ironrdp_core::{Decode, Encode};
 
 /// Preconnection PDU version
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/ironrdp-pdu/src/rdp.rs

@@ -7,9 +7,10 @@ use crate::rdp::capability_sets::CapabilitySetsError;
 use crate::rdp::client_info::{ClientInfo, ClientInfoError};
 use crate::rdp::headers::{BasicSecurityHeader, BasicSecurityHeaderFlags, ShareControlPduType, ShareDataPduType};
 use crate::rdp::server_license::ServerLicenseError;
-use crate::Encode;
-use crate::{Decode, DecodeResult, EncodeResult, PduError};
+use crate::PduError;
+use ironrdp_core::Encode;
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, EncodeResult};
 
 pub mod capability_sets;
 pub mod client_info;

crates/ironrdp-pdu/src/rdp/capability_sets.rs

@@ -4,10 +4,11 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive as _, ToPrimitive as _};
 use thiserror::Error;
 
-use crate::{decode, utils, Decode, DecodeResult, Encode, EncodeResult, PduError};
+use crate::{utils, PduError};
 use ironrdp_core::{
     cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, unsupported_value_err, ReadCursor, WriteCursor,
 };
+use ironrdp_core::{decode, Decode, DecodeResult, Encode, EncodeResult};
 
 mod bitmap;
 mod bitmap_cache;

crates/ironrdp-pdu/src/rdp/capability_sets/bitmap.rs

@@ -3,8 +3,8 @@ mod tests;
 
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const BITMAP_LENGTH: usize = 24;
 

crates/ironrdp-pdu/src/rdp/capability_sets/bitmap/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const BITMAP_BUFFER: [u8; 24] = [
     0x18, 0x00, // preferredBitsPerPixel

crates/ironrdp-pdu/src/rdp/capability_sets/bitmap_cache.rs

@@ -3,8 +3,8 @@ mod tests;
 
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 pub const BITMAP_CACHE_ENTRIES_NUM: usize = 3;
 

crates/ironrdp-pdu/src/rdp/capability_sets/bitmap_cache/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const CACHE_ENTRY_BUFFER: [u8; 4] = [0x64, 0x00, 0x32, 0x00];
 

crates/ironrdp-pdu/src/rdp/capability_sets/bitmap_codecs.rs

@@ -5,11 +5,10 @@ use bitflags::bitflags;
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 
-use crate::{decode, DecodeResult, EncodeResult};
-use crate::{Decode, Encode};
 use ironrdp_core::{
     cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, other_err, ReadCursor, WriteCursor,
 };
+use ironrdp_core::{decode, Decode, DecodeResult, Encode, EncodeResult};
 
 const RFX_ICAP_VERSION: u16 = 0x0100;
 const RFX_ICAP_TILE_SIZE: u16 = 0x40;

crates/ironrdp-pdu/src/rdp/capability_sets/bitmap_codecs/tests.rs

@@ -2,7 +2,7 @@ use ironrdp_core::DecodeErrorKind;
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, decode_cursor, encode_vec};
+use ironrdp_core::{decode, decode_cursor, encode_vec};
 
 const GUID_BUFFER: [u8; 16] = [
     0xb9, 0x1b, 0x8d, 0xca, 0x0f, 0x00, 0x4f, 0x15, 0x58, 0x9f, 0xae, 0x2d, 0x1a, 0x87, 0xe2, 0xd6,

crates/ironrdp-pdu/src/rdp/capability_sets/brush.rs

@@ -4,8 +4,8 @@ mod tests;
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const BRUSH_LENGTH: usize = 4;
 

crates/ironrdp-pdu/src/rdp/capability_sets/brush/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const BRUSH_BUFFER: [u8; 4] = [0x01, 0x00, 0x00, 0x00];
 

crates/ironrdp-pdu/src/rdp/capability_sets/frame_acknowledge.rs

@@ -1,5 +1,5 @@
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FrameAcknowledge {
@@ -45,7 +45,7 @@ impl<'de> Decode<'de> for FrameAcknowledge {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{decode, encode_vec};
+    use ironrdp_core::{decode, encode_vec};
 
     const FRAME_ACKNOWLEDGE_PDU_BUFFER: [u8; 4] = [0xf4, 0xf3, 0xf2, 0xf1];
     const FRAME_ACKNOWLEDGE_PDU: FrameAcknowledge = FrameAcknowledge {

crates/ironrdp-pdu/src/rdp/capability_sets/general.rs

@@ -5,8 +5,8 @@ use std::fmt;
 
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const GENERAL_LENGTH: usize = 20;
 pub const PROTOCOL_VER: u16 = 0x0200;

crates/ironrdp-pdu/src/rdp/capability_sets/general/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const GENERAL_CAPSET_BUFFER: [u8; 20] = [
     0x01, 0x00, // osMajorType

crates/ironrdp-pdu/src/rdp/capability_sets/glyph_cache.rs

@@ -4,8 +4,8 @@ mod tests;
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, invalid_field_err, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 pub const GLYPH_CACHE_NUM: usize = 10;
 

crates/ironrdp-pdu/src/rdp/capability_sets/glyph_cache/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const GLYPH_CACHE_BUFFER: [u8; 48] = [
     0xfe, 0x00, 0x04, 0x00, 0xfe, 0x00, 0x04, 0x00, 0xfe, 0x00, 0x08, 0x00, 0xfe, 0x00, 0x08, 0x00, 0xfe, 0x00, 0x10,

crates/ironrdp-pdu/src/rdp/capability_sets/input.rs

@@ -5,8 +5,9 @@ use bitflags::bitflags;
 use num_traits::{FromPrimitive, ToPrimitive};
 
 use crate::gcc::{KeyboardType, IME_FILE_NAME_SIZE};
-use crate::{utils, Decode, DecodeResult, Encode, EncodeResult};
+use crate::utils;
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const INPUT_LENGTH: usize = 84;
 

crates/ironrdp-pdu/src/rdp/capability_sets/input/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const INPUT_BUFFER: [u8; 84] = [
     0x15, 0x00, // inputFlags

crates/ironrdp-pdu/src/rdp/capability_sets/large_pointer.rs

@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct LargePointer {
@@ -53,7 +53,7 @@ bitflags! {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{decode, encode_vec};
+    use ironrdp_core::{decode, encode_vec};
 
     const LARGE_POINTER_PDU_BUFFER: [u8; 2] = [0x01, 0x00];
     const LARGE_POINTER_PDU: LargePointer = LargePointer {

crates/ironrdp-pdu/src/rdp/capability_sets/multifragment_update.rs

@@ -1,5 +1,5 @@
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct MultifragmentUpdate {
@@ -43,7 +43,7 @@ impl<'de> Decode<'de> for MultifragmentUpdate {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{decode, encode_vec};
+    use ironrdp_core::{decode, encode_vec};
 
     const MULTIFRAGMENT_UPDATE_PDU_BUFFER: [u8; 4] = [0xf4, 0xf3, 0xf2, 0xf1];
     const MULTIFRAGMENT_UPDATE_PDU: MultifragmentUpdate = MultifragmentUpdate {

crates/ironrdp-pdu/src/rdp/capability_sets/offscreen_bitmap_cache.rs

@@ -1,8 +1,8 @@
 #[cfg(test)]
 mod tests;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const OFFSCREEN_BITMAP_CACHE_LENGTH: usize = 8;
 

crates/ironrdp-pdu/src/rdp/capability_sets/offscreen_bitmap_cache/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const OFFSCREEN_BITMAP_CACHE_BUFFER: [u8; 8] = [
     0x01, 0x00, 0x00, 0x00, // offscreenSupportLevel

crates/ironrdp-pdu/src/rdp/capability_sets/order.rs

@@ -3,8 +3,8 @@ mod tests;
 
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const ORDER_LENGTH: usize = 84;
 const ORD_LEVEL_1_ORDERS: u16 = 1;

crates/ironrdp-pdu/src/rdp/capability_sets/order/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const ORDER_BUFFER: [u8; 84] = [
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

crates/ironrdp-pdu/src/rdp/capability_sets/pointer.rs

@@ -1,8 +1,8 @@
 #[cfg(test)]
 mod tests;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const POINTER_LENGTH: usize = 6;
 

crates/ironrdp-pdu/src/rdp/capability_sets/pointer/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const POINTER_BUFFER: [u8; 6] = [
     0x01, 0x00, // colorPointerFlag

crates/ironrdp-pdu/src/rdp/capability_sets/sound.rs

@@ -3,8 +3,8 @@ mod tests;
 
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const SOUND_LENGTH: usize = 4;
 

crates/ironrdp-pdu/src/rdp/capability_sets/sound/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const SOUND_BUFFER: [u8; 4] = [0x01, 0x00, 0x00, 0x00];
 

crates/ironrdp-pdu/src/rdp/capability_sets/surface_commands.rs

@@ -3,8 +3,8 @@ mod tests;
 
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const SURFACE_COMMANDS_LENGTH: usize = 8;
 

crates/ironrdp-pdu/src/rdp/capability_sets/surface_commands/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const SURFACE_COMMANDS_BUFFER: [u8; 8] = [
     0x52, 0x00, 0x00, 0x00, // flags

crates/ironrdp-pdu/src/rdp/capability_sets/virtual_channel.rs

@@ -3,8 +3,8 @@ mod tests;
 
 use bitflags::bitflags;
 
-use crate::{Decode, DecodeResult, Encode, EncodeResult};
 use ironrdp_core::{ensure_fixed_part_size, ensure_size, ReadCursor, WriteCursor};
+use ironrdp_core::{Decode, DecodeResult, Encode, EncodeResult};
 
 const FLAGS_FIELD_SIZE: usize = 4;
 const CHUNK_SIZE_FIELD_SIZE: usize = 4;

crates/ironrdp-pdu/src/rdp/capability_sets/virtual_channel/tests.rs

@@ -1,7 +1,7 @@
 use lazy_static::lazy_static;
 
 use super::*;
-use crate::{decode, encode_vec};
+use ironrdp_core::{decode, encode_vec};
 
 const VIRTUAL_CHANNEL_INCOMPLETE_BUFFER: [u8; 4] = [
     0x01, 0x00, 0x00, 0x00, // flags