use crate::sip::{headers::*, Method, SipMessage, StatusCode};
use crate::transaction::endpoint::EndpointOption;
use crate::transaction::key::{TransactionKey, TransactionRole};
use crate::transaction::transaction::Transaction;
use crate::transaction::EndpointBuilder;
use crate::transport::tcp::TcpConnection;
use crate::transport::{udp::UdpConnection, SipAddr, SipConnection, TransportLayer};
use crate::Result;
use std::convert::TryFrom;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio_util::sync::CancellationToken;
async fn read_request(stream: &mut TcpStream) -> crate::sip::Request {
let mut buf = Vec::new();
let mut chunk = [0u8; 2048];
while !buf.windows(4).any(|w| w == b"\r\n\r\n") {
let n = stream.read(&mut chunk).await.expect("read request");
assert!(n > 0, "peer closed before a full request");
buf.extend_from_slice(&chunk[..n]);
}
let raw = String::from_utf8_lossy(&buf).to_string();
match SipMessage::try_from(raw.as_str()).expect("parse request") {
SipMessage::Request(req) => req,
_ => panic!("expected a request"),
}
}
async fn answer(stream: &mut TcpStream, req: &crate::sip::Request) {
let mut resp = String::from("SIP/2.0 200 OK\r\n");
for header in req.headers.iter() {
match header {
crate::sip::Header::Via(_)
| crate::sip::Header::From(_)
| crate::sip::Header::To(_)
| crate::sip::Header::CallId(_)
| crate::sip::Header::CSeq(_) => {
resp.push_str(&header.to_string());
resp.push_str("\r\n");
}
_ => {}
}
}
resp.push_str("Content-Length: 0\r\n\r\n");
stream
.write_all(resp.as_bytes())
.await
.expect("write response");
}
async fn answer_one(stream: &mut TcpStream) {
let req = read_request(stream).await;
answer(stream, &req).await;
}
fn make_options(peer: std::net::SocketAddr, cseq: u32) -> Result<crate::sip::Request> {
make_request(Method::Options, peer, cseq)
}
fn make_request(
method: Method,
peer: std::net::SocketAddr,
cseq: u32,
) -> Result<crate::sip::Request> {
let uri = crate::sip::Uri::try_from(format!("sip:{};transport=tcp", peer).as_str())?;
let cseq_header = CSeq::new(format!("{cseq} {method}")).into();
Ok(crate::sip::Request {
method,
uri,
headers: vec![
Via::new(format!(
"SIP/2.0/TCP 127.0.0.1:5060;branch=z9hG4bK-reconnect-{cseq}"
))
.into(),
cseq_header,
From::new("<sip:alice@127.0.0.1>;tag=reconnect").into(),
To::new("<sip:bob@127.0.0.1>").into(),
CallId::new("stream-reconnect@127.0.0.1").into(),
MaxForwards::new("70").into(),
]
.into(),
version: crate::sip::Version::V2,
body: vec![],
})
}
async fn final_status(tx: &mut Transaction) -> Option<StatusCode> {
while let Some(msg) = tx.receive().await {
if let SipMessage::Response(resp) = msg {
if resp.status_code.kind() != crate::sip::StatusCodeKind::Provisional {
return Some(resp.status_code);
}
}
}
None
}
async fn build_endpoint(t1: Duration) -> Result<crate::transaction::endpoint::Endpoint> {
let token = CancellationToken::new();
let tl = TransportLayer::new(token.child_token());
let udp = UdpConnection::create_connection("127.0.0.1:0".parse()?, None, None).await?;
tl.add_transport(udp.into());
let option = EndpointOption {
t1,
t1x64: Duration::from_secs(8),
..Default::default()
};
Ok(EndpointBuilder::new()
.with_user_agent("rsipstack-test")
.with_transport_layer(tl)
.with_option(option)
.build())
}
#[tokio::test]
async fn test_request_after_peer_closed_stream_uses_new_connection() -> Result<()> {
let endpoint = build_endpoint(Duration::from_secs(3)).await?;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let peer = listener.local_addr()?;
let peer_task = tokio::spawn(async move {
let (mut first, _) = listener.accept().await.expect("accept first");
answer_one(&mut first).await;
drop(first); let (mut second, _) = listener.accept().await.expect("accept second");
answer_one(&mut second).await;
tokio::time::sleep(Duration::from_secs(10)).await;
});
let inner = endpoint.inner.clone();
let client = async move {
let req = make_options(peer, 1)?;
let key = TransactionKey::from_request(&req, TransactionRole::Client)?;
let mut tx = Transaction::new_client(key, req, inner.clone(), None);
tx.send().await?;
assert_eq!(final_status(&mut tx).await, Some(StatusCode::OK));
let first_connection = tx.connection.clone().expect("first connection");
drop(tx);
let token = first_connection.cancel_token().expect("stream token");
tokio::time::timeout(Duration::from_secs(1), token.cancelled())
.await
.expect("a flow the peer closed must be marked terminated");
let req = make_options(peer, 2)?;
let key = TransactionKey::from_request(&req, TransactionRole::Client)?;
let mut tx = Transaction::new_client(key, req, inner.clone(), None);
tx.send().await?;
let status = tokio::time::timeout(Duration::from_millis(1500), final_status(&mut tx))
.await
.unwrap_or(None);
Ok::<_, crate::Error>(status)
};
let status = tokio::select! {
r = client => r?,
_ = endpoint.serve() => panic!("endpoint stopped"),
};
peer_task.abort();
assert_eq!(
status,
Some(StatusCode::OK),
"the request after the peer closed the TCP connection must be sent on a new \
connection and answered, not written to the closed one"
);
Ok(())
}
#[tokio::test]
async fn test_send_failure_on_stream_is_reported_at_once() -> Result<()> {
for method in [Method::Options, Method::Invite] {
let endpoint = build_endpoint(Duration::from_millis(500)).await?;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let peer = listener.local_addr()?;
let peer_task = tokio::spawn(async move {
let (_first, _) = listener.accept().await.expect("accept");
tokio::time::sleep(Duration::from_secs(10)).await;
});
let target = SipAddr::try_from(&crate::sip::Uri::try_from(
format!("sip:{};transport=tcp", peer).as_str(),
)?)?;
let dead_token = CancellationToken::new();
let dead =
SipConnection::Tcp(TcpConnection::connect(&target, Some(dead_token.clone())).await?);
dead.close().await.ok();
let inner = endpoint.inner.clone();
let request = make_request(method.clone(), peer, 1)?;
let client = async move {
let key = TransactionKey::from_request(&request, TransactionRole::Client)?;
let mut tx = Transaction::new_client(key, request, inner.clone(), Some(dead));
tx.send().await?;
let status = tokio::time::timeout(Duration::from_secs(2), final_status(&mut tx))
.await
.unwrap_or(None);
Ok::<_, crate::Error>(status)
};
let status = tokio::select! {
r = client => r?,
_ = endpoint.serve() => panic!("endpoint stopped"),
};
peer_task.abort();
assert_eq!(
status,
Some(StatusCode::ServiceUnavailable),
"a failed {method} write on a stream connection must be reported to the TU, \
not left to time out"
);
assert!(
dead_token.is_cancelled(),
"the connection whose {method} write failed must be retired"
);
}
Ok(())
}
#[tokio::test]
async fn test_retire_keeps_newer_connection_to_same_peer() -> Result<()> {
let endpoint = build_endpoint(Duration::from_millis(500)).await?;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let peer = listener.local_addr()?;
let peer_task = tokio::spawn(async move {
let mut held = Vec::new();
while let Ok((stream, _)) = listener.accept().await {
held.push(stream);
}
});
let target = SipAddr::try_from(&crate::sip::Uri::try_from(
format!("sip:{};transport=tcp", peer).as_str(),
)?)?;
let old = SipConnection::Tcp(TcpConnection::connect(&target, None).await?);
let newer = SipConnection::Tcp(TcpConnection::connect(&target, None).await?);
let transport_layer = &endpoint.inner.transport_layer;
transport_layer.add_connection(newer.clone());
transport_layer.retire_connection(&old);
let (cached, _) = transport_layer.lookup(&target, None).await?;
assert!(
cached.is_same_stream(&newer),
"retiring an old connection must keep the newer one"
);
transport_layer.retire_connection(&newer);
let (fresh, _) = transport_layer.lookup(&target, None).await?;
assert!(
!fresh.is_same_stream(&newer),
"a retired connection must not be returned by lookup"
);
peer_task.abort();
Ok(())
}