wrest 0.5.7

Async HTTP client for Windows backed by WinHTTP, with a reqwest-compatible API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//! Thin safe wrappers around Win32 / WinHTTP / ICU FFI calls.
//!
//! Every raw `windows_sys` call used by wrest lives in this module tree.
//! The rest of the crate never touches `unsafe` Win32 FFI directly -- it
//! calls these helpers instead.  Each wrapper:
//!
//! * returns `Result<T, Error>` so callers decide how to handle failures,
//! * performs any `&str` → null-terminated wide string conversions, and
//! * hides pointer arithmetic and `std::mem::size_of` boilerplate.
//!
//! The module is split into:
//!
//! * [`winhttp`] -- WinHTTP session, request, query, and I/O wrappers
//! * [`encoding`] -- `MultiByteToWideChar` (NLS) and ICU charset decoding

mod encoding;
mod winhttp;

// Re-export everything so callers use `crate::abi::winhttp_open_session` etc.
pub(crate) use encoding::*;
pub(crate) use winhttp::*;

use crate::Error;
use windows_sys::Win32::Foundation::GetLastError;

// ---------------------------------------------------------------------------
// Low-level result helpers
// ---------------------------------------------------------------------------

/// Build an [`Error`] from the calling thread's last Win32 error.
fn last_win32_error() -> Error {
    let code = unsafe { GetLastError() };
    Error::from_win32(code)
}

/// Map a Win32 `BOOL` (`i32`) return value to `Result`.
fn check_win32_bool(result: i32) -> Result<(), Error> {
    if result != 0 {
        Ok(())
    } else {
        Err(last_win32_error())
    }
}

// ---------------------------------------------------------------------------
// Wide-string helpers
// ---------------------------------------------------------------------------

/// Encode a Rust `&str` as a null-terminated UTF-16 wide string.
fn to_wide(s: &str) -> Vec<u16> {
    s.encode_utf16().chain(std::iter::once(0)).collect()
}

// ---------------------------------------------------------------------------
// Size helpers
// ---------------------------------------------------------------------------

/// `size_of::<T>()` cast to `u32` (DWORD) for Win32 APIs.
#[expect(
    clippy::cast_possible_truncation,
    reason = "compile-time assert above bounds size_of::<T>() to u32::MAX"
)]
pub(crate) const fn dword_size_of<T>() -> u32 {
    const {
        assert!(std::mem::size_of::<T>() <= u32::MAX as usize, "size_of::<T>() exceeds u32::MAX");
    };
    std::mem::size_of::<T>() as u32
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn to_wide_table() {
        let cases: &[(&str, &[u16], &str)] = &[
            ("", &[0], "empty"),
            ("abc", &[b'a' as u16, b'b' as u16, b'c' as u16, 0], "ascii"),
            ("\u{1F600}", &[0xD83D, 0xDE00, 0], "non-BMP surrogate pair"),
        ];

        for &(input, expected, label) in cases {
            let result = to_wide(input);
            assert_eq!(result, expected, "to_wide: {label}");
        }
    }
}