public static String[] getLocalCidrs() { String defaultHostIp = getDefaultHostIp(); List<String> cidrList = new ArrayList<String>(); try { for (NetworkInterface ifc : IteratorUtil.enumerationAsIterable(NetworkInterface.getNetworkInterfaces())) { if (ifc.isUp() && !ifc.isVirtual() && !ifc.isLoopback()) { for (InterfaceAddress address : ifc.getInterfaceAddresses()) { InetAddress addr = address.getAddress(); int prefixLength = address.getNetworkPrefixLength(); if (prefixLength < 32 && prefixLength > 0) { String ip = ipFromInetAddress(addr); if (ip.equalsIgnoreCase(defaultHostIp)) cidrList.add(ipAndNetMaskToCidr(ip, getCidrNetmask(prefixLength))); } } } } } catch (SocketException e) { s_logger.warn("UnknownHostException in getLocalCidrs().", e); } return cidrList.toArray(new String[0]); }
// on linux system public void init2() { try { NetworkInterface networkInterface = NetworkInterface.getByName("eth0"); Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses(); while (inetAddresses.hasMoreElements()) { InetAddress address = inetAddresses.nextElement(); if (!address.isLinkLocalAddress()) { // just get IPv4 address localAddress = address; } } // get broadcast address List<InterfaceAddress> addresses = networkInterface.getInterfaceAddresses(); for (InterfaceAddress address : addresses) { if (address.getBroadcast() != null) { broadcastAddress = address.getBroadcast(); break; } } if (broadcastAddress == null) { System.out.println("get broadcast address error!"); } System.out.println("local ip address is " + localAddress.getHostAddress()); System.out.println("broadcast address is " + broadcastAddress.getHostAddress()); socket = new DatagramSocket(); socket.setBroadcast(true); } catch (SocketException se) { se.printStackTrace(); } }
public void init() { try { localAddress = InetAddress.getLocalHost(); if (localAddress.isLoopbackAddress()) { System.out.println("get local ip error!"); return; } NetworkInterface networkInterface = NetworkInterface.getByInetAddress(localAddress); List<InterfaceAddress> addresses = networkInterface.getInterfaceAddresses(); for (InterfaceAddress address : addresses) { if (address.getAddress() instanceof Inet6Address) { continue; } if (address.getBroadcast() != null) { broadcastAddress = address.getBroadcast(); break; } else { System.out.println("get broadcast address error!"); } } System.out.println("local ip address is " + localAddress.getHostAddress()); System.out.println("broadcast address is " + broadcastAddress.getHostAddress()); socket = new DatagramSocket(2000); socket.setBroadcast(true); } catch (UnknownHostException ue) { ue.printStackTrace(); } catch (SocketException se) { se.printStackTrace(); } }
private static void displayInterfaceInformation(final NetworkInterface networkInterface) throws SocketException { LOG.trace(MessageFormat.format("Display name: %s%n", networkInterface.getDisplayName())); LOG.trace(MessageFormat.format("Name: %s%n", networkInterface.getName())); Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses(); for (InetAddress inetAddress : Collections.list(inetAddresses)) { LOG.trace(MessageFormat.format("InetAddress: %s%n", inetAddress)); } LOG.trace(MessageFormat.format("Parent: %s%n", networkInterface.getParent())); LOG.trace(MessageFormat.format("Up? %s%n", networkInterface.isUp())); LOG.trace(MessageFormat.format("Loopback? %s%n", networkInterface.isLoopback())); LOG.trace(MessageFormat.format("PointToPoint? %s%n", networkInterface.isPointToPoint())); LOG.trace(MessageFormat.format("Supports multicast? %s%n", networkInterface.isVirtual())); LOG.trace(MessageFormat.format("Virtual? %s%n", networkInterface.isVirtual())); LOG.trace( MessageFormat.format( "Hardware address: %s%n", Arrays.toString(networkInterface.getHardwareAddress()))); LOG.trace(MessageFormat.format("MTU: %s%n", networkInterface.getMTU())); List<InterfaceAddress> interfaceAddresses = networkInterface.getInterfaceAddresses(); for (InterfaceAddress addr : interfaceAddresses) { LOG.trace(MessageFormat.format("InterfaceAddress: %s%n", addr.getAddress())); } LOG.trace(MessageFormat.format("%n", null)); Enumeration<NetworkInterface> subInterfaces = networkInterface.getSubInterfaces(); for (NetworkInterface aNetworkInterface : Collections.list(subInterfaces)) { LOG.trace(MessageFormat.format("%nSubInterface%n", null)); displayInterfaceInformation(aNetworkInterface); } LOG.trace(MessageFormat.format("%n", null)); }
public static String[] getNetworkParams(NetworkInterface nic) { List<InterfaceAddress> addrs = nic.getInterfaceAddresses(); if (addrs == null || addrs.size() == 0) { return null; } InterfaceAddress addr = null; for (InterfaceAddress iaddr : addrs) { InetAddress inet = iaddr.getAddress(); if (!inet.isLinkLocalAddress() && !inet.isLoopbackAddress() && !inet.isMulticastAddress() && inet.getAddress().length == 4) { addr = iaddr; break; } } if (addr == null) { return null; } String[] result = new String[3]; result[0] = addr.getAddress().getHostAddress(); try { byte[] mac = nic.getHardwareAddress(); result[1] = byte2Mac(mac); } catch (Exception e) { } result[2] = prefix2Netmask(addr.getNetworkPrefixLength()); return result; }
static { try { InetAddress addr = InetAddress.getLocalHost(); HOST_NAME = addr.getHostName(); Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces(); for (NetworkInterface netint : Collections.list(nets)) { if (null != netint.getHardwareAddress()) { List<InterfaceAddress> list = netint.getInterfaceAddresses(); for (InterfaceAddress interfaceAddress : list) { InetAddress ip = interfaceAddress.getAddress(); if (ip instanceof Inet4Address) { HOST_IP += interfaceAddress.getAddress().toString(); } } } } HOST_IP = HOST_IP.replaceAll("null", ""); } catch (Exception e) { System.out.println("获取服务器IP出错"); } try { osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean(); TotalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb; } catch (Exception e) { System.out.println("获取系统信息失败"); e.printStackTrace(); } }
private InetAddress getLocalAddress(String adaptorName) { try { Enumeration<NetworkInterface> b = NetworkInterface.getNetworkInterfaces(); while (b.hasMoreElements()) { NetworkInterface networkInterface = b.nextElement(); if (networkInterface.getName().equals(adaptorName)) { for (InterfaceAddress f : networkInterface.getInterfaceAddresses()) { if (f.getAddress().isSiteLocalAddress()) { return f.getAddress(); } } } } } catch (SocketException e) { e.printStackTrace(); } return null; }
public static InetAddress getBroadcast() { InetAddress found_bcast_address = null; System.setProperty("java.net.preferIPv4Stack", "true"); try { Enumeration<NetworkInterface> niEnum = NetworkInterface.getNetworkInterfaces(); while (niEnum.hasMoreElements()) { NetworkInterface ni = niEnum.nextElement(); if (!ni.isLoopback()) { for (InterfaceAddress interfaceAddress : ni.getInterfaceAddresses()) { found_bcast_address = interfaceAddress.getBroadcast(); } } } } catch (SocketException e) { e.printStackTrace(); } return found_bcast_address; }
public static String getBroadcast() { if (IP.broadcast == null) { try { NetworkInterface network = NetworkInterface.getByInetAddress(Inet4Address.getLocalHost()); InterfaceAddress address = null; for (InterfaceAddress add : network.getInterfaceAddresses()) { if (add != null) { address = add; break; } } IP.broadcast = address.getBroadcast().toString().split("/")[1]; IP.mask = IP.parsePrefix(address.getNetworkPrefixLength()); } catch (SocketException | UnknownHostException e) { Core.exception(e, "Cannot create Broadcast", "IP"); } } return IP.broadcast; }
@TargetApi(Build.VERSION_CODES.GINGERBREAD) public static void populateLanMasks(Context context, String[] names, InterfaceDetails ret) { try { Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); while (en.hasMoreElements()) { NetworkInterface intf = en.nextElement(); boolean match = false; if (!intf.isUp() || intf.isLoopback()) { continue; } for (String pattern : ITFS_WIFI) { if (intf.getName().startsWith(truncAfter(pattern, "\\+"))) { match = true; break; } } if (!match) continue; ret.wifiName = intf.getName(); Iterator<InterfaceAddress> addrList = intf.getInterfaceAddresses().iterator(); while (addrList.hasNext()) { InterfaceAddress addr = addrList.next(); InetAddress ip = addr.getAddress(); String mask = truncAfter(ip.getHostAddress(), "%") + "/" + addr.getNetworkPrefixLength(); if (ip instanceof Inet4Address) { ret.lanMaskV4 = mask; } else if (ip instanceof Inet6Address) { ret.lanMaskV6 = mask; } } } } catch (SocketException e) { Log.e(TAG, "Error fetching network interface list"); } catch (Exception e) { Log.e(TAG, "Error fetching network interface list"); } }
public static List<InetAddress> getLocalAddresses() { List<InetAddress> addresses = Lists.newArrayList(); Enumeration<NetworkInterface> networkInterfaces; try { networkInterfaces = NetworkInterface.getNetworkInterfaces(); } catch (SocketException e) { throw new IllegalStateException("Error reading network addresses", e); } while (networkInterfaces.hasMoreElements()) { NetworkInterface networkInterface = networkInterfaces.nextElement(); List<InterfaceAddress> interfaceAddresses = networkInterface.getInterfaceAddresses(); for (InterfaceAddress interfaceAddress : interfaceAddresses) { InetAddress address = interfaceAddress.getAddress(); addresses.add(address); } } return addresses; }
private boolean isOnSubnet(InterfaceAddress receiver, InetAddress sender) { byte[] receiverBytes = receiver.getAddress().getAddress(); byte[] senderBytes = sender.getAddress(); byte[] subnetBytes = new byte[4]; short length = receiver.getNetworkPrefixLength(); int position = 0; if (length < 8) { subnetBytes[0] = 0; subnetBytes[1] = 0; subnetBytes[2] = 0; subnetBytes[3] = (byte) (Math.pow(2, length) / 2); } else if (length < 16) { subnetBytes[0] = 0; subnetBytes[1] = 0; subnetBytes[2] = (byte) (Math.pow(2, length) / 2); subnetBytes[3] = 127; } else if (length < 24) { subnetBytes[0] = 0; subnetBytes[1] = (byte) (Math.pow(2, length) / 2); subnetBytes[2] = 127; subnetBytes[3] = 127; } else { subnetBytes[0] = (byte) (Math.pow(2, length) / 2); subnetBytes[1] = 127; subnetBytes[2] = 127; subnetBytes[3] = 127; } for (int x = senderBytes.length - 1; x >= 0; x--) { if ((senderBytes[x] & subnetBytes[x]) != (receiverBytes[x] & subnetBytes[x])) { return false; } position++; } return true; }
public static void printParameter(NetworkInterface ni) throws SocketException { System.out.println(" Name = " + ni.getName()); System.out.println(" Display Name = " + ni.getDisplayName()); System.out.println(" Is up = " + ni.isUp()); System.out.println(" Support multicast = " + ni.supportsMulticast()); System.out.println(" Is loopback = " + ni.isLoopback()); System.out.println(" Is virtual = " + ni.isVirtual()); System.out.println(" Is point to point = " + ni.isPointToPoint()); System.out.println(" Hardware address = " + ni.getHardwareAddress()); System.out.println(" MTU = " + ni.getMTU()); System.out.println("\nList of Interface Addresses:"); List<InterfaceAddress> list = ni.getInterfaceAddresses(); Iterator<InterfaceAddress> it = list.iterator(); while (it.hasNext()) { InterfaceAddress ia = it.next(); System.out.println(" Address = " + ia.getAddress()); System.out.println(" Broadcast = " + ia.getBroadcast()); System.out.println(" Network prefix length = " + ia.getNetworkPrefixLength()); System.out.println(""); } }
public ArrayList<InetAddress> ping() { ArrayList<InetAddress> ret = new ArrayList<InetAddress>(); // Find the server using UDP broadcast try { // Open a random port to send the package DatagramSocket c = new DatagramSocket(); c.setBroadcast(true); byte[] sendData = "DISCOVER_FUIFSERVER_REQUEST".getBytes(); // Try the 255.255.255.255 first try { log.info("client >>> sending request packet to: 255.255.255.255:8888 (DEFAULT)"); DatagramPacket sendPacket = new DatagramPacket( sendData, sendData.length, InetAddress.getByName("255.255.255.255"), 8888); c.send(sendPacket); byte[] recvBuf = new byte[15000]; DatagramPacket pong = new DatagramPacket(recvBuf, recvBuf.length); c.receive(pong); log.info("client >>> recieved PONG"); } catch (Exception e) { } // Broadcast the message over all the network interfaces Enumeration interfaces = NetworkInterface.getNetworkInterfaces(); while (interfaces.hasMoreElements()) { NetworkInterface networkInterface = (NetworkInterface) interfaces.nextElement(); if (networkInterface.isLoopback() || !networkInterface.isUp()) { continue; // Don't want to broadcast to the loopback // interface } for (InterfaceAddress interfaceAddress : networkInterface.getInterfaceAddresses()) { InetAddress broadcast = interfaceAddress.getBroadcast(); if (broadcast == null) { continue; } // Send the broadcast package! try { log.info("client >>> sending request packet to: 255.255.255.255:8888 (DEFAULT)"); DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, broadcast, 8888); c.send(sendPacket); } catch (Exception e) { } log.info( "client >>> Request packet sent to: " + broadcast.getHostAddress() + "; Interface: " + networkInterface.getDisplayName()); } } log.info(">>> Done looping over all network interfaces. Now waiting for a reply!"); // Wait for a response byte[] recvBuf = new byte[15000]; DatagramPacket receivePacket = new DatagramPacket(recvBuf, recvBuf.length); c.receive(receivePacket); // We have a response log.info( ">>> Broadcast response from server: " + receivePacket.getAddress().getHostAddress()); // Check if the message is correct String message = new String(receivePacket.getData()).trim(); if (message.equals("DISCOVER_FUIFSERVER_RESPONSE")) { // DO SOMETHING WITH THE SERVER'S IP (for example, store it in // your controller) // Controller_Base.setServerIp(receivePacket.getAddress()); ret.add(receivePacket.getAddress()); } // Close the port! c.close(); } catch (IOException e) { Logging.logException(e); } return ret; }
public List<MsgEvent> discover() { List<MsgEvent> discoveryList = null; // Find the server using UDP broadcast try { discoveryList = new ArrayList<MsgEvent>(); // Open a random port to send the package c = new DatagramSocket(); c.setBroadcast(true); byte[] sendData = "DISCOVER_FUIFSERVER_REQUEST".getBytes(); // Try the 255.255.255.255 first try { DatagramPacket sendPacket = new DatagramPacket( sendData, sendData.length, InetAddress.getByName("255.255.255.255"), 32005); c.send(sendPacket); // System.out.println(getClass().getName() + ">>> Request packet sent to: 255.255.255.255 // (DEFAULT)"); } catch (Exception e) { } // Broadcast the message over all the network interfaces Enumeration interfaces = NetworkInterface.getNetworkInterfaces(); while (interfaces.hasMoreElements()) { NetworkInterface networkInterface = (NetworkInterface) interfaces.nextElement(); if (networkInterface.isLoopback() || !networkInterface.isUp()) { continue; // Don't want to broadcast to the loopback interface } for (InterfaceAddress interfaceAddress : networkInterface.getInterfaceAddresses()) { InetAddress broadcast = interfaceAddress.getBroadcast(); if (broadcast == null) { continue; } // Send the broadcast package! try { DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, broadcast, 32005); c.send(sendPacket); } catch (Exception e) { } // System.out.println(getClass().getName() + ">>> Request packet sent to: " + // broadcast.getHostAddress() + "; Interface: " + networkInterface.getDisplayName()); } } // System.out.println(getClass().getName() + ">>> Done looping over all network interfaces. // Now waiting for a reply!"); // Wait for a response while (!c.isClosed()) { try { byte[] recvBuf = new byte[15000]; DatagramPacket receivePacket = new DatagramPacket(recvBuf, recvBuf.length); c.receive(receivePacket); // We have a response // System.out.println(getClass().getName() + ">>> Broadcast response from server: " + // receivePacket.getAddress().getHostAddress()); // Check if the message is correct // System.out.println(new String(receivePacket.getData())); String json = new String(receivePacket.getData()).trim(); // String response = "region=region0,agent=agent0,recaddr=" + // packet.getAddress().getHostAddress(); try { MsgEvent me = gson.fromJson(json, MsgEvent.class); if (me != null) { if (!me.getParam("clientip").equals(receivePacket.getAddress().getHostAddress())) { // System.out.println("SAME HOST"); // System.out.println(me.getParamsString() + // receivePacket.getAddress().getHostAddress()); me.setParam("serverip", receivePacket.getAddress().getHostAddress()); discoveryList.add(me); } } } catch (Exception ex) { System.out.println("in loop 0" + ex.toString()); } } catch (SocketException ex) { // eat message.. this should happen } catch (Exception ex) { System.out.println("in loop 1" + ex.toString()); } } // Close the port! // c.close(); // System.out.println("CODY : Dicsicer Client Worker Engned!"); } catch (Exception ex) { System.out.println("while not closed: " + ex.toString()); } return discoveryList; }
@SuppressWarnings({"rawtypes", "unchecked"}) @Override public List<NetInterface<? extends NetInterfaceAddress>> getActiveNetworkInterfaces() throws KuraException { IPAddress netAddress = null; NetInterfaceAddressImpl addressImpl = null; List<NetInterfaceAddress> addresses = null; List<NetInterface<? extends NetInterfaceAddress>> interfaces = new ArrayList<NetInterface<? extends NetInterfaceAddress>>(); EthernetInterfaceImpl ethInterface = null; java.net.NetworkInterface jnInterface = null; List<java.net.InterfaceAddress> jnInterfaceAddresses = null; Enumeration<java.net.NetworkInterface> jnInterfaces = null; try { jnInterfaces = java.net.NetworkInterface.getNetworkInterfaces(); while (jnInterfaces.hasMoreElements()) { try { jnInterface = jnInterfaces.nextElement(); if (jnInterface.isUp() && !jnInterface.isVirtual() && !jnInterface.isLoopback() && !jnInterface.isPointToPoint() && (jnInterface.getHardwareAddress() != null) && !jnInterface.getInterfaceAddresses().isEmpty()) { ethInterface = new EthernetInterfaceImpl(jnInterface.getName()); ethInterface.setVirtual(jnInterface.isVirtual()); ethInterface.setState(NetInterfaceState.ACTIVATED); ethInterface.setAutoConnect(true); byte[] hwAddr = null; boolean isUp = false; boolean isLoop = false; int mtu = 0; boolean isP2p = false; boolean multi = false; try { hwAddr = jnInterface.getHardwareAddress(); isUp = jnInterface.isUp(); isLoop = jnInterface.isLoopback(); mtu = jnInterface.getMTU(); isP2p = jnInterface.isPointToPoint(); multi = jnInterface.supportsMulticast(); } catch (Exception e) { s_logger.warn( "Exception while getting information for interface " + jnInterface.getName(), e); } ethInterface.setHardwareAddress(hwAddr); ethInterface.setLinkUp(isUp); ethInterface.setLoopback(isLoop); ethInterface.setMTU(mtu); ethInterface.setPointToPoint(isP2p); ethInterface.setSupportsMulticast(multi); ethInterface.setUp(isUp); addresses = new ArrayList<NetInterfaceAddress>(); jnInterfaceAddresses = jnInterface.getInterfaceAddresses(); for (java.net.InterfaceAddress jnInterfaceAddress : jnInterfaceAddresses) { netAddress = IPAddress.getByAddress(jnInterfaceAddress.getAddress().getAddress()); addressImpl = new NetInterfaceAddressImpl(); addressImpl.setAddress(netAddress); if (jnInterfaceAddress.getBroadcast() != null) { addressImpl.setBroadcast( IPAddress.getByAddress(jnInterfaceAddress.getBroadcast().getAddress())); } addressImpl.setNetworkPrefixLength(jnInterfaceAddress.getNetworkPrefixLength()); addresses.add(addressImpl); } ethInterface.setNetInterfaceAddresses(addresses); interfaces.add(ethInterface); } } catch (SocketException se) { s_logger.warn( "Exception while getting information for interface " + jnInterface.getName(), se); } } } catch (Exception e) { throw new KuraException(KuraErrorCode.INTERNAL_ERROR, e); } return interfaces; }
public void start() { try { lock.lock(); logger.debug("Starting LIFX communication handler for bulb '{}'.", macAsHex); if (networkJob == null || networkJob.isCancelled()) { networkJob = scheduler.scheduleWithFixedDelay( networkRunnable, 0, PACKET_INTERVAL, TimeUnit.MILLISECONDS); } source = UUID.randomUUID().getLeastSignificantBits() & (-1L >>> 32); logger.debug( "The LIFX handler will use '{}' as source identifier", Long.toString(source, 16)); broadcastAddresses = new ArrayList<InetSocketAddress>(); interfaceAddresses = new ArrayList<InetAddress>(); Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces(); while (networkInterfaces.hasMoreElements()) { NetworkInterface iface = networkInterfaces.nextElement(); if (iface.isUp() && !iface.isLoopback()) { for (InterfaceAddress ifaceAddr : iface.getInterfaceAddresses()) { if (ifaceAddr.getAddress() instanceof Inet4Address) { logger.debug( "Adding '{}' as interface address with MTU {}", ifaceAddr.getAddress(), iface.getMTU()); if (iface.getMTU() > bufferSize) { bufferSize = iface.getMTU(); } interfaceAddresses.add(ifaceAddr.getAddress()); if (ifaceAddr.getBroadcast() != null) { logger.debug("Adding '{}' as broadcast address", ifaceAddr.getBroadcast()); broadcastAddresses.add( new InetSocketAddress(ifaceAddr.getBroadcast(), BROADCAST_PORT)); } } } } } selector = Selector.open(); DatagramChannel broadcastChannel = DatagramChannel.open(StandardProtocolFamily.INET) .setOption(StandardSocketOptions.SO_REUSEADDR, true) .setOption(StandardSocketOptions.SO_BROADCAST, true); broadcastChannel.configureBlocking(false); int offset = lightCounter.getAndIncrement(); logger.debug("Binding the broadcast channel on port {}", BROADCAST_PORT + offset); broadcastChannel.bind(new InetSocketAddress(BROADCAST_PORT + offset)); broadcastKey = broadcastChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); currentLightState.setOffline(); // look for lights on the network GetServiceRequest packet = new GetServiceRequest(); broadcastPacket(packet); } catch (Exception ex) { logger.error("Error occured while initializing LIFX handler: " + ex.getMessage(), ex); } finally { lock.unlock(); } }
/** * Discover WS device on the local network * * @return list of unique devices access strings which might be URLs in most cases */ public static Collection<String> discoverWsDevices() { final Collection<String> addresses = new ConcurrentSkipListSet<>(); final CountDownLatch serverStarted = new CountDownLatch(1); final CountDownLatch serverFinished = new CountDownLatch(1); final Collection<InetAddress> addressList = new ArrayList<>(); try { final Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); if (interfaces != null) { while (interfaces.hasMoreElements()) { NetworkInterface anInterface = interfaces.nextElement(); if (!anInterface.isLoopback()) { final List<InterfaceAddress> interfaceAddresses = anInterface.getInterfaceAddresses(); for (InterfaceAddress address : interfaceAddresses) { addressList.add(address.getAddress()); } } } } } catch (SocketException e) { e.printStackTrace(); } ExecutorService executorService = Executors.newCachedThreadPool(); for (final InetAddress address : addressList) { Runnable runnable = new Runnable() { public void run() { try { final String uuid = UUID.randomUUID().toString(); final String probe = WS_DISCOVERY_PROBE_MESSAGE.replaceAll( "<wsa:MessageID>urn:uuid:.*</wsa:MessageID>", "<wsa:MessageID>urn:uuid:" + uuid + "</wsa:MessageID>"); final int port = random.nextInt(20000) + 40000; @SuppressWarnings("SocketOpenedButNotSafelyClosed") final DatagramSocket server = new DatagramSocket(port, address); new Thread() { public void run() { try { final DatagramPacket packet = new DatagramPacket(new byte[4096], 4096); server.setSoTimeout(WS_DISCOVERY_TIMEOUT); long timerStarted = System.currentTimeMillis(); while (System.currentTimeMillis() - timerStarted < (WS_DISCOVERY_TIMEOUT)) { serverStarted.countDown(); server.receive(packet); final Collection<String> collection = parseSoapResponseForUrls( Arrays.copyOf(packet.getData(), packet.getLength())); for (String key : collection) { addresses.add(key); } } } catch (SocketTimeoutException ignored) { } catch (Exception e) { e.printStackTrace(); } finally { serverFinished.countDown(); server.close(); } } }.start(); try { serverStarted.await(1000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { e.printStackTrace(); } if (address instanceof Inet4Address) { server.send( new DatagramPacket( probe.getBytes(), probe.length(), InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv4), WS_DISCOVERY_PORT)); } else { server.send( new DatagramPacket( probe.getBytes(), probe.length(), InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv6), WS_DISCOVERY_PORT)); } } catch (Exception e) { e.printStackTrace(); } try { serverFinished.await((WS_DISCOVERY_TIMEOUT), TimeUnit.MILLISECONDS); } catch (InterruptedException e) { e.printStackTrace(); } } }; executorService.submit(runnable); } try { executorService.shutdown(); executorService.awaitTermination(WS_DISCOVERY_TIMEOUT + 2000, TimeUnit.MILLISECONDS); } catch (InterruptedException ignored) { } return addresses; }
/** * Automatic UDP discovery of a MAX!Cube * * @return if the cube is found, returns the IP address as a string. Otherwise returns null */ public static final String discoverIp() { String maxCubeIP = null; String maxCubeName = null; String rfAddress = null; Logger logger = LoggerFactory.getLogger(MaxCubeDiscover.class); // Find the MaxCube using UDP broadcast try { DatagramSocket bcSend = new DatagramSocket(); bcSend.setBroadcast(true); byte[] sendData = "eQ3Max*\0**********I".getBytes(); // Broadcast the message over all the network interfaces Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); while (interfaces.hasMoreElements()) { NetworkInterface networkInterface = (NetworkInterface) interfaces.nextElement(); if (networkInterface.isLoopback() || !networkInterface.isUp()) { continue; } for (InterfaceAddress interfaceAddress : networkInterface.getInterfaceAddresses()) { InetAddress broadcast = interfaceAddress.getBroadcast(); if (broadcast == null) { continue; } // Send the broadcast package! try { DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, broadcast, 23272); bcSend.send(sendPacket); } catch (Exception e) { logger.debug(e.getMessage()); logger.debug(Utils.getStackTrace(e)); } logger.trace( "Request packet sent to: {} Interface: {}", broadcast.getHostAddress(), networkInterface.getDisplayName()); } } logger.trace("Done looping over all network interfaces. Now waiting for a reply!"); bcSend.close(); DatagramSocket bcReceipt = new DatagramSocket(23272); bcReceipt.setReuseAddress(true); // Wait for a response byte[] recvBuf = new byte[15000]; DatagramPacket receivePacket = new DatagramPacket(recvBuf, recvBuf.length); bcReceipt.receive(receivePacket); // We have a response logger.trace("Broadcast response from server: {}", receivePacket.getAddress()); // Check if the message is correct String message = new String(receivePacket.getData()).trim(); if (message.startsWith("eQ3Max")) { maxCubeIP = receivePacket.getAddress().getHostAddress(); maxCubeName = message.substring(0, 8); rfAddress = message.substring(8, 18); logger.debug("Found at: {}", maxCubeIP); logger.debug("Name : {}", maxCubeName); logger.debug("Serial : {}", rfAddress); logger.trace("Message : {}", message); } else { logger.info("No Max!Cube gateway found on network"); } // Close the port! bcReceipt.close(); } catch (IOException ex) { logger.debug(ex.toString()); } return maxCubeIP; }
@Override public void run() { long id = System.currentTimeMillis(); running = true; log.info("Beacon thread starting"); long lastBeacon = System.currentTimeMillis() - BEACON_GAP; while (running) { while (running && (System.currentTimeMillis() - lastBeacon) < BEACON_GAP) { try { Thread.sleep(1000); } catch (InterruptedException e) { } } if (!running) continue; DatagramSocket socket = null; try { CentralBeacon beaconPackage = CentralBeacon.newBuilder() .setServerVersion(Central.VERSION) .setSensorPort(deviceServer.getPort()) .setApiPort(apiServer.getPort()) .setServerId(id) .build(); ByteArrayOutputStream data = new ByteArrayOutputStream(); beaconPackage.writeDelimitedTo(data); socket = new DatagramSocket(); socket.setBroadcast(true); List<InetAddress> broadcasts = new LinkedList<InetAddress>(); // Add global broadcast address try { broadcasts.add(InetAddress.getByName("255.255.255.255")); } catch (UnknownHostException e) { } // Add all broadcast addresses for all known links Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); while (interfaces.hasMoreElements()) { NetworkInterface networkInterface = interfaces.nextElement(); if (networkInterface.isLoopback() || !networkInterface.isUp()) { continue; // Skip loopback and interfaces that are down } for (InterfaceAddress address : networkInterface.getInterfaceAddresses()) { broadcasts.add(address.getBroadcast()); } } // Send the beacon package on all braodcast addresses we got for (InetAddress address : broadcasts) { try { socket.send( new DatagramPacket(data.toByteArray(), data.toByteArray().length, address, 12354)); // log.info("Beacon package sent to "+address.getHostAddress()); } catch (Exception e) { // Ignore } } } catch (SocketException e) { log.warning("SocketException in beacon send block"); log.warning(e.toString()); } catch (IOException e) { log.warning("IOException in beacon send block"); log.warning(e.toString()); } finally { lastBeacon = System.currentTimeMillis(); if (socket != null) { socket.close(); } } } log.info("Beacon thread stopping"); }