Struct Response

pub struct Response {
    pub version: Version,
    pub status: StatusCode,
    pub reason: Option<String>,
    pub headers: Vec<TypedHeader>,
    pub body: Bytes,
}

A SIP response message

Represents a SIP response sent from a server to a client, containing a status code, reason phrase, headers, and optional body. SIP responses acknowledge requests and provide information about their processing.

Standard RFC Compliance

This implementation follows RFC 3261, which defines the Session Initiation Protocol.

Fields

• version: The SIP protocol version (typically SIP/2.0)
• status: The response status code (e.g., 200 for OK, 404 for Not Found)
• reason: Optional custom reason phrase (overrides the default for the status code)
• headers: A list of message headers
• body: The message body (optional)

Examples

use rvoip_sip_core::prelude::*;

// Create a 200 OK response
let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::From(From::new(Address::new_with_display_name("Alice", "sip:alice@example.com".parse().unwrap()))))
    .with_header(TypedHeader::To(To::new(Address::new_with_display_name("Bob", "sip:bob@example.com".parse().unwrap()))));

// Or use a convenience method for common responses
let trying = Response::trying();

Fields

version: Version

The SIP version

status: StatusCode

The status code

reason: Option<String>

Custom reason phrase (overrides the default for the status code)

headers: Vec<TypedHeader>

The headers of the response (now typed)

body: Bytes

The body of the response

Implementations

impl Response

pub fn new(status: StatusCode) -> Response

Creates a new SIP response with the specified status code

This initializes a response with SIP/2.0 version, the given status code, default reason phrase, empty headers, and empty body.

Parameters

• status: The SIP status code

Returns

A new Response instance

Examples

use rvoip_sip_core::prelude::*;

// Create a 404 Not Found response
let response = Response::new(StatusCode::NotFound);

assert_eq!(response.status, StatusCode::NotFound);
assert_eq!(response.reason_phrase(), "Not Found");
assert!(response.headers.is_empty());
assert!(response.body.is_empty());

pub fn trying() -> Response

Creates a SIP 100 Trying response

Returns

A new Response with 100 Trying status

Examples

use rvoip_sip_core::prelude::*;

let response = Response::trying();
assert_eq!(response.status, StatusCode::Trying);

pub fn ringing() -> Response

Creates a SIP 180 Ringing response

Returns

A new Response with 180 Ringing status

Examples

use rvoip_sip_core::prelude::*;

let response = Response::ringing();
assert_eq!(response.status, StatusCode::Ringing);

pub fn ok() -> Response

Creates a SIP 200 OK response

Returns

A new Response with 200 OK status

Examples

use rvoip_sip_core::prelude::*;

let response = Response::ok();
assert_eq!(response.status, StatusCode::Ok);

pub fn with_header(self, header: TypedHeader) -> Response

Adds a typed header to the response

Parameters

• header: The typed header to add

Returns

Self for method chaining

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::CallId(CallId::new("abc123")))
    .with_header(TypedHeader::MaxForwards(MaxForwards::new(70)));

assert_eq!(response.headers.len(), 2);

pub fn set_headers(&mut self, headers: Vec<TypedHeader>)

Sets all headers from a Vec (used by parser)

This method replaces all existing headers with the provided ones.

Parameters

• headers: Vector of typed headers to set

Examples

use rvoip_sip_core::prelude::*;

let mut response = Response::new(StatusCode::Ok);
let headers = vec![
    TypedHeader::CallId(CallId::new("abc123")),
    TypedHeader::MaxForwards(MaxForwards::new(70))
];

response.set_headers(headers);
assert_eq!(response.headers.len(), 2);

pub fn with_reason(self, reason: impl Into<String>) -> Response

Sets a custom reason phrase for the response

Parameters

• reason: The custom reason phrase

Returns

Self for method chaining

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok)
    .with_reason("Everything is Awesome");

assert_eq!(response.reason_phrase(), "Everything is Awesome");

pub fn with_body(self, body: impl Into<Bytes>) -> Response

Sets the body of the response

This method also automatically adds or updates the Content-Length header.

Parameters

• body: The body content

Returns

Self for method chaining

pub fn header(&self, name: &HeaderName) -> Option<&TypedHeader>

Retrieves the first typed header with the specified name, if any

Parameters

• name: The header name to look for

Returns

An optional reference to the first matching header

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::CallId(CallId::new("abc123")));

let header = response.header(&HeaderName::CallId);
assert!(header.is_some());

pub fn reason_phrase(&self) -> &str

