Struct librice::stun::attribute::XorMappedAddress

source ·

pub struct XorMappedAddress { /* private fields */ }

Expand description

The XorMappedAddress Attribute

Implementations§

source §

impl XorMappedAddress

source

pub fn new(addr: SocketAddr, transaction: TransactionId) -> Self

Create a new XorMappedAddress Attribute

Examples

let addr = "127.0.0.1:1234".parse().unwrap();
let mapped_addr = XorMappedAddress::new(addr, 0x5678.into());
assert_eq!(mapped_addr.addr(0x5678.into()), addr);

Examples found in repository ?

src/conncheck.rs (line 773)

fn binding_success_response(
    msg: &Message,
    from: SocketAddr,
    local_credentials: MessageIntegrityCredentials,
) -> Result<Message, AgentError> {
    let mut response = Message::new_success(msg);
    response.add_attribute(XorMappedAddress::new(from, msg.transaction_id()))?;
    response.add_message_integrity(&local_credentials)?;
    response.add_fingerprint()?;
    Ok(response)
}

source

pub fn addr(&self, transaction: TransactionId) -> SocketAddr

Retrieve the address stored in a XorMappedAddress

Examples

let addr = "[::1]:1234".parse().unwrap();
let mapped_addr = XorMappedAddress::new(addr, 0x5678.into());
assert_eq!(mapped_addr.addr(0x5678.into()), addr);

Examples found in repository ?

src/stun/attribute.rs (line 1009)

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self.addr {
            SocketAddr::V4(_) => write!(f, "{}: {:?}", self.get_type(), self.addr(0x0.into())),
            SocketAddr::V6(addr) => write!(f, "{}: XOR({:?})", self.get_type(), addr),
        }
    }

More examples

Hide additional examples

src/gathering.rs (line 96)

async fn gather_stun_xor_address(
    local_preference: u8,
    agent: StunAgent,
    transport: TransportType,
    stun_server: SocketAddr,
) -> Result<GatherCandidateAddress, StunError> {
    let msg = generate_bind_request()?;

    agent
        .stun_request_transaction(&msg, stun_server)?
        .build()?
        .perform()
        .await
        .and_then(move |(response, from)| {
            if let Some(attr) = response.attribute::<XorMappedAddress>(XOR_MAPPED_ADDRESS) {
                debug!(
                    "got external address {:?}",
                    attr.addr(response.transaction_id())
                );
                return Ok(GatherCandidateAddress {
                    ctype: CandidateType::ServerReflexive,
                    local_preference,
                    transport,
                    address: attr.addr(response.transaction_id()),
                    base: from,
                    related: Some(stun_server),
                });
            }
            Err(StunError::Failed)
        })
}

src/conncheck.rs (line 232)

    async fn do_stun_request(
        conncheck: Arc<ConnCheck>,
        stun_request: StunRequest,
    ) -> Result<ConnCheckResponse, AgentError> {
        // send binding request
        // wait for response
        // if timeout -> resend?
        // if longer timeout -> fail
        // TODO: optional: if icmp error -> fail
        let (response, from) = match stun_request.perform().await {
            Err(e) => {
                warn!("connectivity check produced error: {:?}", e);
                return Ok(ConnCheckResponse::Failure(conncheck));
            }
            Ok(v) => v,
        };
        trace!("have response: {}", response);

        if !response.is_response() {
            // response is not a response!
            return Ok(ConnCheckResponse::Failure(conncheck));
        }

        // if response error -> fail TODO: might be a recoverable error!
        if response.has_class(MessageClass::Error) {
            warn!("error response {}", response);
            if let Some(err) = response.attribute::<ErrorCode>(ERROR_CODE) {
                if err.code() == ErrorCode::ROLE_CONFLICT {
                    info!("Role conflict received {}", response);
                    return Ok(ConnCheckResponse::RoleConflict(
                        conncheck,
                        stun_request.request().has_attribute(ICE_CONTROLLED),
                    ));
                }
            }
            // FIXME: some failures are recoverable
            return Ok(ConnCheckResponse::Failure(conncheck));
        }

        // if response success:
        // if mismatched address -> fail
        if from != stun_request.peer_address() {
            warn!(
                "response came from different ip {:?} than candidate {:?}",
                from,
                stun_request.peer_address()
            );
            return Ok(ConnCheckResponse::Failure(conncheck));
        }

        if let Some(xor) = response.attribute::<XorMappedAddress>(XOR_MAPPED_ADDRESS) {
            let xor_addr = xor.addr(response.transaction_id());
            // TODO: if response mapped address not in remote candidate list -> new peer-reflexive candidate
            // TODO glare
            return Ok(ConnCheckResponse::Success(conncheck, xor_addr));
        }

        Ok(ConnCheckResponse::Failure(conncheck))
    }