bump version to 0.2.72 and enhance URI extraction logic in contact headers

Author: shenjinti

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsipstack"
-version = "0.2.71"
+version = "0.2.72"
 edition = "2021"
 description = "SIP Stack Rust library for building SIP applications"
 license = "MIT"
@@ -39,6 +39,7 @@ webpki-roots = { version = "1.0.2", optional = true }
 rustls = "0.23.31"
 clap = { version = "4.5.47", features = ["derive"] }
 http = "1.3.1"
+nom = "7.1.3"
 
 [features]
 default = ["rustls", "websocket"]

src/rsip_ext.rs

@@ -74,15 +74,45 @@ macro_rules! header_pop {
 }
 
 pub fn extract_uri_from_contact(line: &str) -> Result<rsip::Uri> {
-    if let Ok(mut uri) = rsip::headers::Contact::from(line).uri() {
-        uri.params
-            .retain(|p| matches!(p, rsip::Param::Transport(_)));
+    if let Ok(uri) = rsip::headers::Contact::from(line).uri() {
         return Ok(uri);
     }
 
-    match line.split('<').nth(1).and_then(|s| s.split('>').next()) {
-        Some(uri) => rsip::Uri::try_from(uri).map_err(Into::into),
-        None => Err(Error::Error("no uri found".to_string())),
+    let tokenizer = CustomContactTokenizer::from_str(line)?;
+    let mut uri = rsip::Uri::try_from(tokenizer.uri()).map_err(Error::from)?;
+    uri.params.retain(|p| {
+        if let rsip::Param::Transport(rsip::Transport::Udp) = p {
+            false
+        } else {
+            true
+        }
+    });
+    apply_tokenizer_params(&mut uri, &tokenizer);
+    return Ok(uri);
+}
+
+fn apply_tokenizer_params(uri: &mut rsip::Uri, tokenizer: &CustomContactTokenizer) {
+    for (name, value) in tokenizer.params.iter().map(|p| (p.name, p.value)) {
+        if name.eq_ignore_ascii_case("transport") {
+            continue;
+        }
+        let mut updated = false;
+        for param in uri.params.iter_mut() {
+            if let rsip::Param::Other(key, existing_value) = param {
+                if key.value().eq_ignore_ascii_case(name) {
+                    *existing_value =
+                        value.map(|v| rsip::param::OtherParamValue::new(v.to_string()));
+                    updated = true;
+                    break;
+                }
+            }
+        }
+        if !updated {
+            uri.params.push(rsip::Param::Other(
+                rsip::param::OtherParam::new(name),
+                value.map(|v| rsip::param::OtherParamValue::new(v.to_string())),
+            ));
+        }
     }
 }
 
@@ -104,6 +134,114 @@ pub fn destination_from_request(request: &rsip::Request) -> Option<SipAddr> {
         .or_else(|| SipAddr::try_from(&request.uri).ok())
 }
 
+use nom::{
+    branch::alt,
+    bytes::complete::{is_not, take_until},
+    character::complete::{char, multispace0},
+    combinator::{map, opt, rest},
+    multi::separated_list0,
+    sequence::{delimited, preceded},
+    IResult,
+};
+
+#[derive(Debug)]
+pub(crate) struct CustomContactTokenizer<'a> {
+    uri: &'a str,
+    params: Vec<CustomContactParamToken<'a>>,
+}
+
+#[derive(Debug)]
+struct CustomContactParamToken<'a> {
+    name: &'a str,
+    value: Option<&'a str>,
+}
+
+impl<'a> CustomContactTokenizer<'a> {
+    pub(crate) fn from_str(input: &'a str) -> super::Result<Self> {
+        let trimmed = input.trim();
+        if trimmed.is_empty() {
+            return Err(Error::Error("empty contact header".into()));
+        }
+
+        match custom_contact_tokenize(trimmed) {
+            Ok((_rem, tokenizer)) => Ok(tokenizer),
+            Err(_) => Ok(Self::from_plain(trimmed)),
+        }
+    }
+
+    fn from_plain(uri: &'a str) -> Self {
+        Self {
+            uri,
+            params: custom_contact_parse_params(uri),
+        }
+    }
+
+    pub(crate) fn uri(&self) -> &'a str {
+        self.uri
+    }
+}
+
+fn custom_contact_tokenize<'a>(input: &'a str) -> IResult<&'a str, CustomContactTokenizer<'a>> {
+    alt((
+        custom_contact_with_brackets,
+        custom_contact_without_brackets,
+    ))(input)
+}
+
+fn custom_contact_with_brackets<'a>(
+    input: &'a str,
+) -> IResult<&'a str, CustomContactTokenizer<'a>> {
+    let (input, _) = multispace0(input)?;
+    let (input, _) = opt(take_until("<"))(input)?;
+    let (input, _) = char('<')(input)?;
+    let (input, uri) = take_until(">")(input)?;
+    let (input, _) = char('>')(input)?;
+
+    let uri = uri.trim();
+    let params = custom_contact_parse_params(uri);
+
+    Ok((input, CustomContactTokenizer { uri, params }))
+}
+
+fn custom_contact_without_brackets<'a>(
+    input: &'a str,
+) -> IResult<&'a str, CustomContactTokenizer<'a>> {
+    let (input, uri) = map(rest, |s: &str| s.trim())(input)?;
+    let params = custom_contact_parse_params(uri);
+    Ok((input, CustomContactTokenizer { uri, params }))
+}
+
+fn custom_contact_parse_params<'a>(uri: &'a str) -> Vec<CustomContactParamToken<'a>> {
+    let path = uri.split_once('?').map_or(uri, |(path, _)| path);
+    if let Some(idx) = path.find(';') {
+        let params_str = &path[idx + 1..];
+        if params_str.is_empty() {
+            return Vec::new();
+        }
+
+        match separated_list0(char(';'), custom_contact_param)(params_str) {
+            Ok((_, params)) => params.into_iter().filter(|p| !p.name.is_empty()).collect(),
+            Err(_) => Vec::new(),
+        }
+    } else {
+        Vec::new()
+    }
+}
+
+fn custom_contact_param<'a>(input: &'a str) -> IResult<&'a str, CustomContactParamToken<'a>> {
+    let (input, _) = multispace0(input)?;
+    let (input, name) = map(is_not("=; \t\r\n?"), |v: &str| v.trim())(input)?;
+    let (input, value) = opt(preceded(
+        char('='),
+        alt((
+            delimited(char('"'), take_until("\""), char('"')),
+            map(is_not("; \t\r\n?"), |v: &str| v.trim()),
+        )),
+    ))(input)?;
+
+    Ok((input, CustomContactParamToken { name, value }))
+}
+
 #[test]
 fn test_rsip_headers_ext() {
     use rsip::{Header, Headers};

src/transaction/tests/mod.rs

@@ -42,15 +42,22 @@ mod tests {
 
     #[test]
     fn test_linphone_contact() {
+        let line = "sip:bob@localhost;transport=udp";
+        let contact_uri = extract_uri_from_contact(line).expect("failed to parse contact");
+        assert_eq!(contact_uri.to_string(), "sip:bob@localhost");
+
         let line = "<sip:bob@localhost;transport=udp>;expires=3600;+org.linphone.specs=\"lime\"";
         let contact_uri = extract_uri_from_contact(line).expect("failed to parse contact");
-        assert_eq!(contact_uri.to_string(), "sip:bob@localhost;transport=UDP");
+        assert_eq!(contact_uri.to_string(), "sip:bob@localhost");
 
         let line = "<sip:bob@restsend.com;transport=udp>;message-expires=2419200;+sip.instance=\"<urn:uuid:12345-81fa-4fe3-aa6c-17bffdbcf619>\"";
         let contact_uri = extract_uri_from_contact(line).expect("failed to parse contact");
+        assert_eq!(contact_uri.to_string(), "sip:bob@restsend.com");
+        let line = "<sip:linphone@domain.com;gr=urn:uuid:c8651907-f0b2-0027-bdbd-ce4ed05c9ef4>;+org.linphone.specs=\"ephemeral/1.1,groupchat/1.1,lime\"";
+        let contact_uri = extract_uri_from_contact(line).expect("failed to parse contact");
         assert_eq!(
             contact_uri.to_string(),
-            "sip:bob@restsend.com;transport=UDP"
+            "sip:linphone@domain.com;gr=urn:uuid:c8651907-f0b2-0027-bdbd-ce4ed05c9ef4"
         );
     }
 }