fix cancel and proxy example

examples/proxy.rs

@@ -474,7 +474,11 @@ async fn handle_invite(state: AppState, mut tx: Transaction) -> Result<()> {
                     match msg {
                         rsip::message::SipMessage::Request(req) => match req.method {
                             rsip::Method::Cancel => {
-                                inv_tx.send_cancel(req).await?;
+                                let mut cancel_req = req.clone();
+                                if let Ok(invite_via) = inv_tx.original.via_header() {
+                                    cancel_req.headers.push_front(invite_via.clone().into());
+                                }
+                                inv_tx.send_cancel(cancel_req).await?;
                             }
                             _ => {}
                         },
@@ -823,13 +827,14 @@ mod tests {
         };
 
         state
+            .inner
             .users
             .lock()
             .await
             .insert(user.username.clone(), user.clone());
 
         // Verify user is stored
-        let stored_user = state.users.lock().await.get("testuser").cloned();
+        let stored_user = state.inner.users.lock().await.get("testuser").cloned();
         assert!(stored_user.is_some());
         assert_eq!(stored_user.unwrap().username, "testuser");
     }
@@ -856,15 +861,13 @@ mod tests {
             to_tag: "remote-tag".to_string(),
         };
 
-        // Add session
-        state.sessions.lock().await.insert(dialog_id.clone());
+        state.inner.sessions.lock().await.insert(dialog_id.clone());
 
-        // Verify session is stored
-        assert!(state.sessions.lock().await.contains(&dialog_id));
+        assert!(state.inner.sessions.lock().await.contains(&dialog_id));
 
         // Remove session
-        assert!(state.sessions.lock().await.remove(&dialog_id));
-        assert!(!state.sessions.lock().await.contains(&dialog_id));
+        assert!(state.inner.sessions.lock().await.remove(&dialog_id));
+        assert!(!state.inner.sessions.lock().await.contains(&dialog_id));
     }
 
     #[tokio::test]

src/transaction/endpoint.rs

@@ -402,16 +402,20 @@ impl EndpointInner {
                                             return Ok(());
                                         }
                                     }
-                                    rsip::StatusCodeKind::RequestFailure => {
-                                        // for ACK to 487, send it where it came from
-                                        connection.send(last_message, Some(from)).await?;
-                                        return Ok(());
-                                    }
                                     _ => {}
                                 }
-                                if let Ok(Some(tag)) = resp.to_header()?.tag() {
+
+                                if let Ok(Some(tag)) = resp.to_header().and_then(|h| h.tag()) {
                                     last_req.to_header_mut().and_then(|h| h.mut_tag(tag)).ok();
                                 }
+
+                                if let rsip::StatusCodeKind::RequestFailure =
+                                    resp.status_code.kind()
+                                {
+                                    // for ACK to 487, send it where it came from
+                                    connection.send(last_message, Some(from)).await?;
+                                    return Ok(());
+                                }
                             }
                         }
                         _ => {}

src/transaction/transaction.rs

@@ -417,7 +417,7 @@ impl Transaction {
 
                     connection.send(cancel, self.destination.as_ref()).await?;
                 }
-                self.transition(TransactionState::Completed).map(|_| ())
+                Ok(())
             }
             _ => Err(Error::TransactionError(
                 format!("invalid state for sending CANCEL {:?}", self.state),