rsip 0.4.0

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
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

use crate::headers::untyped::*;

#[doc(hidden)]
pub use tokenizer::Tokenizer;

/// Big enum holding in each variant every possible header defined in SIP. All variants hold an
/// [untyped](super::untyped) header which is basically a NewType around String.
///
/// In case a header is not defined in Rsip, parsing will store it in the `Other`
/// variant, which is a tuple of Strings.
/// For instance, constructing the `X-Fs-Sending-Message` header (related to SMS in SIP),
/// you can do:
/// ```
/// let x_fs_sending_message = rsip::Header::Other("X-FS-Sending-Message".into(), "f9c4adc8-9c2a-47d5-a7f1-63d20784685e".into());
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Header {
    Accept(Accept),
    AcceptEncoding(AcceptEncoding),
    AcceptLanguage(AcceptLanguage),
    AlertInfo(AlertInfo),
    Allow(Allow),
    AuthenticationInfo(AuthenticationInfo),
    Authorization(Authorization),
    CSeq(CSeq),
    CallId(CallId),
    CallInfo(CallInfo),
    Contact(Contact),
    ContentDisposition(ContentDisposition),
    ContentEncoding(ContentEncoding),
    ContentLanguage(ContentLanguage),
    ContentLength(ContentLength),
    ContentType(ContentType),
    Date(Date),
    ErrorInfo(ErrorInfo),
    Event(Event),
    Expires(Expires),
    From(From),
    InReplyTo(InReplyTo),
    MaxForwards(MaxForwards),
    MimeVersion(MimeVersion),
    MinExpires(MinExpires),
    Organization(Organization),
    Other(String, String),
    Priority(Priority),
    ProxyAuthenticate(ProxyAuthenticate),
    ProxyAuthorization(ProxyAuthorization),
    ProxyRequire(ProxyRequire),
    RecordRoute(RecordRoute),
    ReplyTo(ReplyTo),
    Require(Require),
    RetryAfter(RetryAfter),
    Route(Route),
    Server(Server),
    Subject(Subject),
    SubscriptionState(SubscriptionState),
    Supported(Supported),
    Timestamp(Timestamp),
    To(To),
    Unsupported(Unsupported),
    UserAgent(UserAgent),
    Via(Via),
    Warning(Warning),
    WwwAuthenticate(WwwAuthenticate),
}

