/**
* Returns default <tt>WebRtcDataStream</tt> if it's ready or <tt>null</tt> otherwise.
*
* @return <tt>WebRtcDataStream</tt> if it's ready or <tt>null</tt> otherwise.
* @throws IOException
*/
public WebRtcDataStream getDefaultDataStream() throws IOException {
WebRtcDataStream def;
synchronized (this) {
if (sctpSocket == null) {
def = null;
} else {
// Channel that runs on sid 0
def = channels.get(0);
if (def == null) {
def = openChannel(0, 0, 0, 0, "default");
}
// Pawel Domas: Must be acknowledged before use
/*
* XXX Lyubomir Marinov: We're always sending ordered. According
* to "WebRTC Data Channel Establishment Protocol", we can start
* sending messages containing user data after the
* DATA_CHANNEL_OPEN message has been sent without waiting for
* the reception of the corresponding DATA_CHANNEL_ACK message.
*/
// if (!def.isAcknowledged())
// def = null;
}
}
return def;
}
/**
* {@inheritDoc}
*
* <p>SCTP input data callback.
*/
@Override
public void onSctpPacket(
byte[] data, int sid, int ssn, int tsn, long ppid, int context, int flags) {
if (ppid == WEB_RTC_PPID_CTRL) {
// Channel control PPID
try {
onCtrlPacket(data, sid);
} catch (IOException e) {
logger.error("IOException when processing ctrl packet", e);
}
} else if (ppid == WEB_RTC_PPID_STRING || ppid == WEB_RTC_PPID_BIN) {
WebRtcDataStream channel;
synchronized (this) {
channel = channels.get(sid);
}
if (channel == null) {
logger.error("No channel found for sid: " + sid);
return;
}
if (ppid == WEB_RTC_PPID_STRING) {
// WebRTC String
String str;
String charsetName = "UTF-8";
try {
str = new String(data, charsetName);
} catch (UnsupportedEncodingException uee) {
logger.error("Unsupported charset encoding/name " + charsetName, uee);
str = null;
}
channel.onStringMsg(str);
} else {
// WebRTC Binary
channel.onBinaryMsg(data);
}
} else {
logger.warn("Got message on unsupported PPID: " + ppid);
}
}
/**
* Opens new WebRTC data channel using specified parameters.
*
* @param type channel type as defined in control protocol description. Use 0 for "reliable".
* @param prio channel priority. The higher the number, the lower the priority.
* @param reliab Reliability Parameter<br>
* This field is ignored if a reliable channel is used. If a partial reliable channel with
* limited number of retransmissions is used, this field specifies the number of
* retransmissions. If a partial reliable channel with limited lifetime is used, this field
* specifies the maximum lifetime in milliseconds. The following table summarizes this:<br>
* </br>
* <p>+------------------------------------------------+------------------+ | Channel Type |
* Reliability | | | Parameter |
* +------------------------------------------------+------------------+ |
* DATA_CHANNEL_RELIABLE | Ignored | | DATA_CHANNEL_RELIABLE_UNORDERED | Ignored | |
* DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT | Number of RTX | |
* DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED | Number of RTX | |
* DATA_CHANNEL_PARTIAL_RELIABLE_TIMED | Lifetime in ms | |
* DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED | Lifetime in ms |
* +------------------------------------------------+------------------+
* @param sid SCTP stream id that will be used by new channel (it must not be already used).
* @param label text label for the channel.
* @return new instance of <tt>WebRtcDataStream</tt> that represents opened WebRTC data channel.
* @throws IOException if IO error occurs.
*/
public synchronized WebRtcDataStream openChannel(
int type, int prio, long reliab, int sid, String label) throws IOException {
if (channels.containsKey(sid)) {
throw new IOException("Channel on sid: " + sid + " already exists");
}
// Label Length & Label
byte[] labelBytes;
int labelByteLength;
if (label == null) {
labelBytes = null;
labelByteLength = 0;
} else {
labelBytes = label.getBytes("UTF-8");
labelByteLength = labelBytes.length;
if (labelByteLength > 0xFFFF) labelByteLength = 0xFFFF;
}
// Protocol Length & Protocol
String protocol = WEBRTC_DATA_CHANNEL_PROTOCOL;
byte[] protocolBytes;
int protocolByteLength;
if (protocol == null) {
protocolBytes = null;
protocolByteLength = 0;
} else {
protocolBytes = protocol.getBytes("UTF-8");
protocolByteLength = protocolBytes.length;
if (protocolByteLength > 0xFFFF) protocolByteLength = 0xFFFF;
}
ByteBuffer packet = ByteBuffer.allocate(12 + labelByteLength + protocolByteLength);
// Message open new channel on current sid
// Message Type
packet.put((byte) MSG_OPEN_CHANNEL);
// Channel Type
packet.put((byte) type);
// Priority
packet.putShort((short) prio);
// Reliability Parameter
packet.putInt((int) reliab);
// Label Length
packet.putShort((short) labelByteLength);
// Protocol Length
packet.putShort((short) protocolByteLength);
// Label
if (labelByteLength != 0) {
packet.put(labelBytes, 0, labelByteLength);
}
// Protocol
if (protocolByteLength != 0) {
packet.put(protocolBytes, 0, protocolByteLength);
}
int sentCount = sctpSocket.send(packet.array(), true, sid, WEB_RTC_PPID_CTRL);
if (sentCount != packet.capacity()) {
throw new IOException("Failed to open new chanel on sid: " + sid);
}
WebRtcDataStream channel = new WebRtcDataStream(sctpSocket, sid, label, false);
channels.put(sid, channel);
return channel;
}
/**
* Handles control packet.
*
* @param data raw packet data that arrived on control PPID.
* @param sid SCTP stream id on which the data has arrived.
*/
private synchronized void onCtrlPacket(byte[] data, int sid) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(data);
int messageType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
if (messageType == MSG_CHANNEL_ACK) {
if (logger.isDebugEnabled()) {
logger.debug(getEndpoint().getID() + " ACK received SID: " + sid);
}
// Open channel ACK
WebRtcDataStream channel = channels.get(sid);
if (channel != null) {
// Ack check prevents from firing multiple notifications
// if we get more than one ACKs (by mistake/bug).
if (!channel.isAcknowledged()) {
channel.ackReceived();
notifyChannelOpened(channel);
} else {
logger.warn("Redundant ACK received for SID: " + sid);
}
} else {
logger.error("No channel exists on sid: " + sid);
}
} else if (messageType == MSG_OPEN_CHANNEL) {
int channelType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
int priority = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
long reliability = /* 4 bytes unsigned integer */ 0xFFFFFFFFL & buffer.getInt();
int labelLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
int protocolLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
String label;
String protocol;
if (labelLength == 0) {
label = "";
} else {
byte[] labelBytes = new byte[labelLength];
buffer.get(labelBytes);
label = new String(labelBytes, "UTF-8");
}
if (protocolLength == 0) {
protocol = "";
} else {
byte[] protocolBytes = new byte[protocolLength];
buffer.get(protocolBytes);
protocol = new String(protocolBytes, "UTF-8");
}
if (logger.isDebugEnabled()) {
logger.debug(
"!!! "
+ getEndpoint().getID()
+ " data channel open request on SID: "
+ sid
+ " type: "
+ channelType
+ " prio: "
+ priority
+ " reliab: "
+ reliability
+ " label: "
+ label
+ " proto: "
+ protocol);
}
if (channels.containsKey(sid)) {
logger.error("Channel on sid: " + sid + " already exists");
}
WebRtcDataStream newChannel = new WebRtcDataStream(sctpSocket, sid, label, true);
channels.put(sid, newChannel);
sendOpenChannelAck(sid);
notifyChannelOpened(newChannel);
} else {
logger.error("Unexpected ctrl msg type: " + messageType);
}
}