chore: update version to 0.5.6 and add memchr usage in parser and stream modules

Author: shenjinti

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsipstack"
-version = "0.5.5"
+version = "0.5.6"
 edition = "2021"
 description = "SIP Stack Rust library for building SIP applications"
 license = "MIT"
@@ -34,6 +34,7 @@ hickory-resolver = { version = "0.25.2", features = [
     "tokio",
 ], optional = true }
 bytes = "1.11.1"
+memchr = "2"
 futures-util = "0.3.32"
 parking_lot = "0.12"
 dashmap = "6"
@@ -59,6 +60,7 @@ tokio = { version = "1.50.0", features = ["time", "sync", "macros", "io-util"] }
 tokio = { version = "1.50.0", features = ["full"] }
 
 [dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }
 dotenv = "0.15"
 tempfile = "3"
 sdp-rs = "0.2.1"

src/sip/headers/typed/parse_helpers.rs

@@ -2,6 +2,7 @@ use crate::sip::{
     uri::{parse_params, parse_uri, Param, Uri},
     Error,
 };
+use memchr::memchr;
 pub fn parse_display_uri_params_str(s: &str) -> Result<(Option<String>, Uri, Vec<Param>), Error> {
     let s = s.trim();
     if let Some(lt) = s.find('<') {
@@ -23,24 +24,28 @@ pub fn parse_display_uri_params_str(s: &str) -> Result<(Option<String>, Uri, Vec
     }
 
     let mut uri_end = None;
+    let bytes = s.as_bytes();
+    // Pre-locate '@' once with memchr; used below to decide whether a ':'
+    // introduces a scheme/port or just a userinfo separator.
+    let at_pos = memchr(b'@', bytes);
     let mut in_userinfo = false;
-    let mut chars = s.char_indices().peekable();
 
-    while let Some((i, c)) = chars.next() {
-        match c {
-            '@' if in_userinfo => {
+    for (i, &b) in bytes.iter().enumerate() {
+        match b {
+            b'@' => {
                 in_userinfo = false;
             }
-            ':' if !in_userinfo => {
-                if i > 0 && !s[..i].contains('@') {
+            b':' if !in_userinfo => {
+                // A ':' before the '@' (or when there is no '@') means we are
+                // in the userinfo section (scheme colon is already consumed by
+                // the caller via parse_uri, so here it signals user:password).
+                if at_pos.map_or(false, |at| i < at) {
                     in_userinfo = true;
                 }
             }
-            ';' => {
-                if !in_userinfo {
-                    uri_end = Some(i);
-                    break;
-                }
+            b';' if !in_userinfo => {
+                uri_end = Some(i);
+                break;
             }
             _ => {}
         }
@@ -116,4 +121,68 @@ mod tests {
         assert_eq!(result.2.len(), 1);
         assert!(matches!(&result.2[0], Param::Tag(t) if t.value() == "12345"));
     }
+
+    // ── 无括号、有端口、无 @ ──────────────────────────────────────────────────
+
+    #[test]
+    fn test_no_userinfo_with_port_and_params() {
+        // sip:host:5060;transport=tcp — ':' before ';' but no '@', so
+        // in_userinfo must remain false and ';' triggers uri_end.
+        let result =
+            parse_display_uri_params_str("sip:example.com:5060;transport=tcp").unwrap();
+        assert_eq!(result.1.host_with_port.to_string(), "example.com:5060");
+        assert_eq!(result.2.len(), 1);
+    }
+
+    // ── 无括号、user:password@host ────────────────────────────────────────────
+
+    #[test]
+    fn test_userinfo_password_no_brackets() {
+        let result =
+            parse_display_uri_params_str("sip:alice:secret@example.com;tag=abc").unwrap();
+        let auth = result.1.auth.unwrap();
+        assert_eq!(auth.user, "alice");
+        assert_eq!(auth.password, Some("secret".into()));
+        assert_eq!(result.2.len(), 1);
+    }
+
+    // ── 无括号、纯 host（无 scheme、无 @、无 ';'） ────────────────────────────
+
+    #[test]
+    fn test_no_brackets_no_params_host_only() {
+        let result = parse_display_uri_params_str("sip:example.com").unwrap();
+        assert!(result.1.auth.is_none());
+        assert_eq!(result.1.host_with_port.to_string(), "example.com");
+        assert!(result.2.is_empty());
+    }
+
+    // ── 有括号、display name 含引号 ──────────────────────────────────────────
+
+    #[test]
+    fn test_display_name_with_quotes() {
+        let result =
+            parse_display_uri_params_str("\"Alice Smith\" <sip:alice@example.com>").unwrap();
+        assert_eq!(result.0, Some("Alice Smith".to_string()));
+        assert_eq!(result.1.to_string(), "sip:alice@example.com");
+        assert!(result.2.is_empty());
+    }
+
+    // ── 有括号、display name 为空 ────────────────────────────────────────────
+
+    #[test]
+    fn test_empty_display_name_with_brackets() {
+        let result = parse_display_uri_params_str("<sip:alice@example.com>;tag=xyz").unwrap();
+        assert!(result.0.is_none());
+        assert_eq!(result.2.len(), 1);
+    }
+
+    // ── 多 ';' param（无括号） ────────────────────────────────────────────────
+
+    #[test]
+    fn test_no_brackets_multiple_params_with_at() {
+        let result =
+            parse_display_uri_params_str("sip:bob@example.com;tag=1;expires=60;lr").unwrap();
+        assert_eq!(result.1.auth.as_ref().unwrap().user, "bob");
+        assert_eq!(result.2.len(), 3);
+    }
 }

src/sip/parser.rs

@@ -4,6 +4,7 @@ use crate::sip::{
     uri::parse_uri,
     Error, Method, StatusCode, Uri, Version,
 };
+use memchr::{memchr, memmem};
 pub fn parse_message(data: &[u8]) -> Result<SipMessage, Error> {
     let sep = find_double_crlf(data)
         .ok_or_else(|| Error::ParseError("SIP message: missing \\r\\n\\r\\n separator".into()))?;
@@ -123,8 +124,7 @@ fn parse_response_line(line: &str, headers: Headers, body: Vec<u8>) -> Result<Si
 }
 
 fn find_double_crlf(data: &[u8]) -> Option<usize> {
-    let needle = b"\r\n\r\n";
-    data.windows(4).position(|w| w == needle)
+    memmem::find(data, b"\r\n\r\n")
 }
 
 fn split_crlf_lines(data: &[u8]) -> impl Iterator<Item = &str> {
@@ -146,8 +146,14 @@ impl<'a> Iterator for SplitCrLf<'a> {
         let start = self.pos;
         let rest = &self.data[start..];
 
-        let (end, next_pos) = if let Some(p) = rest.windows(2).position(|w| w == b"\r\n") {
-            (start + p, start + p + 2)
+        // Find '\n' with memchr, then check the preceding '\r'.
+        let (end, next_pos) = if let Some(lf) = memchr(b'\n', rest) {
+            let line_end = if lf > 0 && rest[lf - 1] == b'\r' {
+                start + lf - 1
+            } else {
+                start + lf
+            };
+            (line_end, start + lf + 1)
         } else {
             (self.data.len(), self.data.len())
         };

src/transport/stream.rs

@@ -7,6 +7,7 @@ use crate::{
     Result,
 };
 use bytes::{Buf, BytesMut};
+use memchr::{memchr, memmem};
 use tokio::{
     io::{AsyncRead, AsyncWrite, AsyncWriteExt},
     sync::Mutex,
@@ -64,25 +65,24 @@ impl Decoder for SipCodec {
             return Ok(Some(SipCodecType::KeepaliveResponse));
         }
 
-        if let Some(headers_end) = src.windows(4).position(|w| w == b"\r\n\r\n") {
+        if let Some(headers_end) = memmem::find(src, b"\r\n\r\n") {
             let headers = &src[..headers_end + 4]; // include CRLFCRLF
 
             // Parse Content-Length as u32 without UTF-8 conversion
             let mut content_length: usize = 0;
             let mut start = 0;
             while start < headers.len() {
-                // find end of line
-                let mut end = start;
-                while end < headers.len() && headers[end] != b'\n' {
-                    end += 1;
-                }
+                // find end of line with memchr
+                let end = memchr(b'\n', &headers[start..])
+                    .map(|p| start + p)
+                    .unwrap_or(headers.len());
 
                 let mut line = &headers[start..end];
                 if let Some(&b'\r') = line.last() {
                     line = &line[..line.len().saturating_sub(1)];
                 }
 
-                if let Some(colon) = line.iter().position(|&b| b == b':') {
+                if let Some(colon) = memchr(b':', line) {
                     let header = &line[..colon];
                     let is_cl = if header.len() == CL_FULL_NAME.len()
                         && header
@@ -284,3 +284,178 @@ where
     lock.flush().await?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::transport::connection::{KEEPALIVE_REQUEST, KEEPALIVE_RESPONSE};
+    use bytes::BytesMut;
+    use tokio_util::codec::Decoder;
+
+    fn make_codec() -> SipCodec {
+        SipCodec::new()
+    }
+
+    // Minimal valid INVITE with the given body.
+    fn invite_bytes(body: &str) -> Vec<u8> {
+        let msg = format!(
+            concat!(
+                "INVITE sip:bob@biloxi.com SIP/2.0\r\n",
+                "Via: SIP/2.0/UDP pc33.atlanta.com;branch=z9hG4bK776\r\n",
+                "To: Bob <sip:bob@biloxi.com>\r\n",
+                "From: Alice <sip:alice@atlanta.com>;tag=123\r\n",
+                "Call-ID: abc@test\r\n",
+                "CSeq: 1 INVITE\r\n",
+                "Content-Type: application/sdp\r\n",
+                "Content-Length: {}\r\n",
+                "\r\n",
+                "{}"
+            ),
+            body.len(),
+            body
+        );
+        msg.into_bytes()
+    }
+
+    fn register_bytes() -> Vec<u8> {
+        concat!(
+            "REGISTER sip:registrar.example.com SIP/2.0\r\n",
+            "Via: SIP/2.0/UDP bob:5060;branch=z9hG4bKnashds8\r\n",
+            "To: Bob <sip:bob@example.com>\r\n",
+            "From: Bob <sip:bob@example.com>;tag=456\r\n",
+            "Call-ID: 843817637@998sdasdh09\r\n",
+            "CSeq: 1 REGISTER\r\n",
+            "Content-Length: 0\r\n",
+            "\r\n",
+        )
+        .as_bytes()
+        .to_vec()
+    }
+
+    // ── 基本解码 ──────────────────────────────────────────────────────────────
+
+    #[test]
+    fn decode_complete_message_no_body() {
+        let mut codec = make_codec();
+        let mut buf = BytesMut::from(register_bytes().as_slice());
+        let result = codec.decode(&mut buf).unwrap();
+        assert!(matches!(result, Some(SipCodecType::Message(_))));
+        assert_eq!(buf.len(), 0, "buffer should be fully consumed");
+    }
+
+    #[test]
+    fn decode_complete_message_with_body() {
+        let body = "v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\n";
+        let mut codec = make_codec();
+        let mut buf = BytesMut::from(invite_bytes(body).as_slice());
+        let result = codec.decode(&mut buf).unwrap();
+        assert!(matches!(result, Some(SipCodecType::Message(_))));
+        assert_eq!(buf.len(), 0);
+    }
+
+    // ── 分包：header 尚未完整 ─────────────────────────────────────────────────
+
+    #[test]
+    fn decode_returns_none_when_headers_incomplete() {
+        let mut codec = make_codec();
+        let full = register_bytes();
+        // Feed only the first half of the message.
+        let half = &full[..full.len() / 2];
+        let mut buf = BytesMut::from(half);
+        let result = codec.decode(&mut buf).unwrap();
+        assert!(result.is_none(), "should wait for more data");
+        // Buffer must be untouched.
+        assert_eq!(buf.as_ref(), half);
+    }
+
+    // ── 分包：body 尚未完整 ───────────────────────────────────────────────────
+
+    #[test]
+    fn decode_returns_none_when_body_incomplete() {
+        let body = "v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\n";
+        let mut codec = make_codec();
+        let full = invite_bytes(body);
+        // Feed headers + CRLFCRLF but only half the body.
+        let headers_end = memmem::find(&full, b"\r\n\r\n").unwrap() + 4;
+        let partial_body = body.len() / 2;
+        let partial = &full[..headers_end + partial_body];
+        let mut buf = BytesMut::from(partial);
+        let result = codec.decode(&mut buf).unwrap();
+        assert!(result.is_none());
+        assert_eq!(buf.len(), partial.len());
+    }
+
+    // ── 粘包：两条消息连在一起 ────────────────────────────────────────────────
+
+    #[test]
+    fn decode_two_back_to_back_messages() {
+        let mut codec = make_codec();
+        let mut buf = BytesMut::new();
+        buf.extend_from_slice(&register_bytes());
+        buf.extend_from_slice(&register_bytes());
+
+        let first = codec.decode(&mut buf).unwrap();
+        assert!(matches!(first, Some(SipCodecType::Message(_))));
+
+        let second = codec.decode(&mut buf).unwrap();
+        assert!(matches!(second, Some(SipCodecType::Message(_))));
+
+        assert_eq!(buf.len(), 0);
+    }
+
+    // ── Content-Length 短格式 'l' ─────────────────────────────────────────────
+
+    #[test]
+    fn decode_short_content_length_header() {
+        let body = "hello";
+        let raw = format!(
+            concat!(
+                "INVITE sip:bob@example.com SIP/2.0\r\n",
+                "Via: SIP/2.0/UDP pc;branch=z9hG4bK1\r\n",
+                "To: <sip:bob@example.com>\r\n",
+                "From: <sip:alice@example.com>;tag=1\r\n",
+                "Call-ID: x@y\r\n",
+                "CSeq: 1 INVITE\r\n",
+                "l: {}\r\n",
+                "\r\n",
+                "{}"
+            ),
+            body.len(),
+            body
+        );
+        let mut codec = make_codec();
+        let mut buf = BytesMut::from(raw.as_bytes());
+        let result = codec.decode(&mut buf).unwrap();
+        assert!(matches!(result, Some(SipCodecType::Message(_))));
+    }
+
+    // ── Keepalive 帧 ──────────────────────────────────────────────────────────
+
+    #[test]
+    fn decode_keepalive_request() {
+        let mut codec = make_codec();
+        let mut buf = BytesMut::from(KEEPALIVE_REQUEST.as_ref());
+        let result = codec.decode(&mut buf).unwrap();
+        assert!(matches!(result, Some(SipCodecType::KeepaliveRequest)));
+        assert_eq!(buf.len(), 0);
+    }
+
+    #[test]
+    fn decode_keepalive_response() {
+        let mut codec = make_codec();
+        let mut buf = BytesMut::from(KEEPALIVE_RESPONSE.as_ref());
+        let result = codec.decode(&mut buf).unwrap();
+        assert!(matches!(result, Some(SipCodecType::KeepaliveResponse)));
+        assert_eq!(buf.len(), 0);
+    }
+
+    // ── 消息过大 ─────────────────────────────────────────────────────────────
+
+    #[test]
+    fn decode_rejects_oversized_buffer() {
+        let mut codec = make_codec();
+        let mut buf = BytesMut::from(vec![b'X'; MAX_SIP_MESSAGE_SIZE + 1].as_slice());
+        let result = codec.decode(&mut buf);
+        assert!(result.is_err());
+    }
+}