public sendUDPBroadcastThread() { try { // Creates the socket if (socket == null) { socket = new DatagramSocket(null); socket.setReuseAddress(true); socket.setBroadcast(true); socket.bind(new InetSocketAddress(8080)); socket.setBroadcast(true); } } catch (SocketException e) { e.printStackTrace(); } }
public static void main(String[] args) { int port = 5555; DatagramSocket socket; socket = null; try { socket = new DatagramSocket(port); socket.setBroadcast(true); socket.connect(InetAddress.getByName("255.255.255.255"), 5555); } catch (Exception e) { System.err.println("Connection failed. " + e.getMessage()); } while (true) { String message = "hey"; byte[] buf = message.getBytes(); DatagramPacket packet = new DatagramPacket(buf, buf.length); try { socket.send(packet); } catch (Exception e) { System.err.println("Sending failed. " + e.getMessage()); } } }
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(); } }
// 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(); } }
private static void setupService() { try { // setup webserver to listen on localhost:80 Webserver server = new Webserver(80); // open broadcast socket on port 15000 DatagramSocket broadcast_socket = new DatagramSocket(); broadcast_socket.setBroadcast(true); // {optional} mac address hash String macHash = "12345678909876543212345678909876"; // get IP address from this machine // Create broadcast message String broadcast_msg = "Sensor online, MACHash=" + macHash + ", IP=" + getIP(); // Create broadcast packet DatagramPacket broadcast_packet = new DatagramPacket( broadcast_msg.getBytes(), broadcast_msg.getBytes().length, InetAddress.getByName("255.255.255.255"), 15000); // Send Broadcast packet broadcast_socket.send(broadcast_packet); } catch (IOException ex) { Logger.getLogger(UserTrackerApplication.class.getName()).log(Level.SEVERE, null, ex); } }
@Override public void run() { DatagramSocket socket; int clientListnport = Constants.UDPPort; try { // Keep a socket open to listen to all the UDP trafic that is // destined for this port socket = new DatagramSocket(clientListnport, (Inet4Address) InetAddress.getByName("0.0.0.0")); socket.setBroadcast(true); socket.setSoTimeout(10000); while (WifiReceiver.isWifi) { System.out.println(">>>Ready to receive broadcast packets!"); // Receive a packet byte[] recvBuf = new byte[15000]; DatagramPacket packet = new DatagramPacket(recvBuf, recvBuf.length); try { socket.receive(packet); // Packet received System.out.println( ">>>Discovery packet received from: " + packet.getAddress().getHostAddress()); // See if the packet holds the right command (message) String message = new String(packet.getData()).trim(); if (message.equals(Constants.serverDiscoverString)) { byte[] sendData = Constants.clientReplyString.getBytes(); // Send a response if (!WifiUtils.getipAddress() .equalsIgnoreCase(packet.getAddress().getHostAddress().toString())) { DatagramPacket sendPacket = new DatagramPacket( sendData, sendData.length, packet.getAddress(), packet.getPort()); socket.send(sendPacket); System.out.println(">>>Sent packet to: " + sendPacket.getAddress().getHostAddress()); } } else if (message.equals(Constants.serverFileSending)) { System.out.println("sending reply to recive handshake"); byte[] sendData = Constants.clientFileReceive.getBytes(); DatagramPacket sendPacket = new DatagramPacket( sendData, sendData.length, packet.getAddress(), packet.getPort()); socket.send(sendPacket); Log.d(loggerTag, "handshaking is done"); FileReceiver.waitConnection(); } } catch (SocketTimeoutException e) { // no need of doing anything } } System.out.println("CLientListener : Listener is stoped"); } catch (IOException ex) { System.err.println(ex); } }
public synchronized void init() { try { socket = new DatagramSocket(); socket.setBroadcast(true); addr = InetAddress.getByName(castIP); } catch (Exception e) { e.printStackTrace(); } }
// Discovery thread @Override public void run() { while (!Thread.currentThread().isInterrupted()) { try { socket = new DatagramSocket(DISCOVERY_PORT, InetAddress.getByName("0.0.0.0")); socket.setBroadcast(true); // Keep an UDP Socket open while (!Thread.currentThread().isInterrupted() && socket.isBound()) { // Ready to receive sockets // Receive a packet byte[] rcvBuff = new byte[15000]; DatagramPacket packet = new DatagramPacket(rcvBuff, rcvBuff.length); socket.receive(packet); // Packet received String msg = new String(packet.getData()).trim(); if (msg.equals("REMOTECRAFT_DISCOVERY_REQUEST")) { // Attach world name String msgResponse = "REMOTECRAFT_DISCOVERY_RESPONSE:" + String.valueOf(this.worldSeed) + "_" + this.worldName; byte[] sendData = msgResponse.getBytes(); // Send response DatagramPacket sendPacket = new DatagramPacket( sendData, sendData.length, packet.getAddress(), packet.getPort()); if (socket.isBound()) { try { socket.send(sendPacket); } catch (Exception e) { e.printStackTrace(); } } else { continue; } } } } catch (IOException e) { e.printStackTrace(); } finally { try { socket.disconnect(); socket.close(); } catch (NullPointerException e) { e.printStackTrace(); } } } // while !threadIsInterrupted }
private void sendData(DatagramPacket packet, int localSendingPort) throws Exception { DatagramSocket sock = null; sock = new DatagramSocket(localSendingPort); sock.setReuseAddress(true); sock.setBroadcast(true); sock.send(packet); sock.close(); }
public Candidate discoverFromBroadcast() throws IOException, RetryException, ParserConfigurationException { DatagramSocket socket = new DatagramSocket(); socket.setBroadcast(true); sendBroadcast(socket); List<DatagramPacket> responses = collectBroadcastResponses(socket); return getCandidateFromDatagramResponses(responses); }
@Override protected void open() throws IOException { Log.d(TAG, "Opening udp connection."); socket = (serverPort == -1) ? new DatagramSocket() : new DatagramSocket(serverPort); socket.setBroadcast(true); socket.setReuseAddress(true); socket.setSoTimeout(readTimeout); }
// @Override // protected void onPreExecute() { // Log.i("AsyncTask", "onPreExecute"); // } @Override protected Boolean doInBackground(Void... params) { Log.i("AsyncTask", "doInBackground: Creating socket"); while (networkConnection == true) { try { DatagramSocket client_socket = new DatagramSocket(null); client_socket.setReuseAddress(true); client_socket.setBroadcast(true); client_socket.bind(new InetSocketAddress(PORT)); byte[] receiveData = new byte[1024]; DatagramPacket packet = new DatagramPacket(receiveData, receiveData.length); client_socket.receive(packet); modifiedSentence = new String(packet.getData(), 0, packet.getLength()); Log.i("dostaje dane postaci", modifiedSentence); /*String pierwszy = Character.toString(modifiedSentence.charAt(0)); Log.i("pierwszy znak to", pierwszy);*/ t.start(); u.start(); client_socket.close(); } catch (Throwable e) { e.printStackTrace(); } // setUpMap(); /*if (modifiedSentence.startsWith("$")) { Log.i("parsuje", "nmee"); nmeaParser=new NmeaParser(modifiedSentence); lat=nmeaParser.latitude; lon=nmeaParser.longitude; setUpMap(); } else { sensor.setTxtaccel_x(); sensor.setTxtaccel_y(); sensor.setTxtaccel_z(); sensor.setTxtmac_id(); sensor.setTxtid(); Log.d("set text", "dziala"); }*/ } return true; }
public static void sendTo(String ip, int port, byte[] sendBuf) { try { if (_client == null) { _client = new DatagramSocket(null); _client.setReuseAddress(true); _client.setBroadcast(true); // 设置标志,T OR E OR R广播数据报 // 在2.2左右版本不行。在4.0版本上可行 _client.bind(new InetSocketAddress(port)); } InetAddress address = InetAddress.getByName(ip); DatagramPacket sendpacket = new DatagramPacket(sendBuf, SEND_LENGHT, address, port); _client.setSoTimeout(2000); _client.send(sendpacket); } catch (Exception e) { e.printStackTrace(); } }
// ------------------------------------------------------------ @Override public void run() { DatagramSocket ds; int numServers = Integer.valueOf(rb.getString("NumServers")); ServerDescription[] validServers = new ServerDescription[numServers]; int expectedServers = 0; boolean addToFile = false, serverAdded; System.out.println("Started listening for subagent broadcasts"); for (int i = 0; i < numServers; i++) validServers[i] = new ServerDescription(); try { expectedServers = getExpectedServers(validServers); } catch (GenericException e) { System.out.println("Parse error in file, rejecting subagent"); } int listenPort = Integer.valueOf(rb.getString("broadcastPort")); System.out.println("listen Port is " + listenPort); try { ds = new DatagramSocket(null); ds.setBroadcast(true); ds.setReuseAddress(true); ds.bind(new InetSocketAddress(listenPort)); } catch (IOException e) { System.out.println("Error, broadcast socket not created successfully"); System.out.println("Got message: " + e); return; } byte[] receiveData = new byte[1024]; DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); while (keepRunning) { try { ds.receive(receivePacket); System.out.println("Received a datagram packet"); if (expectedServers < numServers) addToFile = true; else addToFile = false; serverAdded = respondToDatagram(receivePacket, validServers, addToFile, expectedServers); if (serverAdded) expectedServers++; } catch (IOException e) { System.out.println("Error, unable to connect with subagent"); System.out.println("Got message: " + e); } } // end while (keepRunning) }
// Broadcasts a packet containing server address to the LAN every second public void run() { try { DatagramSocket socket = new DatagramSocket(); InetSocketAddress address = new InetSocketAddress("255.255.255.255", DISCOVERY_PORT); byte[] message = new byte[0]; socket.setBroadcast(true); DatagramPacket packet = new DatagramPacket(message, message.length); packet.setSocketAddress(address); while (true) { socket.send(packet); Thread.sleep(1000); } } catch (IOException e) { // Port is in use, we don't know our own address or we could not send the broadcast for some // reason. Either way, discovery won't work. logger.log(Level.SEVERE, null, e); } catch (InterruptedException e) { logger.log(Level.INFO, "Discovery service shutting down"); } }
private void readPackets() { try { if (socket == null) { // InetAddress addr = // InetAddress.getByName(configuration.IP_HERMES); InetSocketAddress socketaddress = new InetSocketAddress(configuration.PORT_HERMES); socket = new DatagramSocket(socketaddress); socket.setReuseAddress(true); socket.setBroadcast(true); socket.setSoTimeout(100); } DatagramPacket datagram = new DatagramPacket(rxbuffer, rxbuffer.length); socket.receive(datagram); handlePacket(datagram); } catch (SocketException se) { } catch (IOException ioe) { } }
public void start() throws Exception { for (int i = bind_port; i <= bind_port + port_range; i++) { try { sock = getSocketFactory().createDatagramSocket("jgroups.bping.sock", i); break; } catch (Throwable t) { if (i > bind_port + port_range) throw new RuntimeException( "failed to open a port in range [" + bind_port + " - " + (bind_port + port_range) + "]", t); } } sock.setBroadcast(true); startReceiver(); super.start(); }
/** * 获取设备信息 * * @param msg * @param listener */ public static void receive(String msg, UdpCallBackListener listener) { ArrayList<String> responses = new ArrayList<String>(); String Strs = ""; try { if (_client == null) { _client = new DatagramSocket(null); _client.setReuseAddress(true); _client.setBroadcast(true); // 设置标志,T OR E OR R广播数据报 // 在2.2左右版本不行。在4.0版本上可行 _client.bind(new InetSocketAddress(port)); } DatagramPacket sendDp = new DatagramPacket( msg.getBytes(), msg.getBytes().length, InetAddress.getByName(IP), port); _client.setSoTimeout(2000); _client.send(sendDp); byte[] buf = new byte[1024]; DatagramPacket receiveDp = new DatagramPacket(buf, buf.length); // 创建长度为100的数据接收包 while (true) { Thread.sleep(50); _client.receive(receiveDp); // 套接字接收数据包 String tmpStr = new String(buf, 0, receiveDp.getLength()).replace(" ", ""); Strs += tmpStr; if (tmpStr.contains(SEND_CODE) && tmpStr.contains(",0")) { String strdev = tmpStr + "|" + receiveDp.getAddress(); if (responses.indexOf(strdev) == -1) responses.add(strdev); } } } catch (Exception e) { if (listener != null) { listener.onError(e); } } if (listener != null) { listener.onFinish(responses); } }
/** * Constructor * * @param broadcastAddress destination address for probes * @param handler update Handler in main thread */ public BroadcastDiscoveryClient(InetAddress broadcastAddress, Handler handler) { mBroadcastAddress = broadcastAddress; mHandler = handler; try { mSocket = new DatagramSocket(); // binds to random port mSocket.setBroadcast(true); } catch (SocketException e) { Log.e(LOG_TAG, "Could not create broadcast client socket.", e); throw new RuntimeException(); } mProbeTimer = new Timer(); mProbeTimerTask = new TimerTask() { @Override public void run() { BroadcastDiscoveryClient.this.sendProbe(); } }; Log.i(LOG_TAG, "Starting client on address " + mBroadcastAddress); }
public CopyOfUdpClient(byte[] bytes) { try { udp = new DatagramSocket(); // 设置广播开关 udp.setBroadcast(false); // recdp = new DatagramPacket(bytes, bytes.length, // InetAddress.getByName("219.150.156.51"), UDP_PORT); recdp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("127.0.0.1"), UDP_PORT); udp.send(recdp); udp.close(); } catch (SocketException e) { System.out.println("创建端口监听客户端失败" + e); e.printStackTrace(); } catch (UnknownHostException ex) { System.out.println("UnknownHostException" + ex); ex.printStackTrace(); } catch (IOException e) { System.out.println("发送失败" + e); e.printStackTrace(); } }
@Override public void run() { try { // Keep a socket open to listen to all the UDP trafic that is // destined for this port socket = new DatagramSocket(8888, InetAddress.getByName("0.0.0.0")); socket.setBroadcast(true); while (true) { log.info("server >>>Ready to receive broadcast packets! on 0.0.0.0:8888"); // Receive a packet byte[] recvBuf = new byte[15000]; DatagramPacket packet = new DatagramPacket(recvBuf, recvBuf.length); socket.receive(packet); // Packet received log.info( "server >>>Discovery packet received from: " + packet.getAddress().getHostAddress()); log.info("server >>>Packet received; data: " + new String(packet.getData())); // See if the packet holds the right command (message) String message = new String(packet.getData()).trim(); if (message.equals("DISCOVER_FUIFSERVER_REQUEST")) { byte[] sendData = "DISCOVER_FUIFSERVER_RESPONSE".getBytes(); // Send a response DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, packet.getAddress(), packet.getPort()); socket.send(sendPacket); log.info("server >>>Sent packet to: " + sendPacket.getAddress().getHostAddress()); } } } catch (Exception e) { Logging.logException(e); } }
@Override public void setBroadcast(boolean broadcast) { try { // See: https://github.com/netty/netty/issues/576 if (broadcast && !DetectionUtil.isWindows() && !DetectionUtil.isRoot() && !socket.getLocalAddress().isAnyLocalAddress()) { // Warn a user about the fact that a non-root user can't receive a // broadcast packet on *nix if the socket is bound on non-wildcard address. logger.warn( "A non-root user can't receive a broadcast packet if the socket " + "is not bound to a wildcard address; setting the SO_BROADCAST flag " + "anyway as requested on the socket which is bound to " + socket.getLocalSocketAddress() + '.'); } socket.setBroadcast(broadcast); } catch (SocketException e) { throw new ChannelException(e); } }
@Override public void run() { // Open for voting logger.log(Level.INFO, "Beginning voting"); voting.beginVoting(); VotingReceiver votingService = new VotingReceiver(); if (votingThread != null && !votingThread.isInterrupted()) { votingThread.interrupt(); } votingThread = new Thread(votingService); votingThread.start(); try { /*If client/server are on the same machine, broadcast may arrive at client * before server opens receive socket. This is not relevant on separate machines * but it avoids an extra voting cycle on single machine tests. */ Thread.sleep(200); // Broadcast start of voting period try { DatagramSocket socket = new DatagramSocket(); InetSocketAddress address = new InetSocketAddress("255.255.255.255", VOTING_PORT); byte[] message = new byte[0]; socket.setBroadcast(true); DatagramPacket packet = new DatagramPacket(message, message.length); packet.setSocketAddress(address); socket.send(packet); } catch (IOException e) { logger.log(Level.SEVERE, null, e); } Thread.sleep(10000); // Run voting for 10 seconds } catch (InterruptedException ex) { logger.log(Level.INFO, "Voting shutting down"); } votingThread.interrupt(); voting.endVoting(MCServer.this); }
@Override public void run() { DatagramSocket socket = null; try { socket = new DatagramSocket(PORT); socket.setReuseAddress(true); socket.setBroadcast(true); try { while (mTransmit) { byte[] buffer = new byte[Packet.LENGTH]; DatagramPacket packet = new DatagramPacket(buffer, buffer.length); socket.receive(packet); final Packet p = new Packet(buffer); if (!p.mValid) { runOnUiThread( new Runnable() { @Override public void run() { mScreen.setBackgroundColor(Color.rgb(255, 255, 0)); } }); Log.w(TAG, "Got bogus message"); continue; } // Handle keep alive if (mKeepAliveThread != null && mKeepAliveThread.mInterval != p.mKeepAliveInterval) { mKeepAliveThread.stopTransmission(); try { mKeepAliveThread.join(); } catch (InterruptedException e) { e.printStackTrace(); } mKeepAliveThread = null; runOnUiThread( new Runnable() { @Override public void run() { mKeepAliveText.setText(""); } }); } if (mKeepAliveThread == null && p.mKeepAliveInterval != 0) { runOnUiThread( new Runnable() { @Override public void run() { mKeepAliveText.setText("" + p.mKeepAliveInterval); } }); mKeepAliveThread = new KeepAliveThread(packet.getAddress().getHostAddress(), p.mKeepAliveInterval); mKeepAliveThread.start(); } // We got a sequence number below that of the previous - reset! if (mLastPacket > p.mPacketNumber) { mLastPacket = 0; mLostPackets = 0; mPacketCount = 0; } if (mLastPacket != 0) { mLostPackets += (p.mPacketNumber - mLastPacket) - 1; } mLastPacket = p.mPacketNumber; mPacketCount += 1; runOnUiThread( new Runnable() { @Override public void run() { resetAnimation(p.mSendInterval); mLastPacketText.setText("" + p.mPacketNumber); mPacketCountText.setText("" + mPacketCount); mLostPacketsText.setText("" + mLostPackets); } }); } } catch (IOException e) { e.printStackTrace(); } } catch (SocketException e) { e.printStackTrace(); } finally { if (socket != null) { socket.close(); } } }
@Override public void run() { // TODO Auto-generated method stub while (running) { if (isDebug) Log.i(TAG, "5s扫描设备>>>>>>>>>>>>" + Thread.currentThread()); receive = 50; // 最大接收数量 isSend = false; String recestr = null; try { listDevices.clear(); sendSocket = new DatagramSocket(); sendSocket.setBroadcast(true); sendSocket.setSoTimeout(3000); sendSocket.send(sendPacket); while (receive-- > 0) { sendSocket.receive(recePacket); recestr = new String(recedata, recePacket.getOffset(), recePacket.getLength()); if (recestr.startsWith(DISCOVERY_RESP)) { Device device = new Device(); device.setDeviceName(recestr.substring(9)); device.setDeviceIp(recePacket.getAddress().getHostAddress()); if (listDevices.indexOf(device) < 0) { listDevices.add(device); if (device.getDeviceIp().equals("10.8.8.1")) { isSend = true; if (isDebug) Log.i(TAG, "扫描到10.8.8.1" + listDevices + "|" + Thread.currentThread()); sendResult(); break; } } } // 每次接收完UDP数据后,重置长度。否则可能会导致下次收到数据包被截断。 recePacket.setLength(default_bufferSize); } } catch (SocketTimeoutException e) { if (isDebug) Log.i(TAG, "扫描3s超时" + listDevices + "|" + Thread.currentThread()); if (!isSend) { sendResult(); } } catch (SocketException e) { receive = 0; if (isDebug) Log.i(TAG, "SocketException>>>>>>" + Thread.currentThread()); if (mScanListener != null) { mScanListener.scanException(); } } catch (IOException e) { receive = 0; if (isDebug) Log.i(TAG, "SocketException>>>>>>" + Thread.currentThread()); if (mScanListener != null) { mScanListener.scanException(); } } sendSocket.close(); if (wipicoVersion >= 2) { // 版本2才进行SSID 扫描 List<ScanResult> listScanResults = WifiAdmin.getInstance(mContext).getScanResults(); if (listScanResults != null) { for (ScanResult bean : listScanResults) { if (DeviceUtil.isMatchSSID(DeviceUtil.ssidCorrect(bean.SSID))) { listWifiDevices.add( new Device(DeviceUtil.ssidCorrect(bean.SSID), bean.capabilities, null)); } } } sendWifiResult(); } try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } } }
/** * 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 protected Void doInBackground(Void... params) { Log.d("Discovery: ", "start UDP Server"); String data = "0::deskcon"; try { // Send "Ask for Hosts" Broadcast serverSocketUDP = new DatagramSocket(5108); serverSocketUDP.setBroadcast(true); InetAddress local = getBroadcast(); // has a broadcast address been found if (local == null) { Log.d("Discovery: ", "no Broadcast Address found"); return null; } DatagramPacket packet = new DatagramPacket(data.getBytes(), data.length(), local, 5108); serverSocketUDP.send(packet); } catch (Exception e) { e.printStackTrace(); Log.d("Discovery: ", "could not start"); return null; } WifiManager wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE); MulticastLock lock = wifi.createMulticastLock("net.screenfreeze.deskcon"); lock.acquire(); // Receive responses from desktop hosts while (!isStopped) { byte[] receiveData = new byte[128]; DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); try { serverSocketUDP.receive(receivePacket); } catch (Exception e) { } final InetAddress address = receivePacket.getAddress(); String msg = new String(receiveData, 0, receivePacket.getLength()); // Check for valid msg boolean isvalismsg = msg.split("::").length == 3; // Process msg if it is not our own broadcast msg if (!msg.equals(data) && !isStopped && isvalismsg) { final DesktopHost desktop = handleReceiveUdp(msg, address); Log.d("udp from: ", "msg " + msg + " " + address); runOnUiThread( new Runnable() { @Override public void run() { dha.add(desktop); } }); } } lock.release(); return null; }
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; }
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; }
@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"); }