Struct default_net::interface::Interface
source · pub struct Interface {
pub index: u32,
pub name: String,
pub friendly_name: Option<String>,
pub description: Option<String>,
pub if_type: InterfaceType,
pub mac_addr: Option<MacAddr>,
pub ipv4: Vec<Ipv4Net>,
pub ipv6: Vec<Ipv6Net>,
pub flags: u32,
pub transmit_speed: Option<u64>,
pub receive_speed: Option<u64>,
pub gateway: Option<Gateway>,
}
Expand description
Structure of Network Interface information
Fields§
§index: u32
Index of network interface
name: String
Name of network interface
friendly_name: Option<String>
Friendly Name of network interface
description: Option<String>
Description of the network interface
if_type: InterfaceType
Interface Type
mac_addr: Option<MacAddr>
MAC address of network interface
ipv4: Vec<Ipv4Net>
List of Ipv4Net for the network interface
ipv6: Vec<Ipv6Net>
List of Ipv6Net for the network interface
flags: u32
Flags for the network interface (OS Specific)
transmit_speed: Option<u64>
Speed in bits per second of the transmit for the network interface
receive_speed: Option<u64>
Speed in bits per second of the receive for the network interface
gateway: Option<Gateway>
Default gateway for the network interface
Implementations§
source§impl Interface
impl Interface
sourcepub fn is_up(&self) -> bool
pub fn is_up(&self) -> bool
Check if the network interface is up
Examples found in repository?
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
fn main() {
let interfaces = default_net::get_interfaces();
for interface in interfaces {
println!("Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Gateway: (Not found)");
}
println!();
}
}
More examples
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
fn main() {
match default_net::get_default_interface() {
Ok(interface) => {
println!("Default Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Default Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Default Gateway: (Not found)");
}
}
Err(e) => {
println!("{}", e);
}
}
}
sourcepub fn is_loopback(&self) -> bool
pub fn is_loopback(&self) -> bool
Check if the network interface is a Loopback interface
Examples found in repository?
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
fn main() {
let interfaces = default_net::get_interfaces();
for interface in interfaces {
println!("Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Gateway: (Not found)");
}
println!();
}
}
More examples
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
fn main() {
match default_net::get_default_interface() {
Ok(interface) => {
println!("Default Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Default Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Default Gateway: (Not found)");
}
}
Err(e) => {
println!("{}", e);
}
}
}
sourcepub fn is_point_to_point(&self) -> bool
pub fn is_point_to_point(&self) -> bool
Check if the network interface is a Point-to-Point interface
Examples found in repository?
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
fn main() {
let interfaces = default_net::get_interfaces();
for interface in interfaces {
println!("Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Gateway: (Not found)");
}
println!();
}
}
More examples
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
fn main() {
match default_net::get_default_interface() {
Ok(interface) => {
println!("Default Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Default Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Default Gateway: (Not found)");
}
}
Err(e) => {
println!("{}", e);
}
}
}
sourcepub fn is_multicast(&self) -> bool
pub fn is_multicast(&self) -> bool
Check if the network interface is a Multicast interface
Examples found in repository?
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
fn main() {
let interfaces = default_net::get_interfaces();
for interface in interfaces {
println!("Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Gateway: (Not found)");
}
println!();
}
}
More examples
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
fn main() {
match default_net::get_default_interface() {
Ok(interface) => {
println!("Default Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Default Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Default Gateway: (Not found)");
}
}
Err(e) => {
println!("{}", e);
}
}
}
sourcepub fn is_broadcast(&self) -> bool
pub fn is_broadcast(&self) -> bool
Check if the network interface is a Broadcast interface
Examples found in repository?
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
fn main() {
let interfaces = default_net::get_interfaces();
for interface in interfaces {
println!("Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Gateway: (Not found)");
}
println!();
}
}
More examples
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
fn main() {
match default_net::get_default_interface() {
Ok(interface) => {
println!("Default Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Default Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Default Gateway: (Not found)");
}
}
Err(e) => {
println!("{}", e);
}
}
}
sourcepub fn is_tun(&self) -> bool
pub fn is_tun(&self) -> bool
Check if the network interface is a TUN interface
Examples found in repository?
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
fn main() {
let interfaces = default_net::get_interfaces();
for interface in interfaces {
println!("Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Gateway: (Not found)");
}
println!();
}
}
More examples
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
fn main() {
match default_net::get_default_interface() {
Ok(interface) => {
println!("Default Interface");
println!("\tIndex: {}", interface.index);
println!("\tName: {}", interface.name);
println!("\tFriendly Name: {:?}", interface.friendly_name);
println!("\tDescription: {:?}", interface.description);
println!("\tType: {}", interface.if_type.name());
println!("\tFlags: {:?}", interface.flags);
println!("\t\tis UP {}", interface.is_up());
println!("\t\tis LOOPBACK {}", interface.is_loopback());
println!("\t\tis MULTICAST {}", interface.is_multicast());
println!("\t\tis BROADCAST {}", interface.is_broadcast());
println!("\t\tis POINT TO POINT {}", interface.is_point_to_point());
println!("\t\tis TUN {}", interface.is_tun());
if let Some(mac_addr) = interface.mac_addr {
println!("\tMAC: {}", mac_addr);
} else {
println!("\tMAC: (Failed to get mac address)");
}
println!("\tIPv4: {:?}", interface.ipv4);
println!("\tIPv6: {:?}", interface.ipv6);
println!("\tTransmit Speed: {:?}", interface.transmit_speed);
println!("\tReceive Speed: {:?}", interface.receive_speed);
if let Some(gateway) = interface.gateway {
println!("Default Gateway");
println!("\tMAC: {}", gateway.mac_addr);
println!("\tIP: {}", gateway.ip_addr);
} else {
println!("Default Gateway: (Not found)");
}
}
Err(e) => {
println!("{}", e);
}
}
}