openthread/ot/
nat64.rs

1// Copyright 2023 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#[allow(missing_debug_implementations)]
8/// NAT64 Address Mapping iterator
9pub struct Nat64AddressMappingIterator<'a, T: ?Sized> {
10    /// NAT64 mapping iter
11    pub ot_nat64_address_mapping_iter: otNat64AddressMappingIterator,
12
13    /// OpenThread instance
14    pub ot_instance: &'a T,
15}
16
17impl<T: ?Sized + Nat64> Iterator for Nat64AddressMappingIterator<'_, T> {
18    type Item = Nat64AddressMapping;
19    fn next(&mut self) -> Option<Self::Item> {
20        let mut mapping = Nat64AddressMapping::default();
21        self.ot_instance
22            .nat64_get_next_address_mapping(&mut self.ot_nat64_address_mapping_iter, &mut mapping)
23            .ok()
24            .map(|()| mapping)
25    }
26}
27
28/// Methods from the [OpenThread "NAT64" Module](https://openthread.io/reference/group/api-nat64).
29pub trait Nat64 {
30    /// Enable or disable NAT64 functions.
31    fn nat64_set_enabled(&self, enabled: bool);
32
33    /// Sets the CIDR used when setting the source address of the outgoing translated IPv4 packets.
34    fn nat64_set_ip4_cidr(&self, ip4_cidr: Ip4Cidr) -> Result;
35
36    /// Get CIDR from OpenThread
37    fn nat64_get_cidr(&self) -> Result<Ip4Cidr>;
38
39    /// Registers a callback to provide received IPv4 datagrams.
40    fn nat64_set_receive_fn<'a, F>(&'a self, f: Option<F>)
41    where
42        F: FnMut(OtMessageBox<'_>) + 'a;
43
44    /// Send a message to NAT64 handler in OpenThread
45    fn nat64_send(&self, message: OtMessageBox<'_>) -> Result;
46
47    /// Send data to NAT64 handler in OpenThread
48    fn nat64_send_data_slice(&self, data_slice: &[u8]) -> Result;
49
50    /// Return AIL prefix to OpenThread
51    fn nat64_infra_if_prefix_discover_done(
52        &self,
53        infra_if_idx: ot::NetifIndex,
54        ip6_prefix: openthread_sys::otIp6Prefix,
55    );
56
57    /// Get the NAT64 address mapping iterator instance
58    fn nat64_get_address_mapping_iterator(&self) -> Nat64AddressMappingIterator<'_, Self> {
59        let mut iter = otNat64AddressMappingIterator::default();
60        self.nat64_init_address_mapping_iterator(&mut iter);
61        Nat64AddressMappingIterator { ot_nat64_address_mapping_iter: iter, ot_instance: self }
62    }
63
64    ///  Init the NAT64 address mapping iterator
65    fn nat64_init_address_mapping_iterator(&self, iter: &mut otNat64AddressMappingIterator);
66
67    /// Get next NAT64 address mapping
68    fn nat64_get_next_address_mapping(
69        &self,
70        iter: &mut otNat64AddressMappingIterator,
71        mapping: &mut Nat64AddressMapping,
72    ) -> Result;
73
74    /// Get NAT64 translator state
75    fn nat64_get_translator_state(&self) -> Nat64State;
76
77    /// Get NAT64 prefix manager state
78    fn nat64_get_prefix_manager_state(&self) -> Nat64State;
79
80    /// Get NAT64 error counters
81    fn nat64_get_error_counters(&self) -> Nat64ErrorCounters;
82
83    /// Get NAT64 protocol counters
84    fn nat64_get_counters(&self) -> Nat64ProtocolCounters;
85}
86
87impl<T: Nat64 + ot::Boxable> Nat64 for ot::Box<T> {
88    fn nat64_set_enabled(&self, enabled: bool) {
89        self.as_ref().nat64_set_enabled(enabled)
90    }
91    fn nat64_set_ip4_cidr(&self, ip4_cidr: Ip4Cidr) -> Result {
92        self.as_ref().nat64_set_ip4_cidr(ip4_cidr)
93    }
94    fn nat64_get_cidr(&self) -> Result<Ip4Cidr> {
95        self.as_ref().nat64_get_cidr()
96    }
97    fn nat64_set_receive_fn<'a, F>(&'a self, f: Option<F>)
98    where
99        F: FnMut(OtMessageBox<'_>) + 'a,
100    {
101        self.as_ref().nat64_set_receive_fn(f)
102    }
103    fn nat64_send(&self, message: OtMessageBox<'_>) -> Result {
104        self.as_ref().nat64_send(message)
105    }
106    fn nat64_send_data_slice(&self, data_slice: &[u8]) -> Result {
107        self.as_ref().nat64_send_data_slice(data_slice)
108    }
109    fn nat64_infra_if_prefix_discover_done(
110        &self,
111        infra_if_idx: ot::NetifIndex,
112        ip6_prefix: openthread_sys::otIp6Prefix,
113    ) {
114        self.as_ref().nat64_infra_if_prefix_discover_done(infra_if_idx, ip6_prefix);
115    }
116    fn nat64_init_address_mapping_iterator(&self, iter: &mut otNat64AddressMappingIterator) {
117        self.as_ref().nat64_init_address_mapping_iterator(iter)
118    }
119    fn nat64_get_next_address_mapping(
120        &self,
121        iter: &mut otNat64AddressMappingIterator,
122        mapping: &mut Nat64AddressMapping,
123    ) -> Result {
124        self.as_ref().nat64_get_next_address_mapping(iter, mapping)
125    }
126    fn nat64_get_translator_state(&self) -> Nat64State {
127        self.as_ref().nat64_get_translator_state()
128    }
129    fn nat64_get_prefix_manager_state(&self) -> Nat64State {
130        self.as_ref().nat64_get_prefix_manager_state()
131    }
132    fn nat64_get_error_counters(&self) -> Nat64ErrorCounters {
133        self.as_ref().nat64_get_error_counters()
134    }
135    fn nat64_get_counters(&self) -> Nat64ProtocolCounters {
136        self.as_ref().nat64_get_counters()
137    }
138}
139
140impl Nat64 for Instance {
141    fn nat64_set_enabled(&self, enabled: bool) {
142        unsafe { otNat64SetEnabled(self.as_ot_ptr(), enabled) }
143    }
144    fn nat64_set_ip4_cidr(&self, ip4_cidr: Ip4Cidr) -> Result {
145        Error::from(unsafe { otNat64SetIp4Cidr(self.as_ot_ptr(), ip4_cidr.as_ot_ptr()) }).into()
146    }
147    fn nat64_get_cidr(&self) -> Result<Ip4Cidr> {
148        let mut ip4_cidr: Ip4Cidr = Default::default();
149
150        let res: Result<(), Error> =
151            Error::from(unsafe { otNat64GetCidr(self.as_ot_ptr(), ip4_cidr.as_ot_mut_ptr()) })
152                .into();
153
154        res.map(|_: ()| ip4_cidr)
155    }
156    fn nat64_set_receive_fn<'a, F>(&'a self, f: Option<F>)
157    where
158        F: FnMut(OtMessageBox<'_>) + 'a,
159    {
160        unsafe extern "C" fn _ot_nat64_receive_callback<'a, F: FnMut(OtMessageBox<'_>) + 'a>(
161            message: *mut otMessage,
162            context: *mut ::std::os::raw::c_void,
163        ) {
164            trace!("_ot_nat64_receive_callback");
165
166            // Convert the `*otMessage` into an `ot::Box<ot::Message>`.
167            let message = OtMessageBox::from_ot_ptr(message)
168                .expect("_ot_nat64_receive_callback: Got NULL otMessage");
169
170            // Reconstitute a reference to our closure.
171            let sender = &mut *(context as *mut F);
172
173            sender(message)
174        }
175
176        let (fn_ptr, fn_box, cb): (_, _, otNat64ReceiveIp4Callback) = if let Some(f) = f {
177            let mut x = Box::new(f);
178
179            (
180                x.as_mut() as *mut F as *mut ::std::os::raw::c_void,
181                Some(x as Box<dyn FnMut(OtMessageBox<'_>) + 'a>),
182                Some(_ot_nat64_receive_callback::<F>),
183            )
184        } else {
185            (std::ptr::null_mut() as *mut ::std::os::raw::c_void, None, None)
186        };
187
188        unsafe {
189            otNat64SetReceiveIp4Callback(self.as_ot_ptr(), cb, fn_ptr);
190
191            // Make sure our object eventually gets cleaned up.
192            // Here we must also transmute our closure to have a 'static lifetime.
193            // We need to do this because the borrow checker cannot infer the
194            // proper lifetime for the singleton instance backing, but
195            // this is guaranteed by the API.
196            self.borrow_backing().nat64_receive_fn.set(std::mem::transmute::<
197                Option<Box<dyn FnMut(OtMessageBox<'_>) + 'a>>,
198                Option<Box<dyn FnMut(OtMessageBox<'_>) + 'static>>,
199            >(fn_box));
200        }
201    }
202
203    fn nat64_send(&self, message: OtMessageBox<'_>) -> Result {
204        Error::from(unsafe { otNat64Send(self.as_ot_ptr(), message.take_ot_ptr()) }).into()
205    }
206
207    fn nat64_send_data_slice(&self, data_slice: &[u8]) -> Result {
208        if let Ok(mut msg) = Message::ip4_new(self, None) {
209            msg.append(data_slice)?;
210            self.nat64_send(msg)?;
211            Ok(())
212        } else if self.get_buffer_info().0.mFreeBuffers == 0 {
213            Err(ot::Error::NoBufs)
214        } else {
215            Err(ot::Error::Failed)
216        }
217    }
218
219    fn nat64_infra_if_prefix_discover_done(
220        &self,
221        infra_if_idx: ot::NetifIndex,
222        ip6_prefix: openthread_sys::otIp6Prefix,
223    ) {
224        unsafe {
225            openthread_sys::otPlatInfraIfDiscoverNat64PrefixDone(
226                self.as_ot_ptr(),
227                infra_if_idx,
228                &ip6_prefix,
229            )
230        }
231    }
232
233    fn nat64_init_address_mapping_iterator(&self, iter: &mut otNat64AddressMappingIterator) {
234        unsafe {
235            otNat64InitAddressMappingIterator(self.as_ot_ptr(), iter);
236        }
237    }
238
239    fn nat64_get_next_address_mapping(
240        &self,
241        iter: &mut otNat64AddressMappingIterator,
242        mapping: &mut Nat64AddressMapping,
243    ) -> Result {
244        Error::from(unsafe {
245            otNat64GetNextAddressMapping(self.as_ot_ptr(), iter, mapping.as_ot_mut_ptr())
246        })
247        .into()
248    }
249
250    fn nat64_get_translator_state(&self) -> Nat64State {
251        unsafe { otNat64GetTranslatorState(self.as_ot_ptr()).into() }
252    }
253
254    fn nat64_get_prefix_manager_state(&self) -> Nat64State {
255        unsafe { otNat64GetPrefixManagerState(self.as_ot_ptr()).into() }
256    }
257
258    fn nat64_get_error_counters(&self) -> Nat64ErrorCounters {
259        unsafe {
260            let mut error_counters: otNat64ErrorCounters = Default::default();
261            otNat64GetErrorCounters(
262                self.as_ot_ptr(),
263                (&mut error_counters) as *mut otNat64ErrorCounters,
264            );
265            error_counters.into()
266        }
267    }
268
269    fn nat64_get_counters(&self) -> Nat64ProtocolCounters {
270        unsafe {
271            let mut protocol_counters: otNat64ProtocolCounters = Default::default();
272            otNat64GetCounters(
273                self.as_ot_ptr(),
274                (&mut protocol_counters) as *mut otNat64ProtocolCounters,
275            );
276            protocol_counters.into()
277        }
278    }
279}
openthread/ot/nat64.rs

openthread/ot/
nat64.rs
