Merged StunStack and StunProvider as there is no good reason for them to live apart.

This commit is contained in:
emcho 2010-01-31 13:03:26 +00:00
parent c6e264395e
commit a73fd1134b
7 changed files with 310 additions and 392 deletions

View File

@ -91,9 +91,9 @@ class StunClientTransaction
private int nextWaitInterval = originalWaitInterval;
/**
* The StunProvider that created us.
* The <tt>StunStack</tt> that created us.
*/
private StunProvider providerCallback = null;
private StunStack stackCallback = null;
/**
* The request that we are retransmitting.
@ -133,8 +133,9 @@ class StunClientTransaction
private Thread retransmissionsThread = null;
/**
* Creates a client transaction
* @param providerCallback the provider that created us.
* Creates a client transaction.
*
* @param stackCallback the stack that created us.
* @param request the request that we are living for.
* @param requestDestination the destination of the request.
* @param localAddress the local <tt>TransportAddress</tt> this transaction
@ -142,16 +143,16 @@ class StunClientTransaction
* @param responseCollector the instance that should receive this request's
* response retransmit.
*/
public StunClientTransaction(StunProvider providerCallback,
public StunClientTransaction(StunStack stackCallback,
Request request,
TransportAddress requestDestination,
TransportAddress localAddress,
ResponseCollector responseCollector)
{
this.providerCallback = providerCallback;
this.request = request;
this.localAddress = localAddress;
this.responseCollector = responseCollector;
this.stackCallback = stackCallback;
this.request = request;
this.localAddress = localAddress;
this.responseCollector = responseCollector;
this.requestDestination = requestDestination;
initTransactionConfiguration();
@ -219,7 +220,7 @@ class StunClientTransaction
waitFor(nextWaitInterval);
responseCollector.processTimeout();
providerCallback.removeClientTransaction(this);
stackCallback.removeClientTransaction(this);
}
@ -259,7 +260,7 @@ class StunClientTransaction
logger.finer("Trying to resend a cancelled transaction.");
return;
}
providerCallback.getNetAccessManager().sendMessage(
stackCallback.getNetAccessManager().sendMessage(
this.request,
localAddress,
requestDestination);
@ -304,8 +305,9 @@ class StunClientTransaction
}
/**
* Dispatches the response then cancels itself and notifies the StunProvider
* Dispatches the response then cancels itself and notifies the StunStack
* for its termination.
*
* @param evt the event that contains the newly received message
*/
void handleResponse(StunMessageEvent evt)

View File

