Merge remote-tracking branch 'origin/upstream'
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
new file mode 100644
index 0000000..4b22af8
--- /dev/null
+++ b/.cargo_vcs_info.json
@@ -0,0 +1,6 @@
+{
+ "git": {
+ "sha1": "ce420118efff83b47767389500ef1562f5074b55"
+ },
+ "path_in_vcs": ""
+}
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..41ca801
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+/target
+Cargo.lock
+*.pcap
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..4cf517e
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,296 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+No unreleased changes yet.
+
+## [0.11.0] - 2023-12-23
+
+### Additions
+
+- wire/ipsec: add basic IPsec parsing/emitting ([#821](https://github.com/smoltcp-rs/smoltcp/pull/821)).
+- phy: add support for `TUNSETIFF` on MIPS, PPC and SPARC ([#839](https://github.com/smoltcp-rs/smoltcp/pull/839)).
+- socket/tcp: accept FIN on zero window ([#845](https://github.com/smoltcp-rs/smoltcp/pull/845)).
+- wire/ipv6: add `is_unique_local()` to IPv6 addresses ([#862](https://github.com/smoltcp-rs/smoltcp/pull/862)).
+- wire/ipv6: add `is_global_unicast()` to IPv6 addresses ([#864](https://github.com/smoltcp-rs/smoltcp/pull/864)).
+- iface/neigh: add `fill_with_expiration` ([#871](https://github.com/smoltcp-rs/smoltcp/pull/871)).
+
+### Fixes
+
+- icmpv6: truncate packet to MTU ([#807](https://github.com/smoltcp-rs/smoltcp/pull/807), [#808](https://github.com/smoltcp-rs/smoltcp/pull/810)).
+- wire/rpl: DAO-ACK DODAG ID was wrongly read ([#824](https://github.com/smoltcp-rs/smoltcp/pull/824)).
+- socket/tcp: don't panic when calling `listen` again on the same local endpoint ([#841](https://github.com/smoltcp-rs/smoltcp/pull/841)).
+- wire/dhcpv4: don't panic when parsing addresses with incorrect amount of bytes ([#843](https://github.com/smoltcp-rs/smoltcp/pull/843)).
+- iface/ndisc: prevent ndisc when the medium is IP ([#865](https://github.com/smoltcp-rs/smoltcp/pull/865)).
+- wire/ieee802154: better parsing of security fields. Correctly parse frame type (3 bits instead of 2 bits) ([#868](https://github.com/smoltcp-rs/smoltcp/pull/864)).
+- wire/ieee802154: better handle address fields for new frame version ([#870](https://github.com/smoltcp-rs/smoltcp/pull/870)).
+- iface/tcp: don't send TCP RST with unspecified addresses ([#867](https://github.com/smoltcp-rs/smoltcp/pull/867)).
+- iface: don't handle empty packets (this would panic when reading the IP version) ([#866](https://github.com/smoltcp-rs/smoltcp/pull/866)).
+- socket/dhcp: Add an upper bound to the renew/rebind timeout in `RetryConfig` ([#835](https://github.com/smoltcp-rs/smoltcp/pull/835)).
+
+### Changes
+
+- iface: rewrite `IpPacket` such that IPv6 packets can contain owned extension headers ([#802](https://github.com/smoltcp-rs/smoltcp/pull/802)).
+- iface: remove generic `T: [u8]` in functions. This reduced the server example by 10KB ([#810](https://github.com/smoltcp-rs/smoltcp/pull/810)).
+- SocketSet: add comment about using static lifetime for SocketSets with owned storage ([#813](https://github.com/smoltcp-rs/smoltcp/pull/813)).
+- phy/RawSocket: open raw socket with `O_NONBLOCK` ([#817](https://github.com/smoltcp-rs/smoltcp/pull/817)).
+- tests/rstest: use rstest for fixture based testing ([#823](https://github.com/smoltcp-rs/smoltcp/pull/823)).
+- docs/readme: update readme about IEEE802.15.4 and 6LoWPAN ([#826](https://github.com/smoltcp-rs/smoltcp/pull/826)).
+- wire/ipv6-hbh: IPv6 HBH has owned options instead of references ([#827](https://github.com/smoltcp-rs/smoltcp/pull/827)).
+- wire/sixlowpan: 6LoWPAN is split into multiple modules ([#828](https://github.com/smoltcp-rs/smoltcp/pull/828)).
+- sockets: match the behaviour of `peek_slice` and `recv_slice` ([#834](https://github.com/smoltcp-rs/smoltcp/pull/834)).
+- dependencies: update to headpless v0.8 ([#853](https://github.com/smoltcp-rs/smoltcp/pull/853)).
+- config: make `config` constants public ([#855](https://github.com/smoltcp-rs/smoltcp/pull/855)).
+- phy/ieee802154: clarify `mtu+=2` for IEEE802.15.4 ([#857](https://github.com/smoltcp-rs/smoltcp/pull/857)).
+- sockets: `recv_slice` returns `RcvError::Truncated` when the length of the slice is smaller than the data received by the socket ([#859](https://github.com/smoltcp-rs/smoltcp/pull/859)).
+- iface/ipv6: `get_source_address` uses [RFC 6724](https://www.rfc-editor.org/rfc/rfc6724) for address selection ([#864](https://github.com/smoltcp-rs/smoltcp/pull/864)).
+- pcap: use IEEE 802.15.4 without FCS for PCAP link types ([#874](https://github.com/smoltcp-rs/smoltcp/pull/874)).
+- iface: rename `IpPacket`/`Ipv4Packet`/`Ipv6Packet` to `Pacet`/`PacketV4`/`PacketV4`. This is to remove the ambiguity with `IpPacket` in `src/wire/` ([#873](https://github.com/smoltcp-rs/smoltcp/pull/873)).
+- wire/ndisc: rewrite parse function (3.1KiB -> 1.9KiB) ([#878](https://github.com/smoltcp-rs/smoltcp/pull/878))
+- iface: Check IPv6 address after processing HBH ([#861](https://github.com/smoltcp-rs/smoltcp/pull/861))
+
+## [0.10.0] - 2023-06-26
+
+- Add optional packet metadata. Allows tracking packets by ID across the whole stack, between the `Device` impl and sockets. One application is timestamping packets with the PHY's collaboration, allowing implementing PTP (#628)
+- Work-in-progress implementation of RPL (Routing Protocol for Low-Power and Lossy Networks), commonly used for IEEE 802.15.4 / 6LoWPAN networks. Wire is mostly complete, full functionality will be in 0.11 hopefully! (#627, #766, #767, #772, #773, #777, #790, #798, #804)
+- dhcp: Add support for rebinding (#744)
+
+- iface:
+ - add support for sending to subnet-local broadcast addrs (like 192.168.1.255). (#801)
+ - Creating an interface requires passing in the time. (#799)
+ - fix wrong payload length of first IPv4 fragment (#791, #792)
+ - Don't discard from unspecified IPv4 src addresses (#787)
+
+- tcp:
+ - do not count window updates as duplicate acks. (#748)
+ - consider segments partially overlapping the window as acceptable (#749)
+ - Perform a reset() after an abort() (#788)
+
+- 6lowpan:
+ - Hop-by-Hop Header compression (#765)
+ - Routing Header compression (#770)
+
+- wire:
+ - reexport DNS opcode, rcode, flag. (#763, #806)
+ - refactor IPv6 Extension Headers to make them more consistent and easier to parse. (#781)
+ - check length field of NDISC redirected head (#784)
+
+- Modify `hardware_addr` and `neighbor_cache` to be not `Option`, add `HardwareAddress::Ip` (#745)
+- Add file descriptor support for tuntap devices, needed for the Android VPN API. (#776)
+- implement Display and Error for error types (#750, #756, #757)
+- Better defmt for Instant, Duration and Ipv6Address (#754, #758)
+- Add Hash trait for enum_with_unknown macro (#755)
+
+## [0.9.1] - 2023-02-08
+
+- iface: make MulticastError public. (#747)
+- Fix parsing of ieee802154 link layer address for NDISC options (#746)
+
+## [0.9.0] - 2023-02-06
+
+- Minimum Supported Rust Version (MSRV) **bumped** from 1.56 to 1.65
+- Added DNS client support.
+ - Add DnsSocket (#465)
+ - Add support for one-shot mDNS resolution (#669)
+- Added support for packet fragmentation and reassembly, both for IPv4 and 6LoWPAN. (#591, #580, #624, #634, #645, #653, #684)
+- Major error handling overhaul.
+ - Previously, _smoltcp_ had a single `Error` enum that all methods returned. Now methods that can fail have their own error enums, with only the actual errors they can return. (#617, #667, #730)
+ - Consuming `phy::Device` tokens is now infallible.
+ - In the case of "buffer full", `phy::Device` implementations must return `None` from the `transmit`/`receive` methods. (Previously, they could either do that, or return tokens and then return `Error::Exhausted` when consuming them. The latter wasted computation since it'd make _smoltcp_ pointlessly spend effort preparing the packet, and is now disallowed).
+ - For all other phy errors, `phy::Device` implementations should drop the packet and handle the error themselves. (Either log it and forget it, or buffer/count it and offer methods to let the user retrieve the error queue/counts.) Returning the error to have it bubble up to `Interface::poll()` is no longer supported.
+- phy: the `trait Device` now uses Generic Associated Types (GAT) for the TX and RX tokens. The main impact of this is `Device` impls can now borrow data (because previously, the`for<'a> T: Device<'a>` bounds required to workaround the lack of GATs essentially implied `T: 'static`.) (#572)
+- iface: The `Interface` API has been significantly simplified and cleaned up.
+ - The builder has been removed (#736)
+ - SocketSet and Device are now borrowed in methods that need them, instead of owning them. (#619)
+ - `Interface` now owns the list of addresses (#719), routes, neighbor cache (#722), 6LoWPAN address contexts, and fragmentation buffers (#736) instead of borrowing them with `managed`.
+ - A new compile-time configuration mechanism has been added, to configure the size of the (now owned) buffers (#742)
+- iface: Change neighbor discovery timeout from 3s to 1s, to match Linux's behavior. (#620)
+- iface: Remove implicit sized bound on device generics (#679)
+- iface/6lowpan: Add address context information for resolving 6LoWPAN addresses (#687)
+- iface/6lowpan: fix incorrect SAM value in IPHC when address is not compressed (#630)
+- iface/6lowpan: packet parsing fuzz fixes (#636)
+- socket: Add send_with to udp, raw, and icmp sockets. These methods enable reserving a packet buffer with a greater size than you need, and then shrinking the size once you know it. (#625)
+- socket: Make `trait AnySocket` object-safe (#718)
+- socket/dhcpv4: add waker support (#623)
+- socket/dhcpv4: indicate new config if there's a packet buffer provided (#685)
+- socket/dhcpv4: Use renewal time from DHCP server ACK, if given (#683)
+- socket/dhcpv4: allow for extra configuration
+ - setting arbitrary options in the request. (#650)
+ - retrieving arbitrary options from the response. (#650)
+ - setting custom parameter request list. (#650)
+ - setting custom timing for retries. (#650)
+ - Allow specifying different server/client DHCP ports (#738)
+- socket/raw: Add `peek` and `peek_slice` methods (#734)
+- socket/raw: When sending packets, send the source IP address unmodified (it was previously replaced with the interface's address if it was unspecified). (#616)
+- socket/tcp: Do not reset socket-level settings, such as keepalive, on reset (#603)
+- socket/tcp: ensure we always accept the segment at offset=0 even if the assembler is full. (#735, #452)
+- socket/tcp: Refactored assembler, now more robust and faster (#726, #735)
+- socket/udp: accept packets with checksum field set to `0`, since that means the checksum is not computed (#632)
+- wire: make many functions const (#693)
+- wire/dhcpv4: remove Option enum (#656)
+- wire/dhcpv4: use heapless Vec for DNS server list (#678)
+- wire/icmpv4: add support for TimeExceeded packets (#609)
+- wire/ip: Remove `IpRepr::Unspecified`, `IpVersion::Unspecified`, `IpAddress::Unspecified` (#579, #616)
+- wire/ip: support parsing unspecified IPv6 IpEndpoints from string (like `[::]:12345`) (#732)
+- wire/ipv6: Make Public Ipv6RoutingType (#691)
+- wire/ndisc: do not error on unrecognized options. (#737)
+- Switch to Rust 2021 edition. (#729)
+- Remove obsolete Cargo feature `rust-1_28` (#725)
+
+## [0.8.2] - 2022-11-27
+
+- tcp: Fix return value of nagle_enable ([#642](https://github.com/smoltcp-rs/smoltcp/pull/642))
+- tcp: Only clear retransmit timer when all packets are acked ([#662](https://github.com/smoltcp-rs/smoltcp/pull/662))
+- tcp: Send incomplete fin packets even if nagle enabled ([#665](https://github.com/smoltcp-rs/smoltcp/pull/665))
+- phy: Fix mtu calculation for raw_socket ([#611](https://github.com/smoltcp-rs/smoltcp/pull/611))
+- wire: Fix ipv6 contains_addr function ([#605](https://github.com/smoltcp-rs/smoltcp/pull/605))
+
+## [0.8.1] - 2022-05-12
+
+- Remove unused `rand_core` dep. ([#589](https://github.com/smoltcp-rs/smoltcp/pull/589))
+- Use socklen_t instead of u32 for RawSocket bind() parameter. Fixes build on 32bit Android. ([#593](https://github.com/smoltcp-rs/smoltcp/pull/593))
+- Propagate phy::RawSocket send errors to caller ([#588](https://github.com/smoltcp-rs/smoltcp/pull/588))
+- Fix Interface set_hardware_addr, get_hardware_addr for ieee802154/6lowpan. ([#584](https://github.com/smoltcp-rs/smoltcp/pull/584))
+
+## [0.8.0] - 2021-12-11
+
+- Minimum Supported Rust Version (MSRV) **bumped** from 1.40 to 1.56
+- Add support for IEEE 802.15.4 + 6LoWPAN medium ([#469](https://github.com/smoltcp-rs/smoltcp/pull/469))
+- Add support for IP medium ([#401](https://github.com/smoltcp-rs/smoltcp/pull/401))
+- Add `defmt` logging support ([#455](https://github.com/smoltcp-rs/smoltcp/pull/455))
+- Add RNG infrastructure ([#547](https://github.com/smoltcp-rs/smoltcp/pull/547), [#573](https://github.com/smoltcp-rs/smoltcp/pull/573))
+- Add `Context` struct that must be passed to some socket methods ([#500](https://github.com/smoltcp-rs/smoltcp/pull/500))
+- Remove `SocketSet`, sockets are owned by `Interface` now. ([#557](https://github.com/smoltcp-rs/smoltcp/pull/557), [#571](https://github.com/smoltcp-rs/smoltcp/pull/571))
+- TCP: Add Nagle's Algorithm. ([#500](https://github.com/smoltcp-rs/smoltcp/pull/500))
+- TCP crash and correctness fixes:
+ - Add Nagle's Algorithm. ([#500](https://github.com/smoltcp-rs/smoltcp/pull/500))
+ - Window scaling fixes. ([#500](https://github.com/smoltcp-rs/smoltcp/pull/500))
+ - Fix delayed ack causing ack not to be sent after 3 packets. ([#530](https://github.com/smoltcp-rs/smoltcp/pull/530))
+ - Fix RTT estimation for RTTs longer than 1 second ([#538](https://github.com/smoltcp-rs/smoltcp/pull/538))
+ - Fix infinite loop when remote side sets a MSS of 0 ([#538](https://github.com/smoltcp-rs/smoltcp/pull/538))
+ - Fix infinite loop when retransmit when remote window is 0 ([#538](https://github.com/smoltcp-rs/smoltcp/pull/538))
+ - Fix crash when receiving a FIN in SYN_SENT state ([#538](https://github.com/smoltcp-rs/smoltcp/pull/538))
+ - Fix overflow crash when receiving a wrong ACK seq in SYN_RECEIVED state ([#538](https://github.com/smoltcp-rs/smoltcp/pull/538))
+ - Fix overflow crash when initial sequence number is u32::MAX ([#538](https://github.com/smoltcp-rs/smoltcp/pull/538))
+ - Fix infinite loop on challenge ACKs ([#542](https://github.com/smoltcp-rs/smoltcp/pull/542))
+ - Reply with RST to invalid packets in SynReceived state. ([#542](https://github.com/smoltcp-rs/smoltcp/pull/542))
+ - Do not abort socket when receiving some invalid packets. ([#542](https://github.com/smoltcp-rs/smoltcp/pull/542))
+ - Make initial sequence number random. ([#547](https://github.com/smoltcp-rs/smoltcp/pull/547))
+ - Reply with RST to ACKs with invalid ackno in SYN_SENT. ([#522](https://github.com/smoltcp-rs/smoltcp/pull/522))
+- ARP fixes to deal better with broken networks:
+ - Fill cache only from ARP packets, not any packets. ([#544](https://github.com/smoltcp-rs/smoltcp/pull/544))
+ - Fill cache only from ARP packets directed at us. ([#544](https://github.com/smoltcp-rs/smoltcp/pull/544))
+ - Reject ARP packets with a source address not in the local network. ([#536](https://github.com/smoltcp-rs/smoltcp/pull/536), [#544](https://github.com/smoltcp-rs/smoltcp/pull/544))
+ - Ignore unknown ARP packets. ([#544](https://github.com/smoltcp-rs/smoltcp/pull/544))
+ - Flush neighbor cache on IP change ([#564](https://github.com/smoltcp-rs/smoltcp/pull/564))
+- UDP: Add `close()` method to unbind socket. ([#475](https://github.com/smoltcp-rs/smoltcp/pull/475), [#482](https://github.com/smoltcp-rs/smoltcp/pull/482))
+- DHCP client improvements:
+ - Refactored implementation to improve reliability and RFC compliance ([#459](https://github.com/smoltcp-rs/smoltcp/pull/459))
+ - Convert to socket ([#459](https://github.com/smoltcp-rs/smoltcp/pull/459))
+ - Added `max_lease_duration` option ([#459](https://github.com/smoltcp-rs/smoltcp/pull/459))
+ - Do not set the BROADCAST flag ([#548](https://github.com/smoltcp-rs/smoltcp/pull/548))
+ - Add option to ignore NAKs ([#548](https://github.com/smoltcp-rs/smoltcp/pull/548))
+- DHCP wire:
+ - Fix DhcpRepr::buffer_len not accounting for lease time, router and subnet options ([#478](https://github.com/smoltcp-rs/smoltcp/pull/478))
+ - Emit DNS servers in DhcpRepr ([#510](https://github.com/smoltcp-rs/smoltcp/pull/510))
+ - Fix incorrect bit for BROADCAST flag ([#548](https://github.com/smoltcp-rs/smoltcp/pull/548))
+- Improve resilience against packet ingress processing errors ([#281](https://github.com/smoltcp-rs/smoltcp/pull/281), [#483](https://github.com/smoltcp-rs/smoltcp/pull/483))
+- Implement `std::error::Error` for `smoltcp::Error` ([#485](https://github.com/smoltcp-rs/smoltcp/pull/485))
+- Update `managed` from 0.7 to 0.8 ([442](https://github.com/smoltcp-rs/smoltcp/pull/442))
+- Fix incorrect timestamp in PCAP captures ([#513](https://github.com/smoltcp-rs/smoltcp/pull/513))
+- Use microseconds instead of milliseconds in Instant and Duration ([#514](https://github.com/smoltcp-rs/smoltcp/pull/514))
+- Expose inner `Device` in `PcapWriter` ([#524](https://github.com/smoltcp-rs/smoltcp/pull/524))
+- Fix assert with any_ip + broadcast dst_addr. ([#533](https://github.com/smoltcp-rs/smoltcp/pull/533), [#534](https://github.com/smoltcp-rs/smoltcp/pull/534))
+- Simplify PcapSink trait ([#535](https://github.com/smoltcp-rs/smoltcp/pull/535))
+- Fix wrong operation order in FuzzInjector ([#525](https://github.com/smoltcp-rs/smoltcp/pull/525), [#535](https://github.com/smoltcp-rs/smoltcp/pull/535))
+
+## [0.7.5] - 2021-06-28
+
+- dhcpv4: emit DNS servers in repr ([#505](https://github.com/smoltcp-rs/smoltcp/pull/505))
+
+## [0.7.4] - 2021-06-11
+
+- tcp: fix "subtract sequence numbers with underflow" on remote window shrink. ([#490](https://github.com/smoltcp-rs/smoltcp/pull/490))
+- tcp: fix subtract with overflow when receiving a SYNACK with unincremented ACK number. ([#491](https://github.com/smoltcp-rs/smoltcp/pull/491))
+- tcp: use nonzero initial sequence number to workaround misbehaving servers. ([#492](https://github.com/smoltcp-rs/smoltcp/pull/492))
+
+## [0.7.3] - 2021-05-29
+
+- Fix "unused attribute" error in recent nightlies.
+
+## [0.7.2] - 2021-05-29
+
+- iface: check for ipv4 subnet broadcast addrs everywhere ([#462](https://github.com/smoltcp-rs/smoltcp/pull/462))
+- dhcp: always send parameter_request_list. ([#456](https://github.com/smoltcp-rs/smoltcp/pull/456))
+- dhcp: Clear expiration time on reset. ([#456](https://github.com/smoltcp-rs/smoltcp/pull/456))
+- phy: fix FaultInjector returning a too big buffer when simulating a drop on tx ([#463](https://github.com/smoltcp-rs/smoltcp/pull/463))
+- tcp rtte: fix "attempt to multiply with overflow". ([#476](https://github.com/smoltcp-rs/smoltcp/pull/476))
+- tcp: LastAck should only change to Closed on ack of fin. ([#477](https://github.com/smoltcp-rs/smoltcp/pull/477))
+- wire/dhcpv4: account for lease time, router and subnet options in DhcpRepr::buffer_len ([#478](https://github.com/smoltcp-rs/smoltcp/pull/478))
+
+## [0.7.1] - 2021-03-27
+
+- ndisc: Fix NeighborSolicit incorrectly asking for src addr instead of dst addr ([419](https://github.com/smoltcp-rs/smoltcp/pull/419))
+- dhcpv4: respect lease time from the server instead of renewing every 60 seconds. ([437](https://github.com/smoltcp-rs/smoltcp/pull/437))
+- Fix build errors due to invalid combinations of features ([416](https://github.com/smoltcp-rs/smoltcp/pull/416), [447](https://github.com/smoltcp-rs/smoltcp/pull/447))
+- wire/ipv4: make some functions const ([420](https://github.com/smoltcp-rs/smoltcp/pull/420))
+- phy: fix BPF on OpenBSD ([421](https://github.com/smoltcp-rs/smoltcp/pull/421), [427](https://github.com/smoltcp-rs/smoltcp/pull/427))
+- phy: enable RawSocket, TapInterface on Android ([435](https://github.com/smoltcp-rs/smoltcp/pull/435))
+- phy: fix phy_wait for waits longer than 1 second ([449](https://github.com/smoltcp-rs/smoltcp/pull/449))
+
+## [0.7.0] - 2021-01-20
+
+- Minimum Supported Rust Version (MSRV) **bumped** from 1.36 to 1.40
+
+### New features
+- tcp: Allow distinguishing between graceful (FIN) and ungraceful (RST) close. On graceful close, `recv()` now returns `Error::Finished`. On ungraceful close, `Error::Illegal` is returned, as before. ([351](https://github.com/smoltcp-rs/smoltcp/pull/351))
+- sockets: Add support for attaching async/await Wakers to sockets. Wakers are woken on socket state changes. ([394](https://github.com/smoltcp-rs/smoltcp/pull/394))
+- tcp: Set retransmission timeout based on an RTT estimation, instead of the previously fixed 100ms. This improves performance on high-latency links, such as mobile networks. ([406](https://github.com/smoltcp-rs/smoltcp/pull/406))
+- tcp: add Delayed ACK support. On by default, with a 10ms delay. ([404](https://github.com/smoltcp-rs/smoltcp/pull/404))
+- ip: Process broadcast packets directed to the subnet's broadcast address, such as 192.168.1.255. Previously broadcast packets were
+only processed when directed to the 255.255.255.255 address. ([377](https://github.com/smoltcp-rs/smoltcp/pull/377))
+
+### Fixes
+- udp,raw,icmp: Fix packet buffer panic caused by large payload ([332](https://github.com/smoltcp-rs/smoltcp/pull/332))
+- dhcpv4: use offered ip in requested ip option ([310](https://github.com/smoltcp-rs/smoltcp/pull/310))
+- dhcpv4: Re-export dhcp::clientv4::Config
+- dhcpv4: Enable `proto-dhcpv4` feature by default. ([327](https://github.com/smoltcp-rs/smoltcp/pull/327))
+- ethernet,arp: Allow for ARP retry during egress ([368](https://github.com/smoltcp-rs/smoltcp/pull/368))
+- ethernet,arp: Only limit the neighbor cache rate after sending a request packet ([369](https://github.com/smoltcp-rs/smoltcp/pull/369))
+- tcp: use provided ip for TcpSocket::connect instead of 0.0.0.0 ([329](https://github.com/smoltcp-rs/smoltcp/pull/329))
+- tcp: Accept data packets in FIN_WAIT_2 state. ([350](https://github.com/smoltcp-rs/smoltcp/pull/350))
+- tcp: Always send updated ack number in `ack_reply()`. ([353](https://github.com/smoltcp-rs/smoltcp/pull/353))
+- tcp: allow sending ACKs in FinWait2 state. ([388](https://github.com/smoltcp-rs/smoltcp/pull/388))
+- tcp: fix racey simultaneous close not sending FIN. ([398](https://github.com/smoltcp-rs/smoltcp/pull/398))
+- tcp: Do not send window updates in states that shouldn't do so ([360](https://github.com/smoltcp-rs/smoltcp/pull/360))
+- tcp: Return RST to unexpected ACK in SYN-SENT state. ([367](https://github.com/smoltcp-rs/smoltcp/pull/367))
+- tcp: Take MTU into account during TcpSocket dispatch. ([384](https://github.com/smoltcp-rs/smoltcp/pull/384))
+- tcp: don't send data outside the remote window ([387](https://github.com/smoltcp-rs/smoltcp/pull/387))
+- phy: Take Ethernet header into account for MTU of RawSocket and TapInterface. ([393](https://github.com/smoltcp-rs/smoltcp/pull/393))
+- phy: add null terminator to c-string passed to libc API ([372](https://github.com/smoltcp-rs/smoltcp/pull/372))
+
+### Quality of Life™ improvements
+- Update to Rust 2018 edition ([396](https://github.com/smoltcp-rs/smoltcp/pull/396))
+- Migrate CI to Github Actions ([390](https://github.com/smoltcp-rs/smoltcp/pull/390))
+- Fix clippy lints, enforce clippy in CI ([395](https://github.com/smoltcp-rs/smoltcp/pull/395), [402](https://github.com/smoltcp-rs/smoltcp/pull/402), [403](https://github.com/smoltcp-rs/smoltcp/pull/403), [405](https://github.com/smoltcp-rs/smoltcp/pull/405), [407](https://github.com/smoltcp-rs/smoltcp/pull/407))
+- Use #[non_exhaustive] for enums and structs ([409](https://github.com/smoltcp-rs/smoltcp/pull/409), [411](https://github.com/smoltcp-rs/smoltcp/pull/411))
+- Simplify lifetime parameters of sockets, SocketSet, EthernetInterface ([410](https://github.com/smoltcp-rs/smoltcp/pull/410), [413](https://github.com/smoltcp-rs/smoltcp/pull/413))
+
+[Unreleased]: https://github.com/smoltcp-rs/smoltcp/compare/v0.11.0...HEAD
+[0.11.0]: https://github.com/smoltcp-rs/smoltcp/compare/v0.10.0...v0.11.0
+[0.10.0]: https://github.com/smoltcp-rs/smoltcp/compare/v0.9.1...v0.10.0
+[0.9.1]: https://github.com/smoltcp-rs/smoltcp/compare/v0.9.0...v0.9.1
+[0.9.0]: https://github.com/smoltcp-rs/smoltcp/compare/v0.8.2...v0.9.0
+[0.8.2]: https://github.com/smoltcp-rs/smoltcp/compare/v0.8.1...v0.8.2
+[0.8.1]: https://github.com/smoltcp-rs/smoltcp/compare/v0.8.0...v0.8.1
+[0.8.0]: https://github.com/smoltcp-rs/smoltcp/compare/v0.7.0...v0.8.0
+[0.7.5]: https://github.com/smoltcp-rs/smoltcp/compare/v0.7.4...v0.7.5
+[0.7.4]: https://github.com/smoltcp-rs/smoltcp/compare/v0.7.3...v0.7.4
+[0.7.3]: https://github.com/smoltcp-rs/smoltcp/compare/v0.7.2...v0.7.3
+[0.7.2]: https://github.com/smoltcp-rs/smoltcp/compare/v0.7.1...v0.7.2
+[0.7.1]: https://github.com/smoltcp-rs/smoltcp/compare/v0.7.0...v0.7.1
+[0.7.0]: https://github.com/smoltcp-rs/smoltcp/compare/v0.6.0...v0.7.0
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..d67ab14
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,466 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.65"
+name = "smoltcp"
+version = "0.11.0"
+authors = ["whitequark <whitequark@whitequark.org>"]
+autoexamples = false
+description = "A TCP/IP stack designed for bare-metal, real-time systems without a heap."
+homepage = "https://github.com/smoltcp-rs/smoltcp"
+documentation = "https://docs.rs/smoltcp/"
+readme = "README.md"
+keywords = [
+ "ip",
+ "tcp",
+ "udp",
+ "ethernet",
+ "network",
+]
+categories = [
+ "embedded",
+ "network-programming",
+]
+license = "0BSD"
+repository = "https://github.com/smoltcp-rs/smoltcp.git"
+
+[profile.release]
+debug = 2
+
+[[example]]
+name = "packet2pcap"
+path = "utils/packet2pcap.rs"
+required-features = ["std"]
+
+[[example]]
+name = "tcpdump"
+required-features = [
+ "std",
+ "phy-raw_socket",
+ "proto-ipv4",
+]
+
+[[example]]
+name = "httpclient"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "proto-ipv6",
+ "socket-tcp",
+]
+
+[[example]]
+name = "ping"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "proto-ipv6",
+ "socket-icmp",
+]
+
+[[example]]
+name = "server"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "socket-tcp",
+ "socket-udp",
+]
+
+[[example]]
+name = "client"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "socket-tcp",
+ "socket-udp",
+]
+
+[[example]]
+name = "loopback"
+required-features = [
+ "log",
+ "medium-ethernet",
+ "proto-ipv4",
+ "socket-tcp",
+]
+
+[[example]]
+name = "multicast"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "proto-igmp",
+ "socket-udp",
+]
+
+[[example]]
+name = "benchmark"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "socket-raw",
+ "socket-udp",
+]
+
+[[example]]
+name = "dhcp_client"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "proto-dhcpv4",
+ "socket-raw",
+]
+
+[[example]]
+name = "sixlowpan"
+required-features = [
+ "std",
+ "medium-ieee802154",
+ "phy-raw_socket",
+ "proto-sixlowpan",
+ "proto-sixlowpan-fragmentation",
+ "socket-udp",
+]
+
+[[example]]
+name = "sixlowpan_benchmark"
+required-features = [
+ "std",
+ "medium-ieee802154",
+ "phy-raw_socket",
+ "proto-sixlowpan",
+ "proto-sixlowpan-fragmentation",
+ "socket-udp",
+]
+
+[[example]]
+name = "dns"
+required-features = [
+ "std",
+ "medium-ethernet",
+ "medium-ip",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "socket-dns",
+]
+
+[dependencies.bitflags]
+version = "1.0"
+default-features = false
+
+[dependencies.byteorder]
+version = "1.0"
+default-features = false
+
+[dependencies.cfg-if]
+version = "1.0.0"
+
+[dependencies.defmt]
+version = "0.3"
+optional = true
+
+[dependencies.heapless]
+version = "0.8"
+
+[dependencies.libc]
+version = "0.2.18"
+optional = true
+
+[dependencies.log]
+version = "0.4.4"
+optional = true
+default-features = false
+
+[dependencies.managed]
+version = "0.8"
+features = ["map"]
+default-features = false
+
+[dev-dependencies.env_logger]
+version = "0.10"
+
+[dev-dependencies.getopts]
+version = "0.2"
+
+[dev-dependencies.rand]
+version = "0.8"
+
+[dev-dependencies.rstest]
+version = "0.17"
+
+[dev-dependencies.url]
+version = "2.0"
+
+[features]
+_proto-fragmentation = []
+alloc = [
+ "managed/alloc",
+ "defmt?/alloc",
+]
+assembler-max-segment-count-1 = []
+assembler-max-segment-count-16 = []
+assembler-max-segment-count-2 = []
+assembler-max-segment-count-3 = []
+assembler-max-segment-count-32 = []
+assembler-max-segment-count-4 = []
+assembler-max-segment-count-8 = []
+async = []
+default = [
+ "std",
+ "log",
+ "medium-ethernet",
+ "medium-ip",
+ "medium-ieee802154",
+ "phy-raw_socket",
+ "phy-tuntap_interface",
+ "proto-ipv4",
+ "proto-igmp",
+ "proto-dhcpv4",
+ "proto-ipv6",
+ "proto-dns",
+ "proto-ipv4-fragmentation",
+ "proto-sixlowpan-fragmentation",
+ "socket-raw",
+ "socket-icmp",
+ "socket-udp",
+ "socket-tcp",
+ "socket-dhcpv4",
+ "socket-dns",
+ "socket-mdns",
+ "packetmeta-id",
+ "async",
+]
+defmt = [
+ "dep:defmt",
+ "heapless/defmt-03",
+]
+dns-max-name-size-128 = []
+dns-max-name-size-255 = []
+dns-max-name-size-64 = []
+dns-max-result-count-1 = []
+dns-max-result-count-16 = []
+dns-max-result-count-2 = []
+dns-max-result-count-3 = []
+dns-max-result-count-32 = []
+dns-max-result-count-4 = []
+dns-max-result-count-8 = []
+dns-max-server-count-1 = []
+dns-max-server-count-16 = []
+dns-max-server-count-2 = []
+dns-max-server-count-3 = []
+dns-max-server-count-32 = []
+dns-max-server-count-4 = []
+dns-max-server-count-8 = []
+fragmentation-buffer-size-1024 = []
+fragmentation-buffer-size-1500 = []
+fragmentation-buffer-size-16384 = []
+fragmentation-buffer-size-2048 = []
+fragmentation-buffer-size-256 = []
+fragmentation-buffer-size-32768 = []
+fragmentation-buffer-size-4096 = []
+fragmentation-buffer-size-512 = []
+fragmentation-buffer-size-65536 = []
+fragmentation-buffer-size-8192 = []
+iface-max-addr-count-1 = []
+iface-max-addr-count-2 = []
+iface-max-addr-count-3 = []
+iface-max-addr-count-4 = []
+iface-max-addr-count-5 = []
+iface-max-addr-count-6 = []
+iface-max-addr-count-7 = []
+iface-max-addr-count-8 = []
+iface-max-multicast-group-count-1 = []
+iface-max-multicast-group-count-1024 = []
+iface-max-multicast-group-count-128 = []
+iface-max-multicast-group-count-16 = []
+iface-max-multicast-group-count-2 = []
+iface-max-multicast-group-count-256 = []
+iface-max-multicast-group-count-3 = []
+iface-max-multicast-group-count-32 = []
+iface-max-multicast-group-count-4 = []
+iface-max-multicast-group-count-5 = []
+iface-max-multicast-group-count-512 = []
+iface-max-multicast-group-count-6 = []
+iface-max-multicast-group-count-64 = []
+iface-max-multicast-group-count-7 = []
+iface-max-multicast-group-count-8 = []
+iface-max-route-count-1 = []
+iface-max-route-count-1024 = []
+iface-max-route-count-128 = []
+iface-max-route-count-16 = []
+iface-max-route-count-2 = []
+iface-max-route-count-256 = []
+iface-max-route-count-3 = []
+iface-max-route-count-32 = []
+iface-max-route-count-4 = []
+iface-max-route-count-5 = []
+iface-max-route-count-512 = []
+iface-max-route-count-6 = []
+iface-max-route-count-64 = []
+iface-max-route-count-7 = []
+iface-max-route-count-8 = []
+iface-max-sixlowpan-address-context-count-1 = []
+iface-max-sixlowpan-address-context-count-1024 = []
+iface-max-sixlowpan-address-context-count-128 = []
+iface-max-sixlowpan-address-context-count-16 = []
+iface-max-sixlowpan-address-context-count-2 = []
+iface-max-sixlowpan-address-context-count-256 = []
+iface-max-sixlowpan-address-context-count-3 = []
+iface-max-sixlowpan-address-context-count-32 = []
+iface-max-sixlowpan-address-context-count-4 = []
+iface-max-sixlowpan-address-context-count-5 = []
+iface-max-sixlowpan-address-context-count-512 = []
+iface-max-sixlowpan-address-context-count-6 = []
+iface-max-sixlowpan-address-context-count-64 = []
+iface-max-sixlowpan-address-context-count-7 = []
+iface-max-sixlowpan-address-context-count-8 = []
+iface-neighbor-cache-count-1 = []
+iface-neighbor-cache-count-1024 = []
+iface-neighbor-cache-count-128 = []
+iface-neighbor-cache-count-16 = []
+iface-neighbor-cache-count-2 = []
+iface-neighbor-cache-count-256 = []
+iface-neighbor-cache-count-3 = []
+iface-neighbor-cache-count-32 = []
+iface-neighbor-cache-count-4 = []
+iface-neighbor-cache-count-5 = []
+iface-neighbor-cache-count-512 = []
+iface-neighbor-cache-count-6 = []
+iface-neighbor-cache-count-64 = []
+iface-neighbor-cache-count-7 = []
+iface-neighbor-cache-count-8 = []
+ipv6-hbh-max-options-1 = []
+ipv6-hbh-max-options-16 = []
+ipv6-hbh-max-options-2 = []
+ipv6-hbh-max-options-3 = []
+ipv6-hbh-max-options-32 = []
+ipv6-hbh-max-options-4 = []
+ipv6-hbh-max-options-8 = []
+medium-ethernet = ["socket"]
+medium-ieee802154 = [
+ "socket",
+ "proto-sixlowpan",
+]
+medium-ip = ["socket"]
+packetmeta-id = []
+phy-raw_socket = [
+ "std",
+ "libc",
+]
+phy-tuntap_interface = [
+ "std",
+ "libc",
+ "medium-ethernet",
+]
+proto-dhcpv4 = ["proto-ipv4"]
+proto-dns = []
+proto-igmp = ["proto-ipv4"]
+proto-ipsec = [
+ "proto-ipsec-ah",
+ "proto-ipsec-esp",
+]
+proto-ipsec-ah = []
+proto-ipsec-esp = []
+proto-ipv4 = []
+proto-ipv4-fragmentation = [
+ "proto-ipv4",
+ "_proto-fragmentation",
+]
+proto-ipv6 = []
+proto-ipv6-fragmentation = [
+ "proto-ipv6",
+ "_proto-fragmentation",
+]
+proto-ipv6-hbh = ["proto-ipv6"]
+proto-ipv6-routing = ["proto-ipv6"]
+proto-rpl = [
+ "proto-ipv6-hbh",
+ "proto-ipv6-routing",
+]
+proto-sixlowpan = ["proto-ipv6"]
+proto-sixlowpan-fragmentation = [
+ "proto-sixlowpan",
+ "_proto-fragmentation",
+]
+reassembly-buffer-count-1 = []
+reassembly-buffer-count-16 = []
+reassembly-buffer-count-2 = []
+reassembly-buffer-count-3 = []
+reassembly-buffer-count-32 = []
+reassembly-buffer-count-4 = []
+reassembly-buffer-count-8 = []
+reassembly-buffer-size-1024 = []
+reassembly-buffer-size-1500 = []
+reassembly-buffer-size-16384 = []
+reassembly-buffer-size-2048 = []
+reassembly-buffer-size-256 = []
+reassembly-buffer-size-32768 = []
+reassembly-buffer-size-4096 = []
+reassembly-buffer-size-512 = []
+reassembly-buffer-size-65536 = []
+reassembly-buffer-size-8192 = []
+rpl-parents-buffer-count-16 = []
+rpl-parents-buffer-count-2 = []
+rpl-parents-buffer-count-32 = []
+rpl-parents-buffer-count-4 = []
+rpl-parents-buffer-count-8 = []
+rpl-relations-buffer-count-1 = []
+rpl-relations-buffer-count-128 = []
+rpl-relations-buffer-count-16 = []
+rpl-relations-buffer-count-2 = []
+rpl-relations-buffer-count-32 = []
+rpl-relations-buffer-count-4 = []
+rpl-relations-buffer-count-64 = []
+rpl-relations-buffer-count-8 = []
+socket = []
+socket-dhcpv4 = [
+ "socket",
+ "medium-ethernet",
+ "proto-dhcpv4",
+]
+socket-dns = [
+ "socket",
+ "proto-dns",
+]
+socket-icmp = ["socket"]
+socket-mdns = ["socket-dns"]
+socket-raw = ["socket"]
+socket-tcp = ["socket"]
+socket-udp = ["socket"]
+std = [
+ "managed/std",
+ "alloc",
+]
+verbose = []
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
new file mode 100644
index 0000000..b3cd9c9
--- /dev/null
+++ b/Cargo.toml.orig
@@ -0,0 +1,305 @@
+[package]
+name = "smoltcp"
+version = "0.11.0"
+edition = "2021"
+rust-version = "1.65"
+authors = ["whitequark <whitequark@whitequark.org>"]
+description = "A TCP/IP stack designed for bare-metal, real-time systems without a heap."
+documentation = "https://docs.rs/smoltcp/"
+homepage = "https://github.com/smoltcp-rs/smoltcp"
+repository = "https://github.com/smoltcp-rs/smoltcp.git"
+readme = "README.md"
+keywords = ["ip", "tcp", "udp", "ethernet", "network"]
+categories = ["embedded", "network-programming"]
+license = "0BSD"
+# Each example should have an explicit `[[example]]` section here to
+# ensure that the correct features are enabled.
+autoexamples = false
+
+[dependencies]
+managed = { version = "0.8", default-features = false, features = ["map"] }
+byteorder = { version = "1.0", default-features = false }
+log = { version = "0.4.4", default-features = false, optional = true }
+libc = { version = "0.2.18", optional = true }
+bitflags = { version = "1.0", default-features = false }
+defmt = { version = "0.3", optional = true }
+cfg-if = "1.0.0"
+heapless = "0.8"
+
+[dev-dependencies]
+env_logger = "0.10"
+getopts = "0.2"
+rand = "0.8"
+url = "2.0"
+rstest = "0.17"
+
+[features]
+std = ["managed/std", "alloc"]
+alloc = ["managed/alloc", "defmt?/alloc"]
+verbose = []
+defmt = ["dep:defmt", "heapless/defmt-03"]
+"medium-ethernet" = ["socket"]
+"medium-ip" = ["socket"]
+"medium-ieee802154" = ["socket", "proto-sixlowpan"]
+
+"phy-raw_socket" = ["std", "libc"]
+"phy-tuntap_interface" = ["std", "libc", "medium-ethernet"]
+
+"proto-ipv4" = []
+"proto-ipv4-fragmentation" = ["proto-ipv4", "_proto-fragmentation"]
+"proto-igmp" = ["proto-ipv4"]
+"proto-dhcpv4" = ["proto-ipv4"]
+"proto-ipv6" = []
+"proto-ipv6-hbh" = ["proto-ipv6"]
+"proto-ipv6-fragmentation" = ["proto-ipv6", "_proto-fragmentation"]
+"proto-ipv6-routing" = ["proto-ipv6"]
+"proto-rpl" = ["proto-ipv6-hbh", "proto-ipv6-routing"]
+"proto-sixlowpan" = ["proto-ipv6"]
+"proto-sixlowpan-fragmentation" = ["proto-sixlowpan", "_proto-fragmentation"]
+"proto-dns" = []
+"proto-ipsec" = ["proto-ipsec-ah", "proto-ipsec-esp"]
+"proto-ipsec-ah" = []
+"proto-ipsec-esp" = []
+
+"socket" = []
+"socket-raw" = ["socket"]
+"socket-udp" = ["socket"]
+"socket-tcp" = ["socket"]
+"socket-icmp" = ["socket"]
+"socket-dhcpv4" = ["socket", "medium-ethernet", "proto-dhcpv4"]
+"socket-dns" = ["socket", "proto-dns"]
+"socket-mdns" = ["socket-dns"]
+
+"packetmeta-id" = []
+
+"async" = []
+
+default = [
+ "std", "log", # needed for `cargo test --no-default-features --features default` :/
+ "medium-ethernet", "medium-ip", "medium-ieee802154",
+ "phy-raw_socket", "phy-tuntap_interface",
+ "proto-ipv4", "proto-igmp", "proto-dhcpv4", "proto-ipv6", "proto-dns",
+ "proto-ipv4-fragmentation", "proto-sixlowpan-fragmentation",
+ "socket-raw", "socket-icmp", "socket-udp", "socket-tcp", "socket-dhcpv4", "socket-dns", "socket-mdns",
+ "packetmeta-id", "async"
+]
+
+# Private features
+# Features starting with "_" are considered private. They should not be enabled by
+# other crates, and they are not considered semver-stable.
+
+"_proto-fragmentation" = []
+
+# BEGIN AUTOGENERATED CONFIG FEATURES
+# Generated by gen_config.py. DO NOT EDIT.
+iface-max-addr-count-1 = []
+iface-max-addr-count-2 = [] # Default
+iface-max-addr-count-3 = []
+iface-max-addr-count-4 = []
+iface-max-addr-count-5 = []
+iface-max-addr-count-6 = []
+iface-max-addr-count-7 = []
+iface-max-addr-count-8 = []
+
+iface-max-multicast-group-count-1 = []
+iface-max-multicast-group-count-2 = []
+iface-max-multicast-group-count-3 = []
+iface-max-multicast-group-count-4 = [] # Default
+iface-max-multicast-group-count-5 = []
+iface-max-multicast-group-count-6 = []
+iface-max-multicast-group-count-7 = []
+iface-max-multicast-group-count-8 = []
+iface-max-multicast-group-count-16 = []
+iface-max-multicast-group-count-32 = []
+iface-max-multicast-group-count-64 = []
+iface-max-multicast-group-count-128 = []
+iface-max-multicast-group-count-256 = []
+iface-max-multicast-group-count-512 = []
+iface-max-multicast-group-count-1024 = []
+
+iface-max-sixlowpan-address-context-count-1 = []
+iface-max-sixlowpan-address-context-count-2 = []
+iface-max-sixlowpan-address-context-count-3 = []
+iface-max-sixlowpan-address-context-count-4 = [] # Default
+iface-max-sixlowpan-address-context-count-5 = []
+iface-max-sixlowpan-address-context-count-6 = []
+iface-max-sixlowpan-address-context-count-7 = []
+iface-max-sixlowpan-address-context-count-8 = []
+iface-max-sixlowpan-address-context-count-16 = []
+iface-max-sixlowpan-address-context-count-32 = []
+iface-max-sixlowpan-address-context-count-64 = []
+iface-max-sixlowpan-address-context-count-128 = []
+iface-max-sixlowpan-address-context-count-256 = []
+iface-max-sixlowpan-address-context-count-512 = []
+iface-max-sixlowpan-address-context-count-1024 = []
+
+iface-neighbor-cache-count-1 = []
+iface-neighbor-cache-count-2 = []
+iface-neighbor-cache-count-3 = []
+iface-neighbor-cache-count-4 = [] # Default
+iface-neighbor-cache-count-5 = []
+iface-neighbor-cache-count-6 = []
+iface-neighbor-cache-count-7 = []
+iface-neighbor-cache-count-8 = []
+iface-neighbor-cache-count-16 = []
+iface-neighbor-cache-count-32 = []
+iface-neighbor-cache-count-64 = []
+iface-neighbor-cache-count-128 = []
+iface-neighbor-cache-count-256 = []
+iface-neighbor-cache-count-512 = []
+iface-neighbor-cache-count-1024 = []
+
+iface-max-route-count-1 = []
+iface-max-route-count-2 = [] # Default
+iface-max-route-count-3 = []
+iface-max-route-count-4 = []
+iface-max-route-count-5 = []
+iface-max-route-count-6 = []
+iface-max-route-count-7 = []
+iface-max-route-count-8 = []
+iface-max-route-count-16 = []
+iface-max-route-count-32 = []
+iface-max-route-count-64 = []
+iface-max-route-count-128 = []
+iface-max-route-count-256 = []
+iface-max-route-count-512 = []
+iface-max-route-count-1024 = []
+
+fragmentation-buffer-size-256 = []
+fragmentation-buffer-size-512 = []
+fragmentation-buffer-size-1024 = []
+fragmentation-buffer-size-1500 = [] # Default
+fragmentation-buffer-size-2048 = []
+fragmentation-buffer-size-4096 = []
+fragmentation-buffer-size-8192 = []
+fragmentation-buffer-size-16384 = []
+fragmentation-buffer-size-32768 = []
+fragmentation-buffer-size-65536 = []
+
+assembler-max-segment-count-1 = []
+assembler-max-segment-count-2 = []
+assembler-max-segment-count-3 = []
+assembler-max-segment-count-4 = [] # Default
+assembler-max-segment-count-8 = []
+assembler-max-segment-count-16 = []
+assembler-max-segment-count-32 = []
+
+reassembly-buffer-size-256 = []
+reassembly-buffer-size-512 = []
+reassembly-buffer-size-1024 = []
+reassembly-buffer-size-1500 = [] # Default
+reassembly-buffer-size-2048 = []
+reassembly-buffer-size-4096 = []
+reassembly-buffer-size-8192 = []
+reassembly-buffer-size-16384 = []
+reassembly-buffer-size-32768 = []
+reassembly-buffer-size-65536 = []
+
+reassembly-buffer-count-1 = [] # Default
+reassembly-buffer-count-2 = []
+reassembly-buffer-count-3 = []
+reassembly-buffer-count-4 = []
+reassembly-buffer-count-8 = []
+reassembly-buffer-count-16 = []
+reassembly-buffer-count-32 = []
+
+ipv6-hbh-max-options-1 = [] # Default
+ipv6-hbh-max-options-2 = []
+ipv6-hbh-max-options-3 = []
+ipv6-hbh-max-options-4 = []
+ipv6-hbh-max-options-8 = []
+ipv6-hbh-max-options-16 = []
+ipv6-hbh-max-options-32 = []
+
+dns-max-result-count-1 = [] # Default
+dns-max-result-count-2 = []
+dns-max-result-count-3 = []
+dns-max-result-count-4 = []
+dns-max-result-count-8 = []
+dns-max-result-count-16 = []
+dns-max-result-count-32 = []
+
+dns-max-server-count-1 = [] # Default
+dns-max-server-count-2 = []
+dns-max-server-count-3 = []
+dns-max-server-count-4 = []
+dns-max-server-count-8 = []
+dns-max-server-count-16 = []
+dns-max-server-count-32 = []
+
+dns-max-name-size-64 = []
+dns-max-name-size-128 = []
+dns-max-name-size-255 = [] # Default
+
+rpl-relations-buffer-count-1 = []
+rpl-relations-buffer-count-2 = []
+rpl-relations-buffer-count-4 = []
+rpl-relations-buffer-count-8 = []
+rpl-relations-buffer-count-16 = [] # Default
+rpl-relations-buffer-count-32 = []
+rpl-relations-buffer-count-64 = []
+rpl-relations-buffer-count-128 = []
+
+rpl-parents-buffer-count-2 = []
+rpl-parents-buffer-count-4 = []
+rpl-parents-buffer-count-8 = [] # Default
+rpl-parents-buffer-count-16 = []
+rpl-parents-buffer-count-32 = []
+
+# END AUTOGENERATED CONFIG FEATURES
+
+[[example]]
+name = "packet2pcap"
+path = "utils/packet2pcap.rs"
+required-features = ["std"]
+
+[[example]]
+name = "tcpdump"
+required-features = ["std", "phy-raw_socket", "proto-ipv4"]
+
+[[example]]
+name = "httpclient"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "proto-ipv6", "socket-tcp"]
+
+[[example]]
+name = "ping"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "proto-ipv6", "socket-icmp"]
+
+[[example]]
+name = "server"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "socket-tcp", "socket-udp"]
+
+[[example]]
+name = "client"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "socket-tcp", "socket-udp"]
+
+[[example]]
+name = "loopback"
+required-features = ["log", "medium-ethernet", "proto-ipv4", "socket-tcp"]
+
+[[example]]
+name = "multicast"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "proto-igmp", "socket-udp"]
+
+[[example]]
+name = "benchmark"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "socket-raw", "socket-udp"]
+
+[[example]]
+name = "dhcp_client"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "proto-dhcpv4", "socket-raw"]
+
+[[example]]
+name = "sixlowpan"
+required-features = ["std", "medium-ieee802154", "phy-raw_socket", "proto-sixlowpan", "proto-sixlowpan-fragmentation", "socket-udp"]
+
+[[example]]
+name = "sixlowpan_benchmark"
+required-features = ["std", "medium-ieee802154", "phy-raw_socket", "proto-sixlowpan", "proto-sixlowpan-fragmentation", "socket-udp"]
+
+[[example]]
+name = "dns"
+required-features = ["std", "medium-ethernet", "medium-ip", "phy-tuntap_interface", "proto-ipv4", "socket-dns"]
+
+[profile.release]
+debug = 2
diff --git a/LICENSE b/LICENSE
new file mode 120000
index 0000000..26f20b7
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1 @@
+LICENSE-0BSD.txt
\ No newline at end of file
diff --git a/LICENSE-0BSD.txt b/LICENSE-0BSD.txt
new file mode 100644
index 0000000..427fafa
--- /dev/null
+++ b/LICENSE-0BSD.txt
@@ -0,0 +1,13 @@
+Copyright (C) 2016 whitequark@whitequark.org
+
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
diff --git a/METADATA b/METADATA
new file mode 100644
index 0000000..ce996b4
--- /dev/null
+++ b/METADATA
@@ -0,0 +1,20 @@
+name: "smoltcp"
+description: "A TCP/IP stack designed for bare-metal, real-time systems without a heap."
+third_party {
+ identifier {
+ type: "crates.io"
+ value: "smoltcp"
+ }
+ identifier {
+ type: "Archive"
+ value: "https://static.crates.io/crates/smoltcp/smoltcp-0.11.0.crate"
+ primary_source: true
+ }
+ version: "0.11.0"
+ license_type: PERMISSIVE
+ last_upgrade_date {
+ year: 2024
+ month: 2
+ day: 17
+ }
+}
diff --git a/MODULE_LICENSE_ZERO_BSD b/MODULE_LICENSE_ZERO_BSD
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_ZERO_BSD
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..48bea6e
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,2 @@
+# Bug component: 688011
+include platform/prebuilts/rust:main:/OWNERS
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..74fa161
--- /dev/null
+++ b/README.md
@@ -0,0 +1,560 @@
+# smoltcp
+
+[](https://docs.rs/smoltcp)
+[](https://crates.io/crates/smoltcp)
+[](https://crates.io/crates/smoltcp)
+[](https://matrix.to/#/#smoltcp:matrix.org)
+[](https://codecov.io/github/smoltcp-rs/smoltcp)
+
+_smoltcp_ is a standalone, event-driven TCP/IP stack that is designed for bare-metal,
+real-time systems. Its design goals are simplicity and robustness. Its design anti-goals
+include complicated compile-time computations, such as macro or type tricks, even
+at cost of performance degradation.
+
+_smoltcp_ does not need heap allocation *at all*, is [extensively documented][docs],
+and compiles on stable Rust 1.65 and later.
+
+_smoltcp_ achieves [~Gbps of throughput](#examplesbenchmarkrs) when tested against
+the Linux TCP stack in loopback mode.
+
+[docs]: https://docs.rs/smoltcp/
+
+## Features
+
+_smoltcp_ is missing many widely deployed features, usually because no one implemented them yet.
+To set expectations right, both implemented and omitted features are listed.
+
+### Media layer
+
+There are 3 supported mediums.
+
+* Ethernet
+ * Regular Ethernet II frames are supported.
+ * Unicast, broadcast and multicast packets are supported.
+ * ARP packets (including gratuitous requests and replies) are supported.
+ * ARP requests are sent at a rate not exceeding one per second.
+ * Cached ARP entries expire after one minute.
+ * 802.3 frames and 802.1Q are **not** supported.
+ * Jumbo frames are **not** supported.
+* IP
+ * Unicast, broadcast and multicast packets are supported.
+* IEEE 802.15.4
+ * Only support for data frames.
+
+### IP layer
+
+#### IPv4
+
+ * IPv4 header checksum is generated and validated.
+ * IPv4 time-to-live value is configurable per socket, set to 64 by default.
+ * IPv4 default gateway is supported.
+ * Routing outgoing IPv4 packets is supported, through a default gateway or a CIDR route table.
+ * IPv4 fragmentation and reassembly is supported.
+ * IPv4 options are **not** supported and are silently ignored.
+
+#### IPv6
+
+ * IPv6 hop-limit value is configurable per socket, set to 64 by default.
+ * Routing outgoing IPv6 packets is supported, through a default gateway or a CIDR route table.
+ * IPv6 hop-by-hop header is supported.
+ * ICMPv6 parameter problem message is generated in response to an unrecognized IPv6 next header.
+ * ICMPv6 parameter problem message is **not** generated in response to an unknown IPv6
+ hop-by-hop option.
+
+#### 6LoWPAN
+
+ * Implementation of [RFC6282](https://tools.ietf.org/rfc/rfc6282.txt).
+ * Fragmentation is supported, as defined in [RFC4944](https://tools.ietf.org/rfc/rfc4944.txt).
+ * UDP header compression/decompression is supported.
+ * Extension header compression/decompression is supported.
+ * Uncompressed IPv6 Extension Headers are **not** supported.
+
+### IP multicast
+
+#### IGMP
+
+The IGMPv1 and IGMPv2 protocols are supported, and IPv4 multicast is available.
+
+ * Membership reports are sent in response to membership queries at
+ equal intervals equal to the maximum response time divided by the
+ number of groups to be reported.
+
+### ICMP layer
+
+#### ICMPv4
+
+The ICMPv4 protocol is supported, and ICMP sockets are available.
+
+ * ICMPv4 header checksum is supported.
+ * ICMPv4 echo replies are generated in response to echo requests.
+ * ICMP sockets can listen to ICMPv4 Port Unreachable messages, or any ICMPv4 messages with
+ a given IPv4 identifier field.
+ * ICMPv4 protocol unreachable messages are **not** passed to higher layers when received.
+ * ICMPv4 parameter problem messages are **not** generated.
+
+#### ICMPv6
+
+The ICMPv6 protocol is supported, and ICMP sockets are available.
+
+ * ICMPv6 header checksum is supported.
+ * ICMPv6 echo replies are generated in response to echo requests.
+ * ICMPv6 protocol unreachable messages are **not** passed to higher layers when received.
+
+#### NDISC
+
+ * Neighbor Advertisement messages are generated in response to Neighbor Solicitations.
+ * Router Advertisement messages are **not** generated or read.
+ * Router Solicitation messages are **not** generated or read.
+ * Redirected Header messages are **not** generated or read.
+
+### UDP layer
+
+The UDP protocol is supported over IPv4 and IPv6, and UDP sockets are available.
+
+ * Header checksum is always generated and validated.
+ * In response to a packet arriving at a port without a listening socket,
+ an ICMP destination unreachable message is generated.
+
+### TCP layer
+
+The TCP protocol is supported over IPv4 and IPv6, and server and client TCP sockets are available.
+
+ * Header checksum is generated and validated.
+ * Maximum segment size is negotiated.
+ * Window scaling is negotiated.
+ * Multiple packets are transmitted without waiting for an acknowledgement.
+ * Reassembly of out-of-order segments is supported, with no more than 4 or 32 gaps in sequence space.
+ * Keep-alive packets may be sent at a configurable interval.
+ * Retransmission timeout starts at at an estimate of RTT, and doubles every time.
+ * Time-wait timeout has a fixed interval of 10 s.
+ * User timeout has a configurable interval.
+ * Delayed acknowledgements are supported, with configurable delay.
+ * Nagle's algorithm is implemented.
+ * Selective acknowledgements are **not** implemented.
+ * Silly window syndrome avoidance is **not** implemented.
+ * Congestion control is **not** implemented.
+ * Timestamping is **not** supported.
+ * Urgent pointer is **ignored**.
+ * Probing Zero Windows is **not** implemented.
+ * Packetization Layer Path MTU Discovery [PLPMTU](https://tools.ietf.org/rfc/rfc4821.txt) is **not** implemented.
+
+## Installation
+
+To use the _smoltcp_ library in your project, add the following to `Cargo.toml`:
+
+```toml
+[dependencies]
+smoltcp = "0.10.0"
+```
+
+The default configuration assumes a hosted environment, for ease of evaluation.
+You probably want to disable default features and configure them one by one:
+
+```toml
+[dependencies]
+smoltcp = { version = "0.10.0", default-features = false, features = ["log"] }
+```
+
+## Feature flags
+
+### Feature `std`
+
+The `std` feature enables use of objects and slices owned by the networking stack through a
+dependency on `std::boxed::Box` and `std::vec::Vec`.
+
+This feature is enabled by default.
+
+### Feature `alloc`
+
+The `alloc` feature enables use of objects owned by the networking stack through a dependency
+on collections from the `alloc` crate. This only works on nightly rustc.
+
+This feature is disabled by default.
+
+### Feature `log`
+
+The `log` feature enables logging of events within the networking stack through
+the [log crate][log]. Normal events (e.g. buffer level or TCP state changes) are emitted with
+the TRACE log level. Exceptional events (e.g. malformed packets) are emitted with
+the DEBUG log level.
+
+[log]: https://crates.io/crates/log
+
+This feature is enabled by default.
+
+### Feature `defmt`
+
+The `defmt` feature enables logging of events with the [defmt crate][defmt].
+
+[defmt]: https://crates.io/crates/defmt
+
+This feature is disabled by default, and cannot be used at the same time as `log`.
+
+### Feature `verbose`
+
+The `verbose` feature enables logging of events where the logging itself may incur very high
+overhead. For example, emitting a log line every time an application reads or writes as little
+as 1 octet from a socket is likely to overwhelm the application logic unless a `BufReader`
+or `BufWriter` is used, which are of course not available on heap-less systems.
+
+This feature is disabled by default.
+
+### Features `phy-raw_socket` and `phy-tuntap_interface`
+
+Enable `smoltcp::phy::RawSocket` and `smoltcp::phy::TunTapInterface`, respectively.
+
+These features are enabled by default.
+
+### Features `socket-raw`, `socket-udp`, `socket-tcp`, `socket-icmp`, `socket-dhcpv4`, `socket-dns`
+
+Enable the corresponding socket type.
+
+These features are enabled by default.
+
+### Features `proto-ipv4`, `proto-ipv6` and `proto-sixlowpan`
+
+Enable [IPv4], [IPv6] and [6LoWPAN] respectively.
+
+[IPv4]: https://tools.ietf.org/rfc/rfc791.txt
+[IPv6]: https://tools.ietf.org/rfc/rfc8200.txt
+[6LoWPAN]: https://tools.ietf.org/rfc/rfc6282.txt
+
+## Configuration
+
+_smoltcp_ has some configuration settings that are set at compile time, affecting sizes
+and counts of buffers.
+
+They can be set in two ways:
+
+- Via Cargo features: enable a feature like `<name>-<value>`. `name` must be in lowercase and
+use dashes instead of underscores. For example. `iface-max-addr-count-3`. Only a selection of values
+is available, check `Cargo.toml` for the list.
+- Via environment variables at build time: set the variable named `SMOLTCP_<value>`. For example
+`SMOLTCP_IFACE_MAX_ADDR_COUNT=3 cargo build`. You can also set them in the `[env]` section of `.cargo/config.toml`.
+Any value can be set, unlike with Cargo features.
+
+Environment variables take precedence over Cargo features. If two Cargo features are enabled for the same setting
+with different values, compilation fails.
+
+### `IFACE_MAX_ADDR_COUNT`
+
+Max amount of IP addresses that can be assigned to one interface (counting both IPv4 and IPv6 addresses). Default: 2.
+
+### `IFACE_MAX_MULTICAST_GROUP_COUNT`
+
+Max amount of multicast groups that can be joined by one interface. Default: 4.
+
+### `IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT`
+
+Max amount of 6LoWPAN address contexts that can be assigned to one interface. Default: 4.
+
+### `IFACE_NEIGHBOR_CACHE_COUNT`
+
+Amount of "IP address -> hardware address" entries the neighbor cache (also known as the "ARP cache" or the "ARP table") holds. Default: 4.
+
+### `IFACE_MAX_ROUTE_COUNT`
+
+Max amount of routes that can be added to one interface. Includes the default route. Includes both IPv4 and IPv6. Default: 2.
+
+### `FRAGMENTATION_BUFFER_SIZE`
+
+Size of the buffer used for fragmenting outgoing packets larger than the MTU. Packets larger than this setting will be dropped instead of fragmented. Default: 1500.
+
+### `ASSEMBLER_MAX_SEGMENT_COUNT`
+
+Maximum number of non-contiguous segments the assembler can hold. Used for both packet reassembly and TCP stream reassembly. Default: 4.
+
+### `REASSEMBLY_BUFFER_SIZE`
+
+Size of the buffer used for reassembling (de-fragmenting) incoming packets. If the reassembled packet is larger than this setting, it will be dropped instead of reassembled. Default: 1500.
+
+### `REASSEMBLY_BUFFER_COUNT`
+
+Number of reassembly buffers, i.e how many different incoming packets can be reassembled at the same time. Default: 1.
+
+### `DNS_MAX_RESULT_COUNT`
+
+Maximum amount of address results for a given DNS query that will be kept. For example, if this is set to 2 and the queried name has 4 `A` records, only the first 2 will be returned. Default: 1.
+
+### `DNS_MAX_SERVER_COUNT`
+
+Maximum amount of DNS servers that can be configured in one DNS socket. Default: 1.
+
+### `DNS_MAX_NAME_SIZE`
+
+Maximum length of DNS names that can be queried. Default: 255.
+
+### IPV6_HBH_MAX_OPTIONS
+
+The maximum amount of parsed options the IPv6 Hop-by-Hop header can hold. Default: 1.
+
+## Hosted usage examples
+
+_smoltcp_, being a freestanding networking stack, needs to be able to transmit and receive
+raw frames. For testing purposes, we will use a regular OS, and run _smoltcp_ in
+a userspace process. Only Linux is supported (right now).
+
+On \*nix OSes, transmitting and receiving raw frames normally requires superuser privileges, but
+on Linux it is possible to create a _persistent tap interface_ that can be manipulated by
+a specific user:
+
+```sh
+sudo ip tuntap add name tap0 mode tap user $USER
+sudo ip link set tap0 up
+sudo ip addr add 192.168.69.100/24 dev tap0
+sudo ip -6 addr add fe80::100/64 dev tap0
+sudo ip -6 addr add fdaa::100/64 dev tap0
+sudo ip -6 route add fe80::/64 dev tap0
+sudo ip -6 route add fdaa::/64 dev tap0
+```
+
+It's possible to let _smoltcp_ access Internet by enabling routing for the tap interface:
+
+```sh
+sudo iptables -t nat -A POSTROUTING -s 192.168.69.0/24 -j MASQUERADE
+sudo sysctl net.ipv4.ip_forward=1
+sudo ip6tables -t nat -A POSTROUTING -s fdaa::/64 -j MASQUERADE
+sudo sysctl -w net.ipv6.conf.all.forwarding=1
+
+# Some distros have a default policy of DROP. This allows the traffic.
+sudo iptables -A FORWARD -i tap0 -s 192.168.69.0/24 -j ACCEPT
+sudo iptables -A FORWARD -o tap0 -d 192.168.69.0/24 -j ACCEPT
+```
+
+### Bridged connection
+
+Instead of the routed connection above, you may also set up a bridged (switched)
+connection. This will make smoltcp speak directly to your LAN, with real ARP, etc.
+It is needed to run the DHCP example.
+
+NOTE: In this case, the examples' IP configuration must match your LAN's!
+
+NOTE: this ONLY works with actual wired Ethernet connections. It
+will NOT work on a WiFi connection.
+
+```sh
+# Replace with your wired Ethernet interface name
+ETH=enp0s20f0u1u1
+
+sudo modprobe bridge
+sudo modprobe br_netfilter
+
+sudo sysctl -w net.bridge.bridge-nf-call-arptables=0
+sudo sysctl -w net.bridge.bridge-nf-call-ip6tables=0
+sudo sysctl -w net.bridge.bridge-nf-call-iptables=0
+
+sudo ip tuntap add name tap0 mode tap user $USER
+sudo brctl addbr br0
+sudo brctl addif br0 tap0
+sudo brctl addif br0 $ETH
+sudo ip link set tap0 up
+sudo ip link set $ETH up
+sudo ip link set br0 up
+
+# This connects your host system to the internet, so you can use it
+# at the same time you run the examples.
+sudo dhcpcd br0
+```
+
+To tear down:
+
+```
+sudo killall dhcpcd
+sudo ip link set br0 down
+sudo brctl delbr br0
+```
+
+### Fault injection
+
+In order to demonstrate the response of _smoltcp_ to adverse network conditions, all examples
+implement fault injection, available through command-line options:
+
+ * The `--drop-chance` option randomly drops packets, with given probability in percents.
+ * The `--corrupt-chance` option randomly mutates one octet in a packet, with given
+ probability in percents.
+ * The `--size-limit` option drops packets larger than specified size.
+ * The `--tx-rate-limit` and `--rx-rate-limit` options set the amount of tokens for
+ a token bucket rate limiter, in packets per bucket.
+ * The `--shaping-interval` option sets the refill interval of a token bucket rate limiter,
+ in milliseconds.
+
+A good starting value for `--drop-chance` and `--corrupt-chance` is 15%. A good starting
+value for `--?x-rate-limit` is 4 and `--shaping-interval` is 50 ms.
+
+Note that packets dropped by the fault injector still get traced;
+the `rx: randomly dropping a packet` message indicates that the packet *above* it got dropped,
+and the `tx: randomly dropping a packet` message indicates that the packet *below* it was.
+
+### Packet dumps
+
+All examples provide a `--pcap` option that writes a [libpcap] file containing a view of every
+packet as it is seen by _smoltcp_.
+
+[libpcap]: https://wiki.wireshark.org/Development/LibpcapFileFormat
+
+### examples/tcpdump.rs
+
+_examples/tcpdump.rs_ is a tiny clone of the _tcpdump_ utility.
+
+Unlike the rest of the examples, it uses raw sockets, and so it can be used on regular interfaces,
+e.g. `eth0` or `wlan0`, as well as the `tap0` interface we've created above.
+
+Read its [source code](/examples/tcpdump.rs), then run it as:
+
+```sh
+cargo build --example tcpdump
+sudo ./target/debug/examples/tcpdump eth0
+```
+
+### examples/httpclient.rs
+
+_examples/httpclient.rs_ emulates a network host that can initiate HTTP requests.
+
+The host is assigned the hardware address `02-00-00-00-00-02`, IPv4 address `192.168.69.1`, and IPv6 address `fdaa::1`.
+
+Read its [source code](/examples/httpclient.rs), then run it as:
+
+```sh
+cargo run --example httpclient -- --tap tap0 ADDRESS URL
+```
+
+For example:
+
+```sh
+cargo run --example httpclient -- --tap tap0 93.184.216.34 http://example.org/
+```
+
+or:
+
+```sh
+cargo run --example httpclient -- --tap tap0 2606:2800:220:1:248:1893:25c8:1946 http://example.org/
+```
+
+It connects to the given address (not a hostname) and URL, and prints any returned response data.
+The TCP socket buffers are limited to 1024 bytes to make packet traces more interesting.
+
+### examples/ping.rs
+
+_examples/ping.rs_ implements a minimal version of the `ping` utility using raw sockets.
+
+The host is assigned the hardware address `02-00-00-00-00-02` and IPv4 address `192.168.69.1`.
+
+Read its [source code](/examples/ping.rs), then run it as:
+
+```sh
+cargo run --example ping -- --tap tap0 ADDRESS
+```
+
+It sends a series of 4 ICMP ECHO\_REQUEST packets to the given address at one second intervals and
+prints out a status line on each valid ECHO\_RESPONSE received.
+
+The first ECHO\_REQUEST packet is expected to be lost since arp\_cache is empty after startup;
+the ECHO\_REQUEST packet is dropped and an ARP request is sent instead.
+
+Currently, netmasks are not implemented, and so the only address this example can reach
+is the other endpoint of the tap interface, `192.168.69.100`. It cannot reach itself because
+packets entering a tap interface do not loop back.
+
+### examples/server.rs
+
+_examples/server.rs_ emulates a network host that can respond to basic requests.
+
+The host is assigned the hardware address `02-00-00-00-00-01` and IPv4 address `192.168.69.1`.
+
+Read its [source code](/examples/server.rs), then run it as:
+
+```sh
+cargo run --example server -- --tap tap0
+```
+
+It responds to:
+
+ * pings (`ping 192.168.69.1`);
+ * UDP packets on port 6969 (`socat stdio udp4-connect:192.168.69.1:6969 <<<"abcdefg"`),
+ where it will respond with reversed chunks of the input indefinitely;
+ * TCP connections on port 6969 (`socat stdio tcp4-connect:192.168.69.1:6969`),
+ where it will respond "hello" to any incoming connection and immediately close it;
+ * TCP connections on port 6970 (`socat stdio tcp4-connect:192.168.69.1:6970 <<<"abcdefg"`),
+ where it will respond with reversed chunks of the input indefinitely.
+ * TCP connections on port 6971 (`socat stdio tcp4-connect:192.168.69.1:6971 </dev/urandom`),
+ which will sink data. Also, keep-alive packets (every 1 s) and a user timeout (at 2 s)
+ are enabled on this port; try to trigger them using fault injection.
+ * TCP connections on port 6972 (`socat stdio tcp4-connect:192.168.69.1:6972 >/dev/null`),
+ which will source data.
+
+Except for the socket on port 6971. the buffers are only 64 bytes long, for convenience
+of testing resource exhaustion conditions.
+
+### examples/client.rs
+
+_examples/client.rs_ emulates a network host that can initiate basic requests.
+
+The host is assigned the hardware address `02-00-00-00-00-02` and IPv4 address `192.168.69.2`.
+
+Read its [source code](/examples/client.rs), then run it as:
+
+```sh
+cargo run --example client -- --tap tap0 ADDRESS PORT
+```
+
+It connects to the given address (not a hostname) and port (e.g. `socat stdio tcp4-listen:1234`),
+and will respond with reversed chunks of the input indefinitely.
+
+### examples/benchmark.rs
+
+_examples/benchmark.rs_ implements a simple throughput benchmark.
+
+Read its [source code](/examples/benchmark.rs), then run it as:
+
+```sh
+cargo run --release --example benchmark -- --tap tap0 [reader|writer]
+```
+
+It establishes a connection to itself from a different thread and reads or writes a large amount
+of data in one direction.
+
+A typical result (achieved on a Intel Core i7-7500U CPU and a Linux 4.9.65 x86_64 kernel running
+on a Dell XPS 13 9360 laptop) is as follows:
+
+```
+$ cargo run -q --release --example benchmark -- --tap tap0 reader
+throughput: 2.556 Gbps
+$ cargo run -q --release --example benchmark -- --tap tap0 writer
+throughput: 5.301 Gbps
+```
+
+## Bare-metal usage examples
+
+Examples that use no services from the host OS are necessarily less illustrative than examples
+that do. Because of this, only one such example is provided.
+
+### examples/loopback.rs
+
+_examples/loopback.rs_ sets up _smoltcp_ to talk with itself via a loopback interface.
+Although it does not require `std`, this example still requires the `alloc` feature to run, as well as `log`, `proto-ipv4` and `socket-tcp`.
+
+Read its [source code](/examples/loopback.rs), then run it without `std`:
+
+```sh
+cargo run --example loopback --no-default-features --features="log proto-ipv4 socket-tcp alloc"
+```
+
+... or with `std` (in this case the features don't have to be explicitly listed):
+
+```sh
+cargo run --example loopback -- --pcap loopback.pcap
+```
+
+It opens a server and a client TCP socket, and transfers a chunk of data. You can examine
+the packet exchange by opening `loopback.pcap` in [Wireshark].
+
+If the `std` feature is enabled, it will print logs and packet dumps, and fault injection
+is possible; otherwise, nothing at all will be displayed and no options are accepted.
+
+[wireshark]: https://wireshark.org
+
+## License
+
+_smoltcp_ is distributed under the terms of 0-clause BSD license.
+
+See [LICENSE-0BSD](LICENSE-0BSD.txt) for details.
diff --git a/benches/bench.rs b/benches/bench.rs
new file mode 100644
index 0000000..2738840
--- /dev/null
+++ b/benches/bench.rs
@@ -0,0 +1,117 @@
+#![feature(test)]
+
+mod wire {
+ use smoltcp::phy::ChecksumCapabilities;
+ use smoltcp::wire::{IpAddress, IpProtocol};
+ #[cfg(feature = "proto-ipv4")]
+ use smoltcp::wire::{Ipv4Address, Ipv4Packet, Ipv4Repr};
+ #[cfg(feature = "proto-ipv6")]
+ use smoltcp::wire::{Ipv6Address, Ipv6Packet, Ipv6Repr};
+ use smoltcp::wire::{TcpControl, TcpPacket, TcpRepr, TcpSeqNumber};
+ use smoltcp::wire::{UdpPacket, UdpRepr};
+
+ extern crate test;
+
+ #[cfg(feature = "proto-ipv6")]
+ const SRC_ADDR: IpAddress = IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+ ]));
+ #[cfg(feature = "proto-ipv6")]
+ const DST_ADDR: IpAddress = IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
+ ]));
+
+ #[cfg(all(not(feature = "proto-ipv6"), feature = "proto-ipv4"))]
+ const SRC_ADDR: IpAddress = IpAddress::Ipv4(Ipv4Address([192, 168, 1, 1]));
+ #[cfg(all(not(feature = "proto-ipv6"), feature = "proto-ipv4"))]
+ const DST_ADDR: IpAddress = IpAddress::Ipv4(Ipv4Address([192, 168, 1, 2]));
+
+ #[bench]
+ #[cfg(any(feature = "proto-ipv6", feature = "proto-ipv4"))]
+ fn bench_emit_tcp(b: &mut test::Bencher) {
+ static PAYLOAD_BYTES: [u8; 400] = [0x2a; 400];
+ let repr = TcpRepr {
+ src_port: 48896,
+ dst_port: 80,
+ control: TcpControl::Syn,
+ seq_number: TcpSeqNumber(0x01234567),
+ ack_number: None,
+ window_len: 0x0123,
+ window_scale: None,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &PAYLOAD_BYTES,
+ };
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+
+ b.iter(|| {
+ let mut packet = TcpPacket::new_unchecked(&mut bytes);
+ repr.emit(
+ &mut packet,
+ &SRC_ADDR,
+ &DST_ADDR,
+ &ChecksumCapabilities::default(),
+ );
+ });
+ }
+
+ #[bench]
+ #[cfg(any(feature = "proto-ipv6", feature = "proto-ipv4"))]
+ fn bench_emit_udp(b: &mut test::Bencher) {
+ static PAYLOAD_BYTES: [u8; 400] = [0x2a; 400];
+ let repr = UdpRepr {
+ src_port: 48896,
+ dst_port: 80,
+ };
+ let mut bytes = vec![0xa5; repr.header_len() + PAYLOAD_BYTES.len()];
+
+ b.iter(|| {
+ let mut packet = UdpPacket::new_unchecked(&mut bytes);
+ repr.emit(
+ &mut packet,
+ &SRC_ADDR,
+ &DST_ADDR,
+ PAYLOAD_BYTES.len(),
+ |buf| buf.copy_from_slice(&PAYLOAD_BYTES),
+ &ChecksumCapabilities::default(),
+ );
+ });
+ }
+
+ #[bench]
+ #[cfg(feature = "proto-ipv4")]
+ fn bench_emit_ipv4(b: &mut test::Bencher) {
+ let repr = Ipv4Repr {
+ src_addr: Ipv4Address([192, 168, 1, 1]),
+ dst_addr: Ipv4Address([192, 168, 1, 2]),
+ next_header: IpProtocol::Tcp,
+ payload_len: 100,
+ hop_limit: 64,
+ };
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+
+ b.iter(|| {
+ let mut packet = Ipv4Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet, &ChecksumCapabilities::default());
+ });
+ }
+
+ #[bench]
+ #[cfg(feature = "proto-ipv6")]
+ fn bench_emit_ipv6(b: &mut test::Bencher) {
+ let repr = Ipv6Repr {
+ src_addr: Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]),
+ dst_addr: Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]),
+ next_header: IpProtocol::Tcp,
+ payload_len: 100,
+ hop_limit: 64,
+ };
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+
+ b.iter(|| {
+ let mut packet = Ipv6Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet);
+ });
+ }
+}
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000..54662ed
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,104 @@
+use std::collections::HashMap;
+use std::fmt::Write;
+use std::path::PathBuf;
+use std::{env, fs};
+
+static CONFIGS: &[(&str, usize)] = &[
+ // BEGIN AUTOGENERATED CONFIG FEATURES
+ // Generated by gen_config.py. DO NOT EDIT.
+ ("IFACE_MAX_ADDR_COUNT", 2),
+ ("IFACE_MAX_MULTICAST_GROUP_COUNT", 4),
+ ("IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT", 4),
+ ("IFACE_NEIGHBOR_CACHE_COUNT", 4),
+ ("IFACE_MAX_ROUTE_COUNT", 2),
+ ("FRAGMENTATION_BUFFER_SIZE", 1500),
+ ("ASSEMBLER_MAX_SEGMENT_COUNT", 4),
+ ("REASSEMBLY_BUFFER_SIZE", 1500),
+ ("REASSEMBLY_BUFFER_COUNT", 1),
+ ("IPV6_HBH_MAX_OPTIONS", 1),
+ ("DNS_MAX_RESULT_COUNT", 1),
+ ("DNS_MAX_SERVER_COUNT", 1),
+ ("DNS_MAX_NAME_SIZE", 255),
+ ("RPL_RELATIONS_BUFFER_COUNT", 16),
+ ("RPL_PARENTS_BUFFER_COUNT", 8),
+ // END AUTOGENERATED CONFIG FEATURES
+];
+
+struct ConfigState {
+ value: usize,
+ seen_feature: bool,
+ seen_env: bool,
+}
+
+fn main() {
+ // only rebuild if build.rs changed. Otherwise Cargo will rebuild if any
+ // other file changed.
+ println!("cargo:rerun-if-changed=build.rs");
+
+ // Rebuild if config envvar changed.
+ for (name, _) in CONFIGS {
+ println!("cargo:rerun-if-env-changed=SMOLTCP_{name}");
+ }
+
+ let mut configs = HashMap::new();
+ for (name, default) in CONFIGS {
+ configs.insert(
+ *name,
+ ConfigState {
+ value: *default,
+ seen_env: false,
+ seen_feature: false,
+ },
+ );
+ }
+
+ for (var, value) in env::vars() {
+ if let Some(name) = var.strip_prefix("SMOLTCP_") {
+ let Some(cfg) = configs.get_mut(name) else {
+ panic!("Unknown env var {name}")
+ };
+
+ let Ok(value) = value.parse::<usize>() else {
+ panic!("Invalid value for env var {name}: {value}")
+ };
+
+ cfg.value = value;
+ cfg.seen_env = true;
+ }
+
+ if let Some(feature) = var.strip_prefix("CARGO_FEATURE_") {
+ if let Some(i) = feature.rfind('_') {
+ let name = &feature[..i];
+ let value = &feature[i + 1..];
+ if let Some(cfg) = configs.get_mut(name) {
+ let Ok(value) = value.parse::<usize>() else {
+ panic!("Invalid value for feature {name}: {value}")
+ };
+
+ // envvars take priority.
+ if !cfg.seen_env {
+ if cfg.seen_feature {
+ panic!(
+ "multiple values set for feature {}: {} and {}",
+ name, cfg.value, value
+ );
+ }
+
+ cfg.value = value;
+ cfg.seen_feature = true;
+ }
+ }
+ }
+ }
+ }
+
+ let mut data = String::new();
+
+ for (name, cfg) in &configs {
+ writeln!(&mut data, "pub const {}: usize = {};", name, cfg.value).unwrap();
+ }
+
+ let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+ let out_file = out_dir.join("config.rs").to_string_lossy().to_string();
+ fs::write(out_file, data).unwrap();
+}
diff --git a/ci.sh b/ci.sh
new file mode 100755
index 0000000..ec20cc7
--- /dev/null
+++ b/ci.sh
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+
+set -eox pipefail
+
+export DEFMT_LOG=trace
+
+MSRV="1.65.0"
+
+RUSTC_VERSIONS=(
+ $MSRV
+ "stable"
+ "nightly"
+)
+
+FEATURES_TEST=(
+ "default"
+ "std,proto-ipv4"
+ "std,medium-ethernet,phy-raw_socket,proto-ipv6,socket-udp,socket-dns"
+ "std,medium-ethernet,phy-tuntap_interface,proto-ipv6,socket-udp"
+ "std,medium-ethernet,proto-ipv4,proto-ipv4-fragmentation,socket-raw,socket-dns"
+ "std,medium-ethernet,proto-ipv4,proto-igmp,socket-raw,socket-dns"
+ "std,medium-ethernet,proto-ipv4,socket-udp,socket-tcp,socket-dns"
+ "std,medium-ethernet,proto-ipv4,proto-dhcpv4,socket-udp"
+ "std,medium-ethernet,medium-ip,medium-ieee802154,proto-ipv6,socket-udp,socket-dns"
+ "std,medium-ethernet,proto-ipv6,socket-tcp"
+ "std,medium-ethernet,medium-ip,proto-ipv4,socket-icmp,socket-tcp"
+ "std,medium-ip,proto-ipv6,socket-icmp,socket-tcp"
+ "std,medium-ieee802154,proto-sixlowpan,socket-udp"
+ "std,medium-ieee802154,proto-sixlowpan,proto-sixlowpan-fragmentation,socket-udp"
+ "std,medium-ieee802154,proto-rpl,proto-sixlowpan,proto-sixlowpan-fragmentation,socket-udp"
+ "std,medium-ip,proto-ipv4,proto-ipv6,socket-tcp,socket-udp"
+ "std,medium-ethernet,medium-ip,medium-ieee802154,proto-ipv4,proto-ipv6,socket-raw,socket-udp,socket-tcp,socket-icmp,socket-dns,async"
+ "std,medium-ieee802154,medium-ip,proto-ipv4,socket-raw"
+ "std,medium-ethernet,proto-ipv4,proto-ipsec,socket-raw"
+)
+
+FEATURES_TEST_NIGHTLY=(
+ "alloc,medium-ethernet,proto-ipv4,proto-ipv6,socket-raw,socket-udp,socket-tcp,socket-icmp"
+)
+
+FEATURES_CHECK=(
+ "medium-ip,medium-ethernet,medium-ieee802154,proto-ipv6,proto-ipv6,proto-igmp,proto-dhcpv4,proto-ipsec,socket-raw,socket-udp,socket-tcp,socket-icmp,socket-dns,async"
+ "defmt,medium-ip,medium-ethernet,proto-ipv6,proto-ipv6,proto-igmp,proto-dhcpv4,socket-raw,socket-udp,socket-tcp,socket-icmp,socket-dns,async"
+ "defmt,alloc,medium-ip,medium-ethernet,proto-ipv6,proto-ipv6,proto-igmp,proto-dhcpv4,socket-raw,socket-udp,socket-tcp,socket-icmp,socket-dns,async"
+)
+
+test() {
+ local version=$1
+ rustup toolchain install $version
+
+ for features in ${FEATURES_TEST[@]}; do
+ cargo +$version test --no-default-features --features "$features"
+ done
+
+ if [[ $version == "nightly" ]]; then
+ for features in ${FEATURES_TEST_NIGHTLY[@]}; do
+ cargo +$version test --no-default-features --features "$features"
+ done
+ fi
+}
+
+check() {
+ local version=$1
+ rustup toolchain install $version
+
+ export DEFMT_LOG="trace"
+
+ for features in ${FEATURES_CHECK[@]}; do
+ cargo +$version check --no-default-features --features "$features"
+ done
+}
+
+clippy() {
+ rustup toolchain install $MSRV
+ rustup component add clippy --toolchain=$MSRV
+ cargo +$MSRV clippy --tests --examples -- -D warnings
+}
+
+coverage() {
+ for features in ${FEATURES_TEST[@]}; do
+ cargo llvm-cov --no-report --no-default-features --features "$features"
+ done
+ cargo llvm-cov report --lcov --output-path lcov.info
+}
+
+if [[ $1 == "test" || $1 == "all" ]]; then
+ if [[ -n $2 ]]; then
+ if [[ $2 == "msrv" ]]; then
+ test $MSRV
+ else
+ test $2
+ fi
+ else
+ for version in ${RUSTC_VERSIONS[@]}; do
+ test $version
+ done
+ fi
+fi
+
+if [[ $1 == "check" || $1 == "all" ]]; then
+ if [[ -n $2 ]]; then
+ if [[ $2 == "msrv" ]]; then
+ check $MSRV
+ else
+ check $2
+ fi
+ else
+ for version in ${RUSTC_VERSIONS[@]}; do
+ check $version
+ done
+ fi
+fi
+
+if [[ $1 == "clippy" || $1 == "all" ]]; then
+ clippy
+fi
+
+if [[ $1 == "coverage" || $1 == "all" ]]; then
+ coverage
+fi
diff --git a/examples/benchmark.rs b/examples/benchmark.rs
new file mode 100644
index 0000000..ad2c6e1
--- /dev/null
+++ b/examples/benchmark.rs
@@ -0,0 +1,164 @@
+#![allow(clippy::collapsible_if)]
+
+mod utils;
+
+use std::cmp;
+use std::io::{Read, Write};
+use std::net::TcpStream;
+use std::os::unix::io::AsRawFd;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{wait as phy_wait, Device, Medium};
+use smoltcp::socket::tcp;
+use smoltcp::time::{Duration, Instant};
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
+
+const AMOUNT: usize = 1_000_000_000;
+
+enum Client {
+ Reader,
+ Writer,
+}
+
+fn client(kind: Client) {
+ let port = match kind {
+ Client::Reader => 1234,
+ Client::Writer => 1235,
+ };
+ let mut stream = TcpStream::connect(("192.168.69.1", port)).unwrap();
+ let mut buffer = vec![0; 1_000_000];
+
+ let start = Instant::now();
+
+ let mut processed = 0;
+ while processed < AMOUNT {
+ let length = cmp::min(buffer.len(), AMOUNT - processed);
+ let result = match kind {
+ Client::Reader => stream.read(&mut buffer[..length]),
+ Client::Writer => stream.write(&buffer[..length]),
+ };
+ match result {
+ Ok(0) => break,
+ Ok(result) => {
+ // print!("(P:{})", result);
+ processed += result
+ }
+ Err(err) => panic!("cannot process: {err}"),
+ }
+ }
+
+ let end = Instant::now();
+
+ let elapsed = (end - start).total_millis() as f64 / 1000.0;
+
+ println!("throughput: {:.3} Gbps", AMOUNT as f64 / elapsed / 0.125e9);
+
+ CLIENT_DONE.store(true, Ordering::SeqCst);
+}
+
+static CLIENT_DONE: AtomicBool = AtomicBool::new(false);
+
+fn main() {
+ #[cfg(feature = "log")]
+ utils::setup_logging("info");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+ free.push("MODE");
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+ let mode = match matches.free[0].as_ref() {
+ "reader" => Client::Reader,
+ "writer" => Client::Writer,
+ _ => panic!("invalid mode"),
+ };
+
+ let tcp1_rx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp1_tx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp1_socket = tcp::Socket::new(tcp1_rx_buffer, tcp1_tx_buffer);
+
+ let tcp2_rx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp2_tx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp2_socket = tcp::Socket::new(tcp2_rx_buffer, tcp2_tx_buffer);
+
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+ config.random_seed = rand::random();
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+ .unwrap();
+ });
+
+ let mut sockets = SocketSet::new(vec![]);
+ let tcp1_handle = sockets.add(tcp1_socket);
+ let tcp2_handle = sockets.add(tcp2_socket);
+ let default_timeout = Some(Duration::from_millis(1000));
+
+ thread::spawn(move || client(mode));
+ let mut processed = 0;
+ while !CLIENT_DONE.load(Ordering::SeqCst) {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ // tcp:1234: emit data
+ let socket = sockets.get_mut::<tcp::Socket>(tcp1_handle);
+ if !socket.is_open() {
+ socket.listen(1234).unwrap();
+ }
+
+ if socket.can_send() {
+ if processed < AMOUNT {
+ let length = socket
+ .send(|buffer| {
+ let length = cmp::min(buffer.len(), AMOUNT - processed);
+ (length, length)
+ })
+ .unwrap();
+ processed += length;
+ }
+ }
+
+ // tcp:1235: sink data
+ let socket = sockets.get_mut::<tcp::Socket>(tcp2_handle);
+ if !socket.is_open() {
+ socket.listen(1235).unwrap();
+ }
+
+ if socket.can_recv() {
+ if processed < AMOUNT {
+ let length = socket
+ .recv(|buffer| {
+ let length = cmp::min(buffer.len(), AMOUNT - processed);
+ (length, length)
+ })
+ .unwrap();
+ processed += length;
+ }
+ }
+
+ match iface.poll_at(timestamp, &sockets) {
+ Some(poll_at) if timestamp < poll_at => {
+ phy_wait(fd, Some(poll_at - timestamp)).expect("wait error");
+ }
+ Some(_) => (),
+ None => {
+ phy_wait(fd, default_timeout).expect("wait error");
+ }
+ }
+ }
+}
diff --git a/examples/client.rs b/examples/client.rs
new file mode 100644
index 0000000..c18c08f
--- /dev/null
+++ b/examples/client.rs
@@ -0,0 +1,118 @@
+mod utils;
+
+use log::debug;
+use std::os::unix::io::AsRawFd;
+use std::str::{self, FromStr};
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{wait as phy_wait, Device, Medium};
+use smoltcp::socket::tcp;
+use smoltcp::time::Instant;
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address, Ipv6Address};
+
+fn main() {
+ utils::setup_logging("");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+ free.push("ADDRESS");
+ free.push("PORT");
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+ let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
+ let port = u16::from_str(&matches.free[1]).expect("invalid port format");
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+ config.random_seed = rand::random();
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ });
+ iface
+ .routes_mut()
+ .add_default_ipv4_route(Ipv4Address::new(192, 168, 69, 100))
+ .unwrap();
+ iface
+ .routes_mut()
+ .add_default_ipv6_route(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100))
+ .unwrap();
+
+ // Create sockets
+ let tcp_rx_buffer = tcp::SocketBuffer::new(vec![0; 1500]);
+ let tcp_tx_buffer = tcp::SocketBuffer::new(vec![0; 1500]);
+ let tcp_socket = tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer);
+ let mut sockets = SocketSet::new(vec![]);
+ let tcp_handle = sockets.add(tcp_socket);
+
+ let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
+ socket
+ .connect(iface.context(), (address, port), 49500)
+ .unwrap();
+
+ let mut tcp_active = false;
+ loop {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
+ if socket.is_active() && !tcp_active {
+ debug!("connected");
+ } else if !socket.is_active() && tcp_active {
+ debug!("disconnected");
+ break;
+ }
+ tcp_active = socket.is_active();
+
+ if socket.may_recv() {
+ let data = socket
+ .recv(|data| {
+ let mut data = data.to_owned();
+ if !data.is_empty() {
+ debug!(
+ "recv data: {:?}",
+ str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
+ );
+ data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
+ data.reverse();
+ data.extend(b"\n");
+ }
+ (data.len(), data)
+ })
+ .unwrap();
+ if socket.can_send() && !data.is_empty() {
+ debug!(
+ "send data: {:?}",
+ str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
+ );
+ socket.send_slice(&data[..]).unwrap();
+ }
+ } else if socket.may_send() {
+ debug!("close");
+ socket.close();
+ }
+
+ phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
+ }
+}
diff --git a/examples/dhcp_client.rs b/examples/dhcp_client.rs
new file mode 100644
index 0000000..9ef46c2
--- /dev/null
+++ b/examples/dhcp_client.rs
@@ -0,0 +1,94 @@
+#![allow(clippy::option_map_unit_fn)]
+mod utils;
+
+use log::*;
+use std::os::unix::io::AsRawFd;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::socket::dhcpv4;
+use smoltcp::time::Instant;
+use smoltcp::wire::{EthernetAddress, IpCidr, Ipv4Address, Ipv4Cidr};
+use smoltcp::{
+ phy::{wait as phy_wait, Device, Medium},
+ time::Duration,
+};
+
+fn main() {
+ #[cfg(feature = "log")]
+ utils::setup_logging("");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+ config.random_seed = rand::random();
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+
+ // Create sockets
+ let mut dhcp_socket = dhcpv4::Socket::new();
+
+ // Set a ridiculously short max lease time to show DHCP renews work properly.
+ // This will cause the DHCP client to start renewing after 5 seconds, and give up the
+ // lease after 10 seconds if renew hasn't succeeded.
+ // IMPORTANT: This should be removed in production.
+ dhcp_socket.set_max_lease_duration(Some(Duration::from_secs(10)));
+
+ let mut sockets = SocketSet::new(vec![]);
+ let dhcp_handle = sockets.add(dhcp_socket);
+
+ loop {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ let event = sockets.get_mut::<dhcpv4::Socket>(dhcp_handle).poll();
+ match event {
+ None => {}
+ Some(dhcpv4::Event::Configured(config)) => {
+ debug!("DHCP config acquired!");
+
+ debug!("IP address: {}", config.address);
+ set_ipv4_addr(&mut iface, config.address);
+
+ if let Some(router) = config.router {
+ debug!("Default gateway: {}", router);
+ iface.routes_mut().add_default_ipv4_route(router).unwrap();
+ } else {
+ debug!("Default gateway: None");
+ iface.routes_mut().remove_default_ipv4_route();
+ }
+
+ for (i, s) in config.dns_servers.iter().enumerate() {
+ debug!("DNS server {}: {}", i, s);
+ }
+ }
+ Some(dhcpv4::Event::Deconfigured) => {
+ debug!("DHCP lost config!");
+ set_ipv4_addr(&mut iface, Ipv4Cidr::new(Ipv4Address::UNSPECIFIED, 0));
+ iface.routes_mut().remove_default_ipv4_route();
+ }
+ }
+
+ phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
+ }
+}
+
+fn set_ipv4_addr(iface: &mut Interface, cidr: Ipv4Cidr) {
+ iface.update_ip_addrs(|addrs| {
+ let dest = addrs.iter_mut().next().unwrap();
+ *dest = IpCidr::Ipv4(cidr);
+ });
+}
diff --git a/examples/dns.rs b/examples/dns.rs
new file mode 100644
index 0000000..977f405
--- /dev/null
+++ b/examples/dns.rs
@@ -0,0 +1,92 @@
+mod utils;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::Device;
+use smoltcp::phy::{wait as phy_wait, Medium};
+use smoltcp::socket::dns::{self, GetQueryResultError};
+use smoltcp::time::Instant;
+use smoltcp::wire::{DnsQueryType, EthernetAddress, IpAddress, IpCidr, Ipv4Address, Ipv6Address};
+use std::os::unix::io::AsRawFd;
+
+fn main() {
+ utils::setup_logging("warn");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+ free.push("ADDRESS");
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+ let name = &matches.free[0];
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+ config.random_seed = rand::random();
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ });
+ iface
+ .routes_mut()
+ .add_default_ipv4_route(Ipv4Address::new(192, 168, 69, 100))
+ .unwrap();
+ iface
+ .routes_mut()
+ .add_default_ipv6_route(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100))
+ .unwrap();
+
+ // Create sockets
+ let servers = &[
+ Ipv4Address::new(8, 8, 4, 4).into(),
+ Ipv4Address::new(8, 8, 8, 8).into(),
+ ];
+ let dns_socket = dns::Socket::new(servers, vec![]);
+
+ let mut sockets = SocketSet::new(vec![]);
+ let dns_handle = sockets.add(dns_socket);
+
+ let socket = sockets.get_mut::<dns::Socket>(dns_handle);
+ let query = socket
+ .start_query(iface.context(), name, DnsQueryType::A)
+ .unwrap();
+
+ loop {
+ let timestamp = Instant::now();
+ log::debug!("timestamp {:?}", timestamp);
+
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ match sockets
+ .get_mut::<dns::Socket>(dns_handle)
+ .get_query_result(query)
+ {
+ Ok(addrs) => {
+ println!("Query done: {addrs:?}");
+ break;
+ }
+ Err(GetQueryResultError::Pending) => {} // not done yet
+ Err(e) => panic!("query failed: {e:?}"),
+ }
+
+ phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
+ }
+}
diff --git a/examples/httpclient.rs b/examples/httpclient.rs
new file mode 100644
index 0000000..8f3a53a
--- /dev/null
+++ b/examples/httpclient.rs
@@ -0,0 +1,123 @@
+mod utils;
+
+use log::debug;
+use std::os::unix::io::AsRawFd;
+use std::str::{self, FromStr};
+use url::Url;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{wait as phy_wait, Device, Medium};
+use smoltcp::socket::tcp;
+use smoltcp::time::Instant;
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address, Ipv6Address};
+
+fn main() {
+ utils::setup_logging("");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+ free.push("ADDRESS");
+ free.push("URL");
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+ let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
+ let url = Url::parse(&matches.free[1]).expect("invalid url format");
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+ config.random_seed = rand::random();
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ });
+ iface
+ .routes_mut()
+ .add_default_ipv4_route(Ipv4Address::new(192, 168, 69, 100))
+ .unwrap();
+ iface
+ .routes_mut()
+ .add_default_ipv6_route(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100))
+ .unwrap();
+
+ // Create sockets
+ let tcp_rx_buffer = tcp::SocketBuffer::new(vec![0; 1024]);
+ let tcp_tx_buffer = tcp::SocketBuffer::new(vec![0; 1024]);
+ let tcp_socket = tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer);
+
+ let mut sockets = SocketSet::new(vec![]);
+ let tcp_handle = sockets.add(tcp_socket);
+
+ enum State {
+ Connect,
+ Request,
+ Response,
+ }
+ let mut state = State::Connect;
+
+ loop {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
+ let cx = iface.context();
+
+ state = match state {
+ State::Connect if !socket.is_active() => {
+ debug!("connecting");
+ let local_port = 49152 + rand::random::<u16>() % 16384;
+ socket
+ .connect(cx, (address, url.port().unwrap_or(80)), local_port)
+ .unwrap();
+ State::Request
+ }
+ State::Request if socket.may_send() => {
+ debug!("sending request");
+ let http_get = "GET ".to_owned() + url.path() + " HTTP/1.1\r\n";
+ socket.send_slice(http_get.as_ref()).expect("cannot send");
+ let http_host = "Host: ".to_owned() + url.host_str().unwrap() + "\r\n";
+ socket.send_slice(http_host.as_ref()).expect("cannot send");
+ socket
+ .send_slice(b"Connection: close\r\n")
+ .expect("cannot send");
+ socket.send_slice(b"\r\n").expect("cannot send");
+ State::Response
+ }
+ State::Response if socket.can_recv() => {
+ socket
+ .recv(|data| {
+ println!("{}", str::from_utf8(data).unwrap_or("(invalid utf8)"));
+ (data.len(), ())
+ })
+ .unwrap();
+ State::Response
+ }
+ State::Response if !socket.may_recv() => {
+ debug!("received complete response");
+ break;
+ }
+ _ => state,
+ };
+
+ phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
+ }
+}
diff --git a/examples/loopback.rs b/examples/loopback.rs
new file mode 100644
index 0000000..7ca95b1
--- /dev/null
+++ b/examples/loopback.rs
@@ -0,0 +1,184 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(unused_mut)]
+#![allow(clippy::collapsible_if)]
+
+#[cfg(feature = "std")]
+#[allow(dead_code)]
+mod utils;
+
+use core::str;
+use log::{debug, error, info};
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{Device, Loopback, Medium};
+use smoltcp::socket::tcp;
+use smoltcp::time::{Duration, Instant};
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
+
+#[cfg(not(feature = "std"))]
+mod mock {
+ use core::cell::Cell;
+ use smoltcp::time::{Duration, Instant};
+
+ #[derive(Debug)]
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub struct Clock(Cell<Instant>);
+
+ impl Clock {
+ pub fn new() -> Clock {
+ Clock(Cell::new(Instant::from_millis(0)))
+ }
+
+ pub fn advance(&self, duration: Duration) {
+ self.0.set(self.0.get() + duration)
+ }
+
+ pub fn elapsed(&self) -> Instant {
+ self.0.get()
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+mod mock {
+ use smoltcp::time::{Duration, Instant};
+ use std::sync::atomic::{AtomicUsize, Ordering};
+ use std::sync::Arc;
+
+ // should be AtomicU64 but that's unstable
+ #[derive(Debug, Clone)]
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub struct Clock(Arc<AtomicUsize>);
+
+ impl Clock {
+ pub fn new() -> Clock {
+ Clock(Arc::new(AtomicUsize::new(0)))
+ }
+
+ pub fn advance(&self, duration: Duration) {
+ self.0
+ .fetch_add(duration.total_millis() as usize, Ordering::SeqCst);
+ }
+
+ pub fn elapsed(&self) -> Instant {
+ Instant::from_millis(self.0.load(Ordering::SeqCst) as i64)
+ }
+ }
+}
+
+fn main() {
+ let clock = mock::Clock::new();
+ let device = Loopback::new(Medium::Ethernet);
+
+ #[cfg(feature = "std")]
+ let mut device = {
+ let clock = clock.clone();
+ utils::setup_logging_with_clock("", move || clock.elapsed());
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_middleware_options(&mut opts, &mut free);
+
+ let mut matches = utils::parse_options(&opts, free);
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ true)
+ };
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8))
+ .unwrap();
+ });
+
+ // Create sockets
+ let server_socket = {
+ // It is not strictly necessary to use a `static mut` and unsafe code here, but
+ // on embedded systems that smoltcp targets it is far better to allocate the data
+ // statically to verify that it fits into RAM rather than get undefined behavior
+ // when stack overflows.
+ static mut TCP_SERVER_RX_DATA: [u8; 1024] = [0; 1024];
+ static mut TCP_SERVER_TX_DATA: [u8; 1024] = [0; 1024];
+ let tcp_rx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_SERVER_RX_DATA[..] });
+ let tcp_tx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_SERVER_TX_DATA[..] });
+ tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer)
+ };
+
+ let client_socket = {
+ static mut TCP_CLIENT_RX_DATA: [u8; 1024] = [0; 1024];
+ static mut TCP_CLIENT_TX_DATA: [u8; 1024] = [0; 1024];
+ let tcp_rx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_CLIENT_RX_DATA[..] });
+ let tcp_tx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_CLIENT_TX_DATA[..] });
+ tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer)
+ };
+
+ let mut sockets: [_; 2] = Default::default();
+ let mut sockets = SocketSet::new(&mut sockets[..]);
+ let server_handle = sockets.add(server_socket);
+ let client_handle = sockets.add(client_socket);
+
+ let mut did_listen = false;
+ let mut did_connect = false;
+ let mut done = false;
+ while !done && clock.elapsed() < Instant::from_millis(10_000) {
+ iface.poll(clock.elapsed(), &mut device, &mut sockets);
+
+ let mut socket = sockets.get_mut::<tcp::Socket>(server_handle);
+ if !socket.is_active() && !socket.is_listening() {
+ if !did_listen {
+ debug!("listening");
+ socket.listen(1234).unwrap();
+ did_listen = true;
+ }
+ }
+
+ if socket.can_recv() {
+ debug!(
+ "got {:?}",
+ socket.recv(|buffer| { (buffer.len(), str::from_utf8(buffer).unwrap()) })
+ );
+ socket.close();
+ done = true;
+ }
+
+ let mut socket = sockets.get_mut::<tcp::Socket>(client_handle);
+ let cx = iface.context();
+ if !socket.is_open() {
+ if !did_connect {
+ debug!("connecting");
+ socket
+ .connect(cx, (IpAddress::v4(127, 0, 0, 1), 1234), 65000)
+ .unwrap();
+ did_connect = true;
+ }
+ }
+
+ if socket.can_send() {
+ debug!("sending");
+ socket.send_slice(b"0123456789abcdef").unwrap();
+ socket.close();
+ }
+
+ match iface.poll_delay(clock.elapsed(), &sockets) {
+ Some(Duration::ZERO) => debug!("resuming"),
+ Some(delay) => {
+ debug!("sleeping for {} ms", delay);
+ clock.advance(delay)
+ }
+ None => clock.advance(Duration::from_millis(1)),
+ }
+ }
+
+ if done {
+ info!("done")
+ } else {
+ error!("this is taking too long, bailing out")
+ }
+}
diff --git a/examples/multicast.rs b/examples/multicast.rs
new file mode 100644
index 0000000..ea89a2e
--- /dev/null
+++ b/examples/multicast.rs
@@ -0,0 +1,129 @@
+mod utils;
+
+use std::os::unix::io::AsRawFd;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{wait as phy_wait, Device, Medium};
+use smoltcp::socket::{raw, udp};
+use smoltcp::time::Instant;
+use smoltcp::wire::{
+ EthernetAddress, IgmpPacket, IgmpRepr, IpAddress, IpCidr, IpProtocol, IpVersion, Ipv4Address,
+ Ipv4Packet, Ipv6Address,
+};
+
+const MDNS_PORT: u16 = 5353;
+const MDNS_GROUP: [u8; 4] = [224, 0, 0, 251];
+
+fn main() {
+ utils::setup_logging("warn");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+ config.random_seed = rand::random();
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ });
+ iface
+ .routes_mut()
+ .add_default_ipv4_route(Ipv4Address::new(192, 168, 69, 100))
+ .unwrap();
+ iface
+ .routes_mut()
+ .add_default_ipv6_route(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100))
+ .unwrap();
+
+ // Create sockets
+ let mut sockets = SocketSet::new(vec![]);
+
+ // Must fit at least one IGMP packet
+ let raw_rx_buffer = raw::PacketBuffer::new(vec![raw::PacketMetadata::EMPTY; 2], vec![0; 512]);
+ // Will not send IGMP
+ let raw_tx_buffer = raw::PacketBuffer::new(vec![], vec![]);
+ let raw_socket = raw::Socket::new(
+ IpVersion::Ipv4,
+ IpProtocol::Igmp,
+ raw_rx_buffer,
+ raw_tx_buffer,
+ );
+ let raw_handle = sockets.add(raw_socket);
+
+ // Must fit mDNS payload of at least one packet
+ let udp_rx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY; 4], vec![0; 1024]);
+ // Will not send mDNS
+ let udp_tx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 0]);
+ let udp_socket = udp::Socket::new(udp_rx_buffer, udp_tx_buffer);
+ let udp_handle = sockets.add(udp_socket);
+
+ // Join a multicast group to receive mDNS traffic
+ iface
+ .join_multicast_group(
+ &mut device,
+ Ipv4Address::from_bytes(&MDNS_GROUP),
+ Instant::now(),
+ )
+ .unwrap();
+
+ loop {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ let socket = sockets.get_mut::<raw::Socket>(raw_handle);
+
+ if socket.can_recv() {
+ // For display purposes only - normally we wouldn't process incoming IGMP packets
+ // in the application layer
+ match socket.recv() {
+ Err(e) => println!("Recv IGMP error: {e:?}"),
+ Ok(buf) => {
+ Ipv4Packet::new_checked(buf)
+ .and_then(|ipv4_packet| IgmpPacket::new_checked(ipv4_packet.payload()))
+ .and_then(|igmp_packet| IgmpRepr::parse(&igmp_packet))
+ .map(|igmp_repr| println!("IGMP packet: {igmp_repr:?}"))
+ .unwrap_or_else(|e| println!("parse IGMP error: {e:?}"));
+ }
+ }
+ }
+
+ let socket = sockets.get_mut::<udp::Socket>(udp_handle);
+ if !socket.is_open() {
+ socket.bind(MDNS_PORT).unwrap()
+ }
+
+ if socket.can_recv() {
+ socket
+ .recv()
+ .map(|(data, sender)| {
+ println!("mDNS traffic: {} UDP bytes from {}", data.len(), sender)
+ })
+ .unwrap_or_else(|e| println!("Recv UDP error: {e:?}"));
+ }
+
+ phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
+ }
+}
diff --git a/examples/ping.rs b/examples/ping.rs
new file mode 100644
index 0000000..7e33a21
--- /dev/null
+++ b/examples/ping.rs
@@ -0,0 +1,281 @@
+mod utils;
+
+use byteorder::{ByteOrder, NetworkEndian};
+use smoltcp::iface::{Interface, SocketSet};
+use std::cmp;
+use std::collections::HashMap;
+use std::os::unix::io::AsRawFd;
+use std::str::FromStr;
+
+use smoltcp::iface::Config;
+use smoltcp::phy::wait as phy_wait;
+use smoltcp::phy::Device;
+use smoltcp::socket::icmp;
+use smoltcp::wire::{
+ EthernetAddress, Icmpv4Packet, Icmpv4Repr, Icmpv6Packet, Icmpv6Repr, IpAddress, IpCidr,
+ Ipv4Address, Ipv6Address,
+};
+use smoltcp::{
+ phy::Medium,
+ time::{Duration, Instant},
+};
+
+macro_rules! send_icmp_ping {
+ ( $repr_type:ident, $packet_type:ident, $ident:expr, $seq_no:expr,
+ $echo_payload:expr, $socket:expr, $remote_addr:expr ) => {{
+ let icmp_repr = $repr_type::EchoRequest {
+ ident: $ident,
+ seq_no: $seq_no,
+ data: &$echo_payload,
+ };
+
+ let icmp_payload = $socket.send(icmp_repr.buffer_len(), $remote_addr).unwrap();
+
+ let icmp_packet = $packet_type::new_unchecked(icmp_payload);
+ (icmp_repr, icmp_packet)
+ }};
+}
+
+macro_rules! get_icmp_pong {
+ ( $repr_type:ident, $repr:expr, $payload:expr, $waiting_queue:expr, $remote_addr:expr,
+ $timestamp:expr, $received:expr ) => {{
+ if let $repr_type::EchoReply { seq_no, data, .. } = $repr {
+ if let Some(_) = $waiting_queue.get(&seq_no) {
+ let packet_timestamp_ms = NetworkEndian::read_i64(data);
+ println!(
+ "{} bytes from {}: icmp_seq={}, time={}ms",
+ data.len(),
+ $remote_addr,
+ seq_no,
+ $timestamp.total_millis() - packet_timestamp_ms
+ );
+ $waiting_queue.remove(&seq_no);
+ $received += 1;
+ }
+ }
+ }};
+}
+
+fn main() {
+ utils::setup_logging("warn");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+ opts.optopt(
+ "c",
+ "count",
+ "Amount of echo request packets to send (default: 4)",
+ "COUNT",
+ );
+ opts.optopt(
+ "i",
+ "interval",
+ "Interval between successive packets sent (seconds) (default: 1)",
+ "INTERVAL",
+ );
+ opts.optopt(
+ "",
+ "timeout",
+ "Maximum wait duration for an echo response packet (seconds) (default: 5)",
+ "TIMEOUT",
+ );
+ free.push("ADDRESS");
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+ let device_caps = device.capabilities();
+ let remote_addr = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
+ let count = matches
+ .opt_str("count")
+ .map(|s| usize::from_str(&s).unwrap())
+ .unwrap_or(4);
+ let interval = matches
+ .opt_str("interval")
+ .map(|s| Duration::from_secs(u64::from_str(&s).unwrap()))
+ .unwrap_or_else(|| Duration::from_secs(1));
+ let timeout = Duration::from_secs(
+ matches
+ .opt_str("timeout")
+ .map(|s| u64::from_str(&s).unwrap())
+ .unwrap_or(5),
+ );
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+ config.random_seed = rand::random();
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ });
+ iface
+ .routes_mut()
+ .add_default_ipv4_route(Ipv4Address::new(192, 168, 69, 100))
+ .unwrap();
+ iface
+ .routes_mut()
+ .add_default_ipv6_route(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100))
+ .unwrap();
+
+ // Create sockets
+ let icmp_rx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 256]);
+ let icmp_tx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 256]);
+ let icmp_socket = icmp::Socket::new(icmp_rx_buffer, icmp_tx_buffer);
+ let mut sockets = SocketSet::new(vec![]);
+ let icmp_handle = sockets.add(icmp_socket);
+
+ let mut send_at = Instant::from_millis(0);
+ let mut seq_no = 0;
+ let mut received = 0;
+ let mut echo_payload = [0xffu8; 40];
+ let mut waiting_queue = HashMap::new();
+ let ident = 0x22b;
+
+ loop {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ let timestamp = Instant::now();
+ let socket = sockets.get_mut::<icmp::Socket>(icmp_handle);
+ if !socket.is_open() {
+ socket.bind(icmp::Endpoint::Ident(ident)).unwrap();
+ send_at = timestamp;
+ }
+
+ if socket.can_send() && seq_no < count as u16 && send_at <= timestamp {
+ NetworkEndian::write_i64(&mut echo_payload, timestamp.total_millis());
+
+ match remote_addr {
+ IpAddress::Ipv4(_) => {
+ let (icmp_repr, mut icmp_packet) = send_icmp_ping!(
+ Icmpv4Repr,
+ Icmpv4Packet,
+ ident,
+ seq_no,
+ echo_payload,
+ socket,
+ remote_addr
+ );
+ icmp_repr.emit(&mut icmp_packet, &device_caps.checksum);
+ }
+ IpAddress::Ipv6(address) => {
+ let (icmp_repr, mut icmp_packet) = send_icmp_ping!(
+ Icmpv6Repr,
+ Icmpv6Packet,
+ ident,
+ seq_no,
+ echo_payload,
+ socket,
+ remote_addr
+ );
+ icmp_repr.emit(
+ &iface
+ .get_source_address_ipv6(&address)
+ .unwrap()
+ .into_address(),
+ &remote_addr,
+ &mut icmp_packet,
+ &device_caps.checksum,
+ );
+ }
+ }
+
+ waiting_queue.insert(seq_no, timestamp);
+ seq_no += 1;
+ send_at += interval;
+ }
+
+ if socket.can_recv() {
+ let (payload, _) = socket.recv().unwrap();
+
+ match remote_addr {
+ IpAddress::Ipv4(_) => {
+ let icmp_packet = Icmpv4Packet::new_checked(&payload).unwrap();
+ let icmp_repr = Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap();
+ get_icmp_pong!(
+ Icmpv4Repr,
+ icmp_repr,
+ payload,
+ waiting_queue,
+ remote_addr,
+ timestamp,
+ received
+ );
+ }
+ IpAddress::Ipv6(address) => {
+ let icmp_packet = Icmpv6Packet::new_checked(&payload).unwrap();
+ let icmp_repr = Icmpv6Repr::parse(
+ &remote_addr,
+ &iface
+ .get_source_address_ipv6(&address)
+ .unwrap()
+ .into_address(),
+ &icmp_packet,
+ &device_caps.checksum,
+ )
+ .unwrap();
+ get_icmp_pong!(
+ Icmpv6Repr,
+ icmp_repr,
+ payload,
+ waiting_queue,
+ remote_addr,
+ timestamp,
+ received
+ );
+ }
+ }
+ }
+
+ waiting_queue.retain(|seq, from| {
+ if timestamp - *from < timeout {
+ true
+ } else {
+ println!("From {remote_addr} icmp_seq={seq} timeout");
+ false
+ }
+ });
+
+ if seq_no == count as u16 && waiting_queue.is_empty() {
+ break;
+ }
+
+ let timestamp = Instant::now();
+ match iface.poll_at(timestamp, &sockets) {
+ Some(poll_at) if timestamp < poll_at => {
+ let resume_at = cmp::min(poll_at, send_at);
+ phy_wait(fd, Some(resume_at - timestamp)).expect("wait error");
+ }
+ Some(_) => (),
+ None => {
+ phy_wait(fd, Some(send_at - timestamp)).expect("wait error");
+ }
+ }
+ }
+
+ println!("--- {remote_addr} ping statistics ---");
+ println!(
+ "{} packets transmitted, {} received, {:.0}% packet loss",
+ seq_no,
+ received,
+ 100.0 * (seq_no - received) as f64 / seq_no as f64
+ );
+}
diff --git a/examples/server.rs b/examples/server.rs
new file mode 100644
index 0000000..33d95c5
--- /dev/null
+++ b/examples/server.rs
@@ -0,0 +1,209 @@
+mod utils;
+
+use log::debug;
+use std::fmt::Write;
+use std::os::unix::io::AsRawFd;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{wait as phy_wait, Device, Medium};
+use smoltcp::socket::{tcp, udp};
+use smoltcp::time::{Duration, Instant};
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address, Ipv6Address};
+
+fn main() {
+ utils::setup_logging("");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_tuntap_options(&mut opts, &mut free);
+ utils::add_middleware_options(&mut opts, &mut free);
+
+ let mut matches = utils::parse_options(&opts, free);
+ let device = utils::parse_tuntap_options(&mut matches);
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => todo!(),
+ };
+
+ config.random_seed = rand::random();
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ });
+ iface
+ .routes_mut()
+ .add_default_ipv4_route(Ipv4Address::new(192, 168, 69, 100))
+ .unwrap();
+ iface
+ .routes_mut()
+ .add_default_ipv6_route(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x100))
+ .unwrap();
+
+ // Create sockets
+ let udp_rx_buffer = udp::PacketBuffer::new(
+ vec![udp::PacketMetadata::EMPTY, udp::PacketMetadata::EMPTY],
+ vec![0; 65535],
+ );
+ let udp_tx_buffer = udp::PacketBuffer::new(
+ vec![udp::PacketMetadata::EMPTY, udp::PacketMetadata::EMPTY],
+ vec![0; 65535],
+ );
+ let udp_socket = udp::Socket::new(udp_rx_buffer, udp_tx_buffer);
+
+ let tcp1_rx_buffer = tcp::SocketBuffer::new(vec![0; 64]);
+ let tcp1_tx_buffer = tcp::SocketBuffer::new(vec![0; 128]);
+ let tcp1_socket = tcp::Socket::new(tcp1_rx_buffer, tcp1_tx_buffer);
+
+ let tcp2_rx_buffer = tcp::SocketBuffer::new(vec![0; 64]);
+ let tcp2_tx_buffer = tcp::SocketBuffer::new(vec![0; 128]);
+ let tcp2_socket = tcp::Socket::new(tcp2_rx_buffer, tcp2_tx_buffer);
+
+ let tcp3_rx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp3_tx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp3_socket = tcp::Socket::new(tcp3_rx_buffer, tcp3_tx_buffer);
+
+ let tcp4_rx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp4_tx_buffer = tcp::SocketBuffer::new(vec![0; 65535]);
+ let tcp4_socket = tcp::Socket::new(tcp4_rx_buffer, tcp4_tx_buffer);
+
+ let mut sockets = SocketSet::new(vec![]);
+ let udp_handle = sockets.add(udp_socket);
+ let tcp1_handle = sockets.add(tcp1_socket);
+ let tcp2_handle = sockets.add(tcp2_socket);
+ let tcp3_handle = sockets.add(tcp3_socket);
+ let tcp4_handle = sockets.add(tcp4_socket);
+
+ let mut tcp_6970_active = false;
+ loop {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ // udp:6969: respond "hello"
+ let socket = sockets.get_mut::<udp::Socket>(udp_handle);
+ if !socket.is_open() {
+ socket.bind(6969).unwrap()
+ }
+
+ let client = match socket.recv() {
+ Ok((data, endpoint)) => {
+ debug!("udp:6969 recv data: {:?} from {}", data, endpoint);
+ let mut data = data.to_vec();
+ data.reverse();
+ Some((endpoint, data))
+ }
+ Err(_) => None,
+ };
+ if let Some((endpoint, data)) = client {
+ debug!("udp:6969 send data: {:?} to {}", data, endpoint,);
+ socket.send_slice(&data, endpoint).unwrap();
+ }
+
+ // tcp:6969: respond "hello"
+ let socket = sockets.get_mut::<tcp::Socket>(tcp1_handle);
+ if !socket.is_open() {
+ socket.listen(6969).unwrap();
+ }
+
+ if socket.can_send() {
+ debug!("tcp:6969 send greeting");
+ writeln!(socket, "hello").unwrap();
+ debug!("tcp:6969 close");
+ socket.close();
+ }
+
+ // tcp:6970: echo with reverse
+ let socket = sockets.get_mut::<tcp::Socket>(tcp2_handle);
+ if !socket.is_open() {
+ socket.listen(6970).unwrap()
+ }
+
+ if socket.is_active() && !tcp_6970_active {
+ debug!("tcp:6970 connected");
+ } else if !socket.is_active() && tcp_6970_active {
+ debug!("tcp:6970 disconnected");
+ }
+ tcp_6970_active = socket.is_active();
+
+ if socket.may_recv() {
+ let data = socket
+ .recv(|buffer| {
+ let recvd_len = buffer.len();
+ let mut data = buffer.to_owned();
+ if !data.is_empty() {
+ debug!("tcp:6970 recv data: {:?}", data);
+ data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
+ data.reverse();
+ data.extend(b"\n");
+ }
+ (recvd_len, data)
+ })
+ .unwrap();
+ if socket.can_send() && !data.is_empty() {
+ debug!("tcp:6970 send data: {:?}", data);
+ socket.send_slice(&data[..]).unwrap();
+ }
+ } else if socket.may_send() {
+ debug!("tcp:6970 close");
+ socket.close();
+ }
+
+ // tcp:6971: sinkhole
+ let socket = sockets.get_mut::<tcp::Socket>(tcp3_handle);
+ if !socket.is_open() {
+ socket.listen(6971).unwrap();
+ socket.set_keep_alive(Some(Duration::from_millis(1000)));
+ socket.set_timeout(Some(Duration::from_millis(2000)));
+ }
+
+ if socket.may_recv() {
+ socket
+ .recv(|buffer| {
+ if !buffer.is_empty() {
+ debug!("tcp:6971 recv {:?} octets", buffer.len());
+ }
+ (buffer.len(), ())
+ })
+ .unwrap();
+ } else if socket.may_send() {
+ socket.close();
+ }
+
+ // tcp:6972: fountain
+ let socket = sockets.get_mut::<tcp::Socket>(tcp4_handle);
+ if !socket.is_open() {
+ socket.listen(6972).unwrap()
+ }
+
+ if socket.may_send() {
+ socket
+ .send(|data| {
+ if !data.is_empty() {
+ debug!("tcp:6972 send {:?} octets", data.len());
+ for (i, b) in data.iter_mut().enumerate() {
+ *b = (i % 256) as u8;
+ }
+ }
+ (data.len(), ())
+ })
+ .unwrap();
+ }
+
+ phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
+ }
+}
diff --git a/examples/sixlowpan.rs b/examples/sixlowpan.rs
new file mode 100644
index 0000000..0d9ec21
--- /dev/null
+++ b/examples/sixlowpan.rs
@@ -0,0 +1,177 @@
+//! 6lowpan example
+//!
+//! This example is designed to run using the Linux ieee802154/6lowpan support,
+//! using mac802154_hwsim.
+//!
+//! mac802154_hwsim allows you to create multiple "virtual" radios and specify
+//! which is in range with which. This is very useful for testing without
+//! needing real hardware. By default it creates two interfaces `wpan0` and
+//! `wpan1` that are in range with each other. You can customize this with
+//! the `wpan-hwsim` tool.
+//!
+//! We'll configure Linux to speak 6lowpan on `wpan0`, and leave `wpan1`
+//! unconfigured so smoltcp can use it with a raw socket.
+//!
+//! # Setup
+//!
+//! modprobe mac802154_hwsim
+//!
+//! ip link set wpan0 down
+//! ip link set wpan1 down
+//! iwpan dev wpan0 set pan_id 0xbeef
+//! iwpan dev wpan1 set pan_id 0xbeef
+//! ip link add link wpan0 name lowpan0 type lowpan
+//! ip link set wpan0 up
+//! ip link set wpan1 up
+//! ip link set lowpan0 up
+//!
+//! # Running
+//!
+//! Run it with `sudo ./target/debug/examples/sixlowpan`.
+//!
+//! You can set wireshark to sniff on interface `wpan0` to see the packets.
+//!
+//! Ping it with `ping fe80::180b:4242:4242:4242%lowpan0`.
+//!
+//! Speak UDP with `nc -uv fe80::180b:4242:4242:4242%lowpan0 6969`.
+//!
+//! # Teardown
+//!
+//! rmmod mac802154_hwsim
+//!
+
+mod utils;
+
+use log::debug;
+use std::os::unix::io::AsRawFd;
+use std::str;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{wait as phy_wait, Device, Medium, RawSocket};
+use smoltcp::socket::tcp;
+use smoltcp::socket::udp;
+use smoltcp::time::Instant;
+use smoltcp::wire::{EthernetAddress, Ieee802154Address, Ieee802154Pan, IpAddress, IpCidr};
+
+fn main() {
+ utils::setup_logging("");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_middleware_options(&mut opts, &mut free);
+
+ let mut matches = utils::parse_options(&opts, free);
+
+ let device = RawSocket::new("wpan1", Medium::Ieee802154).unwrap();
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => Config::new(
+ Ieee802154Address::Extended([0x1a, 0x0b, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42]).into(),
+ ),
+ };
+ config.random_seed = rand::random();
+ config.pan_id = Some(Ieee802154Pan(0xbeef));
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(
+ IpAddress::v6(0xfe80, 0, 0, 0, 0x180b, 0x4242, 0x4242, 0x4242),
+ 64,
+ ))
+ .unwrap();
+ });
+
+ // Create sockets
+ let udp_rx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 1280]);
+ let udp_tx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 1280]);
+ let udp_socket = udp::Socket::new(udp_rx_buffer, udp_tx_buffer);
+
+ let tcp_rx_buffer = tcp::SocketBuffer::new(vec![0; 4096]);
+ let tcp_tx_buffer = tcp::SocketBuffer::new(vec![0; 4096]);
+ let tcp_socket = tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer);
+
+ let mut sockets = SocketSet::new(vec![]);
+ let udp_handle = sockets.add(udp_socket);
+ let tcp_handle = sockets.add(tcp_socket);
+
+ let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
+ socket.listen(50000).unwrap();
+
+ let mut tcp_active = false;
+
+ loop {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ // udp:6969: respond "hello"
+ let socket = sockets.get_mut::<udp::Socket>(udp_handle);
+ if !socket.is_open() {
+ socket.bind(6969).unwrap()
+ }
+
+ let mut buffer = vec![0; 1500];
+ let client = match socket.recv() {
+ Ok((data, endpoint)) => {
+ debug!(
+ "udp:6969 recv data: {:?} from {}",
+ str::from_utf8(data).unwrap(),
+ endpoint
+ );
+ buffer[..data.len()].copy_from_slice(data);
+ Some((data.len(), endpoint))
+ }
+ Err(_) => None,
+ };
+ if let Some((len, endpoint)) = client {
+ debug!(
+ "udp:6969 send data: {:?}",
+ str::from_utf8(&buffer[..len]).unwrap()
+ );
+ socket.send_slice(&buffer[..len], endpoint).unwrap();
+ }
+
+ let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
+ if socket.is_active() && !tcp_active {
+ debug!("connected");
+ } else if !socket.is_active() && tcp_active {
+ debug!("disconnected");
+ }
+ tcp_active = socket.is_active();
+
+ if socket.may_recv() {
+ let data = socket
+ .recv(|data| {
+ let data = data.to_owned();
+ if !data.is_empty() {
+ debug!(
+ "recv data: {:?}",
+ str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
+ );
+ }
+ (data.len(), data)
+ })
+ .unwrap();
+
+ if socket.can_send() && !data.is_empty() {
+ debug!(
+ "send data: {:?}",
+ str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
+ );
+ socket.send_slice(&data[..]).unwrap();
+ }
+ } else if socket.may_send() {
+ debug!("close");
+ socket.close();
+ }
+
+ phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
+ }
+}
diff --git a/examples/sixlowpan_benchmark.rs b/examples/sixlowpan_benchmark.rs
new file mode 100644
index 0000000..4e61491
--- /dev/null
+++ b/examples/sixlowpan_benchmark.rs
@@ -0,0 +1,235 @@
+//! 6lowpan benchmark example
+//!
+//! This example runs a simple TCP throughput benchmark using the 6lowpan implementation in smoltcp
+//! It is designed to run using the Linux ieee802154/6lowpan support,
+//! using mac802154_hwsim.
+//!
+//! mac802154_hwsim allows you to create multiple "virtual" radios and specify
+//! which is in range with which. This is very useful for testing without
+//! needing real hardware. By default it creates two interfaces `wpan0` and
+//! `wpan1` that are in range with each other. You can customize this with
+//! the `wpan-hwsim` tool.
+//!
+//! We'll configure Linux to speak 6lowpan on `wpan0`, and leave `wpan1`
+//! unconfigured so smoltcp can use it with a raw socket.
+//!
+//!
+//!
+//!
+//!
+//! # Setup
+//!
+//! modprobe mac802154_hwsim
+//!
+//! ip link set wpan0 down
+//! ip link set wpan1 down
+//! iwpan dev wpan0 set pan_id 0xbeef
+//! iwpan dev wpan1 set pan_id 0xbeef
+//! ip link add link wpan0 name lowpan0 type lowpan
+//! ip link set wpan0 up
+//! ip link set wpan1 up
+//! ip link set lowpan0 up
+//!
+//!
+//! # Running
+//!
+//! Compile with `cargo build --release --example sixlowpan_benchmark`
+//! Run it with `sudo ./target/release/examples/sixlowpan_benchmark [reader|writer]`.
+//!
+//! # Teardown
+//!
+//! rmmod mac802154_hwsim
+//!
+
+mod utils;
+
+use std::os::unix::io::AsRawFd;
+use std::str;
+
+use smoltcp::iface::{Config, Interface, SocketSet};
+use smoltcp::phy::{wait as phy_wait, Device, Medium, RawSocket};
+use smoltcp::socket::tcp;
+use smoltcp::wire::{EthernetAddress, Ieee802154Address, Ieee802154Pan, IpAddress, IpCidr};
+
+//For benchmark
+use smoltcp::time::{Duration, Instant};
+use std::cmp;
+use std::io::{Read, Write};
+use std::net::SocketAddrV6;
+use std::net::TcpStream;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+
+use std::fs;
+
+fn if_nametoindex(ifname: &str) -> u32 {
+ let contents = fs::read_to_string(format!("/sys/devices/virtual/net/{ifname}/ifindex"))
+ .expect("couldn't read interface from \"/sys/devices/virtual/net\"")
+ .replace('\n', "");
+ contents.parse::<u32>().unwrap()
+}
+
+const AMOUNT: usize = 100_000_000;
+
+enum Client {
+ Reader,
+ Writer,
+}
+
+fn client(kind: Client) {
+ let port: u16 = match kind {
+ Client::Reader => 1234,
+ Client::Writer => 1235,
+ };
+
+ let scope_id = if_nametoindex("lowpan0");
+
+ let socket_addr = SocketAddrV6::new(
+ "fe80:0:0:0:180b:4242:4242:4242".parse().unwrap(),
+ port,
+ 0,
+ scope_id,
+ );
+
+ let mut stream = TcpStream::connect(socket_addr).expect("failed to connect TLKAGMKA");
+ let mut buffer = vec![0; 1_000_000];
+
+ let start = Instant::now();
+
+ let mut processed = 0;
+ while processed < AMOUNT {
+ let length = cmp::min(buffer.len(), AMOUNT - processed);
+ let result = match kind {
+ Client::Reader => stream.read(&mut buffer[..length]),
+ Client::Writer => stream.write(&buffer[..length]),
+ };
+ match result {
+ Ok(0) => break,
+ Ok(result) => {
+ // print!("(P:{})", result);
+ processed += result
+ }
+ Err(err) => panic!("cannot process: {err}"),
+ }
+ }
+
+ let end = Instant::now();
+
+ let elapsed = (end - start).total_millis() as f64 / 1000.0;
+
+ println!("throughput: {:.3} Gbps", AMOUNT as f64 / elapsed / 0.125e9);
+
+ CLIENT_DONE.store(true, Ordering::SeqCst);
+}
+
+static CLIENT_DONE: AtomicBool = AtomicBool::new(false);
+
+fn main() {
+ #[cfg(feature = "log")]
+ utils::setup_logging("info");
+
+ let (mut opts, mut free) = utils::create_options();
+ utils::add_middleware_options(&mut opts, &mut free);
+ free.push("MODE");
+
+ let mut matches = utils::parse_options(&opts, free);
+
+ let device = RawSocket::new("wpan1", Medium::Ieee802154).unwrap();
+
+ let fd = device.as_raw_fd();
+ let mut device =
+ utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+
+ let mode = match matches.free[0].as_ref() {
+ "reader" => Client::Reader,
+ "writer" => Client::Writer,
+ _ => panic!("invalid mode"),
+ };
+
+ // Create interface
+ let mut config = match device.capabilities().medium {
+ Medium::Ethernet => {
+ Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+ }
+ Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
+ Medium::Ieee802154 => Config::new(
+ Ieee802154Address::Extended([0x1a, 0x0b, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42]).into(),
+ ),
+ };
+ config.random_seed = rand::random();
+ config.pan_id = Some(Ieee802154Pan(0xbeef));
+
+ let mut iface = Interface::new(config, &mut device, Instant::now());
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(
+ IpAddress::v6(0xfe80, 0, 0, 0, 0x180b, 0x4242, 0x4242, 0x4242),
+ 64,
+ ))
+ .unwrap();
+ });
+
+ let tcp1_rx_buffer = tcp::SocketBuffer::new(vec![0; 4096]);
+ let tcp1_tx_buffer = tcp::SocketBuffer::new(vec![0; 4096]);
+ let tcp1_socket = tcp::Socket::new(tcp1_rx_buffer, tcp1_tx_buffer);
+
+ let tcp2_rx_buffer = tcp::SocketBuffer::new(vec![0; 4096]);
+ let tcp2_tx_buffer = tcp::SocketBuffer::new(vec![0; 4096]);
+ let tcp2_socket = tcp::Socket::new(tcp2_rx_buffer, tcp2_tx_buffer);
+
+ let mut sockets = SocketSet::new(vec![]);
+ let tcp1_handle = sockets.add(tcp1_socket);
+ let tcp2_handle = sockets.add(tcp2_socket);
+
+ let default_timeout = Some(Duration::from_millis(1000));
+
+ thread::spawn(move || client(mode));
+ let mut processed = 0;
+
+ while !CLIENT_DONE.load(Ordering::SeqCst) {
+ let timestamp = Instant::now();
+ iface.poll(timestamp, &mut device, &mut sockets);
+
+ // tcp:1234: emit data
+ let socket = sockets.get_mut::<tcp::Socket>(tcp1_handle);
+ if !socket.is_open() {
+ socket.listen(1234).unwrap();
+ }
+
+ if socket.can_send() && processed < AMOUNT {
+ let length = socket
+ .send(|buffer| {
+ let length = cmp::min(buffer.len(), AMOUNT - processed);
+ (length, length)
+ })
+ .unwrap();
+ processed += length;
+ }
+
+ // tcp:1235: sink data
+ let socket = sockets.get_mut::<tcp::Socket>(tcp2_handle);
+ if !socket.is_open() {
+ socket.listen(1235).unwrap();
+ }
+
+ if socket.can_recv() && processed < AMOUNT {
+ let length = socket
+ .recv(|buffer| {
+ let length = cmp::min(buffer.len(), AMOUNT - processed);
+ (length, length)
+ })
+ .unwrap();
+ processed += length;
+ }
+
+ match iface.poll_at(timestamp, &sockets) {
+ Some(poll_at) if timestamp < poll_at => {
+ phy_wait(fd, Some(poll_at - timestamp)).expect("wait error");
+ }
+ Some(_) => (),
+ None => {
+ phy_wait(fd, default_timeout).expect("wait error");
+ }
+ }
+ }
+}
diff --git a/examples/tcpdump.rs b/examples/tcpdump.rs
new file mode 100644
index 0000000..2baf376
--- /dev/null
+++ b/examples/tcpdump.rs
@@ -0,0 +1,21 @@
+use smoltcp::phy::wait as phy_wait;
+use smoltcp::phy::{Device, RawSocket, RxToken};
+use smoltcp::time::Instant;
+use smoltcp::wire::{EthernetFrame, PrettyPrinter};
+use std::env;
+use std::os::unix::io::AsRawFd;
+
+fn main() {
+ let ifname = env::args().nth(1).unwrap();
+ let mut socket = RawSocket::new(ifname.as_ref(), smoltcp::phy::Medium::Ethernet).unwrap();
+ loop {
+ phy_wait(socket.as_raw_fd(), None).unwrap();
+ let (rx_token, _) = socket.receive(Instant::now()).unwrap();
+ rx_token.consume(|buffer| {
+ println!(
+ "{}",
+ PrettyPrinter::<EthernetFrame<&[u8]>>::new("", &buffer)
+ );
+ })
+ }
+}
diff --git a/examples/utils.rs b/examples/utils.rs
new file mode 100644
index 0000000..dbe9076
--- /dev/null
+++ b/examples/utils.rs
@@ -0,0 +1,218 @@
+#![allow(dead_code)]
+
+#[cfg(feature = "log")]
+use env_logger::Builder;
+use getopts::{Matches, Options};
+#[cfg(feature = "log")]
+use log::{trace, Level, LevelFilter};
+use std::env;
+use std::fs::File;
+use std::io::{self, Write};
+use std::process;
+use std::str::{self, FromStr};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[cfg(feature = "phy-tuntap_interface")]
+use smoltcp::phy::TunTapInterface;
+use smoltcp::phy::{Device, FaultInjector, Medium, Tracer};
+use smoltcp::phy::{PcapMode, PcapWriter};
+use smoltcp::time::{Duration, Instant};
+
+#[cfg(feature = "log")]
+pub fn setup_logging_with_clock<F>(filter: &str, since_startup: F)
+where
+ F: Fn() -> Instant + Send + Sync + 'static,
+{
+ Builder::new()
+ .format(move |buf, record| {
+ let elapsed = since_startup();
+ let timestamp = format!("[{elapsed}]");
+ if record.target().starts_with("smoltcp::") {
+ writeln!(
+ buf,
+ "\x1b[0m{} ({}): {}\x1b[0m",
+ timestamp,
+ record.target().replace("smoltcp::", ""),
+ record.args()
+ )
+ } else if record.level() == Level::Trace {
+ let message = format!("{}", record.args());
+ writeln!(
+ buf,
+ "\x1b[37m{} {}\x1b[0m",
+ timestamp,
+ message.replace('\n', "\n ")
+ )
+ } else {
+ writeln!(
+ buf,
+ "\x1b[32m{} ({}): {}\x1b[0m",
+ timestamp,
+ record.target(),
+ record.args()
+ )
+ }
+ })
+ .filter(None, LevelFilter::Trace)
+ .parse_filters(filter)
+ .parse_env("RUST_LOG")
+ .init();
+}
+
+#[cfg(feature = "log")]
+pub fn setup_logging(filter: &str) {
+ setup_logging_with_clock(filter, Instant::now)
+}
+
+pub fn create_options() -> (Options, Vec<&'static str>) {
+ let mut opts = Options::new();
+ opts.optflag("h", "help", "print this help menu");
+ (opts, Vec::new())
+}
+
+pub fn parse_options(options: &Options, free: Vec<&str>) -> Matches {
+ match options.parse(env::args().skip(1)) {
+ Err(err) => {
+ println!("{err}");
+ process::exit(1)
+ }
+ Ok(matches) => {
+ if matches.opt_present("h") || matches.free.len() != free.len() {
+ let brief = format!(
+ "Usage: {} [OPTION]... {}",
+ env::args().next().unwrap(),
+ free.join(" ")
+ );
+ print!("{}", options.usage(&brief));
+ process::exit((matches.free.len() != free.len()) as _);
+ }
+ matches
+ }
+ }
+}
+
+pub fn add_tuntap_options(opts: &mut Options, _free: &mut [&str]) {
+ opts.optopt("", "tun", "TUN interface to use", "tun0");
+ opts.optopt("", "tap", "TAP interface to use", "tap0");
+}
+
+#[cfg(feature = "phy-tuntap_interface")]
+pub fn parse_tuntap_options(matches: &mut Matches) -> TunTapInterface {
+ let tun = matches.opt_str("tun");
+ let tap = matches.opt_str("tap");
+ match (tun, tap) {
+ (Some(tun), None) => TunTapInterface::new(&tun, Medium::Ip).unwrap(),
+ (None, Some(tap)) => TunTapInterface::new(&tap, Medium::Ethernet).unwrap(),
+ _ => panic!("You must specify exactly one of --tun or --tap"),
+ }
+}
+
+pub fn add_middleware_options(opts: &mut Options, _free: &mut [&str]) {
+ opts.optopt("", "pcap", "Write a packet capture file", "FILE");
+ opts.optopt(
+ "",
+ "drop-chance",
+ "Chance of dropping a packet (%)",
+ "CHANCE",
+ );
+ opts.optopt(
+ "",
+ "corrupt-chance",
+ "Chance of corrupting a packet (%)",
+ "CHANCE",
+ );
+ opts.optopt(
+ "",
+ "size-limit",
+ "Drop packets larger than given size (octets)",
+ "SIZE",
+ );
+ opts.optopt(
+ "",
+ "tx-rate-limit",
+ "Drop packets after transmit rate exceeds given limit \
+ (packets per interval)",
+ "RATE",
+ );
+ opts.optopt(
+ "",
+ "rx-rate-limit",
+ "Drop packets after transmit rate exceeds given limit \
+ (packets per interval)",
+ "RATE",
+ );
+ opts.optopt(
+ "",
+ "shaping-interval",
+ "Sets the interval for rate limiting (ms)",
+ "RATE",
+ );
+}
+
+pub fn parse_middleware_options<D>(
+ matches: &mut Matches,
+ device: D,
+ loopback: bool,
+) -> FaultInjector<Tracer<PcapWriter<D, Box<dyn io::Write>>>>
+where
+ D: Device,
+{
+ let drop_chance = matches
+ .opt_str("drop-chance")
+ .map(|s| u8::from_str(&s).unwrap())
+ .unwrap_or(0);
+ let corrupt_chance = matches
+ .opt_str("corrupt-chance")
+ .map(|s| u8::from_str(&s).unwrap())
+ .unwrap_or(0);
+ let size_limit = matches
+ .opt_str("size-limit")
+ .map(|s| usize::from_str(&s).unwrap())
+ .unwrap_or(0);
+ let tx_rate_limit = matches
+ .opt_str("tx-rate-limit")
+ .map(|s| u64::from_str(&s).unwrap())
+ .unwrap_or(0);
+ let rx_rate_limit = matches
+ .opt_str("rx-rate-limit")
+ .map(|s| u64::from_str(&s).unwrap())
+ .unwrap_or(0);
+ let shaping_interval = matches
+ .opt_str("shaping-interval")
+ .map(|s| u64::from_str(&s).unwrap())
+ .unwrap_or(0);
+
+ let pcap_writer: Box<dyn io::Write> = match matches.opt_str("pcap") {
+ Some(pcap_filename) => Box::new(File::create(pcap_filename).expect("cannot open file")),
+ None => Box::new(io::sink()),
+ };
+
+ let seed = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .unwrap()
+ .subsec_nanos();
+
+ let device = PcapWriter::new(
+ device,
+ pcap_writer,
+ if loopback {
+ PcapMode::TxOnly
+ } else {
+ PcapMode::Both
+ },
+ );
+
+ let device = Tracer::new(device, |_timestamp, _printer| {
+ #[cfg(feature = "log")]
+ trace!("{}", _printer);
+ });
+
+ let mut device = FaultInjector::new(device, seed);
+ device.set_drop_chance(drop_chance);
+ device.set_corrupt_chance(corrupt_chance);
+ device.set_max_packet_size(size_limit);
+ device.set_max_tx_rate(tx_rate_limit);
+ device.set_max_rx_rate(rx_rate_limit);
+ device.set_bucket_interval(Duration::from_millis(shaping_interval));
+ device
+}
diff --git a/gen_config.py b/gen_config.py
new file mode 100644
index 0000000..2569192
--- /dev/null
+++ b/gen_config.py
@@ -0,0 +1,86 @@
+import os
+
+abspath = os.path.abspath(__file__)
+dname = os.path.dirname(abspath)
+os.chdir(dname)
+
+features = []
+
+
+def feature(name, default, min, max, pow2=None):
+ vals = set()
+ val = min
+ while val <= max:
+ vals.add(val)
+ if pow2 == True or (isinstance(pow2, int) and val >= pow2):
+ val *= 2
+ else:
+ val += 1
+ vals.add(default)
+
+ features.append(
+ {
+ "name": name,
+ "default": default,
+ "vals": sorted(list(vals)),
+ }
+ )
+
+
+feature("iface_max_addr_count", default=2, min=1, max=8)
+feature("iface_max_multicast_group_count", default=4, min=1, max=1024, pow2=8)
+feature("iface_max_sixlowpan_address_context_count", default=4, min=1, max=1024, pow2=8)
+feature("iface_neighbor_cache_count", default=4, min=1, max=1024, pow2=8)
+feature("iface_max_route_count", default=2, min=1, max=1024, pow2=8)
+feature("fragmentation_buffer_size", default=1500, min=256, max=65536, pow2=True)
+feature("assembler_max_segment_count", default=4, min=1, max=32, pow2=4)
+feature("reassembly_buffer_size", default=1500, min=256, max=65536, pow2=True)
+feature("reassembly_buffer_count", default=1, min=1, max=32, pow2=4)
+feature("ipv6_hbh_max_options", default=1, min=1, max=32, pow2=4)
+feature("dns_max_result_count", default=1, min=1, max=32, pow2=4)
+feature("dns_max_server_count", default=1, min=1, max=32, pow2=4)
+feature("dns_max_name_size", default=255, min=64, max=255, pow2=True)
+feature("rpl_relations_buffer_count", default=16, min=1, max=128, pow2=True)
+feature("rpl_parents_buffer_count", default=8, min=2, max=32, pow2=True)
+
+# ========= Update Cargo.toml
+
+things = ""
+for f in features:
+ name = f["name"].replace("_", "-")
+ for val in f["vals"]:
+ things += f"{name}-{val} = []"
+ if val == f["default"]:
+ things += " # Default"
+ things += "\n"
+ things += "\n"
+
+SEPARATOR_START = "# BEGIN AUTOGENERATED CONFIG FEATURES\n"
+SEPARATOR_END = "# END AUTOGENERATED CONFIG FEATURES\n"
+HELP = "# Generated by gen_config.py. DO NOT EDIT.\n"
+with open("Cargo.toml", "r") as f:
+ data = f.read()
+before, data = data.split(SEPARATOR_START, maxsplit=1)
+_, after = data.split(SEPARATOR_END, maxsplit=1)
+data = before + SEPARATOR_START + HELP + things + SEPARATOR_END + after
+with open("Cargo.toml", "w") as f:
+ f.write(data)
+
+
+# ========= Update build.rs
+
+things = ""
+for f in features:
+ name = f["name"].upper()
+ things += f' ("{name}", {f["default"]}),\n'
+
+SEPARATOR_START = "// BEGIN AUTOGENERATED CONFIG FEATURES\n"
+SEPARATOR_END = "// END AUTOGENERATED CONFIG FEATURES\n"
+HELP = " // Generated by gen_config.py. DO NOT EDIT.\n"
+with open("build.rs", "r") as f:
+ data = f.read()
+before, data = data.split(SEPARATOR_START, maxsplit=1)
+_, after = data.split(SEPARATOR_END, maxsplit=1)
+data = before + SEPARATOR_START + HELP + things + " " + SEPARATOR_END + after
+with open("build.rs", "w") as f:
+ f.write(data)
diff --git a/src/iface/fragmentation.rs b/src/iface/fragmentation.rs
new file mode 100644
index 0000000..ed00f17
--- /dev/null
+++ b/src/iface/fragmentation.rs
@@ -0,0 +1,506 @@
+#![allow(unused)]
+
+use core::fmt;
+
+use managed::{ManagedMap, ManagedSlice};
+
+use crate::config::{FRAGMENTATION_BUFFER_SIZE, REASSEMBLY_BUFFER_COUNT, REASSEMBLY_BUFFER_SIZE};
+use crate::storage::Assembler;
+use crate::time::{Duration, Instant};
+use crate::wire::*;
+
+use core::result::Result;
+
+#[cfg(feature = "alloc")]
+type Buffer = alloc::vec::Vec<u8>;
+#[cfg(not(feature = "alloc"))]
+type Buffer = [u8; REASSEMBLY_BUFFER_SIZE];
+
+/// Problem when assembling: something was out of bounds.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct AssemblerError;
+
+impl fmt::Display for AssemblerError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "AssemblerError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for AssemblerError {}
+
+/// Packet assembler is full
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct AssemblerFullError;
+
+impl fmt::Display for AssemblerFullError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "AssemblerFullError")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for AssemblerFullError {}
+
+/// Holds different fragments of one packet, used for assembling fragmented packets.
+///
+/// The buffer used for the `PacketAssembler` should either be dynamically sized (ex: Vec<u8>)
+/// or should be statically allocated based upon the MTU of the type of packet being
+/// assembled (ex: 1280 for a IPv6 frame).
+#[derive(Debug)]
+pub struct PacketAssembler<K> {
+ key: Option<K>,
+ buffer: Buffer,
+
+ assembler: Assembler,
+ total_size: Option<usize>,
+ expires_at: Instant,
+}
+
+impl<K> PacketAssembler<K> {
+ /// Create a new empty buffer for fragments.
+ pub const fn new() -> Self {
+ Self {
+ key: None,
+
+ #[cfg(feature = "alloc")]
+ buffer: Buffer::new(),
+ #[cfg(not(feature = "alloc"))]
+ buffer: [0u8; REASSEMBLY_BUFFER_SIZE],
+
+ assembler: Assembler::new(),
+ total_size: None,
+ expires_at: Instant::ZERO,
+ }
+ }
+
+ pub(crate) fn reset(&mut self) {
+ self.key = None;
+ self.assembler.clear();
+ self.total_size = None;
+ self.expires_at = Instant::ZERO;
+ }
+
+ /// Set the total size of the packet assembler.
+ pub(crate) fn set_total_size(&mut self, size: usize) -> Result<(), AssemblerError> {
+ if let Some(old_size) = self.total_size {
+ if old_size != size {
+ return Err(AssemblerError);
+ }
+ }
+
+ #[cfg(not(feature = "alloc"))]
+ if self.buffer.len() < size {
+ return Err(AssemblerError);
+ }
+
+ #[cfg(feature = "alloc")]
+ if self.buffer.len() < size {
+ self.buffer.resize(size, 0);
+ }
+
+ self.total_size = Some(size);
+ Ok(())
+ }
+
+ /// Return the instant when the assembler expires.
+ pub(crate) fn expires_at(&self) -> Instant {
+ self.expires_at
+ }
+
+ pub(crate) fn add_with(
+ &mut self,
+ offset: usize,
+ f: impl Fn(&mut [u8]) -> Result<usize, AssemblerError>,
+ ) -> Result<(), AssemblerError> {
+ if self.buffer.len() < offset {
+ return Err(AssemblerError);
+ }
+
+ let len = f(&mut self.buffer[offset..])?;
+ assert!(offset + len <= self.buffer.len());
+
+ net_debug!(
+ "frag assembler: receiving {} octets at offset {}",
+ len,
+ offset
+ );
+
+ self.assembler.add(offset, len);
+ Ok(())
+ }
+
+ /// Add a fragment into the packet that is being reassembled.
+ ///
+ /// # Errors
+ ///
+ /// - Returns [`Error::PacketAssemblerBufferTooSmall`] when trying to add data into the buffer at a non-existing
+ /// place.
+ pub(crate) fn add(&mut self, data: &[u8], offset: usize) -> Result<(), AssemblerError> {
+ #[cfg(not(feature = "alloc"))]
+ if self.buffer.len() < offset + data.len() {
+ return Err(AssemblerError);
+ }
+
+ #[cfg(feature = "alloc")]
+ if self.buffer.len() < offset + data.len() {
+ self.buffer.resize(offset + data.len(), 0);
+ }
+
+ let len = data.len();
+ self.buffer[offset..][..len].copy_from_slice(data);
+
+ net_debug!(
+ "frag assembler: receiving {} octets at offset {}",
+ len,
+ offset
+ );
+
+ self.assembler.add(offset, data.len());
+ Ok(())
+ }
+
+ /// Get an immutable slice of the underlying packet data, if reassembly complete.
+ /// This will mark the assembler as empty, so that it can be reused.
+ pub(crate) fn assemble(&mut self) -> Option<&'_ [u8]> {
+ if !self.is_complete() {
+ return None;
+ }
+
+ // NOTE: we can unwrap because `is_complete` already checks this.
+ let total_size = self.total_size.unwrap();
+ self.reset();
+ Some(&self.buffer[..total_size])
+ }
+
+ /// Returns `true` when all fragments have been received, otherwise `false`.
+ pub(crate) fn is_complete(&self) -> bool {
+ self.total_size == Some(self.assembler.peek_front())
+ }
+
+ /// Returns `true` when the packet assembler is free to use.
+ fn is_free(&self) -> bool {
+ self.key.is_none()
+ }
+}
+
+/// Set holding multiple [`PacketAssembler`].
+#[derive(Debug)]
+pub struct PacketAssemblerSet<K: Eq + Copy> {
+ assemblers: [PacketAssembler<K>; REASSEMBLY_BUFFER_COUNT],
+}
+
+impl<K: Eq + Copy> PacketAssemblerSet<K> {
+ const NEW_PA: PacketAssembler<K> = PacketAssembler::new();
+
+ /// Create a new set of packet assemblers.
+ pub fn new() -> Self {
+ Self {
+ assemblers: [Self::NEW_PA; REASSEMBLY_BUFFER_COUNT],
+ }
+ }
+
+ /// Get a [`PacketAssembler`] for a specific key.
+ ///
+ /// If it doesn't exist, it is created, with the `expires_at` timestamp.
+ ///
+ /// If the assembler set is full, in which case an error is returned.
+ pub(crate) fn get(
+ &mut self,
+ key: &K,
+ expires_at: Instant,
+ ) -> Result<&mut PacketAssembler<K>, AssemblerFullError> {
+ let mut empty_slot = None;
+ for slot in &mut self.assemblers {
+ if slot.key.as_ref() == Some(key) {
+ return Ok(slot);
+ }
+ if slot.is_free() {
+ empty_slot = Some(slot)
+ }
+ }
+
+ let slot = empty_slot.ok_or(AssemblerFullError)?;
+ slot.key = Some(*key);
+ slot.expires_at = expires_at;
+ Ok(slot)
+ }
+
+ /// Remove all [`PacketAssembler`]s that are expired.
+ pub fn remove_expired(&mut self, timestamp: Instant) {
+ for frag in &mut self.assemblers {
+ if !frag.is_free() && frag.expires_at < timestamp {
+ frag.reset();
+ }
+ }
+ }
+}
+
+// Max len of non-fragmented packets after decompression (including ipv6 header and payload)
+// TODO: lower. Should be (6lowpan mtu) - (min 6lowpan header size) + (max ipv6 header size)
+pub(crate) const MAX_DECOMPRESSED_LEN: usize = 1500;
+
+#[cfg(feature = "_proto-fragmentation")]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub(crate) enum FragKey {
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ Ipv4(Ipv4FragKey),
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ Sixlowpan(SixlowpanFragKey),
+}
+
+pub(crate) struct FragmentsBuffer {
+ #[cfg(feature = "proto-sixlowpan")]
+ pub decompress_buf: [u8; MAX_DECOMPRESSED_LEN],
+
+ #[cfg(feature = "_proto-fragmentation")]
+ pub assembler: PacketAssemblerSet<FragKey>,
+
+ #[cfg(feature = "_proto-fragmentation")]
+ pub reassembly_timeout: Duration,
+}
+
+#[cfg(not(feature = "_proto-fragmentation"))]
+pub(crate) struct Fragmenter {}
+
+#[cfg(not(feature = "_proto-fragmentation"))]
+impl Fragmenter {
+ pub(crate) fn new() -> Self {
+ Self {}
+ }
+}
+
+#[cfg(feature = "_proto-fragmentation")]
+pub(crate) struct Fragmenter {
+ /// The buffer that holds the unfragmented 6LoWPAN packet.
+ pub buffer: [u8; FRAGMENTATION_BUFFER_SIZE],
+ /// The size of the packet without the IEEE802.15.4 header and the fragmentation headers.
+ pub packet_len: usize,
+ /// The amount of bytes that already have been transmitted.
+ pub sent_bytes: usize,
+
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ pub ipv4: Ipv4Fragmenter,
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ pub sixlowpan: SixlowpanFragmenter,
+}
+
+#[cfg(feature = "proto-ipv4-fragmentation")]
+pub(crate) struct Ipv4Fragmenter {
+ /// The IPv4 representation.
+ pub repr: Ipv4Repr,
+ /// The destination hardware address.
+ #[cfg(feature = "medium-ethernet")]
+ pub dst_hardware_addr: EthernetAddress,
+ /// The offset of the next fragment.
+ pub frag_offset: u16,
+ /// The identifier of the stream.
+ pub ident: u16,
+}
+
+#[cfg(feature = "proto-sixlowpan-fragmentation")]
+pub(crate) struct SixlowpanFragmenter {
+ /// The datagram size that is used for the fragmentation headers.
+ pub datagram_size: u16,
+ /// The datagram tag that is used for the fragmentation headers.
+ pub datagram_tag: u16,
+ pub datagram_offset: usize,
+
+ /// The size of the FRAG_N packets.
+ pub fragn_size: usize,
+
+ /// The link layer IEEE802.15.4 source address.
+ pub ll_dst_addr: Ieee802154Address,
+ /// The link layer IEEE802.15.4 source address.
+ pub ll_src_addr: Ieee802154Address,
+}
+
+#[cfg(feature = "_proto-fragmentation")]
+impl Fragmenter {
+ pub(crate) fn new() -> Self {
+ Self {
+ buffer: [0u8; FRAGMENTATION_BUFFER_SIZE],
+ packet_len: 0,
+ sent_bytes: 0,
+
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ ipv4: Ipv4Fragmenter {
+ repr: Ipv4Repr {
+ src_addr: Ipv4Address::default(),
+ dst_addr: Ipv4Address::default(),
+ next_header: IpProtocol::Unknown(0),
+ payload_len: 0,
+ hop_limit: 0,
+ },
+ #[cfg(feature = "medium-ethernet")]
+ dst_hardware_addr: EthernetAddress::default(),
+ frag_offset: 0,
+ ident: 0,
+ },
+
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ sixlowpan: SixlowpanFragmenter {
+ datagram_size: 0,
+ datagram_tag: 0,
+ datagram_offset: 0,
+ fragn_size: 0,
+ ll_dst_addr: Ieee802154Address::Absent,
+ ll_src_addr: Ieee802154Address::Absent,
+ },
+ }
+ }
+
+ /// Return `true` when everything is transmitted.
+ #[inline]
+ pub(crate) fn finished(&self) -> bool {
+ self.packet_len == self.sent_bytes
+ }
+
+ /// Returns `true` when there is nothing to transmit.
+ #[inline]
+ pub(crate) fn is_empty(&self) -> bool {
+ self.packet_len == 0
+ }
+
+ // Reset the buffer.
+ pub(crate) fn reset(&mut self) {
+ self.packet_len = 0;
+ self.sent_bytes = 0;
+
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ {
+ self.ipv4.repr = Ipv4Repr {
+ src_addr: Ipv4Address::default(),
+ dst_addr: Ipv4Address::default(),
+ next_header: IpProtocol::Unknown(0),
+ payload_len: 0,
+ hop_limit: 0,
+ };
+ #[cfg(feature = "medium-ethernet")]
+ {
+ self.ipv4.dst_hardware_addr = EthernetAddress::default();
+ }
+ }
+
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ {
+ self.sixlowpan.datagram_size = 0;
+ self.sixlowpan.datagram_tag = 0;
+ self.sixlowpan.fragn_size = 0;
+ self.sixlowpan.ll_dst_addr = Ieee802154Address::Absent;
+ self.sixlowpan.ll_src_addr = Ieee802154Address::Absent;
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+ struct Key {
+ id: usize,
+ }
+
+ #[test]
+ fn packet_assembler_overlap() {
+ let mut p_assembler = PacketAssembler::<Key>::new();
+
+ p_assembler.set_total_size(5).unwrap();
+
+ let data = b"Rust";
+ p_assembler.add(&data[..], 0);
+ p_assembler.add(&data[..], 1);
+
+ assert_eq!(p_assembler.assemble(), Some(&b"RRust"[..]))
+ }
+
+ #[test]
+ fn packet_assembler_assemble() {
+ let mut p_assembler = PacketAssembler::<Key>::new();
+
+ let data = b"Hello World!";
+
+ p_assembler.set_total_size(data.len()).unwrap();
+
+ p_assembler.add(b"Hello ", 0).unwrap();
+ assert_eq!(p_assembler.assemble(), None);
+
+ p_assembler.add(b"World!", b"Hello ".len()).unwrap();
+
+ assert_eq!(p_assembler.assemble(), Some(&b"Hello World!"[..]));
+ }
+
+ #[test]
+ fn packet_assembler_out_of_order_assemble() {
+ let mut p_assembler = PacketAssembler::<Key>::new();
+
+ let data = b"Hello World!";
+
+ p_assembler.set_total_size(data.len()).unwrap();
+
+ p_assembler.add(b"World!", b"Hello ".len()).unwrap();
+ assert_eq!(p_assembler.assemble(), None);
+
+ p_assembler.add(b"Hello ", 0).unwrap();
+
+ assert_eq!(p_assembler.assemble(), Some(&b"Hello World!"[..]));
+ }
+
+ #[test]
+ fn packet_assembler_set() {
+ let key = Key { id: 1 };
+
+ let mut set = PacketAssemblerSet::new();
+
+ assert!(set.get(&key, Instant::ZERO).is_ok());
+ }
+
+ #[test]
+ fn packet_assembler_set_full() {
+ let mut set = PacketAssemblerSet::new();
+ for i in 0..REASSEMBLY_BUFFER_COUNT {
+ set.get(&Key { id: i }, Instant::ZERO).unwrap();
+ }
+ assert!(set.get(&Key { id: 4 }, Instant::ZERO).is_err());
+ }
+
+ #[test]
+ fn packet_assembler_set_assembling_many() {
+ let mut set = PacketAssemblerSet::new();
+
+ let key = Key { id: 0 };
+ let assr = set.get(&key, Instant::ZERO).unwrap();
+ assert_eq!(assr.assemble(), None);
+ assr.set_total_size(0).unwrap();
+ assr.assemble().unwrap();
+
+ // Test that `.assemble()` effectively deletes it.
+ let assr = set.get(&key, Instant::ZERO).unwrap();
+ assert_eq!(assr.assemble(), None);
+ assr.set_total_size(0).unwrap();
+ assr.assemble().unwrap();
+
+ let key = Key { id: 1 };
+ let assr = set.get(&key, Instant::ZERO).unwrap();
+ assr.set_total_size(0).unwrap();
+ assr.assemble().unwrap();
+
+ let key = Key { id: 2 };
+ let assr = set.get(&key, Instant::ZERO).unwrap();
+ assr.set_total_size(0).unwrap();
+ assr.assemble().unwrap();
+
+ let key = Key { id: 2 };
+ let assr = set.get(&key, Instant::ZERO).unwrap();
+ assr.set_total_size(2).unwrap();
+ assr.add(&[0x00], 0).unwrap();
+ assert_eq!(assr.assemble(), None);
+ let assr = set.get(&key, Instant::ZERO).unwrap();
+ assr.add(&[0x01], 1).unwrap();
+ assert_eq!(assr.assemble(), Some(&[0x00, 0x01][..]));
+ }
+}
diff --git a/src/iface/interface/ethernet.rs b/src/iface/interface/ethernet.rs
new file mode 100644
index 0000000..e2555a1
--- /dev/null
+++ b/src/iface/interface/ethernet.rs
@@ -0,0 +1,76 @@
+use super::check;
+use super::DispatchError;
+use super::EthernetPacket;
+use super::FragmentsBuffer;
+use super::InterfaceInner;
+use super::SocketSet;
+use core::result::Result;
+
+use crate::phy::TxToken;
+use crate::wire::*;
+
+impl InterfaceInner {
+ #[cfg(feature = "medium-ethernet")]
+ pub(super) fn process_ethernet<'frame>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: crate::phy::PacketMeta,
+ frame: &'frame [u8],
+ fragments: &'frame mut FragmentsBuffer,
+ ) -> Option<EthernetPacket<'frame>> {
+ let eth_frame = check!(EthernetFrame::new_checked(frame));
+
+ // Ignore any packets not directed to our hardware address or any of the multicast groups.
+ if !eth_frame.dst_addr().is_broadcast()
+ && !eth_frame.dst_addr().is_multicast()
+ && HardwareAddress::Ethernet(eth_frame.dst_addr()) != self.hardware_addr
+ {
+ return None;
+ }
+
+ match eth_frame.ethertype() {
+ #[cfg(feature = "proto-ipv4")]
+ EthernetProtocol::Arp => self.process_arp(self.now, ð_frame),
+ #[cfg(feature = "proto-ipv4")]
+ EthernetProtocol::Ipv4 => {
+ let ipv4_packet = check!(Ipv4Packet::new_checked(eth_frame.payload()));
+
+ self.process_ipv4(sockets, meta, &ipv4_packet, fragments)
+ .map(EthernetPacket::Ip)
+ }
+ #[cfg(feature = "proto-ipv6")]
+ EthernetProtocol::Ipv6 => {
+ let ipv6_packet = check!(Ipv6Packet::new_checked(eth_frame.payload()));
+ self.process_ipv6(sockets, meta, &ipv6_packet)
+ .map(EthernetPacket::Ip)
+ }
+ // Drop all other traffic.
+ _ => None,
+ }
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ pub(super) fn dispatch_ethernet<Tx, F>(
+ &mut self,
+ tx_token: Tx,
+ buffer_len: usize,
+ f: F,
+ ) -> Result<(), DispatchError>
+ where
+ Tx: TxToken,
+ F: FnOnce(EthernetFrame<&mut [u8]>),
+ {
+ let tx_len = EthernetFrame::<&[u8]>::buffer_len(buffer_len);
+ tx_token.consume(tx_len, |tx_buffer| {
+ debug_assert!(tx_buffer.as_ref().len() == tx_len);
+ let mut frame = EthernetFrame::new_unchecked(tx_buffer);
+
+ let src_addr = self.hardware_addr.ethernet_or_panic();
+ frame.set_src_addr(src_addr);
+
+ f(frame);
+
+ Ok(())
+ })
+ }
+}
diff --git a/src/iface/interface/ieee802154.rs b/src/iface/interface/ieee802154.rs
new file mode 100644
index 0000000..0feca5e
--- /dev/null
+++ b/src/iface/interface/ieee802154.rs
@@ -0,0 +1,94 @@
+use super::*;
+
+use crate::phy::TxToken;
+use crate::wire::*;
+
+impl InterfaceInner {
+ pub(super) fn process_ieee802154<'output, 'payload: 'output>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: PacketMeta,
+ sixlowpan_payload: &'payload [u8],
+ _fragments: &'output mut FragmentsBuffer,
+ ) -> Option<Packet<'output>> {
+ let ieee802154_frame = check!(Ieee802154Frame::new_checked(sixlowpan_payload));
+ let ieee802154_repr = check!(Ieee802154Repr::parse(&ieee802154_frame));
+
+ if ieee802154_repr.frame_type != Ieee802154FrameType::Data {
+ return None;
+ }
+
+ // Drop frames when the user has set a PAN id and the PAN id from frame is not equal to this
+ // When the user didn't set a PAN id (so it is None), then we accept all PAN id's.
+ // We always accept the broadcast PAN id.
+ if self.pan_id.is_some()
+ && ieee802154_repr.dst_pan_id != self.pan_id
+ && ieee802154_repr.dst_pan_id != Some(Ieee802154Pan::BROADCAST)
+ {
+ net_debug!(
+ "IEEE802.15.4: dropping {:?} because not our PAN id (or not broadcast)",
+ ieee802154_repr
+ );
+ return None;
+ }
+
+ match ieee802154_frame.payload() {
+ Some(payload) => {
+ self.process_sixlowpan(sockets, meta, &ieee802154_repr, payload, _fragments)
+ }
+ None => None,
+ }
+ }
+
+ pub(super) fn dispatch_ieee802154<Tx: TxToken>(
+ &mut self,
+ ll_dst_a: Ieee802154Address,
+ tx_token: Tx,
+ meta: PacketMeta,
+ packet: Packet,
+ frag: &mut Fragmenter,
+ ) {
+ let ll_src_a = self.hardware_addr.ieee802154_or_panic();
+
+ // Create the IEEE802.15.4 header.
+ let ieee_repr = Ieee802154Repr {
+ frame_type: Ieee802154FrameType::Data,
+ security_enabled: false,
+ frame_pending: false,
+ ack_request: false,
+ sequence_number: Some(self.get_sequence_number()),
+ pan_id_compression: true,
+ frame_version: Ieee802154FrameVersion::Ieee802154_2003,
+ dst_pan_id: self.pan_id,
+ dst_addr: Some(ll_dst_a),
+ src_pan_id: self.pan_id,
+ src_addr: Some(ll_src_a),
+ };
+
+ self.dispatch_sixlowpan(tx_token, meta, packet, ieee_repr, frag);
+ }
+
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ pub(super) fn dispatch_ieee802154_frag<Tx: TxToken>(
+ &mut self,
+ tx_token: Tx,
+ frag: &mut Fragmenter,
+ ) {
+ // Create the IEEE802.15.4 header.
+ let ieee_repr = Ieee802154Repr {
+ frame_type: Ieee802154FrameType::Data,
+ security_enabled: false,
+ frame_pending: false,
+ ack_request: false,
+ sequence_number: Some(self.get_sequence_number()),
+ pan_id_compression: true,
+ frame_version: Ieee802154FrameVersion::Ieee802154_2003,
+ dst_pan_id: self.pan_id,
+ dst_addr: Some(frag.sixlowpan.ll_dst_addr),
+ src_pan_id: self.pan_id,
+ src_addr: Some(frag.sixlowpan.ll_src_addr),
+ };
+
+ self.dispatch_sixlowpan_frag(tx_token, ieee_repr, frag);
+ }
+}
diff --git a/src/iface/interface/igmp.rs b/src/iface/interface/igmp.rs
new file mode 100644
index 0000000..14856ca
--- /dev/null
+++ b/src/iface/interface/igmp.rs
@@ -0,0 +1,275 @@
+use super::*;
+
+use crate::phy::{Device, PacketMeta};
+use crate::time::{Duration, Instant};
+use crate::wire::*;
+
+use core::result::Result;
+
+/// Error type for `join_multicast_group`, `leave_multicast_group`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum MulticastError {
+ /// The hardware device transmit buffer is full. Try again later.
+ Exhausted,
+ /// The table of joined multicast groups is already full.
+ GroupTableFull,
+ /// IPv6 multicast is not yet supported.
+ Ipv6NotSupported,
+}
+
+impl core::fmt::Display for MulticastError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ MulticastError::Exhausted => write!(f, "Exhausted"),
+ MulticastError::GroupTableFull => write!(f, "GroupTableFull"),
+ MulticastError::Ipv6NotSupported => write!(f, "Ipv6NotSupported"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for MulticastError {}
+
+impl Interface {
+ /// Add an address to a list of subscribed multicast IP addresses.
+ ///
+ /// Returns `Ok(announce_sent)` if the address was added successfully, where `announce_sent`
+ /// indicates whether an initial immediate announcement has been sent.
+ pub fn join_multicast_group<D, T: Into<IpAddress>>(
+ &mut self,
+ device: &mut D,
+ addr: T,
+ timestamp: Instant,
+ ) -> Result<bool, MulticastError>
+ where
+ D: Device + ?Sized,
+ {
+ self.inner.now = timestamp;
+
+ match addr.into() {
+ IpAddress::Ipv4(addr) => {
+ let is_not_new = self
+ .inner
+ .ipv4_multicast_groups
+ .insert(addr, ())
+ .map_err(|_| MulticastError::GroupTableFull)?
+ .is_some();
+ if is_not_new {
+ Ok(false)
+ } else if let Some(pkt) = self.inner.igmp_report_packet(IgmpVersion::Version2, addr)
+ {
+ // Send initial membership report
+ let tx_token = device
+ .transmit(timestamp)
+ .ok_or(MulticastError::Exhausted)?;
+
+ // NOTE(unwrap): packet destination is multicast, which is always routable and doesn't require neighbor discovery.
+ self.inner
+ .dispatch_ip(tx_token, PacketMeta::default(), pkt, &mut self.fragmenter)
+ .unwrap();
+
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ }
+ // Multicast is not yet implemented for other address families
+ #[allow(unreachable_patterns)]
+ _ => Err(MulticastError::Ipv6NotSupported),
+ }
+ }
+
+ /// Remove an address from the subscribed multicast IP addresses.
+ ///
+ /// Returns `Ok(leave_sent)` if the address was removed successfully, where `leave_sent`
+ /// indicates whether an immediate leave packet has been sent.
+ pub fn leave_multicast_group<D, T: Into<IpAddress>>(
+ &mut self,
+ device: &mut D,
+ addr: T,
+ timestamp: Instant,
+ ) -> Result<bool, MulticastError>
+ where
+ D: Device + ?Sized,
+ {
+ self.inner.now = timestamp;
+
+ match addr.into() {
+ IpAddress::Ipv4(addr) => {
+ let was_not_present = self.inner.ipv4_multicast_groups.remove(&addr).is_none();
+ if was_not_present {
+ Ok(false)
+ } else if let Some(pkt) = self.inner.igmp_leave_packet(addr) {
+ // Send group leave packet
+ let tx_token = device
+ .transmit(timestamp)
+ .ok_or(MulticastError::Exhausted)?;
+
+ // NOTE(unwrap): packet destination is multicast, which is always routable and doesn't require neighbor discovery.
+ self.inner
+ .dispatch_ip(tx_token, PacketMeta::default(), pkt, &mut self.fragmenter)
+ .unwrap();
+
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ }
+ // Multicast is not yet implemented for other address families
+ #[allow(unreachable_patterns)]
+ _ => Err(MulticastError::Ipv6NotSupported),
+ }
+ }
+
+ /// Check whether the interface listens to given destination multicast IP address.
+ pub fn has_multicast_group<T: Into<IpAddress>>(&self, addr: T) -> bool {
+ self.inner.has_multicast_group(addr)
+ }
+
+ /// Depending on `igmp_report_state` and the therein contained
+ /// timeouts, send IGMP membership reports.
+ pub(crate) fn igmp_egress<D>(&mut self, device: &mut D) -> bool
+ where
+ D: Device + ?Sized,
+ {
+ match self.inner.igmp_report_state {
+ IgmpReportState::ToSpecificQuery {
+ version,
+ timeout,
+ group,
+ } if self.inner.now >= timeout => {
+ if let Some(pkt) = self.inner.igmp_report_packet(version, group) {
+ // Send initial membership report
+ if let Some(tx_token) = device.transmit(self.inner.now) {
+ // NOTE(unwrap): packet destination is multicast, which is always routable and doesn't require neighbor discovery.
+ self.inner
+ .dispatch_ip(tx_token, PacketMeta::default(), pkt, &mut self.fragmenter)
+ .unwrap();
+ } else {
+ return false;
+ }
+ }
+
+ self.inner.igmp_report_state = IgmpReportState::Inactive;
+ true
+ }
+ IgmpReportState::ToGeneralQuery {
+ version,
+ timeout,
+ interval,
+ next_index,
+ } if self.inner.now >= timeout => {
+ let addr = self
+ .inner
+ .ipv4_multicast_groups
+ .iter()
+ .nth(next_index)
+ .map(|(addr, ())| *addr);
+
+ match addr {
+ Some(addr) => {
+ if let Some(pkt) = self.inner.igmp_report_packet(version, addr) {
+ // Send initial membership report
+ if let Some(tx_token) = device.transmit(self.inner.now) {
+ // NOTE(unwrap): packet destination is multicast, which is always routable and doesn't require neighbor discovery.
+ self.inner
+ .dispatch_ip(
+ tx_token,
+ PacketMeta::default(),
+ pkt,
+ &mut self.fragmenter,
+ )
+ .unwrap();
+ } else {
+ return false;
+ }
+ }
+
+ let next_timeout = (timeout + interval).max(self.inner.now);
+ self.inner.igmp_report_state = IgmpReportState::ToGeneralQuery {
+ version,
+ timeout: next_timeout,
+ interval,
+ next_index: next_index + 1,
+ };
+ true
+ }
+
+ None => {
+ self.inner.igmp_report_state = IgmpReportState::Inactive;
+ false
+ }
+ }
+ }
+ _ => false,
+ }
+ }
+}
+
+impl InterfaceInner {
+ /// Host duties of the **IGMPv2** protocol.
+ ///
+ /// Sets up `igmp_report_state` for responding to IGMP general/specific membership queries.
+ /// Membership must not be reported immediately in order to avoid flooding the network
+ /// after a query is broadcasted by a router; this is not currently done.
+ pub(super) fn process_igmp<'frame>(
+ &mut self,
+ ipv4_repr: Ipv4Repr,
+ ip_payload: &'frame [u8],
+ ) -> Option<Packet<'frame>> {
+ let igmp_packet = check!(IgmpPacket::new_checked(ip_payload));
+ let igmp_repr = check!(IgmpRepr::parse(&igmp_packet));
+
+ // FIXME: report membership after a delay
+ match igmp_repr {
+ IgmpRepr::MembershipQuery {
+ group_addr,
+ version,
+ max_resp_time,
+ } => {
+ // General query
+ if group_addr.is_unspecified()
+ && ipv4_repr.dst_addr == Ipv4Address::MULTICAST_ALL_SYSTEMS
+ {
+ // Are we member in any groups?
+ if self.ipv4_multicast_groups.iter().next().is_some() {
+ let interval = match version {
+ IgmpVersion::Version1 => Duration::from_millis(100),
+ IgmpVersion::Version2 => {
+ // No dependence on a random generator
+ // (see [#24](https://github.com/m-labs/smoltcp/issues/24))
+ // but at least spread reports evenly across max_resp_time.
+ let intervals = self.ipv4_multicast_groups.len() as u32 + 1;
+ max_resp_time / intervals
+ }
+ };
+ self.igmp_report_state = IgmpReportState::ToGeneralQuery {
+ version,
+ timeout: self.now + interval,
+ interval,
+ next_index: 0,
+ };
+ }
+ } else {
+ // Group-specific query
+ if self.has_multicast_group(group_addr) && ipv4_repr.dst_addr == group_addr {
+ // Don't respond immediately
+ let timeout = max_resp_time / 4;
+ self.igmp_report_state = IgmpReportState::ToSpecificQuery {
+ version,
+ timeout: self.now + timeout,
+ group: group_addr,
+ };
+ }
+ }
+ }
+ // Ignore membership reports
+ IgmpRepr::MembershipReport { .. } => (),
+ // Ignore hosts leaving groups
+ IgmpRepr::LeaveGroup { .. } => (),
+ }
+
+ None
+ }
+}
diff --git a/src/iface/interface/ipv4.rs b/src/iface/interface/ipv4.rs
new file mode 100644
index 0000000..7569572
--- /dev/null
+++ b/src/iface/interface/ipv4.rs
@@ -0,0 +1,445 @@
+use super::*;
+
+#[cfg(feature = "socket-dhcpv4")]
+use crate::socket::dhcpv4;
+#[cfg(feature = "socket-icmp")]
+use crate::socket::icmp;
+use crate::socket::AnySocket;
+
+use crate::phy::{Medium, TxToken};
+use crate::time::Instant;
+use crate::wire::*;
+
+impl InterfaceInner {
+ pub(super) fn process_ipv4<'a>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: PacketMeta,
+ ipv4_packet: &Ipv4Packet<&'a [u8]>,
+ frag: &'a mut FragmentsBuffer,
+ ) -> Option<Packet<'a>> {
+ let ipv4_repr = check!(Ipv4Repr::parse(ipv4_packet, &self.caps.checksum));
+ if !self.is_unicast_v4(ipv4_repr.src_addr) && !ipv4_repr.src_addr.is_unspecified() {
+ // Discard packets with non-unicast source addresses but allow unspecified
+ net_debug!("non-unicast or unspecified source address");
+ return None;
+ }
+
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ let ip_payload = {
+ if ipv4_packet.more_frags() || ipv4_packet.frag_offset() != 0 {
+ let key = FragKey::Ipv4(ipv4_packet.get_key());
+
+ let f = match frag.assembler.get(&key, self.now + frag.reassembly_timeout) {
+ Ok(f) => f,
+ Err(_) => {
+ net_debug!("No available packet assembler for fragmented packet");
+ return None;
+ }
+ };
+
+ if !ipv4_packet.more_frags() {
+ // This is the last fragment, so we know the total size
+ check!(f.set_total_size(
+ ipv4_packet.total_len() as usize - ipv4_packet.header_len() as usize
+ + ipv4_packet.frag_offset() as usize,
+ ));
+ }
+
+ if let Err(e) = f.add(ipv4_packet.payload(), ipv4_packet.frag_offset() as usize) {
+ net_debug!("fragmentation error: {:?}", e);
+ return None;
+ }
+
+ // NOTE: according to the standard, the total length needs to be
+ // recomputed, as well as the checksum. However, we don't really use
+ // the IPv4 header after the packet is reassembled.
+ match f.assemble() {
+ Some(payload) => payload,
+ None => return None,
+ }
+ } else {
+ ipv4_packet.payload()
+ }
+ };
+
+ #[cfg(not(feature = "proto-ipv4-fragmentation"))]
+ let ip_payload = ipv4_packet.payload();
+
+ let ip_repr = IpRepr::Ipv4(ipv4_repr);
+
+ #[cfg(feature = "socket-raw")]
+ let handled_by_raw_socket = self.raw_socket_filter(sockets, &ip_repr, ip_payload);
+ #[cfg(not(feature = "socket-raw"))]
+ let handled_by_raw_socket = false;
+
+ #[cfg(feature = "socket-dhcpv4")]
+ {
+ if ipv4_repr.next_header == IpProtocol::Udp
+ && matches!(self.caps.medium, Medium::Ethernet)
+ {
+ let udp_packet = check!(UdpPacket::new_checked(ip_payload));
+ if let Some(dhcp_socket) = sockets
+ .items_mut()
+ .find_map(|i| dhcpv4::Socket::downcast_mut(&mut i.socket))
+ {
+ // First check for source and dest ports, then do `UdpRepr::parse` if they match.
+ // This way we avoid validating the UDP checksum twice for all non-DHCP UDP packets (one here, one in `process_udp`)
+ if udp_packet.src_port() == dhcp_socket.server_port
+ && udp_packet.dst_port() == dhcp_socket.client_port
+ {
+ let (src_addr, dst_addr) = (ip_repr.src_addr(), ip_repr.dst_addr());
+ let udp_repr = check!(UdpRepr::parse(
+ &udp_packet,
+ &src_addr,
+ &dst_addr,
+ &self.caps.checksum
+ ));
+ let udp_payload = udp_packet.payload();
+
+ dhcp_socket.process(self, &ipv4_repr, &udp_repr, udp_payload);
+ return None;
+ }
+ }
+ }
+ }
+
+ if !self.has_ip_addr(ipv4_repr.dst_addr)
+ && !self.has_multicast_group(ipv4_repr.dst_addr)
+ && !self.is_broadcast_v4(ipv4_repr.dst_addr)
+ {
+ // Ignore IP packets not directed at us, or broadcast, or any of the multicast groups.
+ // If AnyIP is enabled, also check if the packet is routed locally.
+ if !self.any_ip
+ || !ipv4_repr.dst_addr.is_unicast()
+ || self
+ .routes
+ .lookup(&IpAddress::Ipv4(ipv4_repr.dst_addr), self.now)
+ .map_or(true, |router_addr| !self.has_ip_addr(router_addr))
+ {
+ return None;
+ }
+ }
+
+ match ipv4_repr.next_header {
+ IpProtocol::Icmp => self.process_icmpv4(sockets, ip_repr, ip_payload),
+
+ #[cfg(feature = "proto-igmp")]
+ IpProtocol::Igmp => self.process_igmp(ipv4_repr, ip_payload),
+
+ #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
+ IpProtocol::Udp => {
+ let udp_packet = check!(UdpPacket::new_checked(ip_payload));
+ let udp_repr = check!(UdpRepr::parse(
+ &udp_packet,
+ &ipv4_repr.src_addr.into(),
+ &ipv4_repr.dst_addr.into(),
+ &self.checksum_caps(),
+ ));
+
+ self.process_udp(
+ sockets,
+ meta,
+ ip_repr,
+ udp_repr,
+ handled_by_raw_socket,
+ udp_packet.payload(),
+ ip_payload,
+ )
+ }
+
+ #[cfg(feature = "socket-tcp")]
+ IpProtocol::Tcp => self.process_tcp(sockets, ip_repr, ip_payload),
+
+ _ if handled_by_raw_socket => None,
+
+ _ => {
+ // Send back as much of the original payload as we can.
+ let payload_len =
+ icmp_reply_payload_len(ip_payload.len(), IPV4_MIN_MTU, ipv4_repr.buffer_len());
+ let icmp_reply_repr = Icmpv4Repr::DstUnreachable {
+ reason: Icmpv4DstUnreachable::ProtoUnreachable,
+ header: ipv4_repr,
+ data: &ip_payload[0..payload_len],
+ };
+ self.icmpv4_reply(ipv4_repr, icmp_reply_repr)
+ }
+ }
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ pub(super) fn process_arp<'frame>(
+ &mut self,
+ timestamp: Instant,
+ eth_frame: &EthernetFrame<&'frame [u8]>,
+ ) -> Option<EthernetPacket<'frame>> {
+ let arp_packet = check!(ArpPacket::new_checked(eth_frame.payload()));
+ let arp_repr = check!(ArpRepr::parse(&arp_packet));
+
+ match arp_repr {
+ ArpRepr::EthernetIpv4 {
+ operation,
+ source_hardware_addr,
+ source_protocol_addr,
+ target_protocol_addr,
+ ..
+ } => {
+ // Only process ARP packets for us.
+ if !self.has_ip_addr(target_protocol_addr) {
+ return None;
+ }
+
+ // Only process REQUEST and RESPONSE.
+ if let ArpOperation::Unknown(_) = operation {
+ net_debug!("arp: unknown operation code");
+ return None;
+ }
+
+ // Discard packets with non-unicast source addresses.
+ if !source_protocol_addr.is_unicast() || !source_hardware_addr.is_unicast() {
+ net_debug!("arp: non-unicast source address");
+ return None;
+ }
+
+ if !self.in_same_network(&IpAddress::Ipv4(source_protocol_addr)) {
+ net_debug!("arp: source IP address not in same network as us");
+ return None;
+ }
+
+ // Fill the ARP cache from any ARP packet aimed at us (both request or response).
+ // We fill from requests too because if someone is requesting our address they
+ // are probably going to talk to us, so we avoid having to request their address
+ // when we later reply to them.
+ self.neighbor_cache.fill(
+ source_protocol_addr.into(),
+ source_hardware_addr.into(),
+ timestamp,
+ );
+
+ if operation == ArpOperation::Request {
+ let src_hardware_addr = self.hardware_addr.ethernet_or_panic();
+
+ Some(EthernetPacket::Arp(ArpRepr::EthernetIpv4 {
+ operation: ArpOperation::Reply,
+ source_hardware_addr: src_hardware_addr,
+ source_protocol_addr: target_protocol_addr,
+ target_hardware_addr: source_hardware_addr,
+ target_protocol_addr: source_protocol_addr,
+ }))
+ } else {
+ None
+ }
+ }
+ }
+ }
+
+ pub(super) fn process_icmpv4<'frame>(
+ &mut self,
+ _sockets: &mut SocketSet,
+ ip_repr: IpRepr,
+ ip_payload: &'frame [u8],
+ ) -> Option<Packet<'frame>> {
+ let icmp_packet = check!(Icmpv4Packet::new_checked(ip_payload));
+ let icmp_repr = check!(Icmpv4Repr::parse(&icmp_packet, &self.caps.checksum));
+
+ #[cfg(feature = "socket-icmp")]
+ let mut handled_by_icmp_socket = false;
+
+ #[cfg(all(feature = "socket-icmp", feature = "proto-ipv4"))]
+ for icmp_socket in _sockets
+ .items_mut()
+ .filter_map(|i| icmp::Socket::downcast_mut(&mut i.socket))
+ {
+ if icmp_socket.accepts(self, &ip_repr, &icmp_repr.into()) {
+ icmp_socket.process(self, &ip_repr, &icmp_repr.into());
+ handled_by_icmp_socket = true;
+ }
+ }
+
+ match icmp_repr {
+ // Respond to echo requests.
+ #[cfg(feature = "proto-ipv4")]
+ Icmpv4Repr::EchoRequest {
+ ident,
+ seq_no,
+ data,
+ } => {
+ let icmp_reply_repr = Icmpv4Repr::EchoReply {
+ ident,
+ seq_no,
+ data,
+ };
+ match ip_repr {
+ IpRepr::Ipv4(ipv4_repr) => self.icmpv4_reply(ipv4_repr, icmp_reply_repr),
+ #[allow(unreachable_patterns)]
+ _ => unreachable!(),
+ }
+ }
+
+ // Ignore any echo replies.
+ Icmpv4Repr::EchoReply { .. } => None,
+
+ // Don't report an error if a packet with unknown type
+ // has been handled by an ICMP socket
+ #[cfg(feature = "socket-icmp")]
+ _ if handled_by_icmp_socket => None,
+
+ // FIXME: do something correct here?
+ _ => None,
+ }
+ }
+
+ pub(super) fn icmpv4_reply<'frame, 'icmp: 'frame>(
+ &self,
+ ipv4_repr: Ipv4Repr,
+ icmp_repr: Icmpv4Repr<'icmp>,
+ ) -> Option<Packet<'frame>> {
+ if !self.is_unicast_v4(ipv4_repr.src_addr) {
+ // Do not send ICMP replies to non-unicast sources
+ None
+ } else if self.is_unicast_v4(ipv4_repr.dst_addr) {
+ // Reply as normal when src_addr and dst_addr are both unicast
+ let ipv4_reply_repr = Ipv4Repr {
+ src_addr: ipv4_repr.dst_addr,
+ dst_addr: ipv4_repr.src_addr,
+ next_header: IpProtocol::Icmp,
+ payload_len: icmp_repr.buffer_len(),
+ hop_limit: 64,
+ };
+ Some(Packet::new_ipv4(
+ ipv4_reply_repr,
+ IpPayload::Icmpv4(icmp_repr),
+ ))
+ } else if self.is_broadcast_v4(ipv4_repr.dst_addr) {
+ // Only reply to broadcasts for echo replies and not other ICMP messages
+ match icmp_repr {
+ Icmpv4Repr::EchoReply { .. } => match self.ipv4_addr() {
+ Some(src_addr) => {
+ let ipv4_reply_repr = Ipv4Repr {
+ src_addr,
+ dst_addr: ipv4_repr.src_addr,
+ next_header: IpProtocol::Icmp,
+ payload_len: icmp_repr.buffer_len(),
+ hop_limit: 64,
+ };
+ Some(Packet::new_ipv4(
+ ipv4_reply_repr,
+ IpPayload::Icmpv4(icmp_repr),
+ ))
+ }
+ None => None,
+ },
+ _ => None,
+ }
+ } else {
+ None
+ }
+ }
+
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ pub(super) fn dispatch_ipv4_frag<Tx: TxToken>(&mut self, tx_token: Tx, frag: &mut Fragmenter) {
+ let caps = self.caps.clone();
+
+ let mtu_max = self.ip_mtu();
+ let ip_len = (frag.packet_len - frag.sent_bytes + frag.ipv4.repr.buffer_len()).min(mtu_max);
+ let payload_len = ip_len - frag.ipv4.repr.buffer_len();
+
+ let more_frags = (frag.packet_len - frag.sent_bytes) != payload_len;
+ frag.ipv4.repr.payload_len = payload_len;
+ frag.sent_bytes += payload_len;
+
+ let mut tx_len = ip_len;
+ #[cfg(feature = "medium-ethernet")]
+ if matches!(caps.medium, Medium::Ethernet) {
+ tx_len += EthernetFrame::<&[u8]>::header_len();
+ }
+
+ // Emit function for the Ethernet header.
+ #[cfg(feature = "medium-ethernet")]
+ let emit_ethernet = |repr: &IpRepr, tx_buffer: &mut [u8]| {
+ let mut frame = EthernetFrame::new_unchecked(tx_buffer);
+
+ let src_addr = self.hardware_addr.ethernet_or_panic();
+ frame.set_src_addr(src_addr);
+ frame.set_dst_addr(frag.ipv4.dst_hardware_addr);
+
+ match repr.version() {
+ #[cfg(feature = "proto-ipv4")]
+ IpVersion::Ipv4 => frame.set_ethertype(EthernetProtocol::Ipv4),
+ #[cfg(feature = "proto-ipv6")]
+ IpVersion::Ipv6 => frame.set_ethertype(EthernetProtocol::Ipv6),
+ }
+ };
+
+ tx_token.consume(tx_len, |mut tx_buffer| {
+ #[cfg(feature = "medium-ethernet")]
+ if matches!(self.caps.medium, Medium::Ethernet) {
+ emit_ethernet(&IpRepr::Ipv4(frag.ipv4.repr), tx_buffer);
+ tx_buffer = &mut tx_buffer[EthernetFrame::<&[u8]>::header_len()..];
+ }
+
+ let mut packet =
+ Ipv4Packet::new_unchecked(&mut tx_buffer[..frag.ipv4.repr.buffer_len()]);
+ frag.ipv4.repr.emit(&mut packet, &caps.checksum);
+ packet.set_ident(frag.ipv4.ident);
+ packet.set_more_frags(more_frags);
+ packet.set_dont_frag(false);
+ packet.set_frag_offset(frag.ipv4.frag_offset);
+
+ if caps.checksum.ipv4.tx() {
+ packet.fill_checksum();
+ }
+
+ tx_buffer[frag.ipv4.repr.buffer_len()..][..payload_len].copy_from_slice(
+ &frag.buffer[frag.ipv4.frag_offset as usize + frag.ipv4.repr.buffer_len()..]
+ [..payload_len],
+ );
+
+ // Update the frag offset for the next fragment.
+ frag.ipv4.frag_offset += payload_len as u16;
+ })
+ }
+
+ #[cfg(feature = "proto-igmp")]
+ pub(super) fn igmp_report_packet<'any>(
+ &self,
+ version: IgmpVersion,
+ group_addr: Ipv4Address,
+ ) -> Option<Packet<'any>> {
+ let iface_addr = self.ipv4_addr()?;
+ let igmp_repr = IgmpRepr::MembershipReport {
+ group_addr,
+ version,
+ };
+ let pkt = Packet::new_ipv4(
+ Ipv4Repr {
+ src_addr: iface_addr,
+ // Send to the group being reported
+ dst_addr: group_addr,
+ next_header: IpProtocol::Igmp,
+ payload_len: igmp_repr.buffer_len(),
+ hop_limit: 1,
+ // [#183](https://github.com/m-labs/smoltcp/issues/183).
+ },
+ IpPayload::Igmp(igmp_repr),
+ );
+ Some(pkt)
+ }
+
+ #[cfg(feature = "proto-igmp")]
+ pub(super) fn igmp_leave_packet<'any>(&self, group_addr: Ipv4Address) -> Option<Packet<'any>> {
+ self.ipv4_addr().map(|iface_addr| {
+ let igmp_repr = IgmpRepr::LeaveGroup { group_addr };
+ Packet::new_ipv4(
+ Ipv4Repr {
+ src_addr: iface_addr,
+ dst_addr: Ipv4Address::MULTICAST_ALL_ROUTERS,
+ next_header: IpProtocol::Igmp,
+ payload_len: igmp_repr.buffer_len(),
+ hop_limit: 1,
+ },
+ IpPayload::Igmp(igmp_repr),
+ )
+ })
+ }
+}
diff --git a/src/iface/interface/ipv6.rs b/src/iface/interface/ipv6.rs
new file mode 100644
index 0000000..22e65b9
--- /dev/null
+++ b/src/iface/interface/ipv6.rs
@@ -0,0 +1,355 @@
+use super::*;
+
+#[cfg(feature = "socket-icmp")]
+use crate::socket::icmp;
+use crate::socket::AnySocket;
+
+use crate::phy::PacketMeta;
+use crate::wire::*;
+
+/// Enum used for the process_hopbyhop function. In some cases, when discarding a packet, an ICMMP
+/// parameter problem message needs to be transmitted to the source of the address. In other cases,
+/// the processing of the IP packet can continue.
+#[allow(clippy::large_enum_variant)]
+enum HopByHopResponse<'frame> {
+ /// Continue processing the IPv6 packet.
+ Continue((IpProtocol, &'frame [u8])),
+ /// Discard the packet and maybe send back an ICMPv6 packet.
+ Discard(Option<Packet<'frame>>),
+}
+
+// We implement `Default` such that we can use the check! macro.
+impl Default for HopByHopResponse<'_> {
+ fn default() -> Self {
+ Self::Discard(None)
+ }
+}
+
+impl InterfaceInner {
+ pub(super) fn process_ipv6<'frame>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: PacketMeta,
+ ipv6_packet: &Ipv6Packet<&'frame [u8]>,
+ ) -> Option<Packet<'frame>> {
+ let ipv6_repr = check!(Ipv6Repr::parse(ipv6_packet));
+
+ if !ipv6_repr.src_addr.is_unicast() {
+ // Discard packets with non-unicast source addresses.
+ net_debug!("non-unicast source address");
+ return None;
+ }
+
+ let (next_header, ip_payload) = if ipv6_repr.next_header == IpProtocol::HopByHop {
+ match self.process_hopbyhop(ipv6_repr, ipv6_packet.payload()) {
+ HopByHopResponse::Discard(e) => return e,
+ HopByHopResponse::Continue(next) => next,
+ }
+ } else {
+ (ipv6_repr.next_header, ipv6_packet.payload())
+ };
+
+ if !self.has_ip_addr(ipv6_repr.dst_addr)
+ && !self.has_multicast_group(ipv6_repr.dst_addr)
+ && !ipv6_repr.dst_addr.is_loopback()
+ {
+ net_trace!("packet IP address not for this interface");
+ return None;
+ }
+
+ #[cfg(feature = "socket-raw")]
+ let handled_by_raw_socket = self.raw_socket_filter(sockets, &ipv6_repr.into(), ip_payload);
+ #[cfg(not(feature = "socket-raw"))]
+ let handled_by_raw_socket = false;
+
+ self.process_nxt_hdr(
+ sockets,
+ meta,
+ ipv6_repr,
+ next_header,
+ handled_by_raw_socket,
+ ip_payload,
+ )
+ }
+
+ fn process_hopbyhop<'frame>(
+ &mut self,
+ ipv6_repr: Ipv6Repr,
+ ip_payload: &'frame [u8],
+ ) -> HopByHopResponse<'frame> {
+ let param_problem = || {
+ let payload_len =
+ icmp_reply_payload_len(ip_payload.len(), IPV6_MIN_MTU, ipv6_repr.buffer_len());
+ self.icmpv6_reply(
+ ipv6_repr,
+ Icmpv6Repr::ParamProblem {
+ reason: Icmpv6ParamProblem::UnrecognizedOption,
+ pointer: ipv6_repr.buffer_len() as u32,
+ header: ipv6_repr,
+ data: &ip_payload[0..payload_len],
+ },
+ )
+ };
+
+ let ext_hdr = check!(Ipv6ExtHeader::new_checked(ip_payload));
+ let ext_repr = check!(Ipv6ExtHeaderRepr::parse(&ext_hdr));
+ let hbh_hdr = check!(Ipv6HopByHopHeader::new_checked(ext_repr.data));
+ let hbh_repr = check!(Ipv6HopByHopRepr::parse(&hbh_hdr));
+
+ for opt_repr in &hbh_repr.options {
+ match opt_repr {
+ Ipv6OptionRepr::Pad1 | Ipv6OptionRepr::PadN(_) => (),
+ #[cfg(feature = "proto-rpl")]
+ Ipv6OptionRepr::Rpl(_) => {}
+
+ Ipv6OptionRepr::Unknown { type_, .. } => {
+ match Ipv6OptionFailureType::from(*type_) {
+ Ipv6OptionFailureType::Skip => (),
+ Ipv6OptionFailureType::Discard => {
+ return HopByHopResponse::Discard(None);
+ }
+ Ipv6OptionFailureType::DiscardSendAll => {
+ return HopByHopResponse::Discard(param_problem());
+ }
+ Ipv6OptionFailureType::DiscardSendUnicast
+ if !ipv6_repr.dst_addr.is_multicast() =>
+ {
+ return HopByHopResponse::Discard(param_problem());
+ }
+ _ => unreachable!(),
+ }
+ }
+ }
+ }
+
+ HopByHopResponse::Continue((
+ ext_repr.next_header,
+ &ip_payload[ext_repr.header_len() + ext_repr.data.len()..],
+ ))
+ }
+
+ /// Given the next header value forward the payload onto the correct process
+ /// function.
+ fn process_nxt_hdr<'frame>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: PacketMeta,
+ ipv6_repr: Ipv6Repr,
+ nxt_hdr: IpProtocol,
+ handled_by_raw_socket: bool,
+ ip_payload: &'frame [u8],
+ ) -> Option<Packet<'frame>> {
+ match nxt_hdr {
+ IpProtocol::Icmpv6 => self.process_icmpv6(sockets, ipv6_repr.into(), ip_payload),
+
+ #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
+ IpProtocol::Udp => {
+ let udp_packet = check!(UdpPacket::new_checked(ip_payload));
+ let udp_repr = check!(UdpRepr::parse(
+ &udp_packet,
+ &ipv6_repr.src_addr.into(),
+ &ipv6_repr.dst_addr.into(),
+ &self.checksum_caps(),
+ ));
+
+ self.process_udp(
+ sockets,
+ meta,
+ ipv6_repr.into(),
+ udp_repr,
+ handled_by_raw_socket,
+ udp_packet.payload(),
+ ip_payload,
+ )
+ }
+
+ #[cfg(feature = "socket-tcp")]
+ IpProtocol::Tcp => self.process_tcp(sockets, ipv6_repr.into(), ip_payload),
+
+ #[cfg(feature = "socket-raw")]
+ _ if handled_by_raw_socket => None,
+
+ _ => {
+ // Send back as much of the original payload as we can.
+ let payload_len =
+ icmp_reply_payload_len(ip_payload.len(), IPV6_MIN_MTU, ipv6_repr.buffer_len());
+ let icmp_reply_repr = Icmpv6Repr::ParamProblem {
+ reason: Icmpv6ParamProblem::UnrecognizedNxtHdr,
+ // The offending packet is after the IPv6 header.
+ pointer: ipv6_repr.buffer_len() as u32,
+ header: ipv6_repr,
+ data: &ip_payload[0..payload_len],
+ };
+ self.icmpv6_reply(ipv6_repr, icmp_reply_repr)
+ }
+ }
+ }
+
+ pub(super) fn process_icmpv6<'frame>(
+ &mut self,
+ _sockets: &mut SocketSet,
+ ip_repr: IpRepr,
+ ip_payload: &'frame [u8],
+ ) -> Option<Packet<'frame>> {
+ let icmp_packet = check!(Icmpv6Packet::new_checked(ip_payload));
+ let icmp_repr = check!(Icmpv6Repr::parse(
+ &ip_repr.src_addr(),
+ &ip_repr.dst_addr(),
+ &icmp_packet,
+ &self.caps.checksum,
+ ));
+
+ #[cfg(feature = "socket-icmp")]
+ let mut handled_by_icmp_socket = false;
+
+ #[cfg(feature = "socket-icmp")]
+ for icmp_socket in _sockets
+ .items_mut()
+ .filter_map(|i| icmp::Socket::downcast_mut(&mut i.socket))
+ {
+ if icmp_socket.accepts(self, &ip_repr, &icmp_repr.into()) {
+ icmp_socket.process(self, &ip_repr, &icmp_repr.into());
+ handled_by_icmp_socket = true;
+ }
+ }
+
+ match icmp_repr {
+ // Respond to echo requests.
+ Icmpv6Repr::EchoRequest {
+ ident,
+ seq_no,
+ data,
+ } => match ip_repr {
+ IpRepr::Ipv6(ipv6_repr) => {
+ let icmp_reply_repr = Icmpv6Repr::EchoReply {
+ ident,
+ seq_no,
+ data,
+ };
+ self.icmpv6_reply(ipv6_repr, icmp_reply_repr)
+ }
+ #[allow(unreachable_patterns)]
+ _ => unreachable!(),
+ },
+
+ // Ignore any echo replies.
+ Icmpv6Repr::EchoReply { .. } => None,
+
+ // Forward any NDISC packets to the ndisc packet handler
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ Icmpv6Repr::Ndisc(repr) if ip_repr.hop_limit() == 0xff => match ip_repr {
+ IpRepr::Ipv6(ipv6_repr) => match self.caps.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => self.process_ndisc(ipv6_repr, repr),
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => self.process_ndisc(ipv6_repr, repr),
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => None,
+ },
+ #[allow(unreachable_patterns)]
+ _ => unreachable!(),
+ },
+
+ // Don't report an error if a packet with unknown type
+ // has been handled by an ICMP socket
+ #[cfg(feature = "socket-icmp")]
+ _ if handled_by_icmp_socket => None,
+
+ // FIXME: do something correct here?
+ _ => None,
+ }
+ }
+
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ pub(super) fn process_ndisc<'frame>(
+ &mut self,
+ ip_repr: Ipv6Repr,
+ repr: NdiscRepr<'frame>,
+ ) -> Option<Packet<'frame>> {
+ match repr {
+ NdiscRepr::NeighborAdvert {
+ lladdr,
+ target_addr,
+ flags,
+ } => {
+ let ip_addr = ip_repr.src_addr.into();
+ if let Some(lladdr) = lladdr {
+ let lladdr = check!(lladdr.parse(self.caps.medium));
+ if !lladdr.is_unicast() || !target_addr.is_unicast() {
+ return None;
+ }
+ if flags.contains(NdiscNeighborFlags::OVERRIDE)
+ || !self.neighbor_cache.lookup(&ip_addr, self.now).found()
+ {
+ self.neighbor_cache.fill(ip_addr, lladdr, self.now)
+ }
+ }
+ None
+ }
+ NdiscRepr::NeighborSolicit {
+ target_addr,
+ lladdr,
+ ..
+ } => {
+ if let Some(lladdr) = lladdr {
+ let lladdr = check!(lladdr.parse(self.caps.medium));
+ if !lladdr.is_unicast() || !target_addr.is_unicast() {
+ return None;
+ }
+ self.neighbor_cache
+ .fill(ip_repr.src_addr.into(), lladdr, self.now);
+ }
+
+ if self.has_solicited_node(ip_repr.dst_addr) && self.has_ip_addr(target_addr) {
+ let advert = Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert {
+ flags: NdiscNeighborFlags::SOLICITED,
+ target_addr,
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ lladdr: Some(self.hardware_addr.into()),
+ });
+ let ip_repr = Ipv6Repr {
+ src_addr: target_addr,
+ dst_addr: ip_repr.src_addr,
+ next_header: IpProtocol::Icmpv6,
+ hop_limit: 0xff,
+ payload_len: advert.buffer_len(),
+ };
+ Some(Packet::new_ipv6(ip_repr, IpPayload::Icmpv6(advert)))
+ } else {
+ None
+ }
+ }
+ _ => None,
+ }
+ }
+
+ pub(super) fn icmpv6_reply<'frame, 'icmp: 'frame>(
+ &self,
+ ipv6_repr: Ipv6Repr,
+ icmp_repr: Icmpv6Repr<'icmp>,
+ ) -> Option<Packet<'frame>> {
+ let src_addr = ipv6_repr.dst_addr;
+ let dst_addr = ipv6_repr.src_addr;
+
+ let src_addr = if src_addr.is_unicast() {
+ src_addr
+ } else if let Some(addr) = self.get_source_address_ipv6(&dst_addr) {
+ addr
+ } else {
+ net_debug!("no suitable source address found");
+ return None;
+ };
+
+ let ipv6_reply_repr = Ipv6Repr {
+ src_addr,
+ dst_addr,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: icmp_repr.buffer_len(),
+ hop_limit: 64,
+ };
+ Some(Packet::new_ipv6(
+ ipv6_reply_repr,
+ IpPayload::Icmpv6(icmp_repr),
+ ))
+ }
+}
diff --git a/src/iface/interface/mod.rs b/src/iface/interface/mod.rs
new file mode 100644
index 0000000..7d6bdc8
--- /dev/null
+++ b/src/iface/interface/mod.rs
@@ -0,0 +1,1644 @@
+// Heads up! Before working on this file you should read the parts
+// of RFC 1122 that discuss Ethernet, ARP and IP for any IPv4 work
+// and RFCs 8200 and 4861 for any IPv6 and NDISC work.
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "medium-ethernet")]
+mod ethernet;
+#[cfg(feature = "medium-ieee802154")]
+mod ieee802154;
+
+#[cfg(feature = "proto-ipv4")]
+mod ipv4;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6;
+#[cfg(feature = "proto-sixlowpan")]
+mod sixlowpan;
+
+#[cfg(feature = "proto-igmp")]
+mod igmp;
+
+#[cfg(feature = "proto-igmp")]
+pub use igmp::MulticastError;
+
+use super::packet::*;
+
+use core::result::Result;
+use heapless::{LinearMap, Vec};
+
+#[cfg(feature = "_proto-fragmentation")]
+use super::fragmentation::FragKey;
+#[cfg(any(feature = "proto-ipv4", feature = "proto-sixlowpan"))]
+use super::fragmentation::PacketAssemblerSet;
+use super::fragmentation::{Fragmenter, FragmentsBuffer};
+
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+use super::neighbor::{Answer as NeighborAnswer, Cache as NeighborCache};
+use super::socket_set::SocketSet;
+use crate::config::{
+ IFACE_MAX_ADDR_COUNT, IFACE_MAX_MULTICAST_GROUP_COUNT,
+ IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT,
+};
+use crate::iface::Routes;
+use crate::phy::PacketMeta;
+use crate::phy::{ChecksumCapabilities, Device, DeviceCapabilities, Medium, RxToken, TxToken};
+use crate::rand::Rand;
+#[cfg(feature = "socket-dns")]
+use crate::socket::dns;
+use crate::socket::*;
+use crate::time::{Duration, Instant};
+
+use crate::wire::*;
+
+macro_rules! check {
+ ($e:expr) => {
+ match $e {
+ Ok(x) => x,
+ Err(_) => {
+ // concat!/stringify! doesn't work with defmt macros
+ #[cfg(not(feature = "defmt"))]
+ net_trace!(concat!("iface: malformed ", stringify!($e)));
+ #[cfg(feature = "defmt")]
+ net_trace!("iface: malformed");
+ return Default::default();
+ }
+ }
+ };
+}
+use check;
+
+/// A network interface.
+///
+/// The network interface logically owns a number of other data structures; to avoid
+/// a dependency on heap allocation, it instead owns a `BorrowMut<[T]>`, which can be
+/// a `&mut [T]`, or `Vec<T>` if a heap is available.
+pub struct Interface {
+ pub(crate) inner: InterfaceInner,
+ fragments: FragmentsBuffer,
+ fragmenter: Fragmenter,
+}
+
+/// The device independent part of an Ethernet network interface.
+///
+/// Separating the device from the data required for processing and dispatching makes
+/// it possible to borrow them independently. For example, the tx and rx tokens borrow
+/// the `device` mutably until they're used, which makes it impossible to call other
+/// methods on the `Interface` in this time (since its `device` field is borrowed
+/// exclusively). However, it is still possible to call methods on its `inner` field.
+pub struct InterfaceInner {
+ caps: DeviceCapabilities,
+ now: Instant,
+ rand: Rand,
+
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ neighbor_cache: NeighborCache,
+ hardware_addr: HardwareAddress,
+ #[cfg(feature = "medium-ieee802154")]
+ sequence_no: u8,
+ #[cfg(feature = "medium-ieee802154")]
+ pan_id: Option<Ieee802154Pan>,
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ ipv4_id: u16,
+ #[cfg(feature = "proto-sixlowpan")]
+ sixlowpan_address_context:
+ Vec<SixlowpanAddressContext, IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT>,
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ tag: u16,
+ ip_addrs: Vec<IpCidr, IFACE_MAX_ADDR_COUNT>,
+ #[cfg(feature = "proto-ipv4")]
+ any_ip: bool,
+ routes: Routes,
+ #[cfg(feature = "proto-igmp")]
+ ipv4_multicast_groups: LinearMap<Ipv4Address, (), IFACE_MAX_MULTICAST_GROUP_COUNT>,
+ /// When to report for (all or) the next multicast group membership via IGMP
+ #[cfg(feature = "proto-igmp")]
+ igmp_report_state: IgmpReportState,
+}
+
+/// Configuration structure used for creating a network interface.
+#[non_exhaustive]
+pub struct Config {
+ /// Random seed.
+ ///
+ /// It is strongly recommended that the random seed is different on each boot,
+ /// to avoid problems with TCP port/sequence collisions.
+ ///
+ /// The seed doesn't have to be cryptographically secure.
+ pub random_seed: u64,
+
+ /// Set the Hardware address the interface will use.
+ ///
+ /// # Panics
+ /// Creating the interface panics if the address is not unicast.
+ pub hardware_addr: HardwareAddress,
+
+ /// Set the IEEE802.15.4 PAN ID the interface will use.
+ ///
+ /// **NOTE**: we use the same PAN ID for destination and source.
+ #[cfg(feature = "medium-ieee802154")]
+ pub pan_id: Option<Ieee802154Pan>,
+}
+
+impl Config {
+ pub fn new(hardware_addr: HardwareAddress) -> Self {
+ Config {
+ random_seed: 0,
+ hardware_addr,
+ #[cfg(feature = "medium-ieee802154")]
+ pan_id: None,
+ }
+ }
+}
+
+impl Interface {
+ /// Create a network interface using the previously provided configuration.
+ ///
+ /// # Panics
+ /// This function panics if the [`Config::hardware_address`] does not match
+ /// the medium of the device.
+ pub fn new<D>(config: Config, device: &mut D, now: Instant) -> Self
+ where
+ D: Device + ?Sized,
+ {
+ let caps = device.capabilities();
+ assert_eq!(
+ config.hardware_addr.medium(),
+ caps.medium,
+ "The hardware address does not match the medium of the interface."
+ );
+
+ let mut rand = Rand::new(config.random_seed);
+
+ #[cfg(feature = "medium-ieee802154")]
+ let mut sequence_no;
+ #[cfg(feature = "medium-ieee802154")]
+ loop {
+ sequence_no = (rand.rand_u32() & 0xff) as u8;
+ if sequence_no != 0 {
+ break;
+ }
+ }
+
+ #[cfg(feature = "proto-sixlowpan")]
+ let mut tag;
+
+ #[cfg(feature = "proto-sixlowpan")]
+ loop {
+ tag = rand.rand_u16();
+ if tag != 0 {
+ break;
+ }
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ let mut ipv4_id;
+
+ #[cfg(feature = "proto-ipv4")]
+ loop {
+ ipv4_id = rand.rand_u16();
+ if ipv4_id != 0 {
+ break;
+ }
+ }
+
+ Interface {
+ fragments: FragmentsBuffer {
+ #[cfg(feature = "proto-sixlowpan")]
+ decompress_buf: [0u8; sixlowpan::MAX_DECOMPRESSED_LEN],
+
+ #[cfg(feature = "_proto-fragmentation")]
+ assembler: PacketAssemblerSet::new(),
+ #[cfg(feature = "_proto-fragmentation")]
+ reassembly_timeout: Duration::from_secs(60),
+ },
+ fragmenter: Fragmenter::new(),
+ inner: InterfaceInner {
+ now,
+ caps,
+ hardware_addr: config.hardware_addr,
+ ip_addrs: Vec::new(),
+ #[cfg(feature = "proto-ipv4")]
+ any_ip: false,
+ routes: Routes::new(),
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ neighbor_cache: NeighborCache::new(),
+ #[cfg(feature = "proto-igmp")]
+ ipv4_multicast_groups: LinearMap::new(),
+ #[cfg(feature = "proto-igmp")]
+ igmp_report_state: IgmpReportState::Inactive,
+ #[cfg(feature = "medium-ieee802154")]
+ sequence_no,
+ #[cfg(feature = "medium-ieee802154")]
+ pan_id: config.pan_id,
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ tag,
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ ipv4_id,
+ #[cfg(feature = "proto-sixlowpan")]
+ sixlowpan_address_context: Vec::new(),
+ rand,
+ },
+ }
+ }
+
+ /// Get the socket context.
+ ///
+ /// The context is needed for some socket methods.
+ pub fn context(&mut self) -> &mut InterfaceInner {
+ &mut self.inner
+ }
+
+ /// Get the HardwareAddress address of the interface.
+ ///
+ /// # Panics
+ /// This function panics if the medium is not Ethernet or Ieee802154.
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ pub fn hardware_addr(&self) -> HardwareAddress {
+ #[cfg(all(feature = "medium-ethernet", not(feature = "medium-ieee802154")))]
+ assert!(self.inner.caps.medium == Medium::Ethernet);
+ #[cfg(all(feature = "medium-ieee802154", not(feature = "medium-ethernet")))]
+ assert!(self.inner.caps.medium == Medium::Ieee802154);
+
+ #[cfg(all(feature = "medium-ieee802154", feature = "medium-ethernet"))]
+ assert!(
+ self.inner.caps.medium == Medium::Ethernet
+ || self.inner.caps.medium == Medium::Ieee802154
+ );
+
+ self.inner.hardware_addr
+ }
+
+ /// Set the HardwareAddress address of the interface.
+ ///
+ /// # Panics
+ /// This function panics if the address is not unicast, and if the medium is not Ethernet or
+ /// Ieee802154.
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ pub fn set_hardware_addr(&mut self, addr: HardwareAddress) {
+ #[cfg(all(feature = "medium-ethernet", not(feature = "medium-ieee802154")))]
+ assert!(self.inner.caps.medium == Medium::Ethernet);
+ #[cfg(all(feature = "medium-ieee802154", not(feature = "medium-ethernet")))]
+ assert!(self.inner.caps.medium == Medium::Ieee802154);
+
+ #[cfg(all(feature = "medium-ieee802154", feature = "medium-ethernet"))]
+ assert!(
+ self.inner.caps.medium == Medium::Ethernet
+ || self.inner.caps.medium == Medium::Ieee802154
+ );
+
+ InterfaceInner::check_hardware_addr(&addr);
+ self.inner.hardware_addr = addr;
+ }
+
+ /// Get the IP addresses of the interface.
+ pub fn ip_addrs(&self) -> &[IpCidr] {
+ self.inner.ip_addrs.as_ref()
+ }
+
+ /// Get the first IPv4 address if present.
+ #[cfg(feature = "proto-ipv4")]
+ pub fn ipv4_addr(&self) -> Option<Ipv4Address> {
+ self.inner.ipv4_addr()
+ }
+
+ /// Get the first IPv6 address if present.
+ #[cfg(feature = "proto-ipv6")]
+ pub fn ipv6_addr(&self) -> Option<Ipv6Address> {
+ self.inner.ipv6_addr()
+ }
+
+ /// Get an address from the interface that could be used as source address. For IPv4, this is
+ /// the first IPv4 address from the list of addresses. For IPv6, the address is based on the
+ /// destination address and uses RFC6724 for selecting the source address.
+ pub fn get_source_address(&self, dst_addr: &IpAddress) -> Option<IpAddress> {
+ self.inner.get_source_address(dst_addr)
+ }
+
+ /// Get an address from the interface that could be used as source address. This is the first
+ /// IPv4 address from the list of addresses in the interface.
+ #[cfg(feature = "proto-ipv4")]
+ pub fn get_source_address_ipv4(&self, dst_addr: &Ipv4Address) -> Option<Ipv4Address> {
+ self.inner.get_source_address_ipv4(dst_addr)
+ }
+
+ /// Get an address from the interface that could be used as source address. The selection is
+ /// based on RFC6724.
+ #[cfg(feature = "proto-ipv6")]
+ pub fn get_source_address_ipv6(&self, dst_addr: &Ipv6Address) -> Option<Ipv6Address> {
+ self.inner.get_source_address_ipv6(dst_addr)
+ }
+
+ /// Update the IP addresses of the interface.
+ ///
+ /// # Panics
+ /// This function panics if any of the addresses are not unicast.
+ pub fn update_ip_addrs<F: FnOnce(&mut Vec<IpCidr, IFACE_MAX_ADDR_COUNT>)>(&mut self, f: F) {
+ f(&mut self.inner.ip_addrs);
+ InterfaceInner::flush_cache(&mut self.inner);
+ InterfaceInner::check_ip_addrs(&self.inner.ip_addrs)
+ }
+
+ /// Check whether the interface has the given IP address assigned.
+ pub fn has_ip_addr<T: Into<IpAddress>>(&self, addr: T) -> bool {
+ self.inner.has_ip_addr(addr)
+ }
+
+ pub fn routes(&self) -> &Routes {
+ &self.inner.routes
+ }
+
+ pub fn routes_mut(&mut self) -> &mut Routes {
+ &mut self.inner.routes
+ }
+
+ /// Enable or disable the AnyIP capability.
+ ///
+ /// AnyIP allowins packets to be received
+ /// locally on IPv4 addresses other than the interface's configured [ip_addrs].
+ /// When AnyIP is enabled and a route prefix in [`routes`](Self::routes) specifies one of
+ /// the interface's [`ip_addrs`](Self::ip_addrs) as its gateway, the interface will accept
+ /// packets addressed to that prefix.
+ ///
+ /// # IPv6
+ ///
+ /// This option is not available or required for IPv6 as packets sent to
+ /// the interface are not filtered by IPv6 address.
+ #[cfg(feature = "proto-ipv4")]
+ pub fn set_any_ip(&mut self, any_ip: bool) {
+ self.inner.any_ip = any_ip;
+ }
+
+ /// Get whether AnyIP is enabled.
+ ///
+ /// See [`set_any_ip`](Self::set_any_ip) for details on AnyIP
+ #[cfg(feature = "proto-ipv4")]
+ pub fn any_ip(&self) -> bool {
+ self.inner.any_ip
+ }
+
+ /// Get the 6LoWPAN address contexts.
+ #[cfg(feature = "proto-sixlowpan")]
+ pub fn sixlowpan_address_context(
+ &self,
+ ) -> &Vec<SixlowpanAddressContext, IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT> {
+ &self.inner.sixlowpan_address_context
+ }
+
+ /// Get a mutable reference to the 6LoWPAN address contexts.
+ #[cfg(feature = "proto-sixlowpan")]
+ pub fn sixlowpan_address_context_mut(
+ &mut self,
+ ) -> &mut Vec<SixlowpanAddressContext, IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT> {
+ &mut self.inner.sixlowpan_address_context
+ }
+
+ /// Get the packet reassembly timeout.
+ #[cfg(feature = "_proto-fragmentation")]
+ pub fn reassembly_timeout(&self) -> Duration {
+ self.fragments.reassembly_timeout
+ }
+
+ /// Set the packet reassembly timeout.
+ #[cfg(feature = "_proto-fragmentation")]
+ pub fn set_reassembly_timeout(&mut self, timeout: Duration) {
+ if timeout > Duration::from_secs(60) {
+ net_debug!("RFC 4944 specifies that the reassembly timeout MUST be set to a maximum of 60 seconds");
+ }
+ self.fragments.reassembly_timeout = timeout;
+ }
+
+ /// Transmit packets queued in the given sockets, and receive packets queued
+ /// in the device.
+ ///
+ /// This function returns a boolean value indicating whether any packets were
+ /// processed or emitted, and thus, whether the readiness of any socket might
+ /// have changed.
+ pub fn poll<D>(
+ &mut self,
+ timestamp: Instant,
+ device: &mut D,
+ sockets: &mut SocketSet<'_>,
+ ) -> bool
+ where
+ D: Device + ?Sized,
+ {
+ self.inner.now = timestamp;
+
+ #[cfg(feature = "_proto-fragmentation")]
+ self.fragments.assembler.remove_expired(timestamp);
+
+ match self.inner.caps.medium {
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 =>
+ {
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ if self.sixlowpan_egress(device) {
+ return true;
+ }
+ }
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ip"))]
+ _ =>
+ {
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ if self.ipv4_egress(device) {
+ return true;
+ }
+ }
+ }
+
+ let mut readiness_may_have_changed = false;
+
+ loop {
+ let mut did_something = false;
+ did_something |= self.socket_ingress(device, sockets);
+ did_something |= self.socket_egress(device, sockets);
+
+ #[cfg(feature = "proto-igmp")]
+ {
+ did_something |= self.igmp_egress(device);
+ }
+
+ if did_something {
+ readiness_may_have_changed = true;
+ } else {
+ break;
+ }
+ }
+
+ readiness_may_have_changed
+ }
+
+ /// Return a _soft deadline_ for calling [poll] the next time.
+ /// The [Instant] returned is the time at which you should call [poll] next.
+ /// It is harmless (but wastes energy) to call it before the [Instant], and
+ /// potentially harmful (impacting quality of service) to call it after the
+ /// [Instant]
+ ///
+ /// [poll]: #method.poll
+ /// [Instant]: struct.Instant.html
+ pub fn poll_at(&mut self, timestamp: Instant, sockets: &SocketSet<'_>) -> Option<Instant> {
+ self.inner.now = timestamp;
+
+ #[cfg(feature = "_proto-fragmentation")]
+ if !self.fragmenter.is_empty() {
+ return Some(Instant::from_millis(0));
+ }
+
+ let inner = &mut self.inner;
+
+ sockets
+ .items()
+ .filter_map(move |item| {
+ let socket_poll_at = item.socket.poll_at(inner);
+ match item
+ .meta
+ .poll_at(socket_poll_at, |ip_addr| inner.has_neighbor(&ip_addr))
+ {
+ PollAt::Ingress => None,
+ PollAt::Time(instant) => Some(instant),
+ PollAt::Now => Some(Instant::from_millis(0)),
+ }
+ })
+ .min()
+ }
+
+ /// Return an _advisory wait time_ for calling [poll] the next time.
+ /// The [Duration] returned is the time left to wait before calling [poll] next.
+ /// It is harmless (but wastes energy) to call it before the [Duration] has passed,
+ /// and potentially harmful (impacting quality of service) to call it after the
+ /// [Duration] has passed.
+ ///
+ /// [poll]: #method.poll
+ /// [Duration]: struct.Duration.html
+ pub fn poll_delay(&mut self, timestamp: Instant, sockets: &SocketSet<'_>) -> Option<Duration> {
+ match self.poll_at(timestamp, sockets) {
+ Some(poll_at) if timestamp < poll_at => Some(poll_at - timestamp),
+ Some(_) => Some(Duration::from_millis(0)),
+ _ => None,
+ }
+ }
+
+ fn socket_ingress<D>(&mut self, device: &mut D, sockets: &mut SocketSet<'_>) -> bool
+ where
+ D: Device + ?Sized,
+ {
+ let mut processed_any = false;
+
+ while let Some((rx_token, tx_token)) = device.receive(self.inner.now) {
+ let rx_meta = rx_token.meta();
+ rx_token.consume(|frame| {
+ if frame.is_empty() {
+ return;
+ }
+
+ match self.inner.caps.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => {
+ if let Some(packet) = self.inner.process_ethernet(
+ sockets,
+ rx_meta,
+ frame,
+ &mut self.fragments,
+ ) {
+ if let Err(err) =
+ self.inner.dispatch(tx_token, packet, &mut self.fragmenter)
+ {
+ net_debug!("Failed to send response: {:?}", err);
+ }
+ }
+ }
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => {
+ if let Some(packet) =
+ self.inner
+ .process_ip(sockets, rx_meta, frame, &mut self.fragments)
+ {
+ if let Err(err) = self.inner.dispatch_ip(
+ tx_token,
+ PacketMeta::default(),
+ packet,
+ &mut self.fragmenter,
+ ) {
+ net_debug!("Failed to send response: {:?}", err);
+ }
+ }
+ }
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => {
+ if let Some(packet) = self.inner.process_ieee802154(
+ sockets,
+ rx_meta,
+ frame,
+ &mut self.fragments,
+ ) {
+ if let Err(err) = self.inner.dispatch_ip(
+ tx_token,
+ PacketMeta::default(),
+ packet,
+ &mut self.fragmenter,
+ ) {
+ net_debug!("Failed to send response: {:?}", err);
+ }
+ }
+ }
+ }
+ processed_any = true;
+ });
+ }
+
+ processed_any
+ }
+
+ fn socket_egress<D>(&mut self, device: &mut D, sockets: &mut SocketSet<'_>) -> bool
+ where
+ D: Device + ?Sized,
+ {
+ let _caps = device.capabilities();
+
+ enum EgressError {
+ Exhausted,
+ Dispatch(DispatchError),
+ }
+
+ let mut emitted_any = false;
+ for item in sockets.items_mut() {
+ if !item
+ .meta
+ .egress_permitted(self.inner.now, |ip_addr| self.inner.has_neighbor(&ip_addr))
+ {
+ continue;
+ }
+
+ let mut neighbor_addr = None;
+ let mut respond = |inner: &mut InterfaceInner, meta: PacketMeta, response: Packet| {
+ neighbor_addr = Some(response.ip_repr().dst_addr());
+ let t = device.transmit(inner.now).ok_or_else(|| {
+ net_debug!("failed to transmit IP: device exhausted");
+ EgressError::Exhausted
+ })?;
+
+ inner
+ .dispatch_ip(t, meta, response, &mut self.fragmenter)
+ .map_err(EgressError::Dispatch)?;
+
+ emitted_any = true;
+
+ Ok(())
+ };
+
+ let result = match &mut item.socket {
+ #[cfg(feature = "socket-raw")]
+ Socket::Raw(socket) => socket.dispatch(&mut self.inner, |inner, (ip, raw)| {
+ respond(
+ inner,
+ PacketMeta::default(),
+ Packet::new(ip, IpPayload::Raw(raw)),
+ )
+ }),
+ #[cfg(feature = "socket-icmp")]
+ Socket::Icmp(socket) => {
+ socket.dispatch(&mut self.inner, |inner, response| match response {
+ #[cfg(feature = "proto-ipv4")]
+ (IpRepr::Ipv4(ipv4_repr), IcmpRepr::Ipv4(icmpv4_repr)) => respond(
+ inner,
+ PacketMeta::default(),
+ Packet::new_ipv4(ipv4_repr, IpPayload::Icmpv4(icmpv4_repr)),
+ ),
+ #[cfg(feature = "proto-ipv6")]
+ (IpRepr::Ipv6(ipv6_repr), IcmpRepr::Ipv6(icmpv6_repr)) => respond(
+ inner,
+ PacketMeta::default(),
+ Packet::new_ipv6(ipv6_repr, IpPayload::Icmpv6(icmpv6_repr)),
+ ),
+ #[allow(unreachable_patterns)]
+ _ => unreachable!(),
+ })
+ }
+ #[cfg(feature = "socket-udp")]
+ Socket::Udp(socket) => {
+ socket.dispatch(&mut self.inner, |inner, meta, (ip, udp, payload)| {
+ respond(inner, meta, Packet::new(ip, IpPayload::Udp(udp, payload)))
+ })
+ }
+ #[cfg(feature = "socket-tcp")]
+ Socket::Tcp(socket) => socket.dispatch(&mut self.inner, |inner, (ip, tcp)| {
+ respond(
+ inner,
+ PacketMeta::default(),
+ Packet::new(ip, IpPayload::Tcp(tcp)),
+ )
+ }),
+ #[cfg(feature = "socket-dhcpv4")]
+ Socket::Dhcpv4(socket) => {
+ socket.dispatch(&mut self.inner, |inner, (ip, udp, dhcp)| {
+ respond(
+ inner,
+ PacketMeta::default(),
+ Packet::new_ipv4(ip, IpPayload::Dhcpv4(udp, dhcp)),
+ )
+ })
+ }
+ #[cfg(feature = "socket-dns")]
+ Socket::Dns(socket) => socket.dispatch(&mut self.inner, |inner, (ip, udp, dns)| {
+ respond(
+ inner,
+ PacketMeta::default(),
+ Packet::new(ip, IpPayload::Udp(udp, dns)),
+ )
+ }),
+ };
+
+ match result {
+ Err(EgressError::Exhausted) => break, // Device buffer full.
+ Err(EgressError::Dispatch(_)) => {
+ // `NeighborCache` already takes care of rate limiting the neighbor discovery
+ // requests from the socket. However, without an additional rate limiting
+ // mechanism, we would spin on every socket that has yet to discover its
+ // neighbor.
+ item.meta.neighbor_missing(
+ self.inner.now,
+ neighbor_addr.expect("non-IP response packet"),
+ );
+ }
+ Ok(()) => {}
+ }
+ }
+ emitted_any
+ }
+
+ /// Process fragments that still need to be sent for IPv4 packets.
+ ///
+ /// This function returns a boolean value indicating whether any packets were
+ /// processed or emitted, and thus, whether the readiness of any socket might
+ /// have changed.
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ fn ipv4_egress<D>(&mut self, device: &mut D) -> bool
+ where
+ D: Device + ?Sized,
+ {
+ // Reset the buffer when we transmitted everything.
+ if self.fragmenter.finished() {
+ self.fragmenter.reset();
+ }
+
+ if self.fragmenter.is_empty() {
+ return false;
+ }
+
+ let pkt = &self.fragmenter;
+ if pkt.packet_len > pkt.sent_bytes {
+ if let Some(tx_token) = device.transmit(self.inner.now) {
+ self.inner
+ .dispatch_ipv4_frag(tx_token, &mut self.fragmenter);
+ return true;
+ }
+ }
+ false
+ }
+
+ /// Process fragments that still need to be sent for 6LoWPAN packets.
+ ///
+ /// This function returns a boolean value indicating whether any packets were
+ /// processed or emitted, and thus, whether the readiness of any socket might
+ /// have changed.
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ fn sixlowpan_egress<D>(&mut self, device: &mut D) -> bool
+ where
+ D: Device + ?Sized,
+ {
+ // Reset the buffer when we transmitted everything.
+ if self.fragmenter.finished() {
+ self.fragmenter.reset();
+ }
+
+ if self.fragmenter.is_empty() {
+ return false;
+ }
+
+ let pkt = &self.fragmenter;
+ if pkt.packet_len > pkt.sent_bytes {
+ if let Some(tx_token) = device.transmit(self.inner.now) {
+ self.inner
+ .dispatch_ieee802154_frag(tx_token, &mut self.fragmenter);
+ return true;
+ }
+ }
+ false
+ }
+}
+
+impl InterfaceInner {
+ #[allow(unused)] // unused depending on which sockets are enabled
+ pub(crate) fn now(&self) -> Instant {
+ self.now
+ }
+
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ #[allow(unused)] // unused depending on which sockets are enabled
+ pub(crate) fn hardware_addr(&self) -> HardwareAddress {
+ self.hardware_addr
+ }
+
+ #[allow(unused)] // unused depending on which sockets are enabled
+ pub(crate) fn checksum_caps(&self) -> ChecksumCapabilities {
+ self.caps.checksum.clone()
+ }
+
+ #[allow(unused)] // unused depending on which sockets are enabled
+ pub(crate) fn ip_mtu(&self) -> usize {
+ self.caps.ip_mtu()
+ }
+
+ #[allow(unused)] // unused depending on which sockets are enabled, and in tests
+ pub(crate) fn rand(&mut self) -> &mut Rand {
+ &mut self.rand
+ }
+
+ #[allow(unused)] // unused depending on which sockets are enabled
+ pub(crate) fn get_source_address(&self, dst_addr: &IpAddress) -> Option<IpAddress> {
+ match dst_addr {
+ #[cfg(feature = "proto-ipv4")]
+ IpAddress::Ipv4(addr) => self.get_source_address_ipv4(addr).map(|a| a.into()),
+ #[cfg(feature = "proto-ipv6")]
+ IpAddress::Ipv6(addr) => self.get_source_address_ipv6(addr).map(|a| a.into()),
+ }
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ #[allow(unused)]
+ pub(crate) fn get_source_address_ipv4(&self, _dst_addr: &Ipv4Address) -> Option<Ipv4Address> {
+ for cidr in self.ip_addrs.iter() {
+ #[allow(irrefutable_let_patterns)] // if only ipv4 is enabled
+ if let IpCidr::Ipv4(cidr) = cidr {
+ return Some(cidr.address());
+ }
+ }
+ None
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ #[allow(unused)]
+ pub(crate) fn get_source_address_ipv6(&self, dst_addr: &Ipv6Address) -> Option<Ipv6Address> {
+ // RFC 6724 describes how to select the correct source address depending on the destination
+ // address.
+
+ // See RFC 6724 Section 4: Candidate source address
+ fn is_candidate_source_address(dst_addr: &Ipv6Address, src_addr: &Ipv6Address) -> bool {
+ // For all multicast and link-local destination addresses, the candidate address MUST
+ // only be an address from the same link.
+ if dst_addr.is_link_local() && !src_addr.is_link_local() {
+ return false;
+ }
+
+ if dst_addr.is_multicast()
+ && matches!(dst_addr.scope(), Ipv6AddressScope::LinkLocal)
+ && src_addr.is_multicast()
+ && !matches!(src_addr.scope(), Ipv6AddressScope::LinkLocal)
+ {
+ return false;
+ }
+
+ // Loopback addresses and multicast address can not be in the candidate source address
+ // list. Except when the destination multicast address has a link-local scope, then the
+ // source address can also be link-local multicast.
+ if src_addr.is_loopback() || src_addr.is_multicast() {
+ return false;
+ }
+
+ true
+ }
+
+ // See RFC 6724 Section 2.2: Common Prefix Length
+ fn common_prefix_length(dst_addr: &Ipv6Cidr, src_addr: &Ipv6Address) -> usize {
+ let addr = dst_addr.address();
+ let mut bits = 0;
+ for (l, r) in addr.as_bytes().iter().zip(src_addr.as_bytes().iter()) {
+ if l == r {
+ bits += 8;
+ } else {
+ bits += (l ^ r).leading_zeros();
+ break;
+ }
+ }
+
+ bits = bits.min(dst_addr.prefix_len() as u32);
+
+ bits as usize
+ }
+
+ // Get the first address that is a candidate address.
+ let mut candidate = self
+ .ip_addrs
+ .iter()
+ .filter_map(|a| match a {
+ #[cfg(feature = "proto-ipv4")]
+ IpCidr::Ipv4(_) => None,
+ #[cfg(feature = "proto-ipv6")]
+ IpCidr::Ipv6(a) => Some(a),
+ })
+ .find(|a| is_candidate_source_address(dst_addr, &a.address()))
+ .unwrap();
+
+ for addr in self.ip_addrs.iter().filter_map(|a| match a {
+ #[cfg(feature = "proto-ipv4")]
+ IpCidr::Ipv4(_) => None,
+ #[cfg(feature = "proto-ipv6")]
+ IpCidr::Ipv6(a) => Some(a),
+ }) {
+ if !is_candidate_source_address(dst_addr, &addr.address()) {
+ continue;
+ }
+
+ // Rule 1: prefer the address that is the same as the output destination address.
+ if candidate.address() != *dst_addr && addr.address() == *dst_addr {
+ candidate = addr;
+ }
+
+ // Rule 2: prefer appropriate scope.
+ if (candidate.address().scope() as u8) < (addr.address().scope() as u8) {
+ if (candidate.address().scope() as u8) < (dst_addr.scope() as u8) {
+ candidate = addr;
+ }
+ } else if (addr.address().scope() as u8) > (dst_addr.scope() as u8) {
+ candidate = addr;
+ }
+
+ // Rule 3: avoid deprecated addresses (TODO)
+ // Rule 4: prefer home addresses (TODO)
+ // Rule 5: prefer outgoing interfaces (TODO)
+ // Rule 5.5: prefer addresses in a prefix advertises by the next-hop (TODO).
+ // Rule 6: prefer matching label (TODO)
+ // Rule 7: prefer temporary addresses (TODO)
+ // Rule 8: use longest matching prefix
+ if common_prefix_length(candidate, dst_addr) < common_prefix_length(addr, dst_addr) {
+ candidate = addr;
+ }
+ }
+
+ Some(candidate.address())
+ }
+
+ #[cfg(test)]
+ #[allow(unused)] // unused depending on which sockets are enabled
+ pub(crate) fn set_now(&mut self, now: Instant) {
+ self.now = now
+ }
+
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ fn check_hardware_addr(addr: &HardwareAddress) {
+ if !addr.is_unicast() {
+ panic!("Hardware address {addr} is not unicast")
+ }
+ }
+
+ fn check_ip_addrs(addrs: &[IpCidr]) {
+ for cidr in addrs {
+ if !cidr.address().is_unicast() && !cidr.address().is_unspecified() {
+ panic!("IP address {} is not unicast", cidr.address())
+ }
+ }
+ }
+
+ #[cfg(feature = "medium-ieee802154")]
+ fn get_sequence_number(&mut self) -> u8 {
+ let no = self.sequence_no;
+ self.sequence_no = self.sequence_no.wrapping_add(1);
+ no
+ }
+
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ fn get_ipv4_ident(&mut self) -> u16 {
+ let ipv4_id = self.ipv4_id;
+ self.ipv4_id = self.ipv4_id.wrapping_add(1);
+ ipv4_id
+ }
+
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ fn get_sixlowpan_fragment_tag(&mut self) -> u16 {
+ let tag = self.tag;
+ self.tag = self.tag.wrapping_add(1);
+ tag
+ }
+
+ /// Determine if the given `Ipv6Address` is the solicited node
+ /// multicast address for a IPv6 addresses assigned to the interface.
+ /// See [RFC 4291 § 2.7.1] for more details.
+ ///
+ /// [RFC 4291 § 2.7.1]: https://tools.ietf.org/html/rfc4291#section-2.7.1
+ #[cfg(feature = "proto-ipv6")]
+ pub fn has_solicited_node(&self, addr: Ipv6Address) -> bool {
+ self.ip_addrs.iter().any(|cidr| {
+ match *cidr {
+ IpCidr::Ipv6(cidr) if cidr.address() != Ipv6Address::LOOPBACK => {
+ // Take the lower order 24 bits of the IPv6 address and
+ // append those bits to FF02:0:0:0:0:1:FF00::/104.
+ addr.as_bytes()[14..] == cidr.address().as_bytes()[14..]
+ }
+ _ => false,
+ }
+ })
+ }
+
+ /// Check whether the interface has the given IP address assigned.
+ fn has_ip_addr<T: Into<IpAddress>>(&self, addr: T) -> bool {
+ let addr = addr.into();
+ self.ip_addrs.iter().any(|probe| probe.address() == addr)
+ }
+
+ /// Get the first IPv4 address of the interface.
+ #[cfg(feature = "proto-ipv4")]
+ pub fn ipv4_addr(&self) -> Option<Ipv4Address> {
+ self.ip_addrs.iter().find_map(|addr| match *addr {
+ IpCidr::Ipv4(cidr) => Some(cidr.address()),
+ #[allow(unreachable_patterns)]
+ _ => None,
+ })
+ }
+
+ /// Get the first IPv6 address if present.
+ #[cfg(feature = "proto-ipv6")]
+ pub fn ipv6_addr(&self) -> Option<Ipv6Address> {
+ self.ip_addrs.iter().find_map(|addr| match *addr {
+ IpCidr::Ipv6(cidr) => Some(cidr.address()),
+ #[allow(unreachable_patterns)]
+ _ => None,
+ })
+ }
+
+ /// Check whether the interface listens to given destination multicast IP address.
+ ///
+ /// If built without feature `proto-igmp` this function will
+ /// always return `false` when using IPv4.
+ fn has_multicast_group<T: Into<IpAddress>>(&self, addr: T) -> bool {
+ match addr.into() {
+ #[cfg(feature = "proto-igmp")]
+ IpAddress::Ipv4(key) => {
+ key == Ipv4Address::MULTICAST_ALL_SYSTEMS
+ || self.ipv4_multicast_groups.get(&key).is_some()
+ }
+ #[cfg(feature = "proto-ipv6")]
+ IpAddress::Ipv6(Ipv6Address::LINK_LOCAL_ALL_NODES) => true,
+ #[cfg(feature = "proto-rpl")]
+ IpAddress::Ipv6(Ipv6Address::LINK_LOCAL_ALL_RPL_NODES) => true,
+ #[cfg(feature = "proto-ipv6")]
+ IpAddress::Ipv6(addr) => self.has_solicited_node(addr),
+ #[allow(unreachable_patterns)]
+ _ => false,
+ }
+ }
+
+ #[cfg(feature = "medium-ip")]
+ fn process_ip<'frame>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: PacketMeta,
+ ip_payload: &'frame [u8],
+ frag: &'frame mut FragmentsBuffer,
+ ) -> Option<Packet<'frame>> {
+ match IpVersion::of_packet(ip_payload) {
+ #[cfg(feature = "proto-ipv4")]
+ Ok(IpVersion::Ipv4) => {
+ let ipv4_packet = check!(Ipv4Packet::new_checked(ip_payload));
+
+ self.process_ipv4(sockets, meta, &ipv4_packet, frag)
+ }
+ #[cfg(feature = "proto-ipv6")]
+ Ok(IpVersion::Ipv6) => {
+ let ipv6_packet = check!(Ipv6Packet::new_checked(ip_payload));
+ self.process_ipv6(sockets, meta, &ipv6_packet)
+ }
+ // Drop all other traffic.
+ _ => None,
+ }
+ }
+
+ #[cfg(feature = "socket-raw")]
+ fn raw_socket_filter(
+ &mut self,
+ sockets: &mut SocketSet,
+ ip_repr: &IpRepr,
+ ip_payload: &[u8],
+ ) -> bool {
+ let mut handled_by_raw_socket = false;
+
+ // Pass every IP packet to all raw sockets we have registered.
+ for raw_socket in sockets
+ .items_mut()
+ .filter_map(|i| raw::Socket::downcast_mut(&mut i.socket))
+ {
+ if raw_socket.accepts(ip_repr) {
+ raw_socket.process(self, ip_repr, ip_payload);
+ handled_by_raw_socket = true;
+ }
+ }
+ handled_by_raw_socket
+ }
+
+ /// Checks if an address is broadcast, taking into account ipv4 subnet-local
+ /// broadcast addresses.
+ pub(crate) fn is_broadcast(&self, address: &IpAddress) -> bool {
+ match address {
+ #[cfg(feature = "proto-ipv4")]
+ IpAddress::Ipv4(address) => self.is_broadcast_v4(*address),
+ #[cfg(feature = "proto-ipv6")]
+ IpAddress::Ipv6(_) => false,
+ }
+ }
+
+ /// Checks if an address is broadcast, taking into account ipv4 subnet-local
+ /// broadcast addresses.
+ #[cfg(feature = "proto-ipv4")]
+ pub(crate) fn is_broadcast_v4(&self, address: Ipv4Address) -> bool {
+ if address.is_broadcast() {
+ return true;
+ }
+
+ self.ip_addrs
+ .iter()
+ .filter_map(|own_cidr| match own_cidr {
+ IpCidr::Ipv4(own_ip) => Some(own_ip.broadcast()?),
+ #[cfg(feature = "proto-ipv6")]
+ IpCidr::Ipv6(_) => None,
+ })
+ .any(|broadcast_address| address == broadcast_address)
+ }
+
+ /// Checks if an ipv4 address is unicast, taking into account subnet broadcast addresses
+ #[cfg(feature = "proto-ipv4")]
+ fn is_unicast_v4(&self, address: Ipv4Address) -> bool {
+ address.is_unicast() && !self.is_broadcast_v4(address)
+ }
+
+ #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
+ #[allow(clippy::too_many_arguments)]
+ fn process_udp<'frame>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: PacketMeta,
+ ip_repr: IpRepr,
+ udp_repr: UdpRepr,
+ handled_by_raw_socket: bool,
+ udp_payload: &'frame [u8],
+ ip_payload: &'frame [u8],
+ ) -> Option<Packet<'frame>> {
+ #[cfg(feature = "socket-udp")]
+ for udp_socket in sockets
+ .items_mut()
+ .filter_map(|i| udp::Socket::downcast_mut(&mut i.socket))
+ {
+ if udp_socket.accepts(self, &ip_repr, &udp_repr) {
+ udp_socket.process(self, meta, &ip_repr, &udp_repr, udp_payload);
+ return None;
+ }
+ }
+
+ #[cfg(feature = "socket-dns")]
+ for dns_socket in sockets
+ .items_mut()
+ .filter_map(|i| dns::Socket::downcast_mut(&mut i.socket))
+ {
+ if dns_socket.accepts(&ip_repr, &udp_repr) {
+ dns_socket.process(self, &ip_repr, &udp_repr, udp_payload);
+ return None;
+ }
+ }
+
+ // The packet wasn't handled by a socket, send an ICMP port unreachable packet.
+ match ip_repr {
+ #[cfg(feature = "proto-ipv4")]
+ IpRepr::Ipv4(_) if handled_by_raw_socket => None,
+ #[cfg(feature = "proto-ipv6")]
+ IpRepr::Ipv6(_) if handled_by_raw_socket => None,
+ #[cfg(feature = "proto-ipv4")]
+ IpRepr::Ipv4(ipv4_repr) => {
+ let payload_len =
+ icmp_reply_payload_len(ip_payload.len(), IPV4_MIN_MTU, ipv4_repr.buffer_len());
+ let icmpv4_reply_repr = Icmpv4Repr::DstUnreachable {
+ reason: Icmpv4DstUnreachable::PortUnreachable,
+ header: ipv4_repr,
+ data: &ip_payload[0..payload_len],
+ };
+ self.icmpv4_reply(ipv4_repr, icmpv4_reply_repr)
+ }
+ #[cfg(feature = "proto-ipv6")]
+ IpRepr::Ipv6(ipv6_repr) => {
+ let payload_len =
+ icmp_reply_payload_len(ip_payload.len(), IPV6_MIN_MTU, ipv6_repr.buffer_len());
+ let icmpv6_reply_repr = Icmpv6Repr::DstUnreachable {
+ reason: Icmpv6DstUnreachable::PortUnreachable,
+ header: ipv6_repr,
+ data: &ip_payload[0..payload_len],
+ };
+ self.icmpv6_reply(ipv6_repr, icmpv6_reply_repr)
+ }
+ }
+ }
+
+ #[cfg(feature = "socket-tcp")]
+ pub(crate) fn process_tcp<'frame>(
+ &mut self,
+ sockets: &mut SocketSet,
+ ip_repr: IpRepr,
+ ip_payload: &'frame [u8],
+ ) -> Option<Packet<'frame>> {
+ let (src_addr, dst_addr) = (ip_repr.src_addr(), ip_repr.dst_addr());
+ let tcp_packet = check!(TcpPacket::new_checked(ip_payload));
+ let tcp_repr = check!(TcpRepr::parse(
+ &tcp_packet,
+ &src_addr,
+ &dst_addr,
+ &self.caps.checksum
+ ));
+
+ for tcp_socket in sockets
+ .items_mut()
+ .filter_map(|i| tcp::Socket::downcast_mut(&mut i.socket))
+ {
+ if tcp_socket.accepts(self, &ip_repr, &tcp_repr) {
+ return tcp_socket
+ .process(self, &ip_repr, &tcp_repr)
+ .map(|(ip, tcp)| Packet::new(ip, IpPayload::Tcp(tcp)));
+ }
+ }
+
+ if tcp_repr.control == TcpControl::Rst
+ || ip_repr.dst_addr().is_unspecified()
+ || ip_repr.src_addr().is_unspecified()
+ {
+ // Never reply to a TCP RST packet with another TCP RST packet. We also never want to
+ // send a TCP RST packet with unspecified addresses.
+ None
+ } else {
+ // The packet wasn't handled by a socket, send a TCP RST packet.
+ let (ip, tcp) = tcp::Socket::rst_reply(&ip_repr, &tcp_repr);
+ Some(Packet::new(ip, IpPayload::Tcp(tcp)))
+ }
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ fn dispatch<Tx>(
+ &mut self,
+ tx_token: Tx,
+ packet: EthernetPacket,
+ frag: &mut Fragmenter,
+ ) -> Result<(), DispatchError>
+ where
+ Tx: TxToken,
+ {
+ match packet {
+ #[cfg(feature = "proto-ipv4")]
+ EthernetPacket::Arp(arp_repr) => {
+ let dst_hardware_addr = match arp_repr {
+ ArpRepr::EthernetIpv4 {
+ target_hardware_addr,
+ ..
+ } => target_hardware_addr,
+ };
+
+ self.dispatch_ethernet(tx_token, arp_repr.buffer_len(), |mut frame| {
+ frame.set_dst_addr(dst_hardware_addr);
+ frame.set_ethertype(EthernetProtocol::Arp);
+
+ let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
+ arp_repr.emit(&mut packet);
+ })
+ }
+ EthernetPacket::Ip(packet) => {
+ self.dispatch_ip(tx_token, PacketMeta::default(), packet, frag)
+ }
+ }
+ }
+
+ fn in_same_network(&self, addr: &IpAddress) -> bool {
+ self.ip_addrs.iter().any(|cidr| cidr.contains_addr(addr))
+ }
+
+ fn route(&self, addr: &IpAddress, timestamp: Instant) -> Option<IpAddress> {
+ // Send directly.
+ // note: no need to use `self.is_broadcast()` to check for subnet-local broadcast addrs
+ // here because `in_same_network` will already return true.
+ if self.in_same_network(addr) || addr.is_broadcast() {
+ return Some(*addr);
+ }
+
+ // Route via a router.
+ self.routes.lookup(addr, timestamp)
+ }
+
+ fn has_neighbor(&self, addr: &IpAddress) -> bool {
+ match self.route(addr, self.now) {
+ Some(_routed_addr) => match self.caps.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => self.neighbor_cache.lookup(&_routed_addr, self.now).found(),
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => self.neighbor_cache.lookup(&_routed_addr, self.now).found(),
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => true,
+ },
+ None => false,
+ }
+ }
+
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ fn lookup_hardware_addr<Tx>(
+ &mut self,
+ tx_token: Tx,
+ src_addr: &IpAddress,
+ dst_addr: &IpAddress,
+ fragmenter: &mut Fragmenter,
+ ) -> Result<(HardwareAddress, Tx), DispatchError>
+ where
+ Tx: TxToken,
+ {
+ if self.is_broadcast(dst_addr) {
+ let hardware_addr = match self.caps.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => HardwareAddress::Ethernet(EthernetAddress::BROADCAST),
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => HardwareAddress::Ieee802154(Ieee802154Address::BROADCAST),
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => unreachable!(),
+ };
+
+ return Ok((hardware_addr, tx_token));
+ }
+
+ if dst_addr.is_multicast() {
+ let b = dst_addr.as_bytes();
+ let hardware_addr = match *dst_addr {
+ #[cfg(feature = "proto-ipv4")]
+ IpAddress::Ipv4(_addr) => match self.caps.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => HardwareAddress::Ethernet(EthernetAddress::from_bytes(&[
+ 0x01,
+ 0x00,
+ 0x5e,
+ b[1] & 0x7F,
+ b[2],
+ b[3],
+ ])),
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => unreachable!(),
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => unreachable!(),
+ },
+ #[cfg(feature = "proto-ipv6")]
+ IpAddress::Ipv6(_addr) => match self.caps.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => HardwareAddress::Ethernet(EthernetAddress::from_bytes(&[
+ 0x33, 0x33, b[12], b[13], b[14], b[15],
+ ])),
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => {
+ // Not sure if this is correct
+ HardwareAddress::Ieee802154(Ieee802154Address::BROADCAST)
+ }
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => unreachable!(),
+ },
+ };
+
+ return Ok((hardware_addr, tx_token));
+ }
+
+ let dst_addr = self
+ .route(dst_addr, self.now)
+ .ok_or(DispatchError::NoRoute)?;
+
+ match self.neighbor_cache.lookup(&dst_addr, self.now) {
+ NeighborAnswer::Found(hardware_addr) => return Ok((hardware_addr, tx_token)),
+ NeighborAnswer::RateLimited => return Err(DispatchError::NeighborPending),
+ _ => (), // XXX
+ }
+
+ match (src_addr, dst_addr) {
+ #[cfg(all(feature = "medium-ethernet", feature = "proto-ipv4"))]
+ (&IpAddress::Ipv4(src_addr), IpAddress::Ipv4(dst_addr))
+ if matches!(self.caps.medium, Medium::Ethernet) =>
+ {
+ net_debug!(
+ "address {} not in neighbor cache, sending ARP request",
+ dst_addr
+ );
+ let src_hardware_addr = self.hardware_addr.ethernet_or_panic();
+
+ let arp_repr = ArpRepr::EthernetIpv4 {
+ operation: ArpOperation::Request,
+ source_hardware_addr: src_hardware_addr,
+ source_protocol_addr: src_addr,
+ target_hardware_addr: EthernetAddress::BROADCAST,
+ target_protocol_addr: dst_addr,
+ };
+
+ if let Err(e) =
+ self.dispatch_ethernet(tx_token, arp_repr.buffer_len(), |mut frame| {
+ frame.set_dst_addr(EthernetAddress::BROADCAST);
+ frame.set_ethertype(EthernetProtocol::Arp);
+
+ arp_repr.emit(&mut ArpPacket::new_unchecked(frame.payload_mut()))
+ })
+ {
+ net_debug!("Failed to dispatch ARP request: {:?}", e);
+ return Err(DispatchError::NeighborPending);
+ }
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ (&IpAddress::Ipv6(src_addr), IpAddress::Ipv6(dst_addr)) => {
+ net_debug!(
+ "address {} not in neighbor cache, sending Neighbor Solicitation",
+ dst_addr
+ );
+
+ let solicit = Icmpv6Repr::Ndisc(NdiscRepr::NeighborSolicit {
+ target_addr: dst_addr,
+ lladdr: Some(self.hardware_addr.into()),
+ });
+
+ let packet = Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr,
+ dst_addr: dst_addr.solicited_node(),
+ next_header: IpProtocol::Icmpv6,
+ payload_len: solicit.buffer_len(),
+ hop_limit: 0xff,
+ },
+ IpPayload::Icmpv6(solicit),
+ );
+
+ if let Err(e) =
+ self.dispatch_ip(tx_token, PacketMeta::default(), packet, fragmenter)
+ {
+ net_debug!("Failed to dispatch NDISC solicit: {:?}", e);
+ return Err(DispatchError::NeighborPending);
+ }
+ }
+
+ #[allow(unreachable_patterns)]
+ _ => (),
+ }
+
+ // The request got dispatched, limit the rate on the cache.
+ self.neighbor_cache.limit_rate(self.now);
+ Err(DispatchError::NeighborPending)
+ }
+
+ fn flush_cache(&mut self) {
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ self.neighbor_cache.flush()
+ }
+
+ fn dispatch_ip<Tx: TxToken>(
+ &mut self,
+ // NOTE(unused_mut): tx_token isn't always mutated, depending on
+ // the feature set that is used.
+ #[allow(unused_mut)] mut tx_token: Tx,
+ meta: PacketMeta,
+ packet: Packet,
+ frag: &mut Fragmenter,
+ ) -> Result<(), DispatchError> {
+ let mut ip_repr = packet.ip_repr();
+ assert!(!ip_repr.dst_addr().is_unspecified());
+
+ // Dispatch IEEE802.15.4:
+
+ #[cfg(feature = "medium-ieee802154")]
+ if matches!(self.caps.medium, Medium::Ieee802154) {
+ let (addr, tx_token) = self.lookup_hardware_addr(
+ tx_token,
+ &ip_repr.src_addr(),
+ &ip_repr.dst_addr(),
+ frag,
+ )?;
+ let addr = addr.ieee802154_or_panic();
+
+ self.dispatch_ieee802154(addr, tx_token, meta, packet, frag);
+ return Ok(());
+ }
+
+ // Dispatch IP/Ethernet:
+
+ let caps = self.caps.clone();
+
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ let ipv4_id = self.get_ipv4_ident();
+
+ // First we calculate the total length that we will have to emit.
+ let mut total_len = ip_repr.buffer_len();
+
+ // Add the size of the Ethernet header if the medium is Ethernet.
+ #[cfg(feature = "medium-ethernet")]
+ if matches!(self.caps.medium, Medium::Ethernet) {
+ total_len = EthernetFrame::<&[u8]>::buffer_len(total_len);
+ }
+
+ // If the medium is Ethernet, then we need to retrieve the destination hardware address.
+ #[cfg(feature = "medium-ethernet")]
+ let (dst_hardware_addr, mut tx_token) = match self.caps.medium {
+ Medium::Ethernet => {
+ match self.lookup_hardware_addr(
+ tx_token,
+ &ip_repr.src_addr(),
+ &ip_repr.dst_addr(),
+ frag,
+ )? {
+ (HardwareAddress::Ethernet(addr), tx_token) => (addr, tx_token),
+ (_, _) => unreachable!(),
+ }
+ }
+ _ => (EthernetAddress([0; 6]), tx_token),
+ };
+
+ // Emit function for the Ethernet header.
+ #[cfg(feature = "medium-ethernet")]
+ let emit_ethernet = |repr: &IpRepr, tx_buffer: &mut [u8]| {
+ let mut frame = EthernetFrame::new_unchecked(tx_buffer);
+
+ let src_addr = self.hardware_addr.ethernet_or_panic();
+ frame.set_src_addr(src_addr);
+ frame.set_dst_addr(dst_hardware_addr);
+
+ match repr.version() {
+ #[cfg(feature = "proto-ipv4")]
+ IpVersion::Ipv4 => frame.set_ethertype(EthernetProtocol::Ipv4),
+ #[cfg(feature = "proto-ipv6")]
+ IpVersion::Ipv6 => frame.set_ethertype(EthernetProtocol::Ipv6),
+ }
+
+ Ok(())
+ };
+
+ // Emit function for the IP header and payload.
+ let emit_ip = |repr: &IpRepr, mut tx_buffer: &mut [u8]| {
+ repr.emit(&mut tx_buffer, &self.caps.checksum);
+
+ let payload = &mut tx_buffer[repr.header_len()..];
+ packet.emit_payload(repr, payload, &caps)
+ };
+
+ let total_ip_len = ip_repr.buffer_len();
+
+ match &mut ip_repr {
+ #[cfg(feature = "proto-ipv4")]
+ IpRepr::Ipv4(repr) => {
+ // If we have an IPv4 packet, then we need to check if we need to fragment it.
+ if total_ip_len > self.caps.max_transmission_unit {
+ #[cfg(feature = "proto-ipv4-fragmentation")]
+ {
+ net_debug!("start fragmentation");
+
+ // Calculate how much we will send now (including the Ethernet header).
+ let tx_len = self.caps.max_transmission_unit;
+
+ let ip_header_len = repr.buffer_len();
+ let first_frag_ip_len = self.caps.ip_mtu();
+
+ if frag.buffer.len() < total_ip_len {
+ net_debug!(
+ "Fragmentation buffer is too small, at least {} needed. Dropping",
+ total_ip_len
+ );
+ return Ok(());
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ {
+ frag.ipv4.dst_hardware_addr = dst_hardware_addr;
+ }
+
+ // Save the total packet len (without the Ethernet header, but with the first
+ // IP header).
+ frag.packet_len = total_ip_len;
+
+ // Save the IP header for other fragments.
+ frag.ipv4.repr = *repr;
+
+ // Save how much bytes we will send now.
+ frag.sent_bytes = first_frag_ip_len;
+
+ // Modify the IP header
+ repr.payload_len = first_frag_ip_len - repr.buffer_len();
+
+ // Emit the IP header to the buffer.
+ emit_ip(&ip_repr, &mut frag.buffer);
+
+ let mut ipv4_packet = Ipv4Packet::new_unchecked(&mut frag.buffer[..]);
+ frag.ipv4.ident = ipv4_id;
+ ipv4_packet.set_ident(ipv4_id);
+ ipv4_packet.set_more_frags(true);
+ ipv4_packet.set_dont_frag(false);
+ ipv4_packet.set_frag_offset(0);
+
+ if caps.checksum.ipv4.tx() {
+ ipv4_packet.fill_checksum();
+ }
+
+ // Transmit the first packet.
+ tx_token.consume(tx_len, |mut tx_buffer| {
+ #[cfg(feature = "medium-ethernet")]
+ if matches!(self.caps.medium, Medium::Ethernet) {
+ emit_ethernet(&ip_repr, tx_buffer)?;
+ tx_buffer = &mut tx_buffer[EthernetFrame::<&[u8]>::header_len()..];
+ }
+
+ // Change the offset for the next packet.
+ frag.ipv4.frag_offset = (first_frag_ip_len - ip_header_len) as u16;
+
+ // Copy the IP header and the payload.
+ tx_buffer[..first_frag_ip_len]
+ .copy_from_slice(&frag.buffer[..first_frag_ip_len]);
+
+ Ok(())
+ })
+ }
+
+ #[cfg(not(feature = "proto-ipv4-fragmentation"))]
+ {
+ net_debug!("Enable the `proto-ipv4-fragmentation` feature for fragmentation support.");
+ Ok(())
+ }
+ } else {
+ tx_token.set_meta(meta);
+
+ // No fragmentation is required.
+ tx_token.consume(total_len, |mut tx_buffer| {
+ #[cfg(feature = "medium-ethernet")]
+ if matches!(self.caps.medium, Medium::Ethernet) {
+ emit_ethernet(&ip_repr, tx_buffer)?;
+ tx_buffer = &mut tx_buffer[EthernetFrame::<&[u8]>::header_len()..];
+ }
+
+ emit_ip(&ip_repr, tx_buffer);
+ Ok(())
+ })
+ }
+ }
+ // We don't support IPv6 fragmentation yet.
+ #[cfg(feature = "proto-ipv6")]
+ IpRepr::Ipv6(_) => tx_token.consume(total_len, |mut tx_buffer| {
+ #[cfg(feature = "medium-ethernet")]
+ if matches!(self.caps.medium, Medium::Ethernet) {
+ emit_ethernet(&ip_repr, tx_buffer)?;
+ tx_buffer = &mut tx_buffer[EthernetFrame::<&[u8]>::header_len()..];
+ }
+
+ emit_ip(&ip_repr, tx_buffer);
+ Ok(())
+ }),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+enum DispatchError {
+ /// No route to dispatch this packet. Retrying won't help unless
+ /// configuration is changed.
+ NoRoute,
+ /// We do have a route to dispatch this packet, but we haven't discovered
+ /// the neighbor for it yet. Discovery has been initiated, dispatch
+ /// should be retried later.
+ NeighborPending,
+}
diff --git a/src/iface/interface/sixlowpan.rs b/src/iface/interface/sixlowpan.rs
new file mode 100644
index 0000000..de2c3e9
--- /dev/null
+++ b/src/iface/interface/sixlowpan.rs
@@ -0,0 +1,922 @@
+use super::*;
+
+use crate::phy::ChecksumCapabilities;
+use crate::wire::*;
+
+// Max len of non-fragmented packets after decompression (including ipv6 header and payload)
+// TODO: lower. Should be (6lowpan mtu) - (min 6lowpan header size) + (max ipv6 header size)
+pub(crate) const MAX_DECOMPRESSED_LEN: usize = 1500;
+
+impl InterfaceInner {
+ pub(super) fn process_sixlowpan<'output, 'payload: 'output>(
+ &mut self,
+ sockets: &mut SocketSet,
+ meta: PacketMeta,
+ ieee802154_repr: &Ieee802154Repr,
+ payload: &'payload [u8],
+ f: &'output mut FragmentsBuffer,
+ ) -> Option<Packet<'output>> {
+ let payload = match check!(SixlowpanPacket::dispatch(payload)) {
+ #[cfg(not(feature = "proto-sixlowpan-fragmentation"))]
+ SixlowpanPacket::FragmentHeader => {
+ net_debug!(
+ "Fragmentation is not supported, \
+ use the `proto-sixlowpan-fragmentation` feature to add support."
+ );
+ return None;
+ }
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ SixlowpanPacket::FragmentHeader => {
+ match self.process_sixlowpan_fragment(ieee802154_repr, payload, f) {
+ Some(payload) => payload,
+ None => return None,
+ }
+ }
+ SixlowpanPacket::IphcHeader => {
+ match Self::sixlowpan_to_ipv6(
+ &self.sixlowpan_address_context,
+ ieee802154_repr,
+ payload,
+ None,
+ &mut f.decompress_buf,
+ ) {
+ Ok(len) => &f.decompress_buf[..len],
+ Err(e) => {
+ net_debug!("sixlowpan decompress failed: {:?}", e);
+ return None;
+ }
+ }
+ }
+ };
+
+ self.process_ipv6(sockets, meta, &check!(Ipv6Packet::new_checked(payload)))
+ }
+
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ fn process_sixlowpan_fragment<'output, 'payload: 'output>(
+ &mut self,
+ ieee802154_repr: &Ieee802154Repr,
+ payload: &'payload [u8],
+ f: &'output mut FragmentsBuffer,
+ ) -> Option<&'output [u8]> {
+ use crate::iface::fragmentation::{AssemblerError, AssemblerFullError};
+
+ // We have a fragment header, which means we cannot process the 6LoWPAN packet,
+ // unless we have a complete one after processing this fragment.
+ let frag = check!(SixlowpanFragPacket::new_checked(payload));
+
+ // The key specifies to which 6LoWPAN fragment it belongs too.
+ // It is based on the link layer addresses, the tag and the size.
+ let key = FragKey::Sixlowpan(frag.get_key(ieee802154_repr));
+
+ // The offset of this fragment in increments of 8 octets.
+ let offset = frag.datagram_offset() as usize * 8;
+
+ // We reserve a spot in the packet assembler set and add the required
+ // information to the packet assembler.
+ // This information is the total size of the packet when it is fully assmbled.
+ // We also pass the header size, since this is needed when other fragments
+ // (other than the first one) are added.
+ let frag_slot = match f.assembler.get(&key, self.now + f.reassembly_timeout) {
+ Ok(frag) => frag,
+ Err(AssemblerFullError) => {
+ net_debug!("No available packet assembler for fragmented packet");
+ return None;
+ }
+ };
+
+ if frag.is_first_fragment() {
+ // The first fragment contains the total size of the IPv6 packet.
+ // However, we received a packet that is compressed following the 6LoWPAN
+ // standard. This means we need to convert the IPv6 packet size to a 6LoWPAN
+ // packet size. The packet size can be different because of first the
+ // compression of the IP header and when UDP is used (because the UDP header
+ // can also be compressed). Other headers are not compressed by 6LoWPAN.
+
+ // First segment tells us the total size.
+ let total_size = frag.datagram_size() as usize;
+ if frag_slot.set_total_size(total_size).is_err() {
+ net_debug!("No available packet assembler for fragmented packet");
+ return None;
+ }
+
+ // Decompress headers+payload into the assembler.
+ if let Err(e) = frag_slot.add_with(0, |buffer| {
+ Self::sixlowpan_to_ipv6(
+ &self.sixlowpan_address_context,
+ ieee802154_repr,
+ frag.payload(),
+ Some(total_size),
+ buffer,
+ )
+ .map_err(|_| AssemblerError)
+ }) {
+ net_debug!("fragmentation error: {:?}", e);
+ return None;
+ }
+ } else {
+ // Add the fragment to the packet assembler.
+ if let Err(e) = frag_slot.add(frag.payload(), offset) {
+ net_debug!("fragmentation error: {:?}", e);
+ return None;
+ }
+ }
+
+ match frag_slot.assemble() {
+ Some(payload) => {
+ net_trace!("6LoWPAN: fragmented packet now complete");
+ Some(payload)
+ }
+ None => None,
+ }
+ }
+
+ fn sixlowpan_to_ipv6(
+ address_context: &[SixlowpanAddressContext],
+ ieee802154_repr: &Ieee802154Repr,
+ iphc_payload: &[u8],
+ total_size: Option<usize>,
+ buffer: &mut [u8],
+ ) -> core::result::Result<usize, crate::wire::Error> {
+ let iphc = SixlowpanIphcPacket::new_checked(iphc_payload)?;
+ let iphc_repr = SixlowpanIphcRepr::parse(
+ &iphc,
+ ieee802154_repr.src_addr,
+ ieee802154_repr.dst_addr,
+ address_context,
+ )?;
+
+ let first_next_header = match iphc_repr.next_header {
+ SixlowpanNextHeader::Compressed => {
+ match SixlowpanNhcPacket::dispatch(iphc.payload())? {
+ SixlowpanNhcPacket::ExtHeader => {
+ SixlowpanExtHeaderPacket::new_checked(iphc.payload())?
+ .extension_header_id()
+ .into()
+ }
+ SixlowpanNhcPacket::UdpHeader => IpProtocol::Udp,
+ }
+ }
+ SixlowpanNextHeader::Uncompressed(proto) => proto,
+ };
+
+ let mut decompressed_size = 40 + iphc.payload().len();
+ let mut next_header = Some(iphc_repr.next_header);
+ let mut data = iphc.payload();
+
+ while let Some(nh) = next_header {
+ match nh {
+ SixlowpanNextHeader::Compressed => match SixlowpanNhcPacket::dispatch(data)? {
+ SixlowpanNhcPacket::ExtHeader => {
+ let ext_hdr = SixlowpanExtHeaderPacket::new_checked(data)?;
+ let ext_repr = SixlowpanExtHeaderRepr::parse(&ext_hdr)?;
+ decompressed_size += 2;
+ decompressed_size -= ext_repr.buffer_len();
+ next_header = Some(ext_repr.next_header);
+
+ if ext_repr.buffer_len() + ext_repr.length as usize > data.len() {
+ return Err(Error);
+ }
+
+ data = &data[ext_repr.buffer_len() + ext_repr.length as usize..];
+ }
+ SixlowpanNhcPacket::UdpHeader => {
+ let udp_packet = SixlowpanUdpNhcPacket::new_checked(data)?;
+ let udp_repr = SixlowpanUdpNhcRepr::parse(
+ &udp_packet,
+ &iphc_repr.src_addr,
+ &iphc_repr.dst_addr,
+ &crate::phy::ChecksumCapabilities::ignored(),
+ )?;
+
+ decompressed_size += 8;
+ decompressed_size -= udp_repr.header_len();
+ break;
+ }
+ },
+ SixlowpanNextHeader::Uncompressed(proto) => match proto {
+ IpProtocol::Tcp => break,
+ IpProtocol::Udp => break,
+ IpProtocol::Icmpv6 => break,
+ proto => {
+ net_debug!("unable to decompress Uncompressed({})", proto);
+ return Err(Error);
+ }
+ },
+ }
+ }
+
+ if buffer.len() < decompressed_size {
+ net_debug!("sixlowpan decompress: buffer too short");
+ return Err(crate::wire::Error);
+ }
+ let buffer = &mut buffer[..decompressed_size];
+
+ let total_size = if let Some(size) = total_size {
+ size
+ } else {
+ decompressed_size
+ };
+
+ let mut rest_size = total_size;
+
+ let ipv6_repr = Ipv6Repr {
+ src_addr: iphc_repr.src_addr,
+ dst_addr: iphc_repr.dst_addr,
+ next_header: first_next_header,
+ payload_len: total_size - 40,
+ hop_limit: iphc_repr.hop_limit,
+ };
+ rest_size -= 40;
+
+ // Emit the decompressed IPHC header (decompressed to an IPv6 header).
+ let mut ipv6_packet = Ipv6Packet::new_unchecked(&mut buffer[..ipv6_repr.buffer_len()]);
+ ipv6_repr.emit(&mut ipv6_packet);
+ let mut buffer = &mut buffer[ipv6_repr.buffer_len()..];
+
+ let mut next_header = Some(iphc_repr.next_header);
+ let mut data = iphc.payload();
+
+ while let Some(nh) = next_header {
+ match nh {
+ SixlowpanNextHeader::Compressed => match SixlowpanNhcPacket::dispatch(data)? {
+ SixlowpanNhcPacket::ExtHeader => {
+ let ext_hdr = SixlowpanExtHeaderPacket::new_checked(data)?;
+ let ext_repr = SixlowpanExtHeaderRepr::parse(&ext_hdr)?;
+
+ let nh = match ext_repr.next_header {
+ SixlowpanNextHeader::Compressed => {
+ let d = &data[ext_repr.length as usize + ext_repr.buffer_len()..];
+ match SixlowpanNhcPacket::dispatch(d)? {
+ SixlowpanNhcPacket::ExtHeader => {
+ SixlowpanExtHeaderPacket::new_checked(d)?
+ .extension_header_id()
+ .into()
+ }
+ SixlowpanNhcPacket::UdpHeader => IpProtocol::Udp,
+ }
+ }
+ SixlowpanNextHeader::Uncompressed(proto) => proto,
+ };
+ next_header = Some(ext_repr.next_header);
+
+ let ipv6_ext_hdr = Ipv6ExtHeaderRepr {
+ next_header: nh,
+ length: ext_repr.length / 8,
+ data: &ext_hdr.payload()[..ext_repr.length as usize],
+ };
+
+ ipv6_ext_hdr.emit(&mut Ipv6ExtHeader::new_unchecked(
+ &mut buffer[..ipv6_ext_hdr.header_len()],
+ ));
+ buffer[ipv6_ext_hdr.header_len()..][..ipv6_ext_hdr.data.len()]
+ .copy_from_slice(ipv6_ext_hdr.data);
+
+ buffer = &mut buffer[ipv6_ext_hdr.header_len() + ipv6_ext_hdr.data.len()..];
+
+ rest_size -= ipv6_ext_hdr.header_len() + ipv6_ext_hdr.data.len();
+ data = &data[ext_repr.buffer_len() + ext_repr.length as usize..];
+ }
+ SixlowpanNhcPacket::UdpHeader => {
+ let udp_packet = SixlowpanUdpNhcPacket::new_checked(data)?;
+ let payload = udp_packet.payload();
+ let udp_repr = SixlowpanUdpNhcRepr::parse(
+ &udp_packet,
+ &iphc_repr.src_addr,
+ &iphc_repr.dst_addr,
+ &ChecksumCapabilities::ignored(),
+ )?;
+
+ if payload.len() + 8 > buffer.len() {
+ return Err(Error);
+ }
+
+ let mut udp = UdpPacket::new_unchecked(&mut buffer[..payload.len() + 8]);
+ udp_repr
+ .0
+ .emit_header(&mut udp, rest_size - udp_repr.0.header_len());
+ buffer[8..][..payload.len()].copy_from_slice(payload);
+
+ break;
+ }
+ },
+ SixlowpanNextHeader::Uncompressed(proto) => match proto {
+ IpProtocol::HopByHop => unreachable!(),
+ IpProtocol::Tcp => {
+ buffer.copy_from_slice(data);
+ break;
+ }
+ IpProtocol::Udp => {
+ buffer.copy_from_slice(data);
+ break;
+ }
+ IpProtocol::Icmpv6 => {
+ buffer.copy_from_slice(data);
+ break;
+ }
+ _ => unreachable!(),
+ },
+ }
+ }
+
+ Ok(decompressed_size)
+ }
+
+ pub(super) fn dispatch_sixlowpan<Tx: TxToken>(
+ &mut self,
+ mut tx_token: Tx,
+ meta: PacketMeta,
+ packet: Packet,
+ ieee_repr: Ieee802154Repr,
+ frag: &mut Fragmenter,
+ ) {
+ let packet = match packet {
+ #[cfg(feature = "proto-ipv4")]
+ Packet::Ipv4(_) => unreachable!(),
+ Packet::Ipv6(packet) => packet,
+ };
+
+ // First we calculate the size we are going to need. If the size is bigger than the MTU,
+ // then we use fragmentation.
+ let (total_size, compressed_size, uncompressed_size) =
+ Self::compressed_packet_size(&packet, &ieee_repr);
+
+ let ieee_len = ieee_repr.buffer_len();
+
+ // TODO(thvdveld): use the MTU of the device.
+ if total_size + ieee_len > 125 {
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ {
+ // The packet does not fit in one Ieee802154 frame, so we need fragmentation.
+ // We do this by emitting everything in the `frag.buffer` from the interface.
+ // After emitting everything into that buffer, we send the first fragment heere.
+ // When `poll` is called again, we check if frag was fully sent, otherwise we
+ // call `dispatch_ieee802154_frag`, which will transmit the other fragments.
+
+ // `dispatch_ieee802154_frag` requires some information about the total packet size,
+ // the link local source and destination address...
+
+ let pkt = frag;
+ if pkt.buffer.len() < total_size {
+ net_debug!(
+ "dispatch_ieee802154: dropping, \
+ fragmentation buffer is too small, at least {} needed",
+ total_size
+ );
+ return;
+ }
+
+ let payload_length = packet.header.payload_len;
+
+ Self::ipv6_to_sixlowpan(
+ &self.checksum_caps(),
+ packet,
+ &ieee_repr,
+ &mut pkt.buffer[..],
+ );
+
+ pkt.sixlowpan.ll_dst_addr = ieee_repr.dst_addr.unwrap();
+ pkt.sixlowpan.ll_src_addr = ieee_repr.src_addr.unwrap();
+ pkt.packet_len = total_size;
+
+ // The datagram size that we need to set in the first fragment header is equal to the
+ // IPv6 payload length + 40.
+ pkt.sixlowpan.datagram_size = (payload_length + 40) as u16;
+
+ let tag = self.get_sixlowpan_fragment_tag();
+ // We save the tag for the other fragments that will be created when calling `poll`
+ // multiple times.
+ pkt.sixlowpan.datagram_tag = tag;
+
+ let frag1 = SixlowpanFragRepr::FirstFragment {
+ size: pkt.sixlowpan.datagram_size,
+ tag,
+ };
+ let fragn = SixlowpanFragRepr::Fragment {
+ size: pkt.sixlowpan.datagram_size,
+ tag,
+ offset: 0,
+ };
+
+ // We calculate how much data we can send in the first fragment and the other
+ // fragments. The eventual IPv6 sizes of these fragments need to be a multiple of eight
+ // (except for the last fragment) since the offset field in the fragment is an offset
+ // in multiples of 8 octets. This is explained in [RFC 4944 § 5.3].
+ //
+ // [RFC 4944 § 5.3]: https://datatracker.ietf.org/doc/html/rfc4944#section-5.3
+
+ let header_diff = uncompressed_size - compressed_size;
+ let frag1_size =
+ (125 - ieee_len - frag1.buffer_len() + header_diff) / 8 * 8 - header_diff;
+
+ pkt.sixlowpan.fragn_size = (125 - ieee_len - fragn.buffer_len()) / 8 * 8;
+ pkt.sent_bytes = frag1_size;
+ pkt.sixlowpan.datagram_offset = frag1_size + header_diff;
+
+ tx_token.set_meta(meta);
+ tx_token.consume(ieee_len + frag1.buffer_len() + frag1_size, |mut tx_buf| {
+ // Add the IEEE header.
+ let mut ieee_packet = Ieee802154Frame::new_unchecked(&mut tx_buf[..ieee_len]);
+ ieee_repr.emit(&mut ieee_packet);
+ tx_buf = &mut tx_buf[ieee_len..];
+
+ // Add the first fragment header
+ let mut frag1_packet = SixlowpanFragPacket::new_unchecked(&mut tx_buf);
+ frag1.emit(&mut frag1_packet);
+ tx_buf = &mut tx_buf[frag1.buffer_len()..];
+
+ // Add the buffer part.
+ tx_buf[..frag1_size].copy_from_slice(&pkt.buffer[..frag1_size]);
+ });
+ }
+
+ #[cfg(not(feature = "proto-sixlowpan-fragmentation"))]
+ {
+ net_debug!(
+ "Enable the `proto-sixlowpan-fragmentation` feature for fragmentation support."
+ );
+ return;
+ }
+ } else {
+ tx_token.set_meta(meta);
+
+ // We don't need fragmentation, so we emit everything to the TX token.
+ tx_token.consume(total_size + ieee_len, |mut tx_buf| {
+ let mut ieee_packet = Ieee802154Frame::new_unchecked(&mut tx_buf[..ieee_len]);
+ ieee_repr.emit(&mut ieee_packet);
+ tx_buf = &mut tx_buf[ieee_len..];
+
+ Self::ipv6_to_sixlowpan(&self.checksum_caps(), packet, &ieee_repr, tx_buf);
+ });
+ }
+ }
+
+ fn ipv6_to_sixlowpan(
+ checksum_caps: &ChecksumCapabilities,
+ mut packet: PacketV6,
+ ieee_repr: &Ieee802154Repr,
+ mut buffer: &mut [u8],
+ ) {
+ let last_header = packet.payload.as_sixlowpan_next_header();
+ let next_header = last_header;
+
+ #[cfg(feature = "proto-ipv6-hbh")]
+ let next_header = if packet.hop_by_hop.is_some() {
+ SixlowpanNextHeader::Compressed
+ } else {
+ next_header
+ };
+
+ #[cfg(feature = "proto-ipv6-routing")]
+ let next_header = if packet.routing.is_some() {
+ SixlowpanNextHeader::Compressed
+ } else {
+ next_header
+ };
+
+ let iphc_repr = SixlowpanIphcRepr {
+ src_addr: packet.header.src_addr,
+ ll_src_addr: ieee_repr.src_addr,
+ dst_addr: packet.header.dst_addr,
+ ll_dst_addr: ieee_repr.dst_addr,
+ next_header,
+ hop_limit: packet.header.hop_limit,
+ ecn: None,
+ dscp: None,
+ flow_label: None,
+ };
+
+ iphc_repr.emit(&mut SixlowpanIphcPacket::new_unchecked(
+ &mut buffer[..iphc_repr.buffer_len()],
+ ));
+ buffer = &mut buffer[iphc_repr.buffer_len()..];
+
+ // Emit the Hop-by-Hop header
+ #[cfg(feature = "proto-ipv6-hbh")]
+ if let Some(hbh) = packet.hop_by_hop {
+ #[allow(unused)]
+ let next_header = last_header;
+
+ #[cfg(feature = "proto-ipv6-routing")]
+ let next_header = if packet.routing.is_some() {
+ SixlowpanNextHeader::Compressed
+ } else {
+ last_header
+ };
+
+ let ext_hdr = SixlowpanExtHeaderRepr {
+ ext_header_id: SixlowpanExtHeaderId::HopByHopHeader,
+ next_header,
+ length: hbh.options.iter().map(|o| o.buffer_len()).sum::<usize>() as u8,
+ };
+ ext_hdr.emit(&mut SixlowpanExtHeaderPacket::new_unchecked(
+ &mut buffer[..ext_hdr.buffer_len()],
+ ));
+ buffer = &mut buffer[ext_hdr.buffer_len()..];
+
+ for opt in &hbh.options {
+ opt.emit(&mut Ipv6Option::new_unchecked(
+ &mut buffer[..opt.buffer_len()],
+ ));
+
+ buffer = &mut buffer[opt.buffer_len()..];
+ }
+ }
+
+ // Emit the Routing header
+ #[cfg(feature = "proto-ipv6-routing")]
+ if let Some(routing) = &packet.routing {
+ let ext_hdr = SixlowpanExtHeaderRepr {
+ ext_header_id: SixlowpanExtHeaderId::RoutingHeader,
+ next_header,
+ length: routing.buffer_len() as u8,
+ };
+ ext_hdr.emit(&mut SixlowpanExtHeaderPacket::new_unchecked(
+ &mut buffer[..ext_hdr.buffer_len()],
+ ));
+ buffer = &mut buffer[ext_hdr.buffer_len()..];
+
+ routing.emit(&mut Ipv6RoutingHeader::new_unchecked(
+ &mut buffer[..routing.buffer_len()],
+ ));
+ buffer = &mut buffer[routing.buffer_len()..];
+ }
+
+ match &mut packet.payload {
+ IpPayload::Icmpv6(icmp_repr) => {
+ icmp_repr.emit(
+ &packet.header.src_addr.into(),
+ &packet.header.dst_addr.into(),
+ &mut Icmpv6Packet::new_unchecked(&mut buffer[..icmp_repr.buffer_len()]),
+ checksum_caps,
+ );
+ }
+ #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
+ IpPayload::Udp(udp_repr, payload) => {
+ let udp_repr = SixlowpanUdpNhcRepr(*udp_repr);
+ udp_repr.emit(
+ &mut SixlowpanUdpNhcPacket::new_unchecked(
+ &mut buffer[..udp_repr.header_len() + payload.len()],
+ ),
+ &iphc_repr.src_addr,
+ &iphc_repr.dst_addr,
+ payload.len(),
+ |buf| buf.copy_from_slice(payload),
+ checksum_caps,
+ );
+ }
+ #[cfg(feature = "socket-tcp")]
+ IpPayload::Tcp(tcp_repr) => {
+ tcp_repr.emit(
+ &mut TcpPacket::new_unchecked(&mut buffer[..tcp_repr.buffer_len()]),
+ &packet.header.src_addr.into(),
+ &packet.header.dst_addr.into(),
+ checksum_caps,
+ );
+ }
+ #[cfg(feature = "socket-raw")]
+ IpPayload::Raw(_raw) => todo!(),
+
+ #[allow(unreachable_patterns)]
+ _ => unreachable!(),
+ }
+ }
+
+ /// Calculates three sizes:
+ /// - total size: the size of a compressed IPv6 packet
+ /// - compressed header size: the size of the compressed headers
+ /// - uncompressed header size: the size of the headers that are not compressed
+ /// They are returned as a tuple in the same order.
+ fn compressed_packet_size(
+ packet: &PacketV6,
+ ieee_repr: &Ieee802154Repr,
+ ) -> (usize, usize, usize) {
+ let last_header = packet.payload.as_sixlowpan_next_header();
+ let next_header = last_header;
+
+ #[cfg(feature = "proto-ipv6-hbh")]
+ let next_header = if packet.hop_by_hop.is_some() {
+ SixlowpanNextHeader::Compressed
+ } else {
+ next_header
+ };
+
+ #[cfg(feature = "proto-ipv6-routing")]
+ let next_header = if packet.routing.is_some() {
+ SixlowpanNextHeader::Compressed
+ } else {
+ next_header
+ };
+
+ let iphc = SixlowpanIphcRepr {
+ src_addr: packet.header.src_addr,
+ ll_src_addr: ieee_repr.src_addr,
+ dst_addr: packet.header.dst_addr,
+ ll_dst_addr: ieee_repr.dst_addr,
+ next_header,
+ hop_limit: packet.header.hop_limit,
+ ecn: None,
+ dscp: None,
+ flow_label: None,
+ };
+
+ let mut total_size = iphc.buffer_len();
+ let mut compressed_hdr_size = iphc.buffer_len();
+ let mut uncompressed_hdr_size = packet.header.buffer_len();
+
+ // Add the hop-by-hop to the sizes.
+ #[cfg(feature = "proto-ipv6-hbh")]
+ if let Some(hbh) = &packet.hop_by_hop {
+ #[allow(unused)]
+ let next_header = last_header;
+
+ #[cfg(feature = "proto-ipv6-routing")]
+ let next_header = if packet.routing.is_some() {
+ SixlowpanNextHeader::Compressed
+ } else {
+ last_header
+ };
+
+ let options_size = hbh.options.iter().map(|o| o.buffer_len()).sum::<usize>();
+
+ let ext_hdr = SixlowpanExtHeaderRepr {
+ ext_header_id: SixlowpanExtHeaderId::HopByHopHeader,
+ next_header,
+ length: hbh.buffer_len() as u8 + options_size as u8,
+ };
+
+ total_size += ext_hdr.buffer_len() + options_size;
+ compressed_hdr_size += ext_hdr.buffer_len() + options_size;
+ uncompressed_hdr_size += hbh.buffer_len() + options_size;
+ }
+
+ // Add the routing header to the sizes.
+ #[cfg(feature = "proto-ipv6-routing")]
+ if let Some(routing) = &packet.routing {
+ let ext_hdr = SixlowpanExtHeaderRepr {
+ ext_header_id: SixlowpanExtHeaderId::RoutingHeader,
+ next_header,
+ length: routing.buffer_len() as u8,
+ };
+ total_size += ext_hdr.buffer_len() + routing.buffer_len();
+ compressed_hdr_size += ext_hdr.buffer_len() + routing.buffer_len();
+ uncompressed_hdr_size += routing.buffer_len();
+ }
+
+ match packet.payload {
+ #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
+ IpPayload::Udp(udp_hdr, payload) => {
+ uncompressed_hdr_size += udp_hdr.header_len();
+
+ let udp_hdr = SixlowpanUdpNhcRepr(udp_hdr);
+ compressed_hdr_size += udp_hdr.header_len();
+
+ total_size += udp_hdr.header_len() + payload.len();
+ }
+ _ => {
+ total_size += packet.header.payload_len;
+ }
+ }
+
+ (total_size, compressed_hdr_size, uncompressed_hdr_size)
+ }
+
+ #[cfg(feature = "proto-sixlowpan-fragmentation")]
+ pub(super) fn dispatch_sixlowpan_frag<Tx: TxToken>(
+ &mut self,
+ tx_token: Tx,
+ ieee_repr: Ieee802154Repr,
+ frag: &mut Fragmenter,
+ ) {
+ // Create the FRAG_N header.
+ let fragn = SixlowpanFragRepr::Fragment {
+ size: frag.sixlowpan.datagram_size,
+ tag: frag.sixlowpan.datagram_tag,
+ offset: (frag.sixlowpan.datagram_offset / 8) as u8,
+ };
+
+ let ieee_len = ieee_repr.buffer_len();
+ let frag_size = (frag.packet_len - frag.sent_bytes).min(frag.sixlowpan.fragn_size);
+
+ tx_token.consume(
+ ieee_repr.buffer_len() + fragn.buffer_len() + frag_size,
+ |mut tx_buf| {
+ let mut ieee_packet = Ieee802154Frame::new_unchecked(&mut tx_buf[..ieee_len]);
+ ieee_repr.emit(&mut ieee_packet);
+ tx_buf = &mut tx_buf[ieee_len..];
+
+ let mut frag_packet =
+ SixlowpanFragPacket::new_unchecked(&mut tx_buf[..fragn.buffer_len()]);
+ fragn.emit(&mut frag_packet);
+ tx_buf = &mut tx_buf[fragn.buffer_len()..];
+
+ // Add the buffer part
+ tx_buf[..frag_size].copy_from_slice(&frag.buffer[frag.sent_bytes..][..frag_size]);
+
+ frag.sent_bytes += frag_size;
+ frag.sixlowpan.datagram_offset += frag_size;
+ },
+ );
+ }
+}
+
+#[cfg(test)]
+#[cfg(all(feature = "proto-rpl", feature = "proto-ipv6-hbh"))]
+mod tests {
+ use super::*;
+
+ static SIXLOWPAN_COMPRESSED_RPL_DAO: [u8; 99] = [
+ 0x61, 0xdc, 0x45, 0xcd, 0xab, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x03, 0x00,
+ 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x7e, 0xf7, 0x00, 0xe0, 0x3a, 0x06, 0x63, 0x04, 0x00,
+ 0x1e, 0x08, 0x00, 0x9b, 0x02, 0x3e, 0x63, 0x1e, 0x40, 0x00, 0xf1, 0xfd, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x05, 0x12, 0x00,
+ 0x80, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x00, 0x03, 0x00, 0x03,
+ 0x00, 0x03, 0x06, 0x14, 0x00, 0x00, 0x00, 0x1e, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+ ];
+
+ static SIXLOWPAN_UNCOMPRESSED_RPL_DAO: [u8; 114] = [
+ 0x60, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x40, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x02, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x3a, 0x00, 0x63, 0x04, 0x00,
+ 0x1e, 0x08, 0x00, 0x9b, 0x02, 0x3e, 0x63, 0x1e, 0x40, 0x00, 0xf1, 0xfd, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x05, 0x12, 0x00,
+ 0x80, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x00, 0x03, 0x00, 0x03,
+ 0x00, 0x03, 0x06, 0x14, 0x00, 0x00, 0x00, 0x1e, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+ ];
+
+ #[test]
+ fn test_sixlowpan_decompress_hop_by_hop_with_icmpv6() {
+ let address_context = [SixlowpanAddressContext([
+ 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ ])];
+
+ let ieee_frame = Ieee802154Frame::new_checked(&SIXLOWPAN_COMPRESSED_RPL_DAO).unwrap();
+ let ieee_repr = Ieee802154Repr::parse(&ieee_frame).unwrap();
+
+ let mut buffer = [0u8; 256];
+ let len = InterfaceInner::sixlowpan_to_ipv6(
+ &address_context,
+ &ieee_repr,
+ ieee_frame.payload().unwrap(),
+ None,
+ &mut buffer[..],
+ )
+ .unwrap();
+
+ assert_eq!(&buffer[..len], &SIXLOWPAN_UNCOMPRESSED_RPL_DAO);
+ }
+
+ #[test]
+ fn test_sixlowpan_compress_hop_by_hop_with_icmpv6() {
+ let ieee_repr = Ieee802154Repr {
+ frame_type: Ieee802154FrameType::Data,
+ security_enabled: false,
+ frame_pending: false,
+ ack_request: true,
+ sequence_number: Some(69),
+ pan_id_compression: true,
+ frame_version: Ieee802154FrameVersion::Ieee802154_2006,
+ dst_pan_id: Some(Ieee802154Pan(43981)),
+ dst_addr: Some(Ieee802154Address::Extended([0, 1, 0, 1, 0, 1, 0, 1])),
+ src_pan_id: None,
+ src_addr: Some(Ieee802154Address::Extended([0, 3, 0, 3, 0, 3, 0, 3])),
+ };
+
+ let mut ip_packet = PacketV6 {
+ header: Ipv6Repr {
+ src_addr: Ipv6Address::from_bytes(&[
+ 253, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 3, 0, 3, 0, 3,
+ ]),
+ dst_addr: Ipv6Address::from_bytes(&[
+ 253, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 1, 0, 1,
+ ]),
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 66,
+ hop_limit: 64,
+ },
+ #[cfg(feature = "proto-ipv6-hbh")]
+ hop_by_hop: None,
+ #[cfg(feature = "proto-ipv6-fragmentation")]
+ fragment: None,
+ #[cfg(feature = "proto-ipv6-routing")]
+ routing: None,
+ payload: IpPayload::Icmpv6(Icmpv6Repr::Rpl(RplRepr::DestinationAdvertisementObject {
+ rpl_instance_id: RplInstanceId::Global(30),
+ expect_ack: false,
+ sequence: 241,
+ dodag_id: Some(Ipv6Address::from_bytes(&[
+ 253, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 1, 0, 1,
+ ])),
+ options: &[],
+ })),
+ };
+
+ let (total_size, _, _) = InterfaceInner::compressed_packet_size(&mut ip_packet, &ieee_repr);
+ let mut buffer = vec![0u8; total_size];
+
+ InterfaceInner::ipv6_to_sixlowpan(
+ &ChecksumCapabilities::default(),
+ ip_packet,
+ &ieee_repr,
+ &mut buffer[..total_size],
+ );
+
+ let result = [
+ 0x7e, 0x0, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x3, 0x0, 0x3, 0x0, 0x3, 0x0,
+ 0x3, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1,
+ 0xe0, 0x3a, 0x6, 0x63, 0x4, 0x0, 0x1e, 0x3, 0x0, 0x9b, 0x2, 0x3e, 0x63, 0x1e, 0x40,
+ 0x0, 0xf1, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0,
+ 0x1, 0x5, 0x12, 0x0, 0x80, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x3, 0x0, 0x3,
+ 0x0, 0x3, 0x0, 0x3, 0x6, 0x14, 0x0, 0x0, 0x0, 0x1e, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x2, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1,
+ ];
+
+ assert_eq!(&result, &result);
+ }
+
+ #[test]
+ fn test_sixlowpan_compress_hop_by_hop_with_udp() {
+ let ieee_repr = Ieee802154Repr {
+ frame_type: Ieee802154FrameType::Data,
+ security_enabled: false,
+ frame_pending: false,
+ ack_request: true,
+ sequence_number: Some(69),
+ pan_id_compression: true,
+ frame_version: Ieee802154FrameVersion::Ieee802154_2006,
+ dst_pan_id: Some(Ieee802154Pan(43981)),
+ dst_addr: Some(Ieee802154Address::Extended([0, 1, 0, 1, 0, 1, 0, 1])),
+ src_pan_id: None,
+ src_addr: Some(Ieee802154Address::Extended([0, 3, 0, 3, 0, 3, 0, 3])),
+ };
+
+ let addr = Ipv6Address::from_bytes(&[253, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 3, 0, 3, 0, 3]);
+ let parent_address =
+ Ipv6Address::from_bytes(&[253, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 1, 0, 1]);
+
+ let mut hbh_options = heapless::Vec::new();
+ hbh_options
+ .push(Ipv6OptionRepr::Rpl(RplHopByHopRepr {
+ down: false,
+ rank_error: false,
+ forwarding_error: false,
+ instance_id: RplInstanceId::from(0x1e),
+ sender_rank: 0x300,
+ }))
+ .unwrap();
+
+ let mut ip_packet = PacketV6 {
+ header: Ipv6Repr {
+ src_addr: addr,
+ dst_addr: parent_address,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 66,
+ hop_limit: 64,
+ },
+ #[cfg(feature = "proto-ipv6-hbh")]
+ hop_by_hop: Some(Ipv6HopByHopRepr {
+ options: hbh_options,
+ }),
+ #[cfg(feature = "proto-ipv6-fragmentation")]
+ fragment: None,
+ #[cfg(feature = "proto-ipv6-routing")]
+ routing: None,
+ payload: IpPayload::Icmpv6(Icmpv6Repr::Rpl(RplRepr::DestinationAdvertisementObject {
+ rpl_instance_id: RplInstanceId::Global(30),
+ expect_ack: false,
+ sequence: 241,
+ dodag_id: Some(Ipv6Address::from_bytes(&[
+ 253, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 1, 0, 1,
+ ])),
+ options: &[
+ 5, 18, 0, 128, 253, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 3, 0, 3, 0, 3, 6, 20, 0, 0,
+ 0, 30, 253, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 1, 0, 1,
+ ],
+ })),
+ };
+
+ let (total_size, _, _) = InterfaceInner::compressed_packet_size(&mut ip_packet, &ieee_repr);
+ let mut buffer = vec![0u8; total_size];
+
+ InterfaceInner::ipv6_to_sixlowpan(
+ &ChecksumCapabilities::default(),
+ ip_packet,
+ &ieee_repr,
+ &mut buffer[..total_size],
+ );
+
+ let result = [
+ 0x7e, 0x0, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x3, 0x0, 0x3, 0x0, 0x3, 0x0,
+ 0x3, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1,
+ 0xe0, 0x3a, 0x6, 0x63, 0x4, 0x0, 0x1e, 0x3, 0x0, 0x9b, 0x2, 0x3e, 0x63, 0x1e, 0x40,
+ 0x0, 0xf1, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0,
+ 0x1, 0x5, 0x12, 0x0, 0x80, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x3, 0x0, 0x3,
+ 0x0, 0x3, 0x0, 0x3, 0x6, 0x14, 0x0, 0x0, 0x0, 0x1e, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x2, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1,
+ ];
+
+ assert_eq!(&buffer[..total_size], &result);
+ }
+}
diff --git a/src/iface/interface/tests/ipv4.rs b/src/iface/interface/tests/ipv4.rs
new file mode 100644
index 0000000..d685f37
--- /dev/null
+++ b/src/iface/interface/tests/ipv4.rs
@@ -0,0 +1,968 @@
+use super::*;
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_no_icmp_no_unicast(#[case] medium: Medium) {
+ let (mut iface, mut sockets, _) = setup(medium);
+
+ // Unknown Ipv4 Protocol
+ //
+ // Because the destination is the broadcast address
+ // this should not trigger and Destination Unreachable
+ // response. See RFC 1122 § 3.2.2.
+ let repr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Unknown(0x0c),
+ payload_len: 0,
+ hop_limit: 0x40,
+ });
+
+ let mut bytes = vec![0u8; 54];
+ repr.emit(&mut bytes, &ChecksumCapabilities::default());
+ let frame = Ipv4Packet::new_unchecked(&bytes[..]);
+
+ // Ensure that the unknown protocol frame does not trigger an
+ // ICMP error response when the destination address is a
+ // broadcast address
+
+ assert_eq!(
+ iface.inner.process_ipv4(
+ &mut sockets,
+ PacketMeta::default(),
+ &frame,
+ &mut iface.fragments
+ ),
+ None
+ );
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_icmp_error_no_payload(#[case] medium: Medium) {
+ static NO_BYTES: [u8; 0] = [];
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ // Unknown Ipv4 Protocol with no payload
+ let repr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
+ dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ next_header: IpProtocol::Unknown(0x0c),
+ payload_len: 0,
+ hop_limit: 0x40,
+ });
+
+ let mut bytes = vec![0u8; 34];
+ repr.emit(&mut bytes, &ChecksumCapabilities::default());
+ let frame = Ipv4Packet::new_unchecked(&bytes[..]);
+
+ // The expected Destination Unreachable response due to the
+ // unknown protocol
+ let icmp_repr = Icmpv4Repr::DstUnreachable {
+ reason: Icmpv4DstUnreachable::ProtoUnreachable,
+ header: Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
+ dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ next_header: IpProtocol::Unknown(12),
+ payload_len: 0,
+ hop_limit: 64,
+ },
+ data: &NO_BYTES,
+ };
+
+ let expected_repr = Packet::new_ipv4(
+ Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
+ next_header: IpProtocol::Icmp,
+ payload_len: icmp_repr.buffer_len(),
+ hop_limit: 64,
+ },
+ IpPayload::Icmpv4(icmp_repr),
+ );
+
+ // Ensure that the unknown protocol triggers an error response.
+ // And we correctly handle no payload.
+
+ assert_eq!(
+ iface.inner.process_ipv4(
+ &mut sockets,
+ PacketMeta::default(),
+ &frame,
+ &mut iface.fragments
+ ),
+ Some(expected_repr)
+ );
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_local_subnet_broadcasts(#[case] medium: Medium) {
+ let (mut iface, _, _device) = setup(medium);
+ iface.update_ip_addrs(|addrs| {
+ addrs.iter_mut().next().map(|addr| {
+ *addr = IpCidr::Ipv4(Ipv4Cidr::new(Ipv4Address([192, 168, 1, 23]), 24));
+ });
+ });
+
+ assert!(iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([255, 255, 255, 255])));
+ assert!(!iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([255, 255, 255, 254])));
+ assert!(iface.inner.is_broadcast_v4(Ipv4Address([192, 168, 1, 255])));
+ assert!(!iface.inner.is_broadcast_v4(Ipv4Address([192, 168, 1, 254])));
+
+ iface.update_ip_addrs(|addrs| {
+ addrs.iter_mut().next().map(|addr| {
+ *addr = IpCidr::Ipv4(Ipv4Cidr::new(Ipv4Address([192, 168, 23, 24]), 16));
+ });
+ });
+ assert!(iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([255, 255, 255, 255])));
+ assert!(!iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([255, 255, 255, 254])));
+ assert!(!iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([192, 168, 23, 255])));
+ assert!(!iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([192, 168, 23, 254])));
+ assert!(!iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([192, 168, 255, 254])));
+ assert!(iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([192, 168, 255, 255])));
+
+ iface.update_ip_addrs(|addrs| {
+ addrs.iter_mut().next().map(|addr| {
+ *addr = IpCidr::Ipv4(Ipv4Cidr::new(Ipv4Address([192, 168, 23, 24]), 8));
+ });
+ });
+ assert!(iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([255, 255, 255, 255])));
+ assert!(!iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([255, 255, 255, 254])));
+ assert!(!iface.inner.is_broadcast_v4(Ipv4Address([192, 23, 1, 255])));
+ assert!(!iface.inner.is_broadcast_v4(Ipv4Address([192, 23, 1, 254])));
+ assert!(!iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([192, 255, 255, 254])));
+ assert!(iface
+ .inner
+ .is_broadcast_v4(Ipv4Address([192, 255, 255, 255])));
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(all(feature = "medium-ip", feature = "socket-udp"))]
+#[case(Medium::Ethernet)]
+#[cfg(all(feature = "medium-ethernet", feature = "socket-udp"))]
+fn test_icmp_error_port_unreachable(#[case] medium: Medium) {
+ static UDP_PAYLOAD: [u8; 12] = [
+ 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x57, 0x6f, 0x6c, 0x64, 0x21,
+ ];
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let mut udp_bytes_unicast = vec![0u8; 20];
+ let mut udp_bytes_broadcast = vec![0u8; 20];
+ let mut packet_unicast = UdpPacket::new_unchecked(&mut udp_bytes_unicast);
+ let mut packet_broadcast = UdpPacket::new_unchecked(&mut udp_bytes_broadcast);
+
+ let udp_repr = UdpRepr {
+ src_port: 67,
+ dst_port: 68,
+ };
+
+ let ip_repr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
+ dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ next_header: IpProtocol::Udp,
+ payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
+ hop_limit: 64,
+ });
+
+ // Emit the representations to a packet
+ udp_repr.emit(
+ &mut packet_unicast,
+ &ip_repr.src_addr(),
+ &ip_repr.dst_addr(),
+ UDP_PAYLOAD.len(),
+ |buf| buf.copy_from_slice(&UDP_PAYLOAD),
+ &ChecksumCapabilities::default(),
+ );
+
+ let data = packet_unicast.into_inner();
+
+ // The expected Destination Unreachable ICMPv4 error response due
+ // to no sockets listening on the destination port.
+ let icmp_repr = Icmpv4Repr::DstUnreachable {
+ reason: Icmpv4DstUnreachable::PortUnreachable,
+ header: Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
+ dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ next_header: IpProtocol::Udp,
+ payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
+ hop_limit: 64,
+ },
+ data,
+ };
+ let expected_repr = Packet::new_ipv4(
+ Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ dst_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
+ next_header: IpProtocol::Icmp,
+ payload_len: icmp_repr.buffer_len(),
+ hop_limit: 64,
+ },
+ IpPayload::Icmpv4(icmp_repr),
+ );
+
+ // Ensure that the unknown protocol triggers an error response.
+ // And we correctly handle no payload.
+ assert_eq!(
+ iface.inner.process_udp(
+ &mut sockets,
+ PacketMeta::default(),
+ ip_repr,
+ udp_repr,
+ false,
+ &UDP_PAYLOAD,
+ data
+ ),
+ Some(expected_repr)
+ );
+
+ let ip_repr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x02]),
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Udp,
+ payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
+ hop_limit: 64,
+ });
+
+ // Emit the representations to a packet
+ udp_repr.emit(
+ &mut packet_broadcast,
+ &ip_repr.src_addr(),
+ &IpAddress::Ipv4(Ipv4Address::BROADCAST),
+ UDP_PAYLOAD.len(),
+ |buf| buf.copy_from_slice(&UDP_PAYLOAD),
+ &ChecksumCapabilities::default(),
+ );
+
+ // Ensure that the port unreachable error does not trigger an
+ // ICMP error response when the destination address is a
+ // broadcast address and no socket is bound to the port.
+ assert_eq!(
+ iface.inner.process_udp(
+ &mut sockets,
+ PacketMeta::default(),
+ ip_repr,
+ udp_repr,
+ false,
+ &UDP_PAYLOAD,
+ packet_broadcast.into_inner(),
+ ),
+ None
+ );
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_handle_ipv4_broadcast(#[case] medium: Medium) {
+ use crate::wire::{Icmpv4Packet, Icmpv4Repr};
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let our_ipv4_addr = iface.ipv4_addr().unwrap();
+ let src_ipv4_addr = Ipv4Address([127, 0, 0, 2]);
+
+ // ICMPv4 echo request
+ let icmpv4_data: [u8; 4] = [0xaa, 0x00, 0x00, 0xff];
+ let icmpv4_repr = Icmpv4Repr::EchoRequest {
+ ident: 0x1234,
+ seq_no: 0xabcd,
+ data: &icmpv4_data,
+ };
+
+ // Send to IPv4 broadcast address
+ let ipv4_repr = Ipv4Repr {
+ src_addr: src_ipv4_addr,
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Icmp,
+ hop_limit: 64,
+ payload_len: icmpv4_repr.buffer_len(),
+ };
+
+ // Emit to ip frame
+ let mut bytes = vec![0u8; ipv4_repr.buffer_len() + icmpv4_repr.buffer_len()];
+ let frame = {
+ ipv4_repr.emit(
+ &mut Ipv4Packet::new_unchecked(&mut bytes[..]),
+ &ChecksumCapabilities::default(),
+ );
+ icmpv4_repr.emit(
+ &mut Icmpv4Packet::new_unchecked(&mut bytes[ipv4_repr.buffer_len()..]),
+ &ChecksumCapabilities::default(),
+ );
+ Ipv4Packet::new_unchecked(&bytes[..])
+ };
+
+ // Expected ICMPv4 echo reply
+ let expected_icmpv4_repr = Icmpv4Repr::EchoReply {
+ ident: 0x1234,
+ seq_no: 0xabcd,
+ data: &icmpv4_data,
+ };
+ let expected_ipv4_repr = Ipv4Repr {
+ src_addr: our_ipv4_addr,
+ dst_addr: src_ipv4_addr,
+ next_header: IpProtocol::Icmp,
+ hop_limit: 64,
+ payload_len: expected_icmpv4_repr.buffer_len(),
+ };
+ let expected_packet =
+ Packet::new_ipv4(expected_ipv4_repr, IpPayload::Icmpv4(expected_icmpv4_repr));
+
+ assert_eq!(
+ iface.inner.process_ipv4(
+ &mut sockets,
+ PacketMeta::default(),
+ &frame,
+ &mut iface.fragments
+ ),
+ Some(expected_packet)
+ );
+}
+
+#[rstest]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_handle_valid_arp_request(#[case] medium: Medium) {
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let mut eth_bytes = vec![0u8; 42];
+
+ let local_ip_addr = Ipv4Address([0x7f, 0x00, 0x00, 0x01]);
+ let remote_ip_addr = Ipv4Address([0x7f, 0x00, 0x00, 0x02]);
+ let local_hw_addr = EthernetAddress([0x02, 0x02, 0x02, 0x02, 0x02, 0x02]);
+ let remote_hw_addr = EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]);
+
+ let repr = ArpRepr::EthernetIpv4 {
+ operation: ArpOperation::Request,
+ source_hardware_addr: remote_hw_addr,
+ source_protocol_addr: remote_ip_addr,
+ target_hardware_addr: EthernetAddress::default(),
+ target_protocol_addr: local_ip_addr,
+ };
+
+ let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
+ frame.set_dst_addr(EthernetAddress::BROADCAST);
+ frame.set_src_addr(remote_hw_addr);
+ frame.set_ethertype(EthernetProtocol::Arp);
+ let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
+ repr.emit(&mut packet);
+
+ // Ensure an ARP Request for us triggers an ARP Reply
+ assert_eq!(
+ iface.inner.process_ethernet(
+ &mut sockets,
+ PacketMeta::default(),
+ frame.into_inner(),
+ &mut iface.fragments
+ ),
+ Some(EthernetPacket::Arp(ArpRepr::EthernetIpv4 {
+ operation: ArpOperation::Reply,
+ source_hardware_addr: local_hw_addr,
+ source_protocol_addr: local_ip_addr,
+ target_hardware_addr: remote_hw_addr,
+ target_protocol_addr: remote_ip_addr
+ }))
+ );
+
+ // Ensure the address of the requester was entered in the cache
+ assert_eq!(
+ iface.inner.lookup_hardware_addr(
+ MockTxToken,
+ &IpAddress::Ipv4(local_ip_addr),
+ &IpAddress::Ipv4(remote_ip_addr),
+ &mut iface.fragmenter,
+ ),
+ Ok((HardwareAddress::Ethernet(remote_hw_addr), MockTxToken))
+ );
+}
+
+#[rstest]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_handle_other_arp_request(#[case] medium: Medium) {
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let mut eth_bytes = vec![0u8; 42];
+
+ let remote_ip_addr = Ipv4Address([0x7f, 0x00, 0x00, 0x02]);
+ let remote_hw_addr = EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]);
+
+ let repr = ArpRepr::EthernetIpv4 {
+ operation: ArpOperation::Request,
+ source_hardware_addr: remote_hw_addr,
+ source_protocol_addr: remote_ip_addr,
+ target_hardware_addr: EthernetAddress::default(),
+ target_protocol_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x03]),
+ };
+
+ let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
+ frame.set_dst_addr(EthernetAddress::BROADCAST);
+ frame.set_src_addr(remote_hw_addr);
+ frame.set_ethertype(EthernetProtocol::Arp);
+ let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
+ repr.emit(&mut packet);
+
+ // Ensure an ARP Request for someone else does not trigger an ARP Reply
+ assert_eq!(
+ iface.inner.process_ethernet(
+ &mut sockets,
+ PacketMeta::default(),
+ frame.into_inner(),
+ &mut iface.fragments
+ ),
+ None
+ );
+
+ // Ensure the address of the requester was NOT entered in the cache
+ assert_eq!(
+ iface.inner.lookup_hardware_addr(
+ MockTxToken,
+ &IpAddress::Ipv4(Ipv4Address([0x7f, 0x00, 0x00, 0x01])),
+ &IpAddress::Ipv4(remote_ip_addr),
+ &mut iface.fragmenter,
+ ),
+ Err(DispatchError::NeighborPending)
+ );
+}
+
+#[rstest]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_arp_flush_after_update_ip(#[case] medium: Medium) {
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let mut eth_bytes = vec![0u8; 42];
+
+ let local_ip_addr = Ipv4Address([0x7f, 0x00, 0x00, 0x01]);
+ let remote_ip_addr = Ipv4Address([0x7f, 0x00, 0x00, 0x02]);
+ let local_hw_addr = EthernetAddress([0x02, 0x02, 0x02, 0x02, 0x02, 0x02]);
+ let remote_hw_addr = EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]);
+
+ let repr = ArpRepr::EthernetIpv4 {
+ operation: ArpOperation::Request,
+ source_hardware_addr: remote_hw_addr,
+ source_protocol_addr: remote_ip_addr,
+ target_hardware_addr: EthernetAddress::default(),
+ target_protocol_addr: Ipv4Address([0x7f, 0x00, 0x00, 0x01]),
+ };
+
+ let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
+ frame.set_dst_addr(EthernetAddress::BROADCAST);
+ frame.set_src_addr(remote_hw_addr);
+ frame.set_ethertype(EthernetProtocol::Arp);
+ {
+ let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
+ repr.emit(&mut packet);
+ }
+
+ // Ensure an ARP Request for us triggers an ARP Reply
+ assert_eq!(
+ iface.inner.process_ethernet(
+ &mut sockets,
+ PacketMeta::default(),
+ frame.into_inner(),
+ &mut iface.fragments
+ ),
+ Some(EthernetPacket::Arp(ArpRepr::EthernetIpv4 {
+ operation: ArpOperation::Reply,
+ source_hardware_addr: local_hw_addr,
+ source_protocol_addr: local_ip_addr,
+ target_hardware_addr: remote_hw_addr,
+ target_protocol_addr: remote_ip_addr
+ }))
+ );
+
+ // Ensure the address of the requester was entered in the cache
+ assert_eq!(
+ iface.inner.lookup_hardware_addr(
+ MockTxToken,
+ &IpAddress::Ipv4(local_ip_addr),
+ &IpAddress::Ipv4(remote_ip_addr),
+ &mut iface.fragmenter,
+ ),
+ Ok((HardwareAddress::Ethernet(remote_hw_addr), MockTxToken))
+ );
+
+ // Update IP addrs to trigger ARP cache flush
+ let local_ip_addr_new = Ipv4Address([0x7f, 0x00, 0x00, 0x01]);
+ iface.update_ip_addrs(|addrs| {
+ addrs.iter_mut().next().map(|addr| {
+ *addr = IpCidr::Ipv4(Ipv4Cidr::new(local_ip_addr_new, 24));
+ });
+ });
+
+ // ARP cache flush after address change
+ assert!(!iface.inner.has_neighbor(&IpAddress::Ipv4(remote_ip_addr)));
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(all(feature = "socket-icmp", feature = "medium-ip"))]
+#[case(Medium::Ethernet)]
+#[cfg(all(feature = "socket-icmp", feature = "medium-ethernet"))]
+fn test_icmpv4_socket(#[case] medium: Medium) {
+ use crate::wire::Icmpv4Packet;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let rx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 24]);
+ let tx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 24]);
+
+ let icmpv4_socket = icmp::Socket::new(rx_buffer, tx_buffer);
+
+ let socket_handle = sockets.add(icmpv4_socket);
+
+ let ident = 0x1234;
+ let seq_no = 0x5432;
+ let echo_data = &[0xff; 16];
+
+ let socket = sockets.get_mut::<icmp::Socket>(socket_handle);
+ // Bind to the ID 0x1234
+ assert_eq!(socket.bind(icmp::Endpoint::Ident(ident)), Ok(()));
+
+ // Ensure the ident we bound to and the ident of the packet are the same.
+ let mut bytes = [0xff; 24];
+ let mut packet = Icmpv4Packet::new_unchecked(&mut bytes[..]);
+ let echo_repr = Icmpv4Repr::EchoRequest {
+ ident,
+ seq_no,
+ data: echo_data,
+ };
+ echo_repr.emit(&mut packet, &ChecksumCapabilities::default());
+ let icmp_data = &*packet.into_inner();
+
+ let ipv4_repr = Ipv4Repr {
+ src_addr: Ipv4Address::new(0x7f, 0x00, 0x00, 0x02),
+ dst_addr: Ipv4Address::new(0x7f, 0x00, 0x00, 0x01),
+ next_header: IpProtocol::Icmp,
+ payload_len: 24,
+ hop_limit: 64,
+ };
+ let ip_repr = IpRepr::Ipv4(ipv4_repr);
+
+ // Open a socket and ensure the packet is handled due to the listening
+ // socket.
+ assert!(!sockets.get_mut::<icmp::Socket>(socket_handle).can_recv());
+
+ // Confirm we still get EchoReply from `smoltcp` even with the ICMP socket listening
+ let echo_reply = Icmpv4Repr::EchoReply {
+ ident,
+ seq_no,
+ data: echo_data,
+ };
+ let ipv4_reply = Ipv4Repr {
+ src_addr: ipv4_repr.dst_addr,
+ dst_addr: ipv4_repr.src_addr,
+ ..ipv4_repr
+ };
+ assert_eq!(
+ iface.inner.process_icmpv4(&mut sockets, ip_repr, icmp_data),
+ Some(Packet::new_ipv4(ipv4_reply, IpPayload::Icmpv4(echo_reply)))
+ );
+
+ let socket = sockets.get_mut::<icmp::Socket>(socket_handle);
+ assert!(socket.can_recv());
+ assert_eq!(
+ socket.recv(),
+ Ok((
+ icmp_data,
+ IpAddress::Ipv4(Ipv4Address::new(0x7f, 0x00, 0x00, 0x02))
+ ))
+ );
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(all(feature = "proto-igmp", feature = "medium-ip"))]
+#[case(Medium::Ethernet)]
+#[cfg(all(feature = "proto-igmp", feature = "medium-ethernet"))]
+fn test_handle_igmp(#[case] medium: Medium) {
+ fn recv_igmp(
+ device: &mut crate::tests::TestingDevice,
+ timestamp: Instant,
+ ) -> Vec<(Ipv4Repr, IgmpRepr)> {
+ let caps = device.capabilities();
+ let checksum_caps = &caps.checksum;
+ recv_all(device, timestamp)
+ .iter()
+ .filter_map(|frame| {
+ let ipv4_packet = match caps.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => {
+ let eth_frame = EthernetFrame::new_checked(frame).ok()?;
+ Ipv4Packet::new_checked(eth_frame.payload()).ok()?
+ }
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => Ipv4Packet::new_checked(&frame[..]).ok()?,
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => todo!(),
+ };
+ let ipv4_repr = Ipv4Repr::parse(&ipv4_packet, checksum_caps).ok()?;
+ let ip_payload = ipv4_packet.payload();
+ let igmp_packet = IgmpPacket::new_checked(ip_payload).ok()?;
+ let igmp_repr = IgmpRepr::parse(&igmp_packet).ok()?;
+ Some((ipv4_repr, igmp_repr))
+ })
+ .collect::<Vec<_>>()
+ }
+
+ let groups = [
+ Ipv4Address::new(224, 0, 0, 22),
+ Ipv4Address::new(224, 0, 0, 56),
+ ];
+
+ let (mut iface, mut sockets, mut device) = setup(medium);
+
+ // Join multicast groups
+ let timestamp = Instant::ZERO;
+ for group in &groups {
+ iface
+ .join_multicast_group(&mut device, *group, timestamp)
+ .unwrap();
+ }
+
+ let reports = recv_igmp(&mut device, timestamp);
+ assert_eq!(reports.len(), 2);
+ for (i, group_addr) in groups.iter().enumerate() {
+ assert_eq!(reports[i].0.next_header, IpProtocol::Igmp);
+ assert_eq!(reports[i].0.dst_addr, *group_addr);
+ assert_eq!(
+ reports[i].1,
+ IgmpRepr::MembershipReport {
+ group_addr: *group_addr,
+ version: IgmpVersion::Version2,
+ }
+ );
+ }
+
+ // General query
+ let timestamp = Instant::ZERO;
+ const GENERAL_QUERY_BYTES: &[u8] = &[
+ 0x46, 0xc0, 0x00, 0x24, 0xed, 0xb4, 0x00, 0x00, 0x01, 0x02, 0x47, 0x43, 0xac, 0x16, 0x63,
+ 0x04, 0xe0, 0x00, 0x00, 0x01, 0x94, 0x04, 0x00, 0x00, 0x11, 0x64, 0xec, 0x8f, 0x00, 0x00,
+ 0x00, 0x00, 0x02, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00,
+ ];
+ {
+ // Transmit GENERAL_QUERY_BYTES into loopback
+ let tx_token = device.transmit(timestamp).unwrap();
+ tx_token.consume(GENERAL_QUERY_BYTES.len(), |buffer| {
+ buffer.copy_from_slice(GENERAL_QUERY_BYTES);
+ });
+ }
+ // Trigger processing until all packets received through the
+ // loopback have been processed, including responses to
+ // GENERAL_QUERY_BYTES. Therefore `recv_all()` would return 0
+ // pkts that could be checked.
+ iface.socket_ingress(&mut device, &mut sockets);
+
+ // Leave multicast groups
+ let timestamp = Instant::ZERO;
+ for group in &groups {
+ iface
+ .leave_multicast_group(&mut device, *group, timestamp)
+ .unwrap();
+ }
+
+ let leaves = recv_igmp(&mut device, timestamp);
+ assert_eq!(leaves.len(), 2);
+ for (i, group_addr) in groups.iter().cloned().enumerate() {
+ assert_eq!(leaves[i].0.next_header, IpProtocol::Igmp);
+ assert_eq!(leaves[i].0.dst_addr, Ipv4Address::MULTICAST_ALL_ROUTERS);
+ assert_eq!(leaves[i].1, IgmpRepr::LeaveGroup { group_addr });
+ }
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(all(feature = "socket-raw", feature = "medium-ip"))]
+#[case(Medium::Ethernet)]
+#[cfg(all(feature = "socket-raw", feature = "medium-ethernet"))]
+fn test_raw_socket_no_reply(#[case] medium: Medium) {
+ use crate::wire::{IpVersion, UdpPacket, UdpRepr};
+
+ let (mut iface, mut sockets, _) = setup(medium);
+
+ let packets = 1;
+ let rx_buffer =
+ raw::PacketBuffer::new(vec![raw::PacketMetadata::EMPTY; packets], vec![0; 48 * 1]);
+ let tx_buffer = raw::PacketBuffer::new(
+ vec![raw::PacketMetadata::EMPTY; packets],
+ vec![0; 48 * packets],
+ );
+ let raw_socket = raw::Socket::new(IpVersion::Ipv4, IpProtocol::Udp, rx_buffer, tx_buffer);
+ sockets.add(raw_socket);
+
+ let src_addr = Ipv4Address([127, 0, 0, 2]);
+ let dst_addr = Ipv4Address([127, 0, 0, 1]);
+
+ const PAYLOAD_LEN: usize = 10;
+
+ let udp_repr = UdpRepr {
+ src_port: 67,
+ dst_port: 68,
+ };
+ let mut bytes = vec![0xff; udp_repr.header_len() + PAYLOAD_LEN];
+ let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
+ udp_repr.emit(
+ &mut packet,
+ &src_addr.into(),
+ &dst_addr.into(),
+ PAYLOAD_LEN,
+ |buf| fill_slice(buf, 0x2a),
+ &ChecksumCapabilities::default(),
+ );
+ let ipv4_repr = Ipv4Repr {
+ src_addr,
+ dst_addr,
+ next_header: IpProtocol::Udp,
+ hop_limit: 64,
+ payload_len: udp_repr.header_len() + PAYLOAD_LEN,
+ };
+
+ // Emit to frame
+ let mut bytes = vec![0u8; ipv4_repr.buffer_len() + udp_repr.header_len() + PAYLOAD_LEN];
+ let frame = {
+ ipv4_repr.emit(
+ &mut Ipv4Packet::new_unchecked(&mut bytes),
+ &ChecksumCapabilities::default(),
+ );
+ udp_repr.emit(
+ &mut UdpPacket::new_unchecked(&mut bytes[ipv4_repr.buffer_len()..]),
+ &src_addr.into(),
+ &dst_addr.into(),
+ PAYLOAD_LEN,
+ |buf| fill_slice(buf, 0x2a),
+ &ChecksumCapabilities::default(),
+ );
+ Ipv4Packet::new_unchecked(&bytes[..])
+ };
+
+ assert_eq!(
+ iface.inner.process_ipv4(
+ &mut sockets,
+ PacketMeta::default(),
+ &frame,
+ &mut iface.fragments
+ ),
+ None
+ );
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(all(feature = "socket-raw", feature = "socket-udp", feature = "medium-ip"))]
+#[case(Medium::Ethernet)]
+#[cfg(all(
+ feature = "socket-raw",
+ feature = "socket-udp",
+ feature = "medium-ethernet"
+))]
+fn test_raw_socket_with_udp_socket(#[case] medium: Medium) {
+ use crate::wire::{IpEndpoint, IpVersion, UdpPacket, UdpRepr};
+
+ static UDP_PAYLOAD: [u8; 5] = [0x48, 0x65, 0x6c, 0x6c, 0x6f];
+
+ let (mut iface, mut sockets, _) = setup(medium);
+
+ let udp_rx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 15]);
+ let udp_tx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 15]);
+ let udp_socket = udp::Socket::new(udp_rx_buffer, udp_tx_buffer);
+ let udp_socket_handle = sockets.add(udp_socket);
+
+ // Bind the socket to port 68
+ let socket = sockets.get_mut::<udp::Socket>(udp_socket_handle);
+ assert_eq!(socket.bind(68), Ok(()));
+ assert!(!socket.can_recv());
+ assert!(socket.can_send());
+
+ let packets = 1;
+ let raw_rx_buffer =
+ raw::PacketBuffer::new(vec![raw::PacketMetadata::EMPTY; packets], vec![0; 48 * 1]);
+ let raw_tx_buffer = raw::PacketBuffer::new(
+ vec![raw::PacketMetadata::EMPTY; packets],
+ vec![0; 48 * packets],
+ );
+ let raw_socket = raw::Socket::new(
+ IpVersion::Ipv4,
+ IpProtocol::Udp,
+ raw_rx_buffer,
+ raw_tx_buffer,
+ );
+ sockets.add(raw_socket);
+
+ let src_addr = Ipv4Address([127, 0, 0, 2]);
+ let dst_addr = Ipv4Address([127, 0, 0, 1]);
+
+ let udp_repr = UdpRepr {
+ src_port: 67,
+ dst_port: 68,
+ };
+ let mut bytes = vec![0xff; udp_repr.header_len() + UDP_PAYLOAD.len()];
+ let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
+ udp_repr.emit(
+ &mut packet,
+ &src_addr.into(),
+ &dst_addr.into(),
+ UDP_PAYLOAD.len(),
+ |buf| buf.copy_from_slice(&UDP_PAYLOAD),
+ &ChecksumCapabilities::default(),
+ );
+ let ipv4_repr = Ipv4Repr {
+ src_addr,
+ dst_addr,
+ next_header: IpProtocol::Udp,
+ hop_limit: 64,
+ payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
+ };
+
+ // Emit to frame
+ let mut bytes = vec![0u8; ipv4_repr.buffer_len() + udp_repr.header_len() + UDP_PAYLOAD.len()];
+ let frame = {
+ ipv4_repr.emit(
+ &mut Ipv4Packet::new_unchecked(&mut bytes),
+ &ChecksumCapabilities::default(),
+ );
+ udp_repr.emit(
+ &mut UdpPacket::new_unchecked(&mut bytes[ipv4_repr.buffer_len()..]),
+ &src_addr.into(),
+ &dst_addr.into(),
+ UDP_PAYLOAD.len(),
+ |buf| buf.copy_from_slice(&UDP_PAYLOAD),
+ &ChecksumCapabilities::default(),
+ );
+ Ipv4Packet::new_unchecked(&bytes[..])
+ };
+
+ assert_eq!(
+ iface.inner.process_ipv4(
+ &mut sockets,
+ PacketMeta::default(),
+ &frame,
+ &mut iface.fragments
+ ),
+ None
+ );
+
+ // Make sure the UDP socket can still receive in presence of a Raw socket that handles UDP
+ let socket = sockets.get_mut::<udp::Socket>(udp_socket_handle);
+ assert!(socket.can_recv());
+ assert_eq!(
+ socket.recv(),
+ Ok((
+ &UDP_PAYLOAD[..],
+ IpEndpoint::new(src_addr.into(), 67).into()
+ ))
+ );
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(all(feature = "socket-udp", feature = "medium-ip"))]
+#[case(Medium::Ethernet)]
+#[cfg(all(feature = "socket-udp", feature = "medium-ethernet"))]
+fn test_icmp_reply_size(#[case] medium: Medium) {
+ use crate::wire::IPV4_MIN_MTU as MIN_MTU;
+ const MAX_PAYLOAD_LEN: usize = 528;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let src_addr = Ipv4Address([192, 168, 1, 1]);
+ let dst_addr = Ipv4Address([192, 168, 1, 2]);
+
+ // UDP packet that if not tructated will cause a icmp port unreachable reply
+ // to exceed the minimum mtu bytes in length.
+ let udp_repr = UdpRepr {
+ src_port: 67,
+ dst_port: 68,
+ };
+ let mut bytes = vec![0xff; udp_repr.header_len() + MAX_PAYLOAD_LEN];
+ let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
+ udp_repr.emit(
+ &mut packet,
+ &src_addr.into(),
+ &dst_addr.into(),
+ MAX_PAYLOAD_LEN,
+ |buf| fill_slice(buf, 0x2a),
+ &ChecksumCapabilities::default(),
+ );
+
+ let ip_repr = Ipv4Repr {
+ src_addr,
+ dst_addr,
+ next_header: IpProtocol::Udp,
+ hop_limit: 64,
+ payload_len: udp_repr.header_len() + MAX_PAYLOAD_LEN,
+ };
+ let payload = packet.into_inner();
+
+ let expected_icmp_repr = Icmpv4Repr::DstUnreachable {
+ reason: Icmpv4DstUnreachable::PortUnreachable,
+ header: ip_repr,
+ data: &payload[..MAX_PAYLOAD_LEN],
+ };
+
+ let expected_ip_repr = Ipv4Repr {
+ src_addr: dst_addr,
+ dst_addr: src_addr,
+ next_header: IpProtocol::Icmp,
+ hop_limit: 64,
+ payload_len: expected_icmp_repr.buffer_len(),
+ };
+
+ assert_eq!(
+ expected_ip_repr.buffer_len() + expected_icmp_repr.buffer_len(),
+ MIN_MTU
+ );
+
+ assert_eq!(
+ iface.inner.process_udp(
+ &mut sockets,
+ PacketMeta::default(),
+ ip_repr.into(),
+ udp_repr,
+ false,
+ &vec![0x2a; MAX_PAYLOAD_LEN],
+ payload,
+ ),
+ Some(Packet::new_ipv4(
+ expected_ip_repr,
+ IpPayload::Icmpv4(expected_icmp_repr)
+ ))
+ );
+}
diff --git a/src/iface/interface/tests/ipv6.rs b/src/iface/interface/tests/ipv6.rs
new file mode 100644
index 0000000..9c5f099
--- /dev/null
+++ b/src/iface/interface/tests/ipv6.rs
@@ -0,0 +1,988 @@
+use super::*;
+
+fn parse_ipv6(data: &[u8]) -> crate::wire::Result<Packet<'_>> {
+ let ipv6_header = Ipv6Packet::new_checked(data)?;
+ let ipv6 = Ipv6Repr::parse(&ipv6_header)?;
+
+ match ipv6.next_header {
+ IpProtocol::HopByHop => todo!(),
+ IpProtocol::Icmp => todo!(),
+ IpProtocol::Igmp => todo!(),
+ IpProtocol::Tcp => todo!(),
+ IpProtocol::Udp => todo!(),
+ IpProtocol::Ipv6Route => todo!(),
+ IpProtocol::Ipv6Frag => todo!(),
+ IpProtocol::IpSecEsp => todo!(),
+ IpProtocol::IpSecAh => todo!(),
+ IpProtocol::Icmpv6 => {
+ let icmp = Icmpv6Repr::parse(
+ &ipv6.src_addr.into(),
+ &ipv6.dst_addr.into(),
+ &Icmpv6Packet::new_checked(ipv6_header.payload())?,
+ &Default::default(),
+ )?;
+ Ok(Packet::new_ipv6(ipv6, IpPayload::Icmpv6(icmp)))
+ }
+ IpProtocol::Ipv6NoNxt => todo!(),
+ IpProtocol::Ipv6Opts => todo!(),
+ IpProtocol::Unknown(_) => todo!(),
+ }
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn multicast_source_address(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x40, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1,
+ ];
+
+ let response = None;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn hop_by_hop_skip_with_icmp(#[case] medium: Medium) {
+ // The following contains:
+ // - IPv6 header
+ // - Hop-by-hop, with options:
+ // - PADN (skipped)
+ // - Unknown option (skipped)
+ // - ICMP echo request
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x3a, 0x0, 0x1, 0x0, 0xf, 0x0, 0x1, 0x0, 0x80, 0x0, 0x2c, 0x88,
+ 0x0, 0x2a, 0x1, 0xa4, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ];
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 19,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoReply {
+ ident: 42,
+ seq_no: 420,
+ data: b"Lorem Ipsum",
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn hop_by_hop_discard_with_icmp(#[case] medium: Medium) {
+ // The following contains:
+ // - IPv6 header
+ // - Hop-by-hop, with options:
+ // - PADN (skipped)
+ // - Unknown option (discard)
+ // - ICMP echo request
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x3a, 0x0, 0x1, 0x0, 0x40, 0x0, 0x1, 0x0, 0x80, 0x0, 0x2c, 0x88,
+ 0x0, 0x2a, 0x1, 0xa4, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ];
+
+ let response = None;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+fn hop_by_hop_discard_param_problem(#[case] medium: Medium) {
+ // The following contains:
+ // - IPv6 header
+ // - Hop-by-hop, with options:
+ // - PADN (skipped)
+ // - Unknown option (discard + ParamProblem)
+ // - ICMP echo request
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x3a, 0x0, 0xC0, 0x0, 0x40, 0x0, 0x1, 0x0, 0x80, 0x0, 0x2c, 0x88,
+ 0x0, 0x2a, 0x1, 0xa4, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ];
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 1),
+ dst_addr: Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 2),
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 75,
+ hop_limit: 64,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::ParamProblem {
+ reason: Icmpv6ParamProblem::UnrecognizedOption,
+ pointer: 40,
+ header: Ipv6Repr {
+ src_addr: Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 2),
+ dst_addr: Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 1),
+ next_header: IpProtocol::HopByHop,
+ payload_len: 27,
+ hop_limit: 64,
+ },
+ data: &[
+ 0x3a, 0x0, 0xC0, 0x0, 0x40, 0x0, 0x1, 0x0, 0x80, 0x0, 0x2c, 0x88, 0x0, 0x2a, 0x1,
+ 0xa4, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ],
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+fn hop_by_hop_discard_with_multicast(#[case] medium: Medium) {
+ // The following contains:
+ // - IPv6 header
+ // - Hop-by-hop, with options:
+ // - PADN (skipped)
+ // - Unknown option (discard (0b11) + ParamProblem)
+ // - ICMP echo request
+ //
+ // In this case, even if the destination address is a multicast address, an ICMPv6 ParamProblem
+ // should be transmitted.
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x02, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x3a, 0x0, 0x80, 0x0, 0x40, 0x0, 0x1, 0x0, 0x80, 0x0, 0x2c, 0x88,
+ 0x0, 0x2a, 0x1, 0xa4, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ];
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 1),
+ dst_addr: Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 2),
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 75,
+ hop_limit: 64,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::ParamProblem {
+ reason: Icmpv6ParamProblem::UnrecognizedOption,
+ pointer: 40,
+ header: Ipv6Repr {
+ src_addr: Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 2),
+ dst_addr: Ipv6Address::new(0xff02, 0, 0, 0, 0, 0, 0, 1),
+ next_header: IpProtocol::HopByHop,
+ payload_len: 27,
+ hop_limit: 64,
+ },
+ data: &[
+ 0x3a, 0x0, 0x80, 0x0, 0x40, 0x0, 0x1, 0x0, 0x80, 0x0, 0x2c, 0x88, 0x0, 0x2a, 0x1,
+ 0xa4, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ],
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn imcp_empty_echo_request(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x8, 0x3a, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x80, 0x0, 0x84, 0x3c, 0x0, 0x0, 0x0, 0x0,
+ ];
+
+ assert_eq!(
+ parse_ipv6(&data),
+ Ok(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 8,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoRequest {
+ ident: 0,
+ seq_no: 0,
+ data: b"",
+ })
+ ))
+ );
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 8,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoReply {
+ ident: 0,
+ seq_no: 0,
+ data: b"",
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn icmp_echo_request(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x13, 0x3a, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x80, 0x0, 0x2c, 0x88, 0x0, 0x2a, 0x1, 0xa4, 0x4c, 0x6f, 0x72,
+ 0x65, 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ];
+
+ assert_eq!(
+ parse_ipv6(&data),
+ Ok(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 19,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoRequest {
+ ident: 42,
+ seq_no: 420,
+ data: b"Lorem Ipsum",
+ })
+ ))
+ );
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 19,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoReply {
+ ident: 42,
+ seq_no: 420,
+ data: b"Lorem Ipsum",
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn icmp_echo_reply_as_input(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x13, 0x3a, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x81, 0x0, 0x2d, 0x56, 0x0, 0x0, 0x0, 0x0, 0x4c, 0x6f, 0x72, 0x65,
+ 0x6d, 0x20, 0x49, 0x70, 0x73, 0x75, 0x6d,
+ ];
+
+ assert_eq!(
+ parse_ipv6(&data),
+ Ok(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 19,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoReply {
+ ident: 0,
+ seq_no: 0,
+ data: b"Lorem Ipsum",
+ })
+ ))
+ );
+
+ let response = None;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn unknown_proto_with_multicast_dst_address(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xff, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1,
+ ];
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 48,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::ParamProblem {
+ reason: Icmpv6ParamProblem::UnrecognizedNxtHdr,
+ pointer: 40,
+ header: Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xff02, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 64,
+ next_header: IpProtocol::Unknown(0x0c),
+ payload_len: 0,
+ },
+ data: &[],
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ip(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn unknown_proto(#[case] medium: Medium) {
+ // Since the destination address is multicast, we should answer with an ICMPv6 message.
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x40, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1,
+ ];
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 48,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::ParamProblem {
+ reason: Icmpv6ParamProblem::UnrecognizedNxtHdr,
+ pointer: 40,
+ header: Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 64,
+ next_header: IpProtocol::Unknown(0x0c),
+ payload_len: 0,
+ },
+ data: &[],
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+}
+
+#[rstest]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn ndsic_neighbor_advertisement_ethernet(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x20, 0x3a, 0xff, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x88, 0x0, 0x3b, 0x9f, 0x40, 0x0, 0x0, 0x0, 0xfe, 0x80, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x1,
+ ];
+
+ assert_eq!(
+ parse_ipv6(&data),
+ Ok(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 255,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 32,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert {
+ flags: NdiscNeighborFlags::SOLICITED,
+ target_addr: Ipv6Address::from_parts(&[0xfe80, 0, 0, 0, 0, 0, 0, 0x0002]),
+ lladdr: Some(RawHardwareAddress::from_bytes(&[0, 0, 0, 0, 0, 1])),
+ }))
+ ))
+ );
+
+ let response = None;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+
+ assert_eq!(
+ iface.inner.neighbor_cache.lookup(
+ &IpAddress::Ipv6(Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002])),
+ iface.inner.now,
+ ),
+ NeighborAnswer::Found(HardwareAddress::Ethernet(EthernetAddress::from_bytes(&[
+ 0, 0, 0, 0, 0, 1
+ ]))),
+ );
+}
+
+#[rstest]
+#[case::ethernet(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn ndsic_neighbor_advertisement_ethernet_multicast_addr(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x20, 0x3a, 0xff, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x88, 0x0, 0x3b, 0xa0, 0x40, 0x0, 0x0, 0x0, 0xfe, 0x80, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x1, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff,
+ ];
+
+ assert_eq!(
+ parse_ipv6(&data),
+ Ok(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 255,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 32,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert {
+ flags: NdiscNeighborFlags::SOLICITED,
+ target_addr: Ipv6Address::from_parts(&[0xfe80, 0, 0, 0, 0, 0, 0, 0x0002]),
+ lladdr: Some(RawHardwareAddress::from_bytes(&[
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+ ])),
+ }))
+ ))
+ );
+
+ let response = None;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+
+ assert_eq!(
+ iface.inner.neighbor_cache.lookup(
+ &IpAddress::Ipv6(Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002])),
+ iface.inner.now,
+ ),
+ NeighborAnswer::NotFound,
+ );
+}
+
+#[rstest]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn ndsic_neighbor_advertisement_ieee802154(#[case] medium: Medium) {
+ let data = [
+ 0x60, 0x0, 0x0, 0x0, 0x0, 0x28, 0x3a, 0xff, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd, 0xbe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x88, 0x0, 0x3b, 0x96, 0x40, 0x0, 0x0, 0x0, 0xfe, 0x80, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ ];
+
+ assert_eq!(
+ parse_ipv6(&data),
+ Ok(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002]),
+ dst_addr: Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0001]),
+ hop_limit: 255,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 40,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert {
+ flags: NdiscNeighborFlags::SOLICITED,
+ target_addr: Ipv6Address::from_parts(&[0xfe80, 0, 0, 0, 0, 0, 0, 0x0002]),
+ lladdr: Some(RawHardwareAddress::from_bytes(&[0, 0, 0, 0, 0, 0, 0, 1])),
+ }))
+ ))
+ );
+
+ let response = None;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ipv6(
+ &mut sockets,
+ PacketMeta::default(),
+ &Ipv6Packet::new_checked(&data[..]).unwrap()
+ ),
+ response
+ );
+
+ assert_eq!(
+ iface.inner.neighbor_cache.lookup(
+ &IpAddress::Ipv6(Ipv6Address::from_parts(&[0xfdbe, 0, 0, 0, 0, 0, 0, 0x0002])),
+ iface.inner.now,
+ ),
+ NeighborAnswer::Found(HardwareAddress::Ieee802154(Ieee802154Address::from_bytes(
+ &[0, 0, 0, 0, 0, 0, 0, 1]
+ ))),
+ );
+}
+
+#[rstest]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+fn test_handle_valid_ndisc_request(#[case] medium: Medium) {
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let mut eth_bytes = vec![0u8; 86];
+
+ let local_ip_addr = Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 1);
+ let remote_ip_addr = Ipv6Address::new(0xfdbe, 0, 0, 0, 0, 0, 0, 2);
+ let local_hw_addr = EthernetAddress([0x02, 0x02, 0x02, 0x02, 0x02, 0x02]);
+ let remote_hw_addr = EthernetAddress([0x52, 0x54, 0x00, 0x00, 0x00, 0x00]);
+
+ let solicit = Icmpv6Repr::Ndisc(NdiscRepr::NeighborSolicit {
+ target_addr: local_ip_addr,
+ lladdr: Some(remote_hw_addr.into()),
+ });
+ let ip_repr = IpRepr::Ipv6(Ipv6Repr {
+ src_addr: remote_ip_addr,
+ dst_addr: local_ip_addr.solicited_node(),
+ next_header: IpProtocol::Icmpv6,
+ hop_limit: 0xff,
+ payload_len: solicit.buffer_len(),
+ });
+
+ let mut frame = EthernetFrame::new_unchecked(&mut eth_bytes);
+ frame.set_dst_addr(EthernetAddress([0x33, 0x33, 0x00, 0x00, 0x00, 0x00]));
+ frame.set_src_addr(remote_hw_addr);
+ frame.set_ethertype(EthernetProtocol::Ipv6);
+ ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
+ solicit.emit(
+ &remote_ip_addr.into(),
+ &local_ip_addr.solicited_node().into(),
+ &mut Icmpv6Packet::new_unchecked(&mut frame.payload_mut()[ip_repr.header_len()..]),
+ &ChecksumCapabilities::default(),
+ );
+
+ let icmpv6_expected = Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert {
+ flags: NdiscNeighborFlags::SOLICITED,
+ target_addr: local_ip_addr,
+ lladdr: Some(local_hw_addr.into()),
+ });
+
+ let ipv6_expected = Ipv6Repr {
+ src_addr: local_ip_addr,
+ dst_addr: remote_ip_addr,
+ next_header: IpProtocol::Icmpv6,
+ hop_limit: 0xff,
+ payload_len: icmpv6_expected.buffer_len(),
+ };
+
+ // Ensure an Neighbor Solicitation triggers a Neighbor Advertisement
+ assert_eq!(
+ iface.inner.process_ethernet(
+ &mut sockets,
+ PacketMeta::default(),
+ frame.into_inner(),
+ &mut iface.fragments
+ ),
+ Some(EthernetPacket::Ip(Packet::new_ipv6(
+ ipv6_expected,
+ IpPayload::Icmpv6(icmpv6_expected)
+ )))
+ );
+
+ // Ensure the address of the requester was entered in the cache
+ assert_eq!(
+ iface.inner.lookup_hardware_addr(
+ MockTxToken,
+ &IpAddress::Ipv6(local_ip_addr),
+ &IpAddress::Ipv6(remote_ip_addr),
+ &mut iface.fragmenter,
+ ),
+ Ok((HardwareAddress::Ethernet(remote_hw_addr), MockTxToken))
+ );
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(feature = "medium-ip")]
+#[case(Medium::Ethernet)]
+#[cfg(feature = "medium-ethernet")]
+#[case(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn test_solicited_node_addrs(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let mut new_addrs = heapless::Vec::<IpCidr, IFACE_MAX_ADDR_COUNT>::new();
+ new_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 1, 2, 0, 2), 64))
+ .unwrap();
+ new_addrs
+ .push(IpCidr::new(
+ IpAddress::v6(0xfe80, 0, 0, 0, 3, 4, 0, 0xffff),
+ 64,
+ ))
+ .unwrap();
+ iface.update_ip_addrs(|addrs| {
+ new_addrs.extend(addrs.to_vec());
+ *addrs = new_addrs;
+ });
+ assert!(iface
+ .inner
+ .has_solicited_node(Ipv6Address::new(0xff02, 0, 0, 0, 0, 1, 0xff00, 0x0002)));
+ assert!(iface
+ .inner
+ .has_solicited_node(Ipv6Address::new(0xff02, 0, 0, 0, 0, 1, 0xff00, 0xffff)));
+ assert!(!iface
+ .inner
+ .has_solicited_node(Ipv6Address::new(0xff02, 0, 0, 0, 0, 1, 0xff00, 0x0003)));
+}
+
+#[rstest]
+#[case(Medium::Ip)]
+#[cfg(all(feature = "socket-udp", feature = "medium-ip"))]
+#[case(Medium::Ethernet)]
+#[cfg(all(feature = "socket-udp", feature = "medium-ethernet"))]
+#[case(Medium::Ieee802154)]
+#[cfg(all(feature = "socket-udp", feature = "medium-ieee802154"))]
+fn test_icmp_reply_size(#[case] medium: Medium) {
+ use crate::wire::Icmpv6DstUnreachable;
+ use crate::wire::IPV6_MIN_MTU as MIN_MTU;
+ const MAX_PAYLOAD_LEN: usize = 1192;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let src_addr = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1);
+ let dst_addr = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 2);
+
+ // UDP packet that if not tructated will cause a icmp port unreachable reply
+ // to exceed the minimum mtu bytes in length.
+ let udp_repr = UdpRepr {
+ src_port: 67,
+ dst_port: 68,
+ };
+ let mut bytes = vec![0xff; udp_repr.header_len() + MAX_PAYLOAD_LEN];
+ let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
+ udp_repr.emit(
+ &mut packet,
+ &src_addr.into(),
+ &dst_addr.into(),
+ MAX_PAYLOAD_LEN,
+ |buf| fill_slice(buf, 0x2a),
+ &ChecksumCapabilities::default(),
+ );
+
+ let ip_repr = Ipv6Repr {
+ src_addr,
+ dst_addr,
+ next_header: IpProtocol::Udp,
+ hop_limit: 64,
+ payload_len: udp_repr.header_len() + MAX_PAYLOAD_LEN,
+ };
+ let payload = packet.into_inner();
+
+ let expected_icmp_repr = Icmpv6Repr::DstUnreachable {
+ reason: Icmpv6DstUnreachable::PortUnreachable,
+ header: ip_repr,
+ data: &payload[..MAX_PAYLOAD_LEN],
+ };
+
+ let expected_ip_repr = Ipv6Repr {
+ src_addr: dst_addr,
+ dst_addr: src_addr,
+ next_header: IpProtocol::Icmpv6,
+ hop_limit: 64,
+ payload_len: expected_icmp_repr.buffer_len(),
+ };
+
+ assert_eq!(
+ expected_ip_repr.buffer_len() + expected_icmp_repr.buffer_len(),
+ MIN_MTU
+ );
+
+ assert_eq!(
+ iface.inner.process_udp(
+ &mut sockets,
+ PacketMeta::default(),
+ ip_repr.into(),
+ udp_repr,
+ false,
+ &vec![0x2a; MAX_PAYLOAD_LEN],
+ payload,
+ ),
+ Some(Packet::new_ipv6(
+ expected_ip_repr,
+ IpPayload::Icmpv6(expected_icmp_repr)
+ ))
+ );
+}
+
+#[cfg(feature = "medium-ip")]
+#[test]
+fn get_source_address() {
+ let (mut iface, _, _) = setup(Medium::Ip);
+
+ const OWN_LINK_LOCAL_ADDR: Ipv6Address = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1);
+ const OWN_UNIQUE_LOCAL_ADDR1: Ipv6Address = Ipv6Address::new(0xfd00, 0, 0, 201, 1, 1, 1, 2);
+ const OWN_UNIQUE_LOCAL_ADDR2: Ipv6Address = Ipv6Address::new(0xfd01, 0, 0, 201, 1, 1, 1, 2);
+ const OWN_GLOBAL_UNICAST_ADDR1: Ipv6Address =
+ Ipv6Address::new(0x2001, 0x0db8, 0x0003, 0, 0, 0, 0, 1);
+
+ // List of addresses of the interface:
+ // fe80::1/64
+ // fd00::201:1:1:1:2/64
+ // fd01::201:1:1:1:2/64
+ // 2001:db8:3::1/64
+ // ::1/128
+ // ::/128
+ iface.update_ip_addrs(|addrs| {
+ addrs.clear();
+
+ addrs
+ .push(IpCidr::Ipv6(Ipv6Cidr::new(OWN_LINK_LOCAL_ADDR, 64)))
+ .unwrap();
+ addrs
+ .push(IpCidr::Ipv6(Ipv6Cidr::new(OWN_UNIQUE_LOCAL_ADDR1, 64)))
+ .unwrap();
+ addrs
+ .push(IpCidr::Ipv6(Ipv6Cidr::new(OWN_UNIQUE_LOCAL_ADDR2, 64)))
+ .unwrap();
+ addrs
+ .push(IpCidr::Ipv6(Ipv6Cidr::new(OWN_GLOBAL_UNICAST_ADDR1, 64)))
+ .unwrap();
+
+ // These should never be used:
+ addrs
+ .push(IpCidr::Ipv6(Ipv6Cidr::new(Ipv6Address::LOOPBACK, 128)))
+ .unwrap();
+ addrs
+ .push(IpCidr::Ipv6(Ipv6Cidr::new(Ipv6Address::UNSPECIFIED, 128)))
+ .unwrap();
+ });
+
+ // List of addresses we test:
+ // fe80::42 -> fe80::1
+ // fd00::201:1:1:1:1 -> fd00::201:1:1:1:2
+ // fd01::201:1:1:1:1 -> fd01::201:1:1:1:2
+ // fd02::201:1:1:1:1 -> fd00::201:1:1:1:2 (because first added in the list)
+ // ff02::1 -> fe80::1 (same scope)
+ // 2001:db8:3::2 -> 2001:db8:3::1
+ // 2001:db9:3::2 -> 2001:db8:3::1
+ const LINK_LOCAL_ADDR: Ipv6Address = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 42);
+ const UNIQUE_LOCAL_ADDR1: Ipv6Address = Ipv6Address::new(0xfd00, 0, 0, 201, 1, 1, 1, 1);
+ const UNIQUE_LOCAL_ADDR2: Ipv6Address = Ipv6Address::new(0xfd01, 0, 0, 201, 1, 1, 1, 1);
+ const UNIQUE_LOCAL_ADDR3: Ipv6Address = Ipv6Address::new(0xfd02, 0, 0, 201, 1, 1, 1, 1);
+ const GLOBAL_UNICAST_ADDR1: Ipv6Address =
+ Ipv6Address::new(0x2001, 0x0db8, 0x0003, 0, 0, 0, 0, 2);
+ const GLOBAL_UNICAST_ADDR2: Ipv6Address =
+ Ipv6Address::new(0x2001, 0x0db9, 0x0003, 0, 0, 0, 0, 2);
+
+ assert_eq!(
+ iface.inner.get_source_address_ipv6(&LINK_LOCAL_ADDR),
+ Some(OWN_LINK_LOCAL_ADDR)
+ );
+ assert_eq!(
+ iface.inner.get_source_address_ipv6(&UNIQUE_LOCAL_ADDR1),
+ Some(OWN_UNIQUE_LOCAL_ADDR1)
+ );
+ assert_eq!(
+ iface.inner.get_source_address_ipv6(&UNIQUE_LOCAL_ADDR2),
+ Some(OWN_UNIQUE_LOCAL_ADDR2)
+ );
+ assert_eq!(
+ iface.inner.get_source_address_ipv6(&UNIQUE_LOCAL_ADDR3),
+ Some(OWN_UNIQUE_LOCAL_ADDR1)
+ );
+ assert_eq!(
+ iface
+ .inner
+ .get_source_address_ipv6(&Ipv6Address::LINK_LOCAL_ALL_NODES),
+ Some(OWN_LINK_LOCAL_ADDR)
+ );
+ assert_eq!(
+ iface.inner.get_source_address_ipv6(&GLOBAL_UNICAST_ADDR1),
+ Some(OWN_GLOBAL_UNICAST_ADDR1)
+ );
+ assert_eq!(
+ iface.inner.get_source_address_ipv6(&GLOBAL_UNICAST_ADDR2),
+ Some(OWN_GLOBAL_UNICAST_ADDR1)
+ );
+
+ assert_eq!(
+ iface.get_source_address_ipv6(&LINK_LOCAL_ADDR),
+ Some(OWN_LINK_LOCAL_ADDR)
+ );
+ assert_eq!(
+ iface.get_source_address_ipv6(&UNIQUE_LOCAL_ADDR1),
+ Some(OWN_UNIQUE_LOCAL_ADDR1)
+ );
+ assert_eq!(
+ iface.get_source_address_ipv6(&UNIQUE_LOCAL_ADDR2),
+ Some(OWN_UNIQUE_LOCAL_ADDR2)
+ );
+ assert_eq!(
+ iface.get_source_address_ipv6(&UNIQUE_LOCAL_ADDR3),
+ Some(OWN_UNIQUE_LOCAL_ADDR1)
+ );
+ assert_eq!(
+ iface.get_source_address_ipv6(&Ipv6Address::LINK_LOCAL_ALL_NODES),
+ Some(OWN_LINK_LOCAL_ADDR)
+ );
+ assert_eq!(
+ iface.get_source_address_ipv6(&GLOBAL_UNICAST_ADDR1),
+ Some(OWN_GLOBAL_UNICAST_ADDR1)
+ );
+ assert_eq!(
+ iface.get_source_address_ipv6(&GLOBAL_UNICAST_ADDR2),
+ Some(OWN_GLOBAL_UNICAST_ADDR1)
+ );
+}
diff --git a/src/iface/interface/tests/mod.rs b/src/iface/interface/tests/mod.rs
new file mode 100644
index 0000000..b4b4416
--- /dev/null
+++ b/src/iface/interface/tests/mod.rs
@@ -0,0 +1,235 @@
+#[cfg(feature = "proto-ipv4")]
+mod ipv4;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6;
+#[cfg(feature = "proto-sixlowpan")]
+mod sixlowpan;
+
+#[cfg(feature = "proto-igmp")]
+use std::vec::Vec;
+
+use crate::tests::setup;
+
+use rstest::*;
+
+use super::*;
+
+use crate::iface::Interface;
+use crate::phy::ChecksumCapabilities;
+#[cfg(feature = "alloc")]
+use crate::phy::Loopback;
+use crate::time::Instant;
+
+#[allow(unused)]
+fn fill_slice(s: &mut [u8], val: u8) {
+ for x in s.iter_mut() {
+ *x = val
+ }
+}
+
+#[cfg(feature = "proto-igmp")]
+fn recv_all(device: &mut crate::tests::TestingDevice, timestamp: Instant) -> Vec<Vec<u8>> {
+ let mut pkts = Vec::new();
+ while let Some((rx, _tx)) = device.receive(timestamp) {
+ rx.consume(|pkt| {
+ pkts.push(pkt.to_vec());
+ });
+ }
+ pkts
+}
+
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct MockTxToken;
+
+impl TxToken for MockTxToken {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ let mut junk = [0; 1536];
+ f(&mut junk[..len])
+ }
+}
+
+#[test]
+#[should_panic(expected = "The hardware address does not match the medium of the interface.")]
+#[cfg(all(feature = "medium-ip", feature = "medium-ethernet", feature = "alloc"))]
+fn test_new_panic() {
+ let mut device = Loopback::new(Medium::Ethernet);
+ let config = Config::new(HardwareAddress::Ip);
+ Interface::new(config, &mut device, Instant::ZERO);
+}
+
+#[rstest]
+#[cfg(feature = "default")]
+fn test_handle_udp_broadcast(
+ #[values(Medium::Ip, Medium::Ethernet, Medium::Ieee802154)] medium: Medium,
+) {
+ use crate::wire::IpEndpoint;
+
+ static UDP_PAYLOAD: [u8; 5] = [0x48, 0x65, 0x6c, 0x6c, 0x6f];
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ let rx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 15]);
+ let tx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 15]);
+
+ let udp_socket = udp::Socket::new(rx_buffer, tx_buffer);
+
+ let mut udp_bytes = vec![0u8; 13];
+ let mut packet = UdpPacket::new_unchecked(&mut udp_bytes);
+
+ let socket_handle = sockets.add(udp_socket);
+
+ #[cfg(feature = "proto-ipv6")]
+ let src_ip = Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1);
+ #[cfg(all(not(feature = "proto-ipv6"), feature = "proto-ipv4"))]
+ let src_ip = Ipv4Address::new(0x7f, 0x00, 0x00, 0x02);
+
+ let udp_repr = UdpRepr {
+ src_port: 67,
+ dst_port: 68,
+ };
+
+ #[cfg(feature = "proto-ipv6")]
+ let ip_repr = IpRepr::Ipv6(Ipv6Repr {
+ src_addr: src_ip,
+ dst_addr: Ipv6Address::LINK_LOCAL_ALL_NODES,
+ next_header: IpProtocol::Udp,
+ payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
+ hop_limit: 0x40,
+ });
+ #[cfg(all(not(feature = "proto-ipv6"), feature = "proto-ipv4"))]
+ let ip_repr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: src_ip,
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Udp,
+ payload_len: udp_repr.header_len() + UDP_PAYLOAD.len(),
+ hop_limit: 0x40,
+ });
+
+ // Bind the socket to port 68
+ let socket = sockets.get_mut::<udp::Socket>(socket_handle);
+ assert_eq!(socket.bind(68), Ok(()));
+ assert!(!socket.can_recv());
+ assert!(socket.can_send());
+
+ udp_repr.emit(
+ &mut packet,
+ &ip_repr.src_addr(),
+ &ip_repr.dst_addr(),
+ UDP_PAYLOAD.len(),
+ |buf| buf.copy_from_slice(&UDP_PAYLOAD),
+ &ChecksumCapabilities::default(),
+ );
+
+ // Packet should be handled by bound UDP socket
+ assert_eq!(
+ iface.inner.process_udp(
+ &mut sockets,
+ PacketMeta::default(),
+ ip_repr,
+ udp_repr,
+ false,
+ &UDP_PAYLOAD,
+ packet.into_inner(),
+ ),
+ None
+ );
+
+ // Make sure the payload to the UDP packet processed by process_udp is
+ // appended to the bound sockets rx_buffer
+ let socket = sockets.get_mut::<udp::Socket>(socket_handle);
+ assert!(socket.can_recv());
+ assert_eq!(
+ socket.recv(),
+ Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_ip.into(), 67).into()))
+ );
+}
+
+#[test]
+#[cfg(all(feature = "medium-ip", feature = "socket-tcp", feature = "proto-ipv6"))]
+pub fn tcp_not_accepted() {
+ let (mut iface, mut sockets, _) = setup(Medium::Ip);
+ let tcp = TcpRepr {
+ src_port: 4242,
+ dst_port: 4243,
+ control: TcpControl::Syn,
+ seq_number: TcpSeqNumber(-10001),
+ ack_number: None,
+ window_len: 256,
+ window_scale: None,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &[],
+ };
+
+ let mut tcp_bytes = vec![0u8; tcp.buffer_len()];
+
+ tcp.emit(
+ &mut TcpPacket::new_unchecked(&mut tcp_bytes),
+ &Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 2).into(),
+ &Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1).into(),
+ &ChecksumCapabilities::default(),
+ );
+
+ assert_eq!(
+ iface.inner.process_tcp(
+ &mut sockets,
+ IpRepr::Ipv6(Ipv6Repr {
+ src_addr: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 2),
+ dst_addr: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ next_header: IpProtocol::Tcp,
+ payload_len: tcp.buffer_len(),
+ hop_limit: 64,
+ }),
+ &tcp_bytes,
+ ),
+ Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ dst_addr: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 2),
+ next_header: IpProtocol::Tcp,
+ payload_len: tcp.buffer_len(),
+ hop_limit: 64,
+ },
+ IpPayload::Tcp(TcpRepr {
+ src_port: 4243,
+ dst_port: 4242,
+ control: TcpControl::Rst,
+ seq_number: TcpSeqNumber(0),
+ ack_number: Some(TcpSeqNumber(-10000)),
+ window_len: 0,
+ window_scale: None,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &[],
+ })
+ ))
+ );
+ // Unspecified destination address.
+ tcp.emit(
+ &mut TcpPacket::new_unchecked(&mut tcp_bytes),
+ &Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 2).into(),
+ &Ipv6Address::UNSPECIFIED.into(),
+ &ChecksumCapabilities::default(),
+ );
+
+ assert_eq!(
+ iface.inner.process_tcp(
+ &mut sockets,
+ IpRepr::Ipv6(Ipv6Repr {
+ src_addr: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 2),
+ dst_addr: Ipv6Address::UNSPECIFIED,
+ next_header: IpProtocol::Tcp,
+ payload_len: tcp.buffer_len(),
+ hop_limit: 64,
+ }),
+ &tcp_bytes,
+ ),
+ None,
+ );
+}
diff --git a/src/iface/interface/tests/sixlowpan.rs b/src/iface/interface/tests/sixlowpan.rs
new file mode 100644
index 0000000..676835e
--- /dev/null
+++ b/src/iface/interface/tests/sixlowpan.rs
@@ -0,0 +1,434 @@
+use super::*;
+
+#[rstest]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn ieee802154_wrong_pan_id(#[case] medium: Medium) {
+ let data = [
+ 0x41, 0xcc, 0x3b, 0xff, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0x62, 0x3a,
+ 0xa6, 0x34, 0x57, 0x29, 0x1c, 0x26,
+ ];
+
+ let response = None;
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+
+ assert_eq!(
+ iface.inner.process_ieee802154(
+ &mut sockets,
+ PacketMeta::default(),
+ &data[..],
+ &mut iface.fragments
+ ),
+ response,
+ );
+}
+
+#[rstest]
+#[case::ieee802154(Medium::Ieee802154)]
+#[cfg(feature = "medium-ieee802154")]
+fn icmp_echo_request(#[case] medium: Medium) {
+ let data = [
+ 0x41, 0xcc, 0x3b, 0xef, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0x62, 0x3a,
+ 0xa6, 0x34, 0x57, 0x29, 0x1c, 0x26, 0x6a, 0x33, 0x0a, 0x62, 0x17, 0x3a, 0x80, 0x00, 0xb0,
+ 0xe3, 0x00, 0x04, 0x00, 0x01, 0x82, 0xf2, 0x82, 0x64, 0x00, 0x00, 0x00, 0x00, 0x66, 0x23,
+ 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+ 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+ 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+ 0x37,
+ ];
+
+ let response = Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::from_parts(&[0xfe80, 0, 0, 0, 0x180b, 0x4242, 0x4242, 0x4242]),
+ dst_addr: Ipv6Address::from_parts(&[0xfe80, 0, 0, 0, 0x241c, 0x2957, 0x34a6, 0x3a62]),
+ hop_limit: 64,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 64,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoReply {
+ ident: 4,
+ seq_no: 1,
+ data: &[
+ 0x82, 0xf2, 0x82, 0x64, 0x00, 0x00, 0x00, 0x00, 0x66, 0x23, 0x0c, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
+ 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
+ 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ ],
+ }),
+ ));
+
+ let (mut iface, mut sockets, _device) = setup(medium);
+ iface.update_ip_addrs(|ips| {
+ ips.push(IpCidr::Ipv6(Ipv6Cidr::new(
+ Ipv6Address::from_parts(&[0xfe80, 0, 0, 0, 0x180b, 0x4242, 0x4242, 0x4242]),
+ 10,
+ )))
+ .unwrap();
+ });
+
+ assert_eq!(
+ iface.inner.process_ieee802154(
+ &mut sockets,
+ PacketMeta::default(),
+ &data[..],
+ &mut iface.fragments
+ ),
+ response,
+ );
+}
+
+#[test]
+#[cfg(feature = "proto-sixlowpan-fragmentation")]
+fn test_echo_request_sixlowpan_128_bytes() {
+ use crate::phy::Checksum;
+
+ let (mut iface, mut sockets, mut device) = setup(Medium::Ieee802154);
+ iface.update_ip_addrs(|ips| {
+ ips.push(IpCidr::Ipv6(Ipv6Cidr::new(
+ Ipv6Address::new(0xfe80, 0x0, 0x0, 0x0, 0x92fc, 0x48c2, 0xa441, 0xfc76),
+ 10,
+ )))
+ .unwrap();
+ });
+ // TODO: modify the example, such that we can also test if the checksum is correctly
+ // computed.
+ iface.inner.caps.checksum.icmpv6 = Checksum::None;
+
+ assert_eq!(iface.inner.caps.medium, Medium::Ieee802154);
+ let now = iface.inner.now();
+
+ iface.inner.neighbor_cache.fill(
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0x2, 0, 0, 0, 0, 0, 0, 0]).into(),
+ HardwareAddress::Ieee802154(Ieee802154Address::default()),
+ now,
+ );
+
+ let mut ieee802154_repr = Ieee802154Repr {
+ frame_type: Ieee802154FrameType::Data,
+ security_enabled: false,
+ frame_pending: false,
+ ack_request: false,
+ sequence_number: Some(5),
+ pan_id_compression: true,
+ frame_version: Ieee802154FrameVersion::Ieee802154_2003,
+ dst_pan_id: Some(Ieee802154Pan(0xbeef)),
+ dst_addr: Some(Ieee802154Address::Extended([
+ 0x90, 0xfc, 0x48, 0xc2, 0xa4, 0x41, 0xfc, 0x76,
+ ])),
+ src_pan_id: Some(Ieee802154Pan(0xbeef)),
+ src_addr: Some(Ieee802154Address::Extended([
+ 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a,
+ ])),
+ };
+
+ // NOTE: this data is retrieved from tests with Contiki-NG
+
+ let request_first_part_packet = SixlowpanFragPacket::new_checked(&[
+ 0xc0, 0xb0, 0x00, 0x8e, 0x6a, 0x33, 0x05, 0x25, 0x2c, 0x3a, 0x80, 0x00, 0xe0, 0x71, 0x00,
+ 0x27, 0x00, 0x02, 0xa2, 0xc2, 0x2d, 0x63, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x5e, 0x0c, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
+ 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
+ 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+ 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+ ])
+ .unwrap();
+
+ let request_first_part_iphc_packet =
+ SixlowpanIphcPacket::new_checked(request_first_part_packet.payload()).unwrap();
+
+ let request_first_part_iphc_repr = SixlowpanIphcRepr::parse(
+ &request_first_part_iphc_packet,
+ ieee802154_repr.src_addr,
+ ieee802154_repr.dst_addr,
+ &iface.inner.sixlowpan_address_context,
+ )
+ .unwrap();
+
+ assert_eq!(
+ request_first_part_iphc_repr.src_addr,
+ Ipv6Address([
+ 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x42, 0x42, 0x42, 0x42, 0x42, 0xb,
+ 0x1a,
+ ]),
+ );
+ assert_eq!(
+ request_first_part_iphc_repr.dst_addr,
+ Ipv6Address([
+ 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x92, 0xfc, 0x48, 0xc2, 0xa4, 0x41, 0xfc,
+ 0x76,
+ ]),
+ );
+
+ let request_second_part = [
+ 0xe0, 0xb0, 0x00, 0x8e, 0x10, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+ 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+ 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+ 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+ ];
+
+ assert_eq!(
+ iface.inner.process_sixlowpan(
+ &mut sockets,
+ PacketMeta::default(),
+ &ieee802154_repr,
+ &request_first_part_packet.into_inner()[..],
+ &mut iface.fragments
+ ),
+ None
+ );
+
+ ieee802154_repr.sequence_number = Some(6);
+
+ // data that was generated when using `ping -s 128`
+ let data = &[
+ 0xa2, 0xc2, 0x2d, 0x63, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x5e, 0x0c, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+ 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c,
+ 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
+ 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a,
+ 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+ 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+ 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+ 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+ ];
+
+ let result = iface.inner.process_sixlowpan(
+ &mut sockets,
+ PacketMeta::default(),
+ &ieee802154_repr,
+ &request_second_part,
+ &mut iface.fragments,
+ );
+
+ assert_eq!(
+ result,
+ Some(Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address([
+ 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x92, 0xfc, 0x48, 0xc2, 0xa4, 0x41,
+ 0xfc, 0x76,
+ ]),
+ dst_addr: Ipv6Address([
+ 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x42, 0x42, 0x42, 0x42, 0x42,
+ 0xb, 0x1a,
+ ]),
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 136,
+ hop_limit: 64,
+ },
+ IpPayload::Icmpv6(Icmpv6Repr::EchoReply {
+ ident: 39,
+ seq_no: 2,
+ data,
+ })
+ ))
+ );
+
+ iface.inner.neighbor_cache.fill(
+ IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x42, 0x42, 0x42, 0x42, 0x42, 0xb, 0x1a,
+ ])),
+ HardwareAddress::Ieee802154(Ieee802154Address::default()),
+ Instant::now(),
+ );
+
+ let tx_token = device.transmit(Instant::now()).unwrap();
+ iface.inner.dispatch_ieee802154(
+ Ieee802154Address::default(),
+ tx_token,
+ PacketMeta::default(),
+ result.unwrap(),
+ &mut iface.fragmenter,
+ );
+
+ assert_eq!(
+ device.queue.pop_front().unwrap(),
+ &[
+ 0x41, 0xcc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+ 0x2, 0x2, 0x2, 0x2, 0xc0, 0xb0, 0x5, 0x4e, 0x7a, 0x11, 0x3a, 0x92, 0xfc, 0x48, 0xc2,
+ 0xa4, 0x41, 0xfc, 0x76, 0x40, 0x42, 0x42, 0x42, 0x42, 0x42, 0xb, 0x1a, 0x81, 0x0, 0x0,
+ 0x0, 0x0, 0x27, 0x0, 0x2, 0xa2, 0xc2, 0x2d, 0x63, 0x0, 0x0, 0x0, 0x0, 0xd9, 0x5e, 0xc,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+ 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+ 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+ 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43,
+ 0x44, 0x45, 0x46, 0x47,
+ ]
+ );
+
+ iface.poll(Instant::now(), &mut device, &mut sockets);
+
+ assert_eq!(
+ device.queue.pop_front().unwrap(),
+ &[
+ 0x41, 0xcc, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+ 0x2, 0x2, 0x2, 0x2, 0xe0, 0xb0, 0x5, 0x4e, 0xf, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
+ 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b,
+ 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+ 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+ 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+ ]
+ );
+}
+
+#[test]
+#[cfg(feature = "proto-sixlowpan-fragmentation")]
+fn test_sixlowpan_udp_with_fragmentation() {
+ use crate::phy::Checksum;
+
+ let mut ieee802154_repr = Ieee802154Repr {
+ frame_type: Ieee802154FrameType::Data,
+ security_enabled: false,
+ frame_pending: false,
+ ack_request: false,
+ sequence_number: Some(5),
+ pan_id_compression: true,
+ frame_version: Ieee802154FrameVersion::Ieee802154_2003,
+ dst_pan_id: Some(Ieee802154Pan(0xbeef)),
+ dst_addr: Some(Ieee802154Address::Extended([
+ 0x90, 0xfc, 0x48, 0xc2, 0xa4, 0x41, 0xfc, 0x76,
+ ])),
+ src_pan_id: Some(Ieee802154Pan(0xbeef)),
+ src_addr: Some(Ieee802154Address::Extended([
+ 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a,
+ ])),
+ };
+
+ let (mut iface, mut sockets, mut device) = setup(Medium::Ieee802154);
+ iface.update_ip_addrs(|ips| {
+ ips.push(IpCidr::Ipv6(Ipv6Cidr::new(
+ Ipv6Address::new(0xfe80, 0x0, 0x0, 0x0, 0x92fc, 0x48c2, 0xa441, 0xfc76),
+ 10,
+ )))
+ .unwrap();
+ });
+ iface.inner.caps.checksum.udp = Checksum::None;
+
+ let udp_rx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 1024 * 4]);
+ let udp_tx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 1024 * 4]);
+ let udp_socket = udp::Socket::new(udp_rx_buffer, udp_tx_buffer);
+ let udp_socket_handle = sockets.add(udp_socket);
+
+ {
+ let socket = sockets.get_mut::<udp::Socket>(udp_socket_handle);
+ assert_eq!(socket.bind(6969), Ok(()));
+ assert!(!socket.can_recv());
+ assert!(socket.can_send());
+ }
+
+ let udp_first_part = &[
+ 0xc0, 0xbc, 0x00, 0x92, 0x6e, 0x33, 0x07, 0xe7, 0xdc, 0xf0, 0xd3, 0xc9, 0x1b, 0x39, 0xbf,
+ 0xa0, 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x69, 0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f,
+ 0x6c, 0x6f, 0x72, 0x20, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63,
+ 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x74, 0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70,
+ 0x69, 0x73, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x2e, 0x20, 0x49, 0x6e,
+ 0x20, 0x61, 0x74, 0x20, 0x72, 0x68, 0x6f, 0x6e, 0x63, 0x75, 0x73, 0x20, 0x74, 0x6f, 0x72,
+ 0x74, 0x6f, 0x72, 0x2e, 0x20, 0x43, 0x72, 0x61, 0x73, 0x20, 0x62, 0x6c, 0x61, 0x6e,
+ ];
+
+ assert_eq!(
+ iface.inner.process_sixlowpan(
+ &mut sockets,
+ PacketMeta::default(),
+ &ieee802154_repr,
+ udp_first_part,
+ &mut iface.fragments
+ ),
+ None
+ );
+
+ ieee802154_repr.sequence_number = Some(6);
+
+ let udp_second_part = &[
+ 0xe0, 0xbc, 0x00, 0x92, 0x11, 0x64, 0x69, 0x74, 0x20, 0x74, 0x65, 0x6c, 0x6c, 0x75, 0x73,
+ 0x20, 0x64, 0x69, 0x61, 0x6d, 0x2c, 0x20, 0x76, 0x61, 0x72, 0x69, 0x75, 0x73, 0x20, 0x76,
+ 0x65, 0x73, 0x74, 0x69, 0x62, 0x75, 0x6c, 0x75, 0x6d, 0x20, 0x6e, 0x69, 0x62, 0x68, 0x20,
+ 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x64, 0x6f, 0x20, 0x6e, 0x65, 0x63, 0x2e,
+ ];
+
+ assert_eq!(
+ iface.inner.process_sixlowpan(
+ &mut sockets,
+ PacketMeta::default(),
+ &ieee802154_repr,
+ udp_second_part,
+ &mut iface.fragments
+ ),
+ None
+ );
+
+ let socket = sockets.get_mut::<udp::Socket>(udp_socket_handle);
+
+ let udp_data = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. \
+In at rhoncus tortor. Cras blandit tellus diam, varius vestibulum nibh commodo nec.";
+ assert_eq!(
+ socket.recv(),
+ Ok((
+ &udp_data[..],
+ IpEndpoint {
+ addr: IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x42, 0x42, 0x42, 0x42, 0x42,
+ 0xb, 0x1a,
+ ])),
+ port: 54217,
+ }
+ .into()
+ ))
+ );
+
+ let tx_token = device.transmit(Instant::now()).unwrap();
+ iface.inner.dispatch_ieee802154(
+ Ieee802154Address::default(),
+ tx_token,
+ PacketMeta::default(),
+ Packet::new_ipv6(
+ Ipv6Repr {
+ src_addr: Ipv6Address::default(),
+ dst_addr: Ipv6Address::default(),
+ next_header: IpProtocol::Udp,
+ payload_len: udp_data.len(),
+ hop_limit: 64,
+ },
+ IpPayload::Udp(
+ UdpRepr {
+ src_port: 1234,
+ dst_port: 1234,
+ },
+ udp_data,
+ ),
+ ),
+ &mut iface.fragmenter,
+ );
+
+ iface.poll(Instant::now(), &mut device, &mut sockets);
+
+ assert_eq!(
+ device.queue.pop_front().unwrap(),
+ &[
+ 0x41, 0xcc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+ 0x2, 0x2, 0x2, 0x2, 0xc0, 0xb4, 0x5, 0x4e, 0x7e, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x4, 0xd2, 0x4, 0xd2, 0x0, 0x0,
+ 0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x69, 0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f,
+ 0x6c, 0x6f, 0x72, 0x20, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20,
+ 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x74, 0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64,
+ 0x69, 0x70, 0x69, 0x73, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x2e,
+ 0x20, 0x49, 0x6e, 0x20, 0x61, 0x74, 0x20, 0x72, 0x68, 0x6f, 0x6e, 0x63, 0x75, 0x73,
+ 0x20, 0x74,
+ ],
+ );
+
+ assert_eq!(
+ device.queue.pop_front().unwrap(),
+ &[
+ 0x41, 0xcc, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+ 0x2, 0x2, 0x2, 0x2, 0xe0, 0xb4, 0x5, 0x4e, 0xf, 0x6f, 0x72, 0x74, 0x6f, 0x72, 0x2e,
+ 0x20, 0x43, 0x72, 0x61, 0x73, 0x20, 0x62, 0x6c, 0x61, 0x6e, 0x64, 0x69, 0x74, 0x20,
+ 0x74, 0x65, 0x6c, 0x6c, 0x75, 0x73, 0x20, 0x64, 0x69, 0x61, 0x6d, 0x2c, 0x20, 0x76,
+ 0x61, 0x72, 0x69, 0x75, 0x73, 0x20, 0x76, 0x65, 0x73, 0x74, 0x69, 0x62, 0x75, 0x6c,
+ 0x75, 0x6d, 0x20, 0x6e, 0x69, 0x62, 0x68, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x64,
+ 0x6f, 0x20, 0x6e, 0x65, 0x63, 0x2e,
+ ]
+ );
+}
diff --git a/src/iface/mod.rs b/src/iface/mod.rs
new file mode 100644
index 0000000..3076088
--- /dev/null
+++ b/src/iface/mod.rs
@@ -0,0 +1,24 @@
+/*! Network interface logic.
+
+The `iface` module deals with the *network interfaces*. It filters incoming frames,
+provides lookup and caching of hardware addresses, and handles management packets.
+*/
+
+mod fragmentation;
+mod interface;
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+mod neighbor;
+mod route;
+#[cfg(feature = "proto-rpl")]
+mod rpl;
+mod socket_meta;
+mod socket_set;
+
+mod packet;
+
+#[cfg(feature = "proto-igmp")]
+pub use self::interface::MulticastError;
+pub use self::interface::{Config, Interface, InterfaceInner as Context};
+
+pub use self::route::{Route, RouteTableFull, Routes};
+pub use self::socket_set::{SocketHandle, SocketSet, SocketStorage};
diff --git a/src/iface/neighbor.rs b/src/iface/neighbor.rs
new file mode 100644
index 0000000..0c451fa
--- /dev/null
+++ b/src/iface/neighbor.rs
@@ -0,0 +1,306 @@
+// Heads up! Before working on this file you should read, at least,
+// the parts of RFC 1122 that discuss ARP.
+
+use heapless::LinearMap;
+
+use crate::config::IFACE_NEIGHBOR_CACHE_COUNT;
+use crate::time::{Duration, Instant};
+use crate::wire::{HardwareAddress, IpAddress};
+
+/// A cached neighbor.
+///
+/// A neighbor mapping translates from a protocol address to a hardware address,
+/// and contains the timestamp past which the mapping should be discarded.
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Neighbor {
+ hardware_addr: HardwareAddress,
+ expires_at: Instant,
+}
+
+/// An answer to a neighbor cache lookup.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub(crate) enum Answer {
+ /// The neighbor address is in the cache and not expired.
+ Found(HardwareAddress),
+ /// The neighbor address is not in the cache, or has expired.
+ NotFound,
+ /// The neighbor address is not in the cache, or has expired,
+ /// and a lookup has been made recently.
+ RateLimited,
+}
+
+impl Answer {
+ /// Returns whether a valid address was found.
+ pub(crate) fn found(&self) -> bool {
+ match self {
+ Answer::Found(_) => true,
+ _ => false,
+ }
+ }
+}
+
+/// A neighbor cache backed by a map.
+#[derive(Debug)]
+pub struct Cache {
+ storage: LinearMap<IpAddress, Neighbor, IFACE_NEIGHBOR_CACHE_COUNT>,
+ silent_until: Instant,
+}
+
+impl Cache {
+ /// Minimum delay between discovery requests, in milliseconds.
+ pub(crate) const SILENT_TIME: Duration = Duration::from_millis(1_000);
+
+ /// Neighbor entry lifetime, in milliseconds.
+ pub(crate) const ENTRY_LIFETIME: Duration = Duration::from_millis(60_000);
+
+ /// Create a cache.
+ pub fn new() -> Self {
+ Self {
+ storage: LinearMap::new(),
+ silent_until: Instant::from_millis(0),
+ }
+ }
+
+ pub fn fill(
+ &mut self,
+ protocol_addr: IpAddress,
+ hardware_addr: HardwareAddress,
+ timestamp: Instant,
+ ) {
+ debug_assert!(protocol_addr.is_unicast());
+ debug_assert!(hardware_addr.is_unicast());
+
+ let expires_at = timestamp + Self::ENTRY_LIFETIME;
+ self.fill_with_expiration(protocol_addr, hardware_addr, expires_at);
+ }
+
+ pub fn fill_with_expiration(
+ &mut self,
+ protocol_addr: IpAddress,
+ hardware_addr: HardwareAddress,
+ expires_at: Instant,
+ ) {
+ debug_assert!(protocol_addr.is_unicast());
+ debug_assert!(hardware_addr.is_unicast());
+
+ let neighbor = Neighbor {
+ expires_at,
+ hardware_addr,
+ };
+ match self.storage.insert(protocol_addr, neighbor) {
+ Ok(Some(old_neighbor)) => {
+ if old_neighbor.hardware_addr != hardware_addr {
+ net_trace!(
+ "replaced {} => {} (was {})",
+ protocol_addr,
+ hardware_addr,
+ old_neighbor.hardware_addr
+ );
+ }
+ }
+ Ok(None) => {
+ net_trace!("filled {} => {} (was empty)", protocol_addr, hardware_addr);
+ }
+ Err((protocol_addr, neighbor)) => {
+ // If we're going down this branch, it means the cache is full, and we need to evict an entry.
+ let old_protocol_addr = *self
+ .storage
+ .iter()
+ .min_by_key(|(_, neighbor)| neighbor.expires_at)
+ .expect("empty neighbor cache storage")
+ .0;
+
+ let _old_neighbor = self.storage.remove(&old_protocol_addr).unwrap();
+ match self.storage.insert(protocol_addr, neighbor) {
+ Ok(None) => {
+ net_trace!(
+ "filled {} => {} (evicted {} => {})",
+ protocol_addr,
+ hardware_addr,
+ old_protocol_addr,
+ _old_neighbor.hardware_addr
+ );
+ }
+ // We've covered everything else above.
+ _ => unreachable!(),
+ }
+ }
+ }
+ }
+
+ pub(crate) fn lookup(&self, protocol_addr: &IpAddress, timestamp: Instant) -> Answer {
+ assert!(protocol_addr.is_unicast());
+
+ if let Some(&Neighbor {
+ expires_at,
+ hardware_addr,
+ }) = self.storage.get(protocol_addr)
+ {
+ if timestamp < expires_at {
+ return Answer::Found(hardware_addr);
+ }
+ }
+
+ if timestamp < self.silent_until {
+ Answer::RateLimited
+ } else {
+ Answer::NotFound
+ }
+ }
+
+ pub(crate) fn limit_rate(&mut self, timestamp: Instant) {
+ self.silent_until = timestamp + Self::SILENT_TIME;
+ }
+
+ pub(crate) fn flush(&mut self) {
+ self.storage.clear()
+ }
+}
+
+#[cfg(feature = "medium-ethernet")]
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::wire::ip::test::{MOCK_IP_ADDR_1, MOCK_IP_ADDR_2, MOCK_IP_ADDR_3, MOCK_IP_ADDR_4};
+
+ use crate::wire::EthernetAddress;
+
+ const HADDR_A: HardwareAddress = HardwareAddress::Ethernet(EthernetAddress([0, 0, 0, 0, 0, 1]));
+ const HADDR_B: HardwareAddress = HardwareAddress::Ethernet(EthernetAddress([0, 0, 0, 0, 0, 2]));
+ const HADDR_C: HardwareAddress = HardwareAddress::Ethernet(EthernetAddress([0, 0, 0, 0, 0, 3]));
+ const HADDR_D: HardwareAddress = HardwareAddress::Ethernet(EthernetAddress([0, 0, 0, 0, 0, 4]));
+
+ #[test]
+ fn test_fill() {
+ let mut cache = Cache::new();
+
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0))
+ .found());
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_2, Instant::from_millis(0))
+ .found());
+
+ cache.fill(MOCK_IP_ADDR_1, HADDR_A, Instant::from_millis(0));
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0)),
+ Answer::Found(HADDR_A)
+ );
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_2, Instant::from_millis(0))
+ .found());
+ assert!(!cache
+ .lookup(
+ &MOCK_IP_ADDR_1,
+ Instant::from_millis(0) + Cache::ENTRY_LIFETIME * 2
+ )
+ .found(),);
+
+ cache.fill(MOCK_IP_ADDR_1, HADDR_A, Instant::from_millis(0));
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_2, Instant::from_millis(0))
+ .found());
+ }
+
+ #[test]
+ fn test_expire() {
+ let mut cache = Cache::new();
+
+ cache.fill(MOCK_IP_ADDR_1, HADDR_A, Instant::from_millis(0));
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0)),
+ Answer::Found(HADDR_A)
+ );
+ assert!(!cache
+ .lookup(
+ &MOCK_IP_ADDR_1,
+ Instant::from_millis(0) + Cache::ENTRY_LIFETIME * 2
+ )
+ .found(),);
+ }
+
+ #[test]
+ fn test_replace() {
+ let mut cache = Cache::new();
+
+ cache.fill(MOCK_IP_ADDR_1, HADDR_A, Instant::from_millis(0));
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0)),
+ Answer::Found(HADDR_A)
+ );
+ cache.fill(MOCK_IP_ADDR_1, HADDR_B, Instant::from_millis(0));
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0)),
+ Answer::Found(HADDR_B)
+ );
+ }
+
+ #[test]
+ fn test_evict() {
+ let mut cache = Cache::new();
+
+ cache.fill(MOCK_IP_ADDR_1, HADDR_A, Instant::from_millis(100));
+ cache.fill(MOCK_IP_ADDR_2, HADDR_B, Instant::from_millis(50));
+ cache.fill(MOCK_IP_ADDR_3, HADDR_C, Instant::from_millis(200));
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_2, Instant::from_millis(1000)),
+ Answer::Found(HADDR_B)
+ );
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_4, Instant::from_millis(1000))
+ .found());
+
+ cache.fill(MOCK_IP_ADDR_4, HADDR_D, Instant::from_millis(300));
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_2, Instant::from_millis(1000))
+ .found());
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_4, Instant::from_millis(1000)),
+ Answer::Found(HADDR_D)
+ );
+ }
+
+ #[test]
+ fn test_hush() {
+ let mut cache = Cache::new();
+
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0)),
+ Answer::NotFound
+ );
+
+ cache.limit_rate(Instant::from_millis(0));
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(100)),
+ Answer::RateLimited
+ );
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(2000)),
+ Answer::NotFound
+ );
+ }
+
+ #[test]
+ fn test_flush() {
+ let mut cache = Cache::new();
+
+ cache.fill(MOCK_IP_ADDR_1, HADDR_A, Instant::from_millis(0));
+ assert_eq!(
+ cache.lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0)),
+ Answer::Found(HADDR_A)
+ );
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_2, Instant::from_millis(0))
+ .found());
+
+ cache.flush();
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0))
+ .found());
+ assert!(!cache
+ .lookup(&MOCK_IP_ADDR_1, Instant::from_millis(0))
+ .found());
+ }
+}
diff --git a/src/iface/packet.rs b/src/iface/packet.rs
new file mode 100644
index 0000000..4fdb19d
--- /dev/null
+++ b/src/iface/packet.rs
@@ -0,0 +1,234 @@
+use crate::phy::DeviceCapabilities;
+use crate::wire::*;
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg(feature = "medium-ethernet")]
+pub(crate) enum EthernetPacket<'a> {
+ #[cfg(feature = "proto-ipv4")]
+ Arp(ArpRepr),
+ Ip(Packet<'a>),
+}
+
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub(crate) enum Packet<'p> {
+ #[cfg(feature = "proto-ipv4")]
+ Ipv4(PacketV4<'p>),
+ #[cfg(feature = "proto-ipv6")]
+ Ipv6(PacketV6<'p>),
+}
+
+impl<'p> Packet<'p> {
+ pub(crate) fn new(ip_repr: IpRepr, payload: IpPayload<'p>) -> Self {
+ match ip_repr {
+ #[cfg(feature = "proto-ipv4")]
+ IpRepr::Ipv4(header) => Self::new_ipv4(header, payload),
+ #[cfg(feature = "proto-ipv6")]
+ IpRepr::Ipv6(header) => Self::new_ipv6(header, payload),
+ }
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ pub(crate) fn new_ipv4(ip_repr: Ipv4Repr, payload: IpPayload<'p>) -> Self {
+ Self::Ipv4(PacketV4 {
+ header: ip_repr,
+ payload,
+ })
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ pub(crate) fn new_ipv6(ip_repr: Ipv6Repr, payload: IpPayload<'p>) -> Self {
+ Self::Ipv6(PacketV6 {
+ header: ip_repr,
+ #[cfg(feature = "proto-ipv6-hbh")]
+ hop_by_hop: None,
+ #[cfg(feature = "proto-ipv6-fragmentation")]
+ fragment: None,
+ #[cfg(feature = "proto-ipv6-routing")]
+ routing: None,
+ payload,
+ })
+ }
+
+ pub(crate) fn ip_repr(&self) -> IpRepr {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Packet::Ipv4(p) => IpRepr::Ipv4(p.header),
+ #[cfg(feature = "proto-ipv6")]
+ Packet::Ipv6(p) => IpRepr::Ipv6(p.header),
+ }
+ }
+
+ pub(crate) fn payload(&self) -> &IpPayload<'p> {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Packet::Ipv4(p) => &p.payload,
+ #[cfg(feature = "proto-ipv6")]
+ Packet::Ipv6(p) => &p.payload,
+ }
+ }
+
+ pub(crate) fn emit_payload(
+ &self,
+ _ip_repr: &IpRepr,
+ payload: &mut [u8],
+ caps: &DeviceCapabilities,
+ ) {
+ match self.payload() {
+ #[cfg(feature = "proto-ipv4")]
+ IpPayload::Icmpv4(icmpv4_repr) => {
+ icmpv4_repr.emit(&mut Icmpv4Packet::new_unchecked(payload), &caps.checksum)
+ }
+ #[cfg(feature = "proto-igmp")]
+ IpPayload::Igmp(igmp_repr) => igmp_repr.emit(&mut IgmpPacket::new_unchecked(payload)),
+ #[cfg(feature = "proto-ipv6")]
+ IpPayload::Icmpv6(icmpv6_repr) => icmpv6_repr.emit(
+ &_ip_repr.src_addr(),
+ &_ip_repr.dst_addr(),
+ &mut Icmpv6Packet::new_unchecked(payload),
+ &caps.checksum,
+ ),
+ #[cfg(feature = "socket-raw")]
+ IpPayload::Raw(raw_packet) => payload.copy_from_slice(raw_packet),
+ #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
+ IpPayload::Udp(udp_repr, inner_payload) => udp_repr.emit(
+ &mut UdpPacket::new_unchecked(payload),
+ &_ip_repr.src_addr(),
+ &_ip_repr.dst_addr(),
+ inner_payload.len(),
+ |buf| buf.copy_from_slice(inner_payload),
+ &caps.checksum,
+ ),
+ #[cfg(feature = "socket-tcp")]
+ IpPayload::Tcp(mut tcp_repr) => {
+ // This is a terrible hack to make TCP performance more acceptable on systems
+ // where the TCP buffers are significantly larger than network buffers,
+ // e.g. a 64 kB TCP receive buffer (and so, when empty, a 64k window)
+ // together with four 1500 B Ethernet receive buffers. If left untreated,
+ // this would result in our peer pushing our window and sever packet loss.
+ //
+ // I'm really not happy about this "solution" but I don't know what else to do.
+ if let Some(max_burst_size) = caps.max_burst_size {
+ let mut max_segment_size = caps.max_transmission_unit;
+ max_segment_size -= _ip_repr.header_len();
+ max_segment_size -= tcp_repr.header_len();
+
+ let max_window_size = max_burst_size * max_segment_size;
+ if tcp_repr.window_len as usize > max_window_size {
+ tcp_repr.window_len = max_window_size as u16;
+ }
+ }
+
+ tcp_repr.emit(
+ &mut TcpPacket::new_unchecked(payload),
+ &_ip_repr.src_addr(),
+ &_ip_repr.dst_addr(),
+ &caps.checksum,
+ );
+ }
+ #[cfg(feature = "socket-dhcpv4")]
+ IpPayload::Dhcpv4(udp_repr, dhcp_repr) => udp_repr.emit(
+ &mut UdpPacket::new_unchecked(payload),
+ &_ip_repr.src_addr(),
+ &_ip_repr.dst_addr(),
+ dhcp_repr.buffer_len(),
+ |buf| dhcp_repr.emit(&mut DhcpPacket::new_unchecked(buf)).unwrap(),
+ &caps.checksum,
+ ),
+ }
+ }
+}
+
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg(feature = "proto-ipv4")]
+pub(crate) struct PacketV4<'p> {
+ header: Ipv4Repr,
+ payload: IpPayload<'p>,
+}
+
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg(feature = "proto-ipv6")]
+pub(crate) struct PacketV6<'p> {
+ pub(crate) header: Ipv6Repr,
+ #[cfg(feature = "proto-ipv6-hbh")]
+ pub(crate) hop_by_hop: Option<Ipv6HopByHopRepr<'p>>,
+ #[cfg(feature = "proto-ipv6-fragmentation")]
+ pub(crate) fragment: Option<Ipv6FragmentRepr>,
+ #[cfg(feature = "proto-ipv6-routing")]
+ pub(crate) routing: Option<Ipv6RoutingRepr<'p>>,
+ pub(crate) payload: IpPayload<'p>,
+}
+
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub(crate) enum IpPayload<'p> {
+ #[cfg(feature = "proto-ipv4")]
+ Icmpv4(Icmpv4Repr<'p>),
+ #[cfg(feature = "proto-igmp")]
+ Igmp(IgmpRepr),
+ #[cfg(feature = "proto-ipv6")]
+ Icmpv6(Icmpv6Repr<'p>),
+ #[cfg(feature = "socket-raw")]
+ Raw(&'p [u8]),
+ #[cfg(any(feature = "socket-udp", feature = "socket-dns"))]
+ Udp(UdpRepr, &'p [u8]),
+ #[cfg(feature = "socket-tcp")]
+ Tcp(TcpRepr<'p>),
+ #[cfg(feature = "socket-dhcpv4")]
+ Dhcpv4(UdpRepr, DhcpRepr<'p>),
+}
+
+impl<'p> IpPayload<'p> {
+ #[cfg(feature = "proto-sixlowpan")]
+ pub(crate) fn as_sixlowpan_next_header(&self) -> SixlowpanNextHeader {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Self::Icmpv4(_) => unreachable!(),
+ #[cfg(feature = "socket-dhcpv4")]
+ Self::Dhcpv4(..) => unreachable!(),
+ #[cfg(feature = "proto-ipv6")]
+ Self::Icmpv6(_) => SixlowpanNextHeader::Uncompressed(IpProtocol::Icmpv6),
+ #[cfg(feature = "proto-igmp")]
+ Self::Igmp(_) => unreachable!(),
+ #[cfg(feature = "socket-tcp")]
+ Self::Tcp(_) => SixlowpanNextHeader::Uncompressed(IpProtocol::Tcp),
+ #[cfg(feature = "socket-udp")]
+ Self::Udp(..) => SixlowpanNextHeader::Compressed,
+ #[cfg(feature = "socket-raw")]
+ Self::Raw(_) => todo!(),
+ }
+ }
+}
+
+#[cfg(any(feature = "proto-ipv4", feature = "proto-ipv6"))]
+pub(crate) fn icmp_reply_payload_len(len: usize, mtu: usize, header_len: usize) -> usize {
+ // Send back as much of the original payload as will fit within
+ // the minimum MTU required by IPv4. See RFC 1812 § 4.3.2.3 for
+ // more details.
+ //
+ // Since the entire network layer packet must fit within the minimum
+ // MTU supported, the payload must not exceed the following:
+ //
+ // <min mtu> - IP Header Size * 2 - ICMPv4 DstUnreachable hdr size
+ len.min(mtu - header_len * 2 - 8)
+}
+
+#[cfg(feature = "proto-igmp")]
+pub(crate) enum IgmpReportState {
+ Inactive,
+ ToGeneralQuery {
+ version: IgmpVersion,
+ timeout: crate::time::Instant,
+ interval: crate::time::Duration,
+ next_index: usize,
+ },
+ ToSpecificQuery {
+ version: IgmpVersion,
+ timeout: crate::time::Instant,
+ group: Ipv4Address,
+ },
+}
diff --git a/src/iface/route.rs b/src/iface/route.rs
new file mode 100644
index 0000000..123c695
--- /dev/null
+++ b/src/iface/route.rs
@@ -0,0 +1,327 @@
+use heapless::Vec;
+
+use crate::config::IFACE_MAX_ROUTE_COUNT;
+use crate::time::Instant;
+use crate::wire::{IpAddress, IpCidr};
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::{Ipv4Address, Ipv4Cidr};
+#[cfg(feature = "proto-ipv6")]
+use crate::wire::{Ipv6Address, Ipv6Cidr};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct RouteTableFull;
+
+impl core::fmt::Display for RouteTableFull {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ write!(f, "Route table full")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RouteTableFull {}
+
+/// A prefix of addresses that should be routed via a router
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Route {
+ pub cidr: IpCidr,
+ pub via_router: IpAddress,
+ /// `None` means "forever".
+ pub preferred_until: Option<Instant>,
+ /// `None` means "forever".
+ pub expires_at: Option<Instant>,
+}
+
+#[cfg(feature = "proto-ipv4")]
+const IPV4_DEFAULT: IpCidr = IpCidr::Ipv4(Ipv4Cidr::new(Ipv4Address::new(0, 0, 0, 0), 0));
+#[cfg(feature = "proto-ipv6")]
+const IPV6_DEFAULT: IpCidr =
+ IpCidr::Ipv6(Ipv6Cidr::new(Ipv6Address::new(0, 0, 0, 0, 0, 0, 0, 0), 0));
+
+impl Route {
+ /// Returns a route to 0.0.0.0/0 via the `gateway`, with no expiry.
+ #[cfg(feature = "proto-ipv4")]
+ pub fn new_ipv4_gateway(gateway: Ipv4Address) -> Route {
+ Route {
+ cidr: IPV4_DEFAULT,
+ via_router: gateway.into(),
+ preferred_until: None,
+ expires_at: None,
+ }
+ }
+
+ /// Returns a route to ::/0 via the `gateway`, with no expiry.
+ #[cfg(feature = "proto-ipv6")]
+ pub fn new_ipv6_gateway(gateway: Ipv6Address) -> Route {
+ Route {
+ cidr: IPV6_DEFAULT,
+ via_router: gateway.into(),
+ preferred_until: None,
+ expires_at: None,
+ }
+ }
+}
+
+/// A routing table.
+#[derive(Debug)]
+pub struct Routes {
+ storage: Vec<Route, IFACE_MAX_ROUTE_COUNT>,
+}
+
+impl Routes {
+ /// Creates a new empty routing table.
+ pub fn new() -> Self {
+ Self {
+ storage: Vec::new(),
+ }
+ }
+
+ /// Update the routes of this node.
+ pub fn update<F: FnOnce(&mut Vec<Route, IFACE_MAX_ROUTE_COUNT>)>(&mut self, f: F) {
+ f(&mut self.storage);
+ }
+
+ /// Add a default ipv4 gateway (ie. "ip route add 0.0.0.0/0 via `gateway`").
+ ///
+ /// On success, returns the previous default route, if any.
+ #[cfg(feature = "proto-ipv4")]
+ pub fn add_default_ipv4_route(
+ &mut self,
+ gateway: Ipv4Address,
+ ) -> Result<Option<Route>, RouteTableFull> {
+ let old = self.remove_default_ipv4_route();
+ self.storage
+ .push(Route::new_ipv4_gateway(gateway))
+ .map_err(|_| RouteTableFull)?;
+ Ok(old)
+ }
+
+ /// Add a default ipv6 gateway (ie. "ip -6 route add ::/0 via `gateway`").
+ ///
+ /// On success, returns the previous default route, if any.
+ #[cfg(feature = "proto-ipv6")]
+ pub fn add_default_ipv6_route(
+ &mut self,
+ gateway: Ipv6Address,
+ ) -> Result<Option<Route>, RouteTableFull> {
+ let old = self.remove_default_ipv6_route();
+ self.storage
+ .push(Route::new_ipv6_gateway(gateway))
+ .map_err(|_| RouteTableFull)?;
+ Ok(old)
+ }
+
+ /// Remove the default ipv4 gateway
+ ///
+ /// On success, returns the previous default route, if any.
+ #[cfg(feature = "proto-ipv4")]
+ pub fn remove_default_ipv4_route(&mut self) -> Option<Route> {
+ if let Some((i, _)) = self
+ .storage
+ .iter()
+ .enumerate()
+ .find(|(_, r)| r.cidr == IPV4_DEFAULT)
+ {
+ Some(self.storage.remove(i))
+ } else {
+ None
+ }
+ }
+
+ /// Remove the default ipv6 gateway
+ ///
+ /// On success, returns the previous default route, if any.
+ #[cfg(feature = "proto-ipv6")]
+ pub fn remove_default_ipv6_route(&mut self) -> Option<Route> {
+ if let Some((i, _)) = self
+ .storage
+ .iter()
+ .enumerate()
+ .find(|(_, r)| r.cidr == IPV6_DEFAULT)
+ {
+ Some(self.storage.remove(i))
+ } else {
+ None
+ }
+ }
+
+ pub(crate) fn lookup(&self, addr: &IpAddress, timestamp: Instant) -> Option<IpAddress> {
+ assert!(addr.is_unicast());
+
+ self.storage
+ .iter()
+ // Keep only matching routes
+ .filter(|route| {
+ if let Some(expires_at) = route.expires_at {
+ if timestamp > expires_at {
+ return false;
+ }
+ }
+ route.cidr.contains_addr(addr)
+ })
+ // pick the most specific one (highest prefix_len)
+ .max_by_key(|route| route.cidr.prefix_len())
+ .map(|route| route.via_router)
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ #[cfg(feature = "proto-ipv6")]
+ mod mock {
+ use super::super::*;
+ pub const ADDR_1A: Ipv6Address =
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1]);
+ pub const ADDR_1B: Ipv6Address =
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 13]);
+ pub const ADDR_1C: Ipv6Address =
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 42]);
+ pub fn cidr_1() -> Ipv6Cidr {
+ Ipv6Cidr::new(
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]),
+ 64,
+ )
+ }
+
+ pub const ADDR_2A: Ipv6Address =
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 51, 100, 0, 0, 0, 0, 0, 0, 0, 1]);
+ pub const ADDR_2B: Ipv6Address =
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 51, 100, 0, 0, 0, 0, 0, 0, 0, 21]);
+ pub fn cidr_2() -> Ipv6Cidr {
+ Ipv6Cidr::new(
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 51, 100, 0, 0, 0, 0, 0, 0, 0, 0]),
+ 64,
+ )
+ }
+ }
+
+ #[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
+ mod mock {
+ use super::super::*;
+ pub const ADDR_1A: Ipv4Address = Ipv4Address([192, 0, 2, 1]);
+ pub const ADDR_1B: Ipv4Address = Ipv4Address([192, 0, 2, 13]);
+ pub const ADDR_1C: Ipv4Address = Ipv4Address([192, 0, 2, 42]);
+ pub fn cidr_1() -> Ipv4Cidr {
+ Ipv4Cidr::new(Ipv4Address([192, 0, 2, 0]), 24)
+ }
+
+ pub const ADDR_2A: Ipv4Address = Ipv4Address([198, 51, 100, 1]);
+ pub const ADDR_2B: Ipv4Address = Ipv4Address([198, 51, 100, 21]);
+ pub fn cidr_2() -> Ipv4Cidr {
+ Ipv4Cidr::new(Ipv4Address([198, 51, 100, 0]), 24)
+ }
+ }
+
+ use self::mock::*;
+
+ #[test]
+ fn test_fill() {
+ let mut routes = Routes::new();
+
+ assert_eq!(
+ routes.lookup(&ADDR_1A.into(), Instant::from_millis(0)),
+ None
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1B.into(), Instant::from_millis(0)),
+ None
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1C.into(), Instant::from_millis(0)),
+ None
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2A.into(), Instant::from_millis(0)),
+ None
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2B.into(), Instant::from_millis(0)),
+ None
+ );
+
+ let route = Route {
+ cidr: cidr_1().into(),
+ via_router: ADDR_1A.into(),
+ preferred_until: None,
+ expires_at: None,
+ };
+ routes.update(|storage| {
+ storage.push(route).unwrap();
+ });
+
+ assert_eq!(
+ routes.lookup(&ADDR_1A.into(), Instant::from_millis(0)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1B.into(), Instant::from_millis(0)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1C.into(), Instant::from_millis(0)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2A.into(), Instant::from_millis(0)),
+ None
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2B.into(), Instant::from_millis(0)),
+ None
+ );
+
+ let route2 = Route {
+ cidr: cidr_2().into(),
+ via_router: ADDR_2A.into(),
+ preferred_until: Some(Instant::from_millis(10)),
+ expires_at: Some(Instant::from_millis(10)),
+ };
+ routes.update(|storage| {
+ storage.push(route2).unwrap();
+ });
+
+ assert_eq!(
+ routes.lookup(&ADDR_1A.into(), Instant::from_millis(0)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1B.into(), Instant::from_millis(0)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1C.into(), Instant::from_millis(0)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2A.into(), Instant::from_millis(0)),
+ Some(ADDR_2A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2B.into(), Instant::from_millis(0)),
+ Some(ADDR_2A.into())
+ );
+
+ assert_eq!(
+ routes.lookup(&ADDR_1A.into(), Instant::from_millis(10)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1B.into(), Instant::from_millis(10)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_1C.into(), Instant::from_millis(10)),
+ Some(ADDR_1A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2A.into(), Instant::from_millis(10)),
+ Some(ADDR_2A.into())
+ );
+ assert_eq!(
+ routes.lookup(&ADDR_2B.into(), Instant::from_millis(10)),
+ Some(ADDR_2A.into())
+ );
+ }
+}
diff --git a/src/iface/rpl/consts.rs b/src/iface/rpl/consts.rs
new file mode 100644
index 0000000..70a6613
--- /dev/null
+++ b/src/iface/rpl/consts.rs
@@ -0,0 +1,8 @@
+pub const SEQUENCE_WINDOW: u8 = 16;
+
+pub const DEFAULT_MIN_HOP_RANK_INCREASE: u16 = 256;
+
+pub const DEFAULT_DIO_INTERVAL_MIN: u32 = 12;
+pub const DEFAULT_DIO_REDUNDANCY_CONSTANT: usize = 10;
+/// This is 20 in the standard, but in Contiki they use:
+pub const DEFAULT_DIO_INTERVAL_DOUBLINGS: u32 = 8;
diff --git a/src/iface/rpl/lollipop.rs b/src/iface/rpl/lollipop.rs
new file mode 100644
index 0000000..4785c77
--- /dev/null
+++ b/src/iface/rpl/lollipop.rs
@@ -0,0 +1,189 @@
+//! Implementation of sequence counters defined in [RFC 6550 § 7.2]. Values from 128 and greater
+//! are used as a linear sequence to indicate a restart and bootstrap the counter. Values less than
+//! or equal to 127 are used as a circular sequence number space of size 128. When operating in the
+//! circular region, if sequence numbers are detected to be too far apart, then they are not
+//! comparable.
+//!
+//! [RFC 6550 § 7.2]: https://datatracker.ietf.org/doc/html/rfc6550#section-7.2
+
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct SequenceCounter(u8);
+
+impl Default for SequenceCounter {
+ fn default() -> Self {
+ // RFC6550 7.2 recommends 240 (256 - SEQUENCE_WINDOW) as the initialization value of the
+ // counter.
+ Self(240)
+ }
+}
+
+impl SequenceCounter {
+ /// Create a new sequence counter.
+ ///
+ /// Use `Self::default()` when a new sequence counter needs to be created with a value that is
+ /// recommended in RFC6550 7.2, being 240.
+ pub fn new(value: u8) -> Self {
+ Self(value)
+ }
+
+ /// Return the value of the sequence counter.
+ pub fn value(&self) -> u8 {
+ self.0
+ }
+
+ /// Increment the sequence counter.
+ ///
+ /// When the sequence counter is greater than or equal to 128, the maximum value is 255.
+ /// When the sequence counter is less than 128, the maximum value is 127.
+ ///
+ /// When an increment of the sequence counter would cause the counter to increment beyond its
+ /// maximum value, the counter MUST wrap back to zero.
+ pub fn increment(&mut self) {
+ let max = if self.0 >= 128 { 255 } else { 127 };
+
+ self.0 = match self.0.checked_add(1) {
+ Some(val) if val <= max => val,
+ _ => 0,
+ };
+ }
+}
+
+impl PartialEq for SequenceCounter {
+ fn eq(&self, other: &Self) -> bool {
+ let a = self.value() as usize;
+ let b = other.value() as usize;
+
+ if ((128..=255).contains(&a) && (0..=127).contains(&b))
+ || ((128..=255).contains(&b) && (0..=127).contains(&a))
+ {
+ false
+ } else {
+ let result = if a > b { a - b } else { b - a };
+
+ if result <= super::consts::SEQUENCE_WINDOW as usize {
+ // RFC1982
+ a == b
+ } else {
+ // This case is actually not comparable.
+ false
+ }
+ }
+ }
+}
+
+impl PartialOrd for SequenceCounter {
+ fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+ use super::consts::SEQUENCE_WINDOW;
+ use core::cmp::Ordering;
+
+ let a = self.value() as usize;
+ let b = other.value() as usize;
+
+ if (128..256).contains(&a) && (0..128).contains(&b) {
+ if 256 + b - a <= SEQUENCE_WINDOW as usize {
+ Some(Ordering::Less)
+ } else {
+ Some(Ordering::Greater)
+ }
+ } else if (128..256).contains(&b) && (0..128).contains(&a) {
+ if 256 + a - b <= SEQUENCE_WINDOW as usize {
+ Some(Ordering::Greater)
+ } else {
+ Some(Ordering::Less)
+ }
+ } else if ((0..128).contains(&a) && (0..128).contains(&b))
+ || ((128..256).contains(&a) && (128..256).contains(&b))
+ {
+ let result = if a > b { a - b } else { b - a };
+
+ if result <= SEQUENCE_WINDOW as usize {
+ // RFC1982
+ a.partial_cmp(&b)
+ } else {
+ // This case is not comparable.
+ None
+ }
+ } else {
+ unreachable!();
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn sequence_counter_increment() {
+ let mut seq = SequenceCounter::new(253);
+ seq.increment();
+ assert_eq!(seq.value(), 254);
+ seq.increment();
+ assert_eq!(seq.value(), 255);
+ seq.increment();
+ assert_eq!(seq.value(), 0);
+
+ let mut seq = SequenceCounter::new(126);
+ seq.increment();
+ assert_eq!(seq.value(), 127);
+ seq.increment();
+ assert_eq!(seq.value(), 0);
+ }
+
+ #[test]
+ fn sequence_counter_comparison() {
+ use core::cmp::Ordering;
+
+ assert!(SequenceCounter::new(240) != SequenceCounter::new(1));
+ assert!(SequenceCounter::new(1) != SequenceCounter::new(240));
+ assert!(SequenceCounter::new(1) != SequenceCounter::new(240));
+ assert!(SequenceCounter::new(240) == SequenceCounter::new(240));
+ assert!(SequenceCounter::new(240 - 17) != SequenceCounter::new(240));
+
+ assert_eq!(
+ SequenceCounter::new(240).partial_cmp(&SequenceCounter::new(5)),
+ Some(Ordering::Greater)
+ );
+ assert_eq!(
+ SequenceCounter::new(250).partial_cmp(&SequenceCounter::new(5)),
+ Some(Ordering::Less)
+ );
+ assert_eq!(
+ SequenceCounter::new(5).partial_cmp(&SequenceCounter::new(250)),
+ Some(Ordering::Greater)
+ );
+ assert_eq!(
+ SequenceCounter::new(127).partial_cmp(&SequenceCounter::new(129)),
+ Some(Ordering::Less)
+ );
+ assert_eq!(
+ SequenceCounter::new(120).partial_cmp(&SequenceCounter::new(121)),
+ Some(Ordering::Less)
+ );
+ assert_eq!(
+ SequenceCounter::new(121).partial_cmp(&SequenceCounter::new(120)),
+ Some(Ordering::Greater)
+ );
+ assert_eq!(
+ SequenceCounter::new(240).partial_cmp(&SequenceCounter::new(241)),
+ Some(Ordering::Less)
+ );
+ assert_eq!(
+ SequenceCounter::new(241).partial_cmp(&SequenceCounter::new(240)),
+ Some(Ordering::Greater)
+ );
+ assert_eq!(
+ SequenceCounter::new(120).partial_cmp(&SequenceCounter::new(120)),
+ Some(Ordering::Equal)
+ );
+ assert_eq!(
+ SequenceCounter::new(240).partial_cmp(&SequenceCounter::new(240)),
+ Some(Ordering::Equal)
+ );
+ assert_eq!(
+ SequenceCounter::new(130).partial_cmp(&SequenceCounter::new(241)),
+ None
+ );
+ }
+}
diff --git a/src/iface/rpl/mod.rs b/src/iface/rpl/mod.rs
new file mode 100644
index 0000000..69aa9ae
--- /dev/null
+++ b/src/iface/rpl/mod.rs
@@ -0,0 +1,9 @@
+#![allow(unused)]
+
+mod consts;
+mod lollipop;
+mod of0;
+mod parents;
+mod rank;
+mod relations;
+mod trickle;
diff --git a/src/iface/rpl/of0.rs b/src/iface/rpl/of0.rs
new file mode 100644
index 0000000..99e4d1f
--- /dev/null
+++ b/src/iface/rpl/of0.rs
@@ -0,0 +1,129 @@
+use super::parents::*;
+use super::rank::Rank;
+
+pub struct ObjectiveFunction0;
+
+pub(crate) trait ObjectiveFunction {
+ const OCP: u16;
+
+ /// Return the new calculated Rank, based on information from the parent.
+ fn rank(current_rank: Rank, parent_rank: Rank) -> Rank;
+
+ /// Return the preferred parent from a given parent set.
+ fn preferred_parent(parent_set: &ParentSet) -> Option<&Parent>;
+}
+
+impl ObjectiveFunction0 {
+ const OCP: u16 = 0;
+
+ const RANK_STRETCH: u16 = 0;
+ const RANK_FACTOR: u16 = 1;
+ const RANK_STEP: u16 = 3;
+
+ fn rank_increase(parent_rank: Rank) -> u16 {
+ (Self::RANK_FACTOR * Self::RANK_STEP + Self::RANK_STRETCH)
+ * parent_rank.min_hop_rank_increase
+ }
+}
+
+impl ObjectiveFunction for ObjectiveFunction0 {
+ const OCP: u16 = 0;
+
+ fn rank(_: Rank, parent_rank: Rank) -> Rank {
+ assert_ne!(parent_rank, Rank::INFINITE);
+
+ Rank::new(
+ parent_rank.value + Self::rank_increase(parent_rank),
+ parent_rank.min_hop_rank_increase,
+ )
+ }
+
+ fn preferred_parent(parent_set: &ParentSet) -> Option<&Parent> {
+ let mut pref_parent: Option<&Parent> = None;
+
+ for (_, parent) in parent_set.parents() {
+ if pref_parent.is_none() || parent.rank() < pref_parent.unwrap().rank() {
+ pref_parent = Some(parent);
+ }
+ }
+
+ pref_parent
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::iface::rpl::consts::DEFAULT_MIN_HOP_RANK_INCREASE;
+
+ use super::*;
+
+ #[test]
+ fn rank_increase() {
+ // 256 (root) + 3 * 256
+ assert_eq!(
+ ObjectiveFunction0::rank(Rank::INFINITE, Rank::ROOT),
+ Rank::new(256 + 3 * 256, DEFAULT_MIN_HOP_RANK_INCREASE)
+ );
+
+ // 1024 + 3 * 256
+ assert_eq!(
+ ObjectiveFunction0::rank(
+ Rank::INFINITE,
+ Rank::new(1024, DEFAULT_MIN_HOP_RANK_INCREASE)
+ ),
+ Rank::new(1024 + 3 * 256, DEFAULT_MIN_HOP_RANK_INCREASE)
+ );
+ }
+
+ #[test]
+ #[should_panic]
+ fn rank_increase_infinite() {
+ assert_eq!(
+ ObjectiveFunction0::rank(Rank::INFINITE, Rank::INFINITE),
+ Rank::INFINITE
+ );
+ }
+
+ #[test]
+ fn empty_set() {
+ assert_eq!(
+ ObjectiveFunction0::preferred_parent(&ParentSet::default()),
+ None
+ );
+ }
+
+ #[test]
+ fn non_empty_set() {
+ use crate::wire::Ipv6Address;
+
+ let mut parents = ParentSet::default();
+
+ parents.add(
+ Ipv6Address::default(),
+ Parent::new(0, Rank::ROOT, Default::default(), Ipv6Address::default()),
+ );
+
+ let mut address = Ipv6Address::default();
+ address.0[15] = 1;
+
+ parents.add(
+ address,
+ Parent::new(
+ 0,
+ Rank::new(1024, DEFAULT_MIN_HOP_RANK_INCREASE),
+ Default::default(),
+ Ipv6Address::default(),
+ ),
+ );
+
+ assert_eq!(
+ ObjectiveFunction0::preferred_parent(&parents),
+ Some(&Parent::new(
+ 0,
+ Rank::ROOT,
+ Default::default(),
+ Ipv6Address::default(),
+ ))
+ );
+ }
+}
diff --git a/src/iface/rpl/parents.rs b/src/iface/rpl/parents.rs
new file mode 100644
index 0000000..70d5a5e
--- /dev/null
+++ b/src/iface/rpl/parents.rs
@@ -0,0 +1,176 @@
+use crate::wire::Ipv6Address;
+
+use super::{lollipop::SequenceCounter, rank::Rank};
+use crate::config::RPL_PARENTS_BUFFER_COUNT;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) struct Parent {
+ rank: Rank,
+ preference: u8,
+ version_number: SequenceCounter,
+ dodag_id: Ipv6Address,
+}
+
+impl Parent {
+ /// Create a new parent.
+ pub(crate) fn new(
+ preference: u8,
+ rank: Rank,
+ version_number: SequenceCounter,
+ dodag_id: Ipv6Address,
+ ) -> Self {
+ Self {
+ rank,
+ preference,
+ version_number,
+ dodag_id,
+ }
+ }
+
+ /// Return the Rank of the parent.
+ pub(crate) fn rank(&self) -> &Rank {
+ &self.rank
+ }
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct ParentSet {
+ parents: heapless::LinearMap<Ipv6Address, Parent, { RPL_PARENTS_BUFFER_COUNT }>,
+}
+
+impl ParentSet {
+ /// Add a new parent to the parent set. The Rank of the new parent should be lower than the
+ /// Rank of the node that holds this parent set.
+ pub(crate) fn add(&mut self, address: Ipv6Address, parent: Parent) {
+ if let Some(p) = self.parents.get_mut(&address) {
+ *p = parent;
+ } else if let Err(p) = self.parents.insert(address, parent) {
+ if let Some((w_a, w_p)) = self.worst_parent() {
+ if w_p.rank.dag_rank() > parent.rank.dag_rank() {
+ self.parents.remove(&w_a.clone()).unwrap();
+ self.parents.insert(address, parent).unwrap();
+ } else {
+ net_debug!("could not add {} to parent set, buffer is full", address);
+ }
+ } else {
+ unreachable!()
+ }
+ }
+ }
+
+ /// Find a parent based on its address.
+ pub(crate) fn find(&self, address: &Ipv6Address) -> Option<&Parent> {
+ self.parents.get(address)
+ }
+
+ /// Find a mutable parent based on its address.
+ pub(crate) fn find_mut(&mut self, address: &Ipv6Address) -> Option<&mut Parent> {
+ self.parents.get_mut(address)
+ }
+
+ /// Return a slice to the parent set.
+ pub(crate) fn parents(&self) -> impl Iterator<Item = (&Ipv6Address, &Parent)> {
+ self.parents.iter()
+ }
+
+ /// Find the worst parent that is currently in the parent set.
+ fn worst_parent(&self) -> Option<(&Ipv6Address, &Parent)> {
+ self.parents.iter().max_by_key(|(k, v)| v.rank.dag_rank())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn add_parent() {
+ let mut set = ParentSet::default();
+ set.add(
+ Default::default(),
+ Parent::new(0, Rank::ROOT, Default::default(), Default::default()),
+ );
+
+ assert_eq!(
+ set.find(&Default::default()),
+ Some(&Parent::new(
+ 0,
+ Rank::ROOT,
+ Default::default(),
+ Default::default()
+ ))
+ );
+ }
+
+ #[test]
+ fn add_more_parents() {
+ use super::super::consts::DEFAULT_MIN_HOP_RANK_INCREASE;
+ let mut set = ParentSet::default();
+
+ let mut last_address = Default::default();
+ for i in 0..RPL_PARENTS_BUFFER_COUNT {
+ let i = i as u16;
+ let mut address = Ipv6Address::default();
+ address.0[15] = i as u8;
+ last_address = address;
+
+ set.add(
+ address,
+ Parent::new(
+ 0,
+ Rank::new(256 * i, DEFAULT_MIN_HOP_RANK_INCREASE),
+ Default::default(),
+ address,
+ ),
+ );
+
+ assert_eq!(
+ set.find(&address),
+ Some(&Parent::new(
+ 0,
+ Rank::new(256 * i, DEFAULT_MIN_HOP_RANK_INCREASE),
+ Default::default(),
+ address,
+ ))
+ );
+ }
+
+ // This one is not added to the set, because its Rank is worse than any other parent in the
+ // set.
+ let mut address = Ipv6Address::default();
+ address.0[15] = 8;
+ set.add(
+ address,
+ Parent::new(
+ 0,
+ Rank::new(256 * 8, DEFAULT_MIN_HOP_RANK_INCREASE),
+ Default::default(),
+ address,
+ ),
+ );
+ assert_eq!(set.find(&address), None);
+
+ /// This Parent has a better rank than the last one in the set.
+ let mut address = Ipv6Address::default();
+ address.0[15] = 9;
+ set.add(
+ address,
+ Parent::new(
+ 0,
+ Rank::new(0, DEFAULT_MIN_HOP_RANK_INCREASE),
+ Default::default(),
+ address,
+ ),
+ );
+ assert_eq!(
+ set.find(&address),
+ Some(&Parent::new(
+ 0,
+ Rank::new(0, DEFAULT_MIN_HOP_RANK_INCREASE),
+ Default::default(),
+ address
+ ))
+ );
+ assert_eq!(set.find(&last_address), None);
+ }
+}
diff --git a/src/iface/rpl/rank.rs b/src/iface/rpl/rank.rs
new file mode 100644
index 0000000..02a5ecf
--- /dev/null
+++ b/src/iface/rpl/rank.rs
@@ -0,0 +1,104 @@
+//! Implementation of the Rank comparison in RPL.
+//!
+//! A Rank can be thought of as a fixed-point number, where the position of the radix point between
+//! the integer part and the fractional part is determined by `MinHopRankIncrease`.
+//! `MinHopRankIncrease` is the minimum increase in Rank between a node and any of its DODAG
+//! parents.
+//! This value is provisined by the DODAG root.
+//!
+//! When Rank is compared, the integer portion of the Rank is to be used.
+//!
+//! Meaning of the comparison:
+//! - **Rank M is less than Rank N**: the position of M is closer to the DODAG root than the position
+//! of N. Node M may safely be a DODAG parent for node N.
+//! - **Ranks are equal**: the positions of both nodes within the DODAG and with respect to the DODAG
+//! are similar or identical. Routing through a node with equal Rank may cause a routing loop.
+//! - **Rank M is greater than Rank N**: the position of node M is farther from the DODAG root
+//! than the position of N. Node M may in fact be in the sub-DODAG of node N. If node N selects
+//! node M as a DODAG parent, there is a risk of creating a loop.
+
+use super::consts::DEFAULT_MIN_HOP_RANK_INCREASE;
+
+/// The Rank is the expression of the relative position within a DODAG Version with regard to
+/// neighbors, and it is not necessarily a good indication or a proper expression of a distance or
+/// a path cost to the root.
+#[derive(Debug, Clone, Copy, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Rank {
+ pub(super) value: u16,
+ pub(super) min_hop_rank_increase: u16,
+}
+
+impl core::fmt::Display for Rank {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ write!(f, "Rank({})", self.dag_rank())
+ }
+}
+
+impl Rank {
+ pub const INFINITE: Self = Rank::new(0xffff, DEFAULT_MIN_HOP_RANK_INCREASE);
+
+ /// The ROOT_RANK is the smallest rank possible.
+ /// DAG_RANK(ROOT_RANK) should be 1. See RFC6550 § 17.
+ pub const ROOT: Self = Rank::new(DEFAULT_MIN_HOP_RANK_INCREASE, DEFAULT_MIN_HOP_RANK_INCREASE);
+
+ /// Create a new Rank from some value and a `MinHopRankIncrease`.
+ /// The `MinHopRankIncrease` is used for calculating the integer part for comparing to other
+ /// Ranks.
+ pub const fn new(value: u16, min_hop_rank_increase: u16) -> Self {
+ assert!(min_hop_rank_increase > 0);
+
+ Self {
+ value,
+ min_hop_rank_increase,
+ }
+ }
+
+ /// Return the integer part of the Rank.
+ pub fn dag_rank(&self) -> u16 {
+ self.value / self.min_hop_rank_increase
+ }
+
+ /// Return the raw Rank value.
+ pub fn raw_value(&self) -> u16 {
+ self.value
+ }
+}
+
+impl PartialEq for Rank {
+ fn eq(&self, other: &Self) -> bool {
+ self.dag_rank() == other.dag_rank()
+ }
+}
+
+impl PartialOrd for Rank {
+ fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+ self.dag_rank().partial_cmp(&other.dag_rank())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn calculate_rank() {
+ let r = Rank::new(27, 16);
+ assert_eq!(r.dag_rank(), 1)
+ }
+
+ #[test]
+ fn comparison() {
+ let r1 = Rank::ROOT;
+ let r2 = Rank::new(16, 16);
+ assert!(r1 == r2);
+
+ let r1 = Rank::new(16, 16);
+ let r2 = Rank::new(32, 16);
+ assert!(r1 < r2);
+
+ let r1 = Rank::ROOT;
+ let r2 = Rank::INFINITE;
+ assert!(r1 < r2);
+ }
+}
diff --git a/src/iface/rpl/relations.rs b/src/iface/rpl/relations.rs
new file mode 100644
index 0000000..da02a3c
--- /dev/null
+++ b/src/iface/rpl/relations.rs
@@ -0,0 +1,162 @@
+use crate::time::Instant;
+use crate::wire::Ipv6Address;
+
+use crate::config::RPL_RELATIONS_BUFFER_COUNT;
+
+#[derive(Debug)]
+pub struct Relation {
+ destination: Ipv6Address,
+ next_hop: Ipv6Address,
+ expiration: Instant,
+}
+
+#[derive(Default, Debug)]
+pub struct Relations {
+ relations: heapless::Vec<Relation, { RPL_RELATIONS_BUFFER_COUNT }>,
+}
+
+impl Relations {
+ /// Add a new relation to the buffer. If there was already a relation in the buffer, then
+ /// update it.
+ pub fn add_relation(
+ &mut self,
+ destination: Ipv6Address,
+ next_hop: Ipv6Address,
+ expiration: Instant,
+ ) {
+ if let Some(r) = self
+ .relations
+ .iter_mut()
+ .find(|r| r.destination == destination)
+ {
+ r.next_hop = next_hop;
+ r.expiration = expiration;
+ } else {
+ let relation = Relation {
+ destination,
+ next_hop,
+ expiration,
+ };
+
+ if let Err(e) = self.relations.push(relation) {
+ net_debug!("Unable to add relation, buffer is full");
+ }
+ }
+ }
+
+ /// Remove all relation entries for a specific destination.
+ pub fn remove_relation(&mut self, destination: Ipv6Address) {
+ self.relations.retain(|r| r.destination != destination)
+ }
+
+ /// Return the next hop for a specific IPv6 address, if there is one.
+ pub fn find_next_hop(&mut self, destination: Ipv6Address) -> Option<Ipv6Address> {
+ self.relations.iter().find_map(|r| {
+ if r.destination == destination {
+ Some(r.next_hop)
+ } else {
+ None
+ }
+ })
+ }
+
+ /// Purge expired relations.
+ pub fn purge(&mut self, now: Instant) {
+ self.relations.retain(|r| r.expiration > now)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::time::Duration;
+
+ fn addresses(count: usize) -> Vec<Ipv6Address> {
+ (0..count)
+ .map(|i| {
+ let mut ip = Ipv6Address::default();
+ ip.0[0] = i as u8;
+ ip
+ })
+ .collect()
+ }
+
+ #[test]
+ fn add_relation() {
+ let addrs = addresses(2);
+
+ let mut relations = Relations::default();
+ relations.add_relation(addrs[0], addrs[1], Instant::now());
+ assert_eq!(relations.relations.len(), 1);
+ }
+
+ #[test]
+ fn add_relations_full_buffer() {
+ let addrs = addresses(crate::config::RPL_RELATIONS_BUFFER_COUNT + 1);
+
+ // Try to add RPL_RELATIONS_BUFFER_COUNT + 1 to the buffer.
+ // The size of the buffer should still be RPL_RELATIONS_BUFFER_COUNT.
+ let mut relations = Relations::default();
+ for a in addrs {
+ relations.add_relation(a, a, Instant::now());
+ }
+
+ assert_eq!(relations.relations.len(), RPL_RELATIONS_BUFFER_COUNT);
+ }
+
+ #[test]
+ fn update_relation() {
+ let addrs = addresses(3);
+
+ let mut relations = Relations::default();
+ relations.add_relation(addrs[0], addrs[1], Instant::now());
+ assert_eq!(relations.relations.len(), 1);
+
+ relations.add_relation(addrs[0], addrs[2], Instant::now());
+ assert_eq!(relations.relations.len(), 1);
+
+ assert_eq!(relations.find_next_hop(addrs[0]), Some(addrs[2]));
+ }
+
+ #[test]
+ fn find_next_hop() {
+ let addrs = addresses(3);
+
+ let mut relations = Relations::default();
+ relations.add_relation(addrs[0], addrs[1], Instant::now());
+ assert_eq!(relations.relations.len(), 1);
+ assert_eq!(relations.find_next_hop(addrs[0]), Some(addrs[1]));
+
+ relations.add_relation(addrs[0], addrs[2], Instant::now());
+ assert_eq!(relations.relations.len(), 1);
+ assert_eq!(relations.find_next_hop(addrs[0]), Some(addrs[2]));
+
+ // Find the next hop of a destination not in the buffer.
+ assert_eq!(relations.find_next_hop(addrs[1]), None);
+ }
+
+ #[test]
+ fn remove_relation() {
+ let addrs = addresses(2);
+
+ let mut relations = Relations::default();
+ relations.add_relation(addrs[0], addrs[1], Instant::now());
+ assert_eq!(relations.relations.len(), 1);
+
+ relations.remove_relation(addrs[0]);
+ assert!(relations.relations.is_empty());
+ }
+
+ #[test]
+ fn purge_relation() {
+ let addrs = addresses(2);
+
+ let mut relations = Relations::default();
+ relations.add_relation(addrs[0], addrs[1], Instant::now() - Duration::from_secs(1));
+
+ assert_eq!(relations.relations.len(), 1);
+
+ relations.purge(Instant::now());
+ assert!(relations.relations.is_empty());
+ }
+}
diff --git a/src/iface/rpl/trickle.rs b/src/iface/rpl/trickle.rs
new file mode 100644
index 0000000..a5b3b97
--- /dev/null
+++ b/src/iface/rpl/trickle.rs
@@ -0,0 +1,266 @@
+//! Implementation of the Trickle timer defined in [RFC 6206]. The algorithm allows node in a lossy
+//! shared medium to exchange information in a highly robust, energy efficient, simple, and
+//! scalable manner. Dynamically adjusting transmission windows allows Trickle to spread new
+//! information fast while sending only a few messages per hour when information does not change.
+//!
+//! **NOTE**: the constants used for the default Trickle timer are the ones from the [Enhanced
+//! Trickle].
+//!
+//! [RFC 6206]: https://datatracker.ietf.org/doc/html/rfc6206
+//! [Enhanced Trickle]: https://d1wqtxts1xzle7.cloudfront.net/71402623/E-Trickle_Enhanced_Trickle_Algorithm_for20211005-2078-1ckh34a.pdf?1633439582=&response-content-disposition=inline%3B+filename%3DE_Trickle_Enhanced_Trickle_Algorithm_for.pdf&Expires=1681472005&Signature=cC7l-Pyr5r64XBNCDeSJ2ha6oqWUtO6A-KlDOyC0UVaHxDV3h3FuVHRtcNp3O9BUfRK8jeuWCYGBkCZgQT4Zgb6XwgVB-3z4TF9o3qBRMteRyYO5vjVkpPBeN7mz4Tl746SsSCHDm2NMtr7UVtLYamriU3D0rryoqLqJXmnkNoJpn~~wJe2H5PmPgIwixTwSvDkfFLSVoESaYS9ZWHZwbW-7G7OxIw8oSYhx9xMBnzkpdmT7sJNmvDzTUhoOjYrHTRM23cLVS9~oOSpT7hKtKD4h5CSmrNK4st07KnT9~tUqEcvGO3aXdd4quRZeKUcCkCbTLvhOEYg9~QqgD8xwhA__&Key-Pair-Id=APKAJLOHF5GGSLRBV4ZA
+
+use crate::{
+ rand::Rand,
+ time::{Duration, Instant},
+};
+
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub(crate) struct TrickleTimer {
+ i_min: u32,
+ i_max: u32,
+ k: usize,
+
+ i: Duration,
+ t: Duration,
+ t_exp: Instant,
+ i_exp: Instant,
+ counter: usize,
+}
+
+impl TrickleTimer {
+ /// Creat a new Trickle timer using the default values.
+ ///
+ /// **NOTE**: the standard defines I as a random value between [Imin, Imax]. However, this
+ /// could result in a t value that is very close to Imax. Therefore, sending DIO messages will
+ /// be sporadic, which is not ideal when a network is started. It might take a long time before
+ /// the network is actually stable. Therefore, we don't draw a random numberm but just use Imin
+ /// for I. This only affects the start of the RPL tree and speeds up building it. Also, we
+ /// don't use the default values from the standard, but the values from the _Enhanced Trickle
+ /// Algorithm for Low-Power and Lossy Networks_ from Baraq Ghaleb et al. This is also what the
+ /// Contiki Trickle timer does.
+ pub(crate) fn default(now: Instant, rand: &mut Rand) -> Self {
+ use super::consts::{
+ DEFAULT_DIO_INTERVAL_DOUBLINGS, DEFAULT_DIO_INTERVAL_MIN,
+ DEFAULT_DIO_REDUNDANCY_CONSTANT,
+ };
+
+ Self::new(
+ DEFAULT_DIO_INTERVAL_MIN,
+ DEFAULT_DIO_INTERVAL_MIN + DEFAULT_DIO_INTERVAL_DOUBLINGS,
+ DEFAULT_DIO_REDUNDANCY_CONSTANT,
+ now,
+ rand,
+ )
+ }
+
+ /// Create a new Trickle timer.
+ pub(crate) fn new(i_min: u32, i_max: u32, k: usize, now: Instant, rand: &mut Rand) -> Self {
+ let mut timer = Self {
+ i_min,
+ i_max,
+ k,
+ i: Duration::ZERO,
+ t: Duration::ZERO,
+ t_exp: Instant::ZERO,
+ i_exp: Instant::ZERO,
+ counter: 0,
+ };
+
+ timer.i = Duration::from_millis(2u32.pow(timer.i_min) as u64);
+ timer.i_exp = now + timer.i;
+ timer.counter = 0;
+
+ timer.set_t(now, rand);
+
+ timer
+ }
+
+ /// Poll the Trickle timer. Returns `true` when the Trickle timer signals that a message can be
+ /// transmitted. This happens when the Trickle timer expires.
+ pub(crate) fn poll(&mut self, now: Instant, rand: &mut Rand) -> bool {
+ let can_transmit = self.can_transmit() && self.t_expired(now);
+
+ if can_transmit {
+ self.set_t(now, rand);
+ }
+
+ if self.i_expired(now) {
+ self.expire(now, rand);
+ }
+
+ can_transmit
+ }
+
+ /// Returns the Instant at which the Trickle timer should be polled again. Polling the Trickle
+ /// timer before this Instant is not harmfull, however, polling after it is not correct.
+ pub(crate) fn poll_at(&self) -> Instant {
+ self.t_exp.min(self.i_exp)
+ }
+
+ /// Signal the Trickle timer that a consistency has been heard, and thus increasing it's
+ /// counter.
+ pub(crate) fn hear_consistent(&mut self) {
+ self.counter += 1;
+ }
+
+ /// Signal the Trickle timer that an inconsistency has been heard. This resets the Trickle
+ /// timer when the current interval is not the smallest possible.
+ pub(crate) fn hear_inconsistency(&mut self, now: Instant, rand: &mut Rand) {
+ let i = Duration::from_millis(2u32.pow(self.i_min) as u64);
+ if self.i > i {
+ self.reset(i, now, rand);
+ }
+ }
+
+ /// Check if the Trickle timer can transmit or not. Returns `false` when the consistency
+ /// counter is bigger or equal to the default consistency constant.
+ pub(crate) fn can_transmit(&self) -> bool {
+ self.k != 0 && self.counter < self.k
+ }
+
+ /// Reset the Trickle timer when the interval has expired.
+ fn expire(&mut self, now: Instant, rand: &mut Rand) {
+ let max_interval = Duration::from_millis(2u32.pow(self.i_max) as u64);
+ let i = if self.i >= max_interval {
+ max_interval
+ } else {
+ self.i + self.i
+ };
+
+ self.reset(i, now, rand);
+ }
+
+ pub(crate) fn reset(&mut self, i: Duration, now: Instant, rand: &mut Rand) {
+ self.i = i;
+ self.i_exp = now + self.i;
+ self.counter = 0;
+ self.set_t(now, rand);
+ }
+
+ pub(crate) const fn max_expiration(&self) -> Duration {
+ Duration::from_millis(2u32.pow(self.i_max) as u64)
+ }
+
+ pub(crate) const fn min_expiration(&self) -> Duration {
+ Duration::from_millis(2u32.pow(self.i_min) as u64)
+ }
+
+ fn set_t(&mut self, now: Instant, rand: &mut Rand) {
+ let t = Duration::from_micros(
+ self.i.total_micros() / 2
+ + (rand.rand_u32() as u64
+ % (self.i.total_micros() - self.i.total_micros() / 2 + 1)),
+ );
+
+ self.t = t;
+ self.t_exp = now + t;
+ }
+
+ fn t_expired(&self, now: Instant) -> bool {
+ now >= self.t_exp
+ }
+
+ fn i_expired(&self, now: Instant) -> bool {
+ now >= self.i_exp
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn trickle_timer_intervals() {
+ let mut rand = Rand::new(1234);
+ let mut now = Instant::ZERO;
+ let mut trickle = TrickleTimer::default(now, &mut rand);
+
+ let mut previous_i = trickle.i;
+
+ while now <= Instant::from_secs(100_000) {
+ trickle.poll(now, &mut rand);
+
+ if now < Instant::ZERO + trickle.max_expiration() {
+ // t should always be inbetween I/2 and I.
+ assert!(trickle.i / 2 < trickle.t);
+ assert!(trickle.i > trickle.t);
+ }
+
+ if previous_i != trickle.i {
+ // When a new Interval is selected, this should be double the previous one.
+ assert_eq!(previous_i * 2, trickle.i);
+ assert_eq!(trickle.counter, 0);
+ previous_i = trickle.i;
+ }
+
+ now += Duration::from_millis(100);
+ }
+ }
+
+ #[test]
+ fn trickle_timer_hear_inconsistency() {
+ let mut rand = Rand::new(1234);
+ let mut now = Instant::ZERO;
+ let mut trickle = TrickleTimer::default(now, &mut rand);
+
+ trickle.counter = 1;
+
+ while now <= Instant::from_secs(10_000) {
+ trickle.poll(now, &mut rand);
+
+ if now < trickle.i_exp && now < Instant::ZERO + trickle.min_expiration() {
+ assert_eq!(trickle.counter, 1);
+ } else {
+ // The first interval expired, so the counter is reset.
+ assert_eq!(trickle.counter, 0);
+ }
+
+ if now == Instant::from_secs(10) {
+ // We set the counter to 1 such that we can test the `hear_inconsistency`.
+ trickle.counter = 1;
+
+ assert_eq!(trickle.counter, 1);
+
+ trickle.hear_inconsistency(now, &mut rand);
+
+ assert_eq!(trickle.counter, 0);
+ assert_eq!(trickle.i, trickle.min_expiration());
+ }
+
+ now += Duration::from_millis(100);
+ }
+ }
+
+ #[test]
+ fn trickle_timer_hear_consistency() {
+ let mut rand = Rand::new(1234);
+ let mut now = Instant::ZERO;
+ let mut trickle = TrickleTimer::default(now, &mut rand);
+
+ trickle.counter = 1;
+
+ let mut transmit_counter = 0;
+
+ while now <= Instant::from_secs(10_000) {
+ trickle.hear_consistent();
+
+ if trickle.poll(now, &mut rand) {
+ transmit_counter += 1;
+ }
+
+ if now == Instant::from_secs(10_000) {
+ use super::super::consts::{
+ DEFAULT_DIO_INTERVAL_DOUBLINGS, DEFAULT_DIO_REDUNDANCY_CONSTANT,
+ };
+ assert!(!trickle.poll(now, &mut rand));
+ assert!(trickle.counter > DEFAULT_DIO_REDUNDANCY_CONSTANT);
+ // We should never have transmitted since the counter was higher than the default
+ // redundancy constant.
+ assert_eq!(transmit_counter, 0);
+ }
+
+ now += Duration::from_millis(100);
+ }
+ }
+}
diff --git a/src/iface/socket_meta.rs b/src/iface/socket_meta.rs
new file mode 100644
index 0000000..82c9908
--- /dev/null
+++ b/src/iface/socket_meta.rs
@@ -0,0 +1,103 @@
+use super::SocketHandle;
+use crate::{
+ socket::PollAt,
+ time::{Duration, Instant},
+ wire::IpAddress,
+};
+
+/// Neighbor dependency.
+///
+/// This enum tracks whether the socket should be polled based on the neighbor
+/// it is going to send packets to.
+#[derive(Debug, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+enum NeighborState {
+ /// Socket can be polled immediately.
+ #[default]
+ Active,
+ /// Socket should not be polled until either `silent_until` passes or
+ /// `neighbor` appears in the neighbor cache.
+ Waiting {
+ neighbor: IpAddress,
+ silent_until: Instant,
+ },
+}
+
+/// Network socket metadata.
+///
+/// This includes things that only external (to the socket, that is) code
+/// is interested in, but which are more conveniently stored inside the socket
+/// itself.
+#[derive(Debug, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub(crate) struct Meta {
+ /// Handle of this socket within its enclosing `SocketSet`.
+ /// Mainly useful for debug output.
+ pub(crate) handle: SocketHandle,
+ /// See [NeighborState](struct.NeighborState.html).
+ neighbor_state: NeighborState,
+}
+
+impl Meta {
+ /// Minimum delay between neighbor discovery requests for this particular
+ /// socket, in milliseconds.
+ ///
+ /// See also `iface::NeighborCache::SILENT_TIME`.
+ pub(crate) const DISCOVERY_SILENT_TIME: Duration = Duration::from_millis(1_000);
+
+ pub(crate) fn poll_at<F>(&self, socket_poll_at: PollAt, has_neighbor: F) -> PollAt
+ where
+ F: Fn(IpAddress) -> bool,
+ {
+ match self.neighbor_state {
+ NeighborState::Active => socket_poll_at,
+ NeighborState::Waiting { neighbor, .. } if has_neighbor(neighbor) => socket_poll_at,
+ NeighborState::Waiting { silent_until, .. } => PollAt::Time(silent_until),
+ }
+ }
+
+ pub(crate) fn egress_permitted<F>(&mut self, timestamp: Instant, has_neighbor: F) -> bool
+ where
+ F: Fn(IpAddress) -> bool,
+ {
+ match self.neighbor_state {
+ NeighborState::Active => true,
+ NeighborState::Waiting {
+ neighbor,
+ silent_until,
+ } => {
+ if has_neighbor(neighbor) {
+ net_trace!(
+ "{}: neighbor {} discovered, unsilencing",
+ self.handle,
+ neighbor
+ );
+ self.neighbor_state = NeighborState::Active;
+ true
+ } else if timestamp >= silent_until {
+ net_trace!(
+ "{}: neighbor {} silence timer expired, rediscovering",
+ self.handle,
+ neighbor
+ );
+ true
+ } else {
+ false
+ }
+ }
+ }
+ }
+
+ pub(crate) fn neighbor_missing(&mut self, timestamp: Instant, neighbor: IpAddress) {
+ net_trace!(
+ "{}: neighbor {} missing, silencing until t+{}",
+ self.handle,
+ neighbor,
+ Self::DISCOVERY_SILENT_TIME
+ );
+ self.neighbor_state = NeighborState::Waiting {
+ neighbor,
+ silent_until: timestamp + Self::DISCOVERY_SILENT_TIME,
+ };
+ }
+}
diff --git a/src/iface/socket_set.rs b/src/iface/socket_set.rs
new file mode 100644
index 0000000..be55fef
--- /dev/null
+++ b/src/iface/socket_set.rs
@@ -0,0 +1,151 @@
+use core::fmt;
+use managed::ManagedSlice;
+
+use super::socket_meta::Meta;
+use crate::socket::{AnySocket, Socket};
+
+/// Opaque struct with space for storing one socket.
+///
+/// This is public so you can use it to allocate space for storing
+/// sockets when creating an Interface.
+#[derive(Debug, Default)]
+pub struct SocketStorage<'a> {
+ inner: Option<Item<'a>>,
+}
+
+impl<'a> SocketStorage<'a> {
+ pub const EMPTY: Self = Self { inner: None };
+}
+
+/// An item of a socket set.
+#[derive(Debug)]
+pub(crate) struct Item<'a> {
+ pub(crate) meta: Meta,
+ pub(crate) socket: Socket<'a>,
+}
+
+/// A handle, identifying a socket in an Interface.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct SocketHandle(usize);
+
+impl fmt::Display for SocketHandle {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "#{}", self.0)
+ }
+}
+
+/// An extensible set of sockets.
+///
+/// The lifetime `'a` is used when storing a `Socket<'a>`. If you're using
+/// owned buffers for your sockets (passed in as `Vec`s) you can use
+/// `SocketSet<'static>`.
+#[derive(Debug)]
+pub struct SocketSet<'a> {
+ sockets: ManagedSlice<'a, SocketStorage<'a>>,
+}
+
+impl<'a> SocketSet<'a> {
+ /// Create a socket set using the provided storage.
+ pub fn new<SocketsT>(sockets: SocketsT) -> SocketSet<'a>
+ where
+ SocketsT: Into<ManagedSlice<'a, SocketStorage<'a>>>,
+ {
+ let sockets = sockets.into();
+ SocketSet { sockets }
+ }
+
+ /// Add a socket to the set, and return its handle.
+ ///
+ /// # Panics
+ /// This function panics if the storage is fixed-size (not a `Vec`) and is full.
+ pub fn add<T: AnySocket<'a>>(&mut self, socket: T) -> SocketHandle {
+ fn put<'a>(index: usize, slot: &mut SocketStorage<'a>, socket: Socket<'a>) -> SocketHandle {
+ net_trace!("[{}]: adding", index);
+ let handle = SocketHandle(index);
+ let mut meta = Meta::default();
+ meta.handle = handle;
+ *slot = SocketStorage {
+ inner: Some(Item { meta, socket }),
+ };
+ handle
+ }
+
+ let socket = socket.upcast();
+
+ for (index, slot) in self.sockets.iter_mut().enumerate() {
+ if slot.inner.is_none() {
+ return put(index, slot, socket);
+ }
+ }
+
+ match &mut self.sockets {
+ ManagedSlice::Borrowed(_) => panic!("adding a socket to a full SocketSet"),
+ #[cfg(feature = "alloc")]
+ ManagedSlice::Owned(sockets) => {
+ sockets.push(SocketStorage { inner: None });
+ let index = sockets.len() - 1;
+ put(index, &mut sockets[index], socket)
+ }
+ }
+ }
+
+ /// Get a socket from the set by its handle, as mutable.
+ ///
+ /// # Panics
+ /// This function may panic if the handle does not belong to this socket set
+ /// or the socket has the wrong type.
+ pub fn get<T: AnySocket<'a>>(&self, handle: SocketHandle) -> &T {
+ match self.sockets[handle.0].inner.as_ref() {
+ Some(item) => {
+ T::downcast(&item.socket).expect("handle refers to a socket of a wrong type")
+ }
+ None => panic!("handle does not refer to a valid socket"),
+ }
+ }
+
+ /// Get a mutable socket from the set by its handle, as mutable.
+ ///
+ /// # Panics
+ /// This function may panic if the handle does not belong to this socket set
+ /// or the socket has the wrong type.
+ pub fn get_mut<T: AnySocket<'a>>(&mut self, handle: SocketHandle) -> &mut T {
+ match self.sockets[handle.0].inner.as_mut() {
+ Some(item) => T::downcast_mut(&mut item.socket)
+ .expect("handle refers to a socket of a wrong type"),
+ None => panic!("handle does not refer to a valid socket"),
+ }
+ }
+
+ /// Remove a socket from the set, without changing its state.
+ ///
+ /// # Panics
+ /// This function may panic if the handle does not belong to this socket set.
+ pub fn remove(&mut self, handle: SocketHandle) -> Socket<'a> {
+ net_trace!("[{}]: removing", handle.0);
+ match self.sockets[handle.0].inner.take() {
+ Some(item) => item.socket,
+ None => panic!("handle does not refer to a valid socket"),
+ }
+ }
+
+ /// Get an iterator to the inner sockets.
+ pub fn iter(&self) -> impl Iterator<Item = (SocketHandle, &Socket<'a>)> {
+ self.items().map(|i| (i.meta.handle, &i.socket))
+ }
+
+ /// Get a mutable iterator to the inner sockets.
+ pub fn iter_mut(&mut self) -> impl Iterator<Item = (SocketHandle, &mut Socket<'a>)> {
+ self.items_mut().map(|i| (i.meta.handle, &mut i.socket))
+ }
+
+ /// Iterate every socket in this set.
+ pub(crate) fn items(&self) -> impl Iterator<Item = &Item<'a>> + '_ {
+ self.sockets.iter().filter_map(|x| x.inner.as_ref())
+ }
+
+ /// Iterate every socket in this set.
+ pub(crate) fn items_mut(&mut self) -> impl Iterator<Item = &mut Item<'a>> + '_ {
+ self.sockets.iter_mut().filter_map(|x| x.inner.as_mut())
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..040ff57
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,180 @@
+#![cfg_attr(not(any(test, feature = "std")), no_std)]
+#![deny(unsafe_code)]
+
+//! The _smoltcp_ library is built in a layered structure, with the layers corresponding
+//! to the levels of API abstraction. Only the highest layers would be used by a typical
+//! application; however, the goal of _smoltcp_ is not just to provide a simple interface
+//! for writing applications but also to be a toolbox of networking primitives, so
+//! every layer is fully exposed and documented.
+//!
+//! When discussing networking stacks and layering, often the [OSI model][osi] is invoked.
+//! _smoltcp_ makes no effort to conform to the OSI model as it is not applicable to TCP/IP.
+//!
+//! # The socket layer
+//! The socket layer APIs are provided in the module [socket](socket/index.html); currently,
+//! raw, ICMP, TCP, and UDP sockets are provided. The socket API provides the usual primitives,
+//! but necessarily differs in many from the [Berkeley socket API][berk], as the latter was
+//! not designed to be used without heap allocation.
+//!
+//! The socket layer provides the buffering, packet construction and validation, and (for
+//! stateful sockets) the state machines, but it is interface-agnostic. An application must
+//! use sockets together with a network interface.
+//!
+//! # The interface layer
+//! The interface layer APIs are provided in the module [iface](iface/index.html); currently,
+//! Ethernet interface is provided.
+//!
+//! The interface layer handles the control messages, physical addressing and neighbor discovery.
+//! It routes packets to and from sockets.
+//!
+//! # The physical layer
+//! The physical layer APIs are provided in the module [phy](phy/index.html); currently,
+//! raw socket and TAP interface are provided. In addition, two _middleware_ interfaces
+//! are provided: the _tracer device_, which prints a human-readable representation of packets,
+//! and the _fault injector device_, which randomly introduces errors into the transmitted
+//! and received packet sequences.
+//!
+//! The physical layer handles interaction with a platform-specific network device.
+//!
+//! # The wire layers
+//! Unlike the higher layers, the wire layer APIs will not be used by a typical application.
+//! They however are the bedrock of _smoltcp_, and everything else is built on top of them.
+//!
+//! The wire layer APIs are designed by the principle "make illegal states ir-representable".
+//! If a wire layer object can be constructed, then it can also be parsed from or emitted to
+//! a lower level.
+//!
+//! The wire layer APIs also provide _tcpdump_-like pretty printing.
+//!
+//! ## The representation layer
+//! The representation layer APIs are provided in the module [wire].
+//!
+//! The representation layer exists to reduce the state space of raw packets. Raw packets
+//! may be nonsensical in a multitude of ways: invalid checksums, impossible combinations of flags,
+//! pointers to fields out of bounds, meaningless options... Representations shed all that,
+//! as well as any features not supported by _smoltcp_.
+//!
+//! ## The packet layer
+//! The packet layer APIs are also provided in the module [wire].
+//!
+//! The packet layer exists to provide a more structured way to work with packets than
+//! treating them as sequences of octets. It makes no judgement as to content of the packets,
+//! except where necessary to provide safe access to fields, and strives to implement every
+//! feature ever defined, to ensure that, when the representation layer is unable to make sense
+//! of a packet, it is still logged correctly and in full.
+//!
+//! # Minimum Supported Rust Version (MSRV)
+//!
+//! This crate is guaranteed to compile on stable Rust 1.65 and up with any valid set of features.
+//! It *might* compile on older versions but that may change in any new patch release.
+//!
+//! The exception is when using the `defmt` feature, in which case `defmt`'s MSRV applies, which
+//! is higher.
+//!
+//! [wire]: wire/index.html
+//! [osi]: https://en.wikipedia.org/wiki/OSI_model
+//! [berk]: https://en.wikipedia.org/wiki/Berkeley_sockets
+
+/* XXX compiler bug
+#![cfg(not(any(feature = "socket-raw",
+ feature = "socket-udp",
+ feature = "socket-tcp")))]
+compile_error!("at least one socket needs to be enabled"); */
+
+#![allow(clippy::match_like_matches_macro)]
+#![allow(clippy::redundant_field_names)]
+#![allow(clippy::identity_op)]
+#![allow(clippy::option_map_unit_fn)]
+#![allow(clippy::unit_arg)]
+#![allow(clippy::new_without_default)]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+#[cfg(not(any(
+ feature = "proto-ipv4",
+ feature = "proto-ipv6",
+ feature = "proto-sixlowpan"
+)))]
+compile_error!("You must enable at least one of the following features: proto-ipv4, proto-ipv6, proto-sixlowpan");
+
+#[cfg(all(
+ feature = "socket",
+ not(any(
+ feature = "socket-raw",
+ feature = "socket-udp",
+ feature = "socket-tcp",
+ feature = "socket-icmp",
+ feature = "socket-dhcpv4",
+ feature = "socket-dns",
+ ))
+))]
+compile_error!("If you enable the socket feature, you must enable at least one of the following features: socket-raw, socket-udp, socket-tcp, socket-icmp, socket-dhcpv4, socket-dns");
+
+#[cfg(all(
+ feature = "socket",
+ not(any(
+ feature = "medium-ethernet",
+ feature = "medium-ip",
+ feature = "medium-ieee802154",
+ ))
+))]
+compile_error!("If you enable the socket feature, you must enable at least one of the following features: medium-ip, medium-ethernet, medium-ieee802154");
+
+#[cfg(all(feature = "defmt", feature = "log"))]
+compile_error!("You must enable at most one of the following features: defmt, log");
+
+#[macro_use]
+mod macros;
+mod parsers;
+mod rand;
+
+#[cfg(test)]
+pub mod config {
+ #![allow(unused)]
+ pub const ASSEMBLER_MAX_SEGMENT_COUNT: usize = 4;
+ pub const DNS_MAX_NAME_SIZE: usize = 255;
+ pub const DNS_MAX_RESULT_COUNT: usize = 1;
+ pub const DNS_MAX_SERVER_COUNT: usize = 1;
+ pub const FRAGMENTATION_BUFFER_SIZE: usize = 1500;
+ pub const IFACE_MAX_ADDR_COUNT: usize = 8;
+ pub const IFACE_MAX_MULTICAST_GROUP_COUNT: usize = 4;
+ pub const IFACE_MAX_ROUTE_COUNT: usize = 4;
+ pub const IFACE_MAX_SIXLOWPAN_ADDRESS_CONTEXT_COUNT: usize = 4;
+ pub const IFACE_NEIGHBOR_CACHE_COUNT: usize = 3;
+ pub const REASSEMBLY_BUFFER_COUNT: usize = 4;
+ pub const REASSEMBLY_BUFFER_SIZE: usize = 1500;
+ pub const RPL_RELATIONS_BUFFER_COUNT: usize = 16;
+ pub const RPL_PARENTS_BUFFER_COUNT: usize = 8;
+ pub const IPV6_HBH_MAX_OPTIONS: usize = 2;
+}
+
+#[cfg(not(test))]
+pub mod config {
+ #![allow(unused)]
+ include!(concat!(env!("OUT_DIR"), "/config.rs"));
+}
+
+#[cfg(any(
+ feature = "medium-ethernet",
+ feature = "medium-ip",
+ feature = "medium-ieee802154"
+))]
+pub mod iface;
+
+pub mod phy;
+#[cfg(feature = "socket")]
+pub mod socket;
+pub mod storage;
+pub mod time;
+pub mod wire;
+
+#[cfg(all(
+ test,
+ any(
+ feature = "medium-ethernet",
+ feature = "medium-ip",
+ feature = "medium-ieee802154"
+ )
+))]
+mod tests;
diff --git a/src/macros.rs b/src/macros.rs
new file mode 100644
index 0000000..e899d24
--- /dev/null
+++ b/src/macros.rs
@@ -0,0 +1,169 @@
+#[cfg(not(test))]
+#[cfg(feature = "log")]
+macro_rules! net_log {
+ (trace, $($arg:expr),*) => { log::trace!($($arg),*) };
+ (debug, $($arg:expr),*) => { log::debug!($($arg),*) };
+}
+
+#[cfg(test)]
+#[cfg(feature = "log")]
+macro_rules! net_log {
+ (trace, $($arg:expr),*) => { println!($($arg),*) };
+ (debug, $($arg:expr),*) => { println!($($arg),*) };
+}
+
+#[cfg(feature = "defmt")]
+macro_rules! net_log {
+ (trace, $($arg:expr),*) => { defmt::trace!($($arg),*) };
+ (debug, $($arg:expr),*) => { defmt::debug!($($arg),*) };
+}
+
+#[cfg(not(any(feature = "log", feature = "defmt")))]
+macro_rules! net_log {
+ ($level:ident, $($arg:expr),*) => {{ $( let _ = $arg; )* }}
+}
+
+macro_rules! net_trace {
+ ($($arg:expr),*) => (net_log!(trace, $($arg),*));
+}
+
+macro_rules! net_debug {
+ ($($arg:expr),*) => (net_log!(debug, $($arg),*));
+}
+
+macro_rules! enum_with_unknown {
+ (
+ $( #[$enum_attr:meta] )*
+ pub enum $name:ident($ty:ty) {
+ $(
+ $( #[$variant_attr:meta] )*
+ $variant:ident = $value:expr
+ ),+ $(,)?
+ }
+ ) => {
+ #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ $( #[$enum_attr] )*
+ pub enum $name {
+ $(
+ $( #[$variant_attr] )*
+ $variant
+ ),*,
+ Unknown($ty)
+ }
+
+ impl ::core::convert::From<$ty> for $name {
+ fn from(value: $ty) -> Self {
+ match value {
+ $( $value => $name::$variant ),*,
+ other => $name::Unknown(other)
+ }
+ }
+ }
+
+ impl ::core::convert::From<$name> for $ty {
+ fn from(value: $name) -> Self {
+ match value {
+ $( $name::$variant => $value ),*,
+ $name::Unknown(other) => other
+ }
+ }
+ }
+ }
+}
+
+#[cfg(feature = "proto-rpl")]
+macro_rules! get {
+ ($buffer:expr, into: $into:ty, fun: $fun:ident, field: $field:expr $(,)?) => {
+ {
+ <$into>::$fun(&$buffer.as_ref()[$field])
+ }
+ };
+
+ ($buffer:expr, into: $into:ty, field: $field:expr $(,)?) => {
+ get!($buffer, into: $into, field: $field, shift: 0, mask: 0b1111_1111)
+ };
+
+ ($buffer:expr, into: $into:ty, field: $field:expr, mask: $bit_mask:expr $(,)?) => {
+ get!($buffer, into: $into, field: $field, shift: 0, mask: $bit_mask)
+ };
+
+ ($buffer:expr, into: $into:ty, field: $field:expr, shift: $bit_shift:expr, mask: $bit_mask:expr $(,)?) => {
+ {
+ <$into>::from((&$buffer.as_ref()[$field] >> $bit_shift) & $bit_mask)
+ }
+ };
+
+ ($buffer:expr, field: $field:expr $(,)?) => {
+ get!($buffer, field: $field, shift: 0, mask: 0b1111_1111)
+ };
+
+ ($buffer:expr, field: $field:expr, mask: $bit_mask:expr $(,)?) => {
+ get!($buffer, field: $field, shift: 0, mask: $bit_mask)
+ };
+
+ ($buffer:expr, field: $field:expr, shift: $bit_shift:expr, mask: $bit_mask:expr $(,)?)
+ =>
+ {
+ {
+ (&$buffer.as_ref()[$field] >> $bit_shift) & $bit_mask
+ }
+ };
+
+ ($buffer:expr, u16, field: $field:expr $(,)?) => {
+ {
+ NetworkEndian::read_u16(&$buffer.as_ref()[$field])
+ }
+ };
+
+ ($buffer:expr, bool, field: $field:expr, shift: $bit_shift:expr, mask: $bit_mask:expr $(,)?) => {
+ {
+ (($buffer.as_ref()[$field] >> $bit_shift) & $bit_mask) == 0b1
+ }
+ };
+
+ ($buffer:expr, u32, field: $field:expr $(,)?) => {
+ {
+ NetworkEndian::read_u32(&$buffer.as_ref()[$field])
+ }
+ };
+}
+
+#[cfg(feature = "proto-rpl")]
+macro_rules! set {
+ ($buffer:expr, address: $address:ident, field: $field:expr $(,)?) => {{
+ $buffer.as_mut()[$field].copy_from_slice($address.as_bytes());
+ }};
+
+ ($buffer:expr, $value:ident, field: $field:expr $(,)?) => {
+ set!($buffer, $value, field: $field, shift: 0, mask: 0b1111_1111)
+ };
+
+ ($buffer:expr, $value:ident, field: $field:expr, mask: $bit_mask:expr $(,)?) => {
+ set!($buffer, $value, field: $field, shift: 0, mask: $bit_mask)
+ };
+
+ ($buffer:expr, $value:ident, field: $field:expr, shift: $bit_shift:expr, mask: $bit_mask:expr $(,)?) => {{
+ let raw =
+ ($buffer.as_ref()[$field] & !($bit_mask << $bit_shift)) | ($value << $bit_shift);
+ $buffer.as_mut()[$field] = raw;
+ }};
+
+ ($buffer:expr, $value:ident, bool, field: $field:expr, mask: $bit_mask:expr $(,)?) => {
+ set!($buffer, $value, bool, field: $field, shift: 0, mask: $bit_mask);
+ };
+
+ ($buffer:expr, $value:ident, bool, field: $field:expr, shift: $bit_shift:expr, mask: $bit_mask:expr $(,)?) => {{
+ let raw = ($buffer.as_ref()[$field] & !($bit_mask << $bit_shift))
+ | (if $value { 0b1 } else { 0b0 } << $bit_shift);
+ $buffer.as_mut()[$field] = raw;
+ }};
+
+ ($buffer:expr, $value:ident, u16, field: $field:expr $(,)?) => {{
+ NetworkEndian::write_u16(&mut $buffer.as_mut()[$field], $value);
+ }};
+
+ ($buffer:expr, $value:ident, u32, field: $field:expr $(,)?) => {{
+ NetworkEndian::write_u32(&mut $buffer.as_mut()[$field], $value);
+ }};
+}
diff --git a/src/parsers.rs b/src/parsers.rs
new file mode 100644
index 0000000..16419ab
--- /dev/null
+++ b/src/parsers.rs
@@ -0,0 +1,765 @@
+#![cfg_attr(
+ not(all(feature = "proto-ipv6", feature = "proto-ipv4")),
+ allow(dead_code)
+)]
+
+use core::result;
+use core::str::FromStr;
+
+#[cfg(feature = "medium-ethernet")]
+use crate::wire::EthernetAddress;
+use crate::wire::{IpAddress, IpCidr, IpEndpoint};
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::{Ipv4Address, Ipv4Cidr};
+#[cfg(feature = "proto-ipv6")]
+use crate::wire::{Ipv6Address, Ipv6Cidr};
+
+type Result<T> = result::Result<T, ()>;
+
+struct Parser<'a> {
+ data: &'a [u8],
+ pos: usize,
+}
+
+impl<'a> Parser<'a> {
+ fn new(data: &'a str) -> Parser<'a> {
+ Parser {
+ data: data.as_bytes(),
+ pos: 0,
+ }
+ }
+
+ fn lookahead_char(&self, ch: u8) -> bool {
+ if self.pos < self.data.len() {
+ self.data[self.pos] == ch
+ } else {
+ false
+ }
+ }
+
+ fn advance(&mut self) -> Result<u8> {
+ match self.data.get(self.pos) {
+ Some(&chr) => {
+ self.pos += 1;
+ Ok(chr)
+ }
+ None => Err(()),
+ }
+ }
+
+ fn try_do<F, T>(&mut self, f: F) -> Option<T>
+ where
+ F: FnOnce(&mut Parser<'a>) -> Result<T>,
+ {
+ let pos = self.pos;
+ match f(self) {
+ Ok(res) => Some(res),
+ Err(()) => {
+ self.pos = pos;
+ None
+ }
+ }
+ }
+
+ fn accept_eof(&mut self) -> Result<()> {
+ if self.data.len() == self.pos {
+ Ok(())
+ } else {
+ Err(())
+ }
+ }
+
+ fn until_eof<F, T>(&mut self, f: F) -> Result<T>
+ where
+ F: FnOnce(&mut Parser<'a>) -> Result<T>,
+ {
+ let res = f(self)?;
+ self.accept_eof()?;
+ Ok(res)
+ }
+
+ fn accept_char(&mut self, chr: u8) -> Result<()> {
+ if self.advance()? == chr {
+ Ok(())
+ } else {
+ Err(())
+ }
+ }
+
+ fn accept_str(&mut self, string: &[u8]) -> Result<()> {
+ for byte in string.iter() {
+ self.accept_char(*byte)?;
+ }
+ Ok(())
+ }
+
+ fn accept_digit(&mut self, hex: bool) -> Result<u8> {
+ let digit = self.advance()?;
+ if digit.is_ascii_digit() {
+ Ok(digit - b'0')
+ } else if hex && (b'a'..=b'f').contains(&digit) {
+ Ok(digit - b'a' + 10)
+ } else if hex && (b'A'..=b'F').contains(&digit) {
+ Ok(digit - b'A' + 10)
+ } else {
+ Err(())
+ }
+ }
+
+ fn accept_number(&mut self, max_digits: usize, max_value: u32, hex: bool) -> Result<u32> {
+ let mut value = self.accept_digit(hex)? as u32;
+ for _ in 1..max_digits {
+ match self.try_do(|p| p.accept_digit(hex)) {
+ Some(digit) => {
+ value *= if hex { 16 } else { 10 };
+ value += digit as u32;
+ }
+ None => break,
+ }
+ }
+ if value < max_value {
+ Ok(value)
+ } else {
+ Err(())
+ }
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ fn accept_mac_joined_with(&mut self, separator: u8) -> Result<EthernetAddress> {
+ let mut octets = [0u8; 6];
+ for (n, octet) in octets.iter_mut().enumerate() {
+ *octet = self.accept_number(2, 0x100, true)? as u8;
+ if n != 5 {
+ self.accept_char(separator)?;
+ }
+ }
+ Ok(EthernetAddress(octets))
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ fn accept_mac(&mut self) -> Result<EthernetAddress> {
+ if let Some(mac) = self.try_do(|p| p.accept_mac_joined_with(b'-')) {
+ return Ok(mac);
+ }
+ if let Some(mac) = self.try_do(|p| p.accept_mac_joined_with(b':')) {
+ return Ok(mac);
+ }
+ Err(())
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ fn accept_ipv4_mapped_ipv6_part(&mut self, parts: &mut [u16], idx: &mut usize) -> Result<()> {
+ let octets = self.accept_ipv4_octets()?;
+
+ parts[*idx] = ((octets[0] as u16) << 8) | (octets[1] as u16);
+ *idx += 1;
+ parts[*idx] = ((octets[2] as u16) << 8) | (octets[3] as u16);
+ *idx += 1;
+
+ Ok(())
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ fn accept_ipv6_part(
+ &mut self,
+ (head, tail): (&mut [u16; 8], &mut [u16; 6]),
+ (head_idx, tail_idx): (&mut usize, &mut usize),
+ mut use_tail: bool,
+ ) -> Result<()> {
+ let double_colon = match self.try_do(|p| p.accept_str(b"::")) {
+ Some(_) if !use_tail && *head_idx < 7 => {
+ // Found a double colon. Start filling out the
+ // tail and set the double colon flag in case
+ // this is the last character we can parse.
+ use_tail = true;
+ true
+ }
+ Some(_) => {
+ // This is a bad address. Only one double colon is
+ // allowed and an address is only 128 bits.
+ return Err(());
+ }
+ None => {
+ if *head_idx != 0 || use_tail && *tail_idx != 0 {
+ // If this is not the first number or the position following
+ // a double colon, we expect there to be a single colon.
+ self.accept_char(b':')?;
+ }
+ false
+ }
+ };
+
+ match self.try_do(|p| p.accept_number(4, 0x10000, true)) {
+ Some(part) if !use_tail && *head_idx < 8 => {
+ // Valid u16 to be added to the address
+ head[*head_idx] = part as u16;
+ *head_idx += 1;
+
+ if *head_idx == 6 && head[0..*head_idx] == [0, 0, 0, 0, 0, 0xffff] {
+ self.try_do(|p| {
+ p.accept_char(b':')?;
+ p.accept_ipv4_mapped_ipv6_part(head, head_idx)
+ });
+ }
+ Ok(())
+ }
+ Some(part) if *tail_idx < 6 => {
+ // Valid u16 to be added to the address
+ tail[*tail_idx] = part as u16;
+ *tail_idx += 1;
+
+ if *tail_idx == 1 && tail[0] == 0xffff && head[0..8] == [0, 0, 0, 0, 0, 0, 0, 0] {
+ self.try_do(|p| {
+ p.accept_char(b':')?;
+ p.accept_ipv4_mapped_ipv6_part(tail, tail_idx)
+ });
+ }
+ Ok(())
+ }
+ Some(_) => {
+ // Tail or head section is too long
+ Err(())
+ }
+ None if double_colon => {
+ // The address ends with "::". E.g. 1234:: or ::
+ Ok(())
+ }
+ None => {
+ // Invalid address
+ Err(())
+ }
+ }?;
+
+ if *head_idx + *tail_idx > 8 {
+ // The head and tail indexes add up to a bad address length.
+ Err(())
+ } else if !self.lookahead_char(b':') {
+ if *head_idx < 8 && !use_tail {
+ // There was no double colon found, and the head is too short
+ return Err(());
+ }
+ Ok(())
+ } else {
+ // Continue recursing
+ self.accept_ipv6_part((head, tail), (head_idx, tail_idx), use_tail)
+ }
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ fn accept_ipv6(&mut self) -> Result<Ipv6Address> {
+ // IPv6 addresses may contain a "::" to indicate a series of
+ // 16 bit sections that evaluate to 0. E.g.
+ //
+ // fe80:0000:0000:0000:0000:0000:0000:0001
+ //
+ // May be written as
+ //
+ // fe80::1
+ //
+ // As a result, we need to find the first section of colon
+ // delimited u16's before a possible "::", then the
+ // possible second section after the "::", and finally
+ // combine the second optional section to the end of the
+ // final address.
+ //
+ // See https://tools.ietf.org/html/rfc4291#section-2.2
+ // for details.
+ let (mut addr, mut tail) = ([0u16; 8], [0u16; 6]);
+ let (mut head_idx, mut tail_idx) = (0, 0);
+
+ self.accept_ipv6_part(
+ (&mut addr, &mut tail),
+ (&mut head_idx, &mut tail_idx),
+ false,
+ )?;
+
+ // We need to copy the tail portion (the portion following the "::") to the
+ // end of the address.
+ addr[8 - tail_idx..].copy_from_slice(&tail[..tail_idx]);
+
+ Ok(Ipv6Address::from_parts(&addr))
+ }
+
+ fn accept_ipv4_octets(&mut self) -> Result<[u8; 4]> {
+ let mut octets = [0u8; 4];
+ for (n, octet) in octets.iter_mut().enumerate() {
+ *octet = self.accept_number(3, 0x100, false)? as u8;
+ if n != 3 {
+ self.accept_char(b'.')?;
+ }
+ }
+ Ok(octets)
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ fn accept_ipv4(&mut self) -> Result<Ipv4Address> {
+ let octets = self.accept_ipv4_octets()?;
+ Ok(Ipv4Address(octets))
+ }
+
+ fn accept_ip(&mut self) -> Result<IpAddress> {
+ #[cfg(feature = "proto-ipv4")]
+ #[allow(clippy::single_match)]
+ match self.try_do(|p| p.accept_ipv4()) {
+ Some(ipv4) => return Ok(IpAddress::Ipv4(ipv4)),
+ None => (),
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ #[allow(clippy::single_match)]
+ match self.try_do(|p| p.accept_ipv6()) {
+ Some(ipv6) => return Ok(IpAddress::Ipv6(ipv6)),
+ None => (),
+ }
+
+ Err(())
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ fn accept_ipv4_endpoint(&mut self) -> Result<IpEndpoint> {
+ let ip = self.accept_ipv4()?;
+
+ let port = if self.accept_eof().is_ok() {
+ 0
+ } else {
+ self.accept_char(b':')?;
+ self.accept_number(5, 65535, false)?
+ };
+
+ Ok(IpEndpoint {
+ addr: IpAddress::Ipv4(ip),
+ port: port as u16,
+ })
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ fn accept_ipv6_endpoint(&mut self) -> Result<IpEndpoint> {
+ if self.lookahead_char(b'[') {
+ self.accept_char(b'[')?;
+ let ip = self.accept_ipv6()?;
+ self.accept_char(b']')?;
+ self.accept_char(b':')?;
+ let port = self.accept_number(5, 65535, false)?;
+
+ Ok(IpEndpoint {
+ addr: IpAddress::Ipv6(ip),
+ port: port as u16,
+ })
+ } else {
+ let ip = self.accept_ipv6()?;
+ Ok(IpEndpoint {
+ addr: IpAddress::Ipv6(ip),
+ port: 0,
+ })
+ }
+ }
+
+ fn accept_ip_endpoint(&mut self) -> Result<IpEndpoint> {
+ #[cfg(feature = "proto-ipv4")]
+ #[allow(clippy::single_match)]
+ match self.try_do(|p| p.accept_ipv4_endpoint()) {
+ Some(ipv4) => return Ok(ipv4),
+ None => (),
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ #[allow(clippy::single_match)]
+ match self.try_do(|p| p.accept_ipv6_endpoint()) {
+ Some(ipv6) => return Ok(ipv6),
+ None => (),
+ }
+
+ Err(())
+ }
+}
+
+#[cfg(feature = "medium-ethernet")]
+impl FromStr for EthernetAddress {
+ type Err = ();
+
+ /// Parse a string representation of an Ethernet address.
+ fn from_str(s: &str) -> Result<EthernetAddress> {
+ Parser::new(s).until_eof(|p| p.accept_mac())
+ }
+}
+
+#[cfg(feature = "proto-ipv4")]
+impl FromStr for Ipv4Address {
+ type Err = ();
+
+ /// Parse a string representation of an IPv4 address.
+ fn from_str(s: &str) -> Result<Ipv4Address> {
+ Parser::new(s).until_eof(|p| p.accept_ipv4())
+ }
+}
+
+#[cfg(feature = "proto-ipv6")]
+impl FromStr for Ipv6Address {
+ type Err = ();
+
+ /// Parse a string representation of an IPv6 address.
+ fn from_str(s: &str) -> Result<Ipv6Address> {
+ Parser::new(s).until_eof(|p| p.accept_ipv6())
+ }
+}
+
+impl FromStr for IpAddress {
+ type Err = ();
+
+ /// Parse a string representation of an IP address.
+ fn from_str(s: &str) -> Result<IpAddress> {
+ Parser::new(s).until_eof(|p| p.accept_ip())
+ }
+}
+
+#[cfg(feature = "proto-ipv4")]
+impl FromStr for Ipv4Cidr {
+ type Err = ();
+
+ /// Parse a string representation of an IPv4 CIDR.
+ fn from_str(s: &str) -> Result<Ipv4Cidr> {
+ Parser::new(s).until_eof(|p| {
+ let ip = p.accept_ipv4()?;
+ p.accept_char(b'/')?;
+ let prefix_len = p.accept_number(2, 33, false)? as u8;
+ Ok(Ipv4Cidr::new(ip, prefix_len))
+ })
+ }
+}
+
+#[cfg(feature = "proto-ipv6")]
+impl FromStr for Ipv6Cidr {
+ type Err = ();
+
+ /// Parse a string representation of an IPv6 CIDR.
+ fn from_str(s: &str) -> Result<Ipv6Cidr> {
+ // https://tools.ietf.org/html/rfc4291#section-2.3
+ Parser::new(s).until_eof(|p| {
+ let ip = p.accept_ipv6()?;
+ p.accept_char(b'/')?;
+ let prefix_len = p.accept_number(3, 129, false)? as u8;
+ Ok(Ipv6Cidr::new(ip, prefix_len))
+ })
+ }
+}
+
+impl FromStr for IpCidr {
+ type Err = ();
+
+ /// Parse a string representation of an IP CIDR.
+ fn from_str(s: &str) -> Result<IpCidr> {
+ #[cfg(feature = "proto-ipv4")]
+ #[allow(clippy::single_match)]
+ match Ipv4Cidr::from_str(s) {
+ Ok(cidr) => return Ok(IpCidr::Ipv4(cidr)),
+ Err(_) => (),
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ #[allow(clippy::single_match)]
+ match Ipv6Cidr::from_str(s) {
+ Ok(cidr) => return Ok(IpCidr::Ipv6(cidr)),
+ Err(_) => (),
+ }
+
+ Err(())
+ }
+}
+
+impl FromStr for IpEndpoint {
+ type Err = ();
+
+ fn from_str(s: &str) -> Result<IpEndpoint> {
+ Parser::new(s).until_eof(|p| p.accept_ip_endpoint())
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ macro_rules! check_cidr_test_array {
+ ($tests:expr, $from_str:path, $variant:path) => {
+ for &(s, cidr) in &$tests {
+ assert_eq!($from_str(s), cidr);
+ assert_eq!(IpCidr::from_str(s), cidr.map($variant));
+
+ if let Ok(cidr) = cidr {
+ assert_eq!($from_str(&format!("{}", cidr)), Ok(cidr));
+ assert_eq!(IpCidr::from_str(&format!("{}", cidr)), Ok($variant(cidr)));
+ }
+ }
+ };
+ }
+
+ #[test]
+ #[cfg(all(feature = "proto-ipv4", feature = "medium-ethernet"))]
+ fn test_mac() {
+ assert_eq!(EthernetAddress::from_str(""), Err(()));
+ assert_eq!(
+ EthernetAddress::from_str("02:00:00:00:00:00"),
+ Ok(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x00]))
+ );
+ assert_eq!(
+ EthernetAddress::from_str("01:23:45:67:89:ab"),
+ Ok(EthernetAddress([0x01, 0x23, 0x45, 0x67, 0x89, 0xab]))
+ );
+ assert_eq!(
+ EthernetAddress::from_str("cd:ef:10:00:00:00"),
+ Ok(EthernetAddress([0xcd, 0xef, 0x10, 0x00, 0x00, 0x00]))
+ );
+ assert_eq!(
+ EthernetAddress::from_str("00:00:00:ab:cd:ef"),
+ Ok(EthernetAddress([0x00, 0x00, 0x00, 0xab, 0xcd, 0xef]))
+ );
+ assert_eq!(
+ EthernetAddress::from_str("00-00-00-ab-cd-ef"),
+ Ok(EthernetAddress([0x00, 0x00, 0x00, 0xab, 0xcd, 0xef]))
+ );
+ assert_eq!(
+ EthernetAddress::from_str("AB-CD-EF-00-00-00"),
+ Ok(EthernetAddress([0xab, 0xcd, 0xef, 0x00, 0x00, 0x00]))
+ );
+ assert_eq!(EthernetAddress::from_str("100:00:00:00:00:00"), Err(()));
+ assert_eq!(EthernetAddress::from_str("002:00:00:00:00:00"), Err(()));
+ assert_eq!(EthernetAddress::from_str("02:00:00:00:00:000"), Err(()));
+ assert_eq!(EthernetAddress::from_str("02:00:00:00:00:0x"), Err(()));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_ipv4() {
+ assert_eq!(Ipv4Address::from_str(""), Err(()));
+ assert_eq!(
+ Ipv4Address::from_str("1.2.3.4"),
+ Ok(Ipv4Address([1, 2, 3, 4]))
+ );
+ assert_eq!(
+ Ipv4Address::from_str("001.2.3.4"),
+ Ok(Ipv4Address([1, 2, 3, 4]))
+ );
+ assert_eq!(Ipv4Address::from_str("0001.2.3.4"), Err(()));
+ assert_eq!(Ipv4Address::from_str("999.2.3.4"), Err(()));
+ assert_eq!(Ipv4Address::from_str("1.2.3.4.5"), Err(()));
+ assert_eq!(Ipv4Address::from_str("1.2.3"), Err(()));
+ assert_eq!(Ipv4Address::from_str("1.2.3."), Err(()));
+ assert_eq!(Ipv4Address::from_str("1.2.3.4."), Err(()));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv6")]
+ fn test_ipv6() {
+ // Obviously not valid
+ assert_eq!(Ipv6Address::from_str(""), Err(()));
+ assert_eq!(
+ Ipv6Address::from_str("fe80:0:0:0:0:0:0:1"),
+ Ok(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1))
+ );
+ assert_eq!(Ipv6Address::from_str("::1"), Ok(Ipv6Address::LOOPBACK));
+ assert_eq!(Ipv6Address::from_str("::"), Ok(Ipv6Address::UNSPECIFIED));
+ assert_eq!(
+ Ipv6Address::from_str("fe80::1"),
+ Ok(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1))
+ );
+ assert_eq!(
+ Ipv6Address::from_str("1234:5678::"),
+ Ok(Ipv6Address::new(0x1234, 0x5678, 0, 0, 0, 0, 0, 0))
+ );
+ assert_eq!(
+ Ipv6Address::from_str("1234:5678::8765:4321"),
+ Ok(Ipv6Address::new(0x1234, 0x5678, 0, 0, 0, 0, 0x8765, 0x4321))
+ );
+ // Two double colons in address
+ assert_eq!(Ipv6Address::from_str("1234:5678::1::1"), Err(()));
+ assert_eq!(
+ Ipv6Address::from_str("4444:333:22:1::4"),
+ Ok(Ipv6Address::new(0x4444, 0x0333, 0x0022, 0x0001, 0, 0, 0, 4))
+ );
+ assert_eq!(
+ Ipv6Address::from_str("1:1:1:1:1:1::"),
+ Ok(Ipv6Address::new(1, 1, 1, 1, 1, 1, 0, 0))
+ );
+ assert_eq!(
+ Ipv6Address::from_str("::1:1:1:1:1:1"),
+ Ok(Ipv6Address::new(0, 0, 1, 1, 1, 1, 1, 1))
+ );
+ assert_eq!(Ipv6Address::from_str("::1:1:1:1:1:1:1"), Err(()));
+ // Double colon appears too late indicating an address that is too long
+ assert_eq!(Ipv6Address::from_str("1:1:1:1:1:1:1::"), Err(()));
+ // Section after double colon is too long for a valid address
+ assert_eq!(Ipv6Address::from_str("::1:1:1:1:1:1:1"), Err(()));
+ // Obviously too long
+ assert_eq!(Ipv6Address::from_str("1:1:1:1:1:1:1:1:1"), Err(()));
+ // Address is too short
+ assert_eq!(Ipv6Address::from_str("1:1:1:1:1:1:1"), Err(()));
+ // Long number
+ assert_eq!(Ipv6Address::from_str("::000001"), Err(()));
+ // IPv4-Mapped address
+ assert_eq!(
+ Ipv6Address::from_str("::ffff:192.168.1.1"),
+ Ok(Ipv6Address([
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 1, 1
+ ]))
+ );
+ assert_eq!(
+ Ipv6Address::from_str("0:0:0:0:0:ffff:192.168.1.1"),
+ Ok(Ipv6Address([
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 1, 1
+ ]))
+ );
+ assert_eq!(
+ Ipv6Address::from_str("0::ffff:192.168.1.1"),
+ Ok(Ipv6Address([
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 1, 1
+ ]))
+ );
+ // Only ffff is allowed in position 6 when IPv4 mapped
+ assert_eq!(Ipv6Address::from_str("0:0:0:0:0:eeee:192.168.1.1"), Err(()));
+ // Positions 1-5 must be 0 when IPv4 mapped
+ assert_eq!(Ipv6Address::from_str("0:0:0:0:1:ffff:192.168.1.1"), Err(()));
+ assert_eq!(Ipv6Address::from_str("1::ffff:192.168.1.1"), Err(()));
+ // Out of range ipv4 octet
+ assert_eq!(Ipv6Address::from_str("0:0:0:0:0:ffff:256.168.1.1"), Err(()));
+ // Invalid hex in ipv4 octet
+ assert_eq!(Ipv6Address::from_str("0:0:0:0:0:ffff:c0.168.1.1"), Err(()));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_ip_ipv4() {
+ assert_eq!(IpAddress::from_str(""), Err(()));
+ assert_eq!(
+ IpAddress::from_str("1.2.3.4"),
+ Ok(IpAddress::Ipv4(Ipv4Address([1, 2, 3, 4])))
+ );
+ assert_eq!(IpAddress::from_str("x"), Err(()));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv6")]
+ fn test_ip_ipv6() {
+ assert_eq!(IpAddress::from_str(""), Err(()));
+ assert_eq!(
+ IpAddress::from_str("fe80::1"),
+ Ok(IpAddress::Ipv6(Ipv6Address::new(
+ 0xfe80, 0, 0, 0, 0, 0, 0, 1
+ )))
+ );
+ assert_eq!(IpAddress::from_str("x"), Err(()));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_cidr_ipv4() {
+ let tests = [
+ (
+ "127.0.0.1/8",
+ Ok(Ipv4Cidr::new(Ipv4Address([127, 0, 0, 1]), 8u8)),
+ ),
+ (
+ "192.168.1.1/24",
+ Ok(Ipv4Cidr::new(Ipv4Address([192, 168, 1, 1]), 24u8)),
+ ),
+ (
+ "8.8.8.8/32",
+ Ok(Ipv4Cidr::new(Ipv4Address([8, 8, 8, 8]), 32u8)),
+ ),
+ (
+ "8.8.8.8/0",
+ Ok(Ipv4Cidr::new(Ipv4Address([8, 8, 8, 8]), 0u8)),
+ ),
+ ("", Err(())),
+ ("1", Err(())),
+ ("127.0.0.1", Err(())),
+ ("127.0.0.1/", Err(())),
+ ("127.0.0.1/33", Err(())),
+ ("127.0.0.1/111", Err(())),
+ ("/32", Err(())),
+ ];
+
+ check_cidr_test_array!(tests, Ipv4Cidr::from_str, IpCidr::Ipv4);
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv6")]
+ fn test_cidr_ipv6() {
+ let tests = [
+ (
+ "fe80::1/64",
+ Ok(Ipv6Cidr::new(
+ Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ 64u8,
+ )),
+ ),
+ (
+ "fe80::/64",
+ Ok(Ipv6Cidr::new(
+ Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 0),
+ 64u8,
+ )),
+ ),
+ ("::1/128", Ok(Ipv6Cidr::new(Ipv6Address::LOOPBACK, 128u8))),
+ ("::/128", Ok(Ipv6Cidr::new(Ipv6Address::UNSPECIFIED, 128u8))),
+ (
+ "fe80:0:0:0:0:0:0:1/64",
+ Ok(Ipv6Cidr::new(
+ Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ 64u8,
+ )),
+ ),
+ ("fe80:0:0:0:0:0:0:1|64", Err(())),
+ ("fe80::|64", Err(())),
+ ("fe80::1::/64", Err(())),
+ ];
+ check_cidr_test_array!(tests, Ipv6Cidr::from_str, IpCidr::Ipv6);
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_endpoint_ipv4() {
+ assert_eq!(IpEndpoint::from_str(""), Err(()));
+ assert_eq!(IpEndpoint::from_str("x"), Err(()));
+ assert_eq!(
+ IpEndpoint::from_str("127.0.0.1"),
+ Ok(IpEndpoint {
+ addr: IpAddress::v4(127, 0, 0, 1),
+ port: 0
+ })
+ );
+ assert_eq!(
+ IpEndpoint::from_str("127.0.0.1:12345"),
+ Ok(IpEndpoint {
+ addr: IpAddress::v4(127, 0, 0, 1),
+ port: 12345
+ })
+ );
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv6")]
+ fn test_endpoint_ipv6() {
+ assert_eq!(IpEndpoint::from_str(""), Err(()));
+ assert_eq!(IpEndpoint::from_str("x"), Err(()));
+ assert_eq!(
+ IpEndpoint::from_str("fe80::1"),
+ Ok(IpEndpoint {
+ addr: IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ port: 0
+ })
+ );
+ assert_eq!(
+ IpEndpoint::from_str("[fe80::1]:12345"),
+ Ok(IpEndpoint {
+ addr: IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ port: 12345
+ })
+ );
+ assert_eq!(
+ IpEndpoint::from_str("[::]:12345"),
+ Ok(IpEndpoint {
+ addr: IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 0),
+ port: 12345
+ })
+ );
+ }
+}
diff --git a/src/phy/fault_injector.rs b/src/phy/fault_injector.rs
new file mode 100644
index 0000000..fffe11a
--- /dev/null
+++ b/src/phy/fault_injector.rs
@@ -0,0 +1,330 @@
+use crate::phy::{self, Device, DeviceCapabilities};
+use crate::time::{Duration, Instant};
+
+use super::PacketMeta;
+
+// We use our own RNG to stay compatible with #![no_std].
+// The use of the RNG below has a slight bias, but it doesn't matter.
+fn xorshift32(state: &mut u32) -> u32 {
+ let mut x = *state;
+ x ^= x << 13;
+ x ^= x >> 17;
+ x ^= x << 5;
+ *state = x;
+ x
+}
+
+// This could be fixed once associated consts are stable.
+const MTU: usize = 1536;
+
+#[derive(Debug, Default, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct Config {
+ corrupt_pct: u8,
+ drop_pct: u8,
+ max_size: usize,
+ max_tx_rate: u64,
+ max_rx_rate: u64,
+ interval: Duration,
+}
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct State {
+ rng_seed: u32,
+ refilled_at: Instant,
+ tx_bucket: u64,
+ rx_bucket: u64,
+}
+
+impl State {
+ fn maybe(&mut self, pct: u8) -> bool {
+ xorshift32(&mut self.rng_seed) % 100 < pct as u32
+ }
+
+ fn corrupt<T: AsMut<[u8]>>(&mut self, mut buffer: T) {
+ let buffer = buffer.as_mut();
+ // We introduce a single bitflip, as the most likely, and the hardest to detect, error.
+ let index = (xorshift32(&mut self.rng_seed) as usize) % buffer.len();
+ let bit = 1 << (xorshift32(&mut self.rng_seed) % 8) as u8;
+ buffer[index] ^= bit;
+ }
+
+ fn refill(&mut self, config: &Config, timestamp: Instant) {
+ if timestamp - self.refilled_at > config.interval {
+ self.tx_bucket = config.max_tx_rate;
+ self.rx_bucket = config.max_rx_rate;
+ self.refilled_at = timestamp;
+ }
+ }
+
+ fn maybe_transmit(&mut self, config: &Config, timestamp: Instant) -> bool {
+ if config.max_tx_rate == 0 {
+ return true;
+ }
+
+ self.refill(config, timestamp);
+ if self.tx_bucket > 0 {
+ self.tx_bucket -= 1;
+ true
+ } else {
+ false
+ }
+ }
+
+ fn maybe_receive(&mut self, config: &Config, timestamp: Instant) -> bool {
+ if config.max_rx_rate == 0 {
+ return true;
+ }
+
+ self.refill(config, timestamp);
+ if self.rx_bucket > 0 {
+ self.rx_bucket -= 1;
+ true
+ } else {
+ false
+ }
+ }
+}
+
+/// A fault injector device.
+///
+/// A fault injector is a device that alters packets traversing through it to simulate
+/// adverse network conditions (such as random packet loss or corruption), or software
+/// or hardware limitations (such as a limited number or size of usable network buffers).
+#[derive(Debug)]
+pub struct FaultInjector<D: Device> {
+ inner: D,
+ state: State,
+ config: Config,
+ rx_buf: [u8; MTU],
+}
+
+impl<D: Device> FaultInjector<D> {
+ /// Create a fault injector device, using the given random number generator seed.
+ pub fn new(inner: D, seed: u32) -> FaultInjector<D> {
+ FaultInjector {
+ inner,
+ state: State {
+ rng_seed: seed,
+ refilled_at: Instant::from_millis(0),
+ tx_bucket: 0,
+ rx_bucket: 0,
+ },
+ config: Config::default(),
+ rx_buf: [0u8; MTU],
+ }
+ }
+
+ /// Return the underlying device, consuming the fault injector.
+ pub fn into_inner(self) -> D {
+ self.inner
+ }
+
+ /// Return the probability of corrupting a packet, in percents.
+ pub fn corrupt_chance(&self) -> u8 {
+ self.config.corrupt_pct
+ }
+
+ /// Return the probability of dropping a packet, in percents.
+ pub fn drop_chance(&self) -> u8 {
+ self.config.drop_pct
+ }
+
+ /// Return the maximum packet size, in octets.
+ pub fn max_packet_size(&self) -> usize {
+ self.config.max_size
+ }
+
+ /// Return the maximum packet transmission rate, in packets per second.
+ pub fn max_tx_rate(&self) -> u64 {
+ self.config.max_tx_rate
+ }
+
+ /// Return the maximum packet reception rate, in packets per second.
+ pub fn max_rx_rate(&self) -> u64 {
+ self.config.max_rx_rate
+ }
+
+ /// Return the interval for packet rate limiting, in milliseconds.
+ pub fn bucket_interval(&self) -> Duration {
+ self.config.interval
+ }
+
+ /// Set the probability of corrupting a packet, in percents.
+ ///
+ /// # Panics
+ /// This function panics if the probability is not between 0% and 100%.
+ pub fn set_corrupt_chance(&mut self, pct: u8) {
+ if pct > 100 {
+ panic!("percentage out of range")
+ }
+ self.config.corrupt_pct = pct
+ }
+
+ /// Set the probability of dropping a packet, in percents.
+ ///
+ /// # Panics
+ /// This function panics if the probability is not between 0% and 100%.
+ pub fn set_drop_chance(&mut self, pct: u8) {
+ if pct > 100 {
+ panic!("percentage out of range")
+ }
+ self.config.drop_pct = pct
+ }
+
+ /// Set the maximum packet size, in octets.
+ pub fn set_max_packet_size(&mut self, size: usize) {
+ self.config.max_size = size
+ }
+
+ /// Set the maximum packet transmission rate, in packets per interval.
+ pub fn set_max_tx_rate(&mut self, rate: u64) {
+ self.config.max_tx_rate = rate
+ }
+
+ /// Set the maximum packet reception rate, in packets per interval.
+ pub fn set_max_rx_rate(&mut self, rate: u64) {
+ self.config.max_rx_rate = rate
+ }
+
+ /// Set the interval for packet rate limiting, in milliseconds.
+ pub fn set_bucket_interval(&mut self, interval: Duration) {
+ self.state.refilled_at = Instant::from_millis(0);
+ self.config.interval = interval
+ }
+}
+
+impl<D: Device> Device for FaultInjector<D> {
+ type RxToken<'a> = RxToken<'a>
+ where
+ Self: 'a;
+ type TxToken<'a> = TxToken<'a, D::TxToken<'a>>
+ where
+ Self: 'a;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ let mut caps = self.inner.capabilities();
+ if caps.max_transmission_unit > MTU {
+ caps.max_transmission_unit = MTU;
+ }
+ caps
+ }
+
+ fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ let (rx_token, tx_token) = self.inner.receive(timestamp)?;
+ let rx_meta = <D::RxToken<'_> as phy::RxToken>::meta(&rx_token);
+
+ let len = super::RxToken::consume(rx_token, |buffer| {
+ if (self.config.max_size > 0 && buffer.len() > self.config.max_size)
+ || buffer.len() > self.rx_buf.len()
+ {
+ net_trace!("rx: dropping a packet that is too large");
+ return None;
+ }
+ self.rx_buf[..buffer.len()].copy_from_slice(buffer);
+ Some(buffer.len())
+ })?;
+
+ let buf = &mut self.rx_buf[..len];
+
+ if self.state.maybe(self.config.drop_pct) {
+ net_trace!("rx: randomly dropping a packet");
+ return None;
+ }
+
+ if !self.state.maybe_receive(&self.config, timestamp) {
+ net_trace!("rx: dropping a packet because of rate limiting");
+ return None;
+ }
+
+ if self.state.maybe(self.config.corrupt_pct) {
+ net_trace!("rx: randomly corrupting a packet");
+ self.state.corrupt(&mut buf[..]);
+ }
+
+ let rx = RxToken { buf, meta: rx_meta };
+ let tx = TxToken {
+ state: &mut self.state,
+ config: self.config,
+ token: tx_token,
+ junk: [0; MTU],
+ timestamp,
+ };
+ Some((rx, tx))
+ }
+
+ fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ self.inner.transmit(timestamp).map(|token| TxToken {
+ state: &mut self.state,
+ config: self.config,
+ token,
+ junk: [0; MTU],
+ timestamp,
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken<'a> {
+ buf: &'a mut [u8],
+ meta: PacketMeta,
+}
+
+impl<'a> phy::RxToken for RxToken<'a> {
+ fn consume<R, F>(self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ f(self.buf)
+ }
+
+ fn meta(&self) -> phy::PacketMeta {
+ self.meta
+ }
+}
+
+#[doc(hidden)]
+pub struct TxToken<'a, Tx: phy::TxToken> {
+ state: &'a mut State,
+ config: Config,
+ token: Tx,
+ junk: [u8; MTU],
+ timestamp: Instant,
+}
+
+impl<'a, Tx: phy::TxToken> phy::TxToken for TxToken<'a, Tx> {
+ fn consume<R, F>(mut self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ let drop = if self.state.maybe(self.config.drop_pct) {
+ net_trace!("tx: randomly dropping a packet");
+ true
+ } else if self.config.max_size > 0 && len > self.config.max_size {
+ net_trace!("tx: dropping a packet that is too large");
+ true
+ } else if !self.state.maybe_transmit(&self.config, self.timestamp) {
+ net_trace!("tx: dropping a packet because of rate limiting");
+ true
+ } else {
+ false
+ };
+
+ if drop {
+ return f(&mut self.junk[..len]);
+ }
+
+ self.token.consume(len, |mut buf| {
+ if self.state.maybe(self.config.corrupt_pct) {
+ net_trace!("tx: corrupting a packet");
+ self.state.corrupt(&mut buf)
+ }
+ f(buf)
+ })
+ }
+
+ fn set_meta(&mut self, meta: PacketMeta) {
+ self.token.set_meta(meta);
+ }
+}
diff --git a/src/phy/fuzz_injector.rs b/src/phy/fuzz_injector.rs
new file mode 100644
index 0000000..6769d8e
--- /dev/null
+++ b/src/phy/fuzz_injector.rs
@@ -0,0 +1,129 @@
+use crate::phy::{self, Device, DeviceCapabilities};
+use crate::time::Instant;
+
+// This could be fixed once associated consts are stable.
+const MTU: usize = 1536;
+
+/// Represents a fuzzer. It is expected to replace bytes in the packet with fuzzed data.
+pub trait Fuzzer {
+ /// Modify a single packet with fuzzed data.
+ fn fuzz_packet(&self, packet_data: &mut [u8]);
+}
+
+/// A fuzz injector device.
+///
+/// A fuzz injector is a device that alters packets traversing through it according to the
+/// directions of a guided fuzzer. It is designed to support fuzzing internal state machines inside
+/// smoltcp, and is not for production use.
+#[allow(unused)]
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct FuzzInjector<D: Device, FTx: Fuzzer, FRx: Fuzzer> {
+ inner: D,
+ fuzz_tx: FTx,
+ fuzz_rx: FRx,
+}
+
+#[allow(unused)]
+impl<D: Device, FTx: Fuzzer, FRx: Fuzzer> FuzzInjector<D, FTx, FRx> {
+ /// Create a fuzz injector device.
+ pub fn new(inner: D, fuzz_tx: FTx, fuzz_rx: FRx) -> FuzzInjector<D, FTx, FRx> {
+ FuzzInjector {
+ inner,
+ fuzz_tx,
+ fuzz_rx,
+ }
+ }
+
+ /// Return the underlying device, consuming the fuzz injector.
+ pub fn into_inner(self) -> D {
+ self.inner
+ }
+}
+
+impl<D: Device, FTx, FRx> Device for FuzzInjector<D, FTx, FRx>
+where
+ FTx: Fuzzer,
+ FRx: Fuzzer,
+{
+ type RxToken<'a> = RxToken<'a, D::RxToken<'a>, FRx>
+ where
+ Self: 'a;
+ type TxToken<'a> = TxToken<'a, D::TxToken<'a>, FTx>
+ where
+ Self: 'a;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ let mut caps = self.inner.capabilities();
+ if caps.max_transmission_unit > MTU {
+ caps.max_transmission_unit = MTU;
+ }
+ caps
+ }
+
+ fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ self.inner.receive(timestamp).map(|(rx_token, tx_token)| {
+ let rx = RxToken {
+ fuzzer: &mut self.fuzz_rx,
+ token: rx_token,
+ };
+ let tx = TxToken {
+ fuzzer: &mut self.fuzz_tx,
+ token: tx_token,
+ };
+ (rx, tx)
+ })
+ }
+
+ fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ self.inner.transmit(timestamp).map(|token| TxToken {
+ fuzzer: &mut self.fuzz_tx,
+ token: token,
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken<'a, Rx: phy::RxToken, F: Fuzzer + 'a> {
+ fuzzer: &'a F,
+ token: Rx,
+}
+
+impl<'a, Rx: phy::RxToken, FRx: Fuzzer> phy::RxToken for RxToken<'a, Rx, FRx> {
+ fn consume<R, F>(self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ self.token.consume(|buffer| {
+ self.fuzzer.fuzz_packet(buffer);
+ f(buffer)
+ })
+ }
+
+ fn meta(&self) -> phy::PacketMeta {
+ self.token.meta()
+ }
+}
+
+#[doc(hidden)]
+pub struct TxToken<'a, Tx: phy::TxToken, F: Fuzzer + 'a> {
+ fuzzer: &'a F,
+ token: Tx,
+}
+
+impl<'a, Tx: phy::TxToken, FTx: Fuzzer> phy::TxToken for TxToken<'a, Tx, FTx> {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ self.token.consume(len, |buf| {
+ let result = f(buf);
+ self.fuzzer.fuzz_packet(buf);
+ result
+ })
+ }
+
+ fn set_meta(&mut self, meta: phy::PacketMeta) {
+ self.token.set_meta(meta)
+ }
+}
diff --git a/src/phy/loopback.rs b/src/phy/loopback.rs
new file mode 100644
index 0000000..1f57c0c
--- /dev/null
+++ b/src/phy/loopback.rs
@@ -0,0 +1,88 @@
+use alloc::collections::VecDeque;
+use alloc::vec::Vec;
+
+use crate::phy::{self, Device, DeviceCapabilities, Medium};
+use crate::time::Instant;
+
+/// A loopback device.
+#[derive(Debug)]
+pub struct Loopback {
+ pub(crate) queue: VecDeque<Vec<u8>>,
+ medium: Medium,
+}
+
+#[allow(clippy::new_without_default)]
+impl Loopback {
+ /// Creates a loopback device.
+ ///
+ /// Every packet transmitted through this device will be received through it
+ /// in FIFO order.
+ pub fn new(medium: Medium) -> Loopback {
+ Loopback {
+ queue: VecDeque::new(),
+ medium,
+ }
+ }
+}
+
+impl Device for Loopback {
+ type RxToken<'a> = RxToken;
+ type TxToken<'a> = TxToken<'a>;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ DeviceCapabilities {
+ max_transmission_unit: 65535,
+ medium: self.medium,
+ ..DeviceCapabilities::default()
+ }
+ }
+
+ fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ self.queue.pop_front().map(move |buffer| {
+ let rx = RxToken { buffer };
+ let tx = TxToken {
+ queue: &mut self.queue,
+ };
+ (rx, tx)
+ })
+ }
+
+ fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ Some(TxToken {
+ queue: &mut self.queue,
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken {
+ buffer: Vec<u8>,
+}
+
+impl phy::RxToken for RxToken {
+ fn consume<R, F>(mut self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ f(&mut self.buffer)
+ }
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TxToken<'a> {
+ queue: &'a mut VecDeque<Vec<u8>>,
+}
+
+impl<'a> phy::TxToken for TxToken<'a> {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ let mut buffer = Vec::new();
+ buffer.resize(len, 0);
+ let result = f(&mut buffer);
+ self.queue.push_back(buffer);
+ result
+ }
+}
diff --git a/src/phy/mod.rs b/src/phy/mod.rs
new file mode 100644
index 0000000..c3845d9
--- /dev/null
+++ b/src/phy/mod.rs
@@ -0,0 +1,398 @@
+/*! Access to networking hardware.
+
+The `phy` module deals with the *network devices*. It provides a trait
+for transmitting and receiving frames, [Device](trait.Device.html)
+and implementations of it:
+
+ * the [_loopback_](struct.Loopback.html), for zero dependency testing;
+ * _middleware_ [Tracer](struct.Tracer.html) and
+ [FaultInjector](struct.FaultInjector.html), to facilitate debugging;
+ * _adapters_ [RawSocket](struct.RawSocket.html) and
+ [TunTapInterface](struct.TunTapInterface.html), to transmit and receive frames
+ on the host OS.
+*/
+# trait for a simple hardware
+Ethernet controller could look as follows:
+
+```rust
+use smoltcp::phy::{self, DeviceCapabilities, Device, Medium};
+use smoltcp::time::Instant;
+
+struct StmPhy {
+ rx_buffer: [u8; 1536],
+ tx_buffer: [u8; 1536],
+}
+
+impl<'a> StmPhy {
+ fn new() -> StmPhy {
+ StmPhy {
+ rx_buffer: [0; 1536],
+ tx_buffer: [0; 1536],
+ }
+ }
+}
+
+impl phy::Device for StmPhy {
+ type RxToken<'a> = StmPhyRxToken<'a> where Self: 'a;
+ type TxToken<'a> = StmPhyTxToken<'a> where Self: 'a;
+
+ fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ Some((StmPhyRxToken(&mut self.rx_buffer[..]),
+ StmPhyTxToken(&mut self.tx_buffer[..])))
+ }
+
+ fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ Some(StmPhyTxToken(&mut self.tx_buffer[..]))
+ }
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ let mut caps = DeviceCapabilities::default();
+ caps.max_transmission_unit = 1536;
+ caps.max_burst_size = Some(1);
+ caps.medium = Medium::Ethernet;
+ caps
+ }
+}
+
+struct StmPhyRxToken<'a>(&'a mut [u8]);
+
+impl<'a> phy::RxToken for StmPhyRxToken<'a> {
+ fn consume<R, F>(mut self, f: F) -> R
+ where F: FnOnce(&mut [u8]) -> R
+ {
+ // TODO: receive packet into buffer
+ let result = f(&mut self.0);
+ println!("rx called");
+ result
+ }
+}
+
+struct StmPhyTxToken<'a>(&'a mut [u8]);
+
+impl<'a> phy::TxToken for StmPhyTxToken<'a> {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where F: FnOnce(&mut [u8]) -> R
+ {
+ let result = f(&mut self.0[..len]);
+ println!("tx called {}", len);
+ // TODO: send packet out
+ result
+ }
+}
+```
+"##
+)]
+
+use crate::time::Instant;
+
+#[cfg(all(
+ any(feature = "phy-raw_socket", feature = "phy-tuntap_interface"),
+ unix
+))]
+mod sys;
+
+mod fault_injector;
+mod fuzz_injector;
+#[cfg(feature = "alloc")]
+mod loopback;
+mod pcap_writer;
+#[cfg(all(feature = "phy-raw_socket", unix))]
+mod raw_socket;
+mod tracer;
+#[cfg(all(
+ feature = "phy-tuntap_interface",
+ any(target_os = "linux", target_os = "android")
+))]
+mod tuntap_interface;
+
+#[cfg(all(
+ any(feature = "phy-raw_socket", feature = "phy-tuntap_interface"),
+ unix
+))]
+pub use self::sys::wait;
+
+pub use self::fault_injector::FaultInjector;
+pub use self::fuzz_injector::{FuzzInjector, Fuzzer};
+#[cfg(feature = "alloc")]
+pub use self::loopback::Loopback;
+pub use self::pcap_writer::{PcapLinkType, PcapMode, PcapSink, PcapWriter};
+#[cfg(all(feature = "phy-raw_socket", unix))]
+pub use self::raw_socket::RawSocket;
+pub use self::tracer::Tracer;
+#[cfg(all(
+ feature = "phy-tuntap_interface",
+ any(target_os = "linux", target_os = "android")
+))]
+pub use self::tuntap_interface::TunTapInterface;
+
+/// Metadata associated to a packet.
+///
+/// The packet metadata is a set of attributes associated to network packets
+/// as they travel up or down the stack. The metadata is get/set by the
+/// [`Device`] implementations or by the user when sending/receiving packets from a
+/// socket.
+///
+/// Metadata fields are enabled via Cargo features. If no field is enabled, this
+/// struct becomes zero-sized, which allows the compiler to optimize it out as if
+/// the packet metadata mechanism didn't exist at all.
+///
+/// Currently only UDP sockets allow setting/retrieving packet metadata. The metadata
+/// for packets emitted with other sockets will be all default values.
+///
+/// This struct is marked as `#[non_exhaustive]`. This means it is not possible to
+/// create it directly by specifying all fields. You have to instead create it with
+/// default values and then set the fields you want. This makes adding metadata
+/// fields a non-breaking change.
+///
+/// ```rust
+/// let mut meta = smoltcp::phy::PacketMeta::default();
+/// #[cfg(feature = "packetmeta-id")]
+/// {
+/// meta.id = 15;
+/// }
+/// ```
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Default)]
+#[non_exhaustive]
+pub struct PacketMeta {
+ #[cfg(feature = "packetmeta-id")]
+ pub id: u32,
+}
+
+/// A description of checksum behavior for a particular protocol.
+#[derive(Debug, Clone, Copy, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Checksum {
+ /// Verify checksum when receiving and compute checksum when sending.
+ #[default]
+ Both,
+ /// Verify checksum when receiving.
+ Rx,
+ /// Compute checksum before sending.
+ Tx,
+ /// Ignore checksum completely.
+ None,
+}
+
+impl Checksum {
+ /// Returns whether checksum should be verified when receiving.
+ pub fn rx(&self) -> bool {
+ match *self {
+ Checksum::Both | Checksum::Rx => true,
+ _ => false,
+ }
+ }
+
+ /// Returns whether checksum should be verified when sending.
+ pub fn tx(&self) -> bool {
+ match *self {
+ Checksum::Both | Checksum::Tx => true,
+ _ => false,
+ }
+ }
+}
+
+/// A description of checksum behavior for every supported protocol.
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub struct ChecksumCapabilities {
+ pub ipv4: Checksum,
+ pub udp: Checksum,
+ pub tcp: Checksum,
+ #[cfg(feature = "proto-ipv4")]
+ pub icmpv4: Checksum,
+ #[cfg(feature = "proto-ipv6")]
+ pub icmpv6: Checksum,
+}
+
+impl ChecksumCapabilities {
+ /// Checksum behavior that results in not computing or verifying checksums
+ /// for any of the supported protocols.
+ pub fn ignored() -> Self {
+ ChecksumCapabilities {
+ ipv4: Checksum::None,
+ udp: Checksum::None,
+ tcp: Checksum::None,
+ #[cfg(feature = "proto-ipv4")]
+ icmpv4: Checksum::None,
+ #[cfg(feature = "proto-ipv6")]
+ icmpv6: Checksum::None,
+ }
+ }
+}
+
+/// A description of device capabilities.
+///
+/// Higher-level protocols may achieve higher throughput or lower latency if they consider
+/// the bandwidth or packet size limitations.
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub struct DeviceCapabilities {
+ /// Medium of the device.
+ ///
+ /// This indicates what kind of packet the sent/received bytes are, and determines
+ /// some behaviors of Interface. For example, ARP/NDISC address resolution is only done
+ /// for Ethernet mediums.
+ pub medium: Medium,
+
+ /// Maximum transmission unit.
+ ///
+ /// The network device is unable to send or receive frames larger than the value returned
+ /// by this function.
+ ///
+ /// For Ethernet devices, this is the maximum Ethernet frame size, including the Ethernet header (14 octets), but
+ /// *not* including the Ethernet FCS (4 octets). Therefore, Ethernet MTU = IP MTU + 14.
+ ///
+ /// Note that in Linux and other OSes, "MTU" is the IP MTU, not the Ethernet MTU, even for Ethernet
+ /// devices. This is a common source of confusion.
+ ///
+ /// Most common IP MTU is 1500. Minimum is 576 (for IPv4) or 1280 (for IPv6). Maximum is 9216 octets.
+ pub max_transmission_unit: usize,
+
+ /// Maximum burst size, in terms of MTU.
+ ///
+ /// The network device is unable to send or receive bursts large than the value returned
+ /// by this function.
+ ///
+ /// If `None`, there is no fixed limit on burst size, e.g. if network buffers are
+ /// dynamically allocated.
+ pub max_burst_size: Option<usize>,
+
+ /// Checksum behavior.
+ ///
+ /// If the network device is capable of verifying or computing checksums for some protocols,
+ /// it can request that the stack not do so in software to improve performance.
+ pub checksum: ChecksumCapabilities,
+}
+
+impl DeviceCapabilities {
+ pub fn ip_mtu(&self) -> usize {
+ match self.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => {
+ self.max_transmission_unit - crate::wire::EthernetFrame::<&[u8]>::header_len()
+ }
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => self.max_transmission_unit,
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => self.max_transmission_unit, // TODO(thvdveld): what is the MTU for Medium::IEEE802
+ }
+ }
+}
+
+/// Type of medium of a device.
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Medium {
+ /// Ethernet medium. Devices of this type send and receive Ethernet frames,
+ /// and interfaces using it must do neighbor discovery via ARP or NDISC.
+ ///
+ /// Examples of devices of this type are Ethernet, WiFi (802.11), Linux `tap`, and VPNs in tap (layer 2) mode.
+ #[cfg(feature = "medium-ethernet")]
+ Ethernet,
+
+ /// IP medium. Devices of this type send and receive IP frames, without an
+ /// Ethernet header. MAC addresses are not used, and no neighbor discovery (ARP, NDISC) is done.
+ ///
+ /// Examples of devices of this type are the Linux `tun`, PPP interfaces, VPNs in tun (layer 3) mode.
+ #[cfg(feature = "medium-ip")]
+ Ip,
+
+ #[cfg(feature = "medium-ieee802154")]
+ Ieee802154,
+}
+
+impl Default for Medium {
+ fn default() -> Medium {
+ #[cfg(feature = "medium-ethernet")]
+ return Medium::Ethernet;
+ #[cfg(all(feature = "medium-ip", not(feature = "medium-ethernet")))]
+ return Medium::Ip;
+ #[cfg(all(
+ feature = "medium-ieee802154",
+ not(feature = "medium-ip"),
+ not(feature = "medium-ethernet")
+ ))]
+ return Medium::Ieee802154;
+ #[cfg(all(
+ not(feature = "medium-ip"),
+ not(feature = "medium-ethernet"),
+ not(feature = "medium-ieee802154")
+ ))]
+ return panic!("No medium enabled");
+ }
+}
+
+/// An interface for sending and receiving raw network frames.
+///
+/// The interface is based on _tokens_, which are types that allow to receive/transmit a
+/// single packet. The `receive` and `transmit` functions only construct such tokens, the
+/// real sending/receiving operation are performed when the tokens are consumed.
+pub trait Device {
+ type RxToken<'a>: RxToken
+ where
+ Self: 'a;
+ type TxToken<'a>: TxToken
+ where
+ Self: 'a;
+
+ /// Construct a token pair consisting of one receive token and one transmit token.
+ ///
+ /// The additional transmit token makes it possible to generate a reply packet based
+ /// on the contents of the received packet. For example, this makes it possible to
+ /// handle arbitrarily large ICMP echo ("ping") requests, where the all received bytes
+ /// need to be sent back, without heap allocation.
+ ///
+ /// The timestamp must be a number of milliseconds, monotonically increasing since an
+ /// arbitrary moment in time, such as system startup.
+ fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)>;
+
+ /// Construct a transmit token.
+ ///
+ /// The timestamp must be a number of milliseconds, monotonically increasing since an
+ /// arbitrary moment in time, such as system startup.
+ fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>>;
+
+ /// Get a description of device capabilities.
+ fn capabilities(&self) -> DeviceCapabilities;
+}
+
+/// A token to receive a single network packet.
+pub trait RxToken {
+ /// Consumes the token to receive a single network packet.
+ ///
+ /// This method receives a packet and then calls the given closure `f` with the raw
+ /// packet bytes as argument.
+ fn consume<R, F>(self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R;
+
+ /// The Packet ID associated with the frame received by this [`RxToken`]
+ fn meta(&self) -> PacketMeta {
+ PacketMeta::default()
+ }
+}
+
+/// A token to transmit a single network packet.
+pub trait TxToken {
+ /// Consumes the token to send a single network packet.
+ ///
+ /// This method constructs a transmit buffer of size `len` and calls the passed
+ /// closure `f` with a mutable reference to that buffer. The closure should construct
+ /// a valid network packet (e.g. an ethernet packet) in the buffer. When the closure
+ /// returns, the transmit buffer is sent out.
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R;
+
+ /// The Packet ID to be associated with the frame to be transmitted by this [`TxToken`].
+ #[allow(unused_variables)]
+ fn set_meta(&mut self, meta: PacketMeta) {}
+}
diff --git a/src/phy/pcap_writer.rs b/src/phy/pcap_writer.rs
new file mode 100644
index 0000000..aadf2a2
--- /dev/null
+++ b/src/phy/pcap_writer.rs
@@ -0,0 +1,268 @@
+use byteorder::{ByteOrder, NativeEndian};
+use core::cell::RefCell;
+use phy::Medium;
+#[cfg(feature = "std")]
+use std::io::Write;
+
+use crate::phy::{self, Device, DeviceCapabilities};
+use crate::time::Instant;
+
+enum_with_unknown! {
+ /// Captured packet header type.
+ pub enum PcapLinkType(u32) {
+ /// Ethernet frames
+ Ethernet = 1,
+ /// IPv4 or IPv6 packets (depending on the version field)
+ Ip = 101,
+ /// IEEE 802.15.4 packets without FCS.
+ Ieee802154WithoutFcs = 230,
+ }
+}
+
+/// Packet capture mode.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum PcapMode {
+ /// Capture both received and transmitted packets.
+ Both,
+ /// Capture only received packets.
+ RxOnly,
+ /// Capture only transmitted packets.
+ TxOnly,
+}
+
+/// A packet capture sink.
+pub trait PcapSink {
+ /// Write data into the sink.
+ fn write(&mut self, data: &[u8]);
+
+ /// Flush data written into the sync.
+ fn flush(&mut self) {}
+
+ /// Write an `u16` into the sink, in native byte order.
+ fn write_u16(&mut self, value: u16) {
+ let mut bytes = [0u8; 2];
+ NativeEndian::write_u16(&mut bytes, value);
+ self.write(&bytes[..])
+ }
+
+ /// Write an `u32` into the sink, in native byte order.
+ fn write_u32(&mut self, value: u32) {
+ let mut bytes = [0u8; 4];
+ NativeEndian::write_u32(&mut bytes, value);
+ self.write(&bytes[..])
+ }
+
+ /// Write the libpcap global header into the sink.
+ ///
+ /// This method may be overridden e.g. if special synchronization is necessary.
+ fn global_header(&mut self, link_type: PcapLinkType) {
+ self.write_u32(0xa1b2c3d4); // magic number
+ self.write_u16(2); // major version
+ self.write_u16(4); // minor version
+ self.write_u32(0); // timezone (= UTC)
+ self.write_u32(0); // accuracy (not used)
+ self.write_u32(65535); // maximum packet length
+ self.write_u32(link_type.into()); // link-layer header type
+ }
+
+ /// Write the libpcap packet header into the sink.
+ ///
+ /// See also the note for [global_header](#method.global_header).
+ ///
+ /// # Panics
+ /// This function panics if `length` is greater than 65535.
+ fn packet_header(&mut self, timestamp: Instant, length: usize) {
+ assert!(length <= 65535);
+
+ self.write_u32(timestamp.secs() as u32); // timestamp seconds
+ self.write_u32(timestamp.micros() as u32); // timestamp microseconds
+ self.write_u32(length as u32); // captured length
+ self.write_u32(length as u32); // original length
+ }
+
+ /// Write the libpcap packet header followed by packet data into the sink.
+ ///
+ /// See also the note for [global_header](#method.global_header).
+ fn packet(&mut self, timestamp: Instant, packet: &[u8]) {
+ self.packet_header(timestamp, packet.len());
+ self.write(packet);
+ self.flush();
+ }
+}
+
+#[cfg(feature = "std")]
+impl<T: Write> PcapSink for T {
+ fn write(&mut self, data: &[u8]) {
+ T::write_all(self, data).expect("cannot write")
+ }
+
+ fn flush(&mut self) {
+ T::flush(self).expect("cannot flush")
+ }
+}
+
+/// A packet capture writer device.
+///
+/// Every packet transmitted or received through this device is timestamped
+/// and written (in the [libpcap] format) using the provided [sink].
+/// Note that writes are fine-grained, and buffering is recommended.
+///
+/// The packet sink should be cheaply cloneable, as it is cloned on every
+/// transmitted packet. For example, `&'a mut Vec<u8>` is cheaply cloneable
+/// but `&std::io::File`
+///
+/// [libpcap]: https://wiki.wireshark.org/Development/LibpcapFileFormat
+/// [sink]: trait.PcapSink.html
+#[derive(Debug)]
+pub struct PcapWriter<D, S>
+where
+ D: Device,
+ S: PcapSink,
+{
+ lower: D,
+ sink: RefCell<S>,
+ mode: PcapMode,
+}
+
+impl<D: Device, S: PcapSink> PcapWriter<D, S> {
+ /// Creates a packet capture writer.
+ pub fn new(lower: D, mut sink: S, mode: PcapMode) -> PcapWriter<D, S> {
+ let medium = lower.capabilities().medium;
+ let link_type = match medium {
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => PcapLinkType::Ip,
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => PcapLinkType::Ethernet,
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => PcapLinkType::Ieee802154WithoutFcs,
+ };
+ sink.global_header(link_type);
+ PcapWriter {
+ lower,
+ sink: RefCell::new(sink),
+ mode,
+ }
+ }
+
+ /// Get a reference to the underlying device.
+ ///
+ /// Even if the device offers reading through a standard reference, it is inadvisable to
+ /// directly read from the device as doing so will circumvent the packet capture.
+ pub fn get_ref(&self) -> &D {
+ &self.lower
+ }
+
+ /// Get a mutable reference to the underlying device.
+ ///
+ /// It is inadvisable to directly read from the device as doing so will circumvent the packet capture.
+ pub fn get_mut(&mut self) -> &mut D {
+ &mut self.lower
+ }
+}
+
+impl<D: Device, S> Device for PcapWriter<D, S>
+where
+ S: PcapSink,
+{
+ type RxToken<'a> = RxToken<'a, D::RxToken<'a>, S>
+ where
+ Self: 'a;
+ type TxToken<'a> = TxToken<'a, D::TxToken<'a>, S>
+ where
+ Self: 'a;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ self.lower.capabilities()
+ }
+
+ fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ let sink = &self.sink;
+ let mode = self.mode;
+ self.lower
+ .receive(timestamp)
+ .map(move |(rx_token, tx_token)| {
+ let rx = RxToken {
+ token: rx_token,
+ sink,
+ mode,
+ timestamp,
+ };
+ let tx = TxToken {
+ token: tx_token,
+ sink,
+ mode,
+ timestamp,
+ };
+ (rx, tx)
+ })
+ }
+
+ fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ let sink = &self.sink;
+ let mode = self.mode;
+ self.lower.transmit(timestamp).map(move |token| TxToken {
+ token,
+ sink,
+ mode,
+ timestamp,
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken<'a, Rx: phy::RxToken, S: PcapSink> {
+ token: Rx,
+ sink: &'a RefCell<S>,
+ mode: PcapMode,
+ timestamp: Instant,
+}
+
+impl<'a, Rx: phy::RxToken, S: PcapSink> phy::RxToken for RxToken<'a, Rx, S> {
+ fn consume<R, F: FnOnce(&mut [u8]) -> R>(self, f: F) -> R {
+ self.token.consume(|buffer| {
+ match self.mode {
+ PcapMode::Both | PcapMode::RxOnly => self
+ .sink
+ .borrow_mut()
+ .packet(self.timestamp, buffer.as_ref()),
+ PcapMode::TxOnly => (),
+ }
+ f(buffer)
+ })
+ }
+
+ fn meta(&self) -> phy::PacketMeta {
+ self.token.meta()
+ }
+}
+
+#[doc(hidden)]
+pub struct TxToken<'a, Tx: phy::TxToken, S: PcapSink> {
+ token: Tx,
+ sink: &'a RefCell<S>,
+ mode: PcapMode,
+ timestamp: Instant,
+}
+
+impl<'a, Tx: phy::TxToken, S: PcapSink> phy::TxToken for TxToken<'a, Tx, S> {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ self.token.consume(len, |buffer| {
+ let result = f(buffer);
+ match self.mode {
+ PcapMode::Both | PcapMode::TxOnly => {
+ self.sink.borrow_mut().packet(self.timestamp, buffer)
+ }
+ PcapMode::RxOnly => (),
+ };
+ result
+ })
+ }
+
+ fn set_meta(&mut self, meta: phy::PacketMeta) {
+ self.token.set_meta(meta)
+ }
+}
diff --git a/src/phy/raw_socket.rs b/src/phy/raw_socket.rs
new file mode 100644
index 0000000..19c5b98
--- /dev/null
+++ b/src/phy/raw_socket.rs
@@ -0,0 +1,137 @@
+use std::cell::RefCell;
+use std::io;
+use std::os::unix::io::{AsRawFd, RawFd};
+use std::rc::Rc;
+use std::vec::Vec;
+
+use crate::phy::{self, sys, Device, DeviceCapabilities, Medium};
+use crate::time::Instant;
+
+/// A socket that captures or transmits the complete frame.
+#[derive(Debug)]
+pub struct RawSocket {
+ medium: Medium,
+ lower: Rc<RefCell<sys::RawSocketDesc>>,
+ mtu: usize,
+}
+
+impl AsRawFd for RawSocket {
+ fn as_raw_fd(&self) -> RawFd {
+ self.lower.borrow().as_raw_fd()
+ }
+}
+
+impl RawSocket {
+ /// Creates a raw socket, bound to the interface called `name`.
+ ///
+ /// This requires superuser privileges or a corresponding capability bit
+ /// set on the executable.
+ pub fn new(name: &str, medium: Medium) -> io::Result<RawSocket> {
+ let mut lower = sys::RawSocketDesc::new(name, medium)?;
+ lower.bind_interface()?;
+
+ let mut mtu = lower.interface_mtu()?;
+
+ #[cfg(feature = "medium-ieee802154")]
+ if medium == Medium::Ieee802154 {
+ // SIOCGIFMTU returns 127 - (ACK_PSDU - FCS - 1) - FCS.
+ // 127 - (5 - 2 - 1) - 2 = 123
+ // For IEEE802154, we want to add (ACK_PSDU - FCS - 1), since that is what SIOCGIFMTU
+ // uses as the size of the link layer header.
+ //
+ // https://github.com/torvalds/linux/blob/7475e51b87969e01a6812eac713a1c8310372e8a/net/mac802154/iface.c#L541
+ mtu += 2;
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ if medium == Medium::Ethernet {
+ // SIOCGIFMTU returns the IP MTU (typically 1500 bytes.)
+ // smoltcp counts the entire Ethernet packet in the MTU, so add the Ethernet header size to it.
+ mtu += crate::wire::EthernetFrame::<&[u8]>::header_len()
+ }
+
+ Ok(RawSocket {
+ medium,
+ lower: Rc::new(RefCell::new(lower)),
+ mtu,
+ })
+ }
+}
+
+impl Device for RawSocket {
+ type RxToken<'a> = RxToken
+ where
+ Self: 'a;
+ type TxToken<'a> = TxToken
+ where
+ Self: 'a;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ DeviceCapabilities {
+ max_transmission_unit: self.mtu,
+ medium: self.medium,
+ ..DeviceCapabilities::default()
+ }
+ }
+
+ fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ let mut lower = self.lower.borrow_mut();
+ let mut buffer = vec![0; self.mtu];
+ match lower.recv(&mut buffer[..]) {
+ Ok(size) => {
+ buffer.resize(size, 0);
+ let rx = RxToken { buffer };
+ let tx = TxToken {
+ lower: self.lower.clone(),
+ };
+ Some((rx, tx))
+ }
+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => None,
+ Err(err) => panic!("{}", err),
+ }
+ }
+
+ fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ Some(TxToken {
+ lower: self.lower.clone(),
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken {
+ buffer: Vec<u8>,
+}
+
+impl phy::RxToken for RxToken {
+ fn consume<R, F>(mut self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ f(&mut self.buffer[..])
+ }
+}
+
+#[doc(hidden)]
+pub struct TxToken {
+ lower: Rc<RefCell<sys::RawSocketDesc>>,
+}
+
+impl phy::TxToken for TxToken {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ let mut lower = self.lower.borrow_mut();
+ let mut buffer = vec![0; len];
+ let result = f(&mut buffer);
+ match lower.send(&buffer[..]) {
+ Ok(_) => {}
+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => {
+ net_debug!("phy: tx failed due to WouldBlock")
+ }
+ Err(err) => panic!("{}", err),
+ }
+ result
+ }
+}
diff --git a/src/phy/sys/bpf.rs b/src/phy/sys/bpf.rs
new file mode 100644
index 0000000..7e65b98
--- /dev/null
+++ b/src/phy/sys/bpf.rs
@@ -0,0 +1,180 @@
+use std::io;
+use std::mem;
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use libc;
+
+use super::{ifreq, ifreq_for};
+use crate::phy::Medium;
+use crate::wire::ETHERNET_HEADER_LEN;
+
+/// set interface
+#[cfg(any(target_os = "macos", target_os = "openbsd"))]
+const BIOCSETIF: libc::c_ulong = 0x8020426c;
+/// get buffer length
+#[cfg(any(target_os = "macos", target_os = "openbsd"))]
+const BIOCGBLEN: libc::c_ulong = 0x40044266;
+/// set immediate/nonblocking read
+#[cfg(any(target_os = "macos", target_os = "openbsd"))]
+const BIOCIMMEDIATE: libc::c_ulong = 0x80044270;
+/// set bpf_hdr struct size
+#[cfg(target_os = "macos")]
+const SIZEOF_BPF_HDR: usize = 18;
+/// set bpf_hdr struct size
+#[cfg(target_os = "openbsd")]
+const SIZEOF_BPF_HDR: usize = 24;
+/// The actual header length may be larger than the bpf_hdr struct due to aligning
+/// see https://github.com/openbsd/src/blob/37ecb4d066e5566411cc16b362d3960c93b1d0be/sys/net/bpf.c#L1649
+/// and https://github.com/apple/darwin-xnu/blob/8f02f2a044b9bb1ad951987ef5bab20ec9486310/bsd/net/bpf.c#L3580
+#[cfg(any(target_os = "macos", target_os = "openbsd"))]
+const BPF_HDRLEN: usize = (((SIZEOF_BPF_HDR + ETHERNET_HEADER_LEN) + mem::align_of::<u32>() - 1)
+ & !(mem::align_of::<u32>() - 1))
+ - ETHERNET_HEADER_LEN;
+
+macro_rules! try_ioctl {
+ ($fd:expr,$cmd:expr,$req:expr) => {
+ unsafe {
+ if libc::ioctl($fd, $cmd, $req) == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ }
+ };
+}
+
+#[derive(Debug)]
+pub struct BpfDevice {
+ fd: libc::c_int,
+ ifreq: ifreq,
+}
+
+impl AsRawFd for BpfDevice {
+ fn as_raw_fd(&self) -> RawFd {
+ self.fd
+ }
+}
+
+fn open_device() -> io::Result<libc::c_int> {
+ unsafe {
+ for i in 0..256 {
+ let dev = format!("/dev/bpf{}\0", i);
+ match libc::open(
+ dev.as_ptr() as *const libc::c_char,
+ libc::O_RDWR | libc::O_NONBLOCK,
+ ) {
+ -1 => continue,
+ fd => return Ok(fd),
+ };
+ }
+ }
+ // at this point, all 256 BPF devices were busy and we weren't able to open any
+ Err(io::Error::last_os_error())
+}
+
+impl BpfDevice {
+ pub fn new(name: &str, _medium: Medium) -> io::Result<BpfDevice> {
+ Ok(BpfDevice {
+ fd: open_device()?,
+ ifreq: ifreq_for(name),
+ })
+ }
+
+ pub fn bind_interface(&mut self) -> io::Result<()> {
+ try_ioctl!(self.fd, BIOCSETIF, &mut self.ifreq);
+
+ Ok(())
+ }
+
+ /// This in fact does not return the interface's mtu,
+ /// but it returns the size of the buffer that the app needs to allocate
+ /// for the BPF device
+ ///
+ /// The `SIOGIFMTU` cant be called on a BPF descriptor. There is a workaround
+ /// to get the actual interface mtu, but this should work better
+ ///
+ /// To get the interface MTU, you would need to create a raw socket first,
+ /// and then call `SIOGIFMTU` for the same interface your BPF device is "bound" to.
+ /// This MTU that you would get would not include the length of `struct bpf_hdr`
+ /// which gets prepended to every packet by BPF,
+ /// and your packet will be truncated if it has the length of the MTU.
+ ///
+ /// The buffer size for BPF is usually 4096 bytes, MTU is typically 1500 bytes.
+ /// You could do something like `mtu += BPF_HDRLEN`,
+ /// but you must change the buffer size the BPF device expects using `BIOCSBLEN` accordingly,
+ /// and you must set it before setting the interface with the `BIOCSETIF` ioctl.
+ ///
+ /// The reason I said this should work better is because you might see some unexpected behavior,
+ /// truncated/unaligned packets, I/O errors on read()
+ /// if you change the buffer size to the actual MTU of the interface.
+ pub fn interface_mtu(&mut self) -> io::Result<usize> {
+ let mut bufsize: libc::c_int = 1;
+ try_ioctl!(self.fd, BIOCIMMEDIATE, &mut bufsize as *mut libc::c_int);
+ try_ioctl!(self.fd, BIOCGBLEN, &mut bufsize as *mut libc::c_int);
+
+ Ok(bufsize as usize)
+ }
+
+ pub fn recv(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
+ unsafe {
+ let len = libc::read(
+ self.fd,
+ buffer.as_mut_ptr() as *mut libc::c_void,
+ buffer.len(),
+ );
+
+ if len == -1 || len < BPF_HDRLEN as isize {
+ return Err(io::Error::last_os_error());
+ }
+
+ let len = len as usize;
+
+ libc::memmove(
+ buffer.as_mut_ptr() as *mut libc::c_void,
+ &buffer[BPF_HDRLEN] as *const u8 as *const libc::c_void,
+ len - BPF_HDRLEN,
+ );
+
+ Ok(len)
+ }
+ }
+
+ pub fn send(&mut self, buffer: &[u8]) -> io::Result<usize> {
+ unsafe {
+ let len = libc::write(
+ self.fd,
+ buffer.as_ptr() as *const libc::c_void,
+ buffer.len(),
+ );
+
+ if len == -1 {
+ Err(io::Error::last_os_error()).unwrap()
+ }
+
+ Ok(len as usize)
+ }
+ }
+}
+
+impl Drop for BpfDevice {
+ fn drop(&mut self) {
+ unsafe {
+ libc::close(self.fd);
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ #[cfg(target_os = "macos")]
+ fn test_aligned_bpf_hdr_len() {
+ assert_eq!(18, BPF_HDRLEN);
+ }
+
+ #[test]
+ #[cfg(target_os = "openbsd")]
+ fn test_aligned_bpf_hdr_len() {
+ assert_eq!(26, BPF_HDRLEN);
+ }
+}
diff --git a/src/phy/sys/linux.rs b/src/phy/sys/linux.rs
new file mode 100644
index 0000000..c73eb4f
--- /dev/null
+++ b/src/phy/sys/linux.rs
@@ -0,0 +1,26 @@
+#![allow(unused)]
+
+pub const SIOCGIFMTU: libc::c_ulong = 0x8921;
+pub const SIOCGIFINDEX: libc::c_ulong = 0x8933;
+pub const ETH_P_ALL: libc::c_short = 0x0003;
+pub const ETH_P_IEEE802154: libc::c_short = 0x00F6;
+
+// Constant definition as per
+// https://github.com/golang/sys/blob/master/unix/zerrors_linux_<arch>.go
+pub const TUNSETIFF: libc::c_ulong = if cfg!(any(
+ target_arch = "mips",
+ target_arch = "mips64",
+ target_arch = "mips64el",
+ target_arch = "mipsel",
+ target_arch = "powerpc",
+ target_arch = "powerpc64",
+ target_arch = "powerpc64le",
+ target_arch = "sparc64"
+)) {
+ 0x800454CA
+} else {
+ 0x400454CA
+};
+pub const IFF_TUN: libc::c_int = 0x0001;
+pub const IFF_TAP: libc::c_int = 0x0002;
+pub const IFF_NO_PI: libc::c_int = 0x1000;
diff --git a/src/phy/sys/mod.rs b/src/phy/sys/mod.rs
new file mode 100644
index 0000000..3f42301
--- /dev/null
+++ b/src/phy/sys/mod.rs
@@ -0,0 +1,136 @@
+#![allow(unsafe_code)]
+
+use crate::time::Duration;
+use std::os::unix::io::RawFd;
+use std::{io, mem, ptr};
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[path = "linux.rs"]
+mod imp;
+
+#[cfg(all(
+ feature = "phy-raw_socket",
+ not(any(target_os = "linux", target_os = "android")),
+ unix
+))]
+pub mod bpf;
+#[cfg(all(
+ feature = "phy-raw_socket",
+ any(target_os = "linux", target_os = "android")
+))]
+pub mod raw_socket;
+#[cfg(all(
+ feature = "phy-tuntap_interface",
+ any(target_os = "linux", target_os = "android")
+))]
+pub mod tuntap_interface;
+
+#[cfg(all(
+ feature = "phy-raw_socket",
+ not(any(target_os = "linux", target_os = "android")),
+ unix
+))]
+pub use self::bpf::BpfDevice as RawSocketDesc;
+#[cfg(all(
+ feature = "phy-raw_socket",
+ any(target_os = "linux", target_os = "android")
+))]
+pub use self::raw_socket::RawSocketDesc;
+#[cfg(all(
+ feature = "phy-tuntap_interface",
+ any(target_os = "linux", target_os = "android")
+))]
+pub use self::tuntap_interface::TunTapInterfaceDesc;
+
+/// Wait until given file descriptor becomes readable, but no longer than given timeout.
+pub fn wait(fd: RawFd, duration: Option<Duration>) -> io::Result<()> {
+ unsafe {
+ let mut readfds = {
+ let mut readfds = mem::MaybeUninit::<libc::fd_set>::uninit();
+ libc::FD_ZERO(readfds.as_mut_ptr());
+ libc::FD_SET(fd, readfds.as_mut_ptr());
+ readfds.assume_init()
+ };
+
+ let mut writefds = {
+ let mut writefds = mem::MaybeUninit::<libc::fd_set>::uninit();
+ libc::FD_ZERO(writefds.as_mut_ptr());
+ writefds.assume_init()
+ };
+
+ let mut exceptfds = {
+ let mut exceptfds = mem::MaybeUninit::<libc::fd_set>::uninit();
+ libc::FD_ZERO(exceptfds.as_mut_ptr());
+ exceptfds.assume_init()
+ };
+
+ let mut timeout = libc::timeval {
+ tv_sec: 0,
+ tv_usec: 0,
+ };
+ let timeout_ptr = if let Some(duration) = duration {
+ timeout.tv_sec = duration.secs() as libc::time_t;
+ timeout.tv_usec = (duration.millis() * 1_000) as libc::suseconds_t;
+ &mut timeout as *mut _
+ } else {
+ ptr::null_mut()
+ };
+
+ let res = libc::select(
+ fd + 1,
+ &mut readfds,
+ &mut writefds,
+ &mut exceptfds,
+ timeout_ptr,
+ );
+ if res == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ Ok(())
+ }
+}
+
+#[cfg(all(
+ any(feature = "phy-tuntap_interface", feature = "phy-raw_socket"),
+ unix
+))]
+#[repr(C)]
+#[derive(Debug)]
+struct ifreq {
+ ifr_name: [libc::c_char; libc::IF_NAMESIZE],
+ ifr_data: libc::c_int, /* ifr_ifindex or ifr_mtu */
+}
+
+#[cfg(all(
+ any(feature = "phy-tuntap_interface", feature = "phy-raw_socket"),
+ unix
+))]
+fn ifreq_for(name: &str) -> ifreq {
+ let mut ifreq = ifreq {
+ ifr_name: [0; libc::IF_NAMESIZE],
+ ifr_data: 0,
+ };
+ for (i, byte) in name.as_bytes().iter().enumerate() {
+ ifreq.ifr_name[i] = *byte as libc::c_char
+ }
+ ifreq
+}
+
+#[cfg(all(
+ any(target_os = "linux", target_os = "android"),
+ any(feature = "phy-tuntap_interface", feature = "phy-raw_socket")
+))]
+fn ifreq_ioctl(
+ lower: libc::c_int,
+ ifreq: &mut ifreq,
+ cmd: libc::c_ulong,
+) -> io::Result<libc::c_int> {
+ unsafe {
+ let res = libc::ioctl(lower, cmd as _, ifreq as *mut ifreq);
+ if res == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ }
+
+ Ok(ifreq.ifr_data)
+}
diff --git a/src/phy/sys/raw_socket.rs b/src/phy/sys/raw_socket.rs
new file mode 100644
index 0000000..f37fe96
--- /dev/null
+++ b/src/phy/sys/raw_socket.rs
@@ -0,0 +1,115 @@
+use super::*;
+use crate::phy::Medium;
+use std::os::unix::io::{AsRawFd, RawFd};
+use std::{io, mem};
+
+#[derive(Debug)]
+pub struct RawSocketDesc {
+ protocol: libc::c_short,
+ lower: libc::c_int,
+ ifreq: ifreq,
+}
+
+impl AsRawFd for RawSocketDesc {
+ fn as_raw_fd(&self) -> RawFd {
+ self.lower
+ }
+}
+
+impl RawSocketDesc {
+ pub fn new(name: &str, medium: Medium) -> io::Result<RawSocketDesc> {
+ let protocol = match medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => imp::ETH_P_ALL,
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => imp::ETH_P_ALL,
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => imp::ETH_P_IEEE802154,
+ };
+
+ let lower = unsafe {
+ let lower = libc::socket(
+ libc::AF_PACKET,
+ libc::SOCK_RAW | libc::SOCK_NONBLOCK,
+ protocol.to_be() as i32,
+ );
+ if lower == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ lower
+ };
+
+ Ok(RawSocketDesc {
+ protocol,
+ lower,
+ ifreq: ifreq_for(name),
+ })
+ }
+
+ pub fn interface_mtu(&mut self) -> io::Result<usize> {
+ ifreq_ioctl(self.lower, &mut self.ifreq, imp::SIOCGIFMTU).map(|mtu| mtu as usize)
+ }
+
+ pub fn bind_interface(&mut self) -> io::Result<()> {
+ let sockaddr = libc::sockaddr_ll {
+ sll_family: libc::AF_PACKET as u16,
+ sll_protocol: self.protocol.to_be() as u16,
+ sll_ifindex: ifreq_ioctl(self.lower, &mut self.ifreq, imp::SIOCGIFINDEX)?,
+ sll_hatype: 1,
+ sll_pkttype: 0,
+ sll_halen: 6,
+ sll_addr: [0; 8],
+ };
+
+ unsafe {
+ let res = libc::bind(
+ self.lower,
+ &sockaddr as *const libc::sockaddr_ll as *const libc::sockaddr,
+ mem::size_of::<libc::sockaddr_ll>() as libc::socklen_t,
+ );
+ if res == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ }
+
+ Ok(())
+ }
+
+ pub fn recv(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
+ unsafe {
+ let len = libc::recv(
+ self.lower,
+ buffer.as_mut_ptr() as *mut libc::c_void,
+ buffer.len(),
+ 0,
+ );
+ if len == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ Ok(len as usize)
+ }
+ }
+
+ pub fn send(&mut self, buffer: &[u8]) -> io::Result<usize> {
+ unsafe {
+ let len = libc::send(
+ self.lower,
+ buffer.as_ptr() as *const libc::c_void,
+ buffer.len(),
+ 0,
+ );
+ if len == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ Ok(len as usize)
+ }
+ }
+}
+
+impl Drop for RawSocketDesc {
+ fn drop(&mut self) {
+ unsafe {
+ libc::close(self.lower);
+ }
+ }
+}
diff --git a/src/phy/sys/tuntap_interface.rs b/src/phy/sys/tuntap_interface.rs
new file mode 100644
index 0000000..3019cad
--- /dev/null
+++ b/src/phy/sys/tuntap_interface.rs
@@ -0,0 +1,130 @@
+use super::*;
+use crate::{phy::Medium, wire::EthernetFrame};
+use std::io;
+use std::os::unix::io::{AsRawFd, RawFd};
+
+#[derive(Debug)]
+pub struct TunTapInterfaceDesc {
+ lower: libc::c_int,
+ mtu: usize,
+}
+
+impl AsRawFd for TunTapInterfaceDesc {
+ fn as_raw_fd(&self) -> RawFd {
+ self.lower
+ }
+}
+
+impl TunTapInterfaceDesc {
+ pub fn new(name: &str, medium: Medium) -> io::Result<TunTapInterfaceDesc> {
+ let lower = unsafe {
+ let lower = libc::open(
+ "/dev/net/tun\0".as_ptr() as *const libc::c_char,
+ libc::O_RDWR | libc::O_NONBLOCK,
+ );
+ if lower == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ lower
+ };
+
+ let mut ifreq = ifreq_for(name);
+ Self::attach_interface_ifreq(lower, medium, &mut ifreq)?;
+ let mtu = Self::mtu_ifreq(medium, &mut ifreq)?;
+
+ Ok(TunTapInterfaceDesc { lower, mtu })
+ }
+
+ pub fn from_fd(fd: RawFd, mtu: usize) -> io::Result<TunTapInterfaceDesc> {
+ Ok(TunTapInterfaceDesc { lower: fd, mtu })
+ }
+
+ fn attach_interface_ifreq(
+ lower: libc::c_int,
+ medium: Medium,
+ ifr: &mut ifreq,
+ ) -> io::Result<()> {
+ let mode = match medium {
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => imp::IFF_TUN,
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => imp::IFF_TAP,
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => todo!(),
+ };
+ ifr.ifr_data = mode | imp::IFF_NO_PI;
+ ifreq_ioctl(lower, ifr, imp::TUNSETIFF).map(|_| ())
+ }
+
+ fn mtu_ifreq(medium: Medium, ifr: &mut ifreq) -> io::Result<usize> {
+ let lower = unsafe {
+ let lower = libc::socket(libc::AF_INET, libc::SOCK_DGRAM, libc::IPPROTO_IP);
+ if lower == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ lower
+ };
+
+ let ip_mtu = ifreq_ioctl(lower, ifr, imp::SIOCGIFMTU).map(|mtu| mtu as usize);
+
+ unsafe {
+ libc::close(lower);
+ }
+
+ // Propagate error after close, to ensure we always close.
+ let ip_mtu = ip_mtu?;
+
+ // SIOCGIFMTU returns the IP MTU (typically 1500 bytes.)
+ // smoltcp counts the entire Ethernet packet in the MTU, so add the Ethernet header size to it.
+ let mtu = match medium {
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => ip_mtu,
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => ip_mtu + EthernetFrame::<&[u8]>::header_len(),
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => todo!(),
+ };
+
+ Ok(mtu)
+ }
+
+ pub fn interface_mtu(&self) -> io::Result<usize> {
+ Ok(self.mtu)
+ }
+
+ pub fn recv(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
+ unsafe {
+ let len = libc::read(
+ self.lower,
+ buffer.as_mut_ptr() as *mut libc::c_void,
+ buffer.len(),
+ );
+ if len == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ Ok(len as usize)
+ }
+ }
+
+ pub fn send(&mut self, buffer: &[u8]) -> io::Result<usize> {
+ unsafe {
+ let len = libc::write(
+ self.lower,
+ buffer.as_ptr() as *const libc::c_void,
+ buffer.len(),
+ );
+ if len == -1 {
+ return Err(io::Error::last_os_error());
+ }
+ Ok(len as usize)
+ }
+ }
+}
+
+impl Drop for TunTapInterfaceDesc {
+ fn drop(&mut self) {
+ unsafe {
+ libc::close(self.lower);
+ }
+ }
+}
diff --git a/src/phy/tracer.rs b/src/phy/tracer.rs
new file mode 100644
index 0000000..48e60ec
--- /dev/null
+++ b/src/phy/tracer.rs
@@ -0,0 +1,189 @@
+use core::fmt;
+
+use crate::phy::{self, Device, DeviceCapabilities, Medium};
+use crate::time::Instant;
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+/// A tracer device.
+///
+/// A tracer is a device that pretty prints all packets traversing it
+/// using the provided writer function, and then passes them to another
+/// device.
+pub struct Tracer<D: Device> {
+ inner: D,
+ writer: fn(Instant, Packet),
+}
+
+impl<D: Device> Tracer<D> {
+ /// Create a tracer device.
+ pub fn new(inner: D, writer: fn(timestamp: Instant, packet: Packet)) -> Tracer<D> {
+ Tracer { inner, writer }
+ }
+
+ /// Get a reference to the underlying device.
+ ///
+ /// Even if the device offers reading through a standard reference, it is inadvisable to
+ /// directly read from the device as doing so will circumvent the tracing.
+ pub fn get_ref(&self) -> &D {
+ &self.inner
+ }
+
+ /// Get a mutable reference to the underlying device.
+ ///
+ /// It is inadvisable to directly read from the device as doing so will circumvent the tracing.
+ pub fn get_mut(&mut self) -> &mut D {
+ &mut self.inner
+ }
+
+ /// Return the underlying device, consuming the tracer.
+ pub fn into_inner(self) -> D {
+ self.inner
+ }
+}
+
+impl<D: Device> Device for Tracer<D> {
+ type RxToken<'a> = RxToken<D::RxToken<'a>>
+ where
+ Self: 'a;
+ type TxToken<'a> = TxToken<D::TxToken<'a>>
+ where
+ Self: 'a;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ self.inner.capabilities()
+ }
+
+ fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ let medium = self.inner.capabilities().medium;
+ self.inner.receive(timestamp).map(|(rx_token, tx_token)| {
+ let rx = RxToken {
+ token: rx_token,
+ writer: self.writer,
+ medium,
+ timestamp,
+ };
+ let tx = TxToken {
+ token: tx_token,
+ writer: self.writer,
+ medium,
+ timestamp,
+ };
+ (rx, tx)
+ })
+ }
+
+ fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ let medium = self.inner.capabilities().medium;
+ self.inner.transmit(timestamp).map(|tx_token| TxToken {
+ token: tx_token,
+ medium,
+ writer: self.writer,
+ timestamp,
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken<Rx: phy::RxToken> {
+ token: Rx,
+ writer: fn(Instant, Packet),
+ medium: Medium,
+ timestamp: Instant,
+}
+
+impl<Rx: phy::RxToken> phy::RxToken for RxToken<Rx> {
+ fn consume<R, F>(self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ self.token.consume(|buffer| {
+ (self.writer)(
+ self.timestamp,
+ Packet {
+ buffer,
+ medium: self.medium,
+ prefix: "<- ",
+ },
+ );
+ f(buffer)
+ })
+ }
+
+ fn meta(&self) -> phy::PacketMeta {
+ self.token.meta()
+ }
+}
+
+#[doc(hidden)]
+pub struct TxToken<Tx: phy::TxToken> {
+ token: Tx,
+ writer: fn(Instant, Packet),
+ medium: Medium,
+ timestamp: Instant,
+}
+
+impl<Tx: phy::TxToken> phy::TxToken for TxToken<Tx> {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ self.token.consume(len, |buffer| {
+ let result = f(buffer);
+ (self.writer)(
+ self.timestamp,
+ Packet {
+ buffer,
+ medium: self.medium,
+ prefix: "-> ",
+ },
+ );
+ result
+ })
+ }
+
+ fn set_meta(&mut self, meta: phy::PacketMeta) {
+ self.token.set_meta(meta)
+ }
+}
+
+pub struct Packet<'a> {
+ buffer: &'a [u8],
+ medium: Medium,
+ prefix: &'static str,
+}
+
+impl<'a> fmt::Display for Packet<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let mut indent = PrettyIndent::new(self.prefix);
+ match self.medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => crate::wire::EthernetFrame::<&'static [u8]>::pretty_print(
+ &self.buffer,
+ f,
+ &mut indent,
+ ),
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => match crate::wire::IpVersion::of_packet(self.buffer) {
+ #[cfg(feature = "proto-ipv4")]
+ Ok(crate::wire::IpVersion::Ipv4) => {
+ crate::wire::Ipv4Packet::<&'static [u8]>::pretty_print(
+ &self.buffer,
+ f,
+ &mut indent,
+ )
+ }
+ #[cfg(feature = "proto-ipv6")]
+ Ok(crate::wire::IpVersion::Ipv6) => {
+ crate::wire::Ipv6Packet::<&'static [u8]>::pretty_print(
+ &self.buffer,
+ f,
+ &mut indent,
+ )
+ }
+ _ => f.write_str("unrecognized IP version"),
+ },
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => Ok(()), // XXX
+ }
+ }
+}
diff --git a/src/phy/tuntap_interface.rs b/src/phy/tuntap_interface.rs
new file mode 100644
index 0000000..32a28db
--- /dev/null
+++ b/src/phy/tuntap_interface.rs
@@ -0,0 +1,126 @@
+use std::cell::RefCell;
+use std::io;
+use std::os::unix::io::{AsRawFd, RawFd};
+use std::rc::Rc;
+use std::vec::Vec;
+
+use crate::phy::{self, sys, Device, DeviceCapabilities, Medium};
+use crate::time::Instant;
+
+/// A virtual TUN (IP) or TAP (Ethernet) interface.
+#[derive(Debug)]
+pub struct TunTapInterface {
+ lower: Rc<RefCell<sys::TunTapInterfaceDesc>>,
+ mtu: usize,
+ medium: Medium,
+}
+
+impl AsRawFd for TunTapInterface {
+ fn as_raw_fd(&self) -> RawFd {
+ self.lower.borrow().as_raw_fd()
+ }
+}
+
+impl TunTapInterface {
+ /// Attaches to a TUN/TAP interface called `name`, or creates it if it does not exist.
+ ///
+ /// If `name` is a persistent interface configured with UID of the current user,
+ /// no special privileges are needed. Otherwise, this requires superuser privileges
+ /// or a corresponding capability set on the executable.
+ pub fn new(name: &str, medium: Medium) -> io::Result<TunTapInterface> {
+ let lower = sys::TunTapInterfaceDesc::new(name, medium)?;
+ let mtu = lower.interface_mtu()?;
+ Ok(TunTapInterface {
+ lower: Rc::new(RefCell::new(lower)),
+ mtu,
+ medium,
+ })
+ }
+
+ /// Attaches to a TUN/TAP interface specified by file descriptor `fd`.
+ ///
+ /// On platforms like Android, a file descriptor to a tun interface is exposed.
+ /// On these platforms, a TunTapInterface cannot be instantiated with a name.
+ pub fn from_fd(fd: RawFd, medium: Medium, mtu: usize) -> io::Result<TunTapInterface> {
+ let lower = sys::TunTapInterfaceDesc::from_fd(fd, mtu)?;
+ Ok(TunTapInterface {
+ lower: Rc::new(RefCell::new(lower)),
+ mtu,
+ medium,
+ })
+ }
+}
+
+impl Device for TunTapInterface {
+ type RxToken<'a> = RxToken;
+ type TxToken<'a> = TxToken;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ DeviceCapabilities {
+ max_transmission_unit: self.mtu,
+ medium: self.medium,
+ ..DeviceCapabilities::default()
+ }
+ }
+
+ fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ let mut lower = self.lower.borrow_mut();
+ let mut buffer = vec![0; self.mtu];
+ match lower.recv(&mut buffer[..]) {
+ Ok(size) => {
+ buffer.resize(size, 0);
+ let rx = RxToken { buffer };
+ let tx = TxToken {
+ lower: self.lower.clone(),
+ };
+ Some((rx, tx))
+ }
+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => None,
+ Err(err) => panic!("{}", err),
+ }
+ }
+
+ fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ Some(TxToken {
+ lower: self.lower.clone(),
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken {
+ buffer: Vec<u8>,
+}
+
+impl phy::RxToken for RxToken {
+ fn consume<R, F>(mut self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ f(&mut self.buffer[..])
+ }
+}
+
+#[doc(hidden)]
+pub struct TxToken {
+ lower: Rc<RefCell<sys::TunTapInterfaceDesc>>,
+}
+
+impl phy::TxToken for TxToken {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ let mut lower = self.lower.borrow_mut();
+ let mut buffer = vec![0; len];
+ let result = f(&mut buffer);
+ match lower.send(&buffer[..]) {
+ Ok(_) => {}
+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => {
+ net_debug!("phy: tx failed due to WouldBlock")
+ }
+ Err(err) => panic!("{}", err),
+ }
+ result
+ }
+}
diff --git a/src/rand.rs b/src/rand.rs
new file mode 100644
index 0000000..15d88f7
--- /dev/null
+++ b/src/rand.rs
@@ -0,0 +1,40 @@
+#![allow(unsafe_code)]
+#![allow(unused)]
+
+#[derive(Debug)]
+pub(crate) struct Rand {
+ state: u64,
+}
+
+impl Rand {
+ pub(crate) const fn new(seed: u64) -> Self {
+ Self { state: seed }
+ }
+
+ pub(crate) fn rand_u32(&mut self) -> u32 {
+ // sPCG32 from https://www.pcg-random.org/paper.html
+ // see also https://nullprogram.com/blog/2017/09/21/
+ const M: u64 = 0xbb2efcec3c39611d;
+ const A: u64 = 0x7590ef39;
+
+ let s = self.state.wrapping_mul(M).wrapping_add(A);
+ self.state = s;
+
+ let shift = 29 - (s >> 61);
+ (s >> shift) as u32
+ }
+
+ pub(crate) fn rand_u16(&mut self) -> u16 {
+ let n = self.rand_u32();
+ (n ^ (n >> 16)) as u16
+ }
+
+ pub(crate) fn rand_source_port(&mut self) -> u16 {
+ loop {
+ let res = self.rand_u16();
+ if res > 1024 {
+ return res;
+ }
+ }
+ }
+}
diff --git a/src/socket/dhcpv4.rs b/src/socket/dhcpv4.rs
new file mode 100644
index 0000000..13ecbd3
--- /dev/null
+++ b/src/socket/dhcpv4.rs
@@ -0,0 +1,1417 @@
+#[cfg(feature = "async")]
+use core::task::Waker;
+
+use crate::iface::Context;
+use crate::time::{Duration, Instant};
+use crate::wire::dhcpv4::field as dhcpv4_field;
+use crate::wire::{
+ DhcpMessageType, DhcpPacket, DhcpRepr, IpAddress, IpProtocol, Ipv4Address, Ipv4Cidr, Ipv4Repr,
+ UdpRepr, DHCP_CLIENT_PORT, DHCP_MAX_DNS_SERVER_COUNT, DHCP_SERVER_PORT, UDP_HEADER_LEN,
+};
+use crate::wire::{DhcpOption, HardwareAddress};
+use heapless::Vec;
+
+#[cfg(feature = "async")]
+use super::WakerRegistration;
+
+use super::PollAt;
+
+const DEFAULT_LEASE_DURATION: Duration = Duration::from_secs(120);
+
+const DEFAULT_PARAMETER_REQUEST_LIST: &[u8] = &[
+ dhcpv4_field::OPT_SUBNET_MASK,
+ dhcpv4_field::OPT_ROUTER,
+ dhcpv4_field::OPT_DOMAIN_NAME_SERVER,
+];
+
+/// IPv4 configuration data provided by the DHCP server.
+#[derive(Debug, Eq, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Config<'a> {
+ /// Information on how to reach the DHCP server that responded with DHCP
+ /// configuration.
+ pub server: ServerInfo,
+ /// IP address
+ pub address: Ipv4Cidr,
+ /// Router address, also known as default gateway. Does not necessarily
+ /// match the DHCP server's address.
+ pub router: Option<Ipv4Address>,
+ /// DNS servers
+ pub dns_servers: Vec<Ipv4Address, DHCP_MAX_DNS_SERVER_COUNT>,
+ /// Received DHCP packet
+ pub packet: Option<DhcpPacket<&'a [u8]>>,
+}
+
+/// Information on how to reach a DHCP server.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct ServerInfo {
+ /// IP address to use as destination in outgoing packets
+ pub address: Ipv4Address,
+ /// Server identifier to use in outgoing packets. Usually equal to server_address,
+ /// but may differ in some situations (eg DHCP relays)
+ pub identifier: Ipv4Address,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct DiscoverState {
+ /// When to send next request
+ retry_at: Instant,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct RequestState {
+ /// When to send next request
+ retry_at: Instant,
+ /// How many retries have been done
+ retry: u16,
+ /// Server we're trying to request from
+ server: ServerInfo,
+ /// IP address that we're trying to request.
+ requested_ip: Ipv4Address,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct RenewState {
+ /// Active network config
+ config: Config<'static>,
+
+ /// Renew timer. When reached, we will start attempting
+ /// to renew this lease with the DHCP server.
+ ///
+ /// Must be less or equal than `rebind_at`.
+ renew_at: Instant,
+
+ /// Rebind timer. When reached, we will start broadcasting to renew
+ /// this lease with any DHCP server.
+ ///
+ /// Must be greater than or equal to `renew_at`, and less than or
+ /// equal to `expires_at`.
+ rebind_at: Instant,
+
+ /// Whether the T2 time has elapsed
+ rebinding: bool,
+
+ /// Expiration timer. When reached, this lease is no longer valid, so it must be
+ /// thrown away and the ethernet interface deconfigured.
+ expires_at: Instant,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+enum ClientState {
+ /// Discovering the DHCP server
+ Discovering(DiscoverState),
+ /// Requesting an address
+ Requesting(RequestState),
+ /// Having an address, refresh it periodically.
+ Renewing(RenewState),
+}
+
+/// Timeout and retry configuration.
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub struct RetryConfig {
+ pub discover_timeout: Duration,
+ /// The REQUEST timeout doubles every 2 tries.
+ pub initial_request_timeout: Duration,
+ pub request_retries: u16,
+ pub min_renew_timeout: Duration,
+ /// An upper bound on how long to wait between retrying a renew or rebind.
+ ///
+ /// Set this to [`Duration::MAX`] if you don't want to impose an upper bound.
+ pub max_renew_timeout: Duration,
+}
+
+impl Default for RetryConfig {
+ fn default() -> Self {
+ Self {
+ discover_timeout: Duration::from_secs(10),
+ initial_request_timeout: Duration::from_secs(5),
+ request_retries: 5,
+ min_renew_timeout: Duration::from_secs(60),
+ max_renew_timeout: Duration::MAX,
+ }
+ }
+}
+
+/// Return value for the `Dhcpv4Socket::poll` function
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Event<'a> {
+ /// Configuration has been lost (for example, the lease has expired)
+ Deconfigured,
+ /// Configuration has been newly acquired, or modified.
+ Configured(Config<'a>),
+}
+
+#[derive(Debug)]
+pub struct Socket<'a> {
+ /// State of the DHCP client.
+ state: ClientState,
+ /// Set to true on config/state change, cleared back to false by the `config` function.
+ config_changed: bool,
+ /// xid of the last sent message.
+ transaction_id: u32,
+
+ /// Max lease duration. If set, it sets a maximum cap to the server-provided lease duration.
+ /// Useful to react faster to IP configuration changes and to test whether renews work correctly.
+ max_lease_duration: Option<Duration>,
+
+ retry_config: RetryConfig,
+
+ /// Ignore NAKs.
+ ignore_naks: bool,
+
+ /// Server port config
+ pub(crate) server_port: u16,
+
+ /// Client port config
+ pub(crate) client_port: u16,
+
+ /// A buffer contains options additional to be added to outgoing DHCP
+ /// packets.
+ outgoing_options: &'a [DhcpOption<'a>],
+ /// A buffer containing all requested parameters.
+ parameter_request_list: Option<&'a [u8]>,
+
+ /// Incoming DHCP packets are copied into this buffer, overwriting the previous.
+ receive_packet_buffer: Option<&'a mut [u8]>,
+
+ /// Waker registration
+ #[cfg(feature = "async")]
+ waker: WakerRegistration,
+}
+
+/// DHCP client socket.
+///
+/// The socket acquires an IP address configuration through DHCP autonomously.
+/// You must query the configuration with `.poll()` after every call to `Interface::poll()`,
+/// and apply the configuration to the `Interface`.
+impl<'a> Socket<'a> {
+ /// Create a DHCPv4 socket
+ #[allow(clippy::new_without_default)]
+ pub fn new() -> Self {
+ Socket {
+ state: ClientState::Discovering(DiscoverState {
+ retry_at: Instant::from_millis(0),
+ }),
+ config_changed: true,
+ transaction_id: 1,
+ max_lease_duration: None,
+ retry_config: RetryConfig::default(),
+ ignore_naks: false,
+ outgoing_options: &[],
+ parameter_request_list: None,
+ receive_packet_buffer: None,
+ #[cfg(feature = "async")]
+ waker: WakerRegistration::new(),
+ server_port: DHCP_SERVER_PORT,
+ client_port: DHCP_CLIENT_PORT,
+ }
+ }
+
+ /// Set the retry/timeouts configuration.
+ pub fn set_retry_config(&mut self, config: RetryConfig) {
+ self.retry_config = config;
+ }
+
+ /// Gets the current retry/timeouts configuration
+ pub fn get_retry_config(&self) -> RetryConfig {
+ self.retry_config
+ }
+
+ /// Set the outgoing options.
+ pub fn set_outgoing_options(&mut self, options: &'a [DhcpOption<'a>]) {
+ self.outgoing_options = options;
+ }
+
+ /// Set the buffer into which incoming DHCP packets are copied into.
+ pub fn set_receive_packet_buffer(&mut self, buffer: &'a mut [u8]) {
+ self.receive_packet_buffer = Some(buffer);
+ }
+
+ /// Set the parameter request list.
+ ///
+ /// This should contain at least `OPT_SUBNET_MASK` (`1`), `OPT_ROUTER`
+ /// (`3`), and `OPT_DOMAIN_NAME_SERVER` (`6`).
+ pub fn set_parameter_request_list(&mut self, parameter_request_list: &'a [u8]) {
+ self.parameter_request_list = Some(parameter_request_list);
+ }
+
+ /// Get the configured max lease duration.
+ ///
+ /// See also [`Self::set_max_lease_duration()`]
+ pub fn max_lease_duration(&self) -> Option<Duration> {
+ self.max_lease_duration
+ }
+
+ /// Set the max lease duration.
+ ///
+ /// When set, the lease duration will be capped at the configured duration if the
+ /// DHCP server gives us a longer lease. This is generally not recommended, but
+ /// can be useful for debugging or reacting faster to network configuration changes.
+ ///
+ /// If None, no max is applied (the lease duration from the DHCP server is used.)
+ pub fn set_max_lease_duration(&mut self, max_lease_duration: Option<Duration>) {
+ self.max_lease_duration = max_lease_duration;
+ }
+
+ /// Get whether to ignore NAKs.
+ ///
+ /// See also [`Self::set_ignore_naks()`]
+ pub fn ignore_naks(&self) -> bool {
+ self.ignore_naks
+ }
+
+ /// Set whether to ignore NAKs.
+ ///
+ /// This is not compliant with the DHCP RFCs, since theoretically
+ /// we must stop using the assigned IP when receiving a NAK. This
+ /// can increase reliability on broken networks with buggy routers
+ /// or rogue DHCP servers, however.
+ pub fn set_ignore_naks(&mut self, ignore_naks: bool) {
+ self.ignore_naks = ignore_naks;
+ }
+
+ /// Set the server/client port
+ ///
+ /// Allows you to specify the ports used by DHCP.
+ /// This is meant to support esoteric usecases allowed by the dhclient program.
+ pub fn set_ports(&mut self, server_port: u16, client_port: u16) {
+ self.server_port = server_port;
+ self.client_port = client_port;
+ }
+
+ pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+ let t = match &self.state {
+ ClientState::Discovering(state) => state.retry_at,
+ ClientState::Requesting(state) => state.retry_at,
+ ClientState::Renewing(state) => if state.rebinding {
+ state.rebind_at
+ } else {
+ state.renew_at.min(state.rebind_at)
+ }
+ .min(state.expires_at),
+ };
+ PollAt::Time(t)
+ }
+
+ pub(crate) fn process(
+ &mut self,
+ cx: &mut Context,
+ ip_repr: &Ipv4Repr,
+ repr: &UdpRepr,
+ payload: &[u8],
+ ) {
+ let src_ip = ip_repr.src_addr;
+
+ // This is enforced in interface.rs.
+ assert!(repr.src_port == self.server_port && repr.dst_port == self.client_port);
+
+ let dhcp_packet = match DhcpPacket::new_checked(payload) {
+ Ok(dhcp_packet) => dhcp_packet,
+ Err(e) => {
+ net_debug!("DHCP invalid pkt from {}: {:?}", src_ip, e);
+ return;
+ }
+ };
+ let dhcp_repr = match DhcpRepr::parse(&dhcp_packet) {
+ Ok(dhcp_repr) => dhcp_repr,
+ Err(e) => {
+ net_debug!("DHCP error parsing pkt from {}: {:?}", src_ip, e);
+ return;
+ }
+ };
+
+ let HardwareAddress::Ethernet(ethernet_addr) = cx.hardware_addr() else {
+ panic!("using DHCPv4 socket with a non-ethernet hardware address.");
+ };
+
+ if dhcp_repr.client_hardware_address != ethernet_addr {
+ return;
+ }
+ if dhcp_repr.transaction_id != self.transaction_id {
+ return;
+ }
+ let server_identifier = match dhcp_repr.server_identifier {
+ Some(server_identifier) => server_identifier,
+ None => {
+ net_debug!(
+ "DHCP ignoring {:?} because missing server_identifier",
+ dhcp_repr.message_type
+ );
+ return;
+ }
+ };
+
+ net_debug!(
+ "DHCP recv {:?} from {}: {:?}",
+ dhcp_repr.message_type,
+ src_ip,
+ dhcp_repr
+ );
+
+ // Copy over the payload into the receive packet buffer.
+ if let Some(buffer) = self.receive_packet_buffer.as_mut() {
+ if let Some(buffer) = buffer.get_mut(..payload.len()) {
+ buffer.copy_from_slice(payload);
+ }
+ }
+
+ match (&mut self.state, dhcp_repr.message_type) {
+ (ClientState::Discovering(_state), DhcpMessageType::Offer) => {
+ if !dhcp_repr.your_ip.is_unicast() {
+ net_debug!("DHCP ignoring OFFER because your_ip is not unicast");
+ return;
+ }
+
+ self.state = ClientState::Requesting(RequestState {
+ retry_at: cx.now(),
+ retry: 0,
+ server: ServerInfo {
+ address: src_ip,
+ identifier: server_identifier,
+ },
+ requested_ip: dhcp_repr.your_ip, // use the offered ip
+ });
+ }
+ (ClientState::Requesting(state), DhcpMessageType::Ack) => {
+ if let Some((config, renew_at, rebind_at, expires_at)) =
+ Self::parse_ack(cx.now(), &dhcp_repr, self.max_lease_duration, state.server)
+ {
+ self.state = ClientState::Renewing(RenewState {
+ config,
+ renew_at,
+ rebind_at,
+ expires_at,
+ rebinding: false,
+ });
+ self.config_changed();
+ }
+ }
+ (ClientState::Requesting(_), DhcpMessageType::Nak) => {
+ if !self.ignore_naks {
+ self.reset();
+ }
+ }
+ (ClientState::Renewing(state), DhcpMessageType::Ack) => {
+ if let Some((config, renew_at, rebind_at, expires_at)) = Self::parse_ack(
+ cx.now(),
+ &dhcp_repr,
+ self.max_lease_duration,
+ state.config.server,
+ ) {
+ state.renew_at = renew_at;
+ state.rebind_at = rebind_at;
+ state.rebinding = false;
+ state.expires_at = expires_at;
+ // The `receive_packet_buffer` field isn't populated until
+ // the client asks for the state, but receiving any packet
+ // will change it, so we indicate that the config has
+ // changed every time if the receive packet buffer is set,
+ // but we only write changes to the rest of the config now.
+ let config_changed =
+ state.config != config || self.receive_packet_buffer.is_some();
+ if state.config != config {
+ state.config = config;
+ }
+ if config_changed {
+ self.config_changed();
+ }
+ }
+ }
+ (ClientState::Renewing(_), DhcpMessageType::Nak) => {
+ if !self.ignore_naks {
+ self.reset();
+ }
+ }
+ _ => {
+ net_debug!(
+ "DHCP ignoring {:?}: unexpected in current state",
+ dhcp_repr.message_type
+ );
+ }
+ }
+ }
+
+ fn parse_ack(
+ now: Instant,
+ dhcp_repr: &DhcpRepr,
+ max_lease_duration: Option<Duration>,
+ server: ServerInfo,
+ ) -> Option<(Config<'static>, Instant, Instant, Instant)> {
+ let subnet_mask = match dhcp_repr.subnet_mask {
+ Some(subnet_mask) => subnet_mask,
+ None => {
+ net_debug!("DHCP ignoring ACK because missing subnet_mask");
+ return None;
+ }
+ };
+
+ let prefix_len = match IpAddress::Ipv4(subnet_mask).prefix_len() {
+ Some(prefix_len) => prefix_len,
+ None => {
+ net_debug!("DHCP ignoring ACK because subnet_mask is not a valid mask");
+ return None;
+ }
+ };
+
+ if !dhcp_repr.your_ip.is_unicast() {
+ net_debug!("DHCP ignoring ACK because your_ip is not unicast");
+ return None;
+ }
+
+ let mut lease_duration = dhcp_repr
+ .lease_duration
+ .map(|d| Duration::from_secs(d as _))
+ .unwrap_or(DEFAULT_LEASE_DURATION);
+ if let Some(max_lease_duration) = max_lease_duration {
+ lease_duration = lease_duration.min(max_lease_duration);
+ }
+
+ // Cleanup the DNS servers list, keeping only unicasts/
+ // TP-Link TD-W8970 sends 0.0.0.0 as second DNS server if there's only one configured :(
+ let mut dns_servers = Vec::new();
+
+ dhcp_repr
+ .dns_servers
+ .iter()
+ .flatten()
+ .filter(|s| s.is_unicast())
+ .for_each(|a| {
+ // This will never produce an error, as both the arrays and `dns_servers`
+ // have length DHCP_MAX_DNS_SERVER_COUNT
+ dns_servers.push(*a).ok();
+ });
+
+ let config = Config {
+ server,
+ address: Ipv4Cidr::new(dhcp_repr.your_ip, prefix_len),
+ router: dhcp_repr.router,
+ dns_servers,
+ packet: None,
+ };
+
+ // Set renew and rebind times as per RFC 2131:
+ // Times T1 and T2 are configurable by the server through
+ // options. T1 defaults to (0.5 * duration_of_lease). T2
+ // defaults to (0.875 * duration_of_lease).
+ let (renew_duration, rebind_duration) = match (
+ dhcp_repr
+ .renew_duration
+ .map(|d| Duration::from_secs(d as u64)),
+ dhcp_repr
+ .rebind_duration
+ .map(|d| Duration::from_secs(d as u64)),
+ ) {
+ (Some(renew_duration), Some(rebind_duration)) => (renew_duration, rebind_duration),
+ (None, None) => (lease_duration / 2, lease_duration * 7 / 8),
+ // RFC 2131 does not say what to do if only one value is
+ // provided, so:
+
+ // If only T1 is provided, set T2 to be 0.75 through the gap
+ // between T1 and the duration of the lease. If T1 is set to
+ // the default (0.5 * duration_of_lease), then T2 will also
+ // be set to the default (0.875 * duration_of_lease).
+ (Some(renew_duration), None) => (
+ renew_duration,
+ renew_duration + (lease_duration - renew_duration) * 3 / 4,
+ ),
+
+ // If only T2 is provided, then T1 will be set to be
+ // whichever is smaller of the default (0.5 *
+ // duration_of_lease) or T2.
+ (None, Some(rebind_duration)) => {
+ ((lease_duration / 2).min(rebind_duration), rebind_duration)
+ }
+ };
+ let renew_at = now + renew_duration;
+ let rebind_at = now + rebind_duration;
+ let expires_at = now + lease_duration;
+
+ Some((config, renew_at, rebind_at, expires_at))
+ }
+
+ #[cfg(not(test))]
+ fn random_transaction_id(cx: &mut Context) -> u32 {
+ cx.rand().rand_u32()
+ }
+
+ #[cfg(test)]
+ fn random_transaction_id(_cx: &mut Context) -> u32 {
+ 0x12345678
+ }
+
+ pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+ where
+ F: FnOnce(&mut Context, (Ipv4Repr, UdpRepr, DhcpRepr)) -> Result<(), E>,
+ {
+ // note: Dhcpv4Socket is only usable in ethernet mediums, so the
+ // unwrap can never fail.
+ let HardwareAddress::Ethernet(ethernet_addr) = cx.hardware_addr() else {
+ panic!("using DHCPv4 socket with a non-ethernet hardware address.");
+ };
+
+ // Worst case biggest IPv4 header length.
+ // 0x0f * 4 = 60 bytes.
+ const MAX_IPV4_HEADER_LEN: usize = 60;
+
+ // We don't directly modify self.transaction_id because sending the packet
+ // may fail. We only want to update state after successfully sending.
+ let next_transaction_id = Self::random_transaction_id(cx);
+
+ let mut dhcp_repr = DhcpRepr {
+ message_type: DhcpMessageType::Discover,
+ transaction_id: next_transaction_id,
+ secs: 0,
+ client_hardware_address: ethernet_addr,
+ client_ip: Ipv4Address::UNSPECIFIED,
+ your_ip: Ipv4Address::UNSPECIFIED,
+ server_ip: Ipv4Address::UNSPECIFIED,
+ router: None,
+ subnet_mask: None,
+ relay_agent_ip: Ipv4Address::UNSPECIFIED,
+ broadcast: false,
+ requested_ip: None,
+ client_identifier: Some(ethernet_addr),
+ server_identifier: None,
+ parameter_request_list: Some(
+ self.parameter_request_list
+ .unwrap_or(DEFAULT_PARAMETER_REQUEST_LIST),
+ ),
+ max_size: Some((cx.ip_mtu() - MAX_IPV4_HEADER_LEN - UDP_HEADER_LEN) as u16),
+ lease_duration: None,
+ renew_duration: None,
+ rebind_duration: None,
+ dns_servers: None,
+ additional_options: self.outgoing_options,
+ };
+
+ let udp_repr = UdpRepr {
+ src_port: self.client_port,
+ dst_port: self.server_port,
+ };
+
+ let mut ipv4_repr = Ipv4Repr {
+ src_addr: Ipv4Address::UNSPECIFIED,
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Udp,
+ payload_len: 0, // filled right before emit
+ hop_limit: 64,
+ };
+
+ match &mut self.state {
+ ClientState::Discovering(state) => {
+ if cx.now() < state.retry_at {
+ return Ok(());
+ }
+
+ // send packet
+ net_debug!(
+ "DHCP send DISCOVER to {}: {:?}",
+ ipv4_repr.dst_addr,
+ dhcp_repr
+ );
+ ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
+ emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
+
+ // Update state AFTER the packet has been successfully sent.
+ state.retry_at = cx.now() + self.retry_config.discover_timeout;
+ self.transaction_id = next_transaction_id;
+ Ok(())
+ }
+ ClientState::Requesting(state) => {
+ if cx.now() < state.retry_at {
+ return Ok(());
+ }
+
+ if state.retry >= self.retry_config.request_retries {
+ net_debug!("DHCP request retries exceeded, restarting discovery");
+ self.reset();
+ return Ok(());
+ }
+
+ dhcp_repr.message_type = DhcpMessageType::Request;
+ dhcp_repr.requested_ip = Some(state.requested_ip);
+ dhcp_repr.server_identifier = Some(state.server.identifier);
+
+ net_debug!(
+ "DHCP send request to {}: {:?}",
+ ipv4_repr.dst_addr,
+ dhcp_repr
+ );
+ ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
+ emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
+
+ // Exponential backoff: Double every 2 retries.
+ state.retry_at = cx.now()
+ + (self.retry_config.initial_request_timeout << (state.retry as u32 / 2));
+ state.retry += 1;
+
+ self.transaction_id = next_transaction_id;
+ Ok(())
+ }
+ ClientState::Renewing(state) => {
+ let now = cx.now();
+ if state.expires_at <= now {
+ net_debug!("DHCP lease expired");
+ self.reset();
+ // return Ok so we get polled again
+ return Ok(());
+ }
+
+ if now < state.renew_at || state.rebinding && now < state.rebind_at {
+ return Ok(());
+ }
+
+ state.rebinding |= now >= state.rebind_at;
+
+ ipv4_repr.src_addr = state.config.address.address();
+ // Renewing is unicast to the original server, rebinding is broadcast
+ if !state.rebinding {
+ ipv4_repr.dst_addr = state.config.server.address;
+ }
+ dhcp_repr.message_type = DhcpMessageType::Request;
+ dhcp_repr.client_ip = state.config.address.address();
+
+ net_debug!("DHCP send renew to {}: {:?}", ipv4_repr.dst_addr, dhcp_repr);
+ ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
+ emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
+
+ // In both RENEWING and REBINDING states, if the client receives no
+ // response to its DHCPREQUEST message, the client SHOULD wait one-half
+ // of the remaining time until T2 (in RENEWING state) and one-half of
+ // the remaining lease time (in REBINDING state), down to a minimum of
+ // 60 seconds, before retransmitting the DHCPREQUEST message.
+ if state.rebinding {
+ state.rebind_at = now
+ + self
+ .retry_config
+ .min_renew_timeout
+ .max((state.expires_at - now) / 2)
+ .min(self.retry_config.max_renew_timeout);
+ } else {
+ state.renew_at = now
+ + self
+ .retry_config
+ .min_renew_timeout
+ .max((state.rebind_at - now) / 2)
+ .min(state.rebind_at - now)
+ .min(self.retry_config.max_renew_timeout);
+ }
+
+ self.transaction_id = next_transaction_id;
+ Ok(())
+ }
+ }
+ }
+
+ /// Reset state and restart discovery phase.
+ ///
+ /// Use this to speed up acquisition of an address in a new
+ /// network if a link was down and it is now back up.
+ pub fn reset(&mut self) {
+ net_trace!("DHCP reset");
+ if let ClientState::Renewing(_) = &self.state {
+ self.config_changed();
+ }
+ self.state = ClientState::Discovering(DiscoverState {
+ retry_at: Instant::from_millis(0),
+ });
+ }
+
+ /// Query the socket for configuration changes.
+ ///
+ /// The socket has an internal "configuration changed" flag. If
+ /// set, this function returns the configuration and resets the flag.
+ pub fn poll(&mut self) -> Option<Event> {
+ if !self.config_changed {
+ None
+ } else if let ClientState::Renewing(state) = &self.state {
+ self.config_changed = false;
+ Some(Event::Configured(Config {
+ server: state.config.server,
+ address: state.config.address,
+ router: state.config.router,
+ dns_servers: state.config.dns_servers.clone(),
+ packet: self
+ .receive_packet_buffer
+ .as_deref()
+ .map(DhcpPacket::new_unchecked),
+ }))
+ } else {
+ self.config_changed = false;
+ Some(Event::Deconfigured)
+ }
+ }
+
+ /// This function _must_ be called when the configuration provided to the
+ /// interface, by this DHCP socket, changes. It will update the `config_changed` field
+ /// so that a subsequent call to `poll` will yield an event, and wake a possible waker.
+ pub(crate) fn config_changed(&mut self) {
+ self.config_changed = true;
+ #[cfg(feature = "async")]
+ self.waker.wake();
+ }
+
+ /// Register a waker.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `poll` method calls, which indicates a new state in the DHCP configuration
+ /// provided by this DHCP socket.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ #[cfg(feature = "async")]
+ pub fn register_waker(&mut self, waker: &Waker) {
+ self.waker.register(waker)
+ }
+}
+
+#[cfg(test)]
+mod test {
+
+ use std::ops::{Deref, DerefMut};
+
+ use super::*;
+ use crate::wire::EthernetAddress;
+
+ // =========================================================================================//
+ // Helper functions
+
+ struct TestSocket {
+ socket: Socket<'static>,
+ cx: Context,
+ }
+
+ impl Deref for TestSocket {
+ type Target = Socket<'static>;
+ fn deref(&self) -> &Self::Target {
+ &self.socket
+ }
+ }
+
+ impl DerefMut for TestSocket {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.socket
+ }
+ }
+
+ fn send(
+ s: &mut TestSocket,
+ timestamp: Instant,
+ (ip_repr, udp_repr, dhcp_repr): (Ipv4Repr, UdpRepr, DhcpRepr),
+ ) {
+ s.cx.set_now(timestamp);
+
+ net_trace!("send: {:?}", ip_repr);
+ net_trace!(" {:?}", udp_repr);
+ net_trace!(" {:?}", dhcp_repr);
+
+ let mut payload = vec![0; dhcp_repr.buffer_len()];
+ dhcp_repr
+ .emit(&mut DhcpPacket::new_unchecked(&mut payload))
+ .unwrap();
+
+ s.socket.process(&mut s.cx, &ip_repr, &udp_repr, &payload)
+ }
+
+ fn recv(s: &mut TestSocket, timestamp: Instant, reprs: &[(Ipv4Repr, UdpRepr, DhcpRepr)]) {
+ s.cx.set_now(timestamp);
+
+ let mut i = 0;
+
+ while s.socket.poll_at(&mut s.cx) <= PollAt::Time(timestamp) {
+ let _ = s
+ .socket
+ .dispatch(&mut s.cx, |_, (mut ip_repr, udp_repr, dhcp_repr)| {
+ assert_eq!(ip_repr.next_header, IpProtocol::Udp);
+ assert_eq!(
+ ip_repr.payload_len,
+ udp_repr.header_len() + dhcp_repr.buffer_len()
+ );
+
+ // We validated the payload len, change it to 0 to make equality testing easier
+ ip_repr.payload_len = 0;
+
+ net_trace!("recv: {:?}", ip_repr);
+ net_trace!(" {:?}", udp_repr);
+ net_trace!(" {:?}", dhcp_repr);
+
+ let got_repr = (ip_repr, udp_repr, dhcp_repr);
+ match reprs.get(i) {
+ Some(want_repr) => assert_eq!(want_repr, &got_repr),
+ None => panic!("Too many reprs emitted"),
+ }
+ i += 1;
+ Ok::<_, ()>(())
+ });
+ }
+
+ assert_eq!(i, reprs.len());
+ }
+
+ macro_rules! send {
+ ($socket:ident, $repr:expr) =>
+ (send!($socket, time 0, $repr));
+ ($socket:ident, time $time:expr, $repr:expr) =>
+ (send(&mut $socket, Instant::from_millis($time), $repr));
+ }
+
+ macro_rules! recv {
+ ($socket:ident, $reprs:expr) => ({
+ recv!($socket, time 0, $reprs);
+ });
+ ($socket:ident, time $time:expr, $reprs:expr) => ({
+ recv(&mut $socket, Instant::from_millis($time), &$reprs);
+ });
+ }
+
+ // =========================================================================================//
+ // Constants
+
+ const TXID: u32 = 0x12345678;
+
+ const MY_IP: Ipv4Address = Ipv4Address([192, 168, 1, 42]);
+ const SERVER_IP: Ipv4Address = Ipv4Address([192, 168, 1, 1]);
+ const DNS_IP_1: Ipv4Address = Ipv4Address([1, 1, 1, 1]);
+ const DNS_IP_2: Ipv4Address = Ipv4Address([1, 1, 1, 2]);
+ const DNS_IP_3: Ipv4Address = Ipv4Address([1, 1, 1, 3]);
+ const DNS_IPS: &[Ipv4Address] = &[DNS_IP_1, DNS_IP_2, DNS_IP_3];
+
+ const MASK_24: Ipv4Address = Ipv4Address([255, 255, 255, 0]);
+
+ const MY_MAC: EthernetAddress = EthernetAddress([0x02, 0x02, 0x02, 0x02, 0x02, 0x02]);
+
+ const IP_BROADCAST: Ipv4Repr = Ipv4Repr {
+ src_addr: Ipv4Address::UNSPECIFIED,
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Udp,
+ payload_len: 0,
+ hop_limit: 64,
+ };
+
+ const IP_BROADCAST_ADDRESSED: Ipv4Repr = Ipv4Repr {
+ src_addr: MY_IP,
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Udp,
+ payload_len: 0,
+ hop_limit: 64,
+ };
+
+ const IP_SERVER_BROADCAST: Ipv4Repr = Ipv4Repr {
+ src_addr: SERVER_IP,
+ dst_addr: Ipv4Address::BROADCAST,
+ next_header: IpProtocol::Udp,
+ payload_len: 0,
+ hop_limit: 64,
+ };
+
+ const IP_RECV: Ipv4Repr = Ipv4Repr {
+ src_addr: SERVER_IP,
+ dst_addr: MY_IP,
+ next_header: IpProtocol::Udp,
+ payload_len: 0,
+ hop_limit: 64,
+ };
+
+ const IP_SEND: Ipv4Repr = Ipv4Repr {
+ src_addr: MY_IP,
+ dst_addr: SERVER_IP,
+ next_header: IpProtocol::Udp,
+ payload_len: 0,
+ hop_limit: 64,
+ };
+
+ const UDP_SEND: UdpRepr = UdpRepr {
+ src_port: DHCP_CLIENT_PORT,
+ dst_port: DHCP_SERVER_PORT,
+ };
+ const UDP_RECV: UdpRepr = UdpRepr {
+ src_port: DHCP_SERVER_PORT,
+ dst_port: DHCP_CLIENT_PORT,
+ };
+
+ const DIFFERENT_CLIENT_PORT: u16 = 6800;
+ const DIFFERENT_SERVER_PORT: u16 = 6700;
+
+ const UDP_SEND_DIFFERENT_PORT: UdpRepr = UdpRepr {
+ src_port: DIFFERENT_CLIENT_PORT,
+ dst_port: DIFFERENT_SERVER_PORT,
+ };
+ const UDP_RECV_DIFFERENT_PORT: UdpRepr = UdpRepr {
+ src_port: DIFFERENT_SERVER_PORT,
+ dst_port: DIFFERENT_CLIENT_PORT,
+ };
+
+ const DHCP_DEFAULT: DhcpRepr = DhcpRepr {
+ message_type: DhcpMessageType::Unknown(99),
+ transaction_id: TXID,
+ secs: 0,
+ client_hardware_address: MY_MAC,
+ client_ip: Ipv4Address::UNSPECIFIED,
+ your_ip: Ipv4Address::UNSPECIFIED,
+ server_ip: Ipv4Address::UNSPECIFIED,
+ router: None,
+ subnet_mask: None,
+ relay_agent_ip: Ipv4Address::UNSPECIFIED,
+ broadcast: false,
+ requested_ip: None,
+ client_identifier: None,
+ server_identifier: None,
+ parameter_request_list: None,
+ dns_servers: None,
+ max_size: None,
+ renew_duration: None,
+ rebind_duration: None,
+ lease_duration: None,
+ additional_options: &[],
+ };
+
+ const DHCP_DISCOVER: DhcpRepr = DhcpRepr {
+ message_type: DhcpMessageType::Discover,
+ client_identifier: Some(MY_MAC),
+ parameter_request_list: Some(&[1, 3, 6]),
+ max_size: Some(1432),
+ ..DHCP_DEFAULT
+ };
+
+ fn dhcp_offer() -> DhcpRepr<'static> {
+ DhcpRepr {
+ message_type: DhcpMessageType::Offer,
+ server_ip: SERVER_IP,
+ server_identifier: Some(SERVER_IP),
+
+ your_ip: MY_IP,
+ router: Some(SERVER_IP),
+ subnet_mask: Some(MASK_24),
+ dns_servers: Some(Vec::from_slice(DNS_IPS).unwrap()),
+ lease_duration: Some(1000),
+
+ ..DHCP_DEFAULT
+ }
+ }
+
+ const DHCP_REQUEST: DhcpRepr = DhcpRepr {
+ message_type: DhcpMessageType::Request,
+ client_identifier: Some(MY_MAC),
+ server_identifier: Some(SERVER_IP),
+ max_size: Some(1432),
+
+ requested_ip: Some(MY_IP),
+ parameter_request_list: Some(&[1, 3, 6]),
+ ..DHCP_DEFAULT
+ };
+
+ fn dhcp_ack() -> DhcpRepr<'static> {
+ DhcpRepr {
+ message_type: DhcpMessageType::Ack,
+ server_ip: SERVER_IP,
+ server_identifier: Some(SERVER_IP),
+
+ your_ip: MY_IP,
+ router: Some(SERVER_IP),
+ subnet_mask: Some(MASK_24),
+ dns_servers: Some(Vec::from_slice(DNS_IPS).unwrap()),
+ lease_duration: Some(1000),
+
+ ..DHCP_DEFAULT
+ }
+ }
+
+ const DHCP_NAK: DhcpRepr = DhcpRepr {
+ message_type: DhcpMessageType::Nak,
+ server_ip: SERVER_IP,
+ server_identifier: Some(SERVER_IP),
+ ..DHCP_DEFAULT
+ };
+
+ const DHCP_RENEW: DhcpRepr = DhcpRepr {
+ message_type: DhcpMessageType::Request,
+ client_identifier: Some(MY_MAC),
+ // NO server_identifier in renew requests, only in first one!
+ client_ip: MY_IP,
+ max_size: Some(1432),
+
+ requested_ip: None,
+ parameter_request_list: Some(&[1, 3, 6]),
+ ..DHCP_DEFAULT
+ };
+
+ const DHCP_REBIND: DhcpRepr = DhcpRepr {
+ message_type: DhcpMessageType::Request,
+ client_identifier: Some(MY_MAC),
+ // NO server_identifier in renew requests, only in first one!
+ client_ip: MY_IP,
+ max_size: Some(1432),
+
+ requested_ip: None,
+ parameter_request_list: Some(&[1, 3, 6]),
+ ..DHCP_DEFAULT
+ };
+
+ // =========================================================================================//
+ // Tests
+
+ use crate::phy::Medium;
+ use crate::tests::setup;
+ use rstest::*;
+
+ fn socket(medium: Medium) -> TestSocket {
+ let (iface, _, _) = setup(medium);
+ let mut s = Socket::new();
+ assert_eq!(s.poll(), Some(Event::Deconfigured));
+ TestSocket {
+ socket: s,
+ cx: iface.inner,
+ }
+ }
+
+ fn socket_different_port(medium: Medium) -> TestSocket {
+ let (iface, _, _) = setup(medium);
+ let mut s = Socket::new();
+ s.set_ports(DIFFERENT_SERVER_PORT, DIFFERENT_CLIENT_PORT);
+
+ assert_eq!(s.poll(), Some(Event::Deconfigured));
+ TestSocket {
+ socket: s,
+ cx: iface.inner,
+ }
+ }
+
+ fn socket_bound(medium: Medium) -> TestSocket {
+ let mut s = socket(medium);
+ s.state = ClientState::Renewing(RenewState {
+ config: Config {
+ server: ServerInfo {
+ address: SERVER_IP,
+ identifier: SERVER_IP,
+ },
+ address: Ipv4Cidr::new(MY_IP, 24),
+ dns_servers: Vec::from_slice(DNS_IPS).unwrap(),
+ router: Some(SERVER_IP),
+ packet: None,
+ },
+ renew_at: Instant::from_secs(500),
+ rebind_at: Instant::from_secs(875),
+ rebinding: false,
+ expires_at: Instant::from_secs(1000),
+ });
+
+ s
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_bind(#[case] medium: Medium) {
+ let mut s = socket(medium);
+
+ recv!(s, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ assert_eq!(s.poll(), None);
+ send!(s, (IP_RECV, UDP_RECV, dhcp_offer()));
+ assert_eq!(s.poll(), None);
+ recv!(s, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ assert_eq!(s.poll(), None);
+ send!(s, (IP_RECV, UDP_RECV, dhcp_ack()));
+
+ assert_eq!(
+ s.poll(),
+ Some(Event::Configured(Config {
+ server: ServerInfo {
+ address: SERVER_IP,
+ identifier: SERVER_IP,
+ },
+ address: Ipv4Cidr::new(MY_IP, 24),
+ dns_servers: Vec::from_slice(DNS_IPS).unwrap(),
+ router: Some(SERVER_IP),
+ packet: None,
+ }))
+ );
+
+ match &s.state {
+ ClientState::Renewing(r) => {
+ assert_eq!(r.renew_at, Instant::from_secs(500));
+ assert_eq!(r.rebind_at, Instant::from_secs(875));
+ assert_eq!(r.expires_at, Instant::from_secs(1000));
+ }
+ _ => panic!("Invalid state"),
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_bind_different_ports(#[case] medium: Medium) {
+ let mut s = socket_different_port(medium);
+
+ recv!(s, [(IP_BROADCAST, UDP_SEND_DIFFERENT_PORT, DHCP_DISCOVER)]);
+ assert_eq!(s.poll(), None);
+ send!(s, (IP_RECV, UDP_RECV_DIFFERENT_PORT, dhcp_offer()));
+ assert_eq!(s.poll(), None);
+ recv!(s, [(IP_BROADCAST, UDP_SEND_DIFFERENT_PORT, DHCP_REQUEST)]);
+ assert_eq!(s.poll(), None);
+ send!(s, (IP_RECV, UDP_RECV_DIFFERENT_PORT, dhcp_ack()));
+
+ assert_eq!(
+ s.poll(),
+ Some(Event::Configured(Config {
+ server: ServerInfo {
+ address: SERVER_IP,
+ identifier: SERVER_IP,
+ },
+ address: Ipv4Cidr::new(MY_IP, 24),
+ dns_servers: Vec::from_slice(DNS_IPS).unwrap(),
+ router: Some(SERVER_IP),
+ packet: None,
+ }))
+ );
+
+ match &s.state {
+ ClientState::Renewing(r) => {
+ assert_eq!(r.renew_at, Instant::from_secs(500));
+ assert_eq!(r.rebind_at, Instant::from_secs(875));
+ assert_eq!(r.expires_at, Instant::from_secs(1000));
+ }
+ _ => panic!("Invalid state"),
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_discover_retransmit(#[case] medium: Medium) {
+ let mut s = socket(medium);
+
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ recv!(s, time 1_000, []);
+ recv!(s, time 10_000, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ recv!(s, time 11_000, []);
+ recv!(s, time 20_000, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+
+ // check after retransmits it still works
+ send!(s, time 20_000, (IP_RECV, UDP_RECV, dhcp_offer()));
+ recv!(s, time 20_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_request_retransmit(#[case] medium: Medium) {
+ let mut s = socket(medium);
+
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ send!(s, time 0, (IP_RECV, UDP_RECV, dhcp_offer()));
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ recv!(s, time 1_000, []);
+ recv!(s, time 5_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ recv!(s, time 6_000, []);
+ recv!(s, time 10_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ recv!(s, time 15_000, []);
+ recv!(s, time 20_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+
+ // check after retransmits it still works
+ send!(s, time 20_000, (IP_RECV, UDP_RECV, dhcp_ack()));
+
+ match &s.state {
+ ClientState::Renewing(r) => {
+ assert_eq!(r.renew_at, Instant::from_secs(20 + 500));
+ assert_eq!(r.expires_at, Instant::from_secs(20 + 1000));
+ }
+ _ => panic!("Invalid state"),
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_request_timeout(#[case] medium: Medium) {
+ let mut s = socket(medium);
+
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ send!(s, time 0, (IP_RECV, UDP_RECV, dhcp_offer()));
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ recv!(s, time 5_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ recv!(s, time 10_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ recv!(s, time 20_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ recv!(s, time 30_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+
+ // After 5 tries and 70 seconds, it gives up.
+ // 5 + 5 + 10 + 10 + 20 = 70
+ recv!(s, time 70_000, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+
+ // check it still works
+ send!(s, time 60_000, (IP_RECV, UDP_RECV, dhcp_offer()));
+ recv!(s, time 60_000, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_request_nak(#[case] medium: Medium) {
+ let mut s = socket(medium);
+
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ send!(s, time 0, (IP_RECV, UDP_RECV, dhcp_offer()));
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_REQUEST)]);
+ send!(s, time 0, (IP_SERVER_BROADCAST, UDP_RECV, DHCP_NAK));
+ recv!(s, time 0, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_renew(#[case] medium: Medium) {
+ let mut s = socket_bound(medium);
+
+ recv!(s, []);
+ assert_eq!(s.poll(), None);
+ recv!(s, time 500_000, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ assert_eq!(s.poll(), None);
+
+ match &s.state {
+ ClientState::Renewing(r) => {
+ // the expiration still hasn't been bumped, because
+ // we haven't received the ACK yet
+ assert_eq!(r.expires_at, Instant::from_secs(1000));
+ }
+ _ => panic!("Invalid state"),
+ }
+
+ send!(s, time 500_000, (IP_RECV, UDP_RECV, dhcp_ack()));
+ assert_eq!(s.poll(), None);
+
+ match &s.state {
+ ClientState::Renewing(r) => {
+ // NOW the expiration gets bumped
+ assert_eq!(r.renew_at, Instant::from_secs(500 + 500));
+ assert_eq!(r.expires_at, Instant::from_secs(500 + 1000));
+ }
+ _ => panic!("Invalid state"),
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_renew_rebind_retransmit(#[case] medium: Medium) {
+ let mut s = socket_bound(medium);
+
+ recv!(s, []);
+ // First renew attempt at T1
+ recv!(s, time 499_000, []);
+ recv!(s, time 500_000, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt at half way to T2
+ recv!(s, time 687_000, []);
+ recv!(s, time 687_500, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt at half way again to T2
+ recv!(s, time 781_000, []);
+ recv!(s, time 781_250, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt 60s later (minimum interval)
+ recv!(s, time 841_000, []);
+ recv!(s, time 841_250, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // No more renews due to minimum interval
+ recv!(s, time 874_000, []);
+ // First rebind attempt
+ recv!(s, time 875_000, [(IP_BROADCAST_ADDRESSED, UDP_SEND, DHCP_REBIND)]);
+ // Next rebind attempt half way to expiry
+ recv!(s, time 937_000, []);
+ recv!(s, time 937_500, [(IP_BROADCAST_ADDRESSED, UDP_SEND, DHCP_REBIND)]);
+ // Next rebind attempt 60s later (minimum interval)
+ recv!(s, time 997_000, []);
+ recv!(s, time 997_500, [(IP_BROADCAST_ADDRESSED, UDP_SEND, DHCP_REBIND)]);
+
+ // check it still works
+ send!(s, time 999_000, (IP_RECV, UDP_RECV, dhcp_ack()));
+ match &s.state {
+ ClientState::Renewing(r) => {
+ // NOW the expiration gets bumped
+ assert_eq!(r.renew_at, Instant::from_secs(999 + 500));
+ assert_eq!(r.expires_at, Instant::from_secs(999 + 1000));
+ }
+ _ => panic!("Invalid state"),
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_renew_rebind_timeout(#[case] medium: Medium) {
+ let mut s = socket_bound(medium);
+
+ recv!(s, []);
+ // First renew attempt at T1
+ recv!(s, time 500_000, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt at half way to T2
+ recv!(s, time 687_500, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt at half way again to T2
+ recv!(s, time 781_250, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt 60s later (minimum interval)
+ recv!(s, time 841_250, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // TODO uncomment below part of test
+ // // First rebind attempt
+ // recv!(s, time 875_000, [(IP_BROADCAST_ADDRESSED, UDP_SEND, DHCP_REBIND)]);
+ // // Next rebind attempt half way to expiry
+ // recv!(s, time 937_500, [(IP_BROADCAST_ADDRESSED, UDP_SEND, DHCP_REBIND)]);
+ // // Next rebind attempt 60s later (minimum interval)
+ // recv!(s, time 997_500, [(IP_BROADCAST_ADDRESSED, UDP_SEND, DHCP_REBIND)]);
+ // No more rebinds due to minimum interval
+ recv!(s, time 1_000_000, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ match &s.state {
+ ClientState::Discovering(_) => {}
+ _ => panic!("Invalid state"),
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_min_max_renew_timeout(#[case] medium: Medium) {
+ let mut s = socket_bound(medium);
+ // Set a minimum of 45s and a maximum of 120s
+ let config = RetryConfig {
+ max_renew_timeout: Duration::from_secs(120),
+ min_renew_timeout: Duration::from_secs(45),
+ ..s.get_retry_config()
+ };
+ s.set_retry_config(config);
+ recv!(s, []);
+ // First renew attempt at T1
+ recv!(s, time 499_999, []);
+ recv!(s, time 500_000, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt 120s after T1 because we hit the max
+ recv!(s, time 619_999, []);
+ recv!(s, time 620_000, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt 120s after previous because we hit the max again
+ recv!(s, time 739_999, []);
+ recv!(s, time 740_000, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt half way to T2
+ recv!(s, time 807_499, []);
+ recv!(s, time 807_500, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next renew attempt 45s after previous because we hit the min
+ recv!(s, time 852_499, []);
+ recv!(s, time 852_500, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ // Next is a rebind, because the min puts us after T2
+ recv!(s, time 874_999, []);
+ recv!(s, time 875_000, [(IP_BROADCAST_ADDRESSED, UDP_SEND, DHCP_REBIND)]);
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_renew_nak(#[case] medium: Medium) {
+ let mut s = socket_bound(medium);
+
+ recv!(s, time 500_000, [(IP_SEND, UDP_SEND, DHCP_RENEW)]);
+ send!(s, time 500_000, (IP_SERVER_BROADCAST, UDP_RECV, DHCP_NAK));
+ recv!(s, time 500_000, [(IP_BROADCAST, UDP_SEND, DHCP_DISCOVER)]);
+ }
+}
diff --git a/src/socket/dns.rs b/src/socket/dns.rs
new file mode 100644
index 0000000..610d5c6
--- /dev/null
+++ b/src/socket/dns.rs
@@ -0,0 +1,699 @@
+#[cfg(feature = "async")]
+use core::task::Waker;
+
+use heapless::Vec;
+use managed::ManagedSlice;
+
+use crate::config::{DNS_MAX_NAME_SIZE, DNS_MAX_RESULT_COUNT, DNS_MAX_SERVER_COUNT};
+use crate::socket::{Context, PollAt};
+use crate::time::{Duration, Instant};
+use crate::wire::dns::{Flags, Opcode, Packet, Question, Rcode, Record, RecordData, Repr, Type};
+use crate::wire::{self, IpAddress, IpProtocol, IpRepr, UdpRepr};
+
+#[cfg(feature = "async")]
+use super::WakerRegistration;
+
+const DNS_PORT: u16 = 53;
+const MDNS_DNS_PORT: u16 = 5353;
+const RETRANSMIT_DELAY: Duration = Duration::from_millis(1_000);
+const MAX_RETRANSMIT_DELAY: Duration = Duration::from_millis(10_000);
+const RETRANSMIT_TIMEOUT: Duration = Duration::from_millis(10_000); // Should generally be 2-10 secs
+
+#[cfg(feature = "proto-ipv6")]
+const MDNS_IPV6_ADDR: IpAddress = IpAddress::Ipv6(crate::wire::Ipv6Address([
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb,
+]));
+
+#[cfg(feature = "proto-ipv4")]
+const MDNS_IPV4_ADDR: IpAddress = IpAddress::Ipv4(crate::wire::Ipv4Address([224, 0, 0, 251]));
+
+/// Error returned by [`Socket::start_query`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum StartQueryError {
+ NoFreeSlot,
+ InvalidName,
+ NameTooLong,
+}
+
+impl core::fmt::Display for StartQueryError {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ StartQueryError::NoFreeSlot => write!(f, "No free slot"),
+ StartQueryError::InvalidName => write!(f, "Invalid name"),
+ StartQueryError::NameTooLong => write!(f, "Name too long"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for StartQueryError {}
+
+/// Error returned by [`Socket::get_query_result`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum GetQueryResultError {
+ /// Query is not done yet.
+ Pending,
+ /// Query failed.
+ Failed,
+}
+
+impl core::fmt::Display for GetQueryResultError {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ GetQueryResultError::Pending => write!(f, "Query is not done yet"),
+ GetQueryResultError::Failed => write!(f, "Query failed"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for GetQueryResultError {}
+
+/// State for an in-progress DNS query.
+///
+/// The only reason this struct is public is to allow the socket state
+/// to be allocated externally.
+#[derive(Debug)]
+pub struct DnsQuery {
+ state: State,
+
+ #[cfg(feature = "async")]
+ waker: WakerRegistration,
+}
+
+impl DnsQuery {
+ fn set_state(&mut self, state: State) {
+ self.state = state;
+ #[cfg(feature = "async")]
+ self.waker.wake();
+ }
+}
+
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
+enum State {
+ Pending(PendingQuery),
+ Completed(CompletedQuery),
+ Failure,
+}
+
+#[derive(Debug)]
+struct PendingQuery {
+ name: Vec<u8, DNS_MAX_NAME_SIZE>,
+ type_: Type,
+
+ port: u16, // UDP port (src for request, dst for response)
+ txid: u16, // transaction ID
+
+ timeout_at: Option<Instant>,
+ retransmit_at: Instant,
+ delay: Duration,
+
+ server_idx: usize,
+ mdns: MulticastDns,
+}
+
+#[derive(Debug)]
+pub enum MulticastDns {
+ Disabled,
+ #[cfg(feature = "socket-mdns")]
+ Enabled,
+}
+
+#[derive(Debug)]
+struct CompletedQuery {
+ addresses: Vec<IpAddress, DNS_MAX_RESULT_COUNT>,
+}
+
+/// A handle to an in-progress DNS query.
+#[derive(Clone, Copy)]
+pub struct QueryHandle(usize);
+
+/// A Domain Name System socket.
+///
+/// A UDP socket is bound to a specific endpoint, and owns transmit and receive
+/// packet buffers.
+#[derive(Debug)]
+pub struct Socket<'a> {
+ servers: Vec<IpAddress, DNS_MAX_SERVER_COUNT>,
+ queries: ManagedSlice<'a, Option<DnsQuery>>,
+
+ /// The time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ hop_limit: Option<u8>,
+}
+
+impl<'a> Socket<'a> {
+ /// Create a DNS socket.
+ ///
+ /// # Panics
+ ///
+ /// Panics if `servers.len() > MAX_SERVER_COUNT`
+ pub fn new<Q>(servers: &[IpAddress], queries: Q) -> Socket<'a>
+ where
+ Q: Into<ManagedSlice<'a, Option<DnsQuery>>>,
+ {
+ Socket {
+ servers: Vec::from_slice(servers).unwrap(),
+ queries: queries.into(),
+ hop_limit: None,
+ }
+ }
+
+ /// Update the list of DNS servers, will replace all existing servers
+ ///
+ /// # Panics
+ ///
+ /// Panics if `servers.len() > MAX_SERVER_COUNT`
+ pub fn update_servers(&mut self, servers: &[IpAddress]) {
+ self.servers = Vec::from_slice(servers).unwrap();
+ }
+
+ /// Return the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// See also the [set_hop_limit](#method.set_hop_limit) method
+ pub fn hop_limit(&self) -> Option<u8> {
+ self.hop_limit
+ }
+
+ /// Set the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// A socket without an explicitly set hop limit value uses the default [IANA recommended]
+ /// value (64).
+ ///
+ /// # Panics
+ ///
+ /// This function panics if a hop limit value of 0 is given. See [RFC 1122 § 3.2.1.7].
+ ///
+ /// [IANA recommended]: https://www.iana.org/assignments/ip-parameters/ip-parameters.xhtml
+ /// [RFC 1122 § 3.2.1.7]: https://tools.ietf.org/html/rfc1122#section-3.2.1.7
+ pub fn set_hop_limit(&mut self, hop_limit: Option<u8>) {
+ // A host MUST NOT send a datagram with a hop limit value of 0
+ if let Some(0) = hop_limit {
+ panic!("the time-to-live value of a packet must not be zero")
+ }
+
+ self.hop_limit = hop_limit
+ }
+
+ fn find_free_query(&mut self) -> Option<QueryHandle> {
+ for (i, q) in self.queries.iter().enumerate() {
+ if q.is_none() {
+ return Some(QueryHandle(i));
+ }
+ }
+
+ match &mut self.queries {
+ ManagedSlice::Borrowed(_) => None,
+ #[cfg(feature = "alloc")]
+ ManagedSlice::Owned(queries) => {
+ queries.push(None);
+ let index = queries.len() - 1;
+ Some(QueryHandle(index))
+ }
+ }
+ }
+
+ /// Start a query.
+ ///
+ /// `name` is specified in human-friendly format, such as `"rust-lang.org"`.
+ /// It accepts names both with and without trailing dot, and they're treated
+ /// the same (there's no support for DNS search path).
+ pub fn start_query(
+ &mut self,
+ cx: &mut Context,
+ name: &str,
+ query_type: Type,
+ ) -> Result<QueryHandle, StartQueryError> {
+ let mut name = name.as_bytes();
+
+ if name.is_empty() {
+ net_trace!("invalid name: zero length");
+ return Err(StartQueryError::InvalidName);
+ }
+
+ // Remove trailing dot, if any
+ if name[name.len() - 1] == b'.' {
+ name = &name[..name.len() - 1];
+ }
+
+ let mut raw_name: Vec<u8, DNS_MAX_NAME_SIZE> = Vec::new();
+
+ let mut mdns = MulticastDns::Disabled;
+ #[cfg(feature = "socket-mdns")]
+ if name.split(|&c| c == b'.').last().unwrap() == b"local" {
+ net_trace!("Starting a mDNS query");
+ mdns = MulticastDns::Enabled;
+ }
+
+ for s in name.split(|&c| c == b'.') {
+ if s.len() > 63 {
+ net_trace!("invalid name: too long label");
+ return Err(StartQueryError::InvalidName);
+ }
+ if s.is_empty() {
+ net_trace!("invalid name: zero length label");
+ return Err(StartQueryError::InvalidName);
+ }
+
+ // Push label
+ raw_name
+ .push(s.len() as u8)
+ .map_err(|_| StartQueryError::NameTooLong)?;
+ raw_name
+ .extend_from_slice(s)
+ .map_err(|_| StartQueryError::NameTooLong)?;
+ }
+
+ // Push terminator.
+ raw_name
+ .push(0x00)
+ .map_err(|_| StartQueryError::NameTooLong)?;
+
+ self.start_query_raw(cx, &raw_name, query_type, mdns)
+ }
+
+ /// Start a query with a raw (wire-format) DNS name.
+ /// `b"\x09rust-lang\x03org\x00"`
+ ///
+ /// You probably want to use [`start_query`] instead.
+ pub fn start_query_raw(
+ &mut self,
+ cx: &mut Context,
+ raw_name: &[u8],
+ query_type: Type,
+ mdns: MulticastDns,
+ ) -> Result<QueryHandle, StartQueryError> {
+ let handle = self.find_free_query().ok_or(StartQueryError::NoFreeSlot)?;
+
+ self.queries[handle.0] = Some(DnsQuery {
+ state: State::Pending(PendingQuery {
+ name: Vec::from_slice(raw_name).map_err(|_| StartQueryError::NameTooLong)?,
+ type_: query_type,
+ txid: cx.rand().rand_u16(),
+ port: cx.rand().rand_source_port(),
+ delay: RETRANSMIT_DELAY,
+ timeout_at: None,
+ retransmit_at: Instant::ZERO,
+ server_idx: 0,
+ mdns,
+ }),
+ #[cfg(feature = "async")]
+ waker: WakerRegistration::new(),
+ });
+ Ok(handle)
+ }
+
+ /// Get the result of a query.
+ ///
+ /// If the query is completed, the query slot is automatically freed.
+ ///
+ /// # Panics
+ /// Panics if the QueryHandle corresponds to a free slot.
+ pub fn get_query_result(
+ &mut self,
+ handle: QueryHandle,
+ ) -> Result<Vec<IpAddress, DNS_MAX_RESULT_COUNT>, GetQueryResultError> {
+ let slot = &mut self.queries[handle.0];
+ let q = slot.as_mut().unwrap();
+ match &mut q.state {
+ // Query is not done yet.
+ State::Pending(_) => Err(GetQueryResultError::Pending),
+ // Query is done
+ State::Completed(q) => {
+ let res = q.addresses.clone();
+ *slot = None; // Free up the slot for recycling.
+ Ok(res)
+ }
+ State::Failure => {
+ *slot = None; // Free up the slot for recycling.
+ Err(GetQueryResultError::Failed)
+ }
+ }
+ }
+
+ /// Cancels a query, freeing the slot.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the QueryHandle corresponds to an already free slot.
+ pub fn cancel_query(&mut self, handle: QueryHandle) {
+ let slot = &mut self.queries[handle.0];
+ if slot.is_none() {
+ panic!("Canceling query in a free slot.")
+ }
+ *slot = None; // Free up the slot for recycling.
+ }
+
+ /// Assign a waker to a query slot
+ ///
+ /// The waker will be woken when the query completes, either successfully or failed.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the QueryHandle corresponds to an already free slot.
+ #[cfg(feature = "async")]
+ pub fn register_query_waker(&mut self, handle: QueryHandle, waker: &Waker) {
+ self.queries[handle.0]
+ .as_mut()
+ .unwrap()
+ .waker
+ .register(waker);
+ }
+
+ pub(crate) fn accepts(&self, ip_repr: &IpRepr, udp_repr: &UdpRepr) -> bool {
+ (udp_repr.src_port == DNS_PORT
+ && self
+ .servers
+ .iter()
+ .any(|server| *server == ip_repr.src_addr()))
+ || (udp_repr.src_port == MDNS_DNS_PORT)
+ }
+
+ pub(crate) fn process(
+ &mut self,
+ _cx: &mut Context,
+ ip_repr: &IpRepr,
+ udp_repr: &UdpRepr,
+ payload: &[u8],
+ ) {
+ debug_assert!(self.accepts(ip_repr, udp_repr));
+
+ let size = payload.len();
+
+ net_trace!(
+ "receiving {} octets from {:?}:{}",
+ size,
+ ip_repr.src_addr(),
+ udp_repr.dst_port
+ );
+
+ let p = match Packet::new_checked(payload) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!("dns packet malformed");
+ return;
+ }
+ };
+ if p.opcode() != Opcode::Query {
+ net_trace!("unwanted opcode {:?}", p.opcode());
+ return;
+ }
+
+ if !p.flags().contains(Flags::RESPONSE) {
+ net_trace!("packet doesn't have response bit set");
+ return;
+ }
+
+ if p.question_count() != 1 {
+ net_trace!("bad question count {:?}", p.question_count());
+ return;
+ }
+
+ // Find pending query
+ for q in self.queries.iter_mut().flatten() {
+ if let State::Pending(pq) = &mut q.state {
+ if udp_repr.dst_port != pq.port || p.transaction_id() != pq.txid {
+ continue;
+ }
+
+ if p.rcode() == Rcode::NXDomain {
+ net_trace!("rcode NXDomain");
+ q.set_state(State::Failure);
+ continue;
+ }
+
+ let payload = p.payload();
+ let (mut payload, question) = match Question::parse(payload) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!("question malformed");
+ return;
+ }
+ };
+
+ if question.type_ != pq.type_ {
+ net_trace!("question type mismatch");
+ return;
+ }
+
+ match eq_names(p.parse_name(question.name), p.parse_name(&pq.name)) {
+ Ok(true) => {}
+ Ok(false) => {
+ net_trace!("question name mismatch");
+ return;
+ }
+ Err(_) => {
+ net_trace!("dns question name malformed");
+ return;
+ }
+ }
+
+ let mut addresses = Vec::new();
+
+ for _ in 0..p.answer_record_count() {
+ let (payload2, r) = match Record::parse(payload) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!("dns answer record malformed");
+ return;
+ }
+ };
+ payload = payload2;
+
+ match eq_names(p.parse_name(r.name), p.parse_name(&pq.name)) {
+ Ok(true) => {}
+ Ok(false) => {
+ net_trace!("answer name mismatch: {:?}", r);
+ continue;
+ }
+ Err(_) => {
+ net_trace!("dns answer record name malformed");
+ return;
+ }
+ }
+
+ match r.data {
+ #[cfg(feature = "proto-ipv4")]
+ RecordData::A(addr) => {
+ net_trace!("A: {:?}", addr);
+ if addresses.push(addr.into()).is_err() {
+ net_trace!("too many addresses in response, ignoring {:?}", addr);
+ }
+ }
+ #[cfg(feature = "proto-ipv6")]
+ RecordData::Aaaa(addr) => {
+ net_trace!("AAAA: {:?}", addr);
+ if addresses.push(addr.into()).is_err() {
+ net_trace!("too many addresses in response, ignoring {:?}", addr);
+ }
+ }
+ RecordData::Cname(name) => {
+ net_trace!("CNAME: {:?}", name);
+
+ // When faced with a CNAME, recursive resolvers are supposed to
+ // resolve the CNAME and append the results for it.
+ //
+ // We update the query with the new name, so that we pick up the A/AAAA
+ // records for the CNAME when we parse them later.
+ // I believe it's mandatory the CNAME results MUST come *after* in the
+ // packet, so it's enough to do one linear pass over it.
+ if copy_name(&mut pq.name, p.parse_name(name)).is_err() {
+ net_trace!("dns answer cname malformed");
+ return;
+ }
+ }
+ RecordData::Other(type_, data) => {
+ net_trace!("unknown: {:?} {:?}", type_, data)
+ }
+ }
+ }
+
+ q.set_state(if addresses.is_empty() {
+ State::Failure
+ } else {
+ State::Completed(CompletedQuery { addresses })
+ });
+
+ // If we get here, packet matched the current query, stop processing.
+ return;
+ }
+ }
+
+ // If we get here, packet matched with no query.
+ net_trace!("no query matched");
+ }
+
+ pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+ where
+ F: FnOnce(&mut Context, (IpRepr, UdpRepr, &[u8])) -> Result<(), E>,
+ {
+ let hop_limit = self.hop_limit.unwrap_or(64);
+
+ for q in self.queries.iter_mut().flatten() {
+ if let State::Pending(pq) = &mut q.state {
+ // As per RFC 6762 any DNS query ending in .local. MUST be sent as mdns
+ // so we internally overwrite the servers for any of those queries
+ // in this function.
+ let servers = match pq.mdns {
+ #[cfg(feature = "socket-mdns")]
+ MulticastDns::Enabled => &[
+ #[cfg(feature = "proto-ipv6")]
+ MDNS_IPV6_ADDR,
+ #[cfg(feature = "proto-ipv4")]
+ MDNS_IPV4_ADDR,
+ ],
+ MulticastDns::Disabled => self.servers.as_slice(),
+ };
+
+ let timeout = if let Some(timeout) = pq.timeout_at {
+ timeout
+ } else {
+ let v = cx.now() + RETRANSMIT_TIMEOUT;
+ pq.timeout_at = Some(v);
+ v
+ };
+
+ // Check timeout
+ if timeout < cx.now() {
+ // DNS timeout
+ pq.timeout_at = Some(cx.now() + RETRANSMIT_TIMEOUT);
+ pq.retransmit_at = Instant::ZERO;
+ pq.delay = RETRANSMIT_DELAY;
+
+ // Try next server. We check below whether we've tried all servers.
+ pq.server_idx += 1;
+ }
+ // Check if we've run out of servers to try.
+ if pq.server_idx >= servers.len() {
+ net_trace!("already tried all servers.");
+ q.set_state(State::Failure);
+ continue;
+ }
+
+ // Check so the IP address is valid
+ if servers[pq.server_idx].is_unspecified() {
+ net_trace!("invalid unspecified DNS server addr.");
+ q.set_state(State::Failure);
+ continue;
+ }
+
+ if pq.retransmit_at > cx.now() {
+ // query is waiting for retransmit
+ continue;
+ }
+
+ let repr = Repr {
+ transaction_id: pq.txid,
+ flags: Flags::RECURSION_DESIRED,
+ opcode: Opcode::Query,
+ question: Question {
+ name: &pq.name,
+ type_: pq.type_,
+ },
+ };
+
+ let mut payload = [0u8; 512];
+ let payload = &mut payload[..repr.buffer_len()];
+ repr.emit(&mut Packet::new_unchecked(payload));
+
+ let dst_port = match pq.mdns {
+ #[cfg(feature = "socket-mdns")]
+ MulticastDns::Enabled => MDNS_DNS_PORT,
+ MulticastDns::Disabled => DNS_PORT,
+ };
+
+ let udp_repr = UdpRepr {
+ src_port: pq.port,
+ dst_port,
+ };
+
+ let dst_addr = servers[pq.server_idx];
+ let src_addr = cx.get_source_address(&dst_addr).unwrap(); // TODO remove unwrap
+ let ip_repr = IpRepr::new(
+ src_addr,
+ dst_addr,
+ IpProtocol::Udp,
+ udp_repr.header_len() + payload.len(),
+ hop_limit,
+ );
+
+ net_trace!(
+ "sending {} octets to {} from port {}",
+ payload.len(),
+ ip_repr.dst_addr(),
+ udp_repr.src_port
+ );
+
+ emit(cx, (ip_repr, udp_repr, payload))?;
+
+ pq.retransmit_at = cx.now() + pq.delay;
+ pq.delay = MAX_RETRANSMIT_DELAY.min(pq.delay * 2);
+
+ return Ok(());
+ }
+ }
+
+ // Nothing to dispatch
+ Ok(())
+ }
+
+ pub(crate) fn poll_at(&self, _cx: &Context) -> PollAt {
+ self.queries
+ .iter()
+ .flatten()
+ .filter_map(|q| match &q.state {
+ State::Pending(pq) => Some(PollAt::Time(pq.retransmit_at)),
+ State::Completed(_) => None,
+ State::Failure => None,
+ })
+ .min()
+ .unwrap_or(PollAt::Ingress)
+ }
+}
+
+fn eq_names<'a>(
+ mut a: impl Iterator<Item = wire::Result<&'a [u8]>>,
+ mut b: impl Iterator<Item = wire::Result<&'a [u8]>>,
+) -> wire::Result<bool> {
+ loop {
+ match (a.next(), b.next()) {
+ // Handle errors
+ (Some(Err(e)), _) => return Err(e),
+ (_, Some(Err(e))) => return Err(e),
+
+ // Both finished -> equal
+ (None, None) => return Ok(true),
+
+ // One finished before the other -> not equal
+ (None, _) => return Ok(false),
+ (_, None) => return Ok(false),
+
+ // Got two labels, check if they're equal
+ (Some(Ok(la)), Some(Ok(lb))) => {
+ if la != lb {
+ return Ok(false);
+ }
+ }
+ }
+ }
+}
+
+fn copy_name<'a, const N: usize>(
+ dest: &mut Vec<u8, N>,
+ name: impl Iterator<Item = wire::Result<&'a [u8]>>,
+) -> Result<(), wire::Error> {
+ dest.truncate(0);
+
+ for label in name {
+ let label = label?;
+ dest.push(label.len() as u8).map_err(|_| wire::Error)?;
+ dest.extend_from_slice(label).map_err(|_| wire::Error)?;
+ }
+
+ // Write terminator 0x00
+ dest.push(0).map_err(|_| wire::Error)?;
+
+ Ok(())
+}
diff --git a/src/socket/icmp.rs b/src/socket/icmp.rs
new file mode 100644
index 0000000..c18b754
--- /dev/null
+++ b/src/socket/icmp.rs
@@ -0,0 +1,1240 @@
+use core::cmp;
+#[cfg(feature = "async")]
+use core::task::Waker;
+
+use crate::phy::ChecksumCapabilities;
+#[cfg(feature = "async")]
+use crate::socket::WakerRegistration;
+use crate::socket::{Context, PollAt};
+
+use crate::storage::Empty;
+use crate::wire::IcmpRepr;
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::{Icmpv4Packet, Icmpv4Repr, Ipv4Repr};
+#[cfg(feature = "proto-ipv6")]
+use crate::wire::{Icmpv6Packet, Icmpv6Repr, Ipv6Repr};
+use crate::wire::{IpAddress, IpListenEndpoint, IpProtocol, IpRepr};
+use crate::wire::{UdpPacket, UdpRepr};
+
+/// Error returned by [`Socket::bind`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum BindError {
+ InvalidState,
+ Unaddressable,
+}
+
+impl core::fmt::Display for BindError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ BindError::InvalidState => write!(f, "invalid state"),
+ BindError::Unaddressable => write!(f, "unaddressable"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BindError {}
+
+/// Error returned by [`Socket::send`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SendError {
+ Unaddressable,
+ BufferFull,
+}
+
+impl core::fmt::Display for SendError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ SendError::Unaddressable => write!(f, "unaddressable"),
+ SendError::BufferFull => write!(f, "buffer full"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SendError {}
+
+/// Error returned by [`Socket::recv`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RecvError {
+ Exhausted,
+ Truncated,
+}
+
+impl core::fmt::Display for RecvError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ RecvError::Exhausted => write!(f, "exhausted"),
+ RecvError::Truncated => write!(f, "truncated"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RecvError {}
+
+/// Type of endpoint to bind the ICMP socket to. See [IcmpSocket::bind] for
+/// more details.
+///
+/// [IcmpSocket::bind]: struct.IcmpSocket.html#method.bind
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Endpoint {
+ #[default]
+ Unspecified,
+ Ident(u16),
+ Udp(IpListenEndpoint),
+}
+
+impl Endpoint {
+ pub fn is_specified(&self) -> bool {
+ match *self {
+ Endpoint::Ident(_) => true,
+ Endpoint::Udp(endpoint) => endpoint.port != 0,
+ Endpoint::Unspecified => false,
+ }
+ }
+}
+
+/// An ICMP packet metadata.
+pub type PacketMetadata = crate::storage::PacketMetadata<IpAddress>;
+
+/// An ICMP packet ring buffer.
+pub type PacketBuffer<'a> = crate::storage::PacketBuffer<'a, IpAddress>;
+
+/// A ICMP socket
+///
+/// An ICMP socket is bound to a specific [IcmpEndpoint] which may
+/// be a specific UDP port to listen for ICMP error messages related
+/// to the port or a specific ICMP identifier value. See [bind] for
+/// more details.
+///
+/// [IcmpEndpoint]: enum.IcmpEndpoint.html
+/// [bind]: #method.bind
+#[derive(Debug)]
+pub struct Socket<'a> {
+ rx_buffer: PacketBuffer<'a>,
+ tx_buffer: PacketBuffer<'a>,
+ /// The endpoint this socket is communicating with
+ endpoint: Endpoint,
+ /// The time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ hop_limit: Option<u8>,
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration,
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration,
+}
+
+impl<'a> Socket<'a> {
+ /// Create an ICMP socket with the given buffers.
+ pub fn new(rx_buffer: PacketBuffer<'a>, tx_buffer: PacketBuffer<'a>) -> Socket<'a> {
+ Socket {
+ rx_buffer,
+ tx_buffer,
+ endpoint: Default::default(),
+ hop_limit: None,
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration::new(),
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration::new(),
+ }
+ }
+
+ /// Register a waker for receive operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `recv` method calls, such as receiving data, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `recv` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_recv_waker(&mut self, waker: &Waker) {
+ self.rx_waker.register(waker)
+ }
+
+ /// Register a waker for send operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `send` method calls, such as space becoming available in the transmit
+ /// buffer, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `send` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_send_waker(&mut self, waker: &Waker) {
+ self.tx_waker.register(waker)
+ }
+
+ /// Return the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// See also the [set_hop_limit](#method.set_hop_limit) method
+ pub fn hop_limit(&self) -> Option<u8> {
+ self.hop_limit
+ }
+
+ /// Set the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// A socket without an explicitly set hop limit value uses the default [IANA recommended]
+ /// value (64).
+ ///
+ /// # Panics
+ ///
+ /// This function panics if a hop limit value of 0 is given. See [RFC 1122 § 3.2.1.7].
+ ///
+ /// [IANA recommended]: https://www.iana.org/assignments/ip-parameters/ip-parameters.xhtml
+ /// [RFC 1122 § 3.2.1.7]: https://tools.ietf.org/html/rfc1122#section-3.2.1.7
+ pub fn set_hop_limit(&mut self, hop_limit: Option<u8>) {
+ // A host MUST NOT send a datagram with a hop limit value of 0
+ if let Some(0) = hop_limit {
+ panic!("the time-to-live value of a packet must not be zero")
+ }
+
+ self.hop_limit = hop_limit
+ }
+
+ /// Bind the socket to the given endpoint.
+ ///
+ /// This function returns `Err(Error::Illegal)` if the socket was open
+ /// (see [is_open](#method.is_open)), and `Err(Error::Unaddressable)`
+ /// if `endpoint` is unspecified (see [is_specified]).
+ ///
+ /// # Examples
+ ///
+ /// ## Bind to ICMP Error messages associated with a specific UDP port:
+ ///
+ /// To [recv] ICMP error messages that are associated with a specific local
+ /// UDP port, the socket may be bound to a given port using [IcmpEndpoint::Udp].
+ /// This may be useful for applications using UDP attempting to detect and/or
+ /// diagnose connection problems.
+ ///
+ /// ```
+ /// use smoltcp::wire::IpListenEndpoint;
+ /// use smoltcp::socket::icmp;
+ /// # let rx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 20]);
+ /// # let tx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 20]);
+ ///
+ /// let mut icmp_socket = // ...
+ /// # icmp::Socket::new(rx_buffer, tx_buffer);
+ ///
+ /// // Bind to ICMP error responses for UDP packets sent from port 53.
+ /// let endpoint = IpListenEndpoint::from(53);
+ /// icmp_socket.bind(icmp::Endpoint::Udp(endpoint)).unwrap();
+ /// ```
+ ///
+ /// ## Bind to a specific ICMP identifier:
+ ///
+ /// To [send] and [recv] ICMP packets that are not associated with a specific UDP
+ /// port, the socket may be bound to a specific ICMP identifier using
+ /// [IcmpEndpoint::Ident]. This is useful for sending and receiving Echo Request/Reply
+ /// messages.
+ ///
+ /// ```
+ /// use smoltcp::wire::IpListenEndpoint;
+ /// use smoltcp::socket::icmp;
+ /// # let rx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 20]);
+ /// # let tx_buffer = icmp::PacketBuffer::new(vec![icmp::PacketMetadata::EMPTY], vec![0; 20]);
+ ///
+ /// let mut icmp_socket = // ...
+ /// # icmp::Socket::new(rx_buffer, tx_buffer);
+ ///
+ /// // Bind to ICMP messages with the ICMP identifier 0x1234
+ /// icmp_socket.bind(icmp::Endpoint::Ident(0x1234)).unwrap();
+ /// ```
+ ///
+ /// [is_specified]: enum.IcmpEndpoint.html#method.is_specified
+ /// [IcmpEndpoint::Ident]: enum.IcmpEndpoint.html#variant.Ident
+ /// [IcmpEndpoint::Udp]: enum.IcmpEndpoint.html#variant.Udp
+ /// [send]: #method.send
+ /// [recv]: #method.recv
+ pub fn bind<T: Into<Endpoint>>(&mut self, endpoint: T) -> Result<(), BindError> {
+ let endpoint = endpoint.into();
+ if !endpoint.is_specified() {
+ return Err(BindError::Unaddressable);
+ }
+
+ if self.is_open() {
+ return Err(BindError::InvalidState);
+ }
+
+ self.endpoint = endpoint;
+
+ #[cfg(feature = "async")]
+ {
+ self.rx_waker.wake();
+ self.tx_waker.wake();
+ }
+
+ Ok(())
+ }
+
+ /// Check whether the transmit buffer is full.
+ #[inline]
+ pub fn can_send(&self) -> bool {
+ !self.tx_buffer.is_full()
+ }
+
+ /// Check whether the receive buffer is not empty.
+ #[inline]
+ pub fn can_recv(&self) -> bool {
+ !self.rx_buffer.is_empty()
+ }
+
+ /// Return the maximum number packets the socket can receive.
+ #[inline]
+ pub fn packet_recv_capacity(&self) -> usize {
+ self.rx_buffer.packet_capacity()
+ }
+
+ /// Return the maximum number packets the socket can transmit.
+ #[inline]
+ pub fn packet_send_capacity(&self) -> usize {
+ self.tx_buffer.packet_capacity()
+ }
+
+ /// Return the maximum number of bytes inside the recv buffer.
+ #[inline]
+ pub fn payload_recv_capacity(&self) -> usize {
+ self.rx_buffer.payload_capacity()
+ }
+
+ /// Return the maximum number of bytes inside the transmit buffer.
+ #[inline]
+ pub fn payload_send_capacity(&self) -> usize {
+ self.tx_buffer.payload_capacity()
+ }
+
+ /// Check whether the socket is open.
+ #[inline]
+ pub fn is_open(&self) -> bool {
+ self.endpoint != Endpoint::Unspecified
+ }
+
+ /// Enqueue a packet to be sent to a given remote address, and return a pointer
+ /// to its payload.
+ ///
+ /// This function returns `Err(Error::Exhausted)` if the transmit buffer is full,
+ /// `Err(Error::Truncated)` if the requested size is larger than the packet buffer
+ /// size, and `Err(Error::Unaddressable)` if the remote address is unspecified.
+ pub fn send(&mut self, size: usize, endpoint: IpAddress) -> Result<&mut [u8], SendError> {
+ if endpoint.is_unspecified() {
+ return Err(SendError::Unaddressable);
+ }
+
+ let packet_buf = self
+ .tx_buffer
+ .enqueue(size, endpoint)
+ .map_err(|_| SendError::BufferFull)?;
+
+ net_trace!("icmp:{}: buffer to send {} octets", endpoint, size);
+ Ok(packet_buf)
+ }
+
+ /// Enqueue a packet to be send to a given remote address and pass the buffer
+ /// to the provided closure. The closure then returns the size of the data written
+ /// into the buffer.
+ ///
+ /// Also see [send](#method.send).
+ pub fn send_with<F>(
+ &mut self,
+ max_size: usize,
+ endpoint: IpAddress,
+ f: F,
+ ) -> Result<usize, SendError>
+ where
+ F: FnOnce(&mut [u8]) -> usize,
+ {
+ if endpoint.is_unspecified() {
+ return Err(SendError::Unaddressable);
+ }
+
+ let size = self
+ .tx_buffer
+ .enqueue_with_infallible(max_size, endpoint, f)
+ .map_err(|_| SendError::BufferFull)?;
+
+ net_trace!("icmp:{}: buffer to send {} octets", endpoint, size);
+ Ok(size)
+ }
+
+ /// Enqueue a packet to be sent to a given remote address, and fill it from a slice.
+ ///
+ /// See also [send](#method.send).
+ pub fn send_slice(&mut self, data: &[u8], endpoint: IpAddress) -> Result<(), SendError> {
+ let packet_buf = self.send(data.len(), endpoint)?;
+ packet_buf.copy_from_slice(data);
+ Ok(())
+ }
+
+ /// Dequeue a packet received from a remote endpoint, and return the `IpAddress` as well
+ /// as a pointer to the payload.
+ ///
+ /// This function returns `Err(Error::Exhausted)` if the receive buffer is empty.
+ pub fn recv(&mut self) -> Result<(&[u8], IpAddress), RecvError> {
+ let (endpoint, packet_buf) = self.rx_buffer.dequeue().map_err(|_| RecvError::Exhausted)?;
+
+ net_trace!(
+ "icmp:{}: receive {} buffered octets",
+ endpoint,
+ packet_buf.len()
+ );
+ Ok((packet_buf, endpoint))
+ }
+
+ /// Dequeue a packet received from a remote endpoint, copy the payload into the given slice,
+ /// and return the amount of octets copied as well as the `IpAddress`
+ ///
+ /// **Note**: when the size of the provided buffer is smaller than the size of the payload,
+ /// the packet is dropped and a `RecvError::Truncated` error is returned.
+ ///
+ /// See also [recv](#method.recv).
+ pub fn recv_slice(&mut self, data: &mut [u8]) -> Result<(usize, IpAddress), RecvError> {
+ let (buffer, endpoint) = self.recv()?;
+
+ if data.len() < buffer.len() {
+ return Err(RecvError::Truncated);
+ }
+
+ let length = cmp::min(data.len(), buffer.len());
+ data[..length].copy_from_slice(&buffer[..length]);
+ Ok((length, endpoint))
+ }
+
+ /// Filter determining which packets received by the interface are appended to
+ /// the given sockets received buffer.
+ pub(crate) fn accepts(&self, cx: &mut Context, ip_repr: &IpRepr, icmp_repr: &IcmpRepr) -> bool {
+ match (&self.endpoint, icmp_repr) {
+ // If we are bound to ICMP errors associated to a UDP port, only
+ // accept Destination Unreachable or Time Exceeded messages with
+ // the data containing a UDP packet send from the local port we
+ // are bound to.
+ #[cfg(feature = "proto-ipv4")]
+ (
+ &Endpoint::Udp(endpoint),
+ &IcmpRepr::Ipv4(
+ Icmpv4Repr::DstUnreachable { data, header, .. }
+ | Icmpv4Repr::TimeExceeded { data, header, .. },
+ ),
+ ) if endpoint.addr.is_none() || endpoint.addr == Some(ip_repr.dst_addr()) => {
+ let packet = UdpPacket::new_unchecked(data);
+ match UdpRepr::parse(
+ &packet,
+ &header.src_addr.into(),
+ &header.dst_addr.into(),
+ &cx.checksum_caps(),
+ ) {
+ Ok(repr) => endpoint.port == repr.src_port,
+ Err(_) => false,
+ }
+ }
+ #[cfg(feature = "proto-ipv6")]
+ (
+ &Endpoint::Udp(endpoint),
+ &IcmpRepr::Ipv6(
+ Icmpv6Repr::DstUnreachable { data, header, .. }
+ | Icmpv6Repr::TimeExceeded { data, header, .. },
+ ),
+ ) if endpoint.addr.is_none() || endpoint.addr == Some(ip_repr.dst_addr()) => {
+ let packet = UdpPacket::new_unchecked(data);
+ match UdpRepr::parse(
+ &packet,
+ &header.src_addr.into(),
+ &header.dst_addr.into(),
+ &cx.checksum_caps(),
+ ) {
+ Ok(repr) => endpoint.port == repr.src_port,
+ Err(_) => false,
+ }
+ }
+ // If we are bound to a specific ICMP identifier value, only accept an
+ // Echo Request/Reply with the identifier field matching the endpoint
+ // port.
+ #[cfg(feature = "proto-ipv4")]
+ (
+ &Endpoint::Ident(bound_ident),
+ &IcmpRepr::Ipv4(Icmpv4Repr::EchoRequest { ident, .. }),
+ )
+ | (
+ &Endpoint::Ident(bound_ident),
+ &IcmpRepr::Ipv4(Icmpv4Repr::EchoReply { ident, .. }),
+ ) => ident == bound_ident,
+ #[cfg(feature = "proto-ipv6")]
+ (
+ &Endpoint::Ident(bound_ident),
+ &IcmpRepr::Ipv6(Icmpv6Repr::EchoRequest { ident, .. }),
+ )
+ | (
+ &Endpoint::Ident(bound_ident),
+ &IcmpRepr::Ipv6(Icmpv6Repr::EchoReply { ident, .. }),
+ ) => ident == bound_ident,
+ _ => false,
+ }
+ }
+
+ pub(crate) fn process(&mut self, _cx: &mut Context, ip_repr: &IpRepr, icmp_repr: &IcmpRepr) {
+ match icmp_repr {
+ #[cfg(feature = "proto-ipv4")]
+ IcmpRepr::Ipv4(icmp_repr) => {
+ net_trace!("icmp: receiving {} octets", icmp_repr.buffer_len());
+
+ match self
+ .rx_buffer
+ .enqueue(icmp_repr.buffer_len(), ip_repr.src_addr())
+ {
+ Ok(packet_buf) => {
+ icmp_repr.emit(
+ &mut Icmpv4Packet::new_unchecked(packet_buf),
+ &ChecksumCapabilities::default(),
+ );
+ }
+ Err(_) => net_trace!("icmp: buffer full, dropped incoming packet"),
+ }
+ }
+ #[cfg(feature = "proto-ipv6")]
+ IcmpRepr::Ipv6(icmp_repr) => {
+ net_trace!("icmp: receiving {} octets", icmp_repr.buffer_len());
+
+ match self
+ .rx_buffer
+ .enqueue(icmp_repr.buffer_len(), ip_repr.src_addr())
+ {
+ Ok(packet_buf) => icmp_repr.emit(
+ &ip_repr.src_addr(),
+ &ip_repr.dst_addr(),
+ &mut Icmpv6Packet::new_unchecked(packet_buf),
+ &ChecksumCapabilities::default(),
+ ),
+ Err(_) => net_trace!("icmp: buffer full, dropped incoming packet"),
+ }
+ }
+ }
+
+ #[cfg(feature = "async")]
+ self.rx_waker.wake();
+ }
+
+ pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+ where
+ F: FnOnce(&mut Context, (IpRepr, IcmpRepr)) -> Result<(), E>,
+ {
+ let hop_limit = self.hop_limit.unwrap_or(64);
+ let res = self.tx_buffer.dequeue_with(|remote_endpoint, packet_buf| {
+ net_trace!(
+ "icmp:{}: sending {} octets",
+ remote_endpoint,
+ packet_buf.len()
+ );
+ match *remote_endpoint {
+ #[cfg(feature = "proto-ipv4")]
+ IpAddress::Ipv4(dst_addr) => {
+ let src_addr = match cx.get_source_address_ipv4(&dst_addr) {
+ Some(addr) => addr,
+ None => {
+ net_trace!(
+ "icmp:{}: not find suitable source address, dropping",
+ remote_endpoint
+ );
+ return Ok(());
+ }
+ };
+ let packet = Icmpv4Packet::new_unchecked(&*packet_buf);
+ let repr = match Icmpv4Repr::parse(&packet, &ChecksumCapabilities::ignored()) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!(
+ "icmp:{}: malformed packet in queue, dropping",
+ remote_endpoint
+ );
+ return Ok(());
+ }
+ };
+ let ip_repr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr,
+ dst_addr,
+ next_header: IpProtocol::Icmp,
+ payload_len: repr.buffer_len(),
+ hop_limit,
+ });
+ emit(cx, (ip_repr, IcmpRepr::Ipv4(repr)))
+ }
+ #[cfg(feature = "proto-ipv6")]
+ IpAddress::Ipv6(dst_addr) => {
+ let src_addr = match cx.get_source_address_ipv6(&dst_addr) {
+ Some(addr) => addr,
+ None => {
+ net_trace!(
+ "icmp:{}: not find suitable source address, dropping",
+ remote_endpoint
+ );
+ return Ok(());
+ }
+ };
+ let packet = Icmpv6Packet::new_unchecked(&*packet_buf);
+ let repr = match Icmpv6Repr::parse(
+ &src_addr.into(),
+ &dst_addr.into(),
+ &packet,
+ &ChecksumCapabilities::ignored(),
+ ) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!(
+ "icmp:{}: malformed packet in queue, dropping",
+ remote_endpoint
+ );
+ return Ok(());
+ }
+ };
+ let ip_repr = IpRepr::Ipv6(Ipv6Repr {
+ src_addr,
+ dst_addr,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: repr.buffer_len(),
+ hop_limit,
+ });
+ emit(cx, (ip_repr, IcmpRepr::Ipv6(repr)))
+ }
+ }
+ });
+ match res {
+ Err(Empty) => Ok(()),
+ Ok(Err(e)) => Err(e),
+ Ok(Ok(())) => {
+ #[cfg(feature = "async")]
+ self.tx_waker.wake();
+ Ok(())
+ }
+ }
+ }
+
+ pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+ if self.tx_buffer.is_empty() {
+ PollAt::Ingress
+ } else {
+ PollAt::Now
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests_common {
+ pub use super::*;
+ pub use crate::wire::IpAddress;
+
+ pub fn buffer(packets: usize) -> PacketBuffer<'static> {
+ PacketBuffer::new(vec![PacketMetadata::EMPTY; packets], vec![0; 66 * packets])
+ }
+
+ pub fn socket(
+ rx_buffer: PacketBuffer<'static>,
+ tx_buffer: PacketBuffer<'static>,
+ ) -> Socket<'static> {
+ Socket::new(rx_buffer, tx_buffer)
+ }
+
+ pub const LOCAL_PORT: u16 = 53;
+
+ pub static UDP_REPR: UdpRepr = UdpRepr {
+ src_port: 53,
+ dst_port: 9090,
+ };
+
+ pub static UDP_PAYLOAD: &[u8] = &[0xff; 10];
+}
+
+#[cfg(all(test, feature = "proto-ipv4"))]
+mod test_ipv4 {
+ use crate::phy::Medium;
+ use crate::tests::setup;
+ use rstest::*;
+
+ use super::tests_common::*;
+ use crate::wire::{Icmpv4DstUnreachable, IpEndpoint, Ipv4Address};
+
+ const REMOTE_IPV4: Ipv4Address = Ipv4Address([192, 168, 1, 2]);
+ const LOCAL_IPV4: Ipv4Address = Ipv4Address([192, 168, 1, 1]);
+ const LOCAL_END_V4: IpEndpoint = IpEndpoint {
+ addr: IpAddress::Ipv4(LOCAL_IPV4),
+ port: LOCAL_PORT,
+ };
+
+ static ECHOV4_REPR: Icmpv4Repr = Icmpv4Repr::EchoRequest {
+ ident: 0x1234,
+ seq_no: 0x5678,
+ data: &[0xff; 16],
+ };
+
+ static LOCAL_IPV4_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: LOCAL_IPV4,
+ dst_addr: REMOTE_IPV4,
+ next_header: IpProtocol::Icmp,
+ payload_len: 24,
+ hop_limit: 0x40,
+ });
+
+ static REMOTE_IPV4_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: REMOTE_IPV4,
+ dst_addr: LOCAL_IPV4,
+ next_header: IpProtocol::Icmp,
+ payload_len: 24,
+ hop_limit: 0x40,
+ });
+
+ #[test]
+ fn test_send_unaddressable() {
+ let mut socket = socket(buffer(0), buffer(1));
+ assert_eq!(
+ socket.send_slice(b"abcdef", IpAddress::Ipv4(Ipv4Address::default())),
+ Err(SendError::Unaddressable)
+ );
+ assert_eq!(socket.send_slice(b"abcdef", REMOTE_IPV4.into()), Ok(()));
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_send_dispatch(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(0), buffer(1));
+ let checksum = ChecksumCapabilities::default();
+
+ assert_eq!(socket.dispatch(cx, |_, _| unreachable!()), Ok::<_, ()>(()));
+
+ // This buffer is too long
+ assert_eq!(
+ socket.send_slice(&[0xff; 67], REMOTE_IPV4.into()),
+ Err(SendError::BufferFull)
+ );
+ assert!(socket.can_send());
+
+ let mut bytes = [0xff; 24];
+ let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
+ ECHOV4_REPR.emit(&mut packet, &checksum);
+
+ assert_eq!(
+ socket.send_slice(&*packet.into_inner(), REMOTE_IPV4.into()),
+ Ok(())
+ );
+ assert_eq!(
+ socket.send_slice(b"123456", REMOTE_IPV4.into()),
+ Err(SendError::BufferFull)
+ );
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(cx, |_, (ip_repr, icmp_repr)| {
+ assert_eq!(ip_repr, LOCAL_IPV4_REPR);
+ assert_eq!(icmp_repr, ECHOV4_REPR.into());
+ Err(())
+ }),
+ Err(())
+ );
+ // buffer is not taken off of the tx queue due to the error
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(cx, |_, (ip_repr, icmp_repr)| {
+ assert_eq!(ip_repr, LOCAL_IPV4_REPR);
+ assert_eq!(icmp_repr, ECHOV4_REPR.into());
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+ // buffer is taken off of the queue this time
+ assert!(socket.can_send());
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_set_hop_limit_v4(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut s = socket(buffer(0), buffer(1));
+ let checksum = ChecksumCapabilities::default();
+
+ let mut bytes = [0xff; 24];
+ let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
+ ECHOV4_REPR.emit(&mut packet, &checksum);
+
+ s.set_hop_limit(Some(0x2a));
+
+ assert_eq!(
+ s.send_slice(&*packet.into_inner(), REMOTE_IPV4.into()),
+ Ok(())
+ );
+ assert_eq!(
+ s.dispatch(cx, |_, (ip_repr, _)| {
+ assert_eq!(
+ ip_repr,
+ IpRepr::Ipv4(Ipv4Repr {
+ src_addr: LOCAL_IPV4,
+ dst_addr: REMOTE_IPV4,
+ next_header: IpProtocol::Icmp,
+ payload_len: ECHOV4_REPR.buffer_len(),
+ hop_limit: 0x2a,
+ })
+ );
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_recv_process(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(1));
+ assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
+
+ assert!(!socket.can_recv());
+ assert_eq!(socket.recv(), Err(RecvError::Exhausted));
+
+ let checksum = ChecksumCapabilities::default();
+
+ let mut bytes = [0xff; 24];
+ let mut packet = Icmpv4Packet::new_unchecked(&mut bytes[..]);
+ ECHOV4_REPR.emit(&mut packet, &checksum);
+ let data = &*packet.into_inner();
+
+ assert!(socket.accepts(cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()));
+ socket.process(cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into());
+ assert!(socket.can_recv());
+
+ assert!(socket.accepts(cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()));
+ socket.process(cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into());
+
+ assert_eq!(socket.recv(), Ok((data, REMOTE_IPV4.into())));
+ assert!(!socket.can_recv());
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_accept_bad_id(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(1));
+ assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
+
+ let checksum = ChecksumCapabilities::default();
+ let mut bytes = [0xff; 20];
+ let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
+ let icmp_repr = Icmpv4Repr::EchoRequest {
+ ident: 0x4321,
+ seq_no: 0x5678,
+ data: &[0xff; 16],
+ };
+ icmp_repr.emit(&mut packet, &checksum);
+
+ // Ensure that a packet with an identifier that isn't the bound
+ // ID is not accepted
+ assert!(!socket.accepts(cx, &REMOTE_IPV4_REPR, &icmp_repr.into()));
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_accepts_udp(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(1));
+ assert_eq!(socket.bind(Endpoint::Udp(LOCAL_END_V4.into())), Ok(()));
+
+ let checksum = ChecksumCapabilities::default();
+
+ let mut bytes = [0xff; 18];
+ let mut packet = UdpPacket::new_unchecked(&mut bytes);
+ UDP_REPR.emit(
+ &mut packet,
+ &REMOTE_IPV4.into(),
+ &LOCAL_IPV4.into(),
+ UDP_PAYLOAD.len(),
+ |buf| buf.copy_from_slice(UDP_PAYLOAD),
+ &checksum,
+ );
+
+ let data = &*packet.into_inner();
+
+ let icmp_repr = Icmpv4Repr::DstUnreachable {
+ reason: Icmpv4DstUnreachable::PortUnreachable,
+ header: Ipv4Repr {
+ src_addr: LOCAL_IPV4,
+ dst_addr: REMOTE_IPV4,
+ next_header: IpProtocol::Icmp,
+ payload_len: 12,
+ hop_limit: 0x40,
+ },
+ data,
+ };
+ let ip_repr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: REMOTE_IPV4,
+ dst_addr: LOCAL_IPV4,
+ next_header: IpProtocol::Icmp,
+ payload_len: icmp_repr.buffer_len(),
+ hop_limit: 0x40,
+ });
+
+ assert!(!socket.can_recv());
+
+ // Ensure we can accept ICMP error response to the bound
+ // UDP port
+ assert!(socket.accepts(cx, &ip_repr, &icmp_repr.into()));
+ socket.process(cx, &ip_repr, &icmp_repr.into());
+ assert!(socket.can_recv());
+
+ let mut bytes = [0x00; 46];
+ let mut packet = Icmpv4Packet::new_unchecked(&mut bytes[..]);
+ icmp_repr.emit(&mut packet, &checksum);
+ assert_eq!(
+ socket.recv(),
+ Ok((&*packet.into_inner(), REMOTE_IPV4.into()))
+ );
+ assert!(!socket.can_recv());
+ }
+}
+
+#[cfg(all(test, feature = "proto-ipv6"))]
+mod test_ipv6 {
+ use crate::phy::Medium;
+ use crate::tests::setup;
+ use rstest::*;
+
+ use super::tests_common::*;
+
+ use crate::wire::{Icmpv6DstUnreachable, IpEndpoint, Ipv6Address};
+
+ const REMOTE_IPV6: Ipv6Address =
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]);
+ const LOCAL_IPV6: Ipv6Address =
+ Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
+ const LOCAL_END_V6: IpEndpoint = IpEndpoint {
+ addr: IpAddress::Ipv6(LOCAL_IPV6),
+ port: LOCAL_PORT,
+ };
+ static ECHOV6_REPR: Icmpv6Repr = Icmpv6Repr::EchoRequest {
+ ident: 0x1234,
+ seq_no: 0x5678,
+ data: &[0xff; 16],
+ };
+
+ static LOCAL_IPV6_REPR: IpRepr = IpRepr::Ipv6(Ipv6Repr {
+ src_addr: LOCAL_IPV6,
+ dst_addr: REMOTE_IPV6,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 24,
+ hop_limit: 0x40,
+ });
+
+ static REMOTE_IPV6_REPR: IpRepr = IpRepr::Ipv6(Ipv6Repr {
+ src_addr: REMOTE_IPV6,
+ dst_addr: LOCAL_IPV6,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 24,
+ hop_limit: 0x40,
+ });
+
+ #[test]
+ fn test_send_unaddressable() {
+ let mut socket = socket(buffer(0), buffer(1));
+ assert_eq!(
+ socket.send_slice(b"abcdef", IpAddress::Ipv6(Ipv6Address::default())),
+ Err(SendError::Unaddressable)
+ );
+ assert_eq!(socket.send_slice(b"abcdef", REMOTE_IPV6.into()), Ok(()));
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_send_dispatch(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(0), buffer(1));
+ let checksum = ChecksumCapabilities::default();
+
+ assert_eq!(socket.dispatch(cx, |_, _| unreachable!()), Ok::<_, ()>(()));
+
+ // This buffer is too long
+ assert_eq!(
+ socket.send_slice(&[0xff; 67], REMOTE_IPV6.into()),
+ Err(SendError::BufferFull)
+ );
+ assert!(socket.can_send());
+
+ let mut bytes = vec![0xff; 24];
+ let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
+ ECHOV6_REPR.emit(
+ &LOCAL_IPV6.into(),
+ &REMOTE_IPV6.into(),
+ &mut packet,
+ &checksum,
+ );
+
+ assert_eq!(
+ socket.send_slice(&*packet.into_inner(), REMOTE_IPV6.into()),
+ Ok(())
+ );
+ assert_eq!(
+ socket.send_slice(b"123456", REMOTE_IPV6.into()),
+ Err(SendError::BufferFull)
+ );
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(cx, |_, (ip_repr, icmp_repr)| {
+ assert_eq!(ip_repr, LOCAL_IPV6_REPR);
+ assert_eq!(icmp_repr, ECHOV6_REPR.into());
+ Err(())
+ }),
+ Err(())
+ );
+ // buffer is not taken off of the tx queue due to the error
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(cx, |_, (ip_repr, icmp_repr)| {
+ assert_eq!(ip_repr, LOCAL_IPV6_REPR);
+ assert_eq!(icmp_repr, ECHOV6_REPR.into());
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+ // buffer is taken off of the queue this time
+ assert!(socket.can_send());
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_set_hop_limit(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut s = socket(buffer(0), buffer(1));
+ let checksum = ChecksumCapabilities::default();
+
+ let mut bytes = vec![0xff; 24];
+ let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
+ ECHOV6_REPR.emit(
+ &LOCAL_IPV6.into(),
+ &REMOTE_IPV6.into(),
+ &mut packet,
+ &checksum,
+ );
+
+ s.set_hop_limit(Some(0x2a));
+
+ assert_eq!(
+ s.send_slice(&*packet.into_inner(), REMOTE_IPV6.into()),
+ Ok(())
+ );
+ assert_eq!(
+ s.dispatch(cx, |_, (ip_repr, _)| {
+ assert_eq!(
+ ip_repr,
+ IpRepr::Ipv6(Ipv6Repr {
+ src_addr: LOCAL_IPV6,
+ dst_addr: REMOTE_IPV6,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: ECHOV6_REPR.buffer_len(),
+ hop_limit: 0x2a,
+ })
+ );
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_recv_process(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(1));
+ assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
+
+ assert!(!socket.can_recv());
+ assert_eq!(socket.recv(), Err(RecvError::Exhausted));
+
+ let checksum = ChecksumCapabilities::default();
+
+ let mut bytes = [0xff; 24];
+ let mut packet = Icmpv6Packet::new_unchecked(&mut bytes[..]);
+ ECHOV6_REPR.emit(
+ &LOCAL_IPV6.into(),
+ &REMOTE_IPV6.into(),
+ &mut packet,
+ &checksum,
+ );
+ let data = &*packet.into_inner();
+
+ assert!(socket.accepts(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
+ socket.process(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into());
+ assert!(socket.can_recv());
+
+ assert!(socket.accepts(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
+ socket.process(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into());
+
+ assert_eq!(socket.recv(), Ok((data, REMOTE_IPV6.into())));
+ assert!(!socket.can_recv());
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_truncated_recv_slice(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(1));
+ assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
+
+ let checksum = ChecksumCapabilities::default();
+
+ let mut bytes = [0xff; 24];
+ let mut packet = Icmpv6Packet::new_unchecked(&mut bytes[..]);
+ ECHOV6_REPR.emit(
+ &LOCAL_IPV6.into(),
+ &REMOTE_IPV6.into(),
+ &mut packet,
+ &checksum,
+ );
+
+ assert!(socket.accepts(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
+ socket.process(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into());
+ assert!(socket.can_recv());
+
+ assert!(socket.accepts(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
+ socket.process(cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into());
+
+ let mut buffer = [0u8; 1];
+ assert_eq!(
+ socket.recv_slice(&mut buffer[..]),
+ Err(RecvError::Truncated)
+ );
+ assert!(!socket.can_recv());
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_accept_bad_id(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(1));
+ assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
+
+ let checksum = ChecksumCapabilities::default();
+ let mut bytes = [0xff; 20];
+ let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
+ let icmp_repr = Icmpv6Repr::EchoRequest {
+ ident: 0x4321,
+ seq_no: 0x5678,
+ data: &[0xff; 16],
+ };
+ icmp_repr.emit(
+ &LOCAL_IPV6.into(),
+ &REMOTE_IPV6.into(),
+ &mut packet,
+ &checksum,
+ );
+
+ // Ensure that a packet with an identifier that isn't the bound
+ // ID is not accepted
+ assert!(!socket.accepts(cx, &REMOTE_IPV6_REPR, &icmp_repr.into()));
+ }
+
+ #[rstest]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ fn test_accepts_udp(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(1));
+ assert_eq!(socket.bind(Endpoint::Udp(LOCAL_END_V6.into())), Ok(()));
+
+ let checksum = ChecksumCapabilities::default();
+
+ let mut bytes = [0xff; 18];
+ let mut packet = UdpPacket::new_unchecked(&mut bytes);
+ UDP_REPR.emit(
+ &mut packet,
+ &REMOTE_IPV6.into(),
+ &LOCAL_IPV6.into(),
+ UDP_PAYLOAD.len(),
+ |buf| buf.copy_from_slice(UDP_PAYLOAD),
+ &checksum,
+ );
+
+ let data = &*packet.into_inner();
+
+ let icmp_repr = Icmpv6Repr::DstUnreachable {
+ reason: Icmpv6DstUnreachable::PortUnreachable,
+ header: Ipv6Repr {
+ src_addr: LOCAL_IPV6,
+ dst_addr: REMOTE_IPV6,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: 12,
+ hop_limit: 0x40,
+ },
+ data,
+ };
+ let ip_repr = IpRepr::Ipv6(Ipv6Repr {
+ src_addr: REMOTE_IPV6,
+ dst_addr: LOCAL_IPV6,
+ next_header: IpProtocol::Icmpv6,
+ payload_len: icmp_repr.buffer_len(),
+ hop_limit: 0x40,
+ });
+
+ assert!(!socket.can_recv());
+
+ // Ensure we can accept ICMP error response to the bound
+ // UDP port
+ assert!(socket.accepts(cx, &ip_repr, &icmp_repr.into()));
+ socket.process(cx, &ip_repr, &icmp_repr.into());
+ assert!(socket.can_recv());
+
+ let mut bytes = [0x00; 66];
+ let mut packet = Icmpv6Packet::new_unchecked(&mut bytes[..]);
+ icmp_repr.emit(
+ &LOCAL_IPV6.into(),
+ &REMOTE_IPV6.into(),
+ &mut packet,
+ &checksum,
+ );
+ assert_eq!(
+ socket.recv(),
+ Ok((&*packet.into_inner(), REMOTE_IPV6.into()))
+ );
+ assert!(!socket.can_recv());
+ }
+}
diff --git a/src/socket/mod.rs b/src/socket/mod.rs
new file mode 100644
index 0000000..7d48b42
--- /dev/null
+++ b/src/socket/mod.rs
@@ -0,0 +1,141 @@
+/*! Communication between endpoints.
+
+The `socket` module deals with *network endpoints* and *buffering*.
+It provides interfaces for accessing buffers of data, and protocol state machines
+for filling and emptying these buffers.
+
+The programming interface implemented here differs greatly from the common Berkeley socket
+interface. Specifically, in the Berkeley interface the buffering is implicit:
+the operating system decides on the good size for a buffer and manages it.
+The interface implemented by this module uses explicit buffering: you decide on the good
+size for a buffer, allocate it, and let the networking stack use it.
+*/
+
+use crate::iface::Context;
+use crate::time::Instant;
+
+#[cfg(feature = "socket-dhcpv4")]
+pub mod dhcpv4;
+#[cfg(feature = "socket-dns")]
+pub mod dns;
+#[cfg(feature = "socket-icmp")]
+pub mod icmp;
+#[cfg(feature = "socket-raw")]
+pub mod raw;
+#[cfg(feature = "socket-tcp")]
+pub mod tcp;
+#[cfg(feature = "socket-udp")]
+pub mod udp;
+
+#[cfg(feature = "async")]
+mod waker;
+
+#[cfg(feature = "async")]
+pub(crate) use self::waker::WakerRegistration;
+
+/// Gives an indication on the next time the socket should be polled.
+#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub(crate) enum PollAt {
+ /// The socket needs to be polled immediately.
+ Now,
+ /// The socket needs to be polled at given [Instant][struct.Instant].
+ Time(Instant),
+ /// The socket does not need to be polled unless there are external changes.
+ Ingress,
+}
+
+/// A network socket.
+///
+/// This enumeration abstracts the various types of sockets based on the IP protocol.
+/// To downcast a `Socket` value to a concrete socket, use the [AnySocket] trait,
+/// e.g. to get `udp::Socket`, call `udp::Socket::downcast(socket)`.
+///
+/// It is usually more convenient to use [SocketSet::get] instead.
+///
+/// [AnySocket]: trait.AnySocket.html
+/// [SocketSet::get]: struct.SocketSet.html#method.get
+#[derive(Debug)]
+pub enum Socket<'a> {
+ #[cfg(feature = "socket-raw")]
+ Raw(raw::Socket<'a>),
+ #[cfg(feature = "socket-icmp")]
+ Icmp(icmp::Socket<'a>),
+ #[cfg(feature = "socket-udp")]
+ Udp(udp::Socket<'a>),
+ #[cfg(feature = "socket-tcp")]
+ Tcp(tcp::Socket<'a>),
+ #[cfg(feature = "socket-dhcpv4")]
+ Dhcpv4(dhcpv4::Socket<'a>),
+ #[cfg(feature = "socket-dns")]
+ Dns(dns::Socket<'a>),
+}
+
+impl<'a> Socket<'a> {
+ pub(crate) fn poll_at(&self, cx: &mut Context) -> PollAt {
+ match self {
+ #[cfg(feature = "socket-raw")]
+ Socket::Raw(s) => s.poll_at(cx),
+ #[cfg(feature = "socket-icmp")]
+ Socket::Icmp(s) => s.poll_at(cx),
+ #[cfg(feature = "socket-udp")]
+ Socket::Udp(s) => s.poll_at(cx),
+ #[cfg(feature = "socket-tcp")]
+ Socket::Tcp(s) => s.poll_at(cx),
+ #[cfg(feature = "socket-dhcpv4")]
+ Socket::Dhcpv4(s) => s.poll_at(cx),
+ #[cfg(feature = "socket-dns")]
+ Socket::Dns(s) => s.poll_at(cx),
+ }
+ }
+}
+
+/// A conversion trait for network sockets.
+pub trait AnySocket<'a> {
+ fn upcast(self) -> Socket<'a>;
+ fn downcast<'c>(socket: &'c Socket<'a>) -> Option<&'c Self>
+ where
+ Self: Sized;
+ fn downcast_mut<'c>(socket: &'c mut Socket<'a>) -> Option<&'c mut Self>
+ where
+ Self: Sized;
+}
+
+macro_rules! from_socket {
+ ($socket:ty, $variant:ident) => {
+ impl<'a> AnySocket<'a> for $socket {
+ fn upcast(self) -> Socket<'a> {
+ Socket::$variant(self)
+ }
+
+ fn downcast<'c>(socket: &'c Socket<'a>) -> Option<&'c Self> {
+ #[allow(unreachable_patterns)]
+ match socket {
+ Socket::$variant(socket) => Some(socket),
+ _ => None,
+ }
+ }
+
+ fn downcast_mut<'c>(socket: &'c mut Socket<'a>) -> Option<&'c mut Self> {
+ #[allow(unreachable_patterns)]
+ match socket {
+ Socket::$variant(socket) => Some(socket),
+ _ => None,
+ }
+ }
+ }
+ };
+}
+
+#[cfg(feature = "socket-raw")]
+from_socket!(raw::Socket<'a>, Raw);
+#[cfg(feature = "socket-icmp")]
+from_socket!(icmp::Socket<'a>, Icmp);
+#[cfg(feature = "socket-udp")]
+from_socket!(udp::Socket<'a>, Udp);
+#[cfg(feature = "socket-tcp")]
+from_socket!(tcp::Socket<'a>, Tcp);
+#[cfg(feature = "socket-dhcpv4")]
+from_socket!(dhcpv4::Socket<'a>, Dhcpv4);
+#[cfg(feature = "socket-dns")]
+from_socket!(dns::Socket<'a>, Dns);
diff --git a/src/socket/raw.rs b/src/socket/raw.rs
new file mode 100644
index 0000000..bb3a204
--- /dev/null
+++ b/src/socket/raw.rs
@@ -0,0 +1,848 @@
+use core::cmp::min;
+#[cfg(feature = "async")]
+use core::task::Waker;
+
+use crate::iface::Context;
+use crate::socket::PollAt;
+#[cfg(feature = "async")]
+use crate::socket::WakerRegistration;
+
+use crate::storage::Empty;
+use crate::wire::{IpProtocol, IpRepr, IpVersion};
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::{Ipv4Packet, Ipv4Repr};
+#[cfg(feature = "proto-ipv6")]
+use crate::wire::{Ipv6Packet, Ipv6Repr};
+
+/// Error returned by [`Socket::bind`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum BindError {
+ InvalidState,
+ Unaddressable,
+}
+
+impl core::fmt::Display for BindError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ BindError::InvalidState => write!(f, "invalid state"),
+ BindError::Unaddressable => write!(f, "unaddressable"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BindError {}
+
+/// Error returned by [`Socket::send`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SendError {
+ BufferFull,
+}
+
+impl core::fmt::Display for SendError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ SendError::BufferFull => write!(f, "buffer full"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SendError {}
+
+/// Error returned by [`Socket::recv`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RecvError {
+ Exhausted,
+ Truncated,
+}
+
+impl core::fmt::Display for RecvError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ RecvError::Exhausted => write!(f, "exhausted"),
+ RecvError::Truncated => write!(f, "truncated"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RecvError {}
+
+/// A UDP packet metadata.
+pub type PacketMetadata = crate::storage::PacketMetadata<()>;
+
+/// A UDP packet ring buffer.
+pub type PacketBuffer<'a> = crate::storage::PacketBuffer<'a, ()>;
+
+/// A raw IP socket.
+///
+/// A raw socket is bound to a specific IP protocol, and owns
+/// transmit and receive packet buffers.
+#[derive(Debug)]
+pub struct Socket<'a> {
+ ip_version: IpVersion,
+ ip_protocol: IpProtocol,
+ rx_buffer: PacketBuffer<'a>,
+ tx_buffer: PacketBuffer<'a>,
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration,
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration,
+}
+
+impl<'a> Socket<'a> {
+ /// Create a raw IP socket bound to the given IP version and datagram protocol,
+ /// with the given buffers.
+ pub fn new(
+ ip_version: IpVersion,
+ ip_protocol: IpProtocol,
+ rx_buffer: PacketBuffer<'a>,
+ tx_buffer: PacketBuffer<'a>,
+ ) -> Socket<'a> {
+ Socket {
+ ip_version,
+ ip_protocol,
+ rx_buffer,
+ tx_buffer,
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration::new(),
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration::new(),
+ }
+ }
+
+ /// Register a waker for receive operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `recv` method calls, such as receiving data, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `recv` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_recv_waker(&mut self, waker: &Waker) {
+ self.rx_waker.register(waker)
+ }
+
+ /// Register a waker for send operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `send` method calls, such as space becoming available in the transmit
+ /// buffer, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `send` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_send_waker(&mut self, waker: &Waker) {
+ self.tx_waker.register(waker)
+ }
+
+ /// Return the IP version the socket is bound to.
+ #[inline]
+ pub fn ip_version(&self) -> IpVersion {
+ self.ip_version
+ }
+
+ /// Return the IP protocol the socket is bound to.
+ #[inline]
+ pub fn ip_protocol(&self) -> IpProtocol {
+ self.ip_protocol
+ }
+
+ /// Check whether the transmit buffer is full.
+ #[inline]
+ pub fn can_send(&self) -> bool {
+ !self.tx_buffer.is_full()
+ }
+
+ /// Check whether the receive buffer is not empty.
+ #[inline]
+ pub fn can_recv(&self) -> bool {
+ !self.rx_buffer.is_empty()
+ }
+
+ /// Return the maximum number packets the socket can receive.
+ #[inline]
+ pub fn packet_recv_capacity(&self) -> usize {
+ self.rx_buffer.packet_capacity()
+ }
+
+ /// Return the maximum number packets the socket can transmit.
+ #[inline]
+ pub fn packet_send_capacity(&self) -> usize {
+ self.tx_buffer.packet_capacity()
+ }
+
+ /// Return the maximum number of bytes inside the recv buffer.
+ #[inline]
+ pub fn payload_recv_capacity(&self) -> usize {
+ self.rx_buffer.payload_capacity()
+ }
+
+ /// Return the maximum number of bytes inside the transmit buffer.
+ #[inline]
+ pub fn payload_send_capacity(&self) -> usize {
+ self.tx_buffer.payload_capacity()
+ }
+
+ /// Enqueue a packet to send, and return a pointer to its payload.
+ ///
+ /// This function returns `Err(Error::Exhausted)` if the transmit buffer is full,
+ /// and `Err(Error::Truncated)` if there is not enough transmit buffer capacity
+ /// to ever send this packet.
+ ///
+ /// If the buffer is filled in a way that does not match the socket's
+ /// IP version or protocol, the packet will be silently dropped.
+ ///
+ /// **Note:** The IP header is parsed and re-serialized, and may not match
+ /// the header actually transmitted bit for bit.
+ pub fn send(&mut self, size: usize) -> Result<&mut [u8], SendError> {
+ let packet_buf = self
+ .tx_buffer
+ .enqueue(size, ())
+ .map_err(|_| SendError::BufferFull)?;
+
+ net_trace!(
+ "raw:{}:{}: buffer to send {} octets",
+ self.ip_version,
+ self.ip_protocol,
+ packet_buf.len()
+ );
+ Ok(packet_buf)
+ }
+
+ /// Enqueue a packet to be send and pass the buffer to the provided closure.
+ /// The closure then returns the size of the data written into the buffer.
+ ///
+ /// Also see [send](#method.send).
+ pub fn send_with<F>(&mut self, max_size: usize, f: F) -> Result<usize, SendError>
+ where
+ F: FnOnce(&mut [u8]) -> usize,
+ {
+ let size = self
+ .tx_buffer
+ .enqueue_with_infallible(max_size, (), f)
+ .map_err(|_| SendError::BufferFull)?;
+
+ net_trace!(
+ "raw:{}:{}: buffer to send {} octets",
+ self.ip_version,
+ self.ip_protocol,
+ size
+ );
+
+ Ok(size)
+ }
+
+ /// Enqueue a packet to send, and fill it from a slice.
+ ///
+ /// See also [send](#method.send).
+ pub fn send_slice(&mut self, data: &[u8]) -> Result<(), SendError> {
+ self.send(data.len())?.copy_from_slice(data);
+ Ok(())
+ }
+
+ /// Dequeue a packet, and return a pointer to the payload.
+ ///
+ /// This function returns `Err(Error::Exhausted)` if the receive buffer is empty.
+ ///
+ /// **Note:** The IP header is parsed and re-serialized, and may not match
+ /// the header actually received bit for bit.
+ pub fn recv(&mut self) -> Result<&[u8], RecvError> {
+ let ((), packet_buf) = self.rx_buffer.dequeue().map_err(|_| RecvError::Exhausted)?;
+
+ net_trace!(
+ "raw:{}:{}: receive {} buffered octets",
+ self.ip_version,
+ self.ip_protocol,
+ packet_buf.len()
+ );
+ Ok(packet_buf)
+ }
+
+ /// Dequeue a packet, and copy the payload into the given slice.
+ ///
+ /// **Note**: when the size of the provided buffer is smaller than the size of the payload,
+ /// the packet is dropped and a `RecvError::Truncated` error is returned.
+ ///
+ /// See also [recv](#method.recv).
+ pub fn recv_slice(&mut self, data: &mut [u8]) -> Result<usize, RecvError> {
+ let buffer = self.recv()?;
+ if data.len() < buffer.len() {
+ return Err(RecvError::Truncated);
+ }
+
+ let length = min(data.len(), buffer.len());
+ data[..length].copy_from_slice(&buffer[..length]);
+ Ok(length)
+ }
+
+ /// Peek at a packet in the receive buffer and return a pointer to the
+ /// payload without removing the packet from the receive buffer.
+ /// This function otherwise behaves identically to [recv](#method.recv).
+ ///
+ /// It returns `Err(Error::Exhausted)` if the receive buffer is empty.
+ pub fn peek(&mut self) -> Result<&[u8], RecvError> {
+ let ((), packet_buf) = self.rx_buffer.peek().map_err(|_| RecvError::Exhausted)?;
+
+ net_trace!(
+ "raw:{}:{}: receive {} buffered octets",
+ self.ip_version,
+ self.ip_protocol,
+ packet_buf.len()
+ );
+
+ Ok(packet_buf)
+ }
+
+ /// Peek at a packet in the receive buffer, copy the payload into the given slice,
+ /// and return the amount of octets copied without removing the packet from the receive buffer.
+ /// This function otherwise behaves identically to [recv_slice](#method.recv_slice).
+ ///
+ /// **Note**: when the size of the provided buffer is smaller than the size of the payload,
+ /// no data is copied into the provided buffer and a `RecvError::Truncated` error is returned.
+ ///
+ /// See also [peek](#method.peek).
+ pub fn peek_slice(&mut self, data: &mut [u8]) -> Result<usize, RecvError> {
+ let buffer = self.peek()?;
+ if data.len() < buffer.len() {
+ return Err(RecvError::Truncated);
+ }
+
+ let length = min(data.len(), buffer.len());
+ data[..length].copy_from_slice(&buffer[..length]);
+ Ok(length)
+ }
+
+ pub(crate) fn accepts(&self, ip_repr: &IpRepr) -> bool {
+ if ip_repr.version() != self.ip_version {
+ return false;
+ }
+ if ip_repr.next_header() != self.ip_protocol {
+ return false;
+ }
+
+ true
+ }
+
+ pub(crate) fn process(&mut self, cx: &mut Context, ip_repr: &IpRepr, payload: &[u8]) {
+ debug_assert!(self.accepts(ip_repr));
+
+ let header_len = ip_repr.header_len();
+ let total_len = header_len + payload.len();
+
+ net_trace!(
+ "raw:{}:{}: receiving {} octets",
+ self.ip_version,
+ self.ip_protocol,
+ total_len
+ );
+
+ match self.rx_buffer.enqueue(total_len, ()) {
+ Ok(buf) => {
+ ip_repr.emit(&mut buf[..header_len], &cx.checksum_caps());
+ buf[header_len..].copy_from_slice(payload);
+ }
+ Err(_) => net_trace!(
+ "raw:{}:{}: buffer full, dropped incoming packet",
+ self.ip_version,
+ self.ip_protocol
+ ),
+ }
+
+ #[cfg(feature = "async")]
+ self.rx_waker.wake();
+ }
+
+ pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+ where
+ F: FnOnce(&mut Context, (IpRepr, &[u8])) -> Result<(), E>,
+ {
+ let ip_protocol = self.ip_protocol;
+ let ip_version = self.ip_version;
+ let _checksum_caps = &cx.checksum_caps();
+ let res = self.tx_buffer.dequeue_with(|&mut (), buffer| {
+ match IpVersion::of_packet(buffer) {
+ #[cfg(feature = "proto-ipv4")]
+ Ok(IpVersion::Ipv4) => {
+ let mut packet = match Ipv4Packet::new_checked(buffer) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!("raw: malformed ipv6 packet in queue, dropping.");
+ return Ok(());
+ }
+ };
+ if packet.next_header() != ip_protocol {
+ net_trace!("raw: sent packet with wrong ip protocol, dropping.");
+ return Ok(());
+ }
+ if _checksum_caps.ipv4.tx() {
+ packet.fill_checksum();
+ } else {
+ // make sure we get a consistently zeroed checksum,
+ // since implementations might rely on it
+ packet.set_checksum(0);
+ }
+
+ let packet = Ipv4Packet::new_unchecked(&*packet.into_inner());
+ let ipv4_repr = match Ipv4Repr::parse(&packet, _checksum_caps) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!("raw: malformed ipv4 packet in queue, dropping.");
+ return Ok(());
+ }
+ };
+ net_trace!("raw:{}:{}: sending", ip_version, ip_protocol);
+ emit(cx, (IpRepr::Ipv4(ipv4_repr), packet.payload()))
+ }
+ #[cfg(feature = "proto-ipv6")]
+ Ok(IpVersion::Ipv6) => {
+ let packet = match Ipv6Packet::new_checked(buffer) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!("raw: malformed ipv6 packet in queue, dropping.");
+ return Ok(());
+ }
+ };
+ if packet.next_header() != ip_protocol {
+ net_trace!("raw: sent ipv6 packet with wrong ip protocol, dropping.");
+ return Ok(());
+ }
+ let packet = Ipv6Packet::new_unchecked(&*packet.into_inner());
+ let ipv6_repr = match Ipv6Repr::parse(&packet) {
+ Ok(x) => x,
+ Err(_) => {
+ net_trace!("raw: malformed ipv6 packet in queue, dropping.");
+ return Ok(());
+ }
+ };
+
+ net_trace!("raw:{}:{}: sending", ip_version, ip_protocol);
+ emit(cx, (IpRepr::Ipv6(ipv6_repr), packet.payload()))
+ }
+ Err(_) => {
+ net_trace!("raw: sent packet with invalid IP version, dropping.");
+ Ok(())
+ }
+ }
+ });
+ match res {
+ Err(Empty) => Ok(()),
+ Ok(Err(e)) => Err(e),
+ Ok(Ok(())) => {
+ #[cfg(feature = "async")]
+ self.tx_waker.wake();
+ Ok(())
+ }
+ }
+ }
+
+ pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+ if self.tx_buffer.is_empty() {
+ PollAt::Ingress
+ } else {
+ PollAt::Now
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use crate::phy::Medium;
+ use crate::tests::setup;
+ use rstest::*;
+
+ use super::*;
+ use crate::wire::IpRepr;
+ #[cfg(feature = "proto-ipv4")]
+ use crate::wire::{Ipv4Address, Ipv4Repr};
+ #[cfg(feature = "proto-ipv6")]
+ use crate::wire::{Ipv6Address, Ipv6Repr};
+
+ fn buffer(packets: usize) -> PacketBuffer<'static> {
+ PacketBuffer::new(vec![PacketMetadata::EMPTY; packets], vec![0; 48 * packets])
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ mod ipv4_locals {
+ use super::*;
+
+ pub fn socket(
+ rx_buffer: PacketBuffer<'static>,
+ tx_buffer: PacketBuffer<'static>,
+ ) -> Socket<'static> {
+ Socket::new(
+ IpVersion::Ipv4,
+ IpProtocol::Unknown(IP_PROTO),
+ rx_buffer,
+ tx_buffer,
+ )
+ }
+
+ pub const IP_PROTO: u8 = 63;
+ pub const HEADER_REPR: IpRepr = IpRepr::Ipv4(Ipv4Repr {
+ src_addr: Ipv4Address([10, 0, 0, 1]),
+ dst_addr: Ipv4Address([10, 0, 0, 2]),
+ next_header: IpProtocol::Unknown(IP_PROTO),
+ payload_len: 4,
+ hop_limit: 64,
+ });
+ pub const PACKET_BYTES: [u8; 24] = [
+ 0x45, 0x00, 0x00, 0x18, 0x00, 0x00, 0x40, 0x00, 0x40, 0x3f, 0x00, 0x00, 0x0a, 0x00,
+ 0x00, 0x01, 0x0a, 0x00, 0x00, 0x02, 0xaa, 0x00, 0x00, 0xff,
+ ];
+ pub const PACKET_PAYLOAD: [u8; 4] = [0xaa, 0x00, 0x00, 0xff];
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ mod ipv6_locals {
+ use super::*;
+
+ pub fn socket(
+ rx_buffer: PacketBuffer<'static>,
+ tx_buffer: PacketBuffer<'static>,
+ ) -> Socket<'static> {
+ Socket::new(
+ IpVersion::Ipv6,
+ IpProtocol::Unknown(IP_PROTO),
+ rx_buffer,
+ tx_buffer,
+ )
+ }
+
+ pub const IP_PROTO: u8 = 63;
+ pub const HEADER_REPR: IpRepr = IpRepr::Ipv6(Ipv6Repr {
+ src_addr: Ipv6Address([
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ ]),
+ dst_addr: Ipv6Address([
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x02,
+ ]),
+ next_header: IpProtocol::Unknown(IP_PROTO),
+ payload_len: 4,
+ hop_limit: 64,
+ });
+
+ pub const PACKET_BYTES: [u8; 44] = [
+ 0x60, 0x00, 0x00, 0x00, 0x00, 0x04, 0x3f, 0x40, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x80, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xaa, 0x00,
+ 0x00, 0xff,
+ ];
+
+ pub const PACKET_PAYLOAD: [u8; 4] = [0xaa, 0x00, 0x00, 0xff];
+ }
+
+ macro_rules! reusable_ip_specific_tests {
+ ($module:ident, $socket:path, $hdr:path, $packet:path, $payload:path) => {
+ mod $module {
+ use super::*;
+
+ #[test]
+ fn test_send_truncated() {
+ let mut socket = $socket(buffer(0), buffer(1));
+ assert_eq!(socket.send_slice(&[0; 56][..]), Err(SendError::BufferFull));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_send_dispatch(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let mut cx = iface.context();
+ let mut socket = $socket(buffer(0), buffer(1));
+
+ assert!(socket.can_send());
+ assert_eq!(
+ socket.dispatch(&mut cx, |_, _| unreachable!()),
+ Ok::<_, ()>(())
+ );
+
+ assert_eq!(socket.send_slice(&$packet[..]), Ok(()));
+ assert_eq!(socket.send_slice(b""), Err(SendError::BufferFull));
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(&mut cx, |_, (ip_repr, ip_payload)| {
+ assert_eq!(ip_repr, $hdr);
+ assert_eq!(ip_payload, &$payload);
+ Err(())
+ }),
+ Err(())
+ );
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(&mut cx, |_, (ip_repr, ip_payload)| {
+ assert_eq!(ip_repr, $hdr);
+ assert_eq!(ip_payload, &$payload);
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+ assert!(socket.can_send());
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_recv_truncated_slice(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let mut cx = iface.context();
+ let mut socket = $socket(buffer(1), buffer(0));
+
+ assert!(socket.accepts(&$hdr));
+ socket.process(&mut cx, &$hdr, &$payload);
+
+ let mut slice = [0; 4];
+ assert_eq!(socket.recv_slice(&mut slice[..]), Err(RecvError::Truncated));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_recv_truncated_packet(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let mut cx = iface.context();
+ let mut socket = $socket(buffer(1), buffer(0));
+
+ let mut buffer = vec![0; 128];
+ buffer[..$packet.len()].copy_from_slice(&$packet[..]);
+
+ assert!(socket.accepts(&$hdr));
+ socket.process(&mut cx, &$hdr, &buffer);
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_peek_truncated_slice(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let mut cx = iface.context();
+ let mut socket = $socket(buffer(1), buffer(0));
+
+ assert!(socket.accepts(&$hdr));
+ socket.process(&mut cx, &$hdr, &$payload);
+
+ let mut slice = [0; 4];
+ assert_eq!(socket.peek_slice(&mut slice[..]), Err(RecvError::Truncated));
+ assert_eq!(socket.recv_slice(&mut slice[..]), Err(RecvError::Truncated));
+ assert_eq!(socket.peek_slice(&mut slice[..]), Err(RecvError::Exhausted));
+ }
+ }
+ };
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ reusable_ip_specific_tests!(
+ ipv4,
+ ipv4_locals::socket,
+ ipv4_locals::HEADER_REPR,
+ ipv4_locals::PACKET_BYTES,
+ ipv4_locals::PACKET_PAYLOAD
+ );
+
+ #[cfg(feature = "proto-ipv6")]
+ reusable_ip_specific_tests!(
+ ipv6,
+ ipv6_locals::socket,
+ ipv6_locals::HEADER_REPR,
+ ipv6_locals::PACKET_BYTES,
+ ipv6_locals::PACKET_PAYLOAD
+ );
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_send_illegal(#[case] medium: Medium) {
+ #[cfg(feature = "proto-ipv4")]
+ {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+ let mut socket = ipv4_locals::socket(buffer(0), buffer(2));
+
+ let mut wrong_version = ipv4_locals::PACKET_BYTES;
+ Ipv4Packet::new_unchecked(&mut wrong_version).set_version(6);
+
+ assert_eq!(socket.send_slice(&wrong_version[..]), Ok(()));
+ assert_eq!(socket.dispatch(cx, |_, _| unreachable!()), Ok::<_, ()>(()));
+
+ let mut wrong_protocol = ipv4_locals::PACKET_BYTES;
+ Ipv4Packet::new_unchecked(&mut wrong_protocol).set_next_header(IpProtocol::Tcp);
+
+ assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(()));
+ assert_eq!(socket.dispatch(cx, |_, _| unreachable!()), Ok::<_, ()>(()));
+ }
+ #[cfg(feature = "proto-ipv6")]
+ {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+ let mut socket = ipv6_locals::socket(buffer(0), buffer(2));
+
+ let mut wrong_version = ipv6_locals::PACKET_BYTES;
+ Ipv6Packet::new_unchecked(&mut wrong_version[..]).set_version(4);
+
+ assert_eq!(socket.send_slice(&wrong_version[..]), Ok(()));
+ assert_eq!(socket.dispatch(cx, |_, _| unreachable!()), Ok::<_, ()>(()));
+
+ let mut wrong_protocol = ipv6_locals::PACKET_BYTES;
+ Ipv6Packet::new_unchecked(&mut wrong_protocol[..]).set_next_header(IpProtocol::Tcp);
+
+ assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(()));
+ assert_eq!(socket.dispatch(cx, |_, _| unreachable!()), Ok::<_, ()>(()));
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_recv_process(#[case] medium: Medium) {
+ #[cfg(feature = "proto-ipv4")]
+ {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+ let mut socket = ipv4_locals::socket(buffer(1), buffer(0));
+ assert!(!socket.can_recv());
+
+ let mut cksumd_packet = ipv4_locals::PACKET_BYTES;
+ Ipv4Packet::new_unchecked(&mut cksumd_packet).fill_checksum();
+
+ assert_eq!(socket.recv(), Err(RecvError::Exhausted));
+ assert!(socket.accepts(&ipv4_locals::HEADER_REPR));
+ socket.process(cx, &ipv4_locals::HEADER_REPR, &ipv4_locals::PACKET_PAYLOAD);
+ assert!(socket.can_recv());
+
+ assert!(socket.accepts(&ipv4_locals::HEADER_REPR));
+ socket.process(cx, &ipv4_locals::HEADER_REPR, &ipv4_locals::PACKET_PAYLOAD);
+ assert_eq!(socket.recv(), Ok(&cksumd_packet[..]));
+ assert!(!socket.can_recv());
+ }
+ #[cfg(feature = "proto-ipv6")]
+ {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+ let mut socket = ipv6_locals::socket(buffer(1), buffer(0));
+ assert!(!socket.can_recv());
+
+ assert_eq!(socket.recv(), Err(RecvError::Exhausted));
+ assert!(socket.accepts(&ipv6_locals::HEADER_REPR));
+ socket.process(cx, &ipv6_locals::HEADER_REPR, &ipv6_locals::PACKET_PAYLOAD);
+ assert!(socket.can_recv());
+
+ assert!(socket.accepts(&ipv6_locals::HEADER_REPR));
+ socket.process(cx, &ipv6_locals::HEADER_REPR, &ipv6_locals::PACKET_PAYLOAD);
+ assert_eq!(socket.recv(), Ok(&ipv6_locals::PACKET_BYTES[..]));
+ assert!(!socket.can_recv());
+ }
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_peek_process(#[case] medium: Medium) {
+ #[cfg(feature = "proto-ipv4")]
+ {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+ let mut socket = ipv4_locals::socket(buffer(1), buffer(0));
+
+ let mut cksumd_packet = ipv4_locals::PACKET_BYTES;
+ Ipv4Packet::new_unchecked(&mut cksumd_packet).fill_checksum();
+
+ assert_eq!(socket.peek(), Err(RecvError::Exhausted));
+ assert!(socket.accepts(&ipv4_locals::HEADER_REPR));
+ socket.process(cx, &ipv4_locals::HEADER_REPR, &ipv4_locals::PACKET_PAYLOAD);
+
+ assert!(socket.accepts(&ipv4_locals::HEADER_REPR));
+ socket.process(cx, &ipv4_locals::HEADER_REPR, &ipv4_locals::PACKET_PAYLOAD);
+ assert_eq!(socket.peek(), Ok(&cksumd_packet[..]));
+ assert_eq!(socket.recv(), Ok(&cksumd_packet[..]));
+ assert_eq!(socket.peek(), Err(RecvError::Exhausted));
+ }
+ #[cfg(feature = "proto-ipv6")]
+ {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+ let mut socket = ipv6_locals::socket(buffer(1), buffer(0));
+
+ assert_eq!(socket.peek(), Err(RecvError::Exhausted));
+ assert!(socket.accepts(&ipv6_locals::HEADER_REPR));
+ socket.process(cx, &ipv6_locals::HEADER_REPR, &ipv6_locals::PACKET_PAYLOAD);
+
+ assert!(socket.accepts(&ipv6_locals::HEADER_REPR));
+ socket.process(cx, &ipv6_locals::HEADER_REPR, &ipv6_locals::PACKET_PAYLOAD);
+ assert_eq!(socket.peek(), Ok(&ipv6_locals::PACKET_BYTES[..]));
+ assert_eq!(socket.recv(), Ok(&ipv6_locals::PACKET_BYTES[..]));
+ assert_eq!(socket.peek(), Err(RecvError::Exhausted));
+ }
+ }
+
+ #[test]
+ fn test_doesnt_accept_wrong_proto() {
+ #[cfg(feature = "proto-ipv4")]
+ {
+ let socket = Socket::new(
+ IpVersion::Ipv4,
+ IpProtocol::Unknown(ipv4_locals::IP_PROTO + 1),
+ buffer(1),
+ buffer(1),
+ );
+ assert!(!socket.accepts(&ipv4_locals::HEADER_REPR));
+ #[cfg(feature = "proto-ipv6")]
+ assert!(!socket.accepts(&ipv6_locals::HEADER_REPR));
+ }
+ #[cfg(feature = "proto-ipv6")]
+ {
+ let socket = Socket::new(
+ IpVersion::Ipv6,
+ IpProtocol::Unknown(ipv6_locals::IP_PROTO + 1),
+ buffer(1),
+ buffer(1),
+ );
+ assert!(!socket.accepts(&ipv6_locals::HEADER_REPR));
+ #[cfg(feature = "proto-ipv4")]
+ assert!(!socket.accepts(&ipv4_locals::HEADER_REPR));
+ }
+ }
+}
diff --git a/src/socket/tcp.rs b/src/socket/tcp.rs
new file mode 100644
index 0000000..d7b85ab
--- /dev/null
+++ b/src/socket/tcp.rs
@@ -0,0 +1,7312 @@
+// Heads up! Before working on this file you should read, at least, RFC 793 and
+// the parts of RFC 1122 that discuss TCP. Consult RFC 7414 when implementing
+// a new feature.
+
+use core::fmt::Display;
+#[cfg(feature = "async")]
+use core::task::Waker;
+use core::{cmp, fmt, mem};
+
+#[cfg(feature = "async")]
+use crate::socket::WakerRegistration;
+use crate::socket::{Context, PollAt};
+use crate::storage::{Assembler, RingBuffer};
+use crate::time::{Duration, Instant};
+use crate::wire::{
+ IpAddress, IpEndpoint, IpListenEndpoint, IpProtocol, IpRepr, TcpControl, TcpRepr, TcpSeqNumber,
+ TCP_HEADER_LEN,
+};
+
+macro_rules! tcp_trace {
+ ($($arg:expr),*) => (net_log!(trace, $($arg),*));
+}
+
+/// Error returned by [`Socket::listen`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum ListenError {
+ InvalidState,
+ Unaddressable,
+}
+
+impl Display for ListenError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ ListenError::InvalidState => write!(f, "invalid state"),
+ ListenError::Unaddressable => write!(f, "unaddressable destination"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ListenError {}
+
+/// Error returned by [`Socket::connect`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum ConnectError {
+ InvalidState,
+ Unaddressable,
+}
+
+impl Display for ConnectError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ ConnectError::InvalidState => write!(f, "invalid state"),
+ ConnectError::Unaddressable => write!(f, "unaddressable destination"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ConnectError {}
+
+/// Error returned by [`Socket::send`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SendError {
+ InvalidState,
+}
+
+impl Display for SendError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ SendError::InvalidState => write!(f, "invalid state"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SendError {}
+
+/// Error returned by [`Socket::recv`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RecvError {
+ InvalidState,
+ Finished,
+}
+
+impl Display for RecvError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ RecvError::InvalidState => write!(f, "invalid state"),
+ RecvError::Finished => write!(f, "operation finished"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RecvError {}
+
+/// A TCP socket ring buffer.
+pub type SocketBuffer<'a> = RingBuffer<'a, u8>;
+
+/// The state of a TCP socket, according to [RFC 793].
+///
+/// [RFC 793]: https://tools.ietf.org/html/rfc793
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum State {
+ Closed,
+ Listen,
+ SynSent,
+ SynReceived,
+ Established,
+ FinWait1,
+ FinWait2,
+ CloseWait,
+ Closing,
+ LastAck,
+ TimeWait,
+}
+
+impl fmt::Display for State {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ State::Closed => write!(f, "CLOSED"),
+ State::Listen => write!(f, "LISTEN"),
+ State::SynSent => write!(f, "SYN-SENT"),
+ State::SynReceived => write!(f, "SYN-RECEIVED"),
+ State::Established => write!(f, "ESTABLISHED"),
+ State::FinWait1 => write!(f, "FIN-WAIT-1"),
+ State::FinWait2 => write!(f, "FIN-WAIT-2"),
+ State::CloseWait => write!(f, "CLOSE-WAIT"),
+ State::Closing => write!(f, "CLOSING"),
+ State::LastAck => write!(f, "LAST-ACK"),
+ State::TimeWait => write!(f, "TIME-WAIT"),
+ }
+ }
+}
+
+// Conservative initial RTT estimate.
+const RTTE_INITIAL_RTT: u32 = 300;
+const RTTE_INITIAL_DEV: u32 = 100;
+
+// Minimum "safety margin" for the RTO that kicks in when the
+// variance gets very low.
+const RTTE_MIN_MARGIN: u32 = 5;
+
+const RTTE_MIN_RTO: u32 = 10;
+const RTTE_MAX_RTO: u32 = 10000;
+
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct RttEstimator {
+ // Using u32 instead of Duration to save space (Duration is i64)
+ rtt: u32,
+ deviation: u32,
+ timestamp: Option<(Instant, TcpSeqNumber)>,
+ max_seq_sent: Option<TcpSeqNumber>,
+ rto_count: u8,
+}
+
+impl Default for RttEstimator {
+ fn default() -> Self {
+ Self {
+ rtt: RTTE_INITIAL_RTT,
+ deviation: RTTE_INITIAL_DEV,
+ timestamp: None,
+ max_seq_sent: None,
+ rto_count: 0,
+ }
+ }
+}
+
+impl RttEstimator {
+ fn retransmission_timeout(&self) -> Duration {
+ let margin = RTTE_MIN_MARGIN.max(self.deviation * 4);
+ let ms = (self.rtt + margin).clamp(RTTE_MIN_RTO, RTTE_MAX_RTO);
+ Duration::from_millis(ms as u64)
+ }
+
+ fn sample(&mut self, new_rtt: u32) {
+ // "Congestion Avoidance and Control", Van Jacobson, Michael J. Karels, 1988
+ self.rtt = (self.rtt * 7 + new_rtt + 7) / 8;
+ let diff = (self.rtt as i32 - new_rtt as i32).unsigned_abs();
+ self.deviation = (self.deviation * 3 + diff + 3) / 4;
+
+ self.rto_count = 0;
+
+ let rto = self.retransmission_timeout().total_millis();
+ tcp_trace!(
+ "rtte: sample={:?} rtt={:?} dev={:?} rto={:?}",
+ new_rtt,
+ self.rtt,
+ self.deviation,
+ rto
+ );
+ }
+
+ fn on_send(&mut self, timestamp: Instant, seq: TcpSeqNumber) {
+ if self
+ .max_seq_sent
+ .map(|max_seq_sent| seq > max_seq_sent)
+ .unwrap_or(true)
+ {
+ self.max_seq_sent = Some(seq);
+ if self.timestamp.is_none() {
+ self.timestamp = Some((timestamp, seq));
+ tcp_trace!("rtte: sampling at seq={:?}", seq);
+ }
+ }
+ }
+
+ fn on_ack(&mut self, timestamp: Instant, seq: TcpSeqNumber) {
+ if let Some((sent_timestamp, sent_seq)) = self.timestamp {
+ if seq >= sent_seq {
+ self.sample((timestamp - sent_timestamp).total_millis() as u32);
+ self.timestamp = None;
+ }
+ }
+ }
+
+ fn on_retransmit(&mut self) {
+ if self.timestamp.is_some() {
+ tcp_trace!("rtte: abort sampling due to retransmit");
+ }
+ self.timestamp = None;
+ self.rto_count = self.rto_count.saturating_add(1);
+ if self.rto_count >= 3 {
+ // This happens in 2 scenarios:
+ // - The RTT is higher than the initial estimate
+ // - The network conditions change, suddenly making the RTT much higher
+ // In these cases, the estimator can get stuck, because it can't sample because
+ // all packets sent would incur a retransmit. To avoid this, force an estimate
+ // increase if we see 3 consecutive retransmissions without any successful sample.
+ self.rto_count = 0;
+ self.rtt = RTTE_MAX_RTO.min(self.rtt * 2);
+ let rto = self.retransmission_timeout().total_millis();
+ tcp_trace!(
+ "rtte: too many retransmissions, increasing: rtt={:?} dev={:?} rto={:?}",
+ self.rtt,
+ self.deviation,
+ rto
+ );
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+enum Timer {
+ Idle {
+ keep_alive_at: Option<Instant>,
+ },
+ Retransmit {
+ expires_at: Instant,
+ delay: Duration,
+ },
+ FastRetransmit,
+ Close {
+ expires_at: Instant,
+ },
+}
+
+const ACK_DELAY_DEFAULT: Duration = Duration::from_millis(10);
+const CLOSE_DELAY: Duration = Duration::from_millis(10_000);
+
+impl Timer {
+ fn new() -> Timer {
+ Timer::Idle {
+ keep_alive_at: None,
+ }
+ }
+
+ fn should_keep_alive(&self, timestamp: Instant) -> bool {
+ match *self {
+ Timer::Idle {
+ keep_alive_at: Some(keep_alive_at),
+ } if timestamp >= keep_alive_at => true,
+ _ => false,
+ }
+ }
+
+ fn should_retransmit(&self, timestamp: Instant) -> Option<Duration> {
+ match *self {
+ Timer::Retransmit { expires_at, delay } if timestamp >= expires_at => {
+ Some(timestamp - expires_at + delay)
+ }
+ Timer::FastRetransmit => Some(Duration::from_millis(0)),
+ _ => None,
+ }
+ }
+
+ fn should_close(&self, timestamp: Instant) -> bool {
+ match *self {
+ Timer::Close { expires_at } if timestamp >= expires_at => true,
+ _ => false,
+ }
+ }
+
+ fn poll_at(&self) -> PollAt {
+ match *self {
+ Timer::Idle {
+ keep_alive_at: Some(keep_alive_at),
+ } => PollAt::Time(keep_alive_at),
+ Timer::Idle {
+ keep_alive_at: None,
+ } => PollAt::Ingress,
+ Timer::Retransmit { expires_at, .. } => PollAt::Time(expires_at),
+ Timer::FastRetransmit => PollAt::Now,
+ Timer::Close { expires_at } => PollAt::Time(expires_at),
+ }
+ }
+
+ fn set_for_idle(&mut self, timestamp: Instant, interval: Option<Duration>) {
+ *self = Timer::Idle {
+ keep_alive_at: interval.map(|interval| timestamp + interval),
+ }
+ }
+
+ fn set_keep_alive(&mut self) {
+ if let Timer::Idle { keep_alive_at } = self {
+ if keep_alive_at.is_none() {
+ *keep_alive_at = Some(Instant::from_millis(0))
+ }
+ }
+ }
+
+ fn rewind_keep_alive(&mut self, timestamp: Instant, interval: Option<Duration>) {
+ if let Timer::Idle { keep_alive_at } = self {
+ *keep_alive_at = interval.map(|interval| timestamp + interval)
+ }
+ }
+
+ fn set_for_retransmit(&mut self, timestamp: Instant, delay: Duration) {
+ match *self {
+ Timer::Idle { .. } | Timer::FastRetransmit { .. } => {
+ *self = Timer::Retransmit {
+ expires_at: timestamp + delay,
+ delay,
+ }
+ }
+ Timer::Retransmit { expires_at, delay } if timestamp >= expires_at => {
+ *self = Timer::Retransmit {
+ expires_at: timestamp + delay,
+ delay: delay * 2,
+ }
+ }
+ Timer::Retransmit { .. } => (),
+ Timer::Close { .. } => (),
+ }
+ }
+
+ fn set_for_fast_retransmit(&mut self) {
+ *self = Timer::FastRetransmit
+ }
+
+ fn set_for_close(&mut self, timestamp: Instant) {
+ *self = Timer::Close {
+ expires_at: timestamp + CLOSE_DELAY,
+ }
+ }
+
+ fn is_retransmit(&self) -> bool {
+ match *self {
+ Timer::Retransmit { .. } | Timer::FastRetransmit => true,
+ _ => false,
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum AckDelayTimer {
+ Idle,
+ Waiting(Instant),
+ Immediate,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+struct Tuple {
+ local: IpEndpoint,
+ remote: IpEndpoint,
+}
+
+impl Display for Tuple {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}:{}", self.local, self.remote)
+ }
+}
+
+/// A Transmission Control Protocol socket.
+///
+/// A TCP socket may passively listen for connections or actively connect to another endpoint.
+/// Note that, for listening sockets, there is no "backlog"; to be able to simultaneously
+/// accept several connections, as many sockets must be allocated, or any new connection
+/// attempts will be reset.
+#[derive(Debug)]
+pub struct Socket<'a> {
+ state: State,
+ timer: Timer,
+ rtte: RttEstimator,
+ assembler: Assembler,
+ rx_buffer: SocketBuffer<'a>,
+ rx_fin_received: bool,
+ tx_buffer: SocketBuffer<'a>,
+ /// Interval after which, if no inbound packets are received, the connection is aborted.
+ timeout: Option<Duration>,
+ /// Interval at which keep-alive packets will be sent.
+ keep_alive: Option<Duration>,
+ /// The time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ hop_limit: Option<u8>,
+ /// Address passed to listen(). Listen address is set when listen() is called and
+ /// used every time the socket is reset back to the LISTEN state.
+ listen_endpoint: IpListenEndpoint,
+ /// Current 4-tuple (local and remote endpoints).
+ tuple: Option<Tuple>,
+ /// The sequence number corresponding to the beginning of the transmit buffer.
+ /// I.e. an ACK(local_seq_no+n) packet removes n bytes from the transmit buffer.
+ local_seq_no: TcpSeqNumber,
+ /// The sequence number corresponding to the beginning of the receive buffer.
+ /// I.e. userspace reading n bytes adds n to remote_seq_no.
+ remote_seq_no: TcpSeqNumber,
+ /// The last sequence number sent.
+ /// I.e. in an idle socket, local_seq_no+tx_buffer.len().
+ remote_last_seq: TcpSeqNumber,
+ /// The last acknowledgement number sent.
+ /// I.e. in an idle socket, remote_seq_no+rx_buffer.len().
+ remote_last_ack: Option<TcpSeqNumber>,
+ /// The last window length sent.
+ remote_last_win: u16,
+ /// The sending window scaling factor advertised to remotes which support RFC 1323.
+ /// It is zero if the window <= 64KiB and/or the remote does not support it.
+ remote_win_shift: u8,
+ /// The remote window size, relative to local_seq_no
+ /// I.e. we're allowed to send octets until local_seq_no+remote_win_len
+ remote_win_len: usize,
+ /// The receive window scaling factor for remotes which support RFC 1323, None if unsupported.
+ remote_win_scale: Option<u8>,
+ /// Whether or not the remote supports selective ACK as described in RFC 2018.
+ remote_has_sack: bool,
+ /// The maximum number of data octets that the remote side may receive.
+ remote_mss: usize,
+ /// The timestamp of the last packet received.
+ remote_last_ts: Option<Instant>,
+ /// The sequence number of the last packet received, used for sACK
+ local_rx_last_seq: Option<TcpSeqNumber>,
+ /// The ACK number of the last packet received.
+ local_rx_last_ack: Option<TcpSeqNumber>,
+ /// The number of packets received directly after
+ /// each other which have the same ACK number.
+ local_rx_dup_acks: u8,
+
+ /// Duration for Delayed ACK. If None no ACKs will be delayed.
+ ack_delay: Option<Duration>,
+ /// Delayed ack timer. If set, packets containing exclusively
+ /// ACK or window updates (ie, no data) won't be sent until expiry.
+ ack_delay_timer: AckDelayTimer,
+
+ /// Used for rate-limiting: No more challenge ACKs will be sent until this instant.
+ challenge_ack_timer: Instant,
+
+ /// Nagle's Algorithm enabled.
+ nagle: bool,
+
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration,
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration,
+}
+
+const DEFAULT_MSS: usize = 536;
+
+impl<'a> Socket<'a> {
+ #[allow(unused_comparisons)] // small usize platforms always pass rx_capacity check
+ /// Create a socket using the given buffers.
+ pub fn new<T>(rx_buffer: T, tx_buffer: T) -> Socket<'a>
+ where
+ T: Into<SocketBuffer<'a>>,
+ {
+ let (rx_buffer, tx_buffer) = (rx_buffer.into(), tx_buffer.into());
+ let rx_capacity = rx_buffer.capacity();
+
+ // From RFC 1323:
+ // [...] the above constraints imply that 2 * the max window size must be less
+ // than 2**31 [...] Thus, the shift count must be limited to 14 (which allows
+ // windows of 2**30 = 1 Gbyte).
+ if rx_capacity > (1 << 30) {
+ panic!("receiving buffer too large, cannot exceed 1 GiB")
+ }
+ let rx_cap_log2 = mem::size_of::<usize>() * 8 - rx_capacity.leading_zeros() as usize;
+
+ Socket {
+ state: State::Closed,
+ timer: Timer::new(),
+ rtte: RttEstimator::default(),
+ assembler: Assembler::new(),
+ tx_buffer,
+ rx_buffer,
+ rx_fin_received: false,
+ timeout: None,
+ keep_alive: None,
+ hop_limit: None,
+ listen_endpoint: IpListenEndpoint::default(),
+ tuple: None,
+ local_seq_no: TcpSeqNumber::default(),
+ remote_seq_no: TcpSeqNumber::default(),
+ remote_last_seq: TcpSeqNumber::default(),
+ remote_last_ack: None,
+ remote_last_win: 0,
+ remote_win_len: 0,
+ remote_win_shift: rx_cap_log2.saturating_sub(16) as u8,
+ remote_win_scale: None,
+ remote_has_sack: false,
+ remote_mss: DEFAULT_MSS,
+ remote_last_ts: None,
+ local_rx_last_ack: None,
+ local_rx_last_seq: None,
+ local_rx_dup_acks: 0,
+ ack_delay: Some(ACK_DELAY_DEFAULT),
+ ack_delay_timer: AckDelayTimer::Idle,
+ challenge_ack_timer: Instant::from_secs(0),
+ nagle: true,
+
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration::new(),
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration::new(),
+ }
+ }
+
+ /// Register a waker for receive operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `recv` method calls, such as receiving data, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `recv` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_recv_waker(&mut self, waker: &Waker) {
+ self.rx_waker.register(waker)
+ }
+
+ /// Register a waker for send operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `send` method calls, such as space becoming available in the transmit
+ /// buffer, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `send` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_send_waker(&mut self, waker: &Waker) {
+ self.tx_waker.register(waker)
+ }
+
+ /// Return the timeout duration.
+ ///
+ /// See also the [set_timeout](#method.set_timeout) method.
+ pub fn timeout(&self) -> Option<Duration> {
+ self.timeout
+ }
+
+ /// Return the ACK delay duration.
+ ///
+ /// See also the [set_ack_delay](#method.set_ack_delay) method.
+ pub fn ack_delay(&self) -> Option<Duration> {
+ self.ack_delay
+ }
+
+ /// Return whether Nagle's Algorithm is enabled.
+ ///
+ /// See also the [set_nagle_enabled](#method.set_nagle_enabled) method.
+ pub fn nagle_enabled(&self) -> bool {
+ self.nagle
+ }
+
+ /// Return the current window field value, including scaling according to RFC 1323.
+ ///
+ /// Used in internal calculations as well as packet generation.
+ ///
+ #[inline]
+ fn scaled_window(&self) -> u16 {
+ cmp::min(
+ self.rx_buffer.window() >> self.remote_win_shift as usize,
+ (1 << 16) - 1,
+ ) as u16
+ }
+
+ /// Set the timeout duration.
+ ///
+ /// A socket with a timeout duration set will abort the connection if either of the following
+ /// occurs:
+ ///
+ /// * After a [connect](#method.connect) call, the remote endpoint does not respond within
+ /// the specified duration;
+ /// * After establishing a connection, there is data in the transmit buffer and the remote
+ /// endpoint exceeds the specified duration between any two packets it sends;
+ /// * After enabling [keep-alive](#method.set_keep_alive), the remote endpoint exceeds
+ /// the specified duration between any two packets it sends.
+ pub fn set_timeout(&mut self, duration: Option<Duration>) {
+ self.timeout = duration
+ }
+
+ /// Set the ACK delay duration.
+ ///
+ /// By default, the ACK delay is set to 10ms.
+ pub fn set_ack_delay(&mut self, duration: Option<Duration>) {
+ self.ack_delay = duration
+ }
+
+ /// Enable or disable Nagle's Algorithm.
+ ///
+ /// Also known as "tinygram prevention". By default, it is enabled.
+ /// Disabling it is equivalent to Linux's TCP_NODELAY flag.
+ ///
+ /// When enabled, Nagle's Algorithm prevents sending segments smaller than MSS if
+ /// there is data in flight (sent but not acknowledged). In other words, it ensures
+ /// at most only one segment smaller than MSS is in flight at a time.
+ ///
+ /// It ensures better network utilization by preventing sending many very small packets,
+ /// at the cost of increased latency in some situations, particularly when the remote peer
+ /// has ACK delay enabled.
+ pub fn set_nagle_enabled(&mut self, enabled: bool) {
+ self.nagle = enabled
+ }
+
+ /// Return the keep-alive interval.
+ ///
+ /// See also the [set_keep_alive](#method.set_keep_alive) method.
+ pub fn keep_alive(&self) -> Option<Duration> {
+ self.keep_alive
+ }
+
+ /// Set the keep-alive interval.
+ ///
+ /// An idle socket with a keep-alive interval set will transmit a "keep-alive ACK" packet
+ /// every time it receives no communication during that interval. As a result, three things
+ /// may happen:
+ ///
+ /// * The remote endpoint is fine and answers with an ACK packet.
+ /// * The remote endpoint has rebooted and answers with an RST packet.
+ /// * The remote endpoint has crashed and does not answer.
+ ///
+ /// The keep-alive functionality together with the timeout functionality allows to react
+ /// to these error conditions.
+ pub fn set_keep_alive(&mut self, interval: Option<Duration>) {
+ self.keep_alive = interval;
+ if self.keep_alive.is_some() {
+ // If the connection is idle and we've just set the option, it would not take effect
+ // until the next packet, unless we wind up the timer explicitly.
+ self.timer.set_keep_alive();
+ }
+ }
+
+ /// Return the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// See also the [set_hop_limit](#method.set_hop_limit) method
+ pub fn hop_limit(&self) -> Option<u8> {
+ self.hop_limit
+ }
+
+ /// Set the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// A socket without an explicitly set hop limit value uses the default [IANA recommended]
+ /// value (64).
+ ///
+ /// # Panics
+ ///
+ /// This function panics if a hop limit value of 0 is given. See [RFC 1122 § 3.2.1.7].
+ ///
+ /// [IANA recommended]: https://www.iana.org/assignments/ip-parameters/ip-parameters.xhtml
+ /// [RFC 1122 § 3.2.1.7]: https://tools.ietf.org/html/rfc1122#section-3.2.1.7
+ pub fn set_hop_limit(&mut self, hop_limit: Option<u8>) {
+ // A host MUST NOT send a datagram with a hop limit value of 0
+ if let Some(0) = hop_limit {
+ panic!("the time-to-live value of a packet must not be zero")
+ }
+
+ self.hop_limit = hop_limit
+ }
+
+ /// Return the local endpoint, or None if not connected.
+ #[inline]
+ pub fn local_endpoint(&self) -> Option<IpEndpoint> {
+ Some(self.tuple?.local)
+ }
+
+ /// Return the remote endpoint, or None if not connected.
+ #[inline]
+ pub fn remote_endpoint(&self) -> Option<IpEndpoint> {
+ Some(self.tuple?.remote)
+ }
+
+ /// Return the connection state, in terms of the TCP state machine.
+ #[inline]
+ pub fn state(&self) -> State {
+ self.state
+ }
+
+ fn reset(&mut self) {
+ let rx_cap_log2 =
+ mem::size_of::<usize>() * 8 - self.rx_buffer.capacity().leading_zeros() as usize;
+
+ self.state = State::Closed;
+ self.timer = Timer::new();
+ self.rtte = RttEstimator::default();
+ self.assembler = Assembler::new();
+ self.tx_buffer.clear();
+ self.rx_buffer.clear();
+ self.rx_fin_received = false;
+ self.listen_endpoint = IpListenEndpoint::default();
+ self.tuple = None;
+ self.local_seq_no = TcpSeqNumber::default();
+ self.remote_seq_no = TcpSeqNumber::default();
+ self.remote_last_seq = TcpSeqNumber::default();
+ self.remote_last_ack = None;
+ self.remote_last_win = 0;
+ self.remote_win_len = 0;
+ self.remote_win_scale = None;
+ self.remote_win_shift = rx_cap_log2.saturating_sub(16) as u8;
+ self.remote_mss = DEFAULT_MSS;
+ self.remote_last_ts = None;
+ self.ack_delay_timer = AckDelayTimer::Idle;
+ self.challenge_ack_timer = Instant::from_secs(0);
+
+ #[cfg(feature = "async")]
+ {
+ self.rx_waker.wake();
+ self.tx_waker.wake();
+ }
+ }
+
+ /// Start listening on the given endpoint.
+ ///
+ /// This function returns `Err(Error::InvalidState)` if the socket was already open
+ /// (see [is_open](#method.is_open)), and `Err(Error::Unaddressable)`
+ /// if the port in the given endpoint is zero.
+ pub fn listen<T>(&mut self, local_endpoint: T) -> Result<(), ListenError>
+ where
+ T: Into<IpListenEndpoint>,
+ {
+ let local_endpoint = local_endpoint.into();
+ if local_endpoint.port == 0 {
+ return Err(ListenError::Unaddressable);
+ }
+
+ if self.is_open() {
+ // If we were already listening to same endpoint there is nothing to do; exit early.
+ //
+ // In the past listening on an socket that was already listening was an error,
+ // however this makes writing an acceptor loop with multiple sockets impossible.
+ // Without this early exit, if you tried to listen on a socket that's already listening you'll
+ // immediately get an error. The only way around this is to abort the socket first
+ // before listening again, but this means that incoming connections can actually
+ // get aborted between the abort() and the next listen().
+ if matches!(self.state, State::Listen) && self.listen_endpoint == local_endpoint {
+ return Ok(());
+ } else {
+ return Err(ListenError::InvalidState);
+ }
+ }
+
+ self.reset();
+ self.listen_endpoint = local_endpoint;
+ self.tuple = None;
+ self.set_state(State::Listen);
+ Ok(())
+ }
+
+ /// Connect to a given endpoint.
+ ///
+ /// The local port must be provided explicitly. Assuming `fn get_ephemeral_port() -> u16`
+ /// allocates a port between 49152 and 65535, a connection may be established as follows:
+ ///
+ /// ```no_run
+ /// # #[cfg(all(
+ /// # feature = "medium-ethernet",
+ /// # feature = "proto-ipv4",
+ /// # ))]
+ /// # {
+ /// # use smoltcp::socket::tcp::{Socket, SocketBuffer};
+ /// # use smoltcp::iface::Interface;
+ /// # use smoltcp::wire::IpAddress;
+ /// #
+ /// # fn get_ephemeral_port() -> u16 {
+ /// # 49152
+ /// # }
+ /// #
+ /// # let mut socket = Socket::new(
+ /// # SocketBuffer::new(vec![0; 1200]),
+ /// # SocketBuffer::new(vec![0; 1200])
+ /// # );
+ /// #
+ /// # let mut iface: Interface = todo!();
+ /// #
+ /// socket.connect(
+ /// iface.context(),
+ /// (IpAddress::v4(10, 0, 0, 1), 80),
+ /// get_ephemeral_port()
+ /// ).unwrap();
+ /// # }
+ /// ```
+ ///
+ /// The local address may optionally be provided.
+ ///
+ /// This function returns an error if the socket was open; see [is_open](#method.is_open).
+ /// It also returns an error if the local or remote port is zero, or if the remote address
+ /// is unspecified.
+ pub fn connect<T, U>(
+ &mut self,
+ cx: &mut Context,
+ remote_endpoint: T,
+ local_endpoint: U,
+ ) -> Result<(), ConnectError>
+ where
+ T: Into<IpEndpoint>,
+ U: Into<IpListenEndpoint>,
+ {
+ let remote_endpoint: IpEndpoint = remote_endpoint.into();
+ let local_endpoint: IpListenEndpoint = local_endpoint.into();
+
+ if self.is_open() {
+ return Err(ConnectError::InvalidState);
+ }
+ if remote_endpoint.port == 0 || remote_endpoint.addr.is_unspecified() {
+ return Err(ConnectError::Unaddressable);
+ }
+ if local_endpoint.port == 0 {
+ return Err(ConnectError::Unaddressable);
+ }
+
+ // If local address is not provided, choose it automatically.
+ let local_endpoint = IpEndpoint {
+ addr: match local_endpoint.addr {
+ Some(addr) => {
+ if addr.is_unspecified() {
+ return Err(ConnectError::Unaddressable);
+ }
+ addr
+ }
+ None => cx
+ .get_source_address(&remote_endpoint.addr)
+ .ok_or(ConnectError::Unaddressable)?,
+ },
+ port: local_endpoint.port,
+ };
+
+ if local_endpoint.addr.version() != remote_endpoint.addr.version() {
+ return Err(ConnectError::Unaddressable);
+ }
+
+ self.reset();
+ self.tuple = Some(Tuple {
+ local: local_endpoint,
+ remote: remote_endpoint,
+ });
+ self.set_state(State::SynSent);
+
+ let seq = Self::random_seq_no(cx);
+ self.local_seq_no = seq;
+ self.remote_last_seq = seq;
+ Ok(())
+ }
+
+ #[cfg(test)]
+ fn random_seq_no(_cx: &mut Context) -> TcpSeqNumber {
+ TcpSeqNumber(10000)
+ }
+
+ #[cfg(not(test))]
+ fn random_seq_no(cx: &mut Context) -> TcpSeqNumber {
+ TcpSeqNumber(cx.rand().rand_u32() as i32)
+ }
+
+ /// Close the transmit half of the full-duplex connection.
+ ///
+ /// Note that there is no corresponding function for the receive half of the full-duplex
+ /// connection; only the remote end can close it. If you no longer wish to receive any
+ /// data and would like to reuse the socket right away, use [abort](#method.abort).
+ pub fn close(&mut self) {
+ match self.state {
+ // In the LISTEN state there is no established connection.
+ State::Listen => self.set_state(State::Closed),
+ // In the SYN-SENT state the remote endpoint is not yet synchronized and, upon
+ // receiving an RST, will abort the connection.
+ State::SynSent => self.set_state(State::Closed),
+ // In the SYN-RECEIVED, ESTABLISHED and CLOSE-WAIT states the transmit half
+ // of the connection is open, and needs to be explicitly closed with a FIN.
+ State::SynReceived | State::Established => self.set_state(State::FinWait1),
+ State::CloseWait => self.set_state(State::LastAck),
+ // In the FIN-WAIT-1, FIN-WAIT-2, CLOSING, LAST-ACK, TIME-WAIT and CLOSED states,
+ // the transmit half of the connection is already closed, and no further
+ // action is needed.
+ State::FinWait1
+ | State::FinWait2
+ | State::Closing
+ | State::TimeWait
+ | State::LastAck
+ | State::Closed => (),
+ }
+ }
+
+ /// Aborts the connection, if any.
+ ///
+ /// This function instantly closes the socket. One reset packet will be sent to the remote
+ /// endpoint.
+ ///
+ /// In terms of the TCP state machine, the socket may be in any state and is moved to
+ /// the `CLOSED` state.
+ pub fn abort(&mut self) {
+ self.set_state(State::Closed);
+ }
+
+ /// Return whether the socket is passively listening for incoming connections.
+ ///
+ /// In terms of the TCP state machine, the socket must be in the `LISTEN` state.
+ #[inline]
+ pub fn is_listening(&self) -> bool {
+ match self.state {
+ State::Listen => true,
+ _ => false,
+ }
+ }
+
+ /// Return whether the socket is open.
+ ///
+ /// This function returns true if the socket will process incoming or dispatch outgoing
+ /// packets. Note that this does not mean that it is possible to send or receive data through
+ /// the socket; for that, use [can_send](#method.can_send) or [can_recv](#method.can_recv).
+ ///
+ /// In terms of the TCP state machine, the socket must not be in the `CLOSED`
+ /// or `TIME-WAIT` states.
+ #[inline]
+ pub fn is_open(&self) -> bool {
+ match self.state {
+ State::Closed => false,
+ State::TimeWait => false,
+ _ => true,
+ }
+ }
+
+ /// Return whether a connection is active.
+ ///
+ /// This function returns true if the socket is actively exchanging packets with
+ /// a remote endpoint. Note that this does not mean that it is possible to send or receive
+ /// data through the socket; for that, use [can_send](#method.can_send) or
+ /// [can_recv](#method.can_recv).
+ ///
+ /// If a connection is established, [abort](#method.close) will send a reset to
+ /// the remote endpoint.
+ ///
+ /// In terms of the TCP state machine, the socket must not be in the `CLOSED`, `TIME-WAIT`,
+ /// or `LISTEN` state.
+ #[inline]
+ pub fn is_active(&self) -> bool {
+ match self.state {
+ State::Closed => false,
+ State::TimeWait => false,
+ State::Listen => false,
+ _ => true,
+ }
+ }
+
+ /// Return whether the transmit half of the full-duplex connection is open.
+ ///
+ /// This function returns true if it's possible to send data and have it arrive
+ /// to the remote endpoint. However, it does not make any guarantees about the state
+ /// of the transmit buffer, and even if it returns true, [send](#method.send) may
+ /// not be able to enqueue any octets.
+ ///
+ /// In terms of the TCP state machine, the socket must be in the `ESTABLISHED` or
+ /// `CLOSE-WAIT` state.
+ #[inline]
+ pub fn may_send(&self) -> bool {
+ match self.state {
+ State::Established => true,
+ // In CLOSE-WAIT, the remote endpoint has closed our receive half of the connection
+ // but we still can transmit indefinitely.
+ State::CloseWait => true,
+ _ => false,
+ }
+ }
+
+ /// Return whether the receive half of the full-duplex connection is open.
+ ///
+ /// This function returns true if it's possible to receive data from the remote endpoint.
+ /// It will return true while there is data in the receive buffer, and if there isn't,
+ /// as long as the remote endpoint has not closed the connection.
+ ///
+ /// In terms of the TCP state machine, the socket must be in the `ESTABLISHED`,
+ /// `FIN-WAIT-1`, or `FIN-WAIT-2` state, or have data in the receive buffer instead.
+ #[inline]
+ pub fn may_recv(&self) -> bool {
+ match self.state {
+ State::Established => true,
+ // In FIN-WAIT-1/2, we have closed our transmit half of the connection but
+ // we still can receive indefinitely.
+ State::FinWait1 | State::FinWait2 => true,
+ // If we have something in the receive buffer, we can receive that.
+ _ if !self.rx_buffer.is_empty() => true,
+ _ => false,
+ }
+ }
+
+ /// Check whether the transmit half of the full-duplex connection is open
+ /// (see [may_send](#method.may_send)), and the transmit buffer is not full.
+ #[inline]
+ pub fn can_send(&self) -> bool {
+ if !self.may_send() {
+ return false;
+ }
+
+ !self.tx_buffer.is_full()
+ }
+
+ /// Return the maximum number of bytes inside the recv buffer.
+ #[inline]
+ pub fn recv_capacity(&self) -> usize {
+ self.rx_buffer.capacity()
+ }
+
+ /// Return the maximum number of bytes inside the transmit buffer.
+ #[inline]
+ pub fn send_capacity(&self) -> usize {
+ self.tx_buffer.capacity()
+ }
+
+ /// Check whether the receive half of the full-duplex connection buffer is open
+ /// (see [may_recv](#method.may_recv)), and the receive buffer is not empty.
+ #[inline]
+ pub fn can_recv(&self) -> bool {
+ if !self.may_recv() {
+ return false;
+ }
+
+ !self.rx_buffer.is_empty()
+ }
+
+ fn send_impl<'b, F, R>(&'b mut self, f: F) -> Result<R, SendError>
+ where
+ F: FnOnce(&'b mut SocketBuffer<'a>) -> (usize, R),
+ {
+ if !self.may_send() {
+ return Err(SendError::InvalidState);
+ }
+
+ // The connection might have been idle for a long time, and so remote_last_ts
+ // would be far in the past. Unless we clear it here, we'll abort the connection
+ // down over in dispatch() by erroneously detecting it as timed out.
+ if self.tx_buffer.is_empty() {
+ self.remote_last_ts = None
+ }
+
+ let _old_length = self.tx_buffer.len();
+ let (size, result) = f(&mut self.tx_buffer);
+ if size > 0 {
+ #[cfg(any(test, feature = "verbose"))]
+ tcp_trace!(
+ "tx buffer: enqueueing {} octets (now {})",
+ size,
+ _old_length + size
+ );
+ }
+ Ok(result)
+ }
+
+ /// Call `f` with the largest contiguous slice of octets in the transmit buffer,
+ /// and enqueue the amount of elements returned by `f`.
+ ///
+ /// This function returns `Err(Error::Illegal)` if the transmit half of
+ /// the connection is not open; see [may_send](#method.may_send).
+ pub fn send<'b, F, R>(&'b mut self, f: F) -> Result<R, SendError>
+ where
+ F: FnOnce(&'b mut [u8]) -> (usize, R),
+ {
+ self.send_impl(|tx_buffer| tx_buffer.enqueue_many_with(f))
+ }
+
+ /// Enqueue a sequence of octets to be sent, and fill it from a slice.
+ ///
+ /// This function returns the amount of octets actually enqueued, which is limited
+ /// by the amount of free space in the transmit buffer; down to zero.
+ ///
+ /// See also [send](#method.send).
+ pub fn send_slice(&mut self, data: &[u8]) -> Result<usize, SendError> {
+ self.send_impl(|tx_buffer| {
+ let size = tx_buffer.enqueue_slice(data);
+ (size, size)
+ })
+ }
+
+ fn recv_error_check(&mut self) -> Result<(), RecvError> {
+ // We may have received some data inside the initial SYN, but until the connection
+ // is fully open we must not dequeue any data, as it may be overwritten by e.g.
+ // another (stale) SYN. (We do not support TCP Fast Open.)
+ if !self.may_recv() {
+ if self.rx_fin_received {
+ return Err(RecvError::Finished);
+ }
+ return Err(RecvError::InvalidState);
+ }
+
+ Ok(())
+ }
+
+ fn recv_impl<'b, F, R>(&'b mut self, f: F) -> Result<R, RecvError>
+ where
+ F: FnOnce(&'b mut SocketBuffer<'a>) -> (usize, R),
+ {
+ self.recv_error_check()?;
+
+ let _old_length = self.rx_buffer.len();
+ let (size, result) = f(&mut self.rx_buffer);
+ self.remote_seq_no += size;
+ if size > 0 {
+ #[cfg(any(test, feature = "verbose"))]
+ tcp_trace!(
+ "rx buffer: dequeueing {} octets (now {})",
+ size,
+ _old_length - size
+ );
+ }
+ Ok(result)
+ }
+
+ /// Call `f` with the largest contiguous slice of octets in the receive buffer,
+ /// and dequeue the amount of elements returned by `f`.
+ ///
+ /// This function errors if the receive half of the connection is not open.
+ ///
+ /// If the receive half has been gracefully closed (with a FIN packet), `Err(Error::Finished)`
+ /// is returned. In this case, the previously received data is guaranteed to be complete.
+ ///
+ /// In all other cases, `Err(Error::Illegal)` is returned and previously received data (if any)
+ /// may be incomplete (truncated).
+ pub fn recv<'b, F, R>(&'b mut self, f: F) -> Result<R, RecvError>
+ where
+ F: FnOnce(&'b mut [u8]) -> (usize, R),
+ {
+ self.recv_impl(|rx_buffer| rx_buffer.dequeue_many_with(f))
+ }
+
+ /// Dequeue a sequence of received octets, and fill a slice from it.
+ ///
+ /// This function returns the amount of octets actually dequeued, which is limited
+ /// by the amount of occupied space in the receive buffer; down to zero.
+ ///
+ /// See also [recv](#method.recv).
+ pub fn recv_slice(&mut self, data: &mut [u8]) -> Result<usize, RecvError> {
+ self.recv_impl(|rx_buffer| {
+ let size = rx_buffer.dequeue_slice(data);
+ (size, size)
+ })
+ }
+
+ /// Peek at a sequence of received octets without removing them from
+ /// the receive buffer, and return a pointer to it.
+ ///
+ /// This function otherwise behaves identically to [recv](#method.recv).
+ pub fn peek(&mut self, size: usize) -> Result<&[u8], RecvError> {
+ self.recv_error_check()?;
+
+ let buffer = self.rx_buffer.get_allocated(0, size);
+ if !buffer.is_empty() {
+ #[cfg(any(test, feature = "verbose"))]
+ tcp_trace!("rx buffer: peeking at {} octets", buffer.len());
+ }
+ Ok(buffer)
+ }
+
+ /// Peek at a sequence of received octets without removing them from
+ /// the receive buffer, and fill a slice from it.
+ ///
+ /// This function otherwise behaves identically to [recv_slice](#method.recv_slice).
+ pub fn peek_slice(&mut self, data: &mut [u8]) -> Result<usize, RecvError> {
+ Ok(self.rx_buffer.read_allocated(0, data))
+ }
+
+ /// Return the amount of octets queued in the transmit buffer.
+ ///
+ /// Note that the Berkeley sockets interface does not have an equivalent of this API.
+ pub fn send_queue(&self) -> usize {
+ self.tx_buffer.len()
+ }
+
+ /// Return the amount of octets queued in the receive buffer. This value can be larger than
+ /// the slice read by the next `recv` or `peek` call because it includes all queued octets,
+ /// and not only the octets that may be returned as a contiguous slice.
+ ///
+ /// Note that the Berkeley sockets interface does not have an equivalent of this API.
+ pub fn recv_queue(&self) -> usize {
+ self.rx_buffer.len()
+ }
+
+ fn set_state(&mut self, state: State) {
+ if self.state != state {
+ tcp_trace!("state={}=>{}", self.state, state);
+ }
+
+ self.state = state;
+
+ #[cfg(feature = "async")]
+ {
+ // Wake all tasks waiting. Even if we haven't received/sent data, this
+ // is needed because return values of functions may change depending on the state.
+ // For example, a pending read has to fail with an error if the socket is closed.
+ self.rx_waker.wake();
+ self.tx_waker.wake();
+ }
+ }
+
+ pub(crate) fn reply(ip_repr: &IpRepr, repr: &TcpRepr) -> (IpRepr, TcpRepr<'static>) {
+ let reply_repr = TcpRepr {
+ src_port: repr.dst_port,
+ dst_port: repr.src_port,
+ control: TcpControl::None,
+ seq_number: TcpSeqNumber(0),
+ ack_number: None,
+ window_len: 0,
+ window_scale: None,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &[],
+ };
+ let ip_reply_repr = IpRepr::new(
+ ip_repr.dst_addr(),
+ ip_repr.src_addr(),
+ IpProtocol::Tcp,
+ reply_repr.buffer_len(),
+ 64,
+ );
+ (ip_reply_repr, reply_repr)
+ }
+
+ pub(crate) fn rst_reply(ip_repr: &IpRepr, repr: &TcpRepr) -> (IpRepr, TcpRepr<'static>) {
+ debug_assert!(repr.control != TcpControl::Rst);
+
+ let (ip_reply_repr, mut reply_repr) = Self::reply(ip_repr, repr);
+
+ // See https://www.snellman.net/blog/archive/2016-02-01-tcp-rst/ for explanation
+ // of why we sometimes send an RST and sometimes an RST|ACK
+ reply_repr.control = TcpControl::Rst;
+ reply_repr.seq_number = repr.ack_number.unwrap_or_default();
+ if repr.control == TcpControl::Syn && repr.ack_number.is_none() {
+ reply_repr.ack_number = Some(repr.seq_number + repr.segment_len());
+ }
+
+ (ip_reply_repr, reply_repr)
+ }
+
+ fn ack_reply(&mut self, ip_repr: &IpRepr, repr: &TcpRepr) -> (IpRepr, TcpRepr<'static>) {
+ let (mut ip_reply_repr, mut reply_repr) = Self::reply(ip_repr, repr);
+
+ // From RFC 793:
+ // [...] an empty acknowledgment segment containing the current send-sequence number
+ // and an acknowledgment indicating the next sequence number expected
+ // to be received.
+ reply_repr.seq_number = self.remote_last_seq;
+ reply_repr.ack_number = Some(self.remote_seq_no + self.rx_buffer.len());
+ self.remote_last_ack = reply_repr.ack_number;
+
+ // From RFC 1323:
+ // The window field [...] of every outgoing segment, with the exception of SYN
+ // segments, is right-shifted by [advertised scale value] bits[...]
+ reply_repr.window_len = self.scaled_window();
+ self.remote_last_win = reply_repr.window_len;
+
+ // If the remote supports selective acknowledgement, add the option to the outgoing
+ // segment.
+ if self.remote_has_sack {
+ net_debug!("sending sACK option with current assembler ranges");
+
+ // RFC 2018: The first SACK block (i.e., the one immediately following the kind and
+ // length fields in the option) MUST specify the contiguous block of data containing
+ // the segment which triggered this ACK, unless that segment advanced the
+ // Acknowledgment Number field in the header.
+ reply_repr.sack_ranges[0] = None;
+
+ if let Some(last_seg_seq) = self.local_rx_last_seq.map(|s| s.0 as u32) {
+ reply_repr.sack_ranges[0] = self
+ .assembler
+ .iter_data(reply_repr.ack_number.map(|s| s.0 as usize).unwrap_or(0))
+ .map(|(left, right)| (left as u32, right as u32))
+ .find(|(left, right)| *left <= last_seg_seq && *right >= last_seg_seq);
+ }
+
+ if reply_repr.sack_ranges[0].is_none() {
+ // The matching segment was removed from the assembler, meaning the acknowledgement
+ // number has advanced, or there was no previous sACK.
+ //
+ // While the RFC says we SHOULD keep a list of reported sACK ranges, and iterate
+ // through those, that is currently infeasible. Instead, we offer the range with
+ // the lowest sequence number (if one exists) to hint at what segments would
+ // most quickly advance the acknowledgement number.
+ reply_repr.sack_ranges[0] = self
+ .assembler
+ .iter_data(reply_repr.ack_number.map(|s| s.0 as usize).unwrap_or(0))
+ .map(|(left, right)| (left as u32, right as u32))
+ .next();
+ }
+ }
+
+ // Since the sACK option may have changed the length of the payload, update that.
+ ip_reply_repr.set_payload_len(reply_repr.buffer_len());
+ (ip_reply_repr, reply_repr)
+ }
+
+ fn challenge_ack_reply(
+ &mut self,
+ cx: &mut Context,
+ ip_repr: &IpRepr,
+ repr: &TcpRepr,
+ ) -> Option<(IpRepr, TcpRepr<'static>)> {
+ if cx.now() < self.challenge_ack_timer {
+ return None;
+ }
+
+ // Rate-limit to 1 per second max.
+ self.challenge_ack_timer = cx.now() + Duration::from_secs(1);
+
+ Some(self.ack_reply(ip_repr, repr))
+ }
+
+ pub(crate) fn accepts(&self, _cx: &mut Context, ip_repr: &IpRepr, repr: &TcpRepr) -> bool {
+ if self.state == State::Closed {
+ return false;
+ }
+
+ // If we're still listening for SYNs and the packet has an ACK, it cannot
+ // be destined to this socket, but another one may well listen on the same
+ // local endpoint.
+ if self.state == State::Listen && repr.ack_number.is_some() {
+ return false;
+ }
+
+ if let Some(tuple) = &self.tuple {
+ // Reject packets not matching the 4-tuple
+ ip_repr.dst_addr() == tuple.local.addr
+ && repr.dst_port == tuple.local.port
+ && ip_repr.src_addr() == tuple.remote.addr
+ && repr.src_port == tuple.remote.port
+ } else {
+ // We're listening, reject packets not matching the listen endpoint.
+ let addr_ok = match self.listen_endpoint.addr {
+ Some(addr) => ip_repr.dst_addr() == addr,
+ None => true,
+ };
+ addr_ok && repr.dst_port != 0 && repr.dst_port == self.listen_endpoint.port
+ }
+ }
+
+ pub(crate) fn process(
+ &mut self,
+ cx: &mut Context,
+ ip_repr: &IpRepr,
+ repr: &TcpRepr,
+ ) -> Option<(IpRepr, TcpRepr<'static>)> {
+ debug_assert!(self.accepts(cx, ip_repr, repr));
+
+ // Consider how much the sequence number space differs from the transmit buffer space.
+ let (sent_syn, sent_fin) = match self.state {
+ // In SYN-SENT or SYN-RECEIVED, we've just sent a SYN.
+ State::SynSent | State::SynReceived => (true, false),
+ // In FIN-WAIT-1, LAST-ACK, or CLOSING, we've just sent a FIN.
+ State::FinWait1 | State::LastAck | State::Closing => (false, true),
+ // In all other states we've already got acknowledgements for
+ // all of the control flags we sent.
+ _ => (false, false),
+ };
+ let control_len = (sent_syn as usize) + (sent_fin as usize);
+
+ // Reject unacceptable acknowledgements.
+ match (self.state, repr.control, repr.ack_number) {
+ // An RST received in response to initial SYN is acceptable if it acknowledges
+ // the initial SYN.
+ (State::SynSent, TcpControl::Rst, None) => {
+ net_debug!("unacceptable RST (expecting RST|ACK) in response to initial SYN");
+ return None;
+ }
+ (State::SynSent, TcpControl::Rst, Some(ack_number)) => {
+ if ack_number != self.local_seq_no + 1 {
+ net_debug!("unacceptable RST|ACK in response to initial SYN");
+ return None;
+ }
+ }
+ // Any other RST need only have a valid sequence number.
+ (_, TcpControl::Rst, _) => (),
+ // The initial SYN cannot contain an acknowledgement.
+ (State::Listen, _, None) => (),
+ // This case is handled in `accepts()`.
+ (State::Listen, _, Some(_)) => unreachable!(),
+ // Every packet after the initial SYN must be an acknowledgement.
+ (_, _, None) => {
+ net_debug!("expecting an ACK");
+ return None;
+ }
+ // SYN|ACK in the SYN-SENT state must have the exact ACK number.
+ (State::SynSent, TcpControl::Syn, Some(ack_number)) => {
+ if ack_number != self.local_seq_no + 1 {
+ net_debug!("unacceptable SYN|ACK in response to initial SYN");
+ return Some(Self::rst_reply(ip_repr, repr));
+ }
+ }
+ // ACKs in the SYN-SENT state are invalid.
+ (State::SynSent, TcpControl::None, Some(ack_number)) => {
+ // If the sequence number matches, ignore it instead of RSTing.
+ // I'm not sure why, I think it may be a workaround for broken TCP
+ // servers, or a defense against reordering. Either way, if Linux
+ // does it, we do too.
+ if ack_number == self.local_seq_no + 1 {
+ net_debug!(
+ "expecting a SYN|ACK, received an ACK with the right ack_number, ignoring."
+ );
+ return None;
+ }
+
+ net_debug!(
+ "expecting a SYN|ACK, received an ACK with the wrong ack_number, sending RST."
+ );
+ return Some(Self::rst_reply(ip_repr, repr));
+ }
+ // Anything else in the SYN-SENT state is invalid.
+ (State::SynSent, _, _) => {
+ net_debug!("expecting a SYN|ACK");
+ return None;
+ }
+ // ACK in the SYN-RECEIVED state must have the exact ACK number, or we RST it.
+ (State::SynReceived, _, Some(ack_number)) => {
+ if ack_number != self.local_seq_no + 1 {
+ net_debug!("unacceptable ACK in response to SYN|ACK");
+ return Some(Self::rst_reply(ip_repr, repr));
+ }
+ }
+ // Every acknowledgement must be for transmitted but unacknowledged data.
+ (_, _, Some(ack_number)) => {
+ let unacknowledged = self.tx_buffer.len() + control_len;
+
+ // Acceptable ACK range (both inclusive)
+ let mut ack_min = self.local_seq_no;
+ let ack_max = self.local_seq_no + unacknowledged;
+
+ // If we have sent a SYN, it MUST be acknowledged.
+ if sent_syn {
+ ack_min += 1;
+ }
+
+ if ack_number < ack_min {
+ net_debug!(
+ "duplicate ACK ({} not in {}...{})",
+ ack_number,
+ ack_min,
+ ack_max
+ );
+ return None;
+ }
+
+ if ack_number > ack_max {
+ net_debug!(
+ "unacceptable ACK ({} not in {}...{})",
+ ack_number,
+ ack_min,
+ ack_max
+ );
+ return self.challenge_ack_reply(cx, ip_repr, repr);
+ }
+ }
+ }
+
+ let window_start = self.remote_seq_no + self.rx_buffer.len();
+ let window_end = self.remote_seq_no + self.rx_buffer.capacity();
+ let segment_start = repr.seq_number;
+ let segment_end = repr.seq_number + repr.payload.len();
+
+ let (payload, payload_offset) = match self.state {
+ // In LISTEN and SYN-SENT states, we have not yet synchronized with the remote end.
+ State::Listen | State::SynSent => (&[][..], 0),
+ _ => {
+ // https://www.rfc-editor.org/rfc/rfc9293.html#name-segment-acceptability-tests
+ let segment_in_window = match (
+ segment_start == segment_end,
+ window_start == window_end,
+ ) {
+ (true, _) if segment_end == window_start - 1 => {
+ net_debug!(
+ "received a keep-alive or window probe packet, will send an ACK"
+ );
+ false
+ }
+ (true, true) => {
+ if window_start == segment_start {
+ true
+ } else {
+ net_debug!(
+ "zero-length segment not inside zero-length window, will send an ACK."
+ );
+ false
+ }
+ }
+ (true, false) => {
+ if window_start <= segment_start && segment_start < window_end {
+ true
+ } else {
+ net_debug!("zero-length segment not inside window, will send an ACK.");
+ false
+ }
+ }
+ (false, true) => {
+ net_debug!(
+ "non-zero-length segment with zero receive window, will only send an ACK"
+ );
+ false
+ }
+ (false, false) => {
+ if (window_start <= segment_start && segment_start < window_end)
+ || (window_start < segment_end && segment_end <= window_end)
+ {
+ true
+ } else {
+ net_debug!(
+ "segment not in receive window ({}..{} not intersecting {}..{}), will send challenge ACK",
+ segment_start,
+ segment_end,
+ window_start,
+ window_end
+ );
+ false
+ }
+ }
+ };
+
+ if segment_in_window {
+ let overlap_start = window_start.max(segment_start);
+ let overlap_end = window_end.min(segment_end);
+
+ // the checks done above imply this.
+ debug_assert!(overlap_start <= overlap_end);
+
+ self.local_rx_last_seq = Some(repr.seq_number);
+
+ (
+ &repr.payload[overlap_start - segment_start..overlap_end - segment_start],
+ overlap_start - window_start,
+ )
+ } else {
+ // If we're in the TIME-WAIT state, restart the TIME-WAIT timeout, since
+ // the remote end may not have realized we've closed the connection.
+ if self.state == State::TimeWait {
+ self.timer.set_for_close(cx.now());
+ }
+
+ return self.challenge_ack_reply(cx, ip_repr, repr);
+ }
+ }
+ };
+
+ // Compute the amount of acknowledged octets, removing the SYN and FIN bits
+ // from the sequence space.
+ let mut ack_len = 0;
+ let mut ack_of_fin = false;
+ let mut ack_all = false;
+ if repr.control != TcpControl::Rst {
+ if let Some(ack_number) = repr.ack_number {
+ // Sequence number corresponding to the first byte in `tx_buffer`.
+ // This normally equals `local_seq_no`, but is 1 higher if we have sent a SYN,
+ // as the SYN occupies 1 sequence number "before" the data.
+ let tx_buffer_start_seq = self.local_seq_no + (sent_syn as usize);
+
+ if ack_number >= tx_buffer_start_seq {
+ ack_len = ack_number - tx_buffer_start_seq;
+
+ // We could've sent data before the FIN, so only remove FIN from the sequence
+ // space if all of that data is acknowledged.
+ if sent_fin && self.tx_buffer.len() + 1 == ack_len {
+ ack_len -= 1;
+ tcp_trace!("received ACK of FIN");
+ ack_of_fin = true;
+ }
+
+ ack_all = self.remote_last_seq == ack_number
+ }
+
+ self.rtte.on_ack(cx.now(), ack_number);
+ }
+ }
+
+ // Disregard control flags we don't care about or shouldn't act on yet.
+ let mut control = repr.control;
+ control = control.quash_psh();
+
+ // If a FIN is received at the end of the current segment but the start of the segment
+ // is not at the start of the receive window, disregard this FIN.
+ if control == TcpControl::Fin && window_start != segment_start {
+ tcp_trace!("ignoring FIN because we don't have full data yet. window_start={} segment_start={}", window_start, segment_start);
+ control = TcpControl::None;
+ }
+
+ // Validate and update the state.
+ match (self.state, control) {
+ // RSTs are not accepted in the LISTEN state.
+ (State::Listen, TcpControl::Rst) => return None,
+
+ // RSTs in SYN-RECEIVED flip the socket back to the LISTEN state.
+ (State::SynReceived, TcpControl::Rst) => {
+ tcp_trace!("received RST");
+ self.tuple = None;
+ self.set_state(State::Listen);
+ return None;
+ }
+
+ // RSTs in any other state close the socket.
+ (_, TcpControl::Rst) => {
+ tcp_trace!("received RST");
+ self.set_state(State::Closed);
+ self.tuple = None;
+ return None;
+ }
+
+ // SYN packets in the LISTEN state change it to SYN-RECEIVED.
+ (State::Listen, TcpControl::Syn) => {
+ tcp_trace!("received SYN");
+ if let Some(max_seg_size) = repr.max_seg_size {
+ if max_seg_size == 0 {
+ tcp_trace!("received SYNACK with zero MSS, ignoring");
+ return None;
+ }
+ self.remote_mss = max_seg_size as usize
+ }
+
+ self.tuple = Some(Tuple {
+ local: IpEndpoint::new(ip_repr.dst_addr(), repr.dst_port),
+ remote: IpEndpoint::new(ip_repr.src_addr(), repr.src_port),
+ });
+ self.local_seq_no = Self::random_seq_no(cx);
+ self.remote_seq_no = repr.seq_number + 1;
+ self.remote_last_seq = self.local_seq_no;
+ self.remote_has_sack = repr.sack_permitted;
+ self.remote_win_scale = repr.window_scale;
+ // Remote doesn't support window scaling, don't do it.
+ if self.remote_win_scale.is_none() {
+ self.remote_win_shift = 0;
+ }
+ self.set_state(State::SynReceived);
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+
+ // ACK packets in the SYN-RECEIVED state change it to ESTABLISHED.
+ (State::SynReceived, TcpControl::None) => {
+ self.set_state(State::Established);
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+
+ // FIN packets in the SYN-RECEIVED state change it to CLOSE-WAIT.
+ // It's not obvious from RFC 793 that this is permitted, but
+ // 7th and 8th steps in the "SEGMENT ARRIVES" event describe this behavior.
+ (State::SynReceived, TcpControl::Fin) => {
+ self.remote_seq_no += 1;
+ self.rx_fin_received = true;
+ self.set_state(State::CloseWait);
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+
+ // SYN|ACK packets in the SYN-SENT state change it to ESTABLISHED.
+ (State::SynSent, TcpControl::Syn) => {
+ tcp_trace!("received SYN|ACK");
+ if let Some(max_seg_size) = repr.max_seg_size {
+ if max_seg_size == 0 {
+ tcp_trace!("received SYNACK with zero MSS, ignoring");
+ return None;
+ }
+ self.remote_mss = max_seg_size as usize;
+ }
+
+ self.remote_seq_no = repr.seq_number + 1;
+ self.remote_last_seq = self.local_seq_no + 1;
+ self.remote_last_ack = Some(repr.seq_number);
+ self.remote_win_scale = repr.window_scale;
+ // Remote doesn't support window scaling, don't do it.
+ if self.remote_win_scale.is_none() {
+ self.remote_win_shift = 0;
+ }
+
+ self.set_state(State::Established);
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+
+ // ACK packets in ESTABLISHED state reset the retransmit timer,
+ // except for duplicate ACK packets which preserve it.
+ (State::Established, TcpControl::None) => {
+ if !self.timer.is_retransmit() || ack_all {
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+ }
+
+ // FIN packets in ESTABLISHED state indicate the remote side has closed.
+ (State::Established, TcpControl::Fin) => {
+ self.remote_seq_no += 1;
+ self.rx_fin_received = true;
+ self.set_state(State::CloseWait);
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+
+ // ACK packets in FIN-WAIT-1 state change it to FIN-WAIT-2, if we've already
+ // sent everything in the transmit buffer. If not, they reset the retransmit timer.
+ (State::FinWait1, TcpControl::None) => {
+ if ack_of_fin {
+ self.set_state(State::FinWait2);
+ }
+ if ack_all {
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+ }
+
+ // FIN packets in FIN-WAIT-1 state change it to CLOSING, or to TIME-WAIT
+ // if they also acknowledge our FIN.
+ (State::FinWait1, TcpControl::Fin) => {
+ self.remote_seq_no += 1;
+ self.rx_fin_received = true;
+ if ack_of_fin {
+ self.set_state(State::TimeWait);
+ self.timer.set_for_close(cx.now());
+ } else {
+ self.set_state(State::Closing);
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+ }
+
+ // Data packets in FIN-WAIT-2 reset the idle timer.
+ (State::FinWait2, TcpControl::None) => {
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+
+ // FIN packets in FIN-WAIT-2 state change it to TIME-WAIT.
+ (State::FinWait2, TcpControl::Fin) => {
+ self.remote_seq_no += 1;
+ self.rx_fin_received = true;
+ self.set_state(State::TimeWait);
+ self.timer.set_for_close(cx.now());
+ }
+
+ // ACK packets in CLOSING state change it to TIME-WAIT.
+ (State::Closing, TcpControl::None) => {
+ if ack_of_fin {
+ self.set_state(State::TimeWait);
+ self.timer.set_for_close(cx.now());
+ } else {
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+ }
+
+ // ACK packets in CLOSE-WAIT state reset the retransmit timer.
+ (State::CloseWait, TcpControl::None) => {
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+
+ // ACK packets in LAST-ACK state change it to CLOSED.
+ (State::LastAck, TcpControl::None) => {
+ if ack_of_fin {
+ // Clear the remote endpoint, or we'll send an RST there.
+ self.set_state(State::Closed);
+ self.tuple = None;
+ } else {
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+ }
+ }
+
+ _ => {
+ net_debug!("unexpected packet {}", repr);
+ return None;
+ }
+ }
+
+ // Update remote state.
+ self.remote_last_ts = Some(cx.now());
+
+ // RFC 1323: The window field (SEG.WND) in the header of every incoming segment, with the
+ // exception of SYN segments, is left-shifted by Snd.Wind.Scale bits before updating SND.WND.
+ let scale = match repr.control {
+ TcpControl::Syn => 0,
+ _ => self.remote_win_scale.unwrap_or(0),
+ };
+ let new_remote_win_len = (repr.window_len as usize) << (scale as usize);
+ let is_window_update = new_remote_win_len != self.remote_win_len;
+ self.remote_win_len = new_remote_win_len;
+
+ if ack_len > 0 {
+ // Dequeue acknowledged octets.
+ debug_assert!(self.tx_buffer.len() >= ack_len);
+ tcp_trace!(
+ "tx buffer: dequeueing {} octets (now {})",
+ ack_len,
+ self.tx_buffer.len() - ack_len
+ );
+ self.tx_buffer.dequeue_allocated(ack_len);
+
+ // There's new room available in tx_buffer, wake the waiting task if any.
+ #[cfg(feature = "async")]
+ self.tx_waker.wake();
+ }
+
+ if let Some(ack_number) = repr.ack_number {
+ // TODO: When flow control is implemented,
+ // refractor the following block within that implementation
+
+ // Detect and react to duplicate ACKs by:
+ // 1. Check if duplicate ACK and change self.local_rx_dup_acks accordingly
+ // 2. If exactly 3 duplicate ACKs received, set for fast retransmit
+ // 3. Update the last received ACK (self.local_rx_last_ack)
+ match self.local_rx_last_ack {
+ // Duplicate ACK if payload empty and ACK doesn't move send window ->
+ // Increment duplicate ACK count and set for retransmit if we just received
+ // the third duplicate ACK
+ Some(last_rx_ack)
+ if repr.payload.is_empty()
+ && last_rx_ack == ack_number
+ && ack_number < self.remote_last_seq
+ && !is_window_update =>
+ {
+ // Increment duplicate ACK count
+ self.local_rx_dup_acks = self.local_rx_dup_acks.saturating_add(1);
+
+ net_debug!(
+ "received duplicate ACK for seq {} (duplicate nr {}{})",
+ ack_number,
+ self.local_rx_dup_acks,
+ if self.local_rx_dup_acks == u8::max_value() {
+ "+"
+ } else {
+ ""
+ }
+ );
+
+ if self.local_rx_dup_acks == 3 {
+ self.timer.set_for_fast_retransmit();
+ net_debug!("started fast retransmit");
+ }
+ }
+ // No duplicate ACK -> Reset state and update last received ACK
+ _ => {
+ if self.local_rx_dup_acks > 0 {
+ self.local_rx_dup_acks = 0;
+ net_debug!("reset duplicate ACK count");
+ }
+ self.local_rx_last_ack = Some(ack_number);
+ }
+ };
+ // We've processed everything in the incoming segment, so advance the local
+ // sequence number past it.
+ self.local_seq_no = ack_number;
+ // During retransmission, if an earlier segment got lost but later was
+ // successfully received, self.local_seq_no can move past self.remote_last_seq.
+ // Do not attempt to retransmit the latter segments; not only this is pointless
+ // in theory but also impossible in practice, since they have been already
+ // deallocated from the buffer.
+ if self.remote_last_seq < self.local_seq_no {
+ self.remote_last_seq = self.local_seq_no
+ }
+ }
+
+ let payload_len = payload.len();
+ if payload_len == 0 {
+ return None;
+ }
+
+ let assembler_was_empty = self.assembler.is_empty();
+
+ // Try adding payload octets to the assembler.
+ let Ok(contig_len) = self
+ .assembler
+ .add_then_remove_front(payload_offset, payload_len)
+ else {
+ net_debug!(
+ "assembler: too many holes to add {} octets at offset {}",
+ payload_len,
+ payload_offset
+ );
+ return None;
+ };
+
+ // Place payload octets into the buffer.
+ tcp_trace!(
+ "rx buffer: receiving {} octets at offset {}",
+ payload_len,
+ payload_offset
+ );
+ let len_written = self.rx_buffer.write_unallocated(payload_offset, payload);
+ debug_assert!(len_written == payload_len);
+
+ if contig_len != 0 {
+ // Enqueue the contiguous data octets in front of the buffer.
+ tcp_trace!(
+ "rx buffer: enqueueing {} octets (now {})",
+ contig_len,
+ self.rx_buffer.len() + contig_len
+ );
+ self.rx_buffer.enqueue_unallocated(contig_len);
+
+ // There's new data in rx_buffer, notify waiting task if any.
+ #[cfg(feature = "async")]
+ self.rx_waker.wake();
+ }
+
+ if !self.assembler.is_empty() {
+ // Print the ranges recorded in the assembler.
+ tcp_trace!("assembler: {}", self.assembler);
+ }
+
+ // Handle delayed acks
+ if let Some(ack_delay) = self.ack_delay {
+ if self.ack_to_transmit() || self.window_to_update() {
+ self.ack_delay_timer = match self.ack_delay_timer {
+ AckDelayTimer::Idle => {
+ tcp_trace!("starting delayed ack timer");
+
+ AckDelayTimer::Waiting(cx.now() + ack_delay)
+ }
+ // RFC1122 says "in a stream of full-sized segments there SHOULD be an ACK
+ // for at least every second segment".
+ // For now, we send an ACK every second received packet, full-sized or not.
+ AckDelayTimer::Waiting(_) => {
+ tcp_trace!("delayed ack timer already started, forcing expiry");
+ AckDelayTimer::Immediate
+ }
+ AckDelayTimer::Immediate => {
+ tcp_trace!("delayed ack timer already force-expired");
+ AckDelayTimer::Immediate
+ }
+ };
+ }
+ }
+
+ // Per RFC 5681, we should send an immediate ACK when either:
+ // 1) an out-of-order segment is received, or
+ // 2) a segment arrives that fills in all or part of a gap in sequence space.
+ if !self.assembler.is_empty() || !assembler_was_empty {
+ // Note that we change the transmitter state here.
+ // This is fine because smoltcp assumes that it can always transmit zero or one
+ // packets for every packet it receives.
+ tcp_trace!("ACKing incoming segment");
+ Some(self.ack_reply(ip_repr, repr))
+ } else {
+ None
+ }
+ }
+
+ fn timed_out(&self, timestamp: Instant) -> bool {
+ match (self.remote_last_ts, self.timeout) {
+ (Some(remote_last_ts), Some(timeout)) => timestamp >= remote_last_ts + timeout,
+ (_, _) => false,
+ }
+ }
+
+ fn seq_to_transmit(&self, cx: &mut Context) -> bool {
+ let ip_header_len = match self.tuple.unwrap().local.addr {
+ #[cfg(feature = "proto-ipv4")]
+ IpAddress::Ipv4(_) => crate::wire::IPV4_HEADER_LEN,
+ #[cfg(feature = "proto-ipv6")]
+ IpAddress::Ipv6(_) => crate::wire::IPV6_HEADER_LEN,
+ };
+
+ // Max segment size we're able to send due to MTU limitations.
+ let local_mss = cx.ip_mtu() - ip_header_len - TCP_HEADER_LEN;
+
+ // The effective max segment size, taking into account our and remote's limits.
+ let effective_mss = local_mss.min(self.remote_mss);
+
+ // Have we sent data that hasn't been ACKed yet?
+ let data_in_flight = self.remote_last_seq != self.local_seq_no;
+
+ // If we want to send a SYN and we haven't done so, do it!
+ if matches!(self.state, State::SynSent | State::SynReceived) && !data_in_flight {
+ return true;
+ }
+
+ // max sequence number we can send.
+ let max_send_seq =
+ self.local_seq_no + core::cmp::min(self.remote_win_len, self.tx_buffer.len());
+
+ // Max amount of octets we can send.
+ let max_send = if max_send_seq >= self.remote_last_seq {
+ max_send_seq - self.remote_last_seq
+ } else {
+ 0
+ };
+
+ // Can we send at least 1 octet?
+ let mut can_send = max_send != 0;
+ // Can we send at least 1 full segment?
+ let can_send_full = max_send >= effective_mss;
+
+ // Do we have to send a FIN?
+ let want_fin = match self.state {
+ State::FinWait1 => true,
+ State::Closing => true,
+ State::LastAck => true,
+ _ => false,
+ };
+
+ // If we're applying the Nagle algorithm we don't want to send more
+ // until one of:
+ // * There's no data in flight
+ // * We can send a full packet
+ // * We have all the data we'll ever send (we're closing send)
+ if self.nagle && data_in_flight && !can_send_full && !want_fin {
+ can_send = false;
+ }
+
+ // Can we actually send the FIN? We can send it if:
+ // 1. We have unsent data that fits in the remote window.
+ // 2. We have no unsent data.
+ // This condition matches only if #2, because #1 is already covered by can_data and we're ORing them.
+ let can_fin = want_fin && self.remote_last_seq == self.local_seq_no + self.tx_buffer.len();
+
+ can_send || can_fin
+ }
+
+ fn delayed_ack_expired(&self, timestamp: Instant) -> bool {
+ match self.ack_delay_timer {
+ AckDelayTimer::Idle => true,
+ AckDelayTimer::Waiting(t) => t <= timestamp,
+ AckDelayTimer::Immediate => true,
+ }
+ }
+
+ fn ack_to_transmit(&self) -> bool {
+ if let Some(remote_last_ack) = self.remote_last_ack {
+ remote_last_ack < self.remote_seq_no + self.rx_buffer.len()
+ } else {
+ false
+ }
+ }
+
+ fn window_to_update(&self) -> bool {
+ match self.state {
+ State::SynSent
+ | State::SynReceived
+ | State::Established
+ | State::FinWait1
+ | State::FinWait2 => self.scaled_window() > self.remote_last_win,
+ _ => false,
+ }
+ }
+
+ pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+ where
+ F: FnOnce(&mut Context, (IpRepr, TcpRepr)) -> Result<(), E>,
+ {
+ if self.tuple.is_none() {
+ return Ok(());
+ }
+
+ if self.remote_last_ts.is_none() {
+ // We get here in exactly two cases:
+ // 1) This socket just transitioned into SYN-SENT.
+ // 2) This socket had an empty transmit buffer and some data was added there.
+ // Both are similar in that the socket has been quiet for an indefinite
+ // period of time, it isn't anymore, and the local endpoint is talking.
+ // So, we start counting the timeout not from the last received packet
+ // but from the first transmitted one.
+ self.remote_last_ts = Some(cx.now());
+ }
+
+ // Check if any state needs to be changed because of a timer.
+ if self.timed_out(cx.now()) {
+ // If a timeout expires, we should abort the connection.
+ net_debug!("timeout exceeded");
+ self.set_state(State::Closed);
+ } else if !self.seq_to_transmit(cx) {
+ if let Some(retransmit_delta) = self.timer.should_retransmit(cx.now()) {
+ // If a retransmit timer expired, we should resend data starting at the last ACK.
+ net_debug!("retransmitting at t+{}", retransmit_delta);
+
+ // Rewind "last sequence number sent", as if we never
+ // had sent them. This will cause all data in the queue
+ // to be sent again.
+ self.remote_last_seq = self.local_seq_no;
+
+ // Clear the `should_retransmit` state. If we can't retransmit right
+ // now for whatever reason (like zero window), this avoids an
+ // infinite polling loop where `poll_at` returns `Now` but `dispatch`
+ // can't actually do anything.
+ self.timer.set_for_idle(cx.now(), self.keep_alive);
+
+ // Inform RTTE, so that it can avoid bogus measurements.
+ self.rtte.on_retransmit();
+ }
+ }
+
+ // Decide whether we're sending a packet.
+ if self.seq_to_transmit(cx) {
+ // If we have data to transmit and it fits into partner's window, do it.
+ tcp_trace!("outgoing segment will send data or flags");
+ } else if self.ack_to_transmit() && self.delayed_ack_expired(cx.now()) {
+ // If we have data to acknowledge, do it.
+ tcp_trace!("outgoing segment will acknowledge");
+ } else if self.window_to_update() && self.delayed_ack_expired(cx.now()) {
+ // If we have window length increase to advertise, do it.
+ tcp_trace!("outgoing segment will update window");
+ } else if self.state == State::Closed {
+ // If we need to abort the connection, do it.
+ tcp_trace!("outgoing segment will abort connection");
+ } else if self.timer.should_keep_alive(cx.now()) {
+ // If we need to transmit a keep-alive packet, do it.
+ tcp_trace!("keep-alive timer expired");
+ } else if self.timer.should_close(cx.now()) {
+ // If we have spent enough time in the TIME-WAIT state, close the socket.
+ tcp_trace!("TIME-WAIT timer expired");
+ self.reset();
+ return Ok(());
+ } else {
+ return Ok(());
+ }
+
+ // NOTE(unwrap): we check tuple is not None the first thing in this function.
+ let tuple = self.tuple.unwrap();
+
+ // Construct the lowered IP representation.
+ // We might need this to calculate the MSS, so do it early.
+ let mut ip_repr = IpRepr::new(
+ tuple.local.addr,
+ tuple.remote.addr,
+ IpProtocol::Tcp,
+ 0,
+ self.hop_limit.unwrap_or(64),
+ );
+
+ // Construct the basic TCP representation, an empty ACK packet.
+ // We'll adjust this to be more specific as needed.
+ let mut repr = TcpRepr {
+ src_port: tuple.local.port,
+ dst_port: tuple.remote.port,
+ control: TcpControl::None,
+ seq_number: self.remote_last_seq,
+ ack_number: Some(self.remote_seq_no + self.rx_buffer.len()),
+ window_len: self.scaled_window(),
+ window_scale: None,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &[],
+ };
+
+ match self.state {
+ // We transmit an RST in the CLOSED state. If we ended up in the CLOSED state
+ // with a specified endpoint, it means that the socket was aborted.
+ State::Closed => {
+ repr.control = TcpControl::Rst;
+ }
+
+ // We never transmit anything in the LISTEN state.
+ State::Listen => return Ok(()),
+
+ // We transmit a SYN in the SYN-SENT state.
+ // We transmit a SYN|ACK in the SYN-RECEIVED state.
+ State::SynSent | State::SynReceived => {
+ repr.control = TcpControl::Syn;
+ // window len must NOT be scaled in SYNs.
+ repr.window_len = self.rx_buffer.window().min((1 << 16) - 1) as u16;
+ if self.state == State::SynSent {
+ repr.ack_number = None;
+ repr.window_scale = Some(self.remote_win_shift);
+ repr.sack_permitted = true;
+ } else {
+ repr.sack_permitted = self.remote_has_sack;
+ repr.window_scale = self.remote_win_scale.map(|_| self.remote_win_shift);
+ }
+ }
+
+ // We transmit data in all states where we may have data in the buffer,
+ // or the transmit half of the connection is still open.
+ State::Established
+ | State::FinWait1
+ | State::Closing
+ | State::CloseWait
+ | State::LastAck => {
+ // Extract as much data as the remote side can receive in this packet
+ // from the transmit buffer.
+
+ // Right edge of window, ie the max sequence number we're allowed to send.
+ let win_right_edge = self.local_seq_no + self.remote_win_len;
+
+ // Max amount of octets we're allowed to send according to the remote window.
+ let win_limit = if win_right_edge >= self.remote_last_seq {
+ win_right_edge - self.remote_last_seq
+ } else {
+ // This can happen if we've sent some data and later the remote side
+ // has shrunk its window so that data is no longer inside the window.
+ // This should be very rare and is strongly discouraged by the RFCs,
+ // but it does happen in practice.
+ // http://www.tcpipguide.com/free/t_TCPWindowManagementIssues.htm
+ 0
+ };
+
+ // Maximum size we're allowed to send. This can be limited by 3 factors:
+ // 1. remote window
+ // 2. MSS the remote is willing to accept, probably determined by their MTU
+ // 3. MSS we can send, determined by our MTU.
+ let size = win_limit
+ .min(self.remote_mss)
+ .min(cx.ip_mtu() - ip_repr.header_len() - TCP_HEADER_LEN);
+
+ let offset = self.remote_last_seq - self.local_seq_no;
+ repr.payload = self.tx_buffer.get_allocated(offset, size);
+
+ // If we've sent everything we had in the buffer, follow it with the PSH or FIN
+ // flags, depending on whether the transmit half of the connection is open.
+ if offset + repr.payload.len() == self.tx_buffer.len() {
+ match self.state {
+ State::FinWait1 | State::LastAck | State::Closing => {
+ repr.control = TcpControl::Fin
+ }
+ State::Established | State::CloseWait if !repr.payload.is_empty() => {
+ repr.control = TcpControl::Psh
+ }
+ _ => (),
+ }
+ }
+ }
+
+ // In FIN-WAIT-2 and TIME-WAIT states we may only transmit ACKs for incoming data or FIN
+ State::FinWait2 | State::TimeWait => {}
+ }
+
+ // There might be more than one reason to send a packet. E.g. the keep-alive timer
+ // has expired, and we also have data in transmit buffer. Since any packet that occupies
+ // sequence space will elicit an ACK, we only need to send an explicit packet if we
+ // couldn't fill the sequence space with anything.
+ let is_keep_alive;
+ if self.timer.should_keep_alive(cx.now()) && repr.is_empty() {
+ repr.seq_number = repr.seq_number - 1;
+ repr.payload = b"\x00"; // RFC 1122 says we should do this
+ is_keep_alive = true;
+ } else {
+ is_keep_alive = false;
+ }
+
+ // Trace a summary of what will be sent.
+ if is_keep_alive {
+ tcp_trace!("sending a keep-alive");
+ } else if !repr.payload.is_empty() {
+ tcp_trace!(
+ "tx buffer: sending {} octets at offset {}",
+ repr.payload.len(),
+ self.remote_last_seq - self.local_seq_no
+ );
+ }
+ if repr.control != TcpControl::None || repr.payload.is_empty() {
+ let flags = match (repr.control, repr.ack_number) {
+ (TcpControl::Syn, None) => "SYN",
+ (TcpControl::Syn, Some(_)) => "SYN|ACK",
+ (TcpControl::Fin, Some(_)) => "FIN|ACK",
+ (TcpControl::Rst, Some(_)) => "RST|ACK",
+ (TcpControl::Psh, Some(_)) => "PSH|ACK",
+ (TcpControl::None, Some(_)) => "ACK",
+ _ => "<unreachable>",
+ };
+ tcp_trace!("sending {}", flags);
+ }
+
+ if repr.control == TcpControl::Syn {
+ // Fill the MSS option. See RFC 6691 for an explanation of this calculation.
+ let max_segment_size = cx.ip_mtu() - ip_repr.header_len() - TCP_HEADER_LEN;
+ repr.max_seg_size = Some(max_segment_size as u16);
+ }
+
+ // Actually send the packet. If this succeeds, it means the packet is in
+ // the device buffer, and its transmission is imminent. If not, we might have
+ // a number of problems, e.g. we need neighbor discovery.
+ //
+ // Bailing out if the packet isn't placed in the device buffer allows us
+ // to not waste time waiting for the retransmit timer on packets that we know
+ // for sure will not be successfully transmitted.
+ ip_repr.set_payload_len(repr.buffer_len());
+ emit(cx, (ip_repr, repr))?;
+
+ // We've sent something, whether useful data or a keep-alive packet, so rewind
+ // the keep-alive timer.
+ self.timer.rewind_keep_alive(cx.now(), self.keep_alive);
+
+ // Reset delayed-ack timer
+ match self.ack_delay_timer {
+ AckDelayTimer::Idle => {}
+ AckDelayTimer::Waiting(_) => {
+ tcp_trace!("stop delayed ack timer")
+ }
+ AckDelayTimer::Immediate => {
+ tcp_trace!("stop delayed ack timer (was force-expired)")
+ }
+ }
+ self.ack_delay_timer = AckDelayTimer::Idle;
+
+ // Leave the rest of the state intact if sending a keep-alive packet, since those
+ // carry a fake segment.
+ if is_keep_alive {
+ return Ok(());
+ }
+
+ // We've sent a packet successfully, so we can update the internal state now.
+ self.remote_last_seq = repr.seq_number + repr.segment_len();
+ self.remote_last_ack = repr.ack_number;
+ self.remote_last_win = repr.window_len;
+
+ if repr.segment_len() > 0 {
+ self.rtte
+ .on_send(cx.now(), repr.seq_number + repr.segment_len());
+ }
+
+ if !self.seq_to_transmit(cx) && repr.segment_len() > 0 {
+ // If we've transmitted all data we could (and there was something at all,
+ // data or flag, to transmit, not just an ACK), wind up the retransmit timer.
+ self.timer
+ .set_for_retransmit(cx.now(), self.rtte.retransmission_timeout());
+ }
+
+ if self.state == State::Closed {
+ // When aborting a connection, forget about it after sending a single RST packet.
+ self.tuple = None;
+ #[cfg(feature = "async")]
+ {
+ // Wake tx now so that async users can wait for the RST to be sent
+ self.tx_waker.wake();
+ }
+ }
+
+ Ok(())
+ }
+
+ #[allow(clippy::if_same_then_else)]
+ pub(crate) fn poll_at(&self, cx: &mut Context) -> PollAt {
+ // The logic here mirrors the beginning of dispatch() closely.
+ if self.tuple.is_none() {
+ // No one to talk to, nothing to transmit.
+ PollAt::Ingress
+ } else if self.remote_last_ts.is_none() {
+ // Socket stopped being quiet recently, we need to acquire a timestamp.
+ PollAt::Now
+ } else if self.state == State::Closed {
+ // Socket was aborted, we have an RST packet to transmit.
+ PollAt::Now
+ } else if self.seq_to_transmit(cx) {
+ // We have a data or flag packet to transmit.
+ PollAt::Now
+ } else {
+ let want_ack = self.ack_to_transmit() || self.window_to_update();
+
+ let delayed_ack_poll_at = match (want_ack, self.ack_delay_timer) {
+ (false, _) => PollAt::Ingress,
+ (true, AckDelayTimer::Idle) => PollAt::Now,
+ (true, AckDelayTimer::Waiting(t)) => PollAt::Time(t),
+ (true, AckDelayTimer::Immediate) => PollAt::Now,
+ };
+
+ let timeout_poll_at = match (self.remote_last_ts, self.timeout) {
+ // If we're transmitting or retransmitting data, we need to poll at the moment
+ // when the timeout would expire.
+ (Some(remote_last_ts), Some(timeout)) => PollAt::Time(remote_last_ts + timeout),
+ // Otherwise we have no timeout.
+ (_, _) => PollAt::Ingress,
+ };
+
+ // We wait for the earliest of our timers to fire.
+ *[self.timer.poll_at(), timeout_poll_at, delayed_ack_poll_at]
+ .iter()
+ .min()
+ .unwrap_or(&PollAt::Ingress)
+ }
+ }
+}
+
+impl<'a> fmt::Write for Socket<'a> {
+ fn write_str(&mut self, slice: &str) -> fmt::Result {
+ let slice = slice.as_bytes();
+ if self.send_slice(slice) == Ok(slice.len()) {
+ Ok(())
+ } else {
+ Err(fmt::Error)
+ }
+ }
+}
+
+// TODO: TCP should work for all features. For now, we only test with the IP feature. We could do
+// it for other features as well with rstest, however, this means we have to modify a lot of the
+// tests in here, which I didn't had the time for at the moment.
+#[cfg(all(test, feature = "medium-ip"))]
+mod test {
+ use super::*;
+ use crate::wire::IpRepr;
+ use core::i32;
+ use std::ops::{Deref, DerefMut};
+ use std::vec::Vec;
+
+ // =========================================================================================//
+ // Constants
+ // =========================================================================================//
+
+ const LOCAL_PORT: u16 = 80;
+ const REMOTE_PORT: u16 = 49500;
+ const LISTEN_END: IpListenEndpoint = IpListenEndpoint {
+ addr: None,
+ port: LOCAL_PORT,
+ };
+ const LOCAL_END: IpEndpoint = IpEndpoint {
+ addr: LOCAL_ADDR.into_address(),
+ port: LOCAL_PORT,
+ };
+ const REMOTE_END: IpEndpoint = IpEndpoint {
+ addr: REMOTE_ADDR.into_address(),
+ port: REMOTE_PORT,
+ };
+ const TUPLE: Tuple = Tuple {
+ local: LOCAL_END,
+ remote: REMOTE_END,
+ };
+ const LOCAL_SEQ: TcpSeqNumber = TcpSeqNumber(10000);
+ const REMOTE_SEQ: TcpSeqNumber = TcpSeqNumber(-10001);
+
+ cfg_if::cfg_if! {
+ if #[cfg(feature = "proto-ipv4")] {
+ use crate::wire::Ipv4Address as IpvXAddress;
+ use crate::wire::Ipv4Repr as IpvXRepr;
+ use IpRepr::Ipv4 as IpReprIpvX;
+
+ const LOCAL_ADDR: IpvXAddress = IpvXAddress([192, 168, 1, 1]);
+ const REMOTE_ADDR: IpvXAddress = IpvXAddress([192, 168, 1, 2]);
+ const OTHER_ADDR: IpvXAddress = IpvXAddress([192, 168, 1, 3]);
+
+ const BASE_MSS: u16 = 1460;
+ } else {
+ use crate::wire::Ipv6Address as IpvXAddress;
+ use crate::wire::Ipv6Repr as IpvXRepr;
+ use IpRepr::Ipv6 as IpReprIpvX;
+
+ const LOCAL_ADDR: IpvXAddress = IpvXAddress([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+ ]);
+ const REMOTE_ADDR: IpvXAddress = IpvXAddress([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
+ ]);
+ const OTHER_ADDR: IpvXAddress = IpvXAddress([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
+ ]);
+
+ const BASE_MSS: u16 = 1440;
+ }
+ }
+
+ const SEND_IP_TEMPL: IpRepr = IpReprIpvX(IpvXRepr {
+ src_addr: LOCAL_ADDR,
+ dst_addr: REMOTE_ADDR,
+ next_header: IpProtocol::Tcp,
+ payload_len: 20,
+ hop_limit: 64,
+ });
+ const SEND_TEMPL: TcpRepr<'static> = TcpRepr {
+ src_port: REMOTE_PORT,
+ dst_port: LOCAL_PORT,
+ control: TcpControl::None,
+ seq_number: TcpSeqNumber(0),
+ ack_number: Some(TcpSeqNumber(0)),
+ window_len: 256,
+ window_scale: None,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &[],
+ };
+ const _RECV_IP_TEMPL: IpRepr = IpReprIpvX(IpvXRepr {
+ src_addr: LOCAL_ADDR,
+ dst_addr: REMOTE_ADDR,
+ next_header: IpProtocol::Tcp,
+ payload_len: 20,
+ hop_limit: 64,
+ });
+ const RECV_TEMPL: TcpRepr<'static> = TcpRepr {
+ src_port: LOCAL_PORT,
+ dst_port: REMOTE_PORT,
+ control: TcpControl::None,
+ seq_number: TcpSeqNumber(0),
+ ack_number: Some(TcpSeqNumber(0)),
+ window_len: 64,
+ window_scale: None,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &[],
+ };
+
+ // =========================================================================================//
+ // Helper functions
+ // =========================================================================================//
+
+ struct TestSocket {
+ socket: Socket<'static>,
+ cx: Context,
+ }
+
+ impl Deref for TestSocket {
+ type Target = Socket<'static>;
+ fn deref(&self) -> &Self::Target {
+ &self.socket
+ }
+ }
+
+ impl DerefMut for TestSocket {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.socket
+ }
+ }
+
+ fn send(
+ socket: &mut TestSocket,
+ timestamp: Instant,
+ repr: &TcpRepr,
+ ) -> Option<TcpRepr<'static>> {
+ socket.cx.set_now(timestamp);
+
+ let ip_repr = IpReprIpvX(IpvXRepr {
+ src_addr: REMOTE_ADDR,
+ dst_addr: LOCAL_ADDR,
+ next_header: IpProtocol::Tcp,
+ payload_len: repr.buffer_len(),
+ hop_limit: 64,
+ });
+ net_trace!("send: {}", repr);
+
+ assert!(socket.socket.accepts(&mut socket.cx, &ip_repr, repr));
+
+ match socket.socket.process(&mut socket.cx, &ip_repr, repr) {
+ Some((_ip_repr, repr)) => {
+ net_trace!("recv: {}", repr);
+ Some(repr)
+ }
+ None => None,
+ }
+ }
+
+ fn recv<F>(socket: &mut TestSocket, timestamp: Instant, mut f: F)
+ where
+ F: FnMut(Result<TcpRepr, ()>),
+ {
+ socket.cx.set_now(timestamp);
+
+ let mut sent = 0;
+ let result = socket
+ .socket
+ .dispatch(&mut socket.cx, |_, (ip_repr, tcp_repr)| {
+ assert_eq!(ip_repr.next_header(), IpProtocol::Tcp);
+ assert_eq!(ip_repr.src_addr(), LOCAL_ADDR.into());
+ assert_eq!(ip_repr.dst_addr(), REMOTE_ADDR.into());
+ assert_eq!(ip_repr.payload_len(), tcp_repr.buffer_len());
+
+ net_trace!("recv: {}", tcp_repr);
+ sent += 1;
+ Ok(f(Ok(tcp_repr)))
+ });
+ match result {
+ Ok(()) => assert_eq!(sent, 1, "Exactly one packet should be sent"),
+ Err(e) => f(Err(e)),
+ }
+ }
+
+ fn recv_nothing(socket: &mut TestSocket, timestamp: Instant) {
+ socket.cx.set_now(timestamp);
+
+ let result: Result<(), ()> = socket
+ .socket
+ .dispatch(&mut socket.cx, |_, (_ip_repr, _tcp_repr)| {
+ panic!("Should not send a packet")
+ });
+
+ assert_eq!(result, Ok(()))
+ }
+
+ macro_rules! send {
+ ($socket:ident, $repr:expr) =>
+ (send!($socket, time 0, $repr));
+ ($socket:ident, $repr:expr, $result:expr) =>
+ (send!($socket, time 0, $repr, $result));
+ ($socket:ident, time $time:expr, $repr:expr) =>
+ (send!($socket, time $time, $repr, None));
+ ($socket:ident, time $time:expr, $repr:expr, $result:expr) =>
+ (assert_eq!(send(&mut $socket, Instant::from_millis($time), &$repr), $result));
+ }
+
+ macro_rules! recv {
+ ($socket:ident, [$( $repr:expr ),*]) => ({
+ $( recv!($socket, Ok($repr)); )*
+ recv_nothing!($socket)
+ });
+ ($socket:ident, $result:expr) =>
+ (recv!($socket, time 0, $result));
+ ($socket:ident, time $time:expr, $result:expr) =>
+ (recv(&mut $socket, Instant::from_millis($time), |result| {
+ // Most of the time we don't care about the PSH flag.
+ let result = result.map(|mut repr| {
+ repr.control = repr.control.quash_psh();
+ repr
+ });
+ assert_eq!(result, $result)
+ }));
+ ($socket:ident, time $time:expr, $result:expr, exact) =>
+ (recv(&mut $socket, Instant::from_millis($time), |repr| assert_eq!(repr, $result)));
+ }
+
+ macro_rules! recv_nothing {
+ ($socket:ident) => (recv_nothing!($socket, time 0));
+ ($socket:ident, time $time:expr) => (recv_nothing(&mut $socket, Instant::from_millis($time)));
+ }
+
+ macro_rules! sanity {
+ ($socket1:expr, $socket2:expr) => {{
+ let (s1, s2) = ($socket1, $socket2);
+ assert_eq!(s1.state, s2.state, "state");
+ assert_eq!(s1.tuple, s2.tuple, "tuple");
+ assert_eq!(s1.local_seq_no, s2.local_seq_no, "local_seq_no");
+ assert_eq!(s1.remote_seq_no, s2.remote_seq_no, "remote_seq_no");
+ assert_eq!(s1.remote_last_seq, s2.remote_last_seq, "remote_last_seq");
+ assert_eq!(s1.remote_last_ack, s2.remote_last_ack, "remote_last_ack");
+ assert_eq!(s1.remote_last_win, s2.remote_last_win, "remote_last_win");
+ assert_eq!(s1.remote_win_len, s2.remote_win_len, "remote_win_len");
+ assert_eq!(s1.timer, s2.timer, "timer");
+ }};
+ }
+
+ fn socket() -> TestSocket {
+ socket_with_buffer_sizes(64, 64)
+ }
+
+ fn socket_with_buffer_sizes(tx_len: usize, rx_len: usize) -> TestSocket {
+ let (iface, _, _) = crate::tests::setup(crate::phy::Medium::Ip);
+
+ let rx_buffer = SocketBuffer::new(vec![0; rx_len]);
+ let tx_buffer = SocketBuffer::new(vec![0; tx_len]);
+ let mut socket = Socket::new(rx_buffer, tx_buffer);
+ socket.set_ack_delay(None);
+ TestSocket {
+ socket,
+ cx: iface.inner,
+ }
+ }
+
+ fn socket_syn_received_with_buffer_sizes(tx_len: usize, rx_len: usize) -> TestSocket {
+ let mut s = socket_with_buffer_sizes(tx_len, rx_len);
+ s.state = State::SynReceived;
+ s.tuple = Some(TUPLE);
+ s.local_seq_no = LOCAL_SEQ;
+ s.remote_seq_no = REMOTE_SEQ + 1;
+ s.remote_last_seq = LOCAL_SEQ;
+ s.remote_win_len = 256;
+ s
+ }
+
+ fn socket_syn_received() -> TestSocket {
+ socket_syn_received_with_buffer_sizes(64, 64)
+ }
+
+ fn socket_syn_sent_with_buffer_sizes(tx_len: usize, rx_len: usize) -> TestSocket {
+ let mut s = socket_with_buffer_sizes(tx_len, rx_len);
+ s.state = State::SynSent;
+ s.tuple = Some(TUPLE);
+ s.local_seq_no = LOCAL_SEQ;
+ s.remote_last_seq = LOCAL_SEQ;
+ s
+ }
+
+ fn socket_syn_sent() -> TestSocket {
+ socket_syn_sent_with_buffer_sizes(64, 64)
+ }
+
+ fn socket_established_with_buffer_sizes(tx_len: usize, rx_len: usize) -> TestSocket {
+ let mut s = socket_syn_received_with_buffer_sizes(tx_len, rx_len);
+ s.state = State::Established;
+ s.local_seq_no = LOCAL_SEQ + 1;
+ s.remote_last_seq = LOCAL_SEQ + 1;
+ s.remote_last_ack = Some(REMOTE_SEQ + 1);
+ s.remote_last_win = 64;
+ s
+ }
+
+ fn socket_established() -> TestSocket {
+ socket_established_with_buffer_sizes(64, 64)
+ }
+
+ fn socket_fin_wait_1() -> TestSocket {
+ let mut s = socket_established();
+ s.state = State::FinWait1;
+ s
+ }
+
+ fn socket_fin_wait_2() -> TestSocket {
+ let mut s = socket_fin_wait_1();
+ s.state = State::FinWait2;
+ s.local_seq_no = LOCAL_SEQ + 1 + 1;
+ s.remote_last_seq = LOCAL_SEQ + 1 + 1;
+ s
+ }
+
+ fn socket_closing() -> TestSocket {
+ let mut s = socket_fin_wait_1();
+ s.state = State::Closing;
+ s.remote_last_seq = LOCAL_SEQ + 1 + 1;
+ s.remote_seq_no = REMOTE_SEQ + 1 + 1;
+ s
+ }
+
+ fn socket_time_wait(from_closing: bool) -> TestSocket {
+ let mut s = socket_fin_wait_2();
+ s.state = State::TimeWait;
+ s.remote_seq_no = REMOTE_SEQ + 1 + 1;
+ if from_closing {
+ s.remote_last_ack = Some(REMOTE_SEQ + 1 + 1);
+ }
+ s.timer = Timer::Close {
+ expires_at: Instant::from_secs(1) + CLOSE_DELAY,
+ };
+ s
+ }
+
+ fn socket_close_wait() -> TestSocket {
+ let mut s = socket_established();
+ s.state = State::CloseWait;
+ s.remote_seq_no = REMOTE_SEQ + 1 + 1;
+ s.remote_last_ack = Some(REMOTE_SEQ + 1 + 1);
+ s
+ }
+
+ fn socket_last_ack() -> TestSocket {
+ let mut s = socket_close_wait();
+ s.state = State::LastAck;
+ s
+ }
+
+ fn socket_recved() -> TestSocket {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 58,
+ ..RECV_TEMPL
+ }]
+ );
+ s
+ }
+
+ // =========================================================================================//
+ // Tests for the CLOSED state.
+ // =========================================================================================//
+ #[test]
+ fn test_closed_reject() {
+ let mut s = socket();
+ assert_eq!(s.state, State::Closed);
+
+ let tcp_repr = TcpRepr {
+ control: TcpControl::Syn,
+ ..SEND_TEMPL
+ };
+ assert!(!s.socket.accepts(&mut s.cx, &SEND_IP_TEMPL, &tcp_repr));
+ }
+
+ #[test]
+ fn test_closed_reject_after_listen() {
+ let mut s = socket();
+ s.listen(LOCAL_END).unwrap();
+ s.close();
+
+ let tcp_repr = TcpRepr {
+ control: TcpControl::Syn,
+ ..SEND_TEMPL
+ };
+ assert!(!s.socket.accepts(&mut s.cx, &SEND_IP_TEMPL, &tcp_repr));
+ }
+
+ #[test]
+ fn test_closed_close() {
+ let mut s = socket();
+ s.close();
+ assert_eq!(s.state, State::Closed);
+ }
+
+ // =========================================================================================//
+ // Tests for the LISTEN state.
+ // =========================================================================================//
+ fn socket_listen() -> TestSocket {
+ let mut s = socket();
+ s.state = State::Listen;
+ s.listen_endpoint = LISTEN_END;
+ s
+ }
+
+ #[test]
+ fn test_listen_sack_option() {
+ let mut s = socket_listen();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ sack_permitted: false,
+ ..SEND_TEMPL
+ }
+ );
+ assert!(!s.remote_has_sack);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+
+ let mut s = socket_listen();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ sack_permitted: true,
+ ..SEND_TEMPL
+ }
+ );
+ assert!(s.remote_has_sack);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_listen_syn_win_scale_buffers() {
+ for (buffer_size, shift_amt) in &[
+ (64, 0),
+ (128, 0),
+ (1024, 0),
+ (65535, 0),
+ (65536, 1),
+ (65537, 1),
+ (131071, 1),
+ (131072, 2),
+ (524287, 3),
+ (524288, 4),
+ (655350, 4),
+ (1048576, 5),
+ ] {
+ let mut s = socket_with_buffer_sizes(64, *buffer_size);
+ s.state = State::Listen;
+ s.listen_endpoint = LISTEN_END;
+ assert_eq!(s.remote_win_shift, *shift_amt);
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ window_scale: Some(0),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.remote_win_shift, *shift_amt);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(*shift_amt),
+ window_len: cmp::min(*buffer_size, 65535) as u16,
+ ..RECV_TEMPL
+ }]
+ );
+ }
+ }
+
+ #[test]
+ fn test_listen_sanity() {
+ let mut s = socket();
+ s.listen(LOCAL_PORT).unwrap();
+ sanity!(s, socket_listen());
+ }
+
+ #[test]
+ fn test_listen_validation() {
+ let mut s = socket();
+ assert_eq!(s.listen(0), Err(ListenError::Unaddressable));
+ }
+
+ #[test]
+ fn test_listen_twice() {
+ let mut s = socket();
+ assert_eq!(s.listen(80), Ok(()));
+ // multiple calls to listen are okay if its the same local endpoint and the state is still in listening
+ assert_eq!(s.listen(80), Ok(()));
+ s.set_state(State::SynReceived); // state change, simulate incoming connection
+ assert_eq!(s.listen(80), Err(ListenError::InvalidState));
+ }
+
+ #[test]
+ fn test_listen_syn() {
+ let mut s = socket_listen();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ ..SEND_TEMPL
+ }
+ );
+ sanity!(s, socket_syn_received());
+ }
+
+ #[test]
+ fn test_listen_syn_reject_ack() {
+ let mut s = socket_listen();
+
+ let tcp_repr = TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ),
+ ..SEND_TEMPL
+ };
+ assert!(!s.socket.accepts(&mut s.cx, &SEND_IP_TEMPL, &tcp_repr));
+
+ assert_eq!(s.state, State::Listen);
+ }
+
+ #[test]
+ fn test_listen_rst() {
+ let mut s = socket_listen();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Listen);
+ }
+
+ #[test]
+ fn test_listen_close() {
+ let mut s = socket_listen();
+ s.close();
+ assert_eq!(s.state, State::Closed);
+ }
+
+ // =========================================================================================//
+ // Tests for the SYN-RECEIVED state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_syn_received_ack() {
+ let mut s = socket_syn_received();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Established);
+ sanity!(s, socket_established());
+ }
+
+ #[test]
+ fn test_syn_received_ack_too_low() {
+ let mut s = socket_syn_received();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ), // wrong
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ window_len: 0,
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.state, State::SynReceived);
+ }
+
+ #[test]
+ fn test_syn_received_ack_too_high() {
+ let mut s = socket_syn_received();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 2), // wrong
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 2,
+ ack_number: None,
+ window_len: 0,
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.state, State::SynReceived);
+ }
+
+ #[test]
+ fn test_syn_received_fin() {
+ let mut s = socket_syn_received();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6 + 1),
+ window_len: 58,
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::CloseWait);
+
+ let mut s2 = socket_close_wait();
+ s2.remote_last_ack = Some(REMOTE_SEQ + 1 + 6 + 1);
+ s2.remote_last_win = 58;
+ sanity!(s, s2);
+ }
+
+ #[test]
+ fn test_syn_received_rst() {
+ let mut s = socket_syn_received();
+ s.listen_endpoint = LISTEN_END;
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Listen);
+ assert_eq!(s.listen_endpoint, LISTEN_END);
+ assert_eq!(s.tuple, None);
+ }
+
+ #[test]
+ fn test_syn_received_no_window_scaling() {
+ let mut s = socket_listen();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state(), State::SynReceived);
+ assert_eq!(s.tuple, Some(TUPLE));
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ window_scale: None,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ window_scale: None,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.remote_win_shift, 0);
+ assert_eq!(s.remote_win_scale, None);
+ }
+
+ #[test]
+ fn test_syn_received_window_scaling() {
+ for scale in 0..14 {
+ let mut s = socket_listen();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ window_scale: Some(scale),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state(), State::SynReceived);
+ assert_eq!(s.tuple, Some(TUPLE));
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ window_scale: None,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.remote_win_scale, Some(scale));
+ }
+ }
+
+ #[test]
+ fn test_syn_received_close() {
+ let mut s = socket_syn_received();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ }
+
+ // =========================================================================================//
+ // Tests for the SYN-SENT state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_connect_validation() {
+ let mut s = socket();
+ assert_eq!(
+ s.socket
+ .connect(&mut s.cx, REMOTE_END, (IpvXAddress::UNSPECIFIED, 0)),
+ Err(ConnectError::Unaddressable)
+ );
+ assert_eq!(
+ s.socket
+ .connect(&mut s.cx, REMOTE_END, (IpvXAddress::UNSPECIFIED, 1024)),
+ Err(ConnectError::Unaddressable)
+ );
+ assert_eq!(
+ s.socket
+ .connect(&mut s.cx, (IpvXAddress::UNSPECIFIED, 0), LOCAL_END),
+ Err(ConnectError::Unaddressable)
+ );
+ s.socket
+ .connect(&mut s.cx, REMOTE_END, LOCAL_END)
+ .expect("Connect failed with valid parameters");
+ assert_eq!(s.tuple, Some(TUPLE));
+ }
+
+ #[test]
+ fn test_connect() {
+ let mut s = socket();
+ s.local_seq_no = LOCAL_SEQ;
+ s.socket
+ .connect(&mut s.cx, REMOTE_END, LOCAL_END.port)
+ .unwrap();
+ assert_eq!(s.tuple, Some(TUPLE));
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 1),
+ max_seg_size: Some(BASE_MSS - 80),
+ window_scale: Some(0),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.tuple, Some(TUPLE));
+ }
+
+ #[test]
+ fn test_connect_unspecified_local() {
+ let mut s = socket();
+ assert_eq!(s.socket.connect(&mut s.cx, REMOTE_END, 80), Ok(()));
+ }
+
+ #[test]
+ fn test_connect_specified_local() {
+ let mut s = socket();
+ assert_eq!(
+ s.socket.connect(&mut s.cx, REMOTE_END, (REMOTE_ADDR, 80)),
+ Ok(())
+ );
+ }
+
+ #[test]
+ fn test_connect_twice() {
+ let mut s = socket();
+ assert_eq!(s.socket.connect(&mut s.cx, REMOTE_END, 80), Ok(()));
+ assert_eq!(
+ s.socket.connect(&mut s.cx, REMOTE_END, 80),
+ Err(ConnectError::InvalidState)
+ );
+ }
+
+ #[test]
+ fn test_syn_sent_sanity() {
+ let mut s = socket();
+ s.local_seq_no = LOCAL_SEQ;
+ s.socket.connect(&mut s.cx, REMOTE_END, LOCAL_END).unwrap();
+ sanity!(s, socket_syn_sent());
+ }
+
+ #[test]
+ fn test_syn_sent_syn_ack() {
+ let mut s = socket_syn_sent();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 1),
+ max_seg_size: Some(BASE_MSS - 80),
+ window_scale: Some(0),
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ recv_nothing!(s, time 1000);
+ assert_eq!(s.state, State::Established);
+ sanity!(s, socket_established());
+ }
+
+ #[test]
+ fn test_syn_sent_syn_ack_not_incremented() {
+ let mut s = socket_syn_sent();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ), // WRONG
+ max_seg_size: Some(BASE_MSS - 80),
+ window_scale: Some(0),
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ window_len: 0,
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.state, State::SynSent);
+ }
+
+ #[test]
+ fn test_syn_sent_rst() {
+ let mut s = socket_syn_sent();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_syn_sent_rst_no_ack() {
+ let mut s = socket_syn_sent();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::SynSent);
+ }
+
+ #[test]
+ fn test_syn_sent_rst_bad_ack() {
+ let mut s = socket_syn_sent();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(TcpSeqNumber(1234)),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::SynSent);
+ }
+
+ #[test]
+ fn test_syn_sent_bad_ack() {
+ let mut s = socket_syn_sent();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::None, // Unexpected
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 1), // Correct
+ ..SEND_TEMPL
+ }
+ );
+
+ // It should trigger no response and change no state
+ recv!(s, []);
+ assert_eq!(s.state, State::SynSent);
+ }
+
+ #[test]
+ fn test_syn_sent_bad_ack_seq_1() {
+ let mut s = socket_syn_sent();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::None,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ), // WRONG
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ, // matching the ack_number of the unexpected ack
+ ack_number: None,
+ window_len: 0,
+ ..RECV_TEMPL
+ })
+ );
+
+ // It should trigger a RST, and change no state
+ assert_eq!(s.state, State::SynSent);
+ }
+
+ #[test]
+ fn test_syn_sent_bad_ack_seq_2() {
+ let mut s = socket_syn_sent();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::None,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 123456), // WRONG
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 123456, // matching the ack_number of the unexpected ack
+ ack_number: None,
+ window_len: 0,
+ ..RECV_TEMPL
+ })
+ );
+
+ // It should trigger a RST, and change no state
+ assert_eq!(s.state, State::SynSent);
+ }
+
+ #[test]
+ fn test_syn_sent_close() {
+ let mut s = socket();
+ s.close();
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_syn_sent_win_scale_buffers() {
+ for (buffer_size, shift_amt) in &[
+ (64, 0),
+ (128, 0),
+ (1024, 0),
+ (65535, 0),
+ (65536, 1),
+ (65537, 1),
+ (131071, 1),
+ (131072, 2),
+ (524287, 3),
+ (524288, 4),
+ (655350, 4),
+ (1048576, 5),
+ ] {
+ let mut s = socket_with_buffer_sizes(64, *buffer_size);
+ s.local_seq_no = LOCAL_SEQ;
+ assert_eq!(s.remote_win_shift, *shift_amt);
+ s.socket.connect(&mut s.cx, REMOTE_END, LOCAL_END).unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(*shift_amt),
+ window_len: cmp::min(*buffer_size, 65535) as u16,
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ }
+ }
+
+ #[test]
+ fn test_syn_sent_syn_ack_no_window_scaling() {
+ let mut s = socket_syn_sent_with_buffer_sizes(1048576, 1048576);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ // scaling does NOT apply to the window value in SYN packets
+ window_len: 65535,
+ window_scale: Some(5),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.remote_win_shift, 5);
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 1),
+ max_seg_size: Some(BASE_MSS - 80),
+ window_scale: None,
+ window_len: 42,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Established);
+ assert_eq!(s.remote_win_shift, 0);
+ assert_eq!(s.remote_win_scale, None);
+ assert_eq!(s.remote_win_len, 42);
+ }
+
+ #[test]
+ fn test_syn_sent_syn_ack_window_scaling() {
+ let mut s = socket_syn_sent();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 1),
+ max_seg_size: Some(BASE_MSS - 80),
+ window_scale: Some(7),
+ window_len: 42,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Established);
+ assert_eq!(s.remote_win_scale, Some(7));
+ // scaling does NOT apply to the window value in SYN packets
+ assert_eq!(s.remote_win_len, 42);
+ }
+
+ // =========================================================================================//
+ // Tests for the ESTABLISHED state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_established_recv() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 58,
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.rx_buffer.dequeue_many(6), &b"abcdef"[..]);
+ }
+
+ #[test]
+ fn test_peek_slice() {
+ const BUF_SIZE: usize = 10;
+
+ let send_buf = b"0123456";
+
+ let mut s = socket_established_with_buffer_sizes(BUF_SIZE, BUF_SIZE);
+
+ // Populate the recv buffer
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &send_buf[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // Peek into the recv buffer
+ let mut peeked_buf = [0u8; BUF_SIZE];
+ let actually_peeked = s.peek_slice(&mut peeked_buf[..]).unwrap();
+ let mut recv_buf = [0u8; BUF_SIZE];
+ let actually_recvd = s.recv_slice(&mut recv_buf[..]).unwrap();
+ assert_eq!(
+ &mut peeked_buf[..actually_peeked],
+ &mut recv_buf[..actually_recvd]
+ );
+ }
+
+ #[test]
+ fn test_peek_slice_buffer_wrap() {
+ const BUF_SIZE: usize = 10;
+
+ let send_buf = b"0123456789";
+
+ let mut s = socket_established_with_buffer_sizes(BUF_SIZE, BUF_SIZE);
+
+ let _ = s.rx_buffer.enqueue_slice(&send_buf[..8]);
+ let _ = s.rx_buffer.dequeue_many(6);
+ let _ = s.rx_buffer.enqueue_slice(&send_buf[..5]);
+
+ let mut peeked_buf = [0u8; BUF_SIZE];
+ let actually_peeked = s.peek_slice(&mut peeked_buf[..]).unwrap();
+ let mut recv_buf = [0u8; BUF_SIZE];
+ let actually_recvd = s.recv_slice(&mut recv_buf[..]).unwrap();
+ assert_eq!(
+ &mut peeked_buf[..actually_peeked],
+ &mut recv_buf[..actually_recvd]
+ );
+ }
+
+ fn setup_rfc2018_cases() -> (TestSocket, Vec<u8>) {
+ // This is a utility function used by the tests for RFC 2018 cases. It configures a socket
+ // in a particular way suitable for those cases.
+ //
+ // RFC 2018: Assume the left window edge is 5000 and that the data transmitter sends [...]
+ // segments, each containing 500 data bytes.
+ let mut s = socket_established_with_buffer_sizes(4000, 4000);
+ s.remote_has_sack = true;
+
+ // create a segment that is 500 bytes long
+ let mut segment: Vec<u8> = Vec::with_capacity(500);
+
+ // move the last ack to 5000 by sending ten of them
+ for _ in 0..50 {
+ segment.extend_from_slice(b"abcdefghij")
+ }
+ for offset in (0..5000).step_by(500) {
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + offset,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &segment,
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + offset + 500),
+ window_len: 3500,
+ ..RECV_TEMPL
+ }]
+ );
+ s.recv(|data| {
+ assert_eq!(data.len(), 500);
+ assert_eq!(data, segment.as_slice());
+ (500, ())
+ })
+ .unwrap();
+ }
+ assert_eq!(s.remote_last_win, 3500);
+ (s, segment)
+ }
+
+ #[test]
+ fn test_established_rfc2018_cases() {
+ // This test case verifies the exact scenarios described on pages 8-9 of RFC 2018. Please
+ // ensure its behavior does not deviate from those scenarios.
+
+ let (mut s, segment) = setup_rfc2018_cases();
+ // RFC 2018:
+ //
+ // Case 2: The first segment is dropped but the remaining 7 are received.
+ //
+ // Upon receiving each of the last seven packets, the data receiver will return a TCP ACK
+ // segment that acknowledges sequence number 5000 and contains a SACK option specifying one
+ // block of queued data:
+ //
+ // Triggering ACK Left Edge Right Edge
+ // Segment
+ //
+ // 5000 (lost)
+ // 5500 5000 5500 6000
+ // 6000 5000 5500 6500
+ // 6500 5000 5500 7000
+ // 7000 5000 5500 7500
+ // 7500 5000 5500 8000
+ // 8000 5000 5500 8500
+ // 8500 5000 5500 9000
+ //
+ for offset in (500..3500).step_by(500) {
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + offset + 5000,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &segment,
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 5000),
+ window_len: 4000,
+ sack_ranges: [
+ Some((
+ REMOTE_SEQ.0 as u32 + 1 + 5500,
+ REMOTE_SEQ.0 as u32 + 1 + 5500 + offset as u32
+ )),
+ None,
+ None
+ ],
+ ..RECV_TEMPL
+ })
+ );
+ }
+ }
+
+ #[test]
+ fn test_established_sliding_window_recv() {
+ let mut s = socket_established();
+ // Update our scaling parameters for a TCP with a scaled buffer.
+ assert_eq!(s.rx_buffer.len(), 0);
+ s.rx_buffer = SocketBuffer::new(vec![0; 262143]);
+ s.assembler = Assembler::new();
+ s.remote_win_scale = Some(0);
+ s.remote_last_win = 65535;
+ s.remote_win_shift = 2;
+
+ // Create a TCP segment that will mostly fill an IP frame.
+ let mut segment: Vec<u8> = Vec::with_capacity(1400);
+ for _ in 0..100 {
+ segment.extend_from_slice(b"abcdefghijklmn")
+ }
+ assert_eq!(segment.len(), 1400);
+
+ // Send the frame
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &segment,
+ ..SEND_TEMPL
+ }
+ );
+
+ // Ensure that the received window size is shifted right by 2.
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1400),
+ window_len: 65185,
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_established_send() {
+ let mut s = socket_established();
+ // First roundtrip after establishing.
+ s.send_slice(b"abcdef").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.tx_buffer.len(), 6);
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.tx_buffer.len(), 0);
+ // Second roundtrip.
+ s.send_slice(b"foobar").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"foobar"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 6),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.tx_buffer.len(), 0);
+ }
+
+ #[test]
+ fn test_established_send_no_ack_send() {
+ let mut s = socket_established();
+ s.set_nagle_enabled(false);
+ s.send_slice(b"abcdef").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ s.send_slice(b"foobar").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"foobar"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_established_send_buf_gt_win() {
+ let mut data = [0; 32];
+ for (i, elem) in data.iter_mut().enumerate() {
+ *elem = i as u8
+ }
+
+ let mut s = socket_established();
+ s.remote_win_len = 16;
+ s.send_slice(&data[..]).unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &data[0..16],
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_established_send_window_shrink() {
+ let mut s = socket_established();
+
+ // 6 octets fit on the remote side's window, so we send them.
+ s.send_slice(b"abcdef").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.tx_buffer.len(), 6);
+
+ println!(
+ "local_seq_no={} remote_win_len={} remote_last_seq={}",
+ s.local_seq_no, s.remote_win_len, s.remote_last_seq
+ );
+
+ // - Peer doesn't ack them yet
+ // - Sends data so we need to reply with an ACK
+ // - ...AND and sends a window announcement that SHRINKS the window, so data we've
+ // previously sent is now outside the window. Yes, this is allowed by TCP.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ window_len: 3,
+ payload: &b"xyzxyz"[..],
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.tx_buffer.len(), 6);
+
+ println!(
+ "local_seq_no={} remote_win_len={} remote_last_seq={}",
+ s.local_seq_no, s.remote_win_len, s.remote_last_seq
+ );
+
+ // More data should not get sent since it doesn't fit in the window
+ s.send_slice(b"foobar").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 64 - 6,
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_established_receive_partially_outside_window() {
+ let mut s = socket_established();
+
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+
+ // Peer decides to retransmit (perhaps because the ACK was lost)
+ // and also pushed data.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ s.recv(|data| {
+ assert_eq!(data, b"def");
+ (3, ())
+ })
+ .unwrap();
+ }
+
+ #[test]
+ fn test_established_send_wrap() {
+ let mut s = socket_established();
+ let local_seq_start = TcpSeqNumber(i32::MAX - 1);
+ s.local_seq_no = local_seq_start + 1;
+ s.remote_last_seq = local_seq_start + 1;
+ s.send_slice(b"abc").unwrap();
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: local_seq_start + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abc"[..],
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_established_no_ack() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: None,
+ ..SEND_TEMPL
+ }
+ );
+ }
+
+ #[test]
+ fn test_established_bad_ack() {
+ let mut s = socket_established();
+ // Already acknowledged data.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(TcpSeqNumber(LOCAL_SEQ.0 - 1)),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.local_seq_no, LOCAL_SEQ + 1);
+ // Data not yet transmitted.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 10),
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.local_seq_no, LOCAL_SEQ + 1);
+ }
+
+ #[test]
+ fn test_established_bad_seq() {
+ let mut s = socket_established();
+ // Data outside of receive window.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 256,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.remote_seq_no, REMOTE_SEQ + 1);
+
+ // Challenge ACKs are rate-limited, we don't get a second one immediately.
+ send!(
+ s,
+ time 100,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 256,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+
+ // If we wait a bit, we do get a new one.
+ send!(
+ s,
+ time 2000,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 256,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.remote_seq_no, REMOTE_SEQ + 1);
+ }
+
+ #[test]
+ fn test_established_fin() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::CloseWait);
+ sanity!(s, socket_close_wait());
+ }
+
+ #[test]
+ fn test_established_fin_after_missing() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1 + 6,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"123456"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.state, State::Established);
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6 + 6),
+ window_len: 52,
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.state, State::Established);
+ }
+
+ #[test]
+ fn test_established_send_fin() {
+ let mut s = socket_established();
+ s.send_slice(b"abcdef").unwrap();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::CloseWait);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_established_rst() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_established_rst_no_ack() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: None,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_established_close() {
+ let mut s = socket_established();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ sanity!(s, socket_fin_wait_1());
+ }
+
+ #[test]
+ fn test_established_abort() {
+ let mut s = socket_established();
+ s.abort();
+ assert_eq!(s.state, State::Closed);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_established_rst_bad_seq() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ, // Wrong seq
+ ack_number: None,
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ })
+ );
+
+ assert_eq!(s.state, State::Established);
+
+ // Send something to advance seq by 1
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1, // correct seq
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"a"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // Send wrong rst again, check that the challenge ack is correctly updated
+ // The ack number must be updated even if we don't call dispatch on the socket
+ // See https://github.com/smoltcp-rs/smoltcp/issues/338
+ send!(
+ s,
+ time 2000,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ, // Wrong seq
+ ack_number: None,
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 2), // this has changed
+ window_len: 63,
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ // =========================================================================================//
+ // Tests for the FIN-WAIT-1 state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_fin_wait_1_fin_ack() {
+ let mut s = socket_fin_wait_1();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::FinWait2);
+ sanity!(s, socket_fin_wait_2());
+ }
+
+ #[test]
+ fn test_fin_wait_1_fin_fin() {
+ let mut s = socket_fin_wait_1();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closing);
+ sanity!(s, socket_closing());
+ }
+
+ #[test]
+ fn test_fin_wait_1_fin_with_data_queued() {
+ let mut s = socket_established();
+ s.remote_win_len = 6;
+ s.send_slice(b"abcdef123456").unwrap();
+ s.close();
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ })
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::FinWait1);
+ }
+
+ #[test]
+ fn test_fin_wait_1_recv() {
+ let mut s = socket_fin_wait_1();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::FinWait1);
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ }
+
+ #[test]
+ fn test_fin_wait_1_close() {
+ let mut s = socket_fin_wait_1();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ }
+
+ // =========================================================================================//
+ // Tests for the FIN-WAIT-2 state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_fin_wait_2_fin() {
+ let mut s = socket_fin_wait_2();
+ send!(s, time 1_000, TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ });
+ assert_eq!(s.state, State::TimeWait);
+ sanity!(s, socket_time_wait(false));
+ }
+
+ #[test]
+ fn test_fin_wait_2_recv() {
+ let mut s = socket_fin_wait_2();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::FinWait2);
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_fin_wait_2_close() {
+ let mut s = socket_fin_wait_2();
+ s.close();
+ assert_eq!(s.state, State::FinWait2);
+ }
+
+ // =========================================================================================//
+ // Tests for the CLOSING state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_closing_ack_fin() {
+ let mut s = socket_closing();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(s, time 1_000, TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ });
+ assert_eq!(s.state, State::TimeWait);
+ sanity!(s, socket_time_wait(true));
+ }
+
+ #[test]
+ fn test_closing_close() {
+ let mut s = socket_closing();
+ s.close();
+ assert_eq!(s.state, State::Closing);
+ }
+
+ // =========================================================================================//
+ // Tests for the TIME-WAIT state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_time_wait_from_fin_wait_2_ack() {
+ let mut s = socket_time_wait(false);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_time_wait_from_closing_no_ack() {
+ let mut s = socket_time_wait(true);
+ recv!(s, []);
+ }
+
+ #[test]
+ fn test_time_wait_close() {
+ let mut s = socket_time_wait(false);
+ s.close();
+ assert_eq!(s.state, State::TimeWait);
+ }
+
+ #[test]
+ fn test_time_wait_retransmit() {
+ let mut s = socket_time_wait(false);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(s, time 5_000, TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }, Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }));
+ assert_eq!(
+ s.timer,
+ Timer::Close {
+ expires_at: Instant::from_secs(5) + CLOSE_DELAY
+ }
+ );
+ }
+
+ #[test]
+ fn test_time_wait_timeout() {
+ let mut s = socket_time_wait(false);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::TimeWait);
+ recv_nothing!(s, time 60_000);
+ assert_eq!(s.state, State::Closed);
+ }
+
+ // =========================================================================================//
+ // Tests for the CLOSE-WAIT state.
+ // =========================================================================================//
+
+ #[test]
+ fn test_close_wait_ack() {
+ let mut s = socket_close_wait();
+ s.send_slice(b"abcdef").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ ..SEND_TEMPL
+ }
+ );
+ }
+
+ #[test]
+ fn test_close_wait_close() {
+ let mut s = socket_close_wait();
+ s.close();
+ assert_eq!(s.state, State::LastAck);
+ sanity!(s, socket_last_ack());
+ }
+
+ // =========================================================================================//
+ // Tests for the LAST-ACK state.
+ // =========================================================================================//
+ #[test]
+ fn test_last_ack_fin_ack() {
+ let mut s = socket_last_ack();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::LastAck);
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_last_ack_ack_not_of_fin() {
+ let mut s = socket_last_ack();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::LastAck);
+
+ // ACK received that doesn't ack the FIN: socket should stay in LastAck.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::LastAck);
+
+ // ACK received of fin: socket should change to Closed.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_last_ack_close() {
+ let mut s = socket_last_ack();
+ s.close();
+ assert_eq!(s.state, State::LastAck);
+ }
+
+ // =========================================================================================//
+ // Tests for transitioning through multiple states.
+ // =========================================================================================//
+
+ #[test]
+ fn test_listen() {
+ let mut s = socket();
+ s.listen(LISTEN_END).unwrap();
+ assert_eq!(s.state, State::Listen);
+ }
+
+ #[test]
+ fn test_three_way_handshake() {
+ let mut s = socket_listen();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state(), State::SynReceived);
+ assert_eq!(s.tuple, Some(TUPLE));
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state(), State::Established);
+ assert_eq!(s.local_seq_no, LOCAL_SEQ + 1);
+ assert_eq!(s.remote_seq_no, REMOTE_SEQ + 1);
+ }
+
+ #[test]
+ fn test_remote_close() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::CloseWait);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ s.close();
+ assert_eq!(s.state, State::LastAck);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_local_close() {
+ let mut s = socket_established();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::FinWait2);
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::TimeWait);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_simultaneous_close() {
+ let mut s = socket_established();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ recv!(
+ s,
+ [TcpRepr {
+ // due to reordering, this is logically located...
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closing);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ // ... at this point
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::TimeWait);
+ recv!(s, []);
+ }
+
+ #[test]
+ fn test_simultaneous_close_combined_fin_ack() {
+ let mut s = socket_established();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::TimeWait);
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_simultaneous_close_raced() {
+ let mut s = socket_established();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+
+ // Socket receives FIN before it has a chance to send its own FIN
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closing);
+
+ // FIN + ack-of-FIN
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::Closing);
+
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::TimeWait);
+ recv!(s, []);
+ }
+
+ #[test]
+ fn test_simultaneous_close_raced_with_data() {
+ let mut s = socket_established();
+ s.send_slice(b"abcdef").unwrap();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+
+ // Socket receives FIN before it has a chance to send its own data+FIN
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closing);
+
+ // data + FIN + ack-of-FIN
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::Closing);
+
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::TimeWait);
+ recv!(s, []);
+ }
+
+ #[test]
+ fn test_fin_with_data() {
+ let mut s = socket_established();
+ s.send_slice(b"abcdef").unwrap();
+ s.close();
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ )
+ }
+
+ #[test]
+ fn test_mutual_close_with_data_1() {
+ let mut s = socket_established();
+ s.send_slice(b"abcdef").unwrap();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ }
+
+ #[test]
+ fn test_mutual_close_with_data_2() {
+ let mut s = socket_established();
+ s.send_slice(b"abcdef").unwrap();
+ s.close();
+ assert_eq!(s.state, State::FinWait1);
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::FinWait2);
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 1),
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.state, State::TimeWait);
+ }
+
+ // =========================================================================================//
+ // Tests for retransmission on packet loss.
+ // =========================================================================================//
+
+ #[test]
+ fn test_duplicate_seq_ack() {
+ let mut s = socket_recved();
+ // remote retransmission
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 58,
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ #[test]
+ fn test_data_retransmit() {
+ let mut s = socket_established();
+ s.send_slice(b"abcdef").unwrap();
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }));
+ recv_nothing!(s, time 1050);
+ recv!(s, time 2000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_data_retransmit_bursts() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+ s.send_slice(b"abcdef012345").unwrap();
+
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::None,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::Psh,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"012345"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv_nothing!(s, time 0);
+
+ recv_nothing!(s, time 50);
+
+ recv!(s, time 1000, Ok(TcpRepr {
+ control: TcpControl::None,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv!(s, time 1500, Ok(TcpRepr {
+ control: TcpControl::Psh,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"012345"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv_nothing!(s, time 1550);
+ }
+
+ #[test]
+ fn test_data_retransmit_bursts_half_ack() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+ s.send_slice(b"abcdef012345").unwrap();
+
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::None,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::Psh,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"012345"[..],
+ ..RECV_TEMPL
+ }), exact);
+ // Acknowledge the first packet
+ send!(s, time 5, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ // The second packet should be re-sent.
+ recv!(s, time 1500, Ok(TcpRepr {
+ control: TcpControl::Psh,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"012345"[..],
+ ..RECV_TEMPL
+ }), exact);
+
+ recv_nothing!(s, time 1550);
+ }
+
+ #[test]
+ fn test_data_retransmit_bursts_half_ack_close() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+ s.send_slice(b"abcdef012345").unwrap();
+ s.close();
+
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::None,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"012345"[..],
+ ..RECV_TEMPL
+ }), exact);
+ // Acknowledge the first packet
+ send!(s, time 5, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ // The second packet should be re-sent.
+ recv!(s, time 1500, Ok(TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"012345"[..],
+ ..RECV_TEMPL
+ }), exact);
+
+ recv_nothing!(s, time 1550);
+ }
+
+ #[test]
+ fn test_send_data_after_syn_ack_retransmit() {
+ let mut s = socket_syn_received();
+ recv!(s, time 50, Ok(TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 750, Ok(TcpRepr { // retransmit
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }));
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state(), State::Established);
+ s.send_slice(b"abcdef").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ )
+ }
+
+ #[test]
+ fn test_established_retransmit_for_dup_ack() {
+ let mut s = socket_established();
+ // Duplicate ACKs do not replace the retransmission timer
+ s.send_slice(b"abc").unwrap();
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abc"[..],
+ ..RECV_TEMPL
+ }));
+ // Retransmit timer is on because all data was sent
+ assert_eq!(s.tx_buffer.len(), 3);
+ // ACK nothing new
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ // Retransmit
+ recv!(s, time 4000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abc"[..],
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_established_retransmit_reset_after_ack() {
+ let mut s = socket_established();
+ s.remote_win_len = 6;
+ s.send_slice(b"abcdef").unwrap();
+ s.send_slice(b"123456").unwrap();
+ s.send_slice(b"ABCDEF").unwrap();
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }));
+ send!(s, time 1005, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ recv!(s, time 1010, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"123456"[..],
+ ..RECV_TEMPL
+ }));
+ send!(s, time 1015, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ recv!(s, time 1020, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"ABCDEF"[..],
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_established_queue_during_retransmission() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+ s.send_slice(b"abcdef123456ABCDEF").unwrap();
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ })); // this one is dropped
+ recv!(s, time 1005, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"123456"[..],
+ ..RECV_TEMPL
+ })); // this one is received
+ recv!(s, time 1010, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"ABCDEF"[..],
+ ..RECV_TEMPL
+ })); // also dropped
+ recv!(s, time 2000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ })); // retransmission
+ send!(s, time 2005, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 6),
+ ..SEND_TEMPL
+ }); // acknowledgement of both segments
+ recv!(s, time 2010, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"ABCDEF"[..],
+ ..RECV_TEMPL
+ })); // retransmission of only unacknowledged data
+ }
+
+ #[test]
+ fn test_close_wait_retransmit_reset_after_ack() {
+ let mut s = socket_close_wait();
+ s.remote_win_len = 6;
+ s.send_slice(b"abcdef").unwrap();
+ s.send_slice(b"123456").unwrap();
+ s.send_slice(b"ABCDEF").unwrap();
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }));
+ send!(s, time 1005, TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ recv!(s, time 1010, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ payload: &b"123456"[..],
+ ..RECV_TEMPL
+ }));
+ send!(s, time 1015, TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ recv!(s, time 1020, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ payload: &b"ABCDEF"[..],
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_fin_wait_1_retransmit_reset_after_ack() {
+ let mut s = socket_established();
+ s.remote_win_len = 6;
+ s.send_slice(b"abcdef").unwrap();
+ s.send_slice(b"123456").unwrap();
+ s.send_slice(b"ABCDEF").unwrap();
+ s.close();
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }));
+ send!(s, time 1005, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ recv!(s, time 1010, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"123456"[..],
+ ..RECV_TEMPL
+ }));
+ send!(s, time 1015, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 6),
+ window_len: 6,
+ ..SEND_TEMPL
+ });
+ recv!(s, time 1020, Ok(TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"ABCDEF"[..],
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_fast_retransmit_after_triple_duplicate_ack() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+
+ // Normal ACK of previously received segment
+ send!(s, time 0, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+
+ // Send a long string of text divided into several packets
+ // because of previously received "window_len"
+ s.send_slice(b"xxxxxxyyyyyywwwwwwzzzzzz").unwrap();
+ // This packet is lost
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"xxxxxx"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1005, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"yyyyyy"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1010, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + (6 * 2),
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"wwwwww"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1015, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + (6 * 3),
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"zzzzzz"[..],
+ ..RECV_TEMPL
+ }));
+
+ // First duplicate ACK
+ send!(s, time 1050, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ // Second duplicate ACK
+ send!(s, time 1055, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ // Third duplicate ACK
+ // Should trigger a fast retransmit of dropped packet
+ send!(s, time 1060, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+
+ // Fast retransmit packet
+ recv!(s, time 1100, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"xxxxxx"[..],
+ ..RECV_TEMPL
+ }));
+
+ recv!(s, time 1105, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"yyyyyy"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1110, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + (6 * 2),
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"wwwwww"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1115, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + (6 * 3),
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"zzzzzz"[..],
+ ..RECV_TEMPL
+ }));
+
+ // After all was send out, enter *normal* retransmission,
+ // don't stay in fast retransmission.
+ assert!(match s.timer {
+ Timer::Retransmit { expires_at, .. } => expires_at > Instant::from_millis(1115),
+ _ => false,
+ });
+
+ // ACK all received segments
+ send!(s, time 1120, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + (6 * 4)),
+ ..SEND_TEMPL
+ });
+ }
+
+ #[test]
+ fn test_fast_retransmit_duplicate_detection_with_data() {
+ let mut s = socket_established();
+
+ s.send_slice(b"abc").unwrap(); // This is lost
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abc"[..],
+ ..RECV_TEMPL
+ }));
+
+ // Normal ACK of previously received segment
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ // First duplicate
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ // Second duplicate
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+
+ assert_eq!(s.local_rx_dup_acks, 2, "duplicate ACK counter is not set");
+
+ // This packet has content, hence should not be detected
+ // as a duplicate ACK and should reset the duplicate ACK count
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"xxxxxx"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 3,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 58,
+ ..RECV_TEMPL
+ }]
+ );
+
+ assert_eq!(
+ s.local_rx_dup_acks, 0,
+ "duplicate ACK counter is not reset when receiving data"
+ );
+ }
+
+ #[test]
+ fn test_fast_retransmit_duplicate_detection_with_window_update() {
+ let mut s = socket_established();
+
+ s.send_slice(b"abc").unwrap(); // This is lost
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abc"[..],
+ ..RECV_TEMPL
+ }));
+
+ // Normal ACK of previously received segment
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ // First duplicate
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ // Second duplicate
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+
+ assert_eq!(s.local_rx_dup_acks, 2, "duplicate ACK counter is not set");
+
+ // This packet has a window update, hence should not be detected
+ // as a duplicate ACK and should reset the duplicate ACK count
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ window_len: 400,
+ ..SEND_TEMPL
+ }
+ );
+
+ assert_eq!(
+ s.local_rx_dup_acks, 0,
+ "duplicate ACK counter is not reset when receiving a window update"
+ );
+ }
+
+ #[test]
+ fn test_fast_retransmit_duplicate_detection() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+
+ // Normal ACK of previously received segment
+ send!(s, time 0, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+
+ // First duplicate, should not be counted as there is nothing to resend
+ send!(s, time 0, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+
+ assert_eq!(
+ s.local_rx_dup_acks, 0,
+ "duplicate ACK counter is set but wound not transmit data"
+ );
+
+ // Send a long string of text divided into several packets
+ // because of small remote_mss
+ s.send_slice(b"xxxxxxyyyyyywwwwwwzzzzzz").unwrap();
+
+ // This packet is reordered in network
+ recv!(s, time 1000, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"xxxxxx"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1005, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"yyyyyy"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1010, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + (6 * 2),
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"wwwwww"[..],
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1015, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + (6 * 3),
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"zzzzzz"[..],
+ ..RECV_TEMPL
+ }));
+
+ // First duplicate ACK
+ send!(s, time 1050, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ // Second duplicate ACK
+ send!(s, time 1055, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ // Reordered packet arrives which should reset duplicate ACK count
+ send!(s, time 1060, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + (6 * 3)),
+ ..SEND_TEMPL
+ });
+
+ assert_eq!(
+ s.local_rx_dup_acks, 0,
+ "duplicate ACK counter is not reset when receiving ACK which updates send window"
+ );
+
+ // ACK all received segments
+ send!(s, time 1120, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + (6 * 4)),
+ ..SEND_TEMPL
+ });
+ }
+
+ #[test]
+ fn test_fast_retransmit_dup_acks_counter() {
+ let mut s = socket_established();
+
+ s.send_slice(b"abc").unwrap(); // This is lost
+ recv!(s, time 0, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abc"[..],
+ ..RECV_TEMPL
+ }));
+
+ send!(s, time 0, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+
+ // A lot of retransmits happen here
+ s.local_rx_dup_acks = u8::max_value() - 1;
+
+ // Send 3 more ACKs, which could overflow local_rx_dup_acks,
+ // but intended behaviour is that we saturate the bounds
+ // of local_rx_dup_acks
+ send!(s, time 0, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ send!(s, time 0, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ send!(s, time 0, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ assert_eq!(
+ s.local_rx_dup_acks,
+ u8::max_value(),
+ "duplicate ACK count should not overflow but saturate"
+ );
+ }
+
+ #[test]
+ fn test_fast_retransmit_zero_window() {
+ let mut s = socket_established();
+
+ send!(s, time 1000, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+
+ s.send_slice(b"abc").unwrap();
+
+ recv!(s, time 0, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abc"[..],
+ ..RECV_TEMPL
+ }));
+
+ // 3 dup acks
+ send!(s, time 1050, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ send!(s, time 1050, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ send!(s, time 1050, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ window_len: 0, // boom
+ ..SEND_TEMPL
+ });
+
+ // even though we're in "fast retransmit", we shouldn't
+ // force-send anything because the remote's window is full.
+ recv_nothing!(s);
+ }
+
+ // =========================================================================================//
+ // Tests for window management.
+ // =========================================================================================//
+
+ #[test]
+ fn test_maximum_segment_size() {
+ let mut s = socket_listen();
+ s.tx_buffer = SocketBuffer::new(vec![0; 32767]);
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: REMOTE_SEQ,
+ ack_number: None,
+ max_seg_size: Some(1000),
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ max_seg_size: Some(BASE_MSS),
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ window_len: 32767,
+ ..SEND_TEMPL
+ }
+ );
+ s.send_slice(&[0; 1200][..]).unwrap();
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &[0; 1000][..],
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ #[test]
+ fn test_close_wait_no_window_update() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &[1, 2, 3, 4],
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::CloseWait);
+
+ // we ack the FIN, with the reduced window size.
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 6),
+ window_len: 60,
+ ..RECV_TEMPL
+ })
+ );
+
+ let rx_buf = &mut [0; 32];
+ assert_eq!(s.recv_slice(rx_buf), Ok(4));
+
+ // check that we do NOT send a window update even if it has changed.
+ recv_nothing!(s);
+ }
+
+ #[test]
+ fn test_time_wait_no_window_update() {
+ let mut s = socket_fin_wait_2();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 2),
+ payload: &[1, 2, 3, 4],
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::TimeWait);
+
+ // we ack the FIN, with the reduced window size.
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 2,
+ ack_number: Some(REMOTE_SEQ + 6),
+ window_len: 60,
+ ..RECV_TEMPL
+ })
+ );
+
+ let rx_buf = &mut [0; 32];
+ assert_eq!(s.recv_slice(rx_buf), Ok(4));
+
+ // check that we do NOT send a window update even if it has changed.
+ recv_nothing!(s);
+ }
+
+ // =========================================================================================//
+ // Tests for flow control.
+ // =========================================================================================//
+
+ #[test]
+ fn test_psh_transmit() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+ s.send_slice(b"abcdef").unwrap();
+ s.send_slice(b"123456").unwrap();
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::None,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::Psh,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"123456"[..],
+ ..RECV_TEMPL
+ }), exact);
+ }
+
+ #[test]
+ fn test_psh_receive() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Psh,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 58,
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_zero_window_ack() {
+ let mut s = socket_established();
+ s.rx_buffer = SocketBuffer::new(vec![0; 6]);
+ s.assembler = Assembler::new();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 0,
+ ..RECV_TEMPL
+ }]
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 6,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"123456"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 0,
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ #[test]
+ fn test_zero_window_fin() {
+ let mut s = socket_established();
+ s.rx_buffer = SocketBuffer::new(vec![0; 6]);
+ s.assembler = Assembler::new();
+ s.ack_delay = None;
+
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 0,
+ ..RECV_TEMPL
+ }]
+ );
+
+ // Even though the sequence space for the FIN itself is outside the window,
+ // it is not data, so FIN must be accepted when window full.
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 6,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &[],
+ control: TcpControl::Fin,
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::CloseWait);
+
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 7),
+ window_len: 0,
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_zero_window_ack_on_window_growth() {
+ let mut s = socket_established();
+ s.rx_buffer = SocketBuffer::new(vec![0; 6]);
+ s.assembler = Assembler::new();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 0,
+ ..RECV_TEMPL
+ }]
+ );
+ recv_nothing!(s, time 0);
+ s.recv(|buffer| {
+ assert_eq!(&buffer[..3], b"abc");
+ (3, ())
+ })
+ .unwrap();
+ recv!(s, time 0, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 3,
+ ..RECV_TEMPL
+ }));
+ recv_nothing!(s, time 0);
+ s.recv(|buffer| {
+ assert_eq!(buffer, b"def");
+ (buffer.len(), ())
+ })
+ .unwrap();
+ recv!(s, time 0, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 6,
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_fill_peer_window() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+ s.send_slice(b"abcdef123456!@#$%^").unwrap();
+ recv!(
+ s,
+ [
+ TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ },
+ TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"123456"[..],
+ ..RECV_TEMPL
+ },
+ TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"!@#$%^"[..],
+ ..RECV_TEMPL
+ }
+ ]
+ );
+ }
+
+ #[test]
+ fn test_announce_window_after_read() {
+ let mut s = socket_established();
+ s.rx_buffer = SocketBuffer::new(vec![0; 6]);
+ s.assembler = Assembler::new();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ window_len: 3,
+ ..RECV_TEMPL
+ }]
+ );
+ // Test that `dispatch` updates `remote_last_win`
+ assert_eq!(s.remote_last_win, s.rx_buffer.window() as u16);
+ s.recv(|buffer| (buffer.len(), ())).unwrap();
+ assert!(s.window_to_update());
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ window_len: 6,
+ ..RECV_TEMPL
+ }]
+ );
+ assert_eq!(s.remote_last_win, s.rx_buffer.window() as u16);
+ // Provoke immediate ACK to test that `process` updates `remote_last_win`
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 6,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"def"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ window_len: 6,
+ ..RECV_TEMPL
+ })
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 3,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 9),
+ window_len: 0,
+ ..RECV_TEMPL
+ })
+ );
+ assert_eq!(s.remote_last_win, s.rx_buffer.window() as u16);
+ s.recv(|buffer| (buffer.len(), ())).unwrap();
+ assert!(s.window_to_update());
+ }
+
+ // =========================================================================================//
+ // Tests for timeouts.
+ // =========================================================================================//
+
+ #[test]
+ fn test_listen_timeout() {
+ let mut s = socket_listen();
+ s.set_timeout(Some(Duration::from_millis(100)));
+ assert_eq!(s.socket.poll_at(&mut s.cx), PollAt::Ingress);
+ }
+
+ #[test]
+ fn test_connect_timeout() {
+ let mut s = socket();
+ s.local_seq_no = LOCAL_SEQ;
+ s.socket
+ .connect(&mut s.cx, REMOTE_END, LOCAL_END.port)
+ .unwrap();
+ s.set_timeout(Some(Duration::from_millis(100)));
+ recv!(s, time 150, Ok(TcpRepr {
+ control: TcpControl::Syn,
+ seq_number: LOCAL_SEQ,
+ ack_number: None,
+ max_seg_size: Some(BASE_MSS),
+ window_scale: Some(0),
+ sack_permitted: true,
+ ..RECV_TEMPL
+ }));
+ assert_eq!(s.state, State::SynSent);
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(250))
+ );
+ recv!(s, time 250, Ok(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(TcpSeqNumber(0)),
+ window_scale: None,
+ ..RECV_TEMPL
+ }));
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_established_timeout() {
+ let mut s = socket_established();
+ s.set_timeout(Some(Duration::from_millis(1000)));
+ recv_nothing!(s, time 250);
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(1250))
+ );
+ s.send_slice(b"abcdef").unwrap();
+ assert_eq!(s.socket.poll_at(&mut s.cx), PollAt::Now);
+ recv!(s, time 255, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }));
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(955))
+ );
+ recv!(s, time 955, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }));
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(1255))
+ );
+ recv!(s, time 1255, Ok(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }));
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_established_keep_alive_timeout() {
+ let mut s = socket_established();
+ s.set_keep_alive(Some(Duration::from_millis(50)));
+ s.set_timeout(Some(Duration::from_millis(100)));
+ recv!(s, time 100, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &[0],
+ ..RECV_TEMPL
+ }));
+ recv_nothing!(s, time 100);
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(150))
+ );
+ send!(s, time 105, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(155))
+ );
+ recv!(s, time 155, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &[0],
+ ..RECV_TEMPL
+ }));
+ recv_nothing!(s, time 155);
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(205))
+ );
+ recv_nothing!(s, time 200);
+ recv!(s, time 205, Ok(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }));
+ recv_nothing!(s, time 205);
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_fin_wait_1_timeout() {
+ let mut s = socket_fin_wait_1();
+ s.set_timeout(Some(Duration::from_millis(1000)));
+ recv!(s, time 100, Ok(TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1100, Ok(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }));
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_last_ack_timeout() {
+ let mut s = socket_last_ack();
+ s.set_timeout(Some(Duration::from_millis(1000)));
+ recv!(s, time 100, Ok(TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }));
+ recv!(s, time 1100, Ok(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 1 + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 1),
+ ..RECV_TEMPL
+ }));
+ assert_eq!(s.state, State::Closed);
+ }
+
+ #[test]
+ fn test_closed_timeout() {
+ let mut s = socket_established();
+ s.set_timeout(Some(Duration::from_millis(200)));
+ s.remote_last_ts = Some(Instant::from_millis(100));
+ s.abort();
+ assert_eq!(s.socket.poll_at(&mut s.cx), PollAt::Now);
+ recv!(s, time 100, Ok(TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ }));
+ assert_eq!(s.socket.poll_at(&mut s.cx), PollAt::Ingress);
+ }
+
+ // =========================================================================================//
+ // Tests for keep-alive.
+ // =========================================================================================//
+
+ #[test]
+ fn test_responds_to_keep_alive() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ #[test]
+ fn test_sends_keep_alive() {
+ let mut s = socket_established();
+ s.set_keep_alive(Some(Duration::from_millis(100)));
+
+ // drain the forced keep-alive packet
+ assert_eq!(s.socket.poll_at(&mut s.cx), PollAt::Now);
+ recv!(s, time 0, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &[0],
+ ..RECV_TEMPL
+ }));
+
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(100))
+ );
+ recv_nothing!(s, time 95);
+ recv!(s, time 100, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &[0],
+ ..RECV_TEMPL
+ }));
+
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(200))
+ );
+ recv_nothing!(s, time 195);
+ recv!(s, time 200, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &[0],
+ ..RECV_TEMPL
+ }));
+
+ send!(s, time 250, TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ });
+ assert_eq!(
+ s.socket.poll_at(&mut s.cx),
+ PollAt::Time(Instant::from_millis(350))
+ );
+ recv_nothing!(s, time 345);
+ recv!(s, time 350, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"\x00"[..],
+ ..RECV_TEMPL
+ }));
+ }
+
+ // =========================================================================================//
+ // Tests for time-to-live configuration.
+ // =========================================================================================//
+
+ #[test]
+ fn test_set_hop_limit() {
+ let mut s = socket_syn_received();
+
+ s.set_hop_limit(Some(0x2a));
+ assert_eq!(
+ s.socket.dispatch(&mut s.cx, |_, (ip_repr, _)| {
+ assert_eq!(ip_repr.hop_limit(), 0x2a);
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+
+ // assert that user-configurable settings are kept,
+ // see https://github.com/smoltcp-rs/smoltcp/issues/601.
+ s.reset();
+ assert_eq!(s.hop_limit(), Some(0x2a));
+ }
+
+ #[test]
+ #[should_panic(expected = "the time-to-live value of a packet must not be zero")]
+ fn test_set_hop_limit_zero() {
+ let mut s = socket_syn_received();
+ s.set_hop_limit(Some(0));
+ }
+
+ // =========================================================================================//
+ // Tests for reassembly.
+ // =========================================================================================//
+
+ #[test]
+ fn test_out_of_order() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 3,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"def"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ ..RECV_TEMPL
+ })
+ );
+ s.recv(|buffer| {
+ assert_eq!(buffer, b"");
+ (buffer.len(), ())
+ })
+ .unwrap();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 58,
+ ..RECV_TEMPL
+ })
+ );
+ s.recv(|buffer| {
+ assert_eq!(buffer, b"abcdef");
+ (buffer.len(), ())
+ })
+ .unwrap();
+ }
+
+ #[test]
+ fn test_buffer_wraparound_rx() {
+ let mut s = socket_established();
+ s.rx_buffer = SocketBuffer::new(vec![0; 6]);
+ s.assembler = Assembler::new();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ s.recv(|buffer| {
+ assert_eq!(buffer, b"abc");
+ (buffer.len(), ())
+ })
+ .unwrap();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 3,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"defghi"[..],
+ ..SEND_TEMPL
+ }
+ );
+ let mut data = [0; 6];
+ assert_eq!(s.recv_slice(&mut data[..]), Ok(6));
+ assert_eq!(data, &b"defghi"[..]);
+ }
+
+ #[test]
+ fn test_buffer_wraparound_tx() {
+ let mut s = socket_established();
+ s.set_nagle_enabled(false);
+
+ s.tx_buffer = SocketBuffer::new(vec![b'.'; 9]);
+ assert_eq!(s.send_slice(b"xxxyyy"), Ok(6));
+ assert_eq!(s.tx_buffer.dequeue_many(3), &b"xxx"[..]);
+ assert_eq!(s.tx_buffer.len(), 3);
+
+ // "abcdef" not contiguous in tx buffer
+ assert_eq!(s.send_slice(b"abcdef"), Ok(6));
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"yyyabc"[..],
+ ..RECV_TEMPL
+ })
+ );
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"def"[..],
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ // =========================================================================================//
+ // Tests for graceful vs ungraceful rx close
+ // =========================================================================================//
+
+ #[test]
+ fn test_rx_close_fin() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ assert_eq!(s.recv(|_| (0, ())), Err(RecvError::Finished));
+ }
+
+ #[test]
+ fn test_rx_close_fin_in_fin_wait_1() {
+ let mut s = socket_fin_wait_1();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::Closing);
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ assert_eq!(s.recv(|_| (0, ())), Err(RecvError::Finished));
+ }
+
+ #[test]
+ fn test_rx_close_fin_in_fin_wait_2() {
+ let mut s = socket_fin_wait_2();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ assert_eq!(s.state, State::TimeWait);
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ assert_eq!(s.recv(|_| (0, ())), Err(RecvError::Finished));
+ }
+
+ #[test]
+ fn test_rx_close_fin_with_hole() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: REMOTE_SEQ + 1 + 6,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"ghi"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ window_len: 61,
+ ..RECV_TEMPL
+ })
+ );
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ s.recv(|data| {
+ assert_eq!(data, b"");
+ (0, ())
+ })
+ .unwrap();
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ + 1 + 9,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ // Error must be `Illegal` even if we've received a FIN,
+ // because we are missing data.
+ assert_eq!(s.recv(|_| (0, ())), Err(RecvError::InvalidState));
+ }
+
+ #[test]
+ fn test_rx_close_rst() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ + 1 + 3,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ assert_eq!(s.recv(|_| (0, ())), Err(RecvError::InvalidState));
+ }
+
+ #[test]
+ fn test_rx_close_rst_with_hole() {
+ let mut s = socket_established();
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 6,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"ghi"[..],
+ ..SEND_TEMPL
+ },
+ Some(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ window_len: 61,
+ ..RECV_TEMPL
+ })
+ );
+ send!(
+ s,
+ TcpRepr {
+ control: TcpControl::Rst,
+ seq_number: REMOTE_SEQ + 1 + 9,
+ ack_number: Some(LOCAL_SEQ + 1),
+ ..SEND_TEMPL
+ }
+ );
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+ assert_eq!(s.recv(|_| (0, ())), Err(RecvError::InvalidState));
+ }
+
+ // =========================================================================================//
+ // Tests for delayed ACK
+ // =========================================================================================//
+
+ #[test]
+ fn test_delayed_ack() {
+ let mut s = socket_established();
+ s.set_ack_delay(Some(ACK_DELAY_DEFAULT));
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // No ACK is immediately sent.
+ recv_nothing!(s);
+
+ // After 10ms, it is sent.
+ recv!(s, time 11, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ window_len: 61,
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_delayed_ack_win() {
+ let mut s = socket_established();
+ s.set_ack_delay(Some(ACK_DELAY_DEFAULT));
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // Reading the data off the buffer should cause a window update.
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+
+ // However, no ACK or window update is immediately sent.
+ recv_nothing!(s);
+
+ // After 10ms, it is sent.
+ recv!(s, time 11, Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ ..RECV_TEMPL
+ }));
+ }
+
+ #[test]
+ fn test_delayed_ack_reply() {
+ let mut s = socket_established();
+ s.set_ack_delay(Some(ACK_DELAY_DEFAULT));
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ s.recv(|data| {
+ assert_eq!(data, b"abc");
+ (3, ())
+ })
+ .unwrap();
+
+ s.send_slice(&b"xyz"[..]).unwrap();
+
+ // Writing data to the socket causes ACK to not be delayed,
+ // because it is immediately sent with the data.
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 3),
+ payload: &b"xyz"[..],
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ #[test]
+ fn test_delayed_ack_every_second_packet() {
+ let mut s = socket_established();
+ s.set_ack_delay(Some(ACK_DELAY_DEFAULT));
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // No ACK is immediately sent.
+ recv_nothing!(s);
+
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 3,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"def"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // Every 2nd packet, ACK is sent without delay.
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 6),
+ window_len: 58,
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ #[test]
+ fn test_delayed_ack_three_packets() {
+ let mut s = socket_established();
+ s.set_ack_delay(Some(ACK_DELAY_DEFAULT));
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abc"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // No ACK is immediately sent.
+ recv_nothing!(s);
+
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 3,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"def"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1 + 6,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"ghi"[..],
+ ..SEND_TEMPL
+ }
+ );
+
+ // Every 2nd (or more) packet, ACK is sent without delay.
+ recv!(
+ s,
+ Ok(TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1 + 9),
+ window_len: 55,
+ ..RECV_TEMPL
+ })
+ );
+ }
+
+ // =========================================================================================//
+ // Tests for Nagle's Algorithm
+ // =========================================================================================//
+
+ #[test]
+ fn test_nagle() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+
+ s.send_slice(b"abcdef").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }]
+ );
+
+ // If there's data in flight, full segments get sent.
+ s.send_slice(b"foobar").unwrap();
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"foobar"[..],
+ ..RECV_TEMPL
+ }]
+ );
+
+ s.send_slice(b"aaabbbccc").unwrap();
+ // If there's data in flight, not-full segments don't get sent.
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"aaabbb"[..],
+ ..RECV_TEMPL
+ }]
+ );
+
+ // Data gets ACKd, so there's no longer data in flight
+ send!(
+ s,
+ TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1 + 6 + 6 + 6),
+ ..SEND_TEMPL
+ }
+ );
+
+ // Now non-full segment gets sent.
+ recv!(
+ s,
+ [TcpRepr {
+ seq_number: LOCAL_SEQ + 1 + 6 + 6 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"ccc"[..],
+ ..RECV_TEMPL
+ }]
+ );
+ }
+
+ #[test]
+ fn test_final_packet_in_stream_doesnt_wait_for_nagle() {
+ let mut s = socket_established();
+ s.remote_mss = 6;
+ s.send_slice(b"abcdef0").unwrap();
+ s.socket.close();
+
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::None,
+ seq_number: LOCAL_SEQ + 1,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..RECV_TEMPL
+ }), exact);
+ recv!(s, time 0, Ok(TcpRepr {
+ control: TcpControl::Fin,
+ seq_number: LOCAL_SEQ + 1 + 6,
+ ack_number: Some(REMOTE_SEQ + 1),
+ payload: &b"0"[..],
+ ..RECV_TEMPL
+ }), exact);
+ }
+
+ // =========================================================================================//
+ // Tests for packet filtering.
+ // =========================================================================================//
+
+ #[test]
+ fn test_doesnt_accept_wrong_port() {
+ let mut s = socket_established();
+ s.rx_buffer = SocketBuffer::new(vec![0; 6]);
+ s.assembler = Assembler::new();
+
+ let tcp_repr = TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ dst_port: LOCAL_PORT + 1,
+ ..SEND_TEMPL
+ };
+ assert!(!s.socket.accepts(&mut s.cx, &SEND_IP_TEMPL, &tcp_repr));
+
+ let tcp_repr = TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ src_port: REMOTE_PORT + 1,
+ ..SEND_TEMPL
+ };
+ assert!(!s.socket.accepts(&mut s.cx, &SEND_IP_TEMPL, &tcp_repr));
+ }
+
+ #[test]
+ fn test_doesnt_accept_wrong_ip() {
+ let mut s = socket_established();
+
+ let tcp_repr = TcpRepr {
+ seq_number: REMOTE_SEQ + 1,
+ ack_number: Some(LOCAL_SEQ + 1),
+ payload: &b"abcdef"[..],
+ ..SEND_TEMPL
+ };
+
+ let ip_repr = IpReprIpvX(IpvXRepr {
+ src_addr: REMOTE_ADDR,
+ dst_addr: LOCAL_ADDR,
+ next_header: IpProtocol::Tcp,
+ payload_len: tcp_repr.buffer_len(),
+ hop_limit: 64,
+ });
+ assert!(s.socket.accepts(&mut s.cx, &ip_repr, &tcp_repr));
+
+ let ip_repr_wrong_src = IpReprIpvX(IpvXRepr {
+ src_addr: OTHER_ADDR,
+ dst_addr: LOCAL_ADDR,
+ next_header: IpProtocol::Tcp,
+ payload_len: tcp_repr.buffer_len(),
+ hop_limit: 64,
+ });
+ assert!(!s.socket.accepts(&mut s.cx, &ip_repr_wrong_src, &tcp_repr));
+
+ let ip_repr_wrong_dst = IpReprIpvX(IpvXRepr {
+ src_addr: REMOTE_ADDR,
+ dst_addr: OTHER_ADDR,
+ next_header: IpProtocol::Tcp,
+ payload_len: tcp_repr.buffer_len(),
+ hop_limit: 64,
+ });
+ assert!(!s.socket.accepts(&mut s.cx, &ip_repr_wrong_dst, &tcp_repr));
+ }
+
+ // =========================================================================================//
+ // Timer tests
+ // =========================================================================================//
+
+ #[test]
+ fn test_timer_retransmit() {
+ const RTO: Duration = Duration::from_millis(100);
+ let mut r = Timer::new();
+ assert_eq!(r.should_retransmit(Instant::from_secs(1)), None);
+ r.set_for_retransmit(Instant::from_millis(1000), RTO);
+ assert_eq!(r.should_retransmit(Instant::from_millis(1000)), None);
+ assert_eq!(r.should_retransmit(Instant::from_millis(1050)), None);
+ assert_eq!(
+ r.should_retransmit(Instant::from_millis(1101)),
+ Some(Duration::from_millis(101))
+ );
+ r.set_for_retransmit(Instant::from_millis(1101), RTO);
+ assert_eq!(r.should_retransmit(Instant::from_millis(1101)), None);
+ assert_eq!(r.should_retransmit(Instant::from_millis(1150)), None);
+ assert_eq!(r.should_retransmit(Instant::from_millis(1200)), None);
+ assert_eq!(
+ r.should_retransmit(Instant::from_millis(1301)),
+ Some(Duration::from_millis(300))
+ );
+ r.set_for_idle(Instant::from_millis(1301), None);
+ assert_eq!(r.should_retransmit(Instant::from_millis(1350)), None);
+ }
+
+ #[test]
+ fn test_rtt_estimator() {
+ let mut r = RttEstimator::default();
+
+ let rtos = &[
+ 751, 766, 755, 731, 697, 656, 613, 567, 523, 484, 445, 411, 378, 350, 322, 299, 280,
+ 261, 243, 229, 215, 206, 197, 188,
+ ];
+
+ for &rto in rtos {
+ r.sample(100);
+ assert_eq!(r.retransmission_timeout(), Duration::from_millis(rto));
+ }
+ }
+}
diff --git a/src/socket/udp.rs b/src/socket/udp.rs
new file mode 100644
index 0000000..82eebf2
--- /dev/null
+++ b/src/socket/udp.rs
@@ -0,0 +1,1030 @@
+use core::cmp::min;
+#[cfg(feature = "async")]
+use core::task::Waker;
+
+use crate::iface::Context;
+use crate::phy::PacketMeta;
+use crate::socket::PollAt;
+#[cfg(feature = "async")]
+use crate::socket::WakerRegistration;
+use crate::storage::Empty;
+use crate::wire::{IpEndpoint, IpListenEndpoint, IpProtocol, IpRepr, UdpRepr};
+
+/// Metadata for a sent or received UDP packet.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct UdpMetadata {
+ pub endpoint: IpEndpoint,
+ pub meta: PacketMeta,
+}
+
+impl<T: Into<IpEndpoint>> From<T> for UdpMetadata {
+ fn from(value: T) -> Self {
+ Self {
+ endpoint: value.into(),
+ meta: PacketMeta::default(),
+ }
+ }
+}
+
+impl core::fmt::Display for UdpMetadata {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ #[cfg(feature = "packetmeta-id")]
+ return write!(f, "{}, PacketID: {:?}", self.endpoint, self.meta);
+
+ #[cfg(not(feature = "packetmeta-id"))]
+ write!(f, "{}", self.endpoint)
+ }
+}
+
+/// A UDP packet metadata.
+pub type PacketMetadata = crate::storage::PacketMetadata<UdpMetadata>;
+
+/// A UDP packet ring buffer.
+pub type PacketBuffer<'a> = crate::storage::PacketBuffer<'a, UdpMetadata>;
+
+/// Error returned by [`Socket::bind`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum BindError {
+ InvalidState,
+ Unaddressable,
+}
+
+impl core::fmt::Display for BindError {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ BindError::InvalidState => write!(f, "invalid state"),
+ BindError::Unaddressable => write!(f, "unaddressable"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BindError {}
+
+/// Error returned by [`Socket::send`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SendError {
+ Unaddressable,
+ BufferFull,
+}
+
+impl core::fmt::Display for SendError {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ SendError::Unaddressable => write!(f, "unaddressable"),
+ SendError::BufferFull => write!(f, "buffer full"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SendError {}
+
+/// Error returned by [`Socket::recv`]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RecvError {
+ Exhausted,
+ Truncated,
+}
+
+impl core::fmt::Display for RecvError {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ RecvError::Exhausted => write!(f, "exhausted"),
+ RecvError::Truncated => write!(f, "truncated"),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RecvError {}
+
+/// A User Datagram Protocol socket.
+///
+/// A UDP socket is bound to a specific endpoint, and owns transmit and receive
+/// packet buffers.
+#[derive(Debug)]
+pub struct Socket<'a> {
+ endpoint: IpListenEndpoint,
+ rx_buffer: PacketBuffer<'a>,
+ tx_buffer: PacketBuffer<'a>,
+ /// The time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ hop_limit: Option<u8>,
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration,
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration,
+}
+
+impl<'a> Socket<'a> {
+ /// Create an UDP socket with the given buffers.
+ pub fn new(rx_buffer: PacketBuffer<'a>, tx_buffer: PacketBuffer<'a>) -> Socket<'a> {
+ Socket {
+ endpoint: IpListenEndpoint::default(),
+ rx_buffer,
+ tx_buffer,
+ hop_limit: None,
+ #[cfg(feature = "async")]
+ rx_waker: WakerRegistration::new(),
+ #[cfg(feature = "async")]
+ tx_waker: WakerRegistration::new(),
+ }
+ }
+
+ /// Register a waker for receive operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `recv` method calls, such as receiving data, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `recv` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_recv_waker(&mut self, waker: &Waker) {
+ self.rx_waker.register(waker)
+ }
+
+ /// Register a waker for send operations.
+ ///
+ /// The waker is woken on state changes that might affect the return value
+ /// of `send` method calls, such as space becoming available in the transmit
+ /// buffer, or the socket closing.
+ ///
+ /// Notes:
+ ///
+ /// - Only one waker can be registered at a time. If another waker was previously registered,
+ /// it is overwritten and will no longer be woken.
+ /// - The Waker is woken only once. Once woken, you must register it again to receive more wakes.
+ /// - "Spurious wakes" are allowed: a wake doesn't guarantee the result of `send` has
+ /// necessarily changed.
+ #[cfg(feature = "async")]
+ pub fn register_send_waker(&mut self, waker: &Waker) {
+ self.tx_waker.register(waker)
+ }
+
+ /// Return the bound endpoint.
+ #[inline]
+ pub fn endpoint(&self) -> IpListenEndpoint {
+ self.endpoint
+ }
+
+ /// Return the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// See also the [set_hop_limit](#method.set_hop_limit) method
+ pub fn hop_limit(&self) -> Option<u8> {
+ self.hop_limit
+ }
+
+ /// Set the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.
+ ///
+ /// A socket without an explicitly set hop limit value uses the default [IANA recommended]
+ /// value (64).
+ ///
+ /// # Panics
+ ///
+ /// This function panics if a hop limit value of 0 is given. See [RFC 1122 § 3.2.1.7].
+ ///
+ /// [IANA recommended]: https://www.iana.org/assignments/ip-parameters/ip-parameters.xhtml
+ /// [RFC 1122 § 3.2.1.7]: https://tools.ietf.org/html/rfc1122#section-3.2.1.7
+ pub fn set_hop_limit(&mut self, hop_limit: Option<u8>) {
+ // A host MUST NOT send a datagram with a hop limit value of 0
+ if let Some(0) = hop_limit {
+ panic!("the time-to-live value of a packet must not be zero")
+ }
+
+ self.hop_limit = hop_limit
+ }
+
+ /// Bind the socket to the given endpoint.
+ ///
+ /// This function returns `Err(Error::Illegal)` if the socket was open
+ /// (see [is_open](#method.is_open)), and `Err(Error::Unaddressable)`
+ /// if the port in the given endpoint is zero.
+ pub fn bind<T: Into<IpListenEndpoint>>(&mut self, endpoint: T) -> Result<(), BindError> {
+ let endpoint = endpoint.into();
+ if endpoint.port == 0 {
+ return Err(BindError::Unaddressable);
+ }
+
+ if self.is_open() {
+ return Err(BindError::InvalidState);
+ }
+
+ self.endpoint = endpoint;
+
+ #[cfg(feature = "async")]
+ {
+ self.rx_waker.wake();
+ self.tx_waker.wake();
+ }
+
+ Ok(())
+ }
+
+ /// Close the socket.
+ pub fn close(&mut self) {
+ // Clear the bound endpoint of the socket.
+ self.endpoint = IpListenEndpoint::default();
+
+ // Reset the RX and TX buffers of the socket.
+ self.tx_buffer.reset();
+ self.rx_buffer.reset();
+
+ #[cfg(feature = "async")]
+ {
+ self.rx_waker.wake();
+ self.tx_waker.wake();
+ }
+ }
+
+ /// Check whether the socket is open.
+ #[inline]
+ pub fn is_open(&self) -> bool {
+ self.endpoint.port != 0
+ }
+
+ /// Check whether the transmit buffer is full.
+ #[inline]
+ pub fn can_send(&self) -> bool {
+ !self.tx_buffer.is_full()
+ }
+
+ /// Check whether the receive buffer is not empty.
+ #[inline]
+ pub fn can_recv(&self) -> bool {
+ !self.rx_buffer.is_empty()
+ }
+
+ /// Return the maximum number packets the socket can receive.
+ #[inline]
+ pub fn packet_recv_capacity(&self) -> usize {
+ self.rx_buffer.packet_capacity()
+ }
+
+ /// Return the maximum number packets the socket can transmit.
+ #[inline]
+ pub fn packet_send_capacity(&self) -> usize {
+ self.tx_buffer.packet_capacity()
+ }
+
+ /// Return the maximum number of bytes inside the recv buffer.
+ #[inline]
+ pub fn payload_recv_capacity(&self) -> usize {
+ self.rx_buffer.payload_capacity()
+ }
+
+ /// Return the maximum number of bytes inside the transmit buffer.
+ #[inline]
+ pub fn payload_send_capacity(&self) -> usize {
+ self.tx_buffer.payload_capacity()
+ }
+
+ /// Enqueue a packet to be sent to a given remote endpoint, and return a pointer
+ /// to its payload.
+ ///
+ /// This function returns `Err(Error::Exhausted)` if the transmit buffer is full,
+ /// `Err(Error::Unaddressable)` if local or remote port, or remote address are unspecified,
+ /// and `Err(Error::Truncated)` if there is not enough transmit buffer capacity
+ /// to ever send this packet.
+ pub fn send(
+ &mut self,
+ size: usize,
+ meta: impl Into<UdpMetadata>,
+ ) -> Result<&mut [u8], SendError> {
+ let meta = meta.into();
+ if self.endpoint.port == 0 {
+ return Err(SendError::Unaddressable);
+ }
+ if meta.endpoint.addr.is_unspecified() {
+ return Err(SendError::Unaddressable);
+ }
+ if meta.endpoint.port == 0 {
+ return Err(SendError::Unaddressable);
+ }
+
+ let payload_buf = self
+ .tx_buffer
+ .enqueue(size, meta)
+ .map_err(|_| SendError::BufferFull)?;
+
+ net_trace!(
+ "udp:{}:{}: buffer to send {} octets",
+ self.endpoint,
+ meta.endpoint,
+ size
+ );
+ Ok(payload_buf)
+ }
+
+ /// Enqueue a packet to be send to a given remote endpoint and pass the buffer
+ /// to the provided closure. The closure then returns the size of the data written
+ /// into the buffer.
+ ///
+ /// Also see [send](#method.send).
+ pub fn send_with<F>(
+ &mut self,
+ max_size: usize,
+ meta: impl Into<UdpMetadata>,
+ f: F,
+ ) -> Result<usize, SendError>
+ where
+ F: FnOnce(&mut [u8]) -> usize,
+ {
+ let meta = meta.into();
+ if self.endpoint.port == 0 {
+ return Err(SendError::Unaddressable);
+ }
+ if meta.endpoint.addr.is_unspecified() {
+ return Err(SendError::Unaddressable);
+ }
+ if meta.endpoint.port == 0 {
+ return Err(SendError::Unaddressable);
+ }
+
+ let size = self
+ .tx_buffer
+ .enqueue_with_infallible(max_size, meta, f)
+ .map_err(|_| SendError::BufferFull)?;
+
+ net_trace!(
+ "udp:{}:{}: buffer to send {} octets",
+ self.endpoint,
+ meta.endpoint,
+ size
+ );
+ Ok(size)
+ }
+
+ /// Enqueue a packet to be sent to a given remote endpoint, and fill it from a slice.
+ ///
+ /// See also [send](#method.send).
+ pub fn send_slice(
+ &mut self,
+ data: &[u8],
+ meta: impl Into<UdpMetadata>,
+ ) -> Result<(), SendError> {
+ self.send(data.len(), meta)?.copy_from_slice(data);
+ Ok(())
+ }
+
+ /// Dequeue a packet received from a remote endpoint, and return the endpoint as well
+ /// as a pointer to the payload.
+ ///
+ /// This function returns `Err(Error::Exhausted)` if the receive buffer is empty.
+ pub fn recv(&mut self) -> Result<(&[u8], UdpMetadata), RecvError> {
+ let (remote_endpoint, payload_buf) =
+ self.rx_buffer.dequeue().map_err(|_| RecvError::Exhausted)?;
+
+ net_trace!(
+ "udp:{}:{}: receive {} buffered octets",
+ self.endpoint,
+ remote_endpoint.endpoint,
+ payload_buf.len()
+ );
+ Ok((payload_buf, remote_endpoint))
+ }
+
+ /// Dequeue a packet received from a remote endpoint, copy the payload into the given slice,
+ /// and return the amount of octets copied as well as the endpoint.
+ ///
+ /// **Note**: when the size of the provided buffer is smaller than the size of the payload,
+ /// the packet is dropped and a `RecvError::Truncated` error is returned.
+ ///
+ /// See also [recv](#method.recv).
+ pub fn recv_slice(&mut self, data: &mut [u8]) -> Result<(usize, UdpMetadata), RecvError> {
+ let (buffer, endpoint) = self.recv().map_err(|_| RecvError::Exhausted)?;
+
+ if data.len() < buffer.len() {
+ return Err(RecvError::Truncated);
+ }
+
+ let length = min(data.len(), buffer.len());
+ data[..length].copy_from_slice(&buffer[..length]);
+ Ok((length, endpoint))
+ }
+
+ /// Peek at a packet received from a remote endpoint, and return the endpoint as well
+ /// as a pointer to the payload without removing the packet from the receive buffer.
+ /// This function otherwise behaves identically to [recv](#method.recv).
+ ///
+ /// It returns `Err(Error::Exhausted)` if the receive buffer is empty.
+ pub fn peek(&mut self) -> Result<(&[u8], &UdpMetadata), RecvError> {
+ let endpoint = self.endpoint;
+ self.rx_buffer.peek().map_err(|_| RecvError::Exhausted).map(
+ |(remote_endpoint, payload_buf)| {
+ net_trace!(
+ "udp:{}:{}: peek {} buffered octets",
+ endpoint,
+ remote_endpoint.endpoint,
+ payload_buf.len()
+ );
+ (payload_buf, remote_endpoint)
+ },
+ )
+ }
+
+ /// Peek at a packet received from a remote endpoint, copy the payload into the given slice,
+ /// and return the amount of octets copied as well as the endpoint without removing the
+ /// packet from the receive buffer.
+ /// This function otherwise behaves identically to [recv_slice](#method.recv_slice).
+ ///
+ /// **Note**: when the size of the provided buffer is smaller than the size of the payload,
+ /// no data is copied into the provided buffer and a `RecvError::Truncated` error is returned.
+ ///
+ /// See also [peek](#method.peek).
+ pub fn peek_slice(&mut self, data: &mut [u8]) -> Result<(usize, &UdpMetadata), RecvError> {
+ let (buffer, endpoint) = self.peek()?;
+
+ if data.len() < buffer.len() {
+ return Err(RecvError::Truncated);
+ }
+
+ let length = min(data.len(), buffer.len());
+ data[..length].copy_from_slice(&buffer[..length]);
+ Ok((length, endpoint))
+ }
+
+ pub(crate) fn accepts(&self, cx: &mut Context, ip_repr: &IpRepr, repr: &UdpRepr) -> bool {
+ if self.endpoint.port != repr.dst_port {
+ return false;
+ }
+ if self.endpoint.addr.is_some()
+ && self.endpoint.addr != Some(ip_repr.dst_addr())
+ && !cx.is_broadcast(&ip_repr.dst_addr())
+ && !ip_repr.dst_addr().is_multicast()
+ {
+ return false;
+ }
+
+ true
+ }
+
+ pub(crate) fn process(
+ &mut self,
+ cx: &mut Context,
+ meta: PacketMeta,
+ ip_repr: &IpRepr,
+ repr: &UdpRepr,
+ payload: &[u8],
+ ) {
+ debug_assert!(self.accepts(cx, ip_repr, repr));
+
+ let size = payload.len();
+
+ let remote_endpoint = IpEndpoint {
+ addr: ip_repr.src_addr(),
+ port: repr.src_port,
+ };
+
+ net_trace!(
+ "udp:{}:{}: receiving {} octets",
+ self.endpoint,
+ remote_endpoint,
+ size
+ );
+
+ let metadata = UdpMetadata {
+ endpoint: remote_endpoint,
+ meta,
+ };
+
+ match self.rx_buffer.enqueue(size, metadata) {
+ Ok(buf) => buf.copy_from_slice(payload),
+ Err(_) => net_trace!(
+ "udp:{}:{}: buffer full, dropped incoming packet",
+ self.endpoint,
+ remote_endpoint
+ ),
+ }
+
+ #[cfg(feature = "async")]
+ self.rx_waker.wake();
+ }
+
+ pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+ where
+ F: FnOnce(&mut Context, PacketMeta, (IpRepr, UdpRepr, &[u8])) -> Result<(), E>,
+ {
+ let endpoint = self.endpoint;
+ let hop_limit = self.hop_limit.unwrap_or(64);
+
+ let res = self.tx_buffer.dequeue_with(|packet_meta, payload_buf| {
+ let src_addr = match endpoint.addr {
+ Some(addr) => addr,
+ None => match cx.get_source_address(&packet_meta.endpoint.addr) {
+ Some(addr) => addr,
+ None => {
+ net_trace!(
+ "udp:{}:{}: cannot find suitable source address, dropping.",
+ endpoint,
+ packet_meta.endpoint
+ );
+ return Ok(());
+ }
+ },
+ };
+
+ net_trace!(
+ "udp:{}:{}: sending {} octets",
+ endpoint,
+ packet_meta.endpoint,
+ payload_buf.len()
+ );
+
+ let repr = UdpRepr {
+ src_port: endpoint.port,
+ dst_port: packet_meta.endpoint.port,
+ };
+ let ip_repr = IpRepr::new(
+ src_addr,
+ packet_meta.endpoint.addr,
+ IpProtocol::Udp,
+ repr.header_len() + payload_buf.len(),
+ hop_limit,
+ );
+
+ emit(cx, packet_meta.meta, (ip_repr, repr, payload_buf))
+ });
+ match res {
+ Err(Empty) => Ok(()),
+ Ok(Err(e)) => Err(e),
+ Ok(Ok(())) => {
+ #[cfg(feature = "async")]
+ self.tx_waker.wake();
+ Ok(())
+ }
+ }
+ }
+
+ pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+ if self.tx_buffer.is_empty() {
+ PollAt::Ingress
+ } else {
+ PollAt::Now
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::wire::{IpRepr, UdpRepr};
+
+ use crate::phy::Medium;
+ use crate::tests::setup;
+ use rstest::*;
+
+ fn buffer(packets: usize) -> PacketBuffer<'static> {
+ PacketBuffer::new(
+ (0..packets)
+ .map(|_| PacketMetadata::EMPTY)
+ .collect::<Vec<_>>(),
+ vec![0; 16 * packets],
+ )
+ }
+
+ fn socket(
+ rx_buffer: PacketBuffer<'static>,
+ tx_buffer: PacketBuffer<'static>,
+ ) -> Socket<'static> {
+ Socket::new(rx_buffer, tx_buffer)
+ }
+
+ const LOCAL_PORT: u16 = 53;
+ const REMOTE_PORT: u16 = 49500;
+
+ cfg_if::cfg_if! {
+ if #[cfg(feature = "proto-ipv4")] {
+ use crate::wire::Ipv4Address as IpvXAddress;
+ use crate::wire::Ipv4Repr as IpvXRepr;
+ use IpRepr::Ipv4 as IpReprIpvX;
+
+ const LOCAL_ADDR: IpvXAddress = IpvXAddress([192, 168, 1, 1]);
+ const REMOTE_ADDR: IpvXAddress = IpvXAddress([192, 168, 1, 2]);
+ const OTHER_ADDR: IpvXAddress = IpvXAddress([192, 168, 1, 3]);
+ } else {
+ use crate::wire::Ipv6Address as IpvXAddress;
+ use crate::wire::Ipv6Repr as IpvXRepr;
+ use IpRepr::Ipv6 as IpReprIpvX;
+
+ const LOCAL_ADDR: IpvXAddress = IpvXAddress([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+ ]);
+ const REMOTE_ADDR: IpvXAddress = IpvXAddress([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
+ ]);
+ const OTHER_ADDR: IpvXAddress = IpvXAddress([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
+ ]);
+ }
+ }
+
+ pub const LOCAL_END: IpEndpoint = IpEndpoint {
+ addr: LOCAL_ADDR.into_address(),
+ port: LOCAL_PORT,
+ };
+ pub const REMOTE_END: IpEndpoint = IpEndpoint {
+ addr: REMOTE_ADDR.into_address(),
+ port: REMOTE_PORT,
+ };
+
+ pub const LOCAL_IP_REPR: IpRepr = IpReprIpvX(IpvXRepr {
+ src_addr: LOCAL_ADDR,
+ dst_addr: REMOTE_ADDR,
+ next_header: IpProtocol::Udp,
+ payload_len: 8 + 6,
+ hop_limit: 64,
+ });
+
+ pub const REMOTE_IP_REPR: IpRepr = IpReprIpvX(IpvXRepr {
+ src_addr: REMOTE_ADDR,
+ dst_addr: LOCAL_ADDR,
+ next_header: IpProtocol::Udp,
+ payload_len: 8 + 6,
+ hop_limit: 64,
+ });
+
+ pub const BAD_IP_REPR: IpRepr = IpReprIpvX(IpvXRepr {
+ src_addr: REMOTE_ADDR,
+ dst_addr: OTHER_ADDR,
+ next_header: IpProtocol::Udp,
+ payload_len: 8 + 6,
+ hop_limit: 64,
+ });
+
+ const LOCAL_UDP_REPR: UdpRepr = UdpRepr {
+ src_port: LOCAL_PORT,
+ dst_port: REMOTE_PORT,
+ };
+
+ const REMOTE_UDP_REPR: UdpRepr = UdpRepr {
+ src_port: REMOTE_PORT,
+ dst_port: LOCAL_PORT,
+ };
+
+ const PAYLOAD: &[u8] = b"abcdef";
+
+ #[test]
+ fn test_bind_unaddressable() {
+ let mut socket = socket(buffer(0), buffer(0));
+ assert_eq!(socket.bind(0), Err(BindError::Unaddressable));
+ }
+
+ #[test]
+ fn test_bind_twice() {
+ let mut socket = socket(buffer(0), buffer(0));
+ assert_eq!(socket.bind(1), Ok(()));
+ assert_eq!(socket.bind(2), Err(BindError::InvalidState));
+ }
+
+ #[test]
+ #[should_panic(expected = "the time-to-live value of a packet must not be zero")]
+ fn test_set_hop_limit_zero() {
+ let mut s = socket(buffer(0), buffer(1));
+ s.set_hop_limit(Some(0));
+ }
+
+ #[test]
+ fn test_send_unaddressable() {
+ let mut socket = socket(buffer(0), buffer(1));
+
+ assert_eq!(
+ socket.send_slice(b"abcdef", REMOTE_END),
+ Err(SendError::Unaddressable)
+ );
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+ assert_eq!(
+ socket.send_slice(
+ b"abcdef",
+ IpEndpoint {
+ addr: IpvXAddress::UNSPECIFIED.into(),
+ ..REMOTE_END
+ }
+ ),
+ Err(SendError::Unaddressable)
+ );
+ assert_eq!(
+ socket.send_slice(
+ b"abcdef",
+ IpEndpoint {
+ port: 0,
+ ..REMOTE_END
+ }
+ ),
+ Err(SendError::Unaddressable)
+ );
+ assert_eq!(socket.send_slice(b"abcdef", REMOTE_END), Ok(()));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_send_dispatch(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+ let mut socket = socket(buffer(0), buffer(1));
+
+ assert_eq!(socket.bind(LOCAL_END), Ok(()));
+
+ assert!(socket.can_send());
+ assert_eq!(
+ socket.dispatch(cx, |_, _, _| unreachable!()),
+ Ok::<_, ()>(())
+ );
+
+ assert_eq!(socket.send_slice(b"abcdef", REMOTE_END), Ok(()));
+ assert_eq!(
+ socket.send_slice(b"123456", REMOTE_END),
+ Err(SendError::BufferFull)
+ );
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(cx, |_, _, (ip_repr, udp_repr, payload)| {
+ assert_eq!(ip_repr, LOCAL_IP_REPR);
+ assert_eq!(udp_repr, LOCAL_UDP_REPR);
+ assert_eq!(payload, PAYLOAD);
+ Err(())
+ }),
+ Err(())
+ );
+ assert!(!socket.can_send());
+
+ assert_eq!(
+ socket.dispatch(cx, |_, _, (ip_repr, udp_repr, payload)| {
+ assert_eq!(ip_repr, LOCAL_IP_REPR);
+ assert_eq!(udp_repr, LOCAL_UDP_REPR);
+ assert_eq!(payload, PAYLOAD);
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+ assert!(socket.can_send());
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_recv_process(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(0));
+
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+
+ assert!(!socket.can_recv());
+ assert_eq!(socket.recv(), Err(RecvError::Exhausted));
+
+ assert!(socket.accepts(cx, &REMOTE_IP_REPR, &REMOTE_UDP_REPR));
+ socket.process(
+ cx,
+ PacketMeta::default(),
+ &REMOTE_IP_REPR,
+ &REMOTE_UDP_REPR,
+ PAYLOAD,
+ );
+ assert!(socket.can_recv());
+
+ assert!(socket.accepts(cx, &REMOTE_IP_REPR, &REMOTE_UDP_REPR));
+ socket.process(
+ cx,
+ PacketMeta::default(),
+ &REMOTE_IP_REPR,
+ &REMOTE_UDP_REPR,
+ PAYLOAD,
+ );
+
+ assert_eq!(socket.recv(), Ok((&b"abcdef"[..], REMOTE_END.into())));
+ assert!(!socket.can_recv());
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_peek_process(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(0));
+
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+
+ assert_eq!(socket.peek(), Err(RecvError::Exhausted));
+
+ socket.process(
+ cx,
+ PacketMeta::default(),
+ &REMOTE_IP_REPR,
+ &REMOTE_UDP_REPR,
+ PAYLOAD,
+ );
+ assert_eq!(socket.peek(), Ok((&b"abcdef"[..], &REMOTE_END.into(),)));
+ assert_eq!(socket.recv(), Ok((&b"abcdef"[..], REMOTE_END.into(),)));
+ assert_eq!(socket.peek(), Err(RecvError::Exhausted));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_recv_truncated_slice(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(0));
+
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+
+ assert!(socket.accepts(cx, &REMOTE_IP_REPR, &REMOTE_UDP_REPR));
+ socket.process(
+ cx,
+ PacketMeta::default(),
+ &REMOTE_IP_REPR,
+ &REMOTE_UDP_REPR,
+ PAYLOAD,
+ );
+
+ let mut slice = [0; 4];
+ assert_eq!(socket.recv_slice(&mut slice[..]), Err(RecvError::Truncated));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_peek_truncated_slice(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(0));
+
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+
+ socket.process(
+ cx,
+ PacketMeta::default(),
+ &REMOTE_IP_REPR,
+ &REMOTE_UDP_REPR,
+ PAYLOAD,
+ );
+
+ let mut slice = [0; 4];
+ assert_eq!(socket.peek_slice(&mut slice[..]), Err(RecvError::Truncated));
+ assert_eq!(socket.recv_slice(&mut slice[..]), Err(RecvError::Truncated));
+ assert_eq!(socket.peek_slice(&mut slice[..]), Err(RecvError::Exhausted));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_set_hop_limit(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut s = socket(buffer(0), buffer(1));
+
+ assert_eq!(s.bind(LOCAL_END), Ok(()));
+
+ s.set_hop_limit(Some(0x2a));
+ assert_eq!(s.send_slice(b"abcdef", REMOTE_END), Ok(()));
+ assert_eq!(
+ s.dispatch(cx, |_, _, (ip_repr, _, _)| {
+ assert_eq!(
+ ip_repr,
+ IpReprIpvX(IpvXRepr {
+ src_addr: LOCAL_ADDR,
+ dst_addr: REMOTE_ADDR,
+ next_header: IpProtocol::Udp,
+ payload_len: 8 + 6,
+ hop_limit: 0x2a,
+ })
+ );
+ Ok::<_, ()>(())
+ }),
+ Ok(())
+ );
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_doesnt_accept_wrong_port(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut socket = socket(buffer(1), buffer(0));
+
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+
+ let mut udp_repr = REMOTE_UDP_REPR;
+ assert!(socket.accepts(cx, &REMOTE_IP_REPR, &udp_repr));
+ udp_repr.dst_port += 1;
+ assert!(!socket.accepts(cx, &REMOTE_IP_REPR, &udp_repr));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_doesnt_accept_wrong_ip(#[case] medium: Medium) {
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ let mut port_bound_socket = socket(buffer(1), buffer(0));
+ assert_eq!(port_bound_socket.bind(LOCAL_PORT), Ok(()));
+ assert!(port_bound_socket.accepts(cx, &BAD_IP_REPR, &REMOTE_UDP_REPR));
+
+ let mut ip_bound_socket = socket(buffer(1), buffer(0));
+ assert_eq!(ip_bound_socket.bind(LOCAL_END), Ok(()));
+ assert!(!ip_bound_socket.accepts(cx, &BAD_IP_REPR, &REMOTE_UDP_REPR));
+ }
+
+ #[test]
+ fn test_send_large_packet() {
+ // buffer(4) creates a payload buffer of size 16*4
+ let mut socket = socket(buffer(0), buffer(4));
+ assert_eq!(socket.bind(LOCAL_END), Ok(()));
+
+ let too_large = b"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdefx";
+ assert_eq!(
+ socket.send_slice(too_large, REMOTE_END),
+ Err(SendError::BufferFull)
+ );
+ assert_eq!(socket.send_slice(&too_large[..16 * 4], REMOTE_END), Ok(()));
+ }
+
+ #[rstest]
+ #[case::ip(Medium::Ip)]
+ #[cfg(feature = "medium-ip")]
+ #[case::ethernet(Medium::Ethernet)]
+ #[cfg(feature = "medium-ethernet")]
+ #[case::ieee802154(Medium::Ieee802154)]
+ #[cfg(feature = "medium-ieee802154")]
+ fn test_process_empty_payload(#[case] medium: Medium) {
+ let meta = Box::leak(Box::new([PacketMetadata::EMPTY]));
+ let recv_buffer = PacketBuffer::new(&mut meta[..], vec![]);
+ let mut socket = socket(recv_buffer, buffer(0));
+
+ let (mut iface, _, _) = setup(medium);
+ let cx = iface.context();
+
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+
+ let repr = UdpRepr {
+ src_port: REMOTE_PORT,
+ dst_port: LOCAL_PORT,
+ };
+ socket.process(cx, PacketMeta::default(), &REMOTE_IP_REPR, &repr, &[]);
+ assert_eq!(socket.recv(), Ok((&[][..], REMOTE_END.into())));
+ }
+
+ #[test]
+ fn test_closing() {
+ let meta = Box::leak(Box::new([PacketMetadata::EMPTY]));
+ let recv_buffer = PacketBuffer::new(&mut meta[..], vec![]);
+ let mut socket = socket(recv_buffer, buffer(0));
+ assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
+
+ assert!(socket.is_open());
+ socket.close();
+ assert!(!socket.is_open());
+ }
+}
diff --git a/src/socket/waker.rs b/src/socket/waker.rs
new file mode 100644
index 0000000..4f42197
--- /dev/null
+++ b/src/socket/waker.rs
@@ -0,0 +1,33 @@
+use core::task::Waker;
+
+/// Utility struct to register and wake a waker.
+#[derive(Debug)]
+pub struct WakerRegistration {
+ waker: Option<Waker>,
+}
+
+impl WakerRegistration {
+ pub const fn new() -> Self {
+ Self { waker: None }
+ }
+
+ /// Register a waker. Overwrites the previous waker, if any.
+ pub fn register(&mut self, w: &Waker) {
+ match self.waker {
+ // Optimization: If both the old and new Wakers wake the same task, we can simply
+ // keep the old waker, skipping the clone. (In most executor implementations,
+ // cloning a waker is somewhat expensive, comparable to cloning an Arc).
+ Some(ref w2) if (w2.will_wake(w)) => {}
+ // In all other cases
+ // - we have no waker registered
+ // - we have a waker registered but it's for a different task.
+ // then clone the new waker and store it
+ _ => self.waker = Some(w.clone()),
+ }
+ }
+
+ /// Wake the registered waker, if any.
+ pub fn wake(&mut self) {
+ self.waker.take().map(|w| w.wake());
+ }
+}
diff --git a/src/storage/assembler.rs b/src/storage/assembler.rs
new file mode 100644
index 0000000..365a1e0
--- /dev/null
+++ b/src/storage/assembler.rs
@@ -0,0 +1,750 @@
+use core::fmt;
+
+use crate::config::ASSEMBLER_MAX_SEGMENT_COUNT;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TooManyHolesError;
+
+impl fmt::Display for TooManyHolesError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "too many holes")
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TooManyHolesError {}
+
+/// A contiguous chunk of absent data, followed by a contiguous chunk of present data.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct Contig {
+ hole_size: usize,
+ data_size: usize,
+}
+
+impl fmt::Display for Contig {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ if self.has_hole() {
+ write!(f, "({})", self.hole_size)?;
+ }
+ if self.has_hole() && self.has_data() {
+ write!(f, " ")?;
+ }
+ if self.has_data() {
+ write!(f, "{}", self.data_size)?;
+ }
+ Ok(())
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Contig {
+ fn format(&self, fmt: defmt::Formatter) {
+ if self.has_hole() {
+ defmt::write!(fmt, "({})", self.hole_size);
+ }
+ if self.has_hole() && self.has_data() {
+ defmt::write!(fmt, " ");
+ }
+ if self.has_data() {
+ defmt::write!(fmt, "{}", self.data_size);
+ }
+ }
+}
+
+impl Contig {
+ const fn empty() -> Contig {
+ Contig {
+ hole_size: 0,
+ data_size: 0,
+ }
+ }
+
+ fn hole_and_data(hole_size: usize, data_size: usize) -> Contig {
+ Contig {
+ hole_size,
+ data_size,
+ }
+ }
+
+ fn has_hole(&self) -> bool {
+ self.hole_size != 0
+ }
+
+ fn has_data(&self) -> bool {
+ self.data_size != 0
+ }
+
+ fn total_size(&self) -> usize {
+ self.hole_size + self.data_size
+ }
+
+ fn shrink_hole_by(&mut self, size: usize) {
+ self.hole_size -= size;
+ }
+
+ fn shrink_hole_to(&mut self, size: usize) {
+ debug_assert!(self.hole_size >= size);
+
+ let total_size = self.total_size();
+ self.hole_size = size;
+ self.data_size = total_size - size;
+ }
+}
+
+/// A buffer (re)assembler.
+///
+/// Currently, up to a hardcoded limit of 4 or 32 holes can be tracked in the buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct Assembler {
+ contigs: [Contig; ASSEMBLER_MAX_SEGMENT_COUNT],
+}
+
+impl fmt::Display for Assembler {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "[ ")?;
+ for contig in self.contigs.iter() {
+ if !contig.has_data() {
+ break;
+ }
+ write!(f, "{contig} ")?;
+ }
+ write!(f, "]")?;
+ Ok(())
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Assembler {
+ fn format(&self, fmt: defmt::Formatter) {
+ defmt::write!(fmt, "[ ");
+ for contig in self.contigs.iter() {
+ if !contig.has_data() {
+ break;
+ }
+ defmt::write!(fmt, "{} ", contig);
+ }
+ defmt::write!(fmt, "]");
+ }
+}
+
+// Invariant on Assembler::contigs:
+// - There's an index `i` where all contigs before have data, and all contigs after don't (are unused).
+// - All contigs with data must have hole_size != 0, except the first.
+
+impl Assembler {
+ /// Create a new buffer assembler.
+ pub const fn new() -> Assembler {
+ const EMPTY: Contig = Contig::empty();
+ Assembler {
+ contigs: [EMPTY; ASSEMBLER_MAX_SEGMENT_COUNT],
+ }
+ }
+
+ pub fn clear(&mut self) {
+ self.contigs.fill(Contig::empty());
+ }
+
+ fn front(&self) -> Contig {
+ self.contigs[0]
+ }
+
+ /// Return length of the front contiguous range without removing it from the assembler
+ pub fn peek_front(&self) -> usize {
+ let front = self.front();
+ if front.has_hole() {
+ 0
+ } else {
+ front.data_size
+ }
+ }
+
+ fn back(&self) -> Contig {
+ self.contigs[self.contigs.len() - 1]
+ }
+
+ /// Return whether the assembler contains no data.
+ pub fn is_empty(&self) -> bool {
+ !self.front().has_data()
+ }
+
+ /// Remove a contig at the given index.
+ fn remove_contig_at(&mut self, at: usize) {
+ debug_assert!(self.contigs[at].has_data());
+
+ for i in at..self.contigs.len() - 1 {
+ if !self.contigs[i].has_data() {
+ return;
+ }
+ self.contigs[i] = self.contigs[i + 1];
+ }
+
+ // Removing the last one.
+ self.contigs[self.contigs.len() - 1] = Contig::empty();
+ }
+
+ /// Add a contig at the given index, and return a pointer to it.
+ fn add_contig_at(&mut self, at: usize) -> Result<&mut Contig, TooManyHolesError> {
+ if self.back().has_data() {
+ return Err(TooManyHolesError);
+ }
+
+ for i in (at + 1..self.contigs.len()).rev() {
+ self.contigs[i] = self.contigs[i - 1];
+ }
+
+ self.contigs[at] = Contig::empty();
+ Ok(&mut self.contigs[at])
+ }
+
+ /// Add a new contiguous range to the assembler,
+ /// or return `Err(TooManyHolesError)` if too many discontinuities are already recorded.
+ pub fn add(&mut self, mut offset: usize, size: usize) -> Result<(), TooManyHolesError> {
+ if size == 0 {
+ return Ok(());
+ }
+
+ let mut i = 0;
+
+ // Find index of the contig containing the start of the range.
+ loop {
+ if i == self.contigs.len() {
+ // The new range is after all the previous ranges, but there/s no space to add it.
+ return Err(TooManyHolesError);
+ }
+ let contig = &mut self.contigs[i];
+ if !contig.has_data() {
+ // The new range is after all the previous ranges. Add it.
+ *contig = Contig::hole_and_data(offset, size);
+ return Ok(());
+ }
+ if offset <= contig.total_size() {
+ break;
+ }
+ offset -= contig.total_size();
+ i += 1;
+ }
+
+ let contig = &mut self.contigs[i];
+ if offset < contig.hole_size {
+ // Range starts within the hole.
+
+ if offset + size < contig.hole_size {
+ // Range also ends within the hole.
+ let new_contig = self.add_contig_at(i)?;
+ new_contig.hole_size = offset;
+ new_contig.data_size = size;
+
+ // Previous contigs[index] got moved to contigs[index+1]
+ self.contigs[i + 1].shrink_hole_by(offset + size);
+ return Ok(());
+ }
+
+ // The range being added covers both a part of the hole and a part of the data
+ // in this contig, shrink the hole in this contig.
+ contig.shrink_hole_to(offset);
+ }
+
+ // coalesce contigs to the right.
+ let mut j = i + 1;
+ while j < self.contigs.len()
+ && self.contigs[j].has_data()
+ && offset + size >= self.contigs[i].total_size() + self.contigs[j].hole_size
+ {
+ self.contigs[i].data_size += self.contigs[j].total_size();
+ j += 1;
+ }
+ let shift = j - i - 1;
+ if shift != 0 {
+ for x in i + 1..self.contigs.len() {
+ if !self.contigs[x].has_data() {
+ break;
+ }
+
+ self.contigs[x] = self
+ .contigs
+ .get(x + shift)
+ .copied()
+ .unwrap_or_else(Contig::empty);
+ }
+ }
+
+ if offset + size > self.contigs[i].total_size() {
+ // The added range still extends beyond the current contig. Increase data size.
+ let left = offset + size - self.contigs[i].total_size();
+ self.contigs[i].data_size += left;
+
+ // Decrease hole size of the next, if any.
+ if i + 1 < self.contigs.len() && self.contigs[i + 1].has_data() {
+ self.contigs[i + 1].hole_size -= left;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Remove a contiguous range from the front of the assembler.
+ /// If no such range, return 0.
+ pub fn remove_front(&mut self) -> usize {
+ let front = self.front();
+ if front.has_hole() || !front.has_data() {
+ 0
+ } else {
+ self.remove_contig_at(0);
+ debug_assert!(front.data_size > 0);
+ front.data_size
+ }
+ }
+
+ /// Add a segment, then remove_front.
+ ///
+ /// This is equivalent to calling `add` then `remove_front` individually,
+ /// except it's guaranteed to not fail when offset = 0.
+ /// This is required for TCP: we must never drop the next expected segment, or
+ /// the protocol might get stuck.
+ pub fn add_then_remove_front(
+ &mut self,
+ offset: usize,
+ size: usize,
+ ) -> Result<usize, TooManyHolesError> {
+ // This is the only case where a segment at offset=0 would cause the
+ // total amount of contigs to rise (and therefore can potentially cause
+ // a TooManyHolesError). Handle it in a way that is guaranteed to succeed.
+ if offset == 0 && size < self.contigs[0].hole_size {
+ self.contigs[0].hole_size -= size;
+ return Ok(size);
+ }
+
+ self.add(offset, size)?;
+ Ok(self.remove_front())
+ }
+
+ /// Iterate over all of the contiguous data ranges.
+ ///
+ /// This is used in calculating what data ranges have been received. The offset indicates the
+ /// number of bytes of contiguous data received before the beginnings of this Assembler.
+ ///
+ /// Data Hole Data
+ /// |--- 100 ---|--- 200 ---|--- 100 ---|
+ ///
+ /// An offset of 1500 would return the ranges: ``(1500, 1600), (1800, 1900)``
+ pub fn iter_data(&self, first_offset: usize) -> AssemblerIter {
+ AssemblerIter::new(self, first_offset)
+ }
+}
+
+pub struct AssemblerIter<'a> {
+ assembler: &'a Assembler,
+ offset: usize,
+ index: usize,
+ left: usize,
+ right: usize,
+}
+
+impl<'a> AssemblerIter<'a> {
+ fn new(assembler: &'a Assembler, offset: usize) -> AssemblerIter<'a> {
+ AssemblerIter {
+ assembler,
+ offset,
+ index: 0,
+ left: 0,
+ right: 0,
+ }
+ }
+}
+
+impl<'a> Iterator for AssemblerIter<'a> {
+ type Item = (usize, usize);
+
+ fn next(&mut self) -> Option<(usize, usize)> {
+ let mut data_range = None;
+ while data_range.is_none() && self.index < self.assembler.contigs.len() {
+ let contig = self.assembler.contigs[self.index];
+ self.left += contig.hole_size;
+ self.right = self.left + contig.data_size;
+ data_range = if self.left < self.right {
+ let data_range = (self.left + self.offset, self.right + self.offset);
+ self.left = self.right;
+ Some(data_range)
+ } else {
+ None
+ };
+ self.index += 1;
+ }
+ data_range
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use std::vec::Vec;
+
+ impl From<Vec<(usize, usize)>> for Assembler {
+ fn from(vec: Vec<(usize, usize)>) -> Assembler {
+ const EMPTY: Contig = Contig::empty();
+
+ let mut contigs = [EMPTY; ASSEMBLER_MAX_SEGMENT_COUNT];
+ for (i, &(hole_size, data_size)) in vec.iter().enumerate() {
+ contigs[i] = Contig {
+ hole_size,
+ data_size,
+ };
+ }
+ Assembler { contigs }
+ }
+ }
+
+ macro_rules! contigs {
+ [$( $x:expr ),*] => ({
+ Assembler::from(vec![$( $x ),*])
+ })
+ }
+
+ #[test]
+ fn test_new() {
+ let assr = Assembler::new();
+ assert_eq!(assr, contigs![]);
+ }
+
+ #[test]
+ fn test_empty_add_full() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(0, 16), Ok(()));
+ assert_eq!(assr, contigs![(0, 16)]);
+ }
+
+ #[test]
+ fn test_empty_add_front() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(0, 4), Ok(()));
+ assert_eq!(assr, contigs![(0, 4)]);
+ }
+
+ #[test]
+ fn test_empty_add_back() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(12, 4), Ok(()));
+ assert_eq!(assr, contigs![(12, 4)]);
+ }
+
+ #[test]
+ fn test_empty_add_mid() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(4, 8), Ok(()));
+ assert_eq!(assr, contigs![(4, 8)]);
+ }
+
+ #[test]
+ fn test_partial_add_front() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(0, 4), Ok(()));
+ assert_eq!(assr, contigs![(0, 12)]);
+ }
+
+ #[test]
+ fn test_partial_add_back() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(12, 4), Ok(()));
+ assert_eq!(assr, contigs![(4, 12)]);
+ }
+
+ #[test]
+ fn test_partial_add_front_overlap() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(0, 8), Ok(()));
+ assert_eq!(assr, contigs![(0, 12)]);
+ }
+
+ #[test]
+ fn test_partial_add_front_overlap_split() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(2, 6), Ok(()));
+ assert_eq!(assr, contigs![(2, 10)]);
+ }
+
+ #[test]
+ fn test_partial_add_back_overlap() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(8, 8), Ok(()));
+ assert_eq!(assr, contigs![(4, 12)]);
+ }
+
+ #[test]
+ fn test_partial_add_back_overlap_split() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(10, 4), Ok(()));
+ assert_eq!(assr, contigs![(4, 10)]);
+ }
+
+ #[test]
+ fn test_partial_add_both_overlap() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(0, 16), Ok(()));
+ assert_eq!(assr, contigs![(0, 16)]);
+ }
+
+ #[test]
+ fn test_partial_add_both_overlap_split() {
+ let mut assr = contigs![(4, 8)];
+ assert_eq!(assr.add(2, 12), Ok(()));
+ assert_eq!(assr, contigs![(2, 12)]);
+ }
+
+ #[test]
+ fn test_rejected_add_keeps_state() {
+ let mut assr = Assembler::new();
+ for c in 1..=ASSEMBLER_MAX_SEGMENT_COUNT {
+ assert_eq!(assr.add(c * 10, 3), Ok(()));
+ }
+ // Maximum of allowed holes is reached
+ let assr_before = assr.clone();
+ assert_eq!(assr.add(1, 3), Err(TooManyHolesError));
+ assert_eq!(assr_before, assr);
+ }
+
+ #[test]
+ fn test_empty_remove_front() {
+ let mut assr = contigs![];
+ assert_eq!(assr.remove_front(), 0);
+ }
+
+ #[test]
+ fn test_trailing_hole_remove_front() {
+ let mut assr = contigs![(0, 4)];
+ assert_eq!(assr.remove_front(), 4);
+ assert_eq!(assr, contigs![]);
+ }
+
+ #[test]
+ fn test_trailing_data_remove_front() {
+ let mut assr = contigs![(0, 4), (4, 4)];
+ assert_eq!(assr.remove_front(), 4);
+ assert_eq!(assr, contigs![(4, 4)]);
+ }
+
+ #[test]
+ fn test_boundary_case_remove_front() {
+ let mut vec = vec![(1, 1); ASSEMBLER_MAX_SEGMENT_COUNT];
+ vec[0] = (0, 2);
+ let mut assr = Assembler::from(vec);
+ assert_eq!(assr.remove_front(), 2);
+ let mut vec = vec![(1, 1); ASSEMBLER_MAX_SEGMENT_COUNT];
+ vec[ASSEMBLER_MAX_SEGMENT_COUNT - 1] = (0, 0);
+ let exp_assr = Assembler::from(vec);
+ assert_eq!(assr, exp_assr);
+ }
+
+ #[test]
+ fn test_shrink_next_hole() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(100, 10), Ok(()));
+ assert_eq!(assr.add(50, 10), Ok(()));
+ assert_eq!(assr.add(40, 30), Ok(()));
+ assert_eq!(assr, contigs![(40, 30), (30, 10)]);
+ }
+
+ #[test]
+ fn test_join_two() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(10, 10), Ok(()));
+ assert_eq!(assr.add(50, 10), Ok(()));
+ assert_eq!(assr.add(15, 40), Ok(()));
+ assert_eq!(assr, contigs![(10, 50)]);
+ }
+
+ #[test]
+ fn test_join_two_reversed() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(50, 10), Ok(()));
+ assert_eq!(assr.add(10, 10), Ok(()));
+ assert_eq!(assr.add(15, 40), Ok(()));
+ assert_eq!(assr, contigs![(10, 50)]);
+ }
+
+ #[test]
+ fn test_join_two_overlong() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(50, 10), Ok(()));
+ assert_eq!(assr.add(10, 10), Ok(()));
+ assert_eq!(assr.add(15, 60), Ok(()));
+ assert_eq!(assr, contigs![(10, 65)]);
+ }
+
+ #[test]
+ fn test_iter_empty() {
+ let assr = Assembler::new();
+ let segments: Vec<_> = assr.iter_data(10).collect();
+ assert_eq!(segments, vec![]);
+ }
+
+ #[test]
+ fn test_iter_full() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(0, 16), Ok(()));
+ let segments: Vec<_> = assr.iter_data(10).collect();
+ assert_eq!(segments, vec![(10, 26)]);
+ }
+
+ #[test]
+ fn test_iter_offset() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(0, 16), Ok(()));
+ let segments: Vec<_> = assr.iter_data(100).collect();
+ assert_eq!(segments, vec![(100, 116)]);
+ }
+
+ #[test]
+ fn test_iter_one_front() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(0, 4), Ok(()));
+ let segments: Vec<_> = assr.iter_data(10).collect();
+ assert_eq!(segments, vec![(10, 14)]);
+ }
+
+ #[test]
+ fn test_iter_one_back() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(12, 4), Ok(()));
+ let segments: Vec<_> = assr.iter_data(10).collect();
+ assert_eq!(segments, vec![(22, 26)]);
+ }
+
+ #[test]
+ fn test_iter_one_mid() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(4, 8), Ok(()));
+ let segments: Vec<_> = assr.iter_data(10).collect();
+ assert_eq!(segments, vec![(14, 22)]);
+ }
+
+ #[test]
+ fn test_iter_one_trailing_gap() {
+ let assr = contigs![(4, 8)];
+ let segments: Vec<_> = assr.iter_data(100).collect();
+ assert_eq!(segments, vec![(104, 112)]);
+ }
+
+ #[test]
+ fn test_iter_two_split() {
+ let assr = contigs![(2, 6), (4, 1)];
+ let segments: Vec<_> = assr.iter_data(100).collect();
+ assert_eq!(segments, vec![(102, 108), (112, 113)]);
+ }
+
+ #[test]
+ fn test_iter_three_split() {
+ let assr = contigs![(2, 6), (2, 1), (2, 2)];
+ let segments: Vec<_> = assr.iter_data(100).collect();
+ assert_eq!(segments, vec![(102, 108), (110, 111), (113, 115)]);
+ }
+
+ #[test]
+ fn test_issue_694() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(0, 1), Ok(()));
+ assert_eq!(assr.add(2, 1), Ok(()));
+ assert_eq!(assr.add(1, 1), Ok(()));
+ }
+
+ #[test]
+ fn test_add_then_remove_front() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(50, 10), Ok(()));
+ assert_eq!(assr.add_then_remove_front(10, 10), Ok(0));
+ assert_eq!(assr, contigs![(10, 10), (30, 10)]);
+ }
+
+ #[test]
+ fn test_add_then_remove_front_at_front() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(50, 10), Ok(()));
+ assert_eq!(assr.add_then_remove_front(0, 10), Ok(10));
+ assert_eq!(assr, contigs![(40, 10)]);
+ }
+
+ #[test]
+ fn test_add_then_remove_front_at_front_touch() {
+ let mut assr = Assembler::new();
+ assert_eq!(assr.add(50, 10), Ok(()));
+ assert_eq!(assr.add_then_remove_front(0, 50), Ok(60));
+ assert_eq!(assr, contigs![]);
+ }
+
+ #[test]
+ fn test_add_then_remove_front_at_front_full() {
+ let mut assr = Assembler::new();
+ for c in 1..=ASSEMBLER_MAX_SEGMENT_COUNT {
+ assert_eq!(assr.add(c * 10, 3), Ok(()));
+ }
+ // Maximum of allowed holes is reached
+ let assr_before = assr.clone();
+ assert_eq!(assr.add_then_remove_front(1, 3), Err(TooManyHolesError));
+ assert_eq!(assr_before, assr);
+ }
+
+ #[test]
+ fn test_add_then_remove_front_at_front_full_offset_0() {
+ let mut assr = Assembler::new();
+ for c in 1..=ASSEMBLER_MAX_SEGMENT_COUNT {
+ assert_eq!(assr.add(c * 10, 3), Ok(()));
+ }
+ assert_eq!(assr.add_then_remove_front(0, 3), Ok(3));
+ }
+
+ // Test against an obviously-correct but inefficient bitmap impl.
+ #[test]
+ fn test_random() {
+ use rand::Rng;
+
+ const MAX_INDEX: usize = 256;
+
+ for max_size in [2, 5, 10, 100] {
+ for _ in 0..300 {
+ //println!("===");
+ let mut assr = Assembler::new();
+ let mut map = [false; MAX_INDEX];
+
+ for _ in 0..60 {
+ let offset = rand::thread_rng().gen_range(0..MAX_INDEX - max_size - 1);
+ let size = rand::thread_rng().gen_range(1..=max_size);
+
+ //println!("add {}..{} {}", offset, offset + size, size);
+ // Real impl
+ let res = assr.add(offset, size);
+
+ // Bitmap impl
+ let mut map2 = map;
+ map2[offset..][..size].fill(true);
+
+ let mut contigs = vec![];
+ let mut hole: usize = 0;
+ let mut data: usize = 0;
+ for b in map2 {
+ if b {
+ data += 1;
+ } else {
+ if data != 0 {
+ contigs.push((hole, data));
+ hole = 0;
+ data = 0;
+ }
+ hole += 1;
+ }
+ }
+
+ // Compare.
+ let wanted_res = if contigs.len() > ASSEMBLER_MAX_SEGMENT_COUNT {
+ Err(TooManyHolesError)
+ } else {
+ Ok(())
+ };
+ assert_eq!(res, wanted_res);
+ if res.is_ok() {
+ map = map2;
+ assert_eq!(assr, Assembler::from(contigs));
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/storage/mod.rs b/src/storage/mod.rs
new file mode 100644
index 0000000..b03de71
--- /dev/null
+++ b/src/storage/mod.rs
@@ -0,0 +1,31 @@
+/*! Specialized containers.
+
+The `storage` module provides containers for use in other modules.
+The containers support both pre-allocated memory, without the `std`
+or `alloc` crates being available, and heap-allocated memory.
+*/
+
+mod assembler;
+mod packet_buffer;
+mod ring_buffer;
+
+pub use self::assembler::Assembler;
+pub use self::packet_buffer::{PacketBuffer, PacketMetadata};
+pub use self::ring_buffer::RingBuffer;
+
+/// A trait for setting a value to a known state.
+///
+/// In-place analog of Default.
+pub trait Resettable {
+ fn reset(&mut self);
+}
+
+/// Error returned when enqueuing into a full buffer.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Full;
+
+/// Error returned when dequeuing from an empty buffer.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Empty;
diff --git a/src/storage/packet_buffer.rs b/src/storage/packet_buffer.rs
new file mode 100644
index 0000000..28119fa
--- /dev/null
+++ b/src/storage/packet_buffer.rs
@@ -0,0 +1,402 @@
+use managed::ManagedSlice;
+
+use crate::storage::{Full, RingBuffer};
+
+use super::Empty;
+
+/// Size and header of a packet.
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct PacketMetadata<H> {
+ size: usize,
+ header: Option<H>,
+}
+
+impl<H> PacketMetadata<H> {
+ /// Empty packet description.
+ pub const EMPTY: PacketMetadata<H> = PacketMetadata {
+ size: 0,
+ header: None,
+ };
+
+ fn padding(size: usize) -> PacketMetadata<H> {
+ PacketMetadata {
+ size: size,
+ header: None,
+ }
+ }
+
+ fn packet(size: usize, header: H) -> PacketMetadata<H> {
+ PacketMetadata {
+ size: size,
+ header: Some(header),
+ }
+ }
+
+ fn is_padding(&self) -> bool {
+ self.header.is_none()
+ }
+}
+
+/// An UDP packet ring buffer.
+#[derive(Debug)]
+pub struct PacketBuffer<'a, H: 'a> {
+ metadata_ring: RingBuffer<'a, PacketMetadata<H>>,
+ payload_ring: RingBuffer<'a, u8>,
+}
+
+impl<'a, H> PacketBuffer<'a, H> {
+ /// Create a new packet buffer with the provided metadata and payload storage.
+ ///
+ /// Metadata storage limits the maximum _number_ of packets in the buffer and payload
+ /// storage limits the maximum _total size_ of packets.
+ pub fn new<MS, PS>(metadata_storage: MS, payload_storage: PS) -> PacketBuffer<'a, H>
+ where
+ MS: Into<ManagedSlice<'a, PacketMetadata<H>>>,
+ PS: Into<ManagedSlice<'a, u8>>,
+ {
+ PacketBuffer {
+ metadata_ring: RingBuffer::new(metadata_storage),
+ payload_ring: RingBuffer::new(payload_storage),
+ }
+ }
+
+ /// Query whether the buffer is empty.
+ pub fn is_empty(&self) -> bool {
+ self.metadata_ring.is_empty()
+ }
+
+ /// Query whether the buffer is full.
+ pub fn is_full(&self) -> bool {
+ self.metadata_ring.is_full()
+ }
+
+ // There is currently no enqueue_with() because of the complexity of managing padding
+ // in case of failure.
+
+ /// Enqueue a single packet with the given header into the buffer, and
+ /// return a reference to its payload, or return `Err(Full)`
+ /// if the buffer is full.
+ pub fn enqueue(&mut self, size: usize, header: H) -> Result<&mut [u8], Full> {
+ if self.payload_ring.capacity() < size || self.metadata_ring.is_full() {
+ return Err(Full);
+ }
+
+ // Ring is currently empty. Clear it (resetting `read_at`) to maximize
+ // for contiguous space.
+ if self.payload_ring.is_empty() {
+ self.payload_ring.clear();
+ }
+
+ let window = self.payload_ring.window();
+ let contig_window = self.payload_ring.contiguous_window();
+
+ if window < size {
+ return Err(Full);
+ } else if contig_window < size {
+ if window - contig_window < size {
+ // The buffer length is larger than the current contiguous window
+ // and is larger than the contiguous window will be after adding
+ // the padding necessary to circle around to the beginning of the
+ // ring buffer.
+ return Err(Full);
+ } else {
+ // Add padding to the end of the ring buffer so that the
+ // contiguous window is at the beginning of the ring buffer.
+ *self.metadata_ring.enqueue_one()? = PacketMetadata::padding(contig_window);
+ // note(discard): function does not write to the result
+ // enqueued padding buffer location
+ let _buf_enqueued = self.payload_ring.enqueue_many(contig_window);
+ }
+ }
+
+ *self.metadata_ring.enqueue_one()? = PacketMetadata::packet(size, header);
+
+ let payload_buf = self.payload_ring.enqueue_many(size);
+ debug_assert!(payload_buf.len() == size);
+ Ok(payload_buf)
+ }
+
+ /// Call `f` with a packet from the buffer large enough to fit `max_size` bytes. The packet
+ /// is shrunk to the size returned from `f` and enqueued into the buffer.
+ pub fn enqueue_with_infallible<'b, F>(
+ &'b mut self,
+ max_size: usize,
+ header: H,
+ f: F,
+ ) -> Result<usize, Full>
+ where
+ F: FnOnce(&'b mut [u8]) -> usize,
+ {
+ if self.payload_ring.capacity() < max_size || self.metadata_ring.is_full() {
+ return Err(Full);
+ }
+
+ let window = self.payload_ring.window();
+ let contig_window = self.payload_ring.contiguous_window();
+
+ if window < max_size {
+ return Err(Full);
+ } else if contig_window < max_size {
+ if window - contig_window < max_size {
+ // The buffer length is larger than the current contiguous window
+ // and is larger than the contiguous window will be after adding
+ // the padding necessary to circle around to the beginning of the
+ // ring buffer.
+ return Err(Full);
+ } else {
+ // Add padding to the end of the ring buffer so that the
+ // contiguous window is at the beginning of the ring buffer.
+ *self.metadata_ring.enqueue_one()? = PacketMetadata::padding(contig_window);
+ // note(discard): function does not write to the result
+ // enqueued padding buffer location
+ let _buf_enqueued = self.payload_ring.enqueue_many(contig_window);
+ }
+ }
+
+ let (size, _) = self
+ .payload_ring
+ .enqueue_many_with(|data| (f(&mut data[..max_size]), ()));
+
+ *self.metadata_ring.enqueue_one()? = PacketMetadata::packet(size, header);
+
+ Ok(size)
+ }
+
+ fn dequeue_padding(&mut self) {
+ let _ = self.metadata_ring.dequeue_one_with(|metadata| {
+ if metadata.is_padding() {
+ // note(discard): function does not use value of dequeued padding bytes
+ let _buf_dequeued = self.payload_ring.dequeue_many(metadata.size);
+ Ok(()) // dequeue metadata
+ } else {
+ Err(()) // don't dequeue metadata
+ }
+ });
+ }
+
+ /// Call `f` with a single packet from the buffer, and dequeue the packet if `f`
+ /// returns successfully, or return `Err(EmptyError)` if the buffer is empty.
+ pub fn dequeue_with<'c, R, E, F>(&'c mut self, f: F) -> Result<Result<R, E>, Empty>
+ where
+ F: FnOnce(&mut H, &'c mut [u8]) -> Result<R, E>,
+ {
+ self.dequeue_padding();
+
+ self.metadata_ring.dequeue_one_with(|metadata| {
+ self.payload_ring
+ .dequeue_many_with(|payload_buf| {
+ debug_assert!(payload_buf.len() >= metadata.size);
+
+ match f(
+ metadata.header.as_mut().unwrap(),
+ &mut payload_buf[..metadata.size],
+ ) {
+ Ok(val) => (metadata.size, Ok(val)),
+ Err(err) => (0, Err(err)),
+ }
+ })
+ .1
+ })
+ }
+
+ /// Dequeue a single packet from the buffer, and return a reference to its payload
+ /// as well as its header, or return `Err(Error::Exhausted)` if the buffer is empty.
+ pub fn dequeue(&mut self) -> Result<(H, &mut [u8]), Empty> {
+ self.dequeue_padding();
+
+ let meta = self.metadata_ring.dequeue_one()?;
+
+ let payload_buf = self.payload_ring.dequeue_many(meta.size);
+ debug_assert!(payload_buf.len() == meta.size);
+ Ok((meta.header.take().unwrap(), payload_buf))
+ }
+
+ /// Peek at a single packet from the buffer without removing it, and return a reference to
+ /// its payload as well as its header, or return `Err(Error:Exhausted)` if the buffer is empty.
+ ///
+ /// This function otherwise behaves identically to [dequeue](#method.dequeue).
+ pub fn peek(&mut self) -> Result<(&H, &[u8]), Empty> {
+ self.dequeue_padding();
+
+ if let Some(metadata) = self.metadata_ring.get_allocated(0, 1).first() {
+ Ok((
+ metadata.header.as_ref().unwrap(),
+ self.payload_ring.get_allocated(0, metadata.size),
+ ))
+ } else {
+ Err(Empty)
+ }
+ }
+
+ /// Return the maximum number packets that can be stored.
+ pub fn packet_capacity(&self) -> usize {
+ self.metadata_ring.capacity()
+ }
+
+ /// Return the maximum number of bytes in the payload ring buffer.
+ pub fn payload_capacity(&self) -> usize {
+ self.payload_ring.capacity()
+ }
+
+ /// Reset the packet buffer and clear any staged.
+ #[allow(unused)]
+ pub(crate) fn reset(&mut self) {
+ self.payload_ring.clear();
+ self.metadata_ring.clear();
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ fn buffer() -> PacketBuffer<'static, ()> {
+ PacketBuffer::new(vec![PacketMetadata::EMPTY; 4], vec![0u8; 16])
+ }
+
+ #[test]
+ fn test_simple() {
+ let mut buffer = buffer();
+ buffer.enqueue(6, ()).unwrap().copy_from_slice(b"abcdef");
+ assert_eq!(buffer.enqueue(16, ()), Err(Full));
+ assert_eq!(buffer.metadata_ring.len(), 1);
+ assert_eq!(buffer.dequeue().unwrap().1, &b"abcdef"[..]);
+ assert_eq!(buffer.dequeue(), Err(Empty));
+ }
+
+ #[test]
+ fn test_peek() {
+ let mut buffer = buffer();
+ assert_eq!(buffer.peek(), Err(Empty));
+ buffer.enqueue(6, ()).unwrap().copy_from_slice(b"abcdef");
+ assert_eq!(buffer.metadata_ring.len(), 1);
+ assert_eq!(buffer.peek().unwrap().1, &b"abcdef"[..]);
+ assert_eq!(buffer.dequeue().unwrap().1, &b"abcdef"[..]);
+ assert_eq!(buffer.peek(), Err(Empty));
+ }
+
+ #[test]
+ fn test_padding() {
+ let mut buffer = buffer();
+ assert!(buffer.enqueue(6, ()).is_ok());
+ assert!(buffer.enqueue(8, ()).is_ok());
+ assert!(buffer.dequeue().is_ok());
+ buffer.enqueue(4, ()).unwrap().copy_from_slice(b"abcd");
+ assert_eq!(buffer.metadata_ring.len(), 3);
+ assert!(buffer.dequeue().is_ok());
+
+ assert_eq!(buffer.dequeue().unwrap().1, &b"abcd"[..]);
+ assert_eq!(buffer.metadata_ring.len(), 0);
+ }
+
+ #[test]
+ fn test_padding_with_large_payload() {
+ let mut buffer = buffer();
+ assert!(buffer.enqueue(12, ()).is_ok());
+ assert!(buffer.dequeue().is_ok());
+ buffer
+ .enqueue(12, ())
+ .unwrap()
+ .copy_from_slice(b"abcdefghijkl");
+ }
+
+ #[test]
+ fn test_dequeue_with() {
+ let mut buffer = buffer();
+ assert!(buffer.enqueue(6, ()).is_ok());
+ assert!(buffer.enqueue(8, ()).is_ok());
+ assert!(buffer.dequeue().is_ok());
+ buffer.enqueue(4, ()).unwrap().copy_from_slice(b"abcd");
+ assert_eq!(buffer.metadata_ring.len(), 3);
+ assert!(buffer.dequeue().is_ok());
+
+ assert!(matches!(
+ buffer.dequeue_with(|_, _| Result::<(), u32>::Err(123)),
+ Ok(Err(_))
+ ));
+ assert_eq!(buffer.metadata_ring.len(), 1);
+
+ assert!(buffer
+ .dequeue_with(|&mut (), payload| {
+ assert_eq!(payload, &b"abcd"[..]);
+ Result::<(), ()>::Ok(())
+ })
+ .is_ok());
+ assert_eq!(buffer.metadata_ring.len(), 0);
+ }
+
+ #[test]
+ fn test_metadata_full_empty() {
+ let mut buffer = buffer();
+ assert!(buffer.is_empty());
+ assert!(!buffer.is_full());
+ assert!(buffer.enqueue(1, ()).is_ok());
+ assert!(!buffer.is_empty());
+ assert!(buffer.enqueue(1, ()).is_ok());
+ assert!(buffer.enqueue(1, ()).is_ok());
+ assert!(!buffer.is_full());
+ assert!(!buffer.is_empty());
+ assert!(buffer.enqueue(1, ()).is_ok());
+ assert!(buffer.is_full());
+ assert!(!buffer.is_empty());
+ assert_eq!(buffer.metadata_ring.len(), 4);
+ assert_eq!(buffer.enqueue(1, ()), Err(Full));
+ }
+
+ #[test]
+ fn test_window_too_small() {
+ let mut buffer = buffer();
+ assert!(buffer.enqueue(4, ()).is_ok());
+ assert!(buffer.enqueue(8, ()).is_ok());
+ assert!(buffer.dequeue().is_ok());
+ assert_eq!(buffer.enqueue(16, ()), Err(Full));
+ assert_eq!(buffer.metadata_ring.len(), 1);
+ }
+
+ #[test]
+ fn test_contiguous_window_too_small() {
+ let mut buffer = buffer();
+ assert!(buffer.enqueue(4, ()).is_ok());
+ assert!(buffer.enqueue(8, ()).is_ok());
+ assert!(buffer.dequeue().is_ok());
+ assert_eq!(buffer.enqueue(8, ()), Err(Full));
+ assert_eq!(buffer.metadata_ring.len(), 1);
+ }
+
+ #[test]
+ fn test_contiguous_window_wrap() {
+ let mut buffer = buffer();
+ assert!(buffer.enqueue(15, ()).is_ok());
+ assert!(buffer.dequeue().is_ok());
+ assert!(buffer.enqueue(16, ()).is_ok());
+ }
+
+ #[test]
+ fn test_capacity_too_small() {
+ let mut buffer = buffer();
+ assert_eq!(buffer.enqueue(32, ()), Err(Full));
+ }
+
+ #[test]
+ fn test_contig_window_prioritized() {
+ let mut buffer = buffer();
+ assert!(buffer.enqueue(4, ()).is_ok());
+ assert!(buffer.dequeue().is_ok());
+ assert!(buffer.enqueue(5, ()).is_ok());
+ }
+
+ #[test]
+ fn clear() {
+ let mut buffer = buffer();
+
+ // Ensure enqueuing data in the buffer fills it somewhat.
+ assert!(buffer.is_empty());
+ assert!(buffer.enqueue(6, ()).is_ok());
+
+ // Ensure that resetting the buffer causes it to be empty.
+ assert!(!buffer.is_empty());
+ buffer.reset();
+ assert!(buffer.is_empty());
+ }
+}
diff --git a/src/storage/ring_buffer.rs b/src/storage/ring_buffer.rs
new file mode 100644
index 0000000..7d461b6
--- /dev/null
+++ b/src/storage/ring_buffer.rs
@@ -0,0 +1,803 @@
+// Some of the functions in ring buffer is marked as #[must_use]. It notes that
+// these functions may have side effects, and it's implemented by [RFC 1940].
+// [RFC 1940]: https://github.com/rust-lang/rust/issues/43302
+
+use core::cmp;
+use managed::ManagedSlice;
+
+use crate::storage::Resettable;
+
+use super::{Empty, Full};
+
+/// A ring buffer.
+///
+/// This ring buffer implementation provides many ways to interact with it:
+///
+/// * Enqueueing or dequeueing one element from corresponding side of the buffer;
+/// * Enqueueing or dequeueing a slice of elements from corresponding side of the buffer;
+/// * Accessing allocated and unallocated areas directly.
+///
+/// It is also zero-copy; all methods provide references into the buffer's storage.
+/// Note that all references are mutable; it is considered more important to allow
+/// in-place processing than to protect from accidental mutation.
+///
+/// This implementation is suitable for both simple uses such as a FIFO queue
+/// of UDP packets, and advanced ones such as a TCP reassembly buffer.
+#[derive(Debug)]
+pub struct RingBuffer<'a, T: 'a> {
+ storage: ManagedSlice<'a, T>,
+ read_at: usize,
+ length: usize,
+}
+
+impl<'a, T: 'a> RingBuffer<'a, T> {
+ /// Create a ring buffer with the given storage.
+ ///
+ /// During creation, every element in `storage` is reset.
+ pub fn new<S>(storage: S) -> RingBuffer<'a, T>
+ where
+ S: Into<ManagedSlice<'a, T>>,
+ {
+ RingBuffer {
+ storage: storage.into(),
+ read_at: 0,
+ length: 0,
+ }
+ }
+
+ /// Clear the ring buffer.
+ pub fn clear(&mut self) {
+ self.read_at = 0;
+ self.length = 0;
+ }
+
+ /// Return the maximum number of elements in the ring buffer.
+ pub fn capacity(&self) -> usize {
+ self.storage.len()
+ }
+
+ /// Clear the ring buffer, and reset every element.
+ pub fn reset(&mut self)
+ where
+ T: Resettable,
+ {
+ self.clear();
+ for elem in self.storage.iter_mut() {
+ elem.reset();
+ }
+ }
+
+ /// Return the current number of elements in the ring buffer.
+ pub fn len(&self) -> usize {
+ self.length
+ }
+
+ /// Return the number of elements that can be added to the ring buffer.
+ pub fn window(&self) -> usize {
+ self.capacity() - self.len()
+ }
+
+ /// Return the largest number of elements that can be added to the buffer
+ /// without wrapping around (i.e. in a single `enqueue_many` call).
+ pub fn contiguous_window(&self) -> usize {
+ cmp::min(self.window(), self.capacity() - self.get_idx(self.length))
+ }
+
+ /// Query whether the buffer is empty.
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ /// Query whether the buffer is full.
+ pub fn is_full(&self) -> bool {
+ self.window() == 0
+ }
+
+ /// Shorthand for `(self.read + idx) % self.capacity()` with an
+ /// additional check to ensure that the capacity is not zero.
+ fn get_idx(&self, idx: usize) -> usize {
+ let len = self.capacity();
+ if len > 0 {
+ (self.read_at + idx) % len
+ } else {
+ 0
+ }
+ }
+
+ /// Shorthand for `(self.read + idx) % self.capacity()` with no
+ /// additional checks to ensure the capacity is not zero.
+ fn get_idx_unchecked(&self, idx: usize) -> usize {
+ (self.read_at + idx) % self.capacity()
+ }
+}
+
+/// This is the "discrete" ring buffer interface: it operates with single elements,
+/// and boundary conditions (empty/full) are errors.
+impl<'a, T: 'a> RingBuffer<'a, T> {
+ /// Call `f` with a single buffer element, and enqueue the element if `f`
+ /// returns successfully, or return `Err(Full)` if the buffer is full.
+ pub fn enqueue_one_with<'b, R, E, F>(&'b mut self, f: F) -> Result<Result<R, E>, Full>
+ where
+ F: FnOnce(&'b mut T) -> Result<R, E>,
+ {
+ if self.is_full() {
+ return Err(Full);
+ }
+
+ let index = self.get_idx_unchecked(self.length);
+ let res = f(&mut self.storage[index]);
+ if res.is_ok() {
+ self.length += 1;
+ }
+ Ok(res)
+ }
+
+ /// Enqueue a single element into the buffer, and return a reference to it,
+ /// or return `Err(Full)` if the buffer is full.
+ ///
+ /// This function is a shortcut for `ring_buf.enqueue_one_with(Ok)`.
+ pub fn enqueue_one(&mut self) -> Result<&mut T, Full> {
+ self.enqueue_one_with(Ok)?
+ }
+
+ /// Call `f` with a single buffer element, and dequeue the element if `f`
+ /// returns successfully, or return `Err(Empty)` if the buffer is empty.
+ pub fn dequeue_one_with<'b, R, E, F>(&'b mut self, f: F) -> Result<Result<R, E>, Empty>
+ where
+ F: FnOnce(&'b mut T) -> Result<R, E>,
+ {
+ if self.is_empty() {
+ return Err(Empty);
+ }
+
+ let next_at = self.get_idx_unchecked(1);
+ let res = f(&mut self.storage[self.read_at]);
+
+ if res.is_ok() {
+ self.length -= 1;
+ self.read_at = next_at;
+ }
+ Ok(res)
+ }
+
+ /// Dequeue an element from the buffer, and return a reference to it,
+ /// or return `Err(Empty)` if the buffer is empty.
+ ///
+ /// This function is a shortcut for `ring_buf.dequeue_one_with(Ok)`.
+ pub fn dequeue_one(&mut self) -> Result<&mut T, Empty> {
+ self.dequeue_one_with(Ok)?
+ }
+}
+
+/// This is the "continuous" ring buffer interface: it operates with element slices,
+/// and boundary conditions (empty/full) simply result in empty slices.
+impl<'a, T: 'a> RingBuffer<'a, T> {
+ /// Call `f` with the largest contiguous slice of unallocated buffer elements,
+ /// and enqueue the amount of elements returned by `f`.
+ ///
+ /// # Panics
+ /// This function panics if the amount of elements returned by `f` is larger
+ /// than the size of the slice passed into it.
+ pub fn enqueue_many_with<'b, R, F>(&'b mut self, f: F) -> (usize, R)
+ where
+ F: FnOnce(&'b mut [T]) -> (usize, R),
+ {
+ if self.length == 0 {
+ // Ring is currently empty. Reset `read_at` to optimize
+ // for contiguous space.
+ self.read_at = 0;
+ }
+
+ let write_at = self.get_idx(self.length);
+ let max_size = self.contiguous_window();
+ let (size, result) = f(&mut self.storage[write_at..write_at + max_size]);
+ assert!(size <= max_size);
+ self.length += size;
+ (size, result)
+ }
+
+ /// Enqueue a slice of elements up to the given size into the buffer,
+ /// and return a reference to them.
+ ///
+ /// This function may return a slice smaller than the given size
+ /// if the free space in the buffer is not contiguous.
+ #[must_use]
+ pub fn enqueue_many(&mut self, size: usize) -> &mut [T] {
+ self.enqueue_many_with(|buf| {
+ let size = cmp::min(size, buf.len());
+ (size, &mut buf[..size])
+ })
+ .1
+ }
+
+ /// Enqueue as many elements from the given slice into the buffer as possible,
+ /// and return the amount of elements that could fit.
+ #[must_use]
+ pub fn enqueue_slice(&mut self, data: &[T]) -> usize
+ where
+ T: Copy,
+ {
+ let (size_1, data) = self.enqueue_many_with(|buf| {
+ let size = cmp::min(buf.len(), data.len());
+ buf[..size].copy_from_slice(&data[..size]);
+ (size, &data[size..])
+ });
+ let (size_2, ()) = self.enqueue_many_with(|buf| {
+ let size = cmp::min(buf.len(), data.len());
+ buf[..size].copy_from_slice(&data[..size]);
+ (size, ())
+ });
+ size_1 + size_2
+ }
+
+ /// Call `f` with the largest contiguous slice of allocated buffer elements,
+ /// and dequeue the amount of elements returned by `f`.
+ ///
+ /// # Panics
+ /// This function panics if the amount of elements returned by `f` is larger
+ /// than the size of the slice passed into it.
+ pub fn dequeue_many_with<'b, R, F>(&'b mut self, f: F) -> (usize, R)
+ where
+ F: FnOnce(&'b mut [T]) -> (usize, R),
+ {
+ let capacity = self.capacity();
+ let max_size = cmp::min(self.len(), capacity - self.read_at);
+ let (size, result) = f(&mut self.storage[self.read_at..self.read_at + max_size]);
+ assert!(size <= max_size);
+ self.read_at = if capacity > 0 {
+ (self.read_at + size) % capacity
+ } else {
+ 0
+ };
+ self.length -= size;
+ (size, result)
+ }
+
+ /// Dequeue a slice of elements up to the given size from the buffer,
+ /// and return a reference to them.
+ ///
+ /// This function may return a slice smaller than the given size
+ /// if the allocated space in the buffer is not contiguous.
+ #[must_use]
+ pub fn dequeue_many(&mut self, size: usize) -> &mut [T] {
+ self.dequeue_many_with(|buf| {
+ let size = cmp::min(size, buf.len());
+ (size, &mut buf[..size])
+ })
+ .1
+ }
+
+ /// Dequeue as many elements from the buffer into the given slice as possible,
+ /// and return the amount of elements that could fit.
+ #[must_use]
+ pub fn dequeue_slice(&mut self, data: &mut [T]) -> usize
+ where
+ T: Copy,
+ {
+ let (size_1, data) = self.dequeue_many_with(|buf| {
+ let size = cmp::min(buf.len(), data.len());
+ data[..size].copy_from_slice(&buf[..size]);
+ (size, &mut data[size..])
+ });
+ let (size_2, ()) = self.dequeue_many_with(|buf| {
+ let size = cmp::min(buf.len(), data.len());
+ data[..size].copy_from_slice(&buf[..size]);
+ (size, ())
+ });
+ size_1 + size_2
+ }
+}
+
+/// This is the "random access" ring buffer interface: it operates with element slices,
+/// and allows to access elements of the buffer that are not adjacent to its head or tail.
+impl<'a, T: 'a> RingBuffer<'a, T> {
+ /// Return the largest contiguous slice of unallocated buffer elements starting
+ /// at the given offset past the last allocated element, and up to the given size.
+ #[must_use]
+ pub fn get_unallocated(&mut self, offset: usize, mut size: usize) -> &mut [T] {
+ let start_at = self.get_idx(self.length + offset);
+ // We can't access past the end of unallocated data.
+ if offset > self.window() {
+ return &mut [];
+ }
+ // We can't enqueue more than there is free space.
+ let clamped_window = self.window() - offset;
+ if size > clamped_window {
+ size = clamped_window
+ }
+ // We can't contiguously enqueue past the end of the storage.
+ let until_end = self.capacity() - start_at;
+ if size > until_end {
+ size = until_end
+ }
+
+ &mut self.storage[start_at..start_at + size]
+ }
+
+ /// Write as many elements from the given slice into unallocated buffer elements
+ /// starting at the given offset past the last allocated element, and return
+ /// the amount written.
+ #[must_use]
+ pub fn write_unallocated(&mut self, offset: usize, data: &[T]) -> usize
+ where
+ T: Copy,
+ {
+ let (size_1, offset, data) = {
+ let slice = self.get_unallocated(offset, data.len());
+ let slice_len = slice.len();
+ slice.copy_from_slice(&data[..slice_len]);
+ (slice_len, offset + slice_len, &data[slice_len..])
+ };
+ let size_2 = {
+ let slice = self.get_unallocated(offset, data.len());
+ let slice_len = slice.len();
+ slice.copy_from_slice(&data[..slice_len]);
+ slice_len
+ };
+ size_1 + size_2
+ }
+
+ /// Enqueue the given number of unallocated buffer elements.
+ ///
+ /// # Panics
+ /// Panics if the number of elements given exceeds the number of unallocated elements.
+ pub fn enqueue_unallocated(&mut self, count: usize) {
+ assert!(count <= self.window());
+ self.length += count;
+ }
+
+ /// Return the largest contiguous slice of allocated buffer elements starting
+ /// at the given offset past the first allocated element, and up to the given size.
+ #[must_use]
+ pub fn get_allocated(&self, offset: usize, mut size: usize) -> &[T] {
+ let start_at = self.get_idx(offset);
+ // We can't read past the end of the allocated data.
+ if offset > self.length {
+ return &mut [];
+ }
+ // We can't read more than we have allocated.
+ let clamped_length = self.length - offset;
+ if size > clamped_length {
+ size = clamped_length
+ }
+ // We can't contiguously dequeue past the end of the storage.
+ let until_end = self.capacity() - start_at;
+ if size > until_end {
+ size = until_end
+ }
+
+ &self.storage[start_at..start_at + size]
+ }
+
+ /// Read as many elements from allocated buffer elements into the given slice
+ /// starting at the given offset past the first allocated element, and return
+ /// the amount read.
+ #[must_use]
+ pub fn read_allocated(&mut self, offset: usize, data: &mut [T]) -> usize
+ where
+ T: Copy,
+ {
+ let (size_1, offset, data) = {
+ let slice = self.get_allocated(offset, data.len());
+ data[..slice.len()].copy_from_slice(slice);
+ (slice.len(), offset + slice.len(), &mut data[slice.len()..])
+ };
+ let size_2 = {
+ let slice = self.get_allocated(offset, data.len());
+ data[..slice.len()].copy_from_slice(slice);
+ slice.len()
+ };
+ size_1 + size_2
+ }
+
+ /// Dequeue the given number of allocated buffer elements.
+ ///
+ /// # Panics
+ /// Panics if the number of elements given exceeds the number of allocated elements.
+ pub fn dequeue_allocated(&mut self, count: usize) {
+ assert!(count <= self.len());
+ self.length -= count;
+ self.read_at = self.get_idx(count);
+ }
+}
+
+impl<'a, T: 'a> From<ManagedSlice<'a, T>> for RingBuffer<'a, T> {
+ fn from(slice: ManagedSlice<'a, T>) -> RingBuffer<'a, T> {
+ RingBuffer::new(slice)
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn test_buffer_length_changes() {
+ let mut ring = RingBuffer::new(vec![0; 2]);
+ assert!(ring.is_empty());
+ assert!(!ring.is_full());
+ assert_eq!(ring.len(), 0);
+ assert_eq!(ring.capacity(), 2);
+ assert_eq!(ring.window(), 2);
+
+ ring.length = 1;
+ assert!(!ring.is_empty());
+ assert!(!ring.is_full());
+ assert_eq!(ring.len(), 1);
+ assert_eq!(ring.capacity(), 2);
+ assert_eq!(ring.window(), 1);
+
+ ring.length = 2;
+ assert!(!ring.is_empty());
+ assert!(ring.is_full());
+ assert_eq!(ring.len(), 2);
+ assert_eq!(ring.capacity(), 2);
+ assert_eq!(ring.window(), 0);
+ }
+
+ #[test]
+ fn test_buffer_enqueue_dequeue_one_with() {
+ let mut ring = RingBuffer::new(vec![0; 5]);
+ assert_eq!(
+ ring.dequeue_one_with(|_| -> Result::<(), ()> { unreachable!() }),
+ Err(Empty)
+ );
+
+ ring.enqueue_one_with(Ok::<_, ()>).unwrap().unwrap();
+ assert!(!ring.is_empty());
+ assert!(!ring.is_full());
+
+ for i in 1..5 {
+ ring.enqueue_one_with(|e| Ok::<_, ()>(*e = i))
+ .unwrap()
+ .unwrap();
+ assert!(!ring.is_empty());
+ }
+ assert!(ring.is_full());
+ assert_eq!(
+ ring.enqueue_one_with(|_| -> Result::<(), ()> { unreachable!() }),
+ Err(Full)
+ );
+
+ for i in 0..5 {
+ assert_eq!(
+ ring.dequeue_one_with(|e| Ok::<_, ()>(*e)).unwrap().unwrap(),
+ i
+ );
+ assert!(!ring.is_full());
+ }
+ assert_eq!(
+ ring.dequeue_one_with(|_| -> Result::<(), ()> { unreachable!() }),
+ Err(Empty)
+ );
+ assert!(ring.is_empty());
+ }
+
+ #[test]
+ fn test_buffer_enqueue_dequeue_one() {
+ let mut ring = RingBuffer::new(vec![0; 5]);
+ assert_eq!(ring.dequeue_one(), Err(Empty));
+
+ ring.enqueue_one().unwrap();
+ assert!(!ring.is_empty());
+ assert!(!ring.is_full());
+
+ for i in 1..5 {
+ *ring.enqueue_one().unwrap() = i;
+ assert!(!ring.is_empty());
+ }
+ assert!(ring.is_full());
+ assert_eq!(ring.enqueue_one(), Err(Full));
+
+ for i in 0..5 {
+ assert_eq!(*ring.dequeue_one().unwrap(), i);
+ assert!(!ring.is_full());
+ }
+ assert_eq!(ring.dequeue_one(), Err(Empty));
+ assert!(ring.is_empty());
+ }
+
+ #[test]
+ fn test_buffer_enqueue_many_with() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ assert_eq!(
+ ring.enqueue_many_with(|buf| {
+ assert_eq!(buf.len(), 12);
+ buf[0..2].copy_from_slice(b"ab");
+ (2, true)
+ }),
+ (2, true)
+ );
+ assert_eq!(ring.len(), 2);
+ assert_eq!(&ring.storage[..], b"ab..........");
+
+ ring.enqueue_many_with(|buf| {
+ assert_eq!(buf.len(), 12 - 2);
+ buf[0..4].copy_from_slice(b"cdXX");
+ (2, ())
+ });
+ assert_eq!(ring.len(), 4);
+ assert_eq!(&ring.storage[..], b"abcdXX......");
+
+ ring.enqueue_many_with(|buf| {
+ assert_eq!(buf.len(), 12 - 4);
+ buf[0..4].copy_from_slice(b"efgh");
+ (4, ())
+ });
+ assert_eq!(ring.len(), 8);
+ assert_eq!(&ring.storage[..], b"abcdefgh....");
+
+ for _ in 0..4 {
+ *ring.dequeue_one().unwrap() = b'.';
+ }
+ assert_eq!(ring.len(), 4);
+ assert_eq!(&ring.storage[..], b"....efgh....");
+
+ ring.enqueue_many_with(|buf| {
+ assert_eq!(buf.len(), 12 - 8);
+ buf[0..4].copy_from_slice(b"ijkl");
+ (4, ())
+ });
+ assert_eq!(ring.len(), 8);
+ assert_eq!(&ring.storage[..], b"....efghijkl");
+
+ ring.enqueue_many_with(|buf| {
+ assert_eq!(buf.len(), 4);
+ buf[0..4].copy_from_slice(b"abcd");
+ (4, ())
+ });
+ assert_eq!(ring.len(), 12);
+ assert_eq!(&ring.storage[..], b"abcdefghijkl");
+
+ for _ in 0..4 {
+ *ring.dequeue_one().unwrap() = b'.';
+ }
+ assert_eq!(ring.len(), 8);
+ assert_eq!(&ring.storage[..], b"abcd....ijkl");
+ }
+
+ #[test]
+ fn test_buffer_enqueue_many() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ ring.enqueue_many(8).copy_from_slice(b"abcdefgh");
+ assert_eq!(ring.len(), 8);
+ assert_eq!(&ring.storage[..], b"abcdefgh....");
+
+ ring.enqueue_many(8).copy_from_slice(b"ijkl");
+ assert_eq!(ring.len(), 12);
+ assert_eq!(&ring.storage[..], b"abcdefghijkl");
+ }
+
+ #[test]
+ fn test_buffer_enqueue_slice() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ assert_eq!(ring.enqueue_slice(b"abcdefgh"), 8);
+ assert_eq!(ring.len(), 8);
+ assert_eq!(&ring.storage[..], b"abcdefgh....");
+
+ for _ in 0..4 {
+ *ring.dequeue_one().unwrap() = b'.';
+ }
+ assert_eq!(ring.len(), 4);
+ assert_eq!(&ring.storage[..], b"....efgh....");
+
+ assert_eq!(ring.enqueue_slice(b"ijklabcd"), 8);
+ assert_eq!(ring.len(), 12);
+ assert_eq!(&ring.storage[..], b"abcdefghijkl");
+ }
+
+ #[test]
+ fn test_buffer_dequeue_many_with() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ assert_eq!(ring.enqueue_slice(b"abcdefghijkl"), 12);
+
+ assert_eq!(
+ ring.dequeue_many_with(|buf| {
+ assert_eq!(buf.len(), 12);
+ assert_eq!(buf, b"abcdefghijkl");
+ buf[..4].copy_from_slice(b"....");
+ (4, true)
+ }),
+ (4, true)
+ );
+ assert_eq!(ring.len(), 8);
+ assert_eq!(&ring.storage[..], b"....efghijkl");
+
+ ring.dequeue_many_with(|buf| {
+ assert_eq!(buf, b"efghijkl");
+ buf[..4].copy_from_slice(b"....");
+ (4, ())
+ });
+ assert_eq!(ring.len(), 4);
+ assert_eq!(&ring.storage[..], b"........ijkl");
+
+ assert_eq!(ring.enqueue_slice(b"abcd"), 4);
+ assert_eq!(ring.len(), 8);
+
+ ring.dequeue_many_with(|buf| {
+ assert_eq!(buf, b"ijkl");
+ buf[..4].copy_from_slice(b"....");
+ (4, ())
+ });
+ ring.dequeue_many_with(|buf| {
+ assert_eq!(buf, b"abcd");
+ buf[..4].copy_from_slice(b"....");
+ (4, ())
+ });
+ assert_eq!(ring.len(), 0);
+ assert_eq!(&ring.storage[..], b"............");
+ }
+
+ #[test]
+ fn test_buffer_dequeue_many() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ assert_eq!(ring.enqueue_slice(b"abcdefghijkl"), 12);
+
+ {
+ let buf = ring.dequeue_many(8);
+ assert_eq!(buf, b"abcdefgh");
+ buf.copy_from_slice(b"........");
+ }
+ assert_eq!(ring.len(), 4);
+ assert_eq!(&ring.storage[..], b"........ijkl");
+
+ {
+ let buf = ring.dequeue_many(8);
+ assert_eq!(buf, b"ijkl");
+ buf.copy_from_slice(b"....");
+ }
+ assert_eq!(ring.len(), 0);
+ assert_eq!(&ring.storage[..], b"............");
+ }
+
+ #[test]
+ fn test_buffer_dequeue_slice() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ assert_eq!(ring.enqueue_slice(b"abcdefghijkl"), 12);
+
+ {
+ let mut buf = [0; 8];
+ assert_eq!(ring.dequeue_slice(&mut buf[..]), 8);
+ assert_eq!(&buf[..], b"abcdefgh");
+ assert_eq!(ring.len(), 4);
+ }
+
+ assert_eq!(ring.enqueue_slice(b"abcd"), 4);
+
+ {
+ let mut buf = [0; 8];
+ assert_eq!(ring.dequeue_slice(&mut buf[..]), 8);
+ assert_eq!(&buf[..], b"ijklabcd");
+ assert_eq!(ring.len(), 0);
+ }
+ }
+
+ #[test]
+ fn test_buffer_get_unallocated() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ assert_eq!(ring.get_unallocated(16, 4), b"");
+
+ {
+ let buf = ring.get_unallocated(0, 4);
+ buf.copy_from_slice(b"abcd");
+ }
+ assert_eq!(&ring.storage[..], b"abcd........");
+
+ let buf_enqueued = ring.enqueue_many(4);
+ assert_eq!(buf_enqueued.len(), 4);
+ assert_eq!(ring.len(), 4);
+
+ {
+ let buf = ring.get_unallocated(4, 8);
+ buf.copy_from_slice(b"ijkl");
+ }
+ assert_eq!(&ring.storage[..], b"abcd....ijkl");
+
+ ring.enqueue_many(8).copy_from_slice(b"EFGHIJKL");
+ ring.dequeue_many(4).copy_from_slice(b"abcd");
+ assert_eq!(ring.len(), 8);
+ assert_eq!(&ring.storage[..], b"abcdEFGHIJKL");
+
+ {
+ let buf = ring.get_unallocated(0, 8);
+ buf.copy_from_slice(b"ABCD");
+ }
+ assert_eq!(&ring.storage[..], b"ABCDEFGHIJKL");
+ }
+
+ #[test]
+ fn test_buffer_write_unallocated() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+ ring.enqueue_many(6).copy_from_slice(b"abcdef");
+ ring.dequeue_many(6).copy_from_slice(b"ABCDEF");
+
+ assert_eq!(ring.write_unallocated(0, b"ghi"), 3);
+ assert_eq!(ring.get_unallocated(0, 3), b"ghi");
+
+ assert_eq!(ring.write_unallocated(3, b"jklmno"), 6);
+ assert_eq!(ring.get_unallocated(3, 3), b"jkl");
+
+ assert_eq!(ring.write_unallocated(9, b"pqrstu"), 3);
+ assert_eq!(ring.get_unallocated(9, 3), b"pqr");
+ }
+
+ #[test]
+ fn test_buffer_get_allocated() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+
+ assert_eq!(ring.get_allocated(16, 4), b"");
+ assert_eq!(ring.get_allocated(0, 4), b"");
+
+ let len_enqueued = ring.enqueue_slice(b"abcd");
+ assert_eq!(ring.get_allocated(0, 8), b"abcd");
+ assert_eq!(len_enqueued, 4);
+
+ let len_enqueued = ring.enqueue_slice(b"efghijkl");
+ ring.dequeue_many(4).copy_from_slice(b"....");
+ assert_eq!(ring.get_allocated(4, 8), b"ijkl");
+ assert_eq!(len_enqueued, 8);
+
+ let len_enqueued = ring.enqueue_slice(b"abcd");
+ assert_eq!(ring.get_allocated(4, 8), b"ijkl");
+ assert_eq!(len_enqueued, 4);
+ }
+
+ #[test]
+ fn test_buffer_read_allocated() {
+ let mut ring = RingBuffer::new(vec![b'.'; 12]);
+ ring.enqueue_many(12).copy_from_slice(b"abcdefghijkl");
+
+ let mut data = [0; 6];
+ assert_eq!(ring.read_allocated(0, &mut data[..]), 6);
+ assert_eq!(&data[..], b"abcdef");
+
+ ring.dequeue_many(6).copy_from_slice(b"ABCDEF");
+ ring.enqueue_many(3).copy_from_slice(b"mno");
+
+ let mut data = [0; 6];
+ assert_eq!(ring.read_allocated(3, &mut data[..]), 6);
+ assert_eq!(&data[..], b"jklmno");
+
+ let mut data = [0; 6];
+ assert_eq!(ring.read_allocated(6, &mut data[..]), 3);
+ assert_eq!(&data[..], b"mno\x00\x00\x00");
+ }
+
+ #[test]
+ fn test_buffer_with_no_capacity() {
+ let mut no_capacity: RingBuffer<u8> = RingBuffer::new(vec![]);
+
+ // Call all functions that calculate the remainder against rx_buffer.capacity()
+ // with a backing storage with a length of 0.
+ assert_eq!(no_capacity.get_unallocated(0, 0), &[]);
+ assert_eq!(no_capacity.get_allocated(0, 0), &[]);
+ no_capacity.dequeue_allocated(0);
+ assert_eq!(no_capacity.enqueue_many(0), &[]);
+ assert_eq!(no_capacity.enqueue_one(), Err(Full));
+ assert_eq!(no_capacity.contiguous_window(), 0);
+ }
+
+ /// Use the buffer a bit. Then empty it and put in an item of
+ /// maximum size. By detecting a length of 0, the implementation
+ /// can reset the current buffer position.
+ #[test]
+ fn test_buffer_write_wholly() {
+ let mut ring = RingBuffer::new(vec![b'.'; 8]);
+ ring.enqueue_many(2).copy_from_slice(b"ab");
+ ring.enqueue_many(2).copy_from_slice(b"cd");
+ assert_eq!(ring.len(), 4);
+ let buf_dequeued = ring.dequeue_many(4);
+ assert_eq!(buf_dequeued, b"abcd");
+ assert_eq!(ring.len(), 0);
+
+ let large = ring.enqueue_many(8);
+ assert_eq!(large.len(), 8);
+ }
+}
diff --git a/src/tests.rs b/src/tests.rs
new file mode 100644
index 0000000..ec026ab
--- /dev/null
+++ b/src/tests.rs
@@ -0,0 +1,148 @@
+use crate::iface::*;
+use crate::wire::*;
+
+pub(crate) fn setup<'a>(medium: Medium) -> (Interface, SocketSet<'a>, TestingDevice) {
+ let mut device = TestingDevice::new(medium);
+
+ let config = Config::new(match medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => {
+ HardwareAddress::Ethernet(EthernetAddress([0x02, 0x02, 0x02, 0x02, 0x02, 0x02]))
+ }
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => HardwareAddress::Ip,
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => HardwareAddress::Ieee802154(Ieee802154Address::Extended([
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ ])),
+ });
+
+ let mut iface = Interface::new(config, &mut device, Instant::ZERO);
+
+ #[cfg(feature = "proto-ipv4")]
+ {
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(192, 168, 1, 1), 24))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8))
+ .unwrap();
+ });
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ {
+ iface.update_ip_addrs(|ip_addrs| {
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 128))
+ .unwrap();
+ ip_addrs
+ .push(IpCidr::new(IpAddress::v6(0xfdbe, 0, 0, 0, 0, 0, 0, 1), 64))
+ .unwrap();
+ });
+ }
+
+ (iface, SocketSet::new(vec![]), device)
+}
+
+use heapless::Deque;
+use heapless::Vec;
+
+use crate::phy::{self, Device, DeviceCapabilities, Medium};
+use crate::time::Instant;
+
+/// A testing device.
+#[derive(Debug)]
+pub struct TestingDevice {
+ pub(crate) queue: Deque<Vec<u8, 1514>, 4>,
+ max_transmission_unit: usize,
+ medium: Medium,
+}
+
+#[allow(clippy::new_without_default)]
+impl TestingDevice {
+ /// Creates a testing device.
+ ///
+ /// Every packet transmitted through this device will be received through it
+ /// in FIFO order.
+ pub fn new(medium: Medium) -> Self {
+ TestingDevice {
+ queue: Deque::new(),
+ max_transmission_unit: match medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => 1514,
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => 1500,
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => 1500,
+ },
+ medium,
+ }
+ }
+}
+
+impl Device for TestingDevice {
+ type RxToken<'a> = RxToken;
+ type TxToken<'a> = TxToken<'a>;
+
+ fn capabilities(&self) -> DeviceCapabilities {
+ DeviceCapabilities {
+ medium: self.medium,
+ max_transmission_unit: self.max_transmission_unit,
+ ..DeviceCapabilities::default()
+ }
+ }
+
+ fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+ self.queue.pop_front().map(move |buffer| {
+ let rx = RxToken { buffer };
+ let tx = TxToken {
+ queue: &mut self.queue,
+ };
+ (rx, tx)
+ })
+ }
+
+ fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
+ Some(TxToken {
+ queue: &mut self.queue,
+ })
+ }
+}
+
+#[doc(hidden)]
+pub struct RxToken {
+ buffer: Vec<u8, 1514>,
+}
+
+impl phy::RxToken for RxToken {
+ fn consume<R, F>(mut self, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ f(&mut self.buffer)
+ }
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TxToken<'a> {
+ queue: &'a mut Deque<Vec<u8, 1514>, 4>,
+}
+
+impl<'a> phy::TxToken for TxToken<'a> {
+ fn consume<R, F>(self, len: usize, f: F) -> R
+ where
+ F: FnOnce(&mut [u8]) -> R,
+ {
+ let mut buffer = Vec::new();
+ buffer.resize(len, 0).unwrap();
+ let result = f(&mut buffer);
+ self.queue.push_back(buffer).unwrap();
+ result
+ }
+}
diff --git a/src/time.rs b/src/time.rs
new file mode 100644
index 0000000..e6904af
--- /dev/null
+++ b/src/time.rs
@@ -0,0 +1,460 @@
+/*! Time structures.
+
+The `time` module contains structures used to represent both
+absolute and relative time.
+
+ - [Instant] is used to represent absolute time.
+ - [Duration] is used to represent relative time.
+
+[Instant]: struct.Instant.html
+[Duration]: struct.Duration.html
+*/
+
+use core::{fmt, ops};
+
+/// A representation of an absolute time value.
+///
+/// The `Instant` type is a wrapper around a `i64` value that
+/// represents a number of microseconds, monotonically increasing
+/// since an arbitrary moment in time, such as system startup.
+///
+/// * A value of `0` is inherently arbitrary.
+/// * A value less than `0` indicates a time before the starting
+/// point.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Instant {
+ micros: i64,
+}
+
+impl Instant {
+ pub const ZERO: Instant = Instant::from_micros_const(0);
+
+ /// Create a new `Instant` from a number of microseconds.
+ pub fn from_micros<T: Into<i64>>(micros: T) -> Instant {
+ Instant {
+ micros: micros.into(),
+ }
+ }
+
+ pub const fn from_micros_const(micros: i64) -> Instant {
+ Instant { micros }
+ }
+
+ /// Create a new `Instant` from a number of milliseconds.
+ pub fn from_millis<T: Into<i64>>(millis: T) -> Instant {
+ Instant {
+ micros: millis.into() * 1000,
+ }
+ }
+
+ /// Create a new `Instant` from a number of milliseconds.
+ pub const fn from_millis_const(millis: i64) -> Instant {
+ Instant {
+ micros: millis * 1000,
+ }
+ }
+
+ /// Create a new `Instant` from a number of seconds.
+ pub fn from_secs<T: Into<i64>>(secs: T) -> Instant {
+ Instant {
+ micros: secs.into() * 1000000,
+ }
+ }
+
+ /// Create a new `Instant` from the current [std::time::SystemTime].
+ ///
+ /// See [std::time::SystemTime::now]
+ ///
+ /// [std::time::SystemTime]: https://doc.rust-lang.org/std/time/struct.SystemTime.html
+ /// [std::time::SystemTime::now]: https://doc.rust-lang.org/std/time/struct.SystemTime.html#method.now
+ #[cfg(feature = "std")]
+ pub fn now() -> Instant {
+ Self::from(::std::time::SystemTime::now())
+ }
+
+ /// The fractional number of milliseconds that have passed
+ /// since the beginning of time.
+ pub const fn millis(&self) -> i64 {
+ self.micros % 1000000 / 1000
+ }
+
+ /// The fractional number of microseconds that have passed
+ /// since the beginning of time.
+ pub const fn micros(&self) -> i64 {
+ self.micros % 1000000
+ }
+
+ /// The number of whole seconds that have passed since the
+ /// beginning of time.
+ pub const fn secs(&self) -> i64 {
+ self.micros / 1000000
+ }
+
+ /// The total number of milliseconds that have passed since
+ /// the beginning of time.
+ pub const fn total_millis(&self) -> i64 {
+ self.micros / 1000
+ }
+ /// The total number of milliseconds that have passed since
+ /// the beginning of time.
+ pub const fn total_micros(&self) -> i64 {
+ self.micros
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<::std::time::Instant> for Instant {
+ fn from(other: ::std::time::Instant) -> Instant {
+ let elapsed = other.elapsed();
+ Instant::from_micros((elapsed.as_secs() * 1_000000) as i64 + elapsed.subsec_micros() as i64)
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<::std::time::SystemTime> for Instant {
+ fn from(other: ::std::time::SystemTime) -> Instant {
+ let n = other
+ .duration_since(::std::time::UNIX_EPOCH)
+ .expect("start time must not be before the unix epoch");
+ Self::from_micros(n.as_secs() as i64 * 1000000 + n.subsec_micros() as i64)
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<Instant> for ::std::time::SystemTime {
+ fn from(val: Instant) -> Self {
+ ::std::time::UNIX_EPOCH + ::std::time::Duration::from_micros(val.micros as u64)
+ }
+}
+
+impl fmt::Display for Instant {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}.{:0>3}s", self.secs(), self.millis())
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Instant {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(f, "{}.{:03}s", self.secs(), self.millis());
+ }
+}
+
+impl ops::Add<Duration> for Instant {
+ type Output = Instant;
+
+ fn add(self, rhs: Duration) -> Instant {
+ Instant::from_micros(self.micros + rhs.total_micros() as i64)
+ }
+}
+
+impl ops::AddAssign<Duration> for Instant {
+ fn add_assign(&mut self, rhs: Duration) {
+ self.micros += rhs.total_micros() as i64;
+ }
+}
+
+impl ops::Sub<Duration> for Instant {
+ type Output = Instant;
+
+ fn sub(self, rhs: Duration) -> Instant {
+ Instant::from_micros(self.micros - rhs.total_micros() as i64)
+ }
+}
+
+impl ops::SubAssign<Duration> for Instant {
+ fn sub_assign(&mut self, rhs: Duration) {
+ self.micros -= rhs.total_micros() as i64;
+ }
+}
+
+impl ops::Sub<Instant> for Instant {
+ type Output = Duration;
+
+ fn sub(self, rhs: Instant) -> Duration {
+ Duration::from_micros((self.micros - rhs.micros).unsigned_abs())
+ }
+}
+
+/// A relative amount of time.
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Duration {
+ micros: u64,
+}
+
+impl Duration {
+ pub const ZERO: Duration = Duration::from_micros(0);
+ /// The longest possible duration we can encode.
+ pub const MAX: Duration = Duration::from_micros(u64::MAX);
+ /// Create a new `Duration` from a number of microseconds.
+ pub const fn from_micros(micros: u64) -> Duration {
+ Duration { micros }
+ }
+
+ /// Create a new `Duration` from a number of milliseconds.
+ pub const fn from_millis(millis: u64) -> Duration {
+ Duration {
+ micros: millis * 1000,
+ }
+ }
+
+ /// Create a new `Instant` from a number of seconds.
+ pub const fn from_secs(secs: u64) -> Duration {
+ Duration {
+ micros: secs * 1000000,
+ }
+ }
+
+ /// The fractional number of milliseconds in this `Duration`.
+ pub const fn millis(&self) -> u64 {
+ self.micros / 1000 % 1000
+ }
+
+ /// The fractional number of milliseconds in this `Duration`.
+ pub const fn micros(&self) -> u64 {
+ self.micros % 1000000
+ }
+
+ /// The number of whole seconds in this `Duration`.
+ pub const fn secs(&self) -> u64 {
+ self.micros / 1000000
+ }
+
+ /// The total number of milliseconds in this `Duration`.
+ pub const fn total_millis(&self) -> u64 {
+ self.micros / 1000
+ }
+
+ /// The total number of microseconds in this `Duration`.
+ pub const fn total_micros(&self) -> u64 {
+ self.micros
+ }
+}
+
+impl fmt::Display for Duration {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}.{:03}s", self.secs(), self.millis())
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Duration {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(f, "{}.{:03}s", self.secs(), self.millis());
+ }
+}
+
+impl ops::Add<Duration> for Duration {
+ type Output = Duration;
+
+ fn add(self, rhs: Duration) -> Duration {
+ Duration::from_micros(self.micros + rhs.total_micros())
+ }
+}
+
+impl ops::AddAssign<Duration> for Duration {
+ fn add_assign(&mut self, rhs: Duration) {
+ self.micros += rhs.total_micros();
+ }
+}
+
+impl ops::Sub<Duration> for Duration {
+ type Output = Duration;
+
+ fn sub(self, rhs: Duration) -> Duration {
+ Duration::from_micros(
+ self.micros
+ .checked_sub(rhs.total_micros())
+ .expect("overflow when subtracting durations"),
+ )
+ }
+}
+
+impl ops::SubAssign<Duration> for Duration {
+ fn sub_assign(&mut self, rhs: Duration) {
+ self.micros = self
+ .micros
+ .checked_sub(rhs.total_micros())
+ .expect("overflow when subtracting durations");
+ }
+}
+
+impl ops::Mul<u32> for Duration {
+ type Output = Duration;
+
+ fn mul(self, rhs: u32) -> Duration {
+ Duration::from_micros(self.micros * rhs as u64)
+ }
+}
+
+impl ops::MulAssign<u32> for Duration {
+ fn mul_assign(&mut self, rhs: u32) {
+ self.micros *= rhs as u64;
+ }
+}
+
+impl ops::Div<u32> for Duration {
+ type Output = Duration;
+
+ fn div(self, rhs: u32) -> Duration {
+ Duration::from_micros(self.micros / rhs as u64)
+ }
+}
+
+impl ops::DivAssign<u32> for Duration {
+ fn div_assign(&mut self, rhs: u32) {
+ self.micros /= rhs as u64;
+ }
+}
+
+impl ops::Shl<u32> for Duration {
+ type Output = Duration;
+
+ fn shl(self, rhs: u32) -> Duration {
+ Duration::from_micros(self.micros << rhs)
+ }
+}
+
+impl ops::ShlAssign<u32> for Duration {
+ fn shl_assign(&mut self, rhs: u32) {
+ self.micros <<= rhs;
+ }
+}
+
+impl ops::Shr<u32> for Duration {
+ type Output = Duration;
+
+ fn shr(self, rhs: u32) -> Duration {
+ Duration::from_micros(self.micros >> rhs)
+ }
+}
+
+impl ops::ShrAssign<u32> for Duration {
+ fn shr_assign(&mut self, rhs: u32) {
+ self.micros >>= rhs;
+ }
+}
+
+impl From<::core::time::Duration> for Duration {
+ fn from(other: ::core::time::Duration) -> Duration {
+ Duration::from_micros(other.as_secs() * 1000000 + other.subsec_micros() as u64)
+ }
+}
+
+impl From<Duration> for ::core::time::Duration {
+ fn from(val: Duration) -> Self {
+ ::core::time::Duration::from_micros(val.total_micros())
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn test_instant_ops() {
+ // std::ops::Add
+ assert_eq!(
+ Instant::from_millis(4) + Duration::from_millis(6),
+ Instant::from_millis(10)
+ );
+ // std::ops::Sub
+ assert_eq!(
+ Instant::from_millis(7) - Duration::from_millis(5),
+ Instant::from_millis(2)
+ );
+ }
+
+ #[test]
+ fn test_instant_getters() {
+ let instant = Instant::from_millis(5674);
+ assert_eq!(instant.secs(), 5);
+ assert_eq!(instant.millis(), 674);
+ assert_eq!(instant.total_millis(), 5674);
+ }
+
+ #[test]
+ fn test_instant_display() {
+ assert_eq!(format!("{}", Instant::from_millis(74)), "0.074s");
+ assert_eq!(format!("{}", Instant::from_millis(5674)), "5.674s");
+ assert_eq!(format!("{}", Instant::from_millis(5000)), "5.000s");
+ }
+
+ #[test]
+ #[cfg(feature = "std")]
+ fn test_instant_conversions() {
+ let mut epoc: ::std::time::SystemTime = Instant::from_millis(0).into();
+ assert_eq!(
+ Instant::from(::std::time::UNIX_EPOCH),
+ Instant::from_millis(0)
+ );
+ assert_eq!(epoc, ::std::time::UNIX_EPOCH);
+ epoc = Instant::from_millis(2085955200i64 * 1000).into();
+ assert_eq!(
+ epoc,
+ ::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(2085955200)
+ );
+ }
+
+ #[test]
+ fn test_duration_ops() {
+ // std::ops::Add
+ assert_eq!(
+ Duration::from_millis(40) + Duration::from_millis(2),
+ Duration::from_millis(42)
+ );
+ // std::ops::Sub
+ assert_eq!(
+ Duration::from_millis(555) - Duration::from_millis(42),
+ Duration::from_millis(513)
+ );
+ // std::ops::Mul
+ assert_eq!(Duration::from_millis(13) * 22, Duration::from_millis(286));
+ // std::ops::Div
+ assert_eq!(Duration::from_millis(53) / 4, Duration::from_micros(13250));
+ }
+
+ #[test]
+ fn test_duration_assign_ops() {
+ let mut duration = Duration::from_millis(4735);
+ duration += Duration::from_millis(1733);
+ assert_eq!(duration, Duration::from_millis(6468));
+ duration -= Duration::from_millis(1234);
+ assert_eq!(duration, Duration::from_millis(5234));
+ duration *= 4;
+ assert_eq!(duration, Duration::from_millis(20936));
+ duration /= 5;
+ assert_eq!(duration, Duration::from_micros(4187200));
+ }
+
+ #[test]
+ #[should_panic(expected = "overflow when subtracting durations")]
+ fn test_sub_from_zero_overflow() {
+ let _ = Duration::from_millis(0) - Duration::from_millis(1);
+ }
+
+ #[test]
+ #[should_panic(expected = "attempt to divide by zero")]
+ fn test_div_by_zero() {
+ let _ = Duration::from_millis(4) / 0;
+ }
+
+ #[test]
+ fn test_duration_getters() {
+ let instant = Duration::from_millis(4934);
+ assert_eq!(instant.secs(), 4);
+ assert_eq!(instant.millis(), 934);
+ assert_eq!(instant.total_millis(), 4934);
+ }
+
+ #[test]
+ fn test_duration_conversions() {
+ let mut std_duration = ::core::time::Duration::from_millis(4934);
+ let duration: Duration = std_duration.into();
+ assert_eq!(duration, Duration::from_millis(4934));
+ assert_eq!(Duration::from(std_duration), Duration::from_millis(4934));
+
+ std_duration = duration.into();
+ assert_eq!(std_duration, ::core::time::Duration::from_millis(4934));
+ }
+}
diff --git a/src/wire/arp.rs b/src/wire/arp.rs
new file mode 100644
index 0000000..bb0df3a
--- /dev/null
+++ b/src/wire/arp.rs
@@ -0,0 +1,458 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::fmt;
+
+use super::{Error, Result};
+
+pub use super::EthernetProtocol as Protocol;
+
+enum_with_unknown! {
+ /// ARP hardware type.
+ pub enum Hardware(u16) {
+ Ethernet = 1
+ }
+}
+
+enum_with_unknown! {
+ /// ARP operation type.
+ pub enum Operation(u16) {
+ Request = 1,
+ Reply = 2
+ }
+}
+
+/// A read/write wrapper around an Address Resolution Protocol packet buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::*;
+
+ pub const HTYPE: Field = 0..2;
+ pub const PTYPE: Field = 2..4;
+ pub const HLEN: usize = 4;
+ pub const PLEN: usize = 5;
+ pub const OPER: Field = 6..8;
+
+ #[inline]
+ pub const fn SHA(hardware_len: u8, _protocol_len: u8) -> Field {
+ let start = OPER.end;
+ start..(start + hardware_len as usize)
+ }
+
+ #[inline]
+ pub const fn SPA(hardware_len: u8, protocol_len: u8) -> Field {
+ let start = SHA(hardware_len, protocol_len).end;
+ start..(start + protocol_len as usize)
+ }
+
+ #[inline]
+ pub const fn THA(hardware_len: u8, protocol_len: u8) -> Field {
+ let start = SPA(hardware_len, protocol_len).end;
+ start..(start + hardware_len as usize)
+ }
+
+ #[inline]
+ pub const fn TPA(hardware_len: u8, protocol_len: u8) -> Field {
+ let start = THA(hardware_len, protocol_len).end;
+ start..(start + protocol_len as usize)
+ }
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with ARP packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_hardware_len] or
+ /// [set_protocol_len].
+ ///
+ /// [set_hardware_len]: #method.set_hardware_len
+ /// [set_protocol_len]: #method.set_protocol_len
+ #[allow(clippy::if_same_then_else)]
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::OPER.end {
+ Err(Error)
+ } else if len < field::TPA(self.hardware_len(), self.protocol_len()).end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the hardware type field.
+ #[inline]
+ pub fn hardware_type(&self) -> Hardware {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::HTYPE]);
+ Hardware::from(raw)
+ }
+
+ /// Return the protocol type field.
+ #[inline]
+ pub fn protocol_type(&self) -> Protocol {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::PTYPE]);
+ Protocol::from(raw)
+ }
+
+ /// Return the hardware length field.
+ #[inline]
+ pub fn hardware_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::HLEN]
+ }
+
+ /// Return the protocol length field.
+ #[inline]
+ pub fn protocol_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::PLEN]
+ }
+
+ /// Return the operation field.
+ #[inline]
+ pub fn operation(&self) -> Operation {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::OPER]);
+ Operation::from(raw)
+ }
+
+ /// Return the source hardware address field.
+ pub fn source_hardware_addr(&self) -> &[u8] {
+ let data = self.buffer.as_ref();
+ &data[field::SHA(self.hardware_len(), self.protocol_len())]
+ }
+
+ /// Return the source protocol address field.
+ pub fn source_protocol_addr(&self) -> &[u8] {
+ let data = self.buffer.as_ref();
+ &data[field::SPA(self.hardware_len(), self.protocol_len())]
+ }
+
+ /// Return the target hardware address field.
+ pub fn target_hardware_addr(&self) -> &[u8] {
+ let data = self.buffer.as_ref();
+ &data[field::THA(self.hardware_len(), self.protocol_len())]
+ }
+
+ /// Return the target protocol address field.
+ pub fn target_protocol_addr(&self) -> &[u8] {
+ let data = self.buffer.as_ref();
+ &data[field::TPA(self.hardware_len(), self.protocol_len())]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the hardware type field.
+ #[inline]
+ pub fn set_hardware_type(&mut self, value: Hardware) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::HTYPE], value.into())
+ }
+
+ /// Set the protocol type field.
+ #[inline]
+ pub fn set_protocol_type(&mut self, value: Protocol) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::PTYPE], value.into())
+ }
+
+ /// Set the hardware length field.
+ #[inline]
+ pub fn set_hardware_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::HLEN] = value
+ }
+
+ /// Set the protocol length field.
+ #[inline]
+ pub fn set_protocol_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::PLEN] = value
+ }
+
+ /// Set the operation field.
+ #[inline]
+ pub fn set_operation(&mut self, value: Operation) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::OPER], value.into())
+ }
+
+ /// Set the source hardware address field.
+ ///
+ /// # Panics
+ /// The function panics if `value` is not `self.hardware_len()` long.
+ pub fn set_source_hardware_addr(&mut self, value: &[u8]) {
+ let (hardware_len, protocol_len) = (self.hardware_len(), self.protocol_len());
+ let data = self.buffer.as_mut();
+ data[field::SHA(hardware_len, protocol_len)].copy_from_slice(value)
+ }
+
+ /// Set the source protocol address field.
+ ///
+ /// # Panics
+ /// The function panics if `value` is not `self.protocol_len()` long.
+ pub fn set_source_protocol_addr(&mut self, value: &[u8]) {
+ let (hardware_len, protocol_len) = (self.hardware_len(), self.protocol_len());
+ let data = self.buffer.as_mut();
+ data[field::SPA(hardware_len, protocol_len)].copy_from_slice(value)
+ }
+
+ /// Set the target hardware address field.
+ ///
+ /// # Panics
+ /// The function panics if `value` is not `self.hardware_len()` long.
+ pub fn set_target_hardware_addr(&mut self, value: &[u8]) {
+ let (hardware_len, protocol_len) = (self.hardware_len(), self.protocol_len());
+ let data = self.buffer.as_mut();
+ data[field::THA(hardware_len, protocol_len)].copy_from_slice(value)
+ }
+
+ /// Set the target protocol address field.
+ ///
+ /// # Panics
+ /// The function panics if `value` is not `self.protocol_len()` long.
+ pub fn set_target_protocol_addr(&mut self, value: &[u8]) {
+ let (hardware_len, protocol_len) = (self.hardware_len(), self.protocol_len());
+ let data = self.buffer.as_mut();
+ data[field::TPA(hardware_len, protocol_len)].copy_from_slice(value)
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+use crate::wire::{EthernetAddress, Ipv4Address};
+
+/// A high-level representation of an Address Resolution Protocol packet.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Repr {
+ /// An Ethernet and IPv4 Address Resolution Protocol packet.
+ EthernetIpv4 {
+ operation: Operation,
+ source_hardware_addr: EthernetAddress,
+ source_protocol_addr: Ipv4Address,
+ target_hardware_addr: EthernetAddress,
+ target_protocol_addr: Ipv4Address,
+ },
+}
+
+impl Repr {
+ /// Parse an Address Resolution Protocol packet and return a high-level representation,
+ /// or return `Err(Error)` if the packet is not recognized.
+ pub fn parse<T: AsRef<[u8]>>(packet: &Packet<T>) -> Result<Repr> {
+ match (
+ packet.hardware_type(),
+ packet.protocol_type(),
+ packet.hardware_len(),
+ packet.protocol_len(),
+ ) {
+ (Hardware::Ethernet, Protocol::Ipv4, 6, 4) => Ok(Repr::EthernetIpv4 {
+ operation: packet.operation(),
+ source_hardware_addr: EthernetAddress::from_bytes(packet.source_hardware_addr()),
+ source_protocol_addr: Ipv4Address::from_bytes(packet.source_protocol_addr()),
+ target_hardware_addr: EthernetAddress::from_bytes(packet.target_hardware_addr()),
+ target_protocol_addr: Ipv4Address::from_bytes(packet.target_protocol_addr()),
+ }),
+ _ => Err(Error),
+ }
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ match *self {
+ Repr::EthernetIpv4 { .. } => field::TPA(6, 4).end,
+ }
+ }
+
+ /// Emit a high-level representation into an Address Resolution Protocol packet.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
+ match *self {
+ Repr::EthernetIpv4 {
+ operation,
+ source_hardware_addr,
+ source_protocol_addr,
+ target_hardware_addr,
+ target_protocol_addr,
+ } => {
+ packet.set_hardware_type(Hardware::Ethernet);
+ packet.set_protocol_type(Protocol::Ipv4);
+ packet.set_hardware_len(6);
+ packet.set_protocol_len(4);
+ packet.set_operation(operation);
+ packet.set_source_hardware_addr(source_hardware_addr.as_bytes());
+ packet.set_source_protocol_addr(source_protocol_addr.as_bytes());
+ packet.set_target_hardware_addr(target_hardware_addr.as_bytes());
+ packet.set_target_protocol_addr(target_protocol_addr.as_bytes());
+ }
+ }
+ }
+}
+
+impl<T: AsRef<[u8]>> fmt::Display for Packet<T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self) {
+ Ok(repr) => write!(f, "{repr}"),
+ _ => {
+ write!(f, "ARP (unrecognized)")?;
+ write!(
+ f,
+ " htype={:?} ptype={:?} hlen={:?} plen={:?} op={:?}",
+ self.hardware_type(),
+ self.protocol_type(),
+ self.hardware_len(),
+ self.protocol_len(),
+ self.operation()
+ )?;
+ write!(
+ f,
+ " sha={:?} spa={:?} tha={:?} tpa={:?}",
+ self.source_hardware_addr(),
+ self.source_protocol_addr(),
+ self.target_hardware_addr(),
+ self.target_protocol_addr()
+ )?;
+ Ok(())
+ }
+ }
+ }
+}
+
+impl fmt::Display for Repr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Repr::EthernetIpv4 {
+ operation,
+ source_hardware_addr,
+ source_protocol_addr,
+ target_hardware_addr,
+ target_protocol_addr,
+ } => {
+ write!(
+ f,
+ "ARP type=Ethernet+IPv4 src={source_hardware_addr}/{source_protocol_addr} tgt={target_hardware_addr}/{target_protocol_addr} op={operation:?}"
+ )
+ }
+ }
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ match Packet::new_checked(buffer) {
+ Err(err) => write!(f, "{indent}({err})"),
+ Ok(packet) => write!(f, "{indent}{packet}"),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ static PACKET_BYTES: [u8; 28] = [
+ 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x21,
+ 0x22, 0x23, 0x24, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x41, 0x42, 0x43, 0x44,
+ ];
+
+ #[test]
+ fn test_deconstruct() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ assert_eq!(packet.hardware_type(), Hardware::Ethernet);
+ assert_eq!(packet.protocol_type(), Protocol::Ipv4);
+ assert_eq!(packet.hardware_len(), 6);
+ assert_eq!(packet.protocol_len(), 4);
+ assert_eq!(packet.operation(), Operation::Request);
+ assert_eq!(
+ packet.source_hardware_addr(),
+ &[0x11, 0x12, 0x13, 0x14, 0x15, 0x16]
+ );
+ assert_eq!(packet.source_protocol_addr(), &[0x21, 0x22, 0x23, 0x24]);
+ assert_eq!(
+ packet.target_hardware_addr(),
+ &[0x31, 0x32, 0x33, 0x34, 0x35, 0x36]
+ );
+ assert_eq!(packet.target_protocol_addr(), &[0x41, 0x42, 0x43, 0x44]);
+ }
+
+ #[test]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; 28];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_hardware_type(Hardware::Ethernet);
+ packet.set_protocol_type(Protocol::Ipv4);
+ packet.set_hardware_len(6);
+ packet.set_protocol_len(4);
+ packet.set_operation(Operation::Request);
+ packet.set_source_hardware_addr(&[0x11, 0x12, 0x13, 0x14, 0x15, 0x16]);
+ packet.set_source_protocol_addr(&[0x21, 0x22, 0x23, 0x24]);
+ packet.set_target_hardware_addr(&[0x31, 0x32, 0x33, 0x34, 0x35, 0x36]);
+ packet.set_target_protocol_addr(&[0x41, 0x42, 0x43, 0x44]);
+ assert_eq!(&*packet.into_inner(), &PACKET_BYTES[..]);
+ }
+
+ fn packet_repr() -> Repr {
+ Repr::EthernetIpv4 {
+ operation: Operation::Request,
+ source_hardware_addr: EthernetAddress::from_bytes(&[
+ 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
+ ]),
+ source_protocol_addr: Ipv4Address::from_bytes(&[0x21, 0x22, 0x23, 0x24]),
+ target_hardware_addr: EthernetAddress::from_bytes(&[
+ 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+ ]),
+ target_protocol_addr: Ipv4Address::from_bytes(&[0x41, 0x42, 0x43, 0x44]),
+ }
+ }
+
+ #[test]
+ fn test_parse() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ let repr = Repr::parse(&packet).unwrap();
+ assert_eq!(repr, packet_repr());
+ }
+
+ #[test]
+ fn test_emit() {
+ let mut bytes = vec![0xa5; 28];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet_repr().emit(&mut packet);
+ assert_eq!(&*packet.into_inner(), &PACKET_BYTES[..]);
+ }
+}
diff --git a/src/wire/dhcpv4.rs b/src/wire/dhcpv4.rs
new file mode 100644
index 0000000..cae9129
--- /dev/null
+++ b/src/wire/dhcpv4.rs
@@ -0,0 +1,1315 @@
+// See https://tools.ietf.org/html/rfc2131 for the DHCP specification.
+
+use bitflags::bitflags;
+use byteorder::{ByteOrder, NetworkEndian};
+use core::iter;
+use heapless::Vec;
+
+use super::{Error, Result};
+use crate::wire::arp::Hardware;
+use crate::wire::{EthernetAddress, Ipv4Address};
+
+pub const SERVER_PORT: u16 = 67;
+pub const CLIENT_PORT: u16 = 68;
+pub const MAX_DNS_SERVER_COUNT: usize = 3;
+
+const DHCP_MAGIC_NUMBER: u32 = 0x63825363;
+
+enum_with_unknown! {
+ /// The possible opcodes of a DHCP packet.
+ pub enum OpCode(u8) {
+ Request = 1,
+ Reply = 2,
+ }
+}
+
+enum_with_unknown! {
+ /// The possible message types of a DHCP packet.
+ pub enum MessageType(u8) {
+ Discover = 1,
+ Offer = 2,
+ Request = 3,
+ Decline = 4,
+ Ack = 5,
+ Nak = 6,
+ Release = 7,
+ Inform = 8,
+ }
+}
+
+bitflags! {
+ pub struct Flags: u16 {
+ const BROADCAST = 0b1000_0000_0000_0000;
+ }
+}
+
+impl MessageType {
+ const fn opcode(&self) -> OpCode {
+ match *self {
+ MessageType::Discover
+ | MessageType::Inform
+ | MessageType::Request
+ | MessageType::Decline
+ | MessageType::Release => OpCode::Request,
+ MessageType::Offer | MessageType::Ack | MessageType::Nak => OpCode::Reply,
+ MessageType::Unknown(_) => OpCode::Unknown(0),
+ }
+ }
+}
+
+/// A buffer for DHCP options.
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct DhcpOptionWriter<'a> {
+ /// The underlying buffer, directly from the DHCP packet representation.
+ buffer: &'a mut [u8],
+}
+
+impl<'a> DhcpOptionWriter<'a> {
+ pub fn new(buffer: &'a mut [u8]) -> Self {
+ Self { buffer }
+ }
+
+ /// Emit a [`DhcpOption`] into a [`DhcpOptionWriter`].
+ pub fn emit(&mut self, option: DhcpOption<'_>) -> Result<()> {
+ if option.data.len() > u8::MAX as _ {
+ return Err(Error);
+ }
+
+ let total_len = 2 + option.data.len();
+ if self.buffer.len() < total_len {
+ return Err(Error);
+ }
+
+ let (buf, rest) = core::mem::take(&mut self.buffer).split_at_mut(total_len);
+ self.buffer = rest;
+
+ buf[0] = option.kind;
+ buf[1] = option.data.len() as _;
+ buf[2..].copy_from_slice(option.data);
+
+ Ok(())
+ }
+
+ pub fn end(&mut self) -> Result<()> {
+ if self.buffer.is_empty() {
+ return Err(Error);
+ }
+
+ self.buffer[0] = field::OPT_END;
+ self.buffer = &mut [];
+ Ok(())
+ }
+}
+
+/// A representation of a single DHCP option.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct DhcpOption<'a> {
+ pub kind: u8,
+ pub data: &'a [u8],
+}
+
+/// A read/write wrapper around a Dynamic Host Configuration Protocol packet buffer.
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+pub(crate) mod field {
+ #![allow(non_snake_case)]
+ #![allow(unused)]
+
+ use crate::wire::field::*;
+
+ pub const OP: usize = 0;
+ pub const HTYPE: usize = 1;
+ pub const HLEN: usize = 2;
+ pub const HOPS: usize = 3;
+ pub const XID: Field = 4..8;
+ pub const SECS: Field = 8..10;
+ pub const FLAGS: Field = 10..12;
+ pub const CIADDR: Field = 12..16;
+ pub const YIADDR: Field = 16..20;
+ pub const SIADDR: Field = 20..24;
+ pub const GIADDR: Field = 24..28;
+ pub const CHADDR: Field = 28..34;
+ pub const SNAME: Field = 34..108;
+ pub const FILE: Field = 108..236;
+ pub const MAGIC_NUMBER: Field = 236..240;
+ pub const OPTIONS: Rest = 240..;
+
+ // Vendor Extensions
+ pub const OPT_END: u8 = 255;
+ pub const OPT_PAD: u8 = 0;
+ pub const OPT_SUBNET_MASK: u8 = 1;
+ pub const OPT_TIME_OFFSET: u8 = 2;
+ pub const OPT_ROUTER: u8 = 3;
+ pub const OPT_TIME_SERVER: u8 = 4;
+ pub const OPT_NAME_SERVER: u8 = 5;
+ pub const OPT_DOMAIN_NAME_SERVER: u8 = 6;
+ pub const OPT_LOG_SERVER: u8 = 7;
+ pub const OPT_COOKIE_SERVER: u8 = 8;
+ pub const OPT_LPR_SERVER: u8 = 9;
+ pub const OPT_IMPRESS_SERVER: u8 = 10;
+ pub const OPT_RESOURCE_LOCATION_SERVER: u8 = 11;
+ pub const OPT_HOST_NAME: u8 = 12;
+ pub const OPT_BOOT_FILE_SIZE: u8 = 13;
+ pub const OPT_MERIT_DUMP: u8 = 14;
+ pub const OPT_DOMAIN_NAME: u8 = 15;
+ pub const OPT_SWAP_SERVER: u8 = 16;
+ pub const OPT_ROOT_PATH: u8 = 17;
+ pub const OPT_EXTENSIONS_PATH: u8 = 18;
+
+ // IP Layer Parameters per Host
+ pub const OPT_IP_FORWARDING: u8 = 19;
+ pub const OPT_NON_LOCAL_SOURCE_ROUTING: u8 = 20;
+ pub const OPT_POLICY_FILTER: u8 = 21;
+ pub const OPT_MAX_DATAGRAM_REASSEMBLY_SIZE: u8 = 22;
+ pub const OPT_DEFAULT_TTL: u8 = 23;
+ pub const OPT_PATH_MTU_AGING_TIMEOUT: u8 = 24;
+ pub const OPT_PATH_MTU_PLATEAU_TABLE: u8 = 25;
+
+ // IP Layer Parameters per Interface
+ pub const OPT_INTERFACE_MTU: u8 = 26;
+ pub const OPT_ALL_SUBNETS_ARE_LOCAL: u8 = 27;
+ pub const OPT_BROADCAST_ADDRESS: u8 = 28;
+ pub const OPT_PERFORM_MASK_DISCOVERY: u8 = 29;
+ pub const OPT_MASK_SUPPLIER: u8 = 30;
+ pub const OPT_PERFORM_ROUTER_DISCOVERY: u8 = 31;
+ pub const OPT_ROUTER_SOLICITATION_ADDRESS: u8 = 32;
+ pub const OPT_STATIC_ROUTE: u8 = 33;
+
+ // Link Layer Parameters per Interface
+ pub const OPT_TRAILER_ENCAPSULATION: u8 = 34;
+ pub const OPT_ARP_CACHE_TIMEOUT: u8 = 35;
+ pub const OPT_ETHERNET_ENCAPSULATION: u8 = 36;
+
+ // TCP Parameters
+ pub const OPT_TCP_DEFAULT_TTL: u8 = 37;
+ pub const OPT_TCP_KEEPALIVE_INTERVAL: u8 = 38;
+ pub const OPT_TCP_KEEPALIVE_GARBAGE: u8 = 39;
+
+ // Application and Service Parameters
+ pub const OPT_NIS_DOMAIN: u8 = 40;
+ pub const OPT_NIS_SERVERS: u8 = 41;
+ pub const OPT_NTP_SERVERS: u8 = 42;
+ pub const OPT_VENDOR_SPECIFIC_INFO: u8 = 43;
+ pub const OPT_NETBIOS_NAME_SERVER: u8 = 44;
+ pub const OPT_NETBIOS_DISTRIBUTION_SERVER: u8 = 45;
+ pub const OPT_NETBIOS_NODE_TYPE: u8 = 46;
+ pub const OPT_NETBIOS_SCOPE: u8 = 47;
+ pub const OPT_X_WINDOW_FONT_SERVER: u8 = 48;
+ pub const OPT_X_WINDOW_DISPLAY_MANAGER: u8 = 49;
+ pub const OPT_NIS_PLUS_DOMAIN: u8 = 64;
+ pub const OPT_NIS_PLUS_SERVERS: u8 = 65;
+ pub const OPT_MOBILE_IP_HOME_AGENT: u8 = 68;
+ pub const OPT_SMTP_SERVER: u8 = 69;
+ pub const OPT_POP3_SERVER: u8 = 70;
+ pub const OPT_NNTP_SERVER: u8 = 71;
+ pub const OPT_WWW_SERVER: u8 = 72;
+ pub const OPT_FINGER_SERVER: u8 = 73;
+ pub const OPT_IRC_SERVER: u8 = 74;
+ pub const OPT_STREETTALK_SERVER: u8 = 75;
+ pub const OPT_STDA_SERVER: u8 = 76;
+
+ // DHCP Extensions
+ pub const OPT_REQUESTED_IP: u8 = 50;
+ pub const OPT_IP_LEASE_TIME: u8 = 51;
+ pub const OPT_OPTION_OVERLOAD: u8 = 52;
+ pub const OPT_TFTP_SERVER_NAME: u8 = 66;
+ pub const OPT_BOOTFILE_NAME: u8 = 67;
+ pub const OPT_DHCP_MESSAGE_TYPE: u8 = 53;
+ pub const OPT_SERVER_IDENTIFIER: u8 = 54;
+ pub const OPT_PARAMETER_REQUEST_LIST: u8 = 55;
+ pub const OPT_MESSAGE: u8 = 56;
+ pub const OPT_MAX_DHCP_MESSAGE_SIZE: u8 = 57;
+ pub const OPT_RENEWAL_TIME_VALUE: u8 = 58;
+ pub const OPT_REBINDING_TIME_VALUE: u8 = 59;
+ pub const OPT_VENDOR_CLASS_ID: u8 = 60;
+ pub const OPT_CLIENT_ID: u8 = 61;
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with DHCP packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// [set_header_len]: #method.set_header_len
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::MAGIC_NUMBER.end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Returns the operation code of this packet.
+ pub fn opcode(&self) -> OpCode {
+ let data = self.buffer.as_ref();
+ OpCode::from(data[field::OP])
+ }
+
+ /// Returns the hardware protocol type (e.g. ethernet).
+ pub fn hardware_type(&self) -> Hardware {
+ let data = self.buffer.as_ref();
+ Hardware::from(u16::from(data[field::HTYPE]))
+ }
+
+ /// Returns the length of a hardware address in bytes (e.g. 6 for ethernet).
+ pub fn hardware_len(&self) -> u8 {
+ self.buffer.as_ref()[field::HLEN]
+ }
+
+ /// Returns the transaction ID.
+ ///
+ /// The transaction ID (called `xid` in the specification) is a random number used to
+ /// associate messages and responses between client and server. The number is chosen by
+ /// the client.
+ pub fn transaction_id(&self) -> u32 {
+ let field = &self.buffer.as_ref()[field::XID];
+ NetworkEndian::read_u32(field)
+ }
+
+ /// Returns the hardware address of the client (called `chaddr` in the specification).
+ ///
+ /// Only ethernet is supported by `smoltcp`, so this functions returns
+ /// an `EthernetAddress`.
+ pub fn client_hardware_address(&self) -> EthernetAddress {
+ let field = &self.buffer.as_ref()[field::CHADDR];
+ EthernetAddress::from_bytes(field)
+ }
+
+ /// Returns the value of the `hops` field.
+ ///
+ /// The `hops` field is set to zero by clients and optionally used by relay agents.
+ pub fn hops(&self) -> u8 {
+ self.buffer.as_ref()[field::HOPS]
+ }
+
+ /// Returns the value of the `secs` field.
+ ///
+ /// The secs field is filled by clients and describes the number of seconds elapsed
+ /// since client began process.
+ pub fn secs(&self) -> u16 {
+ let field = &self.buffer.as_ref()[field::SECS];
+ NetworkEndian::read_u16(field)
+ }
+
+ /// Returns the value of the `magic cookie` field in the DHCP options.
+ ///
+ /// This field should be always be `0x63825363`.
+ pub fn magic_number(&self) -> u32 {
+ let field = &self.buffer.as_ref()[field::MAGIC_NUMBER];
+ NetworkEndian::read_u32(field)
+ }
+
+ /// Returns the Ipv4 address of the client, zero if not set.
+ ///
+ /// This corresponds to the `ciaddr` field in the DHCP specification. According to it,
+ /// this field is “only filled in if client is in `BOUND`, `RENEW` or `REBINDING` state
+ /// and can respond to ARP requests”.
+ pub fn client_ip(&self) -> Ipv4Address {
+ let field = &self.buffer.as_ref()[field::CIADDR];
+ Ipv4Address::from_bytes(field)
+ }
+
+ /// Returns the value of the `yiaddr` field, zero if not set.
+ pub fn your_ip(&self) -> Ipv4Address {
+ let field = &self.buffer.as_ref()[field::YIADDR];
+ Ipv4Address::from_bytes(field)
+ }
+
+ /// Returns the value of the `siaddr` field, zero if not set.
+ pub fn server_ip(&self) -> Ipv4Address {
+ let field = &self.buffer.as_ref()[field::SIADDR];
+ Ipv4Address::from_bytes(field)
+ }
+
+ /// Returns the value of the `giaddr` field, zero if not set.
+ pub fn relay_agent_ip(&self) -> Ipv4Address {
+ let field = &self.buffer.as_ref()[field::GIADDR];
+ Ipv4Address::from_bytes(field)
+ }
+
+ pub fn flags(&self) -> Flags {
+ let field = &self.buffer.as_ref()[field::FLAGS];
+ Flags::from_bits_truncate(NetworkEndian::read_u16(field))
+ }
+
+ /// Return an iterator over the options.
+ #[inline]
+ pub fn options(&self) -> impl Iterator<Item = DhcpOption<'_>> + '_ {
+ let mut buf = &self.buffer.as_ref()[field::OPTIONS];
+ iter::from_fn(move || {
+ loop {
+ match buf.first().copied() {
+ // No more options, return.
+ None => return None,
+ Some(field::OPT_END) => return None,
+
+ // Skip padding.
+ Some(field::OPT_PAD) => buf = &buf[1..],
+ Some(kind) => {
+ if buf.len() < 2 {
+ return None;
+ }
+
+ let len = buf[1] as usize;
+
+ if buf.len() < 2 + len {
+ return None;
+ }
+
+ let opt = DhcpOption {
+ kind,
+ data: &buf[2..2 + len],
+ };
+
+ buf = &buf[2 + len..];
+ return Some(opt);
+ }
+ }
+ }
+ })
+ }
+
+ pub fn get_sname(&self) -> Result<&str> {
+ let data = &self.buffer.as_ref()[field::SNAME];
+ let len = data.iter().position(|&x| x == 0).ok_or(Error)?;
+ if len == 0 {
+ return Err(Error);
+ }
+
+ let data = core::str::from_utf8(&data[..len]).map_err(|_| Error)?;
+ Ok(data)
+ }
+
+ pub fn get_boot_file(&self) -> Result<&str> {
+ let data = &self.buffer.as_ref()[field::FILE];
+ let len = data.iter().position(|&x| x == 0).ok_or(Error)?;
+ if len == 0 {
+ return Err(Error);
+ }
+ let data = core::str::from_utf8(&data[..len]).map_err(|_| Error)?;
+ Ok(data)
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Sets the optional `sname` (“server name”) and `file` (“boot file name”) fields to zero.
+ ///
+ /// The fields are not commonly used, so we set their value always to zero. **This method
+ /// must be called when creating a packet, otherwise the emitted values for these fields
+ /// are undefined!**
+ pub fn set_sname_and_boot_file_to_zero(&mut self) {
+ let data = self.buffer.as_mut();
+ for byte in &mut data[field::SNAME] {
+ *byte = 0;
+ }
+ for byte in &mut data[field::FILE] {
+ *byte = 0;
+ }
+ }
+
+ /// Sets the `OpCode` for the packet.
+ pub fn set_opcode(&mut self, value: OpCode) {
+ let data = self.buffer.as_mut();
+ data[field::OP] = value.into();
+ }
+
+ /// Sets the hardware address type (only ethernet is supported).
+ pub fn set_hardware_type(&mut self, value: Hardware) {
+ let data = self.buffer.as_mut();
+ let number: u16 = value.into();
+ assert!(number <= u16::from(u8::max_value())); // TODO: Replace with TryFrom when it's stable
+ data[field::HTYPE] = number as u8;
+ }
+
+ /// Sets the hardware address length.
+ ///
+ /// Only ethernet is supported, so this field should be set to the value `6`.
+ pub fn set_hardware_len(&mut self, value: u8) {
+ self.buffer.as_mut()[field::HLEN] = value;
+ }
+
+ /// Sets the transaction ID.
+ ///
+ /// The transaction ID (called `xid` in the specification) is a random number used to
+ /// associate messages and responses between client and server. The number is chosen by
+ /// the client.
+ pub fn set_transaction_id(&mut self, value: u32) {
+ let field = &mut self.buffer.as_mut()[field::XID];
+ NetworkEndian::write_u32(field, value)
+ }
+
+ /// Sets the ethernet address of the client.
+ ///
+ /// Sets the `chaddr` field.
+ pub fn set_client_hardware_address(&mut self, value: EthernetAddress) {
+ let field = &mut self.buffer.as_mut()[field::CHADDR];
+ field.copy_from_slice(value.as_bytes());
+ }
+
+ /// Sets the hops field.
+ ///
+ /// The `hops` field is set to zero by clients and optionally used by relay agents.
+ pub fn set_hops(&mut self, value: u8) {
+ self.buffer.as_mut()[field::HOPS] = value;
+ }
+
+ /// Sets the `secs` field.
+ ///
+ /// The secs field is filled by clients and describes the number of seconds elapsed
+ /// since client began process.
+ pub fn set_secs(&mut self, value: u16) {
+ let field = &mut self.buffer.as_mut()[field::SECS];
+ NetworkEndian::write_u16(field, value);
+ }
+
+ /// Sets the value of the `magic cookie` field in the DHCP options.
+ ///
+ /// This field should be always be `0x63825363`.
+ pub fn set_magic_number(&mut self, value: u32) {
+ let field = &mut self.buffer.as_mut()[field::MAGIC_NUMBER];
+ NetworkEndian::write_u32(field, value);
+ }
+
+ /// Sets the Ipv4 address of the client.
+ ///
+ /// This corresponds to the `ciaddr` field in the DHCP specification. According to it,
+ /// this field is “only filled in if client is in `BOUND`, `RENEW` or `REBINDING` state
+ /// and can respond to ARP requests”.
+ pub fn set_client_ip(&mut self, value: Ipv4Address) {
+ let field = &mut self.buffer.as_mut()[field::CIADDR];
+ field.copy_from_slice(value.as_bytes());
+ }
+
+ /// Sets the value of the `yiaddr` field.
+ pub fn set_your_ip(&mut self, value: Ipv4Address) {
+ let field = &mut self.buffer.as_mut()[field::YIADDR];
+ field.copy_from_slice(value.as_bytes());
+ }
+
+ /// Sets the value of the `siaddr` field.
+ pub fn set_server_ip(&mut self, value: Ipv4Address) {
+ let field = &mut self.buffer.as_mut()[field::SIADDR];
+ field.copy_from_slice(value.as_bytes());
+ }
+
+ /// Sets the value of the `giaddr` field.
+ pub fn set_relay_agent_ip(&mut self, value: Ipv4Address) {
+ let field = &mut self.buffer.as_mut()[field::GIADDR];
+ field.copy_from_slice(value.as_bytes());
+ }
+
+ /// Sets the flags to the specified value.
+ pub fn set_flags(&mut self, val: Flags) {
+ let field = &mut self.buffer.as_mut()[field::FLAGS];
+ NetworkEndian::write_u16(field, val.bits());
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> Packet<&'a mut T> {
+ /// Return a pointer to the options.
+ #[inline]
+ pub fn options_mut(&mut self) -> DhcpOptionWriter<'_> {
+ DhcpOptionWriter::new(&mut self.buffer.as_mut()[field::OPTIONS])
+ }
+}
+
+/// A high-level representation of a Dynamic Host Configuration Protocol packet.
+///
+/// DHCP messages have the following layout (see [RFC 2131](https://tools.ietf.org/html/rfc2131)
+/// for details):
+///
+/// ```no_rust
+/// 0 1 2 3
+/// 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
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | message_type | htype (N/A) | hlen (N/A) | hops |
+/// +---------------+---------------+---------------+---------------+
+/// | transaction_id |
+/// +-------------------------------+-------------------------------+
+/// | secs | flags |
+/// +-------------------------------+-------------------------------+
+/// | client_ip |
+/// +---------------------------------------------------------------+
+/// | your_ip |
+/// +---------------------------------------------------------------+
+/// | server_ip |
+/// +---------------------------------------------------------------+
+/// | relay_agent_ip |
+/// +---------------------------------------------------------------+
+/// | |
+/// | client_hardware_address |
+/// | |
+/// | |
+/// +---------------------------------------------------------------+
+/// | |
+/// | sname (N/A) |
+/// +---------------------------------------------------------------+
+/// | |
+/// | file (N/A) |
+/// +---------------------------------------------------------------+
+/// | |
+/// | options |
+/// +---------------------------------------------------------------+
+/// ```
+///
+/// It is assumed that the access layer is Ethernet, so `htype` (the field representing the
+/// hardware address type) is always set to `1`, and `hlen` (which represents the hardware address
+/// length) is set to `6`.
+///
+/// The `options` field has a variable length.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr<'a> {
+ /// This field is also known as `op` in the RFC. It indicates the type of DHCP message this
+ /// packet represents.
+ pub message_type: MessageType,
+ /// This field is also known as `xid` in the RFC. It is a random number chosen by the client,
+ /// used by the client and server to associate messages and responses between a client and a
+ /// server.
+ pub transaction_id: u32,
+ /// seconds elapsed since client began address acquisition or renewal
+ /// process the DHCPREQUEST message MUST use the same value in the DHCP
+ /// message header's 'secs' field and be sent to the same IP broadcast
+ /// address as the original DHCPDISCOVER message.
+ pub secs: u16,
+ /// This field is also known as `chaddr` in the RFC and for networks where the access layer is
+ /// ethernet, it is the client MAC address.
+ pub client_hardware_address: EthernetAddress,
+ /// This field is also known as `ciaddr` in the RFC. It is only filled in if client is in
+ /// BOUND, RENEW or REBINDING state and can respond to ARP requests.
+ pub client_ip: Ipv4Address,
+ /// This field is also known as `yiaddr` in the RFC.
+ pub your_ip: Ipv4Address,
+ /// This field is also known as `siaddr` in the RFC. It may be set by the server in DHCPOFFER
+ /// and DHCPACK messages, and represent the address of the next server to use in bootstrap.
+ pub server_ip: Ipv4Address,
+ /// Default gateway
+ pub router: Option<Ipv4Address>,
+ /// This field comes from a corresponding DhcpOption.
+ pub subnet_mask: Option<Ipv4Address>,
+ /// This field is also known as `giaddr` in the RFC. In order to allow DHCP clients on subnets
+ /// not directly served by DHCP servers to communicate with DHCP servers, DHCP relay agents can
+ /// be installed on these subnets. The DHCP client broadcasts on the local link; the relay
+ /// agent receives the broadcast and transmits it to one or more DHCP servers using unicast.
+ /// The relay agent stores its own IP address in the `relay_agent_ip` field of the DHCP packet.
+ /// The DHCP server uses the `relay_agent_ip` to determine the subnet on which the relay agent
+ /// received the broadcast, and allocates an IP address on that subnet. When the DHCP server
+ /// replies to the client, it sends the reply to the `relay_agent_ip` address, again using
+ /// unicast. The relay agent then retransmits the response on the local network
+ pub relay_agent_ip: Ipv4Address,
+ /// Broadcast flags. It can be set in DHCPDISCOVER, DHCPINFORM and DHCPREQUEST message if the
+ /// client requires the response to be broadcasted.
+ pub broadcast: bool,
+ /// The "requested IP address" option. It can be used by clients in DHCPREQUEST or DHCPDISCOVER
+ /// messages, or by servers in DHCPDECLINE messages.
+ pub requested_ip: Option<Ipv4Address>,
+ /// The "client identifier" option.
+ ///
+ /// The 'client identifier' is an opaque key, not to be interpreted by the server; for example,
+ /// the 'client identifier' may contain a hardware address, identical to the contents of the
+ /// 'chaddr' field, or it may contain another type of identifier, such as a DNS name. The
+ /// 'client identifier' chosen by a DHCP client MUST be unique to that client within the subnet
+ /// to which the client is attached. If the client uses a 'client identifier' in one message,
+ /// it MUST use that same identifier in all subsequent messages, to ensure that all servers
+ /// correctly identify the client.
+ pub client_identifier: Option<EthernetAddress>,
+ /// The "server identifier" option. It is used both to identify a DHCP server
+ /// in a DHCP message and as a destination address from clients to servers.
+ pub server_identifier: Option<Ipv4Address>,
+ /// The parameter request list informs the server about which configuration parameters
+ /// the client is interested in.
+ pub parameter_request_list: Option<&'a [u8]>,
+ /// DNS servers
+ pub dns_servers: Option<Vec<Ipv4Address, MAX_DNS_SERVER_COUNT>>,
+ /// The maximum size dhcp packet the interface can receive
+ pub max_size: Option<u16>,
+ /// The DHCP IP lease duration, specified in seconds.
+ pub lease_duration: Option<u32>,
+ /// The DHCP IP renew duration (T1 interval), in seconds, if specified in the packet.
+ pub renew_duration: Option<u32>,
+ /// The DHCP IP rebind duration (T2 interval), in seconds, if specified in the packet.
+ pub rebind_duration: Option<u32>,
+ /// When returned from [`Repr::parse`], this field will be `None`.
+ /// However, when calling [`Repr::emit`], this field should contain only
+ /// additional DHCP options not known to smoltcp.
+ pub additional_options: &'a [DhcpOption<'a>],
+}
+
+impl<'a> Repr<'a> {
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub fn buffer_len(&self) -> usize {
+ let mut len = field::OPTIONS.start;
+ // message type and end-of-options options
+ len += 3 + 1;
+ if self.requested_ip.is_some() {
+ len += 6;
+ }
+ if self.client_identifier.is_some() {
+ len += 9;
+ }
+ if self.server_identifier.is_some() {
+ len += 6;
+ }
+ if self.max_size.is_some() {
+ len += 4;
+ }
+ if self.router.is_some() {
+ len += 6;
+ }
+ if self.subnet_mask.is_some() {
+ len += 6;
+ }
+ if self.lease_duration.is_some() {
+ len += 6;
+ }
+ if let Some(dns_servers) = &self.dns_servers {
+ len += 2;
+ len += dns_servers.iter().count() * core::mem::size_of::<u32>();
+ }
+ if let Some(list) = self.parameter_request_list {
+ len += list.len() + 2;
+ }
+ for opt in self.additional_options {
+ len += 2 + opt.data.len()
+ }
+
+ len
+ }
+
+ /// Parse a DHCP packet and return a high-level representation.
+ pub fn parse<T>(packet: &'a Packet<&'a T>) -> Result<Self>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ let transaction_id = packet.transaction_id();
+ let client_hardware_address = packet.client_hardware_address();
+ let client_ip = packet.client_ip();
+ let your_ip = packet.your_ip();
+ let server_ip = packet.server_ip();
+ let relay_agent_ip = packet.relay_agent_ip();
+ let secs = packet.secs();
+
+ // only ethernet is supported right now
+ match packet.hardware_type() {
+ Hardware::Ethernet => {
+ if packet.hardware_len() != 6 {
+ return Err(Error);
+ }
+ }
+ Hardware::Unknown(_) => return Err(Error), // unimplemented
+ }
+
+ if packet.magic_number() != DHCP_MAGIC_NUMBER {
+ return Err(Error);
+ }
+
+ let mut message_type = Err(Error);
+ let mut requested_ip = None;
+ let mut client_identifier = None;
+ let mut server_identifier = None;
+ let mut router = None;
+ let mut subnet_mask = None;
+ let mut parameter_request_list = None;
+ let mut dns_servers = None;
+ let mut max_size = None;
+ let mut lease_duration = None;
+ let mut renew_duration = None;
+ let mut rebind_duration = None;
+
+ for option in packet.options() {
+ let data = option.data;
+ match (option.kind, data.len()) {
+ (field::OPT_DHCP_MESSAGE_TYPE, 1) => {
+ let value = MessageType::from(data[0]);
+ if value.opcode() == packet.opcode() {
+ message_type = Ok(value);
+ }
+ }
+ (field::OPT_REQUESTED_IP, 4) => {
+ requested_ip = Some(Ipv4Address::from_bytes(data));
+ }
+ (field::OPT_CLIENT_ID, 7) => {
+ let hardware_type = Hardware::from(u16::from(data[0]));
+ if hardware_type != Hardware::Ethernet {
+ return Err(Error);
+ }
+ client_identifier = Some(EthernetAddress::from_bytes(&data[1..]));
+ }
+ (field::OPT_SERVER_IDENTIFIER, 4) => {
+ server_identifier = Some(Ipv4Address::from_bytes(data));
+ }
+ (field::OPT_ROUTER, 4) => {
+ router = Some(Ipv4Address::from_bytes(data));
+ }
+ (field::OPT_SUBNET_MASK, 4) => {
+ subnet_mask = Some(Ipv4Address::from_bytes(data));
+ }
+ (field::OPT_MAX_DHCP_MESSAGE_SIZE, 2) => {
+ max_size = Some(u16::from_be_bytes([data[0], data[1]]));
+ }
+ (field::OPT_RENEWAL_TIME_VALUE, 4) => {
+ renew_duration = Some(u32::from_be_bytes([data[0], data[1], data[2], data[3]]))
+ }
+ (field::OPT_REBINDING_TIME_VALUE, 4) => {
+ rebind_duration = Some(u32::from_be_bytes([data[0], data[1], data[2], data[3]]))
+ }
+ (field::OPT_IP_LEASE_TIME, 4) => {
+ lease_duration = Some(u32::from_be_bytes([data[0], data[1], data[2], data[3]]))
+ }
+ (field::OPT_PARAMETER_REQUEST_LIST, _) => {
+ parameter_request_list = Some(data);
+ }
+ (field::OPT_DOMAIN_NAME_SERVER, _) => {
+ let mut servers = Vec::new();
+ const IP_ADDR_BYTE_LEN: usize = 4;
+ let mut addrs = data.chunks_exact(IP_ADDR_BYTE_LEN);
+ for chunk in &mut addrs {
+ // We ignore push failures because that will only happen
+ // if we attempt to push more than 4 addresses, and the only
+ // solution to that is to support more addresses.
+ servers.push(Ipv4Address::from_bytes(chunk)).ok();
+ }
+ dns_servers = Some(servers);
+
+ if !addrs.remainder().is_empty() {
+ net_trace!("DHCP domain name servers contained invalid address");
+ }
+ }
+ _ => {}
+ }
+ }
+
+ let broadcast = packet.flags().contains(Flags::BROADCAST);
+
+ Ok(Repr {
+ secs,
+ transaction_id,
+ client_hardware_address,
+ client_ip,
+ your_ip,
+ server_ip,
+ relay_agent_ip,
+ broadcast,
+ requested_ip,
+ server_identifier,
+ router,
+ subnet_mask,
+ client_identifier,
+ parameter_request_list,
+ dns_servers,
+ max_size,
+ lease_duration,
+ renew_duration,
+ rebind_duration,
+ message_type: message_type?,
+ additional_options: &[],
+ })
+ }
+
+ /// Emit a high-level representation into a Dynamic Host
+ /// Configuration Protocol packet.
+ pub fn emit<T>(&self, packet: &mut Packet<&mut T>) -> Result<()>
+ where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ packet.set_sname_and_boot_file_to_zero();
+ packet.set_opcode(self.message_type.opcode());
+ packet.set_hardware_type(Hardware::Ethernet);
+ packet.set_hardware_len(6);
+ packet.set_transaction_id(self.transaction_id);
+ packet.set_client_hardware_address(self.client_hardware_address);
+ packet.set_hops(0);
+ packet.set_secs(self.secs);
+ packet.set_magic_number(0x63825363);
+ packet.set_client_ip(self.client_ip);
+ packet.set_your_ip(self.your_ip);
+ packet.set_server_ip(self.server_ip);
+ packet.set_relay_agent_ip(self.relay_agent_ip);
+
+ let mut flags = Flags::empty();
+ if self.broadcast {
+ flags |= Flags::BROADCAST;
+ }
+ packet.set_flags(flags);
+
+ {
+ let mut options = packet.options_mut();
+
+ options.emit(DhcpOption {
+ kind: field::OPT_DHCP_MESSAGE_TYPE,
+ data: &[self.message_type.into()],
+ })?;
+
+ if let Some(val) = &self.client_identifier {
+ let mut data = [0; 7];
+ data[0] = u16::from(Hardware::Ethernet) as u8;
+ data[1..].copy_from_slice(val.as_bytes());
+
+ options.emit(DhcpOption {
+ kind: field::OPT_CLIENT_ID,
+ data: &data,
+ })?;
+ }
+
+ if let Some(val) = &self.server_identifier {
+ options.emit(DhcpOption {
+ kind: field::OPT_SERVER_IDENTIFIER,
+ data: val.as_bytes(),
+ })?;
+ }
+
+ if let Some(val) = &self.router {
+ options.emit(DhcpOption {
+ kind: field::OPT_ROUTER,
+ data: val.as_bytes(),
+ })?;
+ }
+ if let Some(val) = &self.subnet_mask {
+ options.emit(DhcpOption {
+ kind: field::OPT_SUBNET_MASK,
+ data: val.as_bytes(),
+ })?;
+ }
+ if let Some(val) = &self.requested_ip {
+ options.emit(DhcpOption {
+ kind: field::OPT_REQUESTED_IP,
+ data: val.as_bytes(),
+ })?;
+ }
+ if let Some(val) = &self.max_size {
+ options.emit(DhcpOption {
+ kind: field::OPT_MAX_DHCP_MESSAGE_SIZE,
+ data: &val.to_be_bytes(),
+ })?;
+ }
+ if let Some(val) = &self.lease_duration {
+ options.emit(DhcpOption {
+ kind: field::OPT_IP_LEASE_TIME,
+ data: &val.to_be_bytes(),
+ })?;
+ }
+ if let Some(val) = &self.parameter_request_list {
+ options.emit(DhcpOption {
+ kind: field::OPT_PARAMETER_REQUEST_LIST,
+ data: val,
+ })?;
+ }
+
+ if let Some(dns_servers) = &self.dns_servers {
+ const IP_SIZE: usize = core::mem::size_of::<u32>();
+ let mut servers = [0; MAX_DNS_SERVER_COUNT * IP_SIZE];
+
+ let data_len = dns_servers
+ .iter()
+ .enumerate()
+ .inspect(|(i, ip)| {
+ servers[(i * IP_SIZE)..((i + 1) * IP_SIZE)].copy_from_slice(ip.as_bytes());
+ })
+ .count()
+ * IP_SIZE;
+ options.emit(DhcpOption {
+ kind: field::OPT_DOMAIN_NAME_SERVER,
+ data: &servers[..data_len],
+ })?;
+ }
+
+ for option in self.additional_options {
+ options.emit(*option)?;
+ }
+
+ options.end()?;
+ }
+
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::wire::Ipv4Address;
+
+ const MAGIC_COOKIE: u32 = 0x63825363;
+
+ static DISCOVER_BYTES: &[u8] = &[
+ 0x01, 0x01, 0x06, 0x00, 0x00, 0x00, 0x3d, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+ 0x82, 0x01, 0xfc, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x82, 0x53, 0x63,
+ 0x35, 0x01, 0x01, 0x3d, 0x07, 0x01, 0x00, 0x0b, 0x82, 0x01, 0xfc, 0x42, 0x32, 0x04, 0x00,
+ 0x00, 0x00, 0x00, 0x39, 0x2, 0x5, 0xdc, 0x37, 0x04, 0x01, 0x03, 0x06, 0x2a, 0xff, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ static ACK_DNS_SERVER_BYTES: &[u8] = &[
+ 0x02, 0x01, 0x06, 0x00, 0xcc, 0x34, 0x75, 0xab, 0x00, 0x00, 0x80, 0x00, 0x0a, 0xff, 0x06,
+ 0x91, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xff, 0x06, 0xfe, 0x34, 0x17,
+ 0xeb, 0xc9, 0xaa, 0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x82, 0x53, 0x63,
+ 0x35, 0x01, 0x05, 0x36, 0x04, 0xa3, 0x01, 0x4a, 0x16, 0x01, 0x04, 0xff, 0xff, 0xff, 0x00,
+ 0x2b, 0x05, 0xdc, 0x03, 0x4e, 0x41, 0x50, 0x0f, 0x15, 0x6e, 0x61, 0x74, 0x2e, 0x70, 0x68,
+ 0x79, 0x73, 0x69, 0x63, 0x73, 0x2e, 0x6f, 0x78, 0x2e, 0x61, 0x63, 0x2e, 0x75, 0x6b, 0x00,
+ 0x03, 0x04, 0x0a, 0xff, 0x06, 0xfe, 0x06, 0x10, 0xa3, 0x01, 0x4a, 0x06, 0xa3, 0x01, 0x4a,
+ 0x07, 0xa3, 0x01, 0x4a, 0x03, 0xa3, 0x01, 0x4a, 0x04, 0x2c, 0x10, 0xa3, 0x01, 0x4a, 0x03,
+ 0xa3, 0x01, 0x4a, 0x04, 0xa3, 0x01, 0x4a, 0x06, 0xa3, 0x01, 0x4a, 0x07, 0x2e, 0x01, 0x08,
+ 0xff,
+ ];
+
+ static ACK_LEASE_TIME_BYTES: &[u8] = &[
+ 0x02, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x0a, 0x22, 0x10, 0x0b, 0x0a, 0x22, 0x10, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x04, 0x91,
+ 0x62, 0xd2, 0xa8, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x82, 0x53, 0x63,
+ 0x35, 0x01, 0x05, 0x36, 0x04, 0x0a, 0x22, 0x10, 0x0a, 0x33, 0x04, 0x00, 0x00, 0x02, 0x56,
+ 0x01, 0x04, 0xff, 0xff, 0xff, 0x00, 0x03, 0x04, 0x0a, 0x22, 0x10, 0x0a, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ const IP_NULL: Ipv4Address = Ipv4Address([0, 0, 0, 0]);
+ const CLIENT_MAC: EthernetAddress = EthernetAddress([0x0, 0x0b, 0x82, 0x01, 0xfc, 0x42]);
+ const DHCP_SIZE: u16 = 1500;
+
+ #[test]
+ fn test_deconstruct_discover() {
+ let packet = Packet::new_unchecked(DISCOVER_BYTES);
+ assert_eq!(packet.magic_number(), MAGIC_COOKIE);
+ assert_eq!(packet.opcode(), OpCode::Request);
+ assert_eq!(packet.hardware_type(), Hardware::Ethernet);
+ assert_eq!(packet.hardware_len(), 6);
+ assert_eq!(packet.hops(), 0);
+ assert_eq!(packet.transaction_id(), 0x3d1d);
+ assert_eq!(packet.secs(), 0);
+ assert_eq!(packet.client_ip(), IP_NULL);
+ assert_eq!(packet.your_ip(), IP_NULL);
+ assert_eq!(packet.server_ip(), IP_NULL);
+ assert_eq!(packet.relay_agent_ip(), IP_NULL);
+ assert_eq!(packet.client_hardware_address(), CLIENT_MAC);
+
+ let mut options = packet.options();
+ assert_eq!(
+ options.next(),
+ Some(DhcpOption {
+ kind: field::OPT_DHCP_MESSAGE_TYPE,
+ data: &[0x01]
+ })
+ );
+ assert_eq!(
+ options.next(),
+ Some(DhcpOption {
+ kind: field::OPT_CLIENT_ID,
+ data: &[0x01, 0x00, 0x0b, 0x82, 0x01, 0xfc, 0x42],
+ })
+ );
+ assert_eq!(
+ options.next(),
+ Some(DhcpOption {
+ kind: field::OPT_REQUESTED_IP,
+ data: &[0x00, 0x00, 0x00, 0x00],
+ })
+ );
+ assert_eq!(
+ options.next(),
+ Some(DhcpOption {
+ kind: field::OPT_MAX_DHCP_MESSAGE_SIZE,
+ data: &DHCP_SIZE.to_be_bytes(),
+ })
+ );
+ assert_eq!(
+ options.next(),
+ Some(DhcpOption {
+ kind: field::OPT_PARAMETER_REQUEST_LIST,
+ data: &[1, 3, 6, 42]
+ })
+ );
+ assert_eq!(options.next(), None);
+ }
+
+ #[test]
+ fn test_construct_discover() {
+ let mut bytes = vec![0xa5; 276];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_magic_number(MAGIC_COOKIE);
+ packet.set_sname_and_boot_file_to_zero();
+ packet.set_opcode(OpCode::Request);
+ packet.set_hardware_type(Hardware::Ethernet);
+ packet.set_hardware_len(6);
+ packet.set_hops(0);
+ packet.set_transaction_id(0x3d1d);
+ packet.set_secs(0);
+ packet.set_flags(Flags::empty());
+ packet.set_client_ip(IP_NULL);
+ packet.set_your_ip(IP_NULL);
+ packet.set_server_ip(IP_NULL);
+ packet.set_relay_agent_ip(IP_NULL);
+ packet.set_client_hardware_address(CLIENT_MAC);
+
+ let mut options = packet.options_mut();
+
+ options
+ .emit(DhcpOption {
+ kind: field::OPT_DHCP_MESSAGE_TYPE,
+ data: &[0x01],
+ })
+ .unwrap();
+ options
+ .emit(DhcpOption {
+ kind: field::OPT_CLIENT_ID,
+ data: &[0x01, 0x00, 0x0b, 0x82, 0x01, 0xfc, 0x42],
+ })
+ .unwrap();
+ options
+ .emit(DhcpOption {
+ kind: field::OPT_REQUESTED_IP,
+ data: &[0x00, 0x00, 0x00, 0x00],
+ })
+ .unwrap();
+ options
+ .emit(DhcpOption {
+ kind: field::OPT_MAX_DHCP_MESSAGE_SIZE,
+ data: &DHCP_SIZE.to_be_bytes(),
+ })
+ .unwrap();
+ options
+ .emit(DhcpOption {
+ kind: field::OPT_PARAMETER_REQUEST_LIST,
+ data: &[1, 3, 6, 42],
+ })
+ .unwrap();
+ options.end().unwrap();
+
+ let packet = &mut packet.into_inner()[..];
+ for byte in &mut packet[269..276] {
+ *byte = 0; // padding bytes
+ }
+
+ assert_eq!(packet, DISCOVER_BYTES);
+ }
+
+ const fn offer_repr() -> Repr<'static> {
+ Repr {
+ message_type: MessageType::Offer,
+ transaction_id: 0x3d1d,
+ client_hardware_address: CLIENT_MAC,
+ client_ip: IP_NULL,
+ your_ip: IP_NULL,
+ server_ip: IP_NULL,
+ router: Some(IP_NULL),
+ subnet_mask: Some(IP_NULL),
+ relay_agent_ip: IP_NULL,
+ secs: 0,
+ broadcast: false,
+ requested_ip: None,
+ client_identifier: Some(CLIENT_MAC),
+ server_identifier: None,
+ parameter_request_list: None,
+ dns_servers: None,
+ max_size: None,
+ renew_duration: None,
+ rebind_duration: None,
+ lease_duration: Some(0xffff_ffff), // Infinite lease
+ additional_options: &[],
+ }
+ }
+
+ const fn discover_repr() -> Repr<'static> {
+ Repr {
+ message_type: MessageType::Discover,
+ transaction_id: 0x3d1d,
+ client_hardware_address: CLIENT_MAC,
+ client_ip: IP_NULL,
+ your_ip: IP_NULL,
+ server_ip: IP_NULL,
+ router: None,
+ subnet_mask: None,
+ relay_agent_ip: IP_NULL,
+ broadcast: false,
+ secs: 0,
+ max_size: Some(DHCP_SIZE),
+ renew_duration: None,
+ rebind_duration: None,
+ lease_duration: None,
+ requested_ip: Some(IP_NULL),
+ client_identifier: Some(CLIENT_MAC),
+ server_identifier: None,
+ parameter_request_list: Some(&[1, 3, 6, 42]),
+ dns_servers: None,
+ additional_options: &[],
+ }
+ }
+
+ #[test]
+ fn test_parse_discover() {
+ let packet = Packet::new_unchecked(DISCOVER_BYTES);
+ let repr = Repr::parse(&packet).unwrap();
+ assert_eq!(repr, discover_repr());
+ }
+
+ #[test]
+ fn test_emit_discover() {
+ let repr = discover_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet).unwrap();
+ let packet = &*packet.into_inner();
+ let packet_len = packet.len();
+ assert_eq!(packet, &DISCOVER_BYTES[..packet_len]);
+ for byte in &DISCOVER_BYTES[packet_len..] {
+ assert_eq!(*byte, 0); // padding bytes
+ }
+ }
+
+ #[test]
+ fn test_emit_offer() {
+ let repr = offer_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet).unwrap();
+ }
+
+ #[test]
+ fn test_emit_offer_dns() {
+ let repr = {
+ let mut repr = offer_repr();
+ repr.dns_servers = Some(
+ Vec::from_slice(&[
+ Ipv4Address([163, 1, 74, 6]),
+ Ipv4Address([163, 1, 74, 7]),
+ Ipv4Address([163, 1, 74, 3]),
+ ])
+ .unwrap(),
+ );
+ repr
+ };
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet).unwrap();
+
+ let packet = Packet::new_unchecked(&bytes);
+ let repr_parsed = Repr::parse(&packet).unwrap();
+
+ assert_eq!(
+ repr_parsed.dns_servers,
+ Some(
+ Vec::from_slice(&[
+ Ipv4Address([163, 1, 74, 6]),
+ Ipv4Address([163, 1, 74, 7]),
+ Ipv4Address([163, 1, 74, 3]),
+ ])
+ .unwrap()
+ )
+ );
+ }
+
+ #[test]
+ fn test_emit_dhcp_option() {
+ static DATA: &[u8] = &[1, 3, 6];
+ let dhcp_option = DhcpOption {
+ kind: field::OPT_PARAMETER_REQUEST_LIST,
+ data: DATA,
+ };
+
+ let mut bytes = vec![0xa5; 5];
+ let mut writer = DhcpOptionWriter::new(&mut bytes);
+ writer.emit(dhcp_option).unwrap();
+
+ assert_eq!(
+ &bytes[0..2],
+ &[field::OPT_PARAMETER_REQUEST_LIST, DATA.len() as u8]
+ );
+ assert_eq!(&bytes[2..], DATA);
+ }
+
+ #[test]
+ fn test_parse_ack_dns_servers() {
+ let packet = Packet::new_unchecked(ACK_DNS_SERVER_BYTES);
+ let repr = Repr::parse(&packet).unwrap();
+
+ // The packet described by ACK_BYTES advertises 4 DNS servers
+ // Here we ensure that we correctly parse the first 3 into our fixed
+ // length-3 array (see issue #305)
+ assert_eq!(
+ repr.dns_servers,
+ Some(
+ Vec::from_slice(&[
+ Ipv4Address([163, 1, 74, 6]),
+ Ipv4Address([163, 1, 74, 7]),
+ Ipv4Address([163, 1, 74, 3])
+ ])
+ .unwrap()
+ )
+ );
+ }
+
+ #[test]
+ fn test_parse_ack_lease_duration() {
+ let packet = Packet::new_unchecked(ACK_LEASE_TIME_BYTES);
+ let repr = Repr::parse(&packet).unwrap();
+
+ // Verify that the lease time in the ACK is properly parsed. The packet contains a lease
+ // duration of 598s.
+ assert_eq!(repr.lease_duration, Some(598));
+ }
+}
diff --git a/src/wire/dns.rs b/src/wire/dns.rs
new file mode 100644
index 0000000..2c9c10d
--- /dev/null
+++ b/src/wire/dns.rs
@@ -0,0 +1,793 @@
+#![allow(dead_code)]
+
+use bitflags::bitflags;
+use byteorder::{ByteOrder, NetworkEndian};
+use core::iter;
+use core::iter::Iterator;
+
+use super::{Error, Result};
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::Ipv4Address;
+#[cfg(feature = "proto-ipv6")]
+use crate::wire::Ipv6Address;
+
+enum_with_unknown! {
+ /// DNS OpCodes
+ pub enum Opcode(u8) {
+ Query = 0x00,
+ Status = 0x01,
+ }
+}
+enum_with_unknown! {
+ /// DNS OpCodes
+ pub enum Rcode(u8) {
+ NoError = 0x00,
+ FormErr = 0x01,
+ ServFail = 0x02,
+ NXDomain = 0x03,
+ NotImp = 0x04,
+ Refused = 0x05,
+ YXDomain = 0x06,
+ YXRRSet = 0x07,
+ NXRRSet = 0x08,
+ NotAuth = 0x09,
+ NotZone = 0x0a,
+ }
+}
+
+enum_with_unknown! {
+ /// DNS record types
+ pub enum Type(u16) {
+ A = 0x0001,
+ Ns = 0x0002,
+ Cname = 0x0005,
+ Soa = 0x0006,
+ Aaaa = 0x001c,
+ }
+}
+
+bitflags! {
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub struct Flags: u16 {
+ const RESPONSE = 0b1000_0000_0000_0000;
+ const AUTHORITATIVE = 0b0000_0100_0000_0000;
+ const TRUNCATED = 0b0000_0010_0000_0000;
+ const RECURSION_DESIRED = 0b0000_0001_0000_0000;
+ const RECURSION_AVAILABLE = 0b0000_0000_1000_0000;
+ const AUTHENTIC_DATA = 0b0000_0000_0010_0000;
+ const CHECK_DISABLED = 0b0000_0000_0001_0000;
+ }
+}
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const ID: Field = 0..2;
+ pub const FLAGS: Field = 2..4;
+ pub const QDCOUNT: Field = 4..6;
+ pub const ANCOUNT: Field = 6..8;
+ pub const NSCOUNT: Field = 8..10;
+ pub const ARCOUNT: Field = 10..12;
+
+ pub const HEADER_END: usize = 12;
+}
+
+// DNS class IN (Internet)
+const CLASS_IN: u16 = 1;
+
+/// A read/write wrapper around a DNS packet buffer.
+#[derive(Debug, PartialEq, Eq)]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with DNS packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is smaller than
+ /// the header length.
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::HEADER_END {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ pub fn payload(&self) -> &[u8] {
+ &self.buffer.as_ref()[field::HEADER_END..]
+ }
+
+ pub fn transaction_id(&self) -> u16 {
+ let field = &self.buffer.as_ref()[field::ID];
+ NetworkEndian::read_u16(field)
+ }
+
+ pub fn flags(&self) -> Flags {
+ let field = &self.buffer.as_ref()[field::FLAGS];
+ Flags::from_bits_truncate(NetworkEndian::read_u16(field))
+ }
+
+ pub fn opcode(&self) -> Opcode {
+ let field = &self.buffer.as_ref()[field::FLAGS];
+ let flags = NetworkEndian::read_u16(field);
+ Opcode::from((flags >> 11 & 0xF) as u8)
+ }
+
+ pub fn rcode(&self) -> Rcode {
+ let field = &self.buffer.as_ref()[field::FLAGS];
+ let flags = NetworkEndian::read_u16(field);
+ Rcode::from((flags & 0xF) as u8)
+ }
+
+ pub fn question_count(&self) -> u16 {
+ let field = &self.buffer.as_ref()[field::QDCOUNT];
+ NetworkEndian::read_u16(field)
+ }
+
+ pub fn answer_record_count(&self) -> u16 {
+ let field = &self.buffer.as_ref()[field::ANCOUNT];
+ NetworkEndian::read_u16(field)
+ }
+
+ pub fn authority_record_count(&self) -> u16 {
+ let field = &self.buffer.as_ref()[field::NSCOUNT];
+ NetworkEndian::read_u16(field)
+ }
+
+ pub fn additional_record_count(&self) -> u16 {
+ let field = &self.buffer.as_ref()[field::ARCOUNT];
+ NetworkEndian::read_u16(field)
+ }
+
+ /// Parse part of a name from `bytes`, following pointers if any.
+ pub fn parse_name<'a>(&'a self, mut bytes: &'a [u8]) -> impl Iterator<Item = Result<&'a [u8]>> {
+ let mut packet = self.buffer.as_ref();
+
+ iter::from_fn(move || loop {
+ if bytes.is_empty() {
+ return Some(Err(Error));
+ }
+ match bytes[0] {
+ 0x00 => return None,
+ x if x & 0xC0 == 0x00 => {
+ let len = (x & 0x3F) as usize;
+ if bytes.len() < 1 + len {
+ return Some(Err(Error));
+ }
+ let label = &bytes[1..1 + len];
+ bytes = &bytes[1 + len..];
+ return Some(Ok(label));
+ }
+ x if x & 0xC0 == 0xC0 => {
+ if bytes.len() < 2 {
+ return Some(Err(Error));
+ }
+ let y = bytes[1];
+ let ptr = ((x & 0x3F) as usize) << 8 | (y as usize);
+ if packet.len() <= ptr {
+ return Some(Err(Error));
+ }
+
+ // RFC1035 says: "In this scheme, an entire domain name or a list of labels at
+ // the end of a domain name is replaced with a pointer to a ***prior*** occurrence
+ // of the same name.
+ //
+ // Is it unclear if this means the pointer MUST point backwards in the packet or not. Either way,
+ // pointers that don't point backwards are never seen in the fields, so use this to check that
+ // there are no pointer loops.
+
+ // Split packet into parts before and after `ptr`.
+ // parse the part after, keep only the part before in `packet`. This ensure we never
+ // parse the same byte twice, therefore eliminating pointer loops.
+
+ bytes = &packet[ptr..];
+ packet = &packet[..ptr];
+ }
+ _ => return Some(Err(Error)),
+ }
+ })
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let data = self.buffer.as_mut();
+ &mut data[field::HEADER_END..]
+ }
+
+ pub fn set_transaction_id(&mut self, val: u16) {
+ let field = &mut self.buffer.as_mut()[field::ID];
+ NetworkEndian::write_u16(field, val)
+ }
+
+ pub fn set_flags(&mut self, val: Flags) {
+ let field = &mut self.buffer.as_mut()[field::FLAGS];
+ let mask = Flags::all().bits;
+ let old = NetworkEndian::read_u16(field);
+ NetworkEndian::write_u16(field, (old & !mask) | val.bits());
+ }
+
+ pub fn set_opcode(&mut self, val: Opcode) {
+ let field = &mut self.buffer.as_mut()[field::FLAGS];
+ let mask = 0x3800;
+ let val: u8 = val.into();
+ let val = (val as u16) << 11;
+ let old = NetworkEndian::read_u16(field);
+ NetworkEndian::write_u16(field, (old & !mask) | val);
+ }
+
+ pub fn set_question_count(&mut self, val: u16) {
+ let field = &mut self.buffer.as_mut()[field::QDCOUNT];
+ NetworkEndian::write_u16(field, val)
+ }
+ pub fn set_answer_record_count(&mut self, val: u16) {
+ let field = &mut self.buffer.as_mut()[field::ANCOUNT];
+ NetworkEndian::write_u16(field, val)
+ }
+ pub fn set_authority_record_count(&mut self, val: u16) {
+ let field = &mut self.buffer.as_mut()[field::NSCOUNT];
+ NetworkEndian::write_u16(field, val)
+ }
+ pub fn set_additional_record_count(&mut self, val: u16) {
+ let field = &mut self.buffer.as_mut()[field::ARCOUNT];
+ NetworkEndian::write_u16(field, val)
+ }
+}
+
+/// Parse part of a name from `bytes`, not following pointers.
+/// Returns the unused part of `bytes`, and the pointer offset if the sequence ends with a pointer.
+fn parse_name_part<'a>(
+ mut bytes: &'a [u8],
+ mut f: impl FnMut(&'a [u8]),
+) -> Result<(&'a [u8], Option<usize>)> {
+ loop {
+ let x = *bytes.first().ok_or(Error)?;
+ bytes = &bytes[1..];
+ match x {
+ 0x00 => return Ok((bytes, None)),
+ x if x & 0xC0 == 0x00 => {
+ let len = (x & 0x3F) as usize;
+ let label = bytes.get(..len).ok_or(Error)?;
+ bytes = &bytes[len..];
+ f(label);
+ }
+ x if x & 0xC0 == 0xC0 => {
+ let y = *bytes.first().ok_or(Error)?;
+ bytes = &bytes[1..];
+
+ let ptr = ((x & 0x3F) as usize) << 8 | (y as usize);
+ return Ok((bytes, Some(ptr)));
+ }
+ _ => return Err(Error),
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Question<'a> {
+ pub name: &'a [u8],
+ pub type_: Type,
+}
+
+impl<'a> Question<'a> {
+ pub fn parse(buffer: &'a [u8]) -> Result<(&'a [u8], Question<'a>)> {
+ let (rest, _) = parse_name_part(buffer, |_| ())?;
+ let name = &buffer[..buffer.len() - rest.len()];
+
+ if rest.len() < 4 {
+ return Err(Error);
+ }
+ let type_ = NetworkEndian::read_u16(&rest[0..2]).into();
+ let class = NetworkEndian::read_u16(&rest[2..4]);
+ let rest = &rest[4..];
+
+ if class != CLASS_IN {
+ return Err(Error);
+ }
+
+ Ok((rest, Question { name, type_ }))
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ self.name.len() + 4
+ }
+
+ /// Emit a high-level representation into a DNS packet.
+ pub fn emit(&self, packet: &mut [u8]) {
+ packet[..self.name.len()].copy_from_slice(self.name);
+ let rest = &mut packet[self.name.len()..];
+ NetworkEndian::write_u16(&mut rest[0..2], self.type_.into());
+ NetworkEndian::write_u16(&mut rest[2..4], CLASS_IN);
+ }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Record<'a> {
+ pub name: &'a [u8],
+ pub ttl: u32,
+ pub data: RecordData<'a>,
+}
+
+impl<'a> RecordData<'a> {
+ pub fn parse(type_: Type, data: &'a [u8]) -> Result<RecordData<'a>> {
+ match type_ {
+ #[cfg(feature = "proto-ipv4")]
+ Type::A => {
+ if data.len() != 4 {
+ return Err(Error);
+ }
+ Ok(RecordData::A(Ipv4Address::from_bytes(data)))
+ }
+ #[cfg(feature = "proto-ipv6")]
+ Type::Aaaa => {
+ if data.len() != 16 {
+ return Err(Error);
+ }
+ Ok(RecordData::Aaaa(Ipv6Address::from_bytes(data)))
+ }
+ Type::Cname => Ok(RecordData::Cname(data)),
+ x => Ok(RecordData::Other(x, data)),
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RecordData<'a> {
+ #[cfg(feature = "proto-ipv4")]
+ A(Ipv4Address),
+ #[cfg(feature = "proto-ipv6")]
+ Aaaa(Ipv6Address),
+ Cname(&'a [u8]),
+ Other(Type, &'a [u8]),
+}
+
+impl<'a> Record<'a> {
+ pub fn parse(buffer: &'a [u8]) -> Result<(&'a [u8], Record<'a>)> {
+ let (rest, _) = parse_name_part(buffer, |_| ())?;
+ let name = &buffer[..buffer.len() - rest.len()];
+
+ if rest.len() < 10 {
+ return Err(Error);
+ }
+ let type_ = NetworkEndian::read_u16(&rest[0..2]).into();
+ let class = NetworkEndian::read_u16(&rest[2..4]);
+ let ttl = NetworkEndian::read_u32(&rest[4..8]);
+ let len = NetworkEndian::read_u16(&rest[8..10]) as usize;
+ let rest = &rest[10..];
+
+ if class != CLASS_IN {
+ return Err(Error);
+ }
+
+ let data = rest.get(..len).ok_or(Error)?;
+ let rest = &rest[len..];
+
+ Ok((
+ rest,
+ Record {
+ name,
+ ttl,
+ data: RecordData::parse(type_, data)?,
+ },
+ ))
+ }
+}
+
+/// High-level DNS packet representation.
+///
+/// Currently only supports query packets.
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr<'a> {
+ pub transaction_id: u16,
+ pub opcode: Opcode,
+ pub flags: Flags,
+ pub question: Question<'a>,
+}
+
+impl<'a> Repr<'a> {
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ field::HEADER_END + self.question.buffer_len()
+ }
+
+ /// Emit a high-level representation into a DNS packet.
+ pub fn emit<T: ?Sized>(&self, packet: &mut Packet<&mut T>)
+ where
+ T: AsRef<[u8]> + AsMut<[u8]>,
+ {
+ packet.set_transaction_id(self.transaction_id);
+ packet.set_flags(self.flags);
+ packet.set_opcode(self.opcode);
+ packet.set_question_count(1);
+ packet.set_answer_record_count(0);
+ packet.set_authority_record_count(0);
+ packet.set_additional_record_count(0);
+ self.question.emit(packet.payload_mut())
+ }
+}
+
+#[cfg(feature = "proto-ipv4")] // tests assume ipv4
+#[cfg(test)]
+mod test {
+ use super::*;
+ use std::vec::Vec;
+
+ #[test]
+ fn test_parse_name() {
+ let bytes = &[
+ 0x78, 0x6c, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x03, 0x77,
+ 0x77, 0x77, 0x08, 0x66, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x03, 0x63, 0x6f,
+ 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00,
+ 0x05, 0xf3, 0x00, 0x11, 0x09, 0x73, 0x74, 0x61, 0x72, 0x2d, 0x6d, 0x69, 0x6e, 0x69,
+ 0x04, 0x63, 0x31, 0x30, 0x72, 0xc0, 0x10, 0xc0, 0x2e, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0x00, 0x00, 0x05, 0x00, 0x04, 0x1f, 0x0d, 0x53, 0x24,
+ ];
+ let packet = Packet::new_unchecked(bytes);
+
+ let name_vec = |bytes| {
+ let mut v = Vec::new();
+ packet
+ .parse_name(bytes)
+ .try_for_each(|label| label.map(|label| v.push(label)))
+ .map(|_| v)
+ };
+
+ //assert_eq!(parse_name_len(bytes, 0x0c), Ok(18));
+ assert_eq!(
+ name_vec(&bytes[0x0c..]),
+ Ok(vec![&b"www"[..], &b"facebook"[..], &b"com"[..]])
+ );
+ //assert_eq!(parse_name_len(bytes, 0x22), Ok(2));
+ assert_eq!(
+ name_vec(&bytes[0x22..]),
+ Ok(vec![&b"www"[..], &b"facebook"[..], &b"com"[..]])
+ );
+ //assert_eq!(parse_name_len(bytes, 0x2e), Ok(17));
+ assert_eq!(
+ name_vec(&bytes[0x2e..]),
+ Ok(vec![
+ &b"star-mini"[..],
+ &b"c10r"[..],
+ &b"facebook"[..],
+ &b"com"[..]
+ ])
+ );
+ //assert_eq!(parse_name_len(bytes, 0x3f), Ok(2));
+ assert_eq!(
+ name_vec(&bytes[0x3f..]),
+ Ok(vec![
+ &b"star-mini"[..],
+ &b"c10r"[..],
+ &b"facebook"[..],
+ &b"com"[..]
+ ])
+ );
+ }
+
+ struct Parsed<'a> {
+ packet: Packet<&'a [u8]>,
+ questions: Vec<Question<'a>>,
+ answers: Vec<Record<'a>>,
+ authorities: Vec<Record<'a>>,
+ additionals: Vec<Record<'a>>,
+ }
+
+ impl<'a> Parsed<'a> {
+ fn parse(bytes: &'a [u8]) -> Result<Self> {
+ let packet = Packet::new_unchecked(bytes);
+ let mut questions = Vec::new();
+ let mut answers = Vec::new();
+ let mut authorities = Vec::new();
+ let mut additionals = Vec::new();
+
+ let mut payload = &bytes[12..];
+
+ for _ in 0..packet.question_count() {
+ let (p, r) = Question::parse(payload)?;
+ questions.push(r);
+ payload = p;
+ }
+ for _ in 0..packet.answer_record_count() {
+ let (p, r) = Record::parse(payload)?;
+ answers.push(r);
+ payload = p;
+ }
+ for _ in 0..packet.authority_record_count() {
+ let (p, r) = Record::parse(payload)?;
+ authorities.push(r);
+ payload = p;
+ }
+ for _ in 0..packet.additional_record_count() {
+ let (p, r) = Record::parse(payload)?;
+ additionals.push(r);
+ payload = p;
+ }
+
+ // Check that there are no bytes left
+ assert_eq!(payload.len(), 0);
+
+ Ok(Parsed {
+ packet,
+ questions,
+ answers,
+ authorities,
+ additionals,
+ })
+ }
+ }
+
+ #[test]
+ fn test_parse_request() {
+ let p = Parsed::parse(&[
+ 0x51, 0x84, 0x01, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x67,
+ 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01,
+ ])
+ .unwrap();
+
+ assert_eq!(p.packet.transaction_id(), 0x5184);
+ assert_eq!(
+ p.packet.flags(),
+ Flags::RECURSION_DESIRED | Flags::AUTHENTIC_DATA
+ );
+ assert_eq!(p.packet.opcode(), Opcode::Query);
+ assert_eq!(p.packet.question_count(), 1);
+ assert_eq!(p.packet.answer_record_count(), 0);
+ assert_eq!(p.packet.authority_record_count(), 0);
+ assert_eq!(p.packet.additional_record_count(), 0);
+
+ assert_eq!(p.questions.len(), 1);
+ assert_eq!(
+ p.questions[0].name,
+ &[0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00]
+ );
+ assert_eq!(p.questions[0].type_, Type::A);
+
+ assert_eq!(p.answers.len(), 0);
+ assert_eq!(p.authorities.len(), 0);
+ assert_eq!(p.additionals.len(), 0);
+ }
+
+ #[test]
+ fn test_parse_response() {
+ let p = Parsed::parse(&[
+ 0x51, 0x84, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x06, 0x67,
+ 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01,
+ 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xca, 0x00, 0x04, 0xac, 0xd9,
+ 0xa8, 0xae,
+ ])
+ .unwrap();
+
+ assert_eq!(p.packet.transaction_id(), 0x5184);
+ assert_eq!(
+ p.packet.flags(),
+ Flags::RESPONSE | Flags::RECURSION_DESIRED | Flags::RECURSION_AVAILABLE
+ );
+ assert_eq!(p.packet.opcode(), Opcode::Query);
+ assert_eq!(p.packet.rcode(), Rcode::NoError);
+ assert_eq!(p.packet.question_count(), 1);
+ assert_eq!(p.packet.answer_record_count(), 1);
+ assert_eq!(p.packet.authority_record_count(), 0);
+ assert_eq!(p.packet.additional_record_count(), 0);
+
+ assert_eq!(
+ p.questions[0].name,
+ &[0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00]
+ );
+ assert_eq!(p.questions[0].type_, Type::A);
+
+ assert_eq!(p.answers[0].name, &[0xc0, 0x0c]);
+ assert_eq!(p.answers[0].ttl, 202);
+ assert_eq!(
+ p.answers[0].data,
+ RecordData::A(Ipv4Address::new(0xac, 0xd9, 0xa8, 0xae))
+ );
+ }
+
+ #[test]
+ fn test_parse_response_multiple_a() {
+ let p = Parsed::parse(&[
+ 0x4b, 0x9e, 0x81, 0x80, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x09, 0x72,
+ 0x75, 0x73, 0x74, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x03, 0x6f, 0x72, 0x67, 0x00, 0x00,
+ 0x01, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00,
+ 0x04, 0x0d, 0xe0, 0x77, 0x35, 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x09, 0x00, 0x04, 0x0d, 0xe0, 0x77, 0x28, 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0x00, 0x00, 0x09, 0x00, 0x04, 0x0d, 0xe0, 0x77, 0x43, 0xc0, 0x0c, 0x00, 0x01, 0x00,
+ 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x04, 0x0d, 0xe0, 0x77, 0x62,
+ ])
+ .unwrap();
+
+ assert_eq!(p.packet.transaction_id(), 0x4b9e);
+ assert_eq!(
+ p.packet.flags(),
+ Flags::RESPONSE | Flags::RECURSION_DESIRED | Flags::RECURSION_AVAILABLE
+ );
+ assert_eq!(p.packet.opcode(), Opcode::Query);
+ assert_eq!(p.packet.rcode(), Rcode::NoError);
+ assert_eq!(p.packet.question_count(), 1);
+ assert_eq!(p.packet.answer_record_count(), 4);
+ assert_eq!(p.packet.authority_record_count(), 0);
+ assert_eq!(p.packet.additional_record_count(), 0);
+
+ assert_eq!(
+ p.questions[0].name,
+ &[
+ 0x09, 0x72, 0x75, 0x73, 0x74, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x03, 0x6f, 0x72, 0x67,
+ 0x00
+ ]
+ );
+ assert_eq!(p.questions[0].type_, Type::A);
+
+ assert_eq!(p.answers[0].name, &[0xc0, 0x0c]);
+ assert_eq!(p.answers[0].ttl, 9);
+ assert_eq!(
+ p.answers[0].data,
+ RecordData::A(Ipv4Address::new(0x0d, 0xe0, 0x77, 0x35))
+ );
+
+ assert_eq!(p.answers[1].name, &[0xc0, 0x0c]);
+ assert_eq!(p.answers[1].ttl, 9);
+ assert_eq!(
+ p.answers[1].data,
+ RecordData::A(Ipv4Address::new(0x0d, 0xe0, 0x77, 0x28))
+ );
+
+ assert_eq!(p.answers[2].name, &[0xc0, 0x0c]);
+ assert_eq!(p.answers[2].ttl, 9);
+ assert_eq!(
+ p.answers[2].data,
+ RecordData::A(Ipv4Address::new(0x0d, 0xe0, 0x77, 0x43))
+ );
+
+ assert_eq!(p.answers[3].name, &[0xc0, 0x0c]);
+ assert_eq!(p.answers[3].ttl, 9);
+ assert_eq!(
+ p.answers[3].data,
+ RecordData::A(Ipv4Address::new(0x0d, 0xe0, 0x77, 0x62))
+ );
+ }
+
+ #[test]
+ fn test_parse_response_cname() {
+ let p = Parsed::parse(&[
+ 0x78, 0x6c, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x03, 0x77,
+ 0x77, 0x77, 0x08, 0x66, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x03, 0x63, 0x6f,
+ 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00,
+ 0x05, 0xf3, 0x00, 0x11, 0x09, 0x73, 0x74, 0x61, 0x72, 0x2d, 0x6d, 0x69, 0x6e, 0x69,
+ 0x04, 0x63, 0x31, 0x30, 0x72, 0xc0, 0x10, 0xc0, 0x2e, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0x00, 0x00, 0x05, 0x00, 0x04, 0x1f, 0x0d, 0x53, 0x24,
+ ])
+ .unwrap();
+
+ assert_eq!(p.packet.transaction_id(), 0x786c);
+ assert_eq!(
+ p.packet.flags(),
+ Flags::RESPONSE | Flags::RECURSION_DESIRED | Flags::RECURSION_AVAILABLE
+ );
+ assert_eq!(p.packet.opcode(), Opcode::Query);
+ assert_eq!(p.packet.rcode(), Rcode::NoError);
+ assert_eq!(p.packet.question_count(), 1);
+ assert_eq!(p.packet.answer_record_count(), 2);
+ assert_eq!(p.packet.authority_record_count(), 0);
+ assert_eq!(p.packet.additional_record_count(), 0);
+
+ assert_eq!(
+ p.questions[0].name,
+ &[
+ 0x03, 0x77, 0x77, 0x77, 0x08, 0x66, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x03,
+ 0x63, 0x6f, 0x6d, 0x00
+ ]
+ );
+ assert_eq!(p.questions[0].type_, Type::A);
+
+ // cname
+ assert_eq!(p.answers[0].name, &[0xc0, 0x0c]);
+ assert_eq!(p.answers[0].ttl, 1523);
+ assert_eq!(
+ p.answers[0].data,
+ RecordData::Cname(&[
+ 0x09, 0x73, 0x74, 0x61, 0x72, 0x2d, 0x6d, 0x69, 0x6e, 0x69, 0x04, 0x63, 0x31, 0x30,
+ 0x72, 0xc0, 0x10
+ ])
+ );
+ // a
+ assert_eq!(p.answers[1].name, &[0xc0, 0x2e]);
+ assert_eq!(p.answers[1].ttl, 5);
+ assert_eq!(
+ p.answers[1].data,
+ RecordData::A(Ipv4Address::new(0x1f, 0x0d, 0x53, 0x24))
+ );
+ }
+
+ #[test]
+ fn test_parse_response_nxdomain() {
+ let p = Parsed::parse(&[
+ 0x63, 0xc4, 0x81, 0x83, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x13, 0x61,
+ 0x68, 0x61, 0x73, 0x64, 0x67, 0x68, 0x6c, 0x61, 0x6b, 0x73, 0x6a, 0x68, 0x62, 0x61,
+ 0x61, 0x73, 0x6c, 0x64, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01, 0xc0,
+ 0x20, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x3d, 0x01, 0x61, 0x0c,
+ 0x67, 0x74, 0x6c, 0x64, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x03, 0x6e,
+ 0x65, 0x74, 0x00, 0x05, 0x6e, 0x73, 0x74, 0x6c, 0x64, 0x0c, 0x76, 0x65, 0x72, 0x69,
+ 0x73, 0x69, 0x67, 0x6e, 0x2d, 0x67, 0x72, 0x73, 0xc0, 0x20, 0x5f, 0xce, 0x8b, 0x85,
+ 0x00, 0x00, 0x07, 0x08, 0x00, 0x00, 0x03, 0x84, 0x00, 0x09, 0x3a, 0x80, 0x00, 0x01,
+ 0x51, 0x80,
+ ])
+ .unwrap();
+
+ assert_eq!(p.packet.transaction_id(), 0x63c4);
+ assert_eq!(
+ p.packet.flags(),
+ Flags::RESPONSE | Flags::RECURSION_DESIRED | Flags::RECURSION_AVAILABLE
+ );
+ assert_eq!(p.packet.opcode(), Opcode::Query);
+ assert_eq!(p.packet.rcode(), Rcode::NXDomain);
+ assert_eq!(p.packet.question_count(), 1);
+ assert_eq!(p.packet.answer_record_count(), 0);
+ assert_eq!(p.packet.authority_record_count(), 1);
+ assert_eq!(p.packet.additional_record_count(), 0);
+
+ assert_eq!(p.questions[0].type_, Type::A);
+
+ // SOA authority
+ assert_eq!(p.authorities[0].name, &[0xc0, 0x20]); // com.
+ assert_eq!(p.authorities[0].ttl, 899);
+ assert!(matches!(
+ p.authorities[0].data,
+ RecordData::Other(Type::Soa, _)
+ ));
+ }
+
+ #[test]
+ fn test_emit() {
+ let name = &[
+ 0x09, 0x72, 0x75, 0x73, 0x74, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x03, 0x6f, 0x72, 0x67,
+ 0x00,
+ ];
+
+ let repr = Repr {
+ transaction_id: 0x1234,
+ flags: Flags::RECURSION_DESIRED,
+ opcode: Opcode::Query,
+ question: Question {
+ name,
+ type_: Type::A,
+ },
+ };
+
+ let mut buf = Vec::new();
+ buf.resize(repr.buffer_len(), 0);
+ repr.emit(&mut Packet::new_unchecked(&mut buf));
+
+ let want = &[
+ 0x12, 0x34, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x72,
+ 0x75, 0x73, 0x74, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x03, 0x6f, 0x72, 0x67, 0x00, 0x00,
+ 0x01, 0x00, 0x01,
+ ];
+ assert_eq!(&buf, want);
+ }
+}
diff --git a/src/wire/ethernet.rs b/src/wire/ethernet.rs
new file mode 100644
index 0000000..53dc1ea
--- /dev/null
+++ b/src/wire/ethernet.rs
@@ -0,0 +1,400 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::fmt;
+
+use super::{Error, Result};
+
+enum_with_unknown! {
+ /// Ethernet protocol type.
+ pub enum EtherType(u16) {
+ Ipv4 = 0x0800,
+ Arp = 0x0806,
+ Ipv6 = 0x86DD
+ }
+}
+
+impl fmt::Display for EtherType {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ EtherType::Ipv4 => write!(f, "IPv4"),
+ EtherType::Ipv6 => write!(f, "IPv6"),
+ EtherType::Arp => write!(f, "ARP"),
+ EtherType::Unknown(id) => write!(f, "0x{id:04x}"),
+ }
+ }
+}
+
+/// A six-octet Ethernet II address.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Address(pub [u8; 6]);
+
+impl Address {
+ /// The broadcast address.
+ pub const BROADCAST: Address = Address([0xff; 6]);
+
+ /// Construct an Ethernet address from a sequence of octets, in big-endian.
+ ///
+ /// # Panics
+ /// The function panics if `data` is not six octets long.
+ pub fn from_bytes(data: &[u8]) -> Address {
+ let mut bytes = [0; 6];
+ bytes.copy_from_slice(data);
+ Address(bytes)
+ }
+
+ /// Return an Ethernet address as a sequence of octets, in big-endian.
+ pub const fn as_bytes(&self) -> &[u8] {
+ &self.0
+ }
+
+ /// Query whether the address is an unicast address.
+ pub fn is_unicast(&self) -> bool {
+ !(self.is_broadcast() || self.is_multicast())
+ }
+
+ /// Query whether this address is the broadcast address.
+ pub fn is_broadcast(&self) -> bool {
+ *self == Self::BROADCAST
+ }
+
+ /// Query whether the "multicast" bit in the OUI is set.
+ pub const fn is_multicast(&self) -> bool {
+ self.0[0] & 0x01 != 0
+ }
+
+ /// Query whether the "locally administered" bit in the OUI is set.
+ pub const fn is_local(&self) -> bool {
+ self.0[0] & 0x02 != 0
+ }
+}
+
+impl fmt::Display for Address {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let bytes = self.0;
+ write!(
+ f,
+ "{:02x}-{:02x}-{:02x}-{:02x}-{:02x}-{:02x}",
+ bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]
+ )
+ }
+}
+
+/// A read/write wrapper around an Ethernet II frame buffer.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Frame<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const DESTINATION: Field = 0..6;
+ pub const SOURCE: Field = 6..12;
+ pub const ETHERTYPE: Field = 12..14;
+ pub const PAYLOAD: Rest = 14..;
+}
+
+/// The Ethernet header length
+pub const HEADER_LEN: usize = field::PAYLOAD.start;
+
+impl<T: AsRef<[u8]>> Frame<T> {
+ /// Imbue a raw octet buffer with Ethernet frame structure.
+ pub const fn new_unchecked(buffer: T) -> Frame<T> {
+ Frame { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Frame<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < HEADER_LEN {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consumes the frame, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the length of a frame header.
+ pub const fn header_len() -> usize {
+ HEADER_LEN
+ }
+
+ /// Return the length of a buffer required to hold a packet with the payload
+ /// of a given length.
+ pub const fn buffer_len(payload_len: usize) -> usize {
+ HEADER_LEN + payload_len
+ }
+
+ /// Return the destination address field.
+ #[inline]
+ pub fn dst_addr(&self) -> Address {
+ let data = self.buffer.as_ref();
+ Address::from_bytes(&data[field::DESTINATION])
+ }
+
+ /// Return the source address field.
+ #[inline]
+ pub fn src_addr(&self) -> Address {
+ let data = self.buffer.as_ref();
+ Address::from_bytes(&data[field::SOURCE])
+ }
+
+ /// Return the EtherType field, without checking for 802.1Q.
+ #[inline]
+ pub fn ethertype(&self) -> EtherType {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::ETHERTYPE]);
+ EtherType::from(raw)
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Frame<&'a T> {
+ /// Return a pointer to the payload, without checking for 802.1Q.
+ #[inline]
+ pub fn payload(&self) -> &'a [u8] {
+ let data = self.buffer.as_ref();
+ &data[field::PAYLOAD]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Frame<T> {
+ /// Set the destination address field.
+ #[inline]
+ pub fn set_dst_addr(&mut self, value: Address) {
+ let data = self.buffer.as_mut();
+ data[field::DESTINATION].copy_from_slice(value.as_bytes())
+ }
+
+ /// Set the source address field.
+ #[inline]
+ pub fn set_src_addr(&mut self, value: Address) {
+ let data = self.buffer.as_mut();
+ data[field::SOURCE].copy_from_slice(value.as_bytes())
+ }
+
+ /// Set the EtherType field.
+ #[inline]
+ pub fn set_ethertype(&mut self, value: EtherType) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::ETHERTYPE], value.into())
+ }
+
+ /// Return a mutable pointer to the payload.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let data = self.buffer.as_mut();
+ &mut data[field::PAYLOAD]
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Frame<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+impl<T: AsRef<[u8]>> fmt::Display for Frame<T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(
+ f,
+ "EthernetII src={} dst={} type={}",
+ self.src_addr(),
+ self.dst_addr(),
+ self.ethertype()
+ )
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for Frame<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ let frame = match Frame::new_checked(buffer) {
+ Err(err) => return write!(f, "{indent}({err})"),
+ Ok(frame) => frame,
+ };
+ write!(f, "{indent}{frame}")?;
+
+ match frame.ethertype() {
+ #[cfg(feature = "proto-ipv4")]
+ EtherType::Arp => {
+ indent.increase(f)?;
+ super::ArpPacket::<&[u8]>::pretty_print(&frame.payload(), f, indent)
+ }
+ #[cfg(feature = "proto-ipv4")]
+ EtherType::Ipv4 => {
+ indent.increase(f)?;
+ super::Ipv4Packet::<&[u8]>::pretty_print(&frame.payload(), f, indent)
+ }
+ #[cfg(feature = "proto-ipv6")]
+ EtherType::Ipv6 => {
+ indent.increase(f)?;
+ super::Ipv6Packet::<&[u8]>::pretty_print(&frame.payload(), f, indent)
+ }
+ _ => Ok(()),
+ }
+ }
+}
+
+/// A high-level representation of an Internet Protocol version 4 packet header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr {
+ pub src_addr: Address,
+ pub dst_addr: Address,
+ pub ethertype: EtherType,
+}
+
+impl Repr {
+ /// Parse an Ethernet II frame and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(frame: &Frame<&T>) -> Result<Repr> {
+ frame.check_len()?;
+ Ok(Repr {
+ src_addr: frame.src_addr(),
+ dst_addr: frame.dst_addr(),
+ ethertype: frame.ethertype(),
+ })
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ HEADER_LEN
+ }
+
+ /// Emit a high-level representation into an Ethernet II frame.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, frame: &mut Frame<T>) {
+ frame.set_src_addr(self.src_addr);
+ frame.set_dst_addr(self.dst_addr);
+ frame.set_ethertype(self.ethertype);
+ }
+}
+
+#[cfg(test)]
+mod test {
+ // Tests that are valid with any combination of
+ // "proto-*" features.
+ use super::*;
+
+ #[test]
+ fn test_broadcast() {
+ assert!(Address::BROADCAST.is_broadcast());
+ assert!(!Address::BROADCAST.is_unicast());
+ assert!(Address::BROADCAST.is_multicast());
+ assert!(Address::BROADCAST.is_local());
+ }
+}
+
+#[cfg(test)]
+#[cfg(feature = "proto-ipv4")]
+mod test_ipv4 {
+ // Tests that are valid only with "proto-ipv4"
+ use super::*;
+
+ static FRAME_BYTES: [u8; 64] = [
+ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x08, 0x00, 0xaa,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xff,
+ ];
+
+ static PAYLOAD_BYTES: [u8; 50] = [
+ 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff,
+ ];
+
+ #[test]
+ fn test_deconstruct() {
+ let frame = Frame::new_unchecked(&FRAME_BYTES[..]);
+ assert_eq!(
+ frame.dst_addr(),
+ Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06])
+ );
+ assert_eq!(
+ frame.src_addr(),
+ Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16])
+ );
+ assert_eq!(frame.ethertype(), EtherType::Ipv4);
+ assert_eq!(frame.payload(), &PAYLOAD_BYTES[..]);
+ }
+
+ #[test]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; 64];
+ let mut frame = Frame::new_unchecked(&mut bytes);
+ frame.set_dst_addr(Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]));
+ frame.set_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
+ frame.set_ethertype(EtherType::Ipv4);
+ frame.payload_mut().copy_from_slice(&PAYLOAD_BYTES[..]);
+ assert_eq!(&frame.into_inner()[..], &FRAME_BYTES[..]);
+ }
+}
+
+#[cfg(test)]
+#[cfg(feature = "proto-ipv6")]
+mod test_ipv6 {
+ // Tests that are valid only with "proto-ipv6"
+ use super::*;
+
+ static FRAME_BYTES: [u8; 54] = [
+ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x86, 0xdd, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ ];
+
+ static PAYLOAD_BYTES: [u8; 40] = [
+ 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ ];
+
+ #[test]
+ fn test_deconstruct() {
+ let frame = Frame::new_unchecked(&FRAME_BYTES[..]);
+ assert_eq!(
+ frame.dst_addr(),
+ Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06])
+ );
+ assert_eq!(
+ frame.src_addr(),
+ Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16])
+ );
+ assert_eq!(frame.ethertype(), EtherType::Ipv6);
+ assert_eq!(frame.payload(), &PAYLOAD_BYTES[..]);
+ }
+
+ #[test]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; 54];
+ let mut frame = Frame::new_unchecked(&mut bytes);
+ frame.set_dst_addr(Address([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]));
+ frame.set_src_addr(Address([0x11, 0x12, 0x13, 0x14, 0x15, 0x16]));
+ frame.set_ethertype(EtherType::Ipv6);
+ assert_eq!(PAYLOAD_BYTES.len(), frame.payload_mut().len());
+ frame.payload_mut().copy_from_slice(&PAYLOAD_BYTES[..]);
+ assert_eq!(&frame.into_inner()[..], &FRAME_BYTES[..]);
+ }
+}
diff --git a/src/wire/icmp.rs b/src/wire/icmp.rs
new file mode 100644
index 0000000..6bbc574
--- /dev/null
+++ b/src/wire/icmp.rs
@@ -0,0 +1,25 @@
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::icmpv4;
+#[cfg(feature = "proto-ipv6")]
+use crate::wire::icmpv6;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Repr<'a> {
+ #[cfg(feature = "proto-ipv4")]
+ Ipv4(icmpv4::Repr<'a>),
+ #[cfg(feature = "proto-ipv6")]
+ Ipv6(icmpv6::Repr<'a>),
+}
+#[cfg(feature = "proto-ipv4")]
+impl<'a> From<icmpv4::Repr<'a>> for Repr<'a> {
+ fn from(s: icmpv4::Repr<'a>) -> Self {
+ Repr::Ipv4(s)
+ }
+}
+#[cfg(feature = "proto-ipv6")]
+impl<'a> From<icmpv6::Repr<'a>> for Repr<'a> {
+ fn from(s: icmpv6::Repr<'a>) -> Self {
+ Repr::Ipv6(s)
+ }
+}
diff --git a/src/wire/icmpv4.rs b/src/wire/icmpv4.rs
new file mode 100644
index 0000000..60e1215
--- /dev/null
+++ b/src/wire/icmpv4.rs
@@ -0,0 +1,702 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::{cmp, fmt};
+
+use super::{Error, Result};
+use crate::phy::ChecksumCapabilities;
+use crate::wire::ip::checksum;
+use crate::wire::{Ipv4Packet, Ipv4Repr};
+
+enum_with_unknown! {
+ /// Internet protocol control message type.
+ pub enum Message(u8) {
+ /// Echo reply
+ EchoReply = 0,
+ /// Destination unreachable
+ DstUnreachable = 3,
+ /// Message redirect
+ Redirect = 5,
+ /// Echo request
+ EchoRequest = 8,
+ /// Router advertisement
+ RouterAdvert = 9,
+ /// Router solicitation
+ RouterSolicit = 10,
+ /// Time exceeded
+ TimeExceeded = 11,
+ /// Parameter problem
+ ParamProblem = 12,
+ /// Timestamp
+ Timestamp = 13,
+ /// Timestamp reply
+ TimestampReply = 14
+ }
+}
+
+impl fmt::Display for Message {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Message::EchoReply => write!(f, "echo reply"),
+ Message::DstUnreachable => write!(f, "destination unreachable"),
+ Message::Redirect => write!(f, "message redirect"),
+ Message::EchoRequest => write!(f, "echo request"),
+ Message::RouterAdvert => write!(f, "router advertisement"),
+ Message::RouterSolicit => write!(f, "router solicitation"),
+ Message::TimeExceeded => write!(f, "time exceeded"),
+ Message::ParamProblem => write!(f, "parameter problem"),
+ Message::Timestamp => write!(f, "timestamp"),
+ Message::TimestampReply => write!(f, "timestamp reply"),
+ Message::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// Internet protocol control message subtype for type "Destination Unreachable".
+ pub enum DstUnreachable(u8) {
+ /// Destination network unreachable
+ NetUnreachable = 0,
+ /// Destination host unreachable
+ HostUnreachable = 1,
+ /// Destination protocol unreachable
+ ProtoUnreachable = 2,
+ /// Destination port unreachable
+ PortUnreachable = 3,
+ /// Fragmentation required, and DF flag set
+ FragRequired = 4,
+ /// Source route failed
+ SrcRouteFailed = 5,
+ /// Destination network unknown
+ DstNetUnknown = 6,
+ /// Destination host unknown
+ DstHostUnknown = 7,
+ /// Source host isolated
+ SrcHostIsolated = 8,
+ /// Network administratively prohibited
+ NetProhibited = 9,
+ /// Host administratively prohibited
+ HostProhibited = 10,
+ /// Network unreachable for ToS
+ NetUnreachToS = 11,
+ /// Host unreachable for ToS
+ HostUnreachToS = 12,
+ /// Communication administratively prohibited
+ CommProhibited = 13,
+ /// Host precedence violation
+ HostPrecedViol = 14,
+ /// Precedence cutoff in effect
+ PrecedCutoff = 15
+ }
+}
+
+impl fmt::Display for DstUnreachable {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ DstUnreachable::NetUnreachable => write!(f, "destination network unreachable"),
+ DstUnreachable::HostUnreachable => write!(f, "destination host unreachable"),
+ DstUnreachable::ProtoUnreachable => write!(f, "destination protocol unreachable"),
+ DstUnreachable::PortUnreachable => write!(f, "destination port unreachable"),
+ DstUnreachable::FragRequired => write!(f, "fragmentation required, and DF flag set"),
+ DstUnreachable::SrcRouteFailed => write!(f, "source route failed"),
+ DstUnreachable::DstNetUnknown => write!(f, "destination network unknown"),
+ DstUnreachable::DstHostUnknown => write!(f, "destination host unknown"),
+ DstUnreachable::SrcHostIsolated => write!(f, "source host isolated"),
+ DstUnreachable::NetProhibited => write!(f, "network administratively prohibited"),
+ DstUnreachable::HostProhibited => write!(f, "host administratively prohibited"),
+ DstUnreachable::NetUnreachToS => write!(f, "network unreachable for ToS"),
+ DstUnreachable::HostUnreachToS => write!(f, "host unreachable for ToS"),
+ DstUnreachable::CommProhibited => {
+ write!(f, "communication administratively prohibited")
+ }
+ DstUnreachable::HostPrecedViol => write!(f, "host precedence violation"),
+ DstUnreachable::PrecedCutoff => write!(f, "precedence cutoff in effect"),
+ DstUnreachable::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// Internet protocol control message subtype for type "Redirect Message".
+ pub enum Redirect(u8) {
+ /// Redirect Datagram for the Network
+ Net = 0,
+ /// Redirect Datagram for the Host
+ Host = 1,
+ /// Redirect Datagram for the ToS & network
+ NetToS = 2,
+ /// Redirect Datagram for the ToS & host
+ HostToS = 3
+ }
+}
+
+enum_with_unknown! {
+ /// Internet protocol control message subtype for type "Time Exceeded".
+ pub enum TimeExceeded(u8) {
+ /// TTL expired in transit
+ TtlExpired = 0,
+ /// Fragment reassembly time exceeded
+ FragExpired = 1
+ }
+}
+
+impl fmt::Display for TimeExceeded {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ TimeExceeded::TtlExpired => write!(f, "time-to-live exceeded in transit"),
+ TimeExceeded::FragExpired => write!(f, "fragment reassembly time exceeded"),
+ TimeExceeded::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// Internet protocol control message subtype for type "Parameter Problem".
+ pub enum ParamProblem(u8) {
+ /// Pointer indicates the error
+ AtPointer = 0,
+ /// Missing a required option
+ MissingOption = 1,
+ /// Bad length
+ BadLength = 2
+ }
+}
+
+/// A read/write wrapper around an Internet Control Message Protocol version 4 packet buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const TYPE: usize = 0;
+ pub const CODE: usize = 1;
+ pub const CHECKSUM: Field = 2..4;
+
+ pub const UNUSED: Field = 4..8;
+
+ pub const ECHO_IDENT: Field = 4..6;
+ pub const ECHO_SEQNO: Field = 6..8;
+
+ pub const HEADER_END: usize = 8;
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with ICMPv4 packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_header_len].
+ ///
+ /// [set_header_len]: #method.set_header_len
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::HEADER_END {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the message type field.
+ #[inline]
+ pub fn msg_type(&self) -> Message {
+ let data = self.buffer.as_ref();
+ Message::from(data[field::TYPE])
+ }
+
+ /// Return the message code field.
+ #[inline]
+ pub fn msg_code(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::CODE]
+ }
+
+ /// Return the checksum field.
+ #[inline]
+ pub fn checksum(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::CHECKSUM])
+ }
+
+ /// Return the identifier field (for echo request and reply packets).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not an echo request or reply packet.
+ #[inline]
+ pub fn echo_ident(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::ECHO_IDENT])
+ }
+
+ /// Return the sequence number field (for echo request and reply packets).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not an echo request or reply packet.
+ #[inline]
+ pub fn echo_seq_no(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::ECHO_SEQNO])
+ }
+
+ /// Return the header length.
+ /// The result depends on the value of the message type field.
+ pub fn header_len(&self) -> usize {
+ match self.msg_type() {
+ Message::EchoRequest => field::ECHO_SEQNO.end,
+ Message::EchoReply => field::ECHO_SEQNO.end,
+ Message::DstUnreachable => field::UNUSED.end,
+ _ => field::UNUSED.end, // make a conservative assumption
+ }
+ }
+
+ /// Validate the header checksum.
+ ///
+ /// # Fuzzing
+ /// This function always returns `true` when fuzzing.
+ pub fn verify_checksum(&self) -> bool {
+ if cfg!(fuzzing) {
+ return true;
+ }
+
+ let data = self.buffer.as_ref();
+ checksum::data(data) == !0
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the type-specific data.
+ #[inline]
+ pub fn data(&self) -> &'a [u8] {
+ let data = self.buffer.as_ref();
+ &data[self.header_len()..]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the message type field.
+ #[inline]
+ pub fn set_msg_type(&mut self, value: Message) {
+ let data = self.buffer.as_mut();
+ data[field::TYPE] = value.into()
+ }
+
+ /// Set the message code field.
+ #[inline]
+ pub fn set_msg_code(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::CODE] = value
+ }
+
+ /// Set the checksum field.
+ #[inline]
+ pub fn set_checksum(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::CHECKSUM], value)
+ }
+
+ /// Set the identifier field (for echo request and reply packets).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not an echo request or reply packet.
+ #[inline]
+ pub fn set_echo_ident(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::ECHO_IDENT], value)
+ }
+
+ /// Set the sequence number field (for echo request and reply packets).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not an echo request or reply packet.
+ #[inline]
+ pub fn set_echo_seq_no(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::ECHO_SEQNO], value)
+ }
+
+ /// Compute and fill in the header checksum.
+ pub fn fill_checksum(&mut self) {
+ self.set_checksum(0);
+ let checksum = {
+ let data = self.buffer.as_ref();
+ !checksum::data(data)
+ };
+ self.set_checksum(checksum)
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> Packet<&'a mut T> {
+ /// Return a mutable pointer to the type-specific data.
+ #[inline]
+ pub fn data_mut(&mut self) -> &mut [u8] {
+ let range = self.header_len()..;
+ let data = self.buffer.as_mut();
+ &mut data[range]
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+/// A high-level representation of an Internet Control Message Protocol version 4 packet header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Repr<'a> {
+ EchoRequest {
+ ident: u16,
+ seq_no: u16,
+ data: &'a [u8],
+ },
+ EchoReply {
+ ident: u16,
+ seq_no: u16,
+ data: &'a [u8],
+ },
+ DstUnreachable {
+ reason: DstUnreachable,
+ header: Ipv4Repr,
+ data: &'a [u8],
+ },
+ TimeExceeded {
+ reason: TimeExceeded,
+ header: Ipv4Repr,
+ data: &'a [u8],
+ },
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an Internet Control Message Protocol version 4 packet and return
+ /// a high-level representation.
+ pub fn parse<T>(
+ packet: &Packet<&'a T>,
+ checksum_caps: &ChecksumCapabilities,
+ ) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ // Valid checksum is expected.
+ if checksum_caps.icmpv4.rx() && !packet.verify_checksum() {
+ return Err(Error);
+ }
+
+ match (packet.msg_type(), packet.msg_code()) {
+ (Message::EchoRequest, 0) => Ok(Repr::EchoRequest {
+ ident: packet.echo_ident(),
+ seq_no: packet.echo_seq_no(),
+ data: packet.data(),
+ }),
+
+ (Message::EchoReply, 0) => Ok(Repr::EchoReply {
+ ident: packet.echo_ident(),
+ seq_no: packet.echo_seq_no(),
+ data: packet.data(),
+ }),
+
+ (Message::DstUnreachable, code) => {
+ let ip_packet = Ipv4Packet::new_checked(packet.data())?;
+
+ let payload = &packet.data()[ip_packet.header_len() as usize..];
+ // RFC 792 requires exactly eight bytes to be returned.
+ // We allow more, since there isn't a reason not to, but require at least eight.
+ if payload.len() < 8 {
+ return Err(Error);
+ }
+
+ Ok(Repr::DstUnreachable {
+ reason: DstUnreachable::from(code),
+ header: Ipv4Repr {
+ src_addr: ip_packet.src_addr(),
+ dst_addr: ip_packet.dst_addr(),
+ next_header: ip_packet.next_header(),
+ payload_len: payload.len(),
+ hop_limit: ip_packet.hop_limit(),
+ },
+ data: payload,
+ })
+ }
+
+ (Message::TimeExceeded, code) => {
+ let ip_packet = Ipv4Packet::new_checked(packet.data())?;
+
+ let payload = &packet.data()[ip_packet.header_len() as usize..];
+ // RFC 792 requires exactly eight bytes to be returned.
+ // We allow more, since there isn't a reason not to, but require at least eight.
+ if payload.len() < 8 {
+ return Err(Error);
+ }
+
+ Ok(Repr::TimeExceeded {
+ reason: TimeExceeded::from(code),
+ header: Ipv4Repr {
+ src_addr: ip_packet.src_addr(),
+ dst_addr: ip_packet.dst_addr(),
+ next_header: ip_packet.next_header(),
+ payload_len: payload.len(),
+ hop_limit: ip_packet.hop_limit(),
+ },
+ data: payload,
+ })
+ }
+
+ _ => Err(Error),
+ }
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ match self {
+ &Repr::EchoRequest { data, .. } | &Repr::EchoReply { data, .. } => {
+ field::ECHO_SEQNO.end + data.len()
+ }
+ &Repr::DstUnreachable { header, data, .. }
+ | &Repr::TimeExceeded { header, data, .. } => {
+ field::UNUSED.end + header.buffer_len() + data.len()
+ }
+ }
+ }
+
+ /// Emit a high-level representation into an Internet Control Message Protocol version 4
+ /// packet.
+ pub fn emit<T>(&self, packet: &mut Packet<&mut T>, checksum_caps: &ChecksumCapabilities)
+ where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ packet.set_msg_code(0);
+ match *self {
+ Repr::EchoRequest {
+ ident,
+ seq_no,
+ data,
+ } => {
+ packet.set_msg_type(Message::EchoRequest);
+ packet.set_msg_code(0);
+ packet.set_echo_ident(ident);
+ packet.set_echo_seq_no(seq_no);
+ let data_len = cmp::min(packet.data_mut().len(), data.len());
+ packet.data_mut()[..data_len].copy_from_slice(&data[..data_len])
+ }
+
+ Repr::EchoReply {
+ ident,
+ seq_no,
+ data,
+ } => {
+ packet.set_msg_type(Message::EchoReply);
+ packet.set_msg_code(0);
+ packet.set_echo_ident(ident);
+ packet.set_echo_seq_no(seq_no);
+ let data_len = cmp::min(packet.data_mut().len(), data.len());
+ packet.data_mut()[..data_len].copy_from_slice(&data[..data_len])
+ }
+
+ Repr::DstUnreachable {
+ reason,
+ header,
+ data,
+ } => {
+ packet.set_msg_type(Message::DstUnreachable);
+ packet.set_msg_code(reason.into());
+
+ let mut ip_packet = Ipv4Packet::new_unchecked(packet.data_mut());
+ header.emit(&mut ip_packet, checksum_caps);
+ let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
+ payload.copy_from_slice(data)
+ }
+
+ Repr::TimeExceeded {
+ reason,
+ header,
+ data,
+ } => {
+ packet.set_msg_type(Message::TimeExceeded);
+ packet.set_msg_code(reason.into());
+
+ let mut ip_packet = Ipv4Packet::new_unchecked(packet.data_mut());
+ header.emit(&mut ip_packet, checksum_caps);
+ let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
+ payload.copy_from_slice(data)
+ }
+ }
+
+ if checksum_caps.icmpv4.tx() {
+ packet.fill_checksum()
+ } else {
+ // make sure we get a consistently zeroed checksum,
+ // since implementations might rely on it
+ packet.set_checksum(0);
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self, &ChecksumCapabilities::default()) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => {
+ write!(f, "ICMPv4 ({err})")?;
+ write!(f, " type={:?}", self.msg_type())?;
+ match self.msg_type() {
+ Message::DstUnreachable => {
+ write!(f, " code={:?}", DstUnreachable::from(self.msg_code()))
+ }
+ Message::TimeExceeded => {
+ write!(f, " code={:?}", TimeExceeded::from(self.msg_code()))
+ }
+ _ => write!(f, " code={}", self.msg_code()),
+ }
+ }
+ }
+ }
+}
+
+impl<'a> fmt::Display for Repr<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Repr::EchoRequest {
+ ident,
+ seq_no,
+ data,
+ } => write!(
+ f,
+ "ICMPv4 echo request id={} seq={} len={}",
+ ident,
+ seq_no,
+ data.len()
+ ),
+ Repr::EchoReply {
+ ident,
+ seq_no,
+ data,
+ } => write!(
+ f,
+ "ICMPv4 echo reply id={} seq={} len={}",
+ ident,
+ seq_no,
+ data.len()
+ ),
+ Repr::DstUnreachable { reason, .. } => {
+ write!(f, "ICMPv4 destination unreachable ({reason})")
+ }
+ Repr::TimeExceeded { reason, .. } => {
+ write!(f, "ICMPv4 time exceeded ({reason})")
+ }
+ }
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ let packet = match Packet::new_checked(buffer) {
+ Err(err) => return write!(f, "{indent}({err})"),
+ Ok(packet) => packet,
+ };
+ write!(f, "{indent}{packet}")?;
+
+ match packet.msg_type() {
+ Message::DstUnreachable | Message::TimeExceeded => {
+ indent.increase(f)?;
+ super::Ipv4Packet::<&[u8]>::pretty_print(&packet.data(), f, indent)
+ }
+ _ => Ok(()),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ static ECHO_PACKET_BYTES: [u8; 12] = [
+ 0x08, 0x00, 0x8e, 0xfe, 0x12, 0x34, 0xab, 0xcd, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ static ECHO_DATA_BYTES: [u8; 4] = [0xaa, 0x00, 0x00, 0xff];
+
+ #[test]
+ fn test_echo_deconstruct() {
+ let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::EchoRequest);
+ assert_eq!(packet.msg_code(), 0);
+ assert_eq!(packet.checksum(), 0x8efe);
+ assert_eq!(packet.echo_ident(), 0x1234);
+ assert_eq!(packet.echo_seq_no(), 0xabcd);
+ assert_eq!(packet.data(), &ECHO_DATA_BYTES[..]);
+ assert!(packet.verify_checksum());
+ }
+
+ #[test]
+ fn test_echo_construct() {
+ let mut bytes = vec![0xa5; 12];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_msg_type(Message::EchoRequest);
+ packet.set_msg_code(0);
+ packet.set_echo_ident(0x1234);
+ packet.set_echo_seq_no(0xabcd);
+ packet.data_mut().copy_from_slice(&ECHO_DATA_BYTES[..]);
+ packet.fill_checksum();
+ assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]);
+ }
+
+ fn echo_packet_repr() -> Repr<'static> {
+ Repr::EchoRequest {
+ ident: 0x1234,
+ seq_no: 0xabcd,
+ data: &ECHO_DATA_BYTES,
+ }
+ }
+
+ #[test]
+ fn test_echo_parse() {
+ let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
+ let repr = Repr::parse(&packet, &ChecksumCapabilities::default()).unwrap();
+ assert_eq!(repr, echo_packet_repr());
+ }
+
+ #[test]
+ fn test_echo_emit() {
+ let repr = echo_packet_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet, &ChecksumCapabilities::default());
+ assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_check_len() {
+ let bytes = [0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+ assert_eq!(Packet::new_checked(&[]), Err(Error));
+ assert_eq!(Packet::new_checked(&bytes[..4]), Err(Error));
+ assert!(Packet::new_checked(&bytes[..]).is_ok());
+ }
+}
diff --git a/src/wire/icmpv6.rs b/src/wire/icmpv6.rs
new file mode 100644
index 0000000..72d2451
--- /dev/null
+++ b/src/wire/icmpv6.rs
@@ -0,0 +1,1085 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::{cmp, fmt};
+
+use super::{Error, Result};
+use crate::phy::ChecksumCapabilities;
+use crate::wire::ip::checksum;
+use crate::wire::MldRepr;
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+use crate::wire::NdiscRepr;
+#[cfg(feature = "proto-rpl")]
+use crate::wire::RplRepr;
+use crate::wire::{IpAddress, IpProtocol, Ipv6Packet, Ipv6Repr};
+use crate::wire::{IPV6_HEADER_LEN, IPV6_MIN_MTU};
+
+/// Error packets must not exceed min MTU
+const MAX_ERROR_PACKET_LEN: usize = IPV6_MIN_MTU - IPV6_HEADER_LEN;
+
+enum_with_unknown! {
+ /// Internet protocol control message type.
+ pub enum Message(u8) {
+ /// Destination Unreachable.
+ DstUnreachable = 0x01,
+ /// Packet Too Big.
+ PktTooBig = 0x02,
+ /// Time Exceeded.
+ TimeExceeded = 0x03,
+ /// Parameter Problem.
+ ParamProblem = 0x04,
+ /// Echo Request
+ EchoRequest = 0x80,
+ /// Echo Reply
+ EchoReply = 0x81,
+ /// Multicast Listener Query
+ MldQuery = 0x82,
+ /// Router Solicitation
+ RouterSolicit = 0x85,
+ /// Router Advertisement
+ RouterAdvert = 0x86,
+ /// Neighbor Solicitation
+ NeighborSolicit = 0x87,
+ /// Neighbor Advertisement
+ NeighborAdvert = 0x88,
+ /// Redirect
+ Redirect = 0x89,
+ /// Multicast Listener Report
+ MldReport = 0x8f,
+ /// RPL Control Message
+ RplControl = 0x9b,
+ }
+}
+
+impl Message {
+ /// Per [RFC 4443 § 2.1] ICMPv6 message types with the highest order
+ /// bit set are informational messages while message types without
+ /// the highest order bit set are error messages.
+ ///
+ /// [RFC 4443 § 2.1]: https://tools.ietf.org/html/rfc4443#section-2.1
+ pub fn is_error(&self) -> bool {
+ (u8::from(*self) & 0x80) != 0x80
+ }
+
+ /// Return a boolean value indicating if the given message type
+ /// is an [NDISC] message type.
+ ///
+ /// [NDISC]: https://tools.ietf.org/html/rfc4861
+ pub const fn is_ndisc(&self) -> bool {
+ match *self {
+ Message::RouterSolicit
+ | Message::RouterAdvert
+ | Message::NeighborSolicit
+ | Message::NeighborAdvert
+ | Message::Redirect => true,
+ _ => false,
+ }
+ }
+
+ /// Return a boolean value indicating if the given message type
+ /// is an [MLD] message type.
+ ///
+ /// [MLD]: https://tools.ietf.org/html/rfc3810
+ pub const fn is_mld(&self) -> bool {
+ match *self {
+ Message::MldQuery | Message::MldReport => true,
+ _ => false,
+ }
+ }
+}
+
+impl fmt::Display for Message {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Message::DstUnreachable => write!(f, "destination unreachable"),
+ Message::PktTooBig => write!(f, "packet too big"),
+ Message::TimeExceeded => write!(f, "time exceeded"),
+ Message::ParamProblem => write!(f, "parameter problem"),
+ Message::EchoReply => write!(f, "echo reply"),
+ Message::EchoRequest => write!(f, "echo request"),
+ Message::RouterSolicit => write!(f, "router solicitation"),
+ Message::RouterAdvert => write!(f, "router advertisement"),
+ Message::NeighborSolicit => write!(f, "neighbor solicitation"),
+ Message::NeighborAdvert => write!(f, "neighbor advert"),
+ Message::Redirect => write!(f, "redirect"),
+ Message::MldQuery => write!(f, "multicast listener query"),
+ Message::MldReport => write!(f, "multicast listener report"),
+ Message::RplControl => write!(f, "RPL control message"),
+ Message::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// Internet protocol control message subtype for type "Destination Unreachable".
+ pub enum DstUnreachable(u8) {
+ /// No Route to destination.
+ NoRoute = 0,
+ /// Communication with destination administratively prohibited.
+ AdminProhibit = 1,
+ /// Beyond scope of source address.
+ BeyondScope = 2,
+ /// Address unreachable.
+ AddrUnreachable = 3,
+ /// Port unreachable.
+ PortUnreachable = 4,
+ /// Source address failed ingress/egress policy.
+ FailedPolicy = 5,
+ /// Reject route to destination.
+ RejectRoute = 6
+ }
+}
+
+impl fmt::Display for DstUnreachable {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ DstUnreachable::NoRoute => write!(f, "no route to destination"),
+ DstUnreachable::AdminProhibit => write!(
+ f,
+ "communication with destination administratively prohibited"
+ ),
+ DstUnreachable::BeyondScope => write!(f, "beyond scope of source address"),
+ DstUnreachable::AddrUnreachable => write!(f, "address unreachable"),
+ DstUnreachable::PortUnreachable => write!(f, "port unreachable"),
+ DstUnreachable::FailedPolicy => {
+ write!(f, "source address failed ingress/egress policy")
+ }
+ DstUnreachable::RejectRoute => write!(f, "reject route to destination"),
+ DstUnreachable::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// Internet protocol control message subtype for the type "Parameter Problem".
+ pub enum ParamProblem(u8) {
+ /// Erroneous header field encountered.
+ ErroneousHdrField = 0,
+ /// Unrecognized Next Header type encountered.
+ UnrecognizedNxtHdr = 1,
+ /// Unrecognized IPv6 option encountered.
+ UnrecognizedOption = 2
+ }
+}
+
+impl fmt::Display for ParamProblem {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ ParamProblem::ErroneousHdrField => write!(f, "erroneous header field."),
+ ParamProblem::UnrecognizedNxtHdr => write!(f, "unrecognized next header type."),
+ ParamProblem::UnrecognizedOption => write!(f, "unrecognized IPv6 option."),
+ ParamProblem::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// Internet protocol control message subtype for the type "Time Exceeded".
+ pub enum TimeExceeded(u8) {
+ /// Hop limit exceeded in transit.
+ HopLimitExceeded = 0,
+ /// Fragment reassembly time exceeded.
+ FragReassemExceeded = 1
+ }
+}
+
+impl fmt::Display for TimeExceeded {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ TimeExceeded::HopLimitExceeded => write!(f, "hop limit exceeded in transit"),
+ TimeExceeded::FragReassemExceeded => write!(f, "fragment reassembly time exceeded"),
+ TimeExceeded::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+/// A read/write wrapper around an Internet Control Message Protocol version 6 packet buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ pub(super) buffer: T,
+}
+
+// Ranges and constants describing key boundaries in the ICMPv6 header.
+pub(super) mod field {
+ use crate::wire::field::*;
+
+ // ICMPv6: See https://tools.ietf.org/html/rfc4443
+ pub const TYPE: usize = 0;
+ pub const CODE: usize = 1;
+ pub const CHECKSUM: Field = 2..4;
+
+ pub const UNUSED: Field = 4..8;
+ pub const MTU: Field = 4..8;
+ pub const POINTER: Field = 4..8;
+ pub const ECHO_IDENT: Field = 4..6;
+ pub const ECHO_SEQNO: Field = 6..8;
+
+ pub const HEADER_END: usize = 8;
+
+ // NDISC: See https://tools.ietf.org/html/rfc4861
+ // Router Advertisement message offsets
+ pub const CUR_HOP_LIMIT: usize = 4;
+ pub const ROUTER_FLAGS: usize = 5;
+ pub const ROUTER_LT: Field = 6..8;
+ pub const REACHABLE_TM: Field = 8..12;
+ pub const RETRANS_TM: Field = 12..16;
+
+ // Neighbor Solicitation message offsets
+ pub const TARGET_ADDR: Field = 8..24;
+
+ // Neighbor Advertisement message offsets
+ pub const NEIGH_FLAGS: usize = 4;
+
+ // Redirected Header message offsets
+ pub const DEST_ADDR: Field = 24..40;
+
+ // MLD:
+ // - https://tools.ietf.org/html/rfc3810
+ // - https://tools.ietf.org/html/rfc3810
+ // Multicast Listener Query message
+ pub const MAX_RESP_CODE: Field = 4..6;
+ pub const QUERY_RESV: Field = 6..8;
+ pub const QUERY_MCAST_ADDR: Field = 8..24;
+ pub const SQRV: usize = 24;
+ pub const QQIC: usize = 25;
+ pub const QUERY_NUM_SRCS: Field = 26..28;
+
+ // Multicast Listener Report Message
+ pub const RECORD_RESV: Field = 4..6;
+ pub const NR_MCAST_RCRDS: Field = 6..8;
+
+ // Multicast Address Record Offsets
+ pub const RECORD_TYPE: usize = 0;
+ pub const AUX_DATA_LEN: usize = 1;
+ pub const RECORD_NUM_SRCS: Field = 2..4;
+ pub const RECORD_MCAST_ADDR: Field = 4..20;
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with ICMPv6 packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+
+ if len < 4 {
+ return Err(Error);
+ }
+
+ match self.msg_type() {
+ Message::DstUnreachable
+ | Message::PktTooBig
+ | Message::TimeExceeded
+ | Message::ParamProblem
+ | Message::EchoRequest
+ | Message::EchoReply
+ | Message::MldQuery
+ | Message::RouterSolicit
+ | Message::RouterAdvert
+ | Message::NeighborSolicit
+ | Message::NeighborAdvert
+ | Message::Redirect
+ | Message::MldReport => {
+ if len < field::HEADER_END || len < self.header_len() {
+ return Err(Error);
+ }
+ }
+ #[cfg(feature = "proto-rpl")]
+ Message::RplControl => match super::rpl::RplControlMessage::from(self.msg_code()) {
+ super::rpl::RplControlMessage::DodagInformationSolicitation => {
+ // TODO(thvdveld): replace magic number
+ if len < 6 {
+ return Err(Error);
+ }
+ }
+ super::rpl::RplControlMessage::DodagInformationObject => {
+ // TODO(thvdveld): replace magic number
+ if len < 28 {
+ return Err(Error);
+ }
+ }
+ super::rpl::RplControlMessage::DestinationAdvertisementObject => {
+ // TODO(thvdveld): replace magic number
+ if len < 8 || (self.dao_dodag_id_present() && len < 24) {
+ return Err(Error);
+ }
+ }
+ super::rpl::RplControlMessage::DestinationAdvertisementObjectAck => {
+ // TODO(thvdveld): replace magic number
+ if len < 8 || (self.dao_dodag_id_present() && len < 24) {
+ return Err(Error);
+ }
+ }
+ super::rpl::RplControlMessage::SecureDodagInformationSolicitation
+ | super::rpl::RplControlMessage::SecureDodagInformationObject
+ | super::rpl::RplControlMessage::SecureDestinationAdvertisementObject
+ | super::rpl::RplControlMessage::SecureDestinationAdvertisementObjectAck
+ | super::rpl::RplControlMessage::ConsistencyCheck => return Err(Error),
+ super::rpl::RplControlMessage::Unknown(_) => return Err(Error),
+ },
+ #[cfg(not(feature = "proto-rpl"))]
+ Message::RplControl => return Err(Error),
+ Message::Unknown(_) => return Err(Error),
+ }
+
+ Ok(())
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the message type field.
+ #[inline]
+ pub fn msg_type(&self) -> Message {
+ let data = self.buffer.as_ref();
+ Message::from(data[field::TYPE])
+ }
+
+ /// Return the message code field.
+ #[inline]
+ pub fn msg_code(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::CODE]
+ }
+
+ /// Return the checksum field.
+ #[inline]
+ pub fn checksum(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::CHECKSUM])
+ }
+
+ /// Return the identifier field (for echo request and reply packets).
+ #[inline]
+ pub fn echo_ident(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::ECHO_IDENT])
+ }
+
+ /// Return the sequence number field (for echo request and reply packets).
+ #[inline]
+ pub fn echo_seq_no(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::ECHO_SEQNO])
+ }
+
+ /// Return the MTU field (for packet too big messages).
+ #[inline]
+ pub fn pkt_too_big_mtu(&self) -> u32 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u32(&data[field::MTU])
+ }
+
+ /// Return the pointer field (for parameter problem messages).
+ #[inline]
+ pub fn param_problem_ptr(&self) -> u32 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u32(&data[field::POINTER])
+ }
+
+ /// Return the header length. The result depends on the value of
+ /// the message type field.
+ pub fn header_len(&self) -> usize {
+ match self.msg_type() {
+ Message::DstUnreachable => field::UNUSED.end,
+ Message::PktTooBig => field::MTU.end,
+ Message::TimeExceeded => field::UNUSED.end,
+ Message::ParamProblem => field::POINTER.end,
+ Message::EchoRequest => field::ECHO_SEQNO.end,
+ Message::EchoReply => field::ECHO_SEQNO.end,
+ Message::RouterSolicit => field::UNUSED.end,
+ Message::RouterAdvert => field::RETRANS_TM.end,
+ Message::NeighborSolicit => field::TARGET_ADDR.end,
+ Message::NeighborAdvert => field::TARGET_ADDR.end,
+ Message::Redirect => field::DEST_ADDR.end,
+ Message::MldQuery => field::QUERY_NUM_SRCS.end,
+ Message::MldReport => field::NR_MCAST_RCRDS.end,
+ // For packets that are not included in RFC 4443, do not
+ // include the last 32 bits of the ICMPv6 header in
+ // `header_bytes`. This must be done so that these bytes
+ // can be accessed in the `payload`.
+ _ => field::CHECKSUM.end,
+ }
+ }
+
+ /// Validate the header checksum.
+ ///
+ /// # Fuzzing
+ /// This function always returns `true` when fuzzing.
+ pub fn verify_checksum(&self, src_addr: &IpAddress, dst_addr: &IpAddress) -> bool {
+ if cfg!(fuzzing) {
+ return true;
+ }
+
+ let data = self.buffer.as_ref();
+ checksum::combine(&[
+ checksum::pseudo_header(src_addr, dst_addr, IpProtocol::Icmpv6, data.len() as u32),
+ checksum::data(data),
+ ]) == !0
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the type-specific data.
+ #[inline]
+ pub fn payload(&self) -> &'a [u8] {
+ let data = self.buffer.as_ref();
+ &data[self.header_len()..]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the message type field.
+ #[inline]
+ pub fn set_msg_type(&mut self, value: Message) {
+ let data = self.buffer.as_mut();
+ data[field::TYPE] = value.into()
+ }
+
+ /// Set the message code field.
+ #[inline]
+ pub fn set_msg_code(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::CODE] = value
+ }
+
+ /// Clear any reserved fields in the message header.
+ ///
+ /// # Panics
+ /// This function panics if the message type has not been set.
+ /// See [set_msg_type].
+ ///
+ /// [set_msg_type]: #method.set_msg_type
+ #[inline]
+ pub fn clear_reserved(&mut self) {
+ match self.msg_type() {
+ Message::RouterSolicit
+ | Message::NeighborSolicit
+ | Message::NeighborAdvert
+ | Message::Redirect => {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::UNUSED], 0);
+ }
+ Message::MldQuery => {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::QUERY_RESV], 0);
+ data[field::SQRV] &= 0xf;
+ }
+ Message::MldReport => {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::RECORD_RESV], 0);
+ }
+ ty => panic!("Message type `{ty}` does not have any reserved fields."),
+ }
+ }
+
+ #[inline]
+ pub fn set_checksum(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::CHECKSUM], value)
+ }
+
+ /// Set the identifier field (for echo request and reply packets).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not an echo request or reply packet.
+ #[inline]
+ pub fn set_echo_ident(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::ECHO_IDENT], value)
+ }
+
+ /// Set the sequence number field (for echo request and reply packets).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not an echo request or reply packet.
+ #[inline]
+ pub fn set_echo_seq_no(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::ECHO_SEQNO], value)
+ }
+
+ /// Set the MTU field (for packet too big messages).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not an packet too big packet.
+ #[inline]
+ pub fn set_pkt_too_big_mtu(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::MTU], value)
+ }
+
+ /// Set the pointer field (for parameter problem messages).
+ ///
+ /// # Panics
+ /// This function may panic if this packet is not a parameter problem message.
+ #[inline]
+ pub fn set_param_problem_ptr(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::POINTER], value)
+ }
+
+ /// Compute and fill in the header checksum.
+ pub fn fill_checksum(&mut self, src_addr: &IpAddress, dst_addr: &IpAddress) {
+ self.set_checksum(0);
+ let checksum = {
+ let data = self.buffer.as_ref();
+ !checksum::combine(&[
+ checksum::pseudo_header(src_addr, dst_addr, IpProtocol::Icmpv6, data.len() as u32),
+ checksum::data(data),
+ ])
+ };
+ self.set_checksum(checksum)
+ }
+
+ /// Return a mutable pointer to the type-specific data.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let range = self.header_len()..;
+ let data = self.buffer.as_mut();
+ &mut data[range]
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+/// A high-level representation of an Internet Control Message Protocol version 6 packet header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Repr<'a> {
+ DstUnreachable {
+ reason: DstUnreachable,
+ header: Ipv6Repr,
+ data: &'a [u8],
+ },
+ PktTooBig {
+ mtu: u32,
+ header: Ipv6Repr,
+ data: &'a [u8],
+ },
+ TimeExceeded {
+ reason: TimeExceeded,
+ header: Ipv6Repr,
+ data: &'a [u8],
+ },
+ ParamProblem {
+ reason: ParamProblem,
+ pointer: u32,
+ header: Ipv6Repr,
+ data: &'a [u8],
+ },
+ EchoRequest {
+ ident: u16,
+ seq_no: u16,
+ data: &'a [u8],
+ },
+ EchoReply {
+ ident: u16,
+ seq_no: u16,
+ data: &'a [u8],
+ },
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ Ndisc(NdiscRepr<'a>),
+ Mld(MldRepr<'a>),
+ #[cfg(feature = "proto-rpl")]
+ Rpl(RplRepr<'a>),
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an Internet Control Message Protocol version 6 packet and return
+ /// a high-level representation.
+ pub fn parse<T>(
+ src_addr: &IpAddress,
+ dst_addr: &IpAddress,
+ packet: &Packet<&'a T>,
+ checksum_caps: &ChecksumCapabilities,
+ ) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ fn create_packet_from_payload<'a, T>(packet: &Packet<&'a T>) -> Result<(&'a [u8], Ipv6Repr)>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ // The packet must be truncated to fit the min MTU. Since we don't know the offset of
+ // the ICMPv6 header in the L2 frame, we should only check whether the payload's IPv6
+ // header is present, the rest is allowed to be truncated.
+ let ip_packet = if packet.payload().len() >= IPV6_HEADER_LEN {
+ Ipv6Packet::new_unchecked(packet.payload())
+ } else {
+ return Err(Error);
+ };
+
+ let payload = &packet.payload()[ip_packet.header_len()..];
+ let repr = Ipv6Repr {
+ src_addr: ip_packet.src_addr(),
+ dst_addr: ip_packet.dst_addr(),
+ next_header: ip_packet.next_header(),
+ payload_len: ip_packet.payload_len().into(),
+ hop_limit: ip_packet.hop_limit(),
+ };
+ Ok((payload, repr))
+ }
+ // Valid checksum is expected.
+ if checksum_caps.icmpv6.rx() && !packet.verify_checksum(src_addr, dst_addr) {
+ return Err(Error);
+ }
+
+ match (packet.msg_type(), packet.msg_code()) {
+ (Message::DstUnreachable, code) => {
+ let (payload, repr) = create_packet_from_payload(packet)?;
+ Ok(Repr::DstUnreachable {
+ reason: DstUnreachable::from(code),
+ header: repr,
+ data: payload,
+ })
+ }
+ (Message::PktTooBig, 0) => {
+ let (payload, repr) = create_packet_from_payload(packet)?;
+ Ok(Repr::PktTooBig {
+ mtu: packet.pkt_too_big_mtu(),
+ header: repr,
+ data: payload,
+ })
+ }
+ (Message::TimeExceeded, code) => {
+ let (payload, repr) = create_packet_from_payload(packet)?;
+ Ok(Repr::TimeExceeded {
+ reason: TimeExceeded::from(code),
+ header: repr,
+ data: payload,
+ })
+ }
+ (Message::ParamProblem, code) => {
+ let (payload, repr) = create_packet_from_payload(packet)?;
+ Ok(Repr::ParamProblem {
+ reason: ParamProblem::from(code),
+ pointer: packet.param_problem_ptr(),
+ header: repr,
+ data: payload,
+ })
+ }
+ (Message::EchoRequest, 0) => Ok(Repr::EchoRequest {
+ ident: packet.echo_ident(),
+ seq_no: packet.echo_seq_no(),
+ data: packet.payload(),
+ }),
+ (Message::EchoReply, 0) => Ok(Repr::EchoReply {
+ ident: packet.echo_ident(),
+ seq_no: packet.echo_seq_no(),
+ data: packet.payload(),
+ }),
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ (msg_type, 0) if msg_type.is_ndisc() => NdiscRepr::parse(packet).map(Repr::Ndisc),
+ (msg_type, 0) if msg_type.is_mld() => MldRepr::parse(packet).map(Repr::Mld),
+ #[cfg(feature = "proto-rpl")]
+ (Message::RplControl, _) => RplRepr::parse(packet).map(Repr::Rpl),
+ _ => Err(Error),
+ }
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub fn buffer_len(&self) -> usize {
+ match self {
+ &Repr::DstUnreachable { header, data, .. }
+ | &Repr::PktTooBig { header, data, .. }
+ | &Repr::TimeExceeded { header, data, .. }
+ | &Repr::ParamProblem { header, data, .. } => cmp::min(
+ field::UNUSED.end + header.buffer_len() + data.len(),
+ MAX_ERROR_PACKET_LEN,
+ ),
+ &Repr::EchoRequest { data, .. } | &Repr::EchoReply { data, .. } => {
+ field::ECHO_SEQNO.end + data.len()
+ }
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ &Repr::Ndisc(ndisc) => ndisc.buffer_len(),
+ &Repr::Mld(mld) => mld.buffer_len(),
+ #[cfg(feature = "proto-rpl")]
+ Repr::Rpl(rpl) => rpl.buffer_len(),
+ }
+ }
+
+ /// Emit a high-level representation into an Internet Control Message Protocol version 6
+ /// packet.
+ pub fn emit<T>(
+ &self,
+ src_addr: &IpAddress,
+ dst_addr: &IpAddress,
+ packet: &mut Packet<&mut T>,
+ checksum_caps: &ChecksumCapabilities,
+ ) where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ fn emit_contained_packet<T>(packet: &mut Packet<&mut T>, header: Ipv6Repr, data: &[u8])
+ where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ let icmp_header_len = packet.header_len();
+ let mut ip_packet = Ipv6Packet::new_unchecked(packet.payload_mut());
+ header.emit(&mut ip_packet);
+ let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
+ // FIXME: this should rather be checked at link level, as we can't know in advance how
+ // much space we have for the packet due to IPv6 options and etc
+ let payload_len = cmp::min(
+ data.len(),
+ MAX_ERROR_PACKET_LEN - icmp_header_len - IPV6_HEADER_LEN,
+ );
+ payload[..payload_len].copy_from_slice(&data[..payload_len]);
+ }
+
+ match *self {
+ Repr::DstUnreachable {
+ reason,
+ header,
+ data,
+ } => {
+ packet.set_msg_type(Message::DstUnreachable);
+ packet.set_msg_code(reason.into());
+
+ emit_contained_packet(packet, header, data);
+ }
+
+ Repr::PktTooBig { mtu, header, data } => {
+ packet.set_msg_type(Message::PktTooBig);
+ packet.set_msg_code(0);
+ packet.set_pkt_too_big_mtu(mtu);
+
+ emit_contained_packet(packet, header, data);
+ }
+
+ Repr::TimeExceeded {
+ reason,
+ header,
+ data,
+ } => {
+ packet.set_msg_type(Message::TimeExceeded);
+ packet.set_msg_code(reason.into());
+
+ emit_contained_packet(packet, header, data);
+ }
+
+ Repr::ParamProblem {
+ reason,
+ pointer,
+ header,
+ data,
+ } => {
+ packet.set_msg_type(Message::ParamProblem);
+ packet.set_msg_code(reason.into());
+ packet.set_param_problem_ptr(pointer);
+
+ emit_contained_packet(packet, header, data);
+ }
+
+ Repr::EchoRequest {
+ ident,
+ seq_no,
+ data,
+ } => {
+ packet.set_msg_type(Message::EchoRequest);
+ packet.set_msg_code(0);
+ packet.set_echo_ident(ident);
+ packet.set_echo_seq_no(seq_no);
+ let data_len = cmp::min(packet.payload_mut().len(), data.len());
+ packet.payload_mut()[..data_len].copy_from_slice(&data[..data_len])
+ }
+
+ Repr::EchoReply {
+ ident,
+ seq_no,
+ data,
+ } => {
+ packet.set_msg_type(Message::EchoReply);
+ packet.set_msg_code(0);
+ packet.set_echo_ident(ident);
+ packet.set_echo_seq_no(seq_no);
+ let data_len = cmp::min(packet.payload_mut().len(), data.len());
+ packet.payload_mut()[..data_len].copy_from_slice(&data[..data_len])
+ }
+
+ #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+ Repr::Ndisc(ndisc) => ndisc.emit(packet),
+
+ Repr::Mld(mld) => mld.emit(packet),
+
+ #[cfg(feature = "proto-rpl")]
+ Repr::Rpl(ref rpl) => rpl.emit(packet),
+ }
+
+ if checksum_caps.icmpv6.tx() {
+ packet.fill_checksum(src_addr, dst_addr);
+ } else {
+ // make sure we get a consistently zeroed checksum, since implementations might rely on it
+ packet.set_checksum(0);
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::wire::ip::test::{MOCK_IP_ADDR_1, MOCK_IP_ADDR_2};
+ use crate::wire::{IpProtocol, Ipv6Address, Ipv6Repr};
+
+ static ECHO_PACKET_BYTES: [u8; 12] = [
+ 0x80, 0x00, 0x19, 0xb3, 0x12, 0x34, 0xab, 0xcd, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ static ECHO_PACKET_PAYLOAD: [u8; 4] = [0xaa, 0x00, 0x00, 0xff];
+
+ static PKT_TOO_BIG_BYTES: [u8; 60] = [
+ 0x02, 0x00, 0x0f, 0xc9, 0x00, 0x00, 0x05, 0xdc, 0x60, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x11,
+ 0x40, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x02, 0xbf, 0x00, 0x00, 0x35, 0x00, 0x0c, 0x12, 0x4d, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ static PKT_TOO_BIG_IP_PAYLOAD: [u8; 52] = [
+ 0x60, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x11, 0x40, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xbf, 0x00, 0x00, 0x35, 0x00,
+ 0x0c, 0x12, 0x4d, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ static PKT_TOO_BIG_UDP_PAYLOAD: [u8; 12] = [
+ 0xbf, 0x00, 0x00, 0x35, 0x00, 0x0c, 0x12, 0x4d, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ fn echo_packet_repr() -> Repr<'static> {
+ Repr::EchoRequest {
+ ident: 0x1234,
+ seq_no: 0xabcd,
+ data: &ECHO_PACKET_PAYLOAD,
+ }
+ }
+
+ fn too_big_packet_repr() -> Repr<'static> {
+ Repr::PktTooBig {
+ mtu: 1500,
+ header: Ipv6Repr {
+ src_addr: Ipv6Address([
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x01,
+ ]),
+ dst_addr: Ipv6Address([
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x02,
+ ]),
+ next_header: IpProtocol::Udp,
+ payload_len: 12,
+ hop_limit: 0x40,
+ },
+ data: &PKT_TOO_BIG_UDP_PAYLOAD,
+ }
+ }
+
+ #[test]
+ fn test_echo_deconstruct() {
+ let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::EchoRequest);
+ assert_eq!(packet.msg_code(), 0);
+ assert_eq!(packet.checksum(), 0x19b3);
+ assert_eq!(packet.echo_ident(), 0x1234);
+ assert_eq!(packet.echo_seq_no(), 0xabcd);
+ assert_eq!(packet.payload(), &ECHO_PACKET_PAYLOAD[..]);
+ assert!(packet.verify_checksum(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2));
+ assert!(!packet.msg_type().is_error());
+ }
+
+ #[test]
+ fn test_echo_construct() {
+ let mut bytes = vec![0xa5; 12];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_msg_type(Message::EchoRequest);
+ packet.set_msg_code(0);
+ packet.set_echo_ident(0x1234);
+ packet.set_echo_seq_no(0xabcd);
+ packet
+ .payload_mut()
+ .copy_from_slice(&ECHO_PACKET_PAYLOAD[..]);
+ packet.fill_checksum(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2);
+ assert_eq!(&*packet.into_inner(), &ECHO_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_echo_repr_parse() {
+ let packet = Packet::new_unchecked(&ECHO_PACKET_BYTES[..]);
+ let repr = Repr::parse(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &packet,
+ &ChecksumCapabilities::default(),
+ )
+ .unwrap();
+ assert_eq!(repr, echo_packet_repr());
+ }
+
+ #[test]
+ fn test_echo_emit() {
+ let repr = echo_packet_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &mut packet,
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(&*packet.into_inner(), &ECHO_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_too_big_deconstruct() {
+ let packet = Packet::new_unchecked(&PKT_TOO_BIG_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::PktTooBig);
+ assert_eq!(packet.msg_code(), 0);
+ assert_eq!(packet.checksum(), 0x0fc9);
+ assert_eq!(packet.pkt_too_big_mtu(), 1500);
+ assert_eq!(packet.payload(), &PKT_TOO_BIG_IP_PAYLOAD[..]);
+ assert!(packet.verify_checksum(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2));
+ assert!(packet.msg_type().is_error());
+ }
+
+ #[test]
+ fn test_too_big_construct() {
+ let mut bytes = vec![0xa5; 60];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_msg_type(Message::PktTooBig);
+ packet.set_msg_code(0);
+ packet.set_pkt_too_big_mtu(1500);
+ packet
+ .payload_mut()
+ .copy_from_slice(&PKT_TOO_BIG_IP_PAYLOAD[..]);
+ packet.fill_checksum(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2);
+ assert_eq!(&*packet.into_inner(), &PKT_TOO_BIG_BYTES[..]);
+ }
+
+ #[test]
+ fn test_too_big_repr_parse() {
+ let packet = Packet::new_unchecked(&PKT_TOO_BIG_BYTES[..]);
+ let repr = Repr::parse(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &packet,
+ &ChecksumCapabilities::default(),
+ )
+ .unwrap();
+ assert_eq!(repr, too_big_packet_repr());
+ }
+
+ #[test]
+ fn test_too_big_emit() {
+ let repr = too_big_packet_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &mut packet,
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(&*packet.into_inner(), &PKT_TOO_BIG_BYTES[..]);
+ }
+
+ #[test]
+ fn test_buffer_length_is_truncated_to_mtu() {
+ let repr = Repr::PktTooBig {
+ mtu: 1280,
+ header: Ipv6Repr {
+ src_addr: Default::default(),
+ dst_addr: Default::default(),
+ next_header: IpProtocol::Tcp,
+ hop_limit: 64,
+ payload_len: 1280,
+ },
+ data: &vec![0; 9999],
+ };
+ assert_eq!(repr.buffer_len(), 1280 - IPV6_HEADER_LEN);
+ }
+
+ #[test]
+ fn test_mtu_truncated_payload_roundtrip() {
+ let ip_packet_repr = Ipv6Repr {
+ src_addr: Default::default(),
+ dst_addr: Default::default(),
+ next_header: IpProtocol::Tcp,
+ hop_limit: 64,
+ payload_len: IPV6_MIN_MTU - IPV6_HEADER_LEN,
+ };
+ let mut ip_packet = Ipv6Packet::new_unchecked(vec![0; IPV6_MIN_MTU]);
+ ip_packet_repr.emit(&mut ip_packet);
+
+ let repr1 = Repr::PktTooBig {
+ mtu: IPV6_MIN_MTU as u32,
+ header: ip_packet_repr,
+ data: &ip_packet.as_ref()[IPV6_HEADER_LEN..],
+ };
+ // this is needed to make sure roundtrip gives the same value
+ // it is not needed for ensuring the correct bytes get emitted
+ let repr1 = Repr::PktTooBig {
+ mtu: IPV6_MIN_MTU as u32,
+ header: ip_packet_repr,
+ data: &ip_packet.as_ref()[IPV6_HEADER_LEN..repr1.buffer_len() - field::UNUSED.end],
+ };
+ let mut data = vec![0; MAX_ERROR_PACKET_LEN];
+ let mut packet = Packet::new_unchecked(&mut data);
+ repr1.emit(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &mut packet,
+ &ChecksumCapabilities::default(),
+ );
+
+ let packet = Packet::new_unchecked(&data);
+ let repr2 = Repr::parse(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &packet,
+ &ChecksumCapabilities::default(),
+ )
+ .unwrap();
+
+ assert_eq!(repr1, repr2);
+ }
+
+ #[test]
+ fn test_truncated_payload_ipv6_header_parse_fails() {
+ let repr = too_big_packet_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &mut packet,
+ &ChecksumCapabilities::default(),
+ );
+ let packet = Packet::new_unchecked(&bytes[..field::HEADER_END + IPV6_HEADER_LEN - 1]);
+ assert!(Repr::parse(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &packet,
+ &ChecksumCapabilities::ignored(),
+ )
+ .is_err());
+ }
+}
diff --git a/src/wire/ieee802154.rs b/src/wire/ieee802154.rs
new file mode 100644
index 0000000..33fafb6
--- /dev/null
+++ b/src/wire/ieee802154.rs
@@ -0,0 +1,1182 @@
+use core::fmt;
+
+use byteorder::{ByteOrder, LittleEndian};
+
+use super::{Error, Result};
+use crate::wire::ipv6::Address as Ipv6Address;
+
+enum_with_unknown! {
+ /// IEEE 802.15.4 frame type.
+ pub enum FrameType(u8) {
+ Beacon = 0b000,
+ Data = 0b001,
+ Acknowledgement = 0b010,
+ MacCommand = 0b011,
+ Multipurpose = 0b101,
+ FragmentOrFrak = 0b110,
+ Extended = 0b111,
+ }
+}
+
+impl fmt::Display for FrameType {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ FrameType::Beacon => write!(f, "Beacon"),
+ FrameType::Data => write!(f, "Data"),
+ FrameType::Acknowledgement => write!(f, "Ack"),
+ FrameType::MacCommand => write!(f, "MAC command"),
+ FrameType::Multipurpose => write!(f, "Multipurpose"),
+ FrameType::FragmentOrFrak => write!(f, "FragmentOrFrak"),
+ FrameType::Extended => write!(f, "Extended"),
+ FrameType::Unknown(id) => write!(f, "0b{id:04b}"),
+ }
+ }
+}
+enum_with_unknown! {
+ /// IEEE 802.15.4 addressing mode for destination and source addresses.
+ pub enum AddressingMode(u8) {
+ Absent = 0b00,
+ Short = 0b10,
+ Extended = 0b11,
+ }
+}
+
+impl AddressingMode {
+ /// Return the size in octets of the address.
+ const fn size(&self) -> usize {
+ match self {
+ AddressingMode::Absent => 0,
+ AddressingMode::Short => 2,
+ AddressingMode::Extended => 8,
+ AddressingMode::Unknown(_) => 0, // TODO(thvdveld): what do we need to here?
+ }
+ }
+}
+
+impl fmt::Display for AddressingMode {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ AddressingMode::Absent => write!(f, "Absent"),
+ AddressingMode::Short => write!(f, "Short"),
+ AddressingMode::Extended => write!(f, "Extended"),
+ AddressingMode::Unknown(id) => write!(f, "0b{id:04b}"),
+ }
+ }
+}
+
+/// A IEEE 802.15.4 PAN.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub struct Pan(pub u16);
+
+impl Pan {
+ pub const BROADCAST: Self = Self(0xffff);
+
+ /// Return the PAN ID as bytes.
+ pub fn as_bytes(&self) -> [u8; 2] {
+ let mut pan = [0u8; 2];
+ LittleEndian::write_u16(&mut pan, self.0);
+ pan
+ }
+}
+
+impl fmt::Display for Pan {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{:0x}", self.0)
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Pan {
+ fn format(&self, fmt: defmt::Formatter) {
+ defmt::write!(fmt, "{:02x}", self.0)
+ }
+}
+
+/// A IEEE 802.15.4 address.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub enum Address {
+ Absent,
+ Short([u8; 2]),
+ Extended([u8; 8]),
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Address {
+ fn format(&self, f: defmt::Formatter) {
+ match self {
+ Self::Absent => defmt::write!(f, "not-present"),
+ Self::Short(bytes) => defmt::write!(f, "{:02x}:{:02x}", bytes[0], bytes[1]),
+ Self::Extended(bytes) => defmt::write!(
+ f,
+ "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
+ bytes[0],
+ bytes[1],
+ bytes[2],
+ bytes[3],
+ bytes[4],
+ bytes[5],
+ bytes[6],
+ bytes[7]
+ ),
+ }
+ }
+}
+
+#[cfg(test)]
+impl Default for Address {
+ fn default() -> Self {
+ Address::Extended([0u8; 8])
+ }
+}
+
+impl Address {
+ /// The broadcast address.
+ pub const BROADCAST: Address = Address::Short([0xff; 2]);
+
+ /// Query whether the address is an unicast address.
+ pub fn is_unicast(&self) -> bool {
+ !self.is_broadcast()
+ }
+
+ /// Query whether this address is the broadcast address.
+ pub fn is_broadcast(&self) -> bool {
+ *self == Self::BROADCAST
+ }
+
+ const fn short_from_bytes(a: [u8; 2]) -> Self {
+ Self::Short(a)
+ }
+
+ const fn extended_from_bytes(a: [u8; 8]) -> Self {
+ Self::Extended(a)
+ }
+
+ pub fn from_bytes(a: &[u8]) -> Self {
+ if a.len() == 2 {
+ let mut b = [0u8; 2];
+ b.copy_from_slice(a);
+ Address::Short(b)
+ } else if a.len() == 8 {
+ let mut b = [0u8; 8];
+ b.copy_from_slice(a);
+ Address::Extended(b)
+ } else {
+ panic!("Not an IEEE802.15.4 address");
+ }
+ }
+
+ pub const fn as_bytes(&self) -> &[u8] {
+ match self {
+ Address::Absent => &[],
+ Address::Short(value) => value,
+ Address::Extended(value) => value,
+ }
+ }
+
+ /// Convert the extended address to an Extended Unique Identifier (EUI-64)
+ pub fn as_eui_64(&self) -> Option<[u8; 8]> {
+ match self {
+ Address::Absent | Address::Short(_) => None,
+ Address::Extended(value) => {
+ let mut bytes = [0; 8];
+ bytes.copy_from_slice(&value[..]);
+
+ bytes[0] ^= 1 << 1;
+
+ Some(bytes)
+ }
+ }
+ }
+
+ /// Convert an extended address to a link-local IPv6 address using the EUI-64 format from
+ /// RFC2464.
+ pub fn as_link_local_address(&self) -> Option<Ipv6Address> {
+ let mut bytes = [0; 16];
+ bytes[0] = 0xfe;
+ bytes[1] = 0x80;
+ bytes[8..].copy_from_slice(&self.as_eui_64()?);
+
+ Some(Ipv6Address::from_bytes(&bytes))
+ }
+}
+
+impl fmt::Display for Address {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ Self::Absent => write!(f, "not-present"),
+ Self::Short(bytes) => write!(f, "{:02x}:{:02x}", bytes[0], bytes[1]),
+ Self::Extended(bytes) => write!(
+ f,
+ "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
+ bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]
+ ),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// IEEE 802.15.4 addressing mode for destination and source addresses.
+ pub enum FrameVersion(u8) {
+ Ieee802154_2003 = 0b00,
+ Ieee802154_2006 = 0b01,
+ Ieee802154 = 0b10,
+ }
+}
+
+/// A read/write wrapper around an IEEE 802.15.4 frame buffer.
+#[derive(Debug, Clone)]
+pub struct Frame<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const FRAMECONTROL: Field = 0..2;
+ pub const SEQUENCE_NUMBER: usize = 2;
+ pub const ADDRESSING: Rest = 3..;
+}
+
+macro_rules! fc_bit_field {
+ ($field:ident, $bit:literal) => {
+ #[inline]
+ pub fn $field(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = LittleEndian::read_u16(&data[field::FRAMECONTROL]);
+
+ ((raw >> $bit) & 0b1) == 0b1
+ }
+ };
+}
+
+macro_rules! set_fc_bit_field {
+ ($field:ident, $bit:literal) => {
+ #[inline]
+ pub fn $field(&mut self, val: bool) {
+ let data = &mut self.buffer.as_mut()[field::FRAMECONTROL];
+ let mut raw = LittleEndian::read_u16(data);
+ raw |= ((val as u16) << $bit);
+
+ data.copy_from_slice(&raw.to_le_bytes());
+ }
+ };
+}
+
+impl<T: AsRef<[u8]>> Frame<T> {
+ /// Input a raw octet buffer with Ethernet frame structure.
+ pub const fn new_unchecked(buffer: T) -> Frame<T> {
+ Frame { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Frame<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+
+ // We don't handle unknown frame versions.
+ if matches!(packet.frame_version(), FrameVersion::Unknown(_)) {
+ return Err(Error);
+ }
+
+ // We don't handle unknown addressing modes.
+ if matches!(packet.dst_addressing_mode(), AddressingMode::Unknown(_))
+ || matches!(packet.src_addressing_mode(), AddressingMode::Unknown(_))
+ {
+ return Err(Error);
+ }
+
+ // We don't handle absent addressing mode with PAN ID compression for older frame versions.
+ if matches!(
+ packet.frame_version(),
+ FrameVersion::Ieee802154_2003 | FrameVersion::Ieee802154_2006
+ ) && packet.pan_id_compression()
+ && matches!(packet.dst_addressing_mode(), AddressingMode::Absent)
+ && matches!(packet.src_addressing_mode(), AddressingMode::Absent)
+ {
+ return Err(Error);
+ }
+
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ // We need at least 3 bytes
+ if self.buffer.as_ref().len() < 3 {
+ return Err(Error);
+ }
+
+ // We don't handle frames with a payload larger than 127 bytes.
+ if self.buffer.as_ref().len() > 127 {
+ return Err(Error);
+ }
+
+ let mut offset = field::ADDRESSING.start
+ + if let Some((dst_pan_id, dst_addr, src_pan_id, src_addr)) = self.addr_present_flags()
+ {
+ let mut offset = if dst_pan_id { 2 } else { 0 };
+ offset += dst_addr.size();
+ offset += if src_pan_id { 2 } else { 0 };
+ offset += src_addr.size();
+
+ if offset > self.buffer.as_ref().len() {
+ return Err(Error);
+ }
+ offset
+ } else {
+ 0
+ };
+
+ if self.security_enabled() {
+ // First check that we can access the security header control bits.
+ if offset + 1 > self.buffer.as_ref().len() {
+ return Err(Error);
+ }
+
+ offset += self.security_header_len();
+ }
+
+ if offset > self.buffer.as_ref().len() {
+ return Err(Error);
+ }
+
+ Ok(())
+ }
+
+ /// Consumes the frame, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the FrameType field.
+ #[inline]
+ pub fn frame_type(&self) -> FrameType {
+ let data = self.buffer.as_ref();
+ let raw = LittleEndian::read_u16(&data[field::FRAMECONTROL]);
+ let ft = (raw & 0b111) as u8;
+ FrameType::from(ft)
+ }
+
+ fc_bit_field!(security_enabled, 3);
+ fc_bit_field!(frame_pending, 4);
+ fc_bit_field!(ack_request, 5);
+ fc_bit_field!(pan_id_compression, 6);
+
+ fc_bit_field!(sequence_number_suppression, 8);
+ fc_bit_field!(ie_present, 9);
+
+ /// Return the destination addressing mode.
+ #[inline]
+ pub fn dst_addressing_mode(&self) -> AddressingMode {
+ let data = self.buffer.as_ref();
+ let raw = LittleEndian::read_u16(&data[field::FRAMECONTROL]);
+ let am = ((raw >> 10) & 0b11) as u8;
+ AddressingMode::from(am)
+ }
+
+ /// Return the frame version.
+ #[inline]
+ pub fn frame_version(&self) -> FrameVersion {
+ let data = self.buffer.as_ref();
+ let raw = LittleEndian::read_u16(&data[field::FRAMECONTROL]);
+ let fv = ((raw >> 12) & 0b11) as u8;
+ FrameVersion::from(fv)
+ }
+
+ /// Return the source addressing mode.
+ #[inline]
+ pub fn src_addressing_mode(&self) -> AddressingMode {
+ let data = self.buffer.as_ref();
+ let raw = LittleEndian::read_u16(&data[field::FRAMECONTROL]);
+ let am = ((raw >> 14) & 0b11) as u8;
+ AddressingMode::from(am)
+ }
+
+ /// Return the sequence number of the frame.
+ #[inline]
+ pub fn sequence_number(&self) -> Option<u8> {
+ match self.frame_type() {
+ FrameType::Beacon
+ | FrameType::Data
+ | FrameType::Acknowledgement
+ | FrameType::MacCommand
+ | FrameType::Multipurpose => {
+ let data = self.buffer.as_ref();
+ let raw = data[field::SEQUENCE_NUMBER];
+ Some(raw)
+ }
+ FrameType::Extended | FrameType::FragmentOrFrak | FrameType::Unknown(_) => None,
+ }
+ }
+
+ /// Return the addressing fields.
+ #[inline]
+ fn addressing_fields(&self) -> Option<&[u8]> {
+ match self.frame_type() {
+ FrameType::Beacon
+ | FrameType::Data
+ | FrameType::MacCommand
+ | FrameType::Multipurpose => (),
+ FrameType::Acknowledgement if self.frame_version() == FrameVersion::Ieee802154 => (),
+ FrameType::Acknowledgement
+ | FrameType::Extended
+ | FrameType::FragmentOrFrak
+ | FrameType::Unknown(_) => return None,
+ }
+
+ if let Some((dst_pan_id, dst_addr, src_pan_id, src_addr)) = self.addr_present_flags() {
+ let mut offset = if dst_pan_id { 2 } else { 0 };
+ offset += dst_addr.size();
+ offset += if src_pan_id { 2 } else { 0 };
+ offset += src_addr.size();
+
+ let data = self.buffer.as_ref();
+ Some(&data[field::ADDRESSING][..offset])
+ } else {
+ None
+ }
+ }
+
+ fn addr_present_flags(&self) -> Option<(bool, AddressingMode, bool, AddressingMode)> {
+ let dst_addr_mode = self.dst_addressing_mode();
+ let src_addr_mode = self.src_addressing_mode();
+ let pan_id_compression = self.pan_id_compression();
+
+ use AddressingMode::*;
+ match self.frame_version() {
+ FrameVersion::Ieee802154_2003 | FrameVersion::Ieee802154_2006 => {
+ match (dst_addr_mode, src_addr_mode) {
+ (Absent, src) => Some((false, Absent, true, src)),
+ (dst, Absent) => Some((true, dst, false, Absent)),
+
+ (dst, src) if pan_id_compression => Some((true, dst, false, src)),
+ (dst, src) if !pan_id_compression => Some((true, dst, true, src)),
+ _ => None,
+ }
+ }
+ FrameVersion::Ieee802154 => {
+ Some(match (dst_addr_mode, src_addr_mode, pan_id_compression) {
+ (Absent, Absent, false) => (false, Absent, false, Absent),
+ (Absent, Absent, true) => (true, Absent, false, Absent),
+ (dst, Absent, false) if !matches!(dst, Absent) => (true, dst, false, Absent),
+ (dst, Absent, true) if !matches!(dst, Absent) => (false, dst, false, Absent),
+ (Absent, src, false) if !matches!(src, Absent) => (false, Absent, true, src),
+ (Absent, src, true) if !matches!(src, Absent) => (false, Absent, true, src),
+ (Extended, Extended, false) => (true, Extended, false, Extended),
+ (Extended, Extended, true) => (false, Extended, false, Extended),
+ (Short, Short, false) => (true, Short, true, Short),
+ (Short, Extended, false) => (true, Short, true, Extended),
+ (Extended, Short, false) => (true, Extended, true, Short),
+ (Short, Extended, true) => (true, Short, false, Extended),
+ (Extended, Short, true) => (true, Extended, false, Short),
+ (Short, Short, true) => (true, Short, false, Short),
+ _ => return None,
+ })
+ }
+ _ => None,
+ }
+ }
+
+ /// Return the destination PAN field.
+ #[inline]
+ pub fn dst_pan_id(&self) -> Option<Pan> {
+ if let Some((true, _, _, _)) = self.addr_present_flags() {
+ let addressing_fields = self.addressing_fields()?;
+ Some(Pan(LittleEndian::read_u16(&addressing_fields[..2])))
+ } else {
+ None
+ }
+ }
+
+ /// Return the destination address field.
+ #[inline]
+ pub fn dst_addr(&self) -> Option<Address> {
+ if let Some((dst_pan_id, dst_addr, _, _)) = self.addr_present_flags() {
+ let addressing_fields = self.addressing_fields()?;
+ let offset = if dst_pan_id { 2 } else { 0 };
+
+ match dst_addr {
+ AddressingMode::Absent => Some(Address::Absent),
+ AddressingMode::Short => {
+ let mut raw = [0u8; 2];
+ raw.clone_from_slice(&addressing_fields[offset..offset + 2]);
+ raw.reverse();
+ Some(Address::short_from_bytes(raw))
+ }
+ AddressingMode::Extended => {
+ let mut raw = [0u8; 8];
+ raw.clone_from_slice(&addressing_fields[offset..offset + 8]);
+ raw.reverse();
+ Some(Address::extended_from_bytes(raw))
+ }
+ AddressingMode::Unknown(_) => None,
+ }
+ } else {
+ None
+ }
+ }
+
+ /// Return the destination PAN field.
+ #[inline]
+ pub fn src_pan_id(&self) -> Option<Pan> {
+ if let Some((dst_pan_id, dst_addr, true, _)) = self.addr_present_flags() {
+ let mut offset = if dst_pan_id { 2 } else { 0 };
+ offset += dst_addr.size();
+ let addressing_fields = self.addressing_fields()?;
+ Some(Pan(LittleEndian::read_u16(
+ &addressing_fields[offset..][..2],
+ )))
+ } else {
+ None
+ }
+ }
+
+ /// Return the source address field.
+ #[inline]
+ pub fn src_addr(&self) -> Option<Address> {
+ if let Some((dst_pan_id, dst_addr, src_pan_id, src_addr)) = self.addr_present_flags() {
+ let addressing_fields = self.addressing_fields()?;
+ let mut offset = if dst_pan_id { 2 } else { 0 };
+ offset += dst_addr.size();
+ offset += if src_pan_id { 2 } else { 0 };
+
+ match src_addr {
+ AddressingMode::Absent => Some(Address::Absent),
+ AddressingMode::Short => {
+ let mut raw = [0u8; 2];
+ raw.clone_from_slice(&addressing_fields[offset..offset + 2]);
+ raw.reverse();
+ Some(Address::short_from_bytes(raw))
+ }
+ AddressingMode::Extended => {
+ let mut raw = [0u8; 8];
+ raw.clone_from_slice(&addressing_fields[offset..offset + 8]);
+ raw.reverse();
+ Some(Address::extended_from_bytes(raw))
+ }
+ AddressingMode::Unknown(_) => None,
+ }
+ } else {
+ None
+ }
+ }
+
+ /// Return the index where the auxiliary security header starts.
+ fn aux_security_header_start(&self) -> usize {
+ // We start with 3, because 2 bytes for frame control and the sequence number.
+ let mut index = 3;
+ index += if let Some(addrs) = self.addressing_fields() {
+ addrs.len()
+ } else {
+ 0
+ };
+ index
+ }
+
+ /// Return the size of the security header.
+ fn security_header_len(&self) -> usize {
+ let mut size = 1;
+ size += if self.frame_counter_suppressed() {
+ 0
+ } else {
+ 4
+ };
+ size += if let Some(len) = self.key_identifier_length() {
+ len as usize
+ } else {
+ 0
+ };
+ size
+ }
+
+ /// Return the index where the payload starts.
+ fn payload_start(&self) -> usize {
+ let mut index = self.aux_security_header_start();
+
+ if self.security_enabled() {
+ index += self.security_header_len();
+ }
+
+ index
+ }
+
+ /// Return the length of the key identifier field.
+ fn key_identifier_length(&self) -> Option<u8> {
+ Some(match self.key_identifier_mode() {
+ 0 => 0,
+ 1 => 1,
+ 2 => 5,
+ 3 => 9,
+ _ => return None,
+ })
+ }
+
+ /// Return the security level of the auxiliary security header.
+ pub fn security_level(&self) -> u8 {
+ let index = self.aux_security_header_start();
+ let b = self.buffer.as_ref()[index..][0];
+ b & 0b111
+ }
+
+ /// Return the key identifier mode used by the auxiliary security header.
+ pub fn key_identifier_mode(&self) -> u8 {
+ let index = self.aux_security_header_start();
+ let b = self.buffer.as_ref()[index..][0];
+ (b >> 3) & 0b11
+ }
+
+ /// Return `true` when the frame counter in the security header is suppressed.
+ pub fn frame_counter_suppressed(&self) -> bool {
+ let index = self.aux_security_header_start();
+ let b = self.buffer.as_ref()[index..][0];
+ ((b >> 5) & 0b1) == 0b1
+ }
+
+ /// Return the frame counter field.
+ pub fn frame_counter(&self) -> Option<u32> {
+ if self.frame_counter_suppressed() {
+ None
+ } else {
+ let index = self.aux_security_header_start();
+ let b = &self.buffer.as_ref()[index..];
+ Some(LittleEndian::read_u32(&b[1..1 + 4]))
+ }
+ }
+
+ /// Return the Key Identifier field.
+ fn key_identifier(&self) -> &[u8] {
+ let index = self.aux_security_header_start();
+ let b = &self.buffer.as_ref()[index..];
+ let length = if let Some(len) = self.key_identifier_length() {
+ len as usize
+ } else {
+ 0
+ };
+ &b[5..][..length]
+ }
+
+ /// Return the Key Source field.
+ pub fn key_source(&self) -> Option<&[u8]> {
+ let ki = self.key_identifier();
+ let len = ki.len();
+ if len > 1 {
+ Some(&ki[..len - 1])
+ } else {
+ None
+ }
+ }
+
+ /// Return the Key Index field.
+ pub fn key_index(&self) -> Option<u8> {
+ let ki = self.key_identifier();
+ let len = ki.len();
+
+ if len > 0 {
+ Some(ki[len - 1])
+ } else {
+ None
+ }
+ }
+
+ /// Return the Message Integrity Code (MIC).
+ pub fn message_integrity_code(&self) -> Option<&[u8]> {
+ let mic_len = match self.security_level() {
+ 0 | 4 => return None,
+ 1 | 5 => 4,
+ 2 | 6 => 8,
+ 3 | 7 => 16,
+ _ => panic!(),
+ };
+
+ let data = &self.buffer.as_ref();
+ let len = data.len();
+
+ Some(&data[len - mic_len..])
+ }
+
+ /// Return the MAC header.
+ pub fn mac_header(&self) -> &[u8] {
+ let data = &self.buffer.as_ref();
+ &data[..self.payload_start()]
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Frame<&'a T> {
+ /// Return a pointer to the payload.
+ #[inline]
+ pub fn payload(&self) -> Option<&'a [u8]> {
+ match self.frame_type() {
+ FrameType::Data => {
+ let index = self.payload_start();
+ let data = &self.buffer.as_ref();
+
+ Some(&data[index..])
+ }
+ _ => None,
+ }
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Frame<T> {
+ /// Set the frame type.
+ #[inline]
+ pub fn set_frame_type(&mut self, frame_type: FrameType) {
+ let data = &mut self.buffer.as_mut()[field::FRAMECONTROL];
+ let mut raw = LittleEndian::read_u16(data);
+
+ raw = (raw & !(0b111)) | (u8::from(frame_type) as u16 & 0b111);
+ data.copy_from_slice(&raw.to_le_bytes());
+ }
+
+ set_fc_bit_field!(set_security_enabled, 3);
+ set_fc_bit_field!(set_frame_pending, 4);
+ set_fc_bit_field!(set_ack_request, 5);
+ set_fc_bit_field!(set_pan_id_compression, 6);
+
+ /// Set the frame version.
+ #[inline]
+ pub fn set_frame_version(&mut self, version: FrameVersion) {
+ let data = &mut self.buffer.as_mut()[field::FRAMECONTROL];
+ let mut raw = LittleEndian::read_u16(data);
+
+ raw = (raw & !(0b11 << 12)) | ((u8::from(version) as u16 & 0b11) << 12);
+ data.copy_from_slice(&raw.to_le_bytes());
+ }
+
+ /// Set the frame sequence number.
+ #[inline]
+ pub fn set_sequence_number(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::SEQUENCE_NUMBER] = value;
+ }
+
+ /// Set the destination PAN ID.
+ #[inline]
+ pub fn set_dst_pan_id(&mut self, value: Pan) {
+ // NOTE the destination addressing mode must be different than Absent.
+ // This is the reason why we set it to Extended.
+ self.set_dst_addressing_mode(AddressingMode::Extended);
+
+ let data = self.buffer.as_mut();
+ data[field::ADDRESSING][..2].copy_from_slice(&value.as_bytes());
+ }
+
+ /// Set the destination address.
+ #[inline]
+ pub fn set_dst_addr(&mut self, value: Address) {
+ match value {
+ Address::Absent => self.set_dst_addressing_mode(AddressingMode::Absent),
+ Address::Short(mut value) => {
+ value.reverse();
+ self.set_dst_addressing_mode(AddressingMode::Short);
+ let data = self.buffer.as_mut();
+ data[field::ADDRESSING][2..2 + 2].copy_from_slice(&value);
+ value.reverse();
+ }
+ Address::Extended(mut value) => {
+ value.reverse();
+ self.set_dst_addressing_mode(AddressingMode::Extended);
+ let data = &mut self.buffer.as_mut()[field::ADDRESSING];
+ data[2..2 + 8].copy_from_slice(&value);
+ value.reverse();
+ }
+ }
+ }
+
+ /// Set the destination addressing mode.
+ #[inline]
+ fn set_dst_addressing_mode(&mut self, value: AddressingMode) {
+ let data = &mut self.buffer.as_mut()[field::FRAMECONTROL];
+ let mut raw = LittleEndian::read_u16(data);
+
+ raw = (raw & !(0b11 << 10)) | ((u8::from(value) as u16 & 0b11) << 10);
+ data.copy_from_slice(&raw.to_le_bytes());
+ }
+
+ /// Set the source PAN ID.
+ #[inline]
+ pub fn set_src_pan_id(&mut self, value: Pan) {
+ let offset = match self.dst_addressing_mode() {
+ AddressingMode::Absent => 0,
+ AddressingMode::Short => 2,
+ AddressingMode::Extended => 8,
+ _ => unreachable!(),
+ } + 2;
+
+ let data = &mut self.buffer.as_mut()[field::ADDRESSING];
+ data[offset..offset + 2].copy_from_slice(&value.as_bytes());
+ }
+
+ /// Set the source address.
+ #[inline]
+ pub fn set_src_addr(&mut self, value: Address) {
+ let offset = match self.dst_addressing_mode() {
+ AddressingMode::Absent => 0,
+ AddressingMode::Short => 2,
+ AddressingMode::Extended => 8,
+ _ => unreachable!(),
+ } + 2;
+
+ let offset = offset + if self.pan_id_compression() { 0 } else { 2 };
+
+ match value {
+ Address::Absent => self.set_src_addressing_mode(AddressingMode::Absent),
+ Address::Short(mut value) => {
+ value.reverse();
+ self.set_src_addressing_mode(AddressingMode::Short);
+ let data = &mut self.buffer.as_mut()[field::ADDRESSING];
+ data[offset..offset + 2].copy_from_slice(&value);
+ value.reverse();
+ }
+ Address::Extended(mut value) => {
+ value.reverse();
+ self.set_src_addressing_mode(AddressingMode::Extended);
+ let data = &mut self.buffer.as_mut()[field::ADDRESSING];
+ data[offset..offset + 8].copy_from_slice(&value);
+ value.reverse();
+ }
+ }
+ }
+
+ /// Set the source addressing mode.
+ #[inline]
+ fn set_src_addressing_mode(&mut self, value: AddressingMode) {
+ let data = &mut self.buffer.as_mut()[field::FRAMECONTROL];
+ let mut raw = LittleEndian::read_u16(data);
+
+ raw = (raw & !(0b11 << 14)) | ((u8::from(value) as u16 & 0b11) << 14);
+ data.copy_from_slice(&raw.to_le_bytes());
+ }
+
+ /// Return a mutable pointer to the payload.
+ #[inline]
+ pub fn payload_mut(&mut self) -> Option<&mut [u8]> {
+ match self.frame_type() {
+ FrameType::Data => {
+ let index = self.payload_start();
+ let data = self.buffer.as_mut();
+ Some(&mut data[index..])
+ }
+ _ => None,
+ }
+ }
+}
+
+impl<T: AsRef<[u8]>> fmt::Display for Frame<T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "IEEE802.15.4 frame type={}", self.frame_type())?;
+
+ if let Some(seq) = self.sequence_number() {
+ write!(f, " seq={:02x}", seq)?;
+ }
+
+ if let Some(pan) = self.dst_pan_id() {
+ write!(f, " dst-pan={}", pan)?;
+ }
+
+ if let Some(pan) = self.src_pan_id() {
+ write!(f, " src-pan={}", pan)?;
+ }
+
+ if let Some(addr) = self.dst_addr() {
+ write!(f, " dst={}", addr)?;
+ }
+
+ if let Some(addr) = self.src_addr() {
+ write!(f, " src={}", addr)?;
+ }
+
+ Ok(())
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl<T: AsRef<[u8]>> defmt::Format for Frame<T> {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(f, "IEEE802.15.4 frame type={}", self.frame_type());
+
+ if let Some(seq) = self.sequence_number() {
+ defmt::write!(f, " seq={:02x}", seq);
+ }
+
+ if let Some(pan) = self.dst_pan_id() {
+ defmt::write!(f, " dst-pan={}", pan);
+ }
+
+ if let Some(pan) = self.src_pan_id() {
+ defmt::write!(f, " src-pan={}", pan);
+ }
+
+ if let Some(addr) = self.dst_addr() {
+ defmt::write!(f, " dst={}", addr);
+ }
+
+ if let Some(addr) = self.src_addr() {
+ defmt::write!(f, " src={}", addr);
+ }
+ }
+}
+
+/// A high-level representation of an IEEE802.15.4 frame.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr {
+ pub frame_type: FrameType,
+ pub security_enabled: bool,
+ pub frame_pending: bool,
+ pub ack_request: bool,
+ pub sequence_number: Option<u8>,
+ pub pan_id_compression: bool,
+ pub frame_version: FrameVersion,
+ pub dst_pan_id: Option<Pan>,
+ pub dst_addr: Option<Address>,
+ pub src_pan_id: Option<Pan>,
+ pub src_addr: Option<Address>,
+}
+
+impl Repr {
+ /// Parse an IEEE 802.15.4 frame and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(packet: &Frame<&T>) -> Result<Repr> {
+ // Ensure the basic accessors will work.
+ packet.check_len()?;
+
+ Ok(Repr {
+ frame_type: packet.frame_type(),
+ security_enabled: packet.security_enabled(),
+ frame_pending: packet.frame_pending(),
+ ack_request: packet.ack_request(),
+ sequence_number: packet.sequence_number(),
+ pan_id_compression: packet.pan_id_compression(),
+ frame_version: packet.frame_version(),
+ dst_pan_id: packet.dst_pan_id(),
+ dst_addr: packet.dst_addr(),
+ src_pan_id: packet.src_pan_id(),
+ src_addr: packet.src_addr(),
+ })
+ }
+
+ /// Return the length of a buffer required to hold a packet with the payload of a given length.
+ #[inline]
+ pub const fn buffer_len(&self) -> usize {
+ 3 + 2
+ + match self.dst_addr {
+ Some(Address::Absent) | None => 0,
+ Some(Address::Short(_)) => 2,
+ Some(Address::Extended(_)) => 8,
+ }
+ + if !self.pan_id_compression { 2 } else { 0 }
+ + match self.src_addr {
+ Some(Address::Absent) | None => 0,
+ Some(Address::Short(_)) => 2,
+ Some(Address::Extended(_)) => 8,
+ }
+ }
+
+ /// Emit a high-level representation into an IEEE802.15.4 frame.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, frame: &mut Frame<T>) {
+ frame.set_frame_type(self.frame_type);
+ frame.set_security_enabled(self.security_enabled);
+ frame.set_frame_pending(self.frame_pending);
+ frame.set_ack_request(self.ack_request);
+ frame.set_pan_id_compression(self.pan_id_compression);
+ frame.set_frame_version(self.frame_version);
+
+ if let Some(sequence_number) = self.sequence_number {
+ frame.set_sequence_number(sequence_number);
+ }
+
+ if let Some(dst_pan_id) = self.dst_pan_id {
+ frame.set_dst_pan_id(dst_pan_id);
+ }
+ if let Some(dst_addr) = self.dst_addr {
+ frame.set_dst_addr(dst_addr);
+ }
+
+ if !self.pan_id_compression && self.src_pan_id.is_some() {
+ frame.set_src_pan_id(self.src_pan_id.unwrap());
+ }
+
+ if let Some(src_addr) = self.src_addr {
+ frame.set_src_addr(src_addr);
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn test_broadcast() {
+ assert!(Address::BROADCAST.is_broadcast());
+ assert!(!Address::BROADCAST.is_unicast());
+ }
+
+ #[test]
+ fn prepare_frame() {
+ let mut buffer = [0u8; 128];
+
+ let repr = Repr {
+ frame_type: FrameType::Data,
+ security_enabled: false,
+ frame_pending: false,
+ ack_request: true,
+ pan_id_compression: true,
+ frame_version: FrameVersion::Ieee802154,
+ sequence_number: Some(1),
+ dst_pan_id: Some(Pan(0xabcd)),
+ dst_addr: Some(Address::BROADCAST),
+ src_pan_id: None,
+ src_addr: Some(Address::Extended([
+ 0xc7, 0xd9, 0xb5, 0x14, 0x00, 0x4b, 0x12, 0x00,
+ ])),
+ };
+
+ let buffer_len = repr.buffer_len();
+
+ let mut frame = Frame::new_unchecked(&mut buffer[..buffer_len]);
+ repr.emit(&mut frame);
+
+ println!("{frame:2x?}");
+
+ assert_eq!(frame.frame_type(), FrameType::Data);
+ assert!(!frame.security_enabled());
+ assert!(!frame.frame_pending());
+ assert!(frame.ack_request());
+ assert!(frame.pan_id_compression());
+ assert_eq!(frame.frame_version(), FrameVersion::Ieee802154);
+ assert_eq!(frame.sequence_number(), Some(1));
+ assert_eq!(frame.dst_pan_id(), Some(Pan(0xabcd)));
+ assert_eq!(frame.dst_addr(), Some(Address::BROADCAST));
+ assert_eq!(frame.src_pan_id(), None);
+ assert_eq!(
+ frame.src_addr(),
+ Some(Address::Extended([
+ 0xc7, 0xd9, 0xb5, 0x14, 0x00, 0x4b, 0x12, 0x00
+ ]))
+ );
+ }
+
+ macro_rules! vector_test {
+ ($name:ident $bytes:expr ; $($test_method:ident -> $expected:expr,)*) => {
+ #[test]
+ #[allow(clippy::bool_assert_comparison)]
+ fn $name() -> Result<()> {
+ let frame = &$bytes;
+ let frame = Frame::new_checked(frame)?;
+
+ $(
+ assert_eq!(frame.$test_method(), $expected, stringify!($test_method));
+ )*
+
+ Ok(())
+ }
+ }
+ }
+
+ vector_test! {
+ extended_addr
+ [
+ 0b0000_0001, 0b1100_1100, // frame control
+ 0b0, // seq
+ 0xcd, 0xab, // pan id
+ 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, // dst addr
+ 0x03, 0x04, // pan id
+ 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, // src addr
+ ];
+ frame_type -> FrameType::Data,
+ dst_addr -> Some(Address::Extended([0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00])),
+ src_addr -> Some(Address::Extended([0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00])),
+ dst_pan_id -> Some(Pan(0xabcd)),
+ }
+
+ vector_test! {
+ short_addr
+ [
+ 0x01, 0x98, // frame control
+ 0x00, // sequence number
+ 0x34, 0x12, 0x78, 0x56, // PAN identifier and address of destination
+ 0x34, 0x12, 0xbc, 0x9a, // PAN identifier and address of source
+ ];
+ frame_type -> FrameType::Data,
+ security_enabled -> false,
+ frame_pending -> false,
+ ack_request -> false,
+ pan_id_compression -> false,
+ dst_addressing_mode -> AddressingMode::Short,
+ frame_version -> FrameVersion::Ieee802154_2006,
+ src_addressing_mode -> AddressingMode::Short,
+ dst_pan_id -> Some(Pan(0x1234)),
+ dst_addr -> Some(Address::Short([0x56, 0x78])),
+ src_pan_id -> Some(Pan(0x1234)),
+ src_addr -> Some(Address::Short([0x9a, 0xbc])),
+ }
+
+ vector_test! {
+ zolertia_remote
+ [
+ 0x41, 0xd8, // frame control
+ 0x01, // sequence number
+ 0xcd, 0xab, // Destination PAN id
+ 0xff, 0xff, // Short destination address
+ 0xc7, 0xd9, 0xb5, 0x14, 0x00, 0x4b, 0x12, 0x00, // Extended source address
+ 0x2b, 0x00, 0x00, 0x00, // payload
+ ];
+ frame_type -> FrameType::Data,
+ security_enabled -> false,
+ frame_pending -> false,
+ ack_request -> false,
+ pan_id_compression -> true,
+ dst_addressing_mode -> AddressingMode::Short,
+ frame_version -> FrameVersion::Ieee802154_2006,
+ src_addressing_mode -> AddressingMode::Extended,
+ payload -> Some(&[0x2b, 0x00, 0x00, 0x00][..]),
+ }
+
+ vector_test! {
+ security
+ [
+ 0x69,0xdc, // frame control
+ 0x32, // sequence number
+ 0xcd,0xab, // destination PAN id
+ 0xbf,0x9b,0x15,0x06,0x00,0x4b,0x12,0x00, // extended destination address
+ 0xc7,0xd9,0xb5,0x14,0x00,0x4b,0x12,0x00, // extended source address
+ 0x05, // security control field
+ 0x31,0x01,0x00,0x00, // frame counter
+ 0x3e,0xe8,0xfb,0x85,0xe4,0xcc,0xf4,0x48,0x90,0xfe,0x56,0x66,0xf7,0x1c,0x65,0x9e,0xf9, // data
+ 0x93,0xc8,0x34,0x2e,// MIC
+ ];
+ frame_type -> FrameType::Data,
+ security_enabled -> true,
+ frame_pending -> false,
+ ack_request -> true,
+ pan_id_compression -> true,
+ dst_addressing_mode -> AddressingMode::Extended,
+ frame_version -> FrameVersion::Ieee802154_2006,
+ src_addressing_mode -> AddressingMode::Extended,
+ dst_pan_id -> Some(Pan(0xabcd)),
+ dst_addr -> Some(Address::Extended([0x00,0x12,0x4b,0x00,0x06,0x15,0x9b,0xbf])),
+ src_pan_id -> None,
+ src_addr -> Some(Address::Extended([0x00,0x12,0x4b,0x00,0x14,0xb5,0xd9,0xc7])),
+ security_level -> 5,
+ key_identifier_mode -> 0,
+ frame_counter -> Some(305),
+ key_source -> None,
+ key_index -> None,
+ payload -> Some(&[0x3e,0xe8,0xfb,0x85,0xe4,0xcc,0xf4,0x48,0x90,0xfe,0x56,0x66,0xf7,0x1c,0x65,0x9e,0xf9,0x93,0xc8,0x34,0x2e][..]),
+ message_integrity_code -> Some(&[0x93, 0xC8, 0x34, 0x2E][..]),
+ mac_header -> &[
+ 0x69,0xdc, // frame control
+ 0x32, // sequence number
+ 0xcd,0xab, // destination PAN id
+ 0xbf,0x9b,0x15,0x06,0x00,0x4b,0x12,0x00, // extended destination address
+ 0xc7,0xd9,0xb5,0x14,0x00,0x4b,0x12,0x00, // extended source address
+ 0x05, // security control field
+ 0x31,0x01,0x00,0x00, // frame counter
+ ][..],
+ }
+}
diff --git a/src/wire/igmp.rs b/src/wire/igmp.rs
new file mode 100644
index 0000000..ac13ece
--- /dev/null
+++ b/src/wire/igmp.rs
@@ -0,0 +1,445 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::fmt;
+
+use super::{Error, Result};
+use crate::time::Duration;
+use crate::wire::ip::checksum;
+
+use crate::wire::Ipv4Address;
+
+enum_with_unknown! {
+ /// Internet Group Management Protocol v1/v2 message version/type.
+ pub enum Message(u8) {
+ /// Membership Query
+ MembershipQuery = 0x11,
+ /// Version 2 Membership Report
+ MembershipReportV2 = 0x16,
+ /// Leave Group
+ LeaveGroup = 0x17,
+ /// Version 1 Membership Report
+ MembershipReportV1 = 0x12
+ }
+}
+
+/// A read/write wrapper around an Internet Group Management Protocol v1/v2 packet buffer.
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const TYPE: usize = 0;
+ pub const MAX_RESP_CODE: usize = 1;
+ pub const CHECKSUM: Field = 2..4;
+ pub const GROUP_ADDRESS: Field = 4..8;
+}
+
+impl fmt::Display for Message {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Message::MembershipQuery => write!(f, "membership query"),
+ Message::MembershipReportV2 => write!(f, "version 2 membership report"),
+ Message::LeaveGroup => write!(f, "leave group"),
+ Message::MembershipReportV1 => write!(f, "version 1 membership report"),
+ Message::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+/// Internet Group Management Protocol v1/v2 defined in [RFC 2236].
+///
+/// [RFC 2236]: https://tools.ietf.org/html/rfc2236
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with IGMPv2 packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::GROUP_ADDRESS.end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the message type field.
+ #[inline]
+ pub fn msg_type(&self) -> Message {
+ let data = self.buffer.as_ref();
+ Message::from(data[field::TYPE])
+ }
+
+ /// Return the maximum response time, using the encoding specified in
+ /// [RFC 3376]: 4.1.1. Max Resp Code.
+ ///
+ /// [RFC 3376]: https://tools.ietf.org/html/rfc3376
+ #[inline]
+ pub fn max_resp_code(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::MAX_RESP_CODE]
+ }
+
+ /// Return the checksum field.
+ #[inline]
+ pub fn checksum(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::CHECKSUM])
+ }
+
+ /// Return the source address field.
+ #[inline]
+ pub fn group_addr(&self) -> Ipv4Address {
+ let data = self.buffer.as_ref();
+ Ipv4Address::from_bytes(&data[field::GROUP_ADDRESS])
+ }
+
+ /// Validate the header checksum.
+ ///
+ /// # Fuzzing
+ /// This function always returns `true` when fuzzing.
+ pub fn verify_checksum(&self) -> bool {
+ if cfg!(fuzzing) {
+ return true;
+ }
+
+ let data = self.buffer.as_ref();
+ checksum::data(data) == !0
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the message type field.
+ #[inline]
+ pub fn set_msg_type(&mut self, value: Message) {
+ let data = self.buffer.as_mut();
+ data[field::TYPE] = value.into()
+ }
+
+ /// Set the maximum response time, using the encoding specified in
+ /// [RFC 3376]: 4.1.1. Max Resp Code.
+ #[inline]
+ pub fn set_max_resp_code(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::MAX_RESP_CODE] = value;
+ }
+
+ /// Set the checksum field.
+ #[inline]
+ pub fn set_checksum(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::CHECKSUM], value)
+ }
+
+ /// Set the group address field
+ #[inline]
+ pub fn set_group_address(&mut self, addr: Ipv4Address) {
+ let data = self.buffer.as_mut();
+ data[field::GROUP_ADDRESS].copy_from_slice(addr.as_bytes());
+ }
+
+ /// Compute and fill in the header checksum.
+ pub fn fill_checksum(&mut self) {
+ self.set_checksum(0);
+ let checksum = {
+ let data = self.buffer.as_ref();
+ !checksum::data(data)
+ };
+ self.set_checksum(checksum)
+ }
+}
+
+/// A high-level representation of an Internet Group Management Protocol v1/v2 header.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Repr {
+ MembershipQuery {
+ max_resp_time: Duration,
+ group_addr: Ipv4Address,
+ version: IgmpVersion,
+ },
+ MembershipReport {
+ group_addr: Ipv4Address,
+ version: IgmpVersion,
+ },
+ LeaveGroup {
+ group_addr: Ipv4Address,
+ },
+}
+
+/// Type of IGMP membership report version
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum IgmpVersion {
+ /// IGMPv1
+ Version1,
+ /// IGMPv2
+ Version2,
+}
+
+impl Repr {
+ /// Parse an Internet Group Management Protocol v1/v2 packet and return
+ /// a high-level representation.
+ pub fn parse<T>(packet: &Packet<&T>) -> Result<Repr>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ // Check if the address is 0.0.0.0 or multicast
+ let addr = packet.group_addr();
+ if !addr.is_unspecified() && !addr.is_multicast() {
+ return Err(Error);
+ }
+
+ // construct a packet based on the Type field
+ match packet.msg_type() {
+ Message::MembershipQuery => {
+ let max_resp_time = max_resp_code_to_duration(packet.max_resp_code());
+ // See RFC 3376: 7.1. Query Version Distinctions
+ let version = if packet.max_resp_code() == 0 {
+ IgmpVersion::Version1
+ } else {
+ IgmpVersion::Version2
+ };
+ Ok(Repr::MembershipQuery {
+ max_resp_time,
+ group_addr: addr,
+ version,
+ })
+ }
+ Message::MembershipReportV2 => Ok(Repr::MembershipReport {
+ group_addr: packet.group_addr(),
+ version: IgmpVersion::Version2,
+ }),
+ Message::LeaveGroup => Ok(Repr::LeaveGroup {
+ group_addr: packet.group_addr(),
+ }),
+ Message::MembershipReportV1 => {
+ // for backwards compatibility with IGMPv1
+ Ok(Repr::MembershipReport {
+ group_addr: packet.group_addr(),
+ version: IgmpVersion::Version1,
+ })
+ }
+ _ => Err(Error),
+ }
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ // always 8 bytes
+ field::GROUP_ADDRESS.end
+ }
+
+ /// Emit a high-level representation into an Internet Group Management Protocol v2 packet.
+ pub fn emit<T>(&self, packet: &mut Packet<&mut T>)
+ where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ match *self {
+ Repr::MembershipQuery {
+ max_resp_time,
+ group_addr,
+ version,
+ } => {
+ packet.set_msg_type(Message::MembershipQuery);
+ match version {
+ IgmpVersion::Version1 => packet.set_max_resp_code(0),
+ IgmpVersion::Version2 => {
+ packet.set_max_resp_code(duration_to_max_resp_code(max_resp_time))
+ }
+ }
+ packet.set_group_address(group_addr);
+ }
+ Repr::MembershipReport {
+ group_addr,
+ version,
+ } => {
+ match version {
+ IgmpVersion::Version1 => packet.set_msg_type(Message::MembershipReportV1),
+ IgmpVersion::Version2 => packet.set_msg_type(Message::MembershipReportV2),
+ };
+ packet.set_max_resp_code(0);
+ packet.set_group_address(group_addr);
+ }
+ Repr::LeaveGroup { group_addr } => {
+ packet.set_msg_type(Message::LeaveGroup);
+ packet.set_group_address(group_addr);
+ }
+ }
+
+ packet.fill_checksum()
+ }
+}
+
+fn max_resp_code_to_duration(value: u8) -> Duration {
+ let value: u64 = value.into();
+ let decisecs = if value < 128 {
+ value
+ } else {
+ let mant = value & 0xF;
+ let exp = (value >> 4) & 0x7;
+ (mant | 0x10) << (exp + 3)
+ };
+ Duration::from_millis(decisecs * 100)
+}
+
+const fn duration_to_max_resp_code(duration: Duration) -> u8 {
+ let decisecs = duration.total_millis() / 100;
+ if decisecs < 128 {
+ decisecs as u8
+ } else if decisecs < 31744 {
+ let mut mant = decisecs >> 3;
+ let mut exp = 0u8;
+ while mant > 0x1F && exp < 0x8 {
+ mant >>= 1;
+ exp += 1;
+ }
+ 0x80 | (exp << 4) | (mant as u8 & 0xF)
+ } else {
+ 0xFF
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => write!(f, "IGMP ({err})"),
+ }
+ }
+}
+
+impl fmt::Display for Repr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Repr::MembershipQuery {
+ max_resp_time,
+ group_addr,
+ version,
+ } => write!(
+ f,
+ "IGMP membership query max_resp_time={max_resp_time} group_addr={group_addr} version={version:?}"
+ ),
+ Repr::MembershipReport {
+ group_addr,
+ version,
+ } => write!(
+ f,
+ "IGMP membership report group_addr={group_addr} version={version:?}"
+ ),
+ Repr::LeaveGroup { group_addr } => {
+ write!(f, "IGMP leave group group_addr={group_addr})")
+ }
+ }
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ match Packet::new_checked(buffer) {
+ Err(err) => writeln!(f, "{indent}({err})"),
+ Ok(packet) => writeln!(f, "{indent}{packet}"),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ static LEAVE_PACKET_BYTES: [u8; 8] = [0x17, 0x00, 0x02, 0x69, 0xe0, 0x00, 0x06, 0x96];
+ static REPORT_PACKET_BYTES: [u8; 8] = [0x16, 0x00, 0x08, 0xda, 0xe1, 0x00, 0x00, 0x25];
+
+ #[test]
+ fn test_leave_group_deconstruct() {
+ let packet = Packet::new_unchecked(&LEAVE_PACKET_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::LeaveGroup);
+ assert_eq!(packet.max_resp_code(), 0);
+ assert_eq!(packet.checksum(), 0x269);
+ assert_eq!(
+ packet.group_addr(),
+ Ipv4Address::from_bytes(&[224, 0, 6, 150])
+ );
+ assert!(packet.verify_checksum());
+ }
+
+ #[test]
+ fn test_report_deconstruct() {
+ let packet = Packet::new_unchecked(&REPORT_PACKET_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::MembershipReportV2);
+ assert_eq!(packet.max_resp_code(), 0);
+ assert_eq!(packet.checksum(), 0x08da);
+ assert_eq!(
+ packet.group_addr(),
+ Ipv4Address::from_bytes(&[225, 0, 0, 37])
+ );
+ assert!(packet.verify_checksum());
+ }
+
+ #[test]
+ fn test_leave_construct() {
+ let mut bytes = vec![0xa5; 8];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_msg_type(Message::LeaveGroup);
+ packet.set_max_resp_code(0);
+ packet.set_group_address(Ipv4Address::from_bytes(&[224, 0, 6, 150]));
+ packet.fill_checksum();
+ assert_eq!(&*packet.into_inner(), &LEAVE_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_report_construct() {
+ let mut bytes = vec![0xa5; 8];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_msg_type(Message::MembershipReportV2);
+ packet.set_max_resp_code(0);
+ packet.set_group_address(Ipv4Address::from_bytes(&[225, 0, 0, 37]));
+ packet.fill_checksum();
+ assert_eq!(&*packet.into_inner(), &REPORT_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn max_resp_time_to_duration_and_back() {
+ for i in 0..256usize {
+ let time1 = i as u8;
+ let duration = max_resp_code_to_duration(time1);
+ let time2 = duration_to_max_resp_code(duration);
+ assert!(time1 == time2);
+ }
+ }
+
+ #[test]
+ fn duration_to_max_resp_time_max() {
+ for duration in 31744..65536 {
+ let time = duration_to_max_resp_code(Duration::from_millis(duration * 100));
+ assert_eq!(time, 0xFF);
+ }
+ }
+}
diff --git a/src/wire/ip.rs b/src/wire/ip.rs
new file mode 100644
index 0000000..da80aba
--- /dev/null
+++ b/src/wire/ip.rs
@@ -0,0 +1,998 @@
+use core::convert::From;
+use core::fmt;
+
+use super::{Error, Result};
+use crate::phy::ChecksumCapabilities;
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::{Ipv4Address, Ipv4Cidr, Ipv4Packet, Ipv4Repr};
+#[cfg(feature = "proto-ipv6")]
+use crate::wire::{Ipv6Address, Ipv6Cidr, Ipv6Packet, Ipv6Repr};
+
+/// Internet protocol version.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Version {
+ #[cfg(feature = "proto-ipv4")]
+ Ipv4,
+ #[cfg(feature = "proto-ipv6")]
+ Ipv6,
+}
+
+impl Version {
+ /// Return the version of an IP packet stored in the provided buffer.
+ ///
+ /// This function never returns `Ok(IpVersion::Unspecified)`; instead,
+ /// unknown versions result in `Err(Error)`.
+ pub const fn of_packet(data: &[u8]) -> Result<Version> {
+ match data[0] >> 4 {
+ #[cfg(feature = "proto-ipv4")]
+ 4 => Ok(Version::Ipv4),
+ #[cfg(feature = "proto-ipv6")]
+ 6 => Ok(Version::Ipv6),
+ _ => Err(Error),
+ }
+ }
+}
+
+impl fmt::Display for Version {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Version::Ipv4 => write!(f, "IPv4"),
+ #[cfg(feature = "proto-ipv6")]
+ Version::Ipv6 => write!(f, "IPv6"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// IP datagram encapsulated protocol.
+ pub enum Protocol(u8) {
+ HopByHop = 0x00,
+ Icmp = 0x01,
+ Igmp = 0x02,
+ Tcp = 0x06,
+ Udp = 0x11,
+ Ipv6Route = 0x2b,
+ Ipv6Frag = 0x2c,
+ IpSecEsp = 0x32,
+ IpSecAh = 0x33,
+ Icmpv6 = 0x3a,
+ Ipv6NoNxt = 0x3b,
+ Ipv6Opts = 0x3c
+ }
+}
+
+impl fmt::Display for Protocol {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Protocol::HopByHop => write!(f, "Hop-by-Hop"),
+ Protocol::Icmp => write!(f, "ICMP"),
+ Protocol::Igmp => write!(f, "IGMP"),
+ Protocol::Tcp => write!(f, "TCP"),
+ Protocol::Udp => write!(f, "UDP"),
+ Protocol::Ipv6Route => write!(f, "IPv6-Route"),
+ Protocol::Ipv6Frag => write!(f, "IPv6-Frag"),
+ Protocol::IpSecEsp => write!(f, "IPsec-ESP"),
+ Protocol::IpSecAh => write!(f, "IPsec-AH"),
+ Protocol::Icmpv6 => write!(f, "ICMPv6"),
+ Protocol::Ipv6NoNxt => write!(f, "IPv6-NoNxt"),
+ Protocol::Ipv6Opts => write!(f, "IPv6-Opts"),
+ Protocol::Unknown(id) => write!(f, "0x{id:02x}"),
+ }
+ }
+}
+
+/// An internetworking address.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub enum Address {
+ /// An IPv4 address.
+ #[cfg(feature = "proto-ipv4")]
+ Ipv4(Ipv4Address),
+ /// An IPv6 address.
+ #[cfg(feature = "proto-ipv6")]
+ Ipv6(Ipv6Address),
+}
+
+impl Address {
+ /// Create an address wrapping an IPv4 address with the given octets.
+ #[cfg(feature = "proto-ipv4")]
+ pub const fn v4(a0: u8, a1: u8, a2: u8, a3: u8) -> Address {
+ Address::Ipv4(Ipv4Address::new(a0, a1, a2, a3))
+ }
+
+ /// Create an address wrapping an IPv6 address with the given octets.
+ #[cfg(feature = "proto-ipv6")]
+ #[allow(clippy::too_many_arguments)]
+ pub fn v6(a0: u16, a1: u16, a2: u16, a3: u16, a4: u16, a5: u16, a6: u16, a7: u16) -> Address {
+ Address::Ipv6(Ipv6Address::new(a0, a1, a2, a3, a4, a5, a6, a7))
+ }
+
+ /// Return the protocol version.
+ pub const fn version(&self) -> Version {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(_) => Version::Ipv4,
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(_) => Version::Ipv6,
+ }
+ }
+
+ /// Return an address as a sequence of octets, in big-endian.
+ pub const fn as_bytes(&self) -> &[u8] {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(addr) => addr.as_bytes(),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(addr) => addr.as_bytes(),
+ }
+ }
+
+ /// Query whether the address is a valid unicast address.
+ pub fn is_unicast(&self) -> bool {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(addr) => addr.is_unicast(),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(addr) => addr.is_unicast(),
+ }
+ }
+
+ /// Query whether the address is a valid multicast address.
+ pub const fn is_multicast(&self) -> bool {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(addr) => addr.is_multicast(),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(addr) => addr.is_multicast(),
+ }
+ }
+
+ /// Query whether the address is the broadcast address.
+ pub fn is_broadcast(&self) -> bool {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(addr) => addr.is_broadcast(),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(_) => false,
+ }
+ }
+
+ /// Query whether the address falls into the "unspecified" range.
+ pub fn is_unspecified(&self) -> bool {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(addr) => addr.is_unspecified(),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(addr) => addr.is_unspecified(),
+ }
+ }
+
+ /// If `self` is a CIDR-compatible subnet mask, return `Some(prefix_len)`,
+ /// where `prefix_len` is the number of leading zeroes. Return `None` otherwise.
+ pub fn prefix_len(&self) -> Option<u8> {
+ let mut ones = true;
+ let mut prefix_len = 0;
+ for byte in self.as_bytes() {
+ let mut mask = 0x80;
+ for _ in 0..8 {
+ let one = *byte & mask != 0;
+ if ones {
+ // Expect 1s until first 0
+ if one {
+ prefix_len += 1;
+ } else {
+ ones = false;
+ }
+ } else if one {
+ // 1 where 0 was expected
+ return None;
+ }
+ mask >>= 1;
+ }
+ }
+ Some(prefix_len)
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]
+impl From<::std::net::IpAddr> for Address {
+ fn from(x: ::std::net::IpAddr) -> Address {
+ match x {
+ ::std::net::IpAddr::V4(ipv4) => Address::Ipv4(ipv4.into()),
+ ::std::net::IpAddr::V6(ipv6) => Address::Ipv6(ipv6.into()),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<Address> for ::std::net::IpAddr {
+ fn from(x: Address) -> ::std::net::IpAddr {
+ match x {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(ipv4) => ::std::net::IpAddr::V4(ipv4.into()),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(ipv6) => ::std::net::IpAddr::V6(ipv6.into()),
+ }
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv4"))]
+impl From<::std::net::Ipv4Addr> for Address {
+ fn from(ipv4: ::std::net::Ipv4Addr) -> Address {
+ Address::Ipv4(ipv4.into())
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv6"))]
+impl From<::std::net::Ipv6Addr> for Address {
+ fn from(ipv6: ::std::net::Ipv6Addr) -> Address {
+ Address::Ipv6(ipv6.into())
+ }
+}
+
+#[cfg(feature = "proto-ipv4")]
+impl From<Ipv4Address> for Address {
+ fn from(addr: Ipv4Address) -> Self {
+ Address::Ipv4(addr)
+ }
+}
+
+#[cfg(feature = "proto-ipv6")]
+impl From<Ipv6Address> for Address {
+ fn from(addr: Ipv6Address) -> Self {
+ Address::Ipv6(addr)
+ }
+}
+
+impl fmt::Display for Address {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(addr) => write!(f, "{addr}"),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(addr) => write!(f, "{addr}"),
+ }
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Address {
+ fn format(&self, f: defmt::Formatter) {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ &Address::Ipv4(addr) => defmt::write!(f, "{:?}", addr),
+ #[cfg(feature = "proto-ipv6")]
+ &Address::Ipv6(addr) => defmt::write!(f, "{:?}", addr),
+ }
+ }
+}
+
+/// A specification of a CIDR block, containing an address and a variable-length
+/// subnet masking prefix length.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub enum Cidr {
+ #[cfg(feature = "proto-ipv4")]
+ Ipv4(Ipv4Cidr),
+ #[cfg(feature = "proto-ipv6")]
+ Ipv6(Ipv6Cidr),
+}
+
+impl Cidr {
+ /// Create a CIDR block from the given address and prefix length.
+ ///
+ /// # Panics
+ /// This function panics if the given prefix length is invalid for the given address.
+ pub fn new(addr: Address, prefix_len: u8) -> Cidr {
+ match addr {
+ #[cfg(feature = "proto-ipv4")]
+ Address::Ipv4(addr) => Cidr::Ipv4(Ipv4Cidr::new(addr, prefix_len)),
+ #[cfg(feature = "proto-ipv6")]
+ Address::Ipv6(addr) => Cidr::Ipv6(Ipv6Cidr::new(addr, prefix_len)),
+ }
+ }
+
+ /// Return the IP address of this CIDR block.
+ pub const fn address(&self) -> Address {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Cidr::Ipv4(cidr) => Address::Ipv4(cidr.address()),
+ #[cfg(feature = "proto-ipv6")]
+ Cidr::Ipv6(cidr) => Address::Ipv6(cidr.address()),
+ }
+ }
+
+ /// Return the prefix length of this CIDR block.
+ pub const fn prefix_len(&self) -> u8 {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Cidr::Ipv4(cidr) => cidr.prefix_len(),
+ #[cfg(feature = "proto-ipv6")]
+ Cidr::Ipv6(cidr) => cidr.prefix_len(),
+ }
+ }
+
+ /// Query whether the subnetwork described by this CIDR block contains
+ /// the given address.
+ pub fn contains_addr(&self, addr: &Address) -> bool {
+ match (self, addr) {
+ #[cfg(feature = "proto-ipv4")]
+ (Cidr::Ipv4(cidr), Address::Ipv4(addr)) => cidr.contains_addr(addr),
+ #[cfg(feature = "proto-ipv6")]
+ (Cidr::Ipv6(cidr), Address::Ipv6(addr)) => cidr.contains_addr(addr),
+ #[allow(unreachable_patterns)]
+ _ => false,
+ }
+ }
+
+ /// Query whether the subnetwork described by this CIDR block contains
+ /// the subnetwork described by the given CIDR block.
+ pub fn contains_subnet(&self, subnet: &Cidr) -> bool {
+ match (self, subnet) {
+ #[cfg(feature = "proto-ipv4")]
+ (Cidr::Ipv4(cidr), Cidr::Ipv4(other)) => cidr.contains_subnet(other),
+ #[cfg(feature = "proto-ipv6")]
+ (Cidr::Ipv6(cidr), Cidr::Ipv6(other)) => cidr.contains_subnet(other),
+ #[allow(unreachable_patterns)]
+ _ => false,
+ }
+ }
+}
+
+#[cfg(feature = "proto-ipv4")]
+impl From<Ipv4Cidr> for Cidr {
+ fn from(addr: Ipv4Cidr) -> Self {
+ Cidr::Ipv4(addr)
+ }
+}
+
+#[cfg(feature = "proto-ipv6")]
+impl From<Ipv6Cidr> for Cidr {
+ fn from(addr: Ipv6Cidr) -> Self {
+ Cidr::Ipv6(addr)
+ }
+}
+
+impl fmt::Display for Cidr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Cidr::Ipv4(cidr) => write!(f, "{cidr}"),
+ #[cfg(feature = "proto-ipv6")]
+ Cidr::Ipv6(cidr) => write!(f, "{cidr}"),
+ }
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Cidr {
+ fn format(&self, f: defmt::Formatter) {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ &Cidr::Ipv4(cidr) => defmt::write!(f, "{:?}", cidr),
+ #[cfg(feature = "proto-ipv6")]
+ &Cidr::Ipv6(cidr) => defmt::write!(f, "{:?}", cidr),
+ }
+ }
+}
+
+/// An internet endpoint address.
+///
+/// `Endpoint` always fully specifies both the address and the port.
+///
+/// See also ['ListenEndpoint'], which allows not specifying the address
+/// in order to listen on a given port on any address.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub struct Endpoint {
+ pub addr: Address,
+ pub port: u16,
+}
+
+impl Endpoint {
+ /// Create an endpoint address from given address and port.
+ pub const fn new(addr: Address, port: u16) -> Endpoint {
+ Endpoint { addr: addr, port }
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]
+impl From<::std::net::SocketAddr> for Endpoint {
+ fn from(x: ::std::net::SocketAddr) -> Endpoint {
+ Endpoint {
+ addr: x.ip().into(),
+ port: x.port(),
+ }
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv4"))]
+impl From<::std::net::SocketAddrV4> for Endpoint {
+ fn from(x: ::std::net::SocketAddrV4) -> Endpoint {
+ Endpoint {
+ addr: (*x.ip()).into(),
+ port: x.port(),
+ }
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv6"))]
+impl From<::std::net::SocketAddrV6> for Endpoint {
+ fn from(x: ::std::net::SocketAddrV6) -> Endpoint {
+ Endpoint {
+ addr: (*x.ip()).into(),
+ port: x.port(),
+ }
+ }
+}
+
+impl fmt::Display for Endpoint {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}:{}", self.addr, self.port)
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Endpoint {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(f, "{:?}:{=u16}", self.addr, self.port);
+ }
+}
+
+impl<T: Into<Address>> From<(T, u16)> for Endpoint {
+ fn from((addr, port): (T, u16)) -> Endpoint {
+ Endpoint {
+ addr: addr.into(),
+ port,
+ }
+ }
+}
+
+/// An internet endpoint address for listening.
+///
+/// In contrast with [`Endpoint`], `ListenEndpoint` allows not specifying the address,
+/// in order to listen on a given port at all our addresses.
+///
+/// An endpoint can be constructed from a port, in which case the address is unspecified.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+pub struct ListenEndpoint {
+ pub addr: Option<Address>,
+ pub port: u16,
+}
+
+impl ListenEndpoint {
+ /// Query whether the endpoint has a specified address and port.
+ pub const fn is_specified(&self) -> bool {
+ self.addr.is_some() && self.port != 0
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv4", feature = "proto-ipv6"))]
+impl From<::std::net::SocketAddr> for ListenEndpoint {
+ fn from(x: ::std::net::SocketAddr) -> ListenEndpoint {
+ ListenEndpoint {
+ addr: Some(x.ip().into()),
+ port: x.port(),
+ }
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv4"))]
+impl From<::std::net::SocketAddrV4> for ListenEndpoint {
+ fn from(x: ::std::net::SocketAddrV4) -> ListenEndpoint {
+ ListenEndpoint {
+ addr: Some((*x.ip()).into()),
+ port: x.port(),
+ }
+ }
+}
+
+#[cfg(all(feature = "std", feature = "proto-ipv6"))]
+impl From<::std::net::SocketAddrV6> for ListenEndpoint {
+ fn from(x: ::std::net::SocketAddrV6) -> ListenEndpoint {
+ ListenEndpoint {
+ addr: Some((*x.ip()).into()),
+ port: x.port(),
+ }
+ }
+}
+
+impl fmt::Display for ListenEndpoint {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ if let Some(addr) = self.addr {
+ write!(f, "{}:{}", addr, self.port)
+ } else {
+ write!(f, "*:{}", self.port)
+ }
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for ListenEndpoint {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(f, "{:?}:{=u16}", self.addr, self.port);
+ }
+}
+
+impl From<u16> for ListenEndpoint {
+ fn from(port: u16) -> ListenEndpoint {
+ ListenEndpoint { addr: None, port }
+ }
+}
+
+impl From<Endpoint> for ListenEndpoint {
+ fn from(endpoint: Endpoint) -> ListenEndpoint {
+ ListenEndpoint {
+ addr: Some(endpoint.addr),
+ port: endpoint.port,
+ }
+ }
+}
+
+impl<T: Into<Address>> From<(T, u16)> for ListenEndpoint {
+ fn from((addr, port): (T, u16)) -> ListenEndpoint {
+ ListenEndpoint {
+ addr: Some(addr.into()),
+ port,
+ }
+ }
+}
+
+/// An IP packet representation.
+///
+/// This enum abstracts the various versions of IP packets. It either contains an IPv4
+/// or IPv6 concrete high-level representation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Repr {
+ #[cfg(feature = "proto-ipv4")]
+ Ipv4(Ipv4Repr),
+ #[cfg(feature = "proto-ipv6")]
+ Ipv6(Ipv6Repr),
+}
+
+#[cfg(feature = "proto-ipv4")]
+impl From<Ipv4Repr> for Repr {
+ fn from(repr: Ipv4Repr) -> Repr {
+ Repr::Ipv4(repr)
+ }
+}
+
+#[cfg(feature = "proto-ipv6")]
+impl From<Ipv6Repr> for Repr {
+ fn from(repr: Ipv6Repr) -> Repr {
+ Repr::Ipv6(repr)
+ }
+}
+
+impl Repr {
+ /// Create a new IpRepr, choosing the right IP version for the src/dst addrs.
+ ///
+ /// # Panics
+ ///
+ /// Panics if `src_addr` and `dst_addr` are different IP version.
+ pub fn new(
+ src_addr: Address,
+ dst_addr: Address,
+ next_header: Protocol,
+ payload_len: usize,
+ hop_limit: u8,
+ ) -> Self {
+ match (src_addr, dst_addr) {
+ #[cfg(feature = "proto-ipv4")]
+ (Address::Ipv4(src_addr), Address::Ipv4(dst_addr)) => Self::Ipv4(Ipv4Repr {
+ src_addr,
+ dst_addr,
+ next_header,
+ payload_len,
+ hop_limit,
+ }),
+ #[cfg(feature = "proto-ipv6")]
+ (Address::Ipv6(src_addr), Address::Ipv6(dst_addr)) => Self::Ipv6(Ipv6Repr {
+ src_addr,
+ dst_addr,
+ next_header,
+ payload_len,
+ hop_limit,
+ }),
+ #[allow(unreachable_patterns)]
+ _ => panic!("IP version mismatch: src={src_addr:?} dst={dst_addr:?}"),
+ }
+ }
+
+ /// Return the protocol version.
+ pub const fn version(&self) -> Version {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(_) => Version::Ipv4,
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(_) => Version::Ipv6,
+ }
+ }
+
+ /// Return the source address.
+ pub const fn src_addr(&self) -> Address {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(repr) => Address::Ipv4(repr.src_addr),
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(repr) => Address::Ipv6(repr.src_addr),
+ }
+ }
+
+ /// Return the destination address.
+ pub const fn dst_addr(&self) -> Address {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(repr) => Address::Ipv4(repr.dst_addr),
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(repr) => Address::Ipv6(repr.dst_addr),
+ }
+ }
+
+ /// Return the next header (protocol).
+ pub const fn next_header(&self) -> Protocol {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(repr) => repr.next_header,
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(repr) => repr.next_header,
+ }
+ }
+
+ /// Return the payload length.
+ pub const fn payload_len(&self) -> usize {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(repr) => repr.payload_len,
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(repr) => repr.payload_len,
+ }
+ }
+
+ /// Set the payload length.
+ pub fn set_payload_len(&mut self, length: usize) {
+ match self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(Ipv4Repr { payload_len, .. }) => *payload_len = length,
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(Ipv6Repr { payload_len, .. }) => *payload_len = length,
+ }
+ }
+
+ /// Return the TTL value.
+ pub const fn hop_limit(&self) -> u8 {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(Ipv4Repr { hop_limit, .. }) => hop_limit,
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(Ipv6Repr { hop_limit, .. }) => hop_limit,
+ }
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub const fn header_len(&self) -> usize {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(repr) => repr.buffer_len(),
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(repr) => repr.buffer_len(),
+ }
+ }
+
+ /// Emit this high-level representation into a buffer.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(
+ &self,
+ buffer: T,
+ _checksum_caps: &ChecksumCapabilities,
+ ) {
+ match *self {
+ #[cfg(feature = "proto-ipv4")]
+ Repr::Ipv4(repr) => repr.emit(&mut Ipv4Packet::new_unchecked(buffer), _checksum_caps),
+ #[cfg(feature = "proto-ipv6")]
+ Repr::Ipv6(repr) => repr.emit(&mut Ipv6Packet::new_unchecked(buffer)),
+ }
+ }
+
+ /// Return the total length of a packet that will be emitted from this
+ /// high-level representation.
+ ///
+ /// This is the same as `repr.buffer_len() + repr.payload_len()`.
+ pub const fn buffer_len(&self) -> usize {
+ self.header_len() + self.payload_len()
+ }
+}
+
+pub mod checksum {
+ use byteorder::{ByteOrder, NetworkEndian};
+
+ use super::*;
+
+ const fn propagate_carries(word: u32) -> u16 {
+ let sum = (word >> 16) + (word & 0xffff);
+ ((sum >> 16) as u16) + (sum as u16)
+ }
+
+ /// Compute an RFC 1071 compliant checksum (without the final complement).
+ pub fn data(mut data: &[u8]) -> u16 {
+ let mut accum = 0;
+
+ // For each 32-byte chunk...
+ const CHUNK_SIZE: usize = 32;
+ while data.len() >= CHUNK_SIZE {
+ let mut d = &data[..CHUNK_SIZE];
+ // ... take by 2 bytes and sum them.
+ while d.len() >= 2 {
+ accum += NetworkEndian::read_u16(d) as u32;
+ d = &d[2..];
+ }
+
+ data = &data[CHUNK_SIZE..];
+ }
+
+ // Sum the rest that does not fit the last 32-byte chunk,
+ // taking by 2 bytes.
+ while data.len() >= 2 {
+ accum += NetworkEndian::read_u16(data) as u32;
+ data = &data[2..];
+ }
+
+ // Add the last remaining odd byte, if any.
+ if let Some(&value) = data.first() {
+ accum += (value as u32) << 8;
+ }
+
+ propagate_carries(accum)
+ }
+
+ /// Combine several RFC 1071 compliant checksums.
+ pub fn combine(checksums: &[u16]) -> u16 {
+ let mut accum: u32 = 0;
+ for &word in checksums {
+ accum += word as u32;
+ }
+ propagate_carries(accum)
+ }
+
+ /// Compute an IP pseudo header checksum.
+ pub fn pseudo_header(
+ src_addr: &Address,
+ dst_addr: &Address,
+ next_header: Protocol,
+ length: u32,
+ ) -> u16 {
+ match (src_addr, dst_addr) {
+ #[cfg(feature = "proto-ipv4")]
+ (&Address::Ipv4(src_addr), &Address::Ipv4(dst_addr)) => {
+ let mut proto_len = [0u8; 4];
+ proto_len[1] = next_header.into();
+ NetworkEndian::write_u16(&mut proto_len[2..4], length as u16);
+
+ combine(&[
+ data(src_addr.as_bytes()),
+ data(dst_addr.as_bytes()),
+ data(&proto_len[..]),
+ ])
+ }
+
+ #[cfg(feature = "proto-ipv6")]
+ (&Address::Ipv6(src_addr), &Address::Ipv6(dst_addr)) => {
+ let mut proto_len = [0u8; 8];
+ proto_len[7] = next_header.into();
+ NetworkEndian::write_u32(&mut proto_len[0..4], length);
+ combine(&[
+ data(src_addr.as_bytes()),
+ data(dst_addr.as_bytes()),
+ data(&proto_len[..]),
+ ])
+ }
+
+ #[allow(unreachable_patterns)]
+ _ => panic!("Unexpected pseudo header addresses: {src_addr}, {dst_addr}"),
+ }
+ }
+
+ // We use this in pretty printer implementations.
+ pub(crate) fn format_checksum(f: &mut fmt::Formatter, correct: bool) -> fmt::Result {
+ if !correct {
+ write!(f, " (checksum incorrect)")
+ } else {
+ Ok(())
+ }
+ }
+}
+
+use crate::wire::pretty_print::PrettyIndent;
+
+pub fn pretty_print_ip_payload<T: Into<Repr>>(
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ip_repr: T,
+ payload: &[u8],
+) -> fmt::Result {
+ #[cfg(feature = "proto-ipv4")]
+ use super::pretty_print::PrettyPrint;
+ use crate::wire::ip::checksum::format_checksum;
+ #[cfg(feature = "proto-ipv4")]
+ use crate::wire::Icmpv4Packet;
+ use crate::wire::{TcpPacket, TcpRepr, UdpPacket, UdpRepr};
+
+ let checksum_caps = ChecksumCapabilities::ignored();
+ let repr = ip_repr.into();
+ match repr.next_header() {
+ #[cfg(feature = "proto-ipv4")]
+ Protocol::Icmp => {
+ indent.increase(f)?;
+ Icmpv4Packet::<&[u8]>::pretty_print(&payload, f, indent)
+ }
+ Protocol::Udp => {
+ indent.increase(f)?;
+ match UdpPacket::<&[u8]>::new_checked(payload) {
+ Err(err) => write!(f, "{indent}({err})"),
+ Ok(udp_packet) => {
+ match UdpRepr::parse(
+ &udp_packet,
+ &repr.src_addr(),
+ &repr.dst_addr(),
+ &checksum_caps,
+ ) {
+ Err(err) => write!(f, "{indent}{udp_packet} ({err})"),
+ Ok(udp_repr) => {
+ write!(
+ f,
+ "{}{} len={}",
+ indent,
+ udp_repr,
+ udp_packet.payload().len()
+ )?;
+ let valid =
+ udp_packet.verify_checksum(&repr.src_addr(), &repr.dst_addr());
+ format_checksum(f, valid)
+ }
+ }
+ }
+ }
+ }
+ Protocol::Tcp => {
+ indent.increase(f)?;
+ match TcpPacket::<&[u8]>::new_checked(payload) {
+ Err(err) => write!(f, "{indent}({err})"),
+ Ok(tcp_packet) => {
+ match TcpRepr::parse(
+ &tcp_packet,
+ &repr.src_addr(),
+ &repr.dst_addr(),
+ &checksum_caps,
+ ) {
+ Err(err) => write!(f, "{indent}{tcp_packet} ({err})"),
+ Ok(tcp_repr) => {
+ write!(f, "{indent}{tcp_repr}")?;
+ let valid =
+ tcp_packet.verify_checksum(&repr.src_addr(), &repr.dst_addr());
+ format_checksum(f, valid)
+ }
+ }
+ }
+ }
+ }
+ _ => Ok(()),
+ }
+}
+
+#[cfg(test)]
+pub(crate) mod test {
+ #![allow(unused)]
+
+ #[cfg(feature = "proto-ipv6")]
+ pub(crate) const MOCK_IP_ADDR_1: IpAddress = IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+ ]));
+ #[cfg(feature = "proto-ipv6")]
+ pub(crate) const MOCK_IP_ADDR_2: IpAddress = IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
+ ]));
+ #[cfg(feature = "proto-ipv6")]
+ pub(crate) const MOCK_IP_ADDR_3: IpAddress = IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
+ ]));
+ #[cfg(feature = "proto-ipv6")]
+ pub(crate) const MOCK_IP_ADDR_4: IpAddress = IpAddress::Ipv6(Ipv6Address([
+ 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4,
+ ]));
+ #[cfg(feature = "proto-ipv6")]
+ pub(crate) const MOCK_UNSPECIFIED: IpAddress = IpAddress::Ipv6(Ipv6Address::UNSPECIFIED);
+
+ #[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
+ pub(crate) const MOCK_IP_ADDR_1: IpAddress = IpAddress::Ipv4(Ipv4Address([192, 168, 1, 1]));
+ #[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
+ pub(crate) const MOCK_IP_ADDR_2: IpAddress = IpAddress::Ipv4(Ipv4Address([192, 168, 1, 2]));
+ #[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
+ pub(crate) const MOCK_IP_ADDR_3: IpAddress = IpAddress::Ipv4(Ipv4Address([192, 168, 1, 3]));
+ #[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
+ pub(crate) const MOCK_IP_ADDR_4: IpAddress = IpAddress::Ipv4(Ipv4Address([192, 168, 1, 4]));
+ #[cfg(all(feature = "proto-ipv4", not(feature = "proto-ipv6")))]
+ pub(crate) const MOCK_UNSPECIFIED: IpAddress = IpAddress::Ipv4(Ipv4Address::UNSPECIFIED);
+
+ use super::*;
+ use crate::wire::{IpAddress, IpCidr, IpProtocol};
+ #[cfg(feature = "proto-ipv4")]
+ use crate::wire::{Ipv4Address, Ipv4Repr};
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn to_prefix_len_ipv4() {
+ fn test_eq<A: Into<Address>>(prefix_len: u8, mask: A) {
+ assert_eq!(Some(prefix_len), mask.into().prefix_len());
+ }
+
+ test_eq(0, Ipv4Address::new(0, 0, 0, 0));
+ test_eq(1, Ipv4Address::new(128, 0, 0, 0));
+ test_eq(2, Ipv4Address::new(192, 0, 0, 0));
+ test_eq(3, Ipv4Address::new(224, 0, 0, 0));
+ test_eq(4, Ipv4Address::new(240, 0, 0, 0));
+ test_eq(5, Ipv4Address::new(248, 0, 0, 0));
+ test_eq(6, Ipv4Address::new(252, 0, 0, 0));
+ test_eq(7, Ipv4Address::new(254, 0, 0, 0));
+ test_eq(8, Ipv4Address::new(255, 0, 0, 0));
+ test_eq(9, Ipv4Address::new(255, 128, 0, 0));
+ test_eq(10, Ipv4Address::new(255, 192, 0, 0));
+ test_eq(11, Ipv4Address::new(255, 224, 0, 0));
+ test_eq(12, Ipv4Address::new(255, 240, 0, 0));
+ test_eq(13, Ipv4Address::new(255, 248, 0, 0));
+ test_eq(14, Ipv4Address::new(255, 252, 0, 0));
+ test_eq(15, Ipv4Address::new(255, 254, 0, 0));
+ test_eq(16, Ipv4Address::new(255, 255, 0, 0));
+ test_eq(17, Ipv4Address::new(255, 255, 128, 0));
+ test_eq(18, Ipv4Address::new(255, 255, 192, 0));
+ test_eq(19, Ipv4Address::new(255, 255, 224, 0));
+ test_eq(20, Ipv4Address::new(255, 255, 240, 0));
+ test_eq(21, Ipv4Address::new(255, 255, 248, 0));
+ test_eq(22, Ipv4Address::new(255, 255, 252, 0));
+ test_eq(23, Ipv4Address::new(255, 255, 254, 0));
+ test_eq(24, Ipv4Address::new(255, 255, 255, 0));
+ test_eq(25, Ipv4Address::new(255, 255, 255, 128));
+ test_eq(26, Ipv4Address::new(255, 255, 255, 192));
+ test_eq(27, Ipv4Address::new(255, 255, 255, 224));
+ test_eq(28, Ipv4Address::new(255, 255, 255, 240));
+ test_eq(29, Ipv4Address::new(255, 255, 255, 248));
+ test_eq(30, Ipv4Address::new(255, 255, 255, 252));
+ test_eq(31, Ipv4Address::new(255, 255, 255, 254));
+ test_eq(32, Ipv4Address::new(255, 255, 255, 255));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn to_prefix_len_ipv4_error() {
+ assert_eq!(
+ None,
+ IpAddress::from(Ipv4Address::new(255, 255, 255, 1)).prefix_len()
+ );
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv6")]
+ fn to_prefix_len_ipv6() {
+ fn test_eq<A: Into<Address>>(prefix_len: u8, mask: A) {
+ assert_eq!(Some(prefix_len), mask.into().prefix_len());
+ }
+
+ test_eq(0, Ipv6Address::new(0, 0, 0, 0, 0, 0, 0, 0));
+ test_eq(
+ 128,
+ Ipv6Address::new(
+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+ ),
+ );
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv6")]
+ fn to_prefix_len_ipv6_error() {
+ assert_eq!(
+ None,
+ IpAddress::from(Ipv6Address::new(
+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0, 1
+ ))
+ .prefix_len()
+ );
+ }
+}
diff --git a/src/wire/ipsec_ah.rs b/src/wire/ipsec_ah.rs
new file mode 100644
index 0000000..1c3f00b
--- /dev/null
+++ b/src/wire/ipsec_ah.rs
@@ -0,0 +1,286 @@
+use byteorder::{ByteOrder, NetworkEndian};
+
+use super::{Error, IpProtocol, Result};
+
+/// A read/write wrapper around an IPSec Authentication Header packet buffer.
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+// 0 1 2 3
+// 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
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Next Header | Payload Len | RESERVED |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Security Parameters Index (SPI) |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Sequence Number Field |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// + Integrity Check Value-ICV (variable) |
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::Field;
+
+ pub const NEXT_HEADER: usize = 0;
+ pub const PAYLOAD_LEN: usize = 1;
+ pub const RESERVED: Field = 2..4;
+ pub const SPI: Field = 4..8;
+ pub const SEQUENCE_NUMBER: Field = 8..12;
+
+ pub const fn ICV(payload_len: u8) -> Field {
+ // The `payload_len` is the length of this Authentication Header in 4-octet units, minus 2.
+ let header_len = (payload_len as usize + 2) * 4;
+
+ SEQUENCE_NUMBER.end..header_len
+ }
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with IPsec Authentication Header packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short or shorter than payload length.
+ ///
+ /// The result of this check is invalidated by calling [set_payload_len].
+ ///
+ /// [set_payload_len]: #method.set_payload_len
+ #[allow(clippy::if_same_then_else)]
+ pub fn check_len(&self) -> Result<()> {
+ let data = self.buffer.as_ref();
+ let len = data.len();
+ if len < field::SEQUENCE_NUMBER.end {
+ Err(Error)
+ } else if len < field::ICV(data[field::PAYLOAD_LEN]).end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return next header protocol type
+ /// The value is taken from the list of IP protocol numbers.
+ pub fn next_header(&self) -> IpProtocol {
+ let data = self.buffer.as_ref();
+ IpProtocol::from(data[field::NEXT_HEADER])
+ }
+
+ /// Return the length of this Authentication Header in 4-octet units, minus 2
+ pub fn payload_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::PAYLOAD_LEN]
+ }
+
+ /// Return the security parameters index
+ pub fn security_parameters_index(&self) -> u32 {
+ let field = &self.buffer.as_ref()[field::SPI];
+ NetworkEndian::read_u32(field)
+ }
+
+ /// Return sequence number
+ pub fn sequence_number(&self) -> u32 {
+ let field = &self.buffer.as_ref()[field::SEQUENCE_NUMBER];
+ NetworkEndian::read_u32(field)
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the integrity check value
+ #[inline]
+ pub fn integrity_check_value(&self) -> &'a [u8] {
+ let data = self.buffer.as_ref();
+ &data[field::ICV(data[field::PAYLOAD_LEN])]
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set next header protocol field
+ fn set_next_header(&mut self, value: IpProtocol) {
+ let data = self.buffer.as_mut();
+ data[field::NEXT_HEADER] = value.into()
+ }
+
+ /// Set payload length field
+ fn set_payload_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::PAYLOAD_LEN] = value
+ }
+
+ /// Clear reserved field
+ fn clear_reserved(&mut self) {
+ let data = self.buffer.as_mut();
+ data[field::RESERVED].fill(0)
+ }
+
+ /// Set security parameters index field
+ fn set_security_parameters_index(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::SPI], value)
+ }
+
+ /// Set sequence number
+ fn set_sequence_number(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::SEQUENCE_NUMBER], value)
+ }
+
+ /// Return a mutable pointer to the integrity check value.
+ #[inline]
+ pub fn integrity_check_value_mut(&mut self) -> &mut [u8] {
+ let data = self.buffer.as_mut();
+ let range = field::ICV(data[field::PAYLOAD_LEN]);
+ &mut data[range]
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr<'a> {
+ next_header: IpProtocol,
+ security_parameters_index: u32,
+ sequence_number: u32,
+ integrity_check_value: &'a [u8],
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an IPSec Authentication Header packet and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(packet: &Packet<&'a T>) -> Result<Repr<'a>> {
+ Ok(Repr {
+ next_header: packet.next_header(),
+ security_parameters_index: packet.security_parameters_index(),
+ sequence_number: packet.sequence_number(),
+ integrity_check_value: packet.integrity_check_value(),
+ })
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ self.integrity_check_value.len() + field::SEQUENCE_NUMBER.end
+ }
+
+ /// Emit a high-level representation into an IPSec Authentication Header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, packet: &mut Packet<&'a mut T>) {
+ packet.set_next_header(self.next_header);
+
+ let payload_len = ((field::SEQUENCE_NUMBER.end + self.integrity_check_value.len()) / 4) - 2;
+ packet.set_payload_len(payload_len as u8);
+
+ packet.clear_reserved();
+ packet.set_security_parameters_index(self.security_parameters_index);
+ packet.set_sequence_number(self.sequence_number);
+ packet
+ .integrity_check_value_mut()
+ .copy_from_slice(self.integrity_check_value);
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ static PACKET_BYTES1: [u8; 24] = [
+ 0x32, 0x04, 0x00, 0x00, 0x81, 0x79, 0xb7, 0x05, 0x00, 0x00, 0x00, 0x01, 0x27, 0xcf, 0xc0,
+ 0xa5, 0xe4, 0x3d, 0x69, 0xb3, 0x72, 0x8e, 0xc5, 0xb0,
+ ];
+
+ static PACKET_BYTES2: [u8; 24] = [
+ 0x32, 0x04, 0x00, 0x00, 0xba, 0x8b, 0xd0, 0x60, 0x00, 0x00, 0x00, 0x01, 0xaf, 0xd2, 0xe7,
+ 0xa1, 0x73, 0xd3, 0x29, 0x0b, 0xfe, 0x6b, 0x63, 0x73,
+ ];
+
+ #[test]
+ fn test_deconstruct() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES1[..]);
+ assert_eq!(packet.next_header(), IpProtocol::IpSecEsp);
+ assert_eq!(packet.payload_len(), 4);
+ assert_eq!(packet.security_parameters_index(), 0x8179b705);
+ assert_eq!(packet.sequence_number(), 1);
+ assert_eq!(
+ packet.integrity_check_value(),
+ &[0x27, 0xcf, 0xc0, 0xa5, 0xe4, 0x3d, 0x69, 0xb3, 0x72, 0x8e, 0xc5, 0xb0]
+ );
+ }
+
+ #[test]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; 24];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_next_header(IpProtocol::IpSecEsp);
+ packet.set_payload_len(4);
+ packet.clear_reserved();
+ packet.set_security_parameters_index(0xba8bd060);
+ packet.set_sequence_number(1);
+ const ICV: [u8; 12] = [
+ 0xaf, 0xd2, 0xe7, 0xa1, 0x73, 0xd3, 0x29, 0x0b, 0xfe, 0x6b, 0x63, 0x73,
+ ];
+ packet.integrity_check_value_mut().copy_from_slice(&ICV);
+ assert_eq!(bytes, PACKET_BYTES2);
+ }
+ #[test]
+ fn test_check_len() {
+ assert!(matches!(Packet::new_checked(&PACKET_BYTES1[..10]), Err(_)));
+ assert!(matches!(Packet::new_checked(&PACKET_BYTES1[..22]), Err(_)));
+ assert!(matches!(Packet::new_checked(&PACKET_BYTES1[..]), Ok(_)));
+ }
+
+ fn packet_repr<'a>() -> Repr<'a> {
+ Repr {
+ next_header: IpProtocol::IpSecEsp,
+ security_parameters_index: 0xba8bd060,
+ sequence_number: 1,
+ integrity_check_value: &[
+ 0xaf, 0xd2, 0xe7, 0xa1, 0x73, 0xd3, 0x29, 0x0b, 0xfe, 0x6b, 0x63, 0x73,
+ ],
+ }
+ }
+
+ #[test]
+ fn test_parse() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES2[..]);
+ assert_eq!(Repr::parse(&packet).unwrap(), packet_repr());
+ }
+
+ #[test]
+ fn test_emit() {
+ let mut bytes = vec![0x17; 24];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet_repr().emit(&mut packet);
+ assert_eq!(bytes, PACKET_BYTES2);
+ }
+
+ #[test]
+ fn test_buffer_len() {
+ let header = Packet::new_unchecked(&PACKET_BYTES1[..]);
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(repr.buffer_len(), PACKET_BYTES1.len());
+ }
+}
diff --git a/src/wire/ipsec_esp.rs b/src/wire/ipsec_esp.rs
new file mode 100644
index 0000000..d0cd572
--- /dev/null
+++ b/src/wire/ipsec_esp.rs
@@ -0,0 +1,177 @@
+use super::{Error, Result};
+use byteorder::{ByteOrder, NetworkEndian};
+
+/// A read/write wrapper around an IPSec Encapsulating Security Payload (ESP) packet buffer.
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ use crate::wire::field::Field;
+
+ pub const SPI: Field = 0..4;
+ pub const SEQUENCE_NUMBER: Field = 4..8;
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with IPsec Encapsulating Security Payload packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let data = self.buffer.as_ref();
+ let len = data.len();
+ if len < field::SEQUENCE_NUMBER.end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the security parameters index
+ pub fn security_parameters_index(&self) -> u32 {
+ let field = &self.buffer.as_ref()[field::SPI];
+ NetworkEndian::read_u32(field)
+ }
+
+ /// Return sequence number
+ pub fn sequence_number(&self) -> u32 {
+ let field = &self.buffer.as_ref()[field::SEQUENCE_NUMBER];
+ NetworkEndian::read_u32(field)
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set security parameters index field
+ fn set_security_parameters_index(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::SPI], value)
+ }
+
+ /// Set sequence number
+ fn set_sequence_number(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::SEQUENCE_NUMBER], value)
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr {
+ security_parameters_index: u32,
+ sequence_number: u32,
+}
+
+impl Repr {
+ /// Parse an IPSec Encapsulating Security Payload packet and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]>>(packet: &Packet<T>) -> Result<Repr> {
+ Ok(Repr {
+ security_parameters_index: packet.security_parameters_index(),
+ sequence_number: packet.sequence_number(),
+ })
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ field::SEQUENCE_NUMBER.end
+ }
+
+ /// Emit a high-level representation into an IPSec Encapsulating Security Payload.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
+ packet.set_security_parameters_index(self.security_parameters_index);
+ packet.set_sequence_number(self.sequence_number);
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ static PACKET_BYTES: [u8; 136] = [
+ 0xfb, 0x51, 0x28, 0xa6, 0x00, 0x00, 0x00, 0x02, 0x5d, 0xbe, 0x2d, 0x56, 0xd4, 0x6a, 0x57,
+ 0xf5, 0xfc, 0x69, 0x8b, 0x3c, 0xa6, 0xb6, 0x88, 0x3a, 0x6c, 0xc1, 0x33, 0x92, 0xdb, 0x40,
+ 0xab, 0x11, 0x54, 0xb4, 0x0f, 0x22, 0x4d, 0x37, 0x3a, 0x06, 0x94, 0x1e, 0xd4, 0x25, 0xaf,
+ 0xf0, 0xb0, 0x11, 0x1f, 0x07, 0x96, 0x2a, 0xa7, 0x20, 0xb1, 0xf5, 0x52, 0xb2, 0x12, 0x46,
+ 0xd6, 0xa5, 0x13, 0x4e, 0x97, 0x75, 0x44, 0x19, 0xc7, 0x29, 0x35, 0xc5, 0xed, 0xa4, 0x0c,
+ 0xe7, 0x87, 0xec, 0x9c, 0xb1, 0x12, 0x42, 0x74, 0x7c, 0x12, 0x3c, 0x7f, 0x44, 0x9c, 0x6b,
+ 0x46, 0x27, 0x28, 0xd2, 0x0e, 0xb1, 0x28, 0xd3, 0xd8, 0xc2, 0xd1, 0xac, 0x25, 0xfe, 0xef,
+ 0xed, 0x13, 0xfd, 0x8f, 0x18, 0x9c, 0x2d, 0xb1, 0x0e, 0x50, 0xe9, 0xaa, 0x65, 0x93, 0x56,
+ 0x40, 0x43, 0xa3, 0x72, 0x54, 0xba, 0x1b, 0xb1, 0xaf, 0xca, 0x04, 0x15, 0xf9, 0xef, 0xb7,
+ 0x1d,
+ ];
+
+ #[test]
+ fn test_deconstruct() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ assert_eq!(packet.security_parameters_index(), 0xfb5128a6);
+ assert_eq!(packet.sequence_number(), 2);
+ }
+
+ #[test]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; 8];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_security_parameters_index(0xfb5128a6);
+ packet.set_sequence_number(2);
+ assert_eq!(&bytes, &PACKET_BYTES[..8]);
+ }
+ #[test]
+ fn test_check_len() {
+ assert!(matches!(Packet::new_checked(&PACKET_BYTES[..7]), Err(_)));
+ assert!(matches!(Packet::new_checked(&PACKET_BYTES[..]), Ok(_)));
+ }
+
+ fn packet_repr() -> Repr {
+ Repr {
+ security_parameters_index: 0xfb5128a6,
+ sequence_number: 2,
+ }
+ }
+
+ #[test]
+ fn test_parse() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ assert_eq!(Repr::parse(&packet).unwrap(), packet_repr());
+ }
+
+ #[test]
+ fn test_emit() {
+ let mut bytes = vec![0x17; 8];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet_repr().emit(&mut packet);
+ assert_eq!(&bytes, &PACKET_BYTES[..8]);
+ }
+
+ #[test]
+ fn test_buffer_len() {
+ let header = Packet::new_unchecked(&PACKET_BYTES[..]);
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(repr.buffer_len(), 8);
+ }
+}
diff --git a/src/wire/ipv4.rs b/src/wire/ipv4.rs
new file mode 100644
index 0000000..1027fc2
--- /dev/null
+++ b/src/wire/ipv4.rs
@@ -0,0 +1,1178 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::fmt;
+
+use super::{Error, Result};
+use crate::phy::ChecksumCapabilities;
+use crate::wire::ip::{checksum, pretty_print_ip_payload};
+
+pub use super::IpProtocol as Protocol;
+
+/// Minimum MTU required of all links supporting IPv4. See [RFC 791 § 3.1].
+///
+/// [RFC 791 § 3.1]: https://tools.ietf.org/html/rfc791#section-3.1
+// RFC 791 states the following:
+//
+// > Every internet module must be able to forward a datagram of 68
+// > octets without further fragmentation... Every internet destination
+// > must be able to receive a datagram of 576 octets either in one piece
+// > or in fragments to be reassembled.
+//
+// As a result, we can assume that every host we send packets to can
+// accept a packet of the following size.
+pub const MIN_MTU: usize = 576;
+
+/// Size of IPv4 adderess in octets.
+///
+/// [RFC 8200 § 2]: https://www.rfc-editor.org/rfc/rfc791#section-3.2
+pub const ADDR_SIZE: usize = 4;
+
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Key {
+ id: u16,
+ src_addr: Address,
+ dst_addr: Address,
+ protocol: Protocol,
+}
+
+/// A four-octet IPv4 address.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+pub struct Address(pub [u8; ADDR_SIZE]);
+
+impl Address {
+ /// An unspecified address.
+ pub const UNSPECIFIED: Address = Address([0x00; ADDR_SIZE]);
+
+ /// The broadcast address.
+ pub const BROADCAST: Address = Address([0xff; ADDR_SIZE]);
+
+ /// All multicast-capable nodes
+ pub const MULTICAST_ALL_SYSTEMS: Address = Address([224, 0, 0, 1]);
+
+ /// All multicast-capable routers
+ pub const MULTICAST_ALL_ROUTERS: Address = Address([224, 0, 0, 2]);
+
+ /// Construct an IPv4 address from parts.
+ pub const fn new(a0: u8, a1: u8, a2: u8, a3: u8) -> Address {
+ Address([a0, a1, a2, a3])
+ }
+
+ /// Construct an IPv4 address from a sequence of octets, in big-endian.
+ ///
+ /// # Panics
+ /// The function panics if `data` is not four octets long.
+ pub fn from_bytes(data: &[u8]) -> Address {
+ let mut bytes = [0; ADDR_SIZE];
+ bytes.copy_from_slice(data);
+ Address(bytes)
+ }
+
+ /// Return an IPv4 address as a sequence of octets, in big-endian.
+ pub const fn as_bytes(&self) -> &[u8] {
+ &self.0
+ }
+
+ /// Query whether the address is an unicast address.
+ pub fn is_unicast(&self) -> bool {
+ !(self.is_broadcast() || self.is_multicast() || self.is_unspecified())
+ }
+
+ /// Query whether the address is the broadcast address.
+ pub fn is_broadcast(&self) -> bool {
+ self.0[0..4] == [255; ADDR_SIZE]
+ }
+
+ /// Query whether the address is a multicast address.
+ pub const fn is_multicast(&self) -> bool {
+ self.0[0] & 0xf0 == 224
+ }
+
+ /// Query whether the address falls into the "unspecified" range.
+ pub const fn is_unspecified(&self) -> bool {
+ self.0[0] == 0
+ }
+
+ /// Query whether the address falls into the "link-local" range.
+ pub fn is_link_local(&self) -> bool {
+ self.0[0..2] == [169, 254]
+ }
+
+ /// Query whether the address falls into the "loopback" range.
+ pub const fn is_loopback(&self) -> bool {
+ self.0[0] == 127
+ }
+
+ /// Convert to an `IpAddress`.
+ ///
+ /// Same as `.into()`, but works in `const`.
+ pub const fn into_address(self) -> super::IpAddress {
+ super::IpAddress::Ipv4(self)
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<::std::net::Ipv4Addr> for Address {
+ fn from(x: ::std::net::Ipv4Addr) -> Address {
+ Address(x.octets())
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<Address> for ::std::net::Ipv4Addr {
+ fn from(Address(x): Address) -> ::std::net::Ipv4Addr {
+ x.into()
+ }
+}
+
+impl fmt::Display for Address {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let bytes = self.0;
+ write!(f, "{}.{}.{}.{}", bytes[0], bytes[1], bytes[2], bytes[3])
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Address {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(
+ f,
+ "{=u8}.{=u8}.{=u8}.{=u8}",
+ self.0[0],
+ self.0[1],
+ self.0[2],
+ self.0[3]
+ )
+ }
+}
+
+/// A specification of an IPv4 CIDR block, containing an address and a variable-length
+/// subnet masking prefix length.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+pub struct Cidr {
+ address: Address,
+ prefix_len: u8,
+}
+
+impl Cidr {
+ /// Create an IPv4 CIDR block from the given address and prefix length.
+ ///
+ /// # Panics
+ /// This function panics if the prefix length is larger than 32.
+ #[allow(clippy::no_effect)]
+ pub const fn new(address: Address, prefix_len: u8) -> Cidr {
+ // Replace with const panic (or assert) when stabilized
+ // see: https://github.com/rust-lang/rust/issues/51999
+ ["Prefix length should be <= 32"][(prefix_len > 32) as usize];
+ Cidr {
+ address,
+ prefix_len,
+ }
+ }
+
+ /// Create an IPv4 CIDR block from the given address and network mask.
+ pub fn from_netmask(addr: Address, netmask: Address) -> Result<Cidr> {
+ let netmask = NetworkEndian::read_u32(&netmask.0[..]);
+ if netmask.leading_zeros() == 0 && netmask.trailing_zeros() == netmask.count_zeros() {
+ Ok(Cidr {
+ address: addr,
+ prefix_len: netmask.count_ones() as u8,
+ })
+ } else {
+ Err(Error)
+ }
+ }
+
+ /// Return the address of this IPv4 CIDR block.
+ pub const fn address(&self) -> Address {
+ self.address
+ }
+
+ /// Return the prefix length of this IPv4 CIDR block.
+ pub const fn prefix_len(&self) -> u8 {
+ self.prefix_len
+ }
+
+ /// Return the network mask of this IPv4 CIDR.
+ pub const fn netmask(&self) -> Address {
+ if self.prefix_len == 0 {
+ return Address([0, 0, 0, 0]);
+ }
+
+ let number = 0xffffffffu32 << (32 - self.prefix_len);
+ let data = [
+ ((number >> 24) & 0xff) as u8,
+ ((number >> 16) & 0xff) as u8,
+ ((number >> 8) & 0xff) as u8,
+ ((number >> 0) & 0xff) as u8,
+ ];
+
+ Address(data)
+ }
+
+ /// Return the broadcast address of this IPv4 CIDR.
+ pub fn broadcast(&self) -> Option<Address> {
+ let network = self.network();
+
+ if network.prefix_len == 31 || network.prefix_len == 32 {
+ return None;
+ }
+
+ let network_number = NetworkEndian::read_u32(&network.address.0[..]);
+ let number = network_number | 0xffffffffu32 >> network.prefix_len;
+ let data = [
+ ((number >> 24) & 0xff) as u8,
+ ((number >> 16) & 0xff) as u8,
+ ((number >> 8) & 0xff) as u8,
+ ((number >> 0) & 0xff) as u8,
+ ];
+
+ Some(Address(data))
+ }
+
+ /// Return the network block of this IPv4 CIDR.
+ pub const fn network(&self) -> Cidr {
+ let mask = self.netmask().0;
+ let network = [
+ self.address.0[0] & mask[0],
+ self.address.0[1] & mask[1],
+ self.address.0[2] & mask[2],
+ self.address.0[3] & mask[3],
+ ];
+ Cidr {
+ address: Address(network),
+ prefix_len: self.prefix_len,
+ }
+ }
+
+ /// Query whether the subnetwork described by this IPv4 CIDR block contains
+ /// the given address.
+ pub fn contains_addr(&self, addr: &Address) -> bool {
+ // right shift by 32 is not legal
+ if self.prefix_len == 0 {
+ return true;
+ }
+
+ let shift = 32 - self.prefix_len;
+ let self_prefix = NetworkEndian::read_u32(self.address.as_bytes()) >> shift;
+ let addr_prefix = NetworkEndian::read_u32(addr.as_bytes()) >> shift;
+ self_prefix == addr_prefix
+ }
+
+ /// Query whether the subnetwork described by this IPv4 CIDR block contains
+ /// the subnetwork described by the given IPv4 CIDR block.
+ pub fn contains_subnet(&self, subnet: &Cidr) -> bool {
+ self.prefix_len <= subnet.prefix_len && self.contains_addr(&subnet.address)
+ }
+}
+
+impl fmt::Display for Cidr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}/{}", self.address, self.prefix_len)
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Cidr {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(f, "{}/{=u8}", self.address, self.prefix_len);
+ }
+}
+
+/// A read/write wrapper around an Internet Protocol version 4 packet buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const VER_IHL: usize = 0;
+ pub const DSCP_ECN: usize = 1;
+ pub const LENGTH: Field = 2..4;
+ pub const IDENT: Field = 4..6;
+ pub const FLG_OFF: Field = 6..8;
+ pub const TTL: usize = 8;
+ pub const PROTOCOL: usize = 9;
+ pub const CHECKSUM: Field = 10..12;
+ pub const SRC_ADDR: Field = 12..16;
+ pub const DST_ADDR: Field = 16..20;
+}
+
+pub const HEADER_LEN: usize = field::DST_ADDR.end;
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with IPv4 packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ /// Returns `Err(Error)` if the header length is greater
+ /// than total length.
+ ///
+ /// The result of this check is invalidated by calling [set_header_len]
+ /// and [set_total_len].
+ ///
+ /// [set_header_len]: #method.set_header_len
+ /// [set_total_len]: #method.set_total_len
+ #[allow(clippy::if_same_then_else)]
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::DST_ADDR.end {
+ Err(Error)
+ } else if len < self.header_len() as usize {
+ Err(Error)
+ } else if self.header_len() as u16 > self.total_len() {
+ Err(Error)
+ } else if len < self.total_len() as usize {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the version field.
+ #[inline]
+ pub fn version(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::VER_IHL] >> 4
+ }
+
+ /// Return the header length, in octets.
+ #[inline]
+ pub fn header_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ (data[field::VER_IHL] & 0x0f) * 4
+ }
+
+ /// Return the Differential Services Code Point field.
+ pub fn dscp(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::DSCP_ECN] >> 2
+ }
+
+ /// Return the Explicit Congestion Notification field.
+ pub fn ecn(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::DSCP_ECN] & 0x03
+ }
+
+ /// Return the total length field.
+ #[inline]
+ pub fn total_len(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::LENGTH])
+ }
+
+ /// Return the fragment identification field.
+ #[inline]
+ pub fn ident(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::IDENT])
+ }
+
+ /// Return the "don't fragment" flag.
+ #[inline]
+ pub fn dont_frag(&self) -> bool {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::FLG_OFF]) & 0x4000 != 0
+ }
+
+ /// Return the "more fragments" flag.
+ #[inline]
+ pub fn more_frags(&self) -> bool {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::FLG_OFF]) & 0x2000 != 0
+ }
+
+ /// Return the fragment offset, in octets.
+ #[inline]
+ pub fn frag_offset(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::FLG_OFF]) << 3
+ }
+
+ /// Return the time to live field.
+ #[inline]
+ pub fn hop_limit(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::TTL]
+ }
+
+ /// Return the next_header (protocol) field.
+ #[inline]
+ pub fn next_header(&self) -> Protocol {
+ let data = self.buffer.as_ref();
+ Protocol::from(data[field::PROTOCOL])
+ }
+
+ /// Return the header checksum field.
+ #[inline]
+ pub fn checksum(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::CHECKSUM])
+ }
+
+ /// Return the source address field.
+ #[inline]
+ pub fn src_addr(&self) -> Address {
+ let data = self.buffer.as_ref();
+ Address::from_bytes(&data[field::SRC_ADDR])
+ }
+
+ /// Return the destination address field.
+ #[inline]
+ pub fn dst_addr(&self) -> Address {
+ let data = self.buffer.as_ref();
+ Address::from_bytes(&data[field::DST_ADDR])
+ }
+
+ /// Validate the header checksum.
+ ///
+ /// # Fuzzing
+ /// This function always returns `true` when fuzzing.
+ pub fn verify_checksum(&self) -> bool {
+ if cfg!(fuzzing) {
+ return true;
+ }
+
+ let data = self.buffer.as_ref();
+ checksum::data(&data[..self.header_len() as usize]) == !0
+ }
+
+ /// Returns the key for identifying the packet.
+ pub fn get_key(&self) -> Key {
+ Key {
+ id: self.ident(),
+ src_addr: self.src_addr(),
+ dst_addr: self.dst_addr(),
+ protocol: self.next_header(),
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the payload.
+ #[inline]
+ pub fn payload(&self) -> &'a [u8] {
+ let range = self.header_len() as usize..self.total_len() as usize;
+ let data = self.buffer.as_ref();
+ &data[range]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the version field.
+ #[inline]
+ pub fn set_version(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::VER_IHL] = (data[field::VER_IHL] & !0xf0) | (value << 4);
+ }
+
+ /// Set the header length, in octets.
+ #[inline]
+ pub fn set_header_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::VER_IHL] = (data[field::VER_IHL] & !0x0f) | ((value / 4) & 0x0f);
+ }
+
+ /// Set the Differential Services Code Point field.
+ pub fn set_dscp(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::DSCP_ECN] = (data[field::DSCP_ECN] & !0xfc) | (value << 2)
+ }
+
+ /// Set the Explicit Congestion Notification field.
+ pub fn set_ecn(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::DSCP_ECN] = (data[field::DSCP_ECN] & !0x03) | (value & 0x03)
+ }
+
+ /// Set the total length field.
+ #[inline]
+ pub fn set_total_len(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::LENGTH], value)
+ }
+
+ /// Set the fragment identification field.
+ #[inline]
+ pub fn set_ident(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::IDENT], value)
+ }
+
+ /// Clear the entire flags field.
+ #[inline]
+ pub fn clear_flags(&mut self) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLG_OFF]);
+ let raw = raw & !0xe000;
+ NetworkEndian::write_u16(&mut data[field::FLG_OFF], raw);
+ }
+
+ /// Set the "don't fragment" flag.
+ #[inline]
+ pub fn set_dont_frag(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLG_OFF]);
+ let raw = if value { raw | 0x4000 } else { raw & !0x4000 };
+ NetworkEndian::write_u16(&mut data[field::FLG_OFF], raw);
+ }
+
+ /// Set the "more fragments" flag.
+ #[inline]
+ pub fn set_more_frags(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLG_OFF]);
+ let raw = if value { raw | 0x2000 } else { raw & !0x2000 };
+ NetworkEndian::write_u16(&mut data[field::FLG_OFF], raw);
+ }
+
+ /// Set the fragment offset, in octets.
+ #[inline]
+ pub fn set_frag_offset(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLG_OFF]);
+ let raw = (raw & 0xe000) | (value >> 3);
+ NetworkEndian::write_u16(&mut data[field::FLG_OFF], raw);
+ }
+
+ /// Set the time to live field.
+ #[inline]
+ pub fn set_hop_limit(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::TTL] = value
+ }
+
+ /// Set the next header (protocol) field.
+ #[inline]
+ pub fn set_next_header(&mut self, value: Protocol) {
+ let data = self.buffer.as_mut();
+ data[field::PROTOCOL] = value.into()
+ }
+
+ /// Set the header checksum field.
+ #[inline]
+ pub fn set_checksum(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::CHECKSUM], value)
+ }
+
+ /// Set the source address field.
+ #[inline]
+ pub fn set_src_addr(&mut self, value: Address) {
+ let data = self.buffer.as_mut();
+ data[field::SRC_ADDR].copy_from_slice(value.as_bytes())
+ }
+
+ /// Set the destination address field.
+ #[inline]
+ pub fn set_dst_addr(&mut self, value: Address) {
+ let data = self.buffer.as_mut();
+ data[field::DST_ADDR].copy_from_slice(value.as_bytes())
+ }
+
+ /// Compute and fill in the header checksum.
+ pub fn fill_checksum(&mut self) {
+ self.set_checksum(0);
+ let checksum = {
+ let data = self.buffer.as_ref();
+ !checksum::data(&data[..self.header_len() as usize])
+ };
+ self.set_checksum(checksum)
+ }
+
+ /// Return a mutable pointer to the payload.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let range = self.header_len() as usize..self.total_len() as usize;
+ let data = self.buffer.as_mut();
+ &mut data[range]
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+/// A high-level representation of an Internet Protocol version 4 packet header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr {
+ pub src_addr: Address,
+ pub dst_addr: Address,
+ pub next_header: Protocol,
+ pub payload_len: usize,
+ pub hop_limit: u8,
+}
+
+impl Repr {
+ /// Parse an Internet Protocol version 4 packet and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(
+ packet: &Packet<&T>,
+ checksum_caps: &ChecksumCapabilities,
+ ) -> Result<Repr> {
+ // Version 4 is expected.
+ if packet.version() != 4 {
+ return Err(Error);
+ }
+ // Valid checksum is expected.
+ if checksum_caps.ipv4.rx() && !packet.verify_checksum() {
+ return Err(Error);
+ }
+
+ #[cfg(not(feature = "proto-ipv4-fragmentation"))]
+ // We do not support fragmentation.
+ if packet.more_frags() || packet.frag_offset() != 0 {
+ return Err(Error);
+ }
+
+ let payload_len = packet.total_len() as usize - packet.header_len() as usize;
+
+ // All DSCP values are acceptable, since they are of no concern to receiving endpoint.
+ // All ECN values are acceptable, since ECN requires opt-in from both endpoints.
+ // All TTL values are acceptable, since we do not perform routing.
+ Ok(Repr {
+ src_addr: packet.src_addr(),
+ dst_addr: packet.dst_addr(),
+ next_header: packet.next_header(),
+ payload_len,
+ hop_limit: packet.hop_limit(),
+ })
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ // We never emit any options.
+ field::DST_ADDR.end
+ }
+
+ /// Emit a high-level representation into an Internet Protocol version 4 packet.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(
+ &self,
+ packet: &mut Packet<T>,
+ checksum_caps: &ChecksumCapabilities,
+ ) {
+ packet.set_version(4);
+ packet.set_header_len(field::DST_ADDR.end as u8);
+ packet.set_dscp(0);
+ packet.set_ecn(0);
+ let total_len = packet.header_len() as u16 + self.payload_len as u16;
+ packet.set_total_len(total_len);
+ packet.set_ident(0);
+ packet.clear_flags();
+ packet.set_more_frags(false);
+ packet.set_dont_frag(true);
+ packet.set_frag_offset(0);
+ packet.set_hop_limit(self.hop_limit);
+ packet.set_next_header(self.next_header);
+ packet.set_src_addr(self.src_addr);
+ packet.set_dst_addr(self.dst_addr);
+
+ if checksum_caps.ipv4.tx() {
+ packet.fill_checksum();
+ } else {
+ // make sure we get a consistently zeroed checksum,
+ // since implementations might rely on it
+ packet.set_checksum(0);
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self, &ChecksumCapabilities::ignored()) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => {
+ write!(f, "IPv4 ({err})")?;
+ write!(
+ f,
+ " src={} dst={} proto={} hop_limit={}",
+ self.src_addr(),
+ self.dst_addr(),
+ self.next_header(),
+ self.hop_limit()
+ )?;
+ if self.version() != 4 {
+ write!(f, " ver={}", self.version())?;
+ }
+ if self.header_len() != 20 {
+ write!(f, " hlen={}", self.header_len())?;
+ }
+ if self.dscp() != 0 {
+ write!(f, " dscp={}", self.dscp())?;
+ }
+ if self.ecn() != 0 {
+ write!(f, " ecn={}", self.ecn())?;
+ }
+ write!(f, " tlen={}", self.total_len())?;
+ if self.dont_frag() {
+ write!(f, " df")?;
+ }
+ if self.more_frags() {
+ write!(f, " mf")?;
+ }
+ if self.frag_offset() != 0 {
+ write!(f, " off={}", self.frag_offset())?;
+ }
+ if self.more_frags() || self.frag_offset() != 0 {
+ write!(f, " id={}", self.ident())?;
+ }
+ Ok(())
+ }
+ }
+ }
+}
+
+impl fmt::Display for Repr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(
+ f,
+ "IPv4 src={} dst={} proto={}",
+ self.src_addr, self.dst_addr, self.next_header
+ )
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ use crate::wire::ip::checksum::format_checksum;
+
+ let checksum_caps = ChecksumCapabilities::ignored();
+
+ let (ip_repr, payload) = match Packet::new_checked(buffer) {
+ Err(err) => return write!(f, "{indent}({err})"),
+ Ok(ip_packet) => match Repr::parse(&ip_packet, &checksum_caps) {
+ Err(_) => return Ok(()),
+ Ok(ip_repr) => {
+ if ip_packet.more_frags() || ip_packet.frag_offset() != 0 {
+ write!(
+ f,
+ "{}IPv4 Fragment more_frags={} offset={}",
+ indent,
+ ip_packet.more_frags(),
+ ip_packet.frag_offset()
+ )?;
+ return Ok(());
+ } else {
+ write!(f, "{indent}{ip_repr}")?;
+ format_checksum(f, ip_packet.verify_checksum())?;
+ (ip_repr, ip_packet.payload())
+ }
+ }
+ },
+ };
+
+ pretty_print_ip_payload(f, indent, ip_repr, payload)
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ static PACKET_BYTES: [u8; 30] = [
+ 0x45, 0x00, 0x00, 0x1e, 0x01, 0x02, 0x62, 0x03, 0x1a, 0x01, 0xd5, 0x6e, 0x11, 0x12, 0x13,
+ 0x14, 0x21, 0x22, 0x23, 0x24, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+ ];
+
+ static PAYLOAD_BYTES: [u8; 10] = [0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff];
+
+ #[test]
+ fn test_deconstruct() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ assert_eq!(packet.version(), 4);
+ assert_eq!(packet.header_len(), 20);
+ assert_eq!(packet.dscp(), 0);
+ assert_eq!(packet.ecn(), 0);
+ assert_eq!(packet.total_len(), 30);
+ assert_eq!(packet.ident(), 0x102);
+ assert!(packet.more_frags());
+ assert!(packet.dont_frag());
+ assert_eq!(packet.frag_offset(), 0x203 * 8);
+ assert_eq!(packet.hop_limit(), 0x1a);
+ assert_eq!(packet.next_header(), Protocol::Icmp);
+ assert_eq!(packet.checksum(), 0xd56e);
+ assert_eq!(packet.src_addr(), Address([0x11, 0x12, 0x13, 0x14]));
+ assert_eq!(packet.dst_addr(), Address([0x21, 0x22, 0x23, 0x24]));
+ assert!(packet.verify_checksum());
+ assert_eq!(packet.payload(), &PAYLOAD_BYTES[..]);
+ }
+
+ #[test]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; 30];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_version(4);
+ packet.set_header_len(20);
+ packet.clear_flags();
+ packet.set_dscp(0);
+ packet.set_ecn(0);
+ packet.set_total_len(30);
+ packet.set_ident(0x102);
+ packet.set_more_frags(true);
+ packet.set_dont_frag(true);
+ packet.set_frag_offset(0x203 * 8);
+ packet.set_hop_limit(0x1a);
+ packet.set_next_header(Protocol::Icmp);
+ packet.set_src_addr(Address([0x11, 0x12, 0x13, 0x14]));
+ packet.set_dst_addr(Address([0x21, 0x22, 0x23, 0x24]));
+ packet.fill_checksum();
+ packet.payload_mut().copy_from_slice(&PAYLOAD_BYTES[..]);
+ assert_eq!(&*packet.into_inner(), &PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_overlong() {
+ let mut bytes = vec![];
+ bytes.extend(&PACKET_BYTES[..]);
+ bytes.push(0);
+
+ assert_eq!(
+ Packet::new_unchecked(&bytes).payload().len(),
+ PAYLOAD_BYTES.len()
+ );
+ assert_eq!(
+ Packet::new_unchecked(&mut bytes).payload_mut().len(),
+ PAYLOAD_BYTES.len()
+ );
+ }
+
+ #[test]
+ fn test_total_len_overflow() {
+ let mut bytes = vec![];
+ bytes.extend(&PACKET_BYTES[..]);
+ Packet::new_unchecked(&mut bytes).set_total_len(128);
+
+ assert_eq!(Packet::new_checked(&bytes).unwrap_err(), Error);
+ }
+
+ static REPR_PACKET_BYTES: [u8; 24] = [
+ 0x45, 0x00, 0x00, 0x18, 0x00, 0x00, 0x40, 0x00, 0x40, 0x01, 0xd2, 0x79, 0x11, 0x12, 0x13,
+ 0x14, 0x21, 0x22, 0x23, 0x24, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ static REPR_PAYLOAD_BYTES: [u8; ADDR_SIZE] = [0xaa, 0x00, 0x00, 0xff];
+
+ const fn packet_repr() -> Repr {
+ Repr {
+ src_addr: Address([0x11, 0x12, 0x13, 0x14]),
+ dst_addr: Address([0x21, 0x22, 0x23, 0x24]),
+ next_header: Protocol::Icmp,
+ payload_len: 4,
+ hop_limit: 64,
+ }
+ }
+
+ #[test]
+ fn test_parse() {
+ let packet = Packet::new_unchecked(&REPR_PACKET_BYTES[..]);
+ let repr = Repr::parse(&packet, &ChecksumCapabilities::default()).unwrap();
+ assert_eq!(repr, packet_repr());
+ }
+
+ #[test]
+ fn test_parse_bad_version() {
+ let mut bytes = vec![0; 24];
+ bytes.copy_from_slice(&REPR_PACKET_BYTES[..]);
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_version(6);
+ packet.fill_checksum();
+ let packet = Packet::new_unchecked(&*packet.into_inner());
+ assert_eq!(
+ Repr::parse(&packet, &ChecksumCapabilities::default()),
+ Err(Error)
+ );
+ }
+
+ #[test]
+ fn test_parse_total_len_less_than_header_len() {
+ let mut bytes = vec![0; 40];
+ bytes[0] = 0x09;
+ assert_eq!(Packet::new_checked(&mut bytes), Err(Error));
+ }
+
+ #[test]
+ fn test_emit() {
+ let repr = packet_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len() + REPR_PAYLOAD_BYTES.len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet, &ChecksumCapabilities::default());
+ packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_BYTES);
+ assert_eq!(&*packet.into_inner(), &REPR_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_unspecified() {
+ assert!(Address::UNSPECIFIED.is_unspecified());
+ assert!(!Address::UNSPECIFIED.is_broadcast());
+ assert!(!Address::UNSPECIFIED.is_multicast());
+ assert!(!Address::UNSPECIFIED.is_link_local());
+ assert!(!Address::UNSPECIFIED.is_loopback());
+ }
+
+ #[test]
+ fn test_broadcast() {
+ assert!(!Address::BROADCAST.is_unspecified());
+ assert!(Address::BROADCAST.is_broadcast());
+ assert!(!Address::BROADCAST.is_multicast());
+ assert!(!Address::BROADCAST.is_link_local());
+ assert!(!Address::BROADCAST.is_loopback());
+ }
+
+ #[test]
+ fn test_cidr() {
+ let cidr = Cidr::new(Address::new(192, 168, 1, 10), 24);
+
+ let inside_subnet = [
+ [192, 168, 1, 0],
+ [192, 168, 1, 1],
+ [192, 168, 1, 2],
+ [192, 168, 1, 10],
+ [192, 168, 1, 127],
+ [192, 168, 1, 255],
+ ];
+
+ let outside_subnet = [
+ [192, 168, 0, 0],
+ [127, 0, 0, 1],
+ [192, 168, 2, 0],
+ [192, 168, 0, 255],
+ [0, 0, 0, 0],
+ [255, 255, 255, 255],
+ ];
+
+ let subnets = [
+ ([192, 168, 1, 0], 32),
+ ([192, 168, 1, 255], 24),
+ ([192, 168, 1, 10], 30),
+ ];
+
+ let not_subnets = [
+ ([192, 168, 1, 10], 23),
+ ([127, 0, 0, 1], 8),
+ ([192, 168, 1, 0], 0),
+ ([192, 168, 0, 255], 32),
+ ];
+
+ for addr in inside_subnet.iter().map(|a| Address::from_bytes(a)) {
+ assert!(cidr.contains_addr(&addr));
+ }
+
+ for addr in outside_subnet.iter().map(|a| Address::from_bytes(a)) {
+ assert!(!cidr.contains_addr(&addr));
+ }
+
+ for subnet in subnets
+ .iter()
+ .map(|&(a, p)| Cidr::new(Address::new(a[0], a[1], a[2], a[3]), p))
+ {
+ assert!(cidr.contains_subnet(&subnet));
+ }
+
+ for subnet in not_subnets
+ .iter()
+ .map(|&(a, p)| Cidr::new(Address::new(a[0], a[1], a[2], a[3]), p))
+ {
+ assert!(!cidr.contains_subnet(&subnet));
+ }
+
+ let cidr_without_prefix = Cidr::new(cidr.address(), 0);
+ assert!(cidr_without_prefix.contains_addr(&Address::new(127, 0, 0, 1)));
+ }
+
+ #[test]
+ fn test_cidr_from_netmask() {
+ assert!(Cidr::from_netmask(Address([0, 0, 0, 0]), Address([1, 0, 2, 0])).is_err());
+ assert!(Cidr::from_netmask(Address([0, 0, 0, 0]), Address([0, 0, 0, 0])).is_err());
+ assert_eq!(
+ Cidr::from_netmask(Address([0, 0, 0, 1]), Address([255, 255, 255, 0])).unwrap(),
+ Cidr::new(Address([0, 0, 0, 1]), 24)
+ );
+ assert_eq!(
+ Cidr::from_netmask(Address([192, 168, 0, 1]), Address([255, 255, 0, 0])).unwrap(),
+ Cidr::new(Address([192, 168, 0, 1]), 16)
+ );
+ assert_eq!(
+ Cidr::from_netmask(Address([172, 16, 0, 1]), Address([255, 240, 0, 0])).unwrap(),
+ Cidr::new(Address([172, 16, 0, 1]), 12)
+ );
+ assert_eq!(
+ Cidr::from_netmask(Address([255, 255, 255, 1]), Address([255, 255, 255, 0])).unwrap(),
+ Cidr::new(Address([255, 255, 255, 1]), 24)
+ );
+ assert_eq!(
+ Cidr::from_netmask(Address([255, 255, 255, 255]), Address([255, 255, 255, 255]))
+ .unwrap(),
+ Cidr::new(Address([255, 255, 255, 255]), 32)
+ );
+ }
+
+ #[test]
+ fn test_cidr_netmask() {
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 0]), 0).netmask(),
+ Address([0, 0, 0, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 1]), 24).netmask(),
+ Address([255, 255, 255, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 0]), 32).netmask(),
+ Address([255, 255, 255, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([127, 0, 0, 0]), 8).netmask(),
+ Address([255, 0, 0, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 0, 0]), 16).netmask(),
+ Address([255, 255, 0, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 1, 1]), 16).netmask(),
+ Address([255, 255, 0, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 1, 1]), 17).netmask(),
+ Address([255, 255, 128, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([172, 16, 0, 0]), 12).netmask(),
+ Address([255, 240, 0, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([255, 255, 255, 1]), 24).netmask(),
+ Address([255, 255, 255, 0])
+ );
+ assert_eq!(
+ Cidr::new(Address([255, 255, 255, 255]), 32).netmask(),
+ Address([255, 255, 255, 255])
+ );
+ }
+
+ #[test]
+ fn test_cidr_broadcast() {
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 0]), 0).broadcast().unwrap(),
+ Address([255, 255, 255, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 1]), 24).broadcast().unwrap(),
+ Address([0, 0, 0, 255])
+ );
+ assert_eq!(Cidr::new(Address([0, 0, 0, 0]), 32).broadcast(), None);
+ assert_eq!(
+ Cidr::new(Address([127, 0, 0, 0]), 8).broadcast().unwrap(),
+ Address([127, 255, 255, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 0, 0]), 16)
+ .broadcast()
+ .unwrap(),
+ Address([192, 168, 255, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 1, 1]), 16)
+ .broadcast()
+ .unwrap(),
+ Address([192, 168, 255, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 1, 1]), 17)
+ .broadcast()
+ .unwrap(),
+ Address([192, 168, 127, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([172, 16, 0, 1]), 12).broadcast().unwrap(),
+ Address([172, 31, 255, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([255, 255, 255, 1]), 24)
+ .broadcast()
+ .unwrap(),
+ Address([255, 255, 255, 255])
+ );
+ assert_eq!(
+ Cidr::new(Address([255, 255, 255, 254]), 31).broadcast(),
+ None
+ );
+ assert_eq!(
+ Cidr::new(Address([255, 255, 255, 255]), 32).broadcast(),
+ None
+ );
+ }
+
+ #[test]
+ fn test_cidr_network() {
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 0]), 0).network(),
+ Cidr::new(Address([0, 0, 0, 0]), 0)
+ );
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 1]), 24).network(),
+ Cidr::new(Address([0, 0, 0, 0]), 24)
+ );
+ assert_eq!(
+ Cidr::new(Address([0, 0, 0, 0]), 32).network(),
+ Cidr::new(Address([0, 0, 0, 0]), 32)
+ );
+ assert_eq!(
+ Cidr::new(Address([127, 0, 0, 0]), 8).network(),
+ Cidr::new(Address([127, 0, 0, 0]), 8)
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 0, 0]), 16).network(),
+ Cidr::new(Address([192, 168, 0, 0]), 16)
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 1, 1]), 16).network(),
+ Cidr::new(Address([192, 168, 0, 0]), 16)
+ );
+ assert_eq!(
+ Cidr::new(Address([192, 168, 1, 1]), 17).network(),
+ Cidr::new(Address([192, 168, 0, 0]), 17)
+ );
+ assert_eq!(
+ Cidr::new(Address([172, 16, 0, 1]), 12).network(),
+ Cidr::new(Address([172, 16, 0, 0]), 12)
+ );
+ assert_eq!(
+ Cidr::new(Address([255, 255, 255, 1]), 24).network(),
+ Cidr::new(Address([255, 255, 255, 0]), 24)
+ );
+ assert_eq!(
+ Cidr::new(Address([255, 255, 255, 255]), 32).network(),
+ Cidr::new(Address([255, 255, 255, 255]), 32)
+ );
+ }
+}
diff --git a/src/wire/ipv6.rs b/src/wire/ipv6.rs
new file mode 100644
index 0000000..236600d
--- /dev/null
+++ b/src/wire/ipv6.rs
@@ -0,0 +1,1449 @@
+#![deny(missing_docs)]
+
+use byteorder::{ByteOrder, NetworkEndian};
+use core::fmt;
+
+use super::{Error, Result};
+use crate::wire::ip::pretty_print_ip_payload;
+#[cfg(feature = "proto-ipv4")]
+use crate::wire::ipv4;
+
+pub use super::IpProtocol as Protocol;
+
+/// Minimum MTU required of all links supporting IPv6. See [RFC 8200 § 5].
+///
+/// [RFC 8200 § 5]: https://tools.ietf.org/html/rfc8200#section-5
+pub const MIN_MTU: usize = 1280;
+
+/// Size of IPv6 adderess in octets.
+///
+/// [RFC 8200 § 2]: https://www.rfc-editor.org/rfc/rfc4291#section-2
+pub const ADDR_SIZE: usize = 16;
+
+/// Size of IPv4-mapping prefix in octets.
+///
+/// [RFC 8200 § 2]: https://www.rfc-editor.org/rfc/rfc4291#section-2
+pub const IPV4_MAPPED_PREFIX_SIZE: usize = ADDR_SIZE - 4; // 4 == ipv4::ADDR_SIZE , cannot DRY here because of dependency on a IPv4 module which is behind the feature
+
+/// The [scope] of an address.
+///
+/// [scope]: https://www.rfc-editor.org/rfc/rfc4291#section-2.7
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Scope {
+ /// Interface Local scope
+ InterfaceLocal = 0x1,
+ /// Link local scope
+ LinkLocal = 0x2,
+ /// Administratively configured
+ AdminLocal = 0x4,
+ /// Single site scope
+ SiteLocal = 0x5,
+ /// Organization scope
+ OrganizationLocal = 0x8,
+ /// Global scope
+ Global = 0xE,
+ /// Unknown scope
+ Unknown = 0xFF,
+}
+
+impl From<u8> for Scope {
+ fn from(value: u8) -> Self {
+ match value {
+ 0x1 => Self::InterfaceLocal,
+ 0x2 => Self::LinkLocal,
+ 0x4 => Self::AdminLocal,
+ 0x5 => Self::SiteLocal,
+ 0x8 => Self::OrganizationLocal,
+ 0xE => Self::Global,
+ _ => Self::Unknown,
+ }
+ }
+}
+
+/// A sixteen-octet IPv6 address.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+pub struct Address(pub [u8; ADDR_SIZE]);
+
+impl Address {
+ /// The [unspecified address].
+ ///
+ /// [unspecified address]: https://tools.ietf.org/html/rfc4291#section-2.5.2
+ pub const UNSPECIFIED: Address = Address([0x00; ADDR_SIZE]);
+
+ /// The link-local [all nodes multicast address].
+ ///
+ /// [all nodes multicast address]: https://tools.ietf.org/html/rfc4291#section-2.7.1
+ pub const LINK_LOCAL_ALL_NODES: Address = Address([
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x01,
+ ]);
+
+ /// The link-local [all routers multicast address].
+ ///
+ /// [all routers multicast address]: https://tools.ietf.org/html/rfc4291#section-2.7.1
+ pub const LINK_LOCAL_ALL_ROUTERS: Address = Address([
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x02,
+ ]);
+
+ /// The link-local [all RPL nodes multicast address].
+ ///
+ /// [all RPL nodes multicast address]: https://www.rfc-editor.org/rfc/rfc6550.html#section-20.19
+ pub const LINK_LOCAL_ALL_RPL_NODES: Address = Address([
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x1a,
+ ]);
+
+ /// The [loopback address].
+ ///
+ /// [loopback address]: https://tools.ietf.org/html/rfc4291#section-2.5.3
+ pub const LOOPBACK: Address = Address([
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x01,
+ ]);
+
+ /// The prefix used in [IPv4-mapped addresses].
+ ///
+ /// [IPv4-mapped addresses]: https://www.rfc-editor.org/rfc/rfc4291#section-2.5.5.2
+ pub const IPV4_MAPPED_PREFIX: [u8; IPV4_MAPPED_PREFIX_SIZE] =
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff];
+
+ /// Construct an IPv6 address from parts.
+ #[allow(clippy::too_many_arguments)]
+ pub const fn new(
+ a0: u16,
+ a1: u16,
+ a2: u16,
+ a3: u16,
+ a4: u16,
+ a5: u16,
+ a6: u16,
+ a7: u16,
+ ) -> Address {
+ Address([
+ (a0 >> 8) as u8,
+ a0 as u8,
+ (a1 >> 8) as u8,
+ a1 as u8,
+ (a2 >> 8) as u8,
+ a2 as u8,
+ (a3 >> 8) as u8,
+ a3 as u8,
+ (a4 >> 8) as u8,
+ a4 as u8,
+ (a5 >> 8) as u8,
+ a5 as u8,
+ (a6 >> 8) as u8,
+ a6 as u8,
+ (a7 >> 8) as u8,
+ a7 as u8,
+ ])
+ }
+
+ /// Construct an IPv6 address from a sequence of octets, in big-endian.
+ ///
+ /// # Panics
+ /// The function panics if `data` is not sixteen octets long.
+ pub fn from_bytes(data: &[u8]) -> Address {
+ let mut bytes = [0; ADDR_SIZE];
+ bytes.copy_from_slice(data);
+ Address(bytes)
+ }
+
+ /// Construct an IPv6 address from a sequence of words, in big-endian.
+ ///
+ /// # Panics
+ /// The function panics if `data` is not 8 words long.
+ pub fn from_parts(data: &[u16]) -> Address {
+ assert!(data.len() >= 8);
+ let mut bytes = [0; ADDR_SIZE];
+ for (word_idx, chunk) in bytes.chunks_mut(2).enumerate() {
+ NetworkEndian::write_u16(chunk, data[word_idx]);
+ }
+ Address(bytes)
+ }
+
+ /// Write a IPv6 address to the given slice.
+ ///
+ /// # Panics
+ /// The function panics if `data` is not 8 words long.
+ pub fn write_parts(&self, data: &mut [u16]) {
+ assert!(data.len() >= 8);
+ for (i, chunk) in self.0.chunks(2).enumerate() {
+ data[i] = NetworkEndian::read_u16(chunk);
+ }
+ }
+
+ /// Return an IPv6 address as a sequence of octets, in big-endian.
+ pub const fn as_bytes(&self) -> &[u8] {
+ &self.0
+ }
+
+ /// Query whether the IPv6 address is an [unicast address].
+ ///
+ /// [unicast address]: https://tools.ietf.org/html/rfc4291#section-2.5
+ pub fn is_unicast(&self) -> bool {
+ !(self.is_multicast() || self.is_unspecified())
+ }
+
+ /// Query whether the IPv6 address is a [global unicast address].
+ ///
+ /// [global unicast address]: https://datatracker.ietf.org/doc/html/rfc3587
+ pub const fn is_global_unicast(&self) -> bool {
+ (self.0[0] >> 5) == 0b001
+ }
+
+ /// Query whether the IPv6 address is a [multicast address].
+ ///
+ /// [multicast address]: https://tools.ietf.org/html/rfc4291#section-2.7
+ pub const fn is_multicast(&self) -> bool {
+ self.0[0] == 0xff
+ }
+
+ /// Query whether the IPv6 address is the [unspecified address].
+ ///
+ /// [unspecified address]: https://tools.ietf.org/html/rfc4291#section-2.5.2
+ pub fn is_unspecified(&self) -> bool {
+ self.0 == [0x00; ADDR_SIZE]
+ }
+
+ /// Query whether the IPv6 address is in the [link-local] scope.
+ ///
+ /// [link-local]: https://tools.ietf.org/html/rfc4291#section-2.5.6
+ pub fn is_link_local(&self) -> bool {
+ self.0[0..8] == [0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
+ }
+
+ /// Query whether the IPv6 address is a [Unique Local Address] (ULA).
+ ///
+ /// [Unique Local Address]: https://tools.ietf.org/html/rfc4193
+ pub fn is_unique_local(&self) -> bool {
+ (self.0[0] & 0b1111_1110) == 0xfc
+ }
+
+ /// Query whether the IPv6 address is the [loopback address].
+ ///
+ /// [loopback address]: https://tools.ietf.org/html/rfc4291#section-2.5.3
+ pub fn is_loopback(&self) -> bool {
+ *self == Self::LOOPBACK
+ }
+
+ /// Query whether the IPv6 address is an [IPv4 mapped IPv6 address].
+ ///
+ /// [IPv4 mapped IPv6 address]: https://tools.ietf.org/html/rfc4291#section-2.5.5.2
+ pub fn is_ipv4_mapped(&self) -> bool {
+ self.0[..IPV4_MAPPED_PREFIX_SIZE] == Self::IPV4_MAPPED_PREFIX
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ /// Convert an IPv4 mapped IPv6 address to an IPv4 address.
+ pub fn as_ipv4(&self) -> Option<ipv4::Address> {
+ if self.is_ipv4_mapped() {
+ Some(ipv4::Address::from_bytes(
+ &self.0[IPV4_MAPPED_PREFIX_SIZE..],
+ ))
+ } else {
+ None
+ }
+ }
+
+ /// Helper function used to mask an address given a prefix.
+ ///
+ /// # Panics
+ /// This function panics if `mask` is greater than 128.
+ pub(super) fn mask(&self, mask: u8) -> [u8; ADDR_SIZE] {
+ assert!(mask <= 128);
+ let mut bytes = [0u8; ADDR_SIZE];
+ let idx = (mask as usize) / 8;
+ let modulus = (mask as usize) % 8;
+ let (first, second) = self.0.split_at(idx);
+ bytes[0..idx].copy_from_slice(first);
+ if idx < ADDR_SIZE {
+ let part = second[0];
+ bytes[idx] = part & (!(0xff >> modulus) as u8);
+ }
+ bytes
+ }
+
+ /// The solicited node for the given unicast address.
+ ///
+ /// # Panics
+ /// This function panics if the given address is not
+ /// unicast.
+ pub fn solicited_node(&self) -> Address {
+ assert!(self.is_unicast());
+ Address([
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF,
+ self.0[13], self.0[14], self.0[15],
+ ])
+ }
+
+ /// Return the scope of the address.
+ pub(crate) fn scope(&self) -> Scope {
+ if self.is_multicast() {
+ return Scope::from(self.as_bytes()[1] & 0b1111);
+ }
+
+ if self.is_link_local() {
+ Scope::LinkLocal
+ } else if self.is_unique_local() || self.is_global_unicast() {
+ // ULA are considered global scope
+ // https://www.rfc-editor.org/rfc/rfc6724#section-3.1
+ Scope::Global
+ } else {
+ Scope::Unknown
+ }
+ }
+
+ /// Convert to an `IpAddress`.
+ ///
+ /// Same as `.into()`, but works in `const`.
+ pub const fn into_address(self) -> super::IpAddress {
+ super::IpAddress::Ipv6(self)
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<::std::net::Ipv6Addr> for Address {
+ fn from(x: ::std::net::Ipv6Addr) -> Address {
+ Address(x.octets())
+ }
+}
+
+#[cfg(feature = "std")]
+impl From<Address> for ::std::net::Ipv6Addr {
+ fn from(Address(x): Address) -> ::std::net::Ipv6Addr {
+ x.into()
+ }
+}
+
+impl fmt::Display for Address {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ if self.is_ipv4_mapped() {
+ return write!(
+ f,
+ "::ffff:{}.{}.{}.{}",
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 0],
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 1],
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 2],
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 3]
+ );
+ }
+
+ // The string representation of an IPv6 address should
+ // collapse a series of 16 bit sections that evaluate
+ // to 0 to "::"
+ //
+ // See https://tools.ietf.org/html/rfc4291#section-2.2
+ // for details.
+ enum State {
+ Head,
+ HeadBody,
+ Tail,
+ TailBody,
+ }
+ let mut words = [0u16; 8];
+ self.write_parts(&mut words);
+ let mut state = State::Head;
+ for word in words.iter() {
+ state = match (*word, &state) {
+ // Once a u16 equal to zero write a double colon and
+ // skip to the next non-zero u16.
+ (0, &State::Head) | (0, &State::HeadBody) => {
+ write!(f, "::")?;
+ State::Tail
+ }
+ // Continue iterating without writing any characters until
+ // we hit a non-zero value.
+ (0, &State::Tail) => State::Tail,
+ // When the state is Head or Tail write a u16 in hexadecimal
+ // without the leading colon if the value is not 0.
+ (_, &State::Head) => {
+ write!(f, "{word:x}")?;
+ State::HeadBody
+ }
+ (_, &State::Tail) => {
+ write!(f, "{word:x}")?;
+ State::TailBody
+ }
+ // Write the u16 with a leading colon when parsing a value
+ // that isn't the first in a section
+ (_, &State::HeadBody) | (_, &State::TailBody) => {
+ write!(f, ":{word:x}")?;
+ state
+ }
+ }
+ }
+ Ok(())
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Address {
+ fn format(&self, f: defmt::Formatter) {
+ if self.is_ipv4_mapped() {
+ return defmt::write!(
+ f,
+ "::ffff:{}.{}.{}.{}",
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 0],
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 1],
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 2],
+ self.0[IPV4_MAPPED_PREFIX_SIZE + 3]
+ );
+ }
+
+ // The string representation of an IPv6 address should
+ // collapse a series of 16 bit sections that evaluate
+ // to 0 to "::"
+ //
+ // See https://tools.ietf.org/html/rfc4291#section-2.2
+ // for details.
+ enum State {
+ Head,
+ HeadBody,
+ Tail,
+ TailBody,
+ }
+ let mut words = [0u16; 8];
+ self.write_parts(&mut words);
+ let mut state = State::Head;
+ for word in words.iter() {
+ state = match (*word, &state) {
+ // Once a u16 equal to zero write a double colon and
+ // skip to the next non-zero u16.
+ (0, &State::Head) | (0, &State::HeadBody) => {
+ defmt::write!(f, "::");
+ State::Tail
+ }
+ // Continue iterating without writing any characters until
+ // we hit a non-zero value.
+ (0, &State::Tail) => State::Tail,
+ // When the state is Head or Tail write a u16 in hexadecimal
+ // without the leading colon if the value is not 0.
+ (_, &State::Head) => {
+ defmt::write!(f, "{:x}", word);
+ State::HeadBody
+ }
+ (_, &State::Tail) => {
+ defmt::write!(f, "{:x}", word);
+ State::TailBody
+ }
+ // Write the u16 with a leading colon when parsing a value
+ // that isn't the first in a section
+ (_, &State::HeadBody) | (_, &State::TailBody) => {
+ defmt::write!(f, ":{:x}", word);
+ state
+ }
+ }
+ }
+ }
+}
+
+#[cfg(feature = "proto-ipv4")]
+/// Convert the given IPv4 address into a IPv4-mapped IPv6 address
+impl From<ipv4::Address> for Address {
+ fn from(address: ipv4::Address) -> Self {
+ let mut b = [0_u8; ADDR_SIZE];
+ b[..Self::IPV4_MAPPED_PREFIX.len()].copy_from_slice(&Self::IPV4_MAPPED_PREFIX);
+ b[Self::IPV4_MAPPED_PREFIX.len()..].copy_from_slice(&address.0);
+ Self(b)
+ }
+}
+
+/// A specification of an IPv6 CIDR block, containing an address and a variable-length
+/// subnet masking prefix length.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+pub struct Cidr {
+ address: Address,
+ prefix_len: u8,
+}
+
+impl Cidr {
+ /// The [solicited node prefix].
+ ///
+ /// [solicited node prefix]: https://tools.ietf.org/html/rfc4291#section-2.7.1
+ pub const SOLICITED_NODE_PREFIX: Cidr = Cidr {
+ address: Address([
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0x00,
+ 0x00, 0x00,
+ ]),
+ prefix_len: 104,
+ };
+
+ /// Create an IPv6 CIDR block from the given address and prefix length.
+ ///
+ /// # Panics
+ /// This function panics if the prefix length is larger than 128.
+ pub const fn new(address: Address, prefix_len: u8) -> Cidr {
+ assert!(prefix_len <= 128);
+ Cidr {
+ address,
+ prefix_len,
+ }
+ }
+
+ /// Return the address of this IPv6 CIDR block.
+ pub const fn address(&self) -> Address {
+ self.address
+ }
+
+ /// Return the prefix length of this IPv6 CIDR block.
+ pub const fn prefix_len(&self) -> u8 {
+ self.prefix_len
+ }
+
+ /// Query whether the subnetwork described by this IPv6 CIDR block contains
+ /// the given address.
+ pub fn contains_addr(&self, addr: &Address) -> bool {
+ // right shift by 128 is not legal
+ if self.prefix_len == 0 {
+ return true;
+ }
+
+ self.address.mask(self.prefix_len) == addr.mask(self.prefix_len)
+ }
+
+ /// Query whether the subnetwork described by this IPV6 CIDR block contains
+ /// the subnetwork described by the given IPv6 CIDR block.
+ pub fn contains_subnet(&self, subnet: &Cidr) -> bool {
+ self.prefix_len <= subnet.prefix_len && self.contains_addr(&subnet.address)
+ }
+}
+
+impl fmt::Display for Cidr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ // https://tools.ietf.org/html/rfc4291#section-2.3
+ write!(f, "{}/{}", self.address, self.prefix_len)
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Cidr {
+ fn format(&self, f: defmt::Formatter) {
+ defmt::write!(f, "{}/{=u8}", self.address, self.prefix_len);
+ }
+}
+
+/// A read/write wrapper around an Internet Protocol version 6 packet buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+// Ranges and constants describing the IPv6 header
+//
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |Version| Traffic Class | Flow Label |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Payload Length | Next Header | Hop Limit |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// + +
+// | |
+// + Source Address +
+// | |
+// + +
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// + +
+// | |
+// + Destination Address +
+// | |
+// + +
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// See https://tools.ietf.org/html/rfc2460#section-3 for details.
+mod field {
+ use crate::wire::field::*;
+ // 4-bit version number, 8-bit traffic class, and the
+ // 20-bit flow label.
+ pub const VER_TC_FLOW: Field = 0..4;
+ // 16-bit value representing the length of the payload.
+ // Note: Options are included in this length.
+ pub const LENGTH: Field = 4..6;
+ // 8-bit value identifying the type of header following this
+ // one. Note: The same numbers are used in IPv4.
+ pub const NXT_HDR: usize = 6;
+ // 8-bit value decremented by each node that forwards this
+ // packet. The packet is discarded when the value is 0.
+ pub const HOP_LIMIT: usize = 7;
+ // IPv6 address of the source node.
+ pub const SRC_ADDR: Field = 8..24;
+ // IPv6 address of the destination node.
+ pub const DST_ADDR: Field = 24..40;
+}
+
+/// Length of an IPv6 header.
+pub const HEADER_LEN: usize = field::DST_ADDR.end;
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Create a raw octet buffer with an IPv6 packet structure.
+ #[inline]
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ #[inline]
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_payload_len].
+ ///
+ /// [set_payload_len]: #method.set_payload_len
+ #[inline]
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::DST_ADDR.end || len < self.total_len() {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ #[inline]
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the header length.
+ #[inline]
+ pub const fn header_len(&self) -> usize {
+ // This is not a strictly necessary function, but it makes
+ // code more readable.
+ field::DST_ADDR.end
+ }
+
+ /// Return the version field.
+ #[inline]
+ pub fn version(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::VER_TC_FLOW.start] >> 4
+ }
+
+ /// Return the traffic class.
+ #[inline]
+ pub fn traffic_class(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ ((NetworkEndian::read_u16(&data[0..2]) & 0x0ff0) >> 4) as u8
+ }
+
+ /// Return the flow label field.
+ #[inline]
+ pub fn flow_label(&self) -> u32 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u24(&data[1..4]) & 0x000fffff
+ }
+
+ /// Return the payload length field.
+ #[inline]
+ pub fn payload_len(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::LENGTH])
+ }
+
+ /// Return the payload length added to the known header length.
+ #[inline]
+ pub fn total_len(&self) -> usize {
+ self.header_len() + self.payload_len() as usize
+ }
+
+ /// Return the next header field.
+ #[inline]
+ pub fn next_header(&self) -> Protocol {
+ let data = self.buffer.as_ref();
+ Protocol::from(data[field::NXT_HDR])
+ }
+
+ /// Return the hop limit field.
+ #[inline]
+ pub fn hop_limit(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::HOP_LIMIT]
+ }
+
+ /// Return the source address field.
+ #[inline]
+ pub fn src_addr(&self) -> Address {
+ let data = self.buffer.as_ref();
+ Address::from_bytes(&data[field::SRC_ADDR])
+ }
+
+ /// Return the destination address field.
+ #[inline]
+ pub fn dst_addr(&self) -> Address {
+ let data = self.buffer.as_ref();
+ Address::from_bytes(&data[field::DST_ADDR])
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the payload.
+ #[inline]
+ pub fn payload(&self) -> &'a [u8] {
+ let data = self.buffer.as_ref();
+ let range = self.header_len()..self.total_len();
+ &data[range]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the version field.
+ #[inline]
+ pub fn set_version(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ // Make sure to retain the lower order bits which contain
+ // the higher order bits of the traffic class
+ data[0] = (data[0] & 0x0f) | ((value & 0x0f) << 4);
+ }
+
+ /// Set the traffic class field.
+ #[inline]
+ pub fn set_traffic_class(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ // Put the higher order 4-bits of value in the lower order
+ // 4-bits of the first byte
+ data[0] = (data[0] & 0xf0) | ((value & 0xf0) >> 4);
+ // Put the lower order 4-bits of value in the higher order
+ // 4-bits of the second byte
+ data[1] = (data[1] & 0x0f) | ((value & 0x0f) << 4);
+ }
+
+ /// Set the flow label field.
+ #[inline]
+ pub fn set_flow_label(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ // Retain the lower order 4-bits of the traffic class
+ let raw = (((data[1] & 0xf0) as u32) << 16) | (value & 0x0fffff);
+ NetworkEndian::write_u24(&mut data[1..4], raw);
+ }
+
+ /// Set the payload length field.
+ #[inline]
+ pub fn set_payload_len(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::LENGTH], value);
+ }
+
+ /// Set the next header field.
+ #[inline]
+ pub fn set_next_header(&mut self, value: Protocol) {
+ let data = self.buffer.as_mut();
+ data[field::NXT_HDR] = value.into();
+ }
+
+ /// Set the hop limit field.
+ #[inline]
+ pub fn set_hop_limit(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::HOP_LIMIT] = value;
+ }
+
+ /// Set the source address field.
+ #[inline]
+ pub fn set_src_addr(&mut self, value: Address) {
+ let data = self.buffer.as_mut();
+ data[field::SRC_ADDR].copy_from_slice(value.as_bytes());
+ }
+
+ /// Set the destination address field.
+ #[inline]
+ pub fn set_dst_addr(&mut self, value: Address) {
+ let data = self.buffer.as_mut();
+ data[field::DST_ADDR].copy_from_slice(value.as_bytes());
+ }
+
+ /// Return a mutable pointer to the payload.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let range = self.header_len()..self.total_len();
+ let data = self.buffer.as_mut();
+ &mut data[range]
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => {
+ write!(f, "IPv6 ({err})")?;
+ Ok(())
+ }
+ }
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+/// A high-level representation of an Internet Protocol version 6 packet header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Repr {
+ /// IPv6 address of the source node.
+ pub src_addr: Address,
+ /// IPv6 address of the destination node.
+ pub dst_addr: Address,
+ /// Protocol contained in the next header.
+ pub next_header: Protocol,
+ /// Length of the payload including the extension headers.
+ pub payload_len: usize,
+ /// The 8-bit hop limit field.
+ pub hop_limit: u8,
+}
+
+impl Repr {
+ /// Parse an Internet Protocol version 6 packet and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(packet: &Packet<&T>) -> Result<Repr> {
+ // Ensure basic accessors will work
+ packet.check_len()?;
+ if packet.version() != 6 {
+ return Err(Error);
+ }
+ Ok(Repr {
+ src_addr: packet.src_addr(),
+ dst_addr: packet.dst_addr(),
+ next_header: packet.next_header(),
+ payload_len: packet.payload_len() as usize,
+ hop_limit: packet.hop_limit(),
+ })
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ // This function is not strictly necessary, but it can make client code more readable.
+ field::DST_ADDR.end
+ }
+
+ /// Emit a high-level representation into an Internet Protocol version 6 packet.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
+ // Make no assumptions about the original state of the packet buffer.
+ // Make sure to set every byte.
+ packet.set_version(6);
+ packet.set_traffic_class(0);
+ packet.set_flow_label(0);
+ packet.set_payload_len(self.payload_len as u16);
+ packet.set_hop_limit(self.hop_limit);
+ packet.set_next_header(self.next_header);
+ packet.set_src_addr(self.src_addr);
+ packet.set_dst_addr(self.dst_addr);
+ }
+}
+
+impl fmt::Display for Repr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(
+ f,
+ "IPv6 src={} dst={} nxt_hdr={} hop_limit={}",
+ self.src_addr, self.dst_addr, self.next_header, self.hop_limit
+ )
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Repr {
+ fn format(&self, fmt: defmt::Formatter) {
+ defmt::write!(
+ fmt,
+ "IPv6 src={} dst={} nxt_hdr={} hop_limit={}",
+ self.src_addr,
+ self.dst_addr,
+ self.next_header,
+ self.hop_limit
+ )
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+// TODO: This is very similar to the implementation for IPv4. Make
+// a way to have less copy and pasted code here.
+impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ let (ip_repr, payload) = match Packet::new_checked(buffer) {
+ Err(err) => return write!(f, "{indent}({err})"),
+ Ok(ip_packet) => match Repr::parse(&ip_packet) {
+ Err(_) => return Ok(()),
+ Ok(ip_repr) => {
+ write!(f, "{indent}{ip_repr}")?;
+ (ip_repr, ip_packet.payload())
+ }
+ },
+ };
+
+ pretty_print_ip_payload(f, indent, ip_repr, payload)
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::Error;
+ use super::{Address, Cidr};
+ use super::{Packet, Protocol, Repr};
+ use crate::wire::pretty_print::PrettyPrinter;
+
+ #[cfg(feature = "proto-ipv4")]
+ use crate::wire::ipv4::Address as Ipv4Address;
+
+ const LINK_LOCAL_ADDR: Address = Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1);
+ const UNIQUE_LOCAL_ADDR: Address = Address::new(0xfd00, 0, 0, 201, 1, 1, 1, 1);
+ const GLOBAL_UNICAST_ADDR: Address = Address::new(0x2001, 0xdb8, 0x3, 0, 0, 0, 0, 1);
+
+ #[test]
+ fn test_basic_multicast() {
+ assert!(!Address::LINK_LOCAL_ALL_ROUTERS.is_unspecified());
+ assert!(Address::LINK_LOCAL_ALL_ROUTERS.is_multicast());
+ assert!(!Address::LINK_LOCAL_ALL_ROUTERS.is_link_local());
+ assert!(!Address::LINK_LOCAL_ALL_ROUTERS.is_loopback());
+ assert!(!Address::LINK_LOCAL_ALL_ROUTERS.is_unique_local());
+ assert!(!Address::LINK_LOCAL_ALL_ROUTERS.is_global_unicast());
+ assert!(!Address::LINK_LOCAL_ALL_NODES.is_unspecified());
+ assert!(Address::LINK_LOCAL_ALL_NODES.is_multicast());
+ assert!(!Address::LINK_LOCAL_ALL_NODES.is_link_local());
+ assert!(!Address::LINK_LOCAL_ALL_NODES.is_loopback());
+ assert!(!Address::LINK_LOCAL_ALL_NODES.is_unique_local());
+ assert!(!Address::LINK_LOCAL_ALL_NODES.is_global_unicast());
+ }
+
+ #[test]
+ fn test_basic_link_local() {
+ assert!(!LINK_LOCAL_ADDR.is_unspecified());
+ assert!(!LINK_LOCAL_ADDR.is_multicast());
+ assert!(LINK_LOCAL_ADDR.is_link_local());
+ assert!(!LINK_LOCAL_ADDR.is_loopback());
+ assert!(!LINK_LOCAL_ADDR.is_unique_local());
+ assert!(!LINK_LOCAL_ADDR.is_global_unicast());
+ }
+
+ #[test]
+ fn test_basic_loopback() {
+ assert!(!Address::LOOPBACK.is_unspecified());
+ assert!(!Address::LOOPBACK.is_multicast());
+ assert!(!Address::LOOPBACK.is_link_local());
+ assert!(Address::LOOPBACK.is_loopback());
+ assert!(!Address::LOOPBACK.is_unique_local());
+ assert!(!Address::LOOPBACK.is_global_unicast());
+ }
+
+ #[test]
+ fn test_unique_local() {
+ assert!(!UNIQUE_LOCAL_ADDR.is_unspecified());
+ assert!(!UNIQUE_LOCAL_ADDR.is_multicast());
+ assert!(!UNIQUE_LOCAL_ADDR.is_link_local());
+ assert!(!UNIQUE_LOCAL_ADDR.is_loopback());
+ assert!(UNIQUE_LOCAL_ADDR.is_unique_local());
+ assert!(!UNIQUE_LOCAL_ADDR.is_global_unicast());
+ }
+
+ #[test]
+ fn test_global_unicast() {
+ assert!(!GLOBAL_UNICAST_ADDR.is_unspecified());
+ assert!(!GLOBAL_UNICAST_ADDR.is_multicast());
+ assert!(!GLOBAL_UNICAST_ADDR.is_link_local());
+ assert!(!GLOBAL_UNICAST_ADDR.is_loopback());
+ assert!(!GLOBAL_UNICAST_ADDR.is_unique_local());
+ assert!(GLOBAL_UNICAST_ADDR.is_global_unicast());
+ }
+
+ #[test]
+ fn test_address_format() {
+ assert_eq!("ff02::1", format!("{}", Address::LINK_LOCAL_ALL_NODES));
+ assert_eq!("fe80::1", format!("{LINK_LOCAL_ADDR}"));
+ assert_eq!(
+ "fe80::7f00:0:1",
+ format!(
+ "{}",
+ Address::new(0xfe80, 0, 0, 0, 0, 0x7f00, 0x0000, 0x0001)
+ )
+ );
+ assert_eq!("::", format!("{}", Address::UNSPECIFIED));
+ assert_eq!("::1", format!("{}", Address::LOOPBACK));
+
+ #[cfg(feature = "proto-ipv4")]
+ assert_eq!(
+ "::ffff:192.168.1.1",
+ format!("{}", Address::from(Ipv4Address::new(192, 168, 1, 1)))
+ );
+ }
+
+ #[test]
+ fn test_new() {
+ assert_eq!(
+ Address::new(0xff02, 0, 0, 0, 0, 0, 0, 1),
+ Address::LINK_LOCAL_ALL_NODES
+ );
+ assert_eq!(
+ Address::new(0xff02, 0, 0, 0, 0, 0, 0, 2),
+ Address::LINK_LOCAL_ALL_ROUTERS
+ );
+ assert_eq!(Address::new(0, 0, 0, 0, 0, 0, 0, 1), Address::LOOPBACK);
+ assert_eq!(Address::new(0, 0, 0, 0, 0, 0, 0, 0), Address::UNSPECIFIED);
+ assert_eq!(Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1), LINK_LOCAL_ADDR);
+ }
+
+ #[test]
+ fn test_from_parts() {
+ assert_eq!(
+ Address::from_parts(&[0xff02, 0, 0, 0, 0, 0, 0, 1]),
+ Address::LINK_LOCAL_ALL_NODES
+ );
+ assert_eq!(
+ Address::from_parts(&[0xff02, 0, 0, 0, 0, 0, 0, 2]),
+ Address::LINK_LOCAL_ALL_ROUTERS
+ );
+ assert_eq!(
+ Address::from_parts(&[0, 0, 0, 0, 0, 0, 0, 1]),
+ Address::LOOPBACK
+ );
+ assert_eq!(
+ Address::from_parts(&[0, 0, 0, 0, 0, 0, 0, 0]),
+ Address::UNSPECIFIED
+ );
+ assert_eq!(
+ Address::from_parts(&[0xfe80, 0, 0, 0, 0, 0, 0, 1]),
+ LINK_LOCAL_ADDR
+ );
+ }
+
+ #[test]
+ fn test_write_parts() {
+ let mut bytes = [0u16; 8];
+ {
+ Address::LOOPBACK.write_parts(&mut bytes);
+ assert_eq!(Address::LOOPBACK, Address::from_parts(&bytes));
+ }
+ {
+ Address::LINK_LOCAL_ALL_ROUTERS.write_parts(&mut bytes);
+ assert_eq!(Address::LINK_LOCAL_ALL_ROUTERS, Address::from_parts(&bytes));
+ }
+ {
+ LINK_LOCAL_ADDR.write_parts(&mut bytes);
+ assert_eq!(LINK_LOCAL_ADDR, Address::from_parts(&bytes));
+ }
+ }
+
+ #[test]
+ fn test_mask() {
+ let addr = Address::new(0x0123, 0x4567, 0x89ab, 0, 0, 0, 0, 1);
+ assert_eq!(
+ addr.mask(11),
+ [0x01, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ );
+ assert_eq!(
+ addr.mask(15),
+ [0x01, 0x22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ );
+ assert_eq!(
+ addr.mask(26),
+ [0x01, 0x23, 0x45, 0x40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ );
+ assert_eq!(
+ addr.mask(128),
+ [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+ );
+ assert_eq!(
+ addr.mask(127),
+ [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ );
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ #[test]
+ fn test_is_ipv4_mapped() {
+ assert!(!Address::UNSPECIFIED.is_ipv4_mapped());
+ assert!(Address::from(Ipv4Address::new(192, 168, 1, 1)).is_ipv4_mapped());
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ #[test]
+ fn test_as_ipv4() {
+ assert_eq!(None, Address::UNSPECIFIED.as_ipv4());
+
+ let ipv4 = Ipv4Address::new(192, 168, 1, 1);
+ assert_eq!(Some(ipv4), Address::from(ipv4).as_ipv4());
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ #[test]
+ fn test_from_ipv4_address() {
+ assert_eq!(
+ Address([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 1, 1]),
+ Address::from(Ipv4Address::new(192, 168, 1, 1))
+ );
+ assert_eq!(
+ Address([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 222, 1, 41, 90]),
+ Address::from(Ipv4Address::new(222, 1, 41, 90))
+ );
+ }
+
+ #[test]
+ fn test_cidr() {
+ // fe80::1/56
+ // 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ let cidr = Cidr::new(LINK_LOCAL_ADDR, 56);
+
+ let inside_subnet = [
+ // fe80::2
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x02,
+ ],
+ // fe80::1122:3344:5566:7788
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+ 0x77, 0x88,
+ ],
+ // fe80::ff00:0:0:0
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00,
+ ],
+ // fe80::ff
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0xff,
+ ],
+ ];
+
+ let outside_subnet = [
+ // fe80:0:0:101::1
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ ],
+ // ::1
+ [
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ ],
+ // ff02::1
+ [
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ ],
+ // ff02::2
+ [
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x02,
+ ],
+ ];
+
+ let subnets = [
+ // fe80::ffff:ffff:ffff:ffff/65
+ (
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff,
+ ],
+ 65,
+ ),
+ // fe80::1/128
+ (
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x01,
+ ],
+ 128,
+ ),
+ // fe80::1234:5678/96
+ (
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+ 0x34, 0x56, 0x78,
+ ],
+ 96,
+ ),
+ ];
+
+ let not_subnets = [
+ // fe80::101:ffff:ffff:ffff:ffff/55
+ (
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff,
+ ],
+ 55,
+ ),
+ // fe80::101:ffff:ffff:ffff:ffff/56
+ (
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff,
+ ],
+ 56,
+ ),
+ // fe80::101:ffff:ffff:ffff:ffff/57
+ (
+ [
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff,
+ ],
+ 57,
+ ),
+ // ::1/128
+ (
+ [
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x01,
+ ],
+ 128,
+ ),
+ ];
+
+ for addr in inside_subnet.iter().map(|a| Address::from_bytes(a)) {
+ assert!(cidr.contains_addr(&addr));
+ }
+
+ for addr in outside_subnet.iter().map(|a| Address::from_bytes(a)) {
+ assert!(!cidr.contains_addr(&addr));
+ }
+
+ for subnet in subnets.iter().map(|&(a, p)| Cidr::new(Address(a), p)) {
+ assert!(cidr.contains_subnet(&subnet));
+ }
+
+ for subnet in not_subnets.iter().map(|&(a, p)| Cidr::new(Address(a), p)) {
+ assert!(!cidr.contains_subnet(&subnet));
+ }
+
+ let cidr_without_prefix = Cidr::new(LINK_LOCAL_ADDR, 0);
+ assert!(cidr_without_prefix.contains_addr(&Address::LOOPBACK));
+ }
+
+ #[test]
+ #[should_panic(expected = "length")]
+ fn test_from_bytes_too_long() {
+ let _ = Address::from_bytes(&[0u8; 15]);
+ }
+
+ #[test]
+ #[should_panic(expected = "data.len() >= 8")]
+ fn test_from_parts_too_long() {
+ let _ = Address::from_parts(&[0u16; 7]);
+ }
+
+ #[test]
+ fn test_scope() {
+ use super::*;
+ assert_eq!(
+ Address::new(0xff01, 0, 0, 0, 0, 0, 0, 1).scope(),
+ Scope::InterfaceLocal
+ );
+ assert_eq!(
+ Address::new(0xff02, 0, 0, 0, 0, 0, 0, 1).scope(),
+ Scope::LinkLocal
+ );
+ assert_eq!(
+ Address::new(0xff03, 0, 0, 0, 0, 0, 0, 1).scope(),
+ Scope::Unknown
+ );
+ assert_eq!(
+ Address::new(0xff04, 0, 0, 0, 0, 0, 0, 1).scope(),
+ Scope::AdminLocal
+ );
+ assert_eq!(
+ Address::new(0xff05, 0, 0, 0, 0, 0, 0, 1).scope(),
+ Scope::SiteLocal
+ );
+ assert_eq!(
+ Address::new(0xff08, 0, 0, 0, 0, 0, 0, 1).scope(),
+ Scope::OrganizationLocal
+ );
+ assert_eq!(
+ Address::new(0xff0e, 0, 0, 0, 0, 0, 0, 1).scope(),
+ Scope::Global
+ );
+
+ assert_eq!(Address::LINK_LOCAL_ALL_NODES.scope(), Scope::LinkLocal);
+
+ // For source address selection, unicast addresses also have a scope:
+ assert_eq!(LINK_LOCAL_ADDR.scope(), Scope::LinkLocal);
+ assert_eq!(GLOBAL_UNICAST_ADDR.scope(), Scope::Global);
+ assert_eq!(UNIQUE_LOCAL_ADDR.scope(), Scope::Global);
+ }
+
+ static REPR_PACKET_BYTES: [u8; 52] = [
+ 0x60, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x11, 0x40, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, 0x00,
+ 0x0c, 0x02, 0x4e, 0xff, 0xff, 0xff, 0xff,
+ ];
+ static REPR_PAYLOAD_BYTES: [u8; 12] = [
+ 0x00, 0x01, 0x00, 0x02, 0x00, 0x0c, 0x02, 0x4e, 0xff, 0xff, 0xff, 0xff,
+ ];
+
+ const fn packet_repr() -> Repr {
+ Repr {
+ src_addr: Address([
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ ]),
+ dst_addr: Address::LINK_LOCAL_ALL_NODES,
+ next_header: Protocol::Udp,
+ payload_len: 12,
+ hop_limit: 64,
+ }
+ }
+
+ #[test]
+ fn test_packet_deconstruction() {
+ let packet = Packet::new_unchecked(&REPR_PACKET_BYTES[..]);
+ assert_eq!(packet.check_len(), Ok(()));
+ assert_eq!(packet.version(), 6);
+ assert_eq!(packet.traffic_class(), 0);
+ assert_eq!(packet.flow_label(), 0);
+ assert_eq!(packet.total_len(), 0x34);
+ assert_eq!(packet.payload_len() as usize, REPR_PAYLOAD_BYTES.len());
+ assert_eq!(packet.next_header(), Protocol::Udp);
+ assert_eq!(packet.hop_limit(), 0x40);
+ assert_eq!(
+ packet.src_addr(),
+ Address([
+ 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01
+ ])
+ );
+ assert_eq!(packet.dst_addr(), Address::LINK_LOCAL_ALL_NODES);
+ assert_eq!(packet.payload(), &REPR_PAYLOAD_BYTES[..]);
+ }
+
+ #[test]
+ fn test_packet_construction() {
+ let mut bytes = [0xff; 52];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ // Version, Traffic Class, and Flow Label are not
+ // byte aligned. make sure the setters and getters
+ // do not interfere with each other.
+ packet.set_version(6);
+ assert_eq!(packet.version(), 6);
+ packet.set_traffic_class(0x99);
+ assert_eq!(packet.version(), 6);
+ assert_eq!(packet.traffic_class(), 0x99);
+ packet.set_flow_label(0x54321);
+ assert_eq!(packet.traffic_class(), 0x99);
+ assert_eq!(packet.flow_label(), 0x54321);
+ packet.set_payload_len(0xc);
+ packet.set_next_header(Protocol::Udp);
+ packet.set_hop_limit(0xfe);
+ packet.set_src_addr(Address::LINK_LOCAL_ALL_ROUTERS);
+ packet.set_dst_addr(Address::LINK_LOCAL_ALL_NODES);
+ packet
+ .payload_mut()
+ .copy_from_slice(&REPR_PAYLOAD_BYTES[..]);
+ let mut expected_bytes = [
+ 0x69, 0x95, 0x43, 0x21, 0x00, 0x0c, 0x11, 0xfe, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x02, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+ let start = expected_bytes.len() - REPR_PAYLOAD_BYTES.len();
+ expected_bytes[start..].copy_from_slice(&REPR_PAYLOAD_BYTES[..]);
+ assert_eq!(packet.check_len(), Ok(()));
+ assert_eq!(&*packet.into_inner(), &expected_bytes[..]);
+ }
+
+ #[test]
+ fn test_overlong() {
+ let mut bytes = vec![];
+ bytes.extend(&REPR_PACKET_BYTES[..]);
+ bytes.push(0);
+
+ assert_eq!(
+ Packet::new_unchecked(&bytes).payload().len(),
+ REPR_PAYLOAD_BYTES.len()
+ );
+ assert_eq!(
+ Packet::new_unchecked(&mut bytes).payload_mut().len(),
+ REPR_PAYLOAD_BYTES.len()
+ );
+ }
+
+ #[test]
+ fn test_total_len_overflow() {
+ let mut bytes = vec![];
+ bytes.extend(&REPR_PACKET_BYTES[..]);
+ Packet::new_unchecked(&mut bytes).set_payload_len(0x80);
+
+ assert_eq!(Packet::new_checked(&bytes).unwrap_err(), Error);
+ }
+
+ #[test]
+ fn test_repr_parse_valid() {
+ let packet = Packet::new_unchecked(&REPR_PACKET_BYTES[..]);
+ let repr = Repr::parse(&packet).unwrap();
+ assert_eq!(repr, packet_repr());
+ }
+
+ #[test]
+ fn test_repr_parse_bad_version() {
+ let mut bytes = vec![0; 40];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ packet.set_version(4);
+ packet.set_payload_len(0);
+ let packet = Packet::new_unchecked(&*packet.into_inner());
+ assert_eq!(Repr::parse(&packet), Err(Error));
+ }
+
+ #[test]
+ fn test_repr_parse_smaller_than_header() {
+ let mut bytes = vec![0; 40];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ packet.set_version(6);
+ packet.set_payload_len(39);
+ let packet = Packet::new_unchecked(&*packet.into_inner());
+ assert_eq!(Repr::parse(&packet), Err(Error));
+ }
+
+ #[test]
+ fn test_repr_parse_smaller_than_payload() {
+ let mut bytes = vec![0; 40];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ packet.set_version(6);
+ packet.set_payload_len(1);
+ let packet = Packet::new_unchecked(&*packet.into_inner());
+ assert_eq!(Repr::parse(&packet), Err(Error));
+ }
+
+ #[test]
+ fn test_basic_repr_emit() {
+ let repr = packet_repr();
+ let mut bytes = vec![0xff; repr.buffer_len() + REPR_PAYLOAD_BYTES.len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(&mut packet);
+ packet.payload_mut().copy_from_slice(&REPR_PAYLOAD_BYTES);
+ assert_eq!(&*packet.into_inner(), &REPR_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_pretty_print() {
+ assert_eq!(
+ format!(
+ "{}",
+ PrettyPrinter::<Packet<&'static [u8]>>::new("\n", &&REPR_PACKET_BYTES[..])
+ ),
+ "\nIPv6 src=fe80::1 dst=ff02::1 nxt_hdr=UDP hop_limit=64\n \\ UDP src=1 dst=2 len=4"
+ );
+ }
+}
diff --git a/src/wire/ipv6ext_header.rs b/src/wire/ipv6ext_header.rs
new file mode 100644
index 0000000..bc8ef87
--- /dev/null
+++ b/src/wire/ipv6ext_header.rs
@@ -0,0 +1,305 @@
+#![allow(unused)]
+
+use super::IpProtocol;
+use super::{Error, Result};
+
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::*;
+
+ pub const MIN_HEADER_SIZE: usize = 8;
+
+ pub const NXT_HDR: usize = 0;
+ pub const LENGTH: usize = 1;
+ // Variable-length field.
+ //
+ // Length of the header is in 8-octet units, not including the first 8 octets.
+ // The first two octets are the next header type and the header length.
+ pub const fn PAYLOAD(length_field: u8) -> Field {
+ let bytes = length_field as usize * 8 + 8;
+ 2..bytes
+ }
+}
+
+/// A read/write wrapper around an IPv6 Extension Header buffer.
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Header<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+/// Core getter methods relevant to any IPv6 extension header.
+impl<T: AsRef<[u8]>> Header<T> {
+ /// Create a raw octet buffer with an IPv6 Extension Header structure.
+ pub const fn new_unchecked(buffer: T) -> Self {
+ Header { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let header = Self::new_unchecked(buffer);
+ header.check_len()?;
+ Ok(header)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_header_len].
+ ///
+ /// [set_header_len]: #method.set_header_len
+ pub fn check_len(&self) -> Result<()> {
+ let data = self.buffer.as_ref();
+
+ let len = data.len();
+ if len < field::MIN_HEADER_SIZE {
+ return Err(Error);
+ }
+
+ let of = field::PAYLOAD(data[field::LENGTH]);
+ if len < of.end {
+ return Err(Error);
+ }
+
+ Ok(())
+ }
+
+ /// Consume the header, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the next header field.
+ pub fn next_header(&self) -> IpProtocol {
+ let data = self.buffer.as_ref();
+ IpProtocol::from(data[field::NXT_HDR])
+ }
+
+ /// Return the header length field.
+ pub fn header_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::LENGTH]
+ }
+}
+
+impl<'h, T: AsRef<[u8]> + ?Sized> Header<&'h T> {
+ /// Return the payload of the IPv6 extension header.
+ pub fn payload(&self) -> &'h [u8] {
+ let data = self.buffer.as_ref();
+ &data[field::PAYLOAD(data[field::LENGTH])]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
+ /// Set the next header field.
+ #[inline]
+ pub fn set_next_header(&mut self, value: IpProtocol) {
+ let data = self.buffer.as_mut();
+ data[field::NXT_HDR] = value.into();
+ }
+
+ /// Set the extension header data length. The length of the header is
+ /// in 8-octet units, not including the first 8 octets.
+ #[inline]
+ pub fn set_header_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::LENGTH] = value;
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> Header<&'a mut T> {
+ /// Return a mutable pointer to the payload data.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let data = self.buffer.as_mut();
+ let len = data[field::LENGTH];
+ &mut data[field::PAYLOAD(len)]
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr<'a> {
+ pub next_header: IpProtocol,
+ pub length: u8,
+ pub data: &'a [u8],
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an IPv6 Extension Header Header and return a high-level representation.
+ pub fn parse<T>(header: &Header<&'a T>) -> Result<Self>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ Ok(Self {
+ next_header: header.next_header(),
+ length: header.header_len(),
+ data: header.payload(),
+ })
+ }
+
+ /// Return the length, in bytes, of a header that will be emitted from this high-level
+ /// representation.
+ pub const fn header_len(&self) -> usize {
+ 2
+ }
+
+ /// Emit a high-level representation into an IPv6 Extension Header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, header: &mut Header<&mut T>) {
+ header.set_next_header(self.next_header);
+ header.set_header_len(self.length);
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ // A Hop-by-Hop Option header with a PadN option of option data length 4.
+ static REPR_PACKET_PAD4: [u8; 8] = [0x6, 0x0, 0x1, 0x4, 0x0, 0x0, 0x0, 0x0];
+
+ // A Hop-by-Hop Option header with a PadN option of option data length 12.
+ static REPR_PACKET_PAD12: [u8; 16] = [
+ 0x06, 0x1, 0x1, 0x0C, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ ];
+
+ #[test]
+ fn test_check_len() {
+ // zero byte buffer
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&REPR_PACKET_PAD4[..0]).check_len()
+ );
+ // no length field
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&REPR_PACKET_PAD4[..1]).check_len()
+ );
+ // less than 8 bytes
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&REPR_PACKET_PAD4[..7]).check_len()
+ );
+ // valid
+ assert_eq!(Ok(()), Header::new_unchecked(&REPR_PACKET_PAD4).check_len());
+ // valid
+ assert_eq!(
+ Ok(()),
+ Header::new_unchecked(&REPR_PACKET_PAD12).check_len()
+ );
+ // length field value greater than number of bytes
+ let header: [u8; 8] = [0x06, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0];
+ assert_eq!(Err(Error), Header::new_unchecked(&header).check_len());
+ }
+
+ #[test]
+ fn test_header_deconstruct() {
+ let header = Header::new_unchecked(&REPR_PACKET_PAD4);
+ assert_eq!(header.next_header(), IpProtocol::Tcp);
+ assert_eq!(header.header_len(), 0);
+ assert_eq!(header.payload(), &REPR_PACKET_PAD4[2..]);
+
+ let header = Header::new_unchecked(&REPR_PACKET_PAD12);
+ assert_eq!(header.next_header(), IpProtocol::Tcp);
+ assert_eq!(header.header_len(), 1);
+ assert_eq!(header.payload(), &REPR_PACKET_PAD12[2..]);
+ }
+
+ #[test]
+ fn test_overlong() {
+ let mut bytes = vec![];
+ bytes.extend(&REPR_PACKET_PAD4[..]);
+ bytes.push(0);
+
+ assert_eq!(
+ Header::new_unchecked(&bytes).payload().len(),
+ REPR_PACKET_PAD4[2..].len()
+ );
+ assert_eq!(
+ Header::new_unchecked(&mut bytes).payload_mut().len(),
+ REPR_PACKET_PAD4[2..].len()
+ );
+
+ let mut bytes = vec![];
+ bytes.extend(&REPR_PACKET_PAD12[..]);
+ bytes.push(0);
+
+ assert_eq!(
+ Header::new_unchecked(&bytes).payload().len(),
+ REPR_PACKET_PAD12[2..].len()
+ );
+ assert_eq!(
+ Header::new_unchecked(&mut bytes).payload_mut().len(),
+ REPR_PACKET_PAD12[2..].len()
+ );
+ }
+
+ #[test]
+ fn test_header_len_overflow() {
+ let mut bytes = vec![];
+ bytes.extend(REPR_PACKET_PAD4);
+ let len = bytes.len() as u8;
+ Header::new_unchecked(&mut bytes).set_header_len(len + 1);
+
+ assert_eq!(Header::new_checked(&bytes).unwrap_err(), Error);
+
+ let mut bytes = vec![];
+ bytes.extend(REPR_PACKET_PAD12);
+ let len = bytes.len() as u8;
+ Header::new_unchecked(&mut bytes).set_header_len(len + 1);
+
+ assert_eq!(Header::new_checked(&bytes).unwrap_err(), Error);
+ }
+
+ #[test]
+ fn test_repr_parse_valid() {
+ let header = Header::new_unchecked(&REPR_PACKET_PAD4);
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(
+ repr,
+ Repr {
+ next_header: IpProtocol::Tcp,
+ length: 0,
+ data: &REPR_PACKET_PAD4[2..]
+ }
+ );
+
+ let header = Header::new_unchecked(&REPR_PACKET_PAD12);
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(
+ repr,
+ Repr {
+ next_header: IpProtocol::Tcp,
+ length: 1,
+ data: &REPR_PACKET_PAD12[2..]
+ }
+ );
+ }
+
+ #[test]
+ fn test_repr_emit() {
+ let repr = Repr {
+ next_header: IpProtocol::Tcp,
+ length: 0,
+ data: &REPR_PACKET_PAD4[2..],
+ };
+ let mut bytes = [0u8; 2];
+ let mut header = Header::new_unchecked(&mut bytes);
+ repr.emit(&mut header);
+ assert_eq!(header.into_inner(), &REPR_PACKET_PAD4[..2]);
+
+ let repr = Repr {
+ next_header: IpProtocol::Tcp,
+ length: 1,
+ data: &REPR_PACKET_PAD12[2..],
+ };
+ let mut bytes = [0u8; 2];
+ let mut header = Header::new_unchecked(&mut bytes);
+ repr.emit(&mut header);
+ assert_eq!(header.into_inner(), &REPR_PACKET_PAD12[..2]);
+ }
+}
diff --git a/src/wire/ipv6fragment.rs b/src/wire/ipv6fragment.rs
new file mode 100644
index 0000000..cf6b6d0
--- /dev/null
+++ b/src/wire/ipv6fragment.rs
@@ -0,0 +1,283 @@
+use super::{Error, Result};
+use core::fmt;
+
+use byteorder::{ByteOrder, NetworkEndian};
+
+/// A read/write wrapper around an IPv6 Fragment Header.
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Header<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+// Format of the Fragment Header
+//
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Next Header | Reserved | Fragment Offset |Res|M|
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Identification |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// See https://tools.ietf.org/html/rfc8200#section-4.5 for details.
+//
+// **NOTE**: The fields start counting after the header length field.
+mod field {
+ use crate::wire::field::*;
+
+ // 16-bit field containing the fragment offset, reserved and more fragments values.
+ pub const FR_OF_M: Field = 0..2;
+ // 32-bit field identifying the fragmented packet
+ pub const IDENT: Field = 2..6;
+ /// 1 bit flag indicating if there are more fragments coming.
+ pub const M: usize = 1;
+}
+
+impl<T: AsRef<[u8]>> Header<T> {
+ /// Create a raw octet buffer with an IPv6 Fragment Header structure.
+ pub const fn new_unchecked(buffer: T) -> Header<T> {
+ Header { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Header<T>> {
+ let header = Self::new_unchecked(buffer);
+ header.check_len()?;
+ Ok(header)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let data = self.buffer.as_ref();
+ let len = data.len();
+
+ if len < field::IDENT.end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the header, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the fragment offset field.
+ #[inline]
+ pub fn frag_offset(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::FR_OF_M]) >> 3
+ }
+
+ /// Return more fragment flag field.
+ #[inline]
+ pub fn more_frags(&self) -> bool {
+ let data = self.buffer.as_ref();
+ (data[field::M] & 0x1) == 1
+ }
+
+ /// Return the fragment identification value field.
+ #[inline]
+ pub fn ident(&self) -> u32 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u32(&data[field::IDENT])
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
+ /// Set reserved fields.
+ ///
+ /// Set 8-bit reserved field after the next header field.
+ /// Set 2-bit reserved field between fragment offset and more fragments.
+ #[inline]
+ pub fn clear_reserved(&mut self) {
+ let data = self.buffer.as_mut();
+ // Retain the higher order 5 bits and lower order 1 bit
+ data[field::M] &= 0xf9;
+ }
+
+ /// Set the fragment offset field.
+ #[inline]
+ pub fn set_frag_offset(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ // Retain the lower order 3 bits
+ let raw = ((value & 0x1fff) << 3) | ((data[field::M] & 0x7) as u16);
+ NetworkEndian::write_u16(&mut data[field::FR_OF_M], raw);
+ }
+
+ /// Set the more fragments flag field.
+ #[inline]
+ pub fn set_more_frags(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ // Retain the high order 7 bits
+ let raw = (data[field::M] & 0xfe) | (value as u8 & 0x1);
+ data[field::M] = raw;
+ }
+
+ /// Set the fragmentation identification field.
+ #[inline]
+ pub fn set_ident(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::IDENT], value);
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Header<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => {
+ write!(f, "IPv6 Fragment ({err})")?;
+ Ok(())
+ }
+ }
+ }
+}
+
+/// A high-level representation of an IPv6 Fragment header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr {
+ /// The offset of the data following this header, relative to the start of the Fragmentable
+ /// Part of the original packet.
+ pub frag_offset: u16,
+ /// When there are more fragments following this header
+ pub more_frags: bool,
+ /// The identification for every packet that is fragmented.
+ pub ident: u32,
+}
+
+impl Repr {
+ /// Parse an IPv6 Fragment Header and return a high-level representation.
+ pub fn parse<T>(header: &Header<&T>) -> Result<Repr>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ Ok(Repr {
+ frag_offset: header.frag_offset(),
+ more_frags: header.more_frags(),
+ ident: header.ident(),
+ })
+ }
+
+ /// Return the length, in bytes, of a header that will be emitted from this high-level
+ /// representation.
+ pub const fn buffer_len(&self) -> usize {
+ field::IDENT.end
+ }
+
+ /// Emit a high-level representation into an IPv6 Fragment Header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, header: &mut Header<&mut T>) {
+ header.clear_reserved();
+ header.set_frag_offset(self.frag_offset);
+ header.set_more_frags(self.more_frags);
+ header.set_ident(self.ident);
+ }
+}
+
+impl fmt::Display for Repr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(
+ f,
+ "IPv6 Fragment offset={} more={} ident={}",
+ self.frag_offset, self.more_frags, self.ident
+ )
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ // A Fragment Header with more fragments remaining
+ static BYTES_HEADER_MORE_FRAG: [u8; 6] = [0x0, 0x1, 0x0, 0x0, 0x30, 0x39];
+
+ // A Fragment Header with no more fragments remaining
+ static BYTES_HEADER_LAST_FRAG: [u8; 6] = [0xa, 0x0, 0x0, 0x1, 0x9, 0x32];
+
+ #[test]
+ fn test_check_len() {
+ // less than 6 bytes
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&BYTES_HEADER_MORE_FRAG[..5]).check_len()
+ );
+ // valid
+ assert_eq!(
+ Ok(()),
+ Header::new_unchecked(&BYTES_HEADER_MORE_FRAG).check_len()
+ );
+ }
+
+ #[test]
+ fn test_header_deconstruct() {
+ let header = Header::new_unchecked(&BYTES_HEADER_MORE_FRAG);
+ assert_eq!(header.frag_offset(), 0);
+ assert!(header.more_frags());
+ assert_eq!(header.ident(), 12345);
+
+ let header = Header::new_unchecked(&BYTES_HEADER_LAST_FRAG);
+ assert_eq!(header.frag_offset(), 320);
+ assert!(!header.more_frags());
+ assert_eq!(header.ident(), 67890);
+ }
+
+ #[test]
+ fn test_repr_parse_valid() {
+ let header = Header::new_unchecked(&BYTES_HEADER_MORE_FRAG);
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(
+ repr,
+ Repr {
+ frag_offset: 0,
+ more_frags: true,
+ ident: 12345
+ }
+ );
+
+ let header = Header::new_unchecked(&BYTES_HEADER_LAST_FRAG);
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(
+ repr,
+ Repr {
+ frag_offset: 320,
+ more_frags: false,
+ ident: 67890
+ }
+ );
+ }
+
+ #[test]
+ fn test_repr_emit() {
+ let repr = Repr {
+ frag_offset: 0,
+ more_frags: true,
+ ident: 12345,
+ };
+ let mut bytes = [0u8; 6];
+ let mut header = Header::new_unchecked(&mut bytes);
+ repr.emit(&mut header);
+ assert_eq!(header.into_inner(), &BYTES_HEADER_MORE_FRAG[0..6]);
+
+ let repr = Repr {
+ frag_offset: 320,
+ more_frags: false,
+ ident: 67890,
+ };
+ let mut bytes = [0u8; 6];
+ let mut header = Header::new_unchecked(&mut bytes);
+ repr.emit(&mut header);
+ assert_eq!(header.into_inner(), &BYTES_HEADER_LAST_FRAG[0..6]);
+ }
+
+ #[test]
+ fn test_buffer_len() {
+ let header = Header::new_unchecked(&BYTES_HEADER_MORE_FRAG);
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(repr.buffer_len(), BYTES_HEADER_MORE_FRAG.len());
+ }
+}
diff --git a/src/wire/ipv6hbh.rs b/src/wire/ipv6hbh.rs
new file mode 100644
index 0000000..bc68300
--- /dev/null
+++ b/src/wire/ipv6hbh.rs
@@ -0,0 +1,176 @@
+use super::{Error, Ipv6Option, Ipv6OptionRepr, Ipv6OptionsIterator, Result};
+
+use heapless::Vec;
+
+/// A read/write wrapper around an IPv6 Hop-by-Hop Header buffer.
+pub struct Header<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+impl<T: AsRef<[u8]>> Header<T> {
+ /// Create a raw octet buffer with an IPv6 Hop-by-Hop Header structure.
+ pub const fn new_unchecked(buffer: T) -> Self {
+ Header { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let header = Self::new_unchecked(buffer);
+ header.check_len()?;
+ Ok(header)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_header_len].
+ ///
+ /// [set_header_len]: #method.set_header_len
+ pub fn check_len(&self) -> Result<()> {
+ if self.buffer.as_ref().is_empty() {
+ return Err(Error);
+ }
+
+ Ok(())
+ }
+
+ /// Consume the header, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Header<&'a T> {
+ /// Return the options of the IPv6 Hop-by-Hop header.
+ pub fn options(&self) -> &'a [u8] {
+ self.buffer.as_ref()
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> Header<&'a mut T> {
+ /// Return a mutable pointer to the options of the IPv6 Hop-by-Hop header.
+ pub fn options_mut(&mut self) -> &mut [u8] {
+ self.buffer.as_mut()
+ }
+}
+
+/// A high-level representation of an IPv6 Hop-by-Hop Header.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Repr<'a> {
+ pub options: heapless::Vec<Ipv6OptionRepr<'a>, { crate::config::IPV6_HBH_MAX_OPTIONS }>,
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an IPv6 Hop-by-Hop Header and return a high-level representation.
+ pub fn parse<T>(header: &'a Header<&'a T>) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ let mut options = Vec::new();
+
+ let iter = Ipv6OptionsIterator::new(header.options());
+
+ for option in iter {
+ let option = option?;
+
+ if let Err(e) = options.push(option) {
+ net_trace!("error when parsing hop-by-hop options: {}", e);
+ break;
+ }
+ }
+
+ Ok(Self { options })
+ }
+
+ /// Return the length, in bytes, of a header that will be emitted from this high-level
+ /// representation.
+ pub fn buffer_len(&self) -> usize {
+ self.options.iter().map(|o| o.buffer_len()).sum()
+ }
+
+ /// Emit a high-level representation into an IPv6 Hop-by-Hop Header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, header: &mut Header<&mut T>) {
+ let mut buffer = header.options_mut();
+
+ for opt in &self.options {
+ opt.emit(&mut Ipv6Option::new_unchecked(
+ &mut buffer[..opt.buffer_len()],
+ ));
+ buffer = &mut buffer[opt.buffer_len()..];
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::wire::Error;
+
+ // A Hop-by-Hop Option header with a PadN option of option data length 4.
+ static REPR_PACKET_PAD4: [u8; 6] = [0x1, 0x4, 0x0, 0x0, 0x0, 0x0];
+
+ // A Hop-by-Hop Option header with a PadN option of option data length 12.
+ static REPR_PACKET_PAD12: [u8; 14] = [
+ 0x1, 0x0C, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ ];
+
+ #[test]
+ fn test_check_len() {
+ // zero byte buffer
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&REPR_PACKET_PAD4[..0]).check_len()
+ );
+ // valid
+ assert_eq!(Ok(()), Header::new_unchecked(&REPR_PACKET_PAD4).check_len());
+ // valid
+ assert_eq!(
+ Ok(()),
+ Header::new_unchecked(&REPR_PACKET_PAD12).check_len()
+ );
+ }
+
+ #[test]
+ fn test_repr_parse_valid() {
+ let header = Header::new_unchecked(&REPR_PACKET_PAD4);
+ let repr = Repr::parse(&header).unwrap();
+
+ let mut options = Vec::new();
+ options.push(Ipv6OptionRepr::PadN(4)).unwrap();
+ assert_eq!(repr, Repr { options });
+
+ let header = Header::new_unchecked(&REPR_PACKET_PAD12);
+ let repr = Repr::parse(&header).unwrap();
+
+ let mut options = Vec::new();
+ options.push(Ipv6OptionRepr::PadN(12)).unwrap();
+ assert_eq!(repr, Repr { options });
+ }
+
+ #[test]
+ fn test_repr_emit() {
+ let mut options = Vec::new();
+ options.push(Ipv6OptionRepr::PadN(4)).unwrap();
+ let repr = Repr { options };
+
+ let mut bytes = [0u8; 6];
+ let mut header = Header::new_unchecked(&mut bytes);
+ repr.emit(&mut header);
+
+ assert_eq!(header.into_inner(), &REPR_PACKET_PAD4[..]);
+
+ let mut options = Vec::new();
+ options.push(Ipv6OptionRepr::PadN(12)).unwrap();
+ let repr = Repr { options };
+
+ let mut bytes = [0u8; 14];
+ let mut header = Header::new_unchecked(&mut bytes);
+ repr.emit(&mut header);
+
+ assert_eq!(header.into_inner(), &REPR_PACKET_PAD12[..]);
+ }
+}
diff --git a/src/wire/ipv6option.rs b/src/wire/ipv6option.rs
new file mode 100644
index 0000000..dfbd6ac
--- /dev/null
+++ b/src/wire/ipv6option.rs
@@ -0,0 +1,611 @@
+use super::{Error, Result};
+#[cfg(feature = "proto-rpl")]
+use super::{RplHopByHopPacket, RplHopByHopRepr};
+
+use core::fmt;
+
+enum_with_unknown! {
+ /// IPv6 Extension Header Option Type
+ pub enum Type(u8) {
+ /// 1 byte of padding
+ Pad1 = 0,
+ /// Multiple bytes of padding
+ PadN = 1,
+ /// RPL Option
+ Rpl = 0x63,
+ }
+}
+
+impl fmt::Display for Type {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Type::Pad1 => write!(f, "Pad1"),
+ Type::PadN => write!(f, "PadN"),
+ Type::Rpl => write!(f, "RPL"),
+ Type::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+enum_with_unknown! {
+ /// Action required when parsing the given IPv6 Extension
+ /// Header Option Type fails
+ pub enum FailureType(u8) {
+ /// Skip this option and continue processing the packet
+ Skip = 0b00000000,
+ /// Discard the containing packet
+ Discard = 0b01000000,
+ /// Discard the containing packet and notify the sender
+ DiscardSendAll = 0b10000000,
+ /// Discard the containing packet and only notify the sender
+ /// if the sender is a unicast address
+ DiscardSendUnicast = 0b11000000,
+ }
+}
+
+impl fmt::Display for FailureType {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ FailureType::Skip => write!(f, "skip"),
+ FailureType::Discard => write!(f, "discard"),
+ FailureType::DiscardSendAll => write!(f, "discard and send error"),
+ FailureType::DiscardSendUnicast => write!(f, "discard and send error if unicast"),
+ FailureType::Unknown(id) => write!(f, "Unknown({id})"),
+ }
+ }
+}
+
+impl From<Type> for FailureType {
+ fn from(other: Type) -> FailureType {
+ let raw: u8 = other.into();
+ Self::from(raw & 0b11000000u8)
+ }
+}
+
+/// A read/write wrapper around an IPv6 Extension Header Option.
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ipv6Option<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+// Format of Option
+//
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- - - - - - - - -
+// | Option Type | Opt Data Len | Option Data
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- - - - - - - - -
+//
+//
+// See https://tools.ietf.org/html/rfc8200#section-4.2 for details.
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::*;
+
+ // 8-bit identifier of the type of option.
+ pub const TYPE: usize = 0;
+ // 8-bit unsigned integer. Length of the DATA field of this option, in octets.
+ pub const LENGTH: usize = 1;
+ // Variable-length field. Option-Type-specific data.
+ pub const fn DATA(length: u8) -> Field {
+ 2..length as usize + 2
+ }
+}
+
+impl<T: AsRef<[u8]>> Ipv6Option<T> {
+ /// Create a raw octet buffer with an IPv6 Extension Header Option structure.
+ pub const fn new_unchecked(buffer: T) -> Ipv6Option<T> {
+ Ipv6Option { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Ipv6Option<T>> {
+ let opt = Self::new_unchecked(buffer);
+ opt.check_len()?;
+ Ok(opt)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_data_len].
+ ///
+ /// [set_data_len]: #method.set_data_len
+ pub fn check_len(&self) -> Result<()> {
+ let data = self.buffer.as_ref();
+ let len = data.len();
+
+ if len < field::LENGTH {
+ return Err(Error);
+ }
+
+ if self.option_type() == Type::Pad1 {
+ return Ok(());
+ }
+
+ if len == field::LENGTH {
+ return Err(Error);
+ }
+
+ let df = field::DATA(data[field::LENGTH]);
+
+ if len < df.end {
+ return Err(Error);
+ }
+
+ Ok(())
+ }
+
+ /// Consume the ipv6 option, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the option type.
+ #[inline]
+ pub fn option_type(&self) -> Type {
+ let data = self.buffer.as_ref();
+ Type::from(data[field::TYPE])
+ }
+
+ /// Return the length of the data.
+ ///
+ /// # Panics
+ /// This function panics if this is an 1-byte padding option.
+ #[inline]
+ pub fn data_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::LENGTH]
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Ipv6Option<&'a T> {
+ /// Return the option data.
+ ///
+ /// # Panics
+ /// This function panics if this is an 1-byte padding option.
+ #[inline]
+ pub fn data(&self) -> &'a [u8] {
+ let len = self.data_len();
+ let data = self.buffer.as_ref();
+ &data[field::DATA(len)]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Ipv6Option<T> {
+ /// Set the option type.
+ #[inline]
+ pub fn set_option_type(&mut self, value: Type) {
+ let data = self.buffer.as_mut();
+ data[field::TYPE] = value.into();
+ }
+
+ /// Set the option data length.
+ ///
+ /// # Panics
+ /// This function panics if this is an 1-byte padding option.
+ #[inline]
+ pub fn set_data_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::LENGTH] = value;
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> Ipv6Option<&'a mut T> {
+ /// Return a mutable pointer to the option data.
+ ///
+ /// # Panics
+ /// This function panics if this is an 1-byte padding option.
+ #[inline]
+ pub fn data_mut(&mut self) -> &mut [u8] {
+ let len = self.data_len();
+ let data = self.buffer.as_mut();
+ &mut data[field::DATA(len)]
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Ipv6Option<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => {
+ write!(f, "IPv6 Extension Option ({err})")?;
+ Ok(())
+ }
+ }
+ }
+}
+
+/// A high-level representation of an IPv6 Extension Header Option.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Repr<'a> {
+ Pad1,
+ PadN(u8),
+ #[cfg(feature = "proto-rpl")]
+ Rpl(RplHopByHopRepr),
+ Unknown {
+ type_: Type,
+ length: u8,
+ data: &'a [u8],
+ },
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an IPv6 Extension Header Option and return a high-level representation.
+ pub fn parse<T>(opt: &Ipv6Option<&'a T>) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ match opt.option_type() {
+ Type::Pad1 => Ok(Repr::Pad1),
+ Type::PadN => Ok(Repr::PadN(opt.data_len())),
+
+ #[cfg(feature = "proto-rpl")]
+ Type::Rpl => Ok(Repr::Rpl(RplHopByHopRepr::parse(
+ &RplHopByHopPacket::new_checked(opt.data())?,
+ ))),
+ #[cfg(not(feature = "proto-rpl"))]
+ Type::Rpl => Ok(Repr::Unknown {
+ type_: Type::Rpl,
+ length: opt.data_len(),
+ data: opt.data(),
+ }),
+
+ unknown_type @ Type::Unknown(_) => Ok(Repr::Unknown {
+ type_: unknown_type,
+ length: opt.data_len(),
+ data: opt.data(),
+ }),
+ }
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ match *self {
+ Repr::Pad1 => 1,
+ Repr::PadN(length) => field::DATA(length).end,
+ #[cfg(feature = "proto-rpl")]
+ Repr::Rpl(opt) => field::DATA(opt.buffer_len() as u8).end,
+ Repr::Unknown { length, .. } => field::DATA(length).end,
+ }
+ }
+
+ /// Emit a high-level representation into an IPv6 Extension Header Option.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, opt: &mut Ipv6Option<&'a mut T>) {
+ match *self {
+ Repr::Pad1 => opt.set_option_type(Type::Pad1),
+ Repr::PadN(len) => {
+ opt.set_option_type(Type::PadN);
+ opt.set_data_len(len);
+ // Ensure all padding bytes are set to zero.
+ for x in opt.data_mut().iter_mut() {
+ *x = 0
+ }
+ }
+ #[cfg(feature = "proto-rpl")]
+ Repr::Rpl(rpl) => {
+ opt.set_option_type(Type::Rpl);
+ opt.set_data_len(4);
+ rpl.emit(&mut crate::wire::RplHopByHopPacket::new_unchecked(
+ opt.data_mut(),
+ ));
+ }
+ Repr::Unknown {
+ type_,
+ length,
+ data,
+ } => {
+ opt.set_option_type(type_);
+ opt.set_data_len(length);
+ opt.data_mut().copy_from_slice(&data[..length as usize]);
+ }
+ }
+ }
+}
+
+/// A iterator for IPv6 options.
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ipv6OptionsIterator<'a> {
+ pos: usize,
+ length: usize,
+ data: &'a [u8],
+ hit_error: bool,
+}
+
+impl<'a> Ipv6OptionsIterator<'a> {
+ /// Create a new `Ipv6OptionsIterator`, used to iterate over the
+ /// options contained in a IPv6 Extension Header (e.g. the Hop-by-Hop
+ /// header).
+ pub fn new(data: &'a [u8]) -> Ipv6OptionsIterator<'a> {
+ let length = data.len();
+ Ipv6OptionsIterator {
+ pos: 0,
+ hit_error: false,
+ length,
+ data,
+ }
+ }
+}
+
+impl<'a> Iterator for Ipv6OptionsIterator<'a> {
+ type Item = Result<Repr<'a>>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.pos < self.length && !self.hit_error {
+ // If we still have data to parse and we have not previously
+ // hit an error, attempt to parse the next option.
+ match Ipv6Option::new_checked(&self.data[self.pos..]) {
+ Ok(hdr) => match Repr::parse(&hdr) {
+ Ok(repr) => {
+ self.pos += repr.buffer_len();
+ Some(Ok(repr))
+ }
+ Err(e) => {
+ self.hit_error = true;
+ Some(Err(e))
+ }
+ },
+ Err(e) => {
+ self.hit_error = true;
+ Some(Err(e))
+ }
+ }
+ } else {
+ // If we failed to parse a previous option or hit the end of the
+ // buffer, we do not continue to iterate.
+ None
+ }
+ }
+}
+
+impl<'a> fmt::Display for Repr<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "IPv6 Option ")?;
+ match *self {
+ Repr::Pad1 => write!(f, "{} ", Type::Pad1),
+ Repr::PadN(len) => write!(f, "{} length={} ", Type::PadN, len),
+ #[cfg(feature = "proto-rpl")]
+ Repr::Rpl(rpl) => write!(f, "{} {rpl}", Type::Rpl),
+ Repr::Unknown { type_, length, .. } => write!(f, "{type_} length={length} "),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ static IPV6OPTION_BYTES_PAD1: [u8; 1] = [0x0];
+ static IPV6OPTION_BYTES_PADN: [u8; 3] = [0x1, 0x1, 0x0];
+ static IPV6OPTION_BYTES_UNKNOWN: [u8; 5] = [0xff, 0x3, 0x0, 0x0, 0x0];
+ #[cfg(feature = "proto-rpl")]
+ static IPV6OPTION_BYTES_RPL: [u8; 6] = [0x63, 0x04, 0x00, 0x1e, 0x08, 0x00];
+
+ #[test]
+ fn test_check_len() {
+ let bytes = [0u8];
+ // zero byte buffer
+ assert_eq!(
+ Err(Error),
+ Ipv6Option::new_unchecked(&bytes[..0]).check_len()
+ );
+ // pad1
+ assert_eq!(
+ Ok(()),
+ Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1).check_len()
+ );
+
+ // padn with truncated data
+ assert_eq!(
+ Err(Error),
+ Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN[..2]).check_len()
+ );
+ // padn
+ assert_eq!(
+ Ok(()),
+ Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN).check_len()
+ );
+
+ // unknown option type with truncated data
+ assert_eq!(
+ Err(Error),
+ Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN[..4]).check_len()
+ );
+ assert_eq!(
+ Err(Error),
+ Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN[..1]).check_len()
+ );
+ // unknown type
+ assert_eq!(
+ Ok(()),
+ Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN).check_len()
+ );
+
+ #[cfg(feature = "proto-rpl")]
+ {
+ assert_eq!(
+ Ok(()),
+ Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_RPL).check_len()
+ );
+ }
+ }
+
+ #[test]
+ #[should_panic(expected = "index out of bounds")]
+ fn test_data_len() {
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1);
+ opt.data_len();
+ }
+
+ #[test]
+ fn test_option_deconstruct() {
+ // one octet of padding
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1);
+ assert_eq!(opt.option_type(), Type::Pad1);
+
+ // two octets of padding
+ let bytes: [u8; 2] = [0x1, 0x0];
+ let opt = Ipv6Option::new_unchecked(&bytes);
+ assert_eq!(opt.option_type(), Type::PadN);
+ assert_eq!(opt.data_len(), 0);
+
+ // three octets of padding
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN);
+ assert_eq!(opt.option_type(), Type::PadN);
+ assert_eq!(opt.data_len(), 1);
+ assert_eq!(opt.data(), &[0]);
+
+ // extra bytes in buffer
+ let bytes: [u8; 10] = [0x1, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff];
+ let opt = Ipv6Option::new_unchecked(&bytes);
+ assert_eq!(opt.option_type(), Type::PadN);
+ assert_eq!(opt.data_len(), 7);
+ assert_eq!(opt.data(), &[0, 0, 0, 0, 0, 0, 0]);
+
+ // unrecognized option
+ let bytes: [u8; 1] = [0xff];
+ let opt = Ipv6Option::new_unchecked(&bytes);
+ assert_eq!(opt.option_type(), Type::Unknown(255));
+
+ // unrecognized option without length and data
+ assert_eq!(Ipv6Option::new_checked(&bytes), Err(Error));
+
+ #[cfg(feature = "proto-rpl")]
+ {
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_RPL);
+ assert_eq!(opt.option_type(), Type::Rpl);
+ assert_eq!(opt.data_len(), 4);
+ assert_eq!(opt.data(), &[0x00, 0x1e, 0x08, 0x00]);
+ }
+ }
+
+ #[test]
+ fn test_option_parse() {
+ // one octet of padding
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PAD1);
+ let pad1 = Repr::parse(&opt).unwrap();
+ assert_eq!(pad1, Repr::Pad1);
+ assert_eq!(pad1.buffer_len(), 1);
+
+ // two or more octets of padding
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_PADN);
+ let padn = Repr::parse(&opt).unwrap();
+ assert_eq!(padn, Repr::PadN(1));
+ assert_eq!(padn.buffer_len(), 3);
+
+ // unrecognized option type
+ let data = [0u8; 3];
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_UNKNOWN);
+ let unknown = Repr::parse(&opt).unwrap();
+ assert_eq!(
+ unknown,
+ Repr::Unknown {
+ type_: Type::Unknown(255),
+ length: 3,
+ data: &data
+ }
+ );
+
+ #[cfg(feature = "proto-rpl")]
+ {
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_RPL);
+ let rpl = Repr::parse(&opt).unwrap();
+
+ assert_eq!(
+ rpl,
+ Repr::Rpl(crate::wire::RplHopByHopRepr {
+ down: false,
+ rank_error: false,
+ forwarding_error: false,
+ instance_id: crate::wire::RplInstanceId::from(0x1e),
+ sender_rank: 0x0800,
+ })
+ );
+ }
+ }
+
+ #[test]
+ fn test_option_emit() {
+ let repr = Repr::Pad1;
+ let mut bytes = [255u8; 1]; // don't assume bytes are initialized to zero
+ let mut opt = Ipv6Option::new_unchecked(&mut bytes);
+ repr.emit(&mut opt);
+ assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PAD1);
+
+ let repr = Repr::PadN(1);
+ let mut bytes = [255u8; 3]; // don't assume bytes are initialized to zero
+ let mut opt = Ipv6Option::new_unchecked(&mut bytes);
+ repr.emit(&mut opt);
+ assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_PADN);
+
+ let data = [0u8; 3];
+ let repr = Repr::Unknown {
+ type_: Type::Unknown(255),
+ length: 3,
+ data: &data,
+ };
+ let mut bytes = [254u8; 5]; // don't assume bytes are initialized to zero
+ let mut opt = Ipv6Option::new_unchecked(&mut bytes);
+ repr.emit(&mut opt);
+ assert_eq!(opt.into_inner(), &IPV6OPTION_BYTES_UNKNOWN);
+
+ #[cfg(feature = "proto-rpl")]
+ {
+ let opt = Ipv6Option::new_unchecked(&IPV6OPTION_BYTES_RPL);
+ let rpl = Repr::parse(&opt).unwrap();
+ let mut bytes = [0u8; 6];
+ rpl.emit(&mut Ipv6Option::new_unchecked(&mut bytes));
+
+ assert_eq!(&bytes, &IPV6OPTION_BYTES_RPL);
+ }
+ }
+
+ #[test]
+ fn test_failure_type() {
+ let mut failure_type: FailureType = Type::Pad1.into();
+ assert_eq!(failure_type, FailureType::Skip);
+ failure_type = Type::PadN.into();
+ assert_eq!(failure_type, FailureType::Skip);
+ failure_type = Type::Unknown(0b01000001).into();
+ assert_eq!(failure_type, FailureType::Discard);
+ failure_type = Type::Unknown(0b10100000).into();
+ assert_eq!(failure_type, FailureType::DiscardSendAll);
+ failure_type = Type::Unknown(0b11000100).into();
+ assert_eq!(failure_type, FailureType::DiscardSendUnicast);
+ }
+
+ #[test]
+ fn test_options_iter() {
+ let options = [
+ 0x00, 0x01, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x11, 0x00, 0x01,
+ 0x08, 0x00,
+ ];
+
+ let iterator = Ipv6OptionsIterator::new(&options);
+ for (i, opt) in iterator.enumerate() {
+ match (i, opt) {
+ (0, Ok(Repr::Pad1)) => continue,
+ (1, Ok(Repr::PadN(1))) => continue,
+ (2, Ok(Repr::PadN(2))) => continue,
+ (3, Ok(Repr::PadN(0))) => continue,
+ (4, Ok(Repr::Pad1)) => continue,
+ (
+ 5,
+ Ok(Repr::Unknown {
+ type_: Type::Unknown(0x11),
+ length: 0,
+ ..
+ }),
+ ) => continue,
+ (6, Err(Error)) => continue,
+ (i, res) => panic!("Unexpected option `{res:?}` at index {i}"),
+ }
+ }
+ }
+}
diff --git a/src/wire/ipv6routing.rs b/src/wire/ipv6routing.rs
new file mode 100644
index 0000000..a4943b7
--- /dev/null
+++ b/src/wire/ipv6routing.rs
@@ -0,0 +1,606 @@
+use super::{Error, Result};
+use core::fmt;
+
+use crate::wire::Ipv6Address as Address;
+
+enum_with_unknown! {
+ /// IPv6 Extension Routing Header Routing Type
+ pub enum Type(u8) {
+ /// Source Route (DEPRECATED)
+ ///
+ /// See https://tools.ietf.org/html/rfc5095 for details.
+ Type0 = 0,
+ /// Nimrod (DEPRECATED 2009-05-06)
+ Nimrod = 1,
+ /// Type 2 Routing Header for Mobile IPv6
+ ///
+ /// See https://tools.ietf.org/html/rfc6275#section-6.4 for details.
+ Type2 = 2,
+ /// RPL Source Routing Header
+ ///
+ /// See https://tools.ietf.org/html/rfc6554 for details.
+ Rpl = 3,
+ /// RFC3692-style Experiment 1
+ ///
+ /// See https://tools.ietf.org/html/rfc4727 for details.
+ Experiment1 = 253,
+ /// RFC3692-style Experiment 2
+ ///
+ /// See https://tools.ietf.org/html/rfc4727 for details.
+ Experiment2 = 254,
+ /// Reserved for future use
+ Reserved = 252
+ }
+}
+
+impl fmt::Display for Type {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Type::Type0 => write!(f, "Type0"),
+ Type::Nimrod => write!(f, "Nimrod"),
+ Type::Type2 => write!(f, "Type2"),
+ Type::Rpl => write!(f, "Rpl"),
+ Type::Experiment1 => write!(f, "Experiment1"),
+ Type::Experiment2 => write!(f, "Experiment2"),
+ Type::Reserved => write!(f, "Reserved"),
+ Type::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+/// A read/write wrapper around an IPv6 Routing Header buffer.
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Header<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+// Format of the Routing Header
+//
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Next Header | Hdr Ext Len | Routing Type | Segments Left |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// . .
+// . type-specific data .
+// . .
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+//
+// See https://tools.ietf.org/html/rfc8200#section-4.4 for details.
+//
+// **NOTE**: The fields start counting after the header length field.
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::*;
+
+ // Minimum size of the header.
+ pub const MIN_HEADER_SIZE: usize = 2;
+
+ // 8-bit identifier of a particular Routing header variant.
+ pub const TYPE: usize = 0;
+ // 8-bit unsigned integer. The number of route segments remaining.
+ pub const SEG_LEFT: usize = 1;
+
+ // The Type 2 Routing Header has the following format:
+ //
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Next Header | Hdr Ext Len=2 | Routing Type=2|Segments Left=1|
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Reserved |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | |
+ // + +
+ // | |
+ // + Home Address +
+ // | |
+ // + +
+ // | |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ // 16-byte field containing the home address of the destination mobile node.
+ pub const HOME_ADDRESS: Field = 6..22;
+
+ // The RPL Source Routing Header has the following format:
+ //
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Next Header | Hdr Ext Len | Routing Type | Segments Left |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | CmprI | CmprE | Pad | Reserved |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | |
+ // . .
+ // . Addresses[1..n] .
+ // . .
+ // | |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ // 8-bit field containing the CmprI and CmprE values.
+ pub const CMPR: usize = 2;
+ // 8-bit field containing the Pad value.
+ pub const PAD: usize = 3;
+ // Variable length field containing addresses
+ pub const ADDRESSES: usize = 6;
+}
+
+/// Core getter methods relevant to any routing type.
+impl<T: AsRef<[u8]>> Header<T> {
+ /// Create a raw octet buffer with an IPv6 Routing Header structure.
+ pub const fn new_unchecked(buffer: T) -> Header<T> {
+ Header { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Header<T>> {
+ let header = Self::new_unchecked(buffer);
+ header.check_len()?;
+ Ok(header)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_header_len].
+ ///
+ /// [set_header_len]: #method.set_header_len
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::MIN_HEADER_SIZE {
+ return Err(Error);
+ }
+
+ match self.routing_type() {
+ Type::Type2 if len < field::HOME_ADDRESS.end => return Err(Error),
+ Type::Rpl if len < field::ADDRESSES => return Err(Error),
+ _ => (),
+ }
+
+ Ok(())
+ }
+
+ /// Consume the header, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the routing type field.
+ #[inline]
+ pub fn routing_type(&self) -> Type {
+ let data = self.buffer.as_ref();
+ Type::from(data[field::TYPE])
+ }
+
+ /// Return the segments left field.
+ #[inline]
+ pub fn segments_left(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::SEG_LEFT]
+ }
+}
+
+/// Getter methods for the Type 2 Routing Header routing type.
+impl<T: AsRef<[u8]>> Header<T> {
+ /// Return the IPv6 Home Address
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the Type2 Routing Header routing type.
+ pub fn home_address(&self) -> Address {
+ let data = self.buffer.as_ref();
+ Address::from_bytes(&data[field::HOME_ADDRESS])
+ }
+}
+
+/// Getter methods for the RPL Source Routing Header routing type.
+impl<T: AsRef<[u8]>> Header<T> {
+ /// Return the number of prefix octets elided from addresses[1..n-1].
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn cmpr_i(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::CMPR] >> 4
+ }
+
+ /// Return the number of prefix octets elided from the last address (`addresses[n]`).
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn cmpr_e(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::CMPR] & 0xf
+ }
+
+ /// Return the number of octets used for padding after `addresses[n]`.
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn pad(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::PAD] >> 4
+ }
+
+ /// Return the address vector in bytes
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn addresses(&self) -> &[u8] {
+ let data = self.buffer.as_ref();
+ &data[field::ADDRESSES..]
+ }
+}
+
+/// Core setter methods relevant to any routing type.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
+ /// Set the routing type.
+ #[inline]
+ pub fn set_routing_type(&mut self, value: Type) {
+ let data = self.buffer.as_mut();
+ data[field::TYPE] = value.into();
+ }
+
+ /// Set the segments left field.
+ #[inline]
+ pub fn set_segments_left(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::SEG_LEFT] = value;
+ }
+
+ /// Initialize reserved fields to 0.
+ ///
+ /// # Panics
+ /// This function may panic if the routing type is not set.
+ #[inline]
+ pub fn clear_reserved(&mut self) {
+ let routing_type = self.routing_type();
+ let data = self.buffer.as_mut();
+
+ match routing_type {
+ Type::Type2 => {
+ data[4] = 0;
+ data[5] = 0;
+ data[6] = 0;
+ data[7] = 0;
+ }
+ Type::Rpl => {
+ // Retain the higher order 4 bits of the padding field
+ data[field::PAD] &= 0xF0;
+ data[4] = 0;
+ data[5] = 0;
+ }
+
+ _ => panic!("Unrecognized routing type when clearing reserved fields."),
+ }
+ }
+}
+
+/// Setter methods for the RPL Source Routing Header routing type.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
+ /// Set the Ipv6 Home Address
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the Type 2 Routing Header routing type.
+ pub fn set_home_address(&mut self, value: Address) {
+ let data = self.buffer.as_mut();
+ data[field::HOME_ADDRESS].copy_from_slice(value.as_bytes());
+ }
+}
+
+/// Setter methods for the RPL Source Routing Header routing type.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
+ /// Set the number of prefix octets elided from addresses[1..n-1].
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn set_cmpr_i(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ let raw = (value << 4) | (data[field::CMPR] & 0xF);
+ data[field::CMPR] = raw;
+ }
+
+ /// Set the number of prefix octets elided from the last address (`addresses[n]`).
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn set_cmpr_e(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ let raw = (value & 0xF) | (data[field::CMPR] & 0xF0);
+ data[field::CMPR] = raw;
+ }
+
+ /// Set the number of octets used for padding after `addresses[n]`.
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn set_pad(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::PAD] = value << 4;
+ }
+
+ /// Set address data
+ ///
+ /// # Panics
+ /// This function may panic if this header is not the RPL Source Routing Header routing type.
+ pub fn set_addresses(&mut self, value: &[u8]) {
+ let data = self.buffer.as_mut();
+ let addresses = &mut data[field::ADDRESSES..];
+ addresses.copy_from_slice(value);
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Header<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => {
+ write!(f, "IPv6 Routing ({err})")?;
+ Ok(())
+ }
+ }
+ }
+}
+
+/// A high-level representation of an IPv6 Routing Header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Repr<'a> {
+ Type2 {
+ /// Number of route segments remaining.
+ segments_left: u8,
+ /// The home address of the destination mobile node.
+ home_address: Address,
+ },
+ Rpl {
+ /// Number of route segments remaining.
+ segments_left: u8,
+ /// Number of prefix octets from each segment, except the last segment, that are elided.
+ cmpr_i: u8,
+ /// Number of prefix octets from the last segment that are elided.
+ cmpr_e: u8,
+ /// Number of octets that are used for padding after `address[n]` at the end of the
+ /// RPL Source Route Header.
+ pad: u8,
+ /// Vector of addresses, numbered 1 to `n`.
+ addresses: &'a [u8],
+ },
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an IPv6 Routing Header and return a high-level representation.
+ pub fn parse<T>(header: &'a Header<&'a T>) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ match header.routing_type() {
+ Type::Type2 => Ok(Repr::Type2 {
+ segments_left: header.segments_left(),
+ home_address: header.home_address(),
+ }),
+ Type::Rpl => Ok(Repr::Rpl {
+ segments_left: header.segments_left(),
+ cmpr_i: header.cmpr_i(),
+ cmpr_e: header.cmpr_e(),
+ pad: header.pad(),
+ addresses: header.addresses(),
+ }),
+
+ _ => Err(Error),
+ }
+ }
+
+ /// Return the length, in bytes, of a header that will be emitted from this high-level
+ /// representation.
+ pub const fn buffer_len(&self) -> usize {
+ match self {
+ // Routing Type + Segments Left + Reserved + Home Address
+ Repr::Type2 { home_address, .. } => 2 + 4 + home_address.as_bytes().len(),
+ Repr::Rpl { addresses, .. } => 2 + 4 + addresses.len(),
+ }
+ }
+
+ /// Emit a high-level representation into an IPv6 Routing Header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, header: &mut Header<&mut T>) {
+ match *self {
+ Repr::Type2 {
+ segments_left,
+ home_address,
+ } => {
+ header.set_routing_type(Type::Type2);
+ header.set_segments_left(segments_left);
+ header.clear_reserved();
+ header.set_home_address(home_address);
+ }
+ Repr::Rpl {
+ segments_left,
+ cmpr_i,
+ cmpr_e,
+ pad,
+ addresses,
+ } => {
+ header.set_routing_type(Type::Rpl);
+ header.set_segments_left(segments_left);
+ header.set_cmpr_i(cmpr_i);
+ header.set_cmpr_e(cmpr_e);
+ header.set_pad(pad);
+ header.clear_reserved();
+ header.set_addresses(addresses);
+ }
+ }
+ }
+}
+
+impl<'a> fmt::Display for Repr<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Repr::Type2 {
+ segments_left,
+ home_address,
+ } => {
+ write!(
+ f,
+ "IPv6 Routing type={} seg_left={} home_address={}",
+ Type::Type2,
+ segments_left,
+ home_address
+ )
+ }
+ Repr::Rpl {
+ segments_left,
+ cmpr_i,
+ cmpr_e,
+ pad,
+ ..
+ } => {
+ write!(
+ f,
+ "IPv6 Routing type={} seg_left={} cmpr_i={} cmpr_e={} pad={}",
+ Type::Rpl,
+ segments_left,
+ cmpr_i,
+ cmpr_e,
+ pad
+ )
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ // A Type 2 Routing Header
+ static BYTES_TYPE2: [u8; 22] = [
+ 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x1,
+ ];
+
+ // A representation of a Type 2 Routing header
+ static REPR_TYPE2: Repr = Repr::Type2 {
+ segments_left: 1,
+ home_address: Address::LOOPBACK,
+ };
+
+ // A Source Routing Header with full IPv6 addresses in bytes
+ static BYTES_SRH_FULL: [u8; 38] = [
+ 0x3, 0x2, 0x0, 0x0, 0x0, 0x0, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x2, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+ 0x3, 0x1,
+ ];
+
+ // A representation of a Source Routing Header with full IPv6 addresses
+ static REPR_SRH_FULL: Repr = Repr::Rpl {
+ segments_left: 2,
+ cmpr_i: 0,
+ cmpr_e: 0,
+ pad: 0,
+ addresses: &[
+ 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0xfd,
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x1,
+ ],
+ };
+
+ // A Source Routing Header with elided IPv6 addresses in bytes
+ static BYTES_SRH_ELIDED: [u8; 14] = [
+ 0x3, 0x2, 0xfe, 0x50, 0x0, 0x0, 0x2, 0x3, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+ ];
+
+ // A representation of a Source Routing Header with elided IPv6 addresses
+ static REPR_SRH_ELIDED: Repr = Repr::Rpl {
+ segments_left: 2,
+ cmpr_i: 15,
+ cmpr_e: 14,
+ pad: 5,
+ addresses: &[0x2, 0x3, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0],
+ };
+
+ #[test]
+ fn test_check_len() {
+ // less than min header size
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&BYTES_TYPE2[..3]).check_len()
+ );
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&BYTES_SRH_FULL[..3]).check_len()
+ );
+ assert_eq!(
+ Err(Error),
+ Header::new_unchecked(&BYTES_SRH_ELIDED[..3]).check_len()
+ );
+ // valid
+ assert_eq!(Ok(()), Header::new_unchecked(&BYTES_TYPE2[..]).check_len());
+ assert_eq!(
+ Ok(()),
+ Header::new_unchecked(&BYTES_SRH_FULL[..]).check_len()
+ );
+ assert_eq!(
+ Ok(()),
+ Header::new_unchecked(&BYTES_SRH_ELIDED[..]).check_len()
+ );
+ }
+
+ #[test]
+ fn test_header_deconstruct() {
+ let header = Header::new_unchecked(&BYTES_TYPE2[..]);
+ assert_eq!(header.routing_type(), Type::Type2);
+ assert_eq!(header.segments_left(), 1);
+ assert_eq!(header.home_address(), Address::LOOPBACK);
+
+ let header = Header::new_unchecked(&BYTES_SRH_FULL[..]);
+ assert_eq!(header.routing_type(), Type::Rpl);
+ assert_eq!(header.segments_left(), 2);
+ assert_eq!(header.addresses(), &BYTES_SRH_FULL[6..]);
+
+ let header = Header::new_unchecked(&BYTES_SRH_ELIDED[..]);
+ assert_eq!(header.routing_type(), Type::Rpl);
+ assert_eq!(header.segments_left(), 2);
+ assert_eq!(header.addresses(), &BYTES_SRH_ELIDED[6..]);
+ }
+
+ #[test]
+ fn test_repr_parse_valid() {
+ let header = Header::new_checked(&BYTES_TYPE2[..]).unwrap();
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(repr, REPR_TYPE2);
+
+ let header = Header::new_checked(&BYTES_SRH_FULL[..]).unwrap();
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(repr, REPR_SRH_FULL);
+
+ let header = Header::new_checked(&BYTES_SRH_ELIDED[..]).unwrap();
+ let repr = Repr::parse(&header).unwrap();
+ assert_eq!(repr, REPR_SRH_ELIDED);
+ }
+
+ #[test]
+ fn test_repr_emit() {
+ let mut bytes = [0u8; 22];
+ let mut header = Header::new_unchecked(&mut bytes[..]);
+ REPR_TYPE2.emit(&mut header);
+ assert_eq!(header.into_inner(), &BYTES_TYPE2[..]);
+
+ let mut bytes = [0u8; 38];
+ let mut header = Header::new_unchecked(&mut bytes[..]);
+ REPR_SRH_FULL.emit(&mut header);
+ assert_eq!(header.into_inner(), &BYTES_SRH_FULL[..]);
+
+ let mut bytes = [0u8; 14];
+ let mut header = Header::new_unchecked(&mut bytes[..]);
+ REPR_SRH_ELIDED.emit(&mut header);
+ assert_eq!(header.into_inner(), &BYTES_SRH_ELIDED[..]);
+ }
+
+ #[test]
+ fn test_buffer_len() {
+ assert_eq!(REPR_TYPE2.buffer_len(), 22);
+ assert_eq!(REPR_SRH_FULL.buffer_len(), 38);
+ assert_eq!(REPR_SRH_ELIDED.buffer_len(), 14);
+ }
+}
diff --git a/src/wire/mld.rs b/src/wire/mld.rs
new file mode 100644
index 0000000..18872b5
--- /dev/null
+++ b/src/wire/mld.rs
@@ -0,0 +1,578 @@
+// Packet implementation for the Multicast Listener Discovery
+// protocol. See [RFC 3810] and [RFC 2710].
+//
+// [RFC 3810]: https://tools.ietf.org/html/rfc3810
+// [RFC 2710]: https://tools.ietf.org/html/rfc2710
+
+use byteorder::{ByteOrder, NetworkEndian};
+
+use super::{Error, Result};
+use crate::wire::icmpv6::{field, Message, Packet};
+use crate::wire::Ipv6Address;
+
+enum_with_unknown! {
+ /// MLDv2 Multicast Listener Report Record Type. See [RFC 3810 § 5.2.12] for
+ /// more details.
+ ///
+ /// [RFC 3810 § 5.2.12]: https://tools.ietf.org/html/rfc3010#section-5.2.12
+ pub enum RecordType(u8) {
+ /// Interface has a filter mode of INCLUDE for the specified multicast address.
+ ModeIsInclude = 0x01,
+ /// Interface has a filter mode of EXCLUDE for the specified multicast address.
+ ModeIsExclude = 0x02,
+ /// Interface has changed to a filter mode of INCLUDE for the specified
+ /// multicast address.
+ ChangeToInclude = 0x03,
+ /// Interface has changed to a filter mode of EXCLUDE for the specified
+ /// multicast address.
+ ChangeToExclude = 0x04,
+ /// Interface wishes to listen to the sources in the specified list.
+ AllowNewSources = 0x05,
+ /// Interface no longer wishes to listen to the sources in the specified list.
+ BlockOldSources = 0x06
+ }
+}
+
+/// Getters for the Multicast Listener Query message header.
+/// See [RFC 3810 § 5.1].
+///
+/// [RFC 3810 § 5.1]: https://tools.ietf.org/html/rfc3010#section-5.1
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the maximum response code field.
+ #[inline]
+ pub fn max_resp_code(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::MAX_RESP_CODE])
+ }
+
+ /// Return the address being queried.
+ #[inline]
+ pub fn mcast_addr(&self) -> Ipv6Address {
+ let data = self.buffer.as_ref();
+ Ipv6Address::from_bytes(&data[field::QUERY_MCAST_ADDR])
+ }
+
+ /// Return the Suppress Router-Side Processing flag.
+ #[inline]
+ pub fn s_flag(&self) -> bool {
+ let data = self.buffer.as_ref();
+ (data[field::SQRV] & 0x08) != 0
+ }
+
+ /// Return the Querier's Robustness Variable.
+ #[inline]
+ pub fn qrv(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::SQRV] & 0x7
+ }
+
+ /// Return the Querier's Query Interval Code.
+ #[inline]
+ pub fn qqic(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::QQIC]
+ }
+
+ /// Return number of sources.
+ #[inline]
+ pub fn num_srcs(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::QUERY_NUM_SRCS])
+ }
+}
+
+/// Getters for the Multicast Listener Report message header.
+/// See [RFC 3810 § 5.2].
+///
+/// [RFC 3810 § 5.2]: https://tools.ietf.org/html/rfc3010#section-5.2
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the number of Multicast Address Records.
+ #[inline]
+ pub fn nr_mcast_addr_rcrds(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::NR_MCAST_RCRDS])
+ }
+}
+
+/// Setters for the Multicast Listener Query message header.
+/// See [RFC 3810 § 5.1].
+///
+/// [RFC 3810 § 5.1]: https://tools.ietf.org/html/rfc3010#section-5.1
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the maximum response code field.
+ #[inline]
+ pub fn set_max_resp_code(&mut self, code: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::MAX_RESP_CODE], code);
+ }
+
+ /// Set the address being queried.
+ #[inline]
+ pub fn set_mcast_addr(&mut self, addr: Ipv6Address) {
+ let data = self.buffer.as_mut();
+ data[field::QUERY_MCAST_ADDR].copy_from_slice(addr.as_bytes());
+ }
+
+ /// Set the Suppress Router-Side Processing flag.
+ #[inline]
+ pub fn set_s_flag(&mut self) {
+ let data = self.buffer.as_mut();
+ let current = data[field::SQRV];
+ data[field::SQRV] = 0x8 | (current & 0x7);
+ }
+
+ /// Clear the Suppress Router-Side Processing flag.
+ #[inline]
+ pub fn clear_s_flag(&mut self) {
+ let data = self.buffer.as_mut();
+ data[field::SQRV] &= 0x7;
+ }
+
+ /// Set the Querier's Robustness Variable.
+ #[inline]
+ pub fn set_qrv(&mut self, value: u8) {
+ assert!(value < 8);
+ let data = self.buffer.as_mut();
+ data[field::SQRV] = (data[field::SQRV] & 0x8) | value & 0x7;
+ }
+
+ /// Set the Querier's Query Interval Code.
+ #[inline]
+ pub fn set_qqic(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::QQIC] = value;
+ }
+
+ /// Set number of sources.
+ #[inline]
+ pub fn set_num_srcs(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::QUERY_NUM_SRCS], value);
+ }
+}
+
+/// Setters for the Multicast Listener Report message header.
+/// See [RFC 3810 § 5.2].
+///
+/// [RFC 3810 § 5.2]: https://tools.ietf.org/html/rfc3010#section-5.2
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the number of Multicast Address Records.
+ #[inline]
+ pub fn set_nr_mcast_addr_rcrds(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::NR_MCAST_RCRDS], value)
+ }
+}
+
+/// A read/write wrapper around an MLDv2 Listener Report Message Address Record.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct AddressRecord<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+impl<T: AsRef<[u8]>> AddressRecord<T> {
+ /// Imbue a raw octet buffer with a Address Record structure.
+ pub const fn new_unchecked(buffer: T) -> Self {
+ Self { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error::Truncated)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::RECORD_MCAST_ADDR.end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+}
+
+/// Getters for a MLDv2 Listener Report Message Address Record.
+/// See [RFC 3810 § 5.2].
+///
+/// [RFC 3810 § 5.2]: https://tools.ietf.org/html/rfc3010#section-5.2
+impl<T: AsRef<[u8]>> AddressRecord<T> {
+ /// Return the record type for the given sources.
+ #[inline]
+ pub fn record_type(&self) -> RecordType {
+ let data = self.buffer.as_ref();
+ RecordType::from(data[field::RECORD_TYPE])
+ }
+
+ /// Return the length of the auxiliary data.
+ #[inline]
+ pub fn aux_data_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::AUX_DATA_LEN]
+ }
+
+ /// Return the number of sources field.
+ #[inline]
+ pub fn num_srcs(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::RECORD_NUM_SRCS])
+ }
+
+ /// Return the multicast address field.
+ #[inline]
+ pub fn mcast_addr(&self) -> Ipv6Address {
+ let data = self.buffer.as_ref();
+ Ipv6Address::from_bytes(&data[field::RECORD_MCAST_ADDR])
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> AddressRecord<&'a T> {
+ /// Return a pointer to the address records.
+ #[inline]
+ pub fn payload(&self) -> &'a [u8] {
+ let data = self.buffer.as_ref();
+ &data[field::RECORD_MCAST_ADDR.end..]
+ }
+}
+
+/// Setters for a MLDv2 Listener Report Message Address Record.
+/// See [RFC 3810 § 5.2].
+///
+/// [RFC 3810 § 5.2]: https://tools.ietf.org/html/rfc3010#section-5.2
+impl<T: AsMut<[u8]> + AsRef<[u8]>> AddressRecord<T> {
+ /// Return the record type for the given sources.
+ #[inline]
+ pub fn set_record_type(&mut self, rty: RecordType) {
+ let data = self.buffer.as_mut();
+ data[field::RECORD_TYPE] = rty.into();
+ }
+
+ /// Return the length of the auxiliary data.
+ #[inline]
+ pub fn set_aux_data_len(&mut self, len: u8) {
+ let data = self.buffer.as_mut();
+ data[field::AUX_DATA_LEN] = len;
+ }
+
+ /// Return the number of sources field.
+ #[inline]
+ pub fn set_num_srcs(&mut self, num_srcs: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::RECORD_NUM_SRCS], num_srcs);
+ }
+
+ /// Return the multicast address field.
+ ///
+ /// # Panics
+ /// This function panics if the given address is not a multicast address.
+ #[inline]
+ pub fn set_mcast_addr(&mut self, addr: Ipv6Address) {
+ assert!(addr.is_multicast());
+ let data = self.buffer.as_mut();
+ data[field::RECORD_MCAST_ADDR].copy_from_slice(addr.as_bytes());
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> AddressRecord<T> {
+ /// Return a pointer to the address records.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let data = self.buffer.as_mut();
+ &mut data[field::RECORD_MCAST_ADDR.end..]
+ }
+}
+
+/// A high-level representation of an MLDv2 packet header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Repr<'a> {
+ Query {
+ max_resp_code: u16,
+ mcast_addr: Ipv6Address,
+ s_flag: bool,
+ qrv: u8,
+ qqic: u8,
+ num_srcs: u16,
+ data: &'a [u8],
+ },
+ Report {
+ nr_mcast_addr_rcrds: u16,
+ data: &'a [u8],
+ },
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an MLDv2 packet and return a high-level representation.
+ pub fn parse<T>(packet: &Packet<&'a T>) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ match packet.msg_type() {
+ Message::MldQuery => Ok(Repr::Query {
+ max_resp_code: packet.max_resp_code(),
+ mcast_addr: packet.mcast_addr(),
+ s_flag: packet.s_flag(),
+ qrv: packet.qrv(),
+ qqic: packet.qqic(),
+ num_srcs: packet.num_srcs(),
+ data: packet.payload(),
+ }),
+ Message::MldReport => Ok(Repr::Report {
+ nr_mcast_addr_rcrds: packet.nr_mcast_addr_rcrds(),
+ data: packet.payload(),
+ }),
+ _ => Err(Error),
+ }
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ match self {
+ Repr::Query { data, .. } => field::QUERY_NUM_SRCS.end + data.len(),
+ Repr::Report { data, .. } => field::NR_MCAST_RCRDS.end + data.len(),
+ }
+ }
+
+ /// Emit a high-level representation into an MLDv2 packet.
+ pub fn emit<T>(&self, packet: &mut Packet<&mut T>)
+ where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ match self {
+ Repr::Query {
+ max_resp_code,
+ mcast_addr,
+ s_flag,
+ qrv,
+ qqic,
+ num_srcs,
+ data,
+ } => {
+ packet.set_msg_type(Message::MldQuery);
+ packet.set_msg_code(0);
+ packet.clear_reserved();
+ packet.set_max_resp_code(*max_resp_code);
+ packet.set_mcast_addr(*mcast_addr);
+ if *s_flag {
+ packet.set_s_flag();
+ } else {
+ packet.clear_s_flag();
+ }
+ packet.set_qrv(*qrv);
+ packet.set_qqic(*qqic);
+ packet.set_num_srcs(*num_srcs);
+ packet.payload_mut().copy_from_slice(&data[..]);
+ }
+ Repr::Report {
+ nr_mcast_addr_rcrds,
+ data,
+ } => {
+ packet.set_msg_type(Message::MldReport);
+ packet.set_msg_code(0);
+ packet.clear_reserved();
+ packet.set_nr_mcast_addr_rcrds(*nr_mcast_addr_rcrds);
+ packet.payload_mut().copy_from_slice(&data[..]);
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::phy::ChecksumCapabilities;
+ use crate::wire::icmpv6::Message;
+ use crate::wire::Icmpv6Repr;
+
+ static QUERY_PACKET_BYTES: [u8; 44] = [
+ 0x82, 0x00, 0x73, 0x74, 0x04, 0x00, 0x00, 0x00, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0a, 0x12, 0x00, 0x01, 0xff, 0x02,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+ ];
+
+ static QUERY_PACKET_PAYLOAD: [u8; 16] = [
+ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x02,
+ ];
+
+ static REPORT_PACKET_BYTES: [u8; 44] = [
+ 0x8f, 0x00, 0x73, 0x85, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0xff, 0x02, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0x02,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+ ];
+
+ static REPORT_PACKET_PAYLOAD: [u8; 36] = [
+ 0x01, 0x00, 0x00, 0x01, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+ ];
+
+ fn create_repr<'a>(ty: Message) -> Icmpv6Repr<'a> {
+ match ty {
+ Message::MldQuery => Icmpv6Repr::Mld(Repr::Query {
+ max_resp_code: 0x400,
+ mcast_addr: Ipv6Address::LINK_LOCAL_ALL_NODES,
+ s_flag: true,
+ qrv: 0x02,
+ qqic: 0x12,
+ num_srcs: 0x01,
+ data: &QUERY_PACKET_PAYLOAD,
+ }),
+ Message::MldReport => Icmpv6Repr::Mld(Repr::Report {
+ nr_mcast_addr_rcrds: 1,
+ data: &REPORT_PACKET_PAYLOAD,
+ }),
+ _ => {
+ panic!("Message type must be a MLDv2 message type");
+ }
+ }
+ }
+
+ #[test]
+ fn test_query_deconstruct() {
+ let packet = Packet::new_unchecked(&QUERY_PACKET_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::MldQuery);
+ assert_eq!(packet.msg_code(), 0);
+ assert_eq!(packet.checksum(), 0x7374);
+ assert_eq!(packet.max_resp_code(), 0x0400);
+ assert_eq!(packet.mcast_addr(), Ipv6Address::LINK_LOCAL_ALL_NODES);
+ assert!(packet.s_flag());
+ assert_eq!(packet.qrv(), 0x02);
+ assert_eq!(packet.qqic(), 0x12);
+ assert_eq!(packet.num_srcs(), 0x01);
+ assert_eq!(
+ Ipv6Address::from_bytes(packet.payload()),
+ Ipv6Address::LINK_LOCAL_ALL_ROUTERS
+ );
+ }
+
+ #[test]
+ fn test_query_construct() {
+ let mut bytes = vec![0xff; 44];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ packet.set_msg_type(Message::MldQuery);
+ packet.set_msg_code(0);
+ packet.set_max_resp_code(0x0400);
+ packet.set_mcast_addr(Ipv6Address::LINK_LOCAL_ALL_NODES);
+ packet.set_s_flag();
+ packet.set_qrv(0x02);
+ packet.set_qqic(0x12);
+ packet.set_num_srcs(0x01);
+ packet
+ .payload_mut()
+ .copy_from_slice(Ipv6Address::LINK_LOCAL_ALL_ROUTERS.as_bytes());
+ packet.clear_reserved();
+ packet.fill_checksum(
+ &Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
+ &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
+ );
+ assert_eq!(&*packet.into_inner(), &QUERY_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_record_deconstruct() {
+ let packet = Packet::new_unchecked(&REPORT_PACKET_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::MldReport);
+ assert_eq!(packet.msg_code(), 0);
+ assert_eq!(packet.checksum(), 0x7385);
+ assert_eq!(packet.nr_mcast_addr_rcrds(), 0x01);
+ let addr_rcrd = AddressRecord::new_unchecked(packet.payload());
+ assert_eq!(addr_rcrd.record_type(), RecordType::ModeIsInclude);
+ assert_eq!(addr_rcrd.aux_data_len(), 0x00);
+ assert_eq!(addr_rcrd.num_srcs(), 0x01);
+ assert_eq!(addr_rcrd.mcast_addr(), Ipv6Address::LINK_LOCAL_ALL_NODES);
+ assert_eq!(
+ Ipv6Address::from_bytes(addr_rcrd.payload()),
+ Ipv6Address::LINK_LOCAL_ALL_ROUTERS
+ );
+ }
+
+ #[test]
+ fn test_record_construct() {
+ let mut bytes = vec![0xff; 44];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ packet.set_msg_type(Message::MldReport);
+ packet.set_msg_code(0);
+ packet.clear_reserved();
+ packet.set_nr_mcast_addr_rcrds(1);
+ {
+ let mut addr_rcrd = AddressRecord::new_unchecked(packet.payload_mut());
+ addr_rcrd.set_record_type(RecordType::ModeIsInclude);
+ addr_rcrd.set_aux_data_len(0);
+ addr_rcrd.set_num_srcs(1);
+ addr_rcrd.set_mcast_addr(Ipv6Address::LINK_LOCAL_ALL_NODES);
+ addr_rcrd
+ .payload_mut()
+ .copy_from_slice(Ipv6Address::LINK_LOCAL_ALL_ROUTERS.as_bytes());
+ }
+ packet.fill_checksum(
+ &Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
+ &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
+ );
+ assert_eq!(&*packet.into_inner(), &REPORT_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_query_repr_parse() {
+ let packet = Packet::new_unchecked(&QUERY_PACKET_BYTES[..]);
+ let repr = Icmpv6Repr::parse(
+ &Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
+ &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
+ &packet,
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(repr, Ok(create_repr(Message::MldQuery)));
+ }
+
+ #[test]
+ fn test_report_repr_parse() {
+ let packet = Packet::new_unchecked(&REPORT_PACKET_BYTES[..]);
+ let repr = Icmpv6Repr::parse(
+ &Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
+ &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
+ &packet,
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(repr, Ok(create_repr(Message::MldReport)));
+ }
+
+ #[test]
+ fn test_query_repr_emit() {
+ let mut bytes = [0x2a; 44];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ let repr = create_repr(Message::MldQuery);
+ repr.emit(
+ &Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
+ &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
+ &mut packet,
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(&*packet.into_inner(), &QUERY_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_report_repr_emit() {
+ let mut bytes = [0x2a; 44];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ let repr = create_repr(Message::MldReport);
+ repr.emit(
+ &Ipv6Address::LINK_LOCAL_ALL_NODES.into(),
+ &Ipv6Address::LINK_LOCAL_ALL_ROUTERS.into(),
+ &mut packet,
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(&*packet.into_inner(), &REPORT_PACKET_BYTES[..]);
+ }
+}
diff --git a/src/wire/mod.rs b/src/wire/mod.rs
new file mode 100644
index 0000000..5aed2d4
--- /dev/null
+++ b/src/wire/mod.rs
@@ -0,0 +1,524 @@
+/*! Low-level packet access and construction.
+
+The `wire` module deals with the packet *representation*. It provides two levels
+of functionality.
+
+ * First, it provides functions to extract fields from sequences of octets,
+ and to insert fields into sequences of octets. This happens `Packet` family of
+ structures, e.g. [EthernetFrame] or [Ipv4Packet].
+ * Second, in cases where the space of valid field values is much smaller than the space
+ of possible field values, it provides a compact, high-level representation
+ of packet data that can be parsed from and emitted into a sequence of octets.
+ This happens through the `Repr` family of structs and enums, e.g. [ArpRepr] or [Ipv4Repr].
+
+[EthernetFrame]: struct.EthernetFrame.html
+[Ipv4Packet]: struct.Ipv4Packet.html
+[ArpRepr]: enum.ArpRepr.html
+[Ipv4Repr]: struct.Ipv4Repr.html
+
+The functions in the `wire` module are designed for use together with `-Cpanic=abort`.
+
+The `Packet` family of data structures guarantees that, if the `Packet::check_len()` method
+returned `Ok(())`, then no accessor or setter method will panic; however, the guarantee
+provided by `Packet::check_len()` may no longer hold after changing certain fields,
+which are listed in the documentation for the specific packet.
+
+The `Packet::new_checked` method is a shorthand for a combination of `Packet::new_unchecked`
+and `Packet::check_len`.
+When parsing untrusted input, it is *necessary* to use `Packet::new_checked()`;
+so long as the buffer is not modified, no accessor will fail.
+When emitting output, though, it is *incorrect* to use `Packet::new_checked()`;
+the length check is likely to succeed on a zeroed buffer, but fail on a buffer
+filled with data from a previous packet, such as when reusing buffers, resulting
+in nondeterministic panics with some network devices but not others.
+The buffer length for emission is not calculated by the `Packet` layer.
+
+In the `Repr` family of data structures, the `Repr::parse()` method never panics
+as long as `Packet::new_checked()` (or `Packet::check_len()`) has succeeded, and
+the `Repr::emit()` method never panics as long as the underlying buffer is exactly
+`Repr::buffer_len()` octets long.
+
+# Examples
+
+To emit an IP packet header into an octet buffer, and then parse it back:
+
+```rust
+# #[cfg(feature = "proto-ipv4")]
+# {
+use smoltcp::phy::ChecksumCapabilities;
+use smoltcp::wire::*;
+let repr = Ipv4Repr {
+ src_addr: Ipv4Address::new(10, 0, 0, 1),
+ dst_addr: Ipv4Address::new(10, 0, 0, 2),
+ next_header: IpProtocol::Tcp,
+ payload_len: 10,
+ hop_limit: 64,
+};
+let mut buffer = vec![0; repr.buffer_len() + repr.payload_len];
+{ // emission
+ let mut packet = Ipv4Packet::new_unchecked(&mut buffer);
+ repr.emit(&mut packet, &ChecksumCapabilities::default());
+}
+{ // parsing
+ let packet = Ipv4Packet::new_checked(&buffer)
+ .expect("truncated packet");
+ let parsed = Ipv4Repr::parse(&packet, &ChecksumCapabilities::default())
+ .expect("malformed packet");
+ assert_eq!(repr, parsed);
+}
+# }
+```
+*/
+
+mod field {
+ pub type Field = ::core::ops::Range<usize>;
+ pub type Rest = ::core::ops::RangeFrom<usize>;
+}
+
+pub mod pretty_print;
+
+#[cfg(all(feature = "proto-ipv4", feature = "medium-ethernet"))]
+mod arp;
+#[cfg(feature = "proto-dhcpv4")]
+pub(crate) mod dhcpv4;
+#[cfg(feature = "proto-dns")]
+pub(crate) mod dns;
+#[cfg(feature = "medium-ethernet")]
+mod ethernet;
+#[cfg(any(feature = "proto-ipv4", feature = "proto-ipv6"))]
+mod icmp;
+#[cfg(feature = "proto-ipv4")]
+mod icmpv4;
+#[cfg(feature = "proto-ipv6")]
+mod icmpv6;
+#[cfg(feature = "medium-ieee802154")]
+pub mod ieee802154;
+#[cfg(feature = "proto-igmp")]
+mod igmp;
+pub(crate) mod ip;
+#[cfg(feature = "proto-ipv4")]
+mod ipv4;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6ext_header;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6fragment;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6hbh;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6option;
+#[cfg(feature = "proto-ipv6")]
+mod ipv6routing;
+#[cfg(feature = "proto-ipv6")]
+mod mld;
+#[cfg(all(
+ feature = "proto-ipv6",
+ any(feature = "medium-ethernet", feature = "medium-ieee802154")
+))]
+mod ndisc;
+#[cfg(all(
+ feature = "proto-ipv6",
+ any(feature = "medium-ethernet", feature = "medium-ieee802154")
+))]
+mod ndiscoption;
+#[cfg(feature = "proto-rpl")]
+mod rpl;
+#[cfg(all(feature = "proto-sixlowpan", feature = "medium-ieee802154"))]
+mod sixlowpan;
+mod tcp;
+mod udp;
+
+#[cfg(feature = "proto-ipsec-ah")]
+mod ipsec_ah;
+
+#[cfg(feature = "proto-ipsec-esp")]
+mod ipsec_esp;
+
+use core::fmt;
+
+use crate::phy::Medium;
+
+pub use self::pretty_print::PrettyPrinter;
+
+#[cfg(feature = "medium-ethernet")]
+pub use self::ethernet::{
+ Address as EthernetAddress, EtherType as EthernetProtocol, Frame as EthernetFrame,
+ Repr as EthernetRepr, HEADER_LEN as ETHERNET_HEADER_LEN,
+};
+
+#[cfg(all(feature = "proto-ipv4", feature = "medium-ethernet"))]
+pub use self::arp::{
+ Hardware as ArpHardware, Operation as ArpOperation, Packet as ArpPacket, Repr as ArpRepr,
+};
+
+#[cfg(feature = "proto-rpl")]
+pub use self::rpl::{
+ data::HopByHopOption as RplHopByHopRepr, data::Packet as RplHopByHopPacket,
+ options::Packet as RplOptionPacket, options::Repr as RplOptionRepr,
+ InstanceId as RplInstanceId, Repr as RplRepr,
+};
+
+#[cfg(all(feature = "proto-sixlowpan", feature = "medium-ieee802154"))]
+pub use self::sixlowpan::{
+ frag::{Key as SixlowpanFragKey, Packet as SixlowpanFragPacket, Repr as SixlowpanFragRepr},
+ iphc::{Packet as SixlowpanIphcPacket, Repr as SixlowpanIphcRepr},
+ nhc::{
+ ExtHeaderId as SixlowpanExtHeaderId, ExtHeaderPacket as SixlowpanExtHeaderPacket,
+ ExtHeaderRepr as SixlowpanExtHeaderRepr, NhcPacket as SixlowpanNhcPacket,
+ UdpNhcPacket as SixlowpanUdpNhcPacket, UdpNhcRepr as SixlowpanUdpNhcRepr,
+ },
+ AddressContext as SixlowpanAddressContext, NextHeader as SixlowpanNextHeader, SixlowpanPacket,
+};
+
+#[cfg(feature = "medium-ieee802154")]
+pub use self::ieee802154::{
+ Address as Ieee802154Address, AddressingMode as Ieee802154AddressingMode,
+ Frame as Ieee802154Frame, FrameType as Ieee802154FrameType,
+ FrameVersion as Ieee802154FrameVersion, Pan as Ieee802154Pan, Repr as Ieee802154Repr,
+};
+
+pub use self::ip::{
+ Address as IpAddress, Cidr as IpCidr, Endpoint as IpEndpoint,
+ ListenEndpoint as IpListenEndpoint, Protocol as IpProtocol, Repr as IpRepr,
+ Version as IpVersion,
+};
+
+#[cfg(feature = "proto-ipv4")]
+pub use self::ipv4::{
+ Address as Ipv4Address, Cidr as Ipv4Cidr, Key as Ipv4FragKey, Packet as Ipv4Packet,
+ Repr as Ipv4Repr, HEADER_LEN as IPV4_HEADER_LEN, MIN_MTU as IPV4_MIN_MTU,
+};
+
+#[cfg(feature = "proto-ipv6")]
+pub(crate) use self::ipv6::Scope as Ipv6AddressScope;
+#[cfg(feature = "proto-ipv6")]
+pub use self::ipv6::{
+ Address as Ipv6Address, Cidr as Ipv6Cidr, Packet as Ipv6Packet, Repr as Ipv6Repr,
+ HEADER_LEN as IPV6_HEADER_LEN, MIN_MTU as IPV6_MIN_MTU,
+};
+
+#[cfg(feature = "proto-ipv6")]
+pub use self::ipv6option::{
+ FailureType as Ipv6OptionFailureType, Ipv6Option, Ipv6OptionsIterator, Repr as Ipv6OptionRepr,
+ Type as Ipv6OptionType,
+};
+
+#[cfg(feature = "proto-ipv6")]
+pub use self::ipv6ext_header::{Header as Ipv6ExtHeader, Repr as Ipv6ExtHeaderRepr};
+
+#[cfg(feature = "proto-ipv6")]
+pub use self::ipv6fragment::{Header as Ipv6FragmentHeader, Repr as Ipv6FragmentRepr};
+
+#[cfg(feature = "proto-ipv6")]
+pub use self::ipv6hbh::{Header as Ipv6HopByHopHeader, Repr as Ipv6HopByHopRepr};
+
+#[cfg(feature = "proto-ipv6")]
+pub use self::ipv6routing::{
+ Header as Ipv6RoutingHeader, Repr as Ipv6RoutingRepr, Type as Ipv6RoutingType,
+};
+
+#[cfg(feature = "proto-ipv4")]
+pub use self::icmpv4::{
+ DstUnreachable as Icmpv4DstUnreachable, Message as Icmpv4Message, Packet as Icmpv4Packet,
+ ParamProblem as Icmpv4ParamProblem, Redirect as Icmpv4Redirect, Repr as Icmpv4Repr,
+ TimeExceeded as Icmpv4TimeExceeded,
+};
+
+#[cfg(feature = "proto-igmp")]
+pub use self::igmp::{IgmpVersion, Packet as IgmpPacket, Repr as IgmpRepr};
+
+#[cfg(feature = "proto-ipv6")]
+pub use self::icmpv6::{
+ DstUnreachable as Icmpv6DstUnreachable, Message as Icmpv6Message, Packet as Icmpv6Packet,
+ ParamProblem as Icmpv6ParamProblem, Repr as Icmpv6Repr, TimeExceeded as Icmpv6TimeExceeded,
+};
+
+#[cfg(any(feature = "proto-ipv4", feature = "proto-ipv6"))]
+pub use self::icmp::Repr as IcmpRepr;
+
+#[cfg(all(
+ feature = "proto-ipv6",
+ any(feature = "medium-ethernet", feature = "medium-ieee802154")
+))]
+pub use self::ndisc::{
+ NeighborFlags as NdiscNeighborFlags, Repr as NdiscRepr, RouterFlags as NdiscRouterFlags,
+};
+
+#[cfg(all(
+ feature = "proto-ipv6",
+ any(feature = "medium-ethernet", feature = "medium-ieee802154")
+))]
+pub use self::ndiscoption::{
+ NdiscOption, PrefixInfoFlags as NdiscPrefixInfoFlags,
+ PrefixInformation as NdiscPrefixInformation, RedirectedHeader as NdiscRedirectedHeader,
+ Repr as NdiscOptionRepr, Type as NdiscOptionType,
+};
+
+#[cfg(feature = "proto-ipv6")]
+pub use self::mld::{AddressRecord as MldAddressRecord, Repr as MldRepr};
+
+pub use self::udp::{Packet as UdpPacket, Repr as UdpRepr, HEADER_LEN as UDP_HEADER_LEN};
+
+pub use self::tcp::{
+ Control as TcpControl, Packet as TcpPacket, Repr as TcpRepr, SeqNumber as TcpSeqNumber,
+ TcpOption, HEADER_LEN as TCP_HEADER_LEN,
+};
+
+#[cfg(feature = "proto-dhcpv4")]
+pub use self::dhcpv4::{
+ DhcpOption, DhcpOptionWriter, MessageType as DhcpMessageType, Packet as DhcpPacket,
+ Repr as DhcpRepr, CLIENT_PORT as DHCP_CLIENT_PORT,
+ MAX_DNS_SERVER_COUNT as DHCP_MAX_DNS_SERVER_COUNT, SERVER_PORT as DHCP_SERVER_PORT,
+};
+
+#[cfg(feature = "proto-dns")]
+pub use self::dns::{
+ Flags as DnsFlags, Opcode as DnsOpcode, Packet as DnsPacket, Rcode as DnsRcode,
+ Repr as DnsRepr, Type as DnsQueryType,
+};
+
+#[cfg(feature = "proto-ipsec-ah")]
+pub use self::ipsec_ah::{Packet as IpSecAuthHeaderPacket, Repr as IpSecAuthHeaderRepr};
+
+#[cfg(feature = "proto-ipsec-esp")]
+pub use self::ipsec_esp::{Packet as IpSecEspPacket, Repr as IpSecEspRepr};
+
+/// Parsing a packet failed.
+///
+/// Either it is malformed, or it is not supported by smoltcp.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Error;
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "wire::Error")
+ }
+}
+
+pub type Result<T> = core::result::Result<T, Error>;
+
+/// Representation of an hardware address, such as an Ethernet address or an IEEE802.15.4 address.
+#[cfg(any(
+ feature = "medium-ip",
+ feature = "medium-ethernet",
+ feature = "medium-ieee802154"
+))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum HardwareAddress {
+ #[cfg(feature = "medium-ip")]
+ Ip,
+ #[cfg(feature = "medium-ethernet")]
+ Ethernet(EthernetAddress),
+ #[cfg(feature = "medium-ieee802154")]
+ Ieee802154(Ieee802154Address),
+}
+
+#[cfg(any(
+ feature = "medium-ip",
+ feature = "medium-ethernet",
+ feature = "medium-ieee802154"
+))]
+impl HardwareAddress {
+ pub const fn as_bytes(&self) -> &[u8] {
+ match self {
+ #[cfg(feature = "medium-ip")]
+ HardwareAddress::Ip => unreachable!(),
+ #[cfg(feature = "medium-ethernet")]
+ HardwareAddress::Ethernet(addr) => addr.as_bytes(),
+ #[cfg(feature = "medium-ieee802154")]
+ HardwareAddress::Ieee802154(addr) => addr.as_bytes(),
+ }
+ }
+
+ /// Query whether the address is an unicast address.
+ pub fn is_unicast(&self) -> bool {
+ match self {
+ #[cfg(feature = "medium-ip")]
+ HardwareAddress::Ip => unreachable!(),
+ #[cfg(feature = "medium-ethernet")]
+ HardwareAddress::Ethernet(addr) => addr.is_unicast(),
+ #[cfg(feature = "medium-ieee802154")]
+ HardwareAddress::Ieee802154(addr) => addr.is_unicast(),
+ }
+ }
+
+ /// Query whether the address is a broadcast address.
+ pub fn is_broadcast(&self) -> bool {
+ match self {
+ #[cfg(feature = "medium-ip")]
+ HardwareAddress::Ip => unreachable!(),
+ #[cfg(feature = "medium-ethernet")]
+ HardwareAddress::Ethernet(addr) => addr.is_broadcast(),
+ #[cfg(feature = "medium-ieee802154")]
+ HardwareAddress::Ieee802154(addr) => addr.is_broadcast(),
+ }
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ pub(crate) fn ethernet_or_panic(&self) -> EthernetAddress {
+ match self {
+ HardwareAddress::Ethernet(addr) => *addr,
+ #[allow(unreachable_patterns)]
+ _ => panic!("HardwareAddress is not Ethernet."),
+ }
+ }
+
+ #[cfg(feature = "medium-ieee802154")]
+ pub(crate) fn ieee802154_or_panic(&self) -> Ieee802154Address {
+ match self {
+ HardwareAddress::Ieee802154(addr) => *addr,
+ #[allow(unreachable_patterns)]
+ _ => panic!("HardwareAddress is not Ethernet."),
+ }
+ }
+
+ #[inline]
+ pub(crate) fn medium(&self) -> Medium {
+ match self {
+ #[cfg(feature = "medium-ip")]
+ HardwareAddress::Ip => Medium::Ip,
+ #[cfg(feature = "medium-ethernet")]
+ HardwareAddress::Ethernet(_) => Medium::Ethernet,
+ #[cfg(feature = "medium-ieee802154")]
+ HardwareAddress::Ieee802154(_) => Medium::Ieee802154,
+ }
+ }
+}
+
+#[cfg(any(
+ feature = "medium-ip",
+ feature = "medium-ethernet",
+ feature = "medium-ieee802154"
+))]
+impl core::fmt::Display for HardwareAddress {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self {
+ #[cfg(feature = "medium-ip")]
+ HardwareAddress::Ip => write!(f, "no hardware addr"),
+ #[cfg(feature = "medium-ethernet")]
+ HardwareAddress::Ethernet(addr) => write!(f, "{addr}"),
+ #[cfg(feature = "medium-ieee802154")]
+ HardwareAddress::Ieee802154(addr) => write!(f, "{addr}"),
+ }
+ }
+}
+
+#[cfg(feature = "medium-ethernet")]
+impl From<EthernetAddress> for HardwareAddress {
+ fn from(addr: EthernetAddress) -> Self {
+ HardwareAddress::Ethernet(addr)
+ }
+}
+
+#[cfg(feature = "medium-ieee802154")]
+impl From<Ieee802154Address> for HardwareAddress {
+ fn from(addr: Ieee802154Address) -> Self {
+ HardwareAddress::Ieee802154(addr)
+ }
+}
+
+#[cfg(not(feature = "medium-ieee802154"))]
+pub const MAX_HARDWARE_ADDRESS_LEN: usize = 6;
+#[cfg(feature = "medium-ieee802154")]
+pub const MAX_HARDWARE_ADDRESS_LEN: usize = 8;
+
+/// Unparsed hardware address.
+///
+/// Used to make NDISC parsing agnostic of the hardware medium in use.
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct RawHardwareAddress {
+ len: u8,
+ data: [u8; MAX_HARDWARE_ADDRESS_LEN],
+}
+
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+impl RawHardwareAddress {
+ pub fn from_bytes(addr: &[u8]) -> Self {
+ let mut data = [0u8; MAX_HARDWARE_ADDRESS_LEN];
+ data[..addr.len()].copy_from_slice(addr);
+
+ Self {
+ len: addr.len() as u8,
+ data,
+ }
+ }
+
+ pub fn as_bytes(&self) -> &[u8] {
+ &self.data[..self.len as usize]
+ }
+
+ pub const fn len(&self) -> usize {
+ self.len as usize
+ }
+
+ pub const fn is_empty(&self) -> bool {
+ self.len == 0
+ }
+
+ pub fn parse(&self, medium: Medium) -> Result<HardwareAddress> {
+ match medium {
+ #[cfg(feature = "medium-ethernet")]
+ Medium::Ethernet => {
+ if self.len() < 6 {
+ return Err(Error);
+ }
+ Ok(HardwareAddress::Ethernet(EthernetAddress::from_bytes(
+ self.as_bytes(),
+ )))
+ }
+ #[cfg(feature = "medium-ieee802154")]
+ Medium::Ieee802154 => {
+ if self.len() < 8 {
+ return Err(Error);
+ }
+ Ok(HardwareAddress::Ieee802154(Ieee802154Address::from_bytes(
+ self.as_bytes(),
+ )))
+ }
+ #[cfg(feature = "medium-ip")]
+ Medium::Ip => unreachable!(),
+ }
+ }
+}
+
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+impl core::fmt::Display for RawHardwareAddress {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ for (i, &b) in self.as_bytes().iter().enumerate() {
+ if i != 0 {
+ write!(f, ":")?;
+ }
+ write!(f, "{b:02x}")?;
+ }
+ Ok(())
+ }
+}
+
+#[cfg(feature = "medium-ethernet")]
+impl From<EthernetAddress> for RawHardwareAddress {
+ fn from(addr: EthernetAddress) -> Self {
+ Self::from_bytes(addr.as_bytes())
+ }
+}
+
+#[cfg(feature = "medium-ieee802154")]
+impl From<Ieee802154Address> for RawHardwareAddress {
+ fn from(addr: Ieee802154Address) -> Self {
+ Self::from_bytes(addr.as_bytes())
+ }
+}
+
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+impl From<HardwareAddress> for RawHardwareAddress {
+ fn from(addr: HardwareAddress) -> Self {
+ Self::from_bytes(addr.as_bytes())
+ }
+}
diff --git a/src/wire/ndisc.rs b/src/wire/ndisc.rs
new file mode 100644
index 0000000..691b69b
--- /dev/null
+++ b/src/wire/ndisc.rs
@@ -0,0 +1,541 @@
+use bitflags::bitflags;
+use byteorder::{ByteOrder, NetworkEndian};
+
+use super::{Error, Result};
+use crate::time::Duration;
+use crate::wire::icmpv6::{field, Message, Packet};
+use crate::wire::Ipv6Address;
+use crate::wire::RawHardwareAddress;
+use crate::wire::{NdiscOption, NdiscOptionRepr};
+use crate::wire::{NdiscPrefixInformation, NdiscRedirectedHeader};
+
+bitflags! {
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub struct RouterFlags: u8 {
+ const MANAGED = 0b10000000;
+ const OTHER = 0b01000000;
+ }
+}
+
+bitflags! {
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub struct NeighborFlags: u8 {
+ const ROUTER = 0b10000000;
+ const SOLICITED = 0b01000000;
+ const OVERRIDE = 0b00100000;
+ }
+}
+
+/// Getters for the Router Advertisement message header.
+/// See [RFC 4861 § 4.2].
+///
+/// [RFC 4861 § 4.2]: https://tools.ietf.org/html/rfc4861#section-4.2
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the current hop limit field.
+ #[inline]
+ pub fn current_hop_limit(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::CUR_HOP_LIMIT]
+ }
+
+ /// Return the Router Advertisement flags.
+ #[inline]
+ pub fn router_flags(&self) -> RouterFlags {
+ let data = self.buffer.as_ref();
+ RouterFlags::from_bits_truncate(data[field::ROUTER_FLAGS])
+ }
+
+ /// Return the router lifetime field.
+ #[inline]
+ pub fn router_lifetime(&self) -> Duration {
+ let data = self.buffer.as_ref();
+ Duration::from_secs(NetworkEndian::read_u16(&data[field::ROUTER_LT]) as u64)
+ }
+
+ /// Return the reachable time field.
+ #[inline]
+ pub fn reachable_time(&self) -> Duration {
+ let data = self.buffer.as_ref();
+ Duration::from_millis(NetworkEndian::read_u32(&data[field::REACHABLE_TM]) as u64)
+ }
+
+ /// Return the retransmit time field.
+ #[inline]
+ pub fn retrans_time(&self) -> Duration {
+ let data = self.buffer.as_ref();
+ Duration::from_millis(NetworkEndian::read_u32(&data[field::RETRANS_TM]) as u64)
+ }
+}
+
+/// Common getters for the [Neighbor Solicitation], [Neighbor Advertisement], and
+/// [Redirect] message types.
+///
+/// [Neighbor Solicitation]: https://tools.ietf.org/html/rfc4861#section-4.3
+/// [Neighbor Advertisement]: https://tools.ietf.org/html/rfc4861#section-4.4
+/// [Redirect]: https://tools.ietf.org/html/rfc4861#section-4.5
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the target address field.
+ #[inline]
+ pub fn target_addr(&self) -> Ipv6Address {
+ let data = self.buffer.as_ref();
+ Ipv6Address::from_bytes(&data[field::TARGET_ADDR])
+ }
+}
+
+/// Getters for the Neighbor Solicitation message header.
+/// See [RFC 4861 § 4.3].
+///
+/// [RFC 4861 § 4.3]: https://tools.ietf.org/html/rfc4861#section-4.3
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the Neighbor Solicitation flags.
+ #[inline]
+ pub fn neighbor_flags(&self) -> NeighborFlags {
+ let data = self.buffer.as_ref();
+ NeighborFlags::from_bits_truncate(data[field::NEIGH_FLAGS])
+ }
+}
+
+/// Getters for the Redirect message header.
+/// See [RFC 4861 § 4.5].
+///
+/// [RFC 4861 § 4.5]: https://tools.ietf.org/html/rfc4861#section-4.5
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the destination address field.
+ #[inline]
+ pub fn dest_addr(&self) -> Ipv6Address {
+ let data = self.buffer.as_ref();
+ Ipv6Address::from_bytes(&data[field::DEST_ADDR])
+ }
+}
+
+/// Setters for the Router Advertisement message header.
+/// See [RFC 4861 § 4.2].
+///
+/// [RFC 4861 § 4.2]: https://tools.ietf.org/html/rfc4861#section-4.2
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the current hop limit field.
+ #[inline]
+ pub fn set_current_hop_limit(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::CUR_HOP_LIMIT] = value;
+ }
+
+ /// Set the Router Advertisement flags.
+ #[inline]
+ pub fn set_router_flags(&mut self, flags: RouterFlags) {
+ self.buffer.as_mut()[field::ROUTER_FLAGS] = flags.bits();
+ }
+
+ /// Set the router lifetime field.
+ #[inline]
+ pub fn set_router_lifetime(&mut self, value: Duration) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::ROUTER_LT], value.secs() as u16);
+ }
+
+ /// Set the reachable time field.
+ #[inline]
+ pub fn set_reachable_time(&mut self, value: Duration) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::REACHABLE_TM], value.total_millis() as u32);
+ }
+
+ /// Set the retransmit time field.
+ #[inline]
+ pub fn set_retrans_time(&mut self, value: Duration) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::RETRANS_TM], value.total_millis() as u32);
+ }
+}
+
+/// Common setters for the [Neighbor Solicitation], [Neighbor Advertisement], and
+/// [Redirect] message types.
+///
+/// [Neighbor Solicitation]: https://tools.ietf.org/html/rfc4861#section-4.3
+/// [Neighbor Advertisement]: https://tools.ietf.org/html/rfc4861#section-4.4
+/// [Redirect]: https://tools.ietf.org/html/rfc4861#section-4.5
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the target address field.
+ #[inline]
+ pub fn set_target_addr(&mut self, value: Ipv6Address) {
+ let data = self.buffer.as_mut();
+ data[field::TARGET_ADDR].copy_from_slice(value.as_bytes());
+ }
+}
+
+/// Setters for the Neighbor Solicitation message header.
+/// See [RFC 4861 § 4.3].
+///
+/// [RFC 4861 § 4.3]: https://tools.ietf.org/html/rfc4861#section-4.3
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the Neighbor Solicitation flags.
+ #[inline]
+ pub fn set_neighbor_flags(&mut self, flags: NeighborFlags) {
+ self.buffer.as_mut()[field::NEIGH_FLAGS] = flags.bits();
+ }
+}
+
+/// Setters for the Redirect message header.
+/// See [RFC 4861 § 4.5].
+///
+/// [RFC 4861 § 4.5]: https://tools.ietf.org/html/rfc4861#section-4.5
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the destination address field.
+ #[inline]
+ pub fn set_dest_addr(&mut self, value: Ipv6Address) {
+ let data = self.buffer.as_mut();
+ data[field::DEST_ADDR].copy_from_slice(value.as_bytes());
+ }
+}
+
+/// A high-level representation of an Neighbor Discovery packet header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Repr<'a> {
+ RouterSolicit {
+ lladdr: Option<RawHardwareAddress>,
+ },
+ RouterAdvert {
+ hop_limit: u8,
+ flags: RouterFlags,
+ router_lifetime: Duration,
+ reachable_time: Duration,
+ retrans_time: Duration,
+ lladdr: Option<RawHardwareAddress>,
+ mtu: Option<u32>,
+ prefix_info: Option<NdiscPrefixInformation>,
+ },
+ NeighborSolicit {
+ target_addr: Ipv6Address,
+ lladdr: Option<RawHardwareAddress>,
+ },
+ NeighborAdvert {
+ flags: NeighborFlags,
+ target_addr: Ipv6Address,
+ lladdr: Option<RawHardwareAddress>,
+ },
+ Redirect {
+ target_addr: Ipv6Address,
+ dest_addr: Ipv6Address,
+ lladdr: Option<RawHardwareAddress>,
+ redirected_hdr: Option<NdiscRedirectedHeader<'a>>,
+ },
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an NDISC packet and return a high-level representation of the
+ /// packet.
+ #[allow(clippy::single_match)]
+ pub fn parse<T>(packet: &Packet<&'a T>) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ let (mut src_ll_addr, mut mtu, mut prefix_info, mut target_ll_addr, mut redirected_hdr) =
+ (None, None, None, None, None);
+
+ let mut offset = 0;
+ while packet.payload().len() > offset {
+ let pkt = NdiscOption::new_checked(&packet.payload()[offset..])?;
+
+ // If an option doesn't parse, ignore it and still parse the others.
+ if let Ok(opt) = NdiscOptionRepr::parse(&pkt) {
+ match opt {
+ NdiscOptionRepr::SourceLinkLayerAddr(addr) => src_ll_addr = Some(addr),
+ NdiscOptionRepr::TargetLinkLayerAddr(addr) => target_ll_addr = Some(addr),
+ NdiscOptionRepr::PrefixInformation(prefix) => prefix_info = Some(prefix),
+ NdiscOptionRepr::RedirectedHeader(redirect) => redirected_hdr = Some(redirect),
+ NdiscOptionRepr::Mtu(m) => mtu = Some(m),
+ _ => {}
+ }
+ }
+
+ let len = pkt.data_len() as usize * 8;
+ if len == 0 {
+ return Err(Error);
+ }
+ offset += len;
+ }
+
+ match packet.msg_type() {
+ Message::RouterSolicit => Ok(Repr::RouterSolicit {
+ lladdr: src_ll_addr,
+ }),
+ Message::RouterAdvert => Ok(Repr::RouterAdvert {
+ hop_limit: packet.current_hop_limit(),
+ flags: packet.router_flags(),
+ router_lifetime: packet.router_lifetime(),
+ reachable_time: packet.reachable_time(),
+ retrans_time: packet.retrans_time(),
+ lladdr: src_ll_addr,
+ mtu,
+ prefix_info,
+ }),
+ Message::NeighborSolicit => Ok(Repr::NeighborSolicit {
+ target_addr: packet.target_addr(),
+ lladdr: src_ll_addr,
+ }),
+ Message::NeighborAdvert => Ok(Repr::NeighborAdvert {
+ flags: packet.neighbor_flags(),
+ target_addr: packet.target_addr(),
+ lladdr: target_ll_addr,
+ }),
+ Message::Redirect => Ok(Repr::Redirect {
+ target_addr: packet.target_addr(),
+ dest_addr: packet.dest_addr(),
+ lladdr: src_ll_addr,
+ redirected_hdr,
+ }),
+ _ => Err(Error),
+ }
+ }
+
+ pub const fn buffer_len(&self) -> usize {
+ match self {
+ &Repr::RouterSolicit { lladdr } => match lladdr {
+ Some(addr) => {
+ field::UNUSED.end + { NdiscOptionRepr::SourceLinkLayerAddr(addr).buffer_len() }
+ }
+ None => field::UNUSED.end,
+ },
+ &Repr::RouterAdvert {
+ lladdr,
+ mtu,
+ prefix_info,
+ ..
+ } => {
+ let mut offset = 0;
+ if let Some(lladdr) = lladdr {
+ offset += NdiscOptionRepr::TargetLinkLayerAddr(lladdr).buffer_len();
+ }
+ if let Some(mtu) = mtu {
+ offset += NdiscOptionRepr::Mtu(mtu).buffer_len();
+ }
+ if let Some(prefix_info) = prefix_info {
+ offset += NdiscOptionRepr::PrefixInformation(prefix_info).buffer_len();
+ }
+ field::RETRANS_TM.end + offset
+ }
+ &Repr::NeighborSolicit { lladdr, .. } | &Repr::NeighborAdvert { lladdr, .. } => {
+ let mut offset = field::TARGET_ADDR.end;
+ if let Some(lladdr) = lladdr {
+ offset += NdiscOptionRepr::SourceLinkLayerAddr(lladdr).buffer_len();
+ }
+ offset
+ }
+ &Repr::Redirect {
+ lladdr,
+ redirected_hdr,
+ ..
+ } => {
+ let mut offset = field::DEST_ADDR.end;
+ if let Some(lladdr) = lladdr {
+ offset += NdiscOptionRepr::TargetLinkLayerAddr(lladdr).buffer_len();
+ }
+ if let Some(NdiscRedirectedHeader { header, data }) = redirected_hdr {
+ offset +=
+ NdiscOptionRepr::RedirectedHeader(NdiscRedirectedHeader { header, data })
+ .buffer_len();
+ }
+ offset
+ }
+ }
+ }
+
+ pub fn emit<T>(&self, packet: &mut Packet<&mut T>)
+ where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ match *self {
+ Repr::RouterSolicit { lladdr } => {
+ packet.set_msg_type(Message::RouterSolicit);
+ packet.set_msg_code(0);
+ packet.clear_reserved();
+ if let Some(lladdr) = lladdr {
+ let mut opt_pkt = NdiscOption::new_unchecked(packet.payload_mut());
+ NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt);
+ }
+ }
+
+ Repr::RouterAdvert {
+ hop_limit,
+ flags,
+ router_lifetime,
+ reachable_time,
+ retrans_time,
+ lladdr,
+ mtu,
+ prefix_info,
+ } => {
+ packet.set_msg_type(Message::RouterAdvert);
+ packet.set_msg_code(0);
+ packet.set_current_hop_limit(hop_limit);
+ packet.set_router_flags(flags);
+ packet.set_router_lifetime(router_lifetime);
+ packet.set_reachable_time(reachable_time);
+ packet.set_retrans_time(retrans_time);
+ let mut offset = 0;
+ if let Some(lladdr) = lladdr {
+ let mut opt_pkt = NdiscOption::new_unchecked(packet.payload_mut());
+ let opt = NdiscOptionRepr::SourceLinkLayerAddr(lladdr);
+ opt.emit(&mut opt_pkt);
+ offset += opt.buffer_len();
+ }
+ if let Some(mtu) = mtu {
+ let mut opt_pkt =
+ NdiscOption::new_unchecked(&mut packet.payload_mut()[offset..]);
+ NdiscOptionRepr::Mtu(mtu).emit(&mut opt_pkt);
+ offset += NdiscOptionRepr::Mtu(mtu).buffer_len();
+ }
+ if let Some(prefix_info) = prefix_info {
+ let mut opt_pkt =
+ NdiscOption::new_unchecked(&mut packet.payload_mut()[offset..]);
+ NdiscOptionRepr::PrefixInformation(prefix_info).emit(&mut opt_pkt)
+ }
+ }
+
+ Repr::NeighborSolicit {
+ target_addr,
+ lladdr,
+ } => {
+ packet.set_msg_type(Message::NeighborSolicit);
+ packet.set_msg_code(0);
+ packet.clear_reserved();
+ packet.set_target_addr(target_addr);
+ if let Some(lladdr) = lladdr {
+ let mut opt_pkt = NdiscOption::new_unchecked(packet.payload_mut());
+ NdiscOptionRepr::SourceLinkLayerAddr(lladdr).emit(&mut opt_pkt);
+ }
+ }
+
+ Repr::NeighborAdvert {
+ flags,
+ target_addr,
+ lladdr,
+ } => {
+ packet.set_msg_type(Message::NeighborAdvert);
+ packet.set_msg_code(0);
+ packet.clear_reserved();
+ packet.set_neighbor_flags(flags);
+ packet.set_target_addr(target_addr);
+ if let Some(lladdr) = lladdr {
+ let mut opt_pkt = NdiscOption::new_unchecked(packet.payload_mut());
+ NdiscOptionRepr::TargetLinkLayerAddr(lladdr).emit(&mut opt_pkt);
+ }
+ }
+
+ Repr::Redirect {
+ target_addr,
+ dest_addr,
+ lladdr,
+ redirected_hdr,
+ } => {
+ packet.set_msg_type(Message::Redirect);
+ packet.set_msg_code(0);
+ packet.clear_reserved();
+ packet.set_target_addr(target_addr);
+ packet.set_dest_addr(dest_addr);
+ let offset = match lladdr {
+ Some(lladdr) => {
+ let mut opt_pkt = NdiscOption::new_unchecked(packet.payload_mut());
+ NdiscOptionRepr::TargetLinkLayerAddr(lladdr).emit(&mut opt_pkt);
+ NdiscOptionRepr::TargetLinkLayerAddr(lladdr).buffer_len()
+ }
+ None => 0,
+ };
+ if let Some(redirected_hdr) = redirected_hdr {
+ let mut opt_pkt =
+ NdiscOption::new_unchecked(&mut packet.payload_mut()[offset..]);
+ NdiscOptionRepr::RedirectedHeader(redirected_hdr).emit(&mut opt_pkt);
+ }
+ }
+ }
+ }
+}
+
+#[cfg(feature = "medium-ethernet")]
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::phy::ChecksumCapabilities;
+ use crate::wire::ip::test::{MOCK_IP_ADDR_1, MOCK_IP_ADDR_2};
+ use crate::wire::EthernetAddress;
+ use crate::wire::Icmpv6Repr;
+
+ static ROUTER_ADVERT_BYTES: [u8; 24] = [
+ 0x86, 0x00, 0xa9, 0xde, 0x40, 0x80, 0x03, 0x84, 0x00, 0x00, 0x03, 0x84, 0x00, 0x00, 0x03,
+ 0x84, 0x01, 0x01, 0x52, 0x54, 0x00, 0x12, 0x34, 0x56,
+ ];
+ static SOURCE_LINK_LAYER_OPT: [u8; 8] = [0x01, 0x01, 0x52, 0x54, 0x00, 0x12, 0x34, 0x56];
+
+ fn create_repr<'a>() -> Icmpv6Repr<'a> {
+ Icmpv6Repr::Ndisc(Repr::RouterAdvert {
+ hop_limit: 64,
+ flags: RouterFlags::MANAGED,
+ router_lifetime: Duration::from_secs(900),
+ reachable_time: Duration::from_millis(900),
+ retrans_time: Duration::from_millis(900),
+ lladdr: Some(EthernetAddress([0x52, 0x54, 0x00, 0x12, 0x34, 0x56]).into()),
+ mtu: None,
+ prefix_info: None,
+ })
+ }
+
+ #[test]
+ fn test_router_advert_deconstruct() {
+ let packet = Packet::new_unchecked(&ROUTER_ADVERT_BYTES[..]);
+ assert_eq!(packet.msg_type(), Message::RouterAdvert);
+ assert_eq!(packet.msg_code(), 0);
+ assert_eq!(packet.current_hop_limit(), 64);
+ assert_eq!(packet.router_flags(), RouterFlags::MANAGED);
+ assert_eq!(packet.router_lifetime(), Duration::from_secs(900));
+ assert_eq!(packet.reachable_time(), Duration::from_millis(900));
+ assert_eq!(packet.retrans_time(), Duration::from_millis(900));
+ assert_eq!(packet.payload(), &SOURCE_LINK_LAYER_OPT[..]);
+ }
+
+ #[test]
+ fn test_router_advert_construct() {
+ let mut bytes = vec![0x0; 24];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_msg_type(Message::RouterAdvert);
+ packet.set_msg_code(0);
+ packet.set_current_hop_limit(64);
+ packet.set_router_flags(RouterFlags::MANAGED);
+ packet.set_router_lifetime(Duration::from_secs(900));
+ packet.set_reachable_time(Duration::from_millis(900));
+ packet.set_retrans_time(Duration::from_millis(900));
+ packet
+ .payload_mut()
+ .copy_from_slice(&SOURCE_LINK_LAYER_OPT[..]);
+ packet.fill_checksum(&MOCK_IP_ADDR_1, &MOCK_IP_ADDR_2);
+ assert_eq!(&*packet.into_inner(), &ROUTER_ADVERT_BYTES[..]);
+ }
+
+ #[test]
+ fn test_router_advert_repr_parse() {
+ let packet = Packet::new_unchecked(&ROUTER_ADVERT_BYTES[..]);
+ assert_eq!(
+ Icmpv6Repr::parse(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &packet,
+ &ChecksumCapabilities::default()
+ )
+ .unwrap(),
+ create_repr()
+ );
+ }
+
+ #[test]
+ fn test_router_advert_repr_emit() {
+ let mut bytes = vec![0x2a; 24];
+ let mut packet = Packet::new_unchecked(&mut bytes[..]);
+ create_repr().emit(
+ &MOCK_IP_ADDR_1,
+ &MOCK_IP_ADDR_2,
+ &mut packet,
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(&*packet.into_inner(), &ROUTER_ADVERT_BYTES[..]);
+ }
+}
diff --git a/src/wire/ndiscoption.rs b/src/wire/ndiscoption.rs
new file mode 100644
index 0000000..eff7a93
--- /dev/null
+++ b/src/wire/ndiscoption.rs
@@ -0,0 +1,768 @@
+use bitflags::bitflags;
+use byteorder::{ByteOrder, NetworkEndian};
+use core::fmt;
+
+use super::{Error, Result};
+use crate::time::Duration;
+use crate::wire::{Ipv6Address, Ipv6Packet, Ipv6Repr, MAX_HARDWARE_ADDRESS_LEN};
+
+use crate::wire::RawHardwareAddress;
+
+enum_with_unknown! {
+ /// NDISC Option Type
+ pub enum Type(u8) {
+ /// Source Link-layer Address
+ SourceLinkLayerAddr = 0x1,
+ /// Target Link-layer Address
+ TargetLinkLayerAddr = 0x2,
+ /// Prefix Information
+ PrefixInformation = 0x3,
+ /// Redirected Header
+ RedirectedHeader = 0x4,
+ /// MTU
+ Mtu = 0x5
+ }
+}
+
+impl fmt::Display for Type {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ Type::SourceLinkLayerAddr => write!(f, "source link-layer address"),
+ Type::TargetLinkLayerAddr => write!(f, "target link-layer address"),
+ Type::PrefixInformation => write!(f, "prefix information"),
+ Type::RedirectedHeader => write!(f, "redirected header"),
+ Type::Mtu => write!(f, "mtu"),
+ Type::Unknown(id) => write!(f, "{id}"),
+ }
+ }
+}
+
+bitflags! {
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub struct PrefixInfoFlags: u8 {
+ const ON_LINK = 0b10000000;
+ const ADDRCONF = 0b01000000;
+ }
+}
+
+/// A read/write wrapper around an [NDISC Option].
+///
+/// [NDISC Option]: https://tools.ietf.org/html/rfc4861#section-4.6
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct NdiscOption<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+// Format of an NDISC Option
+//
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Type | Length | ... |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// ~ ... ~
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// See https://tools.ietf.org/html/rfc4861#section-4.6 for details.
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::*;
+
+ // 8-bit identifier of the type of option.
+ pub const TYPE: usize = 0;
+ // 8-bit unsigned integer. Length of the option, in units of 8 octets.
+ pub const LENGTH: usize = 1;
+ // Minimum length of an option.
+ pub const MIN_OPT_LEN: usize = 8;
+ // Variable-length field. Option-Type-specific data.
+ pub const fn DATA(length: u8) -> Field {
+ 2..length as usize * 8
+ }
+
+ // Source/Target Link-layer Option fields.
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Type | Length | Link-Layer Address ...
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ // Prefix Information Option fields.
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Type | Length | Prefix Length |L|A| Reserved1 |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Valid Lifetime |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Preferred Lifetime |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Reserved2 |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | |
+ // + +
+ // | |
+ // + Prefix +
+ // | |
+ // + +
+ // | |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ // Prefix length.
+ pub const PREFIX_LEN: usize = 2;
+ // Flags field of prefix header.
+ pub const FLAGS: usize = 3;
+ // Valid lifetime.
+ pub const VALID_LT: Field = 4..8;
+ // Preferred lifetime.
+ pub const PREF_LT: Field = 8..12;
+ // Reserved bits
+ pub const PREF_RESERVED: Field = 12..16;
+ // Prefix
+ pub const PREFIX: Field = 16..32;
+
+ // Redirected Header Option fields.
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Type | Length | Reserved |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Reserved |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | |
+ // ~ IP header + data ~
+ // | |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ // Reserved bits.
+ pub const REDIRECTED_RESERVED: Field = 2..8;
+ pub const REDIR_MIN_SZ: usize = 48;
+
+ // MTU Option fields
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | Type | Length | Reserved |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // | MTU |
+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ // MTU
+ pub const MTU: Field = 4..8;
+}
+
+/// Core getter methods relevant to any type of NDISC option.
+impl<T: AsRef<[u8]>> NdiscOption<T> {
+ /// Create a raw octet buffer with an NDISC Option structure.
+ pub const fn new_unchecked(buffer: T) -> NdiscOption<T> {
+ NdiscOption { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<NdiscOption<T>> {
+ let opt = Self::new_unchecked(buffer);
+ opt.check_len()?;
+
+ // A data length field of 0 is invalid.
+ if opt.data_len() == 0 {
+ return Err(Error);
+ }
+
+ Ok(opt)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ ///
+ /// The result of this check is invalidated by calling [set_data_len].
+ ///
+ /// [set_data_len]: #method.set_data_len
+ pub fn check_len(&self) -> Result<()> {
+ let data = self.buffer.as_ref();
+ let len = data.len();
+
+ if len < field::MIN_OPT_LEN {
+ Err(Error)
+ } else {
+ let data_range = field::DATA(data[field::LENGTH]);
+ if len < data_range.end {
+ Err(Error)
+ } else {
+ match self.option_type() {
+ Type::SourceLinkLayerAddr | Type::TargetLinkLayerAddr | Type::Mtu => Ok(()),
+ Type::PrefixInformation if data_range.end >= field::PREFIX.end => Ok(()),
+ Type::RedirectedHeader if data_range.end >= field::REDIR_MIN_SZ => Ok(()),
+ Type::Unknown(_) => Ok(()),
+ _ => Err(Error),
+ }
+ }
+ }
+ }
+
+ /// Consume the NDISC option, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the option type.
+ #[inline]
+ pub fn option_type(&self) -> Type {
+ let data = self.buffer.as_ref();
+ Type::from(data[field::TYPE])
+ }
+
+ /// Return the length of the data.
+ #[inline]
+ pub fn data_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ data[field::LENGTH]
+ }
+}
+
+/// Getter methods only relevant for Source/Target Link-layer Address options.
+impl<T: AsRef<[u8]>> NdiscOption<T> {
+ /// Return the Source/Target Link-layer Address.
+ #[inline]
+ pub fn link_layer_addr(&self) -> RawHardwareAddress {
+ let len = MAX_HARDWARE_ADDRESS_LEN.min(self.data_len() as usize * 8 - 2);
+ let data = self.buffer.as_ref();
+ RawHardwareAddress::from_bytes(&data[2..len + 2])
+ }
+}
+
+/// Getter methods only relevant for the MTU option.
+impl<T: AsRef<[u8]>> NdiscOption<T> {
+ /// Return the MTU value.
+ #[inline]
+ pub fn mtu(&self) -> u32 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u32(&data[field::MTU])
+ }
+}
+
+/// Getter methods only relevant for the Prefix Information option.
+impl<T: AsRef<[u8]>> NdiscOption<T> {
+ /// Return the prefix length.
+ #[inline]
+ pub fn prefix_len(&self) -> u8 {
+ self.buffer.as_ref()[field::PREFIX_LEN]
+ }
+
+ /// Return the prefix information flags.
+ #[inline]
+ pub fn prefix_flags(&self) -> PrefixInfoFlags {
+ PrefixInfoFlags::from_bits_truncate(self.buffer.as_ref()[field::FLAGS])
+ }
+
+ /// Return the valid lifetime of the prefix.
+ #[inline]
+ pub fn valid_lifetime(&self) -> Duration {
+ let data = self.buffer.as_ref();
+ Duration::from_secs(NetworkEndian::read_u32(&data[field::VALID_LT]) as u64)
+ }
+
+ /// Return the preferred lifetime of the prefix.
+ #[inline]
+ pub fn preferred_lifetime(&self) -> Duration {
+ let data = self.buffer.as_ref();
+ Duration::from_secs(NetworkEndian::read_u32(&data[field::PREF_LT]) as u64)
+ }
+
+ /// Return the prefix.
+ #[inline]
+ pub fn prefix(&self) -> Ipv6Address {
+ let data = self.buffer.as_ref();
+ Ipv6Address::from_bytes(&data[field::PREFIX])
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> NdiscOption<&'a T> {
+ /// Return the option data.
+ #[inline]
+ pub fn data(&self) -> &'a [u8] {
+ let len = self.data_len();
+ let data = self.buffer.as_ref();
+ &data[field::DATA(len)]
+ }
+}
+
+/// Core setter methods relevant to any type of NDISC option.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> NdiscOption<T> {
+ /// Set the option type.
+ #[inline]
+ pub fn set_option_type(&mut self, value: Type) {
+ let data = self.buffer.as_mut();
+ data[field::TYPE] = value.into();
+ }
+
+ /// Set the option data length.
+ #[inline]
+ pub fn set_data_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ data[field::LENGTH] = value;
+ }
+}
+
+/// Setter methods only relevant for Source/Target Link-layer Address options.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> NdiscOption<T> {
+ /// Set the Source/Target Link-layer Address.
+ #[inline]
+ pub fn set_link_layer_addr(&mut self, addr: RawHardwareAddress) {
+ let data = self.buffer.as_mut();
+ data[2..2 + addr.len()].copy_from_slice(addr.as_bytes())
+ }
+}
+
+/// Setter methods only relevant for the MTU option.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> NdiscOption<T> {
+ /// Set the MTU value.
+ #[inline]
+ pub fn set_mtu(&mut self, value: u32) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::MTU], value);
+ }
+}
+
+/// Setter methods only relevant for the Prefix Information option.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> NdiscOption<T> {
+ /// Set the prefix length.
+ #[inline]
+ pub fn set_prefix_len(&mut self, value: u8) {
+ self.buffer.as_mut()[field::PREFIX_LEN] = value;
+ }
+
+ /// Set the prefix information flags.
+ #[inline]
+ pub fn set_prefix_flags(&mut self, flags: PrefixInfoFlags) {
+ self.buffer.as_mut()[field::FLAGS] = flags.bits();
+ }
+
+ /// Set the valid lifetime of the prefix.
+ #[inline]
+ pub fn set_valid_lifetime(&mut self, time: Duration) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::VALID_LT], time.secs() as u32);
+ }
+
+ /// Set the preferred lifetime of the prefix.
+ #[inline]
+ pub fn set_preferred_lifetime(&mut self, time: Duration) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::PREF_LT], time.secs() as u32);
+ }
+
+ /// Clear the reserved bits.
+ #[inline]
+ pub fn clear_prefix_reserved(&mut self) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u32(&mut data[field::PREF_RESERVED], 0);
+ }
+
+ /// Set the prefix.
+ #[inline]
+ pub fn set_prefix(&mut self, addr: Ipv6Address) {
+ let data = self.buffer.as_mut();
+ data[field::PREFIX].copy_from_slice(addr.as_bytes());
+ }
+}
+
+/// Setter methods only relevant for the Redirected Header option.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> NdiscOption<T> {
+ /// Clear the reserved bits.
+ #[inline]
+ pub fn clear_redirected_reserved(&mut self) {
+ let data = self.buffer.as_mut();
+ data[field::REDIRECTED_RESERVED].fill_with(|| 0);
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> NdiscOption<&'a mut T> {
+ /// Return a mutable pointer to the option data.
+ #[inline]
+ pub fn data_mut(&mut self) -> &mut [u8] {
+ let len = self.data_len();
+ let data = self.buffer.as_mut();
+ &mut data[field::DATA(len)]
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for NdiscOption<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match Repr::parse(self) {
+ Ok(repr) => write!(f, "{repr}"),
+ Err(err) => {
+ write!(f, "NDISC Option ({err})")?;
+ Ok(())
+ }
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct PrefixInformation {
+ pub prefix_len: u8,
+ pub flags: PrefixInfoFlags,
+ pub valid_lifetime: Duration,
+ pub preferred_lifetime: Duration,
+ pub prefix: Ipv6Address,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct RedirectedHeader<'a> {
+ pub header: Ipv6Repr,
+ pub data: &'a [u8],
+}
+
+/// A high-level representation of an NDISC Option.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Repr<'a> {
+ SourceLinkLayerAddr(RawHardwareAddress),
+ TargetLinkLayerAddr(RawHardwareAddress),
+ PrefixInformation(PrefixInformation),
+ RedirectedHeader(RedirectedHeader<'a>),
+ Mtu(u32),
+ Unknown {
+ type_: u8,
+ length: u8,
+ data: &'a [u8],
+ },
+}
+
+impl<'a> Repr<'a> {
+ /// Parse an NDISC Option and return a high-level representation.
+ pub fn parse<T>(opt: &NdiscOption<&'a T>) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ match opt.option_type() {
+ Type::SourceLinkLayerAddr => {
+ if opt.data_len() >= 1 {
+ Ok(Repr::SourceLinkLayerAddr(opt.link_layer_addr()))
+ } else {
+ Err(Error)
+ }
+ }
+ Type::TargetLinkLayerAddr => {
+ if opt.data_len() >= 1 {
+ Ok(Repr::TargetLinkLayerAddr(opt.link_layer_addr()))
+ } else {
+ Err(Error)
+ }
+ }
+ Type::PrefixInformation => {
+ if opt.data_len() == 4 {
+ Ok(Repr::PrefixInformation(PrefixInformation {
+ prefix_len: opt.prefix_len(),
+ flags: opt.prefix_flags(),
+ valid_lifetime: opt.valid_lifetime(),
+ preferred_lifetime: opt.preferred_lifetime(),
+ prefix: opt.prefix(),
+ }))
+ } else {
+ Err(Error)
+ }
+ }
+ Type::RedirectedHeader => {
+ // If the options data length is less than 6, the option
+ // does not have enough data to fill out the IP header
+ // and common option fields.
+ if opt.data_len() < 6 {
+ Err(Error)
+ } else {
+ let redirected_packet = &opt.data()[field::REDIRECTED_RESERVED.len()..];
+
+ let ip_packet = Ipv6Packet::new_checked(redirected_packet)?;
+ let ip_repr = Ipv6Repr::parse(&ip_packet)?;
+
+ Ok(Repr::RedirectedHeader(RedirectedHeader {
+ header: ip_repr,
+ data: &redirected_packet[ip_repr.buffer_len()..][..ip_repr.payload_len],
+ }))
+ }
+ }
+ Type::Mtu => {
+ if opt.data_len() == 1 {
+ Ok(Repr::Mtu(opt.mtu()))
+ } else {
+ Err(Error)
+ }
+ }
+ Type::Unknown(id) => {
+ // A length of 0 is invalid.
+ if opt.data_len() != 0 {
+ Ok(Repr::Unknown {
+ type_: id,
+ length: opt.data_len(),
+ data: opt.data(),
+ })
+ } else {
+ Err(Error)
+ }
+ }
+ }
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ match self {
+ &Repr::SourceLinkLayerAddr(addr) | &Repr::TargetLinkLayerAddr(addr) => {
+ let len = 2 + addr.len();
+ // Round up to next multiple of 8
+ (len + 7) / 8 * 8
+ }
+ &Repr::PrefixInformation(_) => field::PREFIX.end,
+ &Repr::RedirectedHeader(RedirectedHeader { header, data }) => {
+ (8 + header.buffer_len() + data.len() + 7) / 8 * 8
+ }
+ &Repr::Mtu(_) => field::MTU.end,
+ &Repr::Unknown { length, .. } => field::DATA(length).end,
+ }
+ }
+
+ /// Emit a high-level representation into an NDISC Option.
+ pub fn emit<T>(&self, opt: &mut NdiscOption<&'a mut T>)
+ where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ match *self {
+ Repr::SourceLinkLayerAddr(addr) => {
+ opt.set_option_type(Type::SourceLinkLayerAddr);
+ let opt_len = addr.len() + 2;
+ opt.set_data_len(((opt_len + 7) / 8) as u8); // round to next multiple of 8.
+ opt.set_link_layer_addr(addr);
+ }
+ Repr::TargetLinkLayerAddr(addr) => {
+ opt.set_option_type(Type::TargetLinkLayerAddr);
+ let opt_len = addr.len() + 2;
+ opt.set_data_len(((opt_len + 7) / 8) as u8); // round to next multiple of 8.
+ opt.set_link_layer_addr(addr);
+ }
+ Repr::PrefixInformation(PrefixInformation {
+ prefix_len,
+ flags,
+ valid_lifetime,
+ preferred_lifetime,
+ prefix,
+ }) => {
+ opt.clear_prefix_reserved();
+ opt.set_option_type(Type::PrefixInformation);
+ opt.set_data_len(4);
+ opt.set_prefix_len(prefix_len);
+ opt.set_prefix_flags(flags);
+ opt.set_valid_lifetime(valid_lifetime);
+ opt.set_preferred_lifetime(preferred_lifetime);
+ opt.set_prefix(prefix);
+ }
+ Repr::RedirectedHeader(RedirectedHeader { header, data }) => {
+ // TODO(thvdveld): I think we need to check if the data we are sending is not
+ // exceeding the MTU.
+ opt.clear_redirected_reserved();
+ opt.set_option_type(Type::RedirectedHeader);
+ opt.set_data_len((((8 + header.buffer_len() + data.len()) + 7) / 8) as u8);
+ let mut packet = &mut opt.data_mut()[field::REDIRECTED_RESERVED.end - 2..];
+ let mut ip_packet = Ipv6Packet::new_unchecked(&mut packet);
+ header.emit(&mut ip_packet);
+ ip_packet.payload_mut().copy_from_slice(data);
+ }
+ Repr::Mtu(mtu) => {
+ opt.set_option_type(Type::Mtu);
+ opt.set_data_len(1);
+ opt.set_mtu(mtu);
+ }
+ Repr::Unknown {
+ type_: id,
+ length,
+ data,
+ } => {
+ opt.set_option_type(Type::Unknown(id));
+ opt.set_data_len(length);
+ opt.data_mut().copy_from_slice(data);
+ }
+ }
+ }
+}
+
+impl<'a> fmt::Display for Repr<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "NDISC Option: ")?;
+ match *self {
+ Repr::SourceLinkLayerAddr(addr) => {
+ write!(f, "SourceLinkLayer addr={addr}")
+ }
+ Repr::TargetLinkLayerAddr(addr) => {
+ write!(f, "TargetLinkLayer addr={addr}")
+ }
+ Repr::PrefixInformation(PrefixInformation {
+ prefix, prefix_len, ..
+ }) => {
+ write!(f, "PrefixInformation prefix={prefix}/{prefix_len}")
+ }
+ Repr::RedirectedHeader(RedirectedHeader { header, .. }) => {
+ write!(f, "RedirectedHeader header={header}")
+ }
+ Repr::Mtu(mtu) => {
+ write!(f, "MTU mtu={mtu}")
+ }
+ Repr::Unknown {
+ type_: id, length, ..
+ } => {
+ write!(f, "Unknown({id}) length={length}")
+ }
+ }
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for NdiscOption<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ match NdiscOption::new_checked(buffer) {
+ Err(err) => write!(f, "{indent}({err})"),
+ Ok(ndisc) => match Repr::parse(&ndisc) {
+ Err(_) => Ok(()),
+ Ok(repr) => {
+ write!(f, "{indent}{repr}")
+ }
+ },
+ }
+ }
+}
+
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+#[cfg(test)]
+mod test {
+ use super::Error;
+ use super::{NdiscOption, PrefixInfoFlags, PrefixInformation, Repr, Type};
+ use crate::time::Duration;
+ use crate::wire::Ipv6Address;
+
+ #[cfg(feature = "medium-ethernet")]
+ use crate::wire::EthernetAddress;
+ #[cfg(all(not(feature = "medium-ethernet"), feature = "medium-ieee802154"))]
+ use crate::wire::Ieee802154Address;
+
+ static PREFIX_OPT_BYTES: [u8; 32] = [
+ 0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x03, 0x84, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00,
+ 0x00, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ ];
+
+ #[test]
+ fn test_deconstruct() {
+ let opt = NdiscOption::new_unchecked(&PREFIX_OPT_BYTES[..]);
+ assert_eq!(opt.option_type(), Type::PrefixInformation);
+ assert_eq!(opt.data_len(), 4);
+ assert_eq!(opt.prefix_len(), 64);
+ assert_eq!(
+ opt.prefix_flags(),
+ PrefixInfoFlags::ON_LINK | PrefixInfoFlags::ADDRCONF
+ );
+ assert_eq!(opt.valid_lifetime(), Duration::from_secs(900));
+ assert_eq!(opt.preferred_lifetime(), Duration::from_secs(1000));
+ assert_eq!(opt.prefix(), Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1));
+ }
+
+ #[test]
+ fn test_construct() {
+ let mut bytes = [0x00; 32];
+ let mut opt = NdiscOption::new_unchecked(&mut bytes[..]);
+ opt.set_option_type(Type::PrefixInformation);
+ opt.set_data_len(4);
+ opt.set_prefix_len(64);
+ opt.set_prefix_flags(PrefixInfoFlags::ON_LINK | PrefixInfoFlags::ADDRCONF);
+ opt.set_valid_lifetime(Duration::from_secs(900));
+ opt.set_preferred_lifetime(Duration::from_secs(1000));
+ opt.set_prefix(Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1));
+ assert_eq!(&PREFIX_OPT_BYTES[..], &*opt.into_inner());
+ }
+
+ #[test]
+ fn test_short_packet() {
+ assert_eq!(NdiscOption::new_checked(&[0x00, 0x00]), Err(Error));
+ let bytes = [0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+ assert_eq!(NdiscOption::new_checked(&bytes), Err(Error));
+ }
+
+ #[cfg(feature = "medium-ethernet")]
+ #[test]
+ fn test_repr_parse_link_layer_opt_ethernet() {
+ let mut bytes = [0x01, 0x01, 0x54, 0x52, 0x00, 0x12, 0x23, 0x34];
+ let addr = EthernetAddress([0x54, 0x52, 0x00, 0x12, 0x23, 0x34]);
+ {
+ assert_eq!(
+ Repr::parse(&NdiscOption::new_unchecked(&bytes)),
+ Ok(Repr::SourceLinkLayerAddr(addr.into()))
+ );
+ }
+ bytes[0] = 0x02;
+ {
+ assert_eq!(
+ Repr::parse(&NdiscOption::new_unchecked(&bytes)),
+ Ok(Repr::TargetLinkLayerAddr(addr.into()))
+ );
+ }
+ }
+
+ #[cfg(all(not(feature = "medium-ethernet"), feature = "medium-ieee802154"))]
+ #[test]
+ fn test_repr_parse_link_layer_opt_ieee802154() {
+ let mut bytes = [
+ 0x01, 0x02, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00,
+ ];
+ let addr = Ieee802154Address::Extended([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
+ {
+ assert_eq!(
+ Repr::parse(&NdiscOption::new_unchecked(&bytes)),
+ Ok(Repr::SourceLinkLayerAddr(addr.into()))
+ );
+ }
+ bytes[0] = 0x02;
+ {
+ assert_eq!(
+ Repr::parse(&NdiscOption::new_unchecked(&bytes)),
+ Ok(Repr::TargetLinkLayerAddr(addr.into()))
+ );
+ }
+ }
+
+ #[test]
+ fn test_repr_parse_prefix_info() {
+ let repr = Repr::PrefixInformation(PrefixInformation {
+ prefix_len: 64,
+ flags: PrefixInfoFlags::ON_LINK | PrefixInfoFlags::ADDRCONF,
+ valid_lifetime: Duration::from_secs(900),
+ preferred_lifetime: Duration::from_secs(1000),
+ prefix: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ });
+ assert_eq!(
+ Repr::parse(&NdiscOption::new_unchecked(&PREFIX_OPT_BYTES)),
+ Ok(repr)
+ );
+ }
+
+ #[test]
+ fn test_repr_emit_prefix_info() {
+ let mut bytes = [0x2a; 32];
+ let repr = Repr::PrefixInformation(PrefixInformation {
+ prefix_len: 64,
+ flags: PrefixInfoFlags::ON_LINK | PrefixInfoFlags::ADDRCONF,
+ valid_lifetime: Duration::from_secs(900),
+ preferred_lifetime: Duration::from_secs(1000),
+ prefix: Ipv6Address::new(0xfe80, 0, 0, 0, 0, 0, 0, 1),
+ });
+ let mut opt = NdiscOption::new_unchecked(&mut bytes);
+ repr.emit(&mut opt);
+ assert_eq!(&opt.into_inner()[..], &PREFIX_OPT_BYTES[..]);
+ }
+
+ #[test]
+ fn test_repr_parse_mtu() {
+ let bytes = [0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x05, 0xdc];
+ assert_eq!(
+ Repr::parse(&NdiscOption::new_unchecked(&bytes)),
+ Ok(Repr::Mtu(1500))
+ );
+ }
+}
diff --git a/src/wire/pretty_print.rs b/src/wire/pretty_print.rs
new file mode 100644
index 0000000..fe7d8b8
--- /dev/null
+++ b/src/wire/pretty_print.rs
@@ -0,0 +1,126 @@
+/*! Pretty-printing of packet representation.
+
+The `pretty_print` module provides bits and pieces for printing concise,
+easily human readable packet listings.
+
+# Example
+
+A packet can be formatted using the `PrettyPrinter` wrapper:
+
+```rust
+use smoltcp::wire::*;
+let buffer = vec![
+ // Ethernet II
+ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+ 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
+ 0x08, 0x00,
+ // IPv4
+ 0x45, 0x00, 0x00, 0x20,
+ 0x00, 0x00, 0x40, 0x00,
+ 0x40, 0x01, 0xd2, 0x79,
+ 0x11, 0x12, 0x13, 0x14,
+ 0x21, 0x22, 0x23, 0x24,
+ // ICMPv4
+ 0x08, 0x00, 0x8e, 0xfe,
+ 0x12, 0x34, 0xab, 0xcd,
+ 0xaa, 0x00, 0x00, 0xff
+];
+
+let result = "\
+EthernetII src=11-12-13-14-15-16 dst=01-02-03-04-05-06 type=IPv4\n\
+\\ IPv4 src=17.18.19.20 dst=33.34.35.36 proto=ICMP (checksum incorrect)\n \
+ \\ ICMPv4 echo request id=4660 seq=43981 len=4\
+";
+
+#[cfg(all(feature = "medium-ethernet", feature = "proto-ipv4"))]
+assert_eq!(
+ result,
+ &format!("{}", PrettyPrinter::<EthernetFrame<&'static [u8]>>::new("", &buffer))
+);
+```
+*/
+
+use core::fmt;
+use core::marker::PhantomData;
+
+/// Indentation state.
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct PrettyIndent {
+ prefix: &'static str,
+ level: usize,
+}
+
+impl PrettyIndent {
+ /// Create an indentation state. The entire listing will be indented by the width
+ /// of `prefix`, and `prefix` will appear at the start of the first line.
+ pub fn new(prefix: &'static str) -> PrettyIndent {
+ PrettyIndent { prefix, level: 0 }
+ }
+
+ /// Increase indentation level.
+ pub fn increase(&mut self, f: &mut fmt::Formatter) -> fmt::Result {
+ writeln!(f)?;
+ self.level += 1;
+ Ok(())
+ }
+}
+
+impl fmt::Display for PrettyIndent {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ if self.level == 0 {
+ write!(f, "{}", self.prefix)
+ } else {
+ write!(f, "{0:1$}{0:2$}\\ ", "", self.prefix.len(), self.level - 1)
+ }
+ }
+}
+
+/// Interface for printing listings.
+pub trait PrettyPrint {
+ /// Write a concise, formatted representation of a packet contained in the provided
+ /// buffer, and any nested packets it may contain.
+ ///
+ /// `pretty_print` accepts a buffer and not a packet wrapper because the packet might
+ /// be truncated, and so it might not be possible to create the packet wrapper.
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ fmt: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result;
+}
+
+/// Wrapper for using a `PrettyPrint` where a `Display` is expected.
+pub struct PrettyPrinter<'a, T: PrettyPrint> {
+ prefix: &'static str,
+ buffer: &'a dyn AsRef<[u8]>,
+ phantom: PhantomData<T>,
+}
+
+impl<'a, T: PrettyPrint> PrettyPrinter<'a, T> {
+ /// Format the listing with the recorded parameters when Display::fmt is called.
+ pub fn new(prefix: &'static str, buffer: &'a dyn AsRef<[u8]>) -> PrettyPrinter<'a, T> {
+ PrettyPrinter {
+ prefix: prefix,
+ buffer: buffer,
+ phantom: PhantomData,
+ }
+ }
+}
+
+impl<'a, T: PrettyPrint + AsRef<[u8]>> PrettyPrinter<'a, T> {
+ /// Create a `PrettyPrinter` which prints the given object.
+ pub fn print(printable: &'a T) -> PrettyPrinter<'a, T> {
+ PrettyPrinter {
+ prefix: "",
+ buffer: printable,
+ phantom: PhantomData,
+ }
+ }
+}
+
+impl<'a, T: PrettyPrint> fmt::Display for PrettyPrinter<'a, T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ T::pretty_print(&self.buffer, f, &mut PrettyIndent::new(self.prefix))
+ }
+}
diff --git a/src/wire/rpl.rs b/src/wire/rpl.rs
new file mode 100644
index 0000000..0a8467c
--- /dev/null
+++ b/src/wire/rpl.rs
@@ -0,0 +1,2721 @@
+//! Implementation of the RPL packet formats. See [RFC 6550 § 6].
+//!
+//! [RFC 6550 § 6]: https://datatracker.ietf.org/doc/html/rfc6550#section-6
+
+use byteorder::{ByteOrder, NetworkEndian};
+
+use super::{Error, Result};
+use crate::wire::icmpv6::Packet;
+use crate::wire::ipv6::Address;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+pub enum InstanceId {
+ Global(u8),
+ Local(u8),
+}
+
+impl From<u8> for InstanceId {
+ fn from(val: u8) -> Self {
+ const MASK: u8 = 0b0111_1111;
+
+ if ((val >> 7) & 0xb1) == 0b0 {
+ Self::Global(val & MASK)
+ } else {
+ Self::Local(val & MASK)
+ }
+ }
+}
+
+impl From<InstanceId> for u8 {
+ fn from(val: InstanceId) -> Self {
+ match val {
+ InstanceId::Global(val) => 0b0000_0000 | val,
+ InstanceId::Local(val) => 0b1000_0000 | val,
+ }
+ }
+}
+
+impl InstanceId {
+ /// Return the real part of the ID.
+ pub fn id(&self) -> u8 {
+ match self {
+ Self::Global(val) => *val,
+ Self::Local(val) => *val,
+ }
+ }
+
+ /// Returns `true` when the DODAG ID is the destination address of the IPv6 packet.
+ #[inline]
+ pub fn dodag_is_destination(&self) -> bool {
+ match self {
+ Self::Global(_) => false,
+ Self::Local(val) => ((val >> 6) & 0b1) == 0b1,
+ }
+ }
+
+ /// Returns `true` when the DODAG ID is the source address of the IPv6 packet.
+ ///
+ /// *NOTE*: this only makes sense when using a local RPL Instance ID and the packet is not a
+ /// RPL control message.
+ #[inline]
+ pub fn dodag_is_source(&self) -> bool {
+ !self.dodag_is_destination()
+ }
+}
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const RPL_INSTANCE_ID: usize = 4;
+
+ // DODAG information solicitation fields (DIS)
+ pub const DIS_FLAGS: usize = 4;
+ pub const DIS_RESERVED: usize = 5;
+
+ // DODAG information object fields (DIO)
+ pub const DIO_VERSION_NUMBER: usize = 5;
+ pub const DIO_RANK: Field = 6..8;
+ pub const DIO_GROUNDED: usize = 8;
+ pub const DIO_MOP: usize = 8;
+ pub const DIO_PRF: usize = 8;
+ pub const DIO_DTSN: usize = 9;
+ //pub const DIO_FLAGS: usize = 10;
+ //pub const DIO_RESERVED: usize = 11;
+ pub const DIO_DODAG_ID: Field = 12..12 + 16;
+
+ // Destination advertisement object (DAO)
+ pub const DAO_K: usize = 5;
+ pub const DAO_D: usize = 5;
+ //pub const DAO_FLAGS: usize = 5;
+ //pub const DAO_RESERVED: usize = 6;
+ pub const DAO_SEQUENCE: usize = 7;
+ pub const DAO_DODAG_ID: Field = 8..8 + 16;
+
+ // Destination advertisement object ack (DAO-ACK)
+ pub const DAO_ACK_D: usize = 5;
+ //pub const DAO_ACK_RESERVED: usize = 5;
+ pub const DAO_ACK_SEQUENCE: usize = 6;
+ pub const DAO_ACK_STATUS: usize = 7;
+ pub const DAO_ACK_DODAG_ID: Field = 8..8 + 16;
+}
+
+enum_with_unknown! {
+ /// RPL Control Message subtypes.
+ pub enum RplControlMessage(u8) {
+ DodagInformationSolicitation = 0x00,
+ DodagInformationObject = 0x01,
+ DestinationAdvertisementObject = 0x02,
+ DestinationAdvertisementObjectAck = 0x03,
+ SecureDodagInformationSolicitation = 0x80,
+ SecureDodagInformationObject = 0x81,
+ SecureDestinationAdvertisementObject = 0x82,
+ SecureDestinationAdvertisementObjectAck = 0x83,
+ ConsistencyCheck = 0x8a,
+ }
+}
+
+impl core::fmt::Display for RplControlMessage {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ RplControlMessage::DodagInformationSolicitation => {
+ write!(f, "DODAG information solicitation (DIS)")
+ }
+ RplControlMessage::DodagInformationObject => {
+ write!(f, "DODAG information object (DIO)")
+ }
+ RplControlMessage::DestinationAdvertisementObject => {
+ write!(f, "destination advertisement object (DAO)")
+ }
+ RplControlMessage::DestinationAdvertisementObjectAck => write!(
+ f,
+ "destination advertisement object acknowledgement (DAO-ACK)"
+ ),
+ RplControlMessage::SecureDodagInformationSolicitation => {
+ write!(f, "secure DODAG information solicitation (DIS)")
+ }
+ RplControlMessage::SecureDodagInformationObject => {
+ write!(f, "secure DODAG information object (DIO)")
+ }
+ RplControlMessage::SecureDestinationAdvertisementObject => {
+ write!(f, "secure destination advertisement object (DAO)")
+ }
+ RplControlMessage::SecureDestinationAdvertisementObjectAck => write!(
+ f,
+ "secure destination advertisement object acknowledgement (DAO-ACK)"
+ ),
+ RplControlMessage::ConsistencyCheck => write!(f, "consistency check (CC)"),
+ RplControlMessage::Unknown(id) => write!(f, "{}", id),
+ }
+ }
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the RPL instance ID.
+ #[inline]
+ pub fn rpl_instance_id(&self) -> InstanceId {
+ get!(self.buffer, into: InstanceId, field: field::RPL_INSTANCE_ID)
+ }
+}
+
+impl<'p, T: AsRef<[u8]> + ?Sized> Packet<&'p T> {
+ /// Return a pointer to the options.
+ pub fn options(&self) -> Result<&'p [u8]> {
+ let len = self.buffer.as_ref().len();
+ match RplControlMessage::from(self.msg_code()) {
+ RplControlMessage::DodagInformationSolicitation if len < field::DIS_RESERVED + 1 => {
+ return Err(Error)
+ }
+ RplControlMessage::DodagInformationObject if len < field::DIO_DODAG_ID.end => {
+ return Err(Error)
+ }
+ RplControlMessage::DestinationAdvertisementObject
+ if self.dao_dodag_id_present() && len < field::DAO_DODAG_ID.end =>
+ {
+ return Err(Error)
+ }
+ RplControlMessage::DestinationAdvertisementObject if len < field::DAO_SEQUENCE + 1 => {
+ return Err(Error)
+ }
+ RplControlMessage::DestinationAdvertisementObjectAck
+ if self.dao_ack_dodag_id_present() && len < field::DAO_ACK_DODAG_ID.end =>
+ {
+ return Err(Error)
+ }
+ RplControlMessage::DestinationAdvertisementObjectAck
+ if len < field::DAO_ACK_STATUS + 1 =>
+ {
+ return Err(Error)
+ }
+ RplControlMessage::SecureDodagInformationSolicitation
+ | RplControlMessage::SecureDodagInformationObject
+ | RplControlMessage::SecureDestinationAdvertisementObject
+ | RplControlMessage::SecureDestinationAdvertisementObjectAck
+ | RplControlMessage::ConsistencyCheck => return Err(Error),
+ RplControlMessage::Unknown(_) => return Err(Error),
+ _ => {}
+ }
+
+ let buffer = &self.buffer.as_ref();
+ Ok(match RplControlMessage::from(self.msg_code()) {
+ RplControlMessage::DodagInformationSolicitation => &buffer[field::DIS_RESERVED + 1..],
+ RplControlMessage::DodagInformationObject => &buffer[field::DIO_DODAG_ID.end..],
+ RplControlMessage::DestinationAdvertisementObject if self.dao_dodag_id_present() => {
+ &buffer[field::DAO_DODAG_ID.end..]
+ }
+ RplControlMessage::DestinationAdvertisementObject => &buffer[field::DAO_SEQUENCE + 1..],
+ RplControlMessage::DestinationAdvertisementObjectAck
+ if self.dao_ack_dodag_id_present() =>
+ {
+ &buffer[field::DAO_ACK_DODAG_ID.end..]
+ }
+ RplControlMessage::DestinationAdvertisementObjectAck => {
+ &buffer[field::DAO_ACK_STATUS + 1..]
+ }
+ RplControlMessage::SecureDodagInformationSolicitation
+ | RplControlMessage::SecureDodagInformationObject
+ | RplControlMessage::SecureDestinationAdvertisementObject
+ | RplControlMessage::SecureDestinationAdvertisementObjectAck
+ | RplControlMessage::ConsistencyCheck => unreachable!(),
+ RplControlMessage::Unknown(_) => unreachable!(),
+ })
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the RPL Instance ID field.
+ #[inline]
+ pub fn set_rpl_instance_id(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::RPL_INSTANCE_ID)
+ }
+}
+
+impl<'p, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> Packet<&'p mut T> {
+ /// Return a pointer to the options.
+ pub fn options_mut(&mut self) -> &mut [u8] {
+ match RplControlMessage::from(self.msg_code()) {
+ RplControlMessage::DodagInformationSolicitation => {
+ &mut self.buffer.as_mut()[field::DIS_RESERVED + 1..]
+ }
+ RplControlMessage::DodagInformationObject => {
+ &mut self.buffer.as_mut()[field::DIO_DODAG_ID.end..]
+ }
+ RplControlMessage::DestinationAdvertisementObject => {
+ if self.dao_dodag_id_present() {
+ &mut self.buffer.as_mut()[field::DAO_DODAG_ID.end..]
+ } else {
+ &mut self.buffer.as_mut()[field::DAO_SEQUENCE + 1..]
+ }
+ }
+ RplControlMessage::DestinationAdvertisementObjectAck => {
+ if self.dao_ack_dodag_id_present() {
+ &mut self.buffer.as_mut()[field::DAO_ACK_DODAG_ID.end..]
+ } else {
+ &mut self.buffer.as_mut()[field::DAO_ACK_STATUS + 1..]
+ }
+ }
+ RplControlMessage::SecureDodagInformationSolicitation
+ | RplControlMessage::SecureDodagInformationObject
+ | RplControlMessage::SecureDestinationAdvertisementObject
+ | RplControlMessage::SecureDestinationAdvertisementObjectAck
+ | RplControlMessage::ConsistencyCheck => todo!("Secure messages not supported"),
+ RplControlMessage::Unknown(_) => todo!(),
+ }
+ }
+}
+
+/// Getters for the DODAG information solicitation (DIS) message.
+///
+/// ```txt
+/// 0 1 2
+/// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | Flags | Reserved | Option(s)...
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// ```
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the DIS flags field.
+ #[inline]
+ pub fn dis_flags(&self) -> u8 {
+ get!(self.buffer, field: field::DIS_FLAGS)
+ }
+
+ /// Return the DIS reserved field.
+ #[inline]
+ pub fn dis_reserved(&self) -> u8 {
+ get!(self.buffer, field: field::DIS_RESERVED)
+ }
+}
+
+/// Setters for the DODAG information solicitation (DIS) message.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Clear the DIS flags field.
+ pub fn clear_dis_flags(&mut self) {
+ self.buffer.as_mut()[field::DIS_FLAGS] = 0;
+ }
+
+ /// Clear the DIS rserved field.
+ pub fn clear_dis_reserved(&mut self) {
+ self.buffer.as_mut()[field::DIS_RESERVED] = 0;
+ }
+}
+
+enum_with_unknown! {
+ pub enum ModeOfOperation(u8) {
+ NoDownwardRoutesMaintained = 0x00,
+ NonStoringMode = 0x01,
+ StoringModeWithoutMulticast = 0x02,
+ StoringModeWithMulticast = 0x03,
+ }
+}
+
+impl Default for ModeOfOperation {
+ fn default() -> Self {
+ Self::StoringModeWithoutMulticast
+ }
+}
+
+/// Getters for the DODAG information object (DIO) message.
+///
+/// ```txt
+/// 0 1 2 3
+/// 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
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | RPLInstanceID |Version Number | Rank |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// |G|0| MOP | Prf | DTSN | Flags | Reserved |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | |
+/// + +
+/// | |
+/// + DODAGID +
+/// | |
+/// + +
+/// | |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | Option(s)...
+/// +-+-+-+-+-+-+-+-+
+/// ```
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the Version Number field.
+ #[inline]
+ pub fn dio_version_number(&self) -> u8 {
+ get!(self.buffer, field: field::DIO_VERSION_NUMBER)
+ }
+
+ /// Return the Rank field.
+ #[inline]
+ pub fn dio_rank(&self) -> u16 {
+ get!(self.buffer, u16, field: field::DIO_RANK)
+ }
+
+ /// Return the value of the Grounded flag.
+ #[inline]
+ pub fn dio_grounded(&self) -> bool {
+ get!(self.buffer, bool, field: field::DIO_GROUNDED, shift: 7, mask: 0b01)
+ }
+
+ /// Return the mode of operation field.
+ #[inline]
+ pub fn dio_mode_of_operation(&self) -> ModeOfOperation {
+ get!(self.buffer, into: ModeOfOperation, field: field::DIO_MOP, shift: 3, mask: 0b111)
+ }
+
+ /// Return the DODAG preference field.
+ #[inline]
+ pub fn dio_dodag_preference(&self) -> u8 {
+ get!(self.buffer, field: field::DIO_PRF, mask: 0b111)
+ }
+
+ /// Return the destination advertisement trigger sequence number.
+ #[inline]
+ pub fn dio_dest_adv_trigger_seq_number(&self) -> u8 {
+ get!(self.buffer, field: field::DIO_DTSN)
+ }
+
+ /// Return the DODAG id, which is an IPv6 address.
+ #[inline]
+ pub fn dio_dodag_id(&self) -> Address {
+ get!(
+ self.buffer,
+ into: Address,
+ fun: from_bytes,
+ field: field::DIO_DODAG_ID
+ )
+ }
+}
+
+/// Setters for the DODAG information object (DIO) message.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the Version Number field.
+ #[inline]
+ pub fn set_dio_version_number(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::DIO_VERSION_NUMBER)
+ }
+
+ /// Set the Rank field.
+ #[inline]
+ pub fn set_dio_rank(&mut self, value: u16) {
+ set!(self.buffer, value, u16, field: field::DIO_RANK)
+ }
+
+ /// Set the value of the Grounded flag.
+ #[inline]
+ pub fn set_dio_grounded(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::DIO_GROUNDED, shift: 7, mask: 0b01)
+ }
+
+ /// Set the mode of operation field.
+ #[inline]
+ pub fn set_dio_mode_of_operation(&mut self, mode: ModeOfOperation) {
+ let raw = (self.buffer.as_ref()[field::DIO_MOP] & !(0b111 << 3)) | (u8::from(mode) << 3);
+ self.buffer.as_mut()[field::DIO_MOP] = raw;
+ }
+
+ /// Set the DODAG preference field.
+ #[inline]
+ pub fn set_dio_dodag_preference(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::DIO_PRF, mask: 0b111)
+ }
+
+ /// Set the destination advertisement trigger sequence number.
+ #[inline]
+ pub fn set_dio_dest_adv_trigger_seq_number(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::DIO_DTSN)
+ }
+
+ /// Set the DODAG id, which is an IPv6 address.
+ #[inline]
+ pub fn set_dio_dodag_id(&mut self, address: Address) {
+ set!(self.buffer, address: address, field: field::DIO_DODAG_ID)
+ }
+}
+
+/// Getters for the Destination Advertisement Object (DAO) message.
+///
+/// ```txt
+/// 0 1 2 3
+/// 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
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | RPLInstanceID |K|D| Flags | Reserved | DAOSequence |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | |
+/// + +
+/// | |
+/// + DODAGID* +
+/// | |
+/// + +
+/// | |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | Option(s)...
+/// +-+-+-+-+-+-+-+-+
+/// ```
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Returns the Expect DAO-ACK flag.
+ #[inline]
+ pub fn dao_ack_request(&self) -> bool {
+ get!(self.buffer, bool, field: field::DAO_K, shift: 7, mask: 0b1)
+ }
+
+ /// Returns the flag indicating that the DODAG ID is present or not.
+ #[inline]
+ pub fn dao_dodag_id_present(&self) -> bool {
+ get!(self.buffer, bool, field: field::DAO_D, shift: 6, mask: 0b1)
+ }
+
+ /// Returns the DODAG sequence flag.
+ #[inline]
+ pub fn dao_dodag_sequence(&self) -> u8 {
+ get!(self.buffer, field: field::DAO_SEQUENCE)
+ }
+
+ /// Returns the DODAG ID, an IPv6 address, when it is present.
+ #[inline]
+ pub fn dao_dodag_id(&self) -> Option<Address> {
+ if self.dao_dodag_id_present() {
+ Some(Address::from_bytes(
+ &self.buffer.as_ref()[field::DAO_DODAG_ID],
+ ))
+ } else {
+ None
+ }
+ }
+}
+
+/// Setters for the Destination Advertisement Object (DAO) message.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the Expect DAO-ACK flag.
+ #[inline]
+ pub fn set_dao_ack_request(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::DAO_K, shift: 7, mask: 0b1,)
+ }
+
+ /// Set the flag indicating that the DODAG ID is present or not.
+ #[inline]
+ pub fn set_dao_dodag_id_present(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::DAO_D, shift: 6, mask: 0b1)
+ }
+
+ /// Set the DODAG sequence flag.
+ #[inline]
+ pub fn set_dao_dodag_sequence(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::DAO_SEQUENCE)
+ }
+
+ /// Set the DODAG ID.
+ #[inline]
+ pub fn set_dao_dodag_id(&mut self, address: Option<Address>) {
+ match address {
+ Some(address) => {
+ self.buffer.as_mut()[field::DAO_DODAG_ID].copy_from_slice(address.as_bytes());
+ self.set_dao_dodag_id_present(true);
+ }
+ None => {
+ self.set_dao_dodag_id_present(false);
+ }
+ }
+ }
+}
+
+/// Getters for the Destination Advertisement Object acknowledgement (DAO-ACK) message.
+///
+/// ```txt
+/// 0 1 2 3
+/// 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
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | RPLInstanceID |D| Reserved | DAOSequence | Status |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | |
+/// + +
+/// | |
+/// + DODAGID* +
+/// | |
+/// + +
+/// | |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// | Option(s)...
+/// +-+-+-+-+-+-+-+-+
+/// ```
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Returns the flag indicating that the DODAG ID is present or not.
+ #[inline]
+ pub fn dao_ack_dodag_id_present(&self) -> bool {
+ get!(self.buffer, bool, field: field::DAO_ACK_D, shift: 7, mask: 0b1)
+ }
+
+ /// Return the DODAG sequence number.
+ #[inline]
+ pub fn dao_ack_sequence(&self) -> u8 {
+ get!(self.buffer, field: field::DAO_ACK_SEQUENCE)
+ }
+
+ /// Return the DOA status field.
+ #[inline]
+ pub fn dao_ack_status(&self) -> u8 {
+ get!(self.buffer, field: field::DAO_ACK_STATUS)
+ }
+
+ /// Returns the DODAG ID, an IPv6 address, when it is present.
+ #[inline]
+ pub fn dao_ack_dodag_id(&self) -> Option<Address> {
+ if self.dao_ack_dodag_id_present() {
+ Some(Address::from_bytes(
+ &self.buffer.as_ref()[field::DAO_ACK_DODAG_ID],
+ ))
+ } else {
+ None
+ }
+ }
+}
+
+/// Setters for the Destination Advertisement Object acknowledgement (DAO-ACK) message.
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the flag indicating that the DODAG ID is present or not.
+ #[inline]
+ pub fn set_dao_ack_dodag_id_present(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::DAO_ACK_D, shift: 7, mask: 0b1)
+ }
+
+ /// Set the DODAG sequence number.
+ #[inline]
+ pub fn set_dao_ack_sequence(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::DAO_ACK_SEQUENCE)
+ }
+
+ /// Set the DOA status field.
+ #[inline]
+ pub fn set_dao_ack_status(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::DAO_ACK_STATUS)
+ }
+
+ /// Set the DODAG ID.
+ #[inline]
+ pub fn set_dao_ack_dodag_id(&mut self, address: Option<Address>) {
+ match address {
+ Some(address) => {
+ self.buffer.as_mut()[field::DAO_ACK_DODAG_ID].copy_from_slice(address.as_bytes());
+ self.set_dao_ack_dodag_id_present(true);
+ }
+ None => {
+ self.set_dao_ack_dodag_id_present(false);
+ }
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Repr<'p> {
+ DodagInformationSolicitation {
+ options: &'p [u8],
+ },
+ DodagInformationObject {
+ rpl_instance_id: InstanceId,
+ version_number: u8,
+ rank: u16,
+ grounded: bool,
+ mode_of_operation: ModeOfOperation,
+ dodag_preference: u8,
+ dtsn: u8,
+ dodag_id: Address,
+ options: &'p [u8],
+ },
+ DestinationAdvertisementObject {
+ rpl_instance_id: InstanceId,
+ expect_ack: bool,
+ sequence: u8,
+ dodag_id: Option<Address>,
+ options: &'p [u8],
+ },
+ DestinationAdvertisementObjectAck {
+ rpl_instance_id: InstanceId,
+ sequence: u8,
+ status: u8,
+ dodag_id: Option<Address>,
+ },
+}
+
+impl core::fmt::Display for Repr<'_> {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ Repr::DodagInformationSolicitation { .. } => {
+ write!(f, "DIS")?;
+ }
+ Repr::DodagInformationObject {
+ rpl_instance_id,
+ version_number,
+ rank,
+ grounded,
+ mode_of_operation,
+ dodag_preference,
+ dtsn,
+ dodag_id,
+ ..
+ } => {
+ write!(
+ f,
+ "DIO \
+ IID={rpl_instance_id:?} \
+ V={version_number} \
+ R={rank} \
+ G={grounded} \
+ MOP={mode_of_operation:?} \
+ Pref={dodag_preference} \
+ DTSN={dtsn} \
+ DODAGID={dodag_id}"
+ )?;
+ }
+ Repr::DestinationAdvertisementObject {
+ rpl_instance_id,
+ expect_ack,
+ sequence,
+ dodag_id,
+ ..
+ } => {
+ write!(
+ f,
+ "DAO \
+ IID={rpl_instance_id:?} \
+ Ack={expect_ack} \
+ Seq={sequence} \
+ DODAGID={dodag_id:?}",
+ )?;
+ }
+ Repr::DestinationAdvertisementObjectAck {
+ rpl_instance_id,
+ sequence,
+ status,
+ dodag_id,
+ ..
+ } => {
+ write!(
+ f,
+ "DAO-ACK \
+ IID={rpl_instance_id:?} \
+ Seq={sequence} \
+ Status={status} \
+ DODAGID={dodag_id:?}",
+ )?;
+ }
+ };
+
+ Ok(())
+ }
+}
+
+impl<'p> Repr<'p> {
+ pub fn set_options(&mut self, options: &'p [u8]) {
+ let opts = match self {
+ Repr::DodagInformationSolicitation { options } => options,
+ Repr::DodagInformationObject { options, .. } => options,
+ Repr::DestinationAdvertisementObject { options, .. } => options,
+ Repr::DestinationAdvertisementObjectAck { .. } => unreachable!(),
+ };
+
+ *opts = options;
+ }
+
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(packet: &Packet<&'p T>) -> Result<Self> {
+ let options = packet.options()?;
+ match RplControlMessage::from(packet.msg_code()) {
+ RplControlMessage::DodagInformationSolicitation => {
+ Ok(Repr::DodagInformationSolicitation { options })
+ }
+ RplControlMessage::DodagInformationObject => Ok(Repr::DodagInformationObject {
+ rpl_instance_id: packet.rpl_instance_id(),
+ version_number: packet.dio_version_number(),
+ rank: packet.dio_rank(),
+ grounded: packet.dio_grounded(),
+ mode_of_operation: packet.dio_mode_of_operation(),
+ dodag_preference: packet.dio_dodag_preference(),
+ dtsn: packet.dio_dest_adv_trigger_seq_number(),
+ dodag_id: packet.dio_dodag_id(),
+ options,
+ }),
+ RplControlMessage::DestinationAdvertisementObject => {
+ Ok(Repr::DestinationAdvertisementObject {
+ rpl_instance_id: packet.rpl_instance_id(),
+ expect_ack: packet.dao_ack_request(),
+ sequence: packet.dao_dodag_sequence(),
+ dodag_id: packet.dao_dodag_id(),
+ options,
+ })
+ }
+ RplControlMessage::DestinationAdvertisementObjectAck => {
+ Ok(Repr::DestinationAdvertisementObjectAck {
+ rpl_instance_id: packet.rpl_instance_id(),
+ sequence: packet.dao_ack_sequence(),
+ status: packet.dao_ack_status(),
+ dodag_id: packet.dao_ack_dodag_id(),
+ })
+ }
+ RplControlMessage::SecureDodagInformationSolicitation
+ | RplControlMessage::SecureDodagInformationObject
+ | RplControlMessage::SecureDestinationAdvertisementObject
+ | RplControlMessage::SecureDestinationAdvertisementObjectAck
+ | RplControlMessage::ConsistencyCheck => Err(Error),
+ RplControlMessage::Unknown(_) => Err(Error),
+ }
+ }
+
+ pub fn buffer_len(&self) -> usize {
+ let mut len = 4 + match self {
+ Repr::DodagInformationSolicitation { .. } => 2,
+ Repr::DodagInformationObject { .. } => 24,
+ Repr::DestinationAdvertisementObject { dodag_id, .. } => {
+ if dodag_id.is_some() {
+ 20
+ } else {
+ 4
+ }
+ }
+ Repr::DestinationAdvertisementObjectAck { dodag_id, .. } => {
+ if dodag_id.is_some() {
+ 20
+ } else {
+ 4
+ }
+ }
+ };
+
+ let opts = match self {
+ Repr::DodagInformationSolicitation { options } => &options[..],
+ Repr::DodagInformationObject { options, .. } => &options[..],
+ Repr::DestinationAdvertisementObject { options, .. } => &options[..],
+ Repr::DestinationAdvertisementObjectAck { .. } => &[],
+ };
+
+ len += opts.len();
+
+ len
+ }
+
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, packet: &mut Packet<&mut T>) {
+ packet.set_msg_type(crate::wire::icmpv6::Message::RplControl);
+
+ match self {
+ Repr::DodagInformationSolicitation { .. } => {
+ packet.set_msg_code(RplControlMessage::DodagInformationSolicitation.into());
+ packet.clear_dis_flags();
+ packet.clear_dis_reserved();
+ }
+ Repr::DodagInformationObject {
+ rpl_instance_id,
+ version_number,
+ rank,
+ grounded,
+ mode_of_operation,
+ dodag_preference,
+ dtsn,
+ dodag_id,
+ ..
+ } => {
+ packet.set_msg_code(RplControlMessage::DodagInformationObject.into());
+ packet.set_rpl_instance_id((*rpl_instance_id).into());
+ packet.set_dio_version_number(*version_number);
+ packet.set_dio_rank(*rank);
+ packet.set_dio_grounded(*grounded);
+ packet.set_dio_mode_of_operation(*mode_of_operation);
+ packet.set_dio_dodag_preference(*dodag_preference);
+ packet.set_dio_dest_adv_trigger_seq_number(*dtsn);
+ packet.set_dio_dodag_id(*dodag_id);
+ }
+ Repr::DestinationAdvertisementObject {
+ rpl_instance_id,
+ expect_ack,
+ sequence,
+ dodag_id,
+ ..
+ } => {
+ packet.set_msg_code(RplControlMessage::DestinationAdvertisementObject.into());
+ packet.set_rpl_instance_id((*rpl_instance_id).into());
+ packet.set_dao_ack_request(*expect_ack);
+ packet.set_dao_dodag_sequence(*sequence);
+ packet.set_dao_dodag_id(*dodag_id);
+ }
+ Repr::DestinationAdvertisementObjectAck {
+ rpl_instance_id,
+ sequence,
+ status,
+ dodag_id,
+ ..
+ } => {
+ packet.set_msg_code(RplControlMessage::DestinationAdvertisementObjectAck.into());
+ packet.set_rpl_instance_id((*rpl_instance_id).into());
+ packet.set_dao_ack_sequence(*sequence);
+ packet.set_dao_ack_status(*status);
+ packet.set_dao_ack_dodag_id(*dodag_id);
+ }
+ }
+
+ let options = match self {
+ Repr::DodagInformationSolicitation { options } => &options[..],
+ Repr::DodagInformationObject { options, .. } => &options[..],
+ Repr::DestinationAdvertisementObject { options, .. } => &options[..],
+ Repr::DestinationAdvertisementObjectAck { .. } => &[],
+ };
+
+ packet.options_mut().copy_from_slice(options);
+ }
+}
+
+pub mod options {
+ use byteorder::{ByteOrder, NetworkEndian};
+
+ use super::{Error, InstanceId, Result};
+ use crate::wire::ipv6::Address;
+
+ /// A read/write wrapper around a RPL Control Message Option.
+ #[derive(Debug, Clone)]
+ pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+ }
+
+ enum_with_unknown! {
+ pub enum OptionType(u8) {
+ Pad1 = 0x00,
+ PadN = 0x01,
+ DagMetricContainer = 0x02,
+ RouteInformation = 0x03,
+ DodagConfiguration = 0x04,
+ RplTarget = 0x05,
+ TransitInformation = 0x06,
+ SolicitedInformation = 0x07,
+ PrefixInformation = 0x08,
+ RplTargetDescriptor = 0x09,
+ }
+ }
+
+ impl From<&Repr<'_>> for OptionType {
+ fn from(repr: &Repr) -> Self {
+ match repr {
+ Repr::Pad1 => Self::Pad1,
+ Repr::PadN(_) => Self::PadN,
+ Repr::DagMetricContainer => Self::DagMetricContainer,
+ Repr::RouteInformation { .. } => Self::RouteInformation,
+ Repr::DodagConfiguration { .. } => Self::DodagConfiguration,
+ Repr::RplTarget { .. } => Self::RplTarget,
+ Repr::TransitInformation { .. } => Self::TransitInformation,
+ Repr::SolicitedInformation { .. } => Self::SolicitedInformation,
+ Repr::PrefixInformation { .. } => Self::PrefixInformation,
+ Repr::RplTargetDescriptor { .. } => Self::RplTargetDescriptor,
+ }
+ }
+ }
+
+ mod field {
+ use crate::wire::field::*;
+
+ // Generic fields.
+ pub const TYPE: usize = 0;
+ pub const LENGTH: usize = 1;
+
+ pub const PADN: Rest = 2..;
+
+ // Route Information fields.
+ pub const ROUTE_INFO_PREFIX_LENGTH: usize = 2;
+ pub const ROUTE_INFO_RESERVED: usize = 3;
+ pub const ROUTE_INFO_PREFERENCE: usize = 3;
+ pub const ROUTE_INFO_LIFETIME: Field = 4..9;
+
+ // DODAG Configuration fields.
+ pub const DODAG_CONF_FLAGS: usize = 2;
+ pub const DODAG_CONF_AUTHENTICATION_ENABLED: usize = 2;
+ pub const DODAG_CONF_PATH_CONTROL_SIZE: usize = 2;
+ pub const DODAG_CONF_DIO_INTERVAL_DOUBLINGS: usize = 3;
+ pub const DODAG_CONF_DIO_INTERVAL_MINIMUM: usize = 4;
+ pub const DODAG_CONF_DIO_REDUNDANCY_CONSTANT: usize = 5;
+ pub const DODAG_CONF_DIO_MAX_RANK_INCREASE: Field = 6..8;
+ pub const DODAG_CONF_MIN_HOP_RANK_INCREASE: Field = 8..10;
+ pub const DODAG_CONF_OBJECTIVE_CODE_POINT: Field = 10..12;
+ pub const DODAG_CONF_DEFAULT_LIFETIME: usize = 13;
+ pub const DODAG_CONF_LIFETIME_UNIT: Field = 14..16;
+
+ // RPL Target fields.
+ pub const RPL_TARGET_FLAGS: usize = 2;
+ pub const RPL_TARGET_PREFIX_LENGTH: usize = 3;
+
+ // Transit Information fields.
+ pub const TRANSIT_INFO_FLAGS: usize = 2;
+ pub const TRANSIT_INFO_EXTERNAL: usize = 2;
+ pub const TRANSIT_INFO_PATH_CONTROL: usize = 3;
+ pub const TRANSIT_INFO_PATH_SEQUENCE: usize = 4;
+ pub const TRANSIT_INFO_PATH_LIFETIME: usize = 5;
+ pub const TRANSIT_INFO_PARENT_ADDRESS: Field = 6..6 + 16;
+
+ // Solicited Information fields.
+ pub const SOLICITED_INFO_RPL_INSTANCE_ID: usize = 2;
+ pub const SOLICITED_INFO_FLAGS: usize = 3;
+ pub const SOLICITED_INFO_VERSION_PREDICATE: usize = 3;
+ pub const SOLICITED_INFO_INSTANCE_ID_PREDICATE: usize = 3;
+ pub const SOLICITED_INFO_DODAG_ID_PREDICATE: usize = 3;
+ pub const SOLICITED_INFO_DODAG_ID: Field = 4..20;
+ pub const SOLICITED_INFO_VERSION_NUMBER: usize = 20;
+
+ // Prefix Information fields.
+ pub const PREFIX_INFO_PREFIX_LENGTH: usize = 2;
+ pub const PREFIX_INFO_RESERVED1: usize = 3;
+ pub const PREFIX_INFO_ON_LINK: usize = 3;
+ pub const PREFIX_INFO_AUTONOMOUS_CONF: usize = 3;
+ pub const PREFIX_INFO_ROUTER_ADDRESS_FLAG: usize = 3;
+ pub const PREFIX_INFO_VALID_LIFETIME: Field = 4..8;
+ pub const PREFIX_INFO_PREFERRED_LIFETIME: Field = 8..12;
+ pub const PREFIX_INFO_RESERVED2: Field = 12..16;
+ pub const PREFIX_INFO_PREFIX: Field = 16..16 + 16;
+
+ // RPL Target Descriptor fields.
+ pub const TARGET_DESCRIPTOR: Field = 2..6;
+ }
+
+ /// Getters for the RPL Control Message Options.
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with RPL Control Message Option structure.
+ #[inline]
+ pub fn new_unchecked(buffer: T) -> Self {
+ Packet { buffer }
+ }
+
+ #[inline]
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ if buffer.as_ref().is_empty() {
+ return Err(Error);
+ }
+
+ Ok(Packet { buffer })
+ }
+
+ /// Return the type field.
+ #[inline]
+ pub fn option_type(&self) -> OptionType {
+ OptionType::from(self.buffer.as_ref()[field::TYPE])
+ }
+
+ /// Return the length field.
+ #[inline]
+ pub fn option_length(&self) -> u8 {
+ get!(self.buffer, field: field::LENGTH)
+ }
+ }
+
+ impl<'p, T: AsRef<[u8]> + ?Sized> Packet<&'p T> {
+ /// Return a pointer to the next option.
+ #[inline]
+ pub fn next_option(&self) -> Option<&'p [u8]> {
+ if !self.buffer.as_ref().is_empty() {
+ match self.option_type() {
+ OptionType::Pad1 => Some(&self.buffer.as_ref()[1..]),
+ OptionType::Unknown(_) => unreachable!(),
+ _ => {
+ let len = self.option_length();
+ Some(&self.buffer.as_ref()[2 + len as usize..])
+ }
+ }
+ } else {
+ None
+ }
+ }
+ }
+
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the Option Type field.
+ #[inline]
+ pub fn set_option_type(&mut self, option_type: OptionType) {
+ self.buffer.as_mut()[field::TYPE] = option_type.into();
+ }
+
+ /// Set the Option Length field.
+ #[inline]
+ pub fn set_option_length(&mut self, length: u8) {
+ self.buffer.as_mut()[field::LENGTH] = length;
+ }
+ }
+
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ #[inline]
+ pub fn clear_padn(&mut self, size: u8) {
+ for b in &mut self.buffer.as_mut()[field::PADN][..size as usize] {
+ *b = 0;
+ }
+ }
+ }
+
+ /// Getters for the DAG Metric Container Option Message.
+
+ /// Getters for the Route Information Option Message.
+ ///
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Type = 0x03 | Option Length | Prefix Length |Resvd|Prf|Resvd|
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Route Lifetime |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | |
+ /// . Prefix (Variable Length) .
+ /// . .
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// ```
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the Prefix Length field.
+ #[inline]
+ pub fn prefix_length(&self) -> u8 {
+ get!(self.buffer, field: field::ROUTE_INFO_PREFIX_LENGTH)
+ }
+
+ /// Return the Route Preference field.
+ #[inline]
+ pub fn route_preference(&self) -> u8 {
+ (self.buffer.as_ref()[field::ROUTE_INFO_PREFERENCE] & 0b0001_1000) >> 3
+ }
+
+ /// Return the Route Lifetime field.
+ #[inline]
+ pub fn route_lifetime(&self) -> u32 {
+ get!(self.buffer, u32, field: field::ROUTE_INFO_LIFETIME)
+ }
+ }
+
+ impl<'p, T: AsRef<[u8]> + ?Sized> Packet<&'p T> {
+ /// Return the Prefix field.
+ #[inline]
+ pub fn prefix(&self) -> &'p [u8] {
+ let option_len = self.option_length();
+ &self.buffer.as_ref()[field::ROUTE_INFO_LIFETIME.end..]
+ [..option_len as usize - field::ROUTE_INFO_LIFETIME.end]
+ }
+ }
+
+ /// Setters for the Route Information Option Message.
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the Prefix Length field.
+ #[inline]
+ pub fn set_route_info_prefix_length(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::ROUTE_INFO_PREFIX_LENGTH)
+ }
+
+ /// Set the Route Preference field.
+ #[inline]
+ pub fn set_route_info_route_preference(&mut self, _value: u8) {
+ todo!();
+ }
+
+ /// Set the Route Lifetime field.
+ #[inline]
+ pub fn set_route_info_route_lifetime(&mut self, value: u32) {
+ set!(self.buffer, value, u32, field: field::ROUTE_INFO_LIFETIME)
+ }
+
+ /// Set the prefix field.
+ #[inline]
+ pub fn set_route_info_prefix(&mut self, _prefix: &[u8]) {
+ todo!();
+ }
+
+ /// Clear the reserved field.
+ #[inline]
+ pub fn clear_route_info_reserved(&mut self) {
+ self.buffer.as_mut()[field::ROUTE_INFO_RESERVED] = 0;
+ }
+ }
+
+ /// Getters for the DODAG Configuration Option Message.
+ ///
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Type = 0x04 |Opt Length = 14| Flags |A| PCS | DIOIntDoubl. |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | DIOIntMin. | DIORedun. | MaxRankIncrease |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | MinHopRankIncrease | OCP |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Reserved | Def. Lifetime | Lifetime Unit |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// ```
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the Authentication Enabled field.
+ #[inline]
+ pub fn authentication_enabled(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::DODAG_CONF_AUTHENTICATION_ENABLED,
+ shift: 3,
+ mask: 0b1
+ )
+ }
+
+ /// Return the Path Control Size field.
+ #[inline]
+ pub fn path_control_size(&self) -> u8 {
+ get!(self.buffer, field: field::DODAG_CONF_PATH_CONTROL_SIZE, mask: 0b111)
+ }
+
+ /// Return the DIO Interval Doublings field.
+ #[inline]
+ pub fn dio_interval_doublings(&self) -> u8 {
+ get!(self.buffer, field: field::DODAG_CONF_DIO_INTERVAL_DOUBLINGS)
+ }
+
+ /// Return the DIO Interval Minimum field.
+ #[inline]
+ pub fn dio_interval_minimum(&self) -> u8 {
+ get!(self.buffer, field: field::DODAG_CONF_DIO_INTERVAL_MINIMUM)
+ }
+
+ /// Return the DIO Redundancy Constant field.
+ #[inline]
+ pub fn dio_redundancy_constant(&self) -> u8 {
+ get!(
+ self.buffer,
+ field: field::DODAG_CONF_DIO_REDUNDANCY_CONSTANT
+ )
+ }
+
+ /// Return the Max Rank Increase field.
+ #[inline]
+ pub fn max_rank_increase(&self) -> u16 {
+ get!(
+ self.buffer,
+ u16,
+ field: field::DODAG_CONF_DIO_MAX_RANK_INCREASE
+ )
+ }
+
+ /// Return the Minimum Hop Rank Increase field.
+ #[inline]
+ pub fn minimum_hop_rank_increase(&self) -> u16 {
+ get!(
+ self.buffer,
+ u16,
+ field: field::DODAG_CONF_MIN_HOP_RANK_INCREASE
+ )
+ }
+
+ /// Return the Objective Code Point field.
+ #[inline]
+ pub fn objective_code_point(&self) -> u16 {
+ get!(
+ self.buffer,
+ u16,
+ field: field::DODAG_CONF_OBJECTIVE_CODE_POINT
+ )
+ }
+
+ /// Return the Default Lifetime field.
+ #[inline]
+ pub fn default_lifetime(&self) -> u8 {
+ get!(self.buffer, field: field::DODAG_CONF_DEFAULT_LIFETIME)
+ }
+
+ /// Return the Lifetime Unit field.
+ #[inline]
+ pub fn lifetime_unit(&self) -> u16 {
+ get!(self.buffer, u16, field: field::DODAG_CONF_LIFETIME_UNIT)
+ }
+ }
+
+ /// Getters for the DODAG Configuration Option Message.
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Clear the Flags field.
+ #[inline]
+ pub fn clear_dodag_conf_flags(&mut self) {
+ self.buffer.as_mut()[field::DODAG_CONF_FLAGS] = 0;
+ }
+
+ /// Set the Authentication Enabled field.
+ #[inline]
+ pub fn set_dodag_conf_authentication_enabled(&mut self, value: bool) {
+ set!(
+ self.buffer,
+ value,
+ bool,
+ field: field::DODAG_CONF_AUTHENTICATION_ENABLED,
+ shift: 3,
+ mask: 0b1
+ )
+ }
+
+ /// Set the Path Control Size field.
+ #[inline]
+ pub fn set_dodag_conf_path_control_size(&mut self, value: u8) {
+ set!(
+ self.buffer,
+ value,
+ field: field::DODAG_CONF_PATH_CONTROL_SIZE,
+ mask: 0b111
+ )
+ }
+
+ /// Set the DIO Interval Doublings field.
+ #[inline]
+ pub fn set_dodag_conf_dio_interval_doublings(&mut self, value: u8) {
+ set!(
+ self.buffer,
+ value,
+ field: field::DODAG_CONF_DIO_INTERVAL_DOUBLINGS
+ )
+ }
+
+ /// Set the DIO Interval Minimum field.
+ #[inline]
+ pub fn set_dodag_conf_dio_interval_minimum(&mut self, value: u8) {
+ set!(
+ self.buffer,
+ value,
+ field: field::DODAG_CONF_DIO_INTERVAL_MINIMUM
+ )
+ }
+
+ /// Set the DIO Redundancy Constant field.
+ #[inline]
+ pub fn set_dodag_conf_dio_redundancy_constant(&mut self, value: u8) {
+ set!(
+ self.buffer,
+ value,
+ field: field::DODAG_CONF_DIO_REDUNDANCY_CONSTANT
+ )
+ }
+
+ /// Set the Max Rank Increase field.
+ #[inline]
+ pub fn set_dodag_conf_max_rank_increase(&mut self, value: u16) {
+ set!(
+ self.buffer,
+ value,
+ u16,
+ field: field::DODAG_CONF_DIO_MAX_RANK_INCREASE
+ )
+ }
+
+ /// Set the Minimum Hop Rank Increase field.
+ #[inline]
+ pub fn set_dodag_conf_minimum_hop_rank_increase(&mut self, value: u16) {
+ set!(
+ self.buffer,
+ value,
+ u16,
+ field: field::DODAG_CONF_MIN_HOP_RANK_INCREASE
+ )
+ }
+
+ /// Set the Objective Code Point field.
+ #[inline]
+ pub fn set_dodag_conf_objective_code_point(&mut self, value: u16) {
+ set!(
+ self.buffer,
+ value,
+ u16,
+ field: field::DODAG_CONF_OBJECTIVE_CODE_POINT
+ )
+ }
+
+ /// Set the Default Lifetime field.
+ #[inline]
+ pub fn set_dodag_conf_default_lifetime(&mut self, value: u8) {
+ set!(
+ self.buffer,
+ value,
+ field: field::DODAG_CONF_DEFAULT_LIFETIME
+ )
+ }
+
+ /// Set the Lifetime Unit field.
+ #[inline]
+ pub fn set_dodag_conf_lifetime_unit(&mut self, value: u16) {
+ set!(
+ self.buffer,
+ value,
+ u16,
+ field: field::DODAG_CONF_LIFETIME_UNIT
+ )
+ }
+ }
+
+ /// Getters for the RPL Target Option Message.
+ ///
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Type = 0x05 | Option Length | Flags | Prefix Length |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | |
+ /// + +
+ /// | Target Prefix (Variable Length) |
+ /// . .
+ /// . .
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// ```
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the Target Prefix Length field.
+ pub fn target_prefix_length(&self) -> u8 {
+ get!(self.buffer, field: field::RPL_TARGET_PREFIX_LENGTH)
+ }
+ }
+
+ impl<'p, T: AsRef<[u8]> + ?Sized> Packet<&'p T> {
+ /// Return the Target Prefix field.
+ #[inline]
+ pub fn target_prefix(&self) -> &'p [u8] {
+ let option_len = self.option_length();
+ &self.buffer.as_ref()[field::RPL_TARGET_PREFIX_LENGTH + 1..]
+ [..option_len as usize - field::RPL_TARGET_PREFIX_LENGTH + 1]
+ }
+ }
+
+ /// Setters for the RPL Target Option Message.
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Clear the Flags field.
+ #[inline]
+ pub fn clear_rpl_target_flags(&mut self) {
+ self.buffer.as_mut()[field::RPL_TARGET_FLAGS] = 0;
+ }
+
+ /// Set the Target Prefix Length field.
+ #[inline]
+ pub fn set_rpl_target_prefix_length(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::RPL_TARGET_PREFIX_LENGTH)
+ }
+
+ /// Set the Target Prefix field.
+ #[inline]
+ pub fn set_rpl_target_prefix(&mut self, prefix: &[u8]) {
+ self.buffer.as_mut()[field::RPL_TARGET_PREFIX_LENGTH + 1..][..prefix.len()]
+ .copy_from_slice(prefix);
+ }
+ }
+
+ /// Getters for the Transit Information Option Message.
+ ///
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Type = 0x06 | Option Length |E| Flags | Path Control |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Path Sequence | Path Lifetime | |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
+ /// | |
+ /// + +
+ /// | |
+ /// + Parent Address* +
+ /// | |
+ /// + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// ```
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the External flag.
+ #[inline]
+ pub fn is_external(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::TRANSIT_INFO_EXTERNAL,
+ shift: 7,
+ mask: 0b1,
+ )
+ }
+
+ /// Return the Path Control field.
+ #[inline]
+ pub fn path_control(&self) -> u8 {
+ get!(self.buffer, field: field::TRANSIT_INFO_PATH_CONTROL)
+ }
+
+ /// Return the Path Sequence field.
+ #[inline]
+ pub fn path_sequence(&self) -> u8 {
+ get!(self.buffer, field: field::TRANSIT_INFO_PATH_SEQUENCE)
+ }
+
+ /// Return the Path Lifetime field.
+ #[inline]
+ pub fn path_lifetime(&self) -> u8 {
+ get!(self.buffer, field: field::TRANSIT_INFO_PATH_LIFETIME)
+ }
+
+ /// Return the Parent Address field.
+ #[inline]
+ pub fn parent_address(&self) -> Option<Address> {
+ if self.option_length() > 5 {
+ Some(Address::from_bytes(
+ &self.buffer.as_ref()[field::TRANSIT_INFO_PARENT_ADDRESS],
+ ))
+ } else {
+ None
+ }
+ }
+ }
+
+ /// Setters for the Transit Information Option Message.
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Clear the Flags field.
+ #[inline]
+ pub fn clear_transit_info_flags(&mut self) {
+ self.buffer.as_mut()[field::TRANSIT_INFO_FLAGS] = 0;
+ }
+
+ /// Set the External flag.
+ #[inline]
+ pub fn set_transit_info_is_external(&mut self, value: bool) {
+ set!(
+ self.buffer,
+ value,
+ bool,
+ field: field::TRANSIT_INFO_EXTERNAL,
+ shift: 7,
+ mask: 0b1
+ )
+ }
+
+ /// Set the Path Control field.
+ #[inline]
+ pub fn set_transit_info_path_control(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::TRANSIT_INFO_PATH_CONTROL)
+ }
+
+ /// Set the Path Sequence field.
+ #[inline]
+ pub fn set_transit_info_path_sequence(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::TRANSIT_INFO_PATH_SEQUENCE)
+ }
+
+ /// Set the Path Lifetime field.
+ #[inline]
+ pub fn set_transit_info_path_lifetime(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::TRANSIT_INFO_PATH_LIFETIME)
+ }
+
+ /// Set the Parent Address field.
+ #[inline]
+ pub fn set_transit_info_parent_address(&mut self, address: Address) {
+ self.buffer.as_mut()[field::TRANSIT_INFO_PARENT_ADDRESS]
+ .copy_from_slice(address.as_bytes());
+ }
+ }
+
+ /// Getters for the Solicited Information Option Message.
+ ///
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Type = 0x07 |Opt Length = 19| RPLInstanceID |V|I|D| Flags |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | |
+ /// + +
+ /// | |
+ /// + DODAGID +
+ /// | |
+ /// + +
+ /// | |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// |Version Number |
+ /// +-+-+-+-+-+-+-+-+
+ /// ```
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the RPL Instance ID field.
+ #[inline]
+ pub fn rpl_instance_id(&self) -> u8 {
+ get!(self.buffer, field: field::SOLICITED_INFO_RPL_INSTANCE_ID)
+ }
+
+ /// Return the Version Predicate flag.
+ #[inline]
+ pub fn version_predicate(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::SOLICITED_INFO_VERSION_PREDICATE,
+ shift: 7,
+ mask: 0b1,
+ )
+ }
+
+ /// Return the Instance ID Predicate flag.
+ #[inline]
+ pub fn instance_id_predicate(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::SOLICITED_INFO_INSTANCE_ID_PREDICATE,
+ shift: 6,
+ mask: 0b1,
+ )
+ }
+
+ /// Return the DODAG Predicate ID flag.
+ #[inline]
+ pub fn dodag_id_predicate(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::SOLICITED_INFO_DODAG_ID_PREDICATE,
+ shift: 5,
+ mask: 0b1,
+ )
+ }
+
+ /// Return the DODAG ID field.
+ #[inline]
+ pub fn dodag_id(&self) -> Address {
+ get!(
+ self.buffer,
+ into: Address,
+ fun: from_bytes,
+ field: field::SOLICITED_INFO_DODAG_ID
+ )
+ }
+
+ /// Return the Version Number field.
+ #[inline]
+ pub fn version_number(&self) -> u8 {
+ get!(self.buffer, field: field::SOLICITED_INFO_VERSION_NUMBER)
+ }
+ }
+
+ /// Setters for the Solicited Information Option Message.
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Clear the Flags field.
+ #[inline]
+ pub fn clear_solicited_info_flags(&mut self) {
+ self.buffer.as_mut()[field::SOLICITED_INFO_FLAGS] = 0;
+ }
+
+ /// Set the RPL Instance ID field.
+ #[inline]
+ pub fn set_solicited_info_rpl_instance_id(&mut self, value: u8) {
+ set!(
+ self.buffer,
+ value,
+ field: field::SOLICITED_INFO_RPL_INSTANCE_ID
+ )
+ }
+
+ /// Set the Version Predicate flag.
+ #[inline]
+ pub fn set_solicited_info_version_predicate(&mut self, value: bool) {
+ set!(
+ self.buffer,
+ value,
+ bool,
+ field: field::SOLICITED_INFO_VERSION_PREDICATE,
+ shift: 7,
+ mask: 0b1
+ )
+ }
+
+ /// Set the Instance ID Predicate flag.
+ #[inline]
+ pub fn set_solicited_info_instance_id_predicate(&mut self, value: bool) {
+ set!(
+ self.buffer,
+ value,
+ bool,
+ field: field::SOLICITED_INFO_INSTANCE_ID_PREDICATE,
+ shift: 6,
+ mask: 0b1
+ )
+ }
+
+ /// Set the DODAG Predicate ID flag.
+ #[inline]
+ pub fn set_solicited_info_dodag_id_predicate(&mut self, value: bool) {
+ set!(
+ self.buffer,
+ value,
+ bool,
+ field: field::SOLICITED_INFO_DODAG_ID_PREDICATE,
+ shift: 5,
+ mask: 0b1
+ )
+ }
+
+ /// Set the DODAG ID field.
+ #[inline]
+ pub fn set_solicited_info_dodag_id(&mut self, address: Address) {
+ set!(
+ self.buffer,
+ address: address,
+ field: field::SOLICITED_INFO_DODAG_ID
+ )
+ }
+
+ /// Set the Version Number field.
+ #[inline]
+ pub fn set_solicited_info_version_number(&mut self, value: u8) {
+ set!(
+ self.buffer,
+ value,
+ field: field::SOLICITED_INFO_VERSION_NUMBER
+ )
+ }
+ }
+
+ /// Getters for the Prefix Information Option Message.
+ ///
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Type = 0x08 |Opt Length = 30| Prefix Length |L|A|R|Reserved1|
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Valid Lifetime |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Preferred Lifetime |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Reserved2 |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | |
+ /// + +
+ /// | |
+ /// + Prefix +
+ /// | |
+ /// + +
+ /// | |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// ```
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the Prefix Length field.
+ #[inline]
+ pub fn prefix_info_prefix_length(&self) -> u8 {
+ get!(self.buffer, field: field::PREFIX_INFO_PREFIX_LENGTH)
+ }
+
+ /// Return the On-Link flag.
+ #[inline]
+ pub fn on_link(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::PREFIX_INFO_ON_LINK,
+ shift: 7,
+ mask: 0b1,
+ )
+ }
+
+ /// Return the Autonomous Address-Configuration flag.
+ #[inline]
+ pub fn autonomous_address_configuration(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::PREFIX_INFO_AUTONOMOUS_CONF,
+ shift: 6,
+ mask: 0b1,
+ )
+ }
+
+ /// Return the Router Address flag.
+ #[inline]
+ pub fn router_address(&self) -> bool {
+ get!(
+ self.buffer,
+ bool,
+ field: field::PREFIX_INFO_ROUTER_ADDRESS_FLAG,
+ shift: 5,
+ mask: 0b1,
+ )
+ }
+
+ /// Return the Valid Lifetime field.
+ #[inline]
+ pub fn valid_lifetime(&self) -> u32 {
+ get!(self.buffer, u32, field: field::PREFIX_INFO_VALID_LIFETIME)
+ }
+
+ /// Return the Preferred Lifetime field.
+ #[inline]
+ pub fn preferred_lifetime(&self) -> u32 {
+ get!(
+ self.buffer,
+ u32,
+ field: field::PREFIX_INFO_PREFERRED_LIFETIME
+ )
+ }
+ }
+
+ impl<'p, T: AsRef<[u8]> + ?Sized> Packet<&'p T> {
+ /// Return the Prefix field.
+ #[inline]
+ pub fn destination_prefix(&self) -> &'p [u8] {
+ &self.buffer.as_ref()[field::PREFIX_INFO_PREFIX]
+ }
+ }
+
+ /// Setters for the Prefix Information Option Message.
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Clear the reserved fields.
+ #[inline]
+ pub fn clear_prefix_info_reserved(&mut self) {
+ self.buffer.as_mut()[field::PREFIX_INFO_RESERVED1] = 0;
+ self.buffer.as_mut()[field::PREFIX_INFO_RESERVED2].copy_from_slice(&[0; 4]);
+ }
+
+ /// Set the Prefix Length field.
+ #[inline]
+ pub fn set_prefix_info_prefix_length(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::PREFIX_INFO_PREFIX_LENGTH)
+ }
+
+ /// Set the On-Link flag.
+ #[inline]
+ pub fn set_prefix_info_on_link(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::PREFIX_INFO_ON_LINK, shift: 7, mask: 0b1)
+ }
+
+ /// Set the Autonomous Address-Configuration flag.
+ #[inline]
+ pub fn set_prefix_info_autonomous_address_configuration(&mut self, value: bool) {
+ set!(
+ self.buffer,
+ value,
+ bool,
+ field: field::PREFIX_INFO_AUTONOMOUS_CONF,
+ shift: 6,
+ mask: 0b1
+ )
+ }
+
+ /// Set the Router Address flag.
+ #[inline]
+ pub fn set_prefix_info_router_address(&mut self, value: bool) {
+ set!(
+ self.buffer,
+ value,
+ bool,
+ field: field::PREFIX_INFO_ROUTER_ADDRESS_FLAG,
+ shift: 5,
+ mask: 0b1
+ )
+ }
+
+ /// Set the Valid Lifetime field.
+ #[inline]
+ pub fn set_prefix_info_valid_lifetime(&mut self, value: u32) {
+ set!(
+ self.buffer,
+ value,
+ u32,
+ field: field::PREFIX_INFO_VALID_LIFETIME
+ )
+ }
+
+ /// Set the Preferred Lifetime field.
+ #[inline]
+ pub fn set_prefix_info_preferred_lifetime(&mut self, value: u32) {
+ set!(
+ self.buffer,
+ value,
+ u32,
+ field: field::PREFIX_INFO_PREFERRED_LIFETIME
+ )
+ }
+
+ /// Set the Prefix field.
+ #[inline]
+ pub fn set_prefix_info_destination_prefix(&mut self, prefix: &[u8]) {
+ self.buffer.as_mut()[field::PREFIX_INFO_PREFIX].copy_from_slice(prefix);
+ }
+ }
+
+ /// Getters for the RPL Target Descriptor Option Message.
+ ///
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Type = 0x09 |Opt Length = 4 | Descriptor
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// Descriptor (cont.) |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// ```
+ impl<T: AsRef<[u8]>> Packet<T> {
+ /// Return the Descriptor field.
+ #[inline]
+ pub fn descriptor(&self) -> u32 {
+ get!(self.buffer, u32, field: field::TARGET_DESCRIPTOR)
+ }
+ }
+
+ /// Setters for the RPL Target Descriptor Option Message.
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the Descriptor field.
+ #[inline]
+ pub fn set_rpl_target_descriptor_descriptor(&mut self, value: u32) {
+ set!(self.buffer, value, u32, field: field::TARGET_DESCRIPTOR)
+ }
+ }
+
+ #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub enum Repr<'p> {
+ Pad1,
+ PadN(u8),
+ DagMetricContainer,
+ RouteInformation {
+ prefix_length: u8,
+ preference: u8,
+ lifetime: u32,
+ prefix: &'p [u8],
+ },
+ DodagConfiguration {
+ authentication_enabled: bool,
+ path_control_size: u8,
+ dio_interval_doublings: u8,
+ dio_interval_min: u8,
+ dio_redundancy_constant: u8,
+ max_rank_increase: u16,
+ minimum_hop_rank_increase: u16,
+ objective_code_point: u16,
+ default_lifetime: u8,
+ lifetime_unit: u16,
+ },
+ RplTarget {
+ prefix_length: u8,
+ prefix: crate::wire::Ipv6Address, // FIXME: this is not the correct type, because the
+ // field can be an IPv6 address, a prefix or a
+ // multicast group.
+ },
+ TransitInformation {
+ external: bool,
+ path_control: u8,
+ path_sequence: u8,
+ path_lifetime: u8,
+ parent_address: Option<Address>,
+ },
+ SolicitedInformation {
+ rpl_instance_id: InstanceId,
+ version_predicate: bool,
+ instance_id_predicate: bool,
+ dodag_id_predicate: bool,
+ dodag_id: Address,
+ version_number: u8,
+ },
+ PrefixInformation {
+ prefix_length: u8,
+ on_link: bool,
+ autonomous_address_configuration: bool,
+ router_address: bool,
+ valid_lifetime: u32,
+ preferred_lifetime: u32,
+ destination_prefix: &'p [u8],
+ },
+ RplTargetDescriptor {
+ descriptor: u32,
+ },
+ }
+
+ impl core::fmt::Display for Repr<'_> {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ Repr::Pad1 => write!(f, "Pad1"),
+ Repr::PadN(n) => write!(f, "PadN({n})"),
+ Repr::DagMetricContainer => todo!(),
+ Repr::RouteInformation {
+ prefix_length,
+ preference,
+ lifetime,
+ prefix,
+ } => {
+ write!(
+ f,
+ "ROUTE INFO \
+ PrefixLength={prefix_length} \
+ Preference={preference} \
+ Lifetime={lifetime} \
+ Prefix={prefix:0x?}"
+ )
+ }
+ Repr::DodagConfiguration {
+ dio_interval_doublings,
+ dio_interval_min,
+ dio_redundancy_constant,
+ max_rank_increase,
+ minimum_hop_rank_increase,
+ objective_code_point,
+ default_lifetime,
+ lifetime_unit,
+ ..
+ } => {
+ write!(
+ f,
+ "DODAG CONF \
+ IntD={dio_interval_doublings} \
+ IntMin={dio_interval_min} \
+ RedCst={dio_redundancy_constant} \
+ MaxRankIncr={max_rank_increase} \
+ MinHopRankIncr={minimum_hop_rank_increase} \
+ OCP={objective_code_point} \
+ DefaultLifetime={default_lifetime} \
+ LifeUnit={lifetime_unit}"
+ )
+ }
+ Repr::RplTarget {
+ prefix_length,
+ prefix,
+ } => {
+ write!(
+ f,
+ "RPL Target \
+ PrefixLength={prefix_length} \
+ Prefix={prefix:0x?}"
+ )
+ }
+ Repr::TransitInformation {
+ external,
+ path_control,
+ path_sequence,
+ path_lifetime,
+ parent_address,
+ } => {
+ write!(
+ f,
+ "Transit Info \
+ External={external} \
+ PathCtrl={path_control} \
+ PathSqnc={path_sequence} \
+ PathLifetime={path_lifetime} \
+ Parent={parent_address:0x?}"
+ )
+ }
+ Repr::SolicitedInformation {
+ rpl_instance_id,
+ version_predicate,
+ instance_id_predicate,
+ dodag_id_predicate,
+ dodag_id,
+ version_number,
+ } => {
+ write!(
+ f,
+ "Solicited Info \
+ I={instance_id_predicate} \
+ IID={rpl_instance_id:0x?} \
+ D={dodag_id_predicate} \
+ DODAGID={dodag_id} \
+ V={version_predicate} \
+ Version={version_number}"
+ )
+ }
+ Repr::PrefixInformation {
+ prefix_length,
+ on_link,
+ autonomous_address_configuration,
+ router_address,
+ valid_lifetime,
+ preferred_lifetime,
+ destination_prefix,
+ } => {
+ write!(
+ f,
+ "Prefix Info \
+ PrefixLength={prefix_length} \
+ L={on_link} A={autonomous_address_configuration} R={router_address} \
+ Valid={valid_lifetime} \
+ Preferred={preferred_lifetime} \
+ Prefix={destination_prefix:0x?}"
+ )
+ }
+ Repr::RplTargetDescriptor { .. } => write!(f, "Target Descriptor"),
+ }
+ }
+ }
+
+ impl<'p> Repr<'p> {
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(packet: &Packet<&'p T>) -> Result<Self> {
+ match packet.option_type() {
+ OptionType::Pad1 => Ok(Repr::Pad1),
+ OptionType::PadN => Ok(Repr::PadN(packet.option_length())),
+ OptionType::DagMetricContainer => todo!(),
+ OptionType::RouteInformation => Ok(Repr::RouteInformation {
+ prefix_length: packet.prefix_length(),
+ preference: packet.route_preference(),
+ lifetime: packet.route_lifetime(),
+ prefix: packet.prefix(),
+ }),
+ OptionType::DodagConfiguration => Ok(Repr::DodagConfiguration {
+ authentication_enabled: packet.authentication_enabled(),
+ path_control_size: packet.path_control_size(),
+ dio_interval_doublings: packet.dio_interval_doublings(),
+ dio_interval_min: packet.dio_interval_minimum(),
+ dio_redundancy_constant: packet.dio_redundancy_constant(),
+ max_rank_increase: packet.max_rank_increase(),
+ minimum_hop_rank_increase: packet.minimum_hop_rank_increase(),
+ objective_code_point: packet.objective_code_point(),
+ default_lifetime: packet.default_lifetime(),
+ lifetime_unit: packet.lifetime_unit(),
+ }),
+ OptionType::RplTarget => Ok(Repr::RplTarget {
+ prefix_length: packet.target_prefix_length(),
+ prefix: crate::wire::Ipv6Address::from_bytes(packet.target_prefix()),
+ }),
+ OptionType::TransitInformation => Ok(Repr::TransitInformation {
+ external: packet.is_external(),
+ path_control: packet.path_control(),
+ path_sequence: packet.path_sequence(),
+ path_lifetime: packet.path_lifetime(),
+ parent_address: packet.parent_address(),
+ }),
+ OptionType::SolicitedInformation => Ok(Repr::SolicitedInformation {
+ rpl_instance_id: InstanceId::from(packet.rpl_instance_id()),
+ version_predicate: packet.version_predicate(),
+ instance_id_predicate: packet.instance_id_predicate(),
+ dodag_id_predicate: packet.dodag_id_predicate(),
+ dodag_id: packet.dodag_id(),
+ version_number: packet.version_number(),
+ }),
+ OptionType::PrefixInformation => Ok(Repr::PrefixInformation {
+ prefix_length: packet.prefix_info_prefix_length(),
+ on_link: packet.on_link(),
+ autonomous_address_configuration: packet.autonomous_address_configuration(),
+ router_address: packet.router_address(),
+ valid_lifetime: packet.valid_lifetime(),
+ preferred_lifetime: packet.preferred_lifetime(),
+ destination_prefix: packet.destination_prefix(),
+ }),
+ OptionType::RplTargetDescriptor => Ok(Repr::RplTargetDescriptor {
+ descriptor: packet.descriptor(),
+ }),
+ OptionType::Unknown(_) => Err(Error),
+ }
+ }
+
+ pub fn buffer_len(&self) -> usize {
+ match self {
+ Repr::Pad1 => 1,
+ Repr::PadN(size) => 2 + *size as usize,
+ Repr::DagMetricContainer => todo!(),
+ Repr::RouteInformation { prefix, .. } => 2 + 6 + prefix.len(),
+ Repr::DodagConfiguration { .. } => 2 + 14,
+ Repr::RplTarget { prefix, .. } => 2 + 2 + prefix.0.len(),
+ Repr::TransitInformation { parent_address, .. } => {
+ 2 + 4 + if parent_address.is_some() { 16 } else { 0 }
+ }
+ Repr::SolicitedInformation { .. } => 2 + 2 + 16 + 1,
+ Repr::PrefixInformation { .. } => 32,
+ Repr::RplTargetDescriptor { .. } => 2 + 4,
+ }
+ }
+
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, packet: &mut Packet<&'p mut T>) {
+ let mut option_length = self.buffer_len() as u8;
+
+ packet.set_option_type(self.into());
+
+ if !matches!(self, Repr::Pad1) {
+ option_length -= 2;
+ packet.set_option_length(option_length);
+ }
+
+ match self {
+ Repr::Pad1 => {}
+ Repr::PadN(size) => {
+ packet.clear_padn(*size);
+ }
+ Repr::DagMetricContainer => {
+ unimplemented!();
+ }
+ Repr::RouteInformation {
+ prefix_length,
+ preference,
+ lifetime,
+ prefix,
+ } => {
+ packet.clear_route_info_reserved();
+ packet.set_route_info_prefix_length(*prefix_length);
+ packet.set_route_info_route_preference(*preference);
+ packet.set_route_info_route_lifetime(*lifetime);
+ packet.set_route_info_prefix(prefix);
+ }
+ Repr::DodagConfiguration {
+ authentication_enabled,
+ path_control_size,
+ dio_interval_doublings,
+ dio_interval_min,
+ dio_redundancy_constant,
+ max_rank_increase,
+ minimum_hop_rank_increase,
+ objective_code_point,
+ default_lifetime,
+ lifetime_unit,
+ } => {
+ packet.clear_dodag_conf_flags();
+ packet.set_dodag_conf_authentication_enabled(*authentication_enabled);
+ packet.set_dodag_conf_path_control_size(*path_control_size);
+ packet.set_dodag_conf_dio_interval_doublings(*dio_interval_doublings);
+ packet.set_dodag_conf_dio_interval_minimum(*dio_interval_min);
+ packet.set_dodag_conf_dio_redundancy_constant(*dio_redundancy_constant);
+ packet.set_dodag_conf_max_rank_increase(*max_rank_increase);
+ packet.set_dodag_conf_minimum_hop_rank_increase(*minimum_hop_rank_increase);
+ packet.set_dodag_conf_objective_code_point(*objective_code_point);
+ packet.set_dodag_conf_default_lifetime(*default_lifetime);
+ packet.set_dodag_conf_lifetime_unit(*lifetime_unit);
+ }
+ Repr::RplTarget {
+ prefix_length,
+ prefix,
+ } => {
+ packet.clear_rpl_target_flags();
+ packet.set_rpl_target_prefix_length(*prefix_length);
+ packet.set_rpl_target_prefix(prefix.as_bytes());
+ }
+ Repr::TransitInformation {
+ external,
+ path_control,
+ path_sequence,
+ path_lifetime,
+ parent_address,
+ } => {
+ packet.clear_transit_info_flags();
+ packet.set_transit_info_is_external(*external);
+ packet.set_transit_info_path_control(*path_control);
+ packet.set_transit_info_path_sequence(*path_sequence);
+ packet.set_transit_info_path_lifetime(*path_lifetime);
+
+ if let Some(address) = parent_address {
+ packet.set_transit_info_parent_address(*address);
+ }
+ }
+ Repr::SolicitedInformation {
+ rpl_instance_id,
+ version_predicate,
+ instance_id_predicate,
+ dodag_id_predicate,
+ dodag_id,
+ version_number,
+ } => {
+ packet.clear_solicited_info_flags();
+ packet.set_solicited_info_rpl_instance_id((*rpl_instance_id).into());
+ packet.set_solicited_info_version_predicate(*version_predicate);
+ packet.set_solicited_info_instance_id_predicate(*instance_id_predicate);
+ packet.set_solicited_info_dodag_id_predicate(*dodag_id_predicate);
+ packet.set_solicited_info_version_number(*version_number);
+ packet.set_solicited_info_dodag_id(*dodag_id);
+ }
+ Repr::PrefixInformation {
+ prefix_length,
+ on_link,
+ autonomous_address_configuration,
+ router_address,
+ valid_lifetime,
+ preferred_lifetime,
+ destination_prefix,
+ } => {
+ packet.clear_prefix_info_reserved();
+ packet.set_prefix_info_prefix_length(*prefix_length);
+ packet.set_prefix_info_on_link(*on_link);
+ packet.set_prefix_info_autonomous_address_configuration(
+ *autonomous_address_configuration,
+ );
+ packet.set_prefix_info_router_address(*router_address);
+ packet.set_prefix_info_valid_lifetime(*valid_lifetime);
+ packet.set_prefix_info_preferred_lifetime(*preferred_lifetime);
+ packet.set_prefix_info_destination_prefix(destination_prefix);
+ }
+ Repr::RplTargetDescriptor { descriptor } => {
+ packet.set_rpl_target_descriptor_descriptor(*descriptor);
+ }
+ }
+ }
+ }
+}
+
+pub mod data {
+ use super::{InstanceId, Result};
+ use byteorder::{ByteOrder, NetworkEndian};
+
+ mod field {
+ use crate::wire::field::*;
+
+ pub const FLAGS: usize = 0;
+ pub const INSTANCE_ID: usize = 1;
+ pub const SENDER_RANK: Field = 2..4;
+ }
+
+ /// A read/write wrapper around a RPL Packet Information send with
+ /// an IPv6 Hop-by-Hop option, defined in RFC6553.
+ /// ```txt
+ /// 0 1 2 3
+ /// 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
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | Option Type | Opt Data Len |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// |O|R|F|0|0|0|0|0| RPLInstanceID | SenderRank |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// | (sub-TLVs) |
+ /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ /// ```
+ #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+ pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+ }
+
+ impl<T: AsRef<[u8]>> Packet<T> {
+ #[inline]
+ pub fn new_unchecked(buffer: T) -> Self {
+ Self { buffer }
+ }
+
+ #[inline]
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ #[inline]
+ pub fn check_len(&self) -> Result<()> {
+ if self.buffer.as_ref().len() == 4 {
+ Ok(())
+ } else {
+ Err(crate::wire::Error)
+ }
+ }
+
+ #[inline]
+ pub fn is_down(&self) -> bool {
+ get!(self.buffer, bool, field: field::FLAGS, shift: 7, mask: 0b1)
+ }
+
+ #[inline]
+ pub fn has_rank_error(&self) -> bool {
+ get!(self.buffer, bool, field: field::FLAGS, shift: 6, mask: 0b1)
+ }
+
+ #[inline]
+ pub fn has_forwarding_error(&self) -> bool {
+ get!(self.buffer, bool, field: field::FLAGS, shift: 5, mask: 0b1)
+ }
+
+ #[inline]
+ pub fn rpl_instance_id(&self) -> InstanceId {
+ get!(self.buffer, into: InstanceId, field: field::INSTANCE_ID)
+ }
+
+ #[inline]
+ pub fn sender_rank(&self) -> u16 {
+ get!(self.buffer, u16, field: field::SENDER_RANK)
+ }
+ }
+
+ impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ #[inline]
+ pub fn set_is_down(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::FLAGS, shift: 7, mask: 0b1)
+ }
+
+ #[inline]
+ pub fn set_has_rank_error(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::FLAGS, shift: 6, mask: 0b1)
+ }
+
+ #[inline]
+ pub fn set_has_forwarding_error(&mut self, value: bool) {
+ set!(self.buffer, value, bool, field: field::FLAGS, shift: 5, mask: 0b1)
+ }
+
+ #[inline]
+ pub fn set_rpl_instance_id(&mut self, value: u8) {
+ set!(self.buffer, value, field: field::INSTANCE_ID)
+ }
+
+ #[inline]
+ pub fn set_sender_rank(&mut self, value: u16) {
+ set!(self.buffer, value, u16, field: field::SENDER_RANK)
+ }
+ }
+
+ /// A high-level representation of an IPv6 Extension Header Option.
+ #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+ #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+ pub struct HopByHopOption {
+ pub down: bool,
+ pub rank_error: bool,
+ pub forwarding_error: bool,
+ pub instance_id: InstanceId,
+ pub sender_rank: u16,
+ }
+
+ impl HopByHopOption {
+ /// Parse an IPv6 Extension Header Option and return a high-level representation.
+ pub fn parse<T>(opt: &Packet<&T>) -> Self
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ Self {
+ down: opt.is_down(),
+ rank_error: opt.has_rank_error(),
+ forwarding_error: opt.has_forwarding_error(),
+ instance_id: opt.rpl_instance_id(),
+ sender_rank: opt.sender_rank(),
+ }
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub const fn buffer_len(&self) -> usize {
+ 4
+ }
+
+ /// Emit a high-level representation into an IPv6 Extension Header Option.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, opt: &mut Packet<&mut T>) {
+ opt.set_is_down(self.down);
+ opt.set_has_rank_error(self.rank_error);
+ opt.set_has_forwarding_error(self.forwarding_error);
+ opt.set_rpl_instance_id(self.instance_id.into());
+ opt.set_sender_rank(self.sender_rank);
+ }
+ }
+
+ impl core::fmt::Display for HopByHopOption {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ write!(
+ f,
+ "down={} rank_error={} forw_error={} IID={:?} sender_rank={}",
+ self.down,
+ self.rank_error,
+ self.forwarding_error,
+ self.instance_id,
+ self.sender_rank
+ )
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::options::{Packet as OptionPacket, Repr as OptionRepr};
+ use super::Repr as RplRepr;
+ use super::*;
+ use crate::phy::ChecksumCapabilities;
+ use crate::wire::{icmpv6::*, *};
+
+ #[test]
+ fn dis_packet() {
+ let data = [0x7a, 0x3b, 0x3a, 0x1a, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00];
+
+ let ll_src_address =
+ Ieee802154Address::Extended([0x9e, 0xd3, 0xa2, 0x9c, 0x57, 0x1a, 0x4f, 0xe4]);
+ let ll_dst_address = Ieee802154Address::Short([0xff, 0xff]);
+
+ let packet = SixlowpanIphcPacket::new_checked(&data).unwrap();
+ let repr =
+ SixlowpanIphcRepr::parse(&packet, Some(ll_src_address), Some(ll_dst_address), &[])
+ .unwrap();
+
+ let icmp_repr = match repr.next_header {
+ SixlowpanNextHeader::Uncompressed(IpProtocol::Icmpv6) => {
+ let icmp_packet = Icmpv6Packet::new_checked(packet.payload()).unwrap();
+ match Icmpv6Repr::parse(
+ &IpAddress::Ipv6(repr.src_addr),
+ &IpAddress::Ipv6(repr.dst_addr),
+ &icmp_packet,
+ &ChecksumCapabilities::ignored(),
+ ) {
+ Ok(icmp @ Icmpv6Repr::Rpl(RplRepr::DodagInformationSolicitation { .. })) => {
+ icmp
+ }
+ _ => unreachable!(),
+ }
+ }
+ _ => unreachable!(),
+ };
+
+ // We also try to emit the packet:
+ let mut buffer = vec![0u8; repr.buffer_len() + icmp_repr.buffer_len()];
+ repr.emit(&mut SixlowpanIphcPacket::new_unchecked(
+ &mut buffer[..repr.buffer_len()],
+ ));
+ icmp_repr.emit(
+ &repr.src_addr.into(),
+ &repr.dst_addr.into(),
+ &mut Icmpv6Packet::new_unchecked(
+ &mut buffer[repr.buffer_len()..][..icmp_repr.buffer_len()],
+ ),
+ &ChecksumCapabilities::ignored(),
+ );
+
+ assert_eq!(&data[..], &buffer[..]);
+ }
+
+ /// Parsing of DIO packets.
+ #[test]
+ fn dio_packet() {
+ let data = [
+ 0x9b, 0x01, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x80, 0x08, 0xf0, 0x00, 0x00, 0xfd, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+ 0x04, 0x0e, 0x00, 0x08, 0x0c, 0x00, 0x04, 0x00, 0x00, 0x80, 0x00, 0x01, 0x00, 0x1e,
+ 0x00, 0x3c, 0x08, 0x1e, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0x00, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ let addr = Address::from_bytes(&[
+ 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01,
+ 0x00, 0x01,
+ ]);
+
+ let dest_prefix = [
+ 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00,
+ ];
+
+ let packet = Packet::new_checked(&data[..]).unwrap();
+ assert_eq!(packet.msg_type(), Message::RplControl);
+ assert_eq!(
+ RplControlMessage::from(packet.msg_code()),
+ RplControlMessage::DodagInformationObject
+ );
+
+ let mut dio_repr = RplRepr::parse(&packet).unwrap();
+ match dio_repr {
+ RplRepr::DodagInformationObject {
+ rpl_instance_id,
+ version_number,
+ rank,
+ grounded,
+ mode_of_operation,
+ dodag_preference,
+ dtsn,
+ dodag_id,
+ ..
+ } => {
+ assert_eq!(rpl_instance_id, InstanceId::from(0));
+ assert_eq!(version_number, 240);
+ assert_eq!(rank, 128);
+ assert!(!grounded);
+ assert_eq!(mode_of_operation, ModeOfOperation::NonStoringMode);
+ assert_eq!(dodag_preference, 0);
+ assert_eq!(dtsn, 240);
+ assert_eq!(dodag_id, addr);
+ }
+ _ => unreachable!(),
+ }
+
+ let option = OptionPacket::new_unchecked(packet.options().unwrap());
+ let dodag_conf_option = OptionRepr::parse(&option).unwrap();
+ match dodag_conf_option {
+ OptionRepr::DodagConfiguration {
+ authentication_enabled,
+ path_control_size,
+ dio_interval_doublings,
+ dio_interval_min,
+ dio_redundancy_constant,
+ max_rank_increase,
+ minimum_hop_rank_increase,
+ objective_code_point,
+ default_lifetime,
+ lifetime_unit,
+ } => {
+ assert!(!authentication_enabled);
+ assert_eq!(path_control_size, 0);
+ assert_eq!(dio_interval_doublings, 8);
+ assert_eq!(dio_interval_min, 12);
+ assert_eq!(dio_redundancy_constant, 0);
+ assert_eq!(max_rank_increase, 1024);
+ assert_eq!(minimum_hop_rank_increase, 128);
+ assert_eq!(objective_code_point, 1);
+ assert_eq!(default_lifetime, 30);
+ assert_eq!(lifetime_unit, 60);
+ }
+ _ => unreachable!(),
+ }
+
+ let option = OptionPacket::new_unchecked(option.next_option().unwrap());
+ let prefix_info_option = OptionRepr::parse(&option).unwrap();
+ match prefix_info_option {
+ OptionRepr::PrefixInformation {
+ prefix_length,
+ on_link,
+ autonomous_address_configuration,
+ valid_lifetime,
+ preferred_lifetime,
+ destination_prefix,
+ ..
+ } => {
+ assert_eq!(prefix_length, 64);
+ assert!(!on_link);
+ assert!(autonomous_address_configuration);
+ assert_eq!(valid_lifetime, u32::MAX);
+ assert_eq!(preferred_lifetime, u32::MAX);
+ assert_eq!(destination_prefix, &dest_prefix[..]);
+ }
+ _ => unreachable!(),
+ }
+
+ let mut options_buffer =
+ vec![0u8; dodag_conf_option.buffer_len() + prefix_info_option.buffer_len()];
+
+ dodag_conf_option.emit(&mut OptionPacket::new_unchecked(
+ &mut options_buffer[..dodag_conf_option.buffer_len()],
+ ));
+ prefix_info_option.emit(&mut OptionPacket::new_unchecked(
+ &mut options_buffer[dodag_conf_option.buffer_len()..]
+ [..prefix_info_option.buffer_len()],
+ ));
+
+ dio_repr.set_options(&options_buffer[..]);
+
+ let mut buffer = vec![0u8; dio_repr.buffer_len()];
+ dio_repr.emit(&mut Packet::new_unchecked(&mut buffer[..]));
+
+ assert_eq!(&data[..], &buffer[..]);
+ }
+
+ /// Parsing of DAO packets.
+ #[test]
+ fn dao_packet() {
+ let data = [
+ 0x9b, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0xf1, 0x05, 0x12, 0x00, 0x80, 0xfd, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02,
+ 0x06, 0x14, 0x00, 0x00, 0x00, 0x1e, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+ ];
+
+ let target_prefix = [
+ 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x02, 0x00, 0x02,
+ 0x00, 0x02,
+ ];
+
+ let parent_addr = Address::from_bytes(&[
+ 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01,
+ 0x00, 0x01,
+ ]);
+
+ let packet = Packet::new_checked(&data[..]).unwrap();
+ let mut dao_repr = RplRepr::parse(&packet).unwrap();
+ match dao_repr {
+ RplRepr::DestinationAdvertisementObject {
+ rpl_instance_id,
+ expect_ack,
+ sequence,
+ dodag_id,
+ ..
+ } => {
+ assert_eq!(rpl_instance_id, InstanceId::from(0));
+ assert!(expect_ack);
+ assert_eq!(sequence, 241);
+ assert_eq!(dodag_id, None);
+ }
+ _ => unreachable!(),
+ }
+
+ let option = OptionPacket::new_unchecked(packet.options().unwrap());
+
+ let rpl_target_option = OptionRepr::parse(&option).unwrap();
+ match rpl_target_option {
+ OptionRepr::RplTarget {
+ prefix_length,
+ prefix,
+ } => {
+ assert_eq!(prefix_length, 128);
+ assert_eq!(prefix.as_bytes(), &target_prefix[..]);
+ }
+ _ => unreachable!(),
+ }
+
+ let option = OptionPacket::new_unchecked(option.next_option().unwrap());
+ let transit_info_option = OptionRepr::parse(&option).unwrap();
+ match transit_info_option {
+ OptionRepr::TransitInformation {
+ external,
+ path_control,
+ path_sequence,
+ path_lifetime,
+ parent_address,
+ } => {
+ assert!(!external);
+ assert_eq!(path_control, 0);
+ assert_eq!(path_sequence, 0);
+ assert_eq!(path_lifetime, 30);
+ assert_eq!(parent_address, Some(parent_addr));
+ }
+ _ => unreachable!(),
+ }
+
+ let mut options_buffer =
+ vec![0u8; rpl_target_option.buffer_len() + transit_info_option.buffer_len()];
+
+ rpl_target_option.emit(&mut OptionPacket::new_unchecked(
+ &mut options_buffer[..rpl_target_option.buffer_len()],
+ ));
+ transit_info_option.emit(&mut OptionPacket::new_unchecked(
+ &mut options_buffer[rpl_target_option.buffer_len()..]
+ [..transit_info_option.buffer_len()],
+ ));
+
+ dao_repr.set_options(&options_buffer[..]);
+
+ let mut buffer = vec![0u8; dao_repr.buffer_len()];
+ dao_repr.emit(&mut Packet::new_unchecked(&mut buffer[..]));
+
+ assert_eq!(&data[..], &buffer[..]);
+ }
+
+ /// Parsing of DAO-ACK packets.
+ #[test]
+ fn dao_ack_packet() {
+ let data = [0x9b, 0x03, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x00];
+
+ let packet = Packet::new_checked(&data[..]).unwrap();
+ let dao_ack_repr = RplRepr::parse(&packet).unwrap();
+ match dao_ack_repr {
+ RplRepr::DestinationAdvertisementObjectAck {
+ rpl_instance_id,
+ sequence,
+ status,
+ dodag_id,
+ ..
+ } => {
+ assert_eq!(rpl_instance_id, InstanceId::from(0));
+ assert_eq!(sequence, 241);
+ assert_eq!(status, 0);
+ assert_eq!(dodag_id, None);
+ }
+ _ => unreachable!(),
+ }
+
+ let mut buffer = vec![0u8; dao_ack_repr.buffer_len()];
+ dao_ack_repr.emit(&mut Packet::new_unchecked(&mut buffer[..]));
+
+ assert_eq!(&data[..], &buffer[..]);
+
+ let data = [
+ 0x9b, 0x03, 0x0, 0x0, 0x1e, 0x80, 0xf0, 0x00, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ ];
+
+ let packet = Packet::new_checked(&data[..]).unwrap();
+ let dao_ack_repr = RplRepr::parse(&packet).unwrap();
+ match dao_ack_repr {
+ RplRepr::DestinationAdvertisementObjectAck {
+ rpl_instance_id,
+ sequence,
+ status,
+ dodag_id,
+ ..
+ } => {
+ assert_eq!(rpl_instance_id, InstanceId::from(30));
+ assert_eq!(sequence, 240);
+ assert_eq!(status, 0x0);
+ assert_eq!(
+ dodag_id,
+ Some(Ipv6Address([
+ 254, 128, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1
+ ]))
+ );
+ }
+ _ => unreachable!(),
+ }
+
+ let mut buffer = vec![0u8; dao_ack_repr.buffer_len()];
+ dao_ack_repr.emit(&mut Packet::new_unchecked(&mut buffer[..]));
+
+ assert_eq!(&data[..], &buffer[..]);
+ }
+}
diff --git a/src/wire/sixlowpan/frag.rs b/src/wire/sixlowpan/frag.rs
new file mode 100644
index 0000000..de45702
--- /dev/null
+++ b/src/wire/sixlowpan/frag.rs
@@ -0,0 +1,275 @@
+//! Implementation of the fragment headers from [RFC 4944 § 5.3].
+//!
+//! [RFC 4944 § 5.3]: https://datatracker.ietf.org/doc/html/rfc4944#section-5.3
+
+use super::{DISPATCH_FIRST_FRAGMENT_HEADER, DISPATCH_FRAGMENT_HEADER};
+use crate::wire::{Error, Result};
+use crate::wire::{Ieee802154Address, Ieee802154Repr};
+use byteorder::{ByteOrder, NetworkEndian};
+
+/// Key used for identifying all the link fragments that belong to the same packet.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Key {
+ pub(crate) ll_src_addr: Ieee802154Address,
+ pub(crate) ll_dst_addr: Ieee802154Address,
+ pub(crate) datagram_size: u16,
+ pub(crate) datagram_tag: u16,
+}
+
+/// A read/write wrapper around a 6LoWPAN Fragment header.
+/// [RFC 4944 § 5.3] specifies the format of the header.
+///
+/// A First Fragment header has the following format:
+/// ```txt
+/// 1 2 3
+/// 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
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// |1 1 0 0 0| datagram_size | datagram_tag |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// ```
+///
+/// Subsequent fragment headers have the following format:
+/// ```txt
+/// 1 2 3
+/// 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
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// |1 1 1 0 0| datagram_size | datagram_tag |
+/// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/// |datagram_offset|
+/// +-+-+-+-+-+-+-+-+
+/// ```
+///
+/// [RFC 4944 § 5.3]: https://datatracker.ietf.org/doc/html/rfc4944#section-5.3
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+pub const FIRST_FRAGMENT_HEADER_SIZE: usize = 4;
+pub const NEXT_FRAGMENT_HEADER_SIZE: usize = 5;
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const DISPATCH: usize = 0;
+ pub const DATAGRAM_SIZE: Field = 0..2;
+ pub const DATAGRAM_TAG: Field = 2..4;
+ pub const DATAGRAM_OFFSET: usize = 4;
+
+ pub const FIRST_FRAGMENT_REST: Rest = super::FIRST_FRAGMENT_HEADER_SIZE..;
+ pub const NEXT_FRAGMENT_REST: Rest = super::NEXT_FRAGMENT_HEADER_SIZE..;
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Input a raw octet buffer with a 6LoWPAN Fragment header structure.
+ pub const fn new_unchecked(buffer: T) -> Self {
+ Self { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+
+ let dispatch = packet.dispatch();
+
+ if dispatch != DISPATCH_FIRST_FRAGMENT_HEADER && dispatch != DISPATCH_FRAGMENT_HEADER {
+ return Err(Error);
+ }
+
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let buffer = self.buffer.as_ref();
+ if buffer.is_empty() {
+ return Err(Error);
+ }
+
+ match self.dispatch() {
+ DISPATCH_FIRST_FRAGMENT_HEADER if buffer.len() >= FIRST_FRAGMENT_HEADER_SIZE => Ok(()),
+ DISPATCH_FIRST_FRAGMENT_HEADER if buffer.len() < FIRST_FRAGMENT_HEADER_SIZE => {
+ Err(Error)
+ }
+ DISPATCH_FRAGMENT_HEADER if buffer.len() >= NEXT_FRAGMENT_HEADER_SIZE => Ok(()),
+ DISPATCH_FRAGMENT_HEADER if buffer.len() < NEXT_FRAGMENT_HEADER_SIZE => Err(Error),
+ _ => Err(Error),
+ }
+ }
+
+ /// Consumes the frame, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the dispatch field.
+ pub fn dispatch(&self) -> u8 {
+ let raw = self.buffer.as_ref();
+ raw[field::DISPATCH] >> 3
+ }
+
+ /// Return the total datagram size.
+ pub fn datagram_size(&self) -> u16 {
+ let raw = self.buffer.as_ref();
+ NetworkEndian::read_u16(&raw[field::DATAGRAM_SIZE]) & 0b111_1111_1111
+ }
+
+ /// Return the datagram tag.
+ pub fn datagram_tag(&self) -> u16 {
+ let raw = self.buffer.as_ref();
+ NetworkEndian::read_u16(&raw[field::DATAGRAM_TAG])
+ }
+
+ /// Return the datagram offset.
+ pub fn datagram_offset(&self) -> u8 {
+ match self.dispatch() {
+ DISPATCH_FIRST_FRAGMENT_HEADER => 0,
+ DISPATCH_FRAGMENT_HEADER => {
+ let raw = self.buffer.as_ref();
+ raw[field::DATAGRAM_OFFSET]
+ }
+ _ => unreachable!(),
+ }
+ }
+
+ /// Returns `true` when this header is from the first fragment of a link.
+ pub fn is_first_fragment(&self) -> bool {
+ self.dispatch() == DISPATCH_FIRST_FRAGMENT_HEADER
+ }
+
+ /// Returns the key for identifying the packet it belongs to.
+ pub fn get_key(&self, ieee802154_repr: &Ieee802154Repr) -> Key {
+ Key {
+ ll_src_addr: ieee802154_repr.src_addr.unwrap(),
+ ll_dst_addr: ieee802154_repr.dst_addr.unwrap(),
+ datagram_size: self.datagram_size(),
+ datagram_tag: self.datagram_tag(),
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return the payload.
+ pub fn payload(&self) -> &'a [u8] {
+ match self.dispatch() {
+ DISPATCH_FIRST_FRAGMENT_HEADER => {
+ let raw = self.buffer.as_ref();
+ &raw[field::FIRST_FRAGMENT_REST]
+ }
+ DISPATCH_FRAGMENT_HEADER => {
+ let raw = self.buffer.as_ref();
+ &raw[field::NEXT_FRAGMENT_REST]
+ }
+ _ => unreachable!(),
+ }
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ fn set_dispatch_field(&mut self, value: u8) {
+ let raw = self.buffer.as_mut();
+ raw[field::DISPATCH] = (raw[field::DISPATCH] & !(0b11111 << 3)) | (value << 3);
+ }
+
+ fn set_datagram_size(&mut self, size: u16) {
+ let raw = self.buffer.as_mut();
+ let mut v = NetworkEndian::read_u16(&raw[field::DATAGRAM_SIZE]);
+ v = (v & !0b111_1111_1111) | size;
+
+ NetworkEndian::write_u16(&mut raw[field::DATAGRAM_SIZE], v);
+ }
+
+ fn set_datagram_tag(&mut self, tag: u16) {
+ let raw = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut raw[field::DATAGRAM_TAG], tag);
+ }
+
+ fn set_datagram_offset(&mut self, offset: u8) {
+ let raw = self.buffer.as_mut();
+ raw[field::DATAGRAM_OFFSET] = offset;
+ }
+}
+
+/// A high-level representation of a 6LoWPAN Fragment header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum Repr {
+ FirstFragment { size: u16, tag: u16 },
+ Fragment { size: u16, tag: u16, offset: u8 },
+}
+
+impl core::fmt::Display for Repr {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ Repr::FirstFragment { size, tag } => {
+ write!(f, "FirstFrag size={size} tag={tag}")
+ }
+ Repr::Fragment { size, tag, offset } => {
+ write!(f, "NthFrag size={size} tag={tag} offset={offset}")
+ }
+ }
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Repr {
+ fn format(&self, fmt: defmt::Formatter) {
+ match self {
+ Repr::FirstFragment { size, tag } => {
+ defmt::write!(fmt, "FirstFrag size={} tag={}", size, tag);
+ }
+ Repr::Fragment { size, tag, offset } => {
+ defmt::write!(fmt, "NthFrag size={} tag={} offset={}", size, tag, offset);
+ }
+ }
+ }
+}
+
+impl Repr {
+ /// Parse a 6LoWPAN Fragment header.
+ pub fn parse<T: AsRef<[u8]>>(packet: &Packet<T>) -> Result<Self> {
+ let size = packet.datagram_size();
+ let tag = packet.datagram_tag();
+
+ match packet.dispatch() {
+ DISPATCH_FIRST_FRAGMENT_HEADER => Ok(Self::FirstFragment { size, tag }),
+ DISPATCH_FRAGMENT_HEADER => Ok(Self::Fragment {
+ size,
+ tag,
+ offset: packet.datagram_offset(),
+ }),
+ _ => Err(Error),
+ }
+ }
+
+ /// Returns the length of the Fragment header.
+ pub const fn buffer_len(&self) -> usize {
+ match self {
+ Self::FirstFragment { .. } => field::FIRST_FRAGMENT_REST.start,
+ Self::Fragment { .. } => field::NEXT_FRAGMENT_REST.start,
+ }
+ }
+
+ /// Emit a high-level representation into a 6LoWPAN Fragment header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
+ match self {
+ Self::FirstFragment { size, tag } => {
+ packet.set_dispatch_field(DISPATCH_FIRST_FRAGMENT_HEADER);
+ packet.set_datagram_size(*size);
+ packet.set_datagram_tag(*tag);
+ }
+ Self::Fragment { size, tag, offset } => {
+ packet.set_dispatch_field(DISPATCH_FRAGMENT_HEADER);
+ packet.set_datagram_size(*size);
+ packet.set_datagram_tag(*tag);
+ packet.set_datagram_offset(*offset);
+ }
+ }
+ }
+}
diff --git a/src/wire/sixlowpan/iphc.rs b/src/wire/sixlowpan/iphc.rs
new file mode 100644
index 0000000..f9dcc2b
--- /dev/null
+++ b/src/wire/sixlowpan/iphc.rs
@@ -0,0 +1,948 @@
+//! Implementation of IP Header Compression from [RFC 6282 § 3.1].
+//! It defines the compression of IPv6 headers.
+//!
+//! [RFC 6282 § 3.1]: https://datatracker.ietf.org/doc/html/rfc6282#section-3.1
+
+use super::{
+ AddressContext, AddressMode, Error, NextHeader, Result, UnresolvedAddress, DISPATCH_IPHC_HEADER,
+};
+use crate::wire::{ieee802154::Address as LlAddress, ipv6, IpProtocol};
+use byteorder::{ByteOrder, NetworkEndian};
+
+mod field {
+ use crate::wire::field::*;
+
+ pub const IPHC_FIELD: Field = 0..2;
+}
+
+macro_rules! get_field {
+ ($name:ident, $mask:expr, $shift:expr) => {
+ fn $name(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::IPHC_FIELD]);
+ ((raw >> $shift) & $mask) as u8
+ }
+ };
+}
+
+macro_rules! set_field {
+ ($name:ident, $mask:expr, $shift:expr) => {
+ fn $name(&mut self, val: u8) {
+ let data = &mut self.buffer.as_mut()[field::IPHC_FIELD];
+ let mut raw = NetworkEndian::read_u16(data);
+
+ raw = (raw & !($mask << $shift)) | ((val as u16) << $shift);
+ NetworkEndian::write_u16(data, raw);
+ }
+ };
+}
+
+/// A read/write wrapper around a 6LoWPAN IPHC header.
+/// [RFC 6282 § 3.1] specifies the format of the header.
+///
+/// The header always start with the following base format (from [RFC 6282 § 3.1.1]):
+/// ```txt
+/// 0 1
+/// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+/// +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+/// | 0 | 1 | 1 | TF |NH | HLIM |CID|SAC| SAM | M |DAC| DAM |
+/// +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+/// ```
+/// With:
+/// - TF: Traffic Class and Flow Label
+/// - NH: Next Header
+/// - HLIM: Hop Limit
+/// - CID: Context Identifier Extension
+/// - SAC: Source Address Compression
+/// - SAM: Source Address Mode
+/// - M: Multicast Compression
+/// - DAC: Destination Address Compression
+/// - DAM: Destination Address Mode
+///
+/// Depending on the flags in the base format, the following fields are added to the header:
+/// - Traffic Class and Flow Label
+/// - Next Header
+/// - Hop Limit
+/// - IPv6 source address
+/// - IPv6 destination address
+///
+/// [RFC 6282 § 3.1]: https://datatracker.ietf.org/doc/html/rfc6282#section-3.1
+/// [RFC 6282 § 3.1.1]: https://datatracker.ietf.org/doc/html/rfc6282#section-3.1.1
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Input a raw octet buffer with a 6LoWPAN IPHC header structure.
+ pub const fn new_unchecked(buffer: T) -> Self {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let buffer = self.buffer.as_ref();
+ if buffer.len() < 2 {
+ return Err(Error);
+ }
+
+ let mut offset = self.ip_fields_start()
+ + self.traffic_class_size()
+ + self.next_header_size()
+ + self.hop_limit_size();
+ offset += self.src_address_size();
+ offset += self.dst_address_size();
+
+ if offset as usize > buffer.len() {
+ return Err(Error);
+ }
+
+ Ok(())
+ }
+
+ /// Consumes the frame, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the Next Header field.
+ pub fn next_header(&self) -> NextHeader {
+ let nh = self.nh_field();
+
+ if nh == 1 {
+ // The next header field is compressed.
+ // It is also encoded using LOWPAN_NHC.
+ NextHeader::Compressed
+ } else {
+ // The full 8 bits for Next Header are carried in-line.
+ let start = (self.ip_fields_start() + self.traffic_class_size()) as usize;
+
+ let data = self.buffer.as_ref();
+ let nh = data[start..start + 1][0];
+ NextHeader::Uncompressed(IpProtocol::from(nh))
+ }
+ }
+
+ /// Return the Hop Limit.
+ pub fn hop_limit(&self) -> u8 {
+ match self.hlim_field() {
+ 0b00 => {
+ let start = (self.ip_fields_start()
+ + self.traffic_class_size()
+ + self.next_header_size()) as usize;
+
+ let data = self.buffer.as_ref();
+ data[start..start + 1][0]
+ }
+ 0b01 => 1,
+ 0b10 => 64,
+ 0b11 => 255,
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the Source Context Identifier.
+ pub fn src_context_id(&self) -> Option<u8> {
+ if self.cid_field() == 1 {
+ let data = self.buffer.as_ref();
+ Some(data[2] >> 4)
+ } else {
+ None
+ }
+ }
+
+ /// Return the Destination Context Identifier.
+ pub fn dst_context_id(&self) -> Option<u8> {
+ if self.cid_field() == 1 {
+ let data = self.buffer.as_ref();
+ Some(data[2] & 0x0f)
+ } else {
+ None
+ }
+ }
+
+ /// Return the ECN field (when it is inlined).
+ pub fn ecn_field(&self) -> Option<u8> {
+ match self.tf_field() {
+ 0b00 | 0b01 | 0b10 => {
+ let start = self.ip_fields_start() as usize;
+ Some(self.buffer.as_ref()[start..][0] & 0b1100_0000)
+ }
+ 0b11 => None,
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the DSCP field (when it is inlined).
+ pub fn dscp_field(&self) -> Option<u8> {
+ match self.tf_field() {
+ 0b00 | 0b10 => {
+ let start = self.ip_fields_start() as usize;
+ Some(self.buffer.as_ref()[start..][0] & 0b111111)
+ }
+ 0b01 | 0b11 => None,
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the flow label field (when it is inlined).
+ pub fn flow_label_field(&self) -> Option<u16> {
+ match self.tf_field() {
+ 0b00 => {
+ let start = self.ip_fields_start() as usize;
+ Some(NetworkEndian::read_u16(
+ &self.buffer.as_ref()[start..][2..4],
+ ))
+ }
+ 0b01 => {
+ let start = self.ip_fields_start() as usize;
+ Some(NetworkEndian::read_u16(
+ &self.buffer.as_ref()[start..][1..3],
+ ))
+ }
+ 0b10 | 0b11 => None,
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the Source Address.
+ pub fn src_addr(&self) -> Result<UnresolvedAddress> {
+ let start = (self.ip_fields_start()
+ + self.traffic_class_size()
+ + self.next_header_size()
+ + self.hop_limit_size()) as usize;
+
+ let data = self.buffer.as_ref();
+ match (self.sac_field(), self.sam_field()) {
+ (0, 0b00) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullInline(
+ &data[start..][..16],
+ ))),
+ (0, 0b01) => Ok(UnresolvedAddress::WithoutContext(
+ AddressMode::InLine64bits(&data[start..][..8]),
+ )),
+ (0, 0b10) => Ok(UnresolvedAddress::WithoutContext(
+ AddressMode::InLine16bits(&data[start..][..2]),
+ )),
+ (0, 0b11) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided)),
+ (1, 0b00) => Ok(UnresolvedAddress::WithContext((
+ 0,
+ AddressMode::Unspecified,
+ ))),
+ (1, 0b01) => {
+ if let Some(id) = self.src_context_id() {
+ Ok(UnresolvedAddress::WithContext((
+ id as usize,
+ AddressMode::InLine64bits(&data[start..][..8]),
+ )))
+ } else {
+ Err(Error)
+ }
+ }
+ (1, 0b10) => {
+ if let Some(id) = self.src_context_id() {
+ Ok(UnresolvedAddress::WithContext((
+ id as usize,
+ AddressMode::InLine16bits(&data[start..][..2]),
+ )))
+ } else {
+ Err(Error)
+ }
+ }
+ (1, 0b11) => {
+ if let Some(id) = self.src_context_id() {
+ Ok(UnresolvedAddress::WithContext((
+ id as usize,
+ AddressMode::FullyElided,
+ )))
+ } else {
+ Err(Error)
+ }
+ }
+ _ => Err(Error),
+ }
+ }
+
+ /// Return the Destination Address.
+ pub fn dst_addr(&self) -> Result<UnresolvedAddress> {
+ let start = (self.ip_fields_start()
+ + self.traffic_class_size()
+ + self.next_header_size()
+ + self.hop_limit_size()
+ + self.src_address_size()) as usize;
+
+ let data = self.buffer.as_ref();
+ match (self.m_field(), self.dac_field(), self.dam_field()) {
+ (0, 0, 0b00) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullInline(
+ &data[start..][..16],
+ ))),
+ (0, 0, 0b01) => Ok(UnresolvedAddress::WithoutContext(
+ AddressMode::InLine64bits(&data[start..][..8]),
+ )),
+ (0, 0, 0b10) => Ok(UnresolvedAddress::WithoutContext(
+ AddressMode::InLine16bits(&data[start..][..2]),
+ )),
+ (0, 0, 0b11) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided)),
+ (0, 1, 0b00) => Ok(UnresolvedAddress::Reserved),
+ (0, 1, 0b01) => {
+ if let Some(id) = self.dst_context_id() {
+ Ok(UnresolvedAddress::WithContext((
+ id as usize,
+ AddressMode::InLine64bits(&data[start..][..8]),
+ )))
+ } else {
+ Err(Error)
+ }
+ }
+ (0, 1, 0b10) => {
+ if let Some(id) = self.dst_context_id() {
+ Ok(UnresolvedAddress::WithContext((
+ id as usize,
+ AddressMode::InLine16bits(&data[start..][..2]),
+ )))
+ } else {
+ Err(Error)
+ }
+ }
+ (0, 1, 0b11) => {
+ if let Some(id) = self.dst_context_id() {
+ Ok(UnresolvedAddress::WithContext((
+ id as usize,
+ AddressMode::FullyElided,
+ )))
+ } else {
+ Err(Error)
+ }
+ }
+ (1, 0, 0b00) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullInline(
+ &data[start..][..16],
+ ))),
+ (1, 0, 0b01) => Ok(UnresolvedAddress::WithoutContext(
+ AddressMode::Multicast48bits(&data[start..][..6]),
+ )),
+ (1, 0, 0b10) => Ok(UnresolvedAddress::WithoutContext(
+ AddressMode::Multicast32bits(&data[start..][..4]),
+ )),
+ (1, 0, 0b11) => Ok(UnresolvedAddress::WithoutContext(
+ AddressMode::Multicast8bits(&data[start..][..1]),
+ )),
+ (1, 1, 0b00) => Ok(UnresolvedAddress::WithContext((
+ 0,
+ AddressMode::NotSupported,
+ ))),
+ (1, 1, 0b01 | 0b10 | 0b11) => Ok(UnresolvedAddress::Reserved),
+ _ => Err(Error),
+ }
+ }
+
+ get_field!(dispatch_field, 0b111, 13);
+ get_field!(tf_field, 0b11, 11);
+ get_field!(nh_field, 0b1, 10);
+ get_field!(hlim_field, 0b11, 8);
+ get_field!(cid_field, 0b1, 7);
+ get_field!(sac_field, 0b1, 6);
+ get_field!(sam_field, 0b11, 4);
+ get_field!(m_field, 0b1, 3);
+ get_field!(dac_field, 0b1, 2);
+ get_field!(dam_field, 0b11, 0);
+
+ /// Return the start for the IP fields.
+ fn ip_fields_start(&self) -> u8 {
+ 2 + self.cid_size()
+ }
+
+ /// Get the size in octets of the traffic class field.
+ fn traffic_class_size(&self) -> u8 {
+ match self.tf_field() {
+ 0b00 => 4,
+ 0b01 => 3,
+ 0b10 => 1,
+ 0b11 => 0,
+ _ => unreachable!(),
+ }
+ }
+
+ /// Get the size in octets of the next header field.
+ fn next_header_size(&self) -> u8 {
+ (self.nh_field() != 1) as u8
+ }
+
+ /// Get the size in octets of the hop limit field.
+ fn hop_limit_size(&self) -> u8 {
+ (self.hlim_field() == 0b00) as u8
+ }
+
+ /// Get the size in octets of the CID field.
+ fn cid_size(&self) -> u8 {
+ (self.cid_field() == 1) as u8
+ }
+
+ /// Get the size in octets of the source address.
+ fn src_address_size(&self) -> u8 {
+ match (self.sac_field(), self.sam_field()) {
+ (0, 0b00) => 16, // The full address is carried in-line.
+ (0, 0b01) => 8, // The first 64 bits are elided.
+ (0, 0b10) => 2, // The first 112 bits are elided.
+ (0, 0b11) => 0, // The address is fully elided.
+ (1, 0b00) => 0, // The UNSPECIFIED address.
+ (1, 0b01) => 8, // Address derived using context information.
+ (1, 0b10) => 2, // Address derived using context information.
+ (1, 0b11) => 0, // Address derived using context information.
+ _ => unreachable!(),
+ }
+ }
+
+ /// Get the size in octets of the address address.
+ fn dst_address_size(&self) -> u8 {
+ match (self.m_field(), self.dac_field(), self.dam_field()) {
+ (0, 0, 0b00) => 16, // The full address is carried in-line.
+ (0, 0, 0b01) => 8, // The first 64 bits are elided.
+ (0, 0, 0b10) => 2, // The first 112 bits are elided.
+ (0, 0, 0b11) => 0, // The address is fully elided.
+ (0, 1, 0b00) => 0, // Reserved.
+ (0, 1, 0b01) => 8, // Address derived using context information.
+ (0, 1, 0b10) => 2, // Address derived using context information.
+ (0, 1, 0b11) => 0, // Address derived using context information.
+ (1, 0, 0b00) => 16, // The full address is carried in-line.
+ (1, 0, 0b01) => 6, // The address takes the form ffXX::00XX:XXXX:XXXX.
+ (1, 0, 0b10) => 4, // The address takes the form ffXX::00XX:XXXX.
+ (1, 0, 0b11) => 1, // The address takes the form ff02::00XX.
+ (1, 1, 0b00) => 6, // Match Unicast-Prefix-based IPv6.
+ (1, 1, 0b01) => 0, // Reserved.
+ (1, 1, 0b10) => 0, // Reserved.
+ (1, 1, 0b11) => 0, // Reserved.
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the length of the header.
+ pub fn header_len(&self) -> usize {
+ let mut len = self.ip_fields_start();
+ len += self.traffic_class_size();
+ len += self.next_header_size();
+ len += self.hop_limit_size();
+ len += self.src_address_size();
+ len += self.dst_address_size();
+
+ len as usize
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the payload.
+ pub fn payload(&self) -> &'a [u8] {
+ let mut len = self.ip_fields_start();
+ len += self.traffic_class_size();
+ len += self.next_header_size();
+ len += self.hop_limit_size();
+ len += self.src_address_size();
+ len += self.dst_address_size();
+
+ let len = len as usize;
+
+ let data = self.buffer.as_ref();
+ &data[len..]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the dispatch field to `0b011`.
+ fn set_dispatch_field(&mut self) {
+ let data = &mut self.buffer.as_mut()[field::IPHC_FIELD];
+ let mut raw = NetworkEndian::read_u16(data);
+
+ raw = (raw & !(0b111 << 13)) | (0b11 << 13);
+ NetworkEndian::write_u16(data, raw);
+ }
+
+ set_field!(set_tf_field, 0b11, 11);
+ set_field!(set_nh_field, 0b1, 10);
+ set_field!(set_hlim_field, 0b11, 8);
+ set_field!(set_cid_field, 0b1, 7);
+ set_field!(set_sac_field, 0b1, 6);
+ set_field!(set_sam_field, 0b11, 4);
+ set_field!(set_m_field, 0b1, 3);
+ set_field!(set_dac_field, 0b1, 2);
+ set_field!(set_dam_field, 0b11, 0);
+
+ fn set_field(&mut self, idx: usize, value: &[u8]) {
+ let raw = self.buffer.as_mut();
+ raw[idx..idx + value.len()].copy_from_slice(value);
+ }
+
+ /// Set the Next Header.
+ ///
+ /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
+ fn set_next_header(&mut self, nh: NextHeader, mut idx: usize) -> usize {
+ match nh {
+ NextHeader::Uncompressed(nh) => {
+ self.set_nh_field(0);
+ self.set_field(idx, &[nh.into()]);
+ idx += 1;
+ }
+ NextHeader::Compressed => self.set_nh_field(1),
+ }
+
+ idx
+ }
+
+ /// Set the Hop Limit.
+ ///
+ /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
+ fn set_hop_limit(&mut self, hl: u8, mut idx: usize) -> usize {
+ match hl {
+ 255 => self.set_hlim_field(0b11),
+ 64 => self.set_hlim_field(0b10),
+ 1 => self.set_hlim_field(0b01),
+ _ => {
+ self.set_hlim_field(0b00);
+ self.set_field(idx, &[hl]);
+ idx += 1;
+ }
+ }
+
+ idx
+ }
+
+ /// Set the Source Address based on the IPv6 address and the Link-Local address.
+ ///
+ /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
+ fn set_src_address(
+ &mut self,
+ src_addr: ipv6::Address,
+ ll_src_addr: Option<LlAddress>,
+ mut idx: usize,
+ ) -> usize {
+ self.set_cid_field(0);
+ self.set_sac_field(0);
+ let src = src_addr.as_bytes();
+ if src_addr == ipv6::Address::UNSPECIFIED {
+ self.set_sac_field(1);
+ self.set_sam_field(0b00);
+ } else if src_addr.is_link_local() {
+ // We have a link local address.
+ // The remainder of the address can be elided when the context contains
+ // a 802.15.4 short address or a 802.15.4 extended address which can be
+ // converted to a eui64 address.
+ let is_eui_64 = ll_src_addr
+ .map(|addr| {
+ addr.as_eui_64()
+ .map(|addr| addr[..] == src[8..])
+ .unwrap_or(false)
+ })
+ .unwrap_or(false);
+
+ if src[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
+ let ll = [src[14], src[15]];
+
+ if ll_src_addr == Some(LlAddress::Short(ll)) {
+ // We have the context from the 802.15.4 frame.
+ // The context contains the short address.
+ // We can elide the source address.
+ self.set_sam_field(0b11);
+ } else {
+ // We don't have the context from the 802.15.4 frame.
+ // We cannot elide the source address, however we can elide 112 bits.
+ self.set_sam_field(0b10);
+
+ self.set_field(idx, &src[14..]);
+ idx += 2;
+ }
+ } else if is_eui_64 {
+ // We have the context from the 802.15.4 frame.
+ // The context contains the extended address.
+ // We can elide the source address.
+ self.set_sam_field(0b11);
+ } else {
+ // We cannot elide the source address, however we can elide 64 bits.
+ self.set_sam_field(0b01);
+
+ self.set_field(idx, &src[8..]);
+ idx += 8;
+ }
+ } else {
+ // We cannot elide anything.
+ self.set_sam_field(0b00);
+ self.set_field(idx, src);
+ idx += 16;
+ }
+
+ idx
+ }
+
+ /// Set the Destination Address based on the IPv6 address and the Link-Local address.
+ ///
+ /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
+ fn set_dst_address(
+ &mut self,
+ dst_addr: ipv6::Address,
+ ll_dst_addr: Option<LlAddress>,
+ mut idx: usize,
+ ) -> usize {
+ self.set_dac_field(0);
+ self.set_dam_field(0);
+ self.set_m_field(0);
+ let dst = dst_addr.as_bytes();
+ if dst_addr.is_multicast() {
+ self.set_m_field(1);
+
+ if dst[1] == 0x02 && dst[2..15] == [0; 13] {
+ self.set_dam_field(0b11);
+
+ self.set_field(idx, &[dst[15]]);
+ idx += 1;
+ } else if dst[2..13] == [0; 11] {
+ self.set_dam_field(0b10);
+
+ self.set_field(idx, &[dst[1]]);
+ idx += 1;
+ self.set_field(idx, &dst[13..]);
+ idx += 3;
+ } else if dst[2..11] == [0; 9] {
+ self.set_dam_field(0b01);
+
+ self.set_field(idx, &[dst[1]]);
+ idx += 1;
+ self.set_field(idx, &dst[11..]);
+ idx += 5;
+ } else {
+ self.set_dam_field(0b11);
+
+ self.set_field(idx, dst);
+ idx += 16;
+ }
+ } else if dst_addr.is_link_local() {
+ let is_eui_64 = ll_dst_addr
+ .map(|addr| {
+ addr.as_eui_64()
+ .map(|addr| addr[..] == dst[8..])
+ .unwrap_or(false)
+ })
+ .unwrap_or(false);
+
+ if dst[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
+ let ll = [dst[14], dst[15]];
+
+ if ll_dst_addr == Some(LlAddress::Short(ll)) {
+ self.set_dam_field(0b11);
+ } else {
+ self.set_dam_field(0b10);
+
+ self.set_field(idx, &dst[14..]);
+ idx += 2;
+ }
+ } else if is_eui_64 {
+ self.set_dam_field(0b11);
+ } else {
+ self.set_dam_field(0b01);
+
+ self.set_field(idx, &dst[8..]);
+ idx += 8;
+ }
+ } else {
+ self.set_dam_field(0b00);
+
+ self.set_field(idx, dst);
+ idx += 16;
+ }
+
+ idx
+ }
+
+ /// Return a mutable pointer to the payload.
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let mut len = self.ip_fields_start();
+
+ len += self.traffic_class_size();
+ len += self.next_header_size();
+ len += self.hop_limit_size();
+ len += self.src_address_size();
+ len += self.dst_address_size();
+
+ let len = len as usize;
+
+ let data = self.buffer.as_mut();
+ &mut data[len..]
+ }
+}
+
+/// A high-level representation of a 6LoWPAN IPHC header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Repr {
+ pub src_addr: ipv6::Address,
+ pub ll_src_addr: Option<LlAddress>,
+ pub dst_addr: ipv6::Address,
+ pub ll_dst_addr: Option<LlAddress>,
+ pub next_header: NextHeader,
+ pub hop_limit: u8,
+ // TODO(thvdveld): refactor the following fields into something else
+ pub ecn: Option<u8>,
+ pub dscp: Option<u8>,
+ pub flow_label: Option<u16>,
+}
+
+impl core::fmt::Display for Repr {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ write!(
+ f,
+ "IPHC src={} dst={} nxt-hdr={} hop-limit={}",
+ self.src_addr, self.dst_addr, self.next_header, self.hop_limit
+ )
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Repr {
+ fn format(&self, fmt: defmt::Formatter) {
+ defmt::write!(
+ fmt,
+ "IPHC src={} dst={} nxt-hdr={} hop-limit={}",
+ self.src_addr,
+ self.dst_addr,
+ self.next_header,
+ self.hop_limit
+ );
+ }
+}
+
+impl Repr {
+ /// Parse a 6LoWPAN IPHC header and return a high-level representation.
+ ///
+ /// The `ll_src_addr` and `ll_dst_addr` are the link-local addresses used for resolving the
+ /// IPv6 packets.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(
+ packet: &Packet<&T>,
+ ll_src_addr: Option<LlAddress>,
+ ll_dst_addr: Option<LlAddress>,
+ addr_context: &[AddressContext],
+ ) -> Result<Self> {
+ // Ensure basic accessors will work.
+ packet.check_len()?;
+
+ if packet.dispatch_field() != DISPATCH_IPHC_HEADER {
+ // This is not an LOWPAN_IPHC packet.
+ return Err(Error);
+ }
+
+ let src_addr = packet.src_addr()?.resolve(ll_src_addr, addr_context)?;
+ let dst_addr = packet.dst_addr()?.resolve(ll_dst_addr, addr_context)?;
+
+ Ok(Self {
+ src_addr,
+ ll_src_addr,
+ dst_addr,
+ ll_dst_addr,
+ next_header: packet.next_header(),
+ hop_limit: packet.hop_limit(),
+ ecn: packet.ecn_field(),
+ dscp: packet.dscp_field(),
+ flow_label: packet.flow_label_field(),
+ })
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub fn buffer_len(&self) -> usize {
+ let mut len = 0;
+ len += 2; // The minimal header length
+
+ len += match self.next_header {
+ NextHeader::Compressed => 0, // The next header is compressed (we don't need to inline what the next header is)
+ NextHeader::Uncompressed(_) => 1, // The next header field is inlined
+ };
+
+ // Hop Limit size
+ len += match self.hop_limit {
+ 255 | 64 | 1 => 0, // We can inline the hop limit
+ _ => 1,
+ };
+
+ // Add the length of the source address
+ len += if self.src_addr == ipv6::Address::UNSPECIFIED {
+ 0
+ } else if self.src_addr.is_link_local() {
+ let src = self.src_addr.as_bytes();
+ let ll = [src[14], src[15]];
+
+ let is_eui_64 = self
+ .ll_src_addr
+ .map(|addr| {
+ addr.as_eui_64()
+ .map(|addr| addr[..] == src[8..])
+ .unwrap_or(false)
+ })
+ .unwrap_or(false);
+
+ if src[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
+ if self.ll_src_addr == Some(LlAddress::Short(ll)) {
+ 0
+ } else {
+ 2
+ }
+ } else if is_eui_64 {
+ 0
+ } else {
+ 8
+ }
+ } else {
+ 16
+ };
+
+ // Add the size of the destination header
+ let dst = self.dst_addr.as_bytes();
+ len += if self.dst_addr.is_multicast() {
+ if dst[1] == 0x02 && dst[2..15] == [0; 13] {
+ 1
+ } else if dst[2..13] == [0; 11] {
+ 4
+ } else if dst[2..11] == [0; 9] {
+ 6
+ } else {
+ 16
+ }
+ } else if self.dst_addr.is_link_local() {
+ let is_eui_64 = self
+ .ll_dst_addr
+ .map(|addr| {
+ addr.as_eui_64()
+ .map(|addr| addr[..] == dst[8..])
+ .unwrap_or(false)
+ })
+ .unwrap_or(false);
+
+ if dst[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
+ let ll = [dst[14], dst[15]];
+
+ if self.ll_dst_addr == Some(LlAddress::Short(ll)) {
+ 0
+ } else {
+ 2
+ }
+ } else if is_eui_64 {
+ 0
+ } else {
+ 8
+ }
+ } else {
+ 16
+ };
+
+ len += match (self.ecn, self.dscp, self.flow_label) {
+ (Some(_), Some(_), Some(_)) => 4,
+ (Some(_), None, Some(_)) => 3,
+ (Some(_), Some(_), None) => 1,
+ (None, None, None) => 0,
+ _ => unreachable!(),
+ };
+
+ len
+ }
+
+ /// Emit a high-level representation into a 6LoWPAN IPHC header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
+ let idx = 2;
+
+ packet.set_dispatch_field();
+
+ // FIXME(thvdveld): we don't set anything from the traffic flow.
+ packet.set_tf_field(0b11);
+
+ let idx = packet.set_next_header(self.next_header, idx);
+ let idx = packet.set_hop_limit(self.hop_limit, idx);
+ let idx = packet.set_src_address(self.src_addr, self.ll_src_addr, idx);
+ packet.set_dst_address(self.dst_addr, self.ll_dst_addr, idx);
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn iphc_fields() {
+ let bytes = [
+ 0x7a, 0x33, // IPHC
+ 0x3a, // Next header
+ ];
+
+ let packet = Packet::new_unchecked(bytes);
+
+ assert_eq!(packet.dispatch_field(), 0b011);
+ assert_eq!(packet.tf_field(), 0b11);
+ assert_eq!(packet.nh_field(), 0b0);
+ assert_eq!(packet.hlim_field(), 0b10);
+ assert_eq!(packet.cid_field(), 0b0);
+ assert_eq!(packet.sac_field(), 0b0);
+ assert_eq!(packet.sam_field(), 0b11);
+ assert_eq!(packet.m_field(), 0b0);
+ assert_eq!(packet.dac_field(), 0b0);
+ assert_eq!(packet.dam_field(), 0b11);
+
+ assert_eq!(
+ packet.next_header(),
+ NextHeader::Uncompressed(IpProtocol::Icmpv6)
+ );
+
+ assert_eq!(packet.src_address_size(), 0);
+ assert_eq!(packet.dst_address_size(), 0);
+ assert_eq!(packet.hop_limit(), 64);
+
+ assert_eq!(
+ packet.src_addr(),
+ Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided))
+ );
+ assert_eq!(
+ packet.dst_addr(),
+ Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided))
+ );
+
+ let bytes = [
+ 0x7e, 0xf7, // IPHC,
+ 0x00, // CID
+ ];
+
+ let packet = Packet::new_unchecked(bytes);
+
+ assert_eq!(packet.dispatch_field(), 0b011);
+ assert_eq!(packet.tf_field(), 0b11);
+ assert_eq!(packet.nh_field(), 0b1);
+ assert_eq!(packet.hlim_field(), 0b10);
+ assert_eq!(packet.cid_field(), 0b1);
+ assert_eq!(packet.sac_field(), 0b1);
+ assert_eq!(packet.sam_field(), 0b11);
+ assert_eq!(packet.m_field(), 0b0);
+ assert_eq!(packet.dac_field(), 0b1);
+ assert_eq!(packet.dam_field(), 0b11);
+
+ assert_eq!(packet.next_header(), NextHeader::Compressed);
+
+ assert_eq!(packet.src_address_size(), 0);
+ assert_eq!(packet.dst_address_size(), 0);
+ assert_eq!(packet.hop_limit(), 64);
+
+ assert_eq!(
+ packet.src_addr(),
+ Ok(UnresolvedAddress::WithContext((
+ 0,
+ AddressMode::FullyElided
+ )))
+ );
+ assert_eq!(
+ packet.dst_addr(),
+ Ok(UnresolvedAddress::WithContext((
+ 0,
+ AddressMode::FullyElided
+ )))
+ );
+ }
+}
diff --git a/src/wire/sixlowpan/mod.rs b/src/wire/sixlowpan/mod.rs
new file mode 100644
index 0000000..03a5218
--- /dev/null
+++ b/src/wire/sixlowpan/mod.rs
@@ -0,0 +1,371 @@
+//! Implementation of [RFC 6282] which specifies a compression format for IPv6 datagrams over
+//! IEEE802.154-based networks.
+//!
+//! [RFC 6282]: https://datatracker.ietf.org/doc/html/rfc6282
+
+use super::{Error, Result};
+use crate::wire::ieee802154::Address as LlAddress;
+use crate::wire::ipv6;
+use crate::wire::IpProtocol;
+
+pub mod frag;
+pub mod iphc;
+pub mod nhc;
+
+const ADDRESS_CONTEXT_LENGTH: usize = 8;
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct AddressContext(pub [u8; ADDRESS_CONTEXT_LENGTH]);
+
+/// The representation of an unresolved address. 6LoWPAN compression of IPv6 addresses can be with
+/// and without context information. The decompression with context information is not yet
+/// implemented.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum UnresolvedAddress<'a> {
+ WithoutContext(AddressMode<'a>),
+ WithContext((usize, AddressMode<'a>)),
+ Reserved,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum AddressMode<'a> {
+ /// The full address is carried in-line.
+ FullInline(&'a [u8]),
+ /// The first 64-bits of the address are elided. The value of those bits
+ /// is the link-local prefix padded with zeros. The remaining 64 bits are
+ /// carried in-line.
+ InLine64bits(&'a [u8]),
+ /// The first 112 bits of the address are elided. The value of the first
+ /// 64 bits is the link-local prefix padded with zeros. The following 64 bits
+ /// are 0000:00ff:fe00:XXXX, where XXXX are the 16 bits carried in-line.
+ InLine16bits(&'a [u8]),
+ /// The address is fully elided. The first 64 bits of the address are
+ /// the link-local prefix padded with zeros. The remaining 64 bits are
+ /// computed from the encapsulating header (e.g., 802.15.4 or IPv6 source address)
+ /// as specified in Section 3.2.2.
+ FullyElided,
+ /// The address takes the form ffXX::00XX:XXXX:XXXX
+ Multicast48bits(&'a [u8]),
+ /// The address takes the form ffXX::00XX:XXXX.
+ Multicast32bits(&'a [u8]),
+ /// The address takes the form ff02::00XX.
+ Multicast8bits(&'a [u8]),
+ /// The unspecified address.
+ Unspecified,
+ NotSupported,
+}
+
+const LINK_LOCAL_PREFIX: [u8; 2] = [0xfe, 0x80];
+const EUI64_MIDDLE_VALUE: [u8; 2] = [0xff, 0xfe];
+
+impl<'a> UnresolvedAddress<'a> {
+ pub fn resolve(
+ self,
+ ll_address: Option<LlAddress>,
+ addr_context: &[AddressContext],
+ ) -> Result<ipv6::Address> {
+ let mut bytes = [0; 16];
+
+ let copy_context = |index: usize, bytes: &mut [u8]| -> Result<()> {
+ if index >= addr_context.len() {
+ return Err(Error);
+ }
+
+ let context = addr_context[index];
+ bytes[..ADDRESS_CONTEXT_LENGTH].copy_from_slice(&context.0);
+
+ Ok(())
+ };
+
+ match self {
+ UnresolvedAddress::WithoutContext(mode) => match mode {
+ AddressMode::FullInline(addr) => Ok(ipv6::Address::from_bytes(addr)),
+ AddressMode::InLine64bits(inline) => {
+ bytes[0..2].copy_from_slice(&LINK_LOCAL_PREFIX[..]);
+ bytes[8..].copy_from_slice(inline);
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ AddressMode::InLine16bits(inline) => {
+ bytes[0..2].copy_from_slice(&LINK_LOCAL_PREFIX[..]);
+ bytes[11..13].copy_from_slice(&EUI64_MIDDLE_VALUE[..]);
+ bytes[14..].copy_from_slice(inline);
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ AddressMode::FullyElided => {
+ bytes[0..2].copy_from_slice(&LINK_LOCAL_PREFIX[..]);
+ match ll_address {
+ Some(LlAddress::Short(ll)) => {
+ bytes[11..13].copy_from_slice(&EUI64_MIDDLE_VALUE[..]);
+ bytes[14..].copy_from_slice(&ll);
+ }
+ Some(addr @ LlAddress::Extended(_)) => match addr.as_eui_64() {
+ Some(addr) => bytes[8..].copy_from_slice(&addr),
+ None => return Err(Error),
+ },
+ Some(LlAddress::Absent) => return Err(Error),
+ None => return Err(Error),
+ }
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ AddressMode::Multicast48bits(inline) => {
+ bytes[0] = 0xff;
+ bytes[1] = inline[0];
+ bytes[11..].copy_from_slice(&inline[1..][..5]);
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ AddressMode::Multicast32bits(inline) => {
+ bytes[0] = 0xff;
+ bytes[1] = inline[0];
+ bytes[13..].copy_from_slice(&inline[1..][..3]);
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ AddressMode::Multicast8bits(inline) => {
+ bytes[0] = 0xff;
+ bytes[1] = 0x02;
+ bytes[15] = inline[0];
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ _ => Err(Error),
+ },
+ UnresolvedAddress::WithContext(mode) => match mode {
+ (_, AddressMode::Unspecified) => Ok(ipv6::Address::UNSPECIFIED),
+ (index, AddressMode::InLine64bits(inline)) => {
+ copy_context(index, &mut bytes[..])?;
+ bytes[16 - inline.len()..].copy_from_slice(inline);
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ (index, AddressMode::InLine16bits(inline)) => {
+ copy_context(index, &mut bytes[..])?;
+ bytes[16 - inline.len()..].copy_from_slice(inline);
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ (index, AddressMode::FullyElided) => {
+ match ll_address {
+ Some(LlAddress::Short(ll)) => {
+ bytes[11..13].copy_from_slice(&EUI64_MIDDLE_VALUE[..]);
+ bytes[14..].copy_from_slice(&ll);
+ }
+ Some(addr @ LlAddress::Extended(_)) => match addr.as_eui_64() {
+ Some(addr) => bytes[8..].copy_from_slice(&addr),
+ None => return Err(Error),
+ },
+ Some(LlAddress::Absent) => return Err(Error),
+ None => return Err(Error),
+ }
+
+ copy_context(index, &mut bytes[..])?;
+
+ Ok(ipv6::Address::from_bytes(&bytes[..]))
+ }
+ _ => Err(Error),
+ },
+ UnresolvedAddress::Reserved => Err(Error),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SixlowpanPacket {
+ FragmentHeader,
+ IphcHeader,
+}
+
+const DISPATCH_FIRST_FRAGMENT_HEADER: u8 = 0b11000;
+const DISPATCH_FRAGMENT_HEADER: u8 = 0b11100;
+const DISPATCH_IPHC_HEADER: u8 = 0b011;
+const DISPATCH_UDP_HEADER: u8 = 0b11110;
+const DISPATCH_EXT_HEADER: u8 = 0b1110;
+
+impl SixlowpanPacket {
+ /// Returns the type of the 6LoWPAN header.
+ /// This can either be a fragment header or an IPHC header.
+ ///
+ /// # Errors
+ /// Returns `[Error::Unrecognized]` when neither the Fragment Header dispatch or the IPHC
+ /// dispatch is recognized.
+ pub fn dispatch(buffer: impl AsRef<[u8]>) -> Result<Self> {
+ let raw = buffer.as_ref();
+
+ if raw.is_empty() {
+ return Err(Error);
+ }
+
+ if raw[0] >> 3 == DISPATCH_FIRST_FRAGMENT_HEADER || raw[0] >> 3 == DISPATCH_FRAGMENT_HEADER
+ {
+ Ok(Self::FragmentHeader)
+ } else if raw[0] >> 5 == DISPATCH_IPHC_HEADER {
+ Ok(Self::IphcHeader)
+ } else {
+ Err(Error)
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum NextHeader {
+ Compressed,
+ Uncompressed(IpProtocol),
+}
+
+impl core::fmt::Display for NextHeader {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ NextHeader::Compressed => write!(f, "compressed"),
+ NextHeader::Uncompressed(protocol) => write!(f, "{protocol}"),
+ }
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for NextHeader {
+ fn format(&self, fmt: defmt::Formatter) {
+ match self {
+ NextHeader::Compressed => defmt::write!(fmt, "compressed"),
+ NextHeader::Uncompressed(protocol) => defmt::write!(fmt, "{}", protocol),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn sixlowpan_fragment_emit() {
+ let repr = frag::Repr::FirstFragment {
+ size: 0xff,
+ tag: 0xabcd,
+ };
+ let buffer = [0u8; 4];
+ let mut packet = frag::Packet::new_unchecked(buffer);
+
+ assert_eq!(repr.buffer_len(), 4);
+ repr.emit(&mut packet);
+
+ assert_eq!(packet.datagram_size(), 0xff);
+ assert_eq!(packet.datagram_tag(), 0xabcd);
+ assert_eq!(packet.into_inner(), [0xc0, 0xff, 0xab, 0xcd]);
+
+ let repr = frag::Repr::Fragment {
+ size: 0xff,
+ tag: 0xabcd,
+ offset: 0xcc,
+ };
+ let buffer = [0u8; 5];
+ let mut packet = frag::Packet::new_unchecked(buffer);
+
+ assert_eq!(repr.buffer_len(), 5);
+ repr.emit(&mut packet);
+
+ assert_eq!(packet.datagram_size(), 0xff);
+ assert_eq!(packet.datagram_tag(), 0xabcd);
+ assert_eq!(packet.into_inner(), [0xe0, 0xff, 0xab, 0xcd, 0xcc]);
+ }
+
+ #[test]
+ fn sixlowpan_three_fragments() {
+ use crate::wire::ieee802154::Frame as Ieee802154Frame;
+ use crate::wire::ieee802154::Repr as Ieee802154Repr;
+ use crate::wire::Ieee802154Address;
+
+ let key = frag::Key {
+ ll_src_addr: Ieee802154Address::Extended([50, 147, 130, 47, 40, 8, 62, 217]),
+ ll_dst_addr: Ieee802154Address::Extended([26, 11, 66, 66, 66, 66, 66, 66]),
+ datagram_size: 307,
+ datagram_tag: 63,
+ };
+
+ let frame1: &[u8] = &[
+ 0x41, 0xcc, 0x92, 0xef, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0xd9,
+ 0x3e, 0x08, 0x28, 0x2f, 0x82, 0x93, 0x32, 0xc1, 0x33, 0x00, 0x3f, 0x6e, 0x33, 0x02,
+ 0x35, 0x3d, 0xf0, 0xd2, 0x5f, 0x1b, 0x39, 0xb4, 0x6b, 0x4c, 0x6f, 0x72, 0x65, 0x6d,
+ 0x20, 0x69, 0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x73,
+ 0x69, 0x74, 0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65,
+ 0x63, 0x74, 0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70, 0x69, 0x73, 0x63,
+ 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x2e, 0x20, 0x41, 0x6c, 0x69, 0x71,
+ 0x75, 0x61, 0x6d, 0x20, 0x64, 0x75, 0x69, 0x20, 0x6f, 0x64, 0x69, 0x6f, 0x2c, 0x20,
+ 0x69, 0x61, 0x63, 0x75, 0x6c, 0x69, 0x73, 0x20, 0x76, 0x65, 0x6c, 0x20, 0x72,
+ ];
+
+ let ieee802154_frame = Ieee802154Frame::new_checked(frame1).unwrap();
+ let ieee802154_repr = Ieee802154Repr::parse(&ieee802154_frame).unwrap();
+
+ let sixlowpan_frame =
+ SixlowpanPacket::dispatch(ieee802154_frame.payload().unwrap()).unwrap();
+
+ let frag = if let SixlowpanPacket::FragmentHeader = sixlowpan_frame {
+ frag::Packet::new_checked(ieee802154_frame.payload().unwrap()).unwrap()
+ } else {
+ unreachable!()
+ };
+
+ assert_eq!(frag.datagram_size(), 307);
+ assert_eq!(frag.datagram_tag(), 0x003f);
+ assert_eq!(frag.datagram_offset(), 0);
+
+ assert_eq!(frag.get_key(&ieee802154_repr), key);
+
+ let frame2: &[u8] = &[
+ 0x41, 0xcc, 0x93, 0xef, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0xd9,
+ 0x3e, 0x08, 0x28, 0x2f, 0x82, 0x93, 0x32, 0xe1, 0x33, 0x00, 0x3f, 0x11, 0x75, 0x74,
+ 0x72, 0x75, 0x6d, 0x20, 0x61, 0x74, 0x2c, 0x20, 0x74, 0x72, 0x69, 0x73, 0x74, 0x69,
+ 0x71, 0x75, 0x65, 0x20, 0x6e, 0x6f, 0x6e, 0x20, 0x6e, 0x75, 0x6e, 0x63, 0x20, 0x65,
+ 0x72, 0x61, 0x74, 0x20, 0x63, 0x75, 0x72, 0x61, 0x65, 0x2e, 0x20, 0x4c, 0x6f, 0x72,
+ 0x65, 0x6d, 0x20, 0x69, 0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f, 0x6c, 0x6f, 0x72,
+ 0x20, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63, 0x6f, 0x6e,
+ 0x73, 0x65, 0x63, 0x74, 0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70, 0x69,
+ 0x73, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c, 0x69, 0x74,
+ ];
+
+ let ieee802154_frame = Ieee802154Frame::new_checked(frame2).unwrap();
+ let ieee802154_repr = Ieee802154Repr::parse(&ieee802154_frame).unwrap();
+
+ let sixlowpan_frame =
+ SixlowpanPacket::dispatch(ieee802154_frame.payload().unwrap()).unwrap();
+
+ let frag = if let SixlowpanPacket::FragmentHeader = sixlowpan_frame {
+ frag::Packet::new_checked(ieee802154_frame.payload().unwrap()).unwrap()
+ } else {
+ unreachable!()
+ };
+
+ assert_eq!(frag.datagram_size(), 307);
+ assert_eq!(frag.datagram_tag(), 0x003f);
+ assert_eq!(frag.datagram_offset(), 136 / 8);
+
+ assert_eq!(frag.get_key(&ieee802154_repr), key);
+
+ let frame3: &[u8] = &[
+ 0x41, 0xcc, 0x94, 0xef, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0xd9,
+ 0x3e, 0x08, 0x28, 0x2f, 0x82, 0x93, 0x32, 0xe1, 0x33, 0x00, 0x3f, 0x1d, 0x2e, 0x20,
+ 0x41, 0x6c, 0x69, 0x71, 0x75, 0x61, 0x6d, 0x20, 0x64, 0x75, 0x69, 0x20, 0x6f, 0x64,
+ 0x69, 0x6f, 0x2c, 0x20, 0x69, 0x61, 0x63, 0x75, 0x6c, 0x69, 0x73, 0x20, 0x76, 0x65,
+ 0x6c, 0x20, 0x72, 0x75, 0x74, 0x72, 0x75, 0x6d, 0x20, 0x61, 0x74, 0x2c, 0x20, 0x74,
+ 0x72, 0x69, 0x73, 0x74, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x6f, 0x6e, 0x20, 0x6e,
+ 0x75, 0x6e, 0x63, 0x20, 0x65, 0x72, 0x61, 0x74, 0x20, 0x63, 0x75, 0x72, 0x61, 0x65,
+ 0x2e, 0x20, 0x0a,
+ ];
+
+ let ieee802154_frame = Ieee802154Frame::new_checked(frame3).unwrap();
+ let ieee802154_repr = Ieee802154Repr::parse(&ieee802154_frame).unwrap();
+
+ let sixlowpan_frame =
+ SixlowpanPacket::dispatch(ieee802154_frame.payload().unwrap()).unwrap();
+
+ let frag = if let SixlowpanPacket::FragmentHeader = sixlowpan_frame {
+ frag::Packet::new_checked(ieee802154_frame.payload().unwrap()).unwrap()
+ } else {
+ unreachable!()
+ };
+
+ assert_eq!(frag.datagram_size(), 307);
+ assert_eq!(frag.datagram_tag(), 0x003f);
+ assert_eq!(frag.datagram_offset(), 232 / 8);
+
+ assert_eq!(frag.get_key(&ieee802154_repr), key);
+ }
+}
diff --git a/src/wire/sixlowpan/nhc.rs b/src/wire/sixlowpan/nhc.rs
new file mode 100644
index 0000000..5539ce4
--- /dev/null
+++ b/src/wire/sixlowpan/nhc.rs
@@ -0,0 +1,890 @@
+//! Implementation of Next Header Compression from [RFC 6282 § 4].
+//!
+//! [RFC 6282 § 4]: https://datatracker.ietf.org/doc/html/rfc6282#section-4
+use super::{Error, NextHeader, Result, DISPATCH_EXT_HEADER, DISPATCH_UDP_HEADER};
+use crate::{
+ phy::ChecksumCapabilities,
+ wire::{
+ ip::{checksum, Address as IpAddress},
+ ipv6,
+ udp::Repr as UdpRepr,
+ IpProtocol,
+ },
+};
+use byteorder::{ByteOrder, NetworkEndian};
+use ipv6::Address;
+
+macro_rules! get_field {
+ ($name:ident, $mask:expr, $shift:expr) => {
+ fn $name(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ let raw = &data[0];
+ ((raw >> $shift) & $mask) as u8
+ }
+ };
+}
+
+macro_rules! set_field {
+ ($name:ident, $mask:expr, $shift:expr) => {
+ fn $name(&mut self, val: u8) {
+ let data = self.buffer.as_mut();
+ let mut raw = data[0];
+ raw = (raw & !($mask << $shift)) | (val << $shift);
+ data[0] = raw;
+ }
+ };
+}
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+/// A read/write wrapper around a 6LoWPAN_NHC Header.
+/// [RFC 6282 § 4.2] specifies the format of the header.
+///
+/// The header has the following format:
+/// ```txt
+/// 0 1 2 3 4 5 6 7
+/// +---+---+---+---+---+---+---+---+
+/// | 1 | 1 | 1 | 0 | EID |NH |
+/// +---+---+---+---+---+---+---+---+
+/// ```
+///
+/// With:
+/// - EID: the extension header ID
+/// - NH: Next Header
+///
+/// [RFC 6282 § 4.2]: https://datatracker.ietf.org/doc/html/rfc6282#section-4.2
+pub enum NhcPacket {
+ ExtHeader,
+ UdpHeader,
+}
+
+impl NhcPacket {
+ /// Returns the type of the Next Header header.
+ /// This can either be an Extension header or an 6LoWPAN Udp header.
+ ///
+ /// # Errors
+ /// Returns `[Error::Unrecognized]` when neither the Extension Header dispatch or the Udp
+ /// dispatch is recognized.
+ pub fn dispatch(buffer: impl AsRef<[u8]>) -> Result<Self> {
+ let raw = buffer.as_ref();
+ if raw.is_empty() {
+ return Err(Error);
+ }
+
+ if raw[0] >> 4 == DISPATCH_EXT_HEADER {
+ // We have a compressed IPv6 Extension Header.
+ Ok(Self::ExtHeader)
+ } else if raw[0] >> 3 == DISPATCH_UDP_HEADER {
+ // We have a compressed UDP header.
+ Ok(Self::UdpHeader)
+ } else {
+ Err(Error)
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum ExtHeaderId {
+ HopByHopHeader,
+ RoutingHeader,
+ FragmentHeader,
+ DestinationOptionsHeader,
+ MobilityHeader,
+ Header,
+ Reserved,
+}
+
+impl From<ExtHeaderId> for IpProtocol {
+ fn from(val: ExtHeaderId) -> Self {
+ match val {
+ ExtHeaderId::HopByHopHeader => Self::HopByHop,
+ ExtHeaderId::RoutingHeader => Self::Ipv6Route,
+ ExtHeaderId::FragmentHeader => Self::Ipv6Frag,
+ ExtHeaderId::DestinationOptionsHeader => Self::Ipv6Opts,
+ ExtHeaderId::MobilityHeader => Self::Unknown(0),
+ ExtHeaderId::Header => Self::Unknown(0),
+ ExtHeaderId::Reserved => Self::Unknown(0),
+ }
+ }
+}
+
+/// A read/write wrapper around a 6LoWPAN NHC Extension header.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct ExtHeaderPacket<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+impl<T: AsRef<[u8]>> ExtHeaderPacket<T> {
+ /// Input a raw octet buffer with a 6LoWPAN NHC Extension Header structure.
+ pub const fn new_unchecked(buffer: T) -> Self {
+ ExtHeaderPacket { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+
+ if packet.eid_field() > 7 {
+ return Err(Error);
+ }
+
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let buffer = self.buffer.as_ref();
+
+ if buffer.is_empty() {
+ return Err(Error);
+ }
+
+ let mut len = 2;
+ len += self.next_header_size();
+
+ if len <= buffer.len() {
+ Ok(())
+ } else {
+ Err(Error)
+ }
+ }
+
+ /// Consumes the frame, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ get_field!(dispatch_field, 0b1111, 4);
+ get_field!(eid_field, 0b111, 1);
+ get_field!(nh_field, 0b1, 0);
+
+ /// Return the Extension Header ID.
+ pub fn extension_header_id(&self) -> ExtHeaderId {
+ match self.eid_field() {
+ 0 => ExtHeaderId::HopByHopHeader,
+ 1 => ExtHeaderId::RoutingHeader,
+ 2 => ExtHeaderId::FragmentHeader,
+ 3 => ExtHeaderId::DestinationOptionsHeader,
+ 4 => ExtHeaderId::MobilityHeader,
+ 5 | 6 => ExtHeaderId::Reserved,
+ 7 => ExtHeaderId::Header,
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the length field.
+ pub fn length(&self) -> u8 {
+ self.buffer.as_ref()[1 + self.next_header_size()]
+ }
+
+ /// Parse the next header field.
+ pub fn next_header(&self) -> NextHeader {
+ if self.nh_field() == 1 {
+ NextHeader::Compressed
+ } else {
+ // The full 8 bits for Next Header are carried in-line.
+ NextHeader::Uncompressed(IpProtocol::from(self.buffer.as_ref()[1]))
+ }
+ }
+
+ /// Return the size of the Next Header field.
+ fn next_header_size(&self) -> usize {
+ // If nh is set, then the Next Header is compressed using LOWPAN_NHC
+ match self.nh_field() {
+ 0 => 1,
+ 1 => 0,
+ _ => unreachable!(),
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> ExtHeaderPacket<&'a T> {
+ /// Return a pointer to the payload.
+ pub fn payload(&self) -> &'a [u8] {
+ let start = 2 + self.next_header_size();
+ let len = self.length() as usize;
+ &self.buffer.as_ref()[start..][..len]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> ExtHeaderPacket<T> {
+ /// Return a mutable pointer to the payload.
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let start = 2 + self.next_header_size();
+ let len = self.length() as usize;
+ &mut self.buffer.as_mut()[start..][..len]
+ }
+
+ /// Set the dispatch field to `0b1110`.
+ fn set_dispatch_field(&mut self) {
+ let data = self.buffer.as_mut();
+ data[0] = (data[0] & !(0b1111 << 4)) | (DISPATCH_EXT_HEADER << 4);
+ }
+
+ set_field!(set_eid_field, 0b111, 1);
+ set_field!(set_nh_field, 0b1, 0);
+
+ /// Set the Extension Header ID field.
+ fn set_extension_header_id(&mut self, ext_header_id: ExtHeaderId) {
+ let id = match ext_header_id {
+ ExtHeaderId::HopByHopHeader => 0,
+ ExtHeaderId::RoutingHeader => 1,
+ ExtHeaderId::FragmentHeader => 2,
+ ExtHeaderId::DestinationOptionsHeader => 3,
+ ExtHeaderId::MobilityHeader => 4,
+ ExtHeaderId::Reserved => 5,
+ ExtHeaderId::Header => 7,
+ };
+
+ self.set_eid_field(id);
+ }
+
+ /// Set the Next Header.
+ fn set_next_header(&mut self, next_header: NextHeader) {
+ match next_header {
+ NextHeader::Compressed => self.set_nh_field(0b1),
+ NextHeader::Uncompressed(nh) => {
+ self.set_nh_field(0b0);
+
+ let start = 1;
+ let data = self.buffer.as_mut();
+ data[start] = nh.into();
+ }
+ }
+ }
+
+ /// Set the length.
+ fn set_length(&mut self, length: u8) {
+ let start = 1 + self.next_header_size();
+
+ let data = self.buffer.as_mut();
+ data[start] = length;
+ }
+}
+
+/// A high-level representation of an 6LoWPAN NHC Extension header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct ExtHeaderRepr {
+ pub ext_header_id: ExtHeaderId,
+ pub next_header: NextHeader,
+ pub length: u8,
+}
+
+impl ExtHeaderRepr {
+ /// Parse a 6LoWPAN NHC Extension Header packet and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(packet: &ExtHeaderPacket<&T>) -> Result<Self> {
+ // Ensure basic accessors will work.
+ packet.check_len()?;
+
+ if packet.dispatch_field() != DISPATCH_EXT_HEADER {
+ return Err(Error);
+ }
+
+ Ok(Self {
+ ext_header_id: packet.extension_header_id(),
+ next_header: packet.next_header(),
+ length: packet.length(),
+ })
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ pub fn buffer_len(&self) -> usize {
+ let mut len = 1; // The minimal header size
+
+ if self.next_header != NextHeader::Compressed {
+ len += 1;
+ }
+
+ len += 1; // The length
+
+ len
+ }
+
+ /// Emit a high-level representation into a 6LoWPAN NHC Extension Header packet.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut ExtHeaderPacket<T>) {
+ packet.set_dispatch_field();
+ packet.set_extension_header_id(self.ext_header_id);
+ packet.set_next_header(self.next_header);
+ packet.set_length(self.length);
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ use crate::wire::{Ipv6RoutingHeader, Ipv6RoutingRepr};
+
+ #[cfg(feature = "proto-rpl")]
+ use crate::wire::{
+ Ipv6Option, Ipv6OptionRepr, Ipv6OptionsIterator, RplHopByHopRepr, RplInstanceId,
+ };
+
+ #[cfg(feature = "proto-rpl")]
+ const RPL_HOP_BY_HOP_PACKET: [u8; 9] = [0xe0, 0x3a, 0x06, 0x63, 0x04, 0x00, 0x1e, 0x03, 0x00];
+
+ const ROUTING_SR_PACKET: [u8; 32] = [
+ 0xe3, 0x1e, 0x03, 0x03, 0x99, 0x30, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05,
+ 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00,
+ 0x00, 0x00,
+ ];
+
+ #[test]
+ #[cfg(feature = "proto-rpl")]
+ fn test_rpl_hop_by_hop_option_deconstruct() {
+ let header = ExtHeaderPacket::new_checked(&RPL_HOP_BY_HOP_PACKET).unwrap();
+ assert_eq!(
+ header.next_header(),
+ NextHeader::Uncompressed(IpProtocol::Icmpv6)
+ );
+ assert_eq!(header.extension_header_id(), ExtHeaderId::HopByHopHeader);
+
+ let options = header.payload();
+ let mut options = Ipv6OptionsIterator::new(options);
+ let rpl_repr = options.next().unwrap();
+ let rpl_repr = rpl_repr.unwrap();
+
+ match rpl_repr {
+ Ipv6OptionRepr::Rpl(rpl) => {
+ assert_eq!(
+ rpl,
+ RplHopByHopRepr {
+ down: false,
+ rank_error: false,
+ forwarding_error: false,
+ instance_id: RplInstanceId::from(0x1e),
+ sender_rank: 0x0300,
+ }
+ );
+ }
+ _ => unreachable!(),
+ }
+ }
+
+ #[test]
+ #[cfg(feature = "proto-rpl")]
+ fn test_rpl_hop_by_hop_option_emit() {
+ let repr = Ipv6OptionRepr::Rpl(RplHopByHopRepr {
+ down: false,
+ rank_error: false,
+ forwarding_error: false,
+ instance_id: RplInstanceId::from(0x1e),
+ sender_rank: 0x0300,
+ });
+
+ let ext_hdr = ExtHeaderRepr {
+ ext_header_id: ExtHeaderId::HopByHopHeader,
+ next_header: NextHeader::Uncompressed(IpProtocol::Icmpv6),
+ length: repr.buffer_len() as u8,
+ };
+
+ let mut buffer = vec![0u8; ext_hdr.buffer_len() + repr.buffer_len()];
+ ext_hdr.emit(&mut ExtHeaderPacket::new_unchecked(
+ &mut buffer[..ext_hdr.buffer_len()],
+ ));
+ repr.emit(&mut Ipv6Option::new_unchecked(
+ &mut buffer[ext_hdr.buffer_len()..],
+ ));
+
+ assert_eq!(&buffer[..], RPL_HOP_BY_HOP_PACKET);
+ }
+
+ #[test]
+ fn test_source_routing_deconstruct() {
+ let header = ExtHeaderPacket::new_checked(&ROUTING_SR_PACKET).unwrap();
+ assert_eq!(header.next_header(), NextHeader::Compressed);
+ assert_eq!(header.extension_header_id(), ExtHeaderId::RoutingHeader);
+
+ let routing_hdr = Ipv6RoutingHeader::new_checked(header.payload()).unwrap();
+ let repr = Ipv6RoutingRepr::parse(&routing_hdr).unwrap();
+ assert_eq!(
+ repr,
+ Ipv6RoutingRepr::Rpl {
+ segments_left: 3,
+ cmpr_i: 9,
+ cmpr_e: 9,
+ pad: 3,
+ addresses: &[
+ 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00,
+ 0x06, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00
+ ],
+ }
+ );
+ }
+
+ #[test]
+ fn test_source_routing_emit() {
+ let routing_hdr = Ipv6RoutingRepr::Rpl {
+ segments_left: 3,
+ cmpr_i: 9,
+ cmpr_e: 9,
+ pad: 3,
+ addresses: &[
+ 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06,
+ 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
+ ],
+ };
+
+ let ext_hdr = ExtHeaderRepr {
+ ext_header_id: ExtHeaderId::RoutingHeader,
+ next_header: NextHeader::Compressed,
+ length: routing_hdr.buffer_len() as u8,
+ };
+
+ let mut buffer = vec![0u8; ext_hdr.buffer_len() + routing_hdr.buffer_len()];
+ ext_hdr.emit(&mut ExtHeaderPacket::new_unchecked(
+ &mut buffer[..ext_hdr.buffer_len()],
+ ));
+ routing_hdr.emit(&mut Ipv6RoutingHeader::new_unchecked(
+ &mut buffer[ext_hdr.buffer_len()..],
+ ));
+
+ assert_eq!(&buffer[..], ROUTING_SR_PACKET);
+ }
+}
+
+/// A read/write wrapper around a 6LoWPAN_NHC UDP frame.
+/// [RFC 6282 § 4.3] specifies the format of the header.
+///
+/// The base header has the following format:
+/// ```txt
+/// 0 1 2 3 4 5 6 7
+/// +---+---+---+---+---+---+---+---+
+/// | 1 | 1 | 1 | 1 | 0 | C | P |
+/// +---+---+---+---+---+---+---+---+
+/// With:
+/// - C: checksum, specifies if the checksum is elided.
+/// - P: ports, specifies if the ports are elided.
+/// ```
+///
+/// [RFC 6282 § 4.3]: https://datatracker.ietf.org/doc/html/rfc6282#section-4.3
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct UdpNhcPacket<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+impl<T: AsRef<[u8]>> UdpNhcPacket<T> {
+ /// Input a raw octet buffer with a LOWPAN_NHC frame structure for UDP.
+ pub const fn new_unchecked(buffer: T) -> Self {
+ Self { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Self> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error::Truncated)` if the buffer is too short.
+ pub fn check_len(&self) -> Result<()> {
+ let buffer = self.buffer.as_ref();
+
+ if buffer.is_empty() {
+ return Err(Error);
+ }
+
+ let index = 1 + self.ports_size() + self.checksum_size();
+ if index > buffer.len() {
+ return Err(Error);
+ }
+
+ Ok(())
+ }
+
+ /// Consumes the frame, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ get_field!(dispatch_field, 0b11111, 3);
+ get_field!(checksum_field, 0b1, 2);
+ get_field!(ports_field, 0b11, 0);
+
+ /// Returns the index of the start of the next header compressed fields.
+ const fn nhc_fields_start(&self) -> usize {
+ 1
+ }
+
+ /// Return the source port number.
+ pub fn src_port(&self) -> u16 {
+ match self.ports_field() {
+ 0b00 | 0b01 => {
+ // The full 16 bits are carried in-line.
+ let data = self.buffer.as_ref();
+ let start = self.nhc_fields_start();
+
+ NetworkEndian::read_u16(&data[start..start + 2])
+ }
+ 0b10 => {
+ // The first 8 bits are elided.
+ let data = self.buffer.as_ref();
+ let start = self.nhc_fields_start();
+
+ 0xf000 + data[start] as u16
+ }
+ 0b11 => {
+ // The first 12 bits are elided.
+ let data = self.buffer.as_ref();
+ let start = self.nhc_fields_start();
+
+ 0xf0b0 + (data[start] >> 4) as u16
+ }
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the destination port number.
+ pub fn dst_port(&self) -> u16 {
+ match self.ports_field() {
+ 0b00 => {
+ // The full 16 bits are carried in-line.
+ let data = self.buffer.as_ref();
+ let idx = self.nhc_fields_start();
+
+ NetworkEndian::read_u16(&data[idx + 2..idx + 4])
+ }
+ 0b01 => {
+ // The first 8 bits are elided.
+ let data = self.buffer.as_ref();
+ let idx = self.nhc_fields_start();
+
+ 0xf000 + data[idx] as u16
+ }
+ 0b10 => {
+ // The full 16 bits are carried in-line.
+ let data = self.buffer.as_ref();
+ let idx = self.nhc_fields_start();
+
+ NetworkEndian::read_u16(&data[idx + 1..idx + 1 + 2])
+ }
+ 0b11 => {
+ // The first 12 bits are elided.
+ let data = self.buffer.as_ref();
+ let start = self.nhc_fields_start();
+
+ 0xf0b0 + (data[start] & 0xff) as u16
+ }
+ _ => unreachable!(),
+ }
+ }
+
+ /// Return the checksum.
+ pub fn checksum(&self) -> Option<u16> {
+ if self.checksum_field() == 0b0 {
+ // The first 12 bits are elided.
+ let data = self.buffer.as_ref();
+ let start = self.nhc_fields_start() + self.ports_size();
+ Some(NetworkEndian::read_u16(&data[start..start + 2]))
+ } else {
+ // The checksum is elided and needs to be recomputed on the 6LoWPAN termination point.
+ None
+ }
+ }
+
+ // Return the size of the checksum field.
+ pub(crate) fn checksum_size(&self) -> usize {
+ match self.checksum_field() {
+ 0b0 => 2,
+ 0b1 => 0,
+ _ => unreachable!(),
+ }
+ }
+
+ /// Returns the total size of both port numbers.
+ pub(crate) fn ports_size(&self) -> usize {
+ match self.ports_field() {
+ 0b00 => 4, // 16 bits + 16 bits
+ 0b01 => 3, // 16 bits + 8 bits
+ 0b10 => 3, // 8 bits + 16 bits
+ 0b11 => 1, // 4 bits + 4 bits
+ _ => unreachable!(),
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> UdpNhcPacket<&'a T> {
+ /// Return a pointer to the payload.
+ pub fn payload(&self) -> &'a [u8] {
+ let start = 1 + self.ports_size() + self.checksum_size();
+ &self.buffer.as_ref()[start..]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> UdpNhcPacket<T> {
+ /// Return a mutable pointer to the payload.
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let start = 1 + self.ports_size() + 2; // XXX(thvdveld): we assume we put the checksum inlined.
+ &mut self.buffer.as_mut()[start..]
+ }
+
+ /// Set the dispatch field to `0b11110`.
+ fn set_dispatch_field(&mut self) {
+ let data = self.buffer.as_mut();
+ data[0] = (data[0] & !(0b11111 << 3)) | (DISPATCH_UDP_HEADER << 3);
+ }
+
+ set_field!(set_checksum_field, 0b1, 2);
+ set_field!(set_ports_field, 0b11, 0);
+
+ fn set_ports(&mut self, src_port: u16, dst_port: u16) {
+ let mut idx = 1;
+
+ match (src_port, dst_port) {
+ (0xf0b0..=0xf0bf, 0xf0b0..=0xf0bf) => {
+ // We can compress both the source and destination ports.
+ self.set_ports_field(0b11);
+ let data = self.buffer.as_mut();
+ data[idx] = (((src_port - 0xf0b0) as u8) << 4) & ((dst_port - 0xf0b0) as u8);
+ }
+ (0xf000..=0xf0ff, _) => {
+ // We can compress the source port, but not the destination port.
+ self.set_ports_field(0b10);
+ let data = self.buffer.as_mut();
+ data[idx] = (src_port - 0xf000) as u8;
+ idx += 1;
+
+ NetworkEndian::write_u16(&mut data[idx..idx + 2], dst_port);
+ }
+ (_, 0xf000..=0xf0ff) => {
+ // We can compress the destination port, but not the source port.
+ self.set_ports_field(0b01);
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[idx..idx + 2], src_port);
+ idx += 2;
+ data[idx] = (dst_port - 0xf000) as u8;
+ }
+ (_, _) => {
+ // We cannot compress any port.
+ self.set_ports_field(0b00);
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[idx..idx + 2], src_port);
+ idx += 2;
+ NetworkEndian::write_u16(&mut data[idx..idx + 2], dst_port);
+ }
+ };
+ }
+
+ fn set_checksum(&mut self, checksum: u16) {
+ self.set_checksum_field(0b0);
+ let idx = 1 + self.ports_size();
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[idx..idx + 2], checksum);
+ }
+}
+
+/// A high-level representation of a 6LoWPAN NHC UDP header.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct UdpNhcRepr(pub UdpRepr);
+
+impl<'a> UdpNhcRepr {
+ /// Parse a 6LoWPAN NHC UDP packet and return a high-level representation.
+ pub fn parse<T: AsRef<[u8]> + ?Sized>(
+ packet: &UdpNhcPacket<&'a T>,
+ src_addr: &ipv6::Address,
+ dst_addr: &ipv6::Address,
+ checksum_caps: &ChecksumCapabilities,
+ ) -> Result<Self> {
+ packet.check_len()?;
+
+ if packet.dispatch_field() != DISPATCH_UDP_HEADER {
+ return Err(Error);
+ }
+
+ if checksum_caps.udp.rx() {
+ let payload_len = packet.payload().len();
+ let chk_sum = !checksum::combine(&[
+ checksum::pseudo_header(
+ &IpAddress::Ipv6(*src_addr),
+ &IpAddress::Ipv6(*dst_addr),
+ crate::wire::ip::Protocol::Udp,
+ payload_len as u32 + 8,
+ ),
+ packet.src_port(),
+ packet.dst_port(),
+ payload_len as u16 + 8,
+ checksum::data(packet.payload()),
+ ]);
+
+ if let Some(checksum) = packet.checksum() {
+ if chk_sum != checksum {
+ return Err(Error);
+ }
+ }
+ }
+
+ Ok(Self(UdpRepr {
+ src_port: packet.src_port(),
+ dst_port: packet.dst_port(),
+ }))
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub fn header_len(&self) -> usize {
+ let mut len = 1; // The minimal header size
+
+ len += 2; // XXX We assume we will add the checksum at the end
+
+ // Check if we can compress the source and destination ports
+ match (self.src_port, self.dst_port) {
+ (0xf0b0..=0xf0bf, 0xf0b0..=0xf0bf) => len + 1,
+ (0xf000..=0xf0ff, _) | (_, 0xf000..=0xf0ff) => len + 3,
+ (_, _) => len + 4,
+ }
+ }
+
+ /// Emit a high-level representation into a LOWPAN_NHC UDP header.
+ pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(
+ &self,
+ packet: &mut UdpNhcPacket<T>,
+ src_addr: &Address,
+ dst_addr: &Address,
+ payload_len: usize,
+ emit_payload: impl FnOnce(&mut [u8]),
+ checksum_caps: &ChecksumCapabilities,
+ ) {
+ packet.set_dispatch_field();
+ packet.set_ports(self.src_port, self.dst_port);
+ emit_payload(packet.payload_mut());
+
+ if checksum_caps.udp.tx() {
+ let chk_sum = !checksum::combine(&[
+ checksum::pseudo_header(
+ &IpAddress::Ipv6(*src_addr),
+ &IpAddress::Ipv6(*dst_addr),
+ crate::wire::ip::Protocol::Udp,
+ payload_len as u32 + 8,
+ ),
+ self.src_port,
+ self.dst_port,
+ payload_len as u16 + 8,
+ checksum::data(packet.payload_mut()),
+ ]);
+
+ packet.set_checksum(chk_sum);
+ }
+ }
+}
+
+impl core::ops::Deref for UdpNhcRepr {
+ type Target = UdpRepr;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl core::ops::DerefMut for UdpNhcRepr {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn ext_header_nh_inlined() {
+ let bytes = [0xe2, 0x3a, 0x6, 0x3, 0x0, 0xff, 0x0, 0x0, 0x0];
+
+ let packet = ExtHeaderPacket::new_checked(&bytes[..]).unwrap();
+ assert_eq!(packet.next_header_size(), 1);
+ assert_eq!(packet.length(), 6);
+ assert_eq!(packet.dispatch_field(), DISPATCH_EXT_HEADER);
+ assert_eq!(packet.extension_header_id(), ExtHeaderId::RoutingHeader);
+ assert_eq!(
+ packet.next_header(),
+ NextHeader::Uncompressed(IpProtocol::Icmpv6)
+ );
+
+ assert_eq!(packet.payload(), [0x03, 0x00, 0xff, 0x00, 0x00, 0x00]);
+ }
+
+ #[test]
+ fn ext_header_nh_elided() {
+ let bytes = [0xe3, 0x06, 0x03, 0x00, 0xff, 0x00, 0x00, 0x00];
+
+ let packet = ExtHeaderPacket::new_checked(&bytes[..]).unwrap();
+ assert_eq!(packet.next_header_size(), 0);
+ assert_eq!(packet.length(), 6);
+ assert_eq!(packet.dispatch_field(), DISPATCH_EXT_HEADER);
+ assert_eq!(packet.extension_header_id(), ExtHeaderId::RoutingHeader);
+ assert_eq!(packet.next_header(), NextHeader::Compressed);
+
+ assert_eq!(packet.payload(), [0x03, 0x00, 0xff, 0x00, 0x00, 0x00]);
+ }
+
+ #[test]
+ fn ext_header_emit() {
+ let ext_header = ExtHeaderRepr {
+ ext_header_id: ExtHeaderId::RoutingHeader,
+ next_header: NextHeader::Compressed,
+ length: 6,
+ };
+
+ let len = ext_header.buffer_len();
+ let mut buffer = [0u8; 127];
+ let mut packet = ExtHeaderPacket::new_unchecked(&mut buffer[..len]);
+ ext_header.emit(&mut packet);
+
+ assert_eq!(packet.dispatch_field(), DISPATCH_EXT_HEADER);
+ assert_eq!(packet.next_header(), NextHeader::Compressed);
+ assert_eq!(packet.extension_header_id(), ExtHeaderId::RoutingHeader);
+ }
+
+ #[test]
+ fn udp_nhc_fields() {
+ let bytes = [0xf0, 0x16, 0x2e, 0x22, 0x3d, 0x28, 0xc4];
+
+ let packet = UdpNhcPacket::new_checked(&bytes[..]).unwrap();
+ assert_eq!(packet.dispatch_field(), DISPATCH_UDP_HEADER);
+ assert_eq!(packet.checksum(), Some(0x28c4));
+ assert_eq!(packet.src_port(), 5678);
+ assert_eq!(packet.dst_port(), 8765);
+ }
+
+ #[test]
+ fn udp_emit() {
+ let udp = UdpNhcRepr(UdpRepr {
+ src_port: 0xf0b1,
+ dst_port: 0xf001,
+ });
+
+ let payload = b"Hello World!";
+
+ let src_addr = ipv6::Address::default();
+ let dst_addr = ipv6::Address::default();
+
+ let len = udp.header_len() + payload.len();
+ let mut buffer = [0u8; 127];
+ let mut packet = UdpNhcPacket::new_unchecked(&mut buffer[..len]);
+ udp.emit(
+ &mut packet,
+ &src_addr,
+ &dst_addr,
+ payload.len(),
+ |buf| buf.copy_from_slice(&payload[..]),
+ &ChecksumCapabilities::default(),
+ );
+
+ assert_eq!(packet.dispatch_field(), DISPATCH_UDP_HEADER);
+ assert_eq!(packet.src_port(), 0xf0b1);
+ assert_eq!(packet.dst_port(), 0xf001);
+ assert_eq!(packet.payload_mut(), b"Hello World!");
+ }
+}
diff --git a/src/wire/tcp.rs b/src/wire/tcp.rs
new file mode 100644
index 0000000..2482143
--- /dev/null
+++ b/src/wire/tcp.rs
@@ -0,0 +1,1331 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::{cmp, fmt, i32, ops};
+
+use super::{Error, Result};
+use crate::phy::ChecksumCapabilities;
+use crate::wire::ip::checksum;
+use crate::wire::{IpAddress, IpProtocol};
+
+/// A TCP sequence number.
+///
+/// A sequence number is a monotonically advancing integer modulo 2<sup>32</sup>.
+/// Sequence numbers do not have a discontiguity when compared pairwise across a signed overflow.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
+pub struct SeqNumber(pub i32);
+
+impl SeqNumber {
+ pub fn max(self, rhs: Self) -> Self {
+ if self > rhs {
+ self
+ } else {
+ rhs
+ }
+ }
+
+ pub fn min(self, rhs: Self) -> Self {
+ if self < rhs {
+ self
+ } else {
+ rhs
+ }
+ }
+}
+
+impl fmt::Display for SeqNumber {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.0 as u32)
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for SeqNumber {
+ fn format(&self, fmt: defmt::Formatter) {
+ defmt::write!(fmt, "{}", self.0 as u32);
+ }
+}
+
+impl ops::Add<usize> for SeqNumber {
+ type Output = SeqNumber;
+
+ fn add(self, rhs: usize) -> SeqNumber {
+ if rhs > i32::MAX as usize {
+ panic!("attempt to add to sequence number with unsigned overflow")
+ }
+ SeqNumber(self.0.wrapping_add(rhs as i32))
+ }
+}
+
+impl ops::Sub<usize> for SeqNumber {
+ type Output = SeqNumber;
+
+ fn sub(self, rhs: usize) -> SeqNumber {
+ if rhs > i32::MAX as usize {
+ panic!("attempt to subtract to sequence number with unsigned overflow")
+ }
+ SeqNumber(self.0.wrapping_sub(rhs as i32))
+ }
+}
+
+impl ops::AddAssign<usize> for SeqNumber {
+ fn add_assign(&mut self, rhs: usize) {
+ *self = *self + rhs;
+ }
+}
+
+impl ops::Sub for SeqNumber {
+ type Output = usize;
+
+ fn sub(self, rhs: SeqNumber) -> usize {
+ let result = self.0.wrapping_sub(rhs.0);
+ if result < 0 {
+ panic!("attempt to subtract sequence numbers with underflow")
+ }
+ result as usize
+ }
+}
+
+impl cmp::PartialOrd for SeqNumber {
+ fn partial_cmp(&self, other: &SeqNumber) -> Option<cmp::Ordering> {
+ self.0.wrapping_sub(other.0).partial_cmp(&0)
+ }
+}
+
+/// A read/write wrapper around a Transmission Control Protocol packet buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::*;
+
+ pub const SRC_PORT: Field = 0..2;
+ pub const DST_PORT: Field = 2..4;
+ pub const SEQ_NUM: Field = 4..8;
+ pub const ACK_NUM: Field = 8..12;
+ pub const FLAGS: Field = 12..14;
+ pub const WIN_SIZE: Field = 14..16;
+ pub const CHECKSUM: Field = 16..18;
+ pub const URGENT: Field = 18..20;
+
+ pub const fn OPTIONS(length: u8) -> Field {
+ URGENT.end..(length as usize)
+ }
+
+ pub const FLG_FIN: u16 = 0x001;
+ pub const FLG_SYN: u16 = 0x002;
+ pub const FLG_RST: u16 = 0x004;
+ pub const FLG_PSH: u16 = 0x008;
+ pub const FLG_ACK: u16 = 0x010;
+ pub const FLG_URG: u16 = 0x020;
+ pub const FLG_ECE: u16 = 0x040;
+ pub const FLG_CWR: u16 = 0x080;
+ pub const FLG_NS: u16 = 0x100;
+
+ pub const OPT_END: u8 = 0x00;
+ pub const OPT_NOP: u8 = 0x01;
+ pub const OPT_MSS: u8 = 0x02;
+ pub const OPT_WS: u8 = 0x03;
+ pub const OPT_SACKPERM: u8 = 0x04;
+ pub const OPT_SACKRNG: u8 = 0x05;
+}
+
+pub const HEADER_LEN: usize = field::URGENT.end;
+
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with TCP packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ /// Returns `Err(Error)` if the header length field has a value smaller
+ /// than the minimal header length.
+ ///
+ /// The result of this check is invalidated by calling [set_header_len].
+ ///
+ /// [set_header_len]: #method.set_header_len
+ pub fn check_len(&self) -> Result<()> {
+ let len = self.buffer.as_ref().len();
+ if len < field::URGENT.end {
+ Err(Error)
+ } else {
+ let header_len = self.header_len() as usize;
+ if len < header_len || header_len < field::URGENT.end {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the source port field.
+ #[inline]
+ pub fn src_port(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::SRC_PORT])
+ }
+
+ /// Return the destination port field.
+ #[inline]
+ pub fn dst_port(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::DST_PORT])
+ }
+
+ /// Return the sequence number field.
+ #[inline]
+ pub fn seq_number(&self) -> SeqNumber {
+ let data = self.buffer.as_ref();
+ SeqNumber(NetworkEndian::read_i32(&data[field::SEQ_NUM]))
+ }
+
+ /// Return the acknowledgement number field.
+ #[inline]
+ pub fn ack_number(&self) -> SeqNumber {
+ let data = self.buffer.as_ref();
+ SeqNumber(NetworkEndian::read_i32(&data[field::ACK_NUM]))
+ }
+
+ /// Return the FIN flag.
+ #[inline]
+ pub fn fin(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_FIN != 0
+ }
+
+ /// Return the SYN flag.
+ #[inline]
+ pub fn syn(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_SYN != 0
+ }
+
+ /// Return the RST flag.
+ #[inline]
+ pub fn rst(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_RST != 0
+ }
+
+ /// Return the PSH flag.
+ #[inline]
+ pub fn psh(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_PSH != 0
+ }
+
+ /// Return the ACK flag.
+ #[inline]
+ pub fn ack(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_ACK != 0
+ }
+
+ /// Return the URG flag.
+ #[inline]
+ pub fn urg(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_URG != 0
+ }
+
+ /// Return the ECE flag.
+ #[inline]
+ pub fn ece(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_ECE != 0
+ }
+
+ /// Return the CWR flag.
+ #[inline]
+ pub fn cwr(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_CWR != 0
+ }
+
+ /// Return the NS flag.
+ #[inline]
+ pub fn ns(&self) -> bool {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ raw & field::FLG_NS != 0
+ }
+
+ /// Return the header length, in octets.
+ #[inline]
+ pub fn header_len(&self) -> u8 {
+ let data = self.buffer.as_ref();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ ((raw >> 12) * 4) as u8
+ }
+
+ /// Return the window size field.
+ #[inline]
+ pub fn window_len(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::WIN_SIZE])
+ }
+
+ /// Return the checksum field.
+ #[inline]
+ pub fn checksum(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::CHECKSUM])
+ }
+
+ /// Return the urgent pointer field.
+ #[inline]
+ pub fn urgent_at(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::URGENT])
+ }
+
+ /// Return the length of the segment, in terms of sequence space.
+ pub fn segment_len(&self) -> usize {
+ let data = self.buffer.as_ref();
+ let mut length = data.len() - self.header_len() as usize;
+ if self.syn() {
+ length += 1
+ }
+ if self.fin() {
+ length += 1
+ }
+ length
+ }
+
+ /// Returns whether the selective acknowledgement SYN flag is set or not.
+ pub fn selective_ack_permitted(&self) -> Result<bool> {
+ let data = self.buffer.as_ref();
+ let mut options = &data[field::OPTIONS(self.header_len())];
+ while !options.is_empty() {
+ let (next_options, option) = TcpOption::parse(options)?;
+ if option == TcpOption::SackPermitted {
+ return Ok(true);
+ }
+ options = next_options;
+ }
+ Ok(false)
+ }
+
+ /// Return the selective acknowledgement ranges, if any. If there are none in the packet, an
+ /// array of ``None`` values will be returned.
+ ///
+ pub fn selective_ack_ranges(&self) -> Result<[Option<(u32, u32)>; 3]> {
+ let data = self.buffer.as_ref();
+ let mut options = &data[field::OPTIONS(self.header_len())];
+ while !options.is_empty() {
+ let (next_options, option) = TcpOption::parse(options)?;
+ if let TcpOption::SackRange(slice) = option {
+ return Ok(slice);
+ }
+ options = next_options;
+ }
+ Ok([None, None, None])
+ }
+
+ /// Validate the packet checksum.
+ ///
+ /// # Panics
+ /// This function panics unless `src_addr` and `dst_addr` belong to the same family,
+ /// and that family is IPv4 or IPv6.
+ ///
+ /// # Fuzzing
+ /// This function always returns `true` when fuzzing.
+ pub fn verify_checksum(&self, src_addr: &IpAddress, dst_addr: &IpAddress) -> bool {
+ if cfg!(fuzzing) {
+ return true;
+ }
+
+ let data = self.buffer.as_ref();
+ checksum::combine(&[
+ checksum::pseudo_header(src_addr, dst_addr, IpProtocol::Tcp, data.len() as u32),
+ checksum::data(data),
+ ]) == !0
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the options.
+ #[inline]
+ pub fn options(&self) -> &'a [u8] {
+ let header_len = self.header_len();
+ let data = self.buffer.as_ref();
+ &data[field::OPTIONS(header_len)]
+ }
+
+ /// Return a pointer to the payload.
+ #[inline]
+ pub fn payload(&self) -> &'a [u8] {
+ let header_len = self.header_len() as usize;
+ let data = self.buffer.as_ref();
+ &data[header_len..]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the source port field.
+ #[inline]
+ pub fn set_src_port(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::SRC_PORT], value)
+ }
+
+ /// Set the destination port field.
+ #[inline]
+ pub fn set_dst_port(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::DST_PORT], value)
+ }
+
+ /// Set the sequence number field.
+ #[inline]
+ pub fn set_seq_number(&mut self, value: SeqNumber) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_i32(&mut data[field::SEQ_NUM], value.0)
+ }
+
+ /// Set the acknowledgement number field.
+ #[inline]
+ pub fn set_ack_number(&mut self, value: SeqNumber) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_i32(&mut data[field::ACK_NUM], value.0)
+ }
+
+ /// Clear the entire flags field.
+ #[inline]
+ pub fn clear_flags(&mut self) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = raw & !0x0fff;
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the FIN flag.
+ #[inline]
+ pub fn set_fin(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_FIN
+ } else {
+ raw & !field::FLG_FIN
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the SYN flag.
+ #[inline]
+ pub fn set_syn(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_SYN
+ } else {
+ raw & !field::FLG_SYN
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the RST flag.
+ #[inline]
+ pub fn set_rst(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_RST
+ } else {
+ raw & !field::FLG_RST
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the PSH flag.
+ #[inline]
+ pub fn set_psh(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_PSH
+ } else {
+ raw & !field::FLG_PSH
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the ACK flag.
+ #[inline]
+ pub fn set_ack(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_ACK
+ } else {
+ raw & !field::FLG_ACK
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the URG flag.
+ #[inline]
+ pub fn set_urg(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_URG
+ } else {
+ raw & !field::FLG_URG
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the ECE flag.
+ #[inline]
+ pub fn set_ece(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_ECE
+ } else {
+ raw & !field::FLG_ECE
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the CWR flag.
+ #[inline]
+ pub fn set_cwr(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_CWR
+ } else {
+ raw & !field::FLG_CWR
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the NS flag.
+ #[inline]
+ pub fn set_ns(&mut self, value: bool) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = if value {
+ raw | field::FLG_NS
+ } else {
+ raw & !field::FLG_NS
+ };
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the header length, in octets.
+ #[inline]
+ pub fn set_header_len(&mut self, value: u8) {
+ let data = self.buffer.as_mut();
+ let raw = NetworkEndian::read_u16(&data[field::FLAGS]);
+ let raw = (raw & !0xf000) | ((value as u16) / 4) << 12;
+ NetworkEndian::write_u16(&mut data[field::FLAGS], raw)
+ }
+
+ /// Set the window size field.
+ #[inline]
+ pub fn set_window_len(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::WIN_SIZE], value)
+ }
+
+ /// Set the checksum field.
+ #[inline]
+ pub fn set_checksum(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::CHECKSUM], value)
+ }
+
+ /// Set the urgent pointer field.
+ #[inline]
+ pub fn set_urgent_at(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::URGENT], value)
+ }
+
+ /// Compute and fill in the header checksum.
+ ///
+ /// # Panics
+ /// This function panics unless `src_addr` and `dst_addr` belong to the same family,
+ /// and that family is IPv4 or IPv6.
+ pub fn fill_checksum(&mut self, src_addr: &IpAddress, dst_addr: &IpAddress) {
+ self.set_checksum(0);
+ let checksum = {
+ let data = self.buffer.as_ref();
+ !checksum::combine(&[
+ checksum::pseudo_header(src_addr, dst_addr, IpProtocol::Tcp, data.len() as u32),
+ checksum::data(data),
+ ])
+ };
+ self.set_checksum(checksum)
+ }
+
+ /// Return a pointer to the options.
+ #[inline]
+ pub fn options_mut(&mut self) -> &mut [u8] {
+ let header_len = self.header_len();
+ let data = self.buffer.as_mut();
+ &mut data[field::OPTIONS(header_len)]
+ }
+
+ /// Return a mutable pointer to the payload data.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let header_len = self.header_len() as usize;
+ let data = self.buffer.as_mut();
+ &mut data[header_len..]
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+/// A representation of a single TCP option.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum TcpOption<'a> {
+ EndOfList,
+ NoOperation,
+ MaxSegmentSize(u16),
+ WindowScale(u8),
+ SackPermitted,
+ SackRange([Option<(u32, u32)>; 3]),
+ Unknown { kind: u8, data: &'a [u8] },
+}
+
+impl<'a> TcpOption<'a> {
+ pub fn parse(buffer: &'a [u8]) -> Result<(&'a [u8], TcpOption<'a>)> {
+ let (length, option);
+ match *buffer.first().ok_or(Error)? {
+ field::OPT_END => {
+ length = 1;
+ option = TcpOption::EndOfList;
+ }
+ field::OPT_NOP => {
+ length = 1;
+ option = TcpOption::NoOperation;
+ }
+ kind => {
+ length = *buffer.get(1).ok_or(Error)? as usize;
+ let data = buffer.get(2..length).ok_or(Error)?;
+ match (kind, length) {
+ (field::OPT_END, _) | (field::OPT_NOP, _) => unreachable!(),
+ (field::OPT_MSS, 4) => {
+ option = TcpOption::MaxSegmentSize(NetworkEndian::read_u16(data))
+ }
+ (field::OPT_MSS, _) => return Err(Error),
+ (field::OPT_WS, 3) => option = TcpOption::WindowScale(data[0]),
+ (field::OPT_WS, _) => return Err(Error),
+ (field::OPT_SACKPERM, 2) => option = TcpOption::SackPermitted,
+ (field::OPT_SACKPERM, _) => return Err(Error),
+ (field::OPT_SACKRNG, n) => {
+ if n < 10 || (n - 2) % 8 != 0 {
+ return Err(Error);
+ }
+ if n > 26 {
+ // It's possible for a remote to send 4 SACK blocks, but extremely rare.
+ // Better to "lose" that 4th block and save the extra RAM and CPU
+ // cycles in the vastly more common case.
+ //
+ // RFC 2018: SACK option that specifies n blocks will have a length of
+ // 8*n+2 bytes, so the 40 bytes available for TCP options can specify a
+ // maximum of 4 blocks. It is expected that SACK will often be used in
+ // conjunction with the Timestamp option used for RTTM [...] thus a
+ // maximum of 3 SACK blocks will be allowed in this case.
+ net_debug!("sACK with >3 blocks, truncating to 3");
+ }
+ let mut sack_ranges: [Option<(u32, u32)>; 3] = [None; 3];
+
+ // RFC 2018: Each contiguous block of data queued at the data receiver is
+ // defined in the SACK option by two 32-bit unsigned integers in network
+ // byte order[...]
+ sack_ranges.iter_mut().enumerate().for_each(|(i, nmut)| {
+ let left = i * 8;
+ *nmut = if left < data.len() {
+ let mid = left + 4;
+ let right = mid + 4;
+ let range_left = NetworkEndian::read_u32(&data[left..mid]);
+ let range_right = NetworkEndian::read_u32(&data[mid..right]);
+ Some((range_left, range_right))
+ } else {
+ None
+ };
+ });
+ option = TcpOption::SackRange(sack_ranges);
+ }
+ (_, _) => option = TcpOption::Unknown { kind, data },
+ }
+ }
+ }
+ Ok((&buffer[length..], option))
+ }
+
+ pub fn buffer_len(&self) -> usize {
+ match *self {
+ TcpOption::EndOfList => 1,
+ TcpOption::NoOperation => 1,
+ TcpOption::MaxSegmentSize(_) => 4,
+ TcpOption::WindowScale(_) => 3,
+ TcpOption::SackPermitted => 2,
+ TcpOption::SackRange(s) => s.iter().filter(|s| s.is_some()).count() * 8 + 2,
+ TcpOption::Unknown { data, .. } => 2 + data.len(),
+ }
+ }
+
+ pub fn emit<'b>(&self, buffer: &'b mut [u8]) -> &'b mut [u8] {
+ let length;
+ match *self {
+ TcpOption::EndOfList => {
+ length = 1;
+ // There may be padding space which also should be initialized.
+ for p in buffer.iter_mut() {
+ *p = field::OPT_END;
+ }
+ }
+ TcpOption::NoOperation => {
+ length = 1;
+ buffer[0] = field::OPT_NOP;
+ }
+ _ => {
+ length = self.buffer_len();
+ buffer[1] = length as u8;
+ match self {
+ &TcpOption::EndOfList | &TcpOption::NoOperation => unreachable!(),
+ &TcpOption::MaxSegmentSize(value) => {
+ buffer[0] = field::OPT_MSS;
+ NetworkEndian::write_u16(&mut buffer[2..], value)
+ }
+ &TcpOption::WindowScale(value) => {
+ buffer[0] = field::OPT_WS;
+ buffer[2] = value;
+ }
+ &TcpOption::SackPermitted => {
+ buffer[0] = field::OPT_SACKPERM;
+ }
+ &TcpOption::SackRange(slice) => {
+ buffer[0] = field::OPT_SACKRNG;
+ slice
+ .iter()
+ .filter(|s| s.is_some())
+ .enumerate()
+ .for_each(|(i, s)| {
+ let (first, second) = *s.as_ref().unwrap();
+ let pos = i * 8 + 2;
+ NetworkEndian::write_u32(&mut buffer[pos..], first);
+ NetworkEndian::write_u32(&mut buffer[pos + 4..], second);
+ });
+ }
+ &TcpOption::Unknown {
+ kind,
+ data: provided,
+ } => {
+ buffer[0] = kind;
+ buffer[2..].copy_from_slice(provided)
+ }
+ }
+ }
+ }
+ &mut buffer[length..]
+ }
+}
+
+/// The possible control flags of a Transmission Control Protocol packet.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Control {
+ None,
+ Psh,
+ Syn,
+ Fin,
+ Rst,
+}
+
+#[allow(clippy::len_without_is_empty)]
+impl Control {
+ /// Return the length of a control flag, in terms of sequence space.
+ pub const fn len(self) -> usize {
+ match self {
+ Control::Syn | Control::Fin => 1,
+ _ => 0,
+ }
+ }
+
+ /// Turn the PSH flag into no flag, and keep the rest as-is.
+ pub const fn quash_psh(self) -> Control {
+ match self {
+ Control::Psh => Control::None,
+ _ => self,
+ }
+ }
+}
+
+/// A high-level representation of a Transmission Control Protocol packet.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Repr<'a> {
+ pub src_port: u16,
+ pub dst_port: u16,
+ pub control: Control,
+ pub seq_number: SeqNumber,
+ pub ack_number: Option<SeqNumber>,
+ pub window_len: u16,
+ pub window_scale: Option<u8>,
+ pub max_seg_size: Option<u16>,
+ pub sack_permitted: bool,
+ pub sack_ranges: [Option<(u32, u32)>; 3],
+ pub payload: &'a [u8],
+}
+
+impl<'a> Repr<'a> {
+ /// Parse a Transmission Control Protocol packet and return a high-level representation.
+ pub fn parse<T>(
+ packet: &Packet<&'a T>,
+ src_addr: &IpAddress,
+ dst_addr: &IpAddress,
+ checksum_caps: &ChecksumCapabilities,
+ ) -> Result<Repr<'a>>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ // Source and destination ports must be present.
+ if packet.src_port() == 0 {
+ return Err(Error);
+ }
+ if packet.dst_port() == 0 {
+ return Err(Error);
+ }
+ // Valid checksum is expected.
+ if checksum_caps.tcp.rx() && !packet.verify_checksum(src_addr, dst_addr) {
+ return Err(Error);
+ }
+
+ let control = match (packet.syn(), packet.fin(), packet.rst(), packet.psh()) {
+ (false, false, false, false) => Control::None,
+ (false, false, false, true) => Control::Psh,
+ (true, false, false, _) => Control::Syn,
+ (false, true, false, _) => Control::Fin,
+ (false, false, true, _) => Control::Rst,
+ _ => return Err(Error),
+ };
+ let ack_number = match packet.ack() {
+ true => Some(packet.ack_number()),
+ false => None,
+ };
+ // The PSH flag is ignored.
+ // The URG flag and the urgent field is ignored. This behavior is standards-compliant,
+ // however, most deployed systems (e.g. Linux) are *not* standards-compliant, and would
+ // cut the byte at the urgent pointer from the stream.
+
+ let mut max_seg_size = None;
+ let mut window_scale = None;
+ let mut options = packet.options();
+ let mut sack_permitted = false;
+ let mut sack_ranges = [None, None, None];
+ while !options.is_empty() {
+ let (next_options, option) = TcpOption::parse(options)?;
+ match option {
+ TcpOption::EndOfList => break,
+ TcpOption::NoOperation => (),
+ TcpOption::MaxSegmentSize(value) => max_seg_size = Some(value),
+ TcpOption::WindowScale(value) => {
+ // RFC 1323: Thus, the shift count must be limited to 14 (which allows windows
+ // of 2**30 = 1 Gigabyte). If a Window Scale option is received with a shift.cnt
+ // value exceeding 14, the TCP should log the error but use 14 instead of the
+ // specified value.
+ window_scale = if value > 14 {
+ net_debug!(
+ "{}:{}:{}:{}: parsed window scaling factor >14, setting to 14",
+ src_addr,
+ packet.src_port(),
+ dst_addr,
+ packet.dst_port()
+ );
+ Some(14)
+ } else {
+ Some(value)
+ };
+ }
+ TcpOption::SackPermitted => sack_permitted = true,
+ TcpOption::SackRange(slice) => sack_ranges = slice,
+ _ => (),
+ }
+ options = next_options;
+ }
+
+ Ok(Repr {
+ src_port: packet.src_port(),
+ dst_port: packet.dst_port(),
+ control: control,
+ seq_number: packet.seq_number(),
+ ack_number: ack_number,
+ window_len: packet.window_len(),
+ window_scale: window_scale,
+ max_seg_size: max_seg_size,
+ sack_permitted: sack_permitted,
+ sack_ranges: sack_ranges,
+ payload: packet.payload(),
+ })
+ }
+
+ /// Return the length of a header that will be emitted from this high-level representation.
+ ///
+ /// This should be used for buffer space calculations.
+ /// The TCP header length is a multiple of 4.
+ pub fn header_len(&self) -> usize {
+ let mut length = field::URGENT.end;
+ if self.max_seg_size.is_some() {
+ length += 4
+ }
+ if self.window_scale.is_some() {
+ length += 3
+ }
+ if self.sack_permitted {
+ length += 2;
+ }
+ let sack_range_len: usize = self
+ .sack_ranges
+ .iter()
+ .map(|o| o.map(|_| 8).unwrap_or(0))
+ .sum();
+ if sack_range_len > 0 {
+ length += sack_range_len + 2;
+ }
+ if length % 4 != 0 {
+ length += 4 - length % 4;
+ }
+ length
+ }
+
+ /// Return the length of a packet that will be emitted from this high-level representation.
+ pub fn buffer_len(&self) -> usize {
+ self.header_len() + self.payload.len()
+ }
+
+ /// Emit a high-level representation into a Transmission Control Protocol packet.
+ pub fn emit<T>(
+ &self,
+ packet: &mut Packet<&mut T>,
+ src_addr: &IpAddress,
+ dst_addr: &IpAddress,
+ checksum_caps: &ChecksumCapabilities,
+ ) where
+ T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
+ {
+ packet.set_src_port(self.src_port);
+ packet.set_dst_port(self.dst_port);
+ packet.set_seq_number(self.seq_number);
+ packet.set_ack_number(self.ack_number.unwrap_or(SeqNumber(0)));
+ packet.set_window_len(self.window_len);
+ packet.set_header_len(self.header_len() as u8);
+ packet.clear_flags();
+ match self.control {
+ Control::None => (),
+ Control::Psh => packet.set_psh(true),
+ Control::Syn => packet.set_syn(true),
+ Control::Fin => packet.set_fin(true),
+ Control::Rst => packet.set_rst(true),
+ }
+ packet.set_ack(self.ack_number.is_some());
+ {
+ let mut options = packet.options_mut();
+ if let Some(value) = self.max_seg_size {
+ let tmp = options;
+ options = TcpOption::MaxSegmentSize(value).emit(tmp);
+ }
+ if let Some(value) = self.window_scale {
+ let tmp = options;
+ options = TcpOption::WindowScale(value).emit(tmp);
+ }
+ if self.sack_permitted {
+ let tmp = options;
+ options = TcpOption::SackPermitted.emit(tmp);
+ } else if self.ack_number.is_some() && self.sack_ranges.iter().any(|s| s.is_some()) {
+ let tmp = options;
+ options = TcpOption::SackRange(self.sack_ranges).emit(tmp);
+ }
+
+ if !options.is_empty() {
+ TcpOption::EndOfList.emit(options);
+ }
+ }
+ packet.set_urgent_at(0);
+ packet.payload_mut()[..self.payload.len()].copy_from_slice(self.payload);
+
+ if checksum_caps.tcp.tx() {
+ packet.fill_checksum(src_addr, dst_addr)
+ } else {
+ // make sure we get a consistently zeroed checksum,
+ // since implementations might rely on it
+ packet.set_checksum(0);
+ }
+ }
+
+ /// Return the length of the segment, in terms of sequence space.
+ pub const fn segment_len(&self) -> usize {
+ self.payload.len() + self.control.len()
+ }
+
+ /// Return whether the segment has no flags set (except PSH) and no data.
+ pub const fn is_empty(&self) -> bool {
+ match self.control {
+ _ if !self.payload.is_empty() => false,
+ Control::Syn | Control::Fin | Control::Rst => false,
+ Control::None | Control::Psh => true,
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ // Cannot use Repr::parse because we don't have the IP addresses.
+ write!(f, "TCP src={} dst={}", self.src_port(), self.dst_port())?;
+ if self.syn() {
+ write!(f, " syn")?
+ }
+ if self.fin() {
+ write!(f, " fin")?
+ }
+ if self.rst() {
+ write!(f, " rst")?
+ }
+ if self.psh() {
+ write!(f, " psh")?
+ }
+ if self.ece() {
+ write!(f, " ece")?
+ }
+ if self.cwr() {
+ write!(f, " cwr")?
+ }
+ if self.ns() {
+ write!(f, " ns")?
+ }
+ write!(f, " seq={}", self.seq_number())?;
+ if self.ack() {
+ write!(f, " ack={}", self.ack_number())?;
+ }
+ write!(f, " win={}", self.window_len())?;
+ if self.urg() {
+ write!(f, " urg={}", self.urgent_at())?;
+ }
+ write!(f, " len={}", self.payload().len())?;
+
+ let mut options = self.options();
+ while !options.is_empty() {
+ let (next_options, option) = match TcpOption::parse(options) {
+ Ok(res) => res,
+ Err(err) => return write!(f, " ({err})"),
+ };
+ match option {
+ TcpOption::EndOfList => break,
+ TcpOption::NoOperation => (),
+ TcpOption::MaxSegmentSize(value) => write!(f, " mss={value}")?,
+ TcpOption::WindowScale(value) => write!(f, " ws={value}")?,
+ TcpOption::SackPermitted => write!(f, " sACK")?,
+ TcpOption::SackRange(slice) => write!(f, " sACKr{slice:?}")?, // debug print conveniently includes the []s
+ TcpOption::Unknown { kind, .. } => write!(f, " opt({kind})")?,
+ }
+ options = next_options;
+ }
+ Ok(())
+ }
+}
+
+impl<'a> fmt::Display for Repr<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "TCP src={} dst={}", self.src_port, self.dst_port)?;
+ match self.control {
+ Control::Syn => write!(f, " syn")?,
+ Control::Fin => write!(f, " fin")?,
+ Control::Rst => write!(f, " rst")?,
+ Control::Psh => write!(f, " psh")?,
+ Control::None => (),
+ }
+ write!(f, " seq={}", self.seq_number)?;
+ if let Some(ack_number) = self.ack_number {
+ write!(f, " ack={ack_number}")?;
+ }
+ write!(f, " win={}", self.window_len)?;
+ write!(f, " len={}", self.payload.len())?;
+ if let Some(max_seg_size) = self.max_seg_size {
+ write!(f, " mss={max_seg_size}")?;
+ }
+ Ok(())
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl<'a> defmt::Format for Repr<'a> {
+ fn format(&self, fmt: defmt::Formatter) {
+ defmt::write!(fmt, "TCP src={} dst={}", self.src_port, self.dst_port);
+ match self.control {
+ Control::Syn => defmt::write!(fmt, " syn"),
+ Control::Fin => defmt::write!(fmt, " fin"),
+ Control::Rst => defmt::write!(fmt, " rst"),
+ Control::Psh => defmt::write!(fmt, " psh"),
+ Control::None => (),
+ }
+ defmt::write!(fmt, " seq={}", self.seq_number);
+ if let Some(ack_number) = self.ack_number {
+ defmt::write!(fmt, " ack={}", ack_number);
+ }
+ defmt::write!(fmt, " win={}", self.window_len);
+ defmt::write!(fmt, " len={}", self.payload.len());
+ if let Some(max_seg_size) = self.max_seg_size {
+ defmt::write!(fmt, " mss={}", max_seg_size);
+ }
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ match Packet::new_checked(buffer) {
+ Err(err) => write!(f, "{indent}({err})"),
+ Ok(packet) => write!(f, "{indent}{packet}"),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ #[cfg(feature = "proto-ipv4")]
+ use crate::wire::Ipv4Address;
+
+ #[cfg(feature = "proto-ipv4")]
+ const SRC_ADDR: Ipv4Address = Ipv4Address([192, 168, 1, 1]);
+ #[cfg(feature = "proto-ipv4")]
+ const DST_ADDR: Ipv4Address = Ipv4Address([192, 168, 1, 2]);
+
+ #[cfg(feature = "proto-ipv4")]
+ static PACKET_BYTES: [u8; 28] = [
+ 0xbf, 0x00, 0x00, 0x50, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x60, 0x35, 0x01,
+ 0x23, 0x01, 0xb6, 0x02, 0x01, 0x03, 0x03, 0x0c, 0x01, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ #[cfg(feature = "proto-ipv4")]
+ static OPTION_BYTES: [u8; 4] = [0x03, 0x03, 0x0c, 0x01];
+
+ #[cfg(feature = "proto-ipv4")]
+ static PAYLOAD_BYTES: [u8; 4] = [0xaa, 0x00, 0x00, 0xff];
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_deconstruct() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ assert_eq!(packet.src_port(), 48896);
+ assert_eq!(packet.dst_port(), 80);
+ assert_eq!(packet.seq_number(), SeqNumber(0x01234567));
+ assert_eq!(packet.ack_number(), SeqNumber(0x89abcdefu32 as i32));
+ assert_eq!(packet.header_len(), 24);
+ assert!(packet.fin());
+ assert!(!packet.syn());
+ assert!(packet.rst());
+ assert!(!packet.psh());
+ assert!(packet.ack());
+ assert!(packet.urg());
+ assert_eq!(packet.window_len(), 0x0123);
+ assert_eq!(packet.urgent_at(), 0x0201);
+ assert_eq!(packet.checksum(), 0x01b6);
+ assert_eq!(packet.options(), &OPTION_BYTES[..]);
+ assert_eq!(packet.payload(), &PAYLOAD_BYTES[..]);
+ assert!(packet.verify_checksum(&SRC_ADDR.into(), &DST_ADDR.into()));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; PACKET_BYTES.len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_src_port(48896);
+ packet.set_dst_port(80);
+ packet.set_seq_number(SeqNumber(0x01234567));
+ packet.set_ack_number(SeqNumber(0x89abcdefu32 as i32));
+ packet.set_header_len(24);
+ packet.clear_flags();
+ packet.set_fin(true);
+ packet.set_syn(false);
+ packet.set_rst(true);
+ packet.set_psh(false);
+ packet.set_ack(true);
+ packet.set_urg(true);
+ packet.set_window_len(0x0123);
+ packet.set_urgent_at(0x0201);
+ packet.set_checksum(0xEEEE);
+ packet.options_mut().copy_from_slice(&OPTION_BYTES[..]);
+ packet.payload_mut().copy_from_slice(&PAYLOAD_BYTES[..]);
+ packet.fill_checksum(&SRC_ADDR.into(), &DST_ADDR.into());
+ assert_eq!(&*packet.into_inner(), &PACKET_BYTES[..]);
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_truncated() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..23]);
+ assert_eq!(packet.check_len(), Err(Error));
+ }
+
+ #[test]
+ fn test_impossible_len() {
+ let mut bytes = vec![0; 20];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_header_len(10);
+ assert_eq!(packet.check_len(), Err(Error));
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ static SYN_PACKET_BYTES: [u8; 24] = [
+ 0xbf, 0x00, 0x00, 0x50, 0x01, 0x23, 0x45, 0x67, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02, 0x01,
+ 0x23, 0x7a, 0x8d, 0x00, 0x00, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ #[cfg(feature = "proto-ipv4")]
+ fn packet_repr() -> Repr<'static> {
+ Repr {
+ src_port: 48896,
+ dst_port: 80,
+ seq_number: SeqNumber(0x01234567),
+ ack_number: None,
+ window_len: 0x0123,
+ window_scale: None,
+ control: Control::Syn,
+ max_seg_size: None,
+ sack_permitted: false,
+ sack_ranges: [None, None, None],
+ payload: &PAYLOAD_BYTES,
+ }
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_parse() {
+ let packet = Packet::new_unchecked(&SYN_PACKET_BYTES[..]);
+ let repr = Repr::parse(
+ &packet,
+ &SRC_ADDR.into(),
+ &DST_ADDR.into(),
+ &ChecksumCapabilities::default(),
+ )
+ .unwrap();
+ assert_eq!(repr, packet_repr());
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_emit() {
+ let repr = packet_repr();
+ let mut bytes = vec![0xa5; repr.buffer_len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(
+ &mut packet,
+ &SRC_ADDR.into(),
+ &DST_ADDR.into(),
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(&*packet.into_inner(), &SYN_PACKET_BYTES[..]);
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_header_len_multiple_of_4() {
+ let mut repr = packet_repr();
+ repr.window_scale = Some(0); // This TCP Option needs 3 bytes.
+ assert_eq!(repr.header_len() % 4, 0); // Should e.g. be 28 instead of 27.
+ }
+
+ macro_rules! assert_option_parses {
+ ($opt:expr, $data:expr) => {{
+ assert_eq!(TcpOption::parse($data), Ok((&[][..], $opt)));
+ let buffer = &mut [0; 40][..$opt.buffer_len()];
+ assert_eq!($opt.emit(buffer), &mut []);
+ assert_eq!(&*buffer, $data);
+ }};
+ }
+
+ #[test]
+ fn test_tcp_options() {
+ assert_option_parses!(TcpOption::EndOfList, &[0x00]);
+ assert_option_parses!(TcpOption::NoOperation, &[0x01]);
+ assert_option_parses!(TcpOption::MaxSegmentSize(1500), &[0x02, 0x04, 0x05, 0xdc]);
+ assert_option_parses!(TcpOption::WindowScale(12), &[0x03, 0x03, 0x0c]);
+ assert_option_parses!(TcpOption::SackPermitted, &[0x4, 0x02]);
+ assert_option_parses!(
+ TcpOption::SackRange([Some((500, 1500)), None, None]),
+ &[0x05, 0x0a, 0x00, 0x00, 0x01, 0xf4, 0x00, 0x00, 0x05, 0xdc]
+ );
+ assert_option_parses!(
+ TcpOption::SackRange([Some((875, 1225)), Some((1500, 2500)), None]),
+ &[
+ 0x05, 0x12, 0x00, 0x00, 0x03, 0x6b, 0x00, 0x00, 0x04, 0xc9, 0x00, 0x00, 0x05, 0xdc,
+ 0x00, 0x00, 0x09, 0xc4
+ ]
+ );
+ assert_option_parses!(
+ TcpOption::SackRange([
+ Some((875000, 1225000)),
+ Some((1500000, 2500000)),
+ Some((876543210, 876654320))
+ ]),
+ &[
+ 0x05, 0x1a, 0x00, 0x0d, 0x59, 0xf8, 0x00, 0x12, 0xb1, 0x28, 0x00, 0x16, 0xe3, 0x60,
+ 0x00, 0x26, 0x25, 0xa0, 0x34, 0x3e, 0xfc, 0xea, 0x34, 0x40, 0xae, 0xf0
+ ]
+ );
+ assert_option_parses!(
+ TcpOption::Unknown {
+ kind: 12,
+ data: &[1, 2, 3][..]
+ },
+ &[0x0c, 0x05, 0x01, 0x02, 0x03]
+ )
+ }
+
+ #[test]
+ fn test_malformed_tcp_options() {
+ assert_eq!(TcpOption::parse(&[]), Err(Error));
+ assert_eq!(TcpOption::parse(&[0xc]), Err(Error));
+ assert_eq!(TcpOption::parse(&[0xc, 0x05, 0x01, 0x02]), Err(Error));
+ assert_eq!(TcpOption::parse(&[0xc, 0x01]), Err(Error));
+ assert_eq!(TcpOption::parse(&[0x2, 0x02]), Err(Error));
+ assert_eq!(TcpOption::parse(&[0x3, 0x02]), Err(Error));
+ }
+}
diff --git a/src/wire/udp.rs b/src/wire/udp.rs
new file mode 100644
index 0000000..77f9f84
--- /dev/null
+++ b/src/wire/udp.rs
@@ -0,0 +1,482 @@
+use byteorder::{ByteOrder, NetworkEndian};
+use core::fmt;
+
+use super::{Error, Result};
+use crate::phy::ChecksumCapabilities;
+use crate::wire::ip::checksum;
+use crate::wire::{IpAddress, IpProtocol};
+
+/// A read/write wrapper around an User Datagram Protocol packet buffer.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct Packet<T: AsRef<[u8]>> {
+ buffer: T,
+}
+
+mod field {
+ #![allow(non_snake_case)]
+
+ use crate::wire::field::*;
+
+ pub const SRC_PORT: Field = 0..2;
+ pub const DST_PORT: Field = 2..4;
+ pub const LENGTH: Field = 4..6;
+ pub const CHECKSUM: Field = 6..8;
+
+ pub const fn PAYLOAD(length: u16) -> Field {
+ CHECKSUM.end..(length as usize)
+ }
+}
+
+pub const HEADER_LEN: usize = field::CHECKSUM.end;
+
+#[allow(clippy::len_without_is_empty)]
+impl<T: AsRef<[u8]>> Packet<T> {
+ /// Imbue a raw octet buffer with UDP packet structure.
+ pub const fn new_unchecked(buffer: T) -> Packet<T> {
+ Packet { buffer }
+ }
+
+ /// Shorthand for a combination of [new_unchecked] and [check_len].
+ ///
+ /// [new_unchecked]: #method.new_unchecked
+ /// [check_len]: #method.check_len
+ pub fn new_checked(buffer: T) -> Result<Packet<T>> {
+ let packet = Self::new_unchecked(buffer);
+ packet.check_len()?;
+ Ok(packet)
+ }
+
+ /// Ensure that no accessor method will panic if called.
+ /// Returns `Err(Error)` if the buffer is too short.
+ /// Returns `Err(Error)` if the length field has a value smaller
+ /// than the header length.
+ ///
+ /// The result of this check is invalidated by calling [set_len].
+ ///
+ /// [set_len]: #method.set_len
+ pub fn check_len(&self) -> Result<()> {
+ let buffer_len = self.buffer.as_ref().len();
+ if buffer_len < HEADER_LEN {
+ Err(Error)
+ } else {
+ let field_len = self.len() as usize;
+ if buffer_len < field_len || field_len < HEADER_LEN {
+ Err(Error)
+ } else {
+ Ok(())
+ }
+ }
+ }
+
+ /// Consume the packet, returning the underlying buffer.
+ pub fn into_inner(self) -> T {
+ self.buffer
+ }
+
+ /// Return the source port field.
+ #[inline]
+ pub fn src_port(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::SRC_PORT])
+ }
+
+ /// Return the destination port field.
+ #[inline]
+ pub fn dst_port(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::DST_PORT])
+ }
+
+ /// Return the length field.
+ #[inline]
+ pub fn len(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::LENGTH])
+ }
+
+ /// Return the checksum field.
+ #[inline]
+ pub fn checksum(&self) -> u16 {
+ let data = self.buffer.as_ref();
+ NetworkEndian::read_u16(&data[field::CHECKSUM])
+ }
+
+ /// Validate the packet checksum.
+ ///
+ /// # Panics
+ /// This function panics unless `src_addr` and `dst_addr` belong to the same family,
+ /// and that family is IPv4 or IPv6.
+ ///
+ /// # Fuzzing
+ /// This function always returns `true` when fuzzing.
+ pub fn verify_checksum(&self, src_addr: &IpAddress, dst_addr: &IpAddress) -> bool {
+ if cfg!(fuzzing) {
+ return true;
+ }
+
+ // From the RFC:
+ // > An all zero transmitted checksum value means that the transmitter
+ // > generated no checksum (for debugging or for higher level protocols
+ // > that don't care).
+ if self.checksum() == 0 {
+ return true;
+ }
+
+ let data = self.buffer.as_ref();
+ checksum::combine(&[
+ checksum::pseudo_header(src_addr, dst_addr, IpProtocol::Udp, self.len() as u32),
+ checksum::data(&data[..self.len() as usize]),
+ ]) == !0
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
+ /// Return a pointer to the payload.
+ #[inline]
+ pub fn payload(&self) -> &'a [u8] {
+ let length = self.len();
+ let data = self.buffer.as_ref();
+ &data[field::PAYLOAD(length)]
+ }
+}
+
+impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
+ /// Set the source port field.
+ #[inline]
+ pub fn set_src_port(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::SRC_PORT], value)
+ }
+
+ /// Set the destination port field.
+ #[inline]
+ pub fn set_dst_port(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::DST_PORT], value)
+ }
+
+ /// Set the length field.
+ #[inline]
+ pub fn set_len(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::LENGTH], value)
+ }
+
+ /// Set the checksum field.
+ #[inline]
+ pub fn set_checksum(&mut self, value: u16) {
+ let data = self.buffer.as_mut();
+ NetworkEndian::write_u16(&mut data[field::CHECKSUM], value)
+ }
+
+ /// Compute and fill in the header checksum.
+ ///
+ /// # Panics
+ /// This function panics unless `src_addr` and `dst_addr` belong to the same family,
+ /// and that family is IPv4 or IPv6.
+ pub fn fill_checksum(&mut self, src_addr: &IpAddress, dst_addr: &IpAddress) {
+ self.set_checksum(0);
+ let checksum = {
+ let data = self.buffer.as_ref();
+ !checksum::combine(&[
+ checksum::pseudo_header(src_addr, dst_addr, IpProtocol::Udp, self.len() as u32),
+ checksum::data(&data[..self.len() as usize]),
+ ])
+ };
+ // UDP checksum value of 0 means no checksum; if the checksum really is zero,
+ // use all-ones, which indicates that the remote end must verify the checksum.
+ // Arithmetically, RFC 1071 checksums of all-zeroes and all-ones behave identically,
+ // so no action is necessary on the remote end.
+ self.set_checksum(if checksum == 0 { 0xffff } else { checksum })
+ }
+
+ /// Return a mutable pointer to the payload.
+ #[inline]
+ pub fn payload_mut(&mut self) -> &mut [u8] {
+ let length = self.len();
+ let data = self.buffer.as_mut();
+ &mut data[field::PAYLOAD(length)]
+ }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
+ fn as_ref(&self) -> &[u8] {
+ self.buffer.as_ref()
+ }
+}
+
+/// A high-level representation of an User Datagram Protocol packet.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Repr {
+ pub src_port: u16,
+ pub dst_port: u16,
+}
+
+impl Repr {
+ /// Parse an User Datagram Protocol packet and return a high-level representation.
+ pub fn parse<T>(
+ packet: &Packet<&T>,
+ src_addr: &IpAddress,
+ dst_addr: &IpAddress,
+ checksum_caps: &ChecksumCapabilities,
+ ) -> Result<Repr>
+ where
+ T: AsRef<[u8]> + ?Sized,
+ {
+ // Destination port cannot be omitted (but source port can be).
+ if packet.dst_port() == 0 {
+ return Err(Error);
+ }
+ // Valid checksum is expected...
+ if checksum_caps.udp.rx() && !packet.verify_checksum(src_addr, dst_addr) {
+ match (src_addr, dst_addr) {
+ // ... except on UDP-over-IPv4, where it can be omitted.
+ #[cfg(feature = "proto-ipv4")]
+ (&IpAddress::Ipv4(_), &IpAddress::Ipv4(_)) if packet.checksum() == 0 => (),
+ _ => return Err(Error),
+ }
+ }
+
+ Ok(Repr {
+ src_port: packet.src_port(),
+ dst_port: packet.dst_port(),
+ })
+ }
+
+ /// Return the length of the packet header that will be emitted from this high-level representation.
+ pub const fn header_len(&self) -> usize {
+ HEADER_LEN
+ }
+
+ /// Emit a high-level representation into an User Datagram Protocol packet.
+ ///
+ /// This never calculates the checksum, and is intended for internal-use only,
+ /// not for packets that are going to be actually sent over the network. For
+ /// example, when decompressing 6lowpan.
+ pub(crate) fn emit_header<T: ?Sized>(&self, packet: &mut Packet<&mut T>, payload_len: usize)
+ where
+ T: AsRef<[u8]> + AsMut<[u8]>,
+ {
+ packet.set_src_port(self.src_port);
+ packet.set_dst_port(self.dst_port);
+ packet.set_len((HEADER_LEN + payload_len) as u16);
+ packet.set_checksum(0);
+ }
+
+ /// Emit a high-level representation into an User Datagram Protocol packet.
+ pub fn emit<T: ?Sized>(
+ &self,
+ packet: &mut Packet<&mut T>,
+ src_addr: &IpAddress,
+ dst_addr: &IpAddress,
+ payload_len: usize,
+ emit_payload: impl FnOnce(&mut [u8]),
+ checksum_caps: &ChecksumCapabilities,
+ ) where
+ T: AsRef<[u8]> + AsMut<[u8]>,
+ {
+ packet.set_src_port(self.src_port);
+ packet.set_dst_port(self.dst_port);
+ packet.set_len((HEADER_LEN + payload_len) as u16);
+ emit_payload(packet.payload_mut());
+
+ if checksum_caps.udp.tx() {
+ packet.fill_checksum(src_addr, dst_addr)
+ } else {
+ // make sure we get a consistently zeroed checksum,
+ // since implementations might rely on it
+ packet.set_checksum(0);
+ }
+ }
+}
+
+impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ // Cannot use Repr::parse because we don't have the IP addresses.
+ write!(
+ f,
+ "UDP src={} dst={} len={}",
+ self.src_port(),
+ self.dst_port(),
+ self.payload().len()
+ )
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl<'a, T: AsRef<[u8]> + ?Sized> defmt::Format for Packet<&'a T> {
+ fn format(&self, fmt: defmt::Formatter) {
+ // Cannot use Repr::parse because we don't have the IP addresses.
+ defmt::write!(
+ fmt,
+ "UDP src={} dst={} len={}",
+ self.src_port(),
+ self.dst_port(),
+ self.payload().len()
+ );
+ }
+}
+
+impl fmt::Display for Repr {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "UDP src={} dst={}", self.src_port, self.dst_port)
+ }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Repr {
+ fn format(&self, fmt: defmt::Formatter) {
+ defmt::write!(fmt, "UDP src={} dst={}", self.src_port, self.dst_port);
+ }
+}
+
+use crate::wire::pretty_print::{PrettyIndent, PrettyPrint};
+
+impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
+ fn pretty_print(
+ buffer: &dyn AsRef<[u8]>,
+ f: &mut fmt::Formatter,
+ indent: &mut PrettyIndent,
+ ) -> fmt::Result {
+ match Packet::new_checked(buffer) {
+ Err(err) => write!(f, "{indent}({err})"),
+ Ok(packet) => write!(f, "{indent}{packet}"),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ #[cfg(feature = "proto-ipv4")]
+ use crate::wire::Ipv4Address;
+
+ #[cfg(feature = "proto-ipv4")]
+ const SRC_ADDR: Ipv4Address = Ipv4Address([192, 168, 1, 1]);
+ #[cfg(feature = "proto-ipv4")]
+ const DST_ADDR: Ipv4Address = Ipv4Address([192, 168, 1, 2]);
+
+ #[cfg(feature = "proto-ipv4")]
+ static PACKET_BYTES: [u8; 12] = [
+ 0xbf, 0x00, 0x00, 0x35, 0x00, 0x0c, 0x12, 0x4d, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ #[cfg(feature = "proto-ipv4")]
+ static NO_CHECKSUM_PACKET: [u8; 12] = [
+ 0xbf, 0x00, 0x00, 0x35, 0x00, 0x0c, 0x00, 0x00, 0xaa, 0x00, 0x00, 0xff,
+ ];
+
+ #[cfg(feature = "proto-ipv4")]
+ static PAYLOAD_BYTES: [u8; 4] = [0xaa, 0x00, 0x00, 0xff];
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_deconstruct() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ assert_eq!(packet.src_port(), 48896);
+ assert_eq!(packet.dst_port(), 53);
+ assert_eq!(packet.len(), 12);
+ assert_eq!(packet.checksum(), 0x124d);
+ assert_eq!(packet.payload(), &PAYLOAD_BYTES[..]);
+ assert!(packet.verify_checksum(&SRC_ADDR.into(), &DST_ADDR.into()));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_construct() {
+ let mut bytes = vec![0xa5; 12];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_src_port(48896);
+ packet.set_dst_port(53);
+ packet.set_len(12);
+ packet.set_checksum(0xffff);
+ packet.payload_mut().copy_from_slice(&PAYLOAD_BYTES[..]);
+ packet.fill_checksum(&SRC_ADDR.into(), &DST_ADDR.into());
+ assert_eq!(&*packet.into_inner(), &PACKET_BYTES[..]);
+ }
+
+ #[test]
+ fn test_impossible_len() {
+ let mut bytes = vec![0; 12];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_len(4);
+ assert_eq!(packet.check_len(), Err(Error));
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_zero_checksum() {
+ let mut bytes = vec![0; 8];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_src_port(1);
+ packet.set_dst_port(31881);
+ packet.set_len(8);
+ packet.fill_checksum(&SRC_ADDR.into(), &DST_ADDR.into());
+ assert_eq!(packet.checksum(), 0xffff);
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_no_checksum() {
+ let mut bytes = vec![0; 8];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ packet.set_src_port(1);
+ packet.set_dst_port(31881);
+ packet.set_len(8);
+ packet.set_checksum(0);
+ assert!(packet.verify_checksum(&SRC_ADDR.into(), &DST_ADDR.into()));
+ }
+
+ #[cfg(feature = "proto-ipv4")]
+ fn packet_repr() -> Repr {
+ Repr {
+ src_port: 48896,
+ dst_port: 53,
+ }
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_parse() {
+ let packet = Packet::new_unchecked(&PACKET_BYTES[..]);
+ let repr = Repr::parse(
+ &packet,
+ &SRC_ADDR.into(),
+ &DST_ADDR.into(),
+ &ChecksumCapabilities::default(),
+ )
+ .unwrap();
+ assert_eq!(repr, packet_repr());
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_emit() {
+ let repr = packet_repr();
+ let mut bytes = vec![0xa5; repr.header_len() + PAYLOAD_BYTES.len()];
+ let mut packet = Packet::new_unchecked(&mut bytes);
+ repr.emit(
+ &mut packet,
+ &SRC_ADDR.into(),
+ &DST_ADDR.into(),
+ PAYLOAD_BYTES.len(),
+ |payload| payload.copy_from_slice(&PAYLOAD_BYTES),
+ &ChecksumCapabilities::default(),
+ );
+ assert_eq!(&*packet.into_inner(), &PACKET_BYTES[..]);
+ }
+
+ #[test]
+ #[cfg(feature = "proto-ipv4")]
+ fn test_checksum_omitted() {
+ let packet = Packet::new_unchecked(&NO_CHECKSUM_PACKET[..]);
+ let repr = Repr::parse(
+ &packet,
+ &SRC_ADDR.into(),
+ &DST_ADDR.into(),
+ &ChecksumCapabilities::default(),
+ )
+ .unwrap();
+ assert_eq!(repr, packet_repr());
+ }
+}
diff --git a/utils/packet2pcap.rs b/utils/packet2pcap.rs
new file mode 100644
index 0000000..7d06c6f
--- /dev/null
+++ b/utils/packet2pcap.rs
@@ -0,0 +1,74 @@
+use getopts::Options;
+use smoltcp::phy::{PcapLinkType, PcapSink};
+use smoltcp::time::Instant;
+use std::env;
+use std::fs::File;
+use std::io::{self, Read};
+use std::path::Path;
+use std::process::exit;
+
+fn convert(
+ packet_filename: &Path,
+ pcap_filename: &Path,
+ link_type: PcapLinkType,
+) -> io::Result<()> {
+ let mut packet_file = File::open(packet_filename)?;
+ let mut packet = Vec::new();
+ packet_file.read_to_end(&mut packet)?;
+
+ let mut pcap_file = File::create(pcap_filename)?;
+ PcapSink::global_header(&mut pcap_file, link_type);
+ PcapSink::packet(&mut pcap_file, Instant::from_millis(0), &packet[..]);
+
+ Ok(())
+}
+
+fn print_usage(program: &str, opts: Options) {
+ let brief = format!("Usage: {program} [options] INPUT OUTPUT");
+ print!("{}", opts.usage(&brief));
+}
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ let program = args[0].clone();
+
+ let mut opts = Options::new();
+ opts.optflag("h", "help", "print this help menu");
+ opts.optopt(
+ "t",
+ "link-type",
+ "set link type (one of: ethernet ip)",
+ "TYPE",
+ );
+
+ let matches = match opts.parse(&args[1..]) {
+ Ok(m) => m,
+ Err(e) => {
+ eprintln!("{e}");
+ return;
+ }
+ };
+
+ let link_type = match matches.opt_str("t").as_ref().map(|s| &s[..]) {
+ Some("ethernet") => Some(PcapLinkType::Ethernet),
+ Some("ip") => Some(PcapLinkType::Ip),
+ _ => None,
+ };
+
+ if matches.opt_present("h") || matches.free.len() != 2 || link_type.is_none() {
+ print_usage(&program, opts);
+ return;
+ }
+
+ match convert(
+ Path::new(&matches.free[0]),
+ Path::new(&matches.free[1]),
+ link_type.unwrap(),
+ ) {
+ Ok(()) => (),
+ Err(e) => {
+ eprintln!("Cannot convert packet to pcap: {e}");
+ exit(1);
+ }
+ }
+}
