nusb 0.2.3

Cross-platform low-level access to USB devices in pure Rust
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use once_cell::sync::OnceCell;
use std::{
    os::windows::{
        io::HandleOrNull,
        prelude::{OwnedHandle, RawHandle},
    },
    ptr, thread,
};
use windows_sys::Win32::{
    Foundation::{GetLastError, FALSE, INVALID_HANDLE_VALUE},
    System::IO::{CreateIoCompletionPort, GetQueuedCompletionStatusEx, OVERLAPPED_ENTRY},
};

use crate::Error;

use super::util::raw_handle;

struct IoCompletionPort(OwnedHandle);

impl IoCompletionPort {
    fn new() -> Result<IoCompletionPort, Error> {
        unsafe {
            let port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, ptr::null_mut(), 0, 0);
            match HandleOrNull::from_raw_handle(port as RawHandle).try_into() {
                Ok(handle) => Ok(IoCompletionPort(handle)),
                Err(_) => Err(Error::new_os(
                    crate::ErrorKind::Other,
                    "failed to create IO completion port",
                    GetLastError(),
                )
                .log_error()),
            }
        }
    }

    fn register(&self, handle: &OwnedHandle) -> Result<(), Error> {
        unsafe {
            let r = CreateIoCompletionPort(raw_handle(handle), raw_handle(&self.0), 0, 0);
            if r.is_null() {
                Err(Error::new_os(
                    crate::ErrorKind::Other,
                    "failed to register IO completion port",
                    GetLastError(),
                )
                .log_error())
            } else {
                Ok(())
            }
        }
    }

    fn wait(&self, events: &mut Vec<OVERLAPPED_ENTRY>) -> Result<(), Error> {
        unsafe {
            let mut event_count = 0;
            let r = GetQueuedCompletionStatusEx(
                raw_handle(&self.0),
                events.as_mut_ptr(),
                events
                    .capacity()
                    .try_into()
                    .expect("events capacity should fit in u32"),
                &mut event_count,
                u32::MAX,
                0,
            );

            if r == FALSE {
                Err(Error::new_os(
                    crate::ErrorKind::Other,
                    "failed to get events from IO completion port",
                    GetLastError(),
                )
                .log_error())
            } else {
                events.set_len(event_count as usize);
                Ok(())
            }
        }
    }
}

static IOCP_HANDLE: OnceCell<IoCompletionPort> = OnceCell::new();

pub(super) fn register(usb_fd: &OwnedHandle) -> Result<(), Error> {
    let mut start_thread = false;
    let iocp = IOCP_HANDLE.get_or_try_init(|| {
        start_thread = true;
        IoCompletionPort::new()
    })?;

    if start_thread {
        thread::spawn(event_loop);
    }

    iocp.register(usb_fd)
}

fn event_loop() {
    let iocp = IOCP_HANDLE.get().unwrap();
    let mut event_list = Vec::with_capacity(8);
    loop {
        event_list.clear();
        iocp.wait(&mut event_list).unwrap();

        for event in &event_list {
            super::transfer::handle_event(event.lpOverlapped);
        }
    }
}