feat(dialog): get via from orignal request

Author: shenjinti

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsipstack"
-version = "0.2.35"
+version = "0.2.36"
 edition = "2021"
 description = "SIP Stack Rust library for building SIP applications"
 license = "MIT"

src/dialog/dialog.rs

@@ -10,14 +10,15 @@ use crate::{
     transaction::{
         endpoint::EndpointInnerRef,
         key::{TransactionKey, TransactionRole},
+        make_via_branch,
         transaction::{Transaction, TransactionEventSender},
     },
     Result,
 };
 use rsip::{
     headers::Route,
     prelude::{HeadersExt, ToTypedHeader, UntypedHeader},
-    typed::{CSeq, Contact},
+    typed::{CSeq, Contact, Via},
     Header, Param, Request, Response, SipMessage, StatusCode,
 };
 use std::sync::{
@@ -289,12 +290,31 @@ impl DialogInner {
         Ok(())
     }
 
-    pub(super) fn make_request(
+    pub(super) fn build_vias_from_request(&self) -> Result<Vec<Via>> {
+        let mut vias = vec![];
+        for header in self.initial_request.headers.iter() {
+            if let Header::Via(via) = header {
+                if let Ok(mut typed_via) = via.typed() {
+                    for param in typed_via.params.iter_mut() {
+                        if let Param::Branch(_) = param {
+                            *param = make_via_branch();
+                        }
+                    }
+                    vias.push(typed_via);
+                    return Ok(vias);
+                }
+            }
+        }
+        let via = self.endpoint_inner.get_via(None, None)?;
+        vias.push(via);
+        Ok(vias)
+    }
+
+    pub(super) fn make_request_with_vias(
         &self,
         method: rsip::Method,
         cseq: Option<u32>,
-        addr: Option<crate::transport::SipAddr>,
-        branch: Option<Param>,
+        vias: Vec<rsip::headers::typed::Via>,
         headers: Option<Vec<rsip::Header>>,
         body: Option<Vec<u8>>,
     ) -> Result<rsip::Request> {
@@ -304,8 +324,9 @@ impl DialogInner {
             method,
         };
 
-        let via = self.endpoint_inner.get_via(addr, branch)?;
-        headers.push(via.into());
+        for via in vias {
+            headers.push(Header::Via(via.into()));
+        }
         headers.push(Header::CallId(
             self.id.lock().unwrap().call_id.clone().into(),
         ));
@@ -339,6 +360,19 @@ impl DialogInner {
         Ok(req)
     }
 
+    pub(super) fn make_request(
+        &self,
+        method: rsip::Method,
+        cseq: Option<u32>,
+        addr: Option<crate::transport::SipAddr>,
+        branch: Option<Param>,
+        headers: Option<Vec<rsip::Header>>,
+        body: Option<Vec<u8>>,
+    ) -> Result<rsip::Request> {
+        let via = self.endpoint_inner.get_via(addr, branch)?;
+        self.make_request_with_vias(method, cseq, vec![via], headers, body)
+    }
+
     pub(super) fn make_response(
         &self,
         request: &Request,

src/dialog/server_dialog.rs

@@ -331,9 +331,14 @@ impl ServerInviteDialog {
             return Ok(());
         }
         info!(id=%self.id(), "sending bye request");
-        let request = self
-            .inner
-            .make_request(rsip::Method::Bye, None, None, None, None, None)?;
+
+        let request = self.inner.make_request_with_vias(
+            rsip::Method::Bye,
+            None,
+            self.inner.build_vias_from_request()?,
+            None,
+            None,
+        )?;
 
         match self.inner.do_request(request).await {
             Ok(_) => {}
@@ -383,9 +388,13 @@ impl ServerInviteDialog {
             return Ok(None);
         }
         info!(id=%self.id(), "sending re-invite request, body: \n{:?}", body);
-        let request =
-            self.inner
-                .make_request(rsip::Method::Invite, None, None, None, headers, body)?;
+        let request = self.inner.make_request_with_vias(
+            rsip::Method::Invite,
+            None,
+            self.inner.build_vias_from_request()?,
+            headers,
+            body,
+        )?;
         let resp = self.inner.do_request(request.clone()).await;
         match resp {
             Ok(Some(ref resp)) => {
@@ -436,9 +445,13 @@ impl ServerInviteDialog {
             return Ok(None);
         }
         info!(id=%self.id(), "sending update request, body: \n{:?}", body);
-        let request =
-            self.inner
-                .make_request(rsip::Method::Update, None, None, None, headers, body)?;
+        let request = self.inner.make_request_with_vias(
+            rsip::Method::Update,
+            None,
+            self.inner.build_vias_from_request()?,
+            headers,
+            body,
+        )?;
         self.inner.do_request(request.clone()).await
     }
 
@@ -483,9 +496,13 @@ impl ServerInviteDialog {
             return Ok(None);
         }
         info!(id=%self.id(), "sending info request, body: \n{:?}", body);
-        let request =
-            self.inner
-                .make_request(rsip::Method::Info, None, None, None, headers, body)?;
+        let request = self.inner.make_request_with_vias(
+            rsip::Method::Info,
+            None,
+            self.inner.build_vias_from_request()?,
+            headers,
+            body,
+        )?;
         self.inner.do_request(request.clone()).await
     }
 
@@ -608,7 +625,7 @@ impl ServerInviteDialog {
 
     async fn handle_invite(&mut self, tx: &mut Transaction) -> Result<()> {
         let handle_loop = async {
-            if !self.inner.is_confirmed() {
+            if !self.inner.is_confirmed() && matches!(tx.original.method, rsip::Method::Invite) {
                 match self.inner.transition(DialogState::Calling(self.id())) {
                     Ok(_) => {
                         tx.send_trying().await.ok();

src/dialog/tests/mod.rs

@@ -1,3 +1,4 @@
 mod test_client_dialog;
 mod test_dialog_layer;
 mod test_dialog_states;
+mod test_server_dialog;

src/dialog/tests/test_dialog_states.rs

@@ -14,12 +14,13 @@ use tokio::sync::mpsc::unbounded_channel;
 use tokio_util::sync::CancellationToken;
 
 /// Test helper to create a mock INVITE request
-fn create_invite_request(from_tag: &str, to_tag: &str, call_id: &str) -> Request {
+pub(super) fn create_invite_request(from_tag: &str, to_tag: &str, call_id: &str) -> Request {
     Request {
         method: rsip::Method::Invite,
         uri: rsip::Uri::try_from("sip:[email protected]:5060").unwrap(),
         headers: vec![
-            Via::new("SIP/2.0/UDP alice.example.com:5060;branch=z9hG4bKnashds").into(),
+            Via::new("SIP/2.0/UDP alice.example.com:5060;branch=z9hG4bKnashds;received=172.0.0.1")
+                .into(),
             CSeq::new("1 INVITE").into(),
             From::new(&format!("Alice <sip:[email protected]>;tag={}", from_tag)).into(),
             To::new(&format!("Bob <sip:[email protected]>;tag={}", to_tag)).into(),
@@ -57,7 +58,8 @@ fn create_response(status: StatusCode, from_tag: &str, to_tag: &str, call_id: &s
     }
 }
 
-async fn create_test_endpoint() -> crate::Result<crate::transaction::endpoint::Endpoint> {
+pub(super) async fn create_test_endpoint() -> crate::Result<crate::transaction::endpoint::Endpoint>
+{
     let token = CancellationToken::new();
     let tl = TransportLayer::new(token.child_token());
     let endpoint = EndpointBuilder::new()

src/dialog/tests/test_server_dialog.rs

@@ -0,0 +1,69 @@
+use rsip::prelude::{HeadersExt, ToTypedHeader};
+use tokio::sync::mpsc::unbounded_channel;
+
+use crate::{
+    dialog::{
+        dialog::DialogInner,
+        tests::test_dialog_states::{create_invite_request, create_test_endpoint},
+        DialogId,
+    },
+    transaction::key::TransactionRole,
+};
+
+#[tokio::test]
+async fn test_dialog_make_request() -> crate::Result<()> {
+    // Create dialog ID
+    let dialog_id = DialogId {
+        call_id: "test-call-id-123".to_string(),
+        from_tag: "alice-tag-456".to_string(),
+        to_tag: "bob-tag-789".to_string(),
+    };
+
+    let endpoint = create_test_endpoint().await?;
+    let (tu_sender, _tu_receiver) = unbounded_channel();
+    let (state_sender, _state_receiver) = unbounded_channel();
+    // Create INVITE request
+    let invite_req = create_invite_request("alice-tag-456", "", "test-call-id-123");
+    // Create dialog inner
+    let dialog_inner = DialogInner::new(
+        TransactionRole::Client,
+        dialog_id.clone(),
+        invite_req.clone(),
+        endpoint.inner.clone(),
+        state_sender,
+        None,
+        Some(rsip::Uri::try_from("sip:[email protected]:5060")?),
+        tu_sender,
+    )
+    .expect("Failed to create dialog inner");
+
+    let bye = dialog_inner
+        .make_request_with_vias(
+            rsip::Method::Bye,
+            None,
+            dialog_inner
+                .build_vias_from_request()
+                .expect("Failed to build vias"),
+            None,
+            None,
+        )
+        .expect("Failed to make request");
+    assert_eq!(bye.method, rsip::Method::Bye);
+
+    assert_eq!(
+        bye.via_header()
+            .expect("not via header")
+            .typed()?
+            .received()?,
+        "172.0.0.1".parse().ok()
+    );
+    assert!(
+        bye.via_header().expect("not via header").typed()?.branch()
+            != invite_req
+                .via_header()
+                .expect("not via header")
+                .typed()?
+                .branch()
+    );
+    Ok(())
+}