ftth-rsip 0.4.1

SIP Rust library, parser & generator of SIP
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

pub fn generate_register() -> ftth_rsip::SipMessage {
    let mut headers: ftth_rsip::Headers = Default::default();

    let base_uri = ftth_rsip::Uri {
        scheme: Some(ftth_rsip::Scheme::Sips),
        auth: Some(("bob", Option::<String>::None).into()),
        host_with_port: ftth_rsip::Domain::from("biloxi.example.com").into(),
        ..Default::default()
    };

    headers.push(
        ftth_rsip::typed::Via {
            version: ftth_rsip::Version::V2,
            transport: ftth_rsip::Transport::Tls,
            uri: ftth_rsip::Uri {
                host_with_port: (ftth_rsip::Domain::from("client.biloxi.example.com"), 5060).into(),
                ..Default::default()
            },
            params: vec![ftth_rsip::Param::Branch(ftth_rsip::param::Branch::new(
                "z9hG4bKnashds7",
            ))],
        }
        .into(),
    );
    headers.push(ftth_rsip::headers::MaxForwards::default().into());
    headers.push(
        ftth_rsip::typed::From {
            display_name: Some("Bob".into()),
            uri: base_uri.clone(),
            params: vec![ftth_rsip::Param::Tag(ftth_rsip::param::Tag::new("a73kszlfl"))],
        }
        .into(),
    );
    headers.push(
        ftth_rsip::typed::To {
            display_name: Some("Bob".into()),
            uri: base_uri.clone(),
            params: Default::default(),
        }
        .into(),
    );
    headers.push(ftth_rsip::headers::CallId::default().into());
    headers.push(
        ftth_rsip::typed::CSeq {
            seq: 1,
            method: ftth_rsip::Method::Register,
        }
        .into(),
    );
    headers.push(
        ftth_rsip::typed::Contact {
            display_name: None,
            uri: base_uri,
            params: Default::default(),
        }
        .into(),
    );
    headers.push(ftth_rsip::headers::ContentLength::default().into());

    ftth_rsip::Request {
        method: ftth_rsip::Method::Register,
        uri: ftth_rsip::Uri {
            scheme: Some(ftth_rsip::Scheme::Sips),
            host_with_port: ftth_rsip::Domain::from("ss2.biloxi.example.com").into(),
            ..Default::default()
        },
        headers: headers,
        version: ftth_rsip::Version::V2,
        body: Default::default(),
    }
    .into()
}

pub fn create_unauthorized_from(request: ftth_rsip::Request) -> Result<ftth_rsip::SipMessage, ftth_rsip::Error> {
    use ftth_rsip::prelude::*;

    let mut headers: ftth_rsip::Headers = Default::default();
    headers.push(request.via_header()?.clone().into());
    headers.push(request.from_header()?.clone().into());
    let to = request.to_header()?.typed()?;
    let to = to.with_tag("1410948204".into());
    headers.push(to.into());
    headers.push(request.call_id_header()?.clone().into());
    headers.push(request.cseq_header()?.clone().into());
    headers.push(ftth_rsip::Header::ContentLength(Default::default()));
    headers.push(ftth_rsip::Header::Server(Default::default()));

    headers.push(
        ftth_rsip::typed::WwwAuthenticate {
            realm: "atlanta.example.com".into(),
            nonce: "ea9c8e88df84f1cec4341ae6cbe5a359".into(),
            algorithm: Some(ftth_rsip::headers::auth::Algorithm::Md5),
            qop: Some(ftth_rsip::headers::auth::Qop::Auth),
            stale: Some("FALSE".into()),
            opaque: Some("".into()),
            ..Default::default()
        }
        .into(),
    );

    Ok(ftth_rsip::Response {
        status_code: 401.into(),
        headers,
        version: ftth_rsip::Version::V2,
        body: Default::default(),
    }
    .into())
}

fn main() -> Result<(), ftth_rsip::Error> {
    use std::convert::TryInto;

    let register_request = generate_register();
    println!("Sending REGISTER request: \n{}", register_request);

    let unauthorized_response = create_unauthorized_from(register_request.try_into()?)?;
    println!(
        "Responding with 401 to REGISTER request: \n{}",
        unauthorized_response
    );

    Ok(())
}