Refactoring Stun4j
This commit is contained in:
parent
33ed858355
commit
a7d1a7fdc9
@ -6,11 +6,9 @@
|
||||
*/
|
||||
package org.ice4j;
|
||||
|
||||
import java.util.EventObject;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.util.*;
|
||||
|
||||
import org.ice4j.message.*;
|
||||
import org.ice4j.stack.*;
|
||||
|
||||
|
||||
/**
|
||||
@ -20,12 +18,8 @@ import org.ice4j.stack.*;
|
||||
* as well as the Descriptor of the NetAccessPoint that received it (In case the
|
||||
* stack is used on more than one ports/addresses).
|
||||
*
|
||||
* <p>Organisation: <p> Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
|
||||
public class StunMessageEvent
|
||||
extends EventObject
|
||||
{
|
||||
@ -37,12 +31,12 @@ public class StunMessageEvent
|
||||
/**
|
||||
* The message itself.
|
||||
*/
|
||||
private Message message = null;
|
||||
private Message message = null;
|
||||
|
||||
/**
|
||||
* The sending address.
|
||||
*/
|
||||
private TransportAddress remoteAddress = null;
|
||||
private TransportAddress remoteAddress = null;
|
||||
|
||||
/**
|
||||
* Constructs a StunMessageEvent according to the specified message.
|
||||
|
||||
@ -8,6 +8,8 @@
|
||||
package org.ice4j.ice.harvest;
|
||||
|
||||
import org.ice4j.ice.*;
|
||||
import org.ice4j.stack.*;
|
||||
import org.ice4j.stunclient.*;
|
||||
|
||||
/**
|
||||
* A <tt>StunCandidateHarvester</tt> gathers STUN <tt>Candidate</tt>s for a
|
||||
@ -28,5 +30,8 @@ public class StunCandidateHarvester
|
||||
public void harvest(Component component)
|
||||
{
|
||||
//todo implement
|
||||
StunClient client = new StunClient(stack);
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -13,10 +13,7 @@ import org.ice4j.*;
|
||||
* NetAccessManager (and more precisely - MessageProcessors). This is our
|
||||
* way of keeping scalable network and stun layers.
|
||||
*
|
||||
* <p>Organisation: <p> Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
|
||||
interface MessageEventHandler
|
||||
|
||||
@ -12,26 +12,43 @@ import org.ice4j.*;
|
||||
import org.ice4j.message.*;
|
||||
|
||||
/**
|
||||
* The class is used to parse and dispatch incoming messages in a multithreaded
|
||||
* The class is used to parse and dispatch incoming messages in a multi-thread
|
||||
* manner.
|
||||
*
|
||||
* <p>Organisation: Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
|
||||
class MessageProcessor
|
||||
implements Runnable
|
||||
{
|
||||
private static final Logger logger =
|
||||
Logger.getLogger(MessageProcessor.class.getName());
|
||||
/**
|
||||
* Our class logger.
|
||||
*/
|
||||
private static final Logger logger
|
||||
= Logger.getLogger(MessageProcessor.class.getName());
|
||||
|
||||
/**
|
||||
* The queue where we store incoming messages until they are collected.
|
||||
*/
|
||||
private MessageQueue messageQueue = null;
|
||||
|
||||
/**
|
||||
* The listener that will be retrieving <tt>MessageEvent</tt>s
|
||||
*/
|
||||
private MessageEventHandler messageHandler = null;
|
||||
|
||||
/**
|
||||
* The listener that will be collecting error notifications.
|
||||
*/
|
||||
private ErrorHandler errorHandler = null;
|
||||
|
||||
private boolean isRunning = false;
|
||||
/**
|
||||
* The flag that indicates whether we are still running.
|
||||
*/
|
||||
private boolean isRunning = false;
|
||||
|
||||
/**
|
||||
* A reference to the thread that we use to execute ourselves.
|
||||
*/
|
||||
private Thread runningThread = null;
|
||||
|
||||
/**
|
||||
@ -62,10 +79,8 @@ class MessageProcessor
|
||||
throw new IllegalArgumentException(
|
||||
"The error handler may not be " + null);
|
||||
|
||||
|
||||
|
||||
this.messageQueue = queue;
|
||||
this.messageHandler = messageHandler;
|
||||
this.messageHandler = messageHandler;
|
||||
this.errorHandler = errorHandler;
|
||||
}
|
||||
|
||||
@ -74,8 +89,8 @@ class MessageProcessor
|
||||
*/
|
||||
public void run()
|
||||
{
|
||||
//add an extra try/catch block that handles uncatched errors and helps avoid
|
||||
//having dead threads in our pools.
|
||||
//add an extra try/catch block that handles uncatched errors and helps
|
||||
//avoid having dead threads in our pools.
|
||||
try
|
||||
{
|
||||
while (isRunning)
|
||||
@ -89,8 +104,7 @@ class MessageProcessor
|
||||
{
|
||||
if(isRunning())
|
||||
logger.log(Level.WARNING,
|
||||
"A net access point has gone useless:",
|
||||
ex);
|
||||
"A net access point has gone useless:", ex);
|
||||
//nothing to do here since we test whether we are running
|
||||
//just beneath ...
|
||||
}
|
||||
@ -106,10 +120,10 @@ class MessageProcessor
|
||||
Message stunMessage = null;
|
||||
try
|
||||
{
|
||||
stunMessage =
|
||||
Message.decode(rawMessage.getBytes(),
|
||||
(char) 0,
|
||||
(char) rawMessage.getMessageLength());
|
||||
stunMessage
|
||||
= Message.decode(rawMessage.getBytes(),
|
||||
(char) 0,
|
||||
(char) rawMessage.getMessageLength());
|
||||
}
|
||||
catch (StunException ex)
|
||||
{
|
||||
|
||||
@ -7,10 +7,9 @@
|
||||
package org.ice4j.stack;
|
||||
|
||||
|
||||
import java.util.Hashtable;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.util.*;
|
||||
import java.net.DatagramSocket;
|
||||
import java.util.logging.*;
|
||||
|
||||
import org.ice4j.*;
|
||||
@ -22,32 +21,34 @@ import org.ice4j.message.*;
|
||||
* Instances that operate with the NetAccessManager are only supposed to
|
||||
* understand STUN talk and shouldn't be aware of datagrams sockets, and etc.
|
||||
*
|
||||
* <p>Organisation: Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
|
||||
class NetAccessManager
|
||||
implements ErrorHandler
|
||||
{
|
||||
/**
|
||||
* Our class logger
|
||||
*/
|
||||
private static final Logger logger =
|
||||
Logger.getLogger(NetAccessManager.class.getName());
|
||||
/**
|
||||
* All access points currently in use. The table maps NetAccessPointDescriptor-s
|
||||
* to NetAccessPoint-s
|
||||
* All access points currently in use. The table maps
|
||||
* <tt>NetAccessPointDescriptor</tt>s to <tt>NetAccessPoint</tt>s
|
||||
*/
|
||||
private Hashtable<NetAccessPointDescriptor, NetAccessPoint> netAccessPoints = new Hashtable<NetAccessPointDescriptor, NetAccessPoint>();
|
||||
private Hashtable<NetAccessPointDescriptor, NetAccessPoint> netAccessPoints
|
||||
= new Hashtable<NetAccessPointDescriptor, NetAccessPoint>();
|
||||
|
||||
/**
|
||||
* A synchronized FIFO where incoming messages are stocked for processing.
|
||||
*/
|
||||
private MessageQueue messageQueue = new MessageQueue();
|
||||
private MessageQueue messageQueue = new MessageQueue();
|
||||
|
||||
/**
|
||||
* A thread pool of message processors.
|
||||
*/
|
||||
private Vector<MessageProcessor> messageProcessors = new Vector<MessageProcessor>();
|
||||
private Vector<MessageProcessor> messageProcessors
|
||||
= new Vector<MessageProcessor>();
|
||||
|
||||
/**
|
||||
* The instance that should be notified whan an incoming message has been
|
||||
@ -81,7 +82,6 @@ class NetAccessManager
|
||||
messageEventHandler = evtHandler;
|
||||
}
|
||||
|
||||
//------------------------ error handling -------------------------------------
|
||||
/**
|
||||
* A civilized way of not caring!
|
||||
* @param message a description of the error
|
||||
@ -96,7 +96,7 @@ class NetAccessManager
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the faulty thread and tries to repair the damage and instanciate
|
||||
* Clears the faulty thread and tries to repair the damage and instantiate
|
||||
* a replacement.
|
||||
*
|
||||
* @param callingThread the thread where the error occurred.
|
||||
@ -124,7 +124,8 @@ class NetAccessManager
|
||||
{
|
||||
//make sure nothing's left and notify user
|
||||
removeNetAccessPoint(ap.getDescriptor());
|
||||
logger.log(Level.WARNING, "Failed to relaunch accesspoint:" + ap,
|
||||
logger.log(Level.WARNING, "Failed to relaunch accesspoint:"
|
||||
+ ap,
|
||||
ex);
|
||||
}
|
||||
}
|
||||
@ -160,7 +161,8 @@ class NetAccessManager
|
||||
if(netAccessPoints.containsKey(apDescriptor))
|
||||
return;
|
||||
|
||||
NetAccessPoint ap = new NetAccessPoint(apDescriptor, messageQueue, this);
|
||||
NetAccessPoint ap
|
||||
= new NetAccessPoint(apDescriptor, messageQueue, this);
|
||||
netAccessPoints.put(apDescriptor, ap);
|
||||
ap.start();
|
||||
}
|
||||
@ -181,13 +183,17 @@ class NetAccessManager
|
||||
{
|
||||
|
||||
//no null check - let it through a null pointer exception
|
||||
TransportAddress address = new TransportAddress(socket.getLocalAddress(), socket.getLocalPort());
|
||||
NetAccessPointDescriptor apDescriptor = new NetAccessPointDescriptor(address);
|
||||
TransportAddress address = new TransportAddress(
|
||||
socket.getLocalAddress(), socket.getLocalPort());
|
||||
NetAccessPointDescriptor apDescriptor
|
||||
= new NetAccessPointDescriptor(address);
|
||||
|
||||
if(netAccessPoints.containsKey(apDescriptor))
|
||||
return apDescriptor;
|
||||
|
||||
NetAccessPoint ap = new NetAccessPoint(apDescriptor, messageQueue, this);
|
||||
NetAccessPoint ap
|
||||
= new NetAccessPoint(apDescriptor, messageQueue, this);
|
||||
|
||||
//call the useExternalSocket method to avoid closing the socket when
|
||||
//removing the accesspoint. Bug Report - Dave Stuart - SipQuest
|
||||
ap.useExternalSocket(socket);
|
||||
@ -245,8 +251,8 @@ class NetAccessManager
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws StunException INVALID_ARGUMENT if threadPoolSize is not a
|
||||
* valid size.
|
||||
* Fills the thread pool with the initially specified number of message
|
||||
* processors.
|
||||
*/
|
||||
private void initThreadPool()
|
||||
{
|
||||
@ -258,7 +264,7 @@ class NetAccessManager
|
||||
/**
|
||||
* Starts all message processors
|
||||
*
|
||||
* @param newSize the new thread poolsize
|
||||
* @param newSize the new thread pool size
|
||||
*/
|
||||
private void fillUpThreadPool(int newSize)
|
||||
{
|
||||
@ -307,7 +313,7 @@ class NetAccessManager
|
||||
*/
|
||||
void sendMessage(Message stunMessage,
|
||||
NetAccessPointDescriptor apDescriptor,
|
||||
TransportAddress address)
|
||||
TransportAddress address)
|
||||
throws IOException, IllegalArgumentException, StunException
|
||||
{
|
||||
byte[] bytes = stunMessage.encode();
|
||||
|
||||
@ -6,8 +6,7 @@
|
||||
*/
|
||||
package org.ice4j.stack;
|
||||
|
||||
import java.util.*;
|
||||
import java.io.IOException;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.util.logging.*;
|
||||
|
||||
@ -19,27 +18,25 @@ import org.ice4j.*;
|
||||
* messages to the MessageProcessor as well as sending datagrams to the STUN server
|
||||
* specified by the original NetAccessPointDescriptor.
|
||||
*
|
||||
* <p>Organisation: Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
|
||||
class NetAccessPoint
|
||||
implements Runnable
|
||||
{
|
||||
/**
|
||||
* Our class logger.
|
||||
*/
|
||||
private static final Logger logger =
|
||||
Logger.getLogger(NetAccessPoint.class.getName());
|
||||
|
||||
/**
|
||||
* Creates a new access point.
|
||||
*/
|
||||
NetAccessPoint()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Max datagram size.
|
||||
*/
|
||||
private static final int MAX_DATAGRAM_SIZE = 8 * 1024;
|
||||
|
||||
|
||||
/**
|
||||
* The message queue is where incoming messages are added.
|
||||
*/
|
||||
@ -50,32 +47,16 @@ class NetAccessPoint
|
||||
*/
|
||||
protected DatagramSocket sock;
|
||||
|
||||
/**
|
||||
* Indicates whether the access point is using a socket that was created
|
||||
* by someone else. The variable is set to true when the AP's socket is
|
||||
* set using the <code>useExternalSocket()</code> method and is consulted
|
||||
* inside the stop method. When its value is true, the AP's socket is not
|
||||
* closed when <code>stop()</code>ing the AP.
|
||||
*
|
||||
* This variable is part of bug fix reported by Dave Stuart - SipQuest
|
||||
*/
|
||||
private boolean isUsingExternalSocket = false;
|
||||
|
||||
/**
|
||||
* A flag that is set to false to exit the message processor.
|
||||
*/
|
||||
private boolean isRunning;
|
||||
|
||||
/**
|
||||
* The descriptor used to create this access point.
|
||||
*/
|
||||
private NetAccessPointDescriptor apDescriptor = null;
|
||||
|
||||
/**
|
||||
* The instance to be notified if errors occur in the network listening
|
||||
* thread.
|
||||
*/
|
||||
private ErrorHandler errorHandler = null;
|
||||
private ErrorHandler errorHandler = null;
|
||||
|
||||
/**
|
||||
* Used for locking socket operations
|
||||
@ -84,15 +65,16 @@ class NetAccessPoint
|
||||
|
||||
/**
|
||||
* Creates a network access point.
|
||||
* @param apDescriptor the address and port where to bind.
|
||||
* @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.
|
||||
*/
|
||||
NetAccessPoint(NetAccessPointDescriptor apDescriptor,
|
||||
MessageQueue messageQueue,
|
||||
ErrorHandler errorHandler)
|
||||
protected NetAccessPoint(DatagramSocket socket,
|
||||
MessageQueue messageQueue,
|
||||
ErrorHandler errorHandler)
|
||||
{
|
||||
this.apDescriptor = apDescriptor;
|
||||
this.sock = socket;
|
||||
this.messageQueue = messageQueue;
|
||||
this.errorHandler = errorHandler;
|
||||
}
|
||||
@ -106,19 +88,8 @@ class NetAccessPoint
|
||||
void start()
|
||||
throws IOException
|
||||
{
|
||||
synchronized(socketLock){
|
||||
|
||||
//do not create the socket earlier as someone might want to set an
|
||||
// existing one was != null fixed (Ranga)
|
||||
if (sock == null)
|
||||
{
|
||||
this.sock = new DatagramSocket(getDescriptor().getAddress().
|
||||
getSocketAddress());
|
||||
this.isUsingExternalSocket = false;
|
||||
logger.info("Bound a socket on ap: " + toString());
|
||||
}
|
||||
|
||||
sock.setReceiveBufferSize(MAX_DATAGRAM_SIZE);
|
||||
synchronized(socketLock)
|
||||
{
|
||||
this.isRunning = true;
|
||||
Thread thread = new Thread(this);
|
||||
thread.start();
|
||||
@ -126,13 +97,14 @@ class NetAccessPoint
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the NetAccessPointDescriptor that contains the port and address
|
||||
* associated with this accesspoint.
|
||||
* @return the NetAccessPointDescriptor associated with this AP.
|
||||
* 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.
|
||||
*/
|
||||
NetAccessPointDescriptor getDescriptor()
|
||||
protected DatagramSocket getSocket()
|
||||
{
|
||||
return apDescriptor;
|
||||
return sock;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -149,6 +121,11 @@ class NetAccessPoint
|
||||
DatagramPacket packet = new DatagramPacket(message, bufsize);
|
||||
|
||||
sock.receive(packet);
|
||||
|
||||
//get lost if we are no longer running.
|
||||
if(!isRunning)
|
||||
return;
|
||||
|
||||
logger.finest("received datagram");
|
||||
|
||||
RawMessage rawMessage = new RawMessage( message,
|
||||
@ -172,10 +149,9 @@ class NetAccessPoint
|
||||
+ "receive a message.",
|
||||
ex);
|
||||
}
|
||||
else
|
||||
{
|
||||
//The exception was most probably caused by calling this.stop()
|
||||
// ....
|
||||
//The exception was most probably caused by calling
|
||||
//this.stop() ....
|
||||
}
|
||||
}
|
||||
catch (IOException ex)
|
||||
@ -200,101 +176,31 @@ class NetAccessPoint
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Shut down the access point. Close the socket for recieving
|
||||
* incoming messages. The method won't close the socket if it was created
|
||||
* outside the stack (Bug Report - Dave Stuart - SipQuest). It also seems
|
||||
* that sometimes sockets don't immdeiately free their port and trying
|
||||
* to bind to that port immediately after gets us an exception. We therefore
|
||||
* null the socket, wait for 200 miliseconds and call the garbage collector
|
||||
* this seems to be working fine but is not what one could call neat
|
||||
* behaviour, so if you'd like to disable it - set the
|
||||
* org.ice4j.stack.HARD_SOCK_CLOSE property to anything different from
|
||||
* true. If you'd want us to wait more or less - set
|
||||
* org.ice4j.stack.WAIT_FOR_SOCK_CLOSE to the appropriate number of
|
||||
* miliseconds.
|
||||
* Makes the access point stop listening on its socket.
|
||||
*
|
||||
*/
|
||||
synchronized void stop()
|
||||
{
|
||||
this.isRunning = false;
|
||||
|
||||
//avoid a needless null pointer exception
|
||||
if (sock != null
|
||||
&& isUsingExternalSocket == false)
|
||||
{
|
||||
synchronized (socketLock)
|
||||
{
|
||||
sock.close();
|
||||
|
||||
logger.info("Closed socket on ap " + toString());
|
||||
sock = null;
|
||||
String hardSocketClose =
|
||||
System.getProperty("org.ice4j.stack.HARD_SOCK_CLOSE");
|
||||
|
||||
//sometimes sockts stay open even after closing them. make sure
|
||||
//this doesn't happen here. (unless the user doesn't want us to)
|
||||
if (hardSocketClose == null
|
||||
|| hardSocketClose.equalsIgnoreCase("true"))
|
||||
{
|
||||
|
||||
int waitForSockClose = 200;
|
||||
try
|
||||
{
|
||||
String waitForSockCloseStr =
|
||||
System.getProperty(
|
||||
"org.ice4j.stack.WAIT_FOR_SOCK_CLOSE");
|
||||
if (waitForSockCloseStr != null &&
|
||||
waitForSockCloseStr.length() > 0){
|
||||
|
||||
waitForSockClose =
|
||||
Integer.parseInt(System.getProperty(
|
||||
waitForSockCloseStr));
|
||||
}
|
||||
}
|
||||
catch (Throwable t)
|
||||
{
|
||||
logger.log(
|
||||
Level.WARNING,
|
||||
"Failed to parse wait_for_sock_close prop", t);
|
||||
|
||||
if (waitForSockClose < 0)
|
||||
{
|
||||
waitForSockClose = 200;
|
||||
}
|
||||
}
|
||||
|
||||
//wait
|
||||
try
|
||||
{
|
||||
wait(waitForSockClose);
|
||||
}
|
||||
catch (InterruptedException t)
|
||||
{
|
||||
logger.warning("Interrupted waiting for sock close.");
|
||||
}
|
||||
System.gc();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.getSocketAddress());
|
||||
synchronized(socketLock){
|
||||
message, 0, message.length, address.getSocketAddress());
|
||||
|
||||
synchronized(socketLock)
|
||||
{
|
||||
sock.send(datagramPacket);
|
||||
}
|
||||
}
|
||||
@ -313,8 +219,9 @@ class NetAccessPoint
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets a socket for the access point to use. This socket will not be closed
|
||||
* when the AP is <code>stop()</code>ed (Bug Report - Dave Stuart - SipQuest).
|
||||
* Sets a socket for the access point to use. This socket will not be
|
||||
* closed when the AP is <tt>stop()</tt>ed (Bug Report - Dave Stuart).
|
||||
*
|
||||
* @param socket the socket that the AP should use.
|
||||
*/
|
||||
void useExternalSocket(DatagramSocket socket)
|
||||
|
||||
@ -15,11 +15,7 @@ import org.ice4j.*;
|
||||
* of the host that sent it and the address and port where it was received
|
||||
* (locally).
|
||||
*
|
||||
* <p>Organisation: <p> Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
*
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
class RawMessage
|
||||
{
|
||||
@ -31,34 +27,29 @@ class RawMessage
|
||||
/**
|
||||
* The length of the message.
|
||||
*/
|
||||
private int messageLength = -1;
|
||||
private int messageLength = -1;
|
||||
|
||||
/**
|
||||
* The addres and port where the message was sent from.
|
||||
* The address and port where the message was sent from.
|
||||
*/
|
||||
private InetSocketAddress remoteAddress = null;
|
||||
|
||||
|
||||
/**
|
||||
* The descriptor of the net access point that received the message.
|
||||
*/
|
||||
private NetAccessPointDescriptor receivingAccessPoint = null;
|
||||
|
||||
/**
|
||||
* Constructs a raw message with the specified field values. All parameters
|
||||
* are cloned before being assigned to class members.
|
||||
*
|
||||
* @param messageBytes the message itself.
|
||||
* @param remoteAddress the address where the message came from.
|
||||
* @param remotePort the port where the message came from.
|
||||
* @param netApDescriptor the access point the received the message.s
|
||||
* @param messageBytes the message itself.
|
||||
* @param messageLength the number of bytes currently stored in the
|
||||
* <tt>messageBytes</tt> array.
|
||||
* @param remoteAddress the address where the message came from.
|
||||
* @param remotePort the port where the message came from.
|
||||
*
|
||||
* @throws NullPointerException if one or more of the parameters were null.
|
||||
*/
|
||||
RawMessage(byte[] messageBytes,
|
||||
int messageLength,
|
||||
InetAddress remoteAddress,
|
||||
int remotePort,
|
||||
NetAccessPointDescriptor netApDescriptor)
|
||||
RawMessage(byte[] messageBytes,
|
||||
InetAddress remoteAddress,
|
||||
int messageLength,
|
||||
int remotePort)
|
||||
{
|
||||
//... don't do a null check - let it throw an NP exception
|
||||
|
||||
@ -68,8 +59,6 @@ class RawMessage
|
||||
0, messageBytes.length);
|
||||
|
||||
this.remoteAddress = new InetSocketAddress(remoteAddress, remotePort);
|
||||
this.receivingAccessPoint =
|
||||
(NetAccessPointDescriptor)netApDescriptor.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -92,7 +81,6 @@ class RawMessage
|
||||
return messageLength;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the address and port of the host that sent the message
|
||||
* @return the [address]:[port] pair that sent the message.
|
||||
@ -101,13 +89,4 @@ class RawMessage
|
||||
{
|
||||
return this.remoteAddress;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a descriptor of the access point that received the message.
|
||||
* @return a descriptor of the access point that received the message.
|
||||
*/
|
||||
NetAccessPointDescriptor getNetAccessPoint()
|
||||
{
|
||||
return this.receivingAccessPoint;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/*
|
||||
* Stun4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
*
|
||||
@ -7,9 +6,9 @@
|
||||
*/
|
||||
package org.ice4j.stack;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
import java.util.logging.*;
|
||||
import java.io.*;
|
||||
|
||||
import org.ice4j.*;
|
||||
import org.ice4j.message.*;
|
||||
@ -20,40 +19,40 @@ import org.ice4j.message.*;
|
||||
* responses. In the Stun4J implementation it is the transaction layer that
|
||||
* ensures reliable delivery.
|
||||
*
|
||||
* <p>Organisation: <p> Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
|
||||
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>();
|
||||
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>();
|
||||
private Hashtable<TransactionID, StunServerTransaction> serverTransactions
|
||||
= new Hashtable<TransactionID, StunServerTransaction>();
|
||||
|
||||
/**
|
||||
* The stack that created us.
|
||||
*/
|
||||
private StunStack stunStack = null;
|
||||
private StunStack stunStack = null;
|
||||
|
||||
/**
|
||||
* A dispatcher for incoming requests event;
|
||||
*/
|
||||
private EventDispatcher eventDispatcher = new EventDispatcher();
|
||||
|
||||
|
||||
private EventDispatcher eventDispatcher = new EventDispatcher();
|
||||
|
||||
//------------------ public interface
|
||||
/**
|
||||
@ -88,10 +87,7 @@ public class StunProvider
|
||||
throws StunException, IOException, IllegalArgumentException
|
||||
{
|
||||
StunClientTransaction clientTransaction
|
||||
= new StunClientTransaction(this,
|
||||
request,
|
||||
sendTo,
|
||||
sendThrough,
|
||||
= new StunClientTransaction(this, request, sendTo, sendThrough,
|
||||
collector);
|
||||
|
||||
clientTransactions.put(clientTransaction.getTransactionID(),
|
||||
@ -120,7 +116,7 @@ public class StunProvider
|
||||
public void sendResponse(byte[] transactionID,
|
||||
Response response,
|
||||
NetAccessPointDescriptor sendThrough,
|
||||
TransportAddress sendTo)
|
||||
TransportAddress sendTo)
|
||||
throws StunException,
|
||||
IOException,
|
||||
IllegalArgumentException
|
||||
@ -129,13 +125,15 @@ public class StunProvider
|
||||
StunServerTransaction sTran =
|
||||
serverTransactions.get(tid);
|
||||
|
||||
if(sTran == null || sTran.isReransmitting()){
|
||||
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{
|
||||
else
|
||||
{
|
||||
sTran.sendResponse(response, sendThrough, sendTo);
|
||||
}
|
||||
|
||||
@ -179,8 +177,6 @@ public class StunProvider
|
||||
eventDispatcher.addRequestListener(apDescriptor, listener);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//------------- stack internals ------------------------------------------------
|
||||
/**
|
||||
* Returns the currently active instance of NetAccessManager. Used by client
|
||||
@ -235,7 +231,8 @@ public class StunProvider
|
||||
createTransactionID(msg.getTransactionID());
|
||||
|
||||
StunServerTransaction sTran = serverTransactions.get(serverTid);
|
||||
if( sTran != null){
|
||||
if( sTran != null)
|
||||
{
|
||||
|
||||
//requests from this transaction have already been seen
|
||||
//retransmit the response if there was any
|
||||
@ -255,10 +252,14 @@ public class StunProvider
|
||||
|
||||
String propagate = System.getProperty(
|
||||
"org.ice4j.PROPAGATE_RECEIVED_RETRANSMISSIONS");
|
||||
if(propagate == null || !propagate.trim().equalsIgnoreCase("true"))
|
||||
if(propagate == null
|
||||
|| !propagate.trim().equalsIgnoreCase("true"))
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
else{
|
||||
else
|
||||
{
|
||||
logger.finest("exising transaction not found");
|
||||
sTran =
|
||||
new StunServerTransaction(this, serverTid);
|
||||
@ -266,13 +267,14 @@ public class StunProvider
|
||||
serverTransactions.put(serverTid, sTran);
|
||||
sTran.start();
|
||||
}
|
||||
|
||||
eventDispatcher.fireMessageEvent(event);
|
||||
}
|
||||
//response
|
||||
else if(msg instanceof Response)
|
||||
{
|
||||
TransactionID tid = TransactionID.
|
||||
createTransactionID(msg.getTransactionID());
|
||||
TransactionID tid
|
||||
= TransactionID.createTransactionID(msg.getTransactionID());
|
||||
|
||||
StunClientTransaction tran =
|
||||
clientTransactions.remove(tid);
|
||||
@ -284,9 +286,11 @@ public class StunProvider
|
||||
else
|
||||
{
|
||||
//do nothing - just drop the phantom response.
|
||||
logger.fine("Dropped response - no matching client tran found.");
|
||||
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());
|
||||
logger.fine("all tids in stock were"
|
||||
+ clientTransactions.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@ -299,8 +303,9 @@ public class StunProvider
|
||||
{
|
||||
eventDispatcher.removeAllListeners();
|
||||
|
||||
Enumeration tids = clientTransactions.keys();
|
||||
while (tids.hasMoreElements()) {
|
||||
Enumeration<TransactionID> tids = clientTransactions.keys();
|
||||
while (tids.hasMoreElements())
|
||||
{
|
||||
TransactionID item = (TransactionID)tids.nextElement();
|
||||
StunClientTransaction tran = clientTransactions.remove(item);
|
||||
if(tran != null)
|
||||
@ -309,10 +314,10 @@ public class StunProvider
|
||||
}
|
||||
|
||||
tids = serverTransactions.keys();
|
||||
while (tids.hasMoreElements()) {
|
||||
while (tids.hasMoreElements())
|
||||
{
|
||||
TransactionID item = (TransactionID)tids.nextElement();
|
||||
StunServerTransaction tran =
|
||||
serverTransactions.remove(item);
|
||||
StunServerTransaction tran = serverTransactions.remove(item);
|
||||
if(tran != null)
|
||||
tran.expire();
|
||||
|
||||
|
||||
@ -38,6 +38,9 @@ public class StunStack
|
||||
*/
|
||||
public static final int DEFAULT_THREAD_POOL_SIZE = 3;
|
||||
|
||||
/**
|
||||
* This stack's provider.
|
||||
*/
|
||||
private StunProvider stunProvider = null;
|
||||
|
||||
/**
|
||||
@ -54,17 +57,14 @@ public class StunStack
|
||||
return stackInstance;
|
||||
}
|
||||
|
||||
//----------------------- PUBLIC INTERFACE ---------------------------------
|
||||
|
||||
|
||||
/**
|
||||
* Sets the number of Message processors running in the same time.
|
||||
*
|
||||
* @param threadPoolSize the number of message process threads to run.
|
||||
* @throws StunException
|
||||
* @throws IllegalArgumentException if threadPoolSize is not a valid size.
|
||||
*/
|
||||
public void setThreadPoolSize(int threadPoolSize)
|
||||
throws StunException
|
||||
throws IllegalArgumentException
|
||||
{
|
||||
netAccessManager.setThreadPoolSize(threadPoolSize);
|
||||
}
|
||||
@ -84,8 +84,8 @@ public class StunStack
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates and starts the specified Network Access Point based on the specified
|
||||
* socket and returns a relevant descriptor.
|
||||
* Creates and starts the specified Network Access Point based on the
|
||||
* specified socket and returns a relevant descriptor.
|
||||
*
|
||||
* @param sock The socket that the new access point should represent.
|
||||
* @throws IOException if we fail to setup the socket.
|
||||
@ -120,7 +120,6 @@ public class StunStack
|
||||
return stunProvider;
|
||||
}
|
||||
|
||||
//-------------------- internal stuff --------------------------------------
|
||||
/**
|
||||
* Private constructor as we want a singleton pattern.
|
||||
*/
|
||||
|
||||
@ -6,10 +6,9 @@
|
||||
*/
|
||||
package org.ice4j.stunclient;
|
||||
|
||||
import java.net.DatagramSocket;
|
||||
import java.io.*;
|
||||
import java.util.logging.*;
|
||||
import java.net.*;
|
||||
import java.util.logging.*;
|
||||
|
||||
import org.ice4j.*;
|
||||
import org.ice4j.attribute.*;
|
||||
@ -19,18 +18,19 @@ import org.ice4j.stack.*;
|
||||
/**
|
||||
* The class provides basic means of discovering a public IP address. All it
|
||||
* does is send a binding request through a specified port and return the
|
||||
* mapped address it got back or null if there was no reponse.
|
||||
* mapped address it got back or <tt>null</tt> if there was no reponse.
|
||||
*
|
||||
* <p>Organisation: <p> Louis Pasteur University, Strasbourg, France</p>
|
||||
* <p>Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
||||
* @author Emil Ivov
|
||||
* @version 0.1
|
||||
*/
|
||||
|
||||
public class SimpleAddressDetector
|
||||
{
|
||||
/**
|
||||
* Our class logger.
|
||||
*/
|
||||
private static final Logger logger
|
||||
= Logger.getLogger(SimpleAddressDetector.class.getName());
|
||||
|
||||
/**
|
||||
* The stack to use for STUN communication.
|
||||
*/
|
||||
@ -47,7 +47,7 @@ public class SimpleAddressDetector
|
||||
private TransportAddress serverAddress = null;
|
||||
|
||||
/**
|
||||
* A utility used to flatten the multithreaded architecture of the Stack
|
||||
* A utility used to flatten the multi-threaded architecture of the Stack
|
||||
* and execute the discovery process in a synchronized manner
|
||||
*/
|
||||
private BlockingRequestSender requestSender = null;
|
||||
@ -98,9 +98,12 @@ public class SimpleAddressDetector
|
||||
|
||||
/**
|
||||
* Creates a listening point from the following address and attempts to
|
||||
* discover how it is mapped so that using inside the application is possible.
|
||||
* discover how it is mapped so that using inside the application is
|
||||
* possible.
|
||||
*
|
||||
* @param address the [address]:[port] pair where ther request should be
|
||||
* sent from.
|
||||
*
|
||||
* @return a StunAddress object containing the mapped address or null if
|
||||
* discovery failed.
|
||||
* @throws IOException if <tt>address</tt> is already bound.
|
||||
@ -153,7 +156,9 @@ public class SimpleAddressDetector
|
||||
}
|
||||
|
||||
/* in STUN bis, the response contains a XOR-MAPPED-ADDRESS */
|
||||
XorMappedAddressAttribute xorAtt = (XorMappedAddressAttribute)res.getAttribute(Attribute.XOR_MAPPED_ADDRESS);
|
||||
XorMappedAddressAttribute xorAtt = (XorMappedAddressAttribute)res
|
||||
.getAttribute(Attribute.XOR_MAPPED_ADDRESS);
|
||||
|
||||
if(xorAtt != null)
|
||||
{
|
||||
byte xoring[] = new byte[16];
|
||||
@ -219,7 +224,8 @@ public class SimpleAddressDetector
|
||||
}
|
||||
|
||||
/* in STUN bis, the response contains a XOR-MAPPED-ADDRESS */
|
||||
XorMappedAddressAttribute xorAtt = (XorMappedAddressAttribute)res.getAttribute(Attribute.XOR_MAPPED_ADDRESS);
|
||||
XorMappedAddressAttribute xorAtt = (XorMappedAddressAttribute)res
|
||||
.getAttribute(Attribute.XOR_MAPPED_ADDRESS);
|
||||
if(xorAtt != null)
|
||||
{
|
||||
byte xoring[] = new byte[16];
|
||||
@ -250,20 +256,4 @@ public class SimpleAddressDetector
|
||||
{
|
||||
return getMappingFor(new TransportAddress(port));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
public static void main(String[] args)
|
||||
throws Exception
|
||||
{
|
||||
SimpleAddressDetector detector = new SimpleAddressDetector(
|
||||
new StunAddress("stun01.sipphone.com", 3478));
|
||||
detector.start();
|
||||
StunAddress mappedAddr = detector.getMappingFor(5060);
|
||||
|
||||
System.out.println("address is " + mappedAddr);
|
||||
|
||||
detector.shutDown();
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
@ -17,8 +17,6 @@ import org.ice4j.stunclient.*;
|
||||
* and receive responses
|
||||
*
|
||||
* @author Namal Senarathne
|
||||
*
|
||||
* TODO : The constructor must have a reference to ICE Agent
|
||||
*/
|
||||
public class StunClient
|
||||
implements ResponseCollector
|
||||
@ -44,6 +42,10 @@ public class StunClient
|
||||
*/
|
||||
private HashMap<byte[], Request> requestMap = new HashMap<byte[], Request>();
|
||||
|
||||
/**
|
||||
* Creates a new Instance of the ST
|
||||
* @param stunStack
|
||||
*/
|
||||
public StunClient(StunStack stunStack)
|
||||
{
|
||||
this.stunStack = stunStack;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user