Embassy Net

https://docs.embassy.dev/embassy-net/0.7.1/default/
Admin
Embassy Net is a no-std no-alloc async network stack for embedded systems built on smoltcp,...
Tokens:78,342
Snippets:558
Trust Score:8.2
Update:4 months ago
Show doc for...
Tokens:
Raw
### Initialize Network Stack with DHCPv4

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Stack.html

Example of initializing the network stack with DHCPv4 configuration. Ensure `Runner::run` is started before using `wait_config_up`. This function may never return if DHCP fails, so a timeout mechanism is recommended.

```rust
let config = embassy_net::Config::dhcpv4(Default::default());
// Init network stack
// NOTE: DHCP and DNS need one socket slot if enabled. This is why we're
// provisioning space for 3 sockets here: one for DHCP, one for DNS, and one for your code (e.g. TCP).
// If you use more sockets you must increase this. If you don't enable DHCP or DNS you can decrease it.
static RESOURCES: StaticCell<embassy_net::StackResources<3>> = StaticCell::new();
let (stack, runner) = embassy_net::new(
   driver,
   config,
   RESOURCES.init(embassy_net::StackResources::new()),
   seed
);
// Launch network task that runs `runner.run().await`
spawner.spawn(net_task(runner)).unwrap();
// Wait for DHCP config
stack.wait_config_up().await;
// use the network stack
// ...
```

--------------------------------

### Calculate Steps Between Ipv4 Addrs

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv4Address.html

This is a nightly-only experimental API. Returns the bounds on the number of successor steps required to get from start to end.

```rust
fn steps_between(_: &Ipv4Addr, _: &Ipv4Addr) -> (usize, Option<usize>)
```

--------------------------------

### Accessing Ipv6Addr Constants

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv6Address.html

Examples of using the built-in constants for localhost and unspecified addresses.

```rust
use std::net::Ipv6Addr;

let addr = Ipv6Addr::LOCALHOST;
assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
```

```rust
use std::net::Ipv6Addr;

let addr = Ipv6Addr::UNSPECIFIED;
assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));
```

--------------------------------

### HardwareAddress as_bytes Method

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.HardwareAddress.html

Provides a method to get the hardware address as a byte slice. This is useful for low-level network operations or when interfacing with hardware that expects raw byte representations of addresses.

```rust
pub const fn as_bytes(&self) -> &[u8]
```

--------------------------------

### Get IP Address Version

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/dns/enum.IpAddress.html

Returns the protocol version (IPv4 or IPv6) of the Address. This is useful for conditional logic based on the address type.

```rust
pub const fn version(&self) -> Version
```

--------------------------------

### Config Initialization

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Config.html

Demonstrates how to initialize the `Config` struct using static or dynamic IP addressing methods.

```APIDOC
## Implementations for Config

### `impl Config`

#### `pub const fn ipv4_static(config: StaticConfigV4) -> Self`
IPv4 configuration with static addressing.

#### `pub const fn ipv6_static(config: StaticConfigV6) -> Self`
IPv6 configuration with static addressing.

#### `pub const fn dhcpv4(config: DhcpConfig) -> Self`
IPv4 configuration with dynamic addressing.

##### Example
```rust
let _cfg = Config::dhcpv4(Default::default());
```
```

--------------------------------

### Get the size of an IPv6 address in bits

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv6Address.html

Retrieves the constant value for the number of bits in an IPv6 address. No setup is required beyond importing `Ipv6Addr`.

```rust
use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::BITS, 128);
```

--------------------------------

### Network Stack Initialization

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/embassy_net/index.html

Documentation for creating and configuring the network stack.

```APIDOC
## Function: new

### Description
Creates a new network stack instance.

### Parameters
- **config** (Config) - Required - Network stack configuration.
- **resources** (StackResources) - Required - Memory resources needed for the network stack.

### Response
- **Stack** (Object) - Returns a handle to the initialized network stack.
```

--------------------------------

### Get Icmpv4Packet Checksum

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Retrieves the checksum field from the ICMPv4 packet.

```rust
pub fn checksum(&self) -> u16
```

--------------------------------

### write_ready Method

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/tcp/struct.TcpSocket.html

Documentation for the `write_ready` method, likely associated with a writer interface.

```APIDOC
#### fn write_ready(&mut self) -> Result<bool, Self::Error>

### Description
Get whether the writer is ready for immediately writing.
```

--------------------------------

### Create and use an IPv6 loopback address

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv6Address.html

Demonstrates creating an IPv6 loopback address and checking its properties. Requires importing `Ipv6Addr`.

```rust
use std::net::Ipv6Addr;

let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
assert_eq!("::1".parse(), Ok(localhost));
assert_eq!(localhost.is_loopback(), true);
```

--------------------------------

### Get octets from Ipv4Addr

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv4Address.html

