Struct Ringing 

pub struct Ringing { /* private fields */ }

An invitation that has been rung but not yet answered.

Holding this is what makes a reliable 180 possible at all: the response has to be retransmitted until a PRACK arrives, and something has to own the sequence number and the early dialog’s tag in the meantime.

Implementations

impl Ringing

pub fn tag(&self) -> &str

The To tag this side chose, which the eventual 200 must reuse.

A provisional that establishes a dialog has already told the caller what the remote tag is (RFC 3261 §12.1.1). Answering later with a different tag creates a second dialog, and the caller ACKs the one it knows about while this side waits for an ACK to the other.

pub fn is_reliable(&self) -> bool

Whether the provisional was sent reliably.

pub fn is_acknowledged(&self) -> bool

Whether the caller has acknowledged it.

pub fn peer_allows_update(&self) -> bool

Whether the caller’s Allow listed UPDATE (RFC 3311 §4).

pub fn has_early_session(&self) -> bool

Whether the session was described and answered before the call was accepted.

True only after ring_early. It is what makes an offer-carrying UPDATE legal in this dialog: RFC 3311 §5.1 will not let one out while an offer/answer exchange is open, and before the 200 the only way to close one is RFC 3262 §5’s answer in a reliable provisional.

pub fn media(&self) -> Option<&MediaSession>

The running media session described by the reliable provisional, when there is one.

ring_early starts it before returning, so an answerer can send an announcement and receive caller audio before the INVITE is accepted. crate::answer_early moves this exact session into the resulting crate::Call.

pub async fn on_update(&mut self, incoming: &Incoming) -> Result<bool>

Answer an UPDATE that arrived in the early dialog (RFC 3311 §5.2).

Returns whether it was one for this dialog. The rules are the same code the calling side runs from Dialing::on_update: §5.1 makes UPDATE something either end may send, so a second copy of §5.2 here would be a second place for it to drift.

An offer arriving before this side has answered the INVITE’s own — that is, after ring rather than ring_early — draws the 500 of §5.2’s third rule. Not 491: nothing of ours is outstanding, the peer is simply early, and telling it otherwise would send it into a back-off instead of the retry that will work.

pub async fn update(&mut self, direction: Direction) -> Result<()>

Renegotiate the early session from this side (RFC 3311 §5.1).

Requires ring_early: without an answer already given to the INVITE’s offer this side owes one, and RFC 3264 forbids a second offer while one is open — the far end would answer 500 and be right to.

pub async fn on_prack(&mut self, incoming: &Incoming) -> Result<bool>

Handle an in-dialog PRACK. Returns whether it was one for this ringing.

§3: a PRACK that matches is answered 2xx and stops the retransmissions; one that matches nothing “MUST” be answered 481. Answering 481 matters more than it looks — it tells a caller that acknowledged something we never sent that the two sides disagree, instead of leaving its PRACK transaction to time out looking like a lost packet.

Trait Implementations

impl Debug for Ringing

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

Formats the value using the given formatter.

impl Drop for Ringing

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.