@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 int read(byte[] buffer, int offset, int readLength) throws UdpDataSourceException { if (readLength == 0) { return 0; } if (packetRemaining == 0) { // We've read all of the data from the current packet. Get another. try { socket.receive(packet); } catch (IOException e) { throw new UdpDataSourceException(e); } packetRemaining = packet.getLength(); bytesTransferred(packetRemaining); } int packetOffset = packet.getLength() - packetRemaining; int bytesToRead = Math.min(packetRemaining, readLength); System.arraycopy(packetBuffer, packetOffset, buffer, offset, bytesToRead); packetRemaining -= bytesToRead; return bytesToRead; }
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 ); } } } }
private DatagramPacket receive() { byte[] receiveBuffer = new byte[BUFFER_LENGTH]; DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, BUFFER_LENGTH); try { this.serverSocket.receive(receivePacket); } catch (IOException e) { System.out.println("SLOTH SERVER: Failed to receive because: " + e.getMessage() + ": Continuing..."); e.printStackTrace(); } return receivePacket; }
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 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 ); } }
@Override public void run() { this.thread = Thread.currentThread(); final byte[] bytes = new byte[4096]; final DatagramPacket packet = new DatagramPacket(bytes, bytes.length); try { while (!shutdown) { latch.countDown(); sock.receive(packet); ++count; final LogEvent event = objectMapper.readValue(packet.getData(), Log4jLogEvent.class); queue.add(event); } } catch (final Throwable e) { e.printStackTrace(); if (!shutdown) { Throwables.rethrow(e); } } }
/*** * Retrieves the time from the specified server and port and * returns it. The time is the number of seconds since * 00:00 (midnight) 1 January 1900 GMT, as specified by RFC 868. * This method reads the raw 32-bit big-endian * unsigned integer from the server, converts it to a Java long, and * returns the value. * * @param host The address of the server. * @param port The port of the service. * @return The time value retrieved from the server. * @throws IOException If an error occurs while retrieving the time. ***/ public long getTime(InetAddress host, int port) throws IOException { long time; DatagramPacket sendPacket, receivePacket; sendPacket = new DatagramPacket(__dummyData, __dummyData.length, host, port); receivePacket = new DatagramPacket(__timeData, __timeData.length); _socket_.send(sendPacket); _socket_.receive(receivePacket); time = 0L; time |= (((__timeData[0] & 0xff) << 24) & 0xffffffffL); time |= (((__timeData[1] & 0xff) << 16) & 0xffffffffL); time |= (((__timeData[2] & 0xff) << 8) & 0xffffffffL); time |= ((__timeData[3] & 0xff) & 0xffffffffL); return time; }
public Command read() throws IOException { Command answer = null; Endpoint from = null; synchronized (readLock) { while (true) { DatagramPacket datagram = createDatagramPacket(); channel.receive(datagram); // TODO could use a DataInput implementation that talks direct // to the byte[] to avoid object allocation receiveCounter++; DataInputStream dataIn = new DataInputStream(new ByteArrayInputStream(datagram.getData(), 0, datagram.getLength())); from = headerMarshaller.createEndpoint(datagram, dataIn); answer = (Command)wireFormat.unmarshal(dataIn); break; } } if (answer != null) { answer.setFrom(from); if (LOG.isDebugEnabled()) { LOG.debug("Channel: " + name + " about to process: " + answer); } } return answer; }
DatagramSocket socket = null; try { socket = new DatagramSocket(); broadcast(udpPort, socket); socket.setSoTimeout(timeoutMillis); DatagramPacket packet = discoveryHandler.onRequestNewDatagramPacket(); try { socket.receive(packet); } catch (SocketTimeoutException ex) { if (INFO) info("kryonet", "Host discovery timed out.");
private static Map<String,String> getMessages(List<String> fragments, int timeout) throws IOException { long startTime = System.currentTimeMillis(); Map<String,String> results = new HashMap<>(); do { receiveData = new byte[65535]; receivePacket.setData(receiveData); try { serverSocket.receive(receivePacket); String message = new String(receivePacket.getData()).trim(); fragments.stream().forEach(fragment -> { if (message.startsWith(fragment)) { results.put(fragment, message); } }); } catch (SocketTimeoutException e) { //expected so that we keep looping } } while (results.size()<fragments.size() && (System.currentTimeMillis() < (startTime + timeout))); return results; }
private void processRequests() throws IOException { byte[] buffer = new byte[1024]; DatagramPacket packet = new DatagramPacket(buffer, buffer.length); socket.receive(packet); String messageReceived = new String(packet.getData(), 0, packet.getLength(), charset); LOGGER.debug("Message received: {}", messageReceived); receivedMessages.add(messageReceived); }
// bind to INADDR_ANY, allowing packets on all IP addresses of host: DatagramSocket dsock = new DatagramSocket(55555); DatagramPacket packet = new DatagramPacket(new byte[8192]); //next packet can be from anywhere including local host (127.0.0.0/8) dsock.receive(packet); // restrict communication to a single host/port: dsock.connect(new InetSocketAddress("somehost.net", 99)); // next packet can only be from somehost.net on port 99: dsock.receive(packet);
public void run() { byte[] buf=new byte[RoundTrip.PAYLOAD]; DatagramPacket packet=new DatagramPacket(buf, 0, buf.length); for(;;) { try { sock.receive(packet); if(packet.getLength() != RoundTrip.PAYLOAD) throw new IllegalStateException("expected " + RoundTrip.PAYLOAD + " bytes, but got only " + packet.getLength()); if(receiver != null) receiver.receive(packet.getSocketAddress(), buf, packet.getOffset(), packet.getLength()); } catch(IOException ex) { break; } catch(Exception e) { e.printStackTrace(); } } } }
while (enabled) { packet = new DatagramPacket(buf, buf.length); dataSocket.receive(packet);
/** Broadcasts a UDP message on the LAN to discover any running servers. The address of the first server to respond is * returned. * @param udpPort The UDP port of the server. * @param timeoutMillis The number of milliseconds to wait for a response. * @return the first server found, or null if no server responded. */ public InetAddress discoverHost (int udpPort, int timeoutMillis) { DatagramSocket socket = null; try { socket = new DatagramSocket(); broadcast(udpPort, socket); socket.setSoTimeout(timeoutMillis); DatagramPacket packet = discoveryHandler.onRequestNewDatagramPacket(); try { socket.receive(packet); } catch (SocketTimeoutException ex) { if (INFO) info("kryonet", "Host discovery timed out."); return null; } if (INFO) info("kryonet", "Discovered server: " + packet.getAddress()); discoveryHandler.onDiscoveredHost(packet, getKryo()); return packet.getAddress(); } catch (IOException ex) { if (ERROR) error("kryonet", "Host discovery failed.", ex); return null; } finally { if (socket != null) socket.close(); discoveryHandler.onFinally(); } }
/*** * Receive the reply data from the server. This will always be 512 bytes * or less. Chargen and quote of the day only return one packet. Netstat * and systat require multiple calls to receive() with timeout detection. * * @return The reply data from the server. * @throws IOException If an error occurs while receiving the datagram. ***/ public byte[] receive() throws IOException { int length; byte[] result; _socket_.receive(__receivePacket); result = new byte[length = __receivePacket.getLength()]; System.arraycopy(__receiveData, 0, result, 0, length); return result; }
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);
public static void main(String[] args) { try { DatagramSocket socket = new DatagramSocket(1234); byte[] data = new byte[4]; DatagramPacket packet = new DatagramPacket(data, data.length ); socket.receive(packet); int len = 0; // byte[] -> int for (int i = 0; i < 4; ++i) { len |= (data[3-i] & 0xff) << (i << 3); } // now we know the length of the payload byte[] buffer = new byte[len]; packet = new DatagramPacket(buffer, buffer.length ); socket.receive(packet); ByteArrayInputStream baos = new ByteArrayInputStream(buffer); ObjectInputStream oos = new ObjectInputStream(baos); ClientModel c1 = (ClientModel)oos.readObject(); c1.print(); } catch(Exception e) { e.printStackTrace(); } }