@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); } } }
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); } }
AutoBuffer( DatagramPacket pack ) { _size = pack.getLength(); _bb = ByteBuffer.wrap(pack.getData(), 0, pack.getLength()).order(ByteOrder.nativeOrder()); _bb.position(0); _read = true; _firstPage = true; _chan = null; _h2o = H2ONode.intern(pack.getAddress(), getPort()); _persist = 0; // No persistance }
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(); } } } }
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; }
_socket.receive(dpacket); int size = dpacket.getLength(); if (_log.shouldLog(Log.INFO)) _log.info("After blocking socket.receive: packet is " + size + " bytes on " + System.identityHashCode(packet)); receive(packet); _log.info("Received a 0 byte udp packet from " + dpacket.getAddress() + ":" + dpacket.getPort()); _transport.getEstablisher().receiveHolePunch(dpacket.getAddress(), dpacket.getPort()); packet.release();
@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; }
@Override boolean process() throws IOException { ReceiveBufferSizePredictor predictor = channel.getConfig().getReceiveBufferSizePredictor(); byte[] buf = new byte[predictor.nextReceiveBufferSize()]; DatagramPacket packet = new DatagramPacket(buf, buf.length); try { channel.socket.receive(packet); } catch (InterruptedIOException e) { // Can happen on interruption. // Keep receiving unless the channel is closed. return true; } fireMessageReceived( channel, channel.getConfig().getBufferFactory().getBuffer(buf, 0, packet.getLength()), packet.getSocketAddress()); return true; }
/** how many times we tried to validate the packet */ //int getValidateCount() { return _validateCount; } @Override public String toString() { verifyNotReleased(); StringBuilder buf = new StringBuilder(256); buf.append(_packet.getLength()); buf.append(" byte pkt with "); buf.append(Addresses.toString(_packet.getAddress().getAddress(), _packet.getPort())); //buf.append(" id=").append(System.identityHashCode(this)); if (_messageType >= 0) buf.append(" msgType=").append(_messageType); if (_markedType >= 0) buf.append(" markType=").append(_markedType); if (_fragmentCount > 0) buf.append(" fragCount=").append(_fragmentCount); if (_enqueueTime > 0) buf.append(" sinceEnqueued=").append(_context.clock().now() - _enqueueTime); if (_receivedTime > 0) buf.append(" sinceReceived=").append(_context.clock().now() - _receivedTime); //buf.append(" beforeReceiveFragments=").append((_beforeReceiveFragments > 0 ? _context.clock().now()-_beforeReceiveFragments : -1)); //buf.append(" sinceHandled=").append((_afterHandlingTime > 0 ? _context.clock().now()-_afterHandlingTime : -1)); //buf.append("\ndata=").append(Base64.encode(_packet.getData(), _packet.getOffset(), _packet.getLength())); return buf.toString(); }
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); }
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 run() { byte[] buf = new byte[BUFF_SIZE]; DatagramPacket packet = new DatagramPacket(buf, 0, buf.length); while (started.get()) { doTimeKeepingServices(); try { mcast.receive(packet); if (packet.getLength() > 0) { String str = new String(packet.getData(), packet.getOffset(), packet.getLength()); processData(str); } } catch (SocketTimeoutException se) { // ignore } catch (IOException e) { if (started.get()) { LOG.error("failed to process packet: " + e); } } } }
@Override public void send(DatagramPacket packet) throws IOException { int port = isNativeConnected ? 0 : packet.getPort(); InetAddress address = isNativeConnected ? null : packet.getAddress(); IoBridge.sendto(fd, packet.getData(), packet.getOffset(), packet.getLength(), 0, address, port); }
void doReceive(DatagramSocket socket) throws IOException { int consumed= offset + length; _internalPacket.setData(buffer, consumed, buffer.length - consumed); socket.receive(_internalPacket); length= _internalPacket.getLength(); _socketAddress= (InetSocketAddress) _internalPacket.getSocketAddress(); _address= DATAGRAM_SCHEME + _internalPacket.getAddress().getHostName() + ":" + _internalPacket.getPort(); } }
/*** * 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; }
assertEquals(0, mockEventLoop.lastOutgoing.getLength()); assertEquals(Inet4Address.getByAddress(new byte[]{8, 8, 8, 8}), mockEventLoop.lastOutgoing.getAddress()); assertEquals(0, mockEventLoop.lastOutgoing.getLength()); assertEquals(Inet4Address.getByAddress(new byte[]{1, 1, 1, 8}), mockEventLoop.lastOutgoing.getAddress()); assertNull(mockEventLoop.lastResponse);
@Override public void run() { try { OutputStream out = localTcpSocket.getOutputStream(); while (true) { byte[] b = new byte[500]; DatagramPacket p = new DatagramPacket(b, 500); localUdpSocket.receive(p); if (p.getLength() == 0) continue; LOGGER.fine("UDP Client Received and Sending to TCP Server:" + new String(p.getData(), 0, p.getLength(), "UTF-8")); out.write(p.getData(), 0, p.getLength()); out.flush(); LOGGER.fine("Client Flush"); } } catch (IOException e) { LOGGER.log(Level.WARNING, "exception", e); } }
DatagramPacket dp = new DatagramPacket(lMsg, lMsg.length); DatagramSocket ds = null; ds.receive(dp); i.putExtra(Main.MESSAGE_STRING, new String(lMsg, 0, dp.getLength())); Main.MainContext.getApplicationContext().sendBroadcast(i);