// Java language // Buffer for receiving incoming data byte[] inboundDatagramBuffer = new byte[1024]; DatagramPacket inboundDatagram = new DatagramPacket(inboundDatagramBuffer, inboundDatagramBuffer.length); // Source IP address InetAddress sourceAddress = inboundDatagram.getAddress(); // Source port int sourcePort = inboundDatagram.getPort(); // Actually receive the datagram socket.receive(inboundDatagram);
/** * Gets the host address and the port to which this datagram packet is sent * as a {@code SocketAddress} object. * * @return the SocketAddress of the target host. */ public synchronized SocketAddress getSocketAddress() { return new InetSocketAddress(getAddress(), getPort()); }
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; }
@Override protected int peek(InetAddress sender) throws IOException { // We don't actually want the data: we just want the DatagramPacket's filled-in address. DatagramPacket packet = new DatagramPacket(EmptyArray.BYTE, 0); int result = peekData(packet); // Note: evil side-effect on InetAddress! This method should have returned InetSocketAddress! sender.ipaddress = packet.getAddress().getAddress(); return result; }
/** 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(); }
DatagramPacket packet = new DatagramPacket(buffer, buffer.length); String json = new String(IoUtils.tryDecompress(packet.getData()), "UTF-8").trim(); LogUtils.LOG.info("received push data: " + json + " from " + packet.getAddress().toString()); udpSocket.send(new DatagramPacket(ack.getBytes(Charset.forName("UTF-8")), ack.getBytes(Charset.forName("UTF-8")).length, packet.getSocketAddress())); } catch (Exception 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 }
/*** * Creates an acknowledgement packet based from a received * datagram. Assumes the datagram is at least length 4, else an * ArrayIndexOutOfBoundsException may be thrown. * * @param datagram The datagram containing the received acknowledgement. * @throws TFTPPacketException If the datagram isn't a valid TFTP * acknowledgement packet. ***/ TFTPAckPacket(DatagramPacket datagram) throws TFTPPacketException { super(TFTPPacket.ACKNOWLEDGEMENT, datagram.getAddress(), datagram.getPort()); byte[] data; data = datagram.getData(); if (getType() != data[1]) { throw new TFTPPacketException("TFTP operator code does not match type."); } _blockNumber = (((data[2] & 0xff) << 8) | (data[3] & 0xff)); }
byte[] b = new byte[BUFFER_LENGTH]; DatagramPacket dgram = new DatagramPacket(b, b.length); MulticastSocket socket = new MulticastSocket(DEST_PORT); // must bind receive side socket.joinGroup(InetAddress.getByName(MCAST_ADDR)); while(true) { socket.receive(dgram); // blocks until a datagram is received System.err.println("Received " + dgram.getLength() + " bytes from " + dgram.getAddress()); dgram.setLength(b.length); // must reset length field! }
@Override public boolean validate(final DatagramPacket response) { if (response.getAddress().equals(m_client.getAddress())) { // Parse the incoming data NtpMessage m = new NtpMessage(response.getData()); LOG.info("NTP message received {}", m.toString()); // All timestamps returned on the package are required in order to process the NTP package on the client side. return m.originateTimestamp > 0 && m.transmitTimestamp > 0 && m.referenceTimestamp > 0 && m.receiveTimestamp > 0; }else{ return false; } }
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);
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; } } } }
DatagramPacket datagram = new DatagramPacket(buf, buf.length); + datagram.getAddress().getHostAddress() + ":" + datagram.getPort() + " on: " + localAddress );
protected void sendUpnpNotify(InetAddress aSocketAddress) { String notifyData = null; notifyData = String.format(notifyTemplate, Configuration.UPNP_MULTICAST_ADDRESS, Configuration.UPNP_DISCOVERY_PORT, responseAddress, httpServerPort, bridgeId, bridgeSNUUID, bridgeSNUUID); log.debug("sendUpnpNotify notifyTemplate is <<<" + notifyData + ">>>"); DatagramPacket notifyPacket = new DatagramPacket(notifyData.getBytes(), notifyData.length(), aSocketAddress, Configuration.UPNP_DISCOVERY_PORT); try { upnpMulticastSocket.send(notifyPacket); } catch (IOException e1) { log.warn("UpnpListener encountered an error sending upnp notify packet. IP: " + notifyPacket.getAddress().getHostAddress() + " with message: " + e1.getMessage()); log.debug("UpnpListener send upnp notify exception: ", e1); } } }
int size = dpacket.getLength(); if (_log.shouldLog(Log.INFO)) _log.info("After blocking socket.receive: packet is " + size + " bytes on " + System.identityHashCode(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 void run() { LOG.info("Received UDP Syslog message of {} bytes from {}", packet.getLength(), packet.getAddress()); onMessage(arr, packet.getData(), packet.getOffset(), packet.getLength(), conn, packet.getAddress()); } }
cipher.init(Cipher.DECRYPT_MODE, peer.getPrivateKey()); final byte[] data = decryptBlocks(packet.getData(), cipher, 256, 245); return new Envelope(new PeerInfo(peer.getPublicKey(), peerId, packet.getAddress().getHostAddress(), packet.getPort()), msg);
@Override boolean handle(DatagramPacket packet) { // Relay Destination if (c++ < 100) { // 100 packets are enough to discover relay address this.setHost(packet.getAddress()); this.setPort(packet.getPort()); return true; } else { c = 1000; // Prevents long overflow // Check Source Address. If it's different, discard packet. return this.getHost().equals(packet.getAddress()); } }
@Override public synchronized void receive(DatagramPacket p) throws IOException { log.debug("Emulate receive: " + p); if (toRead == null) { throw new SocketException(); } p.setData(toRead.getData()); p.setAddress(toRead.getAddress()); //p.setSocketAddress(toRead.getSocketAddress()); toRead = null; }
_log.debug("Packet to send known: " + packet); long acquireTime = _context.clock().now(); int size = packet.getPacket().getLength(); } catch (IOException ioe) { if (_log.shouldLog(Log.WARN)) _log.warn("Error sending to " + packet.getPacket().getAddress(), ioe); _context.statManager().addRateData("udp.sendException", 1, packet.getLifetime()); if (_socket.isClosed()) {