Returns the reason phrase for this response

Returns

A string slice with the reason phrase

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok);
assert_eq!(response.reason_phrase(), "OK");

// With custom reason
let custom = Response::new(StatusCode::Ok).with_reason("Everything is Awesome");
assert_eq!(custom.reason_phrase(), "Everything is Awesome");

pub fn typed_header<T>(&self) -> Option<&T>

where T: TypedHeaderTrait + Debug + 'static, <T as TypedHeaderTrait>::Name: Debug,

Retrieves the first header with the specified type, if any.

pub fn call_id(&self) -> Option<&CallId>

Get the Call-ID header value, if present

Returns

An optional reference to the CallId

pub fn from(&self) -> Option<&From>

Retrieves the From header value, if present

Returns

An optional reference to the From header

Examples

use rvoip_sip_core::prelude::*;
use std::str::FromStr;

// Create a URI for the address
let uri = Uri::from_str("sip:alice@atlanta.com").unwrap();
// Create an address with display name
let address = Address::new_with_display_name("Alice", uri);
// Create a From header with the address
let mut from = From::new(address);
// Add a tag parameter
from.set_tag("1928301774");
 
let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::From(from.clone()));

let retrieved = response.from();
assert!(retrieved.is_some());

pub fn to(&self) -> Option<&To>

Retrieves the To header value, if present

Returns

An optional reference to the To header

Examples

use rvoip_sip_core::prelude::*;

let to = To::new(Address::new_with_display_name("Bob", "sip:bob@example.com".parse().unwrap()));
let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::To(to.clone()));

let retrieved = response.to();
assert!(retrieved.is_some());

pub fn cseq(&self) -> Option<&CSeq>

Retrieves the CSeq header value, if present

Returns

An optional reference to the CSeq header

Examples

use rvoip_sip_core::prelude::*;

let cseq = CSeq::new(1, Method::Invite);
let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::CSeq(cseq.clone()));

let retrieved = response.cseq();
assert!(retrieved.is_some());
assert_eq!(retrieved.unwrap().method().clone(), Method::Invite);

pub fn via_headers(&self) -> Vec<Via>

Get all Via headers as structured Via objects

Returns

A vector of all Via headers in the response

Examples

use rvoip_sip_core::prelude::*;

let via = Via::new(
    "SIP", "2.0", "UDP",
    "example.com", Some(5060),
    vec![Param::branch("z9hG4bK123456")]
).unwrap();
let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::Via(via.clone()));

let vias = response.via_headers();
assert_eq!(vias.len(), 1);

pub fn first_via(&self) -> Option<Via>

Get the first Via header as a structured Via object

Returns

The first Via header if present, or None

Examples

use rvoip_sip_core::prelude::*;

let via = Via::new(
    "SIP", "2.0", "UDP",
    "example.com", Some(5060),
    vec![Param::branch("z9hG4bK123456")]
).unwrap();
let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::Via(via.clone()));

let first_via = response.first_via();
assert!(first_via.is_some());

pub fn status(&self) -> StatusCode

Returns the status code of the response

Returns

The response status code

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok);
assert_eq!(response.status(), StatusCode::Ok);

pub fn body(&self) -> &[u8]

Returns a reference to the body content

Returns

A slice reference to the message body bytes

Examples

use rvoip_sip_core::prelude::*;
use bytes::Bytes;

let body_content = "test body";
let response = Response::new(StatusCode::Ok)
    .with_body(Bytes::from(body_content));

assert_eq!(response.body(), body_content.as_bytes());

pub fn from_request(status: StatusCode, request: &Request) -> Response

Creates a new response with all essential headers copied from a request

This is a convenience method that creates a response with:

• From header (copied from request)
• To header (copied from request)
• Call-ID header (copied from request)
• CSeq header (copied from request)
• Via headers (copied from request)

Parameters

• status: The status code for the response
• request: The request to copy headers from

Returns

A well-formed Response with all required headers

Examples

use rvoip_sip_core::prelude::*;
use rvoip_sip_core::types::headers::HeaderAccess;
use std::str::FromStr;

// Create a URI for the addresses
let alice_uri = Uri::from_str("sip:alice@example.com").unwrap();
let alice_addr = Address::new(alice_uri);
let from = From::new(alice_addr);

let bob_uri = Uri::from_str("sip:bob@example.com").unwrap();
let bob_addr = Address::new(bob_uri);
let to = To::new(bob_addr);

