refactor(pdu)!: fix unwrap_used clippy lint warnings (#964)

Co-authored-by: Benoît CORTIER <git.divisible626@passmail.com>

Author: RRRadicalEdward

crates/ironrdp-acceptor/src/connection.rs

@@ -381,16 +381,10 @@ impl Sequence for Acceptor {
 
                 debug!(message = ?settings_initial, "Received");
 
-                let early_capability = settings_initial
-                    .conference_create_request
-                    .gcc_blocks
-                    .core
-                    .optional_data
-                    .early_capability_flags;
-
-                let joined: Vec<_> = settings_initial
-                    .conference_create_request
-                    .gcc_blocks
+                let gcc_blocks = settings_initial.conference_create_request.into_gcc_blocks();
+                let early_capability = gcc_blocks.core.optional_data.early_capability_flags;
+
+                let joined: Vec<_> = gcc_blocks
                     .network
                     .map(|network| {
                         network
@@ -450,10 +444,8 @@ impl Sequence for Acceptor {
                 );
 
                 let settings_response = mcs::ConnectResponse {
-                    conference_create_response: gcc::ConferenceCreateResponse {
-                        user_id: self.user_channel_id,
-                        gcc_blocks: server_blocks,
-                    },
+                    conference_create_response: gcc::ConferenceCreateResponse::new(self.user_channel_id, server_blocks)
+                        .map_err(ConnectorError::decode)?,
                     called_connect_id: 1,
                     domain_parameters: mcs::DomainParameters::target(),
                 };

crates/ironrdp-connector/src/connection.rs

@@ -345,7 +345,8 @@ impl Sequence for ClientConnector {
                 let client_gcc_blocks =
                     create_gcc_blocks(&self.config, selected_protocol, self.static_channels.values())?;
 
-                let connect_initial = mcs::ConnectInitial::with_gcc_blocks(client_gcc_blocks);
+                let connect_initial =
+                    mcs::ConnectInitial::with_gcc_blocks(client_gcc_blocks).map_err(ConnectorError::decode)?;
 
                 debug!(message = ?connect_initial, "Send");
 
@@ -365,9 +366,9 @@ impl Sequence for ClientConnector {
 
                 debug!(message = ?connect_response, "Received");
 
-                let client_gcc_blocks = &connect_initial.conference_create_request.gcc_blocks;
+                let client_gcc_blocks = connect_initial.conference_create_request.gcc_blocks();
 
-                let server_gcc_blocks = connect_response.conference_create_response.gcc_blocks;
+                let server_gcc_blocks = connect_response.conference_create_response.into_gcc_blocks();
 
                 if client_gcc_blocks.security == gcc::ClientSecurityData::no_security()
                     && server_gcc_blocks.security != gcc::ServerSecurityData::no_security()

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

@@ -7,8 +7,8 @@ use ironrdp_core::{
     decode_cursor, ensure_fixed_part_size, ensure_size, invalid_field_err, Decode, DecodeError, DecodeResult, Encode,
     EncodeResult, InvalidFieldErr as _, ReadCursor, WriteCursor,
 };
-use num_derive::{FromPrimitive, ToPrimitive};
-use num_traits::{FromPrimitive as _, ToPrimitive as _};
+use num_derive::FromPrimitive;
+use num_traits::FromPrimitive as _;
 
 use super::bitmap::BitmapUpdateData;
 use super::pointer::PointerUpdateData;
@@ -136,15 +136,15 @@ impl Encode for FastPathUpdatePdu<'_> {
         }
 
         let mut header = 0u8;
-        header.set_bits(0..4, self.update_code.to_u8().unwrap());
-        header.set_bits(4..6, self.fragmentation.to_u8().unwrap());
+        header.set_bits(0..4, self.update_code.as_u8());
+        header.set_bits(4..6, self.fragmentation.as_u8());
 
         dst.write_u8(header);
 
         if self.compression_flags.is_some() {
             header.set_bits(6..8, Compression::COMPRESSION_USED.bits());
-            let compression_flags_with_type = self.compression_flags.map(|f| f.bits()).unwrap_or(0)
-                | self.compression_type.and_then(|f| f.to_u8()).unwrap_or(0);
+            let compression_flags_with_type =
+                self.compression_flags.map(|f| f.bits()).unwrap_or(0) | self.compression_type.map_or(0, |f| f.as_u8());
             dst.write_u8(compression_flags_with_type);
         }
 
@@ -312,7 +312,8 @@ impl Encode for FastPathUpdate<'_> {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive)]
 pub enum UpdateCode {
     Orders = 0x0,
     Bitmap = 0x1,
@@ -328,6 +329,16 @@ pub enum UpdateCode {
     LargePointer = 0xc,
 }
 
+impl UpdateCode {
+    #[expect(
+        clippy::as_conversions,
+        reason = "guarantees discriminant layout, and as is the only way to cast enum -> primitive"
+    )]
+    pub fn as_u8(self) -> u8 {
+        self as u8
+    }
+}
+
 impl From<&FastPathUpdate<'_>> for UpdateCode {
     fn from(update: &FastPathUpdate<'_>) -> Self {
         match update {
@@ -346,14 +357,25 @@ impl From<&FastPathUpdate<'_>> for UpdateCode {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive)]
 pub enum Fragmentation {
     Single = 0x0,
     Last = 0x1,
     First = 0x2,
     Next = 0x3,
 }
 
+impl Fragmentation {
+    #[expect(
+        clippy::as_conversions,
+        reason = "guarantees discriminant layout, and as is the only way to cast enum -> primitive"
+    )]
+    pub fn as_u8(self) -> u8 {
+        self as u8
+    }
+}
+
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
     pub struct EncryptionFlags: u8 {

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

@@ -7,7 +7,7 @@ use ironrdp_core::{
     WriteCursor,
 };
 use num_derive::{FromPrimitive, ToPrimitive};
-use num_traits::{FromPrimitive as _, ToPrimitive as _};
+use num_traits::FromPrimitive as _;
 
 use crate::geometry::ExclusiveRectangle;
 
@@ -31,7 +31,7 @@ impl Encode for SurfaceCommand<'_> {
         ensure_size!(in: dst, size: self.size());
 
         let cmd_type = SurfaceCommandType::from(self);
-        dst.write_u16(cmd_type.to_u16().unwrap());
+        dst.write_u16(cmd_type.as_u16());
 
         match self {
             Self::SetSurfaceBits(pdu) | Self::StreamSurfaceBits(pdu) => pdu.encode(dst),
@@ -324,14 +324,24 @@ impl Decode<'_> for BitmapDataHeader {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, FromPrimitive, ToPrimitive)]
+#[derive(Debug, Copy, Clone, PartialEq, FromPrimitive)]
 #[repr(u16)]
 enum SurfaceCommandType {
     SetSurfaceBits = 0x01,
     FrameMarker = 0x04,
     StreamSurfaceBits = 0x06,
 }
 
+impl SurfaceCommandType {
+    #[expect(
+        clippy::as_conversions,
+        reason = "guarantees discriminant layout, and as is the only way to cast enum -> primitive"
+    )]
+    fn as_u16(self) -> u16 {
+        self as u16
+    }
+}
+
 impl From<&SurfaceCommand<'_>> for SurfaceCommandType {
     fn from(command: &SurfaceCommand<'_>) -> Self {
         match command {

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

@@ -5,8 +5,8 @@ use ironrdp_core::{
     cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, Decode, DecodeResult, Encode, EncodeResult,
     ReadCursor, WriteCursor,
 };
-use num_derive::{FromPrimitive, ToPrimitive};
-use num_traits::{FromPrimitive as _, ToPrimitive as _};
+use num_derive::FromPrimitive;
+use num_traits::FromPrimitive as _;
 
 use crate::rdp::capability_sets::{RfxCaps, RfxCapset};
 
@@ -187,7 +187,7 @@ impl Encode for BlockHeader {
     fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()> {
         ensure_fixed_part_size!(in: dst);
 
-        dst.write_u16(self.ty.to_u16().unwrap());
+        dst.write_u16(self.ty.as_u16());
         dst.write_u32(cast_length!("data len", self.data_length)?);
 
         Ok(())
@@ -307,7 +307,7 @@ impl<'de> Decode<'de> for FrameAcknowledgePdu {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive)]
 #[repr(u16)]
 pub enum BlockType {
     Tile = 0xCAC3,
@@ -330,4 +330,12 @@ impl BlockType {
             BlockType::Context | BlockType::FrameBegin | BlockType::FrameEnd | BlockType::Region | BlockType::Extension
         )
     }
+
+    #[expect(
+        clippy::as_conversions,
+        reason = "guarantees discriminant layout, and as is the only way to cast enum -> primitive"
+    )]
+    fn as_u16(self) -> u16 {
+        self as u16
+    }
 }

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

@@ -4,8 +4,8 @@ use ironrdp_core::{
     cast_length, ensure_fixed_part_size, ensure_size, invalid_field_err, Decode, DecodeResult, Encode, EncodeResult,
     ReadCursor, WriteCursor,
 };
-use num_derive::{FromPrimitive, ToPrimitive};
-use num_traits::{FromPrimitive as _, ToPrimitive as _};
+use num_derive::FromPrimitive;
+use num_traits::FromPrimitive as _;
 
 use crate::codecs::rfx::Block;
 
@@ -48,7 +48,7 @@ impl Encode for ContextPdu {
         properties.set_bits(0..3, self.flags.bits());
         properties.set_bits(3..5, COLOR_CONVERSION_ICT);
         properties.set_bits(5..9, CLW_XFORM_DWT_53_A);
-        properties.set_bits(9..13, self.entropy_algorithm.to_u16().unwrap());
+        properties.set_bits(9..13, self.entropy_algorithm.as_u16());
         properties.set_bits(13..15, SCALAR_QUANTIZATION);
         properties.set_bit(15, false); // reserved
         dst.write_u16(properties);
@@ -297,7 +297,7 @@ impl Encode for TileSetPdu<'_> {
         properties.set_bits(1..4, OperatingMode::empty().bits()); // The decoder MUST ignore this flag
         properties.set_bits(4..6, COLOR_CONVERSION_ICT);
         properties.set_bits(6..10, CLW_XFORM_DWT_53_A);
-        properties.set_bits(10..14, self.entropy_algorithm.to_u16().unwrap());
+        properties.set_bits(10..14, self.entropy_algorithm.as_u16());
         properties.set_bits(14..16, SCALAR_QUANTIZATION);
         dst.write_u16(properties);
 
@@ -666,13 +666,23 @@ impl<'de> Decode<'de> for Tile<'de> {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive)]
 #[repr(u16)]
 pub enum EntropyAlgorithm {
     Rlgr1 = 0x01,
     Rlgr3 = 0x04,
 }
 
+impl EntropyAlgorithm {
+    #[expect(
+        clippy::as_conversions,
+        reason = "guarantees discriminant layout, and as is the only way to cast enum -> primitive"
+    )]
+    fn as_u16(self) -> u16 {
+        self as u16
+    }
+}
+
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
     pub struct OperatingMode: u16 {