382 lines
11 KiB
Rust
382 lines
11 KiB
Rust
use std::convert::TryFrom;
|
||
|
||
use jid::Jid;
|
||
use xmpp_parsers::{
|
||
iq::IqSetPayload,
|
||
jingle::{ContentId, Creator, Disposition, ReasonElement, Senders, SessionId},
|
||
jingle_ibb::Transport as IbbTransport,
|
||
jingle_grouping::Group,
|
||
jingle_s5b::Transport as Socks5Transport,
|
||
ns::{JINGLE, JINGLE_GROUPING, JINGLE_IBB, JINGLE_ICE_UDP, JINGLE_RTP, JINGLE_S5B},
|
||
Element,
|
||
Error,
|
||
};
|
||
|
||
use crate::{
|
||
jingle_ice_udp::Transport as IceUdpTransport,
|
||
jingle_rtp::Description as RtpDescription,
|
||
};
|
||
|
||
generate_attribute!(
|
||
/// The action attribute.
|
||
Action, "action", {
|
||
/// Accept a content-add action received from another party.
|
||
ContentAccept => "content-accept",
|
||
|
||
/// Add one or more new content definitions to the session.
|
||
ContentAdd => "content-add",
|
||
|
||
/// Change the directionality of media sending.
|
||
ContentModify => "content-modify",
|
||
|
||
/// Reject a content-add action received from another party.
|
||
ContentReject => "content-reject",
|
||
|
||
/// Remove one or more content definitions from the session.
|
||
ContentRemove => "content-remove",
|
||
|
||
/// Exchange information about parameters for an application type.
|
||
DescriptionInfo => "description-info",
|
||
|
||
/// Exchange information about security preconditions.
|
||
SecurityInfo => "security-info",
|
||
|
||
/// Definitively accept a session negotiation.
|
||
SessionAccept => "session-accept",
|
||
|
||
/// Send session-level information, such as a ping or a ringing message.
|
||
SessionInfo => "session-info",
|
||
|
||
/// Request negotiation of a new Jingle session.
|
||
SessionInitiate => "session-initiate",
|
||
|
||
/// End an existing session.
|
||
SessionTerminate => "session-terminate",
|
||
|
||
/// Accept a transport-replace action received from another party.
|
||
TransportAccept => "transport-accept",
|
||
|
||
/// Exchange transport candidates.
|
||
TransportInfo => "transport-info",
|
||
|
||
/// Reject a transport-replace action received from another party.
|
||
TransportReject => "transport-reject",
|
||
|
||
/// Redefine a transport method or replace it with a different method.
|
||
TransportReplace => "transport-replace",
|
||
|
||
/// --- Non-standard values used by Jitsi Meet: ---
|
||
|
||
/// Add a source to existing content.
|
||
SourceAdd => "source-add",
|
||
}
|
||
);
|
||
|
||
/// The main Jingle container, to be included in an iq stanza.
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub struct Jingle {
|
||
/// The action to execute on both ends.
|
||
pub action: Action,
|
||
|
||
/// Who the initiator is.
|
||
pub initiator: Option<Jid>,
|
||
|
||
/// Who the responder is.
|
||
pub responder: Option<Jid>,
|
||
|
||
/// Unique session identifier between two entities.
|
||
pub sid: SessionId,
|
||
|
||
/// A list of contents to be negotiated in this session.
|
||
pub contents: Vec<Content>,
|
||
|
||
/// An optional reason.
|
||
pub reason: Option<ReasonElement>,
|
||
|
||
/// An optional grouping.
|
||
pub group: Option<Group>,
|
||
|
||
/// Payloads to be included.
|
||
pub other: Vec<Element>,
|
||
}
|
||
|
||
impl IqSetPayload for Jingle {}
|
||
|
||
impl Jingle {
|
||
/// Create a new Jingle element.
|
||
pub fn new(action: Action, sid: SessionId) -> Jingle {
|
||
Jingle {
|
||
action,
|
||
sid,
|
||
initiator: None,
|
||
responder: None,
|
||
contents: Vec::new(),
|
||
reason: None,
|
||
group: None,
|
||
other: Vec::new(),
|
||
}
|
||
}
|
||
|
||
/// Set the initiator’s JID.
|
||
pub fn with_initiator(mut self, initiator: Jid) -> Jingle {
|
||
self.initiator = Some(initiator);
|
||
self
|
||
}
|
||
|
||
/// Set the responder’s JID.
|
||
pub fn with_responder(mut self, responder: Jid) -> Jingle {
|
||
self.responder = Some(responder);
|
||
self
|
||
}
|
||
|
||
/// Add a content to this Jingle container.
|
||
pub fn add_content(mut self, content: Content) -> Jingle {
|
||
self.contents.push(content);
|
||
self
|
||
}
|
||
|
||
/// Set the reason in this Jingle container.
|
||
pub fn set_reason(mut self, reason: ReasonElement) -> Jingle {
|
||
self.reason = Some(reason);
|
||
self
|
||
}
|
||
|
||
/// Set the grouping in this Jingle container.
|
||
pub fn set_group(mut self, group: Group) -> Jingle {
|
||
self.group = Some(group);
|
||
self
|
||
}
|
||
}
|
||
|
||
impl TryFrom<Element> for Jingle {
|
||
type Error = Error;
|
||
|
||
fn try_from(root: Element) -> Result<Jingle, Error> {
|
||
check_self!(root, "jingle", JINGLE, "Jingle");
|
||
|
||
let mut jingle = Jingle {
|
||
action: get_attr!(root, "action", Required),
|
||
initiator: get_attr!(root, "initiator", Option),
|
||
responder: get_attr!(root, "responder", Option),
|
||
sid: get_attr!(root, "sid", Required),
|
||
contents: vec![],
|
||
reason: None,
|
||
group: None,
|
||
other: vec![],
|
||
};
|
||
|
||
for child in root.children().cloned() {
|
||
if child.is("content", JINGLE) {
|
||
let content = Content::try_from(child)?;
|
||
jingle.contents.push(content);
|
||
} else if child.is("reason", JINGLE) {
|
||
if jingle.reason.is_some() {
|
||
return Err(Error::ParseError(
|
||
"Jingle must not have more than one reason.",
|
||
));
|
||
}
|
||
let reason = ReasonElement::try_from(child)?;
|
||
jingle.reason = Some(reason);
|
||
} else if child.is("group", JINGLE_GROUPING) {
|
||
if jingle.group.is_some() {
|
||
return Err(Error::ParseError(
|
||
"Jingle must not have more than one grouping.",
|
||
));
|
||
}
|
||
let group = Group::try_from(child)?;
|
||
jingle.group = Some(group);
|
||
} else {
|
||
jingle.other.push(child);
|
||
}
|
||
}
|
||
|
||
Ok(jingle)
|
||
}
|
||
}
|
||
|
||
impl From<Jingle> for Element {
|
||
fn from(jingle: Jingle) -> Element {
|
||
Element::builder("jingle", JINGLE)
|
||
.attr("action", jingle.action)
|
||
.attr("initiator", jingle.initiator)
|
||
.attr("responder", jingle.responder)
|
||
.attr("sid", jingle.sid)
|
||
.append_all(jingle.contents)
|
||
.append_all(jingle.reason.map(Element::from))
|
||
.append_all(jingle.group.map(Element::from))
|
||
.build()
|
||
}
|
||
}
|
||
|
||
/// Enum wrapping all of the various supported descriptions of a Content.
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub enum Description {
|
||
/// Jingle RTP Sessions (XEP-0167) description.
|
||
Rtp(RtpDescription),
|
||
|
||
/// To be used for any description that isn’t known at compile-time.
|
||
Unknown(Element),
|
||
}
|
||
|
||
impl TryFrom<Element> for Description {
|
||
type Error = Error;
|
||
|
||
fn try_from(elem: Element) -> Result<Description, Error> {
|
||
Ok(if elem.is("description", JINGLE_RTP) {
|
||
Description::Rtp(RtpDescription::try_from(elem)?)
|
||
} else {
|
||
Description::Unknown(elem)
|
||
})
|
||
}
|
||
}
|
||
|
||
impl From<RtpDescription> for Description {
|
||
fn from(desc: RtpDescription) -> Description {
|
||
Description::Rtp(desc)
|
||
}
|
||
}
|
||
|
||
impl From<Description> for Element {
|
||
fn from(desc: Description) -> Element {
|
||
match desc {
|
||
Description::Rtp(desc) => desc.into(),
|
||
Description::Unknown(elem) => elem,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Enum wrapping all of the various supported transports of a Content.
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub enum Transport {
|
||
/// Jingle ICE-UDP Bytestreams (XEP-0176) transport.
|
||
IceUdp(IceUdpTransport),
|
||
|
||
/// Jingle In-Band Bytestreams (XEP-0261) transport.
|
||
Ibb(IbbTransport),
|
||
|
||
/// Jingle SOCKS5 Bytestreams (XEP-0260) transport.
|
||
Socks5(Socks5Transport),
|
||
|
||
/// To be used for any transport that isn’t known at compile-time.
|
||
Unknown(Element),
|
||
}
|
||
|
||
impl TryFrom<Element> for Transport {
|
||
type Error = Error;
|
||
|
||
fn try_from(elem: Element) -> Result<Transport, Error> {
|
||
Ok(if elem.is("transport", JINGLE_ICE_UDP) {
|
||
Transport::IceUdp(IceUdpTransport::try_from(elem)?)
|
||
} else if elem.is("transport", JINGLE_IBB) {
|
||
Transport::Ibb(IbbTransport::try_from(elem)?)
|
||
} else if elem.is("transport", JINGLE_S5B) {
|
||
Transport::Socks5(Socks5Transport::try_from(elem)?)
|
||
} else {
|
||
Transport::Unknown(elem)
|
||
})
|
||
}
|
||
}
|
||
|
||
impl From<IceUdpTransport> for Transport {
|
||
fn from(transport: IceUdpTransport) -> Transport {
|
||
Transport::IceUdp(transport)
|
||
}
|
||
}
|
||
|
||
impl From<IbbTransport> for Transport {
|
||
fn from(transport: IbbTransport) -> Transport {
|
||
Transport::Ibb(transport)
|
||
}
|
||
}
|
||
|
||
impl From<Socks5Transport> for Transport {
|
||
fn from(transport: Socks5Transport) -> Transport {
|
||
Transport::Socks5(transport)
|
||
}
|
||
}
|
||
|
||
impl From<Transport> for Element {
|
||
fn from(transport: Transport) -> Element {
|
||
match transport {
|
||
Transport::IceUdp(transport) => transport.into(),
|
||
Transport::Ibb(transport) => transport.into(),
|
||
Transport::Socks5(transport) => transport.into(),
|
||
Transport::Unknown(elem) => elem,
|
||
}
|
||
}
|
||
}
|
||
|
||
generate_element!(
|
||
/// Describes a session’s content, there can be multiple content in one
|
||
/// session.
|
||
Content, "content", JINGLE,
|
||
attributes: [
|
||
/// Who created this content.
|
||
creator: Option<Creator> = "creator",
|
||
|
||
/// How the content definition is to be interpreted by the recipient.
|
||
disposition: Default<Disposition> = "disposition",
|
||
|
||
/// A per-session unique identifier for this content.
|
||
name: Required<ContentId> = "name",
|
||
|
||
/// Who can send data for this content.
|
||
senders: Default<Senders> = "senders",
|
||
],
|
||
children: [
|
||
/// What to send.
|
||
description: Option<Description> = ("description", *) => Description,
|
||
|
||
/// How to send it.
|
||
transport: Option<Transport> = ("transport", *) => Transport,
|
||
|
||
/// With which security.
|
||
security: Option<Element> = ("security", JINGLE) => Element
|
||
]
|
||
);
|
||
|
||
impl Content {
|
||
/// Create a new content.
|
||
pub fn new(creator: Creator, name: ContentId) -> Content {
|
||
Content {
|
||
creator: Some(creator),
|
||
name,
|
||
disposition: Disposition::Session,
|
||
senders: Senders::Both,
|
||
description: None,
|
||
transport: None,
|
||
security: None,
|
||
}
|
||
}
|
||
|
||
/// Set how the content is to be interpreted by the recipient.
|
||
pub fn with_disposition(mut self, disposition: Disposition) -> Content {
|
||
self.disposition = disposition;
|
||
self
|
||
}
|
||
|
||
/// Specify who can send data for this content.
|
||
pub fn with_senders(mut self, senders: Senders) -> Content {
|
||
self.senders = senders;
|
||
self
|
||
}
|
||
|
||
/// Set the description of this content.
|
||
pub fn with_description<D: Into<Description>>(mut self, description: D) -> Content {
|
||
self.description = Some(description.into());
|
||
self
|
||
}
|
||
|
||
/// Set the transport of this content.
|
||
pub fn with_transport<T: Into<Transport>>(mut self, transport: T) -> Content {
|
||
self.transport = Some(transport.into());
|
||
self
|
||
}
|
||
|
||
/// Set the security of this content.
|
||
pub fn with_security(mut self, security: Element) -> Content {
|
||
self.security = Some(security);
|
||
self
|
||
}
|
||
}
|