peach-workspace/peach-network/src/error.rs

use std::io;
use std::num::ParseIntError;

use io::Error as IoError;
use jsonrpc_core::{types::error::Error as JsonRpcError, ErrorCode};
use probes::ProbeError;
use regex::Error as RegexError;
use serde_json::Error as SerdeError;
use wpactrl::WpaError;

#[derive(Debug)]
pub enum NetworkError {
    Add { ssid: String },

    NoState { iface: String, source: IoError },

    Disable { id: String, iface: String },

    Disconnect { iface: String },

    GenWpaPassphrase { ssid: String, source: IoError },

    GenWpaPassphraseWarning { ssid: String, err_msg: String },

    Id { ssid: String, iface: String },

    NoIp { iface: String, source: IoError },

    Rssi { iface: String },

    RssiPercent { iface: String },

    Ssid { iface: String },

    State { iface: String },

    Status { iface: String },

    Traffic { iface: String },

    SavedNetworks,

    AvailableNetworks { iface: String },

    MissingParams(JsonRpcError),

    Modify { id: String, iface: String },

    Ip { iface: String },

    ParseInt(ParseIntError),

    NoTraffic { iface: String, source: ProbeError },

    Reassociate { iface: String },

    Reconfigure,

    Reconnect { iface: String },

    Regex(RegexError),

    Delete { id: String, iface: String },

    WlanState(IoError),

    WlanOperstate(IoError),

    Save,

    Connect { id: String, iface: String },

    StartAp0(IoError),

    StartWlan0(IoError),

    SerdeSerialize(SerdeError),

    WpaCtrl(WpaError),
}

impl std::error::Error for NetworkError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match *self {
            NetworkError::Add { .. } => None,
            NetworkError::NoState { ref source, .. } => Some(source),
            NetworkError::Disable { .. } => None,
            NetworkError::Disconnect { .. } => None,
            NetworkError::GenWpaPassphrase { ref source, .. } => Some(source),
            NetworkError::GenWpaPassphraseWarning { .. } => None,
            NetworkError::Id { .. } => None,
            NetworkError::NoIp { ref source, .. } => Some(source),
            NetworkError::Rssi { .. } => None,
            NetworkError::RssiPercent { .. } => None,
            NetworkError::Ssid { .. } => None,
            NetworkError::State { .. } => None,
            NetworkError::Status { .. } => None,
            NetworkError::Traffic { .. } => None,
            NetworkError::SavedNetworks => None,
            NetworkError::AvailableNetworks { .. } => None,
            NetworkError::MissingParams(ref source) => Some(source),
            NetworkError::Modify { .. } => None,
            NetworkError::Ip { .. } => None,
            NetworkError::ParseInt(ref source) => Some(source),
            NetworkError::NoTraffic { ref source, .. } => Some(source),
            NetworkError::Reassociate { .. } => None,
            NetworkError::Reconfigure { .. } => None,
            NetworkError::Reconnect { .. } => None,
            NetworkError::Regex(ref source) => Some(source),
            NetworkError::Delete { .. } => None,
            NetworkError::WlanState(ref source) => Some(source),
            NetworkError::WlanOperstate(ref source) => Some(source),
            NetworkError::Save => None,
            NetworkError::Connect { .. } => None,
            NetworkError::StartWlan0(ref source) => Some(source),
            NetworkError::StartAp0(ref source) => Some(source),
            NetworkError::SerdeSerialize(ref source) => Some(source),
            NetworkError::WpaCtrl(ref source) => Some(source),
        }
    }
}

