/**
* Handles a specific <tt>IOException</tt> which was thrown during the execution of {@link
* #runInConnectThread(DTLSProtocol, TlsPeer, DatagramTransport)} while trying to establish a DTLS
* connection
*
* @param ioe the <tt>IOException</tt> to handle
* @param msg the human-readable message to log about the specified <tt>ioe</tt>
* @param i the number of tries remaining after the current one
* @return <tt>true</tt> if the specified <tt>ioe</tt> was successfully handled; <tt>false</tt>,
* otherwise
*/
private boolean handleRunInConnectThreadException(IOException ioe, String msg, int i) {
// 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) return false;
if (ioe instanceof TlsFatalAlert) {
TlsFatalAlert tfa = (TlsFatalAlert) ioe;
short alertDescription = tfa.getAlertDescription();
if (alertDescription == AlertDescription.unexpected_message) {
msg += " Received fatal unexpected message.";
if (i == 0
|| !Thread.currentThread().equals(connectThread)
|| connector == null
|| mediaType == null) {
msg += " Giving up after " + (CONNECT_TRIES - i) + " retries.";
} else {
msg += " Will retry.";
logger.error(msg, ioe);
return true;
}
} else {
msg += " Received fatal alert " + alertDescription + ".";
}
}
logger.error(msg, ioe);
return false;
}
/**
* Closes given {@link #transportManagers} of this <tt>Conference</tt> and removes corresponding
* channel bundle.
*/
void closeTransportManager(TransportManager transportManager) {
synchronized (transportManagers) {
for (Iterator<IceUdpTransportManager> i = transportManagers.values().iterator();
i.hasNext(); ) {
if (i.next() == transportManager) {
i.remove();
// Presumably, we have a single association for
// transportManager.
break;
}
}
// Close manager
try {
transportManager.close();
} catch (Throwable t) {
logger.warn(
"Failed to close an IceUdpTransportManager of" + " conference " + getID() + "!", t);
// The whole point of explicitly closing the
// transportManagers of this Conference is to prevent memory
// leaks. Hence, it does not make sense to possibly leave
// TransportManagers open because a TransportManager has
// failed to close.
if (t instanceof InterruptedException) Thread.currentThread().interrupt();
else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
}
}
/**
* Expires this <tt>Conference</tt>, its <tt>Content</tt>s and their respective <tt>Channel</tt>s.
* Releases the resources acquired by this instance throughout its life time and prepares it to be
* garbage collected.
*/
public void expire() {
synchronized (this) {
if (expired) return;
else expired = true;
}
EventAdmin eventAdmin = videobridge.getEventAdmin();
if (eventAdmin != null) eventAdmin.sendEvent(EventFactory.conferenceExpired(this));
setRecording(false);
if (recorderEventHandler != null) {
recorderEventHandler.close();
recorderEventHandler = null;
}
Videobridge videobridge = getVideobridge();
try {
videobridge.expireConference(this);
} finally {
// Expire the Contents of this Conference.
for (Content content : getContents()) {
try {
content.expire();
} catch (Throwable t) {
logger.warn(
"Failed to expire content " + content.getName() + " of conference " + getID() + "!",
t);
if (t instanceof InterruptedException) Thread.currentThread().interrupt();
else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
}
// Close the transportManagers of this Conference. Normally, there
// will be no TransportManager left to close at this point because
// all Channels have expired and the last Channel to be removed from
// a TransportManager closes the TransportManager. However, a
// Channel may have expired before it has learned of its
// TransportManager and then the TransportManager will not close.
closeTransportManagers();
if (logger.isInfoEnabled()) {
logger.info(
"Expired conference " + getID() + ". " + videobridge.getConferenceCountString());
}
}
}
/**
* Gets the {@code SRTPTransformer} used by this instance. If {@link #_srtpTransformer} does not
* exist (yet) and the state of this instance indicates that its initialization is in progess,
* then blocks until {@code _srtpTransformer} is initialized and returns it.
*
* @return the {@code SRTPTransformer} used by this instance
*/
private SinglePacketTransformer waitInitializeAndGetSRTPTransformer() {
SinglePacketTransformer srtpTransformer = _srtpTransformer;
if (srtpTransformer != null) return srtpTransformer;
if (rtcpmux && Component.RTCP == componentID) return initializeSRTCPTransformerFromRtp();
// XXX It is our explicit policy to rely on the SrtpListener to notify
// the user that the session is not secure. Unfortunately, (1) the
// SrtpListener is not supported by this DTLS SrtpControl implementation
// and (2) encrypted packets may arrive soon enough to be let through
// while _srtpTransformer is still initializing. Consequently, we will
// block and wait for _srtpTransformer to initialize.
boolean interrupted = false;
try {
synchronized (this) {
do {
srtpTransformer = _srtpTransformer;
if (srtpTransformer != null) break; // _srtpTransformer is initialized
if (connectThread == null) {
// Though _srtpTransformer is NOT initialized, there is
// no point in waiting because there is no one to
// initialize it.
break;
}
try {
// It does not really matter (enough) how much we wait
// here because we wait in a loop.
long timeout = CONNECT_TRIES * CONNECT_RETRY_INTERVAL;
wait(timeout);
} catch (InterruptedException ie) {
interrupted = true;
}
} while (true);
}
} finally {
if (interrupted) Thread.currentThread().interrupt();
}
return srtpTransformer;
}
/**
* Determines whether {@link #runInConnectThread(DTLSProtocol, TlsPeer, DatagramTransport)} is to
* try to establish a DTLS connection.
*
* @param i the number of tries remaining after the current one
* @param datagramTransport
* @return <tt>true</tt> to try to establish a DTLS connection; otherwise, <tt>false</tt>
*/
private boolean enterRunInConnectThreadLoop(int i, DatagramTransport datagramTransport) {
if (i < 0 || i > CONNECT_TRIES) {
return false;
} else {
Thread currentThread = Thread.currentThread();
synchronized (this) {
if (i > 0 && i < CONNECT_TRIES - 1) {
boolean interrupted = false;
try {
wait(CONNECT_RETRY_INTERVAL);
} catch (InterruptedException ie) {
interrupted = true;
}
if (interrupted) currentThread.interrupt();
}
return currentThread.equals(this.connectThread)
&& datagramTransport.equals(this.datagramTransport);
}
}
}
/**
* Makes home folder and the configuration file readable and writable only to the owner.
*
* @param cs the <tt>ConfigurationService</tt> instance to check for home folder and configuration
* file.
*/
private static void fixPermissions(ConfigurationService cs) {
if (!OSUtils.IS_LINUX && !OSUtils.IS_MAC) return;
try {
// let's check config file and config folder
File homeFolder = new File(cs.getScHomeDirLocation(), cs.getScHomeDirName());
Set<PosixFilePermission> perms =
new HashSet<PosixFilePermission>() {
{
add(PosixFilePermission.OWNER_READ);
add(PosixFilePermission.OWNER_WRITE);
add(PosixFilePermission.OWNER_EXECUTE);
}
};
Files.setPosixFilePermissions(Paths.get(homeFolder.getAbsolutePath()), perms);
String fileName = cs.getConfigurationFilename();
if (fileName != null) {
File cf = new File(homeFolder, fileName);
if (cf.exists()) {
perms =
new HashSet<PosixFilePermission>() {
{
add(PosixFilePermission.OWNER_READ);
add(PosixFilePermission.OWNER_WRITE);
}
};
Files.setPosixFilePermissions(Paths.get(cf.getAbsolutePath()), perms);
}
}
} catch (Throwable t) {
logger.error("Error creating c lib instance for fixing file permissions", t);
if (t instanceof InterruptedException) Thread.currentThread().interrupt();
else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
}
/**
* Runs in {@link #connectThread} to initialize {@link #dtlsTransport}.
*
* @param dtlsProtocol
* @param tlsPeer
* @param datagramTransport
*/
private void runInConnectThread(
DTLSProtocol dtlsProtocol, TlsPeer tlsPeer, DatagramTransport datagramTransport) {
DTLSTransport dtlsTransport = null;
final boolean srtp = !transformEngine.isSrtpDisabled();
int srtpProtectionProfile = 0;
TlsContext tlsContext = null;
// DTLS client
if (dtlsProtocol instanceof DTLSClientProtocol) {
DTLSClientProtocol dtlsClientProtocol = (DTLSClientProtocol) dtlsProtocol;
TlsClientImpl tlsClient = (TlsClientImpl) tlsPeer;
for (int i = CONNECT_TRIES - 1; i >= 0; i--) {
if (!enterRunInConnectThreadLoop(i, datagramTransport)) break;
try {
dtlsTransport = dtlsClientProtocol.connect(tlsClient, datagramTransport);
break;
} catch (IOException ioe) {
if (!handleRunInConnectThreadException(
ioe, "Failed to connect this DTLS client to a DTLS" + " server!", i)) {
break;
}
}
}
if (dtlsTransport != null && srtp) {
srtpProtectionProfile = tlsClient.getChosenProtectionProfile();
tlsContext = tlsClient.getContext();
}
}
// DTLS server
else if (dtlsProtocol instanceof DTLSServerProtocol) {
DTLSServerProtocol dtlsServerProtocol = (DTLSServerProtocol) dtlsProtocol;
TlsServerImpl tlsServer = (TlsServerImpl) tlsPeer;
for (int i = CONNECT_TRIES - 1; i >= 0; i--) {
if (!enterRunInConnectThreadLoop(i, datagramTransport)) break;
try {
dtlsTransport = dtlsServerProtocol.accept(tlsServer, datagramTransport);
break;
} catch (IOException ioe) {
if (!handleRunInConnectThreadException(
ioe, "Failed to accept a connection from a DTLS client!", i)) {
break;
}
}
}
if (dtlsTransport != null && srtp) {
srtpProtectionProfile = tlsServer.getChosenProtectionProfile();
tlsContext = tlsServer.getContext();
}
} else {
// It MUST be either a DTLS client or a DTLS server.
throw new IllegalStateException("dtlsProtocol");
}
SinglePacketTransformer srtpTransformer =
(dtlsTransport == null || !srtp)
? null
: initializeSRTPTransformer(srtpProtectionProfile, tlsContext);
boolean closeSRTPTransformer;
synchronized (this) {
if (Thread.currentThread().equals(this.connectThread)
&& datagramTransport.equals(this.datagramTransport)) {
this.dtlsTransport = dtlsTransport;
_srtpTransformer = srtpTransformer;
notifyAll();
}
closeSRTPTransformer = (_srtpTransformer != srtpTransformer);
}
if (closeSRTPTransformer && srtpTransformer != null) srtpTransformer.close();
}