@@ -121,9 +121,31 @@ impl From<State> for winscard::winscard::State {
 /// The user can use this environment variable to customize the `pcsc-lite` library loading.
 const PCSC_LITE_LIB_PATH_ENV: &str = "PCSC_LITE_LIB_PATH";
 
+/// Windows device type for the smart card IOCTLs.
+///
+/// `#define FILE_DEVICE_SMARTCARD 0x00000031`
+const FILE_DEVICE_SMARTCARD: u32 = 0x0000_0031;
+
+/// Translates a Windows smart card control code into its `pcsc-lite` counterpart.
+///
+/// Windows encodes `SCARD_CTL_CODE(code)` as `0x00310000 | (code << 2)`, `pcsc-lite` as
+/// `0x42000000 + code`. RDP servers always send the Windows encoding.
+///
+/// Control codes that do not belong to the smart card device type are returned unchanged.
+pub fn win_scard_ctl_code_to_pcsc_lite(control_code: u32) -> u32 {
+    // `#define DEVICE_TYPE_FROM_CTL_CODE(ctrlCode) (((DWORD)(ctrlCode & 0xFFFF0000)) >> 16)`
+    if (control_code >> 16) != FILE_DEVICE_SMARTCARD {
+        return control_code;
+    }
+
+    // `#define FUNCTION_FROM_CTL_CODE(ctrlCode) ((DWORD)((ctrlCode >> 2) & 0xFFF))`
+    0x4200_0000 + ((control_code >> 2) & 0xFFF)
+}
+
 pub fn initialize_pcsc_lite_api() -> WinScardResult<PcscLiteApiFunctionTable> {
-    let pcsc_lite_path = if let Ok(lib_path) = env::var(PCSC_LITE_LIB_PATH_ENV) {
-        Cow::Owned(lib_path)
+    let user_selected_lib = env::var(PCSC_LITE_LIB_PATH_ENV).ok();
+    let pcsc_lite_path = if let Some(lib_path) = user_selected_lib.as_deref() {
+        Cow::Borrowed(lib_path)
     } else {
         #[cfg(target_os = "macos")]
         {
@@ -147,16 +169,22 @@ pub fn initialize_pcsc_lite_api() -> WinScardResult<PcscLiteApiFunctionTable> {
         ));
     }
 
-    macro_rules! load_fn {
-        ($func_name:literal) => {{
-            let fn_name = CString::new($func_name).expect("CString creation should not fail");
+    macro_rules! load_sym {
+        ($sym_name:literal) => {{
+            let sym_name = CString::new($sym_name).expect("CString creation should not fail");
 
             // SAFETY:
             // - We've checked the `handle` above.
-            // - `fn_name` is correct and hardcoded in the code.
-            let fn_ptr = unsafe { dlsym(handle, fn_name.as_ptr()) };
-            debug!(?fn_ptr, $func_name);
+            // - `sym_name` is correct and hardcoded in the code.
+            let sym_ptr = unsafe { dlsym(handle, sym_name.as_ptr()) };
+            debug!(?sym_ptr, $sym_name);
 
+            sym_ptr
+        }};
+    }
+
+    macro_rules! transmute_fn {
+        ($fn_ptr:expr) => {{
             // SAFETY:
             // - `*mut c_void` and target transmute type are both C pointers. They have the same layout.
             //   Thus, we can safely transmute the C pointer to the C function pointer.
@@ -165,11 +193,18 @@ pub fn initialize_pcsc_lite_api() -> WinScardResult<PcscLiteApiFunctionTable> {
             unsafe {
                 // Not great to silent, but mostly fine in this context.
                 #[expect(clippy::missing_transmute_annotations)]
-                std::mem::transmute::<*mut libc::c_void, _>(fn_ptr)
+                std::mem::transmute::<*mut libc::c_void, _>($fn_ptr)
             }
         }};
     }
 
+    macro_rules! load_fn {
+        ($func_name:literal) => {{
+            let fn_ptr = load_sym!($func_name);
+            transmute_fn!(fn_ptr)
+        }};
+    }
+
     macro_rules! load_io_request {
         ($req_name:literal) => {{
             let req_name = CString::new($req_name).expect("CString creation should not fail");
@@ -189,6 +224,34 @@ pub fn initialize_pcsc_lite_api() -> WinScardResult<PcscLiteApiFunctionTable> {
         }};
     }
 
+    // `PCSC.framework` exports both the legacy pcsc-lite 1.1.2 `SCardControl` (5 parameters) and
+    // `SCardControl132` (7 parameters); its header redirects the former to the latter. A real pcsc-lite
+    // build exports only `SCardControl`, with 7 parameters. Since both libraries can be loaded here, and
+    // the two `SCardControl` variants are indistinguishable by symbol name, only accept the legacy name
+    // from a library the user pointed us at explicitly.
+    #[cfg(target_os = "macos")]
+    let scard_control = {
+        let mut fn_ptr = load_sym!("SCardControl132");
+
+        if fn_ptr.is_null() && user_selected_lib.is_some() {
+            fn_ptr = load_sym!("SCardControl");
+        }
+
+        if fn_ptr.is_null() {
+            return Err(Error::new(
+                ErrorKind::InternalError,
+                format!(
+                    "pcsc-lite library does not export SCardControl132: {}",
+                    pcsc_lite_path.to_str().unwrap()
+                ),
+            ));
+        }
+
+        transmute_fn!(fn_ptr)
+    };
+    #[cfg(not(target_os = "macos"))]
+    let scard_control = load_fn!("SCardControl");
+
     Ok(PcscLiteApiFunctionTable {
         SCardEstablishContext: load_fn!("SCardEstablishContext"),
         SCardReleaseContext: load_fn!("SCardReleaseContext"),
@@ -199,7 +262,7 @@ pub fn initialize_pcsc_lite_api() -> WinScardResult<PcscLiteApiFunctionTable> {
         SCardEndTransaction: load_fn!("SCardEndTransaction"),
         SCardStatus: load_fn!("SCardStatus"),
         SCardGetStatusChange: load_fn!("SCardGetStatusChange"),
-        SCardControl: load_fn!("SCardControl"),
+        SCardControl: scard_control,
         SCardGetAttrib: load_fn!("SCardGetAttrib"),
         SCardSetAttrib: load_fn!("SCardSetAttrib"),
         SCardTransmit: load_fn!("SCardTransmit"),
@@ -214,3 +277,36 @@ pub fn initialize_pcsc_lite_api() -> WinScardResult<PcscLiteApiFunctionTable> {
         g_rgSCardRawPci: load_io_request!("g_rgSCardRawPci"),
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::win_scard_ctl_code_to_pcsc_lite;
+
+    #[test]
+    fn get_feature_request_control_code_is_translated() {
+        // `#define CM_IOCTL_GET_FEATURE_REQUEST SCARD_CTL_CODE(3400)`
+        assert_eq!(0x4200_0D48, win_scard_ctl_code_to_pcsc_lite(0x0031_3520));
+    }
+
+    #[test]
+    fn smart_card_control_codes_are_translated() {
+        // `#define IOCTL_SMARTCARD_POWER SCARD_CTL_CODE(1)`
+        assert_eq!(0x4200_0001, win_scard_ctl_code_to_pcsc_lite(0x0031_0004));
+        // `#define IOCTL_SMARTCARD_GET_ATTRIBUTE SCARD_CTL_CODE(2)`
+        assert_eq!(0x4200_0002, win_scard_ctl_code_to_pcsc_lite(0x0031_0008));
+        // `#define IOCTL_SMARTCARD_GET_STATE SCARD_CTL_CODE(14)`
+        assert_eq!(0x4200_000E, win_scard_ctl_code_to_pcsc_lite(0x0031_0038));
+    }
+
+    #[test]
+    fn pcsc_lite_control_codes_are_passed_through() {
+        assert_eq!(0x4200_0D48, win_scard_ctl_code_to_pcsc_lite(0x4200_0D48));
+        assert_eq!(0x4200_0001, win_scard_ctl_code_to_pcsc_lite(0x4200_0001));
+    }
+
+    #[test]
+    fn non_smart_card_control_codes_are_passed_through() {
+        // `FILE_DEVICE_KEYBOARD`.
+        assert_eq!(0x000B_0004, win_scard_ctl_code_to_pcsc_lite(0x000B_0004));
+    }
+}
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 use std::fmt;
-use std::ptr::null_mut;
+use std::ptr::{null, null_mut};
 
 #[cfg(target_os = "windows")]
 use ffi_types::winscard::functions::SCardApiFunctionTable;
@@ -27,6 +27,34 @@ enum HandleState {
     Connected(ScardHandle),
 }
 
+/// Converts the [ControlCode] into the value expected by the underlying smart card API.
+#[cfg(target_os = "windows")]
+fn native_control_code(code: ControlCode) -> u32 {
+    code
+}
+
+/// Converts the [ControlCode] into the value expected by the underlying smart card API.
+///
+/// See [`crate::winscard::pcsc_lite::win_scard_ctl_code_to_pcsc_lite`].
+#[cfg(not(target_os = "windows"))]
+fn native_control_code(code: ControlCode) -> crate::winscard::pcsc_lite::Dword {
+    // `Dword` is `u32` on macOS and `c_ulong` elsewhere.
+    #[allow(clippy::useless_conversion)]
+    crate::winscard::pcsc_lite::win_scard_ctl_code_to_pcsc_lite(code).into()
+}
+
+/// Returns a pointer to the `SCardControl` input buffer.
+///
+/// An empty slice has a dangling pointer, so a null pointer is returned instead. Both `WinSCard`
+/// and `pcsc-lite` allow `pbSendBuffer` to be null when `cbSendLength` is 0.
+fn control_input_ptr(input: &[u8]) -> *const core::ffi::c_void {
+    if input.is_empty() {
+        null()
+    } else {
+        input.as_ptr().cast()
+    }
+}
+
 /// Represents a system-provided smart card.
 ///
 /// _Hint:_ It's **always better** to explicitly disconnect the card using the [SystemScard::disconnect] method.
@@ -217,22 +245,27 @@ impl WinScard for SystemScard {
     // What if the `code` will be corresponding to operation with output and
     // user will use this method instead of `control_with_output`? Then safety conditions will be violated.
     fn control(&mut self, code: ControlCode, input: &[u8]) -> WinScardResult<()> {
+        let control_code = native_control_code(code);
+        let input_ptr = control_input_ptr(input);
+        // pcsc-lite dereferences `lpBytesReturned` unconditionally.
+        let mut bytes_returned = 0;
+
         try_execute!(
             // SAFETY:
             // - `h_card` is set by a previous call to `SCardConnectA`.
-            // - `input.as_ptr()` is a valid, readable pointer to a
+            // - `input_ptr` is null or a valid, readable pointer to a slice of `input.len()` bytes.
             // - `lpOutBuffer` can be null.
             // - `cbOutBufferSize` is 0 because `lpOutBuffer` is null.
-            // - `lpBytesReturned` can be null if `lpOutBuffer` is null.
+            // - `&mut bytes_returned` is a properly-aligned, writable pointer to a local variable.
             unsafe {
                 (self.api.SCardControl)(
                     self.h_card()?,
-                    code.into(),
-                    input.as_ptr().cast(),
+                    control_code,
+                    input_ptr,
                     input.len().try_into()?,
                     null_mut(),
                     0,
-                    null_mut(),
+                    &mut bytes_returned,
                 )
             },
             "SCardControl failed"
@@ -242,21 +275,23 @@ impl WinScard for SystemScard {
     }
 
     fn control_with_output(&mut self, code: ControlCode, input: &[u8], output: &mut [u8]) -> WinScardResult<usize> {
+        let control_code = native_control_code(code);
+        let input_ptr = control_input_ptr(input);
         let mut receive_len = 0;
         let output_buf_len = output.len().try_into()?;
 
         try_execute!(
             // SAFETY:
             // - `h_card` is set by a previous call to `SCardConnectA`.
-            // - `input.as_ptr()` is a valid, readable pointer to a slice.
+            // - `input_ptr` is null or a valid, readable pointer to a slice of `input.len()` bytes.
             // - `output` is a properly-aligned, writable pointer to a valid slice with size of `output_buf_len`.
             // - `output_buf_len` is valid length for `output` buffer.
             // - `&mut receive_len` is a properly-aligned, writable pointer to a local variable.
             unsafe {
                 (self.api.SCardControl)(
                     self.h_card()?,
-                    code.into(),
-                    input.as_ptr().cast(),
+                    control_code,
+                    input_ptr,
                     input.len().try_into()?,
                     output.as_mut_ptr().cast(),
                     output_buf_len,
@@ -443,3 +478,22 @@ impl WinScard for SystemScard {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::ptr::null;
+
+    use super::control_input_ptr;
+
+    #[test]
+    fn empty_control_input_is_a_null_pointer() {
+        let empty: &[u8] = &[];
+        assert_eq!(null(), control_input_ptr(empty));
+    }
+
+    #[test]
+    fn non_empty_control_input_points_to_the_data() {
+        let input = [1_u8, 2, 3];
+        assert_eq!(input.as_ptr().cast(), control_input_ptr(&input));
+    }
+}