@Override public void run() { try (DatagramSocket socket = new DatagramSocket()) { for (int i = 0; i < 4; i++) { String message = clientName + " - Log request: " + i; DatagramPacket request = new DatagramPacket(message.getBytes(), message.getBytes().length, remoteAddress); socket.send(request); byte[] data = new byte[1024]; DatagramPacket reply = new DatagramPacket(data, data.length); socket.receive(reply); if (reply.getLength() == 0) { LOGGER.info("Read zero bytes"); } else { LOGGER.info(new String(reply.getData(), 0, reply.getLength())); } artificialDelayOf(100); } } catch (IOException e1) { LOGGER.error("error sending packets", e1); } } }
@Override public void write(byte[] b, int off, int len) throws IOException { // Important not to cache InetAddress and let the JVM/OS to handle DNS caching. datagramSocket.send(new DatagramPacket(b, off, len, InetAddress.getByName(host), port)); }
public void write(final String string) throws IOException { if(this.ds != null && this.address != null) { byte[] bytes = string.getBytes(); // // syslog packets must be less than 1024 bytes // int bytesLength = bytes.length; if (bytesLength >= 1024) { bytesLength = 1024; } DatagramPacket packet = new DatagramPacket(bytes, bytesLength, address, port); ds.send(packet); } }
try { DatagramSocket socket = new DatagramSocket(); Log.d("VS", "Socket Created"); DatagramPacket packet; final InetAddress destination = InetAddress.getByName("192.168.1.5"); Log.d("VS", "Address retrieved"); packet = new DatagramPacket (buffer,buffer.length,destination,port); socket.send(packet); System.out.println("MinBufferSize: " +minBufSize);
private void unicast(String msg, String host) { if (logger.isInfoEnabled()) { logger.info("Send unicast message: " + msg + " to " + host + ":" + multicastPort); } try { byte[] data = (msg + "\n").getBytes(); DatagramPacket hi = new DatagramPacket(data, data.length, InetAddress.getByName(host), multicastPort); multicastSocket.send(hi); } catch (Exception e) { throw new IllegalStateException(e.getMessage(), e); } }
ds = new DatagramSocket(); DatagramPacket dp; dp = new DatagramPacket(Message.getBytes(), Message.length(), Main.BroadcastAddress, Main.SERVER_PORT); ds.setBroadcast(true); ds.send(dp);
public void run() { while(true) { try { byte[] buf=new byte[1024]; DatagramPacket packet=new DatagramPacket(buf, buf.length); mcast_sock.receive(packet); byte[] recv_buf=packet.getData(); int recv_len=packet.getLength(); System.out.println(new String(recv_buf,0,recv_len) + " [sender=" + packet.getAddress().getHostAddress() + ':' + packet.getPort() + ']'); } catch(Exception ex) { System.err.println("Receiver terminated: " + ex); break; } } } }
public void run(){ Configure conf = Configure.getInstance(); byte[] receiveData = new byte[conf.net_udp_packet_max_bytes]; DatagramSocket serverSocket = null; int flag; try { serverSocket = new DatagramSocket(conf.net_local_udp_port); DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); while(true){ serverSocket.receive(receivePacket); flag = DataInputX.toInt(receiveData, 0); if(flag == NetCafe.UDP_CAFE_MTU){ processMTU(receiveData, receivePacket.getAddress()); }else{ process(flag, receiveData); } } }catch(Exception ex){ ex.printStackTrace(); }finally{ if(serverSocket !=null){ try {serverSocket.close();}catch(Exception ex){} } } }
public void relayPacket(DatagramPacket packet) { try { DatagramPacket echo = new DatagramPacket(packet.getData(), packet.getLength(), host, port); dataSocket.send(echo); } catch (IOException e) { Log.error(e.getMessage(), e); } }
@Override public void run() { byte[] buf = new byte[1024]; DatagramPacket recv = new DatagramPacket(buf, buf.length); while (true) { try { mutilcastSocket.receive(recv); MulticastGroup.this.receive(new String(recv.getData()).trim(), (InetSocketAddress) recv.getSocketAddress()); } catch (Exception e) { logger.error(e.getMessage(), e); } } } }, "MulticastGroupReceiver");
public void run() { while(t != null) { try { buf=new byte[256]; packet=new DatagramPacket(buf, buf.length); sock.receive(packet); System.out.println("<< Received packet from " + packet.getAddress().getHostAddress() + ':' + packet.getPort() + ": " + new String(packet.getData())); } catch(Exception e) { System.err.println(e); break; } } t=null; }
public ByteBuffer read() { checkClosed(); try { DatagramPacket packet = new DatagramPacket( buffer, buffer.length ); sock.receive(packet); // Wrap it in a ByteBuffer for the caller return ByteBuffer.wrap( buffer, 0, packet.getLength() ); } catch( IOException e ) { if( !connected.get() ) { // Nothing to see here... just move along return null; } throw new ConnectorException( "Error reading from connection to:" + remoteAddress, e ); } }
public void createSocket() throws IOException { try { InetSocketAddress address = new InetSocketAddress(this.serverHost, this.serverPort); socket = new DatagramSocket(); packet = new DatagramPacket("".getBytes(StandardCharsets.UTF_8), 0, 0, address.getAddress(), this.serverPort); } catch (IOException ioe) { throw NetUtils.wrapException(this.serverHost, this.serverPort, "localhost", 0, ioe); } }
public void run() { log.log( Level.FINE, "Kernel started for connection:{0}.", address ); // An atomic is safest and costs almost nothing while( go.get() ) { try { // Could reuse the packet but I don't see the // point and it may lead to subtle bugs if not properly // reset. DatagramPacket packet = new DatagramPacket( buffer, buffer.length ); socket.receive(packet); newData( packet ); } catch( IOException e ) { if( !go.get() ) return; reportError( e ); } } } }
DatagramSocket socket = new DatagramSocket(PORT); socket.setBroadcast(true); DatagramPacket packet = new DatagramPacket(data.getBytes(), data.length(), getBroadcastAddress(), DISCOVERY_PORT); socket.send(packet); byte[] buf = new byte[1024]; DatagramPacket packet = new DatagramPacket(buf, buf.length); socket.receive(packet);
boolean entered = BTraceRuntime.enter(); try { ds = new DatagramSocket(); DatagramPacket dp = new DatagramPacket(new byte[0], 0); try { dp.setAddress(InetAddress.getByName(SharedSettings.GLOBAL.getStatsdHost())); } catch (UnknownHostException e) { System.err.println("[statsd] invalid host defined: " + SharedSettings.GLOBAL.getStatsdHost()); } else { dp.setData(sb.toString().getBytes(CHARSET)); ds.send(dp); sb.setLength(0); ds.send(dp);
@Override public void run() { try { InputStream in = localTcpSocket.getInputStream(); InetAddress remoteHost = InetAddress.getByName(remoteUdpHost); process.start(); while (true) { byte[] b = new byte[500]; int s = in.read(b); // if (s == -1) continue; LOGGER.fine("TCP Client:" + new String(b, 0, s, "UTF-8")); DatagramPacket udpPacket = new DatagramPacket(b, s); udpPacket.setAddress(remoteHost); udpPacket.setPort(remoteUdpPort); localUdpSocket.send(udpPacket); } } catch (IOException e) { LOGGER.log(Level.WARNING, "exception", e); } }
private void unicast(String msg, String host) { if (logger.isInfoEnabled()) { logger.info("Send unicast message: " + msg + " to " + host + ":" + multicastPort); } try { byte[] data = (msg + "\n").getBytes(); DatagramPacket hi = new DatagramPacket(data, data.length, InetAddress.getByName(host), multicastPort); multicastSocket.send(hi); } catch (Exception e) { throw new IllegalStateException(e.getMessage(), e); } }
@Override public void broadcast(byte[] data) throws Exception { DatagramPacket packet = new DatagramPacket(data, data.length, groupAddress, groupPort); broadcastingSocket.send(packet); }
static public boolean sendUdp(InetAddress IPAddress, int port, byte [] byteArray){ DatagramSocket datagram = null; try { Configure conf = Configure.getInstance(); if (byteArray.length > conf.net_udp_packet_max_bytes) { return sendMTU(IPAddress, port, byteArray, conf.net_udp_packet_max_bytes); } datagram = new DatagramSocket(); DatagramPacket packet = new DatagramPacket(byteArray, byteArray.length); packet.setAddress(IPAddress); packet.setPort(port); datagram.send(packet); return true; } catch (Exception e) { e.printStackTrace(); } finally{ if(datagram != null){ try { datagram.close(); } catch(Exception ex){} } } return false; }