Struct NetworkManager

pub struct NetworkManager { /* private fields */ }

Implementations

impl NetworkManager

pub fn new() -> Self

Examples found in repository

examples/hotspot.rs (line 64)

fn run() -> Result<()> {
    let Options {
        interface,
        ssid,
        password,
    } = parse_options();

    let pass_str = match password {
        Some(ref s) => Some(s as &str),
        None => None,
    };

    let manager = NetworkManager::new();

    let device = find_device(&manager, interface)?;
    let wifi_device = device.as_wifi_device().unwrap();

    wifi_device.create_hotspot(&ssid as &str, pass_str, None)?;

    Ok(())
}

examples/create.rs (line 54)

fn run() -> Result<()> {
    let args: Vec<String> = env::args().collect();

    if args.len() != 3 {
        println!("USAGE: create SSID PASSWORD");
        process::exit(1);
    }

    let manager = NetworkManager::new();

    let device = find_device(&manager)?;

    let wifi_device = device.as_wifi_device().unwrap();

    let access_points = wifi_device.get_access_points()?;

    let ap_index = find_access_point(&access_points, &args[1] as &str)?;

    let credentials = AccessPointCredentials::Wpa {
        passphrase: args[2].clone(),
    };

    wifi_device.connect(&access_points[ap_index], &credentials)?;

    Ok(())
}

pub fn with_method_timeout(timeout: u64) -> Self

pub fn start_service(timeout: u64) -> Result<ServiceState>

Starts the Network Manager service.

Examples

use network_manager::NetworkManager;
let state = NetworkManager::start_service(10).unwrap();
println!("{:?}", state);

pub fn stop_service(timeout: u64) -> Result<ServiceState>

Stops the Network Manager service.

Examples

use network_manager::NetworkManager;
let state = NetworkManager::stop_service(10).unwrap();
println!("{:?}", state);

pub fn get_service_state() -> Result<ServiceState>

Gets the state of the Network Manager service.

Examples

use network_manager::NetworkManager;
let state = NetworkManager::get_service_state().unwrap();
println!("{:?}", state);

pub fn get_connections(&self) -> Result<Vec<Connection>>

Get a list of Network Manager connections sorted by path.

Examples

use network_manager::NetworkManager;
let manager = NetworkManager::new();
let connections = manager.get_connections().unwrap();
println!("{:?}", connections);

pub fn get_active_connections(&self) -> Result<Vec<Connection>>

pub fn get_devices(&self) -> Result<Vec<Device>>

Get a list of Network Manager devices.

Examples

use network_manager::NetworkManager;
let manager = NetworkManager::new();
let devices = manager.get_devices().unwrap();
println!("{:?}", devices);

Examples found in repository

examples/create.rs (line 74)

fn find_device(manager: &NetworkManager) -> Result<Device> {
    let devices = manager.get_devices()?;

    let index = devices
        .iter()
        .position(|d| *d.device_type() == DeviceType::WiFi);

    if let Some(index) = index {
        Ok(devices[index].clone())
    } else {
        bail!(ErrorKind::Runtime("Cannot find a WiFi device".into()))
    }
}

examples/hotspot.rs (line 124)

fn find_device(manager: &NetworkManager, interface: Option<String>) -> Result<Device> {
    if let Some(interface) = interface {
        let device = manager.get_device_by_interface(&interface)?;

        if *device.device_type() == DeviceType::WiFi {
            Ok(device)
        } else {
            bail!(ErrorKind::Runtime(format!(
                "{} is not a WiFi device",
                interface
            )))
        }
    } else {
        let devices = manager.get_devices()?;

        let index = devices
            .iter()
            .position(|d| *d.device_type() == DeviceType::WiFi);

        if let Some(index) = index {
            Ok(devices[index].clone())
        } else {
            bail!(ErrorKind::Runtime("Cannot find a WiFi device".into()))
        }
    }
}

pub fn get_device_by_interface(&self, interface: &str) -> Result<Device>

Examples found in repository

examples/hotspot.rs (line 113)

fn find_device(manager: &NetworkManager, interface: Option<String>) -> Result<Device> {
    if let Some(interface) = interface {
        let device = manager.get_device_by_interface(&interface)?;

        if *device.device_type() == DeviceType::WiFi {
            Ok(device)
        } else {
            bail!(ErrorKind::Runtime(format!(
                "{} is not a WiFi device",
                interface
            )))
        }
    } else {
        let devices = manager.get_devices()?;

        let index = devices
            .iter()
            .position(|d| *d.device_type() == DeviceType::WiFi);

        if let Some(index) = index {
            Ok(devices[index].clone())
        } else {
            bail!(ErrorKind::Runtime("Cannot find a WiFi device".into()))
        }
    }
}

pub fn get_state(&self) -> Result<NetworkManagerState>

pub fn get_connectivity(&self) -> Result<Connectivity>

pub fn is_networking_enabled(&self) -> Result<bool>

pub fn is_wireless_enabled(&self) -> Result<bool>

Trait Implementations

impl Default for NetworkManager

fn default() -> Self

Returns the “default value” for a type.