@Override public void send(DatagramPacket packet) throws IOException { int port = isNativeConnected ? 0 : packet.getPort(); InetAddress address = isNativeConnected ? null : packet.getAddress(); IoBridge.sendto(fd, packet.getData(), packet.getOffset(), packet.getLength(), 0, address, port); }
private void doRecv(DatagramPacket pack, int flags) throws IOException { IoBridge.recvfrom(false, fd, pack.getData(), pack.getOffset(), pack.getLength(), flags, pack, isNativeConnected); if (isNativeConnected) { updatePacketRecvAddress(pack); } }
public void run() { byte[] buf=new byte[RoundTrip.PAYLOAD]; DatagramPacket packet=new DatagramPacket(buf, 0, buf.length); for(;;) { try { sock.receive(packet); if(packet.getLength() != RoundTrip.PAYLOAD) throw new IllegalStateException("expected " + RoundTrip.PAYLOAD + " bytes, but got only " + packet.getLength()); if(receiver != null) receiver.receive(packet.getSocketAddress(), buf, packet.getOffset(), packet.getLength()); } catch(IOException ex) { break; } catch(Exception e) { e.printStackTrace(); } } } }
public void run() { byte[] buf = new byte[BUFF_SIZE]; DatagramPacket packet = new DatagramPacket(buf, 0, buf.length); while (started.get()) { doTimeKeepingServices(); try { mcast.receive(packet); if (packet.getLength() > 0) { String str = new String(packet.getData(), packet.getOffset(), packet.getLength()); processData(str); } } catch (SocketTimeoutException se) { // ignore } catch (IOException e) { if (started.get()) { LOG.error("failed to process packet: " + e); } } } }
private SocketAddress receiveImpl(ByteBuffer target, boolean loop) throws IOException { SocketAddress retAddr = null; DatagramPacket receivePacket; int oldposition = target.position(); int received = 0; // TODO: disallow mapped buffers and lose this conditional? if (target.hasArray()) { receivePacket = new DatagramPacket(target.array(), target.position() + target.arrayOffset(), target.remaining()); } else { receivePacket = new DatagramPacket(new byte[target.remaining()], target.remaining()); } do { received = IoBridge.recvfrom(false, fd, receivePacket.getData(), receivePacket.getOffset(), receivePacket.getLength(), 0, receivePacket, isConnected()); if (receivePacket != null && receivePacket.getAddress() != null) { if (received > 0) { if (target.hasArray()) { target.position(oldposition + received); } else { // copy the data of received packet target.put(receivePacket.getData(), 0, received); } } retAddr = receivePacket.getSocketAddress(); break; } } while (loop); return retAddr; }
public void run() { byte[] buf; DatagramPacket packet; while(Thread.currentThread().equals(thread)) { buf=new byte[10000]; // requests are small (responses might be bigger) packet=new DatagramPacket(buf, 0, buf.length); try { diag_sock.receive(packet); int payloadStartOffset = 0; if(isAuthorizationRequired()){ payloadStartOffset = authorizeProbeRequest(packet); } handleDiagnosticProbe(packet.getSocketAddress(), diag_sock, new String(packet.getData(), packet.getOffset() + payloadStartOffset, packet.getLength())); } catch(IOException socket_ex) { } catch(Throwable e) { log.error(Util.getMessage("FailureHandlingDiagnosticsRequest"), e); } } }
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(msg); } catch(SocketException socketEx) { break; } catch(Throwable ex) { log.error(Util.getMessage("FailedReceivingPacketFrom"), packet.getSocketAddress(), ex); } } if(log.isTraceEnabled()) log.trace("receiver thread terminated"); }
public void run() { final byte[] receive_buf=new byte[65535]; DatagramPacket packet=new DatagramPacket(receive_buf, receive_buf.length); while(mcast_sock != null && receiver != null && Thread.currentThread().equals(receiver)) { packet.setData(receive_buf, 0, receive_buf.length); try { mcast_sock.receive(packet); DataInput inp=new ByteArrayDataInputStream(packet.getData(), packet.getOffset(), packet.getLength()); Message msg=new Message(); msg.readFrom(inp); if(!Objects.equals(local_addr,msg.getSrc())) // discard discovery request from self up(msg); } catch(SocketException socketEx) { break; } catch(Throwable ex) { log.error(Util.getMessage("FailedReceivingPacketFrom"), packet.getSocketAddress(), ex); } } log.debug("receiver thread terminated"); }
public void run() { final byte receive_buf[]=new byte[66000]; // to be on the safe side (IPv6 == 65575 bytes, IPv4 = 65535) final DatagramPacket packet=new DatagramPacket(receive_buf, receive_buf.length); while(thread != null && Thread.currentThread().equals(thread)) { try { // solves Android ISSUE #24748 - DatagramPacket truncated UDP in ICS if(is_android) packet.setLength(receive_buf.length); receiver_socket.receive(packet); int len=packet.getLength(); if(len > receive_buf.length && log.isErrorEnabled()) log.error(Util.getMessage("SizeOfTheReceivedPacket"), len, receive_buf.length, receive_buf.length); receive(new IpAddress(packet.getAddress(), packet.getPort()), receive_buf, packet.getOffset(), len); } catch(SocketException sock_ex) { if(receiver_socket.isClosed()) { log.debug("receiver socket is closed, exception=" + sock_ex); break; } log.error(Util.getMessage("FailedReceivingPacket"), sock_ex); } catch(Throwable ex) { log.error(Util.getMessage("FailedReceivingPacket"), ex); } } if(log.isDebugEnabled()) log.debug(name + " thread terminated"); }
@Override public void run() { final byte[] buf = new byte[MAX_PACKET_SIZE]; final DatagramPacket packet = new DatagramPacket(buf, buf.length); while (!socket.isClosed() && !Thread.currentThread().isInterrupted()) { startSignal.countDown(); try { // TODO This doesn't handle the case of a progress being split across two packets socket.receive(packet); if (packet.getLength() == 0) { continue; } final ByteArrayInputStream in = new ByteArrayInputStream(packet.getData(), packet.getOffset(), packet.getLength()); parser.processStream(in); } catch (SocketException e) { // Most likley a Socket closed exception, which we can safely ignore } catch (IOException e) { // We have no good way to report this back to the user... yet // TODO Report to the user that this failed in some way } } } }
/** * Process acknowledgments, if requested. */ @Override public void run() { try { this.ackThreadRunning = true; this.ackLatch.countDown(); DatagramPacket ackPack = new DatagramPacket(new byte[100], 100); while (true) { this.getSocket().receive(ackPack); String id = new String(ackPack.getData(), ackPack.getOffset(), ackPack.getLength()); if (logger.isDebugEnabled()) { logger.debug("Received ack for " + id + " from " + ackPack.getAddress().getHostAddress()); } CountDownLatch latch = this.ackControl.get(id); if (latch != null) { latch.countDown(); } } } catch (IOException e) { if (this.socket != null && !this.socket.isClosed()) { logger.error("Error on UDP Acknowledge thread: " + e.getMessage()); } } finally { this.ackThreadRunning = false; } }
/** * Handles an incoming Octo packet of type {@code data}. */ private void handleDataPacket(DatagramPacket p) { byte[] msgBytes = new byte[p.getLength() - OctoPacket.OCTO_HEADER_LENGTH]; System.arraycopy( p.getData(), p.getOffset() + OctoPacket.OCTO_HEADER_LENGTH, msgBytes, 0, msgBytes.length); String msg = new String(msgBytes, StandardCharsets.UTF_8); if (logger.isDebugEnabled()) { logger.debug("Received a message in an Octo data packet: " + msg); } octoEndpoints.messageTransport.onMessage(this, msg); }
public void initialize(UDPPacket packet) { int off = packet.getPacket().getOffset(); int len = packet.getPacket().getLength(); off += UDPPacket.MAC_SIZE + UDPPacket.IV_SIZE; len -= UDPPacket.MAC_SIZE + UDPPacket.IV_SIZE; initialize(packet.getPacket().getData(), off, len); }
/** * Decrypt this valid packet, overwriting the _data buffer's payload * with the decrypted data (leaving the MAC and IV unaltered) * */ public synchronized void decrypt(SessionKey cipherKey) { verifyNotReleased(); System.arraycopy(_data, MAC_SIZE, _ivBuf, 0, IV_SIZE); int len = _packet.getLength(); // As of 0.9.7, ignore padding beyond the last mod 16, // it could otherwise blow up in decryption. // This allows for better obfuscation. // Probably works without this since _data is bigger than necessary, but let's not // bother decrypting and risk overrun. int rem = len & 0x0f; if (rem != 0) len -= rem; int off = _packet.getOffset() + MAC_SIZE + IV_SIZE; _context.aes().decrypt(_data, off, _data, off, cipherKey, _ivBuf, len - MAC_SIZE - IV_SIZE); }
@Override public void receive(DatagramPacket p) throws IOException { super.receive(p); try { // Strip the Octo header. The code which actually handles // the values in the Octo header has already executed in // the accept() method of the DatagramPacketFilter for the // associated channel. p.setData( p.getData(), p.getOffset() + OctoPacket.OCTO_HEADER_LENGTH, p.getLength() - OctoPacket.OCTO_HEADER_LENGTH); } catch (Exception e) { // TODO: more graceful handling logger.error( "Failed to strip Octo header while receiving a packet:" + e); } }
int off = p.getOffset(); int len = p.getLength();
dg.receive(p); int len = p.getLength(); int off = p.getOffset(); byte[] data = p.getData(); _log.info("Got datagram length " + len);
/** * {@inheritDoc} */ @Override public boolean accept(DatagramPacket p) { byte[] buf = p.getData(); int off = p.getOffset(); int len = p.getLength(); // If isRtpRtcp fails, this is not a valid RTP packet either. if (!RawPacket.isRtpRtcp(buf, off, len)) { return acceptNonRtp && DTLSDatagramFilter.isDTLS(p); } if (RTCPUtils.isRtcp(buf, off, len)) { return rtcp && acceptRTCP(buf, off, len); } else { return !rtcp && acceptRTP(RawPacket.getPayloadType(buf, off, len)); } }
byte[] src = receivedPacket.getData(); int length = receivedPacket.getLength(); int offset = receivedPacket.getOffset(); byte[] dest = new byte[length]; System.arraycopy(src, offset, dest, 0, length);