Retrieves the four eight-bit integers that compose the IPv4 address.

```rust
use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(127, 0, 0, 1);
assert_eq!(addr.octets(), [127, 0, 0, 1]);
```

--------------------------------

### Network Stack Initialization

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/fn.new.html

This section describes how to create a new instance of the Embassy network stack.

```APIDOC
## POST /embassy/net/stack

### Description
Creates a new network stack instance with the provided driver, configuration, resources, and random seed.

### Method
POST

### Endpoint
/embassy/net/stack

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **driver** (D) - Required - The network driver to use.
- **config** (Config) - Required - The configuration settings for the network stack.
- **resources** (&'d mut StackResources<SOCK>) - Required - Mutable reference to stack resources.
- **random_seed** (u64) - Required - A seed for random number generation.

### Request Example
```json
{
  "driver": "<your_driver_implementation>",
  "config": {
    "<config_fields>": "<values>"
  },
  "resources": "<stack_resources_implementation>",
  "random_seed": 1234567890
}
```

### Response
#### Success Response (200)
- **Stack** ('d) - The initialized network stack.
- **Runner** ('d, D) - The runner for the network stack.

#### Response Example
```json
{
  "stack": "<stack_instance>",
  "runner": "<runner_instance>"
}
```
```

--------------------------------

### Get Icmpv4Packet Message Code

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Retrieves the message code field from the ICMPv4 packet.

```rust
pub fn msg_code(&self) -> u8
```

--------------------------------

### Get Icmpv4Packet Message Type

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Retrieves the message type field from the ICMPv4 packet.

```rust
pub fn msg_type(&self) -> Message
```

--------------------------------

### Implement From<Address> for HardwareAddress

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.Ieee802154Address.html

Provides a conversion from Address to HardwareAddress.

```rust
fn from(addr: Address) -> HardwareAddress
```

--------------------------------

### Create Config with DHCPv4

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Config.html

Constructs a `Config` instance with dynamic IPv4 addressing using DHCP. Uses `Default::default()` for DHCP settings.

```rust
pub const fn dhcpv4(config: DhcpConfig) -> Self

let _cfg = Config::dhcpv4(Default::default());

```

--------------------------------

### impl<T> CloneToUninit for T

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/raw/enum.IpProtocol.html

Nightly-only experimental API for blanket implementation of `CloneToUninit`.

```APIDOC
## impl<T> CloneToUninit for T

### Description
Nightly-only experimental API for blanket implementation of `CloneToUninit` for types `T` that implement `Clone`.

### Method
`clone_to_uninit`

### Endpoint
N/A (Trait implementation)

### Parameters
- **dest** (*mut u8) - Required - A mutable pointer to the destination memory.

### Request Body
None

### Response
#### Success Response (200)
This method performs an operation and does not return a value directly.

### Response Example
```json
{
  "status": "completed"
}
```
```

--------------------------------

### Get Icmpv4Packet Data Pointer

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Returns a reference to the type-specific data within the ICMPv4 packet.

```rust
pub fn data(&self) -> &'a [u8]
```

--------------------------------

### Get ICMPv6 Parameter Problem Pointer

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv6Packet.html

Retrieves the pointer field for 'parameter problem' messages.

```rust
pub fn param_problem_ptr(&self) -> u32
```

--------------------------------

### fn try_into

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/ping/enum.PingError.html

Documentation for the try_into conversion function.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from the current type into the target type U.

### Response
- **Result<U, <U as TryFrom<T>>::Error>** - Returns the converted type U on success, or an error defined by the TryFrom implementation on failure.
```

--------------------------------

### Get ICMPv6 Packet Too Big MTU

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv6Packet.html

Retrieves the MTU field for 'packet too big' messages.

```rust
pub fn pkt_too_big_mtu(&self) -> u32
```

--------------------------------

### Create New Network Stack

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/fn.new.html

Use this function to initialize a new network stack with a given driver, configuration, resources, and random seed. Ensure all necessary resources are provided.

```rust
pub fn new<'d, D: Driver, constSOCK: usize>(
    driver: D,
    config: Config,
    resources: &'d mut StackResources<SOCK>,
    random_seed: u64,
) -> (Stack<'d>, Runner<'d, D>)

```

--------------------------------

### Ipv4Addr Creation and Parsing

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv4Address.html

Demonstrates how to create an Ipv4Addr from a byte array or a u32, and how to parse it from a string.

```APIDOC
## Ipv4Addr Creation and Parsing

### Description
This section covers the creation of an `Ipv4Addr` from various sources, including byte arrays and unsigned 32-bit integers, as well as parsing from string representations.

### Methods

#### `from([u8; 4]) -> Ipv4Addr`
Creates an `Ipv4Addr` from a four-element byte array.

#### `from(u32) -> Ipv4Addr`
Converts a host byte order `u32` into an `Ipv4Addr` using `Ipv4Addr::from_bits`.

