bump version to 0.2.73 and refactor dialog handling by removing unused destination extraction logic

Author: shenjinti

Cargo.toml

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

src/dialog/client_dialog.rs

@@ -12,7 +12,6 @@ use crate::{
 };
 use rsip::prelude::HasHeaders;
 use rsip::{
-    headers::Route,
     prelude::{HeadersExt, ToTypedHeader, UntypedHeader},
     Header,
 };
@@ -563,17 +562,6 @@ impl ClientInviteDialog {
                                 uri
                             };
                             *self.inner.remote_uri.lock().unwrap() = uri;
-
-                            // update route set from Record-Route header
-                            let mut route_set = Vec::new();
-                            for header in resp.headers.iter() {
-                                if let Header::RecordRoute(record_route) = header {
-                                    route_set.push(Route::from(record_route.value()));
-                                }
-                            }
-                            route_set.reverse();
-                            *self.inner.route_set.lock().unwrap() = route_set;
-
                             self.inner
                                 .transition(DialogState::Confirmed(dialog_id.clone(), resp))?;
                             DialogInner::serve_keepalive_options(self.inner.clone());

src/dialog/dialog.rs

@@ -5,7 +5,7 @@ use super::{
     DialogId,
 };
 use crate::{
-    rsip_ext::{destination_from_request, extract_uri_from_contact},
+    rsip_ext::extract_uri_from_contact,
     transaction::{
         endpoint::EndpointInnerRef,
         key::{TransactionKey, TransactionRole},
@@ -239,6 +239,7 @@ impl DialogInner {
                 route_set.push(Route::from(rr.value()));
             }
         }
+        route_set.reverse();
 
         Ok(Self {
             role,
@@ -472,8 +473,40 @@ impl DialogInner {
 
     pub(super) async fn do_request(&self, request: Request) -> Result<Option<rsip::Response>> {
         let method = request.method().to_owned();
-        let destination =
-            destination_from_request(&request).or_else(|| self.initial_destination.clone());
+        // request destination determination
+        // Route header first, then remote contact, then initial request destination
+        let mut destination = None;
+        for h in request.headers.iter() {
+            if let Header::Route(route) = h {
+                let dest = route
+                    .typed()
+                    .ok()
+                    .map(|r| {
+                        r.uris()
+                            .first()
+                            .map(|u| SipAddr::try_from(&u.uri).ok())
+                            .flatten()
+                    })
+                    .flatten();
+                if dest.is_some() {
+                    destination = dest;
+                    break;
+                }
+            }
+        }
+
+        if destination.is_none() {
+            destination = self
+                .remote_contact
+                .lock()
+                .unwrap()
+                .as_ref()
+                .map(|c| extract_uri_from_contact(c.value()).ok())
+                .flatten()
+                .map(|u| SipAddr::try_from(&u).ok())
+                .flatten()
+                .or_else(|| self.initial_destination.clone());
+        }
 
         let key = TransactionKey::from_request(&request, TransactionRole::Client)?;
         let mut tx = Transaction::new_client(key, request, self.endpoint_inner.clone(), None);
@@ -682,6 +715,7 @@ impl Dialog {
             Dialog::ClientInvite(d) => d.inner.to.lock().unwrap().clone(),
         }
     }
+
     pub fn remote_contact(&self) -> Option<rsip::Uri> {
         match self {
             Dialog::ServerInvite(d) => d
@@ -690,15 +724,15 @@ impl Dialog {
                 .lock()
                 .unwrap()
                 .as_ref()
-                .map(|c| c.uri().ok())
+                .map(|c| extract_uri_from_contact(c.value()).ok())
                 .flatten(),
             Dialog::ClientInvite(d) => d
                 .inner
                 .remote_contact
                 .lock()
                 .unwrap()
                 .as_ref()
-                .map(|c| c.uri().ok())
+                .map(|c| extract_uri_from_contact(c.value()).ok())
                 .flatten(),
         }
     }

src/dialog/dialog_layer.rs

@@ -149,7 +149,7 @@ impl DialogLayer {
         tx: &Transaction,
         state_sender: DialogStateSender,
         credential: Option<Credential>,
-        contact: Option<rsip::Uri>,
+        local_contact: Option<rsip::Uri>,
     ) -> Result<ServerInviteDialog> {
         let mut id = DialogId::try_from(&tx.original)?;
         if !id.to_tag.is_empty() {
@@ -174,7 +174,7 @@ impl DialogLayer {
             self.endpoint.clone(),
             state_sender,
             credential,
-            contact,
+            local_contact,
             tx.tu_sender.clone(),
         )?;
 
@@ -186,7 +186,7 @@ impl DialogLayer {
             .write()
             .unwrap()
             .insert(id.clone(), Dialog::ServerInvite(dialog.clone()));
-        info!("server invite dialog created: {id}");
+        info!(%id, "server invite dialog created");
         Ok(dialog)
     }
 

src/dialog/server_dialog.rs

@@ -680,17 +680,6 @@ impl ServerInviteDialog {
                                 break;
                             }
                             info!(id = %self.id(),"received ack {}", req.uri);
-                            match req.contact_header() {
-                                Ok(contact) => {
-                                    self.inner
-                                        .remote_contact
-                                        .lock()
-                                        .unwrap()
-                                        .replace(contact.clone());
-                                }
-                                _ => {}
-                            }
-
                             self.inner.transition(DialogState::Confirmed(
                                 self.id(),
                                 tx.last_response.clone().unwrap_or_default(),

src/dialog/tests/test_client_dialog.rs

@@ -7,7 +7,6 @@ use crate::dialog::{
     dialog::{DialogInner, DialogState, TerminatedReason},
     DialogId,
 };
-use crate::rsip_ext::destination_from_request;
 use crate::transaction::{endpoint::EndpointBuilder, key::TransactionRole};
 use crate::transport::{SipAddr, TransportLayer};
 use rsip::{headers::*, Request, Response, StatusCode, Uri};
@@ -356,15 +355,5 @@ async fn test_make_request_preserves_remote_target_and_route_order() -> crate::R
         ],
         "Route headers must match the stored route set order"
     );
-
-    let destination = destination_from_request(&request)
-        .expect("route-enabled request should resolve to a destination");
-    let expected_destination =
-        SipAddr::try_from(&Uri::try_from("sip:proxy2.example.com:5070;transport=tcp")?)?;
-    assert_eq!(
-        destination, expected_destination,
-        "First Route entry must determine the transport destination"
-    );
-
     Ok(())
 }

src/rsip_ext.rs

@@ -1,4 +1,4 @@
-use crate::transport::{SipAddr, SipConnection};
+use crate::transport::SipConnection;
 use crate::{Error, Result};
 use rsip::{
     message::HasHeaders,
@@ -116,24 +116,6 @@ fn apply_tokenizer_params(uri: &mut rsip::Uri, tokenizer: &CustomContactTokenize
     }
 }
 
-pub fn destination_from_request(request: &rsip::Request) -> Option<SipAddr> {
-    request
-        .headers
-        .iter()
-        .find_map(|header| match header {
-            rsip::Header::Route(route) => {
-                let uri_str = route.value().to_string();
-                let trimmed = uri_str.trim();
-                let without_brackets = trimmed.trim_matches(['<', '>']);
-                rsip::Uri::try_from(without_brackets)
-                    .ok()
-                    .and_then(|uri| SipAddr::try_from(&uri).ok())
-            }
-            _ => None,
-        })
-        .or_else(|| SipAddr::try_from(&request.uri).ok())
-}
-
 use nom::{
     branch::alt,
     bytes::complete::{is_not, take_until},

src/transaction/transaction.rs

@@ -2,7 +2,6 @@ use super::endpoint::EndpointInnerRef;
 use super::key::TransactionKey;
 use super::{SipConnection, TransactionState, TransactionTimer, TransactionType};
 use crate::dialog::DialogId;
-use crate::rsip_ext::destination_from_request;
 use crate::transaction::make_tag;
 use crate::transport::SipAddr;
 use crate::{Error, Result};
@@ -454,11 +453,6 @@ impl Transaction {
         } else {
             ack.to_owned().into()
         };
-        if let SipMessage::Request(ref req) = ack {
-            if let Some(destination) = destination_from_request(req) {
-                self.destination = Some(destination);
-            }
-        }
         match ack.clone() {
             SipMessage::Request(ack) => self.last_ack.replace(ack),
             _ => None,