Onvif auth

Cargo.toml

@@ -26,7 +26,7 @@ name = "mavlink-camera-manager"
 path = "src/main.rs"
 
 [dependencies]
-clap = { version = "4.5", features = ["derive"] }
+clap = { version = "4.5", features = ["derive", "env"] }
 regex = "1.10.4"
 
 #TODO: Investigate rweb to use openapi spec for free

src/lib/cli/manager.rs

@@ -1,6 +1,6 @@
 use anyhow::Context;
 use clap;
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 use tracing::error;
 
 use crate::{custom, stream::gst::utils::PluginRankConfig};
@@ -101,6 +101,10 @@ struct Args {
     /// Sets the MAVLink System ID.
     #[arg(long, value_name = "SYSTEM_ID", default_value = "1")]
     mavlink_system_id: u8,
+
+    /// Sets Onvif authentications. Alternatively, this can be passed as `MCM_ONVIF_AUTH` environment variable.
+    #[clap(long, value_name = "onvif://<USERNAME>:<PASSWORD>@<HOST>", value_delimiter = ',', value_parser = onvif_auth_validator, env = "MCM_ONVIF_AUTH")]
+    onvif_auth: Vec<String>,
 }
 
 #[derive(Debug)]
@@ -258,6 +262,34 @@ pub fn gst_feature_rank() -> Vec<PluginRankConfig> {
         .collect()
 }
 
