1945709951

Build # 1945709951

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/google/OpenSK/commit/<a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/2e860eb171c6cfe2ea54fdeb297d0e768ba3bcb2">2e860eb17">&lt;a href=&quot;https://github.com/google/OpenSK/commit/</a><a class="double-link" href="https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/2e860eb171c6cfe2ea54fdeb297d0e768ba3bcb2">2e860eb17</a><a href="https://github.com/google/OpenSK/commit/2e860eb171c6cfe2ea54fdeb297d0e768ba3bcb2">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/2e860eb171c6cfe2ea54fdeb297d0e768ba3bcb2&quot;&gt;2e860eb17&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/2e860eb171c6cfe2ea54fdeb297d0e768ba3bcb2&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/OpenSK/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #436: HID refactoring

Run Details

138 of 138 new or added lines in 3 files covered. (100.0%)

12336 of 13581 relevant lines covered (90.83%)

545279.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/env/tock.rs

use crate::ctap::hid::{ChannelID, CtapHid, CtapHidCommand, KeepaliveStatus, ProcessedPacket};
use crate::ctap::status_code::Ctap2StatusCode;
use crate::env::{Env, UserPresence};
use core::cell::Cell;
#[cfg(feature = "debug_ctap")]
use core::fmt::Write;
use crypto::rng256::TockRng256;
use libtock_core::result::{CommandError, EALREADY};
use libtock_drivers::buttons::{self, ButtonState};
#[cfg(feature = "debug_ctap")]
use libtock_drivers::console::Console;
use libtock_drivers::result::{FlexUnwrap, TockError};
use libtock_drivers::timer::Duration;
use libtock_drivers::{led, timer, usb_ctap_hid};

pub struct TockEnv {
    rng: TockRng256,
}

impl TockEnv {
    pub fn new() -> Self {
        let rng = TockRng256 {};
        TockEnv { rng }
    }
}

impl UserPresence for TockEnv {
    fn check(&self, cid: ChannelID) -> Result<(), Ctap2StatusCode> {
        check_user_presence(cid)
    }
}

impl Env for TockEnv {
    type Rng = TockRng256;
    type UserPresence = Self;

    fn rng(&mut self) -> &mut Self::Rng {
        &mut self.rng
    }

    fn user_presence(&mut self) -> &mut Self::UserPresence {
        self
    }
}

// Returns whether the keepalive was sent, or false if cancelled.
fn send_keepalive_up_needed(
    cid: ChannelID,
    timeout: Duration<isize>,
) -> Result<(), Ctap2StatusCode> {
    let keepalive_msg = CtapHid::keepalive(cid, KeepaliveStatus::UpNeeded);
    for mut pkt in keepalive_msg {
        let status = usb_ctap_hid::send_or_recv_with_timeout(&mut pkt, timeout);
        match status {
            None => {
                #[cfg(feature = "debug_ctap")]
                writeln!(Console::new(), "Sending a KEEPALIVE packet timed out").unwrap();
                // TODO: abort user presence test?
            }
            Some(usb_ctap_hid::SendOrRecvStatus::Error) => panic!("Error sending KEEPALIVE packet"),
            Some(usb_ctap_hid::SendOrRecvStatus::Sent) => {
                #[cfg(feature = "debug_ctap")]
                writeln!(Console::new(), "Sent KEEPALIVE packet").unwrap();
            }
            Some(usb_ctap_hid::SendOrRecvStatus::Received) => {
                // We only parse one packet, because we only care about CANCEL.
                let (received_cid, processed_packet) = CtapHid::process_single_packet(&pkt);
                if received_cid != &cid {
                    #[cfg(feature = "debug_ctap")]
                    writeln!(
                        Console::new(),
                        "Received a packet on channel ID {:?} while sending a KEEPALIVE packet",
                        received_cid,
                    )
                    .unwrap();
                    return Ok(());
                }
                match processed_packet {
                    ProcessedPacket::InitPacket { cmd, .. } => {
                        if cmd == CtapHidCommand::Cancel as u8 {
                            // We ignore the payload, we can't answer with an error code anyway.
                            #[cfg(feature = "debug_ctap")]
                            writeln!(Console::new(), "User presence check cancelled").unwrap();
                            return Err(Ctap2StatusCode::CTAP2_ERR_KEEPALIVE_CANCEL);
                        } else {
                            #[cfg(feature = "debug_ctap")]
                            writeln!(
                                Console::new(),
                                "Discarded packet with command {} received while sending a KEEPALIVE packet",
                                cmd,
                            )
                            .unwrap();
                        }
                    }
                    ProcessedPacket::ContinuationPacket { .. } => {
                        #[cfg(feature = "debug_ctap")]
                        writeln!(
                            Console::new(),
                            "Discarded continuation packet received while sending a KEEPALIVE packet",
                        )
                        .unwrap();
                    }
                }
            }
        }
    }
    Ok(())
}

