1932905277

Build # 1932905277

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/4c7dd9204e84ccdff11468a2178654df5cd8ff8b">4c7dd9204">&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/4c7dd9204e84ccdff11468a2178654df5cd8ff8b">4c7dd9204</a><a href="https://github.com/google/OpenSK/commit/4c7dd9204e84ccdff11468a2178654df5cd8ff8b">&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/4c7dd9204e84ccdff11468a2178654df5cd8ff8b&quot;&gt;4c7dd9204&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/4c7dd9204e84ccdff11468a2178654df5cd8ff8b&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 #431: Add Storage and UpgradeStorage to Env

Run Details

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

12852 of 14651 relevant lines covered (87.72%)

516491.81 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, 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;

mod storage;

pub struct TockEnv {
    rng: TockRng256,
    storage: bool,
    upgrade_storage: bool,
}

impl TockEnv {
    /// Returns the unique instance of the Tock environment.
    ///
    /// This function returns `Some` the first time it is called. Afterwards, it repeatedly returns
    /// `None`.
    pub fn new() -> Option<Self> {
        // Make sure the environment was not already taken.
        static TAKEN: AtomicBool = AtomicBool::new(false);
        if TAKEN.fetch_or(true, Ordering::SeqCst) {
            return None;
        }
        Some(TockEnv {
            rng: TockRng256 {},
            storage: false,
            upgrade_storage: false,
        })
    }
}

/// Creates a new storage instance.
///
/// # Safety
///
/// It is probably technically memory-safe to hame 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 for 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 storage(&mut self) -> StorageResult<Self::Storage> {
        assert!(!self.storage);
        self.storage = true;
        unsafe { steal_storage() }
    }

    fn upgrade_storage(&mut self) -> StorageResult<Self::UpgradeStorage> {
        assert!(!self.upgrade_storage);
        self.upgrade_storage = true;
        SyscallUpgradeStorage::new()
    }
}

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

google / OpenSK / 1932905277

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