impl std::fmt::Display for Header {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Accept(inner) => write!(f, "{}", inner),
            Self::AcceptEncoding(inner) => write!(f, "{}", inner),
            Self::AcceptLanguage(inner) => write!(f, "{}", inner),
            Self::AlertInfo(inner) => write!(f, "{}", inner),
            Self::Allow(inner) => write!(f, "{}", inner),
            Self::AuthenticationInfo(inner) => write!(f, "{}", inner),
            Self::Authorization(inner) => write!(f, "{}", inner),
            Self::CSeq(inner) => write!(f, "{}", inner),
            Self::CallId(inner) => write!(f, "{}", inner),
            Self::CallInfo(inner) => write!(f, "{}", inner),
            Self::Contact(inner) => write!(f, "{}", inner),
            Self::ContentDisposition(inner) => write!(f, "{}", inner),
            Self::ContentEncoding(inner) => write!(f, "{}", inner),
            Self::ContentLanguage(inner) => write!(f, "{}", inner),
            Self::ContentLength(inner) => write!(f, "{}", inner),
            Self::ContentType(inner) => write!(f, "{}", inner),
            Self::Date(inner) => write!(f, "{}", inner),
            Self::ErrorInfo(inner) => write!(f, "{}", inner),
            Self::Event(inner) => write!(f, "{}", inner),
            Self::Expires(inner) => write!(f, "{}", inner),
            Self::From(inner) => write!(f, "{}", inner),
            Self::InReplyTo(inner) => write!(f, "{}", inner),
            Self::MaxForwards(inner) => write!(f, "{}", inner),
            Self::MimeVersion(inner) => write!(f, "{}", inner),
            Self::MinExpires(inner) => write!(f, "{}", inner),
            Self::Organization(inner) => write!(f, "{}", inner),
            Self::Other(key, value) => write!(f, "{}: {}", key, value),
            Self::Priority(inner) => write!(f, "{}", inner),
            Self::ProxyAuthenticate(inner) => write!(f, "{}", inner),
            Self::ProxyAuthorization(inner) => write!(f, "{}", inner),
            Self::ProxyRequire(inner) => write!(f, "{}", inner),
            Self::RecordRoute(inner) => write!(f, "{}", inner),
            Self::ReplyTo(inner) => write!(f, "{}", inner),
            Self::Require(inner) => write!(f, "{}", inner),
            Self::RetryAfter(inner) => write!(f, "{}", inner),
            Self::Route(inner) => write!(f, "{}", inner),
            Self::Server(inner) => write!(f, "{}", inner),
            Self::Subject(inner) => write!(f, "{}", inner),
            Self::SubscriptionState(inner) => write!(f, "{}", inner),
            Self::Supported(inner) => write!(f, "{}", inner),
            Self::Timestamp(inner) => write!(f, "{}", inner),
            Self::To(inner) => write!(f, "{}", inner),
            Self::Unsupported(inner) => write!(f, "{}", inner),
            Self::UserAgent(inner) => write!(f, "{}", inner),
            Self::Via(inner) => write!(f, "{}", inner),
            Self::Warning(inner) => write!(f, "{}", inner),
            Self::WwwAuthenticate(inner) => write!(f, "{}", inner),
        }
    }
}

#[doc(hidden)]
pub mod tokenizer {
    use super::*;
    use crate::{Error, IResult, TokenizerError};
    use rsip_derives::Utf8Tokenizer;
    use std::convert::TryInto;

    impl<'a> TryInto<Header> for Tokenizer<'a> {
        type Error = Error;

