Here are the examples of the java api class java.net.DatagramPacket taken from open source projects.
1. UDPServerSocket#readPacket()
Project: Nukkit
File: UDPServerSocket.java
File: UDPServerSocket.java
public DatagramPacket readPacket() throws IOException { ByteBuffer buffer = ByteBuffer.allocate(65536); InetSocketAddress socketAddress = (InetSocketAddress) this.channel.receive(buffer); if (socketAddress == null) { return null; } DatagramPacket packet = new DatagramPacket(new byte[buffer.position()], buffer.position()); packet.setAddress(socketAddress.getAddress()); packet.setPort(socketAddress.getPort()); packet.setLength(buffer.position()); packet.setData(Arrays.copyOf(buffer.array(), packet.getLength())); //MainLogger.getLogger().debug(TextFormat.YELLOW + "In: " + Binary.bytesToHexString(packet.getData(), true)); return packet; /*DatagramPacket packet = new DatagramPacket(new byte[65536], 65536); this.socket.receive(packet); packet.setData(Arrays.copyOf(packet.getData(), packet.getLength())); return packet;*/ }
2. UDPServerSocket#readPacket()
Project: DragonProxy
File: UDPServerSocket.java
File: UDPServerSocket.java
public DatagramPacket readPacket() throws IOException { ByteBuffer buffer = ByteBuffer.allocate(65536); InetSocketAddress socketAddress = (InetSocketAddress) this.channel.receive(buffer); if (socketAddress == null) { return null; } DatagramPacket packet = new DatagramPacket(new byte[buffer.position()], buffer.position()); packet.setAddress(socketAddress.getAddress()); packet.setPort(socketAddress.getPort()); packet.setLength(buffer.position()); packet.setData(Arrays.copyOf(buffer.array(), packet.getLength())); //MainLogger.getLogger().debug(TextFormat.YELLOW + "In: " + Binary.bytesToHexString(packet.getData(), true)); return packet; /*DatagramPacket packet = new DatagramPacket(new byte[65536], 65536); this.socket.receive(packet); packet.setData(Arrays.copyOf(packet.getData(), packet.getLength())); return packet;*/ }
3. UdpSocketTest#testChunkSize()
Project: pinpoint
File: UdpSocketTest.java
File: UdpSocketTest.java
@Test public void testChunkSize() throws IOException { DatagramPacket packet1 = newDatagramPacket(1000); sender.send(packet1); DatagramPacket packet2 = newDatagramPacket(500); sender.send(packet2); DatagramPacket r1 = newDatagramPacket(2000); receiver.receive(r1); Assert.assertEquals(r1.getLength(), 1000); DatagramPacket r2 = newDatagramPacket(2000); receiver.receive(r2); Assert.assertEquals(r2.getLength(), 500); }
4. SnmpAdaptorServer#sendTrapMessage()
Project: jdk7u-jdk
File: SnmpAdaptorServer.java
File: SnmpAdaptorServer.java
/** * Send the specified message on trapSocket. */ private void sendTrapMessage(SnmpMessage msg) throws IOException, SnmpTooBigException { byte[] buffer = new byte[bufferSize]; DatagramPacket packet = new DatagramPacket(buffer, buffer.length); int encodingLength = msg.encodeMessage(buffer); packet.setLength(encodingLength); packet.setAddress(msg.address); packet.setPort(msg.port); if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) { SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag, "sendTrapMessage", "sending trap to " + msg.address + ":" + msg.port); } trapSocket.send(packet); if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) { SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag, "sendTrapMessage", "sent to " + msg.address + ":" + msg.port); } snmpOutTraps++; snmpOutPkts++; }
5. NtpV3Impl#setDatagramPacket()
Project: commons-net
File: NtpV3Impl.java
File: NtpV3Impl.java
/*** * Set the contents of this object from source datagram packet. * * @param srcDp source DatagramPacket to copy contents from, never null. * @throws IllegalArgumentException if srcDp is null or byte length is less than minimum length of 48 bytes */ @Override public void setDatagramPacket(DatagramPacket srcDp) { if (srcDp == null || srcDp.getLength() < buf.length) { throw new IllegalArgumentException(); } byte[] incomingBuf = srcDp.getData(); int len = srcDp.getLength(); if (len > buf.length) { len = buf.length; } System.arraycopy(incomingBuf, 0, buf, 0, len); DatagramPacket dp = getDatagramPacket(); dp.setAddress(srcDp.getAddress()); int port = srcDp.getPort(); dp.setPort(port > 0 ? port : NTP_PORT); dp.setData(buf); }
6. DataUdpAgent#writeMTU()
Project: scouter
File: DataUdpAgent.java
File: DataUdpAgent.java
private void writeMTU(long pkid, int total, int num, int packetSize, byte[] data) throws IOException { DataOutputX out = new DataOutputX(); out.write(NetCafe.CAFE_MTU); out.writeInt(conf.getObjHash()); out.writeLong(pkid); out.writeShort(total); out.writeShort(num); out.writeBlob(data); byte[] buff = out.toByteArray(); DatagramPacket packet = new DatagramPacket(buff, buff.length); packet.setAddress(server_host); packet.setPort(server_port); datagram.send(packet); }
7. DataUdpAgent#writeMTU()
Project: scouter
File: DataUdpAgent.java
File: DataUdpAgent.java
private void writeMTU(long pkid, int total, int num, int packetSize, byte[] data) throws IOException { DataOutputX out = new DataOutputX(); out.write(NetCafe.CAFE_MTU); out.writeInt(conf.getObjHash()); out.writeLong(pkid); out.writeShort(total); out.writeShort(num); out.writeBlob(data); byte[] buff = out.toByteArray(); DatagramPacket packet = new DatagramPacket(buff, buff.length); packet.setAddress(server_host); packet.setPort(server_port); datagram.send(packet); }
8. DefaultObjectPoolTest#testReset()
Project: pinpoint
File: DefaultObjectPoolTest.java
File: DefaultObjectPoolTest.java
@Test public void testReset() throws Exception { DefaultObjectPool<DatagramPacket> pool = new DefaultObjectPool<>(new DatagramPacketFactory(), 1); PooledObject<DatagramPacket> pooledObject = pool.getObject(); DatagramPacket packet = pooledObject.getObject(); packet.setLength(10); pooledObject.returnObject(); DatagramPacket check = pooledObject.getObject(); Assert.assertSame(check, packet); Assert.assertEquals(packet.getLength(), DatagramPacketFactory.UDP_MAX_PACKET_LENGTH); }
9. TimeUDPClient#getTime()
Project: commons-net
File: TimeUDPClient.java
File: TimeUDPClient.java
/*** * 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; }
10. DaytimeUDPClient#getTime()
Project: commons-net
File: DaytimeUDPClient.java
File: DaytimeUDPClient.java
/** * Retrieves the time string from the specified server and port and * returns it. * * @param host The address of the server. * @param port The port of the service. * @return The time string. * @throws IOException If an error occurs while retrieving the time. */ public String getTime(InetAddress host, int port) throws IOException { DatagramPacket sendPacket, receivePacket; sendPacket = new DatagramPacket(__dummyData, __dummyData.length, host, port); receivePacket = new DatagramPacket(__timeData, __timeData.length); _socket_.send(sendPacket); _socket_.receive(receivePacket); // Java 1.6 can use getCharset() return new String(receivePacket.getData(), 0, receivePacket.getLength(), getCharsetName()); }
11. UdpSocketTest#testMaxBytes()
Project: pinpoint
File: UdpSocketTest.java
File: UdpSocketTest.java
@Test public void testMaxBytes() throws IOException { DatagramPacket packet1 = newDatagramPacket(50000); sender.send(packet1); DatagramPacket r1 = newDatagramPacket(50000); receiver.receive(r1); logger.debug("packetSize:{}", r1.getLength()); }
12. Offset#main()
Project: openjdk
File: Offset.java
File: Offset.java
public static void main(String args[]) throws Exception { byte b1[] = new byte[1024]; DatagramPacket p = new DatagramPacket(b1, 512, 512); byte b2[] = new byte[20]; p.setData(b2); if (p.getOffset() != 0) { throw new Exception("setData(byte[]) didn't reset offset"); } }
13. Offset#main()
Project: jdk7u-jdk
File: Offset.java
File: Offset.java
public static void main(String args[]) throws Exception { byte b1[] = new byte[1024]; DatagramPacket p = new DatagramPacket(b1, 512, 512); byte b2[] = new byte[20]; p.setData(b2); if (p.getOffset() != 0) { throw new Exception("setData(byte[]) didn't reset offset"); } }
14. NettyUdpWithInOutUsingPlainSocketTest#sendAndReceiveUdpMessages()
Project: camel
File: NettyUdpWithInOutUsingPlainSocketTest.java
File: NettyUdpWithInOutUsingPlainSocketTest.java
private String sendAndReceiveUdpMessages(String input) throws Exception { DatagramSocket socket = new DatagramSocket(); InetAddress address = InetAddress.getByName("127.0.0.1"); // must append delimiter byte[] data = (input + "\n").getBytes(); DatagramPacket packet = new DatagramPacket(data, data.length, address, getPort()); LOG.debug("+++ Sending data +++"); socket.send(packet); Thread.sleep(1000); byte[] buf = new byte[128]; DatagramPacket receive = new DatagramPacket(buf, buf.length, address, getPort()); LOG.debug("+++ Receiving data +++"); socket.receive(receive); socket.close(); return new String(receive.getData(), 0, receive.getLength()); }
15. NettyUdpWithInOutUsingPlainSocketTest#sendAndReceiveUdpMessages()
Project: camel
File: NettyUdpWithInOutUsingPlainSocketTest.java
File: NettyUdpWithInOutUsingPlainSocketTest.java
private String sendAndReceiveUdpMessages(String input) throws Exception { DatagramSocket socket = new DatagramSocket(); InetAddress address = InetAddress.getByName("127.0.0.1"); // must append delimiter byte[] data = (input + "\n").getBytes(); DatagramPacket packet = new DatagramPacket(data, data.length, address, getPort()); LOG.debug("+++ Sending data +++"); socket.send(packet); Thread.sleep(1000); byte[] buf = new byte[128]; DatagramPacket receive = new DatagramPacket(buf, buf.length, address, getPort()); LOG.debug("+++ Receiving data +++"); socket.receive(receive); socket.close(); return new String(receive.getData(), 0, receive.getLength()); }
16. Mina2UdpWithInOutUsingPlainSocketTest#sendAndReceiveUdpMessages()
Project: camel
File: Mina2UdpWithInOutUsingPlainSocketTest.java
File: Mina2UdpWithInOutUsingPlainSocketTest.java
private String sendAndReceiveUdpMessages(String input) throws Exception { DatagramSocket socket = new DatagramSocket(); InetAddress address = InetAddress.getByName("127.0.0.1"); byte[] data = input.getBytes(); DatagramPacket packet = new DatagramPacket(data, data.length, address, getPort()); LOG.debug("+++ Sending data +++"); socket.send(packet); Thread.sleep(1000); byte[] buf = new byte[128]; DatagramPacket receive = new DatagramPacket(buf, buf.length, address, getPort()); LOG.debug("+++ Receiveing data +++"); socket.receive(receive); socket.close(); return new String(receive.getData(), 0, receive.getLength()); }
17. MinaUdpWithInOutUsingPlainSocketTest#sendAndReceiveUdpMessages()
Project: camel
File: MinaUdpWithInOutUsingPlainSocketTest.java
File: MinaUdpWithInOutUsingPlainSocketTest.java
private String sendAndReceiveUdpMessages(String input) throws Exception { DatagramSocket socket = new DatagramSocket(); InetAddress address = InetAddress.getByName("127.0.0.1"); byte[] data = input.getBytes(); DatagramPacket packet = new DatagramPacket(data, data.length, address, getPort()); LOG.debug("+++ Sending data +++"); socket.send(packet); Thread.sleep(1000); byte[] buf = new byte[128]; DatagramPacket receive = new DatagramPacket(buf, buf.length, address, getPort()); LOG.debug("+++ Receiveing data +++"); socket.receive(receive); socket.close(); return new String(receive.getData(), 0, receive.getLength()); }
18. LENonTerminateTest#mockServer()
Project: zookeeper
File: LENonTerminateTest.java
File: LENonTerminateTest.java
/** * MockServer plays the role of peer C. Respond to two requests for votes * with vote for self and then Assert.fail. */ void mockServer() throws InterruptedException, IOException { byte b[] = new byte[36]; ByteBuffer responseBuffer = ByteBuffer.wrap(b); DatagramPacket packet = new DatagramPacket(b, b.length); QuorumServer server = peers.get(Long.valueOf(2)); DatagramSocket udpSocket = new DatagramSocket(server.addr.getPort()); LOG.info("In MockServer"); mockLatch.countDown(); Vote current = new Vote(2, 1); for (int i = 0; i < 2; ++i) { udpSocket.receive(packet); responseBuffer.rewind(); LOG.info("Received " + responseBuffer.getInt() + " " + responseBuffer.getLong() + " " + responseBuffer.getLong()); LOG.info("From " + packet.getSocketAddress()); responseBuffer.clear(); // Skip the xid responseBuffer.getInt(); responseBuffer.putLong(2); responseBuffer.putLong(current.getId()); responseBuffer.putLong(current.getZxid()); packet.setData(b); udpSocket.send(packet); } }
19. UDPTransportHandlerTest#testSendData()
Project: TLS-Attacker
File: UDPTransportHandlerTest.java
File: UDPTransportHandlerTest.java
@Test public void testSendData() throws Exception { UDPTransportHandler udpTH = new UDPTransportHandler(); DatagramSocket testSocket = new DatagramSocket(); testSocket.setSoTimeout(1000); udpTH.initialize(localhost.getHostName(), testSocket.getLocalPort()); byte[] txData = new byte[8192]; RandomHelper.getRandom().nextBytes(txData); byte[] rxData = new byte[8192]; DatagramPacket rxPacket = new DatagramPacket(rxData, rxData.length, localhost, testSocket.getLocalPort()); udpTH.sendData(txData); testSocket.receive(rxPacket); assertEquals("Confirm size of the sent data", txData.length, rxPacket.getLength()); assertArrayEquals("Confirm sent data equals received data", txData, rxPacket.getData()); udpTH.closeConnection(); testSocket.close(); }
20. UDPTransportHandler#initialize()
Project: TLS-Attacker
File: UDPTransportHandler.java
File: UDPTransportHandler.java
@Override public void initialize(String remoteAddress, int remotePort) throws IOException { datagramSocket = new DatagramSocket(); datagramSocket.setSoTimeout(DEFAULT_TLS_TIMEOUT); datagramSocket.connect(InetAddress.getByName(remoteAddress), remotePort); sentPacket = new DatagramPacket(new byte[0], 0, datagramSocket.getInetAddress(), datagramSocket.getPort()); if (LOGGER.isDebugEnabled()) { StringBuilder logOut = new StringBuilder(); logOut.append("Socket bound to \""); logOut.append(datagramSocket.getLocalAddress().getCanonicalHostName()); logOut.append(":"); logOut.append(datagramSocket.getLocalPort()); logOut.append("\". Specified remote host and port: \""); logOut.append(datagramSocket.getInetAddress().getCanonicalHostName()); logOut.append(":"); logOut.append(datagramSocket.getPort()); logOut.append("\"."); LOGGER.debug(logOut.toString()); } }
21. UPNPHelper#sendMessage()
Project: ps3mediaserver
File: UPNPHelper.java
File: UPNPHelper.java
/** * Send the provided message to the socket. * * @param socket the socket * @param nt the nt * @param message the message * @throws IOException Signals that an I/O exception has occurred. */ private static void sendMessage(DatagramSocket socket, String nt, String message) throws IOException { String msg = buildMsg(nt, message); //Random rand = new Random(); // logger.trace( "Sending this SSDP packet: " + CRLF + StringUtils.replace(msg, CRLF, "<CRLF>"))); InetAddress upnpAddress = getUPNPAddress(); DatagramPacket ssdpPacket = new DatagramPacket(msg.getBytes(), msg.length(), upnpAddress, UPNP_PORT); socket.send(ssdpPacket); // XXX Why is it necessary to sleep for this random time? What would happen when random equals 0? //sleep(rand.nextInt(1800 / 2)); // XXX Why send the same packet twice? //socket.send(ssdpPacket); // XXX Why is it necessary to sleep for this random time (again)? //sleep(rand.nextInt(1800 / 2)); }
22. NetworkAvailabilityCheckPacketFilterTest#testFilter()
Project: pinpoint
File: NetworkAvailabilityCheckPacketFilterTest.java
File: NetworkAvailabilityCheckPacketFilterTest.java
@Test public void testFilter() throws Exception { SocketAddress localSocketAddress = datagramSocket.getLocalSocketAddress(); logger.debug("localSocket:{}", localSocketAddress); NetworkAvailabilityCheckPacket packet = new NetworkAvailabilityCheckPacket(); boolean skipResult = filter.filter(packet, new InetSocketAddress("localhost", datagramSocket.getLocalPort())); Assert.assertEquals(skipResult, TBaseFilter.BREAK); DatagramPacket receivePacket = new DatagramPacket(new byte[100], 100); datagramSocket.receive(receivePacket); Assert.assertEquals(receivePacket.getLength(), NetworkAvailabilityCheckPacket.DATA_OK.length); Assert.assertArrayEquals(Arrays.copyOf(receivePacket.getData(), NetworkAvailabilityCheckPacket.DATA_OK.length), NetworkAvailabilityCheckPacket.DATA_OK); }
23. UDPMasterTerminal#receiveMessage()
Project: openhab
File: UDPMasterTerminal.java
File: UDPMasterTerminal.java
// sendPackage @Override public byte[] receiveMessage() throws Exception { // 1. Prepare buffer and receive package // max size byte[] buffer = new byte[256]; DatagramPacket packet = new DatagramPacket(buffer, buffer.length); synchronized (m_Socket) { m_Socket.setSoTimeout(m_Timeout); m_Socket.receive(packet); } return buffer; }
24. LightwaveRfBindingFunctionalTest#sendCommand()
Project: openhab
File: LightwaveRfBindingFunctionalTest.java
File: LightwaveRfBindingFunctionalTest.java
private DatagramPacket sendCommand(Item item, String itemConfig, Command command) throws Exception { // Set up sockets for testing DatagramPacket sentPacket = new DatagramPacket(new byte[1024], 1024); CyclicBarrier barrier = new CyclicBarrier(2); doAnswer(waitIndefinitely()).when(mockReceiveSocket).receive(any(DatagramPacket.class)); doAnswer(waitIndefinitely()).when(mockReceiveSocket2).receive(any(DatagramPacket.class)); doAnswer(transmitAnswer(sentPacket, barrier)).when(mockTransmitSocket).send(any(DatagramPacket.class)); // Setup Item config bindingProvider.processBindingConfiguration(CONTEXT, item, itemConfig); binding.addBindingProvider(bindingProvider); // Activate the binding ready for the test binding.activateForTesting(); // Send the command binding.internalReceiveCommand(item.getName(), command); // Wait till the socket has sent the command barrier.await(1000, TimeUnit.MILLISECONDS); return sentPacket; }
25. LightwaveRFReceiverThread#receiveUDP()
Project: openhab
File: LightwaveRFReceiverThread.java
File: LightwaveRFReceiverThread.java
/** * Receive the next UDP packet on the socket * * @return * @throws IOException */ private String receiveUDP() throws IOException { String receivedMessage = ""; byte[] receiveData = new byte[1024]; DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); receiveSocket.receive(receivePacket); receivedMessage = new String(receivePacket.getData(), 0, receivePacket.getLength()); logger.debug("Message received from: " + receivePacket.getAddress() + " message:" + receivedMessage); if (localIps.contains(receivePacket.getAddress())) { logger.debug("Own Message received and will be discarded: {}", receivedMessage); return null; } return receivedMessage; }
26. SsdpDiscovery#sendDiscoveryBroacast()
Project: openhab
File: SsdpDiscovery.java
File: SsdpDiscovery.java
/** * Broadcasts a SSDP discovery message into the network to find provided * services. * * @return The Socket the answers will arrive at. * @throws UnknownHostException * @throws IOException * @throws SocketException * @throws UnsupportedEncodingException */ private MulticastSocket sendDiscoveryBroacast() throws UnknownHostException, IOException, SocketException, UnsupportedEncodingException { InetAddress multicastAddress = InetAddress.getByName("239.255.255.250"); final int port = 1900; MulticastSocket socket = new MulticastSocket(port); socket.setReuseAddress(true); socket.setSoTimeout(130000); socket.joinGroup(multicastAddress); byte[] requestMessage = DISCOVER_MESSAGE.getBytes("UTF-8"); DatagramPacket datagramPacket = new DatagramPacket(requestMessage, requestMessage.length, multicastAddress, port); socket.send(datagramPacket); return socket; }
27. DatagramLogger#main()
Project: oodt
File: DatagramLogger.java
File: DatagramLogger.java
public static void main(String[] argv) throws Throwable { if (argv.length > 0) { System.err.println("This program takes NO command line arguments."); System.err.println("Set the activity.port property to adjust the port number."); System.err.println("Set the activity.storage property to set the Storage class to use."); System.exit(1); } int port = Integer.getInteger("activity.port", VAL); String className = System.getProperty("activity.storage"); if (className == null) { System.err.println("No Storage class defined via the `activity.storage' property; exiting..."); System.exit(1); } Class storageClass = Class.forName(className); storage = (Storage) storageClass.newInstance(); DatagramSocket socket = new DatagramSocket(port); byte[] buf = new byte[INT]; DatagramPacket packet = new DatagramPacket(buf, buf.length); for (; ; ) { socket.receive(packet); byte[] received = new byte[packet.getLength()]; System.arraycopy(packet.getData(), packet.getOffset(), received, 0, packet.getLength()); new ReceiverThread(received).start(); } }
28. MockUdpSyslogServer#run()
Project: logging-log4j2
File: MockUdpSyslogServer.java
File: MockUdpSyslogServer.java
@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) { socket.receive(packet); final String str = new String(packet.getData(), 0, packet.getLength()); messageList.add(str); } } catch (final Exception ex) { if (!shutdown) { throw new RuntimeException(ex); } } }
29. SyslogWriter#flush()
Project: log4j
File: SyslogWriter.java
File: SyslogWriter.java
/** * Sends the pending data. */ public void flush() throws IOException { if (buf.length() == 0) return; // logging here can be problematic during shutdown when writing the footer // logger.debug("Writing out [{}]", buf); byte[] bytes = buf.toString().getBytes(); DatagramPacket packet = new DatagramPacket(bytes, bytes.length, address, port); ds.send(packet); // clean up for next time buf.setLength(0); }
30. LibServer#sendData()
Project: Library-Management-System-Server
File: LibServer.java
File: LibServer.java
public void sendData(byte[] data, InetAddress ipAddress, int port) { String dt = new String(data).trim(); try { dt = EncryptByteArray(data); } catch (Exception e1) { e1.printStackTrace(); } //DatagramPacket packet = new DatagramPacket(data, data.length, ipAddress, port); DatagramPacket packet = new DatagramPacket(dt.getBytes(), dt.getBytes().length, ipAddress, port); try { this.serverSocket.send(packet); } catch (IOException e) { e.printStackTrace(); } }
31. LibClient#sendData()
Project: Library-Management-System-Server
File: LibClient.java
File: LibClient.java
public void sendData(byte[] data) { String dt = new String(data).trim(); try { dt = EncryptByteArray(data); } catch (Exception e1) { e1.printStackTrace(); } DatagramPacket packet = new DatagramPacket(dt.getBytes(), dt.getBytes().length, ipAddress, 5609); try { socket.send(packet); } catch (IOException e) { e.printStackTrace(); } }
32. LibServer#sendData()
Project: Library-Management-System
File: LibServer.java
File: LibServer.java
public void sendData(byte[] data, InetAddress ipAddress, int port) { String dt = new String(data).trim(); try { dt = EncryptByteArray(data); } catch (Exception e1) { e1.printStackTrace(); } //DatagramPacket packet = new DatagramPacket(data, data.length, ipAddress, port); DatagramPacket packet = new DatagramPacket(dt.getBytes(), dt.getBytes().length, ipAddress, port); try { this.serverSocket.send(packet); } catch (IOException e) { e.printStackTrace(); } }
33. LibClient#sendData()
Project: Library-Management-System
File: LibClient.java
File: LibClient.java
public void sendData(byte[] data) { String dt = new String(data).trim(); try { dt = EncryptByteArray(data); } catch (Exception e1) { e1.printStackTrace(); } DatagramPacket packet = new DatagramPacket(dt.getBytes(), dt.getBytes().length, ipAddress, 5609); try { socket.send(packet); } catch (IOException e) { e.printStackTrace(); } }
34. BPING#run()
Project: JGroups
File: BPING.java
File: BPING.java
public void run() { final byte[] receive_buf = new byte[65535]; DatagramPacket packet = new DatagramPacket(receive_buf, receive_buf.length); DataInput inp; while (sock != null && receiver != null && Thread.currentThread().equals(receiver)) { packet.setData(receive_buf, 0, receive_buf.length); try { sock.receive(packet); inp = new ByteArrayDataInputStream(packet.getData(), packet.getOffset(), packet.getLength()); Message msg = new Message(); msg.readFrom(inp); up(new Event(Event.MSG, msg)); } catch (SocketException socketEx) { break; } catch (Throwable ex) { log.error(Util.getMessage("FailedReceivingPacketFrom"), packet.getSocketAddress(), ex); } } if (log.isTraceEnabled()) log.trace("receiver thread terminated"); }
35. DatagramChannelImpl#receiveDirectImpl()
Project: j2objc
File: DatagramChannelImpl.java
File: DatagramChannelImpl.java
private SocketAddress receiveDirectImpl(ByteBuffer target, boolean loop) throws IOException { SocketAddress retAddr = null; DatagramPacket receivePacket = new DatagramPacket(EmptyArray.BYTE, 0); int oldposition = target.position(); int received; do { received = NetworkBridge.recvfrom(false, fd, target, 0, receivePacket, isConnected()); if (receivePacket.getAddress() != null) { // copy the data of received packet if (received > 0) { target.position(oldposition + received); } retAddr = receivePacket.getSocketAddress(); break; } } while (loop); return retAddr; }
36. LogstashUdpMessagePersisterTest#testFailedPersist()
Project: incubator-streams
File: LogstashUdpMessagePersisterTest.java
File: LogstashUdpMessagePersisterTest.java
@Test public void testFailedPersist() { LogstashUdpMessagePersister persister = new LogstashUdpMessagePersister("udp://127.0.0.1:56789"); List<String> messageArray = Lists.newArrayList(); for (int x = 0; x < 10; x++) { messageArray.add("Fake_message #" + x); } persister.persistMessages(messageArray); byte[] receiveData = new byte[1024]; DatagramPacket messageDatagram = new DatagramPacket(receiveData, receiveData.length); try { socket.receive(messageDatagram); assertNotNull(messageDatagram); List<String> messages = Lists.newArrayList(Splitter.on('\n').split(new String(messageDatagram.getData()))); assertEquals(messageArray, messages.subList(0, 10)); } catch (IOException e) { LOGGER.error("Metrics Broadcast Test Failed: " + e.getMessage()); } }
37. HeroicStartupPinger#sendUDP()
Project: heroic
File: HeroicStartupPinger.java
File: HeroicStartupPinger.java
private void sendUDP(PingMessage p) throws IOException { if (ping.getPort() == -1) { throw new IllegalArgumentException("Invalid URI, port is required: " + ping); } final byte[] frame = mapper.writeValueAsBytes(p); InetSocketAddress address = new InetSocketAddress(ping.getHost(), ping.getPort()); final DatagramPacket packet = new DatagramPacket(frame, frame.length, address); try (final DatagramSocket socket = new DatagramSocket()) { socket.send(packet); } }
38. UdpTransportTest#sendUdpDatagram()
Project: graylog2-server
File: UdpTransportTest.java
File: UdpTransportTest.java
private void sendUdpDatagram(String hostname, int port, int size) throws IOException { final InetAddress address = InetAddress.getByName(hostname); final byte[] data = new byte[size]; final DatagramPacket packet = new DatagramPacket(data, data.length, address, port); DatagramSocket toSocket = null; try { toSocket = new DatagramSocket(); toSocket.send(packet); } finally { if (toSocket != null) { toSocket.close(); } } }
39. UdpSocketHandler#runLoop()
Project: fred
File: UdpSocketHandler.java
File: UdpSocketHandler.java
private void runLoop() { byte[] buf = new byte[MAX_RECEIVE_SIZE]; DatagramPacket packet = new DatagramPacket(buf, buf.length); while (_active) { try { realRun(packet); } catch (Throwable t) { System.err.println("Caught " + t); t.printStackTrace(System.err); Logger.error(this, "Caught " + t, t); } } }
40. ConnectionManager#receivePacket()
Project: DragonProxy
File: ConnectionManager.java
File: ConnectionManager.java
private boolean receivePacket() throws IOException { DatagramPacket packet = socket.readPacket(); if (packet == null) { return false; } int len = packet.getLength(); if (len > 0) { SocketAddress source = packet.getSocketAddress(); receiveBytes += len; Packet pkt = getPacketFromPool(packet.getData()[0]); if (pkt != null) { pkt.buffer = packet.getData(); connection.handlePacket(pkt); return true; } else if (packet.getData() != null) { streamRaw(source, packet.getData()); return true; } else { //getLogger().notice("Dropped packet: "+ Arrays.toString(packet.getData())); return false; } } return false; }
41. TestNtpPacket#testEquals()
Project: commons-net
File: TestNtpPacket.java
File: TestNtpPacket.java
@Test public void testEquals() { NtpV3Packet message1 = new NtpV3Impl(); DatagramPacket dp = new DatagramPacket(ntpPacket, ntpPacket.length); message1.setDatagramPacket(dp); NtpV3Packet message2 = new NtpV3Impl(); message2.setDatagramPacket(dp); Assert.assertEquals("hashCode", message1.hashCode(), message2.hashCode()); Assert.assertEquals(message1, message2); // now change the packet to force equals() => false message2.setMode(2); Assert.assertTrue(message1.getMode() != message2.getMode()); Assert.assertFalse(message1.equals(message2)); NtpV3Packet message3 = null; Assert.assertFalse(message1.equals(message3)); }
42. SimpleNTPServer#run()
Project: commons-net
File: SimpleNTPServer.java
File: SimpleNTPServer.java
/** * main thread to service client connections. */ @Override public void run() { running = true; byte buffer[] = new byte[48]; final DatagramPacket request = new DatagramPacket(buffer, buffer.length); do { try { socket.receive(request); final long rcvTime = System.currentTimeMillis(); handlePacket(request, rcvTime); } catch (IOException e) { if (running) { e.printStackTrace(); } } } while (running); }
43. LateralUDPReceiver#waitForMessage()
Project: commons-jcs
File: LateralUDPReceiver.java
File: LateralUDPReceiver.java
/** * Highly unreliable. If it is processing one message while another comes in * , the second message is lost. This is for low concurency peppering. */ public Object waitForMessage() throws IOException { final DatagramPacket packet = new DatagramPacket(m_buffer, m_buffer.length); Object obj = null; try { m_socket.receive(packet); final ByteArrayInputStream byteStream = new ByteArrayInputStream(m_buffer, 0, packet.getLength()); final ObjectInputStream objectStream = new ObjectInputStreamClassLoaderAware(byteStream, null); obj = objectStream.readObject(); } catch (Exception e) { log.error(e); } return obj; }
44. Service#send()
Project: bnd
File: Service.java
File: Service.java
private String send(int port, String m) throws Exception { if (port == -1) return "Invalid port"; byte data[] = m.getBytes("UTF-8"); DatagramPacket p = new DatagramPacket(data, 0, data.length, InetAddress.getLoopbackAddress(), port); DatagramSocket dsocket = new DatagramSocket(); dsocket.setReceiveBufferSize(5000); dsocket.setSoTimeout(5000); try { dsocket.send(p); byte[] buffer = new byte[BUFFER_SIZE]; DatagramPacket dp = new DatagramPacket(buffer, BUFFER_SIZE); dsocket.receive(dp); return new String(dp.getData(), dp.getOffset(), dp.getLength(), "UTF-8"); } catch (SocketTimeoutException stoe) { return "Timed out"; } finally { dsocket.close(); } }
45. UDPTransport#send()
Project: bc-java
File: UDPTransport.java
File: UDPTransport.java
public void send(byte[] buf, int off, int len) throws IOException { if (len > getSendLimit()) { /* * RFC 4347 4.1.1. "If the application attempts to send a record larger than the MTU, * the DTLS implementation SHOULD generate an error, thus avoiding sending a packet * which will be fragmented." */ throw new TlsFatalAlert(AlertDescription.internal_error); } DatagramPacket packet = new DatagramPacket(buf, off, len); socket.send(packet); }
46. UDPTransport#send()
Project: bc-java
File: UDPTransport.java
File: UDPTransport.java
public void send(byte[] buf, int off, int len) throws IOException { if (len > getSendLimit()) { /* * RFC 4347 4.1.1. "If the application attempts to send a record larger than the MTU, * the DTLS implementation SHOULD generate an error, thus avoiding sending a packet * which will be fragmented." */ throw new TlsFatalAlert(AlertDescription.internal_error); } DatagramPacket packet = new DatagramPacket(buf, off, len); socket.send(packet); }
47. MulticastReceiver#main()
Project: axis2-java
File: MulticastReceiver.java
File: MulticastReceiver.java
public static void main(String[] args) throws Exception { MulticastSocket msocket = new MulticastSocket(port); InetAddress group = InetAddress.getByName(ip); msocket.joinGroup(group); byte[] inbuf = new byte[1024]; DatagramPacket packet = new DatagramPacket(inbuf, inbuf.length); // Wait for packet msocket.receive(packet); // Data is now in inbuf int numBytesReceived = packet.getLength(); System.out.println("Recd: " + new String(inbuf, 0, numBytesReceived)); }
48. TestBufferingWrappers#resendAfterStop()
Project: HiTune
File: TestBufferingWrappers.java
File: TestBufferingWrappers.java
//start a wrapped FileAdaptor. Pushes a chunk. Stop it and restart. //chunk hasn't been acked, so should get pushed again. //we delete the file and also change the data type each time through the loop //to make sure we get the cached chunk. public void resendAfterStop(String adaptor) throws IOException, ChukwaAgent.AlreadyRunningException, InterruptedException { ChukwaAgent agent = new ChukwaAgent(conf); String ADAPTORID = "adaptor_test" + System.currentTimeMillis(); String STR = "test data"; int PORTNO = 9878; DatagramSocket send = new DatagramSocket(); byte[] buf = STR.getBytes(); DatagramPacket p = new DatagramPacket(buf, buf.length); p.setSocketAddress(new InetSocketAddress("127.0.0.1", PORTNO)); assertEquals(0, agent.adaptorCount()); String name = agent.processAddCommand("add " + ADAPTORID + " = " + adaptor + " UDPAdaptor raw " + PORTNO + " 0"); assertEquals(name, ADAPTORID); Thread.sleep(500); send.send(p); for (int i = 0; i < 5; ++i) { Chunk c = chunks.waitForAChunk(5000); System.out.println("received " + i); assertNotNull(c); String dat = new String(c.getData()); assertTrue(dat.equals(STR)); assertTrue(c.getDataType().equals("raw")); assertEquals(c.getSeqID(), STR.length()); agent.stopAdaptor(name, AdaptorShutdownPolicy.RESTARTING); //for socket to deregister Thread.sleep(500); name = agent.processAddCommand("add " + ADAPTORID + " = " + adaptor + " UDPAdaptor raw " + PORTNO + " 0"); assertEquals(name, ADAPTORID); } Chunk c = chunks.waitForAChunk(5000); Thread.sleep(500); buf = "different data".getBytes(); p = new DatagramPacket(buf, buf.length); p.setSocketAddress(new InetSocketAddress("127.0.0.1", PORTNO)); send.send(p); c = chunks.waitForAChunk(5000); assertNotNull(c); assertEquals(buf.length + STR.length(), c.getSeqID()); agent.stopAdaptor(name, true); assertEquals(0, agent.adaptorCount()); //before re-binding Thread.sleep(500); agent.shutdown(); }
49. NTPUDPClient#getTime()
Project: commons-net
File: NTPUDPClient.java
File: NTPUDPClient.java
/*** * Retrieves the time information from the specified server and port and * returns it. The time is the number of miliiseconds since * 00:00 (midnight) 1 January 1900 UTC, as specified by RFC 1305. * This method reads the raw NTP packet and constructs a <i>TimeInfo</i> * object that allows access to all the fields of the NTP message header. * <p> * @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 TimeInfo getTime(InetAddress host, int port) throws IOException { // if not connected then open to next available UDP port if (!isOpen()) { open(); } NtpV3Packet message = new NtpV3Impl(); message.setMode(NtpV3Packet.MODE_CLIENT); message.setVersion(_version); DatagramPacket sendPacket = message.getDatagramPacket(); sendPacket.setAddress(host); sendPacket.setPort(port); NtpV3Packet recMessage = new NtpV3Impl(); DatagramPacket receivePacket = recMessage.getDatagramPacket(); /* * Must minimize the time between getting the current time, * timestamping the packet, and sending it out which * introduces an error in the delay time. * No extraneous logging and initializations here !!! */ TimeStamp now = TimeStamp.getCurrentTime(); // Note that if you do not set the transmit time field then originating time // in server response is all 0's which is "Thu Feb 07 01:28:16 EST 2036". message.setTransmitTime(now); _socket_.send(sendPacket); _socket_.receive(receivePacket); long returnTime = System.currentTimeMillis(); // create TimeInfo message container but don't pre-compute the details yet TimeInfo info = new TimeInfo(recMessage, returnTime, false); return info; }
50. DataUdpAgent#sendList()
Project: scouter
File: DataUdpAgent.java
File: DataUdpAgent.java
private void sendList(int bufferCount, byte[] buffer) throws IOException { DataOutputX outter = new DataOutputX(); outter.write(NetCafe.CAFE_N); outter.writeShort(bufferCount); outter.write(buffer); byte[] buff = outter.toByteArray(); DatagramPacket packet = new DatagramPacket(buff, buff.length); packet.setAddress(server_host); packet.setPort(server_port); datagram.send(packet); }
51. UDPBroadcastThreadTest#sendQueryTo()
Project: Jenkins2
File: UDPBroadcastThreadTest.java
File: UDPBroadcastThreadTest.java
private void sendQueryTo(DatagramSocket s, InetAddress dest) throws IOException { DatagramPacket p = new DatagramPacket(new byte[1024], 1024); p.setAddress(dest); p.setPort(UDPBroadcastThread.PORT); s.send(p); }
52. UDPBroadcastThreadTest#sendQueryTo()
Project: hudson
File: UDPBroadcastThreadTest.java
File: UDPBroadcastThreadTest.java
private void sendQueryTo(DatagramSocket s, InetAddress dest) throws IOException { DatagramPacket p = new DatagramPacket(new byte[1024], 1024); p.setAddress(dest); p.setPort(UDPBroadcastThread.PORT); s.send(p); }
53. UdpSocketHandler#sendPacket()
Project: fred
File: UdpSocketHandler.java
File: UdpSocketHandler.java
/** * Send a block of encoded bytes to a peer. This is called by * send, and by IncomingPacketFilter.processOutgoing(..). * @param blockToSend The data block to send. * @param destination The peer to send it to. */ @Override public void sendPacket(byte[] blockToSend, Peer destination, boolean allowLocalAddresses) throws LocalAddressException { assert (blockToSend != null); if (!_active) { Logger.error(this, "Trying to send packet but no longer active"); // packets after shutdown. return; } // there should be no DNS needed here, but go ahead if we can, but complain doing it if (destination.getAddress(false, allowLocalAddresses) == null) { Logger.error(this, "Tried sending to destination without pre-looked up IP address(needs a real Peer.getHostname()): null:" + destination.getPort(), new Exception("error")); if (destination.getAddress(true, allowLocalAddresses) == null) { Logger.error(this, "Tried sending to bad destination address: null:" + destination.getPort(), new Exception("error")); return; } } if (_dropProbability > 0) { if (dropRandom.nextInt() % _dropProbability == 0) { Logger.normal(this, "DROPPED: " + _sock.getLocalPort() + " -> " + destination.getPort()); return; } } InetAddress address = destination.getAddress(false, allowLocalAddresses); assert (address != null); int port = destination.getPort(); DatagramPacket packet = new DatagramPacket(blockToSend, blockToSend.length); packet.setAddress(address); packet.setPort(port); try { _sock.send(packet); tracker.sentPacketTo(destination); boolean isLocal = (!IPUtil.isValidAddress(address, false)) && (IPUtil.isValidAddress(address, true)); collector.addInfo(address, port, 0, getHeadersLength(address) + blockToSend.length, isLocal); if (logMINOR) Logger.minor(this, "Sent packet length " + blockToSend.length + " to " + address + ':' + port); } catch (IOException e) { if (packet.getAddress() instanceof Inet6Address) { Logger.normal(this, "Error while sending packet to IPv6 address: " + destination + ": " + e); } else { Logger.error(this, "Error while sending packet to " + destination + ": " + e, e); } } }
54. NtpClient#getOffset()
Project: railo
File: NtpClient.java
File: NtpClient.java
/** * returns the offest from the ntp server to local system * @return * @throws IOException */ public long getOffset() throws IOException { /// Send request DatagramSocket socket = new DatagramSocket(); socket.setSoTimeout(10000); InetAddress address = InetAddress.getByName(serverName); byte[] buf = new NtpMessage().toByteArray(); DatagramPacket packet = new DatagramPacket(buf, buf.length, address, 123); // Set the transmit timestamp *just* before sending the packet NtpMessage.encodeTimestamp(packet.getData(), 40, (System.currentTimeMillis() / 1000.0) + 2208988800.0); socket.send(packet); // Get response packet = new DatagramPacket(buf, buf.length); socket.receive(packet); // Immediately record the incoming timestamp double destinationTimestamp = (System.currentTimeMillis() / 1000.0) + 2208988800.0; // Process response NtpMessage msg = new NtpMessage(packet.getData()); //double roundTripDelay = (destinationTimestamp-msg.originateTimestamp) - (msg.receiveTimestamp-msg.transmitTimestamp); double localClockOffset = ((msg.receiveTimestamp - msg.originateTimestamp) + (msg.transmitTimestamp - destinationTimestamp)) / 2; return (long) (localClockOffset * 1000); }
55. PacketUtilsTest#testSliceData3()
Project: pinpoint
File: PacketUtilsTest.java
File: PacketUtilsTest.java
@Test public void testSliceData3() throws Exception { DatagramPacket packet = createPacket(10); Arrays.fill(packet.getData(), 1, 8, (byte) 'a'); packet.setLength(4); byte[] bytes1 = PacketUtils.sliceData(packet, 0); Assert.assertArrayEquals(bytes1, Arrays.copyOf(packet.getData(), 4)); }
56. PacketUtilsTest#testSliceData1()
Project: pinpoint
File: PacketUtilsTest.java
File: PacketUtilsTest.java
@Test public void testSliceData1() throws Exception { DatagramPacket packet = createPacket(10); packet.setLength(5); byte[] bytes1 = PacketUtils.sliceData(packet, 0); Assert.assertEquals(bytes1.length, 5); }
57. UdpSocketTest#testDatagramMaxSend()
Project: pinpoint
File: UdpSocketTest.java
File: UdpSocketTest.java
@Test public void testDatagramMaxSend() throws IOException { DatagramPacket packet1 = newDatagramPacket(AcceptedSize); sender.send(packet1); DatagramPacket r1 = newDatagramPacket(AcceptedSize); receiver.receive(r1); Assert.assertEquals(r1.getLength(), AcceptedSize); }
58. DatagramPacketFactoryTest#testBeforeReturn()
Project: pinpoint
File: DatagramPacketFactoryTest.java
File: DatagramPacketFactoryTest.java
@Test public void testBeforeReturn() throws Exception { int bufferLength = 10; DatagramPacketFactory factory = new DatagramPacketFactory(bufferLength); DatagramPacket packet = factory.create(); packet.setLength(1); factory.beforeReturn(packet); Assert.assertEquals(bufferLength, packet.getLength()); }
59. PortUnreachable#execute()
Project: openjdk
File: PortUnreachable.java
File: PortUnreachable.java
void execute() throws Exception { // pick a port for the server DatagramSocket sock2 = new DatagramSocket(); serverPort = sock2.getLocalPort(); // send a burst of packets to the unbound port - we should get back // icmp port unreachable messages // InetAddress addr = InetAddress.getLocalHost(); byte b[] = "Hello me".getBytes(); DatagramPacket packet = new DatagramPacket(b, b.length, addr, serverPort); //close just before sending sock2.close(); for (int i = 0; i < 100; i++) clientSock.send(packet); serverSend(); // try to receive b = new byte[25]; packet = new DatagramPacket(b, b.length, addr, serverPort); clientSock.setSoTimeout(10000); clientSock.receive(packet); System.out.println("client received data packet " + new String(packet.getData())); // done clientSock.close(); }
60. BioUdpBenchmarkClient#start()
Project: mina
File: BioUdpBenchmarkClient.java
File: BioUdpBenchmarkClient.java
/** * {@inheritDoc} */ public void start(int port, final CountDownLatch counter, final byte[] data) throws IOException { InetAddress serverAddress = InetAddress.getLocalHost(); byte[] buffer = new byte[65507]; sender = new DatagramSocket(port + 1); DatagramPacket pduSent = new DatagramPacket(data, data.length, serverAddress, port); DatagramPacket pduReceived = new DatagramPacket(buffer, data.length); sender.send(pduSent); boolean done = false; while (!done) { try { sender.receive(pduReceived); for (int i = 0; i < pduReceived.getLength(); ++i) { counter.countDown(); if (counter.getCount() > 0) { sender.send(pduSent); break; } else { done = true; } } } catch (IOException ioe) { } } sender.close(); }
61. TCollectorUDPWriter#sendOutput()
Project: jmxtrans
File: TCollectorUDPWriter.java
File: TCollectorUDPWriter.java
/** * Send a single metric to TCollector. * * @param metricLine - the line containing the metric name, value, and tags for a single metric; excludes the * "put" keyword expected by OpenTSDB and the trailing newline character. */ @Override protected void sendOutput(String metricLine) throws IOException { DatagramPacket packet; byte[] data; data = metricLine.getBytes("UTF-8"); packet = new DatagramPacket(data, 0, data.length, this.address); this.dgSocket.send(packet); }
62. TestNtpPacket#testCreate()
Project: commons-net
File: TestNtpPacket.java
File: TestNtpPacket.java
@Test public void testCreate() { NtpV3Packet message = new NtpV3Impl(); // byte 0 [bit numbers 7-6] message.setLeapIndicator(0); // byte 0 [bit numbers 5-4] message.setVersion(NtpV3Packet.VERSION_3); // byte 0 [bit numbers 3-0] message.setMode(4); // byte 1 message.setStratum(3); // byte 2 message.setPoll(4); // byte 3 message.setPrecision(-17); // bytes 4-7 message.setRootDelay(100); // bytes 8-11 message.setRootDispersion(3382); // byte 12-15 message.setReferenceId(0x81531472); message.setReferenceTime(new TimeStamp(0xd552447fec1d6000L)); message.setOriginateTimeStamp(new TimeStamp(0xd5524718ac49ba5eL)); message.setReceiveTimeStamp(new TimeStamp(0xd55247194b6d9000L)); message.setTransmitTime(new TimeStamp(0xd55247194b797000L)); Assert.assertEquals(-17, message.getPrecision()); Assert.assertEquals(4, message.getPoll()); Assert.assertEquals(100, message.getRootDelay()); Assert.assertEquals(3382, message.getRootDispersion()); Assert.assertEquals(0x81531472, message.getReferenceId()); Assert.assertNotNull(message.getReferenceTimeStamp()); Assert.assertEquals("NTP", message.getType()); Assert.assertEquals("Server", message.getModeName()); Assert.assertEquals("129.83.20.114", message.getReferenceIdString()); Assert.assertEquals(51, message.getRootDispersionInMillis()); Assert.assertEquals(message.getRootDelay() / 65.536, message.getRootDelayInMillisDouble(), 1e-13); // this creates a new datagram DatagramPacket dp = message.getDatagramPacket(); Assert.assertNotNull(dp); // fixed 48-byte length Assert.assertEquals(48, dp.getLength()); NtpV3Packet message2 = new NtpV3Impl(); DatagramPacket dp2 = new DatagramPacket(ntpPacket, ntpPacket.length); message2.setDatagramPacket(dp2); Assert.assertEquals(message2, message); Assert.assertEquals(message2.hashCode(), message.hashCode()); Assert.assertEquals(message2.toString(), message.toString()); }
63. TFTP#receive()
Project: commons-net
File: TFTP.java
File: TFTP.java
/*** * Receives a TFTPPacket. * * @return The TFTPPacket received. * @throws InterruptedIOException If a socket timeout occurs. The * Java documentation claims an InterruptedIOException is thrown * on a DatagramSocket timeout, but in practice we find a * SocketException is thrown. You should catch both to be safe. * @throws SocketException If a socket timeout occurs. The * Java documentation claims an InterruptedIOException is thrown * on a DatagramSocket timeout, but in practice we find a * SocketException is thrown. You should catch both to be safe. * @throws IOException If some other I/O error occurs. * @throws TFTPPacketException If an invalid TFTP packet is received. ***/ public final TFTPPacket receive() throws IOException, InterruptedIOException, SocketException, TFTPPacketException { DatagramPacket packet; packet = new DatagramPacket(new byte[PACKET_SIZE], PACKET_SIZE); _socket_.receive(packet); return TFTPPacket.newTFTPPacket(packet); }
64. TFTP#beginBufferedOps()
Project: commons-net
File: TFTP.java
File: TFTP.java
/*** * Initializes the internal buffers. Buffers are used by * {@link #bufferedSend bufferedSend() } and * {@link #bufferedReceive bufferedReceive() }. This * method must be called before calling either one of those two * methods. When you finish using buffered operations, you must * call {@link #endBufferedOps endBufferedOps() }. ***/ public final void beginBufferedOps() { __receiveBuffer = new byte[PACKET_SIZE]; __receiveDatagram = new DatagramPacket(__receiveBuffer, __receiveBuffer.length); _sendBuffer = new byte[PACKET_SIZE]; __sendDatagram = new DatagramPacket(_sendBuffer, _sendBuffer.length); }
65. TFTP#discardPackets()
Project: commons-net
File: TFTP.java
File: TFTP.java
/*** * This method synchronizes a connection by discarding all packets that * may be in the local socket buffer. This method need only be called * when you implement your own TFTP client or server. * * @throws IOException if an I/O error occurs. ***/ public final void discardPackets() throws IOException { int to; DatagramPacket datagram; datagram = new DatagramPacket(new byte[PACKET_SIZE], PACKET_SIZE); to = getSoTimeout(); setSoTimeout(1); try { while (true) { _socket_.receive(datagram); } } catch (SocketException e) { } catch (InterruptedIOException e) { } setSoTimeout(to); }
66. UDPTransport#receive()
Project: bc-java
File: UDPTransport.java
File: UDPTransport.java
public int receive(byte[] buf, int off, int len, int waitMillis) throws IOException { socket.setSoTimeout(waitMillis); DatagramPacket packet = new DatagramPacket(buf, off, len); socket.receive(packet); return packet.getLength(); }
67. UDPTransport#receive()
Project: bc-java
File: UDPTransport.java
File: UDPTransport.java
public int receive(byte[] buf, int off, int len, int waitMillis) throws IOException { socket.setSoTimeout(waitMillis); DatagramPacket packet = new DatagramPacket(buf, off, len); socket.receive(packet); return packet.getLength(); }
68. OnvifService#broadcastProbeMessage()
Project: WebService
File: OnvifService.java
File: OnvifService.java
private void broadcastProbeMessage(InetAddress inetAddress) { final String uuid = UUID.randomUUID().toString(); final String probe = WS_DISCOVERY_PROBE_MESSAGE.replaceAll("<wsa:MessageID>urn:uuid:.*</wsa:MessageID>", "<wsa:MessageID>urn:uuid:" + uuid + "</wsa:MessageID>"); final int port = random.nextInt(20000) + 40000; Dbug.i(tag, "UUID=" + uuid + ", port=" + port); if (udpSocket != null) { udpSocket.close(); } try { udpSocket = new DatagramSocket(port, inetAddress); } catch (SocketException e) { e.printStackTrace(); } if (udpSocket == null) { Log.e(tag, "udpSocket is null"); return; } byte[] buffer = new byte[4096]; final DatagramPacket packet = new DatagramPacket(buffer, buffer.length); try { udpSocket.setSoTimeout(3000); } catch (SocketException e) { e.printStackTrace(); } if (inetAddress instanceof Inet4Address) { //Log.w(tag, "probe===\n" + new String(probe.getBytes())); try { udpSocket.send(new DatagramPacket(probe.getBytes(), probe.length(), InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv4), WS_DISCOVERY_PORT)); } catch (IOException e) { e.printStackTrace(); } } long start = System.currentTimeMillis(); long currentTime = 0; do { try { Log.i(tag, "receive wait.....current time=" + currentTime); udpSocket.receive(packet); } catch (IOException e) { Subscription subscription = Observable.create(new Observable.OnSubscribe<Void>() { @Override public void call(Subscriber<? super Void> subscriber) { subscriber.onNext(null); } }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Void>() { @Override public void call(Void aVoid) { if (mOnProbeListener != null) { mOnProbeListener.onFailure("Socket timeout exception."); } } }); if (!subscription.isUnsubscribed()) { subscription.unsubscribe(); } e.printStackTrace(); } //final Collection<String> collection = parseSoapResponseForUrls(Arrays.copyOf(packet.getData(), packet.getLength())); //byte[] data = Arrays.copyOf(packet.getData(), packet.getLength()); Log.i(tag, "packet.getData size===" + packet.getData().length + ", packet =" + packet.getLength()); if (packet.getLength() > 0) { String receiveData = new String(packet.getData()).trim(); if (TextUtils.isEmpty(receiveData)) { try { udpSocket.send(new DatagramPacket(probe.getBytes(), probe.length(), InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv4), WS_DISCOVERY_PORT)); } catch (IOException e) { e.printStackTrace(); } } else { //Log.e(tag, "Receive data===\n" + receiveData); //mServiceUrl = parseDeviceUrlFromXML(new ByteArrayInputStream(receiveData.getBytes())); parseProbeMatch(receiveData); break; } } currentTime = (System.currentTimeMillis() - start); } while (currentTime < 1000); Log.i(tag, "over...........currentTime=" + currentTime); udpSocket.close(); }
69. UDPTransportHandlerTest#testFetchData()
Project: TLS-Attacker
File: UDPTransportHandlerTest.java
File: UDPTransportHandlerTest.java
@Test public void testFetchData() throws Exception { UDPTransportHandler udpTH = new UDPTransportHandler(); DatagramSocket testSocket = new DatagramSocket(); udpTH.initialize(localhost.getHostName(), testSocket.getLocalPort()); testSocket.connect(localhost, udpTH.getLocalPort()); udpTH.setTlsTimeout(1); byte[] allSentData = new byte[0]; byte[] allReceivedData = new byte[0]; byte[] txData; byte[] rxData; DatagramPacket txPacket; int numTestPackets = 100; for (int i = 0; i < numTestPackets; i++) { txData = new byte[RandomHelper.getRandom().nextInt(16383) + 1]; RandomHelper.getRandom().nextBytes(txData); txPacket = new DatagramPacket(txData, txData.length, localhost, udpTH.getLocalPort()); testSocket.send(txPacket); allSentData = ArrayConverter.concatenate(allSentData, txData); rxData = udpTH.fetchData(); allReceivedData = ArrayConverter.concatenate(allReceivedData, rxData); } assertEquals("Confirm size of the received data", allSentData.length, allReceivedData.length); assertArrayEquals("Confirm received data equals sent data", allSentData, allReceivedData); udpTH.closeConnection(); testSocket.close(); }
70. ImageTransmitter#start()
Project: Smack
File: ImageTransmitter.java
File: ImageTransmitter.java
public void start() { byte[] buf = new byte[1024]; final DatagramPacket p = new DatagramPacket(buf, 1024); int keyframe = 0; while (on) { if (transmit) { BufferedImage capture = robot.createScreenCapture(area); QuantizeFilter filter = new QuantizeFilter(); capture = filter.filter(capture, null); long trace = System.currentTimeMillis(); if (++keyframe > KEYFRAME) { keyframe = 0; } LOGGER.fine("KEYFRAME:" + keyframe); for (int i = 0; i < maxI; i++) { for (int j = 0; j < maxJ; j++) { final BufferedImage bufferedImage = capture.getSubimage(i * tileWidth, j * tileWidth, tileWidth, tileWidth); int[] pixels = new int[tileWidth * tileWidth]; PixelGrabber pg = new PixelGrabber(bufferedImage, 0, 0, tileWidth, tileWidth, pixels, 0, tileWidth); try { if (pg.grabPixels()) { if (keyframe == KEYFRAME || !Arrays.equals(tiles[i][j], pixels)) { ByteArrayOutputStream baos = encoder.encode(bufferedImage); if (baos != null) { try { Thread.sleep(1); baos.write(i); baos.write(j); byte[] bytesOut = baos.toByteArray(); if (bytesOut.length > 1000) LOGGER.severe("Bytes out > 1000. Equals " + bytesOut.length); p.setData(bytesOut); p.setAddress(remoteHost); p.setPort(remotePort); try { socket.send(p); } catch (IOException e) { LOGGER.log(Level.WARNING, "exception", e); } tiles[i][j] = pixels; } catch (Exception e) { } } } } } catch (InterruptedException e) { LOGGER.log(Level.WARNING, "exception", e); } } } trace = (System.currentTimeMillis() - trace); LOGGER.fine("Loop Time:" + trace); if (trace < 500) { try { Thread.sleep(500 - trace); } catch (InterruptedException e) { LOGGER.log(Level.WARNING, "exception", e); } } } } }
71. OutgoingMulticastRequest#marshal()
Project: river
File: OutgoingMulticastRequest.java
File: OutgoingMulticastRequest.java
/** * Using the given maximum packet size, marshal a multicast request * into one or more datagram packets. These packets are guaranteed * to contain, between them, all of the groups in which the requestor * is interested. However, the set of ServiceIDs from which the * requestor has heard may be incomplete. * <p> * The datagram packets returned will have been initialized for * sending to the appropriate multicast address and UDP port. * * @param responsePort the port to which respondents should * connect in order to start unicast discovery * @param groups the set of groups in which the requestor is * interested * @param heard the set of ServiceIDs from which the requestor has * already heard * @param maxPacketSize the maximum size to allow for an outgoing packet * * @return an array of datagram packets, which will always * contains at least one member * * @exception IOException an error occurred during marshalling * * @exception IllegalArgumentException when the value of the * <code>maxPacketSize</code> argument * is less than the default packet * size maximum; or when the number * and length of the group names to * marshal, relative to the value of * the <code>maxPacketSize</code> * argument, is too large. */ public static DatagramPacket[] marshal(int responsePort, String[] groups, ServiceID[] heard, int maxPacketSize) throws IOException { if (maxPacketSize < minMaxPacketSize) { throw new IllegalArgumentException("maxPacketSize (" + maxPacketSize + ") is " + "less than minMaxPacketSize (" + minMaxPacketSize + ")"); } //endif // Marshal the fixed header stuff. byte[] marshaledHeader; { ByteArrayOutputStream hbs = new ByteArrayOutputStream(); DataOutputStream hos = new DataOutputStream(hbs); // Write out the relatively fixed stuff first. hos.writeInt(protocolVersion); hos.writeInt(responsePort); marshaledHeader = hbs.toByteArray(); } // Marshal all group names, and find the length of the longest // marshaled representation as we go. byte[][] marshaledGroups = new byte[groups.length][]; // Length of the longest group. int longestGroup = -1; for (int i = 0; i < groups.length; i++) { ByteArrayOutputStream gbs = new ByteArrayOutputStream(); DataOutputStream gos = new DataOutputStream(gbs); gos.writeUTF(groups[i]); gos.flush(); marshaledGroups[i] = gbs.toByteArray(); if (marshaledHeader.length + 4 + /* assume no service IDs heard */ 4 + /* group count */ marshaledGroups[i].length > maxPacketSize) throw new IllegalArgumentException("group name marshals too " + "large (" + marshaledGroups[i].length + " bytes)"); if (marshaledGroups[i].length > longestGroup) longestGroup = marshaledGroups[i].length; } // Marshal the set of service IDs we've heard from. We have // to make sure that we can fit at least one group name into a // request, so if we have heard from too many lookup services, // we have to truncate this set. This is messy. byte[] marshaledHeard; { int prevTotal = 0; int total = 0; int count; ByteArrayOutputStream dbs = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(dbs); // have one too many. for (count = 0; count < heard.length; count++) { heard[count].writeBytes(dos); prevTotal = total; total = dbs.size(); // format here. This can't be avoided. if (marshaledHeader.length + 4 + /* group count */ longestGroup + 4 + /* heard count */ total > maxPacketSize) break; } dos.flush(); dbs.flush(); byte[] tmp = dbs.toByteArray(); ByteArrayOutputStream hbs = new ByteArrayOutputStream(); DataOutputStream hos = new DataOutputStream(hbs); hos.writeInt(count); hos.write(tmp, 0, count == heard.length ? total : prevTotal); hos.flush(); marshaledHeard = hbs.toByteArray(); } // We now know the size of the header and the set of marshaled // service IDs. Fill in the requests using the groups. // Build up a collection of requests. Collection reqs = new Vector(); InetAddress addr = Constants.getRequestAddress(); if (groups.length == 0) { ByteArrayOutputStream bs = new ByteArrayOutputStream(maxPacketSize); DataOutputStream os = new DataOutputStream(bs); os.write(marshaledHeader); os.write(marshaledHeard); // no groups to write os.writeInt(0); os.flush(); byte[] payload = bs.toByteArray(); reqs.add(new DatagramPacket(payload, payload.length, addr, Constants.discoveryPort)); } else { for (int curr = 0; curr < marshaledGroups.length; ) { ByteArrayOutputStream bs = new ByteArrayOutputStream(maxPacketSize); DataOutputStream os = new DataOutputStream(bs); os.write(marshaledHeader); os.write(marshaledHeard); os.flush(); int bytes = bs.size() + 4; int last = curr; while (last < marshaledGroups.length && bytes + marshaledGroups[last].length <= maxPacketSize) { bytes += marshaledGroups[last].length; last += 1; } os.writeInt(last - curr); while (curr < last) { os.write(marshaledGroups[curr++]); } os.flush(); byte[] payload = bs.toByteArray(); reqs.add(new DatagramPacket(payload, payload.length, addr, Constants.discoveryPort)); } } Iterator iter = reqs.iterator(); DatagramPacket[] ary = new DatagramPacket[reqs.size()]; for (int i = 0; iter.hasNext(); i++) { ary[i] = (DatagramPacket) iter.next(); } return ary; }
72. OutgoingMulticastAnnouncement#marshal()
Project: river
File: OutgoingMulticastAnnouncement.java
File: OutgoingMulticastAnnouncement.java
/** * Marshal a multicast announcement into one or more datagram * packets. These packets are guaranteed to contain, between * them, all of the groups of which the to-be-announced lookup * service is a member. <p> * * The datagram packets returned will have been initialized for * sending to the appropriate multicast address and UDP port. * * @param id the ServiceID we are announcing * @param loc a LookupLocator that will allow unicast discovery of * the lookup service we are announcing * @param groups the groups of which the announced lookup service * is a member * @return an array of datagram packets, which will always contain * at least one member * @exception IOException a problem occurred during marshaling */ public static DatagramPacket[] marshal(ServiceID id, LookupLocator loc, String[] groups) throws IOException { if (maxPacketSize < minMaxPacketSize) throw new RuntimeException("value of net.jini.discovery.mtu property is less than " + minMaxPacketSize); // Marshal the fixed header stuff. byte[] marshaledHeader; { ByteArrayOutputStream hbs = new ByteArrayOutputStream(); DataOutputStream hos = new DataOutputStream(hbs); // Write out the relatively fixed stuff first. hos.writeInt(protocolVersion); hos.writeUTF(loc.getHost()); hos.writeInt(loc.getPort()); id.writeBytes(hos); marshaledHeader = hbs.toByteArray(); } if (marshaledHeader.length > maxPacketSize) throw new IllegalArgumentException("host name marshals too large"); byte[][] marshaledGroups = new byte[groups.length][]; // Length of the longest group. int longestGroup = -1; for (int i = 0; i < groups.length; i++) { ByteArrayOutputStream gbs = new ByteArrayOutputStream(); DataOutputStream gos = new DataOutputStream(gbs); gos.writeUTF(groups[i]); gos.flush(); marshaledGroups[i] = gbs.toByteArray(); if (marshaledHeader.length + 4 + /* assume no service IDs heard */ 4 + /* group count */ marshaledGroups[i].length > maxPacketSize) throw new IllegalArgumentException("group name marshals too large (" + marshaledGroups[i].length + " bytes)"); if (marshaledGroups[i].length > longestGroup) longestGroup = marshaledGroups[i].length; } // Build up a collection of requests. Collection reqs = new Vector(); { InetAddress addr = Constants.getAnnouncementAddress(); if (groups.length == 0) { ByteArrayOutputStream bs = new ByteArrayOutputStream(maxPacketSize); DataOutputStream os = new DataOutputStream(bs); os.write(marshaledHeader); os.writeInt(0); byte[] payload = bs.toByteArray(); reqs.add(new DatagramPacket(payload, payload.length, addr, Constants.discoveryPort)); } else { for (int curr = 0; curr < marshaledGroups.length; ) { ByteArrayOutputStream bs = new ByteArrayOutputStream(maxPacketSize); DataOutputStream os = new DataOutputStream(bs); os.write(marshaledHeader); os.flush(); int bytes = bs.size() + 4; int last = curr; while (last < marshaledGroups.length && bytes + marshaledGroups[last].length <= maxPacketSize) { bytes += marshaledGroups[last].length; last += 1; } os.writeInt(last - curr); while (curr < last) { os.write(marshaledGroups[curr++]); } os.flush(); byte[] payload = bs.toByteArray(); reqs.add(new DatagramPacket(payload, payload.length, addr, Constants.discoveryPort)); } } } Iterator iter = reqs.iterator(); DatagramPacket[] ary = new DatagramPacket[reqs.size()]; for (int i = 0; iter.hasNext(); i++) { ary[i] = (DatagramPacket) iter.next(); } return ary; }
73. MulticastDiscoveryAgent#run()
Project: qpid-jms
File: MulticastDiscoveryAgent.java
File: MulticastDiscoveryAgent.java
@Override public void run() { byte[] buf = new byte[BUFF_SIZE]; DatagramPacket packet = new DatagramPacket(buf, 0, buf.length); while (started.get()) { expireOldServices(); try { mcast.receive(packet); if (packet.getLength() > 0) { DiscoveryEvent event = parser.processPacket(packet.getData(), packet.getOffset(), packet.getLength()); if (event != null) { if (event.getType() == EventType.ALIVE) { processAlive(event); } else { processShutdown(event); } } } } catch (SocketTimeoutException se) { } catch (IOException e) { if (started.get()) { LOG.error("failed to process packet: {}", e.getMessage()); LOG.trace(" packet processing failed by: {}", e); } } } }
74. SSDPClient#multicastReceive()
Project: popcorn-android-legacy
File: SSDPClient.java
File: SSDPClient.java
/** Used to receive SSDP Multicast packet */ public DatagramPacket multicastReceive() throws IOException { byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf, buf.length); multicastSocket.receive(dp); return dp; }
75. SSDPClient#responseReceive()
Project: popcorn-android-legacy
File: SSDPClient.java
File: SSDPClient.java
/** Used to receive SSDP Response packet */ public DatagramPacket responseReceive() throws IOException { byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf, buf.length); datagramSocket.receive(dp); return dp; }
76. SSDPClient#send()
Project: popcorn-android-legacy
File: SSDPClient.java
File: SSDPClient.java
/** Used to send SSDP packet */ public void send(String data) throws IOException { DatagramPacket dp = new DatagramPacket(data.getBytes(), data.length(), multicastGroup); datagramSocket.send(dp); }
77. KiteLocalhostConnection#sendJson()
Project: plugins
File: KiteLocalhostConnection.java
File: KiteLocalhostConnection.java
// thread safe because DatagramSocket.send is thread safe. private void sendJson(String jsonString) throws Exception { m_projectComponent.log(jsonString); byte[] packetBytes = jsonString.getBytes("UTF-8"); DatagramPacket packet = new DatagramPacket(packetBytes, packetBytes.length, InetAddress.getByName(UDP_HOST), UDP_PORT); m_outbound.send(packet); }
78. UDPChecker#read()
Project: pinpoint
File: UDPChecker.java
File: UDPChecker.java
private byte[] read(DatagramSocket socket, int readSize) throws IOException { byte[] buf = new byte[readSize]; DatagramPacket datagramPacket = new DatagramPacket(buf, buf.length); socket.receive(datagramPacket); return buf; }
79. UDPChecker#write()
Project: pinpoint
File: UDPChecker.java
File: UDPChecker.java
private void write(DatagramSocket socket, byte[] requestData) throws IOException { DatagramPacket datagramPacket = new DatagramPacket(requestData, requestData.length); socket.send(datagramPacket); }
80. PacketUtilsTest#testSliceData2()
Project: pinpoint
File: PacketUtilsTest.java
File: PacketUtilsTest.java
@Test public void testSliceData2() throws Exception { DatagramPacket packet = createPacket(10); Arrays.fill(packet.getData(), 1, 8, (byte) 'a'); byte[] bytes1 = PacketUtils.sliceData(packet, 0); Assert.assertArrayEquals(bytes1, packet.getData()); }
81. UdpSocketTest#testDatagramSendFail()
Project: pinpoint
File: UdpSocketTest.java
File: UdpSocketTest.java
@Test public void testDatagramSendFail() { int size = 70000; DatagramPacket packet1 = newDatagramPacket(size); try { sender.send(packet1); Assert.fail("expected fail, but succeed"); } catch (IOException ignore) { } }
82. NioUdpDataSenderTest#waitMessageReceived()
Project: pinpoint
File: NioUdpDataSenderTest.java
File: NioUdpDataSenderTest.java
private void waitMessageReceived(int expectReceiveMessageCount) throws IOException { byte[] receiveData = new byte[65535]; DatagramPacket datagramPacket = new DatagramPacket(receiveData, 0, receiveData.length); int remainCount = expectReceiveMessageCount; while (remainCount > 0) { remainCount--; receiver.receive(datagramPacket); } }
83. DatagramPacketFactoryTest#testCreate()
Project: pinpoint
File: DatagramPacketFactoryTest.java
File: DatagramPacketFactoryTest.java
@Test public void testCreate() throws Exception { int bufferLength = 10; DatagramPacketFactory factory = new DatagramPacketFactory(bufferLength); DatagramPacket packet = factory.create(); Assert.assertEquals(bufferLength, packet.getLength()); }
84. UDPReceiverTest#sendSocketBufferSize()
Project: pinpoint
File: UDPReceiverTest.java
File: UDPReceiverTest.java
@Test public void sendSocketBufferSize() throws IOException { DatagramPacket datagramPacket = new DatagramPacket(new byte[0], 0, 0); DatagramSocket datagramSocket = new DatagramSocket(); datagramSocket.connect(new InetSocketAddress("127.0.0.1", 9995)); datagramSocket.send(datagramPacket); datagramSocket.close(); }
85. TestUDPReceiver#read0()
Project: pinpoint
File: TestUDPReceiver.java
File: TestUDPReceiver.java
private PooledObject<DatagramPacket> read0(final DatagramSocket socket) { boolean success = false; PooledObject<DatagramPacket> pooledObject = datagramPacketPool.getObject(); if (pooledObject == null) { logger.error("datagramPacketPool is empty"); return null; } DatagramPacket packet = pooledObject.getObject(); try { try { socket.receive(packet); success = true; } catch (SocketTimeoutException e) { return null; } if (logger.isDebugEnabled()) { logger.debug("DatagramPacket SocketAddress:{} read size:{}", packet.getSocketAddress(), packet.getLength()); if (logger.isTraceEnabled()) { // use trace as packet dump may be large logger.trace("dump packet:{}", PacketUtils.dumpDatagramPacket(packet)); } } } catch (IOException e) { if (!state.get()) { } else { logger.error("IoError, Caused:", e.getMessage(), e); } return null; } finally { if (!success) { pooledObject.returnObject(); } } return pooledObject; }
86. UDPReceiver#read0()
Project: pinpoint
File: UDPReceiver.java
File: UDPReceiver.java
private PooledObject<DatagramPacket> read0(final DatagramSocket socket) { boolean success = false; PooledObject<DatagramPacket> pooledObject = datagramPacketPool.getObject(); if (pooledObject == null) { logger.error("datagramPacketPool is empty"); return null; } DatagramPacket packet = pooledObject.getObject(); try { try { socket.receive(packet); success = true; } catch (SocketTimeoutException e) { return null; } if (logger.isDebugEnabled()) { logger.debug("DatagramPacket SocketAddress:{} read size:{}", packet.getSocketAddress(), packet.getLength()); if (logger.isTraceEnabled()) { // use trace as packet dump may be large logger.trace("dump packet:{}", PacketUtils.dumpDatagramPacket(packet)); } } } catch (IOException e) { if (!state.get()) { } else { logger.error("IoError, Caused:", e.getMessage(), e); } return null; } finally { if (!success) { pooledObject.returnObject(); } } return pooledObject; }
87. PooledPacketWrap#run()
Project: pinpoint
File: PooledPacketWrap.java
File: PooledPacketWrap.java
@Override public void run() { final DatagramPacket packet = pooledObject.getObject(); try { packetHandler.receive(packet); } finally { pooledObject.returnObject(); } }
88. JdpTestCase#run()
Project: openjdk
File: JdpTestCase.java
File: JdpTestCase.java
public void run() throws Exception { log.fine("Test started."); log.fine("Listening for multicast packets at " + connection.address.getHostAddress() + ":" + String.valueOf(connection.port)); log.fine(initialLogMessage()); log.fine("Pause in between packets is: " + connection.pauseInSeconds + " seconds."); startTime = System.currentTimeMillis(); timeOut = connection.pauseInSeconds * TIME_OUT_FACTOR; log.fine("Timeout set to " + String.valueOf(timeOut) + " seconds."); MulticastSocket socket = connection.connectWithTimeout(timeOut * 1000); byte[] buffer = new byte[BUFFER_LENGTH]; DatagramPacket datagram = new DatagramPacket(buffer, buffer.length); do { try { socket.receive(datagram); onReceived(extractUDPpayload(datagram)); } catch (SocketTimeoutException e) { onSocketTimeOut(e); } if (hasTestLivedLongEnough()) { shutdown(); } } while (shouldContinue()); log.fine("Test ended successfully."); }
89. Retransmission#produceHandshakePackets()
Project: openjdk
File: Retransmission.java
File: Retransmission.java
@Override boolean produceHandshakePackets(SSLEngine engine, SocketAddress socketAddr, String side, List<DatagramPacket> packets) throws Exception { boolean finished = super.produceHandshakePackets(engine, socketAddr, side, packets); if (!needPacketLoss || (!engine.getUseClientMode())) { return finished; } List<DatagramPacket> parts = new ArrayList<>(); int lostSeq = 2; for (DatagramPacket packet : packets) { lostSeq--; if (lostSeq == 0) { needPacketLoss = false; // loss this packet System.out.println("Loss a packet"); continue; } parts.add(packet); } packets.clear(); packets.addAll(parts); return finished; }
90. HueEmulationUpnpServer#run()
Project: openhab2-addons
File: HueEmulationUpnpServer.java
File: HueEmulationUpnpServer.java
@Override public void run() { MulticastSocket recvSocket = null; // since jupnp shares port 1900, lets use a different port to send UDP packets on just to be safe. DatagramSocket sendSocket = null; byte[] buf = new byte[1000]; DatagramPacket recv = new DatagramPacket(buf, buf.length); while (running) { try { Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); while (interfaces.hasMoreElements()) { NetworkInterface ni = interfaces.nextElement(); Enumeration<InetAddress> addresses = ni.getInetAddresses(); while (addresses.hasMoreElements()) { InetAddress addr = addresses.nextElement(); if (addr instanceof Inet4Address && !addr.isLoopbackAddress()) { address = addr; break; } } } InetSocketAddress socketAddr = new InetSocketAddress(MULTI_ADDR, UPNP_PORT_RECV); recvSocket = new MulticastSocket(UPNP_PORT_RECV); recvSocket.joinGroup(socketAddr, NetworkInterface.getByInetAddress(address)); sendSocket = new DatagramSocket(); while (running) { recvSocket.receive(recv); if (recv.getLength() > 0) { String data = new String(recv.getData()); logger.trace("Got SSDP Discovery packet from " + recv.getAddress().getHostAddress() + ":" + recv.getPort()); if (data.startsWith("M-SEARCH")) { String msg = String.format(discoString, "http://" + address.getHostAddress().toString() + ":" + System.getProperty("org.osgi.service.http.port") + discoPath, usn); DatagramPacket response = new DatagramPacket(msg.getBytes(), msg.length(), recv.getAddress(), recv.getPort()); try { logger.trace("Sending to " + recv.getAddress().getHostAddress() + " : " + msg); sendSocket.send(response); } catch (IOException e) { logger.error("Could not send UPNP response", e); } } } } } catch (SocketException e) { logger.error("Socket error with UPNP server", e); } catch (IOException e) { logger.error("IO Error with UPNP server", e); } finally { IOUtils.closeQuietly(recvSocket); IOUtils.closeQuietly(sendSocket); if (running) { try { Thread.sleep(3000); } catch (InterruptedException e) { } } } } }
91. UDPMasterTerminal#receiveMessage()
Project: openhab
File: UDPMasterTerminal.java
File: UDPMasterTerminal.java
// receiveMessage public void receiveMessage(byte[] buffer) throws Exception { DatagramPacket packet = new DatagramPacket(buffer, buffer.length); m_Socket.setSoTimeout(m_Timeout); m_Socket.receive(packet); }
92. UDPMasterTerminal#sendMessage()
Project: openhab
File: UDPMasterTerminal.java
File: UDPMasterTerminal.java
// setReceiveTimeout @Override public void sendMessage(byte[] msg) throws Exception { DatagramPacket req = new DatagramPacket(msg, msg.length, m_RemoteAddress, m_RemotePort); synchronized (m_Socket) { m_Socket.send(req); } }
93. LightwaveRfBindingFunctionalTest#testSendingACommandAndVerifyNoInteractions()
Project: openhab
File: LightwaveRfBindingFunctionalTest.java
File: LightwaveRfBindingFunctionalTest.java
private void testSendingACommandAndVerifyNoInteractions(Item item, String itemConfig, Command command, String expectedCommand) throws Exception { DatagramPacket sentPacket = null; try { sentPacket = sendCommand(item, itemConfig, command); } catch (TimeoutException e) { assertEquals(null, sentPacket); } }
94. LightwaveRfBindingFunctionalTest#testSendingACommandAndVerify()
Project: openhab
File: LightwaveRfBindingFunctionalTest.java
File: LightwaveRfBindingFunctionalTest.java
private void testSendingACommandAndVerify(Item item, String itemConfig, Command command, String expectedCommand) throws Exception { DatagramPacket sentPacket = sendCommand(item, itemConfig, command); // Validate what we sent verifyCommandSent(expectedCommand, sentPacket); }
95. EKeyPacketReceiver#run()
Project: openhab
File: EKeyPacketReceiver.java
File: EKeyPacketReceiver.java
@Override public void run() { // start loop running = true; if (socket == null) { throw new IllegalStateException("Cannot access socket. You must call" + " call initializeListener(..) first!"); } byte[] lastpacket = null; DatagramPacket packet = new DatagramPacket(new byte[buffersize], buffersize); while (running) { ekeypacket = null; packet.setData(new byte[buffersize]); try { // wait for the packet socket.receive(packet); } catch (IOException e1) { e1.printStackTrace(); } // if destIp is not set ignore address check - this is not recommended but valid if (destIp == null || packet.getAddress().equals(destIp)) { lastpacket = packet.getData(); try { switch(mode) { case UniformPacket.tHOME: ekeypacket = new HomePacket(deliminator, lastpacket); break; case UniformPacket.tMULTI: ekeypacket = new MultiPacket(deliminator, lastpacket); break; default: // default configuration is the rare packet ekeypacket = new RarePacket(lastpacket); break; } } catch (IllegalArgumentException e) { log.error("Error parsing packet", e); } } if (ekeypacket != null) { listener.publishUpdate(ekeypacket); } else { log.debug("Received a packet that does not match the mode\n" + "you specified in the 'openhab.cfg'!"); } } log.debug("eKey Listener stopped!"); }
96. DiscoveryPacketReceiver#run()
Project: nx-remote-controller-mod
File: DiscoveryPacketReceiver.java
File: DiscoveryPacketReceiver.java
@Override public void run() { byte[] buf = new byte[DISCOVERY_PACKET_SIZE]; DatagramPacket packet = new DatagramPacket(buf, buf.length); try { mSocket = new DatagramSocket(DISCOVERY_UDP_PORT, InetAddress.getByName("0.0.0.0")); mSocket.setBroadcast(true); } catch (SocketException e) { e.printStackTrace(); } catch (UnknownHostException e) { e.printStackTrace(); } try { while (mSocket != null) { mSocket.receive(packet); byte[] data = packet.getData(); String discoveryMessage = new String(data); String[] cameraInfos = discoveryMessage.split("\\|"); if (cameraInfos.length == 4) { String header = cameraInfos[0]; String version = cameraInfos[1]; String model = cameraInfos[2]; // cameraInfos[3] is garbage String ipAddress = packet.getAddress().getHostAddress(); if (header.equals("NX_REMOTE")) { Log.d(TAG, "discovery packet received from " + ipAddress + ". [NX_REMOTE v" + version + " (" + model + ")]"); if (mDiscoveryListener != null) { mDiscoveryListener.onFound(version, model, ipAddress); break; } } } } } catch (IOException e) { e.printStackTrace(); } Log.d(TAG, "DiscoveryPacketReceiver finished."); }
97. SessionManager#receivePacket()
Project: Nukkit
File: SessionManager.java
File: SessionManager.java
private boolean receivePacket() throws Exception { DatagramPacket datagramPacket = this.socket.readPacket(); if (datagramPacket != null) { int len = datagramPacket.getLength(); byte[] buffer = datagramPacket.getData(); String source = datagramPacket.getAddress().getHostAddress(); //in order to block address currentSource = source; int port = datagramPacket.getPort(); if (len > 0) { this.receiveBytes += len; if (this.block.containsKey(source)) { return true; } if (this.ipSec.containsKey(source)) { this.ipSec.put(source, this.ipSec.get(source) + 1); } else { this.ipSec.put(source, 1); } byte pid = buffer[0]; if (pid == UNCONNECTED_PONG.ID) { return false; } Packet packet = this.getPacketFromPool(pid); if (packet != null) { packet.buffer = buffer; this.getSession(source, port).handlePacket(packet); return true; } else if (pid == UNCONNECTED_PING.ID) { packet = new UNCONNECTED_PING(); packet.buffer = buffer; packet.decode(); UNCONNECTED_PONG pk = new UNCONNECTED_PONG(); pk.serverID = this.getID(); pk.pingID = ((UNCONNECTED_PING) packet).pingID; pk.serverName = this.getName(); this.sendPacket(pk, source, port); } else if (buffer.length != 0) { this.streamRAW(source, port, buffer); return true; } else { return false; } } } return false; }
98. RTKInterface#dispatchUDPPacket()
Project: jsonapi
File: RTKInterface.java
File: RTKInterface.java
private void dispatchUDPPacket(String packet, String host, int port) throws IOException { final Object lock = this; lastResponse = null; final DatagramSocket ds = new DatagramSocket(); DatagramPacket dp; try { dp = new DatagramPacket(packet.getBytes(), packet.getBytes("UTF-8").length, InetAddress.getByName(host), port); } catch (UnsupportedEncodingException e) { e.printStackTrace(); return; } ds.send(dp); new Thread() { public void run() { byte[] buffer = new byte[65536]; DatagramPacket incoming = new DatagramPacket(buffer, buffer.length); try { ds.setSoTimeout(5000); ds.receive(incoming); String temp = new String(incoming.getData()); setResponse(temp.trim()); } catch (SocketTimeoutException e) { setResponse("timeout"); } catch (Exception e) { System.err.println("Unexpected Socket error: " + e); e.printStackTrace(); } synchronized (lock) { lock.notifyAll(); } } }.start(); }
99. UdpLoggingServer#processRequests()
Project: jmxtrans
File: UdpLoggingServer.java
File: UdpLoggingServer.java
private void processRequests(DatagramSocket socket) 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); log.debug("Message received: {}", messageReceived); receivedMessages.add(messageReceived); }
100. UDPBroadcastThreadTest#receiveAndVerify()
Project: Jenkins2
File: UDPBroadcastThreadTest.java
File: UDPBroadcastThreadTest.java
/** * Reads a reply from the socket and makes sure its shape is in order. */ private void receiveAndVerify(DatagramSocket s) throws IOException, SAXException, ParserConfigurationException { DatagramPacket p = new DatagramPacket(new byte[1024], 1024); s.receive(p); String xml = new String(p.getData(), 0, p.getLength(), "UTF-8"); System.out.println(xml); // make sure at least this XML parses SAXParserFactory spf = SAXParserFactory.newInstance(); spf.setNamespaceAware(true); spf.newSAXParser().parse(new InputSource(new StringReader(xml)), new DefaultHandler()); }