sipmsg 0.2.0

SIP message parser
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312

use sipmsg::*;

#[test]
fn parse_header() {
    let (input, (_, hdrs)) = SipHeader::parse("Subject:This is a test\r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Subject");
    assert_eq!(hdrs[0].value.vstr, "This is a test");
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) =
        SipHeader::parse("Extension_Header: Value;parameter=false;param2\r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Extension_Header");
    assert_eq!(hdrs[0].value.vstr, "Value;parameter=false;param2");
    
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) = SipHeader::parse("Max-Forwards: 70\r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Max-Forwards");
    assert_eq!(hdrs[0].value.vstr, "70");
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) = SipHeader::parse(
        "Authentication-Info: nextnonce=\"47364c23432d2e131a5fb210812c\"\r\n".as_bytes(),
    )
    .unwrap();
    assert_eq!(input, "\r\n".as_bytes());
    assert_eq!(
        hdrs[0].value.vstr,
        "nextnonce=\"47364c23432d2e131a5fb210812c\""
    );
}

#[test]
fn parse_header_without_value() {
    let (input, (_, hdrs)) = SipHeader::parse("Accept:  \r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Accept");
    assert_eq!(hdrs[0].value.vstr, "");
    assert_eq!(input.len(), 2)
}

#[test]
fn accept_encoding_header() {
    /*
        For testing:
        Accept-Encoding: compress, gzip
        Accept-Encoding:
        Accept-Encoding: *
        Accept-Encoding: compress;q=0.5, gzip;q=1.0
        Accept-Encoding: gzip;q=1.0, identity; q=0.5, *;q=0
        Accept-Encoding: gzip
        Accept-Encoding: gzip, compress, br
        Accept-Encoding: br;q=1.0, gzip;q=0.8, *;q=0.1
    */
    let (input, (_, hdrs)) =
        SipHeader::parse("Accept-Encoding:  compress, gzip \r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Accept-Encoding");
    assert_eq!(hdrs[0].value.vstr, "compress");
    assert_eq!(hdrs[1].name, "Accept-Encoding");
    assert_eq!(hdrs[1].value.vstr, "gzip");
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) = SipHeader::parse("Accept-Encoding:  \r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Accept-Encoding");
    assert_eq!(hdrs[0].value.vstr, "");
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) = SipHeader::parse("Accept-Encoding: *  \r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Accept-Encoding");
    assert_eq!(hdrs[0].value.vstr, "*");
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) =
        SipHeader::parse("Accept-Encoding:compress;q=0.5, gzip;q=1.0\r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Accept-Encoding");
    assert_eq!(hdrs[0].value.vstr, "compress");
    assert_eq!(
        hdrs[0].params().unwrap().get("q").unwrap(),
        &Some("0.5")
    );
    assert_eq!(hdrs[1].name, "Accept-Encoding");
    assert_eq!(hdrs[1].value.vstr, "gzip");
    assert_eq!(
        hdrs[1].params().unwrap().get("q").unwrap(),
        &Some("1.0")
    );
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) =
        SipHeader::parse("Accept-Encoding: gzip;q=1.0, identity; q=0.5, *;q=0\r\n".as_bytes())
            .unwrap();
    assert_eq!(hdrs[0].name, "Accept-Encoding");
    assert_eq!(hdrs[0].value.vstr, "gzip");
    assert_eq!(
        hdrs[0].params().unwrap().get("q").unwrap(),
        &Some("1.0")
    );
    assert_eq!(hdrs[1].name, "Accept-Encoding");
    assert_eq!(hdrs[1].value.vstr, "identity");
    assert_eq!(
        hdrs[1].params().unwrap().get("q").unwrap(),
        &Some("0.5")
    );

    assert_eq!(hdrs[2].name, "Accept-Encoding");
    assert_eq!(hdrs[2].value.vstr, "*");
    assert_eq!(
        hdrs[2].params().unwrap().get("q").unwrap(),
        &Some("0")
    );
    assert_eq!(input.len(), 2);

    let (input, (_, hdrs)) = SipHeader::parse("Accept-Encoding: gzip \r\n".as_bytes()).unwrap();
    assert_eq!(hdrs[0].name, "Accept-Encoding");
    assert_eq!(hdrs[0].value.vstr, "gzip");
    assert_eq!(input.len(), 2)
}

#[test]
fn allow_header() {
    let (input, (_, hdrs)) = SipHeader::parse(
        "Allow: INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY, INFO, PUBLISH\r\n"
            .as_bytes(),
    )
    .unwrap();

    assert_eq!(hdrs[0].name, "Allow");
    assert_eq!(hdrs[0].value.vstr, "INVITE");
    assert_eq!(hdrs[1].value.vstr, "ACK");
    assert_eq!(hdrs[2].value.vstr, "CANCEL");
    assert_eq!(hdrs[3].value.vstr, "OPTIONS");
    assert_eq!(hdrs[4].value.vstr, "BYE");
    assert_eq!(hdrs[5].value.vstr, "REFER");
    assert_eq!(hdrs[6].value.vstr, "SUBSCRIBE");
    assert_eq!(hdrs[7].value.vstr, "NOTIFY");
    assert_eq!(hdrs[8].value.vstr, "INFO");
    assert_eq!(hdrs[9].value.vstr, "PUBLISH");
    assert_eq!(input, "\r\n".as_bytes());
}

#[test]
fn alert_info_header() {
    let (input, (_, hdrs)) =
        SipHeader::parse("Alert-Info: <http://www.example.com/sounds/moo.wav> \r\n".as_bytes())
            .unwrap();

    assert_eq!(hdrs[0].name, "Alert-Info");
    assert_eq!(
        hdrs[0].value.vstr,
        "<http://www.example.com/sounds/moo.wav>"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::AbsoluteURI],
        "http://www.example.com/sounds/moo.wav".as_bytes()
    );
    assert_eq!(input, "\r\n".as_bytes());
}

#[test]
fn accept_language_header() {
    let (input, (_, hdrs)) =
        SipHeader::parse("Accept-Language: da, en-gb;q=0.8, en;q=0.7 \r\n".as_bytes()).unwrap();

    assert_eq!(hdrs[0].name, "Accept-Language");
    assert_eq!(hdrs[0].value.vstr, "da");
    assert_eq!(hdrs[1].value.vstr, "en-gb");
    assert_eq!(
        hdrs[1].params().unwrap().get("q").unwrap(),
        &Some("0.8")
    );

    assert_eq!(hdrs[2].value.vstr, "en");
    assert_eq!(
        hdrs[2].params().unwrap().get("q").unwrap(),
        &Some("0.7")
    );

    assert_eq!(input.len(), 2)
}

#[test]
fn authorization_header() {
    let res = SipHeader::parse("Authorization: Digest username=\"bob\", realm=\"atlanta.example.com\"\
    ,nonce=\"ea9c8e88df84f1cec4341ae6cbe5a359\", opaque=\"\" ,uri=\"sips:ss2.biloxi.example.com\"\r\n".as_bytes());
    let (input, (_, hdrs)) = res.unwrap();
    assert_eq!(
        hdrs[0].value.vstr,
        "Digest username=\"bob\", realm=\"atlanta.example.com\"\
    ,nonce=\"ea9c8e88df84f1cec4341ae6cbe5a359\", opaque=\"\" ,uri=\"sips:ss2.biloxi.example.com\""
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::Username],
        b"bob"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::Realm],
        b"atlanta.example.com"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::Nonce],
        b"ea9c8e88df84f1cec4341ae6cbe5a359"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::Opaque],
        b""
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::DigestUri],
        b"sips:ss2.biloxi.example.com"
    );

    assert_eq!(input, b"\r\n");
}

#[test]
fn call_id_header() {
    let res = SipHeader::parse("i: 3848276298220188511@atlanta.example.com\r\n".as_bytes());
    let (input, (_, hdrs)) = res.unwrap();
    assert_eq!(
        hdrs[0].value.vstr,
        "3848276298220188511@atlanta.example.com"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::ID],
        b"3848276298220188511"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::Host],
        b"atlanta.example.com"
    );
    assert_eq!(input, b"\r\n");

    let res = SipHeader::parse("call-id: 3848276298220188511\r\n".as_bytes());
    let (input, (_, hdrs)) = res.unwrap();
    assert_eq!(hdrs[0].value.vstr, "3848276298220188511");
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::ID],
        b"3848276298220188511"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap().get(&SipHeaderTagType::Host),
        None
    );
    assert_eq!(input, b"\r\n");
}

#[test]
fn callinfo_test() {
    let res = SipHeader::parse(
        "Call-Info: <http://wwww.example.com/alice/photo.jpg> ;purpose=icon,\r\n \
    <http://www.example.com/alice/> ;purpose=info\r\n"
            .as_bytes(),
    );
    let (input, (_, hdrs)) = res.unwrap();
    assert_eq!(
        hdrs[0].value.vstr,
        "<http://wwww.example.com/alice/photo.jpg>"
    );
    assert_eq!(
        hdrs[0].value.tags().unwrap()[&SipHeaderTagType::AbsoluteURI],
        "http://wwww.example.com/alice/photo.jpg".as_bytes()
    );

    assert_eq!(
        hdrs[0].params().unwrap().get("purpose"),
        Some(&Some("icon"))
    );

    assert_eq!(hdrs[1].value.vstr, "<http://www.example.com/alice/>");
    assert_eq!(
        hdrs[1].value.tags().unwrap()[&SipHeaderTagType::AbsoluteURI],
        "http://www.example.com/alice/".as_bytes()
    );

    assert_eq!(
        hdrs[1].params().unwrap().get("purpose"),
        Some(&Some("info"))
    );

    assert_eq!(input, b"\r\n");
}

#[test]
fn content_disposition_header() {
    let (input, (_, hdrs)) = SipHeader::parse(
        "Content-Disposition: attachment; filename=smime.p7s; handling=required\r\n".as_bytes(),
    )
    .unwrap();

    assert_eq!(hdrs[0].name, "Content-Disposition");
    assert_eq!(hdrs[0].value.vstr, "attachment");
    assert_eq!(
        hdrs[0].params().unwrap().get("filename").unwrap(),
        &Some("smime.p7s")
    );
    assert_eq!(
        hdrs[0].params().unwrap().get("handling").unwrap(),
        &Some("required")
    );
    assert_eq!(input.len(), 2)
}

#[test]
fn content_type_header() {
    let (input, (_, hdrs)) = SipHeader::parse(
        "Content-Type: application/sdp\r\n".as_bytes(),
    )
    .unwrap();

    assert_eq!(hdrs[0].name, "Content-Type");
    assert_eq!(hdrs[0].value.vstr, "application/sdp");
    assert_eq!(input.len(), 2)
}