+pub fn onvif_auth() -> HashMap<std::net::Ipv4Addr, onvif::soap::client::Credentials> {
+    MANAGER
+        .clap_matches
+        .onvif_auth
+        .iter()
+        .filter_map(|val| {
+            let url = match url::Url::parse(val) {
+                Ok(url) => url,
+                Err(error) => {
+                    error!("Failed parsing onvif auth url: {error:?}");
+                    return None;
+                }
+            };
+
+            let (host, credentials) =
+                match crate::controls::onvif::manager::Manager::credentials_from_url(&url) {
+                    Ok((host, credentials)) => (host, credentials),
+                    Err(error) => {
+                        error!("Failed to get credentials from url {url}: {error:?}");
+                        return None;
+                    }
+                };
+
+            Some((host, credentials))
+        })
+        .collect()
+}
+
 fn gst_feature_rank_validator(val: &str) -> Result<String, String> {
     if let Some((_key, value_str)) = val.split_once('=') {
         if value_str.parse::<i32>().is_err() {
@@ -279,6 +311,16 @@ fn turn_servers_validator(val: &str) -> Result<String, String> {
     Ok(val.to_owned())
 }
 
+fn onvif_auth_validator(val: &str) -> Result<String, String> {
+    let url = url::Url::parse(val).map_err(|e| format!("Failed parsing onvif auth url: {e:?}"))?;
+
+    if !matches!(url.scheme().to_lowercase().as_str(), "onvif") {
+        return Err("Onvif authentication scheme should be \"onvif\"".to_owned());
+    }
+
+    Ok(val.to_owned())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/lib/controls/onvif/camera.rs

@@ -1,13 +1,28 @@
+use std::sync::Arc;
+
 use onvif::soap;
-use onvif_schema::{devicemgmt::GetDeviceInformationResponse, transport};
+use onvif_schema::transport;
 
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Context, Result};
+use serde::{Deserialize, Serialize};
+use tokio::sync::RwLock;
 use tracing::*;
 
 use crate::{stream::gst::utils::get_encode_from_rtspsrc, video::types::Format};
 
+use super::manager::OnvifDevice;
+
 #[derive(Clone)]
 pub struct OnvifCamera {
+    pub context: Arc<RwLock<OnvifCameraContext>>,
+    pub last_update: std::time::Instant,
+}
+
+pub struct OnvifCameraContext {
+    pub device: OnvifDevice,
+    pub device_information: OnvifDeviceInformation,
+    pub streams_information: Option<Vec<OnvifStreamInformation>>,
+    pub credentials: Option<soap::client::Credentials>,
     devicemgmt: soap::client::Client,
     event: Option<soap::client::Client>,
     deviceio: Option<soap::client::Client>,
@@ -16,7 +31,6 @@ pub struct OnvifCamera {
     imaging: Option<soap::client::Client>,
     ptz: Option<soap::client::Client>,
     analytics: Option<soap::client::Client>,
-    pub streams_information: Option<Vec<OnvifStreamInformation>>,
 }
 
 pub struct Auth {
@@ -30,29 +44,56 @@ pub struct OnvifStreamInformation {
     pub format: Format,
 }
 
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct OnvifDeviceInformation {
+    pub manufacturer: String,
+    pub model: String,
+    pub firmware_version: String,
+    pub serial_number: String,
+    pub hardware_id: String,
+}
+
 impl OnvifCamera {
     #[instrument(level = "trace", skip(auth))]
-    pub async fn try_new(auth: &Auth) -> Result<Self> {
+    pub async fn try_new(device: &OnvifDevice, auth: &Auth) -> Result<Self> {
         let creds = &auth.credentials;
         let devicemgmt_uri = &auth.url;
         let base_uri = &devicemgmt_uri.origin().ascii_serialization();
 
-        let mut this = Self {
-            devicemgmt: soap::client::ClientBuilder::new(devicemgmt_uri)
-                .credentials(creds.clone())
-                .build(),
+        let devicemgmt = soap::client::ClientBuilder::new(devicemgmt_uri)
+            .credentials(creds.clone())
+            .build();
+
+        let device_information =
+            onvif_schema::devicemgmt::get_device_information(&devicemgmt, &Default::default())
+                .await
+                .map(|i| OnvifDeviceInformation {
+                    manufacturer: i.manufacturer,
+                    model: i.model,
+                    firmware_version: i.firmware_version,
+                    serial_number: i.serial_number,
+                    hardware_id: i.hardware_id,
+                })?;
+
+        let mut context = OnvifCameraContext {
+            device: device.clone(),
+            device_information,
+            streams_information: None,
+            credentials: creds.clone(),
+            devicemgmt,
             imaging: None,
             ptz: None,
             event: None,
             deviceio: None,
             media: None,
             media2: None,
             analytics: None,
-            streams_information: None,
         };
 
         let services =
-            onvif_schema::devicemgmt::get_services(&this.devicemgmt, &Default::default()).await?;
+            onvif_schema::devicemgmt::get_services(&context.devicemgmt, &Default::default())
+                .await
+                .context("Failed to get services")?;
 
         for service in &services.service {
             let service_url = url::Url::parse(&service.x_addr).map_err(anyhow::Error::msg)?;
@@ -74,44 +115,75 @@ impl OnvifCamera {
                         );
                     }
                 }
-                "http://www.onvif.org/ver10/events/wsdl" => this.event = svc,
-                "http://www.onvif.org/ver10/deviceIO/wsdl" => this.deviceio = svc,
-                "http://www.onvif.org/ver10/media/wsdl" => this.media = svc,
-                "http://www.onvif.org/ver20/media/wsdl" => this.media2 = svc,
-                "http://www.onvif.org/ver20/imaging/wsdl" => this.imaging = svc,
-                "http://www.onvif.org/ver20/ptz/wsdl" => this.ptz = svc,
-                "http://www.onvif.org/ver20/analytics/wsdl" => this.analytics = svc,
-                _ => trace!("unknown service: {:?}", service),
+                "http://www.onvif.org/ver10/events/wsdl" => context.event = svc,
+                "http://www.onvif.org/ver10/deviceIO/wsdl" => context.deviceio = svc,
+                "http://www.onvif.org/ver10/media/wsdl" => context.media = svc,
+                "http://www.onvif.org/ver20/media/wsdl" => context.media2 = svc,
+                "http://www.onvif.org/ver20/imaging/wsdl" => context.imaging = svc,
+                "http://www.onvif.org/ver20/ptz/wsdl" => context.ptz = svc,
+                "http://www.onvif.org/ver20/analytics/wsdl" => context.analytics = svc,
+                _ => trace!("Unknwon service: {service:?}"),
             }
         }
 
-        this.streams_information
-            .replace(this.get_streams_information().await?);
+        let context = Arc::new(RwLock::new(context));
+
+        if let Err(error) = Self::update_streams_information(&context).await {
+            warn!("Failed to update streams information: {error:?}");
+        }
 
-        Ok(this)
+        Ok(Self {
+            context,
+            last_update: std::time::Instant::now(),
+        })
     }
 
-    #[instrument(level = "trace", skip(self))]
-    pub async fn get_device_information(
-        &self,
-    ) -> Result<GetDeviceInformationResponse, transport::Error> {
-        onvif_schema::devicemgmt::get_device_information(&self.devicemgmt, &Default::default())
-            .await
+    #[instrument(level = "trace", skip_all)]
+    async fn update_streams_information(context: &Arc<RwLock<OnvifCameraContext>>) -> Result<()> {
+        let mut context = context.write().await;
+
+        let media_client = context
+            .media
+            .clone()
+            .ok_or_else(|| transport::Error::Other("Client media is not available".into()))?;
+
+        // Sometimes a camera responds empty, so we try a couple of times to improve our reliability
+        let mut tries = 10;
+        let new_streams_information = loop {
+            let new_streams_information =
+                OnvifCamera::get_streams_information(&media_client, &context.credentials)
+                    .await
+                    .context("Failed to get streams information")?;
+
+            if new_streams_information.is_empty() {
+                if tries == 0 {
+                    return Err(anyhow!("No streams information found"));
+                }
+
+                tries -= 1;
+                continue;
+            }
+
+            break new_streams_information;
+        };
+
+        context.streams_information.replace(new_streams_information);
+
+        Ok(())
     }
 
+    #[instrument(level = "trace", skip_all)]
     async fn get_streams_information(
-        &self,
+        media_client: &soap::client::Client,
+        credentials: &Option<soap::client::Credentials>,
     ) -> Result<Vec<OnvifStreamInformation>, transport::Error> {
         let mut streams_information = vec![];
 
-        let media_client = self
-            .media
-            .as_ref()
-            .ok_or_else(|| transport::Error::Other("Client media is not available".into()))?;
         let profiles = onvif_schema::media::get_profiles(media_client, &Default::default())
             .await?
             .profiles;
-        trace!("get_profiles response: {:#?}", &profiles);
+        trace!("get_profiles response: {profiles:#?}");
+
         let requests: Vec<_> = profiles
             .iter()
             .map(
@@ -138,7 +210,7 @@ impl OnvifCamera {
             trace!("token={} name={}", &profile.token.0, &profile.name.0);
             trace!("\t{}", &stream_uri_response.media_uri.uri);
 
-            let stream_uri = match url::Url::parse(&stream_uri_response.media_uri.uri) {
+            let mut stream_uri = match url::Url::parse(&stream_uri_response.media_uri.uri) {
                 Ok(stream_url) => stream_url,
                 Err(error) => {
                     error!(
@@ -154,7 +226,25 @@ impl OnvifCamera {
                 continue;
             };
 
+            if let Some(credentials) = &credentials {
+                if stream_uri.set_username(&credentials.username).is_err() {
+                    warn!("Failed setting username");
+                    continue;
+                }
+
+                if stream_uri
+                    .set_password(Some(&credentials.password))
+                    .is_err()
+                {
+                    warn!("Failed setting password");
+                    continue;
+                }
+
+                trace!("Using credentials {credentials:?}");
+            }
+
             let Some(encode) = get_encode_from_rtspsrc(&stream_uri).await else {
+                warn!("Failed getting encoding from RTSP stream at {stream_uri}");
                 continue;
             };
 
@@ -182,6 +272,7 @@ impl OnvifCamera {
 
             streams_information.push(OnvifStreamInformation { stream_uri, format });
         }
+
         Ok(streams_information)
     }
 }