Struct ClientInviteTransaction

pub struct ClientInviteTransaction { /* private fields */ }

Client INVITE transaction implementation as defined in RFC 3261 Section 17.1.1.

This struct implements the state machine for client INVITE transactions, which are used for initiating SIP sessions. INVITE transactions have unique behavior, including:

• Automatic ACK generation for non-2xx responses
• Special handling for 2xx responses (transaction terminates without sending ACK)
• Unique timer requirements (Timers A, B, D)

Key behaviors:

• In Calling state: Retransmits INVITE periodically until response or timeout
• In Proceeding state: Waits for a final response
• In Completed state: Has received a final non-2xx response, sent ACK, waiting for retransmissions
• In Terminated state: Transaction is finished

Implementations

impl ClientInviteTransaction

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>

Create a new client INVITE transaction.

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

Arguments

• id - The unique identifier for this transaction
• request - The INVITE request that initiates this transaction
• remote_addr - The address to which the request 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 ClientInviteTransaction or an error

Trait Implementations

impl ClientTransaction for ClientInviteTransaction

fn initiate(&self) -> Pin<Box<dyn Future<Output = Result<()>> + Send + '_>>

Initiates the transaction by sending the first request.

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

Processes an incoming response for this transaction.

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

Returns the original request that initiated this transaction.

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

Returns the last response received by this transaction.

impl Clone for ClientInviteTransaction

fn clone(&self) -> ClientInviteTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClientInviteTransaction

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

Formats the value using the given formatter.

impl Transaction for ClientInviteTransaction

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 ClientInviteTransaction

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.