pub fn blink_leds(pattern_seed: usize) {
    for l in 0..led::count().flex_unwrap() {
        if (pattern_seed ^ l).count_ones() & 1 != 0 {
            led::get(l).flex_unwrap().on().flex_unwrap();
        } else {
            led::get(l).flex_unwrap().off().flex_unwrap();
        }
    }
}

pub fn wink_leds(pattern_seed: usize) {
    // This generates a "snake" pattern circling through the LEDs.
    // Fox example with 4 LEDs the sequence of lit LEDs will be the following.
    // 0 1 2 3
    // * *
    // * * *
    //   * *
    //   * * *
    //     * *
    // *   * *
    // *     *
    // * *   *
    // * *
    let count = led::count().flex_unwrap();
    let a = (pattern_seed / 2) % count;
    let b = ((pattern_seed + 1) / 2) % count;
    let c = ((pattern_seed + 3) / 2) % count;

    for l in 0..count {
        // On nRF52840-DK, logically swap LEDs 3 and 4 so that the order of LEDs form a circle.
        let k = match l {
            2 => 3,
            3 => 2,
            _ => l,
        };
        if k == a || k == b || k == c {
            led::get(l).flex_unwrap().on().flex_unwrap();
        } else {
            led::get(l).flex_unwrap().off().flex_unwrap();
        }
    }
}

pub fn switch_off_leds() {
    for l in 0..led::count().flex_unwrap() {
        led::get(l).flex_unwrap().off().flex_unwrap();
    }
}

const KEEPALIVE_DELAY_MS: isize = 100;
pub const KEEPALIVE_DELAY: Duration<isize> = Duration::from_ms(KEEPALIVE_DELAY_MS);

