/**
* Class is a transport layer for WebRTC data channels. It consists of SCTP connection running on
* top of ICE/DTLS layer. Manages WebRTC data channels. See
* http://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-08 for more info on WebRTC data
* channels.
*
* <p>Control protocol: http://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-03 FIXME handle
* closing of data channels(SCTP stream reset)
*
* @author Pawel Domas
* @author Lyubomir Marinov
* @author Boris Grozev
*/
public class SctpConnection extends Channel
implements SctpDataCallback, SctpSocket.NotificationListener {
/** Generator used to track debug IDs. */
private static int debugIdGen = -1;
/** DTLS transport buffer size. Note: randomly chosen. */
private static final int DTLS_BUFFER_SIZE = 2048;
/** Switch used for debugging SCTP traffic purposes. FIXME to be removed */
private static final boolean LOG_SCTP_PACKETS = false;
/** The logger */
private static final Logger logger = Logger.getLogger(SctpConnection.class);
/**
* Message type used to acknowledge WebRTC data channel allocation on SCTP stream ID on which
* <tt>MSG_OPEN_CHANNEL</tt> message arrives.
*/
private static final int MSG_CHANNEL_ACK = 0x2;
private static final byte[] MSG_CHANNEL_ACK_BYTES = new byte[] {MSG_CHANNEL_ACK};
/**
* Message with this type sent over control PPID in order to open new WebRTC data channel on SCTP
* stream ID that this message is sent.
*/
private static final int MSG_OPEN_CHANNEL = 0x3;
/** SCTP transport buffer size. */
private static final int SCTP_BUFFER_SIZE = DTLS_BUFFER_SIZE - 13;
/** The pool of <tt>Thread</tt>s which run <tt>SctpConnection</tt>s. */
private static final ExecutorService threadPool =
ExecutorUtils.newCachedThreadPool(true, SctpConnection.class.getName());
/** Payload protocol id that identifies binary data in WebRTC data channel. */
static final int WEB_RTC_PPID_BIN = 53;
/** Payload protocol id for control data. Used for <tt>WebRtcDataStream</tt> allocation. */
static final int WEB_RTC_PPID_CTRL = 50;
/** Payload protocol id that identifies text data UTF8 encoded in WebRTC data channels. */
static final int WEB_RTC_PPID_STRING = 51;
/**
* The <tt>String</tt> value of the <tt>Protocol</tt> field of the <tt>DATA_CHANNEL_OPEN</tt>
* message.
*/
private static final String WEBRTC_DATA_CHANNEL_PROTOCOL = "http://jitsi.org/protocols/colibri";
private static synchronized int generateDebugId() {
debugIdGen += 2;
return debugIdGen;
}
/**
* Indicates whether the STCP association is ready and has not been ended by a subsequent state
* change.
*/
private boolean assocIsUp;
/** Indicates if we have accepted incoming connection. */
private boolean acceptedIncomingConnection;
/** Data channels mapped by SCTP stream identified(sid). */
private final Map<Integer, WebRtcDataStream> channels = new HashMap<Integer, WebRtcDataStream>();
/** Debug ID used to distinguish SCTP sockets in packet logs. */
private final int debugId;
/**
* The <tt>AsyncExecutor</tt> which is to asynchronously dispatch the events fired by this
* instance in order to prevent possible listeners from blocking this <tt>SctpConnection</tt> in
* general and {@link #sctpSocket} in particular for too long. The timeout of <tt>15</tt> is
* chosen to be in accord with the time it takes to expire a <tt>Channel</tt>.
*/
private final AsyncExecutor<Runnable> eventDispatcher =
new AsyncExecutor<Runnable>(15, TimeUnit.MILLISECONDS);
/** Datagram socket for ICE/UDP layer. */
private IceSocketWrapper iceSocket;
/**
* List of <tt>WebRtcDataStreamListener</tt>s that will be notified whenever new WebRTC data
* channel is opened.
*/
private final List<WebRtcDataStreamListener> listeners =
new ArrayList<WebRtcDataStreamListener>();
/** Remote SCTP port. */
private final int remoteSctpPort;
/** <tt>SctpSocket</tt> used for SCTP transport. */
private SctpSocket sctpSocket;
/**
* Flag prevents from starting this connection multiple times from {@link #maybeStartStream()}.
*/
private boolean started;
/**
* Initializes a new <tt>SctpConnection</tt> instance.
*
* @param id the string identifier of this connection instance
* @param content the <tt>Content</tt> which is initializing the new instance
* @param endpoint the <tt>Endpoint</tt> of newly created instance
* @param remoteSctpPort the SCTP port used by remote peer
* @param channelBundleId the ID of the channel-bundle this <tt>SctpConnection</tt> is to be a
* part of (or <tt>null</tt> if no it is not to be a part of a channel-bundle).
* @throws Exception if an error occurs while initializing the new instance
*/
public SctpConnection(
String id, Content content, Endpoint endpoint, int remoteSctpPort, String channelBundleId)
throws Exception {
super(content, id, channelBundleId);
setEndpoint(endpoint.getID());
this.remoteSctpPort = remoteSctpPort;
this.debugId = generateDebugId();
}
/**
* Adds <tt>WebRtcDataStreamListener</tt> to the list of listeners.
*
* @param listener the <tt>WebRtcDataStreamListener</tt> to be added to the listeners list.
*/
public void addChannelListener(WebRtcDataStreamListener listener) {
if (listener == null) {
throw new NullPointerException("listener");
} else {
synchronized (listeners) {
if (!listeners.contains(listener)) {
listeners.add(listener);
}
}
}
}
/** {@inheritDoc} */
@Override
protected void closeStream() throws IOException {
try {
synchronized (this) {
assocIsUp = false;
acceptedIncomingConnection = false;
if (sctpSocket != null) {
sctpSocket.close();
sctpSocket = null;
}
}
} finally {
if (iceSocket != null) {
// It is now the responsibility of the transport manager to
// close the socket.
// iceUdpSocket.close();
}
}
}
/** {@inheritDoc} */
@Override
public void expire() {
try {
eventDispatcher.shutdown();
} finally {
super.expire();
}
}
/**
* Gets the <tt>WebRtcDataStreamListener</tt>s added to this instance.
*
* @return the <tt>WebRtcDataStreamListener</tt>s added to this instance or <tt>null</tt> if there
* are no <tt>WebRtcDataStreamListener</tt>s added to this instance
*/
private WebRtcDataStreamListener[] getChannelListeners() {
WebRtcDataStreamListener[] ls;
synchronized (listeners) {
if (listeners.isEmpty()) {
ls = null;
} else {
ls = listeners.toArray(new WebRtcDataStreamListener[listeners.size()]);
}
}
return ls;
}
/**
* 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;
}
/**
* Returns <tt>true</tt> if this <tt>SctpConnection</tt> is connected to the remote peer and
* operational.
*
* @return <tt>true</tt> if this <tt>SctpConnection</tt> is connected to the remote peer and
* operational
*/
public boolean isReady() {
return assocIsUp && acceptedIncomingConnection;
}
/** {@inheritDoc} */
@Override
protected void maybeStartStream() throws IOException {
// connector
final StreamConnector connector = getStreamConnector();
if (connector == null) return;
synchronized (this) {
if (started) return;
threadPool.execute(
new Runnable() {
@Override
public void run() {
try {
Sctp.init();
runOnDtlsTransport(connector);
} catch (IOException e) {
logger.error(e, e);
} finally {
try {
Sctp.finish();
} catch (IOException e) {
logger.error("Failed to shutdown SCTP stack", e);
}
}
}
});
started = true;
}
}
/**
* Submits {@link #notifyChannelOpenedInEventDispatcher(WebRtcDataStream)} to {@link
* #eventDispatcher} for asynchronous execution.
*
* @param dataChannel
*/
private void notifyChannelOpened(final WebRtcDataStream dataChannel) {
if (!isExpired()) {
eventDispatcher.execute(
new Runnable() {
@Override
public void run() {
notifyChannelOpenedInEventDispatcher(dataChannel);
}
});
}
}
private void notifyChannelOpenedInEventDispatcher(WebRtcDataStream dataChannel) {
/*
* When executing asynchronously in eventDispatcher, it is technically
* possible that this SctpConnection may have expired by now.
*/
if (!isExpired()) {
WebRtcDataStreamListener[] ls = getChannelListeners();
if (ls != null) {
for (WebRtcDataStreamListener l : ls) {
l.onChannelOpened(this, dataChannel);
}
}
}
}
/**
* Submits {@link #notifySctpConnectionReadyInEventDispatcher()} to {@link #eventDispatcher} for
* asynchronous execution.
*/
private void notifySctpConnectionReady() {
if (!isExpired()) {
eventDispatcher.execute(
new Runnable() {
@Override
public void run() {
notifySctpConnectionReadyInEventDispatcher();
}
});
}
}
/**
* Notifies the <tt>WebRtcDataStreamListener</tt>s added to this instance that this
* <tt>SctpConnection</tt> is ready i.e. it is connected to the remote peer and operational.
*/
private void notifySctpConnectionReadyInEventDispatcher() {
/*
* When executing asynchronously in eventDispatcher, it is technically
* possible that this SctpConnection may have expired by now.
*/
if (!isExpired() && isReady()) {
WebRtcDataStreamListener[] ls = getChannelListeners();
if (ls != null) {
for (WebRtcDataStreamListener l : ls) {
l.onSctpConnectionReady(this);
}
}
}
}
/**
* 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);
}
}
/** {@inheritDoc} */
@Override
protected void onEndpointChanged(Endpoint oldValue, Endpoint newValue) {
if (oldValue != null) oldValue.setSctpConnection(null);
if (newValue != null) newValue.setSctpConnection(this);
}
/** Implements notification in order to track socket state. */
@Override
public synchronized void onSctpNotification(SctpSocket socket, SctpNotification notification) {
if (logger.isDebugEnabled()) {
logger.debug("socket=" + socket + "; notification=" + notification);
}
switch (notification.sn_type) {
case SctpNotification.SCTP_ASSOC_CHANGE:
SctpNotification.AssociationChange assocChange =
(SctpNotification.AssociationChange) notification;
switch (assocChange.state) {
case SctpNotification.AssociationChange.SCTP_COMM_UP:
if (!assocIsUp) {
boolean wasReady = isReady();
assocIsUp = true;
if (isReady() && !wasReady) notifySctpConnectionReady();
}
break;
case SctpNotification.AssociationChange.SCTP_COMM_LOST:
case SctpNotification.AssociationChange.SCTP_SHUTDOWN_COMP:
case SctpNotification.AssociationChange.SCTP_CANT_STR_ASSOC:
try {
closeStream();
} catch (IOException e) {
logger.error("Error closing SCTP socket", e);
}
break;
}
break;
}
}
/**
* {@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;
}
/**
* Removes <tt>WebRtcDataStreamListener</tt> from the list of listeners.
*
* @param listener the <tt>WebRtcDataStreamListener</tt> to be removed from the listeners list.
*/
public void removeChannelListener(WebRtcDataStreamListener listener) {
if (listener != null) {
synchronized (listeners) {
listeners.remove(listener);
}
}
}
private void runOnDtlsTransport(StreamConnector connector) throws IOException {
DtlsControlImpl dtlsControl = (DtlsControlImpl) getTransportManager().getDtlsControl(this);
DtlsTransformEngine engine = dtlsControl.getTransformEngine();
final DtlsPacketTransformer transformer = (DtlsPacketTransformer) engine.getRTPTransformer();
byte[] receiveBuffer = new byte[SCTP_BUFFER_SIZE];
if (LOG_SCTP_PACKETS) {
System.setProperty(
ConfigurationService.PNAME_SC_HOME_DIR_LOCATION, System.getProperty("java.io.tmpdir"));
System.setProperty(
ConfigurationService.PNAME_SC_HOME_DIR_NAME, SctpConnection.class.getName());
}
synchronized (this) {
// FIXME local SCTP port is hardcoded in bridge offer SDP (Jitsi
// Meet)
sctpSocket = Sctp.createSocket(5000);
assocIsUp = false;
acceptedIncomingConnection = false;
}
// Implement output network link for SCTP stack on DTLS transport
sctpSocket.setLink(
new NetworkLink() {
@Override
public void onConnOut(SctpSocket s, byte[] packet) throws IOException {
if (LOG_SCTP_PACKETS) {
LibJitsi.getPacketLoggingService()
.logPacket(
PacketLoggingService.ProtocolName.ICE4J,
new byte[] {0, 0, 0, (byte) debugId},
5000,
new byte[] {0, 0, 0, (byte) (debugId + 1)},
remoteSctpPort,
PacketLoggingService.TransportName.UDP,
true,
packet);
}
// Send through DTLS transport
transformer.sendApplicationData(packet, 0, packet.length);
}
});
if (logger.isDebugEnabled()) {
logger.debug("Connecting SCTP to port: " + remoteSctpPort + " to " + getEndpoint().getID());
}
sctpSocket.setNotificationListener(this);
sctpSocket.listen();
// FIXME manage threads
threadPool.execute(
new Runnable() {
@Override
public void run() {
SctpSocket sctpSocket = null;
try {
// sctpSocket is set to null on close
sctpSocket = SctpConnection.this.sctpSocket;
while (sctpSocket != null) {
if (sctpSocket.accept()) {
acceptedIncomingConnection = true;
break;
}
Thread.sleep(100);
sctpSocket = SctpConnection.this.sctpSocket;
}
if (isReady()) {
notifySctpConnectionReady();
}
} catch (Exception e) {
logger.error("Error accepting SCTP connection", e);
}
if (sctpSocket == null && logger.isInfoEnabled()) {
logger.info(
"SctpConnection " + getID() + " closed" + " before SctpSocket accept()-ed.");
}
}
});
// Notify that from now on SCTP connection is considered functional
sctpSocket.setDataCallback(this);
// Setup iceSocket
DatagramSocket datagramSocket = connector.getDataSocket();
if (datagramSocket != null) {
this.iceSocket = new IceUdpSocketWrapper(datagramSocket);
} else {
this.iceSocket = new IceTcpSocketWrapper(connector.getDataTCPSocket());
}
DatagramPacket rcvPacket = new DatagramPacket(receiveBuffer, 0, receiveBuffer.length);
// Receive loop, breaks when SCTP socket is closed
try {
do {
iceSocket.receive(rcvPacket);
RawPacket raw =
new RawPacket(rcvPacket.getData(), rcvPacket.getOffset(), rcvPacket.getLength());
raw = transformer.reverseTransform(raw);
// Check for app data
if (raw == null) continue;
if (LOG_SCTP_PACKETS) {
LibJitsi.getPacketLoggingService()
.logPacket(
PacketLoggingService.ProtocolName.ICE4J,
new byte[] {0, 0, 0, (byte) (debugId + 1)},
remoteSctpPort,
new byte[] {0, 0, 0, (byte) debugId},
5000,
PacketLoggingService.TransportName.UDP,
false,
raw.getBuffer(),
raw.getOffset(),
raw.getLength());
}
// Pass network packet to SCTP stack
sctpSocket.onConnIn(raw.getBuffer(), raw.getOffset(), raw.getLength());
} while (true);
} finally {
// Eventually, close the socket although it should happen from
// expire().
synchronized (this) {
assocIsUp = false;
acceptedIncomingConnection = false;
if (sctpSocket != null) {
sctpSocket.close();
sctpSocket = null;
}
}
}
}
/**
* Sends acknowledgment for open channel request on given SCTP stream ID.
*
* @param sid SCTP stream identifier to be used for sending ack.
*/
private void sendOpenChannelAck(int sid) throws IOException {
// Send ACK
byte[] ack = MSG_CHANNEL_ACK_BYTES;
int sendAck = sctpSocket.send(ack, true, sid, WEB_RTC_PPID_CTRL);
if (sendAck != ack.length) {
logger.error("Failed to send open channel confirmation");
}
}
/**
* {@inheritDoc}
*
* <p>Creates a <tt>TransportManager</tt> instance suitable for an <tt>SctpConnection</tt> (e.g.
* with 1 component only).
*/
protected TransportManager createTransportManager(String xmlNamespace) throws IOException {
if (IceUdpTransportPacketExtension.NAMESPACE.equals(xmlNamespace)) {
Content content = getContent();
return new IceUdpTransportManager(
content.getConference(), isInitiator(), 1 /* num components */, content.getName());
} else if (RawUdpTransportPacketExtension.NAMESPACE.equals(xmlNamespace)) {
// TODO: support RawUdp once RawUdpTransportManager is updated
// return new RawUdpTransportManager(this);
throw new IllegalArgumentException("Unsupported Jingle transport " + xmlNamespace);
} else {
throw new IllegalArgumentException("Unsupported Jingle transport " + xmlNamespace);
}
}
}
/**
* Implements a <tt>CandidateHarvester</tt> which gathers <tt>Candidate</tt>s for a specified {@link
* Component} using UPnP.
*
* @author Sebastien Vincent
*/
public class UPNPHarvester extends AbstractCandidateHarvester {
/** The logger. */
private static final Logger logger = Logger.getLogger(UPNPHarvester.class.getName());
/** Maximum port to try to allocate. */
private static final int MAX_RETRIES = 5;
/** ST search field for WANIPConnection. */
private static final String stIP = "urn:schemas-upnp-org:service:WANIPConnection:1";
/** ST search field for WANPPPConnection. */
private static final String stPPP = "urn:schemas-upnp-org:service:WANPPPConnection:1";
/** Synchronization object. */
private final Object rootSync = new Object();
/** Gateway device. */
private GatewayDevice device = null;
/** Number of UPnP discover threads that have finished. */
private int finishThreads = 0;
/**
* Gathers UPnP candidates for all host <tt>Candidate</tt>s that are already present in the
* specified <tt>component</tt>. This method relies on the specified <tt>component</tt> to already
* contain all its host candidates so that it would resolve them.
*
* @param component the {@link Component} that we'd like to gather candidate UPnP
* <tt>Candidate</tt>s for
* @return the <tt>LocalCandidate</tt>s gathered by this <tt>CandidateHarvester</tt>
*/
public synchronized Collection<LocalCandidate> harvest(Component component) {
Collection<LocalCandidate> candidates = new HashSet<>();
int retries = 0;
logger.fine("Begin UPnP harvesting");
try {
if (device == null) {
// do it only once
if (finishThreads == 0) {
try {
UPNPThread wanIPThread = new UPNPThread(stIP);
UPNPThread wanPPPThread = new UPNPThread(stPPP);
wanIPThread.start();
wanPPPThread.start();
synchronized (rootSync) {
while (finishThreads != 2) {
rootSync.wait();
}
}
if (wanIPThread.getDevice() != null) {
device = wanIPThread.getDevice();
} else if (wanPPPThread.getDevice() != null) {
device = wanPPPThread.getDevice();
}
} catch (Throwable e) {
logger.info("UPnP discovery failed: " + e);
}
}
if (device == null) return candidates;
}
InetAddress localAddress = device.getLocalAddress();
String externalIPAddress = device.getExternalIPAddress();
PortMappingEntry portMapping = new PortMappingEntry();
IceSocketWrapper socket =
new IceUdpSocketWrapper(new MultiplexingDatagramSocket(0, localAddress));
int port = socket.getLocalPort();
int externalPort = socket.getLocalPort();
while (retries < MAX_RETRIES) {
if (!device.getSpecificPortMappingEntry(port, "UDP", portMapping)) {
if (device.addPortMapping(
externalPort, port, localAddress.getHostAddress(), "UDP", "ice4j.org: " + port)) {
List<LocalCandidate> cands =
createUPNPCandidate(socket, externalIPAddress, externalPort, component, device);
logger.info("Add UPnP port mapping: " + externalIPAddress + " " + externalPort);
// we have to add the UPNPCandidate and also the base.
// if we don't add the base, we won't be able to add
// peer reflexive candidate if someone contact us on the
// UPNPCandidate
for (LocalCandidate cand : cands) {
// try to add the candidate to the component and then
// only add it to the harvest not redundant
if (component.addLocalCandidate(cand)) {
candidates.add(cand);
}
}
break;
} else {
port++;
}
} else {
port++;
}
retries++;
}
} catch (Throwable e) {
logger.info("Exception while gathering UPnP candidates: " + e);
}
return candidates;
}
/**
* Create a UPnP candidate.
*
* @param socket local socket
* @param externalIP external IP address
* @param port local port
* @param component parent component
* @param device the UPnP gateway device
* @return a new <tt>UPNPCandidate</tt> instance which represents the specified
* <tt>TransportAddress</tt>
* @throws Exception if something goes wrong during candidate creation
*/
private List<LocalCandidate> createUPNPCandidate(
IceSocketWrapper socket,
String externalIP,
int port,
Component component,
GatewayDevice device)
throws Exception {
List<LocalCandidate> ret = new ArrayList<>();
TransportAddress addr = new TransportAddress(externalIP, port, Transport.UDP);
HostCandidate base = new HostCandidate(socket, component);
UPNPCandidate candidate = new UPNPCandidate(addr, base, component, device);
IceSocketWrapper stunSocket = candidate.getStunSocket(null);
candidate.getStunStack().addSocket(stunSocket);
component.getComponentSocket().add(candidate.getCandidateIceSocketWrapper());
ret.add(candidate);
ret.add(base);
return ret;
}
/** UPnP discover thread. */
private class UPNPThread extends Thread {
/** Gateway device. */
private GatewayDevice device = null;
/** ST search field. */
private final String st;
/**
* Constructor.
*
* @param st ST search field
*/
public UPNPThread(String st) {
this.st = st;
}
/**
* Returns gateway device.
*
* @return gateway device
*/
public GatewayDevice getDevice() {
return device;
}
/** Thread Entry point. */
public void run() {
try {
GatewayDiscover gd = new GatewayDiscover(st);
gd.discover();
if (gd.getValidGateway() != null) {
device = gd.getValidGateway();
}
} catch (Throwable e) {
logger.info("Failed to harvest UPnP: " + e);
/*
* The Javadoc on ThreadDeath says: If ThreadDeath is caught by
* a method, it is important that it be rethrown so that the
* thread actually dies.
*/
if (e instanceof ThreadDeath) throw (ThreadDeath) e;
} finally {
synchronized (rootSync) {
finishThreads++;
rootSync.notify();
}
}
}
}
/**
* Returns a <tt>String</tt> representation of this harvester containing its name.
*
* @return a <tt>String</tt> representation of this harvester containing its name.
*/
@Override
public String toString() {
return getClass().getSimpleName();
}
}
/**
* The Network Access Point is the most outward part of the stack. It is constructed around a
* datagram socket and takes care of forwarding incoming messages to the MessageProcessor as well as
* sending datagrams to the STUN server specified by the original NetAccessPointDescriptor.
*
* @author Emil Ivov
*/
class Connector implements Runnable {
/** Our class logger. */
private static final Logger logger = Logger.getLogger(Connector.class.getName());
/** The message queue is where incoming messages are added. */
private final MessageQueue messageQueue;
/** The socket object that used by this access point to access the network. */
private IceSocketWrapper sock;
/** The object that we use to lock socket operations (since the socket itself is often null) */
private final Object sockLock = new Object();
/** A flag that is set to false to exit the message processor. */
private boolean running;
/** The instance to be notified if errors occur in the network listening thread. */
private final ErrorHandler errorHandler;
/** The address that we are listening to. */
private final TransportAddress listenAddress;
/**
* The remote address of the socket of this <tt>Connector</tt> if it is a TCP socket, or
* <tt>null</tt> if it is UDP.
*/
private final TransportAddress remoteAddress;
/**
* Creates a network access point.
*
* @param socket the socket that this access point is supposed to use for communication.
* @param messageQueue the FIFO list where incoming messages should be queued
* @param errorHandler the instance to notify when errors occur.
*/
protected Connector(
IceSocketWrapper socket, MessageQueue messageQueue, ErrorHandler errorHandler) {
this.sock = socket;
this.messageQueue = messageQueue;
this.errorHandler = errorHandler;
Transport transport = socket.getUDPSocket() != null ? Transport.UDP : Transport.TCP;
listenAddress =
new TransportAddress(socket.getLocalAddress(), socket.getLocalPort(), transport);
if (transport == Transport.UDP) {
remoteAddress = null;
} else {
Socket tcpSocket = socket.getTCPSocket();
remoteAddress =
new TransportAddress(tcpSocket.getInetAddress(), tcpSocket.getPort(), transport);
}
}
/** Start the network listening thread. */
void start() {
this.running = true;
Thread thread = new Thread(this, "IceConnector@" + hashCode());
thread.setDaemon(true);
thread.start();
}
/**
* Returns the <tt>DatagramSocket</tt> that contains the port and address associated with this
* access point.
*
* @return the <tt>DatagramSocket</tt> associated with this AP.
*/
protected IceSocketWrapper getSocket() {
return sock;
}
/** The listening thread's run method. */
@Override
public void run() {
DatagramPacket packet = null;
while (this.running) {
try {
IceSocketWrapper localSock;
synchronized (sockLock) {
if (!running) return;
localSock = this.sock;
}
/*
* Make sure localSock's receiveBufferSize is taken into
* account including after it gets changed.
*/
int receiveBufferSize = 1500;
/*
if(localSock.getTCPSocket() != null)
{
receiveBufferSize = localSock.getTCPSocket().
getReceiveBufferSize();
}
else if(localSock.getUDPSocket() != null)
{
receiveBufferSize = localSock.getUDPSocket().
getReceiveBufferSize();
}
*/
if (packet == null) {
packet = new DatagramPacket(new byte[receiveBufferSize], receiveBufferSize);
} else {
byte[] packetData = packet.getData();
if ((packetData == null) || (packetData.length < receiveBufferSize)) {
packet.setData(new byte[receiveBufferSize], 0, receiveBufferSize);
} else {
/*
* XXX Tell the packet it is large enough because the
* socket will not look at the length of the data array
* property and will just respect the length property.
*/
packet.setLength(receiveBufferSize);
}
}
localSock.receive(packet);
// get lost if we are no longer running.
if (!running) return;
logger.finest("received datagram");
RawMessage rawMessage =
new RawMessage(
packet.getData(),
packet.getLength(),
new TransportAddress(
packet.getAddress(), packet.getPort(), listenAddress.getTransport()),
listenAddress);
messageQueue.add(rawMessage);
} catch (SocketException ex) {
if (running) {
logger.log(
Level.WARNING, "Connector died: " + listenAddress + " -> " + remoteAddress, ex);
stop();
// Something wrong has happened
errorHandler.handleFatalError(
this, "A socket exception was thrown" + " while trying to receive a message.", ex);
} else {
// The exception was most probably caused by calling
// this.stop().
}
} catch (ClosedChannelException cce) {
logger.log(Level.WARNING, "A net access point has gone useless:", cce);
stop();
errorHandler.handleFatalError(
this, "ClosedChannelException occurred while listening" + " for messages!", cce);
} catch (IOException ex) {
logger.log(Level.WARNING, "A net access point has gone useless:", ex);
errorHandler.handleError(ex.getMessage(), ex);
// do not stop the thread;
} catch (Throwable ex) {
logger.log(Level.WARNING, "A net access point has gone useless:", ex);
stop();
errorHandler.handleFatalError(
this, "Unknown error occurred while listening for messages!", ex);
}
}
}
/** Makes the access point stop listening on its socket. */
protected void stop() {
synchronized (sockLock) {
this.running = false;
if (this.sock != null) {
this.sock.close();
this.sock = null;
}
}
}
/**
* Sends message through this access point's socket.
*
* @param message the bytes to send.
* @param address message destination.
* @throws IOException if an exception occurs while sending the message.
*/
void sendMessage(byte[] message, TransportAddress address) throws IOException {
DatagramPacket datagramPacket = new DatagramPacket(message, 0, message.length, address);
sock.send(datagramPacket);
}
/**
* Returns a String representation of the object.
*
* @return a String representation of the object.
*/
@Override
public String toString() {
return "ice4j.Connector@" + listenAddress + " status: " + (running ? "not" : "") + " running";
}
/**
* Returns the <tt>TransportAddress</tt> that this access point is bound on.
*
* @return the <tt>TransportAddress</tt> associated with this AP.
*/
TransportAddress getListenAddress() {
return listenAddress;
}
/**
* Returns the remote <tt>TransportAddress</tt> in case of TCP, or <tt>null</tt> in case of UDP.
*
* @return the remote <tt>TransportAddress</tt> in case of TCP, or <tt>null</tt> in case of UDP.
*/
TransportAddress getRemoteAddress() {
return remoteAddress;
}
}
/**
* Implements a <tt>CandidateHarvester</tt> which gathers <tt>Candidate</tt>s for a specified {@link
* Component} using Jingle Nodes as defined in XEP 278 "Jingle Relay Nodes".
*
* @author Sebastien Vincent
*/
public class JingleNodesHarvester extends AbstractCandidateHarvester {
/**
* The <tt>Logger</tt> used by the <tt>JingleNodesHarvester</tt> class and its instances for
* logging output.
*/
private static final Logger logger = Logger.getLogger(JingleNodesHarvester.class.getName());
/** XMPP connection. */
private SmackServiceNode serviceNode = null;
/**
* JingleNodes relay allocate two address/port couple for us. Due to the architecture of Ice4j
* that harvest address for each component, we store the second address/port couple.
*/
private TransportAddress localAddressSecond = null;
/**
* JingleNodes relay allocate two address/port couple for us. Due to the architecture of Ice4j
* that harvest address for each component, we store the second address/port couple.
*/
private TransportAddress relayedAddressSecond = null;
/**
* Constructor.
*
* @param serviceNode the <tt>SmackServiceNode</tt>
*/
public JingleNodesHarvester(SmackServiceNode serviceNode) {
this.serviceNode = serviceNode;
}
/**
* Gathers Jingle Nodes candidates for all host <tt>Candidate</tt>s that are already present in
* the specified <tt>component</tt>. This method relies on the specified <tt>component</tt> to
* already contain all its host candidates so that it would resolve them.
*
* @param component the {@link Component} that we'd like to gather candidate Jingle Nodes
* <tt>Candidate</tt>s for
* @return the <tt>LocalCandidate</tt>s gathered by this <tt>CandidateHarvester</tt>
*/
@Override
public synchronized Collection<LocalCandidate> harvest(Component component) {
logger.info("harvest Jingle Nodes");
Collection<LocalCandidate> candidates = new HashSet<LocalCandidate>();
String ip = null;
int port = -1;
/* if we have already a candidate (RTCP) allocated, get it */
if (localAddressSecond != null && relayedAddressSecond != null) {
LocalCandidate candidate =
createJingleNodesCandidate(relayedAddressSecond, component, localAddressSecond);
// try to add the candidate to the component and then only add it to
// the harvest not redundant (not sure how it could be red. but ...)
if (component.addLocalCandidate(candidate)) {
candidates.add(candidate);
}
localAddressSecond = null;
relayedAddressSecond = null;
return candidates;
}
XMPPConnection conn = serviceNode.getConnection();
JingleChannelIQ ciq = null;
if (serviceNode != null) {
final TrackerEntry preferred = serviceNode.getPreferedRelay();
if (preferred != null) {
ciq = SmackServiceNode.getChannel(conn, preferred.getJid());
}
}
if (ciq != null) {
ip = ciq.getHost();
port = ciq.getRemoteport();
if (logger.isInfoEnabled()) {
logger.info(
"JN relay: " + ip + " remote port:" + port + " local port: " + ciq.getLocalport());
}
if (ip == null || ciq.getRemoteport() == 0) {
logger.warn("JN relay ignored because ip was null or port 0");
return candidates;
}
// Drop the scope or interface name if the relay sends it
// along in its IPv6 address. The scope/ifname is only valid on the
// host that owns the IP and we don't need it here.
int scopeIndex = ip.indexOf('%');
if (scopeIndex > 0) {
logger.warn("Dropping scope from assumed IPv6 address " + ip);
ip = ip.substring(0, scopeIndex);
}
/* RTP */
TransportAddress relayedAddress = new TransportAddress(ip, port, Transport.UDP);
TransportAddress localAddress = new TransportAddress(ip, ciq.getLocalport(), Transport.UDP);
LocalCandidate local = createJingleNodesCandidate(relayedAddress, component, localAddress);
/* RTCP */
relayedAddressSecond = new TransportAddress(ip, port + 1, Transport.UDP);
localAddressSecond = new TransportAddress(ip, ciq.getLocalport() + 1, Transport.UDP);
// try to add the candidate to the component and then only add it to
// the harvest not redundant (not sure how it could be red. but ...)
if (component.addLocalCandidate(local)) {
candidates.add(local);
}
}
return candidates;
}
/**
* Creates a new <tt>JingleNodesRelayedCandidate</tt> instance which is to represent a specific
* <tt>TransportAddress</tt>.
*
* @param transportAddress the <tt>TransportAddress</tt> allocated by the relay
* @param component the <tt>Component</tt> for which the candidate will be added
* @param localEndPoint <tt>TransportAddress</tt> of the Jingle Nodes relay where we will send our
* packet.
* @return a new <tt>JingleNodesRelayedCandidate</tt> instance which represents the specified
* <tt>TransportAddress</tt>
*/
protected JingleNodesCandidate createJingleNodesCandidate(
TransportAddress transportAddress, Component component, TransportAddress localEndPoint) {
JingleNodesCandidate cand = null;
try {
cand = new JingleNodesCandidate(transportAddress, component, localEndPoint);
IceSocketWrapper stunSocket = cand.getStunSocket(null);
cand.getStunStack().addSocket(stunSocket);
} catch (Throwable e) {
logger.debug("Exception occurred when creating JingleNodesCandidate: " + e);
}
return cand;
}
}
/** * @author Bing SU ([email protected]) * @author Lyubomir Marinov * @author Boris Grozev */ public abstract class RTPConnectorInputStream implements PushSourceStream, Runnable { /** * The value of the property <tt>controls</tt> of <tt>RTPConnectorInputStream</tt> when there are * no controls. Explicitly defined in order to reduce unnecessary allocations. */ private static final Object[] EMPTY_CONTROLS = new Object[0]; /** * The length in bytes of the buffers of <tt>RTPConnectorInputStream</tt> receiving packets from * the network. */ public static final int PACKET_RECEIVE_BUFFER_LENGTH = 4 * 1024; /** * The <tt>Logger</tt> used by the <tt>RTPConnectorInputStream</tt> class and its instances to * print debug information. */ private static final Logger logger = Logger.getLogger(RTPConnectorInputStream.class); /** Packet receive buffer */ private final byte[] buffer = new byte[PACKET_RECEIVE_BUFFER_LENGTH]; /** Whether this stream is closed. Used to control the termination of worker thread. */ protected boolean closed; public Participant videoRecorder; /** * The <tt>DatagramPacketFilter</tt>s which allow dropping <tt>DatagramPacket</tt>s before they * are converted into <tt>RawPacket</tt>s. */ private DatagramPacketFilter[] datagramPacketFilters; /** Caught an IO exception during read from socket */ protected boolean ioError = false; /** * The packet data to be read out of this instance through its {@link #read(byte[], int, int)} * method. */ private RawPacket pkt; /** The <tt>Object</tt> which synchronizes the access to {@link #pkt}. */ private final Object pktSyncRoot = new Object(); /** The adapter of this <tt>PushSourceStream</tt> to the <tt>PushBufferStream</tt> interface. */ private final PushBufferStream pushBufferStream; /** * The pool of <tt>RawPacket[]</tt> instances to reduce their allocations and garbage collection. * Contains arrays full of <tt>null</tt>. */ private final Queue<RawPacket[]> rawPacketArrayPool = new LinkedBlockingQueue<RawPacket[]>(); /** * The pool of <tt>RawPacket</tt> instances to reduce their allocations and garbage collection. */ private final Queue<RawPacket> rawPacketPool = new LinkedBlockingQueue<RawPacket>(); /** The Thread receiving packets. */ protected Thread receiverThread = null; /** SourceTransferHandler object which is used to read packets. */ private SourceTransferHandler transferHandler; /** * Whether this <tt>RTPConnectorInputStream</tt> is enabled or disabled. While disabled, the * stream does not accept any packets. */ private boolean enabled = true; /** * Initializes a new <tt>RTPConnectorInputStream</tt> which is to receive packet data from a * specific UDP socket. */ public RTPConnectorInputStream() { // PacketLoggingService addDatagramPacketFilter( new DatagramPacketFilter() { /** * Used for debugging. As we don't log every packet, we must count them and decide which * to log. */ private long numberOfPackets = 0; public boolean accept(DatagramPacket p) { numberOfPackets++; if (RTPConnectorOutputStream.logPacket(numberOfPackets)) { PacketLoggingService packetLogging = LibJitsi.getPacketLoggingService(); if ((packetLogging != null) && packetLogging.isLoggingEnabled(PacketLoggingService.ProtocolName.RTP)) doLogPacket(p); } return true; } }); /* * Adapt this PushSourceStream to the PushBufferStream interface in * order to make it possible to read the Buffer flags of RawPacket. */ pushBufferStream = new PushBufferStreamAdapter(this, null) { @Override protected int doRead(Buffer buffer, byte[] data, int offset, int length) throws IOException { return RTPConnectorInputStream.this.read(buffer, data, offset, length); } }; } /** Close this stream, stops the worker thread. */ public synchronized void close() {} /** * Creates a new <tt>RawPacket</tt> from a specific <tt>DatagramPacket</tt> in order to have this * instance receive its packet data through its {@link #read(byte[], int, int)} method. Returns an * array of <tt>RawPacket</tt> with the created packet as its first element (and <tt>null</tt> for * the other elements). * * <p>Allows extenders to intercept the packet data and possibly filter and/or modify it. * * @param datagramPacket the <tt>DatagramPacket</tt> containing the packet data * @return an array of <tt>RawPacket</tt> containing the <tt>RawPacket</tt> which contains the * packet data of the specified <tt>DatagramPacket</tt> as its first element. */ protected RawPacket[] createRawPacket(DatagramPacket datagramPacket) { RawPacket[] pkts = rawPacketArrayPool.poll(); if (pkts == null) pkts = new RawPacket[1]; RawPacket pkt = rawPacketPool.poll(); if (pkt == null) pkt = new RawPacket(); pkt.setBuffer(datagramPacket.getData()); pkt.setFlags(0); pkt.setLength(datagramPacket.getLength()); pkt.setOffset(datagramPacket.getOffset()); pkts[0] = pkt; return pkts; } /** * Provides a dummy implementation to {@link RTPConnectorInputStream#endOfStream()} that always * returns <tt>false</tt>. * * @return <tt>false</tt>, no matter what. */ public boolean endOfStream() { return false; } /** * Provides a dummy implementation to {@link RTPConnectorInputStream#getContentDescriptor()} that * always returns <tt>null</tt>. * * @return <tt>null</tt>, no matter what. */ public ContentDescriptor getContentDescriptor() { return null; } /** * Provides a dummy implementation to {@link RTPConnectorInputStream#getContentLength()} that * always returns <tt>LENGTH_UNKNOWN</tt>. * * @return <tt>LENGTH_UNKNOWN</tt>, no matter what. */ public long getContentLength() { return LENGTH_UNKNOWN; } /** * Provides a dummy implementation of {@link RTPConnectorInputStream#getControl(String)} that * always returns <tt>null</tt>. * * @param controlType ignored. * @return <tt>null</tt>, no matter what. */ public Object getControl(String controlType) { if (PushBufferStream.class.getName().equals(controlType)) return pushBufferStream; else return null; } /** * Provides a dummy implementation of {@link RTPConnectorInputStream#getControls()} that always * returns <tt>EMPTY_CONTROLS</tt>. * * @return <tt>EMPTY_CONTROLS</tt>, no matter what. */ public Object[] getControls() { return EMPTY_CONTROLS; } /** * Provides a dummy implementation to {@link RTPConnectorInputStream#getMinimumTransferSize()} * that always returns <tt>2 * 1024</tt>. * * @return <tt>2 * 1024</tt>, no matter what. */ public int getMinimumTransferSize() { return 2 * 1024; // twice the MTU size, just to be safe. } /** * Pools the specified <tt>RawPacket</tt> in order to avoid future allocations and to reduce the * effects of garbage collection. * * @param pkt the <tt>RawPacket</tt> to be offered to {@link #rawPacketPool} */ private void poolRawPacket(RawPacket pkt) { pkt.setBuffer(null); pkt.setFlags(0); pkt.setLength(0); pkt.setOffset(0); rawPacketPool.offer(pkt); } /** * Copies the content of the most recently received packet into <tt>buffer</tt>. * * @param buffer the <tt>byte[]</tt> that we'd like to copy the content of the packet to. * @param offset the position where we are supposed to start writing in <tt>buffer</tt>. * @param length the number of <tt>byte</tt>s available for writing in <tt>buffer</tt>. * @return the number of bytes read * @throws IOException if <tt>length</tt> is less than the size of the packet. */ public int read(byte[] buffer, int offset, int length) throws IOException { return read(null, buffer, offset, length); } /** * Copies the content of the most recently received packet into <tt>data</tt>. * * @param buffer an optional <tt>Buffer</tt> instance associated with the specified <tt>data</tt>, * <tt>offset</tt> and <tt>length</tt> and provided to the method in case the implementation * would like to provide additional <tt>Buffer</tt> properties such as <tt>flags</tt> * @param data the <tt>byte[]</tt> that we'd like to copy the content of the packet to. * @param offset the position where we are supposed to start writing in <tt>data</tt>. * @param length the number of <tt>byte</tt>s available for writing in <tt>data</tt>. * @return the number of bytes read * @throws IOException if <tt>length</tt> is less than the size of the packet. */ protected int read(Buffer buffer, byte[] data, int offset, int length) throws IOException { if (data == null) throw new NullPointerException("data"); if (ioError) return -1; RawPacket pkt; synchronized (pktSyncRoot) { pkt = this.pkt; this.pkt = null; } int pktLength; if (pkt == null) { pktLength = 0; } else { // By default, pkt will be returned to the pool after it was read. boolean poolPkt = true; try { pktLength = pkt.getLength(); if (length < pktLength) { /* * If pkt is still the latest RawPacket made available to * reading, reinstate it for the next invocation of read; * otherwise, return it to the pool. */ poolPkt = false; throw new IOException("Input buffer not big enough for " + pktLength); } else { byte[] pktBuffer = pkt.getBuffer(); if (pktBuffer == null) { throw new NullPointerException( "pkt.buffer null, pkt.length " + pktLength + ", pkt.offset " + pkt.getOffset()); } else { System.arraycopy(pkt.getBuffer(), pkt.getOffset(), data, offset, pktLength); if (buffer != null) buffer.setFlags(pkt.getFlags()); } } } finally { if (!poolPkt) { synchronized (pktSyncRoot) { if (this.pkt == null) this.pkt = pkt; else poolPkt = true; } } if (poolPkt) { // Return pkt to the pool because it was successfully read. poolRawPacket(pkt); } } } return pktLength; } /** * Log the packet. * * @param packet packet to log */ protected abstract void doLogPacket(DatagramPacket packet); /** * Receive packet. * * @param p packet for receiving * @throws IOException if something goes wrong during receiving */ protected abstract void receivePacket(DatagramPacket p) throws IOException; /** * Listens for incoming datagrams, stores them for reading by the <tt>read</tt> method and * notifies the local <tt>transferHandler</tt> that there's data to be read. */ public void run() { DatagramPacket p = new DatagramPacket(buffer, 0, PACKET_RECEIVE_BUFFER_LENGTH); while (!closed) { try { // http://code.google.com/p/android/issues/detail?id=24765 if (OSUtils.IS_ANDROID) p.setLength(PACKET_RECEIVE_BUFFER_LENGTH); receivePacket(p); } catch (IOException e) { ioError = true; break; } /* * Do the DatagramPacketFilters accept the received DatagramPacket? */ DatagramPacketFilter[] datagramPacketFilters = getDatagramPacketFilters(); boolean accept; if (!enabled) accept = false; else if (datagramPacketFilters == null) accept = true; else { accept = true; for (int i = 0; i < datagramPacketFilters.length; i++) { try { if (!datagramPacketFilters[i].accept(p)) { accept = false; break; } } catch (Throwable t) { if (t instanceof ThreadDeath) throw (ThreadDeath) t; } } } if (accept) { RawPacket pkts[] = createRawPacket(p); for (int i = 0; i < pkts.length; i++) { RawPacket pkt = pkts[i]; pkts[i] = null; if (pkt != null) { if (pkt.isInvalid()) { /* * Return pkt to the pool because it is invalid and, * consequently, will not be made available to * reading. */ poolRawPacket(pkt); } else { RawPacket oldPkt; synchronized (pktSyncRoot) { oldPkt = this.pkt; this.pkt = pkt; } if (oldPkt != null) { /* * Return oldPkt to the pool because it was made * available to reading and it was not read. */ poolRawPacket(oldPkt); } if (videoRecorder != null) videoRecorder.recordData(pkt); if ((transferHandler != null) && !closed) { try { transferHandler.transferData(this); } catch (Throwable t) { /* * XXX We cannot allow transferHandler to * kill us. */ if (t instanceof ThreadDeath) { throw (ThreadDeath) t; } else { logger.warn("An RTP packet may have not been" + " fully handled.", t); } } } } } } rawPacketArrayPool.offer(pkts); } } } /** * Sets the <tt>transferHandler</tt> that this connector should be notifying when new data is * available for reading. * * @param transferHandler the <tt>transferHandler</tt> that this connector should be notifying * when new data is available for reading. */ public void setTransferHandler(SourceTransferHandler transferHandler) { if (!closed) this.transferHandler = transferHandler; } /** * Changes current thread priority. * * @param priority the new priority. */ public void setPriority(int priority) { // currently no priority is set // if (receiverThread != null) // receiverThread.setPriority(priority); } /** * Gets the <tt>DatagramPacketFilter</tt>s which allow dropping <tt>DatagramPacket</tt>s before * they are converted into <tt>RawPacket</tt>s. * * @return the <tt>DatagramPacketFilter</tt>s which allow dropping <tt>DatagramPacket</tt>s before * they are converted into <tt>RawPacket</tt>s. */ public synchronized DatagramPacketFilter[] getDatagramPacketFilters() { return datagramPacketFilters; } /** * Adds a <tt>DatagramPacketFilter</tt> which allows dropping <tt>DatagramPacket</tt>s before they * are converted into <tt>RawPacket</tt>s. * * @param datagramPacketFilter the <tt>DatagramPacketFilter</tt> which allows dropping * <tt>DatagramPacket</tt>s before they are converted into <tt>RawPacket</tt>s */ public synchronized void addDatagramPacketFilter(DatagramPacketFilter datagramPacketFilter) { if (datagramPacketFilter == null) throw new NullPointerException("datagramPacketFilter"); if (datagramPacketFilters == null) { datagramPacketFilters = new DatagramPacketFilter[] {datagramPacketFilter}; } else { final int length = datagramPacketFilters.length; for (int i = 0; i < length; i++) if (datagramPacketFilter.equals(datagramPacketFilters[i])) return; DatagramPacketFilter[] newDatagramPacketFilters = new DatagramPacketFilter[length + 1]; System.arraycopy(datagramPacketFilters, 0, newDatagramPacketFilters, 0, length); newDatagramPacketFilters[length] = datagramPacketFilter; datagramPacketFilters = newDatagramPacketFilters; } } /** * Enables or disables this <tt>RTPConnectorInputStream</tt>. While the stream is disabled, it * does not accept any packets. * * @param enabled <tt>true</tt> to enable, <tt>false</tt> to disable. */ public void setEnabled(boolean enabled) { if (logger.isDebugEnabled()) logger.debug("setEnabled: " + enabled); this.enabled = enabled; } }