Adds support for storing application data in transaction IDs so that we could keep in there references to CandidatePair-s
This commit is contained in:
parent
44e7266220
commit
f0a6ba00c9
@ -33,7 +33,7 @@ public class BaseStunMessageEvent
|
||||
/**
|
||||
* The ID of the transaction related to {@link #message}.
|
||||
*/
|
||||
private TransactionID transactionID;
|
||||
private TransactionID transactionID = null;
|
||||
|
||||
/**
|
||||
* Initializes a new <tt>BaseStunMessageEvent</tt> associated with a
|
||||
@ -85,4 +85,15 @@ public class BaseStunMessageEvent
|
||||
.createTransactionID(getMessage().getTransactionID());
|
||||
return transactionID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allows descendants of this class to set the transaction ID so that we
|
||||
* don't need to look it up later. This is not mandatory.
|
||||
*
|
||||
* @param tranID the ID of the transaction associated with this event.
|
||||
*/
|
||||
protected void setTransactionID(TransactionID tranID)
|
||||
{
|
||||
this.transactionID = tranID;
|
||||
}
|
||||
}
|
||||
|
||||
@ -31,13 +31,4 @@ public interface ResponseCollector
|
||||
*/
|
||||
public void processTimeout(StunTimeoutEvent event);
|
||||
|
||||
/**
|
||||
* Notifies this collector that the destination of the request has been
|
||||
* determined to be unreachable and that the request should be considered
|
||||
* unanswered.
|
||||
*
|
||||
* @param event the <tt>StunFailureEvent</tt> containing the
|
||||
* <tt>PortUnreachableException</tt> that has just occurred.
|
||||
*/
|
||||
public void processUnreachable(StunFailureEvent event);
|
||||
}
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
package org.ice4j;
|
||||
|
||||
import org.ice4j.message.*;
|
||||
import org.ice4j.stack.*;
|
||||
|
||||
/**
|
||||
* The class is used to dispatch events that occur when a STUN transaction
|
||||
@ -28,11 +29,14 @@ public class StunTimeoutEvent
|
||||
*
|
||||
* @param message the message itself
|
||||
* @param localAddress the local address that the message was sent from.
|
||||
* @param transactionID the ID of the associated with this event.
|
||||
*/
|
||||
public StunTimeoutEvent(Message message,
|
||||
TransportAddress localAddress)
|
||||
TransportAddress localAddress,
|
||||
TransactionID transactionID)
|
||||
{
|
||||
super(localAddress, message);
|
||||
super.setTransactionID(transactionID);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -355,7 +355,6 @@ public class Agent
|
||||
streams.get(0).getCheckList().computeInitialCheckListPairStates();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Computes and sets the foundations foundation for all <tt>Candidate</tt>s
|
||||
* currently found in <tt>component</tt>.
|
||||
|
||||
@ -77,19 +77,32 @@ public class ConnectivityCheckClient
|
||||
paceMaker.start();
|
||||
}
|
||||
|
||||
|
||||
private TransactionID startCheckForPair(CandidatePair pair)
|
||||
/**
|
||||
* Creates a STUN {@link Request} containing the necessary PRIORITY and
|
||||
* CONTROLLING/CONTROLLED attributes. Also stores a reference to
|
||||
* <tt>candidatePair</tt> in the newly created transactionID so that we
|
||||
* could then refer back to it in subsequent response or failure events.
|
||||
*
|
||||
* @param candidatePair that {@link CandidatePair} that we'd like to start
|
||||
* a check for.
|
||||
*
|
||||
* @return a reference to the {@link TransactionID} used in the connectivity
|
||||
* check client transaction or <tt>null</tt> if sending the check has
|
||||
* failed for some reason.
|
||||
*/
|
||||
private TransactionID startCheckForPair(CandidatePair candidatePair)
|
||||
{
|
||||
//we don't need to do a canReach() verification here as it has been
|
||||
//already verified during the gathering process.
|
||||
DatagramSocket stunSocket = ((HostCandidate)pair.getLocalCandidate())
|
||||
.getStunSocket(null);
|
||||
DatagramSocket stunSocket = ((HostCandidate)candidatePair
|
||||
.getLocalCandidate()) .getStunSocket(null);
|
||||
|
||||
Request request = MessageFactory.createBindingRequest();
|
||||
|
||||
//priority
|
||||
//the priority we'd like the remote party to use for a peer reflexive
|
||||
//candidate if one is discovered as a consequence of this check.
|
||||
PriorityAttribute priority = AttributeFactory.createPriorityAttribute(
|
||||
pair.getLocalCandidate().computePriorityForType(
|
||||
candidatePair.getLocalCandidate().computePriorityForType(
|
||||
CandidateType.PEER_REFLEXIVE_CANDIDATE));
|
||||
|
||||
request.addAttribute(priority);
|
||||
@ -115,26 +128,24 @@ public class ConnectivityCheckClient
|
||||
|
||||
request.addAttribute(unameAttr);
|
||||
|
||||
//todo: do this in the stun stack so that we could do the
|
||||
//calculation once the request is ready (we'd need the transaction id
|
||||
//for example.
|
||||
//todo: also implement SASL prepare
|
||||
MessageIntegrityAttribute msgIntegrity = AttributeFactory
|
||||
.createMessageIntegrityAttribute(localUserName);
|
||||
|
||||
|
||||
request.addAttribute(msgIntegrity);
|
||||
|
||||
TransactionID tran;
|
||||
TransactionID tran = TransactionID.createNewTransactionID();
|
||||
tran.setApplicationData(candidatePair);
|
||||
|
||||
try
|
||||
{
|
||||
tran = stunStack.sendRequest(request,
|
||||
pair.getRemoteCandidate().getTransportAddress(), stunSocket,
|
||||
this);
|
||||
stunStack.sendRequest(request,
|
||||
candidatePair.getRemoteCandidate().getTransportAddress(),
|
||||
candidatePair.getLocalCandidate().getTransportAddress(),
|
||||
this, tran);
|
||||
|
||||
if(logger.isLoggable(Level.FINEST))
|
||||
logger.finest("checking pair " + pair + " with tran="
|
||||
logger.finest("checking pair " + candidatePair + " with tran="
|
||||
+ tran.toString());
|
||||
|
||||
return tran;
|
||||
@ -159,18 +170,18 @@ public class ConnectivityCheckClient
|
||||
System.out.println("timeout event=" + event);
|
||||
}
|
||||
|
||||
public void processUnreachable(StunFailureEvent event)
|
||||
{
|
||||
System.out.println("failure event=" + event);
|
||||
}
|
||||
|
||||
/**
|
||||
* The thread that actually sends the checks for a particular check list
|
||||
* in the pace defined in RFC 5245.
|
||||
*/
|
||||
private static class PaceMaker extends Thread
|
||||
{
|
||||
/**
|
||||
* Indicates whether this thread is still running. Not really used at
|
||||
* this point.
|
||||
*/
|
||||
public boolean isRunning = true;
|
||||
|
||||
/**
|
||||
* The {@link ConnectivityCheckClient} that created us.
|
||||
*/
|
||||
@ -225,6 +236,9 @@ public class ConnectivityCheckClient
|
||||
{
|
||||
logger.log(Level.FINER, "PaceMake got interrupted", e);
|
||||
}
|
||||
|
||||
if (!isRunning)
|
||||
return;
|
||||
}
|
||||
|
||||
checkList.setState(CheckListState.RUNNING);
|
||||
@ -242,6 +256,7 @@ public class ConnectivityCheckClient
|
||||
//we are done sending checks for this list. we'll send its
|
||||
//final state in either the processResponse()
|
||||
//processTimeout() or processFailure() method.
|
||||
isRunning = false;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -142,11 +142,36 @@ class StunClientTransaction
|
||||
* @param responseCollector the instance that should receive this request's
|
||||
* response retransmit.
|
||||
*/
|
||||
public StunClientTransaction(StunStack stackCallback,
|
||||
Request request,
|
||||
TransportAddress requestDestination,
|
||||
TransportAddress localAddress,
|
||||
ResponseCollector responseCollector)
|
||||
public StunClientTransaction(StunStack stackCallback,
|
||||
Request request,
|
||||
TransportAddress requestDestination,
|
||||
TransportAddress localAddress,
|
||||
ResponseCollector responseCollector)
|
||||
{
|
||||
this(stackCallback, request, requestDestination, localAddress,
|
||||
responseCollector, TransactionID.createNewTransactionID());
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
* will be communication through.
|
||||
* @param responseCollector the instance that should receive this request's
|
||||
* response retransmit.
|
||||
* @param transactionID the ID that we'd like the new transaction to have
|
||||
* in case the application created it in order to use it for application
|
||||
* data correlation.
|
||||
*/
|
||||
public StunClientTransaction(StunStack stackCallback,
|
||||
Request request,
|
||||
TransportAddress requestDestination,
|
||||
TransportAddress localAddress,
|
||||
ResponseCollector responseCollector,
|
||||
TransactionID transactionID)
|
||||
{
|
||||
this.stackCallback = stackCallback;
|
||||
this.request = request;
|
||||
@ -156,7 +181,8 @@ class StunClientTransaction
|
||||
|
||||
initTransactionConfiguration();
|
||||
|
||||
this.transactionID = TransactionID.createTransactionID();
|
||||
this.transactionID = transactionID;
|
||||
|
||||
try
|
||||
{
|
||||
request.setTransactionID(transactionID.getTransactionID());
|
||||
@ -220,8 +246,8 @@ class StunClientTransaction
|
||||
|
||||
waitFor(nextWaitInterval);
|
||||
|
||||
responseCollector.processTimeout(
|
||||
new StunTimeoutEvent(this.request, getLocalAddress()));
|
||||
responseCollector.processTimeout( new StunTimeoutEvent(
|
||||
this.request, getLocalAddress(), transactionID));
|
||||
stackCallback.removeClientTransaction(this);
|
||||
}
|
||||
|
||||
|
||||
@ -123,6 +123,54 @@ public class StunStack
|
||||
netAccessManager.removeSocket(localAddr);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the transaction with the specified <tt>transactionID</tt> or
|
||||
* <tt>null</tt> if no such transaction exists.
|
||||
*
|
||||
* @param transactionID the ID of the transaction we are looking for.
|
||||
*
|
||||
* @return the {@link StunClientTransaction} we are looking for.
|
||||
*/
|
||||
protected StunClientTransaction getClientTransaction(byte[] transactionID)
|
||||
{
|
||||
synchronized (clientTransactions)
|
||||
{
|
||||
Collection<StunClientTransaction> cTrans
|
||||
= clientTransactions.values();
|
||||
|
||||
for (StunClientTransaction tran : cTrans)
|
||||
{
|
||||
if (tran.getTransactionID().equals(transactionID))
|
||||
return tran;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the transaction with the specified <tt>transactionID</tt> or
|
||||
* <tt>null</tt> if no such transaction exists.
|
||||
*
|
||||
* @param transactionID the ID of the transaction we are looking for.
|
||||
*
|
||||
* @return the {@link StunClientTransaction} we are looking for.
|
||||
*/
|
||||
protected StunServerTransaction getServerTransaction(byte[] transactionID)
|
||||
{
|
||||
synchronized (serverTransactions)
|
||||
{
|
||||
Collection<StunServerTransaction> sTrans
|
||||
= serverTransactions.values();
|
||||
|
||||
for (StunServerTransaction tran : sTrans)
|
||||
{
|
||||
if (tran.getTransactionID().equals(transactionID))
|
||||
return tran;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cancels the {@link StunClientTransaction} with the specified
|
||||
* <tt>transactionID</tt>. Cancellation means that the stack will not
|
||||
@ -237,13 +285,44 @@ public class StunStack
|
||||
TransportAddress sendThrough,
|
||||
ResponseCollector collector )
|
||||
throws IOException, IllegalArgumentException
|
||||
{
|
||||
return sendRequest(request, sendTo, sendThrough, collector,
|
||||
TransactionID.createNewTransactionID());
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
* @param transactionID the ID that we'd like the new transaction to use
|
||||
* in case the application created it in order to use it for application
|
||||
* data correlation.
|
||||
*
|
||||
* @return the <tt>TransactionID</tt> of the <tt>StunClientTransaction</tt>
|
||||
* that we used in order to send the request.
|
||||
*
|
||||
* @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,
|
||||
*/
|
||||
public TransactionID sendRequest( Request request,
|
||||
TransportAddress sendTo,
|
||||
TransportAddress sendThrough,
|
||||
ResponseCollector collector,
|
||||
TransactionID transactionID)
|
||||
throws IOException, IllegalArgumentException
|
||||
{
|
||||
StunClientTransaction clientTransaction
|
||||
= new StunClientTransaction(this, request, sendTo, sendThrough,
|
||||
collector);
|
||||
collector, transactionID);
|
||||
|
||||
clientTransactions.put(clientTransaction.getTransactionID(),
|
||||
clientTransaction);
|
||||
clientTransaction);
|
||||
|
||||
clientTransaction.sendRequest();
|
||||
|
||||
@ -406,8 +485,8 @@ public class StunStack
|
||||
if(msg instanceof Request)
|
||||
{
|
||||
logger.finest("parsing request");
|
||||
TransactionID serverTid = TransactionID.
|
||||
createTransactionID(msg.getTransactionID());
|
||||
|
||||
TransactionID serverTid = event.getTransactionID();
|
||||
|
||||
StunServerTransaction sTran = serverTransactions.get(serverTid);
|
||||
if( sTran != null)
|
||||
@ -450,8 +529,7 @@ public class StunStack
|
||||
//response
|
||||
else if(msg instanceof Response)
|
||||
{
|
||||
TransactionID tid
|
||||
= TransactionID.createTransactionID(msg.getTransactionID());
|
||||
TransactionID tid = event.getTransactionID();
|
||||
StunClientTransaction tran = clientTransactions.remove(tid);
|
||||
|
||||
if(tran != null)
|
||||
|
||||
@ -22,6 +22,11 @@ public class TransactionID
|
||||
*/
|
||||
private final byte transactionID[] = new byte[12];
|
||||
|
||||
/**
|
||||
* Any object that the application would like to correlate to a transaction.
|
||||
*/
|
||||
private Object applicationData = null;
|
||||
|
||||
/**
|
||||
* The object to use to generate the rightmost 8 bytes of the id.
|
||||
*/
|
||||
@ -50,7 +55,7 @@ public class TransactionID
|
||||
*
|
||||
* @return A <tt>TransactionID</tt> object with a unique transaction id.
|
||||
*/
|
||||
public static TransactionID createTransactionID()
|
||||
public static TransactionID createNewTransactionID()
|
||||
{
|
||||
TransactionID tid = new TransactionID();
|
||||
|
||||
@ -73,12 +78,35 @@ public class TransactionID
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a transaction identifier object with the specified id.
|
||||
* @param transactionID the id to give to the new TransactionID
|
||||
* @return a new TransactionID object with the specified id value;
|
||||
* Returns a <tt>TransactionID</tt> instance for the specified id. If
|
||||
* <tt>transactionID</tt> is the ID of a client or a server transaction
|
||||
* already known to the stack, then this method would return a reference
|
||||
* to that transaction's instance so that we could use it to for storing
|
||||
* application data.
|
||||
*
|
||||
* @param transactionID the value of the ID.
|
||||
*
|
||||
* @return a reference to the (possibly already existing)
|
||||
* <tt>TransactionID</tt> corresponding to the value of
|
||||
* <tt>transactionID</tt>
|
||||
*/
|
||||
public static TransactionID createTransactionID(byte[] transactionID)
|
||||
{
|
||||
//first check whether we can find a client or a server tran with the
|
||||
//specified id.
|
||||
StunClientTransaction cliTran = StunStack.getInstance()
|
||||
.getClientTransaction(transactionID);
|
||||
|
||||
if(cliTran != null)
|
||||
return cliTran.getTransactionID();
|
||||
|
||||
StunServerTransaction serTran = StunStack.getInstance()
|
||||
.getServerTransaction(transactionID);
|
||||
|
||||
if(serTran != null)
|
||||
return serTran.getTransactionID();
|
||||
|
||||
//seems that the caller really wants a new ID
|
||||
TransactionID tid = new TransactionID();
|
||||
|
||||
System.arraycopy(transactionID, 0, tid.transactionID, 0, 12);
|
||||
@ -89,7 +117,6 @@ public class TransactionID
|
||||
| (tid.transactionID[1] << 8 & 0x0000FF00)
|
||||
| (tid.transactionID[0] & 0x000000FF);
|
||||
|
||||
|
||||
return tid;
|
||||
}
|
||||
|
||||
@ -177,4 +204,18 @@ public class TransactionID
|
||||
|
||||
return idStr.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Stores <tt>applicationData</tt> in this ID so that we can refer back to
|
||||
* it if we ever need to at a later stage (e.g. when receiving a response
|
||||
* to a {@link StunClientTransaction}).
|
||||
*
|
||||
* @param applicationData a reference to the {@link Object} that the
|
||||
* application would like to correlate to the transaction represented by
|
||||
* this ID.
|
||||
*/
|
||||
public void setApplicationData(Object applicationData)
|
||||
{
|
||||
this.applicationData = applicationData;
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user