openthread/ot/
ip6.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::*;
6
7/// Functional equivalent of [`otsys::otIcmp6EchoMode`](crate::otsys::otIcmp6EchoMode).
8#[derive(Debug, Copy, Clone, Eq, Ord, PartialOrd, PartialEq, num_derive::FromPrimitive)]
9pub enum Icmp6EchoMode {
10    /// ICMPv6 Echo processing enabled for unicast and multicast requests.
11    HandleAll = OT_ICMP6_ECHO_HANDLER_ALL as isize,
12
13    /// ICMPv6 Echo processing disabled.
14    HandleDisabled = OT_ICMP6_ECHO_HANDLER_DISABLED as isize,
15
16    /// ICMPv6 Echo processing enabled only for multicast requests only.
17    HandleMulticastOnly = OT_ICMP6_ECHO_HANDLER_MULTICAST_ONLY as isize,
18
19    /// ICMPv6 Echo processing enabled only for unicast requests only.
20    HandleUnicastOnly = OT_ICMP6_ECHO_HANDLER_UNICAST_ONLY as isize,
21}
22
23impl From<otIcmp6EchoMode> for Icmp6EchoMode {
24    fn from(x: otIcmp6EchoMode) -> Self {
25        use num::FromPrimitive;
26        Self::from_u32(x).unwrap_or_else(|| panic!("Unknown otIcmp6EchoMode value: {x}"))
27    }
28}
29
30impl From<Icmp6EchoMode> for otIcmp6EchoMode {
31    fn from(x: Icmp6EchoMode) -> Self {
32        x as otIcmp6EchoMode
33    }
34}
35
36/// Iterates over the [`NetifAddress`] structs from [`Ip6::ip6_get_unicast_addresses()`].
37#[derive(Default, Debug, Clone)]
38pub struct NetifAddressIterator<'a>(Option<&'a NetifAddress>);
39
40impl<'a> Iterator for NetifAddressIterator<'a> {
41    type Item = &'a NetifAddress;
42
43    fn next(&mut self) -> Option<Self::Item> {
44        if let Some(addr_ref) = self.0 {
45            // SAFETY: The `otNetifAddress` pointer used here comes
46            //         from `otIp6GetUnicastAddresses`, which is guaranteed
47            //         to have valid values for `mNext`.
48            self.0 = unsafe { NetifAddress::ref_from_ot_ptr(addr_ref.0.mNext) };
49            Some(addr_ref)
50        } else {
51            None
52        }
53    }
54}
55
56/// Methods from the [OpenThread "IPv6" Module](https://openthread.io/reference/group/api-ip6).
57pub trait Ip6 {
58    /// Functional equivalent of [`otsys::otIp6Send`](crate::otsys::otIp6Send).
59    fn ip6_send(&self, message: OtMessageBox<'_>) -> Result;
60
61    /// Similar to [`ip6_send()`], but takes a byte slice instead
62    /// of an [`OtMessageBox`](crate::OtMessageBox).
63    fn ip6_send_data(&self, data: &[u8]) -> Result;
64
65    /// Similar to [`ip6_send_data()`], but sends the packet without layer-2 security.
66    fn ip6_send_data_direct(&self, data: &[u8]) -> Result;
67
68    /// Functional equivalent of [`otsys::otIp6IsEnabled`](crate::otsys::otIp6IsEnabled).
69    fn ip6_is_enabled(&self) -> bool;
70
71    /// Functional equivalent of [`otsys::otIp6SetEnabled`](crate::otsys::otIp6SetEnabled).
72    fn ip6_set_enabled(&self, enabled: bool) -> Result;
73
74    /// Functional equivalent of
75    /// [`otsys::otIp6AddUnicastAddress`](crate::otsys::otIp6AddUnicastAddress).
76    fn ip6_add_unicast_address(&self, addr: &NetifAddress) -> Result;
77
78    /// Functional equivalent of
79    /// [`otsys::otIp6RemoveUnicastAddress`](crate::otsys::otIp6RemoveUnicastAddress).
80    fn ip6_remove_unicast_address(&self, addr: &Ip6Address) -> Result;
81
82    /// Functional equivalent of
83    /// [`otsys::otIp6SubscribeMulticastAddress`](crate::otsys::otIp6SubscribeMulticastAddress).
84    fn ip6_join_multicast_group(&self, addr: &Ip6Address) -> Result;
85
86    /// Functional equivalent of
87    /// [`otsys::otIp6UnsubscribeMulticastAddress`](crate::otsys::otIp6UnsubscribeMulticastAddress).
88    fn ip6_leave_multicast_group(&self, addr: &Ip6Address) -> Result;
89
90    /// Sets the IPv6 receive callback closure. Functional equivalent of
91    /// [`otsys::otIp6SetReceiveCallback`](crate::otsys::otIp6SetReceiveCallback).
92    ///
93    /// The closure will ultimately be executed via
94    /// [`ot::Tasklets::process`](crate::ot::Tasklets::process).
95    fn ip6_set_receive_fn<'a, F>(&'a self, f: Option<F>)
96    where
97        F: FnMut(OtMessageBox<'_>) + 'a;
98
99    /// Sets the IPv6 address callback closure. Functional equivalent of
100    /// [`otsys::otIp6SetAddressCallback`](crate::otsys::otIp6SetAddressCallback).
101    ///
102    /// The closure takes two arguments:
103    ///
104    ///  * An instance of [`ot::Ip6AddressInfo`](crate::ot::Ip6AddressInfo).
105    ///  * A `bool` indicating if the address is being added (`true`) or removed (`false`).
106    ///
107    /// The closure will ultimately be executed via
108    /// [`ot::Tasklets::process`](crate::ot::Tasklets::process).
109    fn ip6_set_address_fn<'a, F>(&'a self, f: Option<F>)
110    where
111        F: for<'r> FnMut(Ip6AddressInfo<'r>, bool) + 'a;
112
113    /// Functional equivalent of [`otsys::otIp6IsSlaacEnabled`](crate::otsys::otIp6IsSlaacEnabled).
114    fn ip6_is_slaac_enabled(&self) -> bool;
115
116    /// Functional equivalent of
117    /// [`otsys::otIp6SetSlaacEnabled`](crate::otsys::otIp6SetSlaacEnabled).
118    fn ip6_set_slaac_enabled(&self, enabled: bool);
119
120    /// Functional equivalent of
121    /// [`otsys::otIcmp6GetEchoMode`](crate::otsys::otIcmp6GetEchoMode).
122    fn icmp6_get_echo_mode(&self) -> Icmp6EchoMode;
123
124    /// Functional equivalent of
125    /// [`otsys::otIcmp6SetEchoMode`](crate::otsys::otIcmp6SetEchoMode).
126    fn icmp6_set_echo_mode(&self, mode: Icmp6EchoMode);
127
128    /// Functional equivalent of
129    /// [`otsys::otIp6SetReceiveFilterEnabled`](crate::otsys::otIp6SetReceiveFilterEnabled).
130    fn ip6_set_receive_filter_enabled(&self, enabled: bool);
131
132    /// Functional equivalent of
133    /// [`otsys::otIp6IsReceiveFilterEnabled`](crate::otsys::otIp6IsReceiveFilterEnabled).
134    fn ip6_is_receive_filter_enabled(&self) -> bool;
135
136    /// Functional equivalent of
137    /// [`otsys::otIp6GetBorderRoutingCounters`](crate::otsys::otIp6GetBorderRoutingCounters).
138    fn ip6_get_border_routing_counters(&self) -> &BorderRoutingCounters;
139
140    /// Functional equivalent of
141    /// [`otsys::otIp6GetUnicastAddresses`](crate::otsys::otIp6GetUnicastAddresses).
142    fn ip6_get_unicast_addresses(&self) -> NetifAddressIterator<'_>;
143}
144
145impl<T: Ip6 + ot::Boxable> Ip6 for ot::Box<T> {
146    fn ip6_send(&self, message: OtMessageBox<'_>) -> Result<()> {
147        self.as_ref().ip6_send(message)
148    }
149
150    fn ip6_send_data(&self, data: &[u8]) -> Result {
151        self.as_ref().ip6_send_data(data)
152    }
153
154    fn ip6_send_data_direct(&self, data: &[u8]) -> Result {
155        self.as_ref().ip6_send_data_direct(data)
156    }
157
158    fn ip6_is_enabled(&self) -> bool {
159        self.as_ref().ip6_is_enabled()
160    }
161
162    fn ip6_set_enabled(&self, enabled: bool) -> Result {
163        self.as_ref().ip6_set_enabled(enabled)
164    }
165
166    fn ip6_add_unicast_address(&self, addr: &NetifAddress) -> Result {
167        self.as_ref().ip6_add_unicast_address(addr)
168    }
169
170    fn ip6_remove_unicast_address(&self, addr: &std::net::Ipv6Addr) -> Result {
171        self.as_ref().ip6_remove_unicast_address(addr)
172    }
173
174    fn ip6_join_multicast_group(&self, addr: &std::net::Ipv6Addr) -> Result {
175        self.as_ref().ip6_join_multicast_group(addr)
176    }
177
178    fn ip6_leave_multicast_group(&self, addr: &std::net::Ipv6Addr) -> Result {
179        self.as_ref().ip6_join_multicast_group(addr)
180    }
181
182    fn ip6_set_receive_fn<'a, F>(&'a self, f: Option<F>)
183    where
184        F: FnMut(OtMessageBox<'_>) + 'a,
185    {
186        self.as_ref().ip6_set_receive_fn(f)
187    }
188
189    fn ip6_set_address_fn<'a, F>(&'a self, f: Option<F>)
190    where
191        F: for<'r> FnMut(Ip6AddressInfo<'r>, bool) + 'a,
192    {
193        self.as_ref().ip6_set_address_fn(f)
194    }
195
196    fn ip6_is_slaac_enabled(&self) -> bool {
197        self.as_ref().ip6_is_slaac_enabled()
198    }
199
200    fn ip6_set_slaac_enabled(&self, enabled: bool) {
201        self.as_ref().ip6_set_slaac_enabled(enabled);
202    }
203
204    fn icmp6_get_echo_mode(&self) -> Icmp6EchoMode {
205        self.as_ref().icmp6_get_echo_mode()
206    }
207
208    fn icmp6_set_echo_mode(&self, mode: Icmp6EchoMode) {
209        self.as_ref().icmp6_set_echo_mode(mode)
210    }
211
212    fn ip6_set_receive_filter_enabled(&self, enabled: bool) {
213        self.as_ref().ip6_set_receive_filter_enabled(enabled);
214    }
215
216    fn ip6_is_receive_filter_enabled(&self) -> bool {
217        self.as_ref().ip6_is_receive_filter_enabled()
218    }
219
220    fn ip6_get_border_routing_counters(&self) -> &BorderRoutingCounters {
221        self.as_ref().ip6_get_border_routing_counters()
222    }
223
224    fn ip6_get_unicast_addresses(&self) -> NetifAddressIterator<'_> {
225        self.as_ref().ip6_get_unicast_addresses()
226    }
227}
228
229impl Ip6 for Instance {
230    fn ip6_send(&self, message: OtMessageBox<'_>) -> Result {
231        Error::from(unsafe { otIp6Send(self.as_ot_ptr(), message.take_ot_ptr()) }).into()
232    }
233
234    fn ip6_send_data(&self, data: &[u8]) -> Result {
235        if let Ok(msg) = Message::ip6_new_from_bytes(self, data, None) {
236            self.ip6_send(msg)
237        } else if self.get_buffer_info().0.mFreeBuffers == 0 {
238            Err(ot::Error::NoBufs)
239        } else {
240            Err(ot::Error::Failed)
241        }
242    }
243
244    fn ip6_send_data_direct(&self, data: &[u8]) -> Result {
245        if let Ok(mut msg) = Message::ip6_new_from_bytes(self, data, None) {
246            msg.set_direct_transmission(true);
247            self.ip6_send(msg)
248        } else if self.get_buffer_info().0.mFreeBuffers == 0 {
249            Err(ot::Error::NoBufs)
250        } else {
251            Err(ot::Error::Failed)
252        }
253    }
254
255    fn ip6_is_enabled(&self) -> bool {
256        unsafe { otIp6IsEnabled(self.as_ot_ptr()) }
257    }
258
259    fn ip6_set_enabled(&self, enabled: bool) -> Result {
260        Error::from(unsafe { otIp6SetEnabled(self.as_ot_ptr(), enabled) }).into()
261    }
262
263    fn ip6_add_unicast_address(&self, addr: &NetifAddress) -> Result {
264        Error::from(unsafe { otIp6AddUnicastAddress(self.as_ot_ptr(), addr.as_ot_ptr()) }).into()
265    }
266
267    fn ip6_remove_unicast_address(&self, addr: &std::net::Ipv6Addr) -> Result {
268        Error::from(unsafe { otIp6RemoveUnicastAddress(self.as_ot_ptr(), addr.as_ot_ptr()) }).into()
269    }
270
271    fn ip6_join_multicast_group(&self, addr: &std::net::Ipv6Addr) -> Result {
272        Error::from(unsafe { otIp6SubscribeMulticastAddress(self.as_ot_ptr(), addr.as_ot_ptr()) })
273            .into()
274    }
275
276    fn ip6_leave_multicast_group(&self, addr: &std::net::Ipv6Addr) -> Result {
277        Error::from(unsafe { otIp6UnsubscribeMulticastAddress(self.as_ot_ptr(), addr.as_ot_ptr()) })
278            .into()
279    }
280
281    fn ip6_set_receive_fn<'a, F>(&'a self, f: Option<F>)
282    where
283        F: FnMut(OtMessageBox<'_>) + 'a,
284    {
285        unsafe extern "C" fn _ot_ip6_receive_callback<'a, F: FnMut(OtMessageBox<'_>) + 'a>(
286            message: *mut otMessage,
287            context: *mut ::std::os::raw::c_void,
288        ) {
289            trace!("_ot_ip6_receive_callback");
290
291            // Convert the `*otMessage` into an `ot::Box<ot::Message>`.
292            let message = OtMessageBox::from_ot_ptr(message)
293                .expect("_ot_ip6_receive_callback: Got NULL otMessage");
294
295            // Reconstitute a reference to our closure.
296            let sender = &mut *(context as *mut F);
297
298            sender(message)
299        }
300
301        let (fn_ptr, fn_box, cb): (_, _, otIp6ReceiveCallback) = if let Some(f) = f {
302            let mut x = Box::new(f);
303
304            (
305                x.as_mut() as *mut F as *mut ::std::os::raw::c_void,
306                Some(x as Box<dyn FnMut(OtMessageBox<'_>) + 'a>),
307                Some(_ot_ip6_receive_callback::<F>),
308            )
309        } else {
310            (std::ptr::null_mut() as *mut ::std::os::raw::c_void, None, None)
311        };
312
313        unsafe {
314            otIp6SetReceiveCallback(self.as_ot_ptr(), cb, fn_ptr);
315
316            // Make sure our object eventually gets cleaned up.
317            // Here we must also transmute our closure to have a 'static lifetime.
318            // We need to do this because the borrow checker cannot infer the
319            // proper lifetime for the singleton instance backing, but
320            // this is guaranteed by the API.
321            self.borrow_backing().ip6_receive_fn.set(std::mem::transmute::<
322                Option<Box<dyn FnMut(OtMessageBox<'_>) + 'a>>,
323                Option<Box<dyn FnMut(OtMessageBox<'_>) + 'static>>,
324            >(fn_box));
325        }
326    }
327
328    fn ip6_set_address_fn<'a, F>(&'a self, f: Option<F>)
329    where
330        F: for<'r> FnMut(Ip6AddressInfo<'r>, bool) + 'a,
331    {
332        unsafe extern "C" fn _ot_ip6_address_callback<
333            'a,
334            F: FnMut(Ip6AddressInfo<'_>, bool) + 'a,
335        >(
336            info: *const otIp6AddressInfo,
337            is_added: bool,
338            context: *mut ::std::os::raw::c_void,
339        ) {
340            trace!("_ot_ip6_address_callback");
341
342            // Convert the `*otIp6AddressInfo` into an `&ot::Ip6AddressInfo`.
343            let info = *Ip6AddressInfo::ref_from_ot_ptr(info).unwrap();
344
345            // Reconstitute a reference to our closure.
346            let sender = &mut *(context as *mut F);
347
348            sender(info, is_added)
349        }
350
351        let (fn_ptr, fn_box, cb): (_, _, otIp6AddressCallback) = if let Some(f) = f {
352            let mut x = Box::new(f);
353
354            (
355                x.as_mut() as *mut F as *mut ::std::os::raw::c_void,
356                Some(x as Box<dyn FnMut(Ip6AddressInfo<'_>, bool) + 'a>),
357                Some(_ot_ip6_address_callback::<F>),
358            )
359        } else {
360            (std::ptr::null_mut() as *mut ::std::os::raw::c_void, None, None)
361        };
362
363        unsafe {
364            otIp6SetAddressCallback(self.as_ot_ptr(), cb, fn_ptr);
365
366            // Make sure our object eventually gets cleaned up.
367            // Here we must also transmute our closure to have a 'static lifetime.
368            // We need to do this because the borrow checker cannot infer the
369            // proper lifetime for the singleton instance backing, but
370            // this is guaranteed by the API.
371            self.borrow_backing().ip6_address_fn.set(std::mem::transmute::<
372                Option<Box<dyn FnMut(Ip6AddressInfo<'_>, bool) + 'a>>,
373                Option<Box<dyn FnMut(Ip6AddressInfo<'_>, bool) + 'static>>,
374            >(fn_box));
375        }
376    }
377
378    fn ip6_is_slaac_enabled(&self) -> bool {
379        unsafe { otIp6IsSlaacEnabled(self.as_ot_ptr()) }
380    }
381
382    fn ip6_set_slaac_enabled(&self, enabled: bool) {
383        unsafe { otIp6SetSlaacEnabled(self.as_ot_ptr(), enabled) }
384    }
385
386    fn icmp6_get_echo_mode(&self) -> Icmp6EchoMode {
387        unsafe { otIcmp6GetEchoMode(self.as_ot_ptr()) }.into()
388    }
389
390    fn icmp6_set_echo_mode(&self, mode: Icmp6EchoMode) {
391        unsafe { otIcmp6SetEchoMode(self.as_ot_ptr(), mode.into()) }
392    }
393
394    fn ip6_set_receive_filter_enabled(&self, enabled: bool) {
395        unsafe { otIp6SetReceiveFilterEnabled(self.as_ot_ptr(), enabled) }
396    }
397
398    fn ip6_is_receive_filter_enabled(&self) -> bool {
399        unsafe { otIp6IsReceiveFilterEnabled(self.as_ot_ptr()) }
400    }
401
402    fn ip6_get_border_routing_counters(&self) -> &BorderRoutingCounters {
403        unsafe {
404            BorderRoutingCounters::ref_from_ot_ptr(otIp6GetBorderRoutingCounters(self.as_ot_ptr()))
405                .unwrap()
406        }
407    }
408
409    fn ip6_get_unicast_addresses(&self) -> NetifAddressIterator<'_> {
410        NetifAddressIterator(unsafe {
411            NetifAddress::ref_from_ot_ptr(otIp6GetUnicastAddresses(self.as_ot_ptr()))
412        })
413    }
414}
openthread/ot/ip6.rs

openthread/ot/
ip6.rs
