protected void doTearDown() throws Exception {
try {
s1.close();
} catch (Exception e) {
// ignore
}
try {
s2.close();
} catch (Exception e) {
// ignore
}
super.doTearDown();
}
public void run() {
try {
MulticastSocket socket = new MulticastSocket(UDP_SERVER_PORT);
DatagramPacket packet;
WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE);
@SuppressWarnings("deprecation")
String ip = Formatter.formatIpAddress(wm.getConnectionInfo().getIpAddress());
String partialIp = "";
for (int j = ip.length() - 1; j > 0; j--) {
if (ip.charAt(j) == '.') {
partialIp = ip.substring(0, j + 1);
break;
}
}
for (int i = 2; i <= 255; i++) {
String messageStr = "SAMMS6 Client";
InetAddress sendingAddress =
InetAddress.getByName(partialIp + Integer.toString(i)); // 127.0.0.1
packet =
new DatagramPacket(
messageStr.getBytes(), messageStr.length(), sendingAddress, UDP_SERVER_PORT);
socket.send(packet);
}
socket.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
void MulticastSocketTests() throws Exception {
test("Check SO_REUSEADDR is enabled in MulticastSocket()");
MulticastSocket s1 = new MulticastSocket();
check(s1.getReuseAddress());
s1.close();
test("Check that SO_REUSEADDR is not disabled by " + "MulticastSocket.bind()");
s1 = new MulticastSocket(null);
// bind to specific address
InetSocketAddress isa = new InetSocketAddress(InetAddress.getLocalHost(), 0);
s1.bind(isa);
check(s1.getReuseAddress());
s1.close();
}
@Override
public void run() {
if (!Thread.currentThread().getName().equals("DiscoveryListener daemon")) {
throw new RuntimeException("No right to call this method");
}
inService = true;
while (inService) {
try {
listenBroadCast();
} catch (SocketTimeoutException ex) {
// ignoring
} catch (IOException ioEx) {
ioEx.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
inService = false;
}
}
try {
skt.leaveGroup(InetAddress.getByName(Discovery.SSDP_IP));
skt.close();
} catch (Exception ex) {
// ignoring
}
}
/** Stop listening. */
public void stop() {
isRunning = false;
if (udpListenRequestSocket != null) {
udpListenRequestSocket.close();
}
}
@Override
public int send(String mess) throws Exception, RemoteException, RemoteException {
if (s == null) {
try {
group = InetAddress.getByName(config.getGroup());
if (config.getHost() != null) {
InetAddress addr = InetAddress.getByName(config.getHost());
InetSocketAddress addrs = new InetSocketAddress(addr, config.getMultiport());
s = new MulticastSocket(addrs);
} else s = new MulticastSocket(config.getMultiport());
s.setTimeToLive(config.getTtl());
s.joinGroup(group);
} catch (Exception ex) {
log.error("Unable to use multicast: " + ex);
s = null;
return -1;
}
}
byte[] buf;
buf = mess.getBytes(US_ASCII);
DatagramPacket data = new DatagramPacket(buf, buf.length, group, config.getMultiport());
try {
s.send(data);
} catch (Exception ex) {
log.error("Unable to send colllected load information: " + ex);
s.close();
s = null;
return -1;
}
return 0;
}
/** Close this connection. */
@Override
public synchronized void close() {
if (!connected) {
return;
}
// Finish with the multicast socket
try {
socket.leaveGroup(((MIOPProfile) profile).getGroupInetAddress());
} catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Exception when closing the socket", ex);
}
}
try {
socket.close();
// this will cause exceptions when trying to read from
// the streams. Better than "nulling" them.
if (in_stream != null) {
in_stream.close();
}
if (out_stream != null) {
out_stream.close();
}
} catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Exception when closing the socket", ex);
}
}
connected = false;
}
@Override
protected String doInBackground(String... params) {
WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE);
if (wm != null) {
MulticastLock mcLock = wm.createMulticastLock("SAAMS6");
mcLock.acquire();
}
byte[] byteMessage = new byte[MAX_UDP_DATAGRAM_LEN];
DatagramPacket packet = new DatagramPacket(byteMessage, byteMessage.length);
MulticastSocket socket = null;
while (keepRunning) {
try {
socket = new MulticastSocket(UDP_SERVER_PORT);
socket.receive(packet);
String message = new String(byteMessage, 0, packet.getLength());
if (message.equals("SAMMS6 Server")) {
ServerIP = packet.getSocketAddress().toString();
socket.close();
keepRunning = false;
}
} catch (Throwable e) {
e.printStackTrace();
}
}
return ServerIP;
}
/**
* Connect the socket. Called by MIOPListener.
*
* @param profile
* @param time_out unused, we use SO_TIMEOUT
*/
@Override
public void connect(Profile profile, long time_out) {
if (!is_connected()) {
if (profile instanceof MIOPProfile) {
this.profile = (MIOPProfile) profile;
} else {
throw new org.omg.CORBA.BAD_PARAM(
"attempt to connect an MIOP connection "
+ "to a non-MIOP profile: "
+ profile.getClass());
}
try {
socket = new MulticastSocket(((MIOPProfile) profile).getUIPMCProfile().the_port);
socket.setSoTimeout(socketTimeout);
socket.setTimeToLive(timeToLive);
socket.joinGroup(((MIOPProfile) profile).getGroupInetAddress());
connection_info = socket.toString();
} catch (Exception e) {
if (socket != null) {
socket.close();
}
throw new RuntimeException("Can't create multicast socket: " + profile);
}
connected = true;
groupListener.start();
}
}
/** Leave multicast group and close the multicast socket. */
public void close() {
try {
multicastSocket.leaveGroup(group);
multicastSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Shutdown the listening and publishing resources used for the discovery, as appropriate.
*
* @param grl
*/
protected void cleanupResources(DiscoveryListener grl) {
if (grl != null) { // stop listener
grl.stop();
}
if (udpSocket != null) {
udpSocket.close();
}
}
protected void closeChannel() throws IOException {
if (ms != null) {
try {
ms.close();
} finally {
ms = null;
}
}
}
@Test
public void verifySendMulticast() throws Exception {
MulticastSocket socket;
try {
socket = new MulticastSocket();
} catch (Exception e) {
return;
}
final int testPort = socket.getLocalPort();
final String multicastAddress = this.multicastRule.getGroup();
final String payload = "foo";
final CountDownLatch listening = new CountDownLatch(2);
final CountDownLatch received = new CountDownLatch(2);
Runnable catcher =
new Runnable() {
@Override
public void run() {
try {
byte[] buffer = new byte[8];
DatagramPacket receivedPacket = new DatagramPacket(buffer, buffer.length);
MulticastSocket socket = new MulticastSocket(testPort);
socket.setInterface(InetAddress.getByName(multicastRule.getNic()));
InetAddress group = InetAddress.getByName(multicastAddress);
socket.joinGroup(group);
listening.countDown();
LogFactory.getLog(getClass())
.debug(Thread.currentThread().getName() + " waiting for packet");
socket.receive(receivedPacket);
socket.close();
byte[] src = receivedPacket.getData();
int length = receivedPacket.getLength();
int offset = receivedPacket.getOffset();
byte[] dest = new byte[length];
System.arraycopy(src, offset, dest, 0, length);
assertEquals(payload, new String(dest));
LogFactory.getLog(getClass())
.debug(Thread.currentThread().getName() + " received packet");
received.countDown();
} catch (Exception e) {
listening.countDown();
e.printStackTrace();
}
}
};
Executor executor = Executors.newFixedThreadPool(2);
executor.execute(catcher);
executor.execute(catcher);
assertTrue(listening.await(10000, TimeUnit.MILLISECONDS));
MulticastSendingMessageHandler handler =
new MulticastSendingMessageHandler(multicastAddress, testPort);
handler.setLocalAddress(this.multicastRule.getNic());
handler.handleMessage(MessageBuilder.withPayload(payload).build());
assertTrue(received.await(10000, TimeUnit.MILLISECONDS));
handler.stop();
socket.close();
}
public void leaveGroupe() {
try {
multicastSocket.leaveGroup(InetAddress.getByName(adresse));
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
multicastSocket.close();
}
public static void main(String[] args) throws Exception {
InetAddress addr = InetAddress.getByName("230.0.0.1");
MulticastSocket soc = new MulticastSocket(2056);
soc.joinGroup(addr);
DatagramPacket dp = new DatagramPacket(new byte[80], 80);
for (int i = 0; i < 5; i++) {
soc.receive(dp);
String msg = new String(dp.getData(), 0, dp.getLength());
System.out.println(msg);
}
soc.leaveGroup(addr);
soc.close();
}
@Before
public void assumeMulticast() throws Exception {
InetAddress multicastAddress = InetAddress.getByName("239.255.0.1");
// Make sure receiver is setup before the sender, otherwise the packet gets lost
MulticastSocket receiver = new MulticastSocket(0);
receiver.joinGroup(multicastAddress);
MulticastSocket sender = new MulticastSocket();
sender.setTimeToLive(1);
sender.send(
new DatagramPacket(new byte[] {1}, 0, 1, multicastAddress, receiver.getLocalPort()));
sender.close();
byte[] buffer = new byte[1];
receiver.setSoTimeout(1000);
try {
receiver.receive(new DatagramPacket(buffer, 0, buffer.length));
} catch (SocketTimeoutException x) {
Assume.assumeNoException(x);
} finally {
receiver.close();
}
}
public synchronized void shutdown() {
active = false;
if (advertiseViaMulticastDNS) {
zeroConf.unadvertise();
}
if (handlerThread != null) {
handlerThread.interrupt();
}
if (receiverThread != null) {
receiverThread.interrupt();
}
if (socket != null) {
socket.close();
}
}
public void stop() {
try {
if (!running && multicastSocket.isClosed()) {
return;
}
try {
multicastSocket.close();
} catch (Throwable ignored) {
}
running = false;
if (!stopLatch.await(5, TimeUnit.SECONDS)) {
logger.warning("Failed to shutdown MulticastService in 5 seconds!");
}
} catch (Throwable e) {
logger.warning(e);
}
}
public static void main(final String[] args) throws Exception {
// System.setProperty("java.net.preferIPv4Stack", "true");
if (2 != args.length && 3 != args.length) {
System.out.println(
"Usage: java MulticastSender <multicast address> <number of messages> [interface]");
return;
}
final String address = args[0];
final long count = Long.parseLong(args[1]);
final int port = 4445;
final int serverPort = 4447;
final byte[] buffer = "This is a test string with sufficient data to send".getBytes("ASCII");
final InetAddress group = InetAddress.getByName(address);
MulticastSocket socket;
if (3 == args.length) {
final String interfaceAddress = args[2];
System.out.println("Binding to interface: " + interfaceAddress);
socket = new MulticastSocket(new InetSocketAddress(interfaceAddress, serverPort));
} else {
socket = new MulticastSocket(serverPort);
}
final DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, port);
final MulticastSender sender = new MulticastSender();
final Thread t = new Thread(sender);
t.setDaemon(true);
t.start();
for (long i = count; --i != 0; ) {
packet.setData(buffer);
socket.send(packet);
sender.messageCounter++;
}
Thread.sleep(1000);
socket.close();
}
public boolean send(String msg, String bindAddr, int bindPort) {
try {
MulticastSocket msock;
if ((bindAddr) != null && (0 < bindPort)) {
msock = new MulticastSocket(null);
msock.bind(new InetSocketAddress(bindAddr, bindPort));
} else msock = new MulticastSocket();
DatagramPacket dgmPacket = new DatagramPacket(msg.getBytes(), msg.length(), ssdpMultiGroup);
// Thnaks for Tho Beisch (11/09/04)
msock.setTimeToLive(4);
msock.send(dgmPacket);
msock.close();
} catch (Exception e) {
Debug.warning(e);
return false;
}
return true;
}
void closeMulticastSocket() {
if (mcast_sock != null) {
try {
if (mcast_addr != null) {
// by sending a dummy packet the thread will be awakened
sendDummyPacket(mcast_addr.getIpAddress(), mcast_addr.getPort());
Util.sleep(300);
mcast_sock.leaveGroup(mcast_addr.getIpAddress());
}
mcast_sock.close(); // this will cause the mcast receiver thread to break out of its loop
mcast_sock = null;
if (Trace.trace) {
Trace.info("UDP.closeMulticastSocket()", "multicast socket closed");
}
} catch (IOException ex) {
}
mcast_addr = null;
}
}
public OioDatagramChannel(Integer id, MulticastSocket socket) {
super(null, id);
boolean success = false;
try {
socket.setSoTimeout(SO_TIMEOUT);
socket.setBroadcast(false);
success = true;
} catch (SocketException e) {
throw new ChannelException("Failed to configure the datagram socket timeout.", e);
} finally {
if (!success) {
socket.close();
}
}
this.socket = socket;
config = new DefaultDatagramChannelConfig(socket);
}
@Override
protected void doConnect(SocketAddress remoteAddress, SocketAddress localAddress)
throws Exception {
if (localAddress != null) {
socket.bind(localAddress);
}
boolean success = false;
try {
socket.connect(remoteAddress);
success = true;
} finally {
if (!success) {
try {
socket.close();
} catch (Throwable t) {
logger.warn("Failed to close a socket.", t);
}
}
}
}
public static void main(String[] args) throws IOException {
MulticastSocket socket = new MulticastSocket(4446);
InetAddress address = InetAddress.getByName("230.0.0.1");
socket.joinGroup(address);
DatagramPacket packet;
// get a few quotes
for (int i = 0; i < 5; i++) {
byte[] buf = new byte[256];
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("Quote of the Moment: " + received);
}
socket.leaveGroup(address);
socket.close();
}
public void updatePeers(Integer processId, Integer transactionId) {
MulticastSocket socket = null;
try {
socket = new MulticastSocket(multicastPort);
byte[] buf = new byte[256];
// don't wait for request...just send a quote
String dString = processId.toString() + ":" + transactionId.toString();
buf = dString.getBytes();
InetAddress group = InetAddress.getByName(multicastAddress);
DatagramPacket packet;
packet = new DatagramPacket(buf, buf.length, group, multicastPort);
socket.send(packet);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (socket != null) socket.close();
}
}
public void listenMulticast() throws IOException, InterruptedException {
MulticastSocket socket = new MulticastSocket(multicastPort);
InetAddress group = InetAddress.getByName(multicastAddress);
socket.joinGroup(group);
DatagramPacket packet;
while (true) {
byte[] buf = new byte[256];
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
String received = new String(packet.getData()).trim();
String[] data = received.split(":");
if (Integer.parseInt(data[0]) == this.id) {
consecutiveReceptions++;
} else {
consecutiveReceptions = 0;
}
if (ProcIdLastTimeMap.containsKey(this.id.toString())) {
if (System.currentTimeMillis() - ProcIdLastTimeMap.get(id.toString())
< peersUpdateInterval + 1) {
updatePeers(id, 0);
sleep(peersUpdateInterval);
}
}
ProcIdTransIdMap.put(data[0], data[1]);
ProcIdLastTimeMap.put(data[0], System.currentTimeMillis());
// System.out.println("MulticastReceived: " + received);
if (shouldBeRunning()) {
break;
}
}
socket.leaveGroup(group);
socket.close();
}
public void exit() {
stop();
socket.close();
}
@Test
public void verifySendMulticastWithAcks() throws Exception {
MulticastSocket socket;
try {
socket = new MulticastSocket();
} catch (Exception e) {
return;
}
final int testPort = socket.getLocalPort();
final AtomicInteger ackPort = new AtomicInteger();
final String multicastAddress = "225.6.7.8";
final String payload = "foobar";
final CountDownLatch listening = new CountDownLatch(2);
final CountDownLatch ackListening = new CountDownLatch(1);
final CountDownLatch ackSent = new CountDownLatch(2);
Runnable catcher =
new Runnable() {
@Override
public void run() {
try {
byte[] buffer = new byte[1000];
DatagramPacket receivedPacket = new DatagramPacket(buffer, buffer.length);
MulticastSocket socket = new MulticastSocket(testPort);
socket.setInterface(InetAddress.getByName(multicastRule.getNic()));
socket.setSoTimeout(8000);
InetAddress group = InetAddress.getByName(multicastAddress);
socket.joinGroup(group);
listening.countDown();
assertTrue(ackListening.await(10, TimeUnit.SECONDS));
LogFactory.getLog(getClass())
.debug(Thread.currentThread().getName() + " waiting for packet");
socket.receive(receivedPacket);
socket.close();
byte[] src = receivedPacket.getData();
int length = receivedPacket.getLength();
int offset = receivedPacket.getOffset();
byte[] dest = new byte[6];
System.arraycopy(src, offset + length - 6, dest, 0, 6);
assertEquals(payload, new String(dest));
LogFactory.getLog(getClass())
.debug(Thread.currentThread().getName() + " received packet");
DatagramPacketMessageMapper mapper = new DatagramPacketMessageMapper();
mapper.setAcknowledge(true);
mapper.setLengthCheck(true);
Message<byte[]> message = mapper.toMessage(receivedPacket);
Object id = message.getHeaders().get(IpHeaders.ACK_ID);
byte[] ack = id.toString().getBytes();
DatagramPacket ackPack =
new DatagramPacket(
ack,
ack.length,
new InetSocketAddress(multicastRule.getNic(), ackPort.get()));
DatagramSocket out = new DatagramSocket();
out.send(ackPack);
LogFactory.getLog(getClass())
.debug(
Thread.currentThread().getName()
+ " sent ack to "
+ ackPack.getSocketAddress());
out.close();
ackSent.countDown();
socket.close();
} catch (Exception e) {
listening.countDown();
e.printStackTrace();
}
}
};
Executor executor = Executors.newFixedThreadPool(2);
executor.execute(catcher);
executor.execute(catcher);
assertTrue(listening.await(10000, TimeUnit.MILLISECONDS));
MulticastSendingMessageHandler handler =
new MulticastSendingMessageHandler(
multicastAddress, testPort, true, true, "localhost", 0, 10000);
handler.setLocalAddress(this.multicastRule.getNic());
handler.setMinAcksForSuccess(2);
handler.afterPropertiesSet();
handler.start();
waitAckListening(handler);
ackPort.set(handler.getAckPort());
ackListening.countDown();
handler.handleMessage(MessageBuilder.withPayload(payload).build());
assertTrue(ackSent.await(10000, TimeUnit.MILLISECONDS));
handler.stop();
socket.close();
}
public void close() {
usock.close();
}
public void disconnect() throws Exception {
if (connection != null) connection.close();
allreadyTried = false;
connection = null;
}