fix: update version to 0.2.82 and refactor dialog handling for clarity

Author: shenjinti

Cargo.toml

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

examples/proxy.rs

@@ -291,14 +291,12 @@ async fn process_incoming_request(
                 ack_tx.send().await?;
             }
             rsip::Method::Options => {
-                if tx.endpoint_inner.option.ignore_out_of_dialog_option {
-                    info!(
-                        "ignoring out of dialog OPTIONS request: {:?}",
-                        tx.original.method
-                    );
-                    continue;
-                }
-                tx.reply(rsip::StatusCode::NotAcceptable).await?;
+                info!(
+                    "ignoring out of dialog OPTIONS request: {:?}",
+                    tx.original.method
+                );
+                // do nothing for OPTIONS, may be a attack from scanner
+                // tx.reply(rsip::StatusCode::NotAcceptable).await?;
             }
             _ => {
                 tx.reply(rsip::StatusCode::NotAcceptable).await?;

src/dialog/client_dialog.rs

@@ -1,6 +1,5 @@
 use super::dialog::DialogInnerRef;
 use super::DialogId;
-use crate::dialog::dialog::DialogInner;
 use crate::dialog::{
     authenticate::handle_client_authenticate,
     dialog::{DialogState, TerminatedReason},
@@ -552,7 +551,6 @@ impl ClientInviteDialog {
                                 resp.remote_uri(tx.destination.as_ref())?;
                             self.inner
                                 .transition(DialogState::Confirmed(dialog_id.clone(), resp))?;
-                            DialogInner::serve_keepalive_options(self.inner.clone());
                         }
                         _ => {
                             self.inner.transition(DialogState::Terminated(

src/dialog/dialog.rs

@@ -19,16 +19,13 @@ use rsip::{
     headers::Route,
     prelude::{HeadersExt, ToTypedHeader, UntypedHeader},
     typed::{CSeq, Contact, Via},
-    Header, Param, Request, Response, SipMessage, StatusCode, StatusCodeKind,
+    Header, Param, Request, Response, SipMessage, StatusCode,
 };
 use std::sync::{
     atomic::{AtomicU32, Ordering},
     Arc, Mutex,
 };
-use tokio::{
-    sync::mpsc::{UnboundedReceiver, UnboundedSender},
-    time::interval,
-};
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, info, warn};
 
@@ -180,6 +177,7 @@ pub struct DialogInner {
 
     pub credential: Option<Credential>,
     pub route_set: Mutex<Vec<Route>>,
+
     pub(super) endpoint_inner: EndpointInnerRef,
     pub(super) state_sender: DialogStateSender,
     pub(super) tu_sender: TransactionEventSender,
@@ -587,61 +585,6 @@ impl DialogInner {
         *old_state = state;
         Ok(())
     }
-
-    pub(super) fn serve_keepalive_options(dlg_inner: Arc<Self>) {
-        let keepalive = match dlg_inner.endpoint_inner.option.dialog_keepalive_duration {
-            Some(k) => k,
-            None => return,
-        };
-        let token = dlg_inner.cancel_token.child_token();
-        let dlg_ref = dlg_inner.clone();
-
-        tokio::spawn(async move {
-            let mut ticker = interval(keepalive);
-            // skip first tick, which will be reached immediately
-            ticker.tick().await;
-            let keepalive_loop = async {
-                loop {
-                    ticker.tick().await;
-                    if !dlg_ref.is_confirmed() {
-                        return Ok(());
-                    }
-                    let options = dlg_ref.make_request(
-                        rsip::Method::Options,
-                        None,
-                        None,
-                        None,
-                        None,
-                        None,
-                    )?;
-                    let id = dlg_ref.id.lock().unwrap().clone();
-                    match dlg_ref.do_request(options).await {
-                        Ok(Some(resp)) => match resp.status_code.kind() {
-                            StatusCodeKind::Provisional | StatusCodeKind::Successful => {
-                                continue;
-                            }
-                            _ => {
-                                info!(%id, status = %resp.status_code, "keepalive options failed");
-                            }
-                        },
-                        Ok(None) => {
-                            continue;
-                        }
-                        Err(_) => {}
-                    }
-                    dlg_ref
-                        .transition(DialogState::Terminated(id, TerminatedReason::Timeout))
-                        .ok();
-                    break;
-                }
-                Ok::<(), crate::Error>(())
-            };
-            tokio::select! {
-                _ = token.cancelled() => {}
-                _ = keepalive_loop =>{}
-            };
-        });
-    }
 }
 
 impl std::fmt::Display for DialogState {

src/dialog/server_dialog.rs

@@ -1,6 +1,5 @@
 use super::dialog::{Dialog, DialogInnerRef, DialogState, TerminatedReason};
 use super::DialogId;
-use crate::dialog::dialog::DialogInner;
 use crate::transport::SipConnection;
 use crate::{
     transaction::transaction::{Transaction, TransactionEvent},
@@ -684,7 +683,6 @@ impl ServerInviteDialog {
                                 self.id(),
                                 tx.last_response.clone().unwrap_or_default(),
                             ))?;
-                            DialogInner::serve_keepalive_options(self.inner.clone());
                             break;
                         }
                         rsip::Method::Cancel => {

src/transaction/endpoint.rs

@@ -39,9 +39,7 @@ pub struct EndpointOption {
     pub t4: Duration,
     pub t1x64: Duration,
     pub timerc: Duration,
-    pub ignore_out_of_dialog_option: bool,
     pub callid_suffix: Option<String>,
-    pub dialog_keepalive_duration: Option<Duration>,
 }
 
 impl Default for EndpointOption {
@@ -51,9 +49,7 @@ impl Default for EndpointOption {
             t4: Duration::from_secs(4),
             t1x64: Duration::from_millis(64 * 500),
             timerc: Duration::from_secs(180),
-            ignore_out_of_dialog_option: true,
             callid_suffix: None,
-            dialog_keepalive_duration: Some(Duration::from_secs(60)),
         }
     }
 }

src/transaction/transaction.rs

@@ -46,7 +46,7 @@ pub type TransactionEventSender = UnboundedSender<TransactionEvent>;
 ///     TransactionEvent::Respond(response) => {
 ///         // Send response
 ///     },
-///     TransactionEvent::Terminate => {
+///     TransactionEvent::Terminate(key) => {
 ///         // Clean up transaction
 ///     }
 /// }
@@ -56,7 +56,7 @@ pub enum TransactionEvent {
     Received(SipMessage, Option<SipConnection>),
     Timer(TransactionTimer),
     Respond(Response),
-    Terminate,
+    Terminate(TransactionKey),
 }
 
 /// SIP Transaction
@@ -499,8 +499,8 @@ impl Transaction {
                 TransactionEvent::Respond(response) => {
                     self.respond(response).await.ok();
                 }
-                TransactionEvent::Terminate => {
-                    info!("received terminate event");
+                TransactionEvent::Terminate(key) => {
+                    info!(%key, "received terminate event");
                     return None;
                 }
             }
@@ -672,7 +672,6 @@ impl Transaction {
                             None,
                         );
                         self.inform_tu_response(timeout_response)?;
-                        self.transition(TransactionState::Terminated)?;
                     }
                 }
             }
@@ -685,7 +684,6 @@ impl Transaction {
                         None,
                     );
                     self.inform_tu_response(timeout_response)?;
-                    self.transition(TransactionState::Terminated)?;
                 }
             }
             TransactionState::Completed => {
@@ -841,7 +839,9 @@ impl Transaction {
             }
             TransactionState::Terminated => {
                 self.cleanup();
-                self.tu_sender.send(TransactionEvent::Terminate).ok(); // tell TU to terminate
+                self.tu_sender
+                    .send(TransactionEvent::Terminate(self.key.clone()))
+                    .ok(); // tell TU to terminate
             }
         }
         debug!(