oxvif 0.9.4

Async Rust client library for the ONVIF IP camera protocol
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

//! ONVIF mock server — stateful, with WS-Security auth and file persistence.
//!
//! ```sh
//! # Default: state saved to ~/.oxvif/mock_device.toml
//! cargo run --example mock_server
//!
//! # Custom port + config file
//! cargo run --example mock_server -- 19090 --config /path/to/state.toml
//!
//! # Credentials: admin / admin
//! ```

mod auth;
mod dispatch;
mod helpers;
mod services;
mod snapshot;
mod state;
pub mod xml_parse;

use axum::{
    Router,
    extract::State,
    http::{HeaderMap, StatusCode, header},
    response::IntoResponse,
    routing::{get, post},
};
use std::{net::SocketAddr, sync::Arc};
use tokio::net::TcpListener;

use state::PersistentState;

pub struct MockState {
    pub base: String,
    pub device: PersistentState,
}

#[tokio::main]
async fn main() {
    let port: u16 = std::env::args()
        .nth(1)
        .and_then(|a| a.parse().ok())
        .unwrap_or(18080);

    let state_path = state::resolve_state_path();
    let addr = SocketAddr::from(([127, 0, 0, 1], port));
    let base = format!("http://{addr}");

    let state = Arc::new(MockState {
        base: base.clone(),
        device: PersistentState::load(state_path.clone()),
    });

    let app = Router::new()
        .route("/mock/snapshot.jpg", get(handle_snapshot))
        .route("/{*path}", post(handle_soap))
        .with_state(state);

    let listener = TcpListener::bind(addr).await.expect("bind failed");
    println!("ONVIF mock server listening on {base}");
    println!("  ONVIF_URL={base}/onvif/device");
    println!("  Credentials: admin / admin");
    println!("  State file: {}", state_path.display());
    println!();

    axum::serve(listener, app).await.expect("serve failed");
}

async fn handle_soap(
    State(state): State<Arc<MockState>>,
    headers: HeaderMap,
    body: axum::body::Bytes,
) -> impl IntoResponse {
    let action = helpers::extract_action(&headers).unwrap_or_default();
    let body_str = String::from_utf8_lossy(&body);
    eprintln!("  → {action}");

    if auth::requires_auth(&action) {
        if let Err(reason) = auth::validate_ws_security(&body_str, &state.device) {
            eprintln!("    [AUTH FAIL] {reason}");
            return (
                StatusCode::OK,
                [(header::CONTENT_TYPE, "application/soap+xml; charset=utf-8")],
                auth::auth_fault(&reason),
            );
        }
    }

    let xml = dispatch::dispatch(&action, &state.base, &state.device, &body_str).await;

    (
        StatusCode::OK,
        [(header::CONTENT_TYPE, "application/soap+xml; charset=utf-8")],
        xml,
    )
}

async fn handle_snapshot() -> impl IntoResponse {
    let bmp = snapshot::generate_test_bmp();
    (
        StatusCode::OK,
        [
            (header::CONTENT_TYPE, "image/bmp"),
            (header::CACHE_CONTROL, "no-cache, no-store"),
        ],
        bmp,
    )
}