openiwan 0.2.0

An independently implemented iWAN client and protocol library
Documentation
mod controller;
mod crypto;
mod http;
mod oidc;
mod provider;
mod store;

pub use http::{HttpRequest, HttpResponse, HttpTransport, UreqTransport};
pub use oidc::PendingAuthorization;
pub use provider::{
    ControllerConfig, OidcConfig, PROVIDER_VERSION, ProviderConfig, TokenRequestFormat,
};
pub use store::{
    ManagedServer, ManagedState, STATE_VERSION, default_state_path, load_state, new_device_id,
    save_state,
};

use crate::{Client, ClientConfig, Error, Result};

pub struct ManagedClient<T = UreqTransport> {
    provider: ProviderConfig,
    transport: T,
}

impl ManagedClient<UreqTransport> {
    pub fn new(provider: ProviderConfig) -> Self {
        Self {
            provider,
            transport: UreqTransport::new(),
        }
    }
}

impl<T: HttpTransport> ManagedClient<T> {
    pub fn with_transport(provider: ProviderConfig, transport: T) -> Self {
        Self {
            provider,
            transport,
        }
    }

    pub fn provider(&self) -> &ProviderConfig {
        &self.provider
    }

    pub fn begin_authorization(&self) -> Result<PendingAuthorization> {
        oidc::begin(&self.provider, &self.transport)
    }

    pub fn fetch(
        &self,
        pending: &PendingAuthorization,
        redirect_url: &str,
        device_id: &str,
    ) -> Result<ManagedState> {
        if device_id.is_empty() {
            return Err(Error::ManagedProvider("device id must not be empty".into()));
        }
        let identity = oidc::complete(&self.provider, &self.transport, pending, redirect_url)?;
        controller::fetch(&self.provider, &self.transport, &identity, device_id)
    }

    pub fn build_client(
        &self,
        state: &ManagedState,
        server: &ManagedServer,
        mut config: ClientConfig,
    ) -> Result<Client> {
        state.validate_for(&self.provider.id, &self.provider.controller.domain)?;
        if !state.servers.iter().any(|candidate| candidate == server) {
            return Err(Error::ManagedProvider(
                "selected line is not present in managed state".into(),
            ));
        }
        config.server = server.endpoint();
        config.require_auth_verify_echo = self.provider.require_auth_verify_echo;
        config.xor_key_bytes = self.provider.xor_key_bytes;
        let password = crypto::decrypt_server_password(&self.provider, server)?;
        Client::new(config, server.username.clone(), password.to_string())
    }
}

pub fn select_server<'a>(
    state: &'a ManagedState,
    index: Option<usize>,
    name: Option<&str>,
) -> Result<Option<&'a ManagedServer>> {
    if index.is_some() && name.is_some() {
        return Err(Error::ManagedProvider(
            "line index and line name are mutually exclusive".into(),
        ));
    }
    if let Some(index) = index {
        if index == 0 || index > state.servers.len() {
            return Err(Error::ManagedProvider(format!(
                "line index must be between 1 and {}",
                state.servers.len()
            )));
        }
        return Ok(Some(&state.servers[index - 1]));
    }
    if let Some(name) = name {
        let matches: Vec<_> = state
            .servers
            .iter()
            .filter(|server| server.name == name)
            .collect();
        return match matches.as_slice() {
            [server] => Ok(Some(*server)),
            [] => Err(Error::ManagedProvider(format!("no line is named {name:?}"))),
            _ => Err(Error::ManagedProvider(format!(
                "multiple lines are named {name:?}; use --line-index"
            ))),
        };
    }
    Ok(None)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn selects_by_one_based_index_or_unique_name() {
        let state = ManagedState {
            version: STATE_VERSION,
            provider_id: "test".into(),
            domain: "test".into(),
            device_id: "device".into(),
            fetched_at_unix: 0,
            servers: vec![
                ManagedServer {
                    name: "A".into(),
                    host: "192.0.2.1".into(),
                    port: 6001,
                    username: "a".into(),
                    encrypted_password: "x".into(),
                },
                ManagedServer {
                    name: "B".into(),
                    host: "192.0.2.2".into(),
                    port: 6002,
                    username: "b".into(),
                    encrypted_password: "y".into(),
                },
            ],
        };
        assert_eq!(
            select_server(&state, Some(2), None).unwrap().unwrap().name,
            "B"
        );
        assert_eq!(
            select_server(&state, None, Some("A"))
                .unwrap()
                .unwrap()
                .host,
            "192.0.2.1"
        );
        assert!(select_server(&state, Some(0), None).is_err());
    }
}