impl std::fmt::Display for NetworkError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match *self {
            NetworkError::Add { ref ssid } => {
                write!(f, "Failed to add network for {}", ssid)
            }
            NetworkError::NoState { ref iface, .. } => {
                write!(f, "Failed to retrieve state for interface: {}", iface)
            }
            NetworkError::Disable { ref id, ref iface } => {
                write!(
                    f,
                    "Failed to disable network {} for interface: {}",
                    id, iface
                )
            }
            NetworkError::Disconnect { ref iface } => {
                write!(f, "Failed to disconnect {}", iface)
            }
            NetworkError::GenWpaPassphrase { ref ssid, .. } => {
                write!(f, "Failed to generate wpa passphrase for {}", ssid)
            }
            NetworkError::GenWpaPassphraseWarning {
                ref ssid,
                ref err_msg,
            } => {
                write!(
                    f,
                    "Failed to generate wpa passphrase for {}: {}",
                    ssid, err_msg
                )
            }
            NetworkError::Id {
                ref ssid,
                ref iface,
            } => {
                write!(f, "No ID found for {} on interface: {}", ssid, iface)
            }
            NetworkError::NoIp { ref iface, .. } => {
                write!(f, "Could not access IP address for interface: {}", iface)
            }
            NetworkError::Rssi { ref iface } => {
                write!(f, "Could not find RSSI for interface: {}", iface)
            }
            NetworkError::RssiPercent { ref iface } => {
                write!(
                    f,
                    "Could not find signal quality (%) for interface: {}",
                    iface
                )
            }
            NetworkError::Ssid { ref iface } => {
                write!(f, "Could not find SSID for interface: {}", iface)
            }
            NetworkError::State { ref iface } => {
                write!(f, "No state found for interface: {}", iface)
            }
            NetworkError::Status { ref iface } => {
                write!(f, "No status found for interface: {}", iface)
            }
            NetworkError::Traffic { ref iface } => {
                write!(
                    f,
                    "Could not find network traffice for interface: {}",
                    iface
                )
            }
            NetworkError::SavedNetworks => {
                write!(f, "No saved networks found for default interface")
            }
            NetworkError::AvailableNetworks { ref iface } => {
                write!(f, "No networks found in range of  interface: {}", iface)
            }
            NetworkError::MissingParams(ref source) => {
                write!(f, "Missing expected parameters: {}", source)
            }
            NetworkError::Modify { ref id, ref iface } => {
                write!(
                    f,
                    "Failed to set new password for network {} on {}",
                    id, iface
                )
            }
            NetworkError::Ip { ref iface } => {
                write!(f, "No IP found for interface: {}", iface)
            }
            NetworkError::ParseInt(_) => {
                write!(f, "Failed to parse integer from string for RSSI value")
            }
            NetworkError::NoTraffic { ref iface, .. } => {
                write!(
                    f,
                    "Failed to retrieve network traffic measurement for {}",
                    iface
                )
            }
            NetworkError::Reassociate { ref iface } => {
                write!(
                    f,
                    "Failed to reassociate with WiFi network for interface: {}",
                    iface
                )
            }
            NetworkError::Reconfigure => {
                write!(
                    f,
                    "Failed to force reread of wpa_supplicant configuration file"
                )
            }
            NetworkError::Reconnect { ref iface } => {
                write!(
                    f,
                    "Failed to reconnect with WiFi network for interface: {}",
                    iface
                )
            }
            NetworkError::Regex(_) => write!(f, "Regex command failed"),
            NetworkError::Delete { ref id, ref iface } => {
                write!(
                    f,
                    "Failed to delete network {} for interface: {}",
                    id, iface
                )
            }
            NetworkError::WlanState(_) => write!(f, "Failed to retrieve state of wlan0 service"),
            NetworkError::WlanOperstate(_) => {
                write!(f, "Failed to retrieve connection state of wlan0 interface")
            }
            NetworkError::Save => write!(f, "Failed to save configuration changes to file"),
            NetworkError::Connect { ref id, ref iface } => {
                write!(
                    f,
                    "Failed to connect to network {} for interface: {}",
                    id, iface
                )
            }
            NetworkError::StartWlan0(_) => write!(f, "Failed to start ap0 service"),
            NetworkError::StartAp0(_) => write!(f, "Failed to start wlan0 service"),
            NetworkError::SerdeSerialize(_) => write!(f, "JSON serialization failed"),
            NetworkError::WpaCtrl(_) => write!(f, "WpaCtrl command failed"),
        }
    }
}

impl From<SerdeError> for NetworkError {
    fn from(err: SerdeError) -> Self {
        NetworkError::SerdeSerialize(err)
    }
}

impl From<WpaError> for NetworkError {
    fn from(err: WpaError) -> Self {
        NetworkError::WpaCtrl(err)
    }
}

impl From<ParseIntError> for NetworkError {
    fn from(err: ParseIntError) -> Self {
        NetworkError::ParseInt(err)
    }
}

impl From<RegexError> for NetworkError {
    fn from(err: RegexError) -> Self {
        NetworkError::Regex(err)
    }
}