@ -1,331 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
* Maintained by the SIP Communicator community (http://sip-communicator.org).
*
* Distributable under LGPL license. See terms of license at gnu.org.
*/
package org.ice4j.stack;
import java.io.*;
import java.util.*;
import java.util.logging.*;
import org.ice4j.*;
import org.ice4j.message.*;
/**
* The StunProvider class is an implementation of a Stun Transaction Layer. STUN
* transactions are extremely simple and are only used to correlate requests and
* responses. In the Stun4J implementation it is the transaction layer that
* ensures reliable delivery.
*
* @author Emil Ivov
*/
public class StunProvider
implements MessageEventHandler
{
/**
* Our class logger.
*/
private static final Logger logger =
Logger.getLogger(StunProvider.class.getName());
/**
* Stores active client transactions mapped against TransactionID-s.
*/
private Hashtable<TransactionID, StunClientTransaction> clientTransactions
= new Hashtable<TransactionID, StunClientTransaction>();
/**
* Currently open server transactions. The vector contains transaction ids
* for transactions corresponding to all non-answered received requests.
*/
private Hashtable<TransactionID, StunServerTransaction> serverTransactions
= new Hashtable<TransactionID, StunServerTransaction>();
/**
* The stack that created us.
*/
private StunStack stunStack = null;
/**
* A dispatcher for incoming requests event;
*/
private EventDispatcher eventDispatcher = new EventDispatcher();
//------------------ public interface
/**
* Creates the provider.
* @param stunStack The currently active stack instance.
*/
StunProvider(StunStack stunStack)
{
this.stunStack = stunStack;
}
/**
* Sends the specified request through the specified access point, and
* registers the specified ResponseCollector for later notification.
* @param request the request to send
* @param sendTo the destination address of the request.
* @param sendThrough the local address to use when sending the request
* @param collector the instance to notify when a response arrives or the
* the transaction timeouts
*
* @throws IOException if an error occurs while sending message bytes
* through the network socket.
* @throws IllegalArgumentException if the apDescriptor references an
* access point that had not been installed,
* @throws StunException if message encoding fails,
*
*/
public void sendRequest( Request request,
TransportAddress sendTo,
TransportAddress sendThrough,
ResponseCollector collector )
throws StunException, IOException, IllegalArgumentException
{
StunClientTransaction clientTransaction
= new StunClientTransaction(this, request, sendTo, sendThrough,
collector);
clientTransactions.put(clientTransaction.getTransactionID(),
clientTransaction);
clientTransaction.sendRequest();
}
/**
* Sends the specified response message through the specified access point.
*
* @param transactionID the id of the transaction to use when sending the
* response. Actually we are getting kind of redundant here as we already
* have the id in the response object, but I am bringing out as an extra
* parameter as the user might otherwise forget to explicitly set it.
* @param response the message to send.
* @param sendThrough the local address to use when sending the message.
* @param sendTo the destination of the message.
*
* @throws IOException if an error occurs while sending message bytes
* through the network socket.
* @throws IllegalArgumentException if the apDescriptor references an
* access point that had not been installed,
* @throws StunException if message encoding fails,
*/
public void sendResponse(byte[] transactionID,
Response response,
TransportAddress sendThrough,
TransportAddress sendTo)
throws StunException,
IOException,
IllegalArgumentException
{
TransactionID tid = TransactionID.createTransactionID(transactionID);
StunServerTransaction sTran =
serverTransactions.get(tid);
if(sTran == null || sTran.isReransmitting())
{
throw new StunException(StunException.TRANSACTION_DOES_NOT_EXIST,
"The transaction specified in the response "
+ "object does not exist or has already "
+ "transmitted a response.");
}
else
{
sTran.sendResponse(response, sendThrough, sendTo);
}
}
/**
* Sets the listener that should be notified when a new Request is received.
* @param requestListener the listener interested in incoming requests.
*/
public void addRequestListener(RequestListener requestListener)
{
this.eventDispatcher.addRequestListener( requestListener );
}
/**
* Removes the specified listener from the local listener list. (If any
* instances of this listener have been registered for a particular
* access point, they will not be removed).
* @param listener the RequestListener listener to unregister
*/
public void removeRequestListener(RequestListener listener)
{
this.eventDispatcher.removeRequestListener(listener);
}
/**
* Add a RequestListener for requests coming from a specific NetAccessPoint.
* The listener will be invoked only when a request event is received on
* that specific property.
*
* @param localAddress The local <tt>TransportAddress</tt> that we would
* like to listen on.
* @param listener The ConfigurationChangeListener to be added
*/
public void addRequestListener( TransportAddress localAddress,
RequestListener listener)
{
synchronized(eventDispatcher)
{
eventDispatcher.addRequestListener(localAddress, listener);
}
}
//------------- stack internals ------------------------------------------------
/**
* Returns the currently active instance of NetAccessManager. Used by client
* transactions when sending messages.
* @return the currently active instance of NetAccessManager.
*/
NetAccessManager getNetAccessManager()
{
return stunStack.getNetAccessManager();
}
/**
* Removes a client transaction from this providers client transactions list.
* Method is used by StunClientTransaction-s themselves when a timeout occurs.
* @param tran the transaction to remove.
*/
synchronized void removeClientTransaction(StunClientTransaction tran)
{
clientTransactions.remove(tran.getTransactionID());
}
/**
* Removes a server transaction from this provider's server transactions
* list.
* Method is used by StunServerTransaction-s themselves when they expire.
* @param tran the transaction to remove.
*/
synchronized void removeServerTransaction(StunServerTransaction tran)
{
serverTransactions.remove(tran.getTransactionID());
}
/**
* Called to notify this provider for an incoming message.
*
* @param event the event object that contains the new message.
*/
public void handleMessageEvent(StunMessageEvent event)
{
Message msg = event.getMessage();
if(logger.isLoggable(Level.FINEST))
logger.finest("Received a message on NetAP"
+ event.getLocalAddress()
+ " of type:"
+ (int)msg.getMessageType());
//request
if(msg instanceof Request)
{
logger.finest("parsing request");
TransactionID serverTid = TransactionID.
createTransactionID(msg.getTransactionID());
StunServerTransaction sTran = serverTransactions.get(serverTid);
if( sTran != null)
{
//requests from this transaction have already been seen
//retransmit the response if there was any
logger.finest("found an existing transaction");
try
{
sTran.retransmitResponse();
logger.finest("Response retransmitted");
}
catch (Exception ex)
{
//we couldn't really do anything here .. apart from logging
logger.log(Level.WARNING,
"Failed to retransmit a stun response", ex);
}
String propagate = System.getProperty(
"org.ice4j.PROPAGATE_RECEIVED_RETRANSMISSIONS");
if(propagate == null
|| !propagate.trim().equalsIgnoreCase("true"))
{
return;
}
}
else
{
logger.finest("exising transaction not found");
sTran =
new StunServerTransaction(this, serverTid);
serverTransactions.put(serverTid, sTran);
sTran.start();
}
eventDispatcher.fireMessageEvent(event);
}
//response
else if(msg instanceof Response)
{
TransactionID tid
= TransactionID.createTransactionID(msg.getTransactionID());
StunClientTransaction tran =
clientTransactions.remove(tid);
if(tran != null)
{
tran.handleResponse(event);
}
else
{
//do nothing - just drop the phantom response.
logger.fine("Dropped response - "
+ "no matching client tran found.");
logger.fine("response tid was - " + tid.toString());
logger.fine("all tids in stock were"
+ clientTransactions.toString());
}
}
}
/**
* Cancels all running transactions and prepares for garbage collection
*/
void shutDown()
{
eventDispatcher.removeAllListeners();
Enumeration<TransactionID> tids = clientTransactions.keys();
while (tids.hasMoreElements())
{
TransactionID item = (TransactionID)tids.nextElement();
StunClientTransaction tran = clientTransactions.remove(item);
if(tran != null)
tran.cancel();
}
tids = serverTransactions.keys();
while (tids.hasMoreElements())
{
TransactionID item = (TransactionID)tids.nextElement();
StunServerTransaction tran = serverTransactions.remove(item);
if(tran != null)
tran.expire();
}
}
}

View File

@ -42,9 +42,9 @@ class StunServerTransaction
private long transactionLifetime = 16000;
/**
* The StunProvider that created us.
* The <tt>StunStack</tt> that created us.
*/
private StunProvider providerCallback = null;
private StunStack stackCallback = null;
/**
* The source of the transaction request.
@ -90,14 +90,14 @@ class StunServerTransaction
/**
* Creates a server transaction
* @param providerCallback the provider that created us.
* @param stackCallback the stack that created us.
* @param tranID the transaction id contained by the request that was the
* cause for this transaction.
*/
public StunServerTransaction(StunProvider providerCallback,
TransactionID tranID)
public StunServerTransaction(StunStack stackCallback,
TransactionID tranID)
{
this.providerCallback = providerCallback;
this.stackCallback = stackCallback;
this.transactionID = tranID;
@ -127,7 +127,7 @@ class StunServerTransaction
//let's get lost
expire();
providerCallback.removeServerTransaction(this);
stackCallback.removeServerTransaction(this);
}
/**
@ -186,7 +186,7 @@ class StunServerTransaction
if(expired || !isRetransmitting)
return;
providerCallback.getNetAccessManager().sendMessage(response,
stackCallback.getNetAccessManager().sendMessage(response,
localAddress,
responseDestination);
}

View File

@ -8,8 +8,11 @@ package org.ice4j.stack;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.logging.*;
import org.ice4j.*;
import org.ice4j.message.*;
/**
* The entry point to the Stun4J stack. The class is used to start, stop and
* configure the stack.
@ -17,6 +20,7 @@ import org.ice4j.*;
* @author Emil Ivov
*/
public class StunStack
implements MessageEventHandler
{
/**
* We shouldn't need more than one stack in the same application.
@ -34,9 +38,29 @@ public class StunStack
public static final int DEFAULT_THREAD_POOL_SIZE = 3;
/**
* This stack's provider.
* Our class logger.
*/
private StunProvider stunProvider = null;
private static final Logger logger =
Logger.getLogger(StunStack.class.getName());
/**
* Stores active client transactions mapped against TransactionID-s.
*/
private Hashtable<TransactionID, StunClientTransaction> clientTransactions
= new Hashtable<TransactionID, StunClientTransaction>();
/**
* Currently open server transactions. The vector contains transaction ids
* for transactions corresponding to all non-answered received requests.
*/
private Hashtable<TransactionID, StunServerTransaction> serverTransactions
= new Hashtable<TransactionID, StunServerTransaction>();
/**
* A dispatcher for incoming requests event;
*/
private EventDispatcher eventDispatcher = new EventDispatcher();
/**
* Returns a reference to the singleton StunStack instance. If the stack
@ -90,27 +114,12 @@ public class StunStack
}
/**
* Returns a StunProvider instance to be used for sending and receiving
* messages.
*
* @return an instance of StunProvider
*/
public StunProvider getProvider()
{
return stunProvider;
}
/**
* Private constructor as we want a singleton pattern.
*/
private StunStack()
{
stunProvider = new StunProvider(this);
netAccessManager = new NetAccessManager(stunProvider);
netAccessManager = new NetAccessManager(this);
}
/**
@ -121,4 +130,257 @@ public class StunStack
{
return netAccessManager;
}
/**
* Sends the specified request through the specified access point, and
* registers the specified ResponseCollector for later notification.
* @param request the request to send
* @param sendTo the destination address of the request.
* @param sendThrough the local address to use when sending the request
* @param collector the instance to notify when a response arrives or the
* the transaction timeouts
*
* @throws IOException if an error occurs while sending message bytes
* through the network socket.
* @throws IllegalArgumentException if the apDescriptor references an
* access point that had not been installed,
* @throws StunException if message encoding fails,
*
*/
public void sendRequest( Request request,
TransportAddress sendTo,
TransportAddress sendThrough,
ResponseCollector collector )
throws StunException, IOException, IllegalArgumentException
{
StunClientTransaction clientTransaction
= new StunClientTransaction(this, request, sendTo, sendThrough,
collector);
clientTransactions.put(clientTransaction.getTransactionID(),
clientTransaction);
clientTransaction.sendRequest();
}
/**
* Sends the specified response message through the specified access point.
*
* @param transactionID the id of the transaction to use when sending the
* response. Actually we are getting kind of redundant here as we already
* have the id in the response object, but I am bringing out as an extra
* parameter as the user might otherwise forget to explicitly set it.
* @param response the message to send.
* @param sendThrough the local address to use when sending the message.
* @param sendTo the destination of the message.
*
* @throws IOException if an error occurs while sending message bytes
* through the network socket.
* @throws IllegalArgumentException if the apDescriptor references an
* access point that had not been installed,
* @throws StunException if message encoding fails,
*/
public void sendResponse(byte[] transactionID,
Response response,
TransportAddress sendThrough,
TransportAddress sendTo)
throws StunException,
IOException,
IllegalArgumentException
{
TransactionID tid = TransactionID.createTransactionID(transactionID);
StunServerTransaction sTran =
serverTransactions.get(tid);
if(sTran == null || sTran.isReransmitting())
{
throw new StunException(StunException.TRANSACTION_DOES_NOT_EXIST,
"The transaction specified in the response "
+ "object does not exist or has already "
+ "transmitted a response.");
}
else
{
sTran.sendResponse(response, sendThrough, sendTo);
}
}
/**
* Sets the listener that should be notified when a new Request is received.
* @param requestListener the listener interested in incoming requests.
*/
public void addRequestListener(RequestListener requestListener)
{
this.eventDispatcher.addRequestListener( requestListener );
}
/**
* Removes the specified listener from the local listener list. (If any
* instances of this listener have been registered for a particular
* access point, they will not be removed).
* @param listener the RequestListener listener to unregister
*/
public void removeRequestListener(RequestListener listener)
{
this.eventDispatcher.removeRequestListener(listener);
}
/**
* Add a RequestListener for requests coming from a specific NetAccessPoint.
* The listener will be invoked only when a request event is received on
* that specific property.
*
* @param localAddress The local <tt>TransportAddress</tt> that we would
* like to listen on.
* @param listener The ConfigurationChangeListener to be added
*/
public void addRequestListener( TransportAddress localAddress,
RequestListener listener)
{
synchronized(eventDispatcher)
{
eventDispatcher.addRequestListener(localAddress, listener);
}
}
/**
* Removes a client transaction from this providers client transactions list.
* Method is used by StunClientTransaction-s themselves when a timeout occurs.
* @param tran the transaction to remove.
*/
synchronized void removeClientTransaction(StunClientTransaction tran)
{
clientTransactions.remove(tran.getTransactionID());
}
/**
* Removes a server transaction from this provider's server transactions
* list.
* Method is used by StunServerTransaction-s themselves when they expire.
* @param tran the transaction to remove.
*/
synchronized void removeServerTransaction(StunServerTransaction tran)
{
serverTransactions.remove(tran.getTransactionID());
}
/**
* Called to notify this provider for an incoming message.
*
* @param event the event object that contains the new message.
*/
public void handleMessageEvent(StunMessageEvent event)
{
Message msg = event.getMessage();
if(logger.isLoggable(Level.FINEST))
logger.finest("Received a message on NetAP"
+ event.getLocalAddress()
+ " of type:"
+ (int)msg.getMessageType());
//request
if(msg instanceof Request)
{
logger.finest("parsing request");
TransactionID serverTid = TransactionID.
createTransactionID(msg.getTransactionID());
StunServerTransaction sTran = serverTransactions.get(serverTid);
if( sTran != null)
{
//requests from this transaction have already been seen
//retransmit the response if there was any
logger.finest("found an existing transaction");
try
{
sTran.retransmitResponse();
logger.finest("Response retransmitted");
}
catch (Exception ex)
{
//we couldn't really do anything here .. apart from logging
logger.log(Level.WARNING,
"Failed to retransmit a stun response", ex);
}
String propagate = System.getProperty(
"org.ice4j.PROPAGATE_RECEIVED_RETRANSMISSIONS");
if(propagate == null
|| !propagate.trim().equalsIgnoreCase("true"))
{
return;
}
}
else
{
logger.finest("exising transaction not found");
sTran =
new StunServerTransaction(this, serverTid);
serverTransactions.put(serverTid, sTran);
sTran.start();
}
eventDispatcher.fireMessageEvent(event);
}
//response
else if(msg instanceof Response)
{
TransactionID tid
= TransactionID.createTransactionID(msg.getTransactionID());
StunClientTransaction tran =
clientTransactions.remove(tid);
if(tran != null)
{
tran.handleResponse(event);
}
else
{
//do nothing - just drop the phantom response.
logger.fine("Dropped response - "
+ "no matching client tran found.");
logger.fine("response tid was - " + tid.toString());
logger.fine("all tids in stock were"
+ clientTransactions.toString());
}
}
}
/**
* Cancels all running transactions and prepares for garbage collection
*/
public void shutDown()
{
eventDispatcher.removeAllListeners();
Enumeration<TransactionID> tids = clientTransactions.keys();
while (tids.hasMoreElements())
{
TransactionID item = (TransactionID)tids.nextElement();
StunClientTransaction tran = clientTransactions.remove(item);
if(tran != null)
tran.cancel();
}
tids = serverTransactions.keys();
while (tids.hasMoreElements())
{
TransactionID item = (TransactionID)tids.nextElement();
StunServerTransaction tran = serverTransactions.remove(item);
if(tran != null)
tran.expire();
}
}
}

View File

@ -42,9 +42,9 @@ class BlockingRequestSender
= Logger.getLogger(BlockingRequestSender.class.getName());
/**
* The provider that we are using to send requests through.
* The stack that we are using to send requests through.
*/
private StunProvider stunProvider = null;
private StunStack stunStack = null;
/**
* The transport address that we are bound on.
@ -69,15 +69,15 @@ class BlockingRequestSender
/**
* Creates a new request sender.
* @param stunProvider the provider that the sender should send requests
* @param stunStack the stack that the sender should send requests
* through.
* @param localAddress the <tt>TransportAddress</tt> that requests should be
* leaving from.
*/
BlockingRequestSender(StunProvider stunProvider,
BlockingRequestSender(StunStack stunStack,
TransportAddress localAddress)
{
this.stunProvider = stunProvider;
this.stunStack = stunStack;
this.localAddress = localAddress;
}
@ -128,7 +128,7 @@ class BlockingRequestSender
IOException
{
synchronized(sendLock){
stunProvider.sendRequest(request, serverAddress, localAddress,
stunStack.sendRequest(request, serverAddress, localAddress,
BlockingRequestSender.this);
}

View File

@ -100,11 +100,6 @@ public class NetworkConfigurationDiscoveryProcess
*/
private StunStack stunStack = null;
/**
* The provider to send our messages through
*/
private StunProvider stunProvider = null;
/**
* The point where we'll be listening.
*/
@ -149,7 +144,6 @@ public class NetworkConfigurationDiscoveryProcess
public void shutDown()
{
stunStack = null;
stunProvider = null;
localAddress = null;
requestSender = null;
@ -171,8 +165,7 @@ public class NetworkConfigurationDiscoveryProcess
stunStack.addSocket(sock);
stunProvider = stunStack.getProvider();
requestSender = new BlockingRequestSender(stunProvider, localAddress);
requestSender = new BlockingRequestSender(stunStack, localAddress);
started = true;
}

View File

@ -36,11 +36,6 @@ public class SimpleAddressDetector
*/
private StunStack stunStack = null;
/**
* The provider to send our messages through
*/
private StunProvider stunProvider = null;
/**
* The address of the stun server
*/
@ -81,7 +76,6 @@ public class SimpleAddressDetector
public void shutDown()
{
stunStack = null;
stunProvider = null;
requestSender = null;
}
@ -91,8 +85,6 @@ public class SimpleAddressDetector
public void start()
{
stunStack = StunStack.getInstance();
stunProvider = stunStack.getProvider();
}
@ -114,7 +106,7 @@ public class SimpleAddressDetector
stunStack.addSocket(socket);
requestSender = new BlockingRequestSender(stunProvider, localAddress);
requestSender = new BlockingRequestSender(stunStack, localAddress);
StunMessageEvent evt = null;
try
{