Enum fidl_fuchsia_net_dhcp::Parameter

pub enum Parameter {
    IpAddrs(Vec<Ipv4Address>),
    AddressPool(AddressPool),
    Lease(LeaseLength),
    PermittedMacs(Vec<MacAddress>),
    StaticallyAssignedAddrs(Vec<StaticAssignment>),
    ArpProbe(bool),
    BoundDeviceNames(Vec<String>),
    // some variants omitted
}

The configurable server parameters.

Variants

IpAddrs(Vec<Ipv4Address>)

The IP addresses to which the server is bound. The vector bound has been arbitrarily selected as a generous upper limit.

AddressPool(AddressPool)

The pool of addresses managed by a DHCP server and from which leases are supplied.

The pool is valid iff all of the following are true:

1. All fields are present.
2. The stop address is larger than the start address.
3. The prefix length is large enough to fit the full range of addresses.

For example, a pool of 4 addresses with a 24 bit subnet mask could be specified as: { prefix_length: 24, range_start: 192.168.1.2, range_stop: 192.168.1.5, }

Changing the address pool will not cancel existing leases because the DHCP protocol does not provide a mechanism for doing so. Administrators should take care when changing the address pool for a server with active leases.

Lease(LeaseLength)

The duration of leases offered by the server.

PermittedMacs(Vec<MacAddress>)

The client MAC addresses which the server will issue leases to. By default, the server will not have a permitted MAC list, in which case it will attempt to issue a lease to every client which requests one. If permitted_macs has a non-zero length then the server will only respond to lease requests from clients with MAC in the list. The vector bound has been arbitrarily selected as a generous upper limit.

StaticallyAssignedAddrs(Vec<StaticAssignment>)

Addresses statically assigned to specific hosts or devices. Typically, a network administrator will statically assign addresses to always-on network devices which should always have the same IP address, such as network printers. The vector bound has been arbitrarily selected as a generous upper limit.

ArpProbe(bool)

Enables server behavior where the server ARPs an IP address prior to issuing it in a lease. If the server receives a response, the server will mark the address as in-use and try again with a different address.

BoundDeviceNames(Vec<String>)

The names of the interface to which the server will listen. If this vector is empty, the server will listen on all interfaces and will process incoming DHCP messages regardless of the interface on which they arrive. If this vector is not empty, then the server will only listen for incoming DHCP messages on the named interfaces contained by this vector. The string and vectors bounds have been arbitrarily selected as generous upper limits.

Implementations

impl Parameter

pub fn ordinal(&self) -> u64

pub fn unknown_variant_for_testing() -> Self

pub fn is_unknown(&self) -> bool

Trait Implementations

impl Clone for Parameter

fn clone(&self) -> Parameter

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Parameter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode<Parameter> for Parameter

fn new_empty() -> Self

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_>, offset: usize, depth: Depth ) -> Result<()>

Decodes an object of type T from the decoder’s buffers into self.

impl Encode<Parameter> for &Parameter

unsafe fn encode( self, encoder: &mut Encoder<'_>, offset: usize, _depth: Depth ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl PartialEq for Parameter

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeMarker for Parameter

type Owned = Parameter

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl ValueTypeMarker for Parameter

type Borrowed<'a> = &'a Parameter

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &Self::Owned. There are three cases:

fn borrow<'a>(value: &'a <Self as TypeMarker>::Owned) -> Self::Borrowed<'a>

Cheaply converts from &Self::Owned to Self::Borrowed.

impl Persistable for Parameter