impl From<NetworkError> for JsonRpcError {
    fn from(err: NetworkError) -> Self {
        match &err {
            NetworkError::Add { ssid } => JsonRpcError {
                code: ErrorCode::ServerError(-32000),
                message: format!("Failed to add network for {}", ssid),
                data: None,
            },
            NetworkError::NoState { iface, source } => JsonRpcError {
                code: ErrorCode::ServerError(-32022),
                message: format!(
                    "Failed to retrieve interface state for {}: {}",
                    iface, source
                ),
                data: None,
            },
            NetworkError::Disable { id, iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32029),
                message: format!("Failed to disable network {} for {}", id, iface),
                data: None,
            },
            NetworkError::Disconnect { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32032),
                message: format!("Failed to disconnect {}", iface),
                data: None,
            },
            NetworkError::GenWpaPassphrase { ssid, source } => JsonRpcError {
                code: ErrorCode::ServerError(-32025),
                message: format!("Failed to generate wpa passphrase for {}: {}", ssid, source),
                data: None,
            },
            NetworkError::GenWpaPassphraseWarning { ssid, err_msg } => JsonRpcError {
                code: ErrorCode::ServerError(-32036),
                message: format!(
                    "Failed to generate wpa passphrase for {}: {}",
                    ssid, err_msg
                ),
                data: None,
            },
            NetworkError::Id { iface, ssid } => JsonRpcError {
                code: ErrorCode::ServerError(-32026),
                message: format!("No ID found for {} on interface {}", ssid, iface),
                data: None,
            },
            NetworkError::NoIp { iface, source } => JsonRpcError {
                code: ErrorCode::ServerError(-32001),
                message: format!("Failed to retrieve IP address for {}: {}", iface, source),
                data: None,
            },
            NetworkError::Rssi { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32002),
                message: format!(
                    "Failed to retrieve RSSI for {}. Interface may not be connected",
                    iface
                ),
                data: None,
            },
            NetworkError::RssiPercent { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32034),
                message: format!(
                    "Failed to retrieve signal quality (%) for {}. Interface may not be connected",
                    iface
                ),
                data: None,
            },
            NetworkError::Ssid { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32003),
                message: format!(
                    "Failed to retrieve SSID for {}. Interface may not be connected",
                    iface
                ),
                data: None,
            },
            NetworkError::State { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32023),
                message: format!("No state found for {}. Interface may not exist", iface),
                data: None,
            },
            NetworkError::Status { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32024),
                message: format!("No status found for {}. Interface may not exist", iface),
                data: None,
            },
            NetworkError::Traffic { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32004),
                message: format!(
                    "No network traffic statistics found for {}. Interface may not exist",
                    iface
                ),
                data: None,
            },
            NetworkError::SavedNetworks => JsonRpcError {
                code: ErrorCode::ServerError(-32005),
                message: "No saved networks found".to_string(),
                data: None,
            },
            NetworkError::AvailableNetworks { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32006),
                message: format!("No networks found in range of {}", iface),
                data: None,
            },
            NetworkError::MissingParams(e) => e.clone(),
            NetworkError::Modify { id, iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32033),
                message: format!("Failed to set new password for network {} on {}", id, iface),
                data: None,
            },
            NetworkError::Ip { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32007),
                message: format!("No IP address found for {}", iface),
                data: None,
            },
            NetworkError::ParseInt(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32035),
                message: format!(
                    "Failed to parse integer from string for RSSI value: {}",
                    source
                ),
                data: None,
            },
            NetworkError::NoTraffic { iface, source } => JsonRpcError {
                code: ErrorCode::ServerError(-32015),
                message: format!(
                    "Failed to retrieve network traffic statistics for {}: {}",
                    iface, source
                ),
                data: None,
            },
            NetworkError::Reassociate { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32008),
                message: format!("Failed to reassociate with WiFi network for {}", iface),
                data: None,
            },
            NetworkError::Reconfigure => JsonRpcError {
                code: ErrorCode::ServerError(-32030),
                message: "Failed to force reread of wpa_supplicant configuration file".to_string(),
                data: None,
            },
            NetworkError::Reconnect { iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32009),
                message: format!("Failed to reconnect with WiFi network for {}", iface),
                data: None,
            },
            NetworkError::Regex(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32010),
                message: format!("Regex command error: {}", source),
                data: None,
            },
            NetworkError::Delete { id, iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32028),
                message: format!("Failed to delete network {} for {}", id, iface),
                data: None,
            },
            NetworkError::WlanState(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32011),
                message: format!("Failed to retrieve state of wlan0 service: {}", source),
                data: None,
            },
            NetworkError::WlanOperstate(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32021),
                message: format!(
                    "Failed to retrieve connection state of wlan0 interface: {}",
                    source
                ),
                data: None,
            },
            NetworkError::Save => JsonRpcError {
                code: ErrorCode::ServerError(-32031),
                message: "Failed to save configuration changes to file".to_string(),
                data: None,
            },
            NetworkError::Connect { id, iface } => JsonRpcError {
                code: ErrorCode::ServerError(-32027),
                message: format!("Failed to connect to network {} for {}", id, iface),
                data: None,
            },
            NetworkError::StartAp0(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32016),
                message: format!("Failed to start ap0 service: {}", source),
                data: None,
            },
            NetworkError::StartWlan0(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32018),
                message: format!("Failed to start wlan0 service: {}", source),
                data: None,
            },
            NetworkError::SerdeSerialize(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32012),
                message: format!("JSON serialization failed: {}", source),
                data: None,
            },
            NetworkError::WpaCtrl(source) => JsonRpcError {
                code: ErrorCode::ServerError(-32013),
                message: format!("WPA control interface failure: {}", source),
                data: None,
            },
        }
    }
}