java.net.DatagramPacket

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
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
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
@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
/**
     * 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
/***
     * 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
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
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
@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
/***
     * 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
/**
     * 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
@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
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
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
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
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
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
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
/**
     * 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
@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
@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
/**
	 * 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
@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
// 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
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
/**
     * 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
/**
     * 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
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
@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
/**
   * 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
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
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
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
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
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
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
@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
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
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
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
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
@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
/**
     * 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
/**
     * 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
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
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
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
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
//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
/***
     * 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
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
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
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
/**
	 * 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
/**
	 * 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
@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
@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
@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
@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
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
/**
     * {@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
/**
	 * 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
@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
/***
     * 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
/***
     * 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
/***
     * 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
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
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
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
@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
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
/**
     * 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
/**
     * 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
@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
/** 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
/** 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
/** 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
// 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
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
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
@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
@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
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
@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
@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
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
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
@Override
public void run() {
    final DatagramPacket packet = pooledObject.getObject();
    try {
        packetHandler.receive(packet);
    } finally {
        pooledObject.returnObject();
    }
}

88. JdpTestCase#run()

Project: openjdk
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
@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
@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
// 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
// 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
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
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
@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
@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
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
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
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
/**
     * 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());
}