#### `from_str(&str) -> Result<Ipv4Addr, AddrParseError>`
Parses a string slice into an `Ipv4Addr`. Returns `AddrParseError` on failure.

### Examples

#### Creating from a byte array:
```rust
use std::net::Ipv4Addr;

let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);
```

#### Parsing from a string:
```rust
use std::str::FromStr;
use std::net::Ipv4Addr;

let ip_str = "192.168.1.1";
let ip_addr = Ipv4Addr::from_str(ip_str).unwrap();
assert_eq!(ip_addr.octets(), [192, 168, 1, 1]);
```
```

--------------------------------

### Get Icmpv4Packet Header Length

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Returns the header length of the ICMPv4 packet, which depends on the message type.

```rust
pub fn header_len(&self) -> usize
```

--------------------------------

### Get Size of IPv4 Address in Bits

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv4Address.html

Retrieves the size of an IPv4 address in bits. This is a constant value.

```rust
use std::net::Ipv4Addr;

assert_eq!(Ipv4Addr::BITS, 32);
```

--------------------------------

### Create Config with Static IPv6

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Config.html

Constructs a `Config` instance with static IPv6 addressing. Requires a `StaticConfigV6` struct.

```rust
pub const fn ipv6_static(config: StaticConfigV6) -> Self
```

--------------------------------

### Get multicast scope

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv6Address.html

Retrieves the multicast scope of an address if it is a multicast address. Requires the nightly-only ip feature.

```rust
#![feature(ip)]

use std::net::{Ipv6Addr, Ipv6MulticastScope};

assert_eq!(
    Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0).multicast_scope(),
    Some(Ipv6MulticastScope::Global)
);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).multicast_scope(), None);
```

--------------------------------

### CloneToUninit for T

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/enum.Icmpv4Repr.html

Nightly-only experimental API for copy-assignment to uninitialized memory.

```APIDOC
## impl<T> CloneToUninit for T

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`unsafe fn clone_to_uninit(&self, dest: *mut u8)`
```

--------------------------------

### Get Hop Limit

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.IcmpSocket.html

Returns the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.

```APIDOC
## GET /hop_limit

### Description
Return the time-to-live (IPv4) or hop limit (IPv6) value used in outgoing packets.

### Method
GET

### Endpoint
/hop_limit

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **Option<u8>** - The current hop limit, or None if not set.

#### Response Example
```json
{
  "hop_limit": 64
}
```
```

--------------------------------

### Create Config with Static IPv4

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Config.html

Constructs a `Config` instance with static IPv4 addressing. Requires a `StaticConfigV4` struct.

```rust
pub const fn ipv4_static(config: StaticConfigV4) -> Self
```

--------------------------------

### Create new StackResources

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.StackResources.html

Constructor for initializing a new set of stack resources.

```rust
pub const fn new() -> Self
```

--------------------------------

### Get Mutable Icmpv4Packet Data Pointer

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Returns a mutable reference to the type-specific data within the ICMPv4 packet.

```rust
pub fn data_mut(&mut self) -> &mut [u8]
```

--------------------------------

### Get octets as slice

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv4Address.html

Returns the address octets as a reference to a byte array. Requires the nightly-only feature `ip_as_octets`.

```rust
#![feature(ip_as_octets)]

use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(127, 0, 0, 1);
assert_eq!(addr.as_octets(), &[127, 0, 0, 1]);
```

--------------------------------

### Create IpEndpoint Instance

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.IpEndpoint.html

Constructs a new IpEndpoint with a specified address and port. Ensure the Address type is compatible.

```rust
pub const fn new(addr: Address, port: u16) -> Endpoint
```

--------------------------------

### HardwareAddress Blanket Implementations

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.HardwareAddress.html

Details blanket implementations for HardwareAddress, including Any, Borrow, BorrowMut, CloneToUninit, From<T>, Into<U>, and TryFrom<U>. These provide generic functionality and conversions.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
```

```rust
fn type_id(&self) -> TypeId
```

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
```

```rust
fn borrow(&self) -> &T
```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
```

```rust
fn borrow_mut(&mut self) -> &mut T
```

```rust
impl<T> CloneToUninit for T
where T: Clone,
```

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

```rust
impl<T> From<T> for T
```

```rust
fn from(t: T) -> T
```

```rust
impl<T, U> Into<U> for T
where U: From<T>,
```

```rust
fn into(self) -> U
```

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
```

```rust
type Error = Infallible
```

--------------------------------

### Get ICMPv6 Packet Buffer Length

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/enum.Icmpv6Repr.html

Calculates the required buffer size for emitting the current ICMPv6 representation.

```rust
pub fn buffer_len(&self) -> usize