fn check_user_presence(cid: ChannelID) -> Result<(), Ctap2StatusCode> {
    // The timeout is N times the keepalive delay.
    const TIMEOUT_ITERATIONS: usize =
        crate::ctap::TOUCH_TIMEOUT_MS as usize / KEEPALIVE_DELAY_MS as usize;

    // First, send a keep-alive packet to notify that the keep-alive status has changed.
    send_keepalive_up_needed(cid, KEEPALIVE_DELAY)?;

    // Listen to the button presses.
    let button_touched = Cell::new(false);
    let mut buttons_callback = buttons::with_callback(|_button_num, state| {
        match state {
            ButtonState::Pressed => button_touched.set(true),
            ButtonState::Released => (),
        };
    });
    let mut buttons = buttons_callback.init().flex_unwrap();
    // At the moment, all buttons are accepted. You can customize your setup here.
    for mut button in &mut buttons {
        button.enable().flex_unwrap();
    }

    let mut keepalive_response = Ok(());
    for i in 0..TIMEOUT_ITERATIONS {
        blink_leds(i);

        // Setup a keep-alive callback.
        let keepalive_expired = Cell::new(false);
        let mut keepalive_callback = timer::with_callback(|_, _| {
            keepalive_expired.set(true);
        });
        let mut keepalive = keepalive_callback.init().flex_unwrap();
        let keepalive_alarm = keepalive.set_alarm(KEEPALIVE_DELAY).flex_unwrap();

        // Wait for a button touch or an alarm.
        libtock_drivers::util::yieldk_for(|| button_touched.get() || keepalive_expired.get());

        // Cleanup alarm callback.
        match keepalive.stop_alarm(keepalive_alarm) {
            Ok(()) => (),
            Err(TockError::Command(CommandError {
                return_code: EALREADY,
                ..
            })) => assert!(keepalive_expired.get()),
            Err(_e) => {
                #[cfg(feature = "debug_ctap")]
                panic!("Unexpected error when stopping alarm: {:?}", _e);
                #[cfg(not(feature = "debug_ctap"))]
                panic!("Unexpected error when stopping alarm: <error is only visible with the debug_ctap feature>");
            }
        }

        // TODO: this may take arbitrary time. The keepalive_delay should be adjusted accordingly,
        // so that LEDs blink with a consistent pattern.
        if keepalive_expired.get() {
            // Do not return immediately, because we must clean up still.
            keepalive_response = send_keepalive_up_needed(cid, KEEPALIVE_DELAY);
        }

        if button_touched.get() || keepalive_response.is_err() {
            break;
        }
    }

    switch_off_leds();

    // Cleanup button callbacks.
    for mut button in &mut buttons {
        button.disable().flex_unwrap();
    }

    // Returns whether the user was present.
    if keepalive_response.is_err() {
        keepalive_response
    } else if button_touched.get() {
        Ok(())
    } else {
        Err(Ctap2StatusCode::CTAP2_ERR_USER_ACTION_TIMEOUT)
    }
}

1	use crate::ctap::hid::{ChannelID, CtapHid, CtapHidCommand, KeepaliveStatus, ProcessedPacket};
2	use crate::ctap::status_code::Ctap2StatusCode;
3	use crate::env::{Env, UserPresence};
4	use core::cell::Cell;
5	#[cfg(feature = "debug_ctap")]
6	use core::fmt::Write;
7	use crypto::rng256::TockRng256;
8	use libtock_core::result::{CommandError, EALREADY};
9	use libtock_drivers::buttons::{self, ButtonState};
10	#[cfg(feature = "debug_ctap")]
11	use libtock_drivers::console::Console;
12	use libtock_drivers::result::{FlexUnwrap, TockError};
13	use libtock_drivers::timer::Duration;
14	use libtock_drivers::{led, timer, usb_ctap_hid};
15
16	pub struct TockEnv {
17	rng: TockRng256,
18	}
19
20	impl TockEnv {
21	pub fn new() -> Self {
22	let rng = TockRng256 {};
23	TockEnv { rng }
24	}
25	}
26
27	impl UserPresence for TockEnv {
28	fn check(&self, cid: ChannelID) -> Result<(), Ctap2StatusCode> {
29	check_user_presence(cid)
30	}
31	}
32
33	impl Env for TockEnv {
34	type Rng = TockRng256;
35	type UserPresence = Self;
36
37	fn rng(&mut self) -> &mut Self::Rng {
38	&mut self.rng
39	}
40
41	fn user_presence(&mut self) -> &mut Self::UserPresence {
42	self
43	}
44	}
45
46	// Returns whether the keepalive was sent, or false if cancelled.
47	fn send_keepalive_up_needed(	×
48	cid: ChannelID,	×
49	timeout: Duration<isize>,	×
50	) -> Result<(), Ctap2StatusCode> {	×
51	let keepalive_msg = CtapHid::keepalive(cid, KeepaliveStatus::UpNeeded);	×
52	for mut pkt in keepalive_msg {	×
53	let status = usb_ctap_hid::send_or_recv_with_timeout(&mut pkt, timeout);	×
54	match status {	×
55	None => {	×
56	#[cfg(feature = "debug_ctap")]	×
57	writeln!(Console::new(), "Sending a KEEPALIVE packet timed out").unwrap();	×
58	// TODO: abort user presence test?	×
59	}	×
60	Some(usb_ctap_hid::SendOrRecvStatus::Error) => panic!("Error sending KEEPALIVE packet"),	×
61	Some(usb_ctap_hid::SendOrRecvStatus::Sent) => {	×
62	#[cfg(feature = "debug_ctap")]	×
63	writeln!(Console::new(), "Sent KEEPALIVE packet").unwrap();	×
64	}	×
65	Some(usb_ctap_hid::SendOrRecvStatus::Received) => {
66	// We only parse one packet, because we only care about CANCEL.
67	let (received_cid, processed_packet) = CtapHid::process_single_packet(&pkt);	×
68	if received_cid != &cid {	×
69	#[cfg(feature = "debug_ctap")]
70	writeln!(
71	Console::new(),
72	"Received a packet on channel ID {:?} while sending a KEEPALIVE packet",
73	received_cid,
74	)
75	.unwrap();
76	return Ok(());	×
77	}	×
78	match processed_packet {	×
79	ProcessedPacket::InitPacket { cmd, .. } => {	×
80	if cmd == CtapHidCommand::Cancel as u8 {	×
81	// We ignore the payload, we can't answer with an error code anyway.
82	#[cfg(feature = "debug_ctap")]
83	writeln!(Console::new(), "User presence check cancelled").unwrap();
84	return Err(Ctap2StatusCode::CTAP2_ERR_KEEPALIVE_CANCEL);	×
85	} else {	×
86	#[cfg(feature = "debug_ctap")]	×
87	writeln!(	×
88	Console::new(),	×
89	"Discarded packet with command {} received while sending a KEEPALIVE packet",	×
90	cmd,	×
91	)	×
92	.unwrap();	×
93	}	×
94	}
95	ProcessedPacket::ContinuationPacket { .. } => {	×
96	#[cfg(feature = "debug_ctap")]	×
97	writeln!(	×
98	Console::new(),	×
99	"Discarded continuation packet received while sending a KEEPALIVE packet",	×
100	)	×
101	.unwrap();	×
102	}	×
103	}
104	}
105	}
106	}
107	Ok(())	×
108	}	×
109
110	pub fn blink_leds(pattern_seed: usize) {	×
111	for l in 0..led::count().flex_unwrap() {	×
112	if (pattern_seed ^ l).count_ones() & 1 != 0 {	×
113	led::get(l).flex_unwrap().on().flex_unwrap();	×
114	} else {	×
115	led::get(l).flex_unwrap().off().flex_unwrap();	×
116	}	×
117	}
118	}	×
119
120	pub fn wink_leds(pattern_seed: usize) {	×
121	// This generates a "snake" pattern circling through the LEDs.	×
122	// Fox example with 4 LEDs the sequence of lit LEDs will be the following.	×
123	// 0 1 2 3	×
124	// * *	×
125	// * * *	×
126	// * *	×
127	// * * *	×
128	// * *	×
129	// * * *	×
130	// * *	×
131	// * * *	×
132	// * *	×
133	let count = led::count().flex_unwrap();	×
134	let a = (pattern_seed / 2) % count;	×
135	let b = ((pattern_seed + 1) / 2) % count;	×
136	let c = ((pattern_seed + 3) / 2) % count;	×
137
138	for l in 0..count {	×
139	// On nRF52840-DK, logically swap LEDs 3 and 4 so that the order of LEDs form a circle.
140	let k = match l {	×
141	2 => 3,	×
142	3 => 2,	×
143	_ => l,	×
144	};
145	if k == a \|\| k == b \|\| k == c {	×
146	led::get(l).flex_unwrap().on().flex_unwrap();	×
147	} else {	×
148	led::get(l).flex_unwrap().off().flex_unwrap();	×
149	}	×
150	}
151	}	×
152
153	pub fn switch_off_leds() {	×
154	for l in 0..led::count().flex_unwrap() {	×
155	led::get(l).flex_unwrap().off().flex_unwrap();	×
156	}	×
157	}	×
158
159	const KEEPALIVE_DELAY_MS: isize = 100;
160	pub const KEEPALIVE_DELAY: Duration<isize> = Duration::from_ms(KEEPALIVE_DELAY_MS);
161
162	fn check_user_presence(cid: ChannelID) -> Result<(), Ctap2StatusCode> {	×
163	// The timeout is N times the keepalive delay.
164	const TIMEOUT_ITERATIONS: usize =
165	crate::ctap::TOUCH_TIMEOUT_MS as usize / KEEPALIVE_DELAY_MS as usize;
166
167	// First, send a keep-alive packet to notify that the keep-alive status has changed.
168	send_keepalive_up_needed(cid, KEEPALIVE_DELAY)?;	×
169
170	// Listen to the button presses.
171	let button_touched = Cell::new(false);	×
172	let mut buttons_callback = buttons::with_callback(\|_button_num, state\| {	×
173	match state {	×
174	ButtonState::Pressed => button_touched.set(true),	×
175	ButtonState::Released => (),	×
176	};
177	});	×
178	let mut buttons = buttons_callback.init().flex_unwrap();	×
179	// At the moment, all buttons are accepted. You can customize your setup here.
180	for mut button in &mut buttons {	×
181	button.enable().flex_unwrap();	×
182	}	×
183
184	let mut keepalive_response = Ok(());	×
185	for i in 0..TIMEOUT_ITERATIONS {	×
186	blink_leds(i);	×
187		×
188	// Setup a keep-alive callback.	×
189	let keepalive_expired = Cell::new(false);	×
190	let mut keepalive_callback = timer::with_callback(\|_, _\| {	×
191	keepalive_expired.set(true);
192	});	×
193	let mut keepalive = keepalive_callback.init().flex_unwrap();	×
194	let keepalive_alarm = keepalive.set_alarm(KEEPALIVE_DELAY).flex_unwrap();	×
195		×
196	// Wait for a button touch or an alarm.	×
197	libtock_drivers::util::yieldk_for(\|\| button_touched.get() \|\| keepalive_expired.get());	×
198		×
199	// Cleanup alarm callback.	×
200	match keepalive.stop_alarm(keepalive_alarm) {	×
201	Ok(()) => (),	×
202	Err(TockError::Command(CommandError {	×
203	return_code: EALREADY,	×
204	..	×
205	})) => assert!(keepalive_expired.get()),	×
206	Err(_e) => {	×
207	#[cfg(feature = "debug_ctap")]	×
208	panic!("Unexpected error when stopping alarm: {:?}", _e);	×
209	#[cfg(not(feature = "debug_ctap"))]	×
210	panic!("Unexpected error when stopping alarm: <error is only visible with the debug_ctap feature>");	×
211	}
212	}
213
214	// TODO: this may take arbitrary time. The keepalive_delay should be adjusted accordingly,
215	// so that LEDs blink with a consistent pattern.
216	if keepalive_expired.get() {	×
217	// Do not return immediately, because we must clean up still.	×
218	keepalive_response = send_keepalive_up_needed(cid, KEEPALIVE_DELAY);	×
219	}	×
220
221	if button_touched.get() \|\| keepalive_response.is_err() {	×
222	break;	×
223	}	×
224	}
225
226	switch_off_leds();	×
227
228	// Cleanup button callbacks.
229	for mut button in &mut buttons {	×
230	button.disable().flex_unwrap();	×
231	}	×
232
233	// Returns whether the user was present.
234	if keepalive_response.is_err() {	×
235	keepalive_response	×
236	} else if button_touched.get() {	×
237	Ok(())	×
238	} else {
239	Err(Ctap2StatusCode::CTAP2_ERR_USER_ACTION_TIMEOUT)	×
240	}
241	}	×

google / OpenSK / 1945709951

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous