candidateparser 0.2.0

A parser for the ICE Candidate SDP according to RFC5245.
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

use std::convert::Into;
use std::collections::HashMap;
use std::ffi::CString;
use std::fmt;
use std::net::IpAddr;

/// The ICE candidate struct. Contains all data from the SDP.
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct IceCandidate {
    pub foundation: String,
    pub component_id: u32,
    pub transport: Transport,
    pub priority: u64,
    pub connection_address: IpAddr,
    pub port: u16,
    pub candidate_type: CandidateType,
    pub rel_addr: Option<IpAddr>,
    pub rel_port: Option<u16>,
    pub extensions: Option<HashMap<Vec<u8>, Vec<u8>>>,
}

/// The transport type. In almost all cases this will be `Transport::Udp`.
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
pub enum Transport {
    Udp,
    Extension(String)
}

impl fmt::Display for Transport {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &Transport::Udp => write!(f, "udp"),
            &Transport::Extension(ref e) => write!(f, "{}", e),
        }
    }
}

impl Into<CString> for Transport {
    fn into(self) -> CString {
        match self {
            Transport::Udp => CString::new("udp").unwrap(),
            Transport::Extension(e) => CString::new(e).unwrap(),
        }
    }
}

/// All possible candidate types.
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
pub enum CandidateType {
    Host,
    Srflx,
    Prflx,
    Relay,
    Token(String),
}

impl Into<CString> for CandidateType {
    fn into(self) -> CString {
        match self {
            CandidateType::Host => CString::new("host").unwrap(),
            CandidateType::Srflx => CString::new("srflx").unwrap(),
            CandidateType::Prflx => CString::new("prflx").unwrap(),
            CandidateType::Relay => CString::new("relay").unwrap(),
            CandidateType::Token(e) => CString::new(e).unwrap(),
        }
    }
}

impl fmt::Display for CandidateType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &CandidateType::Host => write!(f, "host"),
            &CandidateType::Srflx => write!(f, "srflx"),
            &CandidateType::Prflx => write!(f, "prflx"),
            &CandidateType::Relay => write!(f, "relay"),
            &CandidateType::Token(ref e) => write!(f, "{}", e),
        }
    }
}

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

    #[test]
    fn test_transport_into_cstring() {
        let converted1: CString = Transport::Udp.into();
        assert_eq!(converted1, CString::new("udp").unwrap());

        let converted2: CString = Transport::Extension("yolo".into()).into();
        assert_eq!(converted2, CString::new("yolo").unwrap());
    }

    #[test]
    fn test_candidate_type_into_cstring() {
        let host: CString = CandidateType::Host.into();
        let srflx: CString = CandidateType::Srflx.into();
        let prflx: CString = CandidateType::Prflx.into();
        let relay: CString = CandidateType::Relay.into();
        let token: CString = CandidateType::Token("Yolo".into()).into();

        assert_eq!(host, CString::new("host").unwrap());
        assert_eq!(srflx, CString::new("srflx").unwrap());
        assert_eq!(prflx, CString::new("prflx").unwrap());
        assert_eq!(relay, CString::new("relay").unwrap());
        assert_eq!(token, CString::new("Yolo").unwrap());
    }
}