```

--------------------------------

### DNS Client Module Overview

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/dns/index.html

Overview of the DNS client structures and enums available in the embassy-net crate.

```APIDOC
## DNS Client Module

### Description
The DNS client is compatible with the `embedded-nal-async` traits. It is recommended to use `Stack::dns_query` directly if `embedded-nal-async` is not required.

### Structs
- **DnsQuery**: State for an in-progress DNS query.
- **DnsSocket**: DNS client compatible with the `embedded-nal-async` traits.
- **Socket**: A Domain Name System socket.

### Enums
- **DnsQueryType**: DNS record types.
- **Error**: Errors returned by DnsSocket.
- **IpAddress**: An internetworking address.
```

--------------------------------

### Suppress Router-Side Processing Flag

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv6Packet.html

Provides methods to get, set, and clear the Suppress Router-Side Processing (S-flag) flag.

```APIDOC
## S-Flag Operations

### Description
Manages the Suppress Router-Side Processing (S-flag) flag.

### Methods
#### GET /packet/s_flag
Retrieves the state of the S-flag.

#### POST /packet/set_s_flag
Sets the S-flag.

#### POST /packet/clear_s_flag
Clears the S-flag.

### Parameters
#### GET /packet/s_flag
None

#### POST /packet/set_s_flag
None

#### POST /packet/clear_s_flag
None

### Response
#### Success Response (200)
- **s_flag** (bool) - The current state of the S-flag (for GET).
- **status** (string) - Indicates success or failure of the operation (for POST).

#### Response Example (GET)
```json
{
  "s_flag": true
}
```
#### Response Example (POST)
```json
{
  "status": "success"
}
```
```

--------------------------------

### Get TCP Socket Send Capacity

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/tcp/struct.TcpWriter.html

Returns the maximum number of bytes that can be held in the transmit buffer of the TCP socket.

```rust
pub fn send_capacity(&self) -> usize
```

--------------------------------

### Default Configuration

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Config.html

Provides the default configuration for the network stack. This is useful for initializing settings when no specific configuration is provided.

```rust
fn default() -> Config
```

--------------------------------

### Get ICMPv6 Payload

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv6Packet.html

Returns a reference to the type-specific data (payload) of the ICMPv6 packet. This method operates on a borrowed packet.

```rust
pub fn payload(&self) -> &'a [u8]
```

--------------------------------

### Get TCP Socket Send Queue Size

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/tcp/struct.TcpWriter.html

Returns the current number of bytes queued in the transmit buffer of the TCP socket.

```rust
pub fn send_queue(&self) -> usize
```

--------------------------------

### Implement Address Methods

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.Ieee802154Address.html

Provides implementations for Address, including constants like BROADCAST and methods for checking address types, converting to byte slices, and deriving EUI-64 or link-local IPv6 addresses.

```rust
pub const BROADCAST: Address
```

```rust
pub fn is_unicast(&self) -> bool
```

```rust
pub fn is_broadcast(&self) -> bool
```

```rust
pub fn from_bytes(a: &[u8]) -> Address
```

```rust
pub const fn as_bytes(&self) -> &[u8]
```

```rust
pub fn as_eui_64(&self) -> Option<[u8; 8]>
```

```rust
pub fn as_link_local_address(&self) -> Option<Ipv6Addr>
```

--------------------------------

### Get Mutable ICMPv6 Payload

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv6Packet.html

Returns a mutable reference to the type-specific data (payload) of the ICMPv6 packet. This allows modification of the payload.

```rust
pub fn payload_mut(&mut self) -> &mut [u8]
```

--------------------------------

### impl<T> CloneToUninit for T

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/enum.Icmpv6Repr.html

Nightly-only experimental blanket implementation of `CloneToUninit` for types `T` that implement `Clone`.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
POST

### Endpoint
N/A (Trait method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **dest** (*mut u8) - A mutable pointer to the destination memory.

### Request Example
```json
{
  "dest": "0x1234567890abcdef"
}
```

### Response
#### Success Response (200)
None (operation is in-place or modifies memory pointed to by `dest`)

### Response Example
```json
null
```
```

--------------------------------

### ICMP Ping Operation

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/ping/index.html

Demonstrates how to initialize a PingManager and perform an ICMP ping operation.

```APIDOC
## ICMP Ping Operation

### Description
This operation uses the PingManager to send an ICMP Echo request to a specified IPv4 address and returns the round-trip time.

### Usage
```rust
use core::net::Ipv4Addr;
use core::str::FromStr;
use embassy_net::icmp::ping::{PingManager, PingParams};
use embassy_net::icmp::PacketMetadata;

let mut rx_buffer = [0; 256];
let mut tx_buffer = [0; 256];
let mut rx_meta = [PacketMetadata::EMPTY];
let mut tx_meta = [PacketMetadata::EMPTY];

