public void run() { // Listen for packets
tracker.startReceive(System.currentTimeMillis());
try {
runLoop();
} catch (Throwable t) {
// Impossible? It keeps on exiting. We get the below,
// but not this...
try {
System.err.print(t.getClass().getName());
System.err.println();
} catch (Throwable tt) {
}
;
try {
System.err.print(t.getMessage());
System.err.println();
} catch (Throwable tt) {
}
;
try {
System.gc();
System.runFinalization();
System.gc();
System.runFinalization();
} catch (Throwable tt) {
}
try {
Runtime r = Runtime.getRuntime();
System.err.print(r.freeMemory());
System.err.println();
System.err.print(r.totalMemory());
System.err.println();
} catch (Throwable tt) {
}
;
try {
t.printStackTrace();
} catch (Throwable tt) {
}
;
} finally {
System.err.println("run() exiting for UdpSocketHandler on port " + _sock.getLocalPort());
Logger.error(this, "run() exiting for UdpSocketHandler on port " + _sock.getLocalPort());
synchronized (this) {
_isDone = true;
notifyAll();
}
}
}
@Test
public void sendEventsOverReconnectionTest()
throws IOException, InterruptedException, ServerError {
DatagramSocket serverSocket = new DatagramSocket();
final int port = serverSocket.getLocalPort();
try {
final RiemannClient client =
new RiemannClient(new SimpleUdpTransport(serverSocket.getLocalPort()));
try {
client.connect();
assertTrue(client.isConnected());
sendTestMessages(serverSocket, client);
// Close listening socket
serverSocket.close();
// Expect send to drop messages silently
final Proto.Event e = Util.createEvent();
client.sendEvents(e);
// Reopen listening socket
serverSocket = new DatagramSocket(new InetSocketAddress(port));
// Expect sent messages to be received again
sendTestMessages(serverSocket, client);
} finally {
client.disconnect();
assertFalse(client.isConnected());
}
} finally {
serverSocket.close();
}
}
/*
* Connect a UDP socket, disconnect it, then send and recv on it.
* It will fail on Linux if we don't silently bind(2) again at the
* end of DatagramSocket.disconnect().
*/
private static void testConnectedUDP(InetAddress addr) throws Exception {
try {
DatagramSocket s = new DatagramSocket(0, addr);
DatagramSocket ss = new DatagramSocket(0, addr);
System.out.print("\tconnect...");
s.connect(ss.getLocalAddress(), ss.getLocalPort());
System.out.print("disconnect...");
s.disconnect();
byte[] data = {0, 1, 2};
DatagramPacket p =
new DatagramPacket(data, data.length, s.getLocalAddress(), s.getLocalPort());
s.setSoTimeout(10000);
System.out.print("send...");
s.send(p);
System.out.print("recv...");
s.receive(p);
System.out.println("OK");
ss.close();
s.close();
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
/**
* 将事件发送到指定的目的地址
*
* @param e
* @param addr
* @param port
* @return
*/
public void sendEvent(Event e, InetAddress addr, int port) throws Exception {
Events events = new Events();
events.addEvent(e);
Log log = new Log();
log.setEvents(events);
StringWriter writer = new StringWriter();
try {
Marshaller.marshal(log, writer);
} catch (MarshalException e1) {
log().warn("marshall log error : " + e1, e1);
} catch (ValidationException e1) {
log().warn("marshall log error : " + e1, e1);
}
String dataXml = writer.toString();
if (StringUtils.trimToNull(dataXml) == null) {
log().error("event cannot marshall " + e);
throw new Exception("event cannot marshall");
}
byte[] data = dataXml.getBytes();
m_pkt = new DatagramPacket(data, data.length);
// m_pkt.setAddress(InetAddress.getByName("127.0.0.1"));
// m_pkt.setPort(5817);
System.out.println("add is : " + addr);
System.out.println("port is : " + port);
System.out.println("m_dgSocket is : " + m_dgSocket.getLocalPort());
m_pkt.setAddress(addr);
m_pkt.setPort(port);
m_dgSocket.send(m_pkt);
}
/** Receive loop for private messaqes. Can be stopped with {@link #setRunning(boolean)} */
private void receivePrivateMessages() {
while (isRunning()) {
try {
final byte[] buf = new byte[BUFFER_SIZE];
final DatagramPacket receivePacket = new DatagramPacket(buf, buf.length);
if (LOG.isDebugEnabled()) {
LOG.debug(
"Waiting for private message, listening on port " + privateSocket.getLocalPort());
}
privateSocket.receive(receivePacket); // wait for a packet
final String data = toString(receivePacket);
if (LOG.isDebugEnabled()) {
LOG.debug("Got a private message: " + data);
}
if (LOG.isDebugEnabled()) {
LOG.debug(
"Received "
+ data
+ " from "
+ receivePacket.getAddress()
+ ":"
+ receivePacket.getPort()
+ ".");
}
processPrivateMessage(data);
} catch (IOException e) {
LOG.error(BUNDLE_MARKER, e.toString(), e);
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("Stopped listening to private messages.");
}
}
private ByteArrayOutputStream receiveFile() {
ByteArrayOutputStream byteOuput = new ByteArrayOutputStream();
int block = 1;
do {
try {
System.out.println("TFTP Packet Count:" + block);
block++;
bufferByteArray = new byte[516];
inDatagramPacket =
new DatagramPacket(
bufferByteArray, bufferByteArray.length, address, datagramSocket.getLocalPort());
datagramSocket.receive(inDatagramPacket);
byte opCode = bufferByteArray[1];
if (opCode == OP_ERROR) {
reportError();
} else if (opCode == OP_DATA) {
byte[] blockNumber = {bufferByteArray[2], bufferByteArray[3]};
DataOutputStream output = new DataOutputStream(byteOuput);
output.write(inDatagramPacket.getData(), 4, inDatagramPacket.getLength() - 4);
sendAck(blockNumber);
}
} catch (IOException ex) {
Logger.getLogger(TFTPClient.class.getName()).log(Level.SEVERE, null, ex);
}
} while (!isLastPacket(inDatagramPacket));
return byteOuput;
}
/**
* Activate this <tt>UDPTerminal</tt>.
*
* @throws Exception if there is a network failure.
*/
public synchronized void activate() throws Exception {
if (!isActive()) {
if (Modbus.debug)
CCLog.info(
"UDPMasterTerminal::activate()::laddr=:" + m_LocalAddress + ":lport=" + m_LocalPort);
if (m_Socket == null) {
if (m_LocalAddress != null && m_LocalPort != -1) {
m_Socket = new DatagramSocket(m_LocalPort, m_LocalAddress);
} else {
m_Socket = new DatagramSocket();
m_LocalPort = m_Socket.getLocalPort();
m_LocalAddress = m_Socket.getLocalAddress();
}
}
if (Modbus.debug) CCLog.info("UDPMasterTerminal::haveSocket():" + m_Socket.toString());
if (Modbus.debug)
CCLog.info(
"UDPMasterTerminal::laddr=:" + m_LocalAddress.toString() + ":lport=" + m_LocalPort);
if (Modbus.debug)
CCLog.info(
"UDPMasterTerminal::raddr=:" + m_RemoteAddress.toString() + ":rport=" + m_RemotePort);
m_Socket.setReceiveBufferSize(1024);
m_Socket.setSendBufferSize(1024);
m_ModbusTransport = new ModbusUDPTransport(this);
m_Active = true;
}
if (Modbus.debug) CCLog.info("UDPMasterTerminal::activated");
}
/**
* Activate this <tt>UDPTerminal</tt>.
*
* @throws Exception if there is a network failure.
*/
public synchronized void activate() throws Exception {
if (!isActive()) {
if (Modbus.debug) System.out.println("UDPSlaveTerminal.activate()");
if (m_Socket == null) {
if (m_LocalAddress != null && m_LocalPort != -1) {
m_Socket = new DatagramSocket(m_LocalPort, m_LocalAddress);
} else {
m_Socket = new DatagramSocket();
m_LocalPort = m_Socket.getLocalPort();
m_LocalAddress = m_Socket.getLocalAddress();
}
}
if (Modbus.debug) System.out.println("UDPSlaveTerminal::haveSocket():" + m_Socket.toString());
if (Modbus.debug)
System.out.println(
"UDPSlaveTerminal::addr=:" + m_LocalAddress.toString() + ":port=" + m_LocalPort);
m_Socket.setReceiveBufferSize(1024);
m_Socket.setSendBufferSize(1024);
m_PacketReceiver = new PacketReceiver();
m_Receiver = new Thread(m_PacketReceiver);
m_Receiver.start();
if (Modbus.debug) System.out.println("UDPSlaveTerminal::receiver started()");
m_PacketSender = new PacketSender();
m_Sender = new Thread(m_PacketSender);
m_Sender.start();
if (Modbus.debug) System.out.println("UDPSlaveTerminal::sender started()");
m_ModbusTransport = new ModbusUDPTransport(this);
if (Modbus.debug) System.out.println("UDPSlaveTerminal::transport created");
m_Active = true;
}
if (Modbus.debug) System.out.println("UDPSlaveTerminal::activated");
}
public static void doEcho(int port) throws IOException {
byte[] buf = new byte[BUF_SIZE];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
DatagramSocket sock = new DatagramSocket(port);
System.out.println(
"Starting UDP echo on"
+ sock.getLocalAddress().getHostAddress()
+ ":"
+ sock.getLocalPort());
while (true) {
try {
sock.receive(packet);
sock.send(packet);
System.out.print(
"UDP From: "
+ packet.getAddress().getHostAddress()
+ ":"
+ packet.getPort()
+ "\n"
+ new String(packet.getData(), 0, packet.getLength())
+ "\n");
System.out.flush();
packet.setLength(buf.length);
// packet = new DatagramPacket(buf,buf.length);
} catch (IOException io_ex) {
}
}
}
public TcpUdpBridgeServer(
String remoteTcpHost, String remoteUdpHost, int remoteTcpPort, int remoteUdpPort) {
this.remoteTcpHost = remoteTcpHost;
this.remoteUdpHost = remoteUdpHost;
this.remoteTcpPort = remoteTcpPort;
this.remoteUdpPort = remoteUdpPort;
try {
serverTcpSocket = new ServerSocket(remoteTcpPort);
localUdpSocket = new DatagramSocket(0);
localUdpPort = localUdpSocket.getLocalPort();
LOGGER.fine("UDP: " + localUdpSocket.getLocalPort());
} catch (IOException e) {
e.printStackTrace();
}
startBridge();
}
public RequestReceiver(int port) throws IOException {
UDPserverSocket = new DatagramSocket(port);
System.out.println(
"UDP Request Receiver Running on "
+ UDPserverSocket.getInetAddress()
+ ":"
+ UDPserverSocket.getLocalPort());
UDPserverSocket.setSoTimeout(0);
}
static String printSocket(DatagramSocket socket) {
return "[Socket: localPort="
+ socket.getLocalPort()
+ ", remoteAddr="
+ socket.getInetAddress()
+ ", localAddr="
+ socket.getLocalAddress()
+ "]";
}
/** Sends a single broadcast discovery request. */
private void sendProbe() {
DatagramPacket packet = makeRequestPacket(DESIRED_SERVICE, mSocket.getLocalPort());
try {
mSocket.send(packet);
} catch (IOException e) {
Log.e(LOG_TAG, "Exception sending broadcast probe", e);
return;
}
}
/**
* ローカル接続データを
*
* @param connectionData
*/
private void addLocalData(ConnectionData connectionData) {
if (localDataSend) {
try {
connectionData.setLocalAddress(InetAddress.getLocalHost().getHostAddress());
connectionData.setLocalPort(socket.getLocalPort());
System.out.println(connectionData.encode());
} catch (Exception e) {
}
}
}
public InetSocketAddress getLocalAddress() throws IOException {
synchronized (generalSync) {
if (ms != null) {
final DatagramSocket ds = ms;
return getLocalAddress(ds.getLocalAddress(), ds.getLocalPort());
} else {
return getLocalAddress(localAddress.getAddress(), localAddress.getPort());
}
}
}
void closeSocket() {
if (sock != null) {
// by sending a dummy packet, the thread will terminate (if it was flagged as stopped before)
sendDummyPacket(sock.getLocalAddress(), sock.getLocalPort());
sock.close();
sock = null;
if (Trace.trace) {
Trace.info("UDP.closeSocket()", "socket closed");
}
}
}
/**
* Send a block of encoded bytes to a peer. This is called by send, and by
* IncomingPacketFilter.processOutgoing(..).
*
* @param blockToSend The data block to send.
* @param destination The peer to send it to.
*/
public void sendPacket(byte[] blockToSend, Peer destination, boolean allowLocalAddresses)
throws LocalAddressException {
assert (blockToSend != null);
if (!_active) {
Logger.error(this, "Trying to send packet but no longer active");
// It is essential that for recording accurate AddressTracker data that we don't send any more
// packets after shutdown.
return;
}
// there should be no DNS needed here, but go ahead if we can, but complain doing it
if (destination.getAddress(false, allowLocalAddresses) == null) {
Logger.error(
this,
"Tried sending to destination without pre-looked up IP address(needs a real Peer.getHostname()): null:"
+ destination.getPort(),
new Exception("error"));
if (destination.getAddress(true, allowLocalAddresses) == null) {
Logger.error(
this,
"Tried sending to bad destination address: null:" + destination.getPort(),
new Exception("error"));
return;
}
}
if (_dropProbability > 0) {
if (dropRandom.nextInt() % _dropProbability == 0) {
Logger.normal(this, "DROPPED: " + _sock.getLocalPort() + " -> " + destination.getPort());
return;
}
}
InetAddress address = destination.getAddress(false, allowLocalAddresses);
assert (address != null);
int port = destination.getPort();
DatagramPacket packet = new DatagramPacket(blockToSend, blockToSend.length);
packet.setAddress(address);
packet.setPort(port);
try {
_sock.send(packet);
tracker.sentPacketTo(destination);
collector.addInfo(address + ":" + port, 0, blockToSend.length + UDP_HEADERS_LENGTH);
if (logMINOR)
Logger.minor(
this, "Sent packet length " + blockToSend.length + " to " + address + ':' + port);
} catch (IOException e) {
if (packet.getAddress() instanceof Inet6Address) {
Logger.normal(
this, "Error while sending packet to IPv6 address: " + destination + ": " + e, e);
} else {
Logger.error(this, "Error while sending packet to " + destination + ": " + e, e);
}
}
}
public DirectoryServer(int port) throws Exception {
super("Directory Server", false);
boolean connected = false;
try {
udp_socket = new DatagramSocket(port);
System.out.println("The DirectoryServer UDP socket was bound to port: " + port);
} catch (SocketException e) {
udp_socket = new DatagramSocket();
System.out.println(
"The DirectoryServer UDP socket was bound to port: " + udp_socket.getLocalPort());
}
udp_socket.setSoTimeout(Server.TIMEOUT_Server);
dsu = new DirectoryServerUDP(this);
if (Application.db_dir == null) {
db_dir = getDirDB(Application.CURRENT_DATABASE_DIR() + Application.DIRECTORY_FILE);
Application.db_dir = db_dir;
} else db_dir = Application.db_dir;
do {
try {
if (port <= 0) port = Server.getRandomPort();
ss = new ServerSocket(port);
connected = true;
} catch (Exception e) {
e.printStackTrace();
connected = false;
port = Server.getRandomPort();
}
} while (!connected);
System.out.println("Got port: " + ss.getLocalPort());
/*
System.out.println("Got net: "+ss.getInetAddress());
System.out.println("Got sock: "+ss.getLocalSocketAddress());
System.out.println("Got obj: "+ss);
*/
Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
for (NetworkInterface netint : Collections.list(nets)) {
out.printf("Display name: %s\n", netint.getDisplayName());
out.printf(
"Name: %s (loopback: %s; p2p:%s; up: %s, v: %s, m:%s)\n",
netint.getName(),
"" + netint.isLoopback(),
"" + netint.isPointToPoint(),
"" + netint.isUp(),
"" + netint.isVirtual(),
"" + netint.supportsMulticast());
Enumeration<InetAddress> inetAddresses = netint.getInetAddresses();
for (InetAddress inetAddress : Collections.list(inetAddresses)) {
out.printf("inetAddress: %s\n", inetAddress);
}
}
initAcceptedInets();
}
/**
* Empfangen einer Nachricht ueber UDP
*
* @return Referenz auf Nachricht, die empfangen wurde
* @param timeout Wartezeit in ms
* @throws IOException
*/
public Object receive(int timeout) throws IOException, SocketTimeoutException {
// Maximale Wartezeit fuer Receive am Socket einstellen
try {
log.info("RECEIVE MIT TIMEOUT: " + timeout);
socket.setSoTimeout(timeout);
// System.out.println("RECEIVE: Maximale Wartezeit: " +
// timeout +" ms");
} catch (SocketException e) {
log.error("RECEIVE: " + "Fehler beim Einstellen der maximalen Wartezeit");
throw e;
}
byte[] bytes = new byte[65527];
DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
// System.out.println("VOR: Empfangene Datenlaenge: " + packet.getLength());
try {
// Blockiert nur, bis Timeout abgelaufen ist
socket.receive(packet);
log.debug("RECEIVE: Empfangene Datenlaenge: " + packet.getLength());
System.out.println("RECEIVE: Empfangene Datenlaenge: " + packet.getLength());
} catch (IOException e2) {
log.error("RECEIVE: " + "Fehler beim Empfangen einer PDU ueber UDP", e2);
throw e2;
}
ByteArrayInputStream bais = new ByteArrayInputStream(packet.getData());
ObjectInputStream ois = new ObjectInputStream(bais);
Object pdu;
try {
// System.out.println("RECEIVE: " +
// "Verfuegbare Bytes Inputstream des UDP-Sockets:" +
// ois.available());
pdu = ois.readObject();
remoteAddress = packet.getAddress();
remotePort = packet.getPort();
log.debug("RECEIVE: " + packet.getPort() + "->" + socket.getLocalPort());
} catch (ClassNotFoundException e) {
log.error("RECEIVE: " + "ClassNotFoundException:", e);
return null;
}
log.info("RECEIVE MIT TIMEOUT ENDE: " + timeout);
return pdu;
}
public ClientTransaction preProcessInvite(SipRequest sipRequest) throws SipUriSyntaxException {
// 8.1.2
SipHeaders requestHeaders = sipRequest.getSipHeaders();
SipURI destinationUri = RequestManager.getDestinationUri(sipRequest, logger);
// TODO if header route is present, addrspec = toproute.nameaddress.addrspec
String transport = RFC3261.TRANSPORT_UDP;
Hashtable<String, String> params = destinationUri.getUriParameters();
if (params != null) {
String reqUriTransport = params.get(RFC3261.PARAM_TRANSPORT);
if (reqUriTransport != null) {
transport = reqUriTransport;
}
}
int port = destinationUri.getPort();
if (port == SipURI.DEFAULT_PORT) {
port = RFC3261.TRANSPORT_DEFAULT_PORT;
}
SipURI sipUri = userAgent.getConfig().getOutboundProxy();
if (sipUri == null) {
sipUri = destinationUri;
}
InetAddress inetAddress;
try {
inetAddress = InetAddress.getByName(sipUri.getHost());
} catch (UnknownHostException e) {
throw new SipUriSyntaxException("unknown host: " + sipUri.getHost(), e);
}
ClientTransaction clientTransaction =
transactionManager.createClientTransaction(
sipRequest, inetAddress, port, transport, null, this);
DatagramSocket datagramSocket;
synchronized (this) {
datagramSocket = getDatagramSocket();
}
try {
SessionDescription sessionDescription =
sdpManager.createSessionDescription(null, datagramSocket.getLocalPort());
sipRequest.setBody(sessionDescription.toString().getBytes());
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
requestHeaders.add(
new SipHeaderFieldName(RFC3261.HDR_CONTENT_TYPE),
new SipHeaderFieldValue(RFC3261.CONTENT_TYPE_SDP));
return clientTransaction;
}
@Test
public void sendEventsTest() throws IOException, InterruptedException, ServerError {
final DatagramSocket serverSocket = new DatagramSocket();
try {
final RiemannClient client =
new RiemannClient(new SimpleUdpTransport(serverSocket.getLocalPort()));
try {
client.connect();
sendTestMessages(serverSocket, client);
} finally {
client.disconnect();
}
} finally {
serverSocket.close();
}
}
private void printState(PrintStream out) {
out.println("UdpSimpleSession state dumping:");
if (sock != null) out.println("Local UDP port: " + sock.getLocalPort());
Iterator iter = multicastReaders.keySet().iterator();
while (iter.hasNext())
out.println("Local Multicast address: " + ((InetSocketAddress) iter.next()));
int nChannels = channels.size();
out.println("Currently connected channels: " + nChannels);
iter = channels.values().iterator();
while (iter.hasNext()) {
Channel c = (Channel) iter.next();
out.println("Channel name: " + c.getChannelID() + " QoS: " + c.getQoS().getQoSID());
}
}
public int start(int port) throws SocketException {
if (socket != null) {
// Server is already running
throw new RuntimeException("Server is already running.");
}
if (port <= 0) {
socket = new DatagramSocket();
} else {
socket = new DatagramSocket(port);
}
int localPort = socket.getLocalPort();
LOGGER.info("Server is started at " + localPort);
startReceiving();
return localPort;
}
/**
* The method queries a Stun server for a binding for the port and address that <tt>sock</tt> is
* bound on.
*
* @param sock the socket whose port and address we'dlike to resolve (the stun message gets sent
* trhough that socket)
* @return StunAddress the address returned by the stun server or null if an error occurred or no
* address was returned
* @throws IOException if an error occurs while stun4j is using sockets.
* @throws BindException if the port is already in use.
*/
private StunAddress queryStunServer(DatagramSocket sock) throws IOException, BindException {
StunAddress mappedAddress = null;
if (detector != null && useStun) {
mappedAddress = detector.getMappingFor(sock);
if (logger.isTraceEnabled()) {
logger.trace(
"For socket with address "
+ sock.getLocalAddress().getHostAddress()
+ " and port "
+ sock.getLocalPort()
+ " the stun server returned the "
+ "following mapping ["
+ mappedAddress
+ "]");
}
}
return mappedAddress;
}
public NetworkManager(String ipAddress, int port) {
// Start the Network Sender thread
// This thread will read from the mWriteToPcQueue and send packets to the PC application
// The mWriteToPcQueue will get packets from the FT_Device write call
try {
mSocket = new DatagramSocket(port);
Log.v("D2xx::", "Local Port " + mSocket.getLocalPort());
NetworkSender myNetworkSender =
new NetworkSender(mWriteToPcQueue, ipAddress, mSocket, port); // Runnable
Thread networkSenderThread = new Thread(myNetworkSender);
networkSenderThread.start();
NetworkReceiver myNetworkReceiver = new NetworkReceiver(mReadFromPcQueue, mSocket);
Thread networkReceiverThread = new Thread(myNetworkReceiver);
networkReceiverThread.start();
} catch (IOException e) {
e.printStackTrace();
}
}
public void run() {
System.out.println(" -----------------UDP Demo Server-----------------" + "\n\n");
while (true) {
try {
// Create a new socket connection bound to the defined port
DatagramSocket sock = new DatagramSocket(BROADCAST_PORT);
System.out.println("Waiting for data on local port: " + sock.getLocalPort());
// Create a packet to contain incoming data
byte[] buf = new byte[256];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
// Wait for incoming data (receive() is a blocking method)
sock.receive(packet);
// Retrieve data from packet and display
String data = new String(packet.getData());
int endIndex = data.indexOf(0);
data = data.substring(0, endIndex);
int remotePort = packet.getPort();
System.out.println("Received data from remote port " + remotePort + ":\n" + data);
// Determine origin of packet and display information
InetAddress remoteAddress = packet.getAddress();
System.out.println("Sent from address: " + remoteAddress.getHostAddress());
// Send back an acknowledgment
String ack = "RECEIVED " + new Date().toString();
sock.send(new DatagramPacket(ack.getBytes(), ack.length(), remoteAddress, remotePort));
sock.close();
} catch (IOException ioe) {
System.out.println("Error: IOException - " + ioe.toString());
}
}
}
@Before
public void setUp() throws Exception {
DatagramSocket serverSocket = startFakeTurnServer();
instance = new TurnClientImpl();
instance.scheduledExecutorService = scheduledExecutorService;
instance.lobbyServerAccessor = lobbyServerAccessor;
instance.turnHost = serverSocket.getLocalAddress().getHostAddress();
instance.turnPort = serverSocket.getLocalPort();
eventsReceivedByTurnServer = new LinkedBlockingQueue<>();
Mockito.doAnswer(
invocation -> {
invocation.getArgumentAt(0, Runnable.class).run();
return null;
})
.when(scheduledExecutorService)
.execute(any());
instance.postConstruct();
}
String dumpSocketInfo() throws Exception {
StringBuffer sb = new StringBuffer();
sb.append("local_addr=").append(local_addr);
sb.append(", mcast_addr=").append(mcast_addr);
sb.append(", bind_addr=").append(bind_addr);
sb.append(", ttl=").append(ip_ttl);
if (sock != null) {
sb.append("\nsocket: bound to ");
sb.append(sock.getLocalAddress().getHostAddress()).append(":").append(sock.getLocalPort());
sb.append(", receive buffer size=").append(sock.getReceiveBufferSize());
sb.append(", send buffer size=").append(sock.getSendBufferSize());
}
if (mcast_sock != null) {
sb.append("\nmulticast socket: bound to ");
sb.append(mcast_sock.getInterface().getHostAddress())
.append(":")
.append(mcast_sock.getLocalPort());
sb.append(", send buffer size=").append(mcast_sock.getSendBufferSize());
sb.append(", receive buffer size=").append(mcast_sock.getReceiveBufferSize());
}
return sb.toString();
}
/**
* 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());
}
}
public UDPEcho(String host, int port) throws IOException, UnknownHostException {
this.hostIP = InetAddress.getByName(host);
this.port = port;
sock = new DatagramSocket();
System.out.println("UDP: " + sock.getLocalAddress() + ":" + sock.getLocalPort());
// sock.connect(hostIP,port);
}