/**
* 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);
}
/** {@inheritDoc} */
@Override
public RawPacket transform(RawPacket pkt) {
byte[] buf = pkt.getBuffer();
int off = pkt.getOffset();
int len = pkt.getLength();
// If the specified pkt represents a DTLS record, then it should pass
// through this PacketTransformer (e.g. it has been sent through
// DatagramTransportImpl).
if (isDtlsRecord(buf, off, len)) return pkt;
// SRTP
if (!transformEngine.isSrtpDisabled()) {
// DTLS-SRTP has not been initialized yet or has failed to
// initialize.
SinglePacketTransformer srtpTransformer = waitInitializeAndGetSRTPTransformer();
if (srtpTransformer != null) pkt = srtpTransformer.transform(pkt);
else if (DROP_UNENCRYPTED_PKTS) pkt = null;
// XXX Else, it is our explicit policy to let the received packet
// pass through and rely on the SrtpListener to notify the user that
// the session is not secured.
}
// Pure/non-SRTP DTLS
else {
// The specified pkt will pass through this PacketTransformer only
// if it gets transformed into a DTLS record.
pkt = null;
sendApplicationData(buf, off, len);
}
return pkt;
}
/**
* Sends a specific <tt>RawPacket</tt> through this <tt>OutputDataStream</tt> to a specific
* <tt>InetSocketAddress</tt>.
*
* @param packet the <tt>RawPacket</tt> to send through this <tt>OutputDataStream</tt> to the
* specified <tt>target</tt>
* @param target the <tt>InetSocketAddress</tt> to which the specified <tt>packet</tt> is to be
* sent through this <tt>OutputDataStream</tt>
* @throws IOException if anything goes wrong while sending the specified <tt>packet</tt> through
* this <tt>OutputDataStream</tt> to the specified <tt>target</tt>
*/
@Override
protected void sendToTarget(RawPacket packet, InetSocketAddress target) throws IOException {
socket.send(
new DatagramPacket(
packet.getBuffer(),
packet.getOffset(),
packet.getLength(),
target.getAddress(),
target.getPort()));
}
public int write(byte[] buffer, int offset, int length, boolean transform) {
RawPacket pkt = rawPacketArray[0];
if (pkt == null) pkt = new RawPacket();
rawPacketArray[0] = pkt;
byte[] pktBuf = pkt.getBuffer();
if (pktBuf == null || pktBuf.length < length) {
pktBuf = new byte[length];
pkt.setBuffer(pktBuf);
}
System.arraycopy(buffer, offset, pktBuf, 0, length);
pkt.setOffset(0);
pkt.setLength(length);
if (transform) {
PacketTransformer packetTransformer =
isControlStream ? rtcpPacketTransformer : rtpPacketTransformer;
if (packetTransformer != null)
rawPacketArray = packetTransformer.reverseTransform(rawPacketArray);
}
SourceTransferHandler transferHandler;
PushSourceStream pushSourceStream;
try {
if (isControlStream) {
transferHandler = controlTransferHandler;
pushSourceStream = getControlInputStream();
} else {
transferHandler = dataTransferHandler;
pushSourceStream = getDataInputStream();
}
} catch (IOException ioe) {
throw new UndeclaredThrowableException(ioe);
}
for (int i = 0; i < rawPacketArray.length; i++) {
RawPacket packet = rawPacketArray[i];
// keep the first element for reuse
if (i != 0) rawPacketArray[i] = null;
if (packet != null) {
if (isControlStream) pendingControlPacket = packet;
else pendingDataPacket = packet;
if (transferHandler != null) {
transferHandler.transferData(pushSourceStream);
}
}
}
return length;
}
private void handleRtpPacket(RawPacket pkt) {
if (pkt != null && pkt.getPayloadType() == vp8PayloadType) {
int ssrc = pkt.getSSRC();
if (!activeVideoSsrcs.contains(ssrc & 0xffffffffL)) {
synchronized (activeVideoSsrcs) {
if (!activeVideoSsrcs.contains(ssrc & 0xffffffffL)) {
activeVideoSsrcs.add(ssrc & 0xffffffffL);
rtcpFeedbackSender.sendFIR(ssrc);
}
}
}
}
}
private void emptyPacketBuffer(long ssrc) {
RawPacket[] pkts = rtpConnector.packetBuffer.emptyBuffer(ssrc);
RTPConnectorImpl.OutputDataStreamImpl dataStream;
try {
dataStream = rtpConnector.getDataOutputStream();
} catch (IOException ioe) {
logger.error("Failed to empty packet buffer for SSRC=" + ssrc + ": " + ioe);
return;
}
for (RawPacket pkt : pkts)
dataStream.write(
pkt.getBuffer(), pkt.getOffset(), pkt.getLength(), false /* already transformed */);
}
/**
* 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;
}
@Override
public RawPacket reverseTransform(RawPacket pkt) {
RecorderRtpImpl.this.handleRtcpPacket(pkt);
if (pkt != null && pkt.getRTCPPayloadType() == 203) {
// An RTCP BYE packet. Remove the receive stream before
// it gets to FMJ, because we want to, for example,
// flush the packet buffer before that.
long ssrc = pkt.getRTCPSSRC() & 0xffffffffl;
if (logger.isInfoEnabled()) logger.info("RTCP BYE for SSRC=" + ssrc);
ReceiveStreamDesc receiveStream = findReceiveStream(ssrc);
if (receiveStream != null) removeReceiveStream(receiveStream, false);
}
return pkt;
}
@Override
public int read(byte[] buffer, int offset, int length) throws IOException {
RawPacket pendingPacket;
if (isControlStream) {
pendingPacket = pendingControlPacket;
} else {
pendingPacket = pendingDataPacket;
}
int bytesToRead = 0;
byte[] pendingPacketBuffer = pendingPacket.getBuffer();
if (pendingPacketBuffer != null) {
int pendingPacketLength = pendingPacket.getLength();
bytesToRead = length > pendingPacketLength ? pendingPacketLength : length;
System.arraycopy(
pendingPacketBuffer, pendingPacket.getOffset(), buffer, offset, bytesToRead);
}
return bytesToRead;
}
/**
* 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
*/
@Override
protected void doLogPacket(RawPacket packet, InetSocketAddress target) {
if (socket == null || packet == null || target == null) return;
// Do not log the packet if it has been processed (and already
// logged) by the ice4j stack.
if (socket instanceof MultiplexingDatagramSocket) return;
PacketLoggingService pktLogging = getPacketLoggingService();
if (pktLogging != null) {
pktLogging.logPacket(
PacketLoggingService.ProtocolName.RTP,
socket.getLocalAddress().getAddress(),
socket.getLocalPort(),
target.getAddress().getAddress(),
target.getPort(),
PacketLoggingService.TransportName.UDP,
true,
packet.getBuffer(),
packet.getOffset(),
packet.getLength());
}
}
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;
}
}
}
}
/**
* Notifies this instance that a <tt>DatagramPacket</tt> packet received on the data
* <tt>DatagramSocket</tt> of this <tt>Channel</tt> has been accepted for further processing
* within Jitsi Videobridge.
*
* @param pkt the accepted <tt>RawPacket</tt>.
*/
public void accepted(RawPacket pkt) {
// With native simulcast we don't have a notification when a stream
// has started/stopped. The simulcast manager implements a timeout
// for the high quality stream and it needs to be notified when
// the channel has accepted a datagram packet for the timeout to
// function correctly.
if (!hasLayers() || pkt == null) {
return;
}
// Find the layer that corresponds to this packet.
int acceptedSSRC = pkt.getSSRC();
SimulcastLayer[] layers = getSimulcastLayers();
SimulcastLayer acceptedLayer = null;
for (SimulcastLayer layer : layers) {
// We only care about the primary SSRC and not the RTX ssrc (or
// future FEC ssrc).
if ((int) layer.getPrimarySSRC() == acceptedSSRC) {
acceptedLayer = layer;
break;
}
}
// If this is not an RTP packet or if we can't find an accepted
// layer, log and return as it makes no sense to continue in this
// situation.
if (acceptedLayer == null) {
return;
}
// There are sequences of packets with increasing timestamps but without
// the marker bit set. Supposedly, they are probes to detect whether the
// bandwidth may increase. We think that they should cause neither the
// start nor the stop of any SimulcastLayer.
// XXX There's RawPacket#getPayloadLength() but the implementation
// includes pkt.paddingSize at the time of this writing and we do not
// know whether that's going to stay that way.
int pktPayloadLength = pkt.getLength() - pkt.getHeaderLength();
int pktPaddingSize = pkt.getPaddingSize();
if (pktPayloadLength <= pktPaddingSize) {
if (logger.isTraceEnabled()) {
logger.trace(
"pkt.payloadLength= "
+ pktPayloadLength
+ " <= pkt.paddingSize= "
+ pktPaddingSize
+ "("
+ pkt.getSequenceNumber()
+ ")");
}
return;
}
// NOTE(gp) we expect the base layer to be always on, so we never touch
// it or starve it.
// XXX Refer to the implementation of
// SimulcastLayer#touch(boolean, RawPacket) for an explanation of why we
// chose to use a return value.
boolean frameStarted = acceptedLayer.touch(pkt);
if (frameStarted) simulcastLayerFrameStarted(acceptedLayer, pkt, layers);
}
/** {@inheritDoc} */
@Override
public RawPacket reverseTransform(RawPacket pkt) {
byte[] buf = pkt.getBuffer();
int off = pkt.getOffset();
int len = pkt.getLength();
if (isDtlsRecord(buf, off, len)) {
if (rtcpmux && Component.RTCP == componentID) {
// This should never happen.
logger.warn(
"Dropping a DTLS record, because it was received on the"
+ " RTCP channel while rtcpmux is in use.");
return null;
}
boolean receive;
synchronized (this) {
if (datagramTransport == null) {
receive = false;
} else {
datagramTransport.queueReceive(buf, off, len);
receive = true;
}
}
if (receive) {
DTLSTransport dtlsTransport = this.dtlsTransport;
if (dtlsTransport == null) {
// The specified pkt looks like a DTLS record and it has
// been consumed for the purposes of the secure channel
// represented by this PacketTransformer.
pkt = null;
} else {
try {
int receiveLimit = dtlsTransport.getReceiveLimit();
int delta = receiveLimit - len;
if (delta > 0) {
pkt.grow(delta);
buf = pkt.getBuffer();
off = pkt.getOffset();
len = pkt.getLength();
} else if (delta < 0) {
pkt.shrink(-delta);
buf = pkt.getBuffer();
off = pkt.getOffset();
len = pkt.getLength();
}
int received = dtlsTransport.receive(buf, off, len, DTLS_TRANSPORT_RECEIVE_WAITMILLIS);
if (received <= 0) {
// No application data was decoded.
pkt = null;
} else {
delta = len - received;
if (delta > 0) pkt.shrink(delta);
}
} catch (IOException ioe) {
pkt = null;
// SrtpControl.start(MediaType) starts its associated
// TransformEngine. We will use that mediaType to signal
// the normal stop then as well i.e. we will ignore
// exception after the procedure to stop this
// PacketTransformer has begun.
if (mediaType != null && !tlsPeerHasRaisedCloseNotifyWarning) {
logger.error("Failed to decode a DTLS record!", ioe);
}
}
}
} else {
// The specified pkt looks like a DTLS record but it is
// unexpected in the current state of the secure channel
// represented by this PacketTransformer. This PacketTransformer
// has not been started (successfully) or has been closed.
pkt = null;
}
} else if (transformEngine.isSrtpDisabled()) {
// In pure DTLS mode only DTLS records pass through.
pkt = null;
} else {
// DTLS-SRTP has not been initialized yet or has failed to
// initialize.
SinglePacketTransformer srtpTransformer = waitInitializeAndGetSRTPTransformer();
if (srtpTransformer != null) pkt = srtpTransformer.reverseTransform(pkt);
else if (DROP_UNENCRYPTED_PKTS) pkt = null;
// XXX Else, it is our explicit policy to let the received packet
// pass through and rely on the SrtpListener to notify the user that
// the session is not secured.
}
return pkt;
}
/**
* 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);
}
}
}