let mut ping_manager = PingManager::new(stack, &mut rx_meta, &mut rx_buffer, &mut tx_meta, &mut tx_buffer);
let addr = "192.168.8.1";
let mut ping_params = PingParams::new(Ipv4Addr::from_str(addr).unwrap());
ping_params.set_payload(b"Hello, router!");
match ping_manager.ping(&ping_params).await {
    Ok(time) => info!("Ping time of {}: {}ms", addr, time.as_millis()),
    Err(ping_error) => warn!("{:?}", ping_error),
};
```
```

--------------------------------

### Get Minimum of Two IP Addresses

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.IpAddress.html

Compares two IP addresses and returns the minimum of the two. This is a utility function from the `Ord` trait.

```rust
fn min(self, other: Self) -> Self
where Self: Sized,
```

--------------------------------

### HardwareAddress From<Address> Implementation

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.HardwareAddress.html

Provides implementations for converting an Address type into a HardwareAddress. This simplifies the process of creating HardwareAddress instances from existing address data.

```rust
fn from(addr: Address) -> HardwareAddress
```

```rust
fn from(addr: Address) -> HardwareAddress
```

--------------------------------

### Get Maximum of Two IP Addresses

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.IpAddress.html

Compares two IP addresses and returns the maximum of the two. This is a utility function from the `Ord` trait.

```rust
fn max(self, other: Self) -> Self
where Self: Sized,
```

--------------------------------

### Get Icmpv4Packet Echo Identifier

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Retrieves the identifier field for echo request and reply packets. Panics if the packet is not an echo request or reply.

```rust
pub fn echo_ident(&self) -> u16
```

--------------------------------

### From and Into Traits

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/raw/struct.RawSocket.html

Documentation for the From and Into traits used for value conversion.

```APIDOC
## From Trait

### Description
Returns the argument unchanged.

### Method
fn from(t: T) -> T

## Into Trait

### Description
Calls U::from(self). This conversion is defined by the implementation of From<T> for U.

### Method
fn into(self) -> U
```

--------------------------------

### Define Static IPv6 Configuration

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.StaticConfigV6.html

Use this struct to configure a static IPv6 address, gateway, and DNS servers. Ensure all fields are correctly set for network connectivity.

```rust
pub struct StaticConfigV6 {
    pub address: Ipv6Cidr,
    pub gateway: Option<Ipv6Address>,
    pub dns_servers: Vec<Ipv6Address, 3>,
}
```

--------------------------------

### Get Prefix Length from CIDR

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.IpAddress.html

If the IP address represents a CIDR-compatible subnet mask, this function returns `Some(prefix_len)`. Otherwise, it returns `None`.

```rust
pub fn prefix_len(&self) -> Option<u8>
```

--------------------------------

### Initialize PingManager

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/ping/struct.PingManager.html

Creates a new instance of PingManager with the required network stack and buffers.

```rust
pub fn new( stack: Stack<'d>, rx_meta: &'d mut [PacketMetadata], rx_buffer: &'d mut [u8], tx_meta: &'d mut [PacketMetadata], tx_buffer: &'d mut [u8], ) -> Self
```

--------------------------------

### Get IPv6 Address Octets

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv6Address.html

The `octets` method returns the sixteen eight-bit integers that constitute the IPv6 address. This method is available from Rust 1.75.0.

```rust
use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(),
           [0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
```

--------------------------------

### TcpConnect::connect

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/tcp/client/struct.TcpClient.html

Establishes a TCP connection to a remote host.

```APIDOC
## TcpConnect::connect

### Description
Connects to the given remote host and port, returning a connection object.

### Parameters
- **remote** (SocketAddr) - Required - The remote address and port to connect to.

### Response
- **Result<Self::Connection<'a>, Self::Error>** - Returns a connection object on success or an error if the connection fails.
```

--------------------------------

### Cidr Implementations

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv4Cidr.html

Documentation for the implementations of the Cidr struct.

```APIDOC
## impl Cidr

### `new(address: Ipv4Addr, prefix_len: u8) -> 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.

### `from_netmask(addr: Ipv4Addr, netmask: Ipv4Addr) -> Result<Cidr, Error>`

Create an IPv4 CIDR block from the given address and network mask.

### `address(&self) -> Ipv4Addr`

Return the address of this IPv4 CIDR block.

### `prefix_len(&self) -> u8`

Return the prefix length of this IPv4 CIDR block.

### `netmask(&self) -> Ipv4Addr`

Return the network mask of this IPv4 CIDR.

### `broadcast(&self) -> Option<Ipv4Addr>`

Return the broadcast address of this IPv4 CIDR.

### `network(&self) -> Cidr`

Return the network block of this IPv4 CIDR.

### `contains_addr(&self, addr: &Ipv4Addr) -> bool`

Query whether the subnetwork described by this IPv4 CIDR block contains the given address.

