rustpbx 0.4.9

A SIP PBX implementation in Rust
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129

pub mod backend;
pub mod flowdb_backend;
pub mod flowdb_codec;
pub mod perf;
pub mod protocol;
pub mod rtp_stats;
pub mod sdp_utils;
pub mod storage;
pub mod wav_utils;

use anyhow::Result;
use bytes::Bytes;
use chrono::{DateTime, Local};
use serde::{Deserialize, Serialize};

pub use backend::{SipFlowBackend, create_backend};
pub use protocol::{MsgType, Packet, parse_packet};
pub use sdp_utils::{extract_call_id, extract_rtp_addr, extract_sdp};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum SipFlowMsgType {
    Sip,
    Rtp,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SipFlowItem {
    pub timestamp: u64,
    #[serde(default)]
    pub seq: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub leg: Option<i32>,
    #[serde(default = "default_msg_type")]
    pub msg_type: SipFlowMsgType,
    #[serde(default)]
    pub src_addr: String,
    #[serde(default)]
    pub dst_addr: String,
    pub payload: Bytes,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SipFlowMediaStats {
    pub leg: i32,
    pub src: String,
    #[serde(default, alias = "count")]
    pub packet_count: usize,
    #[serde(default)]
    pub lost_packets: u64,
    #[serde(default)]
    pub expected_packets: u64,
    #[serde(default)]
    pub loss_percent: f64,
    #[serde(default)]
    pub jitter_ms: Option<f64>,
    #[serde(default)]
    pub ssrc: Option<u32>,
    #[serde(default)]
    pub payload_type: Option<u8>,
    #[serde(default)]
    pub clock_rate: Option<u32>,
}

fn default_msg_type() -> SipFlowMsgType {
    SipFlowMsgType::Sip
}

impl SipFlowItem {
    pub fn message_text(&self) -> Option<String> {
        if self.msg_type == SipFlowMsgType::Sip && !self.payload.is_empty() {
            Some(String::from_utf8_lossy(&self.payload).to_string())
        } else {
            None
        }
    }
}

/// Query interface for SipFlow data
pub struct SipFlowQuery {
    backend: Box<dyn SipFlowBackend>,
}

impl SipFlowQuery {
    pub fn new(backend: Box<dyn SipFlowBackend>) -> Self {
        Self { backend }
    }

    pub async fn get_flow(
        &self,
        call_id: &str,
        start_time: DateTime<Local>,
        end_time: DateTime<Local>,
    ) -> Result<Vec<SipFlowItem>> {
        self.backend.query_flow(call_id, start_time, end_time).await
    }

    pub async fn get_media(
        &self,
        call_id: &str,
        start_time: DateTime<Local>,
        end_time: DateTime<Local>,
    ) -> Result<Vec<u8>> {
        self.backend
            .query_media(call_id, start_time, end_time)
            .await
    }

    pub fn export_jsonl(flow: &[SipFlowItem]) -> String {
        flow.iter()
            .filter_map(|item| {
                let payload_str = String::from_utf8_lossy(&item.payload);
                let obj = serde_json::json!({
                    "timestamp": item.timestamp,
                    "seq": item.seq,
                    "leg": item.leg,
                    "msg_type": item.msg_type,
                    "src_addr": item.src_addr,
                    "dst_addr": item.dst_addr,
                    "payload": payload_str,
                });
                serde_json::to_string(&obj).ok()
            })
            .collect::<Vec<_>>()
            .join("\n")
    }
}

#[cfg(test)]
mod tests;