let request = Request::new(Method::Invite, "sip:bob@example.com".parse().unwrap())
    .with_header(TypedHeader::From(from))
    .with_header(TypedHeader::To(to))
    .with_header(TypedHeader::CallId(CallId::new("abc123")))
    .with_header(TypedHeader::CSeq(CSeq::new(1, Method::Invite)));

let response = Response::from_request(StatusCode::Ok, &request);

assert_eq!(response.status, StatusCode::Ok);
assert!(response.has_header(&HeaderName::From));
assert!(response.has_header(&HeaderName::To));
assert!(response.has_header(&HeaderName::CallId));
assert!(response.has_header(&HeaderName::CSeq));

pub fn version(&self) -> Version

Returns the SIP version

Returns

A clone of the response’s SIP version

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok);
assert_eq!(response.version(), Version::sip_2_0());

pub fn all_headers(&self) -> &[TypedHeader]

Returns a reference to the response headers

Returns

A slice of all TypedHeader objects in the response

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok)
    .with_header(TypedHeader::CallId(CallId::new("abc123")));

assert_eq!(response.all_headers().len(), 1);

pub fn reason(&self) -> Option<&str>

Returns the custom reason if set

Returns

An optional reference to the custom reason string

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok)
    .with_reason("Everything is Awesome");

assert_eq!(response.reason(), Some("Everything is Awesome"));

pub fn body_bytes(&self) -> &Bytes

Returns a reference to the response body as Bytes

Returns

A reference to the response body Bytes

Examples

use rvoip_sip_core::prelude::*;
use bytes::Bytes;

let body_content = "test body";
let response = Response::new(StatusCode::Ok)
    .with_body(Bytes::from(body_content));

assert_eq!(response.body_bytes(), &Bytes::from(body_content));

pub fn status_code(&self) -> u16

Returns the status code as a u16

Returns

The numeric status code value

Examples

use rvoip_sip_core::prelude::*;

let response = Response::new(StatusCode::Ok);
assert_eq!(response.status_code(), 200);

pub fn from_tag(&self) -> Option<String>

Retrieves the From tag, if present

Returns

An optional From tag string

pub fn to_tag(&self) -> Option<String>

Retrieves the To tag, if present

Returns

An optional To tag string

pub fn via_branch(&self) -> Option<String>

Retrieves the Via branch from the first (topmost) Via header

Returns

An optional Via branch string from the first Via header

pub fn first_via_branch(&self) -> Option<String>

Retrieves the Via branch from the first (topmost) Via header

Returns

An optional Via branch string from the first Via header

pub fn all_via_branches(&self) -> Vec<String>

Retrieves all Via branches in order

Returns

A vector of branch strings from all Via headers

pub fn all_via_transports(&self) -> Vec<String>

Retrieves all Via transport protocols in order

Returns

A vector of transport protocol strings from all Via headers

pub fn all_via_hosts(&self) -> Vec<String>

Retrieves all Via hosts in order

Returns

A vector of host strings from all Via headers

Trait Implementations

impl Clone for Response

fn clone(&self) -> Response

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Response

fn deserialize<__D>( __deserializer: __D, ) -> Result<Response, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl HeaderAccess for Response

fn typed_headers<T>(&self) -> Vec<&T>

where T: TypedHeaderTrait + Debug + 'static, <T as TypedHeaderTrait>::Name: Debug,

Returns all headers with the specified type.

fn typed_header<T>(&self) -> Option<&T>

where T: TypedHeaderTrait + Debug + 'static, <T as TypedHeaderTrait>::Name: Debug,

Returns the first header with the specified type, if any.

fn headers(&self, name: &HeaderName) -> Vec<&TypedHeader>

Returns all headers with the specified name.

fn header(&self, name: &HeaderName) -> Option<&TypedHeader>

Returns the first header with the specified name, if any.

fn headers_by_name(&self, name: &str) -> Vec<&TypedHeader>

Returns all headers with the specified name as a string.

fn raw_header_value(&self, name: &HeaderName) -> Option<String>

Returns the raw value of the first header with the specified name, if any.

fn raw_headers(&self, name: &HeaderName) -> Vec<Vec<u8>>

Returns all raw values for headers with the specified name.

fn header_names(&self) -> Vec<HeaderName>

Returns all header names present in the message.

fn has_header(&self, name: &HeaderName) -> bool

Checks if a header with the specified name is present.

impl MessageExtensions for Response

fn body_string(&self) -> Option<String>

Extract body as string if present

impl PartialEq for Response

fn eq(&self, other: &Response) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Response

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Response