openthread/ot/
link.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::prelude_internal::*;
6use std::time::Duration;
7
8/// Methods from the [OpenThread "Link" Module][1].
9///
10/// [1]: https://openthread.io/reference/group/api-link-link
11pub trait Link {
12    /// Functional equivalent of [`otsys::otLinkGetChannel`](crate::otsys::otLinkGetChannel).
13    fn get_channel(&self) -> ChannelIndex;
14
15    /// Functional equivalent of [`otsys::otLinkSetChannel`](crate::otsys::otLinkSetChannel).
16    fn set_channel(&self, index: ChannelIndex) -> Result;
17
18    /// Functional equivalent of [`otsys::otLinkGetCounters`](crate::otsys::otLinkGetCounters).
19    fn link_get_counters(&self) -> &MacCounters;
20
21    /// Functional equivalent of
22    /// [`otsys::otLinkGetExtendedAddress`](crate::otsys::otLinkGetExtendedAddress).
23    fn get_extended_address(&self) -> &ExtAddress;
24
25    /// Functional equivalent of
26    /// [`otsys::otLinkGetFactoryAssignedIeeeEui64`](crate::otsys::otLinkGetFactoryAssignedIeeeEui64).
27    fn get_factory_assigned_ieee_eui_64(&self) -> ExtAddress;
28
29    /// Functional equivalent of [`otsys::otLinkGetPanId`](crate::otsys::otLinkGetPanId).
30    fn get_pan_id(&self) -> PanId;
31
32    /// Functional equivalent of [`otsys::otLinkSetPanId`](crate::otsys::otLinkSetPanId).
33    fn set_pan_id(&self, pan_id: PanId) -> Result;
34
35    /// Functional equivalent of [`otsys::otLinkGetShortAddress`](crate::otsys::otLinkGetShortAddress).
36    fn get_short_address(&self) -> ShortAddress;
37
38    /// Functional equivalent of [`otsys::otLinkIsEnabled`](crate::otsys::otLinkIsEnabled).
39    fn link_is_enabled(&self) -> bool;
40
41    /// Functional equivalent of [`otsys::otLinkSetEnabled`](crate::otsys::otLinkSetEnabled).
42    fn link_set_enabled(&self, enabled: bool) -> Result;
43
44    /// Functional equivalent of [`otsys::otLinkIsPromiscuous`](crate::otsys::otLinkIsPromiscuous).
45    fn link_is_promiscuous(&self) -> bool;
46
47    /// Functional equivalent of
48    /// [`otsys::otLinkSetPromiscuous`](crate::otsys::otLinkSetPromiscuous).
49    fn link_set_promiscuous(&self, promiscuous: bool) -> Result;
50
51    /// Functional equivalent of
52    /// [`otsys::otLinkIsEnergyScanInProgress`](crate::otsys::otLinkIsEnergyScanInProgress).
53    fn is_energy_scan_in_progress(&self) -> bool;
54
55    /// Functional equivalent of
56    /// [`otsys::otLinkIsActiveScanInProgress`](crate::otsys::otLinkIsActiveScanInProgress).
57    fn is_active_scan_in_progress(&self) -> bool;
58
59    /// Functional equivalent of
60    /// [`otsys::otLinkGetSupportedChannelMask`](crate::otsys::otLinkGetSupportedChannelMask).
61    fn get_supported_channel_mask(&self) -> ot::ChannelMask;
62
63    /// Starts an active scan. Functional equivalent of
64    /// [`otsys::otLinkActiveScan`](crate::otsys::otLinkActiveScan).
65    ///
66    /// The closure will ultimately be executed via
67    /// [`ot::Tasklets::process`](crate::ot::Tasklets::process).
68    fn start_active_scan<'a, F>(&self, channels: ChannelMask, dwell: Duration, f: F) -> Result
69    where
70        F: FnMut(Option<&ActiveScanResult>) + 'a;
71
72    /// Starts an energy scan. Functional equivalent of
73    /// [`otsys::otLinkEnergyScan`](crate::otsys::otLinkEnergyScan).
74    ///
75    /// The closure will ultimately be executed via
76    /// [`ot::Tasklets::process`](crate::ot::Tasklets::process).
77    fn start_energy_scan<'a, F>(&self, channels: ChannelMask, dwell: Duration, f: F) -> Result
78    where
79        F: FnMut(Option<&EnergyScanResult>) + 'a;
80}
81
82impl<T: Link + Boxable> Link for ot::Box<T> {
83    fn get_channel(&self) -> ChannelIndex {
84        self.as_ref().get_channel()
85    }
86
87    fn set_channel(&self, index: ChannelIndex) -> Result {
88        self.as_ref().set_channel(index)
89    }
90
91    fn link_get_counters(&self) -> &MacCounters {
92        self.as_ref().link_get_counters()
93    }
94
95    fn get_extended_address(&self) -> &ExtAddress {
96        self.as_ref().get_extended_address()
97    }
98    fn get_factory_assigned_ieee_eui_64(&self) -> ExtAddress {
99        self.as_ref().get_factory_assigned_ieee_eui_64()
100    }
101
102    fn get_pan_id(&self) -> PanId {
103        self.as_ref().get_pan_id()
104    }
105    fn set_pan_id(&self, pan_id: PanId) -> Result<()> {
106        self.as_ref().set_pan_id(pan_id)
107    }
108
109    fn get_short_address(&self) -> ShortAddress {
110        self.as_ref().get_short_address()
111    }
112
113    fn link_is_enabled(&self) -> bool {
114        self.as_ref().link_is_enabled()
115    }
116    fn link_set_enabled(&self, enabled: bool) -> Result {
117        self.as_ref().link_set_enabled(enabled)
118    }
119
120    fn link_is_promiscuous(&self) -> bool {
121        self.as_ref().link_is_promiscuous()
122    }
123    fn link_set_promiscuous(&self, promiscuous: bool) -> Result {
124        self.as_ref().link_set_promiscuous(promiscuous)
125    }
126
127    fn is_energy_scan_in_progress(&self) -> bool {
128        self.as_ref().is_energy_scan_in_progress()
129    }
130    fn is_active_scan_in_progress(&self) -> bool {
131        self.as_ref().is_active_scan_in_progress()
132    }
133
134    fn get_supported_channel_mask(&self) -> ChannelMask {
135        self.as_ref().get_supported_channel_mask()
136    }
137
138    fn start_active_scan<'a, F>(&self, channels: ChannelMask, dwell: Duration, f: F) -> Result
139    where
140        F: FnMut(Option<&ActiveScanResult>) + 'a,
141    {
142        self.as_ref().start_active_scan(channels, dwell, f)
143    }
144
145    fn start_energy_scan<'a, F>(&self, channels: ChannelMask, dwell: Duration, f: F) -> Result
146    where
147        F: FnMut(Option<&EnergyScanResult>) + 'a,
148    {
149        self.as_ref().start_energy_scan(channels, dwell, f)
150    }
151}
152
153impl Link for Instance {
154    fn get_channel(&self) -> ChannelIndex {
155        unsafe { otLinkGetChannel(self.as_ot_ptr()) }
156    }
157
158    fn set_channel(&self, index: ChannelIndex) -> Result {
159        Error::from(unsafe { otLinkSetChannel(self.as_ot_ptr(), index) }).into()
160    }
161
162    fn link_get_counters(&self) -> &MacCounters {
163        unsafe {
164            let mac_counters = otLinkGetCounters(self.as_ot_ptr());
165            MacCounters::ref_from_ot_ptr(mac_counters).unwrap()
166        }
167    }
168
169    fn get_extended_address(&self) -> &ExtAddress {
170        unsafe {
171            let ext_addr = otLinkGetExtendedAddress(self.as_ot_ptr());
172            ExtAddress::ref_from_ot_ptr(ext_addr).unwrap()
173        }
174    }
175
176    fn get_factory_assigned_ieee_eui_64(&self) -> ExtAddress {
177        unsafe {
178            let mut ext_addr = ExtAddress::default();
179            otLinkGetFactoryAssignedIeeeEui64(self.as_ot_ptr(), ext_addr.as_ot_mut_ptr());
180            ext_addr
181        }
182    }
183
184    fn get_pan_id(&self) -> PanId {
185        unsafe { otLinkGetPanId(self.as_ot_ptr()) }
186    }
187
188    fn set_pan_id(&self, pan_id: PanId) -> Result {
189        Error::from(unsafe { otLinkSetPanId(self.as_ot_ptr(), pan_id) }).into()
190    }
191
192    fn get_short_address(&self) -> ShortAddress {
193        unsafe { otLinkGetShortAddress(self.as_ot_ptr()) }
194    }
195
196    fn link_is_enabled(&self) -> bool {
197        unsafe { otLinkIsEnabled(self.as_ot_ptr()) }
198    }
199
200    fn link_set_enabled(&self, enabled: bool) -> Result {
201        Error::from(unsafe { otLinkSetEnabled(self.as_ot_ptr(), enabled) }).into()
202    }
203
204    fn link_is_promiscuous(&self) -> bool {
205        unsafe { otLinkIsPromiscuous(self.as_ot_ptr()) }
206    }
207
208    fn link_set_promiscuous(&self, promiscuous: bool) -> Result {
209        Error::from(unsafe { otLinkSetPromiscuous(self.as_ot_ptr(), promiscuous) }).into()
210    }
211
212    fn is_energy_scan_in_progress(&self) -> bool {
213        unsafe { otLinkIsEnergyScanInProgress(self.as_ot_ptr()) }
214    }
215
216    fn is_active_scan_in_progress(&self) -> bool {
217        unsafe { otLinkIsActiveScanInProgress(self.as_ot_ptr()) }
218    }
219
220    fn get_supported_channel_mask(&self) -> ChannelMask {
221        let mask_u32 = unsafe { otLinkGetSupportedChannelMask(self.as_ot_ptr()) };
222        mask_u32.into()
223    }
224
225    fn start_active_scan<'a, F>(&self, channels: ChannelMask, dwell: Duration, f: F) -> Result
226    where
227        F: FnMut(Option<&ActiveScanResult>) + 'a,
228    {
229        unsafe extern "C" fn _ot_handle_active_scan_result<
230            'a,
231            F: FnMut(Option<&ActiveScanResult>) + 'a,
232        >(
233            result: *mut otActiveScanResult,
234            context: *mut ::std::os::raw::c_void,
235        ) {
236            trace!("_ot_handle_active_scan_result: {:?}", result);
237
238            // Convert the `*otActiveScanResult` into an `Option<&ot::ActiveScanResult>`.
239            let result = ActiveScanResult::ref_from_ot_ptr(result);
240
241            // Reconstitute a reference to our closure.
242            let sender = &mut *(context as *mut F);
243
244            sender(result);
245        }
246
247        let (fn_ptr, fn_box, cb): (_, _, otHandleActiveScanResult) = {
248            let mut x = Box::new(f);
249
250            (
251                x.as_mut() as *mut F as *mut ::std::os::raw::c_void,
252                Some(x as Box<dyn FnMut(Option<&ActiveScanResult>) + 'a>),
253                Some(_ot_handle_active_scan_result::<F>),
254            )
255        };
256
257        unsafe {
258            Error::from(otLinkActiveScan(
259                self.as_ot_ptr(),
260                channels.into(),
261                dwell.as_millis().try_into().unwrap(),
262                cb,
263                fn_ptr,
264            ))
265            .into_result()?;
266
267            // Make sure our object eventually gets cleaned up.
268            // Here we must also transmute our closure to have a 'static lifetime.
269            // We need to do this because the borrow checker cannot infer the
270            // proper lifetime for the singleton instance backing, but
271            // this is guaranteed by the API.
272            self.borrow_backing().active_scan_fn.set(std::mem::transmute::<
273                Option<Box<dyn FnMut(Option<&ActiveScanResult>) + 'a>>,
274                Option<Box<dyn FnMut(Option<&ActiveScanResult>) + 'static>>,
275            >(fn_box));
276        }
277
278        Ok(())
279    }
280
281    fn start_energy_scan<'a, F>(&self, channels: ChannelMask, dwell: Duration, f: F) -> Result
282    where
283        F: FnMut(Option<&EnergyScanResult>) + 'a,
284    {
285        unsafe extern "C" fn _ot_handle_energy_scan_result<
286            'a,
287            F: FnMut(Option<&EnergyScanResult>) + 'a,
288        >(
289            result: *mut otEnergyScanResult,
290            context: *mut ::std::os::raw::c_void,
291        ) {
292            trace!("_ot_handle_energy_scan_result: {:?}", result);
293
294            // Convert the `*otEnergyScanResult` into an `Option<&ot::EnergyScanResult>`.
295            let result = EnergyScanResult::ref_from_ot_ptr(result);
296
297            // Reconstitute a reference to our closure.
298            let sender = &mut *(context as *mut F);
299
300            sender(result);
301        }
302
303        let (fn_ptr, fn_box, cb): (_, _, otHandleEnergyScanResult) = {
304            let mut x = Box::new(f);
305
306            (
307                x.as_mut() as *mut F as *mut ::std::os::raw::c_void,
308                Some(x as Box<dyn FnMut(Option<&EnergyScanResult>) + 'a>),
309                Some(_ot_handle_energy_scan_result::<F>),
310            )
311        };
312
313        unsafe {
314            Error::from(otLinkEnergyScan(
315                self.as_ot_ptr(),
316                channels.into(),
317                dwell.as_millis().try_into().unwrap(),
318                cb,
319                fn_ptr,
320            ))
321            .into_result()?;
322
323            // Make sure our object eventually gets cleaned up.
324            // Here we must also transmute our closure to have a 'static lifetime.
325            // We need to do this because the borrow checker cannot infer the
326            // proper lifetime for the singleton instance backing, but
327            // this is guaranteed by the API.
328            self.borrow_backing().energy_scan_fn.set(std::mem::transmute::<
329                Option<Box<dyn FnMut(Option<&EnergyScanResult>) + 'a>>,
330                Option<Box<dyn FnMut(Option<&EnergyScanResult>) + 'static>>,
331            >(fn_box));
332        }
333
334        Ok(())
335    }
336}
openthread/ot/link.rs

openthread/ot/
link.rs
