dvrip-rs 0.1.0

A Rust library for interacting with DVR-IP devices ported from python-dvr.
Documentation 
1
2
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::commands::Connection;
use crate::constants::{OK_CODES, QCODES};
use crate::dvrip::DVRIPCam;
use crate::error::Result;
use crate::protocol::sofia_hash;
use async_trait::async_trait;
use serde_json::json;
use std::sync::atomic::Ordering;

#[async_trait]
pub trait Authentication: Send + Sync {
    /// Login to the device
    async fn login(&mut self, username: &str, password: &str) -> Result<bool>;

    /// Logout from the device
    async fn logout(&mut self) -> Result<()>;

    /// Check if authenticated
    fn is_authenticated(&self) -> bool;

    /// Get the session ID
    fn session_id(&self) -> u32;

    /// Change user password
    async fn change_password(
        &mut self,
        old_password: &str,
        new_password: &str,
        username: Option<&str>,
    ) -> Result<bool>;
}

#[async_trait]
impl Authentication for DVRIPCam {
    async fn login(&mut self, username: &str, password: &str) -> Result<bool> {
        if !Connection::is_connected(self) {
            Connection::connect(self, self.timeout).await?;
        }

        let data = json!({
            "EncryptType": "MD5",
            "LoginType": "DVRIP-Web",
            "PassWord": sofia_hash(password),
            "UserName": username,
        });
        self.username = Some(username.to_string());

        let reply = self.send_command(1000, data, true).await?.ok_or_else(|| {
            crate::error::DVRIPError::AuthenticationError("Empty response".to_string())
        })?;

        if let Some(ret) = reply.get("Ret").and_then(|r| r.as_u64())
            && OK_CODES.contains(&(ret as u32))
        {
            if let Some(session_str) = reply.get("SessionID").and_then(|s| s.as_str()) {
                let session_id = u32::from_str_radix(&session_str[2..], 16).map_err(|_| {
                    crate::error::DVRIPError::ProtocolError("Invalid SessionID".to_string())
                })?;
                self.session.store(session_id, Ordering::Release);
            }

            if let Some(interval) = reply.get("AliveInterval").and_then(|i| i.as_u64()) {
                self.alive_time.store(interval, Ordering::Release);
            }

            self.authenticated.store(true, Ordering::Release);
            self.start_keep_alive().await;
            return Ok(true);
        }

        Ok(false)
    }

    async fn logout(&mut self) -> Result<()> {
        Connection::close(self).await
    }

    fn is_authenticated(&self) -> bool {
        self.authenticated.load(Ordering::Acquire)
    }

    fn session_id(&self) -> u32 {
        self.session.load(Ordering::Acquire)
    }

    async fn change_password(
        &mut self,
        old_password: &str,
        new_password: &str,
        username: Option<&str>,
    ) -> Result<bool> {
        let data = json!({
            "EncryptType": "MD5",
            "NewPassWord": sofia_hash(new_password),
            "PassWord": sofia_hash(old_password),
            "SessionID": format!("0x{:08X}", self.session_id()),
            "UserName": username.unwrap_or(self.username.as_ref().unwrap_or(&"admin".to_string())),
        });

        let reply = self
            .send_command(
                QCODES.get("ModifyPassword").copied().unwrap_or(1488),
                data,
                true,
            )
            .await?
            .ok_or_else(|| crate::error::DVRIPError::ProtocolError("Empty response".to_string()))?;

        if let Some(ret) = reply.get("Ret").and_then(|r| r.as_u64()) {
            return Ok(OK_CODES.contains(&(ret as u32)));
        }

        Ok(false)
    }
}