void setBufferSizes() {
if (sock != null) {
try {
sock.setSendBufferSize(ucast_send_buf_size);
} catch (Throwable ex) {
Trace.warn("UDP.setBufferSizes()", "failed setting ucast_send_buf_size in sock: " + ex);
}
try {
sock.setReceiveBufferSize(ucast_recv_buf_size);
} catch (Throwable ex) {
Trace.warn("UDP.setBufferSizes()", "failed setting ucast_recv_buf_size in sock: " + ex);
}
}
if (mcast_sock != null) {
try {
mcast_sock.setSendBufferSize(mcast_send_buf_size);
} catch (Throwable ex) {
Trace.warn(
"UDP.setBufferSizes()", "failed setting mcast_send_buf_size in mcast_sock: " + ex);
}
try {
mcast_sock.setReceiveBufferSize(mcast_recv_buf_size);
} catch (Throwable ex) {
Trace.warn(
"UDP.setBufferSizes()", "failed setting mcast_recv_buf_size in mcast_sock: " + ex);
}
}
}
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");
}
}
}
void doSend(byte[] data, InetAddress dest, int port) throws IOException {
DatagramPacket packet;
packet = new DatagramPacket(data, data.length, dest, port);
if (sock != null) {
sock.send(packet);
}
}
/**
* Workaround for the problem encountered in certains JDKs that a thread listening on a socket
* cannot be interrupted. Therefore we just send a dummy datagram packet so that the thread 'wakes
* up' and realizes it has to terminate. Should be removed when all JDKs support
* Thread.interrupt() on reads. Uses sock t send dummy packet, so this socket has to be still
* alive.
*
* @param dest The destination host. Will be local host if null
* @param port The destination port
*/
void sendDummyPacket(InetAddress dest, int port) {
DatagramPacket packet;
byte[] buf = {0};
if (dest == null) {
try {
dest = InetAddress.getLocalHost();
} catch (Exception e) {
}
}
if (Trace.debug) {
Trace.info("UDP.sendDummyPacket()", "sending packet to " + dest + ":" + port);
}
if (sock == null || dest == null) {
Trace.warn(
"UDP.sendDummyPacket()", "sock was null or dest was null, cannot send dummy packet");
return;
}
packet = new DatagramPacket(buf, buf.length, dest, port);
try {
sock.send(packet);
} catch (Throwable e) {
Trace.error(
"UDP.sendDummyPacket()",
"exception sending dummy packet to " + dest + ":" + port + ": " + e);
}
}
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();
}
void handleDiagnosticProbe(InetAddress sender, int port) {
try {
byte[] diag_rsp = getDiagResponse().getBytes();
DatagramPacket rsp = new DatagramPacket(diag_rsp, 0, diag_rsp.length, sender, port);
if (Trace.trace) {
Trace.info(
"UDP.handleDiagnosticProbe()", "sending diag response to " + sender + ":" + port);
}
sock.send(rsp);
} catch (Throwable t) {
Trace.error(
"UDP.handleDiagnosticProbe()",
"failed sending diag rsp to " + sender + ":" + port + ", exception=" + t);
}
}
/**
* Create UDP sender and receiver sockets. Currently there are 2 sockets (sending and receiving).
* This is due to Linux's non-BSD compatibility in the JDK port (see DESIGN).
*/
void createSockets() throws Exception {
InetAddress tmp_addr = null;
// bind_addr not set, try to assign one by default. This is needed on Windows
// changed by bela Feb 12 2003: by default multicast sockets will be bound to all network
// interfaces
// CHANGED *BACK* by bela March 13 2003: binding to all interfaces did not result in a correct
// local_addr. As a matter of fact, comparison between e.g. 0.0.0.0:1234 (on hostA) and
// 0.0.0.0:1.2.3.4 (on hostB) would fail !
if (bind_addr == null) {
InetAddress[] interfaces =
InetAddress.getAllByName(InetAddress.getLocalHost().getHostAddress());
if (interfaces != null && interfaces.length > 0) bind_addr = interfaces[0];
}
if (bind_addr == null) bind_addr = InetAddress.getLocalHost();
if (bind_addr != null && Trace.trace) {
Trace.info(
"UDP.createSockets()",
"unicast sockets will use interface " + bind_addr.getHostAddress());
// 2. Create socket for receiving unicast UDP packets. The address and port
// of this socket will be our local address (local_addr)
// 27-6-2003 bgooren, find available port in range (start_port, start_port+port_range)
}
int rcv_port = bind_port, max_port = bind_port + port_range;
while (rcv_port <= max_port) {
try {
sock = new DatagramSocket(rcv_port, bind_addr);
break;
} catch (SocketException bind_ex) { // Cannot listen on this port
rcv_port++;
} catch (SecurityException sec_ex) { // Not allowed to list on this port
rcv_port++;
}
// Cannot listen at all, throw an Exception
if (rcv_port == max_port + 1) { // +1 due to the increment above
throw new Exception(
"UDP.createSockets(): cannot list on any port in range "
+ bind_port
+ "-"
+ (bind_port + port_range));
}
}
// ucast_recv_sock=new DatagramSocket(bind_port, bind_addr);
if (sock == null) {
throw new Exception("UDP.createSocket(): sock is null");
}
local_addr = new IpAddress(sock.getLocalAddress(), sock.getLocalPort());
if (additional_data != null) {
local_addr.setAdditionalData(additional_data);
// 3. Create socket for receiving IP multicast packets
}
if (ip_mcast) {
mcast_sock = new MulticastSocket(mcast_port);
mcast_sock.setTimeToLive(ip_ttl);
if (bind_addr != null) {
mcast_sock.setInterface(bind_addr);
}
tmp_addr = InetAddress.getByName(mcast_addr_name);
mcast_addr = new IpAddress(tmp_addr, mcast_port);
mcast_sock.joinGroup(tmp_addr);
}
setBufferSizes();
if (Trace.trace) {
Trace.info("UDP.createSockets()", "socket information:\n" + dumpSocketInfo());
}
}