### `contains_subnet(&self, subnet: &Cidr) -> bool`

Query whether the subnetwork described by this IPv4 CIDR block contains the subnetwork described by the given IPv4 CIDR block.
```

--------------------------------

### Get IPv6 Address Octets as Slice

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv6Address.html

The `as_octets` method returns a slice referencing the sixteen eight-bit integers of the IPv6 address. This is a nightly-only experimental API.

```rust
#![feature(ip_as_octets)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).as_octets(),
           &[255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
```

--------------------------------

### Get Icmpv4Packet Echo Sequence Number

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv4Packet.html

Retrieves the sequence number field for echo request and reply packets. Panics if the packet is not an echo request or reply.

```rust
pub fn echo_seq_no(&self) -> u16
```

--------------------------------

### Network Configuration

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/embassy_net/index.html

Overview of configuration structures for the network stack.

```APIDOC
## Structs: Configuration

### Config
- **DhcpConfig** - DHCP configuration settings.
- **StaticConfigV4** - Static IPv4 address configuration.
- **StaticConfigV6** - Static IPv6 address configuration.

### Enums
- **ConfigV4** - Network stack IPv4 configuration.
- **ConfigV6** - Network stack IPv6 configuration.
```

--------------------------------

### Runner::run

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Runner.html

The run method is the primary entry point for the network stack, which must be called in a background task to process network events.

```APIDOC
## Runner::run

### Description
Runs the network stack. This method must be called in a background task to process network events for the stack to function.

### Method
Async Function

### Signature
pub async fn run(&mut self) -> !
```

--------------------------------

### Get Multicast Listener Query Header Fields

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/struct.Icmpv6Packet.html

Provides getters for the header fields specific to the Multicast Listener Query message type, as defined in RFC 3810 § 5.1.

```rust
Getters for the Multicast Listener Query message header. See RFC 3810 § 5.1.
```

--------------------------------

### CloneToUninit

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/dns/enum.DnsQueryType.html

The `CloneToUninit` trait allows for copying data into an uninitialized memory location. This is an experimental, nightly-only feature.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`unsafe fn clone_to_uninit`

### Parameters
- **dest** (*mut u8*) - The destination pointer to copy the data to.

### Notes
This is a nightly-only experimental API.
```

--------------------------------

### PingManager::new

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/ping/struct.PingManager.html

Creates a new instance of the PingManager, initializing it with the required network stack and memory buffers for packet transmission and reception.

```APIDOC
## pub fn new(stack: Stack<'d>, rx_meta: &'d mut [PacketMetadata], rx_buffer: &'d mut [u8], tx_meta: &'d mut [PacketMetadata], tx_buffer: &'d mut [u8]) -> Self

### Description
Creates a new instance of `PingManager` with a `Stack` instance and the buffers used for RX and TX. Note that this does not yet create the ICMP socket.

### Parameters
- **stack** (Stack<'d>) - Required - The network stack instance used for managing network operations.
- **rx_meta** (&'d mut [PacketMetadata]) - Required - Metadata buffer for receiving packets.
- **rx_buffer** (&'d mut [u8]) - Required - Buffer for receiving packets.
- **tx_meta** (&'d mut [PacketMetadata]) - Required - Metadata buffer for transmitting packets.
- **tx_buffer** (&'d mut [u8]) - Required - Buffer for transmitting packets.
```

--------------------------------

### Compare EthernetAddresses for Partial Ordering

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.EthernetAddress.html

Provides partial ordering comparison for `EthernetAddress` instances. This is required by the `PartialOrd` trait.

```rust
impl PartialOrd for Address
```

--------------------------------

### Implement CloneToUninit for T

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Ipv6Address.html

Provides a nightly-only experimental API to clone a value into uninitialized memory.

```rust
impl<T> CloneToUninit for T
where T: Clone,
```

--------------------------------

### Socket Readiness Checks

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/tcp/struct.TcpSocket.html

Methods to check if the socket is ready for sending or receiving data.

```APIDOC
## GET /api/socket/may_send

### Description
Returns 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, write 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.

### Method
GET

### Endpoint
/api/socket/may_send

### Parameters
None

### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **ready** (boolean) - True if the transmit half is open, false otherwise.

#### Response Example
{
  "ready": true
}

## GET /api/socket/can_send

### Description
Checks whether the transmit half of the full-duplex connection is open (see `may_send`), and the transmit buffer is not full.

### Method
GET

### Endpoint
/api/socket/can_send

### Parameters
None

### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **ready** (boolean) - True if the socket can send data, false otherwise.

#### Response Example
{
  "ready": true
}

## GET /api/socket/may_recv

### Description
Returns 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.

### Method
GET

### Endpoint
/api/socket/may_recv

### Parameters
None

### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **ready** (boolean) - True if the receive half is open, false otherwise.

#### Response Example
{
  "ready": true
}

## GET /api/socket/can_recv

### Description
Gets whether the socket is ready to receive data, i.e., whether there is some pending data in the receive buffer.

### Method
GET

### Endpoint
/api/socket/can_recv

### Parameters
None

### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **ready** (boolean) - True if the socket is ready to receive data, false otherwise.

#### Response Example
{
  "ready": true
}
```

--------------------------------

### TcpClient::new

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/tcp/client/struct.TcpClient.html

Creates a new TcpClient instance. Requires a network stack and a TcpClientState to manage connection states.

```rust
pub fn new(stack: Stack<'d>, state: &'d TcpClientState<N, TX_SZ, RX_SZ>) -> Self
```

--------------------------------

### Perform ICMP Ping with Embassy-Net

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/ping/index.html

Demonstrates how to initialize and use the PingManager to send an ICMP Echo request to a specified IPv4 address. Includes setting a custom payload and handling success or error responses. Ensure the network stack is initialized before use.

```rust
use core::net::Ipv4Addr;
use core::str::FromStr;

use embassy_net::icmp::ping::{PingManager, PingParams};
use embassy_net::icmp::PacketMetadata;

let mut rx_buffer = [0; 256];
let mut tx_buffer = [0; 256];
let mut rx_meta = [PacketMetadata::EMPTY];
let mut tx_meta = [PacketMetadata::EMPTY];

let mut ping_manager = PingManager::new(stack, &mut rx_meta, &mut rx_buffer, &mut tx_meta, &mut tx_buffer);
let addr = "192.168.8.1";
let mut ping_params = PingParams::new(Ipv4Addr::from_str(addr).unwrap());
ping_params.set_payload(b"Hello, router!");
match ping_manager.ping(&ping_params).await {
    Ok(time) => info!("Ping time of {}: {}ms", addr, time.as_millis()),
    Err(ping_error) => warn!("{:?}", ping_error),
};

```

--------------------------------

### Compare Configurations for Equality

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Config.html

Tests if two `Config` instances are equal. This is used by the `==` operator.

```rust
fn eq(&self, other: &Config) -> bool
```

--------------------------------

### Config Trait Implementations

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.Config.html

Details the various trait implementations for the `Config` struct, including `Clone`, `Debug`, `Default`, `Format`, `PartialEq`, and `Eq`.

```APIDOC
## Trait Implementations for Config

### `impl Clone for Config`
#### `fn clone(&self) -> Config`
Returns a duplicate of the value.

#### `const fn clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

### `impl Debug for Config`
#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the value using the given formatter.

### `impl Default for Config`
#### `fn default() -> Config`
Returns the “default value” for a type.

### `impl Format for Config`
#### `fn format(&self, f: Formatter<'_>)`
Writes the defmt representation of `self` to `fmt`.

### `impl PartialEq for Config`
#### `fn eq(&self, other: &Config) -> bool`
Tests for `self` and `other` values to be equal.

#### `const fn ne(&self, other: &Rhs) -> bool`
Tests for `!=`.

### `impl Eq for Config`

### `impl StructuralPartialEq for Config`
```

--------------------------------

### Memory Operations: clone_to_uninit

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.DhcpConfig.html

An experimental nightly-only API for performing copy-assignment to uninitialized memory.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from self to the destination pointer. This is a nightly-only experimental API.

### Parameters
- **dest** (*mut u8) - Required - A pointer to the uninitialized memory destination.
```

--------------------------------

### TryFrom and TryInto Traits

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/raw/struct.RawSocket.html

Documentation for fallible conversion traits.

```APIDOC
## TryFrom Trait

### Description
Performs a fallible conversion.

### Associated Types
- **Error**: Infallible (The type returned in the event of a conversion error)

### Method
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

## TryInto Trait

### Description
Performs a fallible conversion into a target type.

### Associated Types
- **Error**: <U as TryFrom<T>>::Error

### Method
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### TcpClient::new

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/tcp/client/struct.TcpClient.html

Creates a new instance of a TCP client with a specified network stack and state.

```APIDOC
## TcpClient::new

### Description
Initializes a new TcpClient instance using the provided network stack and state container.

### Parameters
- **stack** (Stack<'d>) - Required - The network stack to use for connections.
- **state** (&'d TcpClientState<N, TX_SZ, RX_SZ>) - Required - The state storage for the connection pool.
```

--------------------------------

### Define DHCP Configuration

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.DhcpConfig.html

Use this struct to configure DHCP client settings. It allows customization of lease duration, retry behavior, and network parameters. Note that `ignore_naks` is non-compliant with RFCs but can improve reliability on problematic networks.

```rust
#[non_exhaustive]
pub struct DhcpConfig {
    pub max_lease_duration: Option<Duration>,
    pub retry_config: RetryConfig,
    pub ignore_naks: bool,
    pub server_port: u16,
    pub client_port: u16,
    pub hostname: Option<String<MAX_HOSTNAME_LEN>>,
}

```

--------------------------------

### StackResources Implementations

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/struct.StackResources.html

Information on the auto traits, blanket implementations, and specific implementations for the StackResources struct.

```APIDOC
## StackResources<const SOCK: usize> Implementations

### Auto Trait Implementations
- `!Freeze`
- `!RefUnwindSafe`
- `!Send`
- `!Sync`
- `Unpin`
- `!UnwindSafe`

### Blanket Implementations
- `impl<T> Any for T`
  - `fn type_id(&self) -> TypeId`
- `impl<T> Borrow<T> for T`
  - `fn borrow(&self) -> &T`
- `impl<T> BorrowMut<T> for T`
  - `fn borrow_mut(&mut self) -> &mut T`
- `impl<T> From<T> for T`
  - `fn from(t: T) -> T`
- `impl<T, U> Into<U> for T where U: From<T>`
  - `fn into(self) -> U`
- `impl<T, U> TryFrom<U> for T where U: Into<T>`
  - `type Error = Infallible`
  - `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`
- `impl<T, U> TryInto<U> for T where U: TryFrom<T>`
  - `type Error = <U as TryFrom<T>>::Error`
  - `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
```

--------------------------------

### Standard Trait Implementations

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/icmp/ping/struct.PingParams.html

Overview of core Rust traits for type conversion and memory borrowing.

```APIDOC
## Trait Implementations

### Description
Provides standard implementations for common Rust traits including memory borrowing and type conversion.

### Traits
- **Borrow<T>**
  - `fn borrow(&self) -> &T`: Immutably borrows from an owned value.
- **BorrowMut<T>**
  - `fn borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.
- **From<T>**
  - `fn from(t: T) -> T`: Returns the argument unchanged.
- **Into<U>**
  - `fn into(self) -> U`: Performs conversion into type U.
- **TryFrom<U>**
  - `fn try_from(value: U) -> Result<T, Error>`: Attempts a fallible conversion.
- **TryInto<U>**
  - `fn try_into(self) -> Result<U, Error>`: Attempts a fallible conversion into type U.
```

--------------------------------

### HardwareAddress PartialEq Implementation

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/enum.HardwareAddress.html

Implements the PartialEq trait for HardwareAddress, enabling direct comparison of address instances for equality. This is fundamental for network logic that requires checking if two addresses are the same.

```rust
fn eq(&self, other: &HardwareAddress) -> bool
```

```rust
const fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Address Comparison Methods

Source: https://docs.embassy.dev/embassy-net/0.7.1/default/dns/enum.IpAddress.html

Provides methods for comparing Address instances for equality and ordering.

```APIDOC
## fn eq(&self, other: &Address) -> bool

### Description
Tests for `self` and `other` values to be equal, and is used by `==`.

### Method
`eq`

### Parameters
- **other** (Address) - The other Address to compare against.

### Response
- **bool** - True if the addresses are equal, false otherwise.
```

```APIDOC
## fn ne(&self, other: &Rhs) -> bool

### Description
Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.

### Method
`ne`

### Parameters
- **other** (Rhs) - The other value to compare against.

### Response
- **bool** - True if the addresses are not equal, false otherwise.
```

```APIDOC
## fn partial_cmp(&self, other: &Address) -> Option<Ordering>

### Description
This method returns an ordering between `self` and `other` values if one exists.

### Method
`partial_cmp`

### Parameters
- **other** (Address) - The other Address to compare.

### Response
- **Option<Ordering>** - An `Ordering` enum variant if the values can be ordered, otherwise `None`.
```

```APIDOC
## fn lt(&self, other: &Rhs) -> bool

### Description
Tests less than (for `self` and `other`) and is used by the `<` operator.

### Method
`lt`

### Parameters
- **other** (Rhs) - The other value to compare.

### Response
- **bool** - True if `self` is less than `other`, false otherwise.
```

```APIDOC
## fn le(&self, other: &Rhs) -> bool

### Description
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

### Method
`le`

### Parameters
- **other** (Rhs) - The other value to compare.

### Response
- **bool** - True if `self` is less than or equal to `other`, false otherwise.
```

```APIDOC
## fn gt(&self, other: &Rhs) -> bool

### Description
Tests greater than (for `self` and `other`) and is used by the `>` operator.

### Method
`gt`

### Parameters
- **other** (Rhs) - The other value to compare.

### Response
- **bool** - True if `self` is greater than `other`, false otherwise.
```

```APIDOC
## fn ge(&self, other: &Rhs) -> bool

### Description
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.

### Method
`ge`

### Parameters
- **other** (Rhs) - The other value to compare.

### Response
- **bool** - True if `self` is greater than or equal to `other`, false otherwise.
```
Tokens:
Raw