418 lines
19 KiB
Java
418 lines
19 KiB
Java
package eu.siacs.conversations.xmpp.jingle;
|
|
|
|
import android.util.Log;
|
|
import android.util.Pair;
|
|
|
|
import androidx.annotation.NonNull;
|
|
|
|
import com.google.common.base.CharMatcher;
|
|
import com.google.common.base.Joiner;
|
|
import com.google.common.base.Strings;
|
|
import com.google.common.collect.ArrayListMultimap;
|
|
import com.google.common.collect.ImmutableList;
|
|
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
|
|
import eu.siacs.conversations.Config;
|
|
import eu.siacs.conversations.xml.Namespace;
|
|
import eu.siacs.conversations.xmpp.jingle.stanzas.Group;
|
|
import eu.siacs.conversations.xmpp.jingle.stanzas.IceUdpTransportInfo;
|
|
import eu.siacs.conversations.xmpp.jingle.stanzas.RtpDescription;
|
|
|
|
public class SessionDescription {
|
|
|
|
public static final String LINE_DIVIDER = "\r\n";
|
|
private static final String HARDCODED_MEDIA_PROTOCOL =
|
|
"UDP/TLS/RTP/SAVPF"; // probably only true for DTLS-SRTP aka when we have a fingerprint
|
|
private static final int HARDCODED_MEDIA_PORT = 9;
|
|
private static final String HARDCODED_ICE_OPTIONS = "trickle";
|
|
private static final String HARDCODED_CONNECTION = "IN IP4 0.0.0.0";
|
|
|
|
public final int version;
|
|
public final String name;
|
|
public final String connectionData;
|
|
public final ArrayListMultimap<String, String> attributes;
|
|
public final List<Media> media;
|
|
|
|
public SessionDescription(
|
|
int version,
|
|
String name,
|
|
String connectionData,
|
|
ArrayListMultimap<String, String> attributes,
|
|
List<Media> media) {
|
|
this.version = version;
|
|
this.name = name;
|
|
this.connectionData = connectionData;
|
|
this.attributes = attributes;
|
|
this.media = media;
|
|
}
|
|
|
|
private static void appendAttributes(
|
|
StringBuilder s, ArrayListMultimap<String, String> attributes) {
|
|
for (Map.Entry<String, String> attribute : attributes.entries()) {
|
|
final String key = attribute.getKey();
|
|
final String value = attribute.getValue();
|
|
s.append("a=").append(key);
|
|
if (!Strings.isNullOrEmpty(value)) {
|
|
s.append(':').append(value);
|
|
}
|
|
s.append(LINE_DIVIDER);
|
|
}
|
|
}
|
|
|
|
public static SessionDescription parse(final String input) {
|
|
final SessionDescriptionBuilder sessionDescriptionBuilder = new SessionDescriptionBuilder();
|
|
MediaBuilder currentMediaBuilder = null;
|
|
ArrayListMultimap<String, String> attributeMap = ArrayListMultimap.create();
|
|
ImmutableList.Builder<Media> mediaBuilder = new ImmutableList.Builder<>();
|
|
for (final String line : input.split(LINE_DIVIDER)) {
|
|
final String[] pair = line.trim().split("=", 2);
|
|
if (pair.length < 2 || pair[0].length() != 1) {
|
|
Log.d(Config.LOGTAG, "skipping sdp parsing on line " + line);
|
|
continue;
|
|
}
|
|
final char key = pair[0].charAt(0);
|
|
final String value = pair[1];
|
|
switch (key) {
|
|
case 'v':
|
|
sessionDescriptionBuilder.setVersion(ignorantIntParser(value));
|
|
break;
|
|
case 'c':
|
|
if (currentMediaBuilder != null) {
|
|
currentMediaBuilder.setConnectionData(value);
|
|
} else {
|
|
sessionDescriptionBuilder.setConnectionData(value);
|
|
}
|
|
break;
|
|
case 's':
|
|
sessionDescriptionBuilder.setName(value);
|
|
break;
|
|
case 'a':
|
|
final Pair<String, String> attribute = parseAttribute(value);
|
|
attributeMap.put(attribute.first, attribute.second);
|
|
break;
|
|
case 'm':
|
|
if (currentMediaBuilder == null) {
|
|
sessionDescriptionBuilder.setAttributes(attributeMap);
|
|
} else {
|
|
currentMediaBuilder.setAttributes(attributeMap);
|
|
mediaBuilder.add(currentMediaBuilder.createMedia());
|
|
}
|
|
attributeMap = ArrayListMultimap.create();
|
|
currentMediaBuilder = new MediaBuilder();
|
|
final String[] parts = value.split(" ");
|
|
if (parts.length >= 3) {
|
|
currentMediaBuilder.setMedia(parts[0]);
|
|
currentMediaBuilder.setPort(ignorantIntParser(parts[1]));
|
|
currentMediaBuilder.setProtocol(parts[2]);
|
|
ImmutableList.Builder<Integer> formats = new ImmutableList.Builder<>();
|
|
for (int i = 3; i < parts.length; ++i) {
|
|
formats.add(ignorantIntParser(parts[i]));
|
|
}
|
|
currentMediaBuilder.setFormats(formats.build());
|
|
} else {
|
|
Log.d(Config.LOGTAG, "skipping media line " + line);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (currentMediaBuilder != null) {
|
|
currentMediaBuilder.setAttributes(attributeMap);
|
|
mediaBuilder.add(currentMediaBuilder.createMedia());
|
|
} else {
|
|
sessionDescriptionBuilder.setAttributes(attributeMap);
|
|
}
|
|
sessionDescriptionBuilder.setMedia(mediaBuilder.build());
|
|
return sessionDescriptionBuilder.createSessionDescription();
|
|
}
|
|
|
|
public static SessionDescription of(final RtpContentMap contentMap, final boolean isInitiatorContentMap) {
|
|
final SessionDescriptionBuilder sessionDescriptionBuilder = new SessionDescriptionBuilder();
|
|
final ArrayListMultimap<String, String> attributeMap = ArrayListMultimap.create();
|
|
final ImmutableList.Builder<Media> mediaListBuilder = new ImmutableList.Builder<>();
|
|
final Group group = contentMap.group;
|
|
if (group != null) {
|
|
final String semantics = group.getSemantics();
|
|
checkNoWhitespace(semantics, "group semantics value must not contain any whitespace");
|
|
attributeMap.put(
|
|
"group",
|
|
group.getSemantics()
|
|
+ " "
|
|
+ Joiner.on(' ').join(group.getIdentificationTags()));
|
|
}
|
|
|
|
attributeMap.put("msid-semantic", " WMS my-media-stream");
|
|
|
|
for (final Map.Entry<String, RtpContentMap.DescriptionTransport> entry :
|
|
contentMap.contents.entrySet()) {
|
|
final String name = entry.getKey();
|
|
RtpContentMap.DescriptionTransport descriptionTransport = entry.getValue();
|
|
RtpDescription description = descriptionTransport.description;
|
|
IceUdpTransportInfo transport = descriptionTransport.transport;
|
|
final ArrayListMultimap<String, String> mediaAttributes = ArrayListMultimap.create();
|
|
final String ufrag = transport.getAttribute("ufrag");
|
|
final String pwd = transport.getAttribute("pwd");
|
|
if (Strings.isNullOrEmpty(ufrag)) {
|
|
throw new IllegalArgumentException(
|
|
"Transport element is missing required ufrag attribute");
|
|
}
|
|
checkNoWhitespace(ufrag, "ufrag value must not contain any whitespaces");
|
|
mediaAttributes.put("ice-ufrag", ufrag);
|
|
if (Strings.isNullOrEmpty(pwd)) {
|
|
throw new IllegalArgumentException(
|
|
"Transport element is missing required pwd attribute");
|
|
}
|
|
checkNoWhitespace(pwd, "pwd value must not contain any whitespaces");
|
|
mediaAttributes.put("ice-pwd", pwd);
|
|
mediaAttributes.put("ice-options", HARDCODED_ICE_OPTIONS);
|
|
final IceUdpTransportInfo.Fingerprint fingerprint = transport.getFingerprint();
|
|
if (fingerprint != null) {
|
|
mediaAttributes.put(
|
|
"fingerprint", fingerprint.getHash() + " " + fingerprint.getContent());
|
|
final IceUdpTransportInfo.Setup setup = fingerprint.getSetup();
|
|
if (setup != null) {
|
|
mediaAttributes.put("setup", setup.toString().toLowerCase(Locale.ROOT));
|
|
}
|
|
}
|
|
final ImmutableList.Builder<Integer> formatBuilder = new ImmutableList.Builder<>();
|
|
for (RtpDescription.PayloadType payloadType : description.getPayloadTypes()) {
|
|
final String id = payloadType.getId();
|
|
if (Strings.isNullOrEmpty(id)) {
|
|
throw new IllegalArgumentException("Payload type is missing id");
|
|
}
|
|
if (!isInt(id)) {
|
|
throw new IllegalArgumentException("Payload id is not numeric");
|
|
}
|
|
formatBuilder.add(payloadType.getIntId());
|
|
mediaAttributes.put("rtpmap", payloadType.toSdpAttribute());
|
|
final List<RtpDescription.Parameter> parameters = payloadType.getParameters();
|
|
if (parameters.size() == 1) {
|
|
mediaAttributes.put(
|
|
"fmtp", RtpDescription.Parameter.toSdpString(id, parameters.get(0)));
|
|
} else if (parameters.size() > 0) {
|
|
mediaAttributes.put(
|
|
"fmtp", RtpDescription.Parameter.toSdpString(id, parameters));
|
|
}
|
|
for (RtpDescription.FeedbackNegotiation feedbackNegotiation :
|
|
payloadType.getFeedbackNegotiations()) {
|
|
final String type = feedbackNegotiation.getType();
|
|
final String subtype = feedbackNegotiation.getSubType();
|
|
if (Strings.isNullOrEmpty(type)) {
|
|
throw new IllegalArgumentException(
|
|
"a feedback for payload-type "
|
|
+ id
|
|
+ " negotiation is missing type");
|
|
}
|
|
checkNoWhitespace(
|
|
type, "feedback negotiation type must not contain whitespace");
|
|
mediaAttributes.put(
|
|
"rtcp-fb",
|
|
id
|
|
+ " "
|
|
+ type
|
|
+ (Strings.isNullOrEmpty(subtype) ? "" : " " + subtype));
|
|
}
|
|
for (RtpDescription.FeedbackNegotiationTrrInt feedbackNegotiationTrrInt :
|
|
payloadType.feedbackNegotiationTrrInts()) {
|
|
mediaAttributes.put(
|
|
"rtcp-fb", id + " trr-int " + feedbackNegotiationTrrInt.getValue());
|
|
}
|
|
}
|
|
|
|
for (RtpDescription.FeedbackNegotiation feedbackNegotiation :
|
|
description.getFeedbackNegotiations()) {
|
|
final String type = feedbackNegotiation.getType();
|
|
final String subtype = feedbackNegotiation.getSubType();
|
|
if (Strings.isNullOrEmpty(type)) {
|
|
throw new IllegalArgumentException("a feedback negotiation is missing type");
|
|
}
|
|
checkNoWhitespace(type, "feedback negotiation type must not contain whitespace");
|
|
mediaAttributes.put(
|
|
"rtcp-fb",
|
|
"* " + type + (Strings.isNullOrEmpty(subtype) ? "" : " " + subtype));
|
|
}
|
|
for (final RtpDescription.FeedbackNegotiationTrrInt feedbackNegotiationTrrInt :
|
|
description.feedbackNegotiationTrrInts()) {
|
|
mediaAttributes.put("rtcp-fb", "* trr-int " + feedbackNegotiationTrrInt.getValue());
|
|
}
|
|
for (final RtpDescription.RtpHeaderExtension extension :
|
|
description.getHeaderExtensions()) {
|
|
final String id = extension.getId();
|
|
final String uri = extension.getUri();
|
|
if (Strings.isNullOrEmpty(id)) {
|
|
throw new IllegalArgumentException("A header extension is missing id");
|
|
}
|
|
checkNoWhitespace(id, "header extension id must not contain whitespace");
|
|
if (Strings.isNullOrEmpty(uri)) {
|
|
throw new IllegalArgumentException("A header extension is missing uri");
|
|
}
|
|
checkNoWhitespace(uri, "feedback negotiation uri must not contain whitespace");
|
|
mediaAttributes.put("extmap", id + " " + uri);
|
|
}
|
|
|
|
if (description.hasChild(
|
|
"extmap-allow-mixed", Namespace.JINGLE_RTP_HEADER_EXTENSIONS)) {
|
|
mediaAttributes.put("extmap-allow-mixed", "");
|
|
}
|
|
|
|
for (final RtpDescription.SourceGroup sourceGroup : description.getSourceGroups()) {
|
|
final String semantics = sourceGroup.getSemantics();
|
|
final List<String> groups = sourceGroup.getSsrcs();
|
|
if (Strings.isNullOrEmpty(semantics)) {
|
|
throw new IllegalArgumentException(
|
|
"A SSRC group is missing semantics attribute");
|
|
}
|
|
checkNoWhitespace(semantics, "source group semantics must not contain whitespace");
|
|
if (groups.size() == 0) {
|
|
throw new IllegalArgumentException("A SSRC group is missing SSRC ids");
|
|
}
|
|
mediaAttributes.put(
|
|
"ssrc-group",
|
|
String.format("%s %s", semantics, Joiner.on(' ').join(groups)));
|
|
}
|
|
for (final RtpDescription.Source source : description.getSources()) {
|
|
for (final RtpDescription.Source.Parameter parameter : source.getParameters()) {
|
|
final String id = source.getSsrcId();
|
|
final String parameterName = parameter.getParameterName();
|
|
final String parameterValue = parameter.getParameterValue();
|
|
if (Strings.isNullOrEmpty(id)) {
|
|
throw new IllegalArgumentException(
|
|
"A source specific media attribute is missing the id");
|
|
}
|
|
checkNoWhitespace(
|
|
id, "A source specific media attributes must not contain whitespaces");
|
|
if (Strings.isNullOrEmpty(parameterName)) {
|
|
throw new IllegalArgumentException(
|
|
"A source specific media attribute is missing its name");
|
|
}
|
|
if (Strings.isNullOrEmpty(parameterValue)) {
|
|
throw new IllegalArgumentException(
|
|
"A source specific media attribute is missing its value");
|
|
}
|
|
mediaAttributes.put("ssrc", id + " " + parameterName + ":" + parameterValue);
|
|
}
|
|
}
|
|
|
|
mediaAttributes.put("mid", name);
|
|
|
|
mediaAttributes.put(descriptionTransport.senders.asMediaAttribute(isInitiatorContentMap), "");
|
|
if (description.hasChild("rtcp-mux", Namespace.JINGLE_APPS_RTP) || group != null) {
|
|
mediaAttributes.put("rtcp-mux", "");
|
|
}
|
|
|
|
// random additional attributes
|
|
mediaAttributes.put("rtcp", "9 IN IP4 0.0.0.0");
|
|
|
|
final MediaBuilder mediaBuilder = new MediaBuilder();
|
|
mediaBuilder.setMedia(description.getMedia().toString().toLowerCase(Locale.ROOT));
|
|
mediaBuilder.setConnectionData(HARDCODED_CONNECTION);
|
|
mediaBuilder.setPort(HARDCODED_MEDIA_PORT);
|
|
mediaBuilder.setProtocol(HARDCODED_MEDIA_PROTOCOL);
|
|
mediaBuilder.setAttributes(mediaAttributes);
|
|
mediaBuilder.setFormats(formatBuilder.build());
|
|
mediaListBuilder.add(mediaBuilder.createMedia());
|
|
}
|
|
sessionDescriptionBuilder.setVersion(0);
|
|
sessionDescriptionBuilder.setName("-");
|
|
sessionDescriptionBuilder.setMedia(mediaListBuilder.build());
|
|
sessionDescriptionBuilder.setAttributes(attributeMap);
|
|
|
|
return sessionDescriptionBuilder.createSessionDescription();
|
|
}
|
|
|
|
public static String checkNoWhitespace(final String input, final String message) {
|
|
if (CharMatcher.whitespace().matchesAnyOf(input)) {
|
|
throw new IllegalArgumentException(message);
|
|
}
|
|
return input;
|
|
}
|
|
|
|
public static int ignorantIntParser(final String input) {
|
|
try {
|
|
return Integer.parseInt(input);
|
|
} catch (NumberFormatException e) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static boolean isInt(final String input) {
|
|
if (input == null) {
|
|
return false;
|
|
}
|
|
try {
|
|
Integer.parseInt(input);
|
|
return true;
|
|
} catch (NumberFormatException e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static Pair<String, String> parseAttribute(final String input) {
|
|
final String[] pair = input.split(":", 2);
|
|
if (pair.length == 2) {
|
|
return new Pair<>(pair[0], pair[1]);
|
|
} else {
|
|
return new Pair<>(pair[0], "");
|
|
}
|
|
}
|
|
|
|
@NonNull
|
|
@Override
|
|
public String toString() {
|
|
final StringBuilder s =
|
|
new StringBuilder()
|
|
.append("v=")
|
|
.append(version)
|
|
.append(LINE_DIVIDER)
|
|
// TODO randomize or static
|
|
.append("o=- 8770656990916039506 2 IN IP4 127.0.0.1")
|
|
.append(LINE_DIVIDER) // what ever that means
|
|
.append("s=")
|
|
.append(name)
|
|
.append(LINE_DIVIDER)
|
|
.append("t=0 0")
|
|
.append(LINE_DIVIDER);
|
|
appendAttributes(s, attributes);
|
|
for (Media media : this.media) {
|
|
s.append("m=")
|
|
.append(media.media)
|
|
.append(' ')
|
|
.append(media.port)
|
|
.append(' ')
|
|
.append(media.protocol)
|
|
.append(' ')
|
|
.append(Joiner.on(' ').join(media.formats))
|
|
.append(LINE_DIVIDER);
|
|
s.append("c=").append(media.connectionData).append(LINE_DIVIDER);
|
|
appendAttributes(s, media.attributes);
|
|
}
|
|
return s.toString();
|
|
}
|
|
|
|
public static class Media {
|
|
public final String media;
|
|
public final int port;
|
|
public final String protocol;
|
|
public final List<Integer> formats;
|
|
public final String connectionData;
|
|
public final ArrayListMultimap<String, String> attributes;
|
|
|
|
public Media(
|
|
String media,
|
|
int port,
|
|
String protocol,
|
|
List<Integer> formats,
|
|
String connectionData,
|
|
ArrayListMultimap<String, String> attributes) {
|
|
this.media = media;
|
|
this.port = port;
|
|
this.protocol = protocol;
|
|
this.formats = formats;
|
|
this.connectionData = connectionData;
|
|
this.attributes = attributes;
|
|
}
|
|
}
|
|
}
|