Struct ServerInviteTransaction

pub struct ServerInviteTransaction { /* private fields */ }

Server INVITE transaction implementation as defined in RFC 3261 Section 17.2.1.

This struct implements the state machine for server INVITE transactions, which are used for handling session establishment requests. INVITE server transactions have unique behavior, including:

• A four-state machine (Proceeding, Completed, Confirmed, Terminated)
• Special handling for ACK requests in the Completed state
• Response retransmission in the Completed state
• Unique timer requirements (Timers G, H, I)

Key behaviors:

• In Proceeding state: Sends provisional (1xx) responses
• In Completed state: Retransmits final non-2xx response until ACK is received
• In Confirmed state: Waits for Timer I before terminating
• In Terminated state: Transaction is finished

Implementations

impl ServerInviteTransaction

pub fn new( id: TransactionKey, request: Request, remote_addr: SocketAddr, transport: Arc<dyn Transport>, events_tx: Sender<TransactionEvent>, timer_config_override: Option<TimerSettings>, ) -> Result<Self>

Creates a new server INVITE transaction.

This method creates a new INVITE server transaction with the specified parameters. It validates that the request is an INVITE, initializes the transaction data, and spawns the transaction runner task.

According to RFC 3261 Section 17.2.1, INVITE server transactions start in the Proceeding state.

Arguments

• id - The unique identifier for this transaction
• request - The INVITE request that initiated this transaction
• remote_addr - The address to which responses should be sent
• transport - The transport layer to use for sending messages
• events_tx - The channel for sending events to the Transaction User
• timer_config_override - Optional custom timer settings

Returns

A Result containing the new ServerInviteTransaction or an error

Trait Implementations

impl Clone for ServerInviteTransaction

fn clone(&self) -> ServerInviteTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommonServerTransaction for ServerInviteTransaction

fn data(&self) -> &Arc<ServerTransactionData>

Returns the shared transaction data.

impl Debug for ServerInviteTransaction

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

Formats the value using the given formatter.

impl ServerTransaction for ServerInviteTransaction

fn process_request( &self, request: Request, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + '_>>

Processes an incoming request associated with this transaction.

fn send_response( &self, response: Response, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + '_>>

Sends a response for this transaction, triggering appropriate state transitions.

fn last_response(&self) -> Option<Response>

Returns the last response sent by this transaction.

fn original_request_sync(&self) -> Option<Request>

Synchronous accessor for the original request if it’s available without async operations. This is an internal helper method that should be implemented by transaction types that can provide synchronous access to the original request.

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

Gets the Call-ID from the original request that created this transaction.

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

Gets the From tag from the original request that created this transaction.

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

Gets the To tag from the original request that created this transaction.

impl Transaction for ServerInviteTransaction

fn id(&self) -> &TransactionKey

Returns the unique key identifying this transaction. The key is typically derived from the branch parameter of the Via header, the method, and directionality.

fn kind(&self) -> TransactionKind

Returns the TransactionKind of this transaction (e.g., InviteClient, InviteServer).

fn state(&self) -> TransactionState

Returns the current TransactionState of this transaction (e.g., Trying, Proceeding, Completed).

fn remote_addr(&self) -> SocketAddr

Returns the network SocketAddr of the remote party involved in this transaction. For client transactions, this is the destination address. For server transactions, it’s the source address.

fn matches(&self, message: &Message) -> bool

Checks if the given SIP Message (request or response) matches this transaction according to the rules in RFC 3261, Section 17.1.3 (client) and 17.2.3 (server). This involves comparing Via branch, CSeq method and number, From/To tags, Call-ID, etc.

fn as_any(&self) -> &dyn Any

Provides a way to downcast this transaction object to its concrete type if needed. This is a standard Rust pattern for trait objects.

impl TransactionAsync for ServerInviteTransaction

fn process_event<'a>( &'a self, event_type: &'a str, message: Option<Message>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>>

Asynchronously processes a significant event relevant to the transaction.

fn send_command<'a>( &'a self, cmd: InternalTransactionCommand, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>>

Sends an InternalTransactionCommand to this transaction for asynchronous processing.

fn original_request<'a>( &'a self, ) -> Pin<Box<dyn Future<Output = Option<Request>> + Send + 'a>>

Asynchronously retrieves the original SIP request that initiated this transaction.

fn last_response<'a>( &'a self, ) -> Pin<Box<dyn Future<Output = Option<Response>> + Send + 'a>>

Asynchronously retrieves the last SIP response that was either sent (for server transactions) or received (for client transactions) by this transaction.