        fn try_into(self) -> Result<Header, Error> {
            let tokenizer: Utf8Tokenizer = self.try_into()?;

            match tokenizer.name {
                s if s.eq_ignore_ascii_case("Accept") => {
                    Ok(Header::Accept(Accept::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Accept-Encoding") => {
                    Ok(Header::AcceptEncoding(AcceptEncoding::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Accept-Language") => {
                    Ok(Header::AcceptLanguage(AcceptLanguage::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Alert-Info") => {
                    Ok(Header::AlertInfo(AlertInfo::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Allow") => {
                    Ok(Header::Allow(Allow::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Authentication-Info") => Ok(
                    Header::AuthenticationInfo(AuthenticationInfo::new(tokenizer.value)),
                ),
                s if s.eq_ignore_ascii_case("Authorization") => {
                    Ok(Header::Authorization(Authorization::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("CSeq") => Ok(Header::CSeq(CSeq::new(tokenizer.value))),
                s if s.eq_ignore_ascii_case("Call-Id") => {
                    Ok(Header::CallId(CallId::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Call-Info") => {
                    Ok(Header::CallInfo(CallInfo::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Contact") => {
                    Ok(Header::Contact(Contact::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Content-Disposition") => Ok(
                    Header::ContentDisposition(ContentDisposition::new(tokenizer.value)),
                ),
                s if s.eq_ignore_ascii_case("Content-Encoding") => Ok(Header::ContentEncoding(
                    ContentEncoding::new(tokenizer.value),
                )),
                s if s.eq_ignore_ascii_case("Content-Language") => Ok(Header::ContentLanguage(
                    ContentLanguage::new(tokenizer.value),
                )),
                s if s.eq_ignore_ascii_case("Content-Length") => {
                    Ok(Header::ContentLength(ContentLength::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Content-Type") => {
                    Ok(Header::ContentType(ContentType::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Date") => Ok(Header::Date(Date::new(tokenizer.value))),
                s if s.eq_ignore_ascii_case("Error-Info") => {
                    Ok(Header::ErrorInfo(ErrorInfo::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Event") => {
                    Ok(Header::Event(Event::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Expires") => {
                    Ok(Header::Expires(Expires::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("From") => Ok(Header::From(From::new(tokenizer.value))),
                s if s.eq_ignore_ascii_case("In-Reply-To") => {
                    Ok(Header::InReplyTo(InReplyTo::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Max-Forwards") => {
                    Ok(Header::MaxForwards(MaxForwards::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Mime-Version") => {
                    Ok(Header::MimeVersion(MimeVersion::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Min-Expires") => {
                    Ok(Header::MinExpires(MinExpires::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Organization") => {
                    Ok(Header::Organization(Organization::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Priority") => {
                    Ok(Header::Priority(Priority::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Proxy-Authenticate") => Ok(Header::ProxyAuthenticate(
                    ProxyAuthenticate::new(tokenizer.value),
                )),
                s if s.eq_ignore_ascii_case("Proxy-Authorization") => Ok(
                    Header::ProxyAuthorization(ProxyAuthorization::new(tokenizer.value)),
                ),
                s if s.eq_ignore_ascii_case("Proxy-Require") => {
                    Ok(Header::ProxyRequire(ProxyRequire::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Record-Route") => {
                    Ok(Header::RecordRoute(RecordRoute::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Reply-To") => {
                    Ok(Header::ReplyTo(ReplyTo::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Require") => {
                    Ok(Header::Require(Require::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Retry-After") => {
                    Ok(Header::RetryAfter(RetryAfter::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Route") => {
                    Ok(Header::Route(Route::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Server") => {
                    Ok(Header::Server(Server::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Subject") => {
                    Ok(Header::Subject(Subject::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Supported") => {
                    Ok(Header::Supported(Supported::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Timestamp") => {
                    Ok(Header::Timestamp(Timestamp::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("To") => Ok(Header::To(To::new(tokenizer.value))),
                s if s.eq_ignore_ascii_case("Unsupported") => {
                    Ok(Header::Unsupported(Unsupported::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("User-Agent") => {
                    Ok(Header::UserAgent(UserAgent::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("Via") => Ok(Header::Via(Via::new(tokenizer.value))),
                s if s.eq_ignore_ascii_case("Warning") => {
                    Ok(Header::Warning(Warning::new(tokenizer.value)))
                }
                s if s.eq_ignore_ascii_case("WWW-Authenticate") => Ok(Header::WwwAuthenticate(
                    WwwAuthenticate::new(tokenizer.value),
                )),
                _ => Ok(Header::Other(tokenizer.name.into(), tokenizer.value.into())),
            }
        }
    }

    #[derive(Debug, PartialEq, Eq, Utf8Tokenizer)]
    pub struct Tokenizer<'a> {
        pub name: &'a [u8],
        pub value: &'a [u8],
    }

    impl<'a> Tokenizer<'a> {
        pub fn tokenize(part: &'a [u8]) -> IResult<Self> {
            use crate::NomError;
            use nom::{
                branch::alt,
                bytes::complete::{tag, take_until, take_while1},
                character::complete::space0,
                combinator::{map, rest},
                sequence::tuple,
            };

            let (rem, (name, _, _, value)) = tuple((
                take_while1(crate::parser_utils::is_token),
                tag(":"),
                space0,
                alt((
                    map(tuple((take_until("\r\n"), tag("\r\n"))), |(value, _)| value),
                    rest,
                )),
            ))(part)
            .map_err(|_: NomError<'a>| TokenizerError::from(("header", part)).into())?;

            Ok((rem, (name, value).into()))
        }
    }

    impl<'a> std::convert::From<(&'a [u8], &'a [u8])> for Tokenizer<'a> {
        fn from(tuple: (&'a [u8], &'a [u8])) -> Self {
            Self {
                name: tuple.0,
                value: tuple.1,
            }
        }
    }
}