1950611153

Build # 1950611153

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/5a6d9654541d09f3db66ab2b9d03108fcdd37b1d">5a6d96545">&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/5a6d9654541d09f3db66ab2b9d03108fcdd37b1d">5a6d96545</a><a href="https://github.com/google/OpenSK/commit/5a6d9654541d09f3db66ab2b9d03108fcdd37b1d">&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/5a6d9654541d09f3db66ab2b9d03108fcdd37b1d&quot;&gt;5a6d96545&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/5a6d9654541d09f3db66ab2b9d03108fcdd37b1d&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 #438: Add Store and UpgradeStorage to Env

Run Details

1142 of 1142 new or added lines in 10 files covered. (100.0%)

12106 of 13509 relevant lines covered (89.61%)

547576.12 hits per line

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

0.0

/src/env/tock/mod.rs

use self::storage::{SyscallStorage, SyscallUpgradeStorage};
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 core::sync::atomic::{AtomicBool, Ordering};
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};
use persistent_store::{StorageResult, Store};

mod storage;

pub struct TockEnv {
    rng: TockRng256,
    store: Store<SyscallStorage>,
    upgrade_storage: Option<SyscallUpgradeStorage>,
}

impl TockEnv {
    /// Returns the unique instance of the Tock environment.
    ///
    /// # Panics
    ///
    /// - If called a second time.
    pub fn new() -> Self {
        // Make sure the environment was not already taken.
        static TAKEN: AtomicBool = AtomicBool::new(false);
        assert!(!TAKEN.fetch_or(true, Ordering::SeqCst));
        let storage = unsafe { steal_storage() }.unwrap();
        let store = Store::new(storage).ok().unwrap();
        let upgrade_storage = SyscallUpgradeStorage::new().ok();
        TockEnv {
            rng: TockRng256 {},
            store,
            upgrade_storage,
        }
    }
}

/// Creates a new storage instance.
///
/// # Safety
///
/// It is probably technically memory-safe to have multiple storage instances at the same time, but
/// for extra precaution we mark the function as unsafe. To ensure correct usage, this function
/// should only be called if the previous storage instance was dropped.
// This function is exposed to example binaries testing the hardware. This could probably be cleaned
// up by having the persistent store return its storage.
pub unsafe fn steal_storage() -> StorageResult<SyscallStorage> {
    SyscallStorage::new()
}

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;
    type Storage = SyscallStorage;
    type UpgradeStorage = SyscallUpgradeStorage;

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

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

    fn store(&mut self) -> &mut Store<Self::Storage> {
        &mut self.store
    }

    fn upgrade_storage(&mut self) -> Option<&mut Self::UpgradeStorage> {
        self.upgrade_storage.as_mut()
    }
}

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

google / OpenSK / 1950611153

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