openthread/ot/types/
ipv6.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
7use core::fmt::{Debug, Formatter};
8use num_derive::FromPrimitive;
9use std::net::SocketAddrV6;
10
11/// IPv6 Address Type. Functional equivalent of [`otsys::otIp6Address`](crate::otsys::otIp6Address).
12///
13/// ## NOTES ON SAFETY ##
14///
15/// Here we are making the assumption that a [`std::net::Ipv6Addr`] can
16/// be freely and safely transmuted to and from an [`otIp6Address`](crate::otsys::otIp6Address).
17/// Doing this is very convenient. On the face of it, this might seem like a safe assumption:
18/// IPv6 addresses are always 16 bytes long, that ought to be fine, right? And, in my testing,
19/// it does seem to work.
20///
21/// But thinking more carefully about it it seems that this is not *guaranteed* to
22/// be the case. This is supported by the fact that the rust API appears to avoid what
23/// would otherwise be obvious additions, such as a method to return the IPv6 address as
24/// a slice (`octets()` returns a fixed-size array).
25///
26/// As a crutch, I've added static assertions in various places to verify my assumptions.
27/// This effectively eliminates chances of undefined behavior causing problems, but does so
28/// at the expense of failing to compile when those assumptions are not met... So we may
29/// want to revisit this approach in the future if this is a big concern.
30pub type Ip6Address = std::net::Ipv6Addr;
31
32/// Functional equivalent of [`otsys::OT_IP6_PREFIX_BITSIZE`](crate::otsys::OT_IP6_PREFIX_BITSIZE).
33pub const IP6_PREFIX_BITSIZE: u8 = otsys::OT_IP6_PREFIX_BITSIZE as u8;
34
35impl Transparent for std::net::Ipv6Addr {
36    fn from_ot(x: otIp6Address) -> std::net::Ipv6Addr {
37        unsafe { x.mFields.m8.into() }
38    }
39
40    fn into_ot(self) -> otIp6Address {
41        otIp6Address { mFields: otIp6Address__bindgen_ty_1 { m8: self.octets() } }
42    }
43}
44
45unsafe impl OtCastable for std::net::Ipv6Addr {
46    type OtType = otIp6Address;
47
48    fn as_ot_ptr(&self) -> *const otIp6Address {
49        sa::assert_eq_size!(Ip6Address, otIp6Address);
50        sa::assert_eq_align!(Ip6Address, otIp6Address);
51        self as *const Self as *const otIp6Address
52    }
53
54    fn as_ot_mut_ptr(&mut self) -> *mut Self::OtType {
55        self as *mut Self as *mut Self::OtType
56    }
57
58    unsafe fn ref_from_ot_ptr<'a>(ptr: *const otIp6Address) -> Option<&'a Self> {
59        if ptr.is_null() {
60            None
61        } else {
62            sa::assert_eq_size!(Ip6Address, otIp6Address);
63            sa::assert_eq_align!(Ip6Address, otIp6Address);
64
65            // SAFETY: The safety of this dereference is ensured by the above two static assertions.
66            Some(&*(ptr as *const Self))
67        }
68    }
69
70    unsafe fn mut_from_ot_mut_ptr<'a>(ptr: *mut otIp6Address) -> Option<&'a mut Self> {
71        if ptr.is_null() {
72            None
73        } else {
74            sa::assert_eq_size!(Ip6Address, otIp6Address);
75            sa::assert_eq_align!(Ip6Address, otIp6Address);
76
77            // SAFETY: The safety of this dereference is ensured by the above two static assertions.
78            Some(&mut *(ptr as *mut Self))
79        }
80    }
81}
82
83/// Data type representing a 64-bit IPv6 network prefix.
84///
85/// Functional equivalent of [`otsys::otIp6NetworkPrefix`](crate::otsys::otIp6NetworkPrefix).
86#[derive(Default, Clone, Copy)]
87#[repr(transparent)]
88pub struct Ip6NetworkPrefix(pub otIp6NetworkPrefix);
89
90impl_ot_castable!(Ip6NetworkPrefix, otIp6NetworkPrefix);
91
92impl PartialEq for Ip6NetworkPrefix {
93    fn eq(&self, other: &Self) -> bool {
94        self.0.m8 == other.0.m8
95    }
96}
97
98impl Eq for Ip6NetworkPrefix {}
99
100impl Debug for Ip6NetworkPrefix {
101    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
102        std::net::Ipv6Addr::from(*self).fmt(f)?;
103        write!(f, "/64")
104    }
105}
106
107impl std::fmt::Display for Ip6NetworkPrefix {
108    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
109        std::fmt::Debug::fmt(self, f)
110    }
111}
112
113impl Ip6NetworkPrefix {
114    /// Returns this network prefix as a byte slice.
115    pub fn as_slice(&self) -> &[u8] {
116        &self.0.m8
117    }
118
119    /// Returns this network prefix as an 8-byte array by value.
120    pub fn octets(&self) -> [u8; 8] {
121        let mut octets = [0u8; 8];
122        octets.clone_from_slice(self.as_slice());
123        octets
124    }
125
126    /// Returns true is the given address is in this network prefix.
127    pub fn contains(&self, addr: &std::net::Ipv6Addr) -> bool {
128        self.0.m8 == addr.octets()[0..8]
129    }
130}
131
132impl From<[u8; 8]> for Ip6NetworkPrefix {
133    fn from(m8: [u8; 8]) -> Self {
134        Self(otIp6NetworkPrefix { m8 })
135    }
136}
137
138impl From<Ip6NetworkPrefix> for std::net::Ipv6Addr {
139    fn from(prefix: Ip6NetworkPrefix) -> Self {
140        let mut octets = [0u8; 16];
141        octets[0..8].clone_from_slice(prefix.as_slice());
142        octets.into()
143    }
144}
145
146impl From<std::net::Ipv6Addr> for Ip6NetworkPrefix {
147    fn from(x: std::net::Ipv6Addr) -> Self {
148        let mut ret = Ip6NetworkPrefix::default();
149        ret.0.m8.clone_from_slice(&x.octets()[0..8]);
150        ret
151    }
152}
153
154/// Data type representing IPv6 address information.
155///
156/// Functional equivalent of [`otsys::otIp6AddressInfo`](crate::otsys::otIp6AddressInfo).
157/// Note that this type has a lifetime because the original OpenThread
158/// type includes a pointer to the IPv6 address.
159#[derive(Default, Clone, Copy)]
160#[repr(transparent)]
161pub struct Ip6AddressInfo<'a>(otIp6AddressInfo, PhantomData<*mut &'a ()>);
162
163impl_ot_castable!(lifetime Ip6AddressInfo<'_>, otIp6AddressInfo, Default::default());
164
165impl Debug for Ip6AddressInfo<'_> {
166    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
167        self.addr().fmt(f)?;
168        write!(f, "/{} {:?}", self.prefix_len(), self.scope())?;
169        if self.is_preferred() {
170            write!(f, " PREFERRED")?;
171        }
172
173        Ok(())
174    }
175}
176
177impl<'a> Ip6AddressInfo<'a> {
178    /// Returns a reference to the `Ip6Address`.
179    pub fn addr(&self) -> &'a Ip6Address {
180        unsafe { Ip6Address::ref_from_ot_ptr(self.0.mAddress).unwrap() }
181    }
182
183    /// Returns true if this address is preferred.
184    pub fn is_preferred(&self) -> bool {
185        self.0.mPreferred()
186    }
187
188    /// Returns the prefix length of this address.
189    pub fn prefix_len(&self) -> u8 {
190        self.0.mPrefixLength
191    }
192
193    /// Returns the scope of this address
194    pub fn scope(&self) -> Scope {
195        Scope(self.0.mScope())
196    }
197
198    /// Returns true if this address is a multicast address.
199    pub fn is_multicast(&self) -> bool {
200        self.addr().is_multicast()
201    }
202}
203
204/// Type representing an IPv6 scope, as represented on IPv6 multicast addresses.
205#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
206#[repr(transparent)]
207pub struct Scope(pub u8);
208
209#[allow(missing_docs)]
210impl Scope {
211    pub const INTERFACE_LOCAL: Scope = Scope(0x1);
212    pub const LINK_LOCAL: Scope = Scope(0x2);
213    pub const REALM_LOCAL: Scope = Scope(0x3);
214    pub const ADMIN_LOCAL: Scope = Scope(0x4);
215    pub const SITE_LOCAL: Scope = Scope(0x5);
216    pub const ORGANIZATION_LOCAL: Scope = Scope(0x8);
217    pub const GLOBAL: Scope = Scope(0xe);
218}
219
220impl Debug for Scope {
221    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
222        match *self {
223            Self::INTERFACE_LOCAL => write!(f, "Scope::INTERFACE_LOCAL"),
224            Self::LINK_LOCAL => write!(f, "Scope::LINK_LOCAL"),
225            Self::REALM_LOCAL => write!(f, "Scope::REALM_LOCAL"),
226            Self::ADMIN_LOCAL => write!(f, "Scope::ADMIN_LOCAL"),
227            Self::SITE_LOCAL => write!(f, "Scope::SITE_LOCAL"),
228            Self::ORGANIZATION_LOCAL => write!(f, "Scope::ORGANIZATION_LOCAL"),
229            Self::GLOBAL => write!(f, "Scope::GLOBAL"),
230            Scope(x) => write!(f, "Scope({x})"),
231        }
232    }
233}
234
235impl From<Scope> for u8 {
236    fn from(x: Scope) -> Self {
237        x.0
238    }
239}
240
241impl From<Scope> for u32 {
242    fn from(x: Scope) -> Self {
243        x.0 as u32
244    }
245}
246
247/// Type representing the origin of an address
248#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
249pub struct AddressOrigin(pub u8);
250
251impl AddressOrigin {
252    /// Functional equivalent of
253    /// [`otsys::OT_ADDRESS_ORIGIN_DHCPV6`](crate::otsys::OT_ADDRESS_ORIGIN_DHCPV6).
254    pub const DHCPV6: AddressOrigin = AddressOrigin(OT_ADDRESS_ORIGIN_DHCPV6 as u8);
255
256    /// Functional equivalent of
257    /// [`otsys::OT_ADDRESS_ORIGIN_MANUAL`](crate::otsys::OT_ADDRESS_ORIGIN_MANUAL).
258    pub const MANUAL: AddressOrigin = AddressOrigin(OT_ADDRESS_ORIGIN_MANUAL as u8);
259
260    /// Functional equivalent of
261    /// [`otsys::OT_ADDRESS_ORIGIN_SLAAC`](crate::otsys::OT_ADDRESS_ORIGIN_SLAAC).
262    pub const SLAAC: AddressOrigin = AddressOrigin(OT_ADDRESS_ORIGIN_SLAAC as u8);
263
264    /// Functional equivalent of
265    /// [`otsys::OT_ADDRESS_ORIGIN_THREAD`](crate::otsys::OT_ADDRESS_ORIGIN_THREAD).
266    pub const THREAD: AddressOrigin = AddressOrigin(OT_ADDRESS_ORIGIN_THREAD as u8);
267}
268
269impl Debug for AddressOrigin {
270    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
271        match *self {
272            Self::DHCPV6 => write!(f, "AddressOrigin::DHCPV6"),
273            Self::MANUAL => write!(f, "AddressOrigin::MANUAL"),
274            Self::SLAAC => write!(f, "AddressOrigin::SLAAC"),
275            Self::THREAD => write!(f, "AddressOrigin::THREAD"),
276            AddressOrigin(x) => write!(f, "AddressOrigin({x})"),
277        }
278    }
279}
280
281/// Data type representing IPv6 address from a network interface.
282/// Functional equivalent of [`otsys::otNetifAddress`](crate::otsys::otNetifAddress).
283#[derive(Default, Clone, Copy)]
284#[repr(transparent)]
285pub struct NetifAddress(pub(crate) otNetifAddress);
286
287impl_ot_castable!(NetifAddress, otNetifAddress);
288
289impl Debug for NetifAddress {
290    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
291        self.addr().fmt(f)?;
292        write!(f, "/{} {:?}", self.prefix_len(), self.address_origin())?;
293        if let Some(scope) = self.scope() {
294            write!(f, " {scope:?}")?;
295        }
296        if self.is_valid() {
297            write!(f, " VALID")?;
298        }
299        if self.is_preferred() {
300            write!(f, " PREFERRED")?;
301        }
302        if self.is_rloc() {
303            write!(f, " RLOC")?;
304        }
305        Ok(())
306    }
307}
308
309impl std::fmt::Display for NetifAddress {
310    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
311        std::fmt::Debug::fmt(self, f)
312    }
313}
314
315impl NetifAddress {
316    /// Creates a new instance from an Ipv6 address and prefix length.
317    ///
318    /// The resulting instance will have the `valid` and `preferred` bits set.
319    pub fn new(addr: std::net::Ipv6Addr, prefix_len: u8) -> NetifAddress {
320        let mut ret = NetifAddress(otNetifAddress {
321            mAddress: addr.into_ot(),
322            mPrefixLength: prefix_len,
323            mAddressOrigin: 0,
324            _bitfield_align_1: [],
325            _bitfield_1: Default::default(),
326            mNext: std::ptr::null_mut(),
327        });
328        ret.set_valid(true);
329        ret.set_preferred(true);
330        ret
331    }
332
333    /// Returns a reference to the IPv6 address.
334    pub fn addr(&self) -> &Ip6Address {
335        Ip6Address::ref_from_ot_ref(&self.0.mAddress)
336    }
337
338    /// Returns the prefix length for this address.
339    pub fn prefix_len(&self) -> u8 {
340        self.0.mPrefixLength
341    }
342
343    /// Returns the address origin for this address.
344    pub fn address_origin(&self) -> AddressOrigin {
345        AddressOrigin(self.0.mAddressOrigin)
346    }
347
348    /// Returns the scope override for this address.
349    pub fn scope(&self) -> Option<Scope> {
350        if self.0.mScopeOverrideValid() {
351            Some(Scope(self.0.mScopeOverride().try_into().expect("NetifAddress: invalid scope")))
352        } else {
353            None
354        }
355    }
356
357    /// Sets the scope override for this address.
358    pub fn set_scope(&mut self, scope: Option<Scope>) {
359        if let Some(scope) = scope {
360            self.0.set_mScopeOverrideValid(true);
361            self.0.set_mScopeOverride(scope.into());
362        } else {
363            self.0.set_mScopeOverrideValid(false);
364        }
365    }
366
367    /// Returns true if this address is preferred.
368    pub fn is_preferred(&self) -> bool {
369        self.0.mPreferred()
370    }
371
372    /// Sets the `preferred` bit on this address.
373    pub fn set_preferred(&mut self, x: bool) {
374        self.0.set_mPreferred(x)
375    }
376
377    /// Returns true if this address is an RLOC.
378    pub fn is_rloc(&self) -> bool {
379        self.0.mRloc()
380    }
381
382    /// Sets the `rloc` bit on this address.
383    pub fn set_rloc(&mut self, x: bool) {
384        self.0.set_mRloc(x)
385    }
386
387    /// Returns true if this address is valid.
388    pub fn is_valid(&self) -> bool {
389        self.0.mValid()
390    }
391
392    /// Sets the `valid` bit on this address.
393    pub fn set_valid(&mut self, x: bool) {
394        self.0.set_mValid(x)
395    }
396}
397
398/// IPv6 subnet prefix with an arbitrary prefix length.
399/// Functional equivalent of [`otsys::otIp6Prefix`](crate::otsys::otIp6Prefix).
400#[derive(Default, Clone, Copy)]
401#[repr(transparent)]
402pub struct Ip6Prefix(pub otIp6Prefix);
403
404impl_ot_castable!(Ip6Prefix, otIp6Prefix);
405
406impl PartialEq for Ip6Prefix {
407    fn eq(&self, other: &Self) -> bool {
408        self.addr() == other.addr() && self.prefix_len() == other.prefix_len()
409    }
410}
411
412impl Eq for Ip6Prefix {}
413
414impl Debug for Ip6Prefix {
415    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
416        self.addr().fmt(f)?;
417        write!(f, "/{}", self.prefix_len())
418    }
419}
420
421impl std::fmt::Display for Ip6Prefix {
422    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
423        std::fmt::Debug::fmt(self, f)
424    }
425}
426
427impl Ip6Prefix {
428    /// Creates a new `Ip6Prefix` from an Ipv6 address and prefix length.
429    pub fn new<T: Into<Ip6Address>>(addr: T, prefix_len: u8) -> Ip6Prefix {
430        Ip6Prefix(otIp6Prefix { mPrefix: addr.into().into_ot(), mLength: prefix_len })
431    }
432
433    /// Returns a reference to the IPv6 address.
434    pub fn addr(&self) -> &Ip6Address {
435        Ip6Address::ref_from_ot_ref(&self.0.mPrefix)
436    }
437
438    /// Returns the prefix length.
439    pub fn prefix_len(&self) -> u8 {
440        self.0.mLength
441    }
442}
443
444/// Functional equivalent of [`otsys::otSockAddr`](crate::otsys::otSockAddr).
445#[derive(Default, Clone, Copy)]
446#[repr(transparent)]
447pub struct SockAddr(pub otSockAddr);
448
449impl_ot_castable!(SockAddr, otSockAddr);
450
451impl PartialEq for SockAddr {
452    fn eq(&self, other: &Self) -> bool {
453        self.addr() == other.addr() && self.port() == other.port()
454    }
455}
456
457impl Eq for SockAddr {}
458
459impl Debug for SockAddr {
460    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
461        write!(f, "[")?;
462        self.addr().fmt(f)?;
463        write!(f, "]:{}", self.port())
464    }
465}
466
467impl std::fmt::Display for SockAddr {
468    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
469        std::fmt::Debug::fmt(self, f)
470    }
471}
472
473impl SockAddr {
474    /// Creates a new `ot::SockAddr` from an address and port.
475    pub fn new(addr: Ip6Address, port: u16) -> Self {
476        SockAddr(otSockAddr { mAddress: addr.into_ot(), mPort: port })
477    }
478
479    /// Returns the IPv6 address.
480    pub fn addr(&self) -> Ip6Address {
481        Ip6Address::from_ot(self.0.mAddress)
482    }
483
484    /// Returns the port number.
485    pub fn port(&self) -> u16 {
486        self.0.mPort
487    }
488}
489
490impl From<(Ip6Address, u16)> for SockAddr {
491    fn from(x: (Ip6Address, u16)) -> Self {
492        Self::new(x.0, x.1)
493    }
494}
495
496impl From<Ip6Address> for SockAddr {
497    fn from(x: Ip6Address) -> Self {
498        Self::new(x, 0)
499    }
500}
501
502impl From<std::net::SocketAddrV6> for SockAddr {
503    fn from(x: std::net::SocketAddrV6) -> Self {
504        SockAddr::new(*x.ip(), x.port())
505    }
506}
507
508impl From<SockAddr> for std::net::SocketAddrV6 {
509    fn from(x: SockAddr) -> Self {
510        SocketAddrV6::new(x.addr(), x.port(), 0, 0)
511    }
512}
513
514impl From<SockAddr> for std::net::SocketAddr {
515    fn from(x: SockAddr) -> Self {
516        std::net::SocketAddr::V6(x.into())
517    }
518}
519
520/// This enumeration defines the OpenThread network interface identifiers.
521///
522/// Functional equivalent of [`otsys::otNetifIdentifier`](crate::otsys::otNetifIdentifier).
523#[derive(Debug, Copy, Clone, Eq, Ord, PartialOrd, PartialEq, num_derive::FromPrimitive)]
524#[allow(missing_docs)]
525pub enum NetifIdentifier {
526    /// Functional equivalent of [`otsys::OT_NETIF_BACKBONE`](crate::otsys::OT_NETIF_BACKBONE).
527    Backbone = OT_NETIF_BACKBONE as isize,
528
529    /// Functional equivalent of [`otsys::OT_NETIF_THREAD_HOST`](crate::otsys::OT_NETIF_THREAD_HOST).
530    Thread = OT_NETIF_THREAD_HOST as isize,
531
532    /// Functional equivalent of [`otsys::OT_NETIF_UNSPECIFIED`](crate::otsys::OT_NETIF_UNSPECIFIED).
533    Unspecified = OT_NETIF_UNSPECIFIED as isize,
534}
535
536impl From<otNetifIdentifier> for NetifIdentifier {
537    fn from(x: otNetifIdentifier) -> Self {
538        use num::FromPrimitive;
539        Self::from_u32(x).unwrap_or_else(|| panic!("Unknown otNetifIdentifier value: {x}"))
540    }
541}
542
543impl From<NetifIdentifier> for otNetifIdentifier {
544    fn from(x: NetifIdentifier) -> Self {
545        x as otNetifIdentifier
546    }
547}
548
549/// Represents an entry from the discovered prefix table.
550/// Functional equivalent of [`otsys::otBorderRoutingPrefixTableEntry`](crate::otsys::otBorderRoutingPrefixTableEntry).
551#[derive(Default, Clone, Copy)]
552#[repr(transparent)]
553pub struct BorderRoutingPrefixTableEntry(pub otBorderRoutingPrefixTableEntry);
554
555impl_ot_castable!(BorderRoutingPrefixTableEntry, otBorderRoutingPrefixTableEntry);
556
557impl Debug for BorderRoutingPrefixTableEntry {
558    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
559        f.debug_struct("otBorderRoutingPrefixTableEntry")
560            .field("router_address", &self.router_address())
561            .field("prefix", &self.prefix())
562            .field("is_on_link", &self.is_on_link())
563            .field("msec_since_last_update", &self.msec_since_last_update())
564            .field("valid_lifetime", &self.valid_lifetime())
565            .field("preferred_lifetime", &self.preferred_lifetime())
566            .field("route_preference", &self.route_preference())
567            .finish()
568    }
569}
570
571impl std::fmt::Display for BorderRoutingPrefixTableEntry {
572    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
573        std::fmt::Debug::fmt(self, f)
574    }
575}
576
577impl BorderRoutingPrefixTableEntry {
578    /// Returns a reference to the IPv6 address.
579    pub fn router_address(&self) -> &Ip6Address {
580        Ip6Address::ref_from_ot_ref(&self.0.mRouter.mAddress)
581    }
582
583    /// Returns the prefix.
584    pub fn prefix(&self) -> &Ip6Prefix {
585        Ip6Prefix::ref_from_ot_ref(&self.0.mPrefix)
586    }
587
588    /// Returns true if this prefix is on-link.
589    pub fn is_on_link(&self) -> bool {
590        self.0.mIsOnLink
591    }
592
593    /// Returns the number of milliseconds since the last update
594    pub fn msec_since_last_update(&self) -> u32 {
595        self.0.mMsecSinceLastUpdate
596    }
597
598    /// Returns the valid lifetime of the prefix (in seconds)
599    pub fn valid_lifetime(&self) -> u32 {
600        self.0.mValidLifetime
601    }
602
603    /// Returns the preferred lifetime of the prefix (in seconds)
604    pub fn preferred_lifetime(&self) -> u32 {
605        self.0.mPreferredLifetime
606    }
607
608    /// Returns the route preference
609    pub fn route_preference(&self) -> RoutePreference {
610        RoutePreference::from_isize(self.0.mPreferredLifetime as isize)
611            .unwrap_or(RoutePreference::Medium)
612    }
613}
614
615/// This enumeration represents the state of DHCPv6 Prefix Delegation State.
616///
617/// Functional equivalent of [`otsys::otBorderRoutingDhcp6PdState`](crate::otsys::otBorderRoutingDhcp6PdState).
618#[derive(Debug, Default, Copy, Clone, Eq, Ord, PartialOrd, PartialEq, FromPrimitive)]
619#[allow(missing_docs)]
620pub enum BorderRoutingDhcp6PdState {
621    #[default]
622    /// Functional equivalent of [`otsys::OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED`](crate::otsys::OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED)
623    Disabled = OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED as isize,
624
625    /// Functional equivalent of [`otsys::OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED`](crate::otsys::OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED)
626    Stopped = OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED as isize,
627
628    /// Functional equivalent of [`otsys::OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING`](crate::otsys::OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING)
629    Running = OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING as isize,
630}
631
632impl From<otBorderRoutingDhcp6PdState> for BorderRoutingDhcp6PdState {
633    fn from(x: otBorderRoutingDhcp6PdState) -> Self {
634        use num::FromPrimitive;
635        Self::from_u32(x)
636            .unwrap_or_else(|| panic!("Unknown otBorderRoutingDhcp6PdState value: {x}"))
637    }
638}
639
640impl From<BorderRoutingDhcp6PdState> for otBorderRoutingDhcp6PdState {
641    fn from(x: BorderRoutingDhcp6PdState) -> Self {
642        x as otBorderRoutingDhcp6PdState
643    }
644}
openthread/ot/types/ipv6.rs

openthread/ot/types/
ipv6.rs
