packet_formats/icmp/
ndp.rs

1// Copyright 2018 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
5//! Messages used for NDP (ICMPv6).
6
7use core::num::NonZeroU8;
8use core::time::Duration;
9
10use net_types::ip::{Ipv6, Ipv6Addr};
11use zerocopy::byteorder::network_endian::{U16, U32};
12use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, SplitByteSlice, Unaligned};
13
14use crate::icmp::{IcmpIpExt, IcmpPacket, IcmpPacketRaw, IcmpZeroCode};
15use crate::utils::NonZeroDuration;
16
17/// An ICMPv6 packet with an NDP message.
18#[allow(missing_docs)]
19#[derive(Debug)]
20pub enum NdpPacket<B: SplitByteSlice> {
21    RouterSolicitation(IcmpPacket<Ipv6, B, RouterSolicitation>),
22    RouterAdvertisement(IcmpPacket<Ipv6, B, RouterAdvertisement>),
23    NeighborSolicitation(IcmpPacket<Ipv6, B, NeighborSolicitation>),
24    NeighborAdvertisement(IcmpPacket<Ipv6, B, NeighborAdvertisement>),
25    Redirect(IcmpPacket<Ipv6, B, Redirect>),
26}
27
28/// A raw ICMPv6 packet with an NDP message.
29#[allow(missing_docs)]
30#[derive(Debug)]
31pub enum NdpPacketRaw<B: SplitByteSlice> {
32    RouterSolicitation(IcmpPacketRaw<Ipv6, B, RouterSolicitation>),
33    RouterAdvertisement(IcmpPacketRaw<Ipv6, B, RouterAdvertisement>),
34    NeighborSolicitation(IcmpPacketRaw<Ipv6, B, NeighborSolicitation>),
35    NeighborAdvertisement(IcmpPacketRaw<Ipv6, B, NeighborAdvertisement>),
36    Redirect(IcmpPacketRaw<Ipv6, B, Redirect>),
37}
38
39/// A non-zero lifetime conveyed through NDP.
40#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
41pub enum NonZeroNdpLifetime {
42    /// A finite lifetime greater than zero.
43    ///
44    /// Note that the finite lifetime is not statically guaranteed to be less
45    /// than the infinite value representation of a field. E.g. for Prefix
46    /// Information option lifetime 32-bit fields, infinity is represented as
47    /// all 1s but it is possible for this variant to hold a value representing
48    /// X seconds where X is >= 2^32.
49    Finite(NonZeroDuration),
50
51    /// An infinite lifetime.
52    Infinite,
53}
54
55impl NonZeroNdpLifetime {
56    /// Returns a `Some(NonZeroNdpLifetime)` if the passed lifetime is non-zero;
57    /// otherwise `None`.
58    pub fn from_u32_with_infinite(lifetime: u32) -> Option<NonZeroNdpLifetime> {
59        // Per RFC 4861 section 4.6.2,
60        //
61        //   Valid Lifetime
62        //                  32-bit unsigned integer.  The length of time in
63        //                  seconds (relative to the time the packet is sent)
64        //                  that the prefix is valid for the purpose of on-link
65        //                  determination.  A value of all one bits
66        //                  (0xffffffff) represents infinity.  The Valid
67        //                  Lifetime is also used by [ADDRCONF].
68        //
69        //   Preferred Lifetime
70        //                  32-bit unsigned integer.  The length of time in
71        //                  seconds (relative to the time the packet is sent)
72        //                  that addresses generated from the prefix via
73        //                  stateless address autoconfiguration remain
74        //                  preferred [ADDRCONF].  A value of all one bits
75        //                  (0xffffffff) represents infinity.  See [ADDRCONF].
76        match lifetime {
77            u32::MAX => Some(NonZeroNdpLifetime::Infinite),
78            finite => NonZeroDuration::new(Duration::from_secs(finite.into()))
79                .map(NonZeroNdpLifetime::Finite),
80        }
81    }
82
83    /// Returns the minimum finite duration.
84    pub fn min_finite_duration(self, other: NonZeroDuration) -> NonZeroDuration {
85        match self {
86            NonZeroNdpLifetime::Finite(lifetime) => core::cmp::min(lifetime, other),
87            NonZeroNdpLifetime::Infinite => other,
88        }
89    }
90}
91
92/// A records parser for NDP options.
93///
94/// See [`Options`] for more details.
95///
96/// [`Options`]: packet::records::options::Options
97pub type Options<B> = packet::records::options::Options<B, options::NdpOptionsImpl>;
98
99/// A builder for a sequence of NDP options.
100///
101/// See [`OptionSequenceBuilder`] for more details.
102///
103/// [`OptionSequenceBuilder`]: packet::records::options::OptionSequenceBuilder
104pub type OptionSequenceBuilder<'a, I> =
105    packet::records::options::OptionSequenceBuilder<options::NdpOptionBuilder<'a>, I>;
106
107/// An NDP Router Solicitation.
108#[derive(
109    Copy,
110    Clone,
111    Default,
112    Debug,
113    KnownLayout,
114    FromBytes,
115    IntoBytes,
116    Immutable,
117    Unaligned,
118    PartialEq,
119    Eq,
120)]
121#[repr(C)]
122pub struct RouterSolicitation {
123    _reserved: [u8; 4],
124}
125
126impl_icmp_message!(Ipv6, RouterSolicitation, RouterSolicitation, IcmpZeroCode, Options<B>);
127
128/// The preference for a route as defined by [RFC 4191 section 2.1].
129///
130/// [RFC 4191 section 2.1]: https://datatracker.ietf.org/doc/html/rfc4191#section-2.1
131#[allow(missing_docs)]
132#[derive(Copy, Clone, Debug, PartialEq, Eq)]
133pub enum RoutePreference {
134    // We don't want to store invalid states like Reserved, as this MUST NOT be sent nor processed.
135    // From RFC 4191 section 2.1:
136    //   10      Reserved - MUST NOT be sent
137    //   ...
138    //   If the Reserved (10) value is received, the Route Information Option MUST be ignored.
139    High,
140    Medium,
141    Low,
142}
143
144impl Default for RoutePreference {
145    fn default() -> RoutePreference {
146        // As per RFC 4191 section 2.1,
147        //
148        //   Preference values are encoded as a two-bit signed integer, as
149        //   follows:
150        //
151        //      01      High
152        //      00      Medium (default)
153        //      11      Low
154        //      10      Reserved - MUST NOT be sent
155        RoutePreference::Medium
156    }
157}
158
159impl From<RoutePreference> for u8 {
160    fn from(v: RoutePreference) -> u8 {
161        // As per RFC 4191 section 2.1,
162        //
163        //   Preference values are encoded as a two-bit signed integer, as
164        //   follows:
165        //
166        //      01      High
167        //      00      Medium (default)
168        //      11      Low
169        //      10      Reserved - MUST NOT be sent
170        match v {
171            RoutePreference::High => 0b01,
172            RoutePreference::Medium => 0b00,
173            RoutePreference::Low => 0b11,
174        }
175    }
176}
177
178impl TryFrom<u8> for RoutePreference {
179    type Error = ();
180
181    fn try_from(v: u8) -> Result<Self, Self::Error> {
182        // As per RFC 4191 section 2.1,
183        //
184        //   Preference values are encoded as a two-bit signed integer, as
185        //   follows:
186        //
187        //      01      High
188        //      00      Medium (default)
189        //      11      Low
190        //      10      Reserved - MUST NOT be sent
191        match v {
192            0b01 => Ok(RoutePreference::High),
193            0b00 => Ok(RoutePreference::Medium),
194            0b11 => Ok(RoutePreference::Low),
195            _ => Err(()),
196        }
197    }
198}
199
200/// An NDP Router Advertisement.
201#[derive(
202    Copy, Clone, Debug, KnownLayout, FromBytes, IntoBytes, Immutable, Unaligned, PartialEq, Eq,
203)]
204#[repr(C)]
205pub struct RouterAdvertisement {
206    current_hop_limit: u8,
207    configuration_mo: u8,
208    router_lifetime: U16,
209    reachable_time: U32,
210    retransmit_timer: U32,
211}
212
213impl_icmp_message!(Ipv6, RouterAdvertisement, RouterAdvertisement, IcmpZeroCode, Options<B>);
214
215impl RouterAdvertisement {
216    /// Managed address configuration flag.
217    ///
218    /// When set, it indicates that addresses are available via Dynamic Host Configuration Protocol
219    /// (DHCPv6).
220    ///
221    /// If set, the "Pther configuration" flag is redundant and can be ignored because DHCPv6 will
222    /// return all available configuration information.
223    const MANAGED_FLAG: u8 = 0x80;
224
225    /// Other configuration flag.
226    ///
227    /// When set, it indicates that other configuration information is available via DHCPv6.
228    /// Examples of such information are DNS-related information or information on other servers
229    /// within the network.
230    const OTHER_CONFIGURATION_FLAG: u8 = 0x40;
231
232    // As per RFC 4191 section 2.2,
233    //
234    //      0                   1                   2                   3
235    //      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
236    //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
237    //     |     Type      |     Code      |          Checksum             |
238    //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
239    //     | Cur Hop Limit |M|O|H|Prf|Resvd|       Router Lifetime         |
240    //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
241    //     |                         Reachable Time                        |
242    //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
243    //     |                          Retrans Timer                        |
244    //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
245    //
246    //  Fields:
247    //
248    //   Prf (Default Router Preference)
249    //            2-bit signed integer.  Indicates whether to prefer this
250    //            router over other default routers.  If the Router Lifetime
251    //            is zero, the preference value MUST be set to (00) by the
252    //            sender and MUST be ignored by the receiver.  If the Reserved
253    //            (10) value is received, the receiver MUST treat the value as
254    //            if it were (00).
255    const DEFAULT_ROUTER_PREFERENCE_SHIFT: u8 = 3;
256    const DEFAULT_ROUTER_PREFERENCE_MASK: u8 = 0b11 << Self::DEFAULT_ROUTER_PREFERENCE_SHIFT;
257
258    /// Creates a new Router Advertisement with the specified field values.
259    ///
260    /// Equivalent to calling `with_prf` with a default preference value.
261    pub fn new(
262        current_hop_limit: u8,
263        managed_flag: bool,
264        other_config_flag: bool,
265        router_lifetime: u16,
266        reachable_time: u32,
267        retransmit_timer: u32,
268    ) -> Self {
269        Self::with_prf(
270            current_hop_limit,
271            managed_flag,
272            other_config_flag,
273            RoutePreference::default(),
274            router_lifetime,
275            reachable_time,
276            retransmit_timer,
277        )
278    }
279
280    /// Creates a new Router Advertisement with the specified field values.
281    pub fn with_prf(
282        current_hop_limit: u8,
283        managed_flag: bool,
284        other_config_flag: bool,
285        preference: RoutePreference,
286        router_lifetime: u16,
287        reachable_time: u32,
288        retransmit_timer: u32,
289    ) -> Self {
290        let mut configuration_mo = 0;
291
292        if managed_flag {
293            configuration_mo |= Self::MANAGED_FLAG;
294        }
295
296        if other_config_flag {
297            configuration_mo |= Self::OTHER_CONFIGURATION_FLAG;
298        }
299
300        configuration_mo |= (u8::from(preference) << Self::DEFAULT_ROUTER_PREFERENCE_SHIFT)
301            & Self::DEFAULT_ROUTER_PREFERENCE_MASK;
302
303        Self {
304            current_hop_limit,
305            configuration_mo,
306            router_lifetime: U16::new(router_lifetime),
307            reachable_time: U32::new(reachable_time),
308            retransmit_timer: U32::new(retransmit_timer),
309        }
310    }
311
312    /// Returns the current hop limit field.
313    ///
314    /// A value of `None` means unspecified by the source of the Router Advertisement.
315    pub fn current_hop_limit(&self) -> Option<NonZeroU8> {
316        NonZeroU8::new(self.current_hop_limit)
317    }
318
319    /// Returns the router lifetime.
320    ///
321    /// A value of `None` indicates that the router is not a default router and SHOULD
322    /// NOT appear in the default router list.
323    pub fn router_lifetime(&self) -> Option<NonZeroDuration> {
324        // As per RFC 4861 section 4.2, the Router Lifetime field is held in units
325        // of seconds.
326        NonZeroDuration::new(Duration::from_secs(self.router_lifetime.get().into()))
327    }
328
329    /// Returns the reachable time.
330    ///
331    /// A value of `None` means unspecified by the source of the Router Advertisement.
332    pub fn reachable_time(&self) -> Option<NonZeroDuration> {
333        // As per RFC 4861 section 4.2, the Reachable Time field is held in units
334        // of milliseconds.
335        NonZeroDuration::new(Duration::from_millis(self.reachable_time.get().into()))
336    }
337
338    /// Returns the retransmit timer.
339    ///
340    /// A value of `None` means unspecified by the source of the Router Advertisement.
341    pub fn retransmit_timer(&self) -> Option<NonZeroDuration> {
342        // As per RFC 4861 section 4.2, the Retransmit Timer field is held in units
343        // of milliseconds
344        NonZeroDuration::new(Duration::from_millis(self.retransmit_timer.get().into()))
345    }
346}
347
348/// An NDP Neighbor Solicitation.
349#[derive(
350    Copy, Clone, Debug, KnownLayout, FromBytes, IntoBytes, Immutable, Unaligned, PartialEq, Eq,
351)]
352#[repr(C)]
353pub struct NeighborSolicitation {
354    _reserved: [u8; 4],
355    target_address: Ipv6Addr,
356}
357
358impl_icmp_message!(Ipv6, NeighborSolicitation, NeighborSolicitation, IcmpZeroCode, Options<B>);
359
360impl NeighborSolicitation {
361    /// Creates a new neighbor solicitation message with the provided
362    /// `target_address`.
363    pub fn new(target_address: Ipv6Addr) -> Self {
364        Self { _reserved: [0; 4], target_address }
365    }
366
367    /// Get the target address in neighbor solicitation message.
368    pub fn target_address(&self) -> &Ipv6Addr {
369        &self.target_address
370    }
371}
372
373/// An NDP Neighbor Advertisement.
374#[derive(
375    Copy, Clone, Debug, KnownLayout, FromBytes, IntoBytes, Immutable, Unaligned, PartialEq, Eq,
376)]
377#[repr(C)]
378pub struct NeighborAdvertisement {
379    flags_rso: u8,
380    _reserved: [u8; 3],
381    target_address: Ipv6Addr,
382}
383
384impl_icmp_message!(Ipv6, NeighborAdvertisement, NeighborAdvertisement, IcmpZeroCode, Options<B>);
385
386impl NeighborAdvertisement {
387    /// Router flag.
388    ///
389    /// When set, the R-bit indicates that the sender is a router. The R-bit is
390    /// used by Neighbor Unreachability Detection to detect a router that
391    /// changes to a host.
392    const FLAG_ROUTER: u8 = 0x80;
393
394    /// Solicited flag.
395    ///
396    /// When set, the S-bit indicates that the advertisement was sent in
397    /// response to a Neighbor Solicitation from the Destination address. The
398    /// S-bit is used as a reachability confirmation for Neighbor Unreachability
399    /// Detection.  It MUST NOT be set in multicast advertisements or in
400    /// unsolicited unicast advertisements.
401    const FLAG_SOLICITED: u8 = 0x40;
402
403    /// Override flag.
404    ///
405    /// When set, the O-bit indicates that the advertisement should override an
406    /// existing cache entry and update the cached link-layer address. When it
407    /// is not set the advertisement will not update a cached link-layer address
408    /// though it will update an existing Neighbor Cache entry for which no
409    /// link-layer address is known.  It SHOULD NOT be set in solicited
410    /// advertisements for anycast addresses and in solicited proxy
411    /// advertisements. It SHOULD be set in other solicited advertisements and
412    /// in unsolicited advertisements.
413    const FLAG_OVERRIDE: u8 = 0x20;
414
415    /// Creates a new neighbor advertisement message with the provided
416    /// `router_flag`, `solicited_flag`, `override_flag` and `target_address`.
417    pub fn new(
418        router_flag: bool,
419        solicited_flag: bool,
420        override_flag: bool,
421        target_address: Ipv6Addr,
422    ) -> Self {
423        let mut flags_rso = 0;
424
425        if router_flag {
426            flags_rso |= Self::FLAG_ROUTER;
427        }
428
429        if solicited_flag {
430            flags_rso |= Self::FLAG_SOLICITED;
431        }
432
433        if override_flag {
434            flags_rso |= Self::FLAG_OVERRIDE;
435        }
436
437        Self { flags_rso, _reserved: [0; 3], target_address }
438    }
439
440    /// Returns the target_address of an NA message.
441    pub fn target_address(&self) -> &Ipv6Addr {
442        &self.target_address
443    }
444
445    /// Returns the router flag.
446    pub fn router_flag(&self) -> bool {
447        (self.flags_rso & Self::FLAG_ROUTER) != 0
448    }
449
450    /// Returns the solicited flag.
451    pub fn solicited_flag(&self) -> bool {
452        (self.flags_rso & Self::FLAG_SOLICITED) != 0
453    }
454
455    /// Returns the override flag.
456    pub fn override_flag(&self) -> bool {
457        (self.flags_rso & Self::FLAG_OVERRIDE) != 0
458    }
459}
460
461/// An ICMPv6 Redirect Message.
462#[derive(
463    Copy, Clone, Debug, KnownLayout, FromBytes, IntoBytes, Immutable, Unaligned, PartialEq, Eq,
464)]
465#[repr(C)]
466pub struct Redirect {
467    _reserved: [u8; 4],
468    target_address: Ipv6Addr,
469    destination_address: Ipv6Addr,
470}
471
472impl_icmp_message!(Ipv6, Redirect, Redirect, IcmpZeroCode, Options<B>);
473
474/// Parsing and serialization of NDP options.
475pub mod options {
476    use core::num::NonZeroUsize;
477    use core::time::Duration;
478
479    use byteorder::{ByteOrder, NetworkEndian};
480    use net_types::ip::{IpAddress as _, Ipv6Addr, Subnet, SubnetError};
481    use net_types::UnicastAddress;
482    use packet::records::options::{
483        LengthEncoding, OptionBuilder, OptionLayout, OptionParseErr, OptionParseLayout, OptionsImpl,
484    };
485    use packet::BufferView as _;
486    use zerocopy::byteorder::network_endian::U32;
487    use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, Ref, SplitByteSlice, Unaligned};
488
489    use super::NonZeroNdpLifetime;
490    use crate::utils::NonZeroDuration;
491
492    /// A `u32` value representing an infinite lifetime for various NDP options' lifetime fields.
493    pub const INFINITE_LIFETIME_SECONDS: u32 = u32::MAX;
494
495    /// A value representing an infinite lifetime for various NDP options'
496    /// lifetime fields.
497    pub const INFINITE_LIFETIME: NonZeroDuration =
498        NonZeroDuration::from_secs(INFINITE_LIFETIME_SECONDS as u64).unwrap();
499
500    /// The number of reserved bytes immediately following the kind and length
501    /// bytes in a Redirected Header option.
502    ///
503    /// See [RFC 4861 section 4.6.3] for more information.
504    ///
505    /// [RFC 4861 section 4.6.3]: https://tools.ietf.org/html/rfc4861#section-4.6.3
506    const REDIRECTED_HEADER_OPTION_RESERVED_BYTES_LENGTH: usize = 6;
507
508    /// The length of an NDP MTU option, excluding the first 2 bytes (kind and length bytes).
509    ///
510    /// See [RFC 4861 section 4.6.3] for more information.
511    ///
512    /// [RFC 4861 section 4.6.3]: https://tools.ietf.org/html/rfc4861#section-4.6.3
513    const MTU_OPTION_LENGTH: usize = 6;
514
515    /// The number of reserved bytes immediately following the kind and length
516    /// bytes in an MTU option.
517    ///
518    /// See [RFC 4861 section 4.6.4] for more information.
519    ///
520    /// [RFC 4861 section 4.6.4]: https://tools.ietf.org/html/rfc4861#section-4.6.4
521    const MTU_OPTION_RESERVED_BYTES_LENGTH: usize = 2;
522
523    /// Minimum number of bytes in a Nonce option, excluding the kind and length bytes.
524    ///
525    /// See [RFC 3971 section 5.3.2] for more information.
526    ///
527    /// [RFC 3971 section 5.3.2]: https://tools.ietf.org/html/rfc3971#section-5.3.2
528    pub const MIN_NONCE_LENGTH: usize = 6;
529
530    /// Minimum number of bytes in a Recursive DNS Server option, excluding the
531    /// kind and length bytes.
532    ///
533    /// This guarantees that a valid Recurisve DNS Server option holds at least
534    /// 1 address.
535    ///
536    /// See [RFC 8106 section 5.3.1] for more information.
537    ///
538    /// [RFC 8106 section 5.3.1]: https://tools.ietf.org/html/rfc8106#section-5.1
539    const MIN_RECURSIVE_DNS_SERVER_OPTION_LENGTH: usize = 22;
540
541    /// The number of reserved bytes immediately following the kind and length
542    /// bytes in a Recursive DNS Server option.
543    ///
544    /// See [RFC 8106 section 5.3.1] for more information.
545    ///
546    /// [RFC 8106 section 5.3.1]: https://tools.ietf.org/html/rfc8106#section-5.1
547    const RECURSIVE_DNS_SERVER_OPTION_RESERVED_BYTES_LENGTH: usize = 2;
548
549    /// The number of reserved bits immediately following (on the right of) the preference.
550    ///
551    /// See [RFC 4191 section 2.3] for more information.
552    ///
553    /// [RFC 4191 section 2.3]: https://tools.ietf.org/html/rfc4191#section-2.3
554    const ROUTE_INFORMATION_PREFERENCE_RESERVED_BITS_RIGHT: u8 = 3;
555
556    /// A mask to keep only the valid bits for the preference in the Route Information option.
557    ///
558    /// See [RFC 4191 section 2.3] for more information.
559    ///
560    /// [RFC 4191 section 2.3]: https://tools.ietf.org/html/rfc4191#section-2.3
561    const ROUTE_INFORMATION_PREFERENCE_MASK: u8 = 0x18;
562
563    /// The length of an NDP option is specified in units of 8 octets.
564    ///
565    /// See [RFC 4861 section 4.6] for more information.
566    ///
567    /// [RFC 4861 section 4.6]: https://tools.ietf.org/html/rfc4861#section-4.6
568    const OPTION_BYTES_PER_LENGTH_UNIT: usize = 8;
569
570    /// Recursive DNS Server that is advertised by a router in Router Advertisements.
571    ///
572    /// See [RFC 8106 section 5.1].
573    ///
574    /// [RFC 8106 section 5.1]: https://tools.ietf.org/html/rfc8106#section-5.1
575    #[derive(Debug, PartialEq, Eq, Clone)]
576    pub struct RecursiveDnsServer<'a> {
577        lifetime: u32,
578        addresses: &'a [Ipv6Addr],
579    }
580
581    impl<'a> RecursiveDnsServer<'a> {
582        /// The `u32` value representing an infinite lifetime for a RecursiveDnsServer option.
583        pub const INFINITE_LIFETIME: u32 = INFINITE_LIFETIME_SECONDS;
584
585        /// Returns a new `RecursiveDnsServer`.
586        pub fn new(lifetime: u32, addresses: &'a [Ipv6Addr]) -> RecursiveDnsServer<'a> {
587            RecursiveDnsServer { lifetime, addresses }
588        }
589
590        /// Returns the length of time (relative to the time the packet is sent) that
591        /// the DNS servers are valid for name resolution.
592        ///
593        /// A value of [`INFINITE_LIFETIME`] represents infinity; a value of `None`
594        /// means that the servers MUST no longer be used.
595        pub fn lifetime(&self) -> Option<NonZeroDuration> {
596            NonZeroDuration::new(Duration::from_secs(self.lifetime.into()))
597        }
598
599        /// Returns the recursive DNS server addresses.
600        pub fn iter_addresses(&self) -> &'a [Ipv6Addr] {
601            self.addresses
602        }
603
604        /// Parses a Recursive DNS Server option from raw bytes (starting immediately
605        /// after the kind and length bytes).
606        pub fn parse(data: &'a [u8]) -> Result<Self, OptionParseErr> {
607            if data.len() < MIN_RECURSIVE_DNS_SERVER_OPTION_LENGTH {
608                return Err(OptionParseErr);
609            }
610
611            // Skip the reserved bytes which immediately follow the kind and length
612            // bytes.
613            let (_, data) = data.split_at(RECURSIVE_DNS_SERVER_OPTION_RESERVED_BYTES_LENGTH);
614
615            // As per RFC 8106 section 5.1, the 32 bit lifetime field immediately
616            // follows the reserved field.
617            let (lifetime, data) = Ref::<_, U32>::from_prefix(data).map_err(|_| OptionParseErr)?;
618
619            // As per RFC 8106 section 5.1, the list of addresses immediately
620            // follows the lifetime field.
621            let addresses = Ref::into_ref(
622                Ref::<_, [Ipv6Addr]>::from_bytes(data)
623                    .map_err(Into::into)
624                    .map_err(|_: zerocopy::SizeError<_, _>| OptionParseErr)?,
625            );
626
627            // As per RFC 8106 section 5.3.1, the addresses should all be unicast.
628            if !addresses.iter().all(UnicastAddress::is_unicast) {
629                return Err(OptionParseErr);
630            }
631
632            Ok(Self::new(lifetime.get(), addresses))
633        }
634    }
635
636    /// The first 6 bytes of the Route Information option following the Type and
637    /// Length fields.
638    ///
639    /// As per [RFC 4191 section 2.3],
640    ///
641    /// ```text
642    ///   Route Information Option
643    ///
644    ///      0                   1                   2                   3
645    ///       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
646    ///      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
647    ///      |     Type      |    Length     | Prefix Length |Resvd|Prf|Resvd|
648    ///      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
649    ///      |                        Route Lifetime                         |
650    ///      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
651    ///      |                   Prefix (Variable Length)                    |
652    ///      .                                                               .
653    ///      .                                                               .
654    ///      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
655    /// ```
656    ///
657    /// [RFC 4191 section 2.3]: https://datatracker.ietf.org/doc/html/rfc4191#section-2.3
658    #[derive(KnownLayout, FromBytes, IntoBytes, Immutable, Unaligned)]
659    #[repr(C)]
660    struct RouteInformationHeader {
661        prefix_length: u8,
662        flags: u8,
663        route_lifetime: U32,
664    }
665
666    impl RouteInformationHeader {
667        // As per RFC 4191 section 2.3,
668        //
669        //   Route Information Option
670        //
671        //      0                   1                   2                   3
672        //       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
673        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
674        //      |     Type      |    Length     | Prefix Length |Resvd|Prf|Resvd|
675        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
676        //      |                        Route Lifetime                         |
677        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
678        //      |                   Prefix (Variable Length)                    |
679        //      .                                                               .
680        //      .                                                               .
681        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
682        const PREFERENCE_SHIFT: u8 = 3;
683        const PREFERENCE_MASK: u8 = 0b11 << Self::PREFERENCE_SHIFT;
684
685        fn set_preference(&mut self, preference: super::RoutePreference) {
686            let preference: u8 = preference.into();
687
688            self.flags &= !Self::PREFERENCE_MASK;
689            self.flags |= (preference << Self::PREFERENCE_SHIFT) & Self::PREFERENCE_MASK;
690        }
691    }
692
693    /// Builder for a Route Information option.
694    ///
695    /// See [RFC 4191 section 2.3].
696    ///
697    /// [RFC 4191 section 2.3]: https://datatracker.ietf.org/doc/html/rfc4191#section-2.3
698    #[derive(Debug, PartialEq, Eq)]
699    pub struct RouteInformation {
700        prefix: Subnet<Ipv6Addr>,
701        route_lifetime_seconds: u32,
702        preference: super::RoutePreference,
703    }
704
705    impl RouteInformation {
706        /// Returns a new Route Information option builder.
707        pub fn new(
708            prefix: Subnet<Ipv6Addr>,
709            route_lifetime_seconds: u32,
710            preference: super::RoutePreference,
711        ) -> Self {
712            Self { prefix, route_lifetime_seconds, preference }
713        }
714
715        /// The prefix represented as a [`Subnet`].
716        pub fn prefix(&self) -> &Subnet<Ipv6Addr> {
717            &self.prefix
718        }
719
720        /// The preference of the route.
721        pub fn preference(&self) -> super::RoutePreference {
722            self.preference
723        }
724
725        /// Returns the lifetime of the route.
726        pub fn route_lifetime(&self) -> Option<NonZeroNdpLifetime> {
727            NonZeroNdpLifetime::from_u32_with_infinite(self.route_lifetime_seconds)
728        }
729
730        fn prefix_bytes_len(&self) -> usize {
731            let RouteInformation { prefix, route_lifetime_seconds: _, preference: _ } = self;
732
733            let prefix_length = prefix.prefix();
734            // As per RFC 4191 section 2.3,
735            //
736            //    Length     8-bit unsigned integer.  The length of the option
737            //               (including the Type and Length fields) in units of 8
738            //               octets.  The Length field is 1, 2, or 3 depending on the
739            //               Prefix Length.  If Prefix Length is greater than 64, then
740            //               Length must be 3.  If Prefix Length is greater than 0,
741            //               then Length must be 2 or 3.  If Prefix Length is zero,
742            //               then Length must be 1, 2, or 3.
743            //
744            // This function only returns the length of the prefix bytes in units of
745            // 1 octet.
746            if prefix_length == 0 {
747                0
748            } else if prefix_length <= 64 {
749                core::mem::size_of::<Ipv6Addr>() / 2
750            } else {
751                core::mem::size_of::<Ipv6Addr>()
752            }
753        }
754
755        fn serialized_len(&self) -> usize {
756            core::mem::size_of::<RouteInformationHeader>() + self.prefix_bytes_len()
757        }
758
759        fn serialize(&self, buffer: &mut [u8]) {
760            let (mut hdr, buffer) = Ref::<_, RouteInformationHeader>::from_prefix(buffer)
761                .expect("expected buffer to hold enough bytes for serialization");
762
763            let prefix_bytes_len = self.prefix_bytes_len();
764            let RouteInformation { prefix, route_lifetime_seconds, preference } = self;
765
766            hdr.prefix_length = prefix.prefix();
767            hdr.set_preference(*preference);
768            hdr.route_lifetime.set(*route_lifetime_seconds);
769            buffer[..prefix_bytes_len]
770                .copy_from_slice(&prefix.network().bytes()[..prefix_bytes_len])
771        }
772    }
773
774    /// Number of bytes in a Prefix Information option, excluding the kind
775    /// and length bytes.
776    ///
777    /// See [RFC 4861 section 4.6.2] for more information.
778    ///
779    /// [RFC 4861 section 4.6.2]: https://tools.ietf.org/html/rfc4861#section-4.6.2
780    const PREFIX_INFORMATION_OPTION_LENGTH: usize = 30;
781
782    /// Prefix information that is advertised by a router in Router Advertisements.
783    ///
784    /// See [RFC 4861 section 4.6.2].
785    ///
786    /// [RFC 4861 section 4.6.2]: https://tools.ietf.org/html/rfc4861#section-4.6.2
787    #[derive(
788        Debug, KnownLayout, FromBytes, IntoBytes, Immutable, Unaligned, PartialEq, Eq, Clone,
789    )]
790    #[repr(C)]
791    pub struct PrefixInformation {
792        prefix_length: u8,
793        flags_la: u8,
794        valid_lifetime: U32,
795        preferred_lifetime: U32,
796        _reserved: [u8; 4],
797        prefix: Ipv6Addr,
798    }
799
800    impl PrefixInformation {
801        /// The on-link flag within the 4th byte in the prefix information buffer.
802        ///
803        /// See [RFC 4861 section 4.6.2] for more information.
804        ///
805        /// [RFC 4861 section 4.6.2]: https://tools.ietf.org/html/rfc4861#section-4.6.2
806        const ON_LINK_FLAG: u8 = 0x80;
807
808        /// The autonomous address configuration flag within the 4th byte in the
809        /// prefix information buffer
810        ///
811        /// See [RFC 4861 section 4.6.2] for more information.
812        ///
813        /// [RFC 4861 section 4.6.2]: https://tools.ietf.org/html/rfc4861#section-4.6.2
814        const AUTONOMOUS_ADDRESS_CONFIGURATION_FLAG: u8 = 0x40;
815
816        /// Create a new `PrefixInformation`.
817        pub fn new(
818            prefix_length: u8,
819            on_link_flag: bool,
820            autonomous_address_configuration_flag: bool,
821            valid_lifetime: u32,
822            preferred_lifetime: u32,
823            prefix: Ipv6Addr,
824        ) -> Self {
825            let mut flags_la = 0;
826
827            if on_link_flag {
828                flags_la |= Self::ON_LINK_FLAG;
829            }
830
831            if autonomous_address_configuration_flag {
832                flags_la |= Self::AUTONOMOUS_ADDRESS_CONFIGURATION_FLAG;
833            }
834
835            Self {
836                prefix_length,
837                flags_la,
838                valid_lifetime: U32::new(valid_lifetime),
839                preferred_lifetime: U32::new(preferred_lifetime),
840                _reserved: [0; 4],
841                prefix,
842            }
843        }
844
845        /// The number of leading bits in the prefix that are valid.
846        pub fn prefix_length(&self) -> u8 {
847            self.prefix_length
848        }
849
850        /// Is this prefix on the link?
851        ///
852        /// Returns `true` if the prefix is on-link. `false` means that
853        /// no statement is made about on or off-link properties of the
854        /// prefix; nodes MUST NOT conclude that an address derived
855        /// from this prefix is off-link if `false`.
856        pub fn on_link_flag(&self) -> bool {
857            (self.flags_la & Self::ON_LINK_FLAG) != 0
858        }
859
860        /// Can this prefix be used for stateless address configuration?
861        pub fn autonomous_address_configuration_flag(&self) -> bool {
862            (self.flags_la & Self::AUTONOMOUS_ADDRESS_CONFIGURATION_FLAG) != 0
863        }
864
865        /// Get the length of time (relative to the time the packet is sent) that
866        /// the prefix is valid for the purpose of on-link determination and SLAAC.
867        ///
868        /// `None` indicates that the prefix has no valid lifetime and should
869        /// not be considered valid.
870        pub fn valid_lifetime(&self) -> Option<NonZeroNdpLifetime> {
871            NonZeroNdpLifetime::from_u32_with_infinite(self.valid_lifetime.get())
872        }
873
874        /// Get the length of time (relative to the time the packet is sent) that
875        /// addresses generated from the prefix via SLAAC remains preferred.
876        ///
877        /// `None` indicates that the prefix has no preferred lifetime and
878        /// should not be considered preferred.
879        pub fn preferred_lifetime(&self) -> Option<NonZeroNdpLifetime> {
880            NonZeroNdpLifetime::from_u32_with_infinite(self.preferred_lifetime.get())
881        }
882
883        /// An IPv6 address or a prefix of an IPv6 address.
884        ///
885        /// The number of valid leading bits in this prefix is available
886        /// from [`PrefixInformation::prefix_length`];
887        // TODO(https://fxbug.dev/42173363): Consider merging prefix and prefix_length and return a
888        // Subnet.
889        pub fn prefix(&self) -> &Ipv6Addr {
890            &self.prefix
891        }
892
893        /// Gets the prefix as a [`Subnet`].
894        pub fn subnet(&self) -> Result<Subnet<Ipv6Addr>, SubnetError> {
895            Subnet::new(self.prefix, self.prefix_length)
896        }
897    }
898
899    /// Consts for NDP option types.
900    pub mod option_types {
901        /// Prefix Information (https://datatracker.ietf.org/doc/html/rfc4861#section-4.6.2)
902        pub const PREFIX_INFORMATION: u8 = 3;
903
904        /// Recursive DNS Server (https://datatracker.ietf.org/doc/html/rfc8106#section-5.1)
905        pub const RECURSIVE_DNS_SERVER: u8 = 25;
906
907        /// DNS Search List (https://datatracker.ietf.org/doc/html/rfc8106#section-5.2)
908        pub const DNS_SEARCH_LIST: u8 = 31;
909
910        /// 6LoWPAN Context Option (https://datatracker.ietf.org/doc/html/rfc6775#section-4.2)
911        pub const SIXLOWPAN_CONTEXT: u8 = 34;
912
913        /// Captive Portal (https://datatracker.ietf.org/doc/html/rfc8910#section-2.3)
914        pub const CAPTIVE_PORTAL: u8 = 37;
915
916        /// PREF64 (https://datatracker.ietf.org/doc/html/rfc8781#name-option-format)
917        pub const PREF64: u8 = 38;
918
919        /// May return a debug string for a given option type.
920        pub fn debug_name(option_type: u8) -> Option<&'static str> {
921            // Match with preceding `super::...` namespace to avoid accidentally binding
922            // SOME_VARIABLE instead of matching against a named constant.
923            match option_type {
924                super::option_types::PREFIX_INFORMATION => Some("PREFIX_INFORMATION"),
925                super::option_types::RECURSIVE_DNS_SERVER => Some("RECURSIVE_DNS_SERVER"),
926                super::option_types::DNS_SEARCH_LIST => Some("DNS_SEARCH_LIST"),
927                super::option_types::SIXLOWPAN_CONTEXT => Some("SIXLOWPAN_CONTEXT"),
928                super::option_types::CAPTIVE_PORTAL => Some("CAPTIVE_PORTAL"),
929                super::option_types::PREF64 => Some("PREF64"),
930                _ => None,
931            }
932        }
933    }
934
935    use option_types::{PREFIX_INFORMATION, RECURSIVE_DNS_SERVER};
936
937    create_protocol_enum!(
938        /// The types of NDP options that may be found in NDP messages.
939        #[allow(missing_docs)]
940        pub enum NdpOptionType: u8 {
941            SourceLinkLayerAddress, 1, "Source Link-Layer Address";
942            TargetLinkLayerAddress, 2, "Target Link-Layer Address";
943            PrefixInformation, PREFIX_INFORMATION, "Prefix Information";
944            RedirectedHeader, 4, "Redirected Header";
945            Mtu, 5, "MTU";
946            Nonce, 14, "Nonce";
947            RouteInformation, 24, "Route Information";
948            RecursiveDnsServer, RECURSIVE_DNS_SERVER, "Recursive DNS Server";
949        }
950    );
951
952    /// Nonce option used to make sure an advertisement is a fresh response to
953    /// a solicitation sent earlier.
954    ///
955    /// See [RFC 3971 section 5.3.2].
956    ///
957    /// [RFC 3971 section 5.3.2]: https://tools.ietf.org/html/rfc3971#section-5.3.2
958    #[derive(Debug, PartialEq, Eq, Copy, Clone, PartialOrd, Ord)]
959    pub struct NdpNonce<B: SplitByteSlice> {
960        nonce: B,
961    }
962
963    impl<B: SplitByteSlice> NdpNonce<B> {
964        /// The bytes of the nonce.
965        pub fn bytes(&self) -> &[u8] {
966            let Self { nonce } = self;
967            nonce.deref()
968        }
969
970        /// Constructs an `NdpNonce` from a `B: SplitByteSlice`, returning an error
971        /// if the resulting nonce would not have a valid length.
972        pub fn new(value: B) -> Result<Self, InvalidNonceError> {
973            let bytes = value.deref();
974            // As per RFC 3971 section 5.3.2, the length of the random number
975            // must be selected such that the length of the Nonce option
976            // (including the type and length bytes) is a multiple of 8 octets.
977            let nonce_option_length_bytes = bytes.len() + 2;
978            if nonce_option_length_bytes % 8 != 0 {
979                return Err(InvalidNonceError::ResultsInNonMultipleOf8);
980            }
981
982            let nonce_option_length_in_groups_of_8_bytes = nonce_option_length_bytes / 8;
983
984            // The nonce options's length (in terms of groups of 8 octets) would
985            // be too large to fit in a `u8`.
986            match u8::try_from(nonce_option_length_in_groups_of_8_bytes) {
987                Ok(_) => (),
988                Err(_) => return Err(InvalidNonceError::TooLong),
989            };
990
991            Ok(Self { nonce: value })
992        }
993    }
994
995    impl<B: SplitByteSlice> AsRef<[u8]> for NdpNonce<B> {
996        fn as_ref(&self) -> &[u8] {
997            self.bytes()
998        }
999    }
1000
1001    // Provide a `From` implementation for `[u8; MIN_NONCE_LENGTH]` since this
1002    // is a common conversion and is convenient to make infallible.
1003    impl<'a> From<&'a [u8; MIN_NONCE_LENGTH]> for NdpNonce<&'a [u8]> {
1004        fn from(value: &'a [u8; MIN_NONCE_LENGTH]) -> Self {
1005            Self { nonce: &value[..] }
1006        }
1007    }
1008
1009    /// Errors that may occur when constructing a Nonce option.
1010    #[derive(Debug, PartialEq, Eq, Copy, Clone)]
1011    pub enum InvalidNonceError {
1012        /// The nonce's length is such that the nonce option's length would not
1013        /// be a multiple of 8 octets.
1014        ResultsInNonMultipleOf8,
1015        /// The nonce is too long.
1016        TooLong,
1017    }
1018
1019    /// NDP options that may be found in NDP messages.
1020    #[allow(missing_docs)]
1021    #[derive(Debug, PartialEq, Eq)]
1022    pub enum NdpOption<'a> {
1023        SourceLinkLayerAddress(&'a [u8]),
1024        TargetLinkLayerAddress(&'a [u8]),
1025        PrefixInformation(&'a PrefixInformation),
1026
1027        RedirectedHeader { original_packet: &'a [u8] },
1028
1029        Mtu(u32),
1030        Nonce(NdpNonce<&'a [u8]>),
1031
1032        RecursiveDnsServer(RecursiveDnsServer<'a>),
1033        RouteInformation(RouteInformation),
1034    }
1035
1036    impl<'a> NdpOption<'a> {
1037        /// Accessor for the `Nonce` case.
1038        pub fn nonce(self) -> Option<NdpNonce<&'a [u8]>> {
1039            match self {
1040                NdpOption::Nonce(nonce) => Some(nonce),
1041                _ => None,
1042            }
1043        }
1044
1045        /// Accessor for the `SourceLinkLayerAddress` case.
1046        pub fn source_link_layer_address(self) -> Option<&'a [u8]> {
1047            match self {
1048                NdpOption::SourceLinkLayerAddress(a) => Some(a),
1049                _ => None,
1050            }
1051        }
1052
1053        /// Accessor for the `TargetLinkLayerAddress` case.
1054        pub fn target_link_layer_address(self) -> Option<&'a [u8]> {
1055            match self {
1056                NdpOption::TargetLinkLayerAddress(a) => Some(a),
1057                _ => None,
1058            }
1059        }
1060    }
1061
1062    /// An implementation of [`OptionsImpl`] for NDP options.
1063    #[derive(Debug)]
1064    pub struct NdpOptionsImpl;
1065
1066    impl<'a> OptionLayout for NdpOptionsImpl {
1067        type KindLenField = u8;
1068
1069        // For NDP options the length should be multiplied by 8.
1070        const LENGTH_ENCODING: LengthEncoding = LengthEncoding::TypeLengthValue {
1071            option_len_multiplier: NonZeroUsize::new(8).unwrap(),
1072        };
1073    }
1074
1075    impl OptionParseLayout for NdpOptionsImpl {
1076        // TODO(https://fxbug.dev/42129573): Return more verbose logs on parsing errors.
1077        type Error = OptionParseErr;
1078
1079        // NDP options don't have END_OF_OPTIONS or NOP.
1080        const END_OF_OPTIONS: Option<u8> = None;
1081        const NOP: Option<u8> = None;
1082    }
1083
1084    impl OptionsImpl for NdpOptionsImpl {
1085        type Option<'a> = NdpOption<'a>;
1086
1087        fn parse<'a>(
1088            kind: u8,
1089            mut data: &'a [u8],
1090        ) -> Result<Option<NdpOption<'a>>, OptionParseErr> {
1091            let kind = if let Ok(k) = NdpOptionType::try_from(kind) {
1092                k
1093            } else {
1094                return Ok(None);
1095            };
1096
1097            let opt = match kind {
1098                NdpOptionType::SourceLinkLayerAddress => NdpOption::SourceLinkLayerAddress(data),
1099                NdpOptionType::TargetLinkLayerAddress => NdpOption::TargetLinkLayerAddress(data),
1100                NdpOptionType::PrefixInformation => {
1101                    let data = Ref::<_, PrefixInformation>::from_bytes(data)
1102                        .map_err(|_| OptionParseErr)?;
1103                    NdpOption::PrefixInformation(Ref::into_ref(data))
1104                }
1105                NdpOptionType::RedirectedHeader => NdpOption::RedirectedHeader {
1106                    original_packet: &data[REDIRECTED_HEADER_OPTION_RESERVED_BYTES_LENGTH..],
1107                },
1108                NdpOptionType::Mtu => NdpOption::Mtu(NetworkEndian::read_u32(
1109                    &data[MTU_OPTION_RESERVED_BYTES_LENGTH..],
1110                )),
1111                NdpOptionType::Nonce => NdpOption::Nonce(
1112                    NdpNonce::new(data).map_err(|_: InvalidNonceError| OptionParseErr)?,
1113                ),
1114                NdpOptionType::RecursiveDnsServer => {
1115                    NdpOption::RecursiveDnsServer(RecursiveDnsServer::parse(data)?)
1116                }
1117                NdpOptionType::RouteInformation => {
1118                    // RouteInfoFixed represents the part of the RouteInformation option
1119                    // with a known and fixed length. See RFC 4191 section 2.3.
1120                    #[derive(KnownLayout, FromBytes, Immutable, Unaligned)]
1121                    #[repr(C)]
1122                    struct RouteInfoFixed {
1123                        prefix_length: u8,
1124                        preference_raw: u8,
1125                        route_lifetime_seconds: U32,
1126                    }
1127
1128                    let mut buf = &mut data;
1129
1130                    let fixed = buf.take_obj_front::<RouteInfoFixed>().ok_or(OptionParseErr)?;
1131
1132                    // The preference is preceded and followed by two 3-bit reserved fields.
1133                    let preference = super::RoutePreference::try_from(
1134                        (fixed.preference_raw & ROUTE_INFORMATION_PREFERENCE_MASK)
1135                            >> ROUTE_INFORMATION_PREFERENCE_RESERVED_BITS_RIGHT,
1136                    )
1137                    .map_err(|()| OptionParseErr)?;
1138
1139                    // We need to check whether the remaining buffer length storing the prefix is
1140                    // valid.
1141                    // From RFC 4191 section 2.3:
1142                    //   The length of the option (including the Type and Length fields) in units
1143                    //   of 8 octets.  The Length field is 1, 2, or 3 depending on the Prefix
1144                    //   Length.  If Prefix Length is greater than 64, then Length must be 3.  If
1145                    //   Prefix Length is greater than 0, then Length must be 2 or 3.  If Prefix
1146                    //   Length is zero, then Length must be 1, 2, or 3.
1147                    // The RFC refers to the length of the body which is Route Lifetime + Prefix,
1148                    // i.e. the prefix contained in the buffer can have a length from 0 to 2
1149                    // (included) octets i.e. 0 to 16 bytes.
1150                    let buf_len = buf.len();
1151                    if buf_len % OPTION_BYTES_PER_LENGTH_UNIT != 0 {
1152                        return Err(OptionParseErr);
1153                    }
1154                    let length = buf_len / OPTION_BYTES_PER_LENGTH_UNIT;
1155                    match (fixed.prefix_length, length) {
1156                        (65..=128, 2) => {}
1157                        (1..=64, 1 | 2) => {}
1158                        (0, 0 | 1 | 2) => {}
1159                        _ => return Err(OptionParseErr),
1160                    }
1161
1162                    let mut prefix_buf = [0; 16];
1163                    // It is safe to copy because we validated the remaining length of the buffer.
1164                    prefix_buf[..buf_len].copy_from_slice(&buf);
1165                    let prefix = Ipv6Addr::from_bytes(prefix_buf);
1166
1167                    NdpOption::RouteInformation(RouteInformation::new(
1168                        Subnet::new(prefix, fixed.prefix_length).map_err(|_| OptionParseErr)?,
1169                        fixed.route_lifetime_seconds.get(),
1170                        preference,
1171                    ))
1172                }
1173            };
1174
1175            Ok(Some(opt))
1176        }
1177    }
1178
1179    /// Builder for NDP options that may be found in NDP messages.
1180    #[allow(missing_docs)]
1181    #[derive(Debug)]
1182    pub enum NdpOptionBuilder<'a> {
1183        SourceLinkLayerAddress(&'a [u8]),
1184        TargetLinkLayerAddress(&'a [u8]),
1185        PrefixInformation(PrefixInformation),
1186
1187        RedirectedHeader { original_packet: &'a [u8] },
1188
1189        Mtu(u32),
1190        Nonce(NdpNonce<&'a [u8]>),
1191
1192        RouteInformation(RouteInformation),
1193        RecursiveDnsServer(RecursiveDnsServer<'a>),
1194    }
1195
1196    impl<'a> From<&NdpOptionBuilder<'a>> for NdpOptionType {
1197        fn from(v: &NdpOptionBuilder<'a>) -> Self {
1198            match v {
1199                NdpOptionBuilder::SourceLinkLayerAddress(_) => {
1200                    NdpOptionType::SourceLinkLayerAddress
1201                }
1202                NdpOptionBuilder::TargetLinkLayerAddress(_) => {
1203                    NdpOptionType::TargetLinkLayerAddress
1204                }
1205                NdpOptionBuilder::PrefixInformation(_) => NdpOptionType::PrefixInformation,
1206                NdpOptionBuilder::RedirectedHeader { .. } => NdpOptionType::RedirectedHeader,
1207                NdpOptionBuilder::Mtu { .. } => NdpOptionType::Mtu,
1208                NdpOptionBuilder::Nonce(_) => NdpOptionType::Nonce,
1209                NdpOptionBuilder::RouteInformation(_) => NdpOptionType::RouteInformation,
1210                NdpOptionBuilder::RecursiveDnsServer(_) => NdpOptionType::RecursiveDnsServer,
1211            }
1212        }
1213    }
1214
1215    impl<'a> OptionBuilder for NdpOptionBuilder<'a> {
1216        type Layout = NdpOptionsImpl;
1217
1218        fn serialized_len(&self) -> usize {
1219            match self {
1220                NdpOptionBuilder::SourceLinkLayerAddress(data)
1221                | NdpOptionBuilder::TargetLinkLayerAddress(data) => data.len(),
1222                NdpOptionBuilder::PrefixInformation(_) => PREFIX_INFORMATION_OPTION_LENGTH,
1223                NdpOptionBuilder::RedirectedHeader { original_packet } => {
1224                    REDIRECTED_HEADER_OPTION_RESERVED_BYTES_LENGTH + original_packet.len()
1225                }
1226                NdpOptionBuilder::Mtu(_) => MTU_OPTION_LENGTH,
1227                NdpOptionBuilder::Nonce(NdpNonce { nonce }) => nonce.len(),
1228                NdpOptionBuilder::RouteInformation(o) => o.serialized_len(),
1229                NdpOptionBuilder::RecursiveDnsServer(RecursiveDnsServer {
1230                    lifetime,
1231                    addresses,
1232                }) => {
1233                    RECURSIVE_DNS_SERVER_OPTION_RESERVED_BYTES_LENGTH
1234                        + core::mem::size_of_val(lifetime)
1235                        + core::mem::size_of_val(*addresses)
1236                }
1237            }
1238        }
1239
1240        fn option_kind(&self) -> u8 {
1241            NdpOptionType::from(self).into()
1242        }
1243
1244        fn serialize_into(&self, buffer: &mut [u8]) {
1245            match self {
1246                NdpOptionBuilder::SourceLinkLayerAddress(data)
1247                | NdpOptionBuilder::TargetLinkLayerAddress(data) => buffer.copy_from_slice(data),
1248                NdpOptionBuilder::PrefixInformation(pfx_info) => {
1249                    buffer.copy_from_slice(pfx_info.as_bytes());
1250                }
1251                NdpOptionBuilder::RedirectedHeader { original_packet } => {
1252                    // As per RFC 4861 section 4.6.3, the first 6 bytes following the kind and length
1253                    // bytes are reserved so we zero them. The IP header + data field immediately
1254                    // follows.
1255                    let (reserved_bytes, original_packet_bytes) =
1256                        buffer.split_at_mut(REDIRECTED_HEADER_OPTION_RESERVED_BYTES_LENGTH);
1257                    reserved_bytes
1258                        .copy_from_slice(&[0; REDIRECTED_HEADER_OPTION_RESERVED_BYTES_LENGTH]);
1259                    original_packet_bytes.copy_from_slice(original_packet);
1260                }
1261                NdpOptionBuilder::Mtu(mtu) => {
1262                    // As per RFC 4861 section 4.6.4, the first 2 bytes following the kind and length
1263                    // bytes are reserved so we zero them. The MTU field immediately follows.
1264                    let (reserved_bytes, mtu_bytes) =
1265                        buffer.split_at_mut(MTU_OPTION_RESERVED_BYTES_LENGTH);
1266                    reserved_bytes.copy_from_slice(&[0; MTU_OPTION_RESERVED_BYTES_LENGTH]);
1267                    mtu_bytes.copy_from_slice(U32::new(*mtu).as_bytes());
1268                }
1269                NdpOptionBuilder::Nonce(NdpNonce { nonce }) => {
1270                    buffer.copy_from_slice(nonce);
1271                }
1272                NdpOptionBuilder::RouteInformation(p) => p.serialize(buffer),
1273                NdpOptionBuilder::RecursiveDnsServer(RecursiveDnsServer {
1274                    lifetime,
1275                    addresses,
1276                }) => {
1277                    // As per RFC 8106 section 5.1, the first 2 bytes following the kind and length
1278                    // bytes are reserved so we zero them.
1279                    let (reserved_bytes, buffer) =
1280                        buffer.split_at_mut(RECURSIVE_DNS_SERVER_OPTION_RESERVED_BYTES_LENGTH);
1281                    reserved_bytes
1282                        .copy_from_slice(&[0; RECURSIVE_DNS_SERVER_OPTION_RESERVED_BYTES_LENGTH]);
1283
1284                    // As per RFC 8106 section 5.1, the 32 bit lifetime field immediately
1285                    // follows the reserved field, with the list of addresses immediately
1286                    // following the lifetime field.
1287                    let (lifetime_bytes, addresses_bytes) =
1288                        buffer.split_at_mut(core::mem::size_of_val(lifetime));
1289                    lifetime_bytes.copy_from_slice(U32::new(*lifetime).as_bytes());
1290                    addresses_bytes.copy_from_slice(addresses.as_bytes());
1291                }
1292            }
1293        }
1294    }
1295}
1296
1297#[cfg(test)]
1298mod tests {
1299    use byteorder::{ByteOrder, NetworkEndian};
1300    use net_types::ip::{Ip, IpAddress, Subnet};
1301    use packet::{EmptyBuf, InnerPacketBuilder, PacketBuilder, ParseBuffer, Serializer};
1302    use test_case::test_case;
1303    use zerocopy::Ref;
1304
1305    use super::*;
1306    use crate::icmp::{IcmpPacketBuilder, IcmpParseArgs};
1307    use crate::ipv6::{Ipv6Header, Ipv6Packet};
1308
1309    #[test]
1310    fn parse_serialize_redirected_header() {
1311        let expected_packet = [1, 2, 3, 4, 5, 6, 7, 8];
1312        let options =
1313            &[options::NdpOptionBuilder::RedirectedHeader { original_packet: &expected_packet }];
1314        let serialized = OptionSequenceBuilder::new(options.iter())
1315            .into_serializer()
1316            .serialize_vec_outer()
1317            .unwrap();
1318        // 8 bytes for the kind, length and reserved byes + the bytes for the packet.
1319        let mut expected = [0; 16];
1320        // The first two bytes are the kind and length bytes, respectively. This is then
1321        // followed by 6 reserved bytes.
1322        //
1323        // NDP options hold the number of bytes in units of 8 bytes.
1324        (&mut expected[..2]).copy_from_slice(&[4, 2]);
1325        (&mut expected[8..]).copy_from_slice(&expected_packet);
1326        assert_eq!(serialized.as_ref(), expected);
1327
1328        let parsed = Options::parse(&expected[..]).unwrap();
1329        let parsed = parsed.iter().collect::<Vec<options::NdpOption<'_>>>();
1330        assert_eq!(parsed.len(), 1);
1331        assert_eq!(
1332            options::NdpOption::RedirectedHeader { original_packet: &expected_packet },
1333            parsed[0]
1334        );
1335    }
1336
1337    #[test]
1338    fn parse_serialize_mtu_option() {
1339        let expected_mtu = 5781;
1340        let options = &[options::NdpOptionBuilder::Mtu(expected_mtu)];
1341        let serialized = OptionSequenceBuilder::new(options.iter())
1342            .into_serializer()
1343            .serialize_vec_outer()
1344            .unwrap();
1345        // An MTU option is exactly 8 bytes.
1346        //
1347        // The first two bytes are the kind and length bytes, respectively. This is then
1348        // followed by 2 reserved bytes.
1349        let mut expected = [5, 1, 0, 0, 0, 0, 0, 0];
1350        NetworkEndian::write_u32(&mut expected[4..], expected_mtu);
1351        assert_eq!(serialized.as_ref(), expected);
1352
1353        let parsed = Options::parse(&expected[..]).unwrap();
1354        let parsed = parsed.iter().collect::<Vec<options::NdpOption<'_>>>();
1355        assert_eq!(parsed.len(), 1);
1356        assert_eq!(options::NdpOption::Mtu(expected_mtu), parsed[0]);
1357    }
1358
1359    #[test_case(
1360        options::MIN_NONCE_LENGTH - 1 =>
1361            matches Err(options::InvalidNonceError::ResultsInNonMultipleOf8);
1362        "resulting nonce option length must be multiple of 8")]
1363    #[test_case(
1364        options::MIN_NONCE_LENGTH => matches Ok(_);
1365        "MIN_NONCE_LENGTH must validate successfully")]
1366    #[test_case(
1367        usize::from(u8::MAX) * 8 - 2 => matches Ok(_);
1368        "maximum possible nonce length must validate successfully")]
1369    #[test_case(
1370        usize::from(u8::MAX) * 8 - 2 + 8 =>
1371            matches Err(options::InvalidNonceError::TooLong);
1372        "nonce option's length must fit in u8")]
1373    fn nonce_length_validation(
1374        length: usize,
1375    ) -> Result<options::NdpNonce<&'static [u8]>, options::InvalidNonceError> {
1376        const LEN: usize = (u8::MAX as usize + 1) * 8;
1377        const BYTES: [u8; LEN] = [0u8; LEN];
1378        options::NdpNonce::new(&BYTES[..length])
1379    }
1380
1381    #[test]
1382    fn parse_serialize_nonce_option() {
1383        let expected_nonce: [u8; 6] = [1, 2, 3, 4, 5, 6];
1384        let nonce = options::NdpNonce::new(&expected_nonce[..]).expect("should be valid nonce");
1385        let options = &[options::NdpOptionBuilder::Nonce(nonce)];
1386        let serialized = OptionSequenceBuilder::new(options.iter())
1387            .into_serializer()
1388            .serialize_vec_outer()
1389            .unwrap();
1390
1391        // The first two bytes are the kind and length bytes, respectively,
1392        // followed by the nonce bytes.
1393        let mut expected_bytes: [u8; 8] = [14, 1, 0, 0, 0, 0, 0, 0];
1394        expected_bytes[2..].copy_from_slice(&expected_nonce);
1395
1396        assert_eq!(serialized.as_ref(), expected_bytes);
1397
1398        let parsed = Options::parse(&expected_bytes[..]).unwrap();
1399        let parsed = parsed.iter().collect::<Vec<options::NdpOption<'_>>>();
1400        assert_eq!(parsed.len(), 1);
1401        assert_eq!(parsed[0], options::NdpOption::Nonce(nonce));
1402    }
1403
1404    #[test]
1405    fn parse_serialize_prefix_option() {
1406        let expected_prefix_info = options::PrefixInformation::new(
1407            120,
1408            true,
1409            false,
1410            100,
1411            100,
1412            Ipv6Addr::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 168, 0, 0]),
1413        );
1414        let options = &[options::NdpOptionBuilder::PrefixInformation(expected_prefix_info.clone())];
1415        let serialized = OptionSequenceBuilder::new(options.iter())
1416            .into_serializer()
1417            .serialize_vec_outer()
1418            .unwrap();
1419        // A Prefix Information option is exactly 32 bytes.
1420        //
1421        // The first two bytes are the kind and length bytes, respectively. This is then
1422        // immediately followed by the prefix information fields.
1423        let mut expected = [0; 32];
1424        expected[0] = 3;
1425        expected[1] = 4;
1426        (&mut expected[2..]).copy_from_slice(expected_prefix_info.as_bytes());
1427        assert_eq!(serialized.as_ref(), expected);
1428
1429        let parsed = Options::parse(&expected[..]).unwrap();
1430        let parsed = parsed.iter().collect::<Vec<options::NdpOption<'_>>>();
1431        assert_eq!(parsed.len(), 1);
1432        assert_eq!(options::NdpOption::PrefixInformation(&expected_prefix_info), parsed[0]);
1433    }
1434
1435    #[test]
1436    fn parse_serialize_rdnss_option() {
1437        let test = |addrs: &[Ipv6Addr]| {
1438            let lifetime = 120;
1439            let expected_rdnss = options::RecursiveDnsServer::new(lifetime, addrs);
1440            let options = &[options::NdpOptionBuilder::RecursiveDnsServer(expected_rdnss.clone())];
1441            let serialized = OptionSequenceBuilder::new(options.iter())
1442                .into_serializer()
1443                .serialize_vec_outer()
1444                .unwrap();
1445            // 8 bytes for the kind, length, reserved and lifetime bytes + the bytes for
1446            // the addresses.
1447            let mut expected = vec![0; 8 + addrs.len() * usize::from(Ipv6Addr::BYTES)];
1448            // The first two bytes are the kind and length bytes, respectively. This is then
1449            // followed by 2 reserved bytes.
1450            //
1451            // NDP options hold the number of bytes in units of 8 bytes.
1452            (&mut expected[..4]).copy_from_slice(&[
1453                25,
1454                1 + u8::try_from(addrs.len()).unwrap() * 2,
1455                0,
1456                0,
1457            ]);
1458            // The lifetime field.
1459            NetworkEndian::write_u32(&mut expected[4..8], lifetime);
1460            // The list of addressess.
1461            (&mut expected[8..]).copy_from_slice(addrs.as_bytes());
1462            assert_eq!(serialized.as_ref(), expected.as_slice());
1463
1464            let parsed = Options::parse(&expected[..])
1465                .expect("should have parsed a valid recursive dns erver option");
1466            let parsed = parsed.iter().collect::<Vec<options::NdpOption<'_>>>();
1467            assert_eq!(parsed.len(), 1);
1468
1469            // Also check that parsing RDNSS alone works as expected.
1470            assert_eq!(
1471                options::RecursiveDnsServer::parse(&expected[2..]).expect("parsing should succeed"),
1472                expected_rdnss
1473            );
1474
1475            assert_eq!(options::NdpOption::RecursiveDnsServer(expected_rdnss), parsed[0]);
1476        };
1477        test(&[Ipv6Addr::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])]);
1478        test(&[
1479            Ipv6Addr::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
1480            Ipv6Addr::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17]),
1481        ]);
1482    }
1483
1484    #[test]
1485    fn parse_serialize_rdnss_option_error() {
1486        let addrs = [
1487            Ipv6Addr::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
1488            Ipv6Addr::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17]),
1489        ];
1490        let lifetime = 120;
1491        // 8 bytes for the kind, length, reserved and lifetime bytes + the bytes for
1492        // the addresses.
1493        let mut buf = vec![0; 8 + addrs.len() * usize::from(Ipv6Addr::BYTES)];
1494        // The first two bytes are the kind and length bytes, respectively. This is then
1495        // followed by 2 reserved bytes.
1496        //
1497        // NDP options hold the number of bytes in units of 8 bytes.
1498        (&mut buf[..4]).copy_from_slice(&[25, 1 + u8::try_from(addrs.len()).unwrap() * 2, 0, 0]);
1499        // The lifetime field.
1500        NetworkEndian::write_u32(&mut buf[4..8], lifetime);
1501        // The list of addressess.
1502        (&mut buf[8..]).copy_from_slice(addrs.as_bytes());
1503
1504        // Sanity check to make sure `buf` is normally valid.
1505        let _parsed = Options::parse(&buf[..])
1506            .expect("should have parsed a valid recursive dns erver option");
1507
1508        // The option must hold at least 1 address.
1509        let _err = Options::parse(&buf[..8]).expect_err(
1510            "should not have parsed a recursive dns server option that has no addresses",
1511        );
1512
1513        // The option must hold full IPv6 addresses.
1514        let _err = Options::parse(&buf[..buf.len()-1])
1515            .expect_err("should not have parsed a recursive dns server option that cuts off in the middle of an address");
1516
1517        // The option must only hold unicast addresses; unspecified is not allowed.
1518        (&mut buf[8..8 + usize::from(Ipv6Addr::BYTES)])
1519            .copy_from_slice(Ipv6::UNSPECIFIED_ADDRESS.as_bytes());
1520        let _parsed = Options::parse(&buf[..]).expect_err(
1521            "should not have parsed a recursive dns erver option with an unspecified address",
1522        );
1523
1524        // The option must only hold unicast addresses; multicast is not allowed.
1525        (&mut buf[8..8 + usize::from(Ipv6Addr::BYTES)])
1526            .copy_from_slice(Ipv6::ALL_NODES_LINK_LOCAL_MULTICAST_ADDRESS.as_bytes());
1527        let _parsed = Options::parse(&buf[..]).expect_err(
1528            "should not have parsed a recursive dns erver option with a multicast address",
1529        );
1530    }
1531
1532    #[test]
1533    fn parse_neighbor_solicitation() {
1534        use crate::icmp::testdata::ndp_neighbor::*;
1535        let mut buf = SOLICITATION_IP_PACKET_BYTES;
1536        let ip = buf.parse::<Ipv6Packet<_>>().unwrap();
1537        let ipv6_builder = ip.builder();
1538        let (src_ip, dst_ip) = (ip.src_ip(), ip.dst_ip());
1539        let icmp = buf
1540            .parse_with::<_, IcmpPacket<_, _, NeighborSolicitation>>(IcmpParseArgs::new(
1541                src_ip, dst_ip,
1542            ))
1543            .unwrap();
1544
1545        assert_eq!(icmp.message().target_address.ipv6_bytes(), TARGET_ADDRESS);
1546        let collected = icmp.ndp_options().iter().collect::<Vec<options::NdpOption<'_>>>();
1547        for option in collected.iter() {
1548            match option {
1549                options::NdpOption::SourceLinkLayerAddress(address) => {
1550                    assert_eq!(address, &SOURCE_LINK_LAYER_ADDRESS);
1551                }
1552                o => panic!("Found unexpected option: {:?}", o),
1553            }
1554        }
1555        let option_builders =
1556            [options::NdpOptionBuilder::SourceLinkLayerAddress(&SOURCE_LINK_LAYER_ADDRESS)];
1557        let serialized = OptionSequenceBuilder::new(option_builders.iter())
1558            .into_serializer()
1559            .wrap_in(IcmpPacketBuilder::<Ipv6, _>::new(
1560                src_ip,
1561                dst_ip,
1562                IcmpZeroCode,
1563                *icmp.message(),
1564            ))
1565            .wrap_in(ipv6_builder)
1566            .serialize_vec_outer()
1567            .unwrap()
1568            .as_ref()
1569            .to_vec();
1570        assert_eq!(&serialized, &SOLICITATION_IP_PACKET_BYTES)
1571    }
1572
1573    #[test]
1574    fn parse_neighbor_advertisement() {
1575        use crate::icmp::testdata::ndp_neighbor::*;
1576        let mut buf = ADVERTISEMENT_IP_PACKET_BYTES;
1577        let ip = buf.parse::<Ipv6Packet<_>>().unwrap();
1578        let ipv6_builder = ip.builder();
1579        let (src_ip, dst_ip) = (ip.src_ip(), ip.dst_ip());
1580        let icmp = buf
1581            .parse_with::<_, IcmpPacket<_, _, NeighborAdvertisement>>(IcmpParseArgs::new(
1582                src_ip, dst_ip,
1583            ))
1584            .unwrap();
1585        assert_eq!(icmp.message().target_address.ipv6_bytes(), TARGET_ADDRESS);
1586        assert_eq!(icmp.ndp_options().iter().count(), 0);
1587
1588        let serialized = EmptyBuf
1589            .wrap_in(IcmpPacketBuilder::<Ipv6, _>::new(
1590                src_ip,
1591                dst_ip,
1592                IcmpZeroCode,
1593                *icmp.message(),
1594            ))
1595            .wrap_in(ipv6_builder)
1596            .serialize_vec_outer()
1597            .unwrap()
1598            .as_ref()
1599            .to_vec();
1600        assert_eq!(&serialized, &ADVERTISEMENT_IP_PACKET_BYTES);
1601    }
1602
1603    #[test]
1604    fn parse_router_advertisement() {
1605        use crate::icmp::ndp::options::RouteInformation;
1606        use crate::icmp::testdata::ndp_router::*;
1607
1608        let mut buf = ADVERTISEMENT_IP_PACKET_BYTES;
1609        let ip = buf.parse::<Ipv6Packet<_>>().unwrap();
1610        let ipv6_builder = ip.builder();
1611        let (src_ip, dst_ip) = (ip.src_ip(), ip.dst_ip());
1612        let icmp = buf
1613            .parse_with::<_, IcmpPacket<_, _, RouterAdvertisement>>(IcmpParseArgs::new(
1614                src_ip, dst_ip,
1615            ))
1616            .unwrap();
1617        assert_eq!(icmp.message().current_hop_limit(), HOP_LIMIT);
1618        assert_eq!(icmp.message().router_lifetime(), LIFETIME);
1619        assert_eq!(icmp.message().reachable_time(), REACHABLE_TIME);
1620        assert_eq!(icmp.message().retransmit_timer(), RETRANS_TIMER);
1621
1622        assert_eq!(icmp.ndp_options().iter().count(), 5);
1623
1624        let collected = icmp.ndp_options().iter().collect::<Vec<options::NdpOption<'_>>>();
1625        for option in collected.iter() {
1626            match option {
1627                options::NdpOption::SourceLinkLayerAddress(address) => {
1628                    assert_eq!(address, &SOURCE_LINK_LAYER_ADDRESS);
1629                }
1630                options::NdpOption::PrefixInformation(info) => {
1631                    assert_eq!(info.on_link_flag(), PREFIX_INFO_ON_LINK_FLAG);
1632                    assert_eq!(
1633                        info.autonomous_address_configuration_flag(),
1634                        PREFIX_INFO_AUTONOMOUS_ADDRESS_CONFIGURATION_FLAG
1635                    );
1636                    assert_eq!(
1637                        info.valid_lifetime(),
1638                        NonZeroNdpLifetime::from_u32_with_infinite(
1639                            PREFIX_INFO_VALID_LIFETIME_SECONDS
1640                        )
1641                    );
1642                    assert_eq!(
1643                        info.preferred_lifetime(),
1644                        NonZeroNdpLifetime::from_u32_with_infinite(
1645                            PREFIX_INFO_PREFERRED_LIFETIME_SECONDS
1646                        )
1647                    );
1648                    assert_eq!(info.prefix_length(), PREFIX_INFO_PREFIX.prefix());
1649                    assert_eq!(info.prefix(), &PREFIX_INFO_PREFIX.network());
1650                }
1651                options::NdpOption::RouteInformation(_) => {
1652                    // Tested below
1653                }
1654                o => panic!("Found unexpected option: {:?}", o),
1655            }
1656        }
1657
1658        let mut route_information_options = collected
1659            .iter()
1660            .filter_map(|o| match o {
1661                options::NdpOption::RouteInformation(info) => Some(info),
1662                _ => None,
1663            })
1664            .collect::<Vec<&RouteInformation>>();
1665        // We must not make any assumptions on the order of received data, therefore we sort them.
1666        // From RFC 4861 section 4.6.2:
1667        //   Options in Neighbor Discovery packets can appear in any order; receivers MUST be
1668        //   prepared to process them independently of their order.
1669        route_information_options.sort_by_key(|o| o.prefix().prefix());
1670        assert_eq!(
1671            route_information_options,
1672            [
1673                &options::RouteInformation::new(
1674                    ROUTE_INFO_LOW_PREF_PREFIX,
1675                    ROUTE_INFO_LOW_PREF_VALID_LIFETIME_SECONDS,
1676                    ROUTE_INFO_LOW_PREF,
1677                ),
1678                &options::RouteInformation::new(
1679                    ROUTE_INFO_MEDIUM_PREF_PREFIX,
1680                    ROUTE_INFO_MEDIUM_PREF_VALID_LIFETIME_SECONDS,
1681                    ROUTE_INFO_MEDIUM_PREF,
1682                ),
1683                &options::RouteInformation::new(
1684                    ROUTE_INFO_HIGH_PREF_PREFIX,
1685                    ROUTE_INFO_HIGH_PREF_VALID_LIFETIME_SECONDS,
1686                    ROUTE_INFO_HIGH_PREF,
1687                )
1688            ]
1689        );
1690
1691        let option_builders = [
1692            options::NdpOptionBuilder::SourceLinkLayerAddress(&SOURCE_LINK_LAYER_ADDRESS),
1693            options::NdpOptionBuilder::PrefixInformation(options::PrefixInformation::new(
1694                PREFIX_INFO_PREFIX.prefix(),
1695                PREFIX_INFO_ON_LINK_FLAG,
1696                PREFIX_INFO_AUTONOMOUS_ADDRESS_CONFIGURATION_FLAG,
1697                PREFIX_INFO_VALID_LIFETIME_SECONDS,
1698                PREFIX_INFO_PREFERRED_LIFETIME_SECONDS,
1699                PREFIX_INFO_PREFIX.network(),
1700            )),
1701            options::NdpOptionBuilder::RouteInformation(options::RouteInformation::new(
1702                ROUTE_INFO_HIGH_PREF_PREFIX,
1703                ROUTE_INFO_HIGH_PREF_VALID_LIFETIME_SECONDS,
1704                ROUTE_INFO_HIGH_PREF,
1705            )),
1706            options::NdpOptionBuilder::RouteInformation(options::RouteInformation::new(
1707                ROUTE_INFO_MEDIUM_PREF_PREFIX,
1708                ROUTE_INFO_MEDIUM_PREF_VALID_LIFETIME_SECONDS,
1709                ROUTE_INFO_MEDIUM_PREF,
1710            )),
1711            options::NdpOptionBuilder::RouteInformation(options::RouteInformation::new(
1712                ROUTE_INFO_LOW_PREF_PREFIX,
1713                ROUTE_INFO_LOW_PREF_VALID_LIFETIME_SECONDS,
1714                ROUTE_INFO_LOW_PREF,
1715            )),
1716        ];
1717        let serialized = OptionSequenceBuilder::new(option_builders.iter())
1718            .into_serializer()
1719            .wrap_in(IcmpPacketBuilder::<Ipv6, _>::new(
1720                src_ip,
1721                dst_ip,
1722                IcmpZeroCode,
1723                *icmp.message(),
1724            ))
1725            .wrap_in(ipv6_builder)
1726            .serialize_vec_outer()
1727            .unwrap()
1728            .as_ref()
1729            .to_vec();
1730        assert_eq!(&serialized, &ADVERTISEMENT_IP_PACKET_BYTES);
1731    }
1732
1733    struct SerializeRATest {
1734        hop_limit: u8,
1735        managed_flag: bool,
1736        other_config_flag: bool,
1737        preference: RoutePreference,
1738        router_lifetime_seconds: u16,
1739        reachable_time_seconds: u32,
1740        retransmit_timer_seconds: u32,
1741    }
1742
1743    #[test_case(
1744        SerializeRATest{
1745            hop_limit: 1,
1746            managed_flag: true,
1747            other_config_flag: false,
1748            preference: RoutePreference::High,
1749            router_lifetime_seconds: 1_000,
1750            reachable_time_seconds: 1_000_000,
1751            retransmit_timer_seconds: 5,
1752        }; "test_1")]
1753    #[test_case(
1754        SerializeRATest{
1755            hop_limit: 64,
1756            managed_flag: false,
1757            other_config_flag: true,
1758            preference: RoutePreference::Low,
1759            router_lifetime_seconds: 5,
1760            reachable_time_seconds: 23425621,
1761            retransmit_timer_seconds: 13252521,
1762        }; "test_2")]
1763    fn serialize_router_advertisement(test: SerializeRATest) {
1764        let SerializeRATest {
1765            hop_limit,
1766            managed_flag,
1767            other_config_flag,
1768            preference,
1769            router_lifetime_seconds,
1770            reachable_time_seconds,
1771            retransmit_timer_seconds,
1772        } = test;
1773
1774        const SRC_IP: Ipv6Addr =
1775            Ipv6Addr::from_bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
1776        const DST_IP: Ipv6Addr =
1777            Ipv6Addr::from_bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17]);
1778        let icmp = IcmpPacketBuilder::<Ipv6, _>::new(
1779            SRC_IP,
1780            DST_IP,
1781            IcmpZeroCode,
1782            RouterAdvertisement::with_prf(
1783                hop_limit,
1784                managed_flag,
1785                other_config_flag,
1786                preference,
1787                router_lifetime_seconds,
1788                reachable_time_seconds,
1789                retransmit_timer_seconds,
1790            ),
1791        );
1792        let serialized = icmp.wrap_body(EmptyBuf).serialize_vec_outer().unwrap();
1793
1794        // As per RFC 4191 section 2.2,
1795        //
1796        //      0                   1                   2                   3
1797        //      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1798        //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1799        //     |     Type      |     Code      |          Checksum             |
1800        //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1801        //     | Cur Hop Limit |M|O|H|Prf|Resvd|       Router Lifetime         |
1802        //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1803        //     |                         Reachable Time                        |
1804        //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1805        //     |                          Retrans Timer                        |
1806        //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1807        //
1808        // As  per RFC 4861 section 4.2,
1809        //
1810        //    ICMP Fields:
1811        //
1812        //      Type           134
1813        //
1814        //      Code           0
1815        const RA_LEN: u32 = 16;
1816        let mut expected = [0; RA_LEN as usize];
1817        expected[0] = 134;
1818        expected[4] = hop_limit;
1819        if managed_flag {
1820            expected[5] |= 1 << 7;
1821        }
1822        if other_config_flag {
1823            expected[5] |= 1 << 6;
1824        }
1825        expected[5] |= u8::from(preference) << 3;
1826        let (mut router_lifetime, _rest) = Ref::<_, U16>::from_prefix(&mut expected[6..]).unwrap();
1827        router_lifetime.set(router_lifetime_seconds);
1828        let (mut reachable_time, _rest) = Ref::<_, U32>::from_prefix(&mut expected[8..]).unwrap();
1829        reachable_time.set(reachable_time_seconds);
1830        let (mut retransmit_timer, _rest) =
1831            Ref::<_, U32>::from_prefix(&mut expected[12..]).unwrap();
1832        retransmit_timer.set(retransmit_timer_seconds);
1833
1834        let mut c = internet_checksum::Checksum::new();
1835        // Checksum pseudo-header.
1836        c.add_bytes(SRC_IP.bytes());
1837        c.add_bytes(DST_IP.bytes());
1838        c.add_bytes(U32::new(RA_LEN).as_bytes());
1839        c.add_bytes(&[0, crate::ip::Ipv6Proto::Icmpv6.into()]);
1840        // Checksum actual message.
1841        c.add_bytes(&expected[..]);
1842        expected[2..4].copy_from_slice(&c.checksum()[..]);
1843
1844        assert_eq!(serialized.as_ref(), &expected[..]);
1845    }
1846
1847    struct SerializeRioTest {
1848        prefix_length: u8,
1849        route_lifetime_seconds: u32,
1850        preference: RoutePreference,
1851        expected_option_length: u8,
1852    }
1853
1854    // As per RFC 4191 section 2.3,
1855    //
1856    //    Length     8-bit unsigned integer.  The length of the option
1857    //               (including the Type and Length fields) in units of 8
1858    //               octets.  The Length field is 1, 2, or 3 depending on the
1859    //               Prefix Length.  If Prefix Length is greater than 64, then
1860    //               Length must be 3.  If Prefix Length is greater than 0,
1861    //               then Length must be 2 or 3.  If Prefix Length is zero,
1862    //               then Length must be 1, 2, or 3.
1863    #[test_case(
1864        SerializeRioTest{
1865            prefix_length: 0,
1866            route_lifetime_seconds: 1,
1867            preference: RoutePreference::High,
1868            expected_option_length: 8,
1869        }; "prefix_length_0")]
1870    #[test_case(
1871        SerializeRioTest{
1872            prefix_length: 1,
1873            route_lifetime_seconds: 1000,
1874            preference: RoutePreference::Medium,
1875            expected_option_length: 16,
1876        }; "prefix_length_1")]
1877    #[test_case(
1878        SerializeRioTest{
1879            prefix_length: 64,
1880            route_lifetime_seconds: 100000,
1881            preference: RoutePreference::Low,
1882            expected_option_length: 16,
1883        }; "prefix_length_64")]
1884    #[test_case(
1885        SerializeRioTest{
1886            prefix_length: 65,
1887            route_lifetime_seconds: 1000000,
1888            preference: RoutePreference::Medium,
1889            expected_option_length: 24,
1890        }; "prefix_length_65")]
1891    #[test_case(
1892        SerializeRioTest{
1893            prefix_length: 128,
1894            route_lifetime_seconds: 10000000,
1895            preference: RoutePreference::Medium,
1896            expected_option_length: 24,
1897        }; "prefix_length_128")]
1898    fn serialize_route_information_option(test: SerializeRioTest) {
1899        const IPV6ADDR: Ipv6Addr =
1900            Ipv6Addr::new([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]);
1901
1902        let SerializeRioTest {
1903            prefix_length,
1904            route_lifetime_seconds,
1905            preference,
1906            expected_option_length,
1907        } = test;
1908        let prefix = IPV6ADDR.mask(prefix_length);
1909
1910        let option_builders =
1911            [options::NdpOptionBuilder::RouteInformation(options::RouteInformation::new(
1912                Subnet::new(prefix, prefix_length).unwrap(),
1913                route_lifetime_seconds,
1914                preference,
1915            ))];
1916
1917        let serialized = OptionSequenceBuilder::new(option_builders.iter())
1918            .into_serializer()
1919            .serialize_vec_outer()
1920            .unwrap();
1921
1922        // As per RFC 4191 section 2.3,
1923        //
1924        //   Route Information Option
1925        //
1926        //      0                   1                   2                   3
1927        //       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1928        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1929        //      |     Type      |    Length     | Prefix Length |Resvd|Prf|Resvd|
1930        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1931        //      |                        Route Lifetime                         |
1932        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1933        //      |                   Prefix (Variable Length)                    |
1934        //      .                                                               .
1935        //      .                                                               .
1936        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1937        //
1938        //   Fields:
1939        //
1940        //   Type        24
1941        //
1942        //   Length      8-bit unsigned integer.  The length of the option
1943        //               (including the Type and Length fields) in units of 8
1944        //               octets.  The Length field is 1, 2, or 3 depending on the
1945        //               Prefix Length.  If Prefix Length is greater than 64, then
1946        //               Length must be 3.  If Prefix Length is greater than 0,
1947        //               then Length must be 2 or 3.  If Prefix Length is zero,
1948        //               then Length must be 1, 2, or 3.
1949        let mut expected = [0; 24];
1950        expected[0] = 24;
1951        expected[1] = expected_option_length / 8;
1952        expected[2] = prefix_length;
1953        expected[3] = u8::from(preference) << 3;
1954        let (mut lifetime_seconds, _rest) = Ref::<_, U32>::from_prefix(&mut expected[4..]).unwrap();
1955        lifetime_seconds.set(route_lifetime_seconds);
1956        expected[8..].copy_from_slice(prefix.bytes());
1957
1958        assert_eq!(serialized.as_ref(), &expected[..expected_option_length.into()]);
1959    }
1960
1961    #[test_case(0, None)]
1962    #[test_case(
1963        1,
1964        Some(NonZeroNdpLifetime::Finite(NonZeroDuration::new(
1965            Duration::from_secs(1),
1966        ).unwrap()))
1967    )]
1968    #[test_case(
1969        u32::MAX - 1,
1970        Some(NonZeroNdpLifetime::Finite(NonZeroDuration::new(
1971            Duration::from_secs(u64::from(u32::MAX) - 1),
1972        ).unwrap()))
1973    )]
1974    #[test_case(u32::MAX, Some(NonZeroNdpLifetime::Infinite))]
1975    fn non_zero_ndp_lifetime_non_zero_or_max_u32_from_u32_with_infinite(
1976        t: u32,
1977        expected: Option<NonZeroNdpLifetime>,
1978    ) {
1979        assert_eq!(NonZeroNdpLifetime::from_u32_with_infinite(t), expected)
1980    }
1981
1982    const MIN_NON_ZERO_DURATION: Duration = Duration::new(0, 1);
1983    #[test_case(
1984        NonZeroNdpLifetime::Infinite,
1985        NonZeroDuration::new(MIN_NON_ZERO_DURATION).unwrap(),
1986        NonZeroDuration::new(MIN_NON_ZERO_DURATION).unwrap()
1987    )]
1988    #[test_case(
1989        NonZeroNdpLifetime::Infinite,
1990        NonZeroDuration::new(Duration::MAX).unwrap(),
1991        NonZeroDuration::new(Duration::MAX).unwrap()
1992    )]
1993    #[test_case(
1994        NonZeroNdpLifetime::Finite(NonZeroDuration::new(
1995            Duration::from_secs(2)).unwrap()
1996        ),
1997        NonZeroDuration::new(Duration::from_secs(1)).unwrap(),
1998        NonZeroDuration::new(Duration::from_secs(1)).unwrap()
1999    )]
2000    #[test_case(
2001        NonZeroNdpLifetime::Finite(NonZeroDuration::new(
2002            Duration::from_secs(3)).unwrap()
2003        ),
2004        NonZeroDuration::new(Duration::from_secs(4)).unwrap(),
2005        NonZeroDuration::new(Duration::from_secs(3)).unwrap()
2006    )]
2007    fn non_zero_ndp_lifetime_min_finite_duration(
2008        lifetime: NonZeroNdpLifetime,
2009        duration: NonZeroDuration,
2010        expected: NonZeroDuration,
2011    ) {
2012        assert_eq!(lifetime.min_finite_duration(duration), expected)
2013    }
2014}