public static AnnounceRequest parse(byte[] byteArray) { ByteBuffer bufferReceive = ByteBuffer.wrap(byteArray); AnnounceRequest request = new AnnounceRequest(); request.setConnectionId(bufferReceive.getLong(0)); request.setAction(Action.valueOf(bufferReceive.getInt(8))); request.setTransactionId(bufferReceive.getInt(12)); byte[] infoHash = new byte[20]; bufferReceive.position(16); bufferReceive.get(infoHash); request.setInfoHash(Utilities.toHexString(infoHash)); byte[] peerId = new byte[20]; bufferReceive.position(36); bufferReceive.get(peerId); request.setPeerId(new String(peerId)); request.setDownloaded(bufferReceive.getLong(56)); request.setLeft(bufferReceive.getLong(64)); request.setUploaded(bufferReceive.getLong(72)); request.setEvent(Event.valueOf(bufferReceive.getInt(80))); PeerInfo peerInfo = new PeerInfo(); peerInfo.setIpAddress(bufferReceive.getInt(84)); peerInfo.setPort(bufferReceive.getChar(96)); request.setPeerInfo(peerInfo); request.setKey(bufferReceive.getInt(88)); request.setNumWant(bufferReceive.getInt(92)); return request; }
public static long hash64A(final ByteBuffer buf, final int seed) { final ByteOrder byteOrder = buf.order(); buf.order(ByteOrder.LITTLE_ENDIAN); final long m = -4132994306676758123L; final int r = 47; long h = seed ^ buf.remaining() * m; while (buf.remaining() >= 8) { long k = buf.getLong(); k *= m; k ^= k >>> r; k *= m; h ^= k; h *= m; } if (buf.remaining() > 0) { final ByteBuffer finish = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN); finish.put(buf).rewind(); h ^= finish.getLong(); h *= m; } h ^= h >>> r; h *= m; h ^= h >>> r; buf.order(byteOrder); return h; }
private static void parseTCPMsg(byte[] msg) throws UnknownHostException { switch (msg[0]) { case 0x00: if (msg[1] == 0x01) System.out.println("Server: OPEN"); else System.out.println("Server: CLOSED"); break; case 0x01: if (msg[1] == 0x00) System.out.printf("[ERR]: %s", new String(Arrays.copyOfRange(msg, 2, msg.length))); else { ByteBuffer buffer = ByteBuffer.wrap(Arrays.copyOfRange(msg, 1, msg.length)); userId = new UUID(buffer.getLong(), buffer.getLong()); groupIp = InetAddress.getByAddress(ByteBuffer.allocate(4).putInt(buffer.getInt()).array()); // connect to the group and start receiving udpSocket.connect(groupIp.getHostAddress()); udpSocket.startReceive(new UDPHandler()); System.out.printf( "User ID: %s\nGroup IP: %s\nPort: %d\n", userId.toString(), groupIp.getHostAddress(), buffer.getInt()); } break; case 0x02: if (msg[1] == 0x00) System.out.printf("[ERR]: %s", new String(Arrays.copyOfRange(msg, 2, msg.length))); else System.out.println("Successfully deregestered"); default: System.out.println("[ERR] Inavlid msg"); } }
public DataFileAccessorImpl(final File file) throws Exception { this.fileInfo = file; this.file = new RandomAccessFile(file, "rw"); try { this.channel = this.file.getChannel(); final ByteBuffer buffer = ByteBuffer.allocate(HEADER_SIZE); while (buffer.hasRemaining()) { final int rc = this.channel.read(buffer); logger.debug("Read {} bytes", rc); } buffer.flip(); final int magic = buffer.getInt(); final int version = buffer.getInt(); this.start = new Date(buffer.getLong()); this.end = new Date(buffer.getLong()); logger.debug( "Header - magic: {}, version: {}, start: {}, end: {}", new Object[] {magic, version, this.start, this.end}); if (logger.isDebugEnabled()) { logger.debug("File position after header: {}", this.channel.position()); } // position is at end of file } catch (final Exception e) { logger.warn("Failed to open file", e); this.file.close(); throw e; } }
private Object getSingleValue(ByteBuffer buffer) { Object v; if (type.equals("float")) { v = buffer.getFloat(); } else if (type.equals("double")) { v = buffer.getDouble(); } else if (type.equals("int8_t") || type.equals("bool")) { v = (int) buffer.get(); } else if (type.equals("uint8_t")) { v = buffer.get() & 0xFF; } else if (type.equals("int16_t")) { v = (int) buffer.getShort(); } else if (type.equals("uint16_t")) { v = buffer.getShort() & 0xFFFF; } else if (type.equals("int32_t")) { v = buffer.getInt(); } else if (type.equals("uint32_t")) { v = buffer.getInt() & 0xFFFFFFFFl; } else if (type.equals("int64_t")) { v = buffer.getLong(); } else if (type.equals("uint64_t")) { v = buffer.getLong(); } else if (type.equals("char")) { v = buffer.get(); } else { throw new RuntimeException("Unsupported type: " + type); } return v; }
public Object objectFromBuffer(byte[] buffer, int offset, int length) throws Exception { ByteBuffer buf = ByteBuffer.wrap(buffer, offset, length); byte type = buf.get(); switch (type) { case START: case GET_CONFIG: return new MethodCall(type); case SET_OOB: case SET_SYNC: return new MethodCall(type, buf.get() == 1); case SET_NUM_MSGS: case SET_NUM_THREADS: case SET_MSG_SIZE: case SET_ANYCAST_COUNT: return new MethodCall(type, buf.getInt()); case GET: return new MethodCall(type, buf.getLong()); case PUT: Long longarg = buf.getLong(); int len = buf.getInt(); byte[] arg2 = new byte[len]; buf.get(arg2, 0, arg2.length); return new MethodCall(type, longarg, arg2); case SET_READ_PERCENTAGE: return new MethodCall(type, buf.getDouble()); default: throw new IllegalStateException("type " + type + " not known"); } }
public ChmItsfHeader(ByteBuffer bb) { byte[] sbuf = new byte[4]; bb.get(sbuf); signature = new String(sbuf); version = bb.getInt(); header_len = bb.getInt(); unknown_000c = bb.getInt(); last_modified = ByteBufferHelper.parseBigEndianInt(bb); Calendar c = Calendar.getInstance(); c.set(1970, Calendar.JANUARY, 1); c.add(Calendar.SECOND, 0x3DB0C239); timestamp = c.getTime(); // DateFormat f = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); // System.out.println("Last modified: " + f.format(timestamp)); lang_id = bb.getInt(); bb.get(new byte[32]); unknown_len = bb.getLong(); unknown_offset = bb.getLong(); dir_offset = bb.getLong(); dir_len = bb.getLong(); data_offset = 0; // TODO: if (version >= 3) { data_offset = bb.getLong(); } }
private Object getValue(MAVLinkDataType type, int offset) { switch (type) { case CHAR: return payloadBB.get(offset); case UINT8: return payloadBB.get(offset) & 0xFF; case INT8: return (int) payloadBB.get(offset); case UINT16: return payloadBB.getShort(offset) & 0xFFFF; case INT16: return (int) payloadBB.getShort(offset); case UINT32: return payloadBB.getInt(offset) & 0xFFFFFFFFl; case INT32: return payloadBB.getInt(offset); case UINT64: return payloadBB.getLong(offset); case INT64: return payloadBB.getLong(offset); case FLOAT: return payloadBB.getFloat(offset); case DOUBLE: return payloadBB.getDouble(offset); default: throw new RuntimeException("Unknown type: " + type); } }
DigitalGoodsPurchase(ByteBuffer buffer, byte transactionVersion) { super(buffer, transactionVersion); this.goodsId = buffer.getLong(); this.quantity = buffer.getInt(); this.priceNQT = buffer.getLong(); this.deliveryDeadlineTimestamp = buffer.getInt(); }
@Override public Object fetch(long r, Charset encoding) { ByteBuffer bb = pickByteBuffer(); long len = ngx_http_clojure_mem_get_request_body(r, bb.array(), BYTE_ARRAY_OFFSET, bb.capacity()); if (len == 0) { return null; } else if (len < 0) { len = -len; bb.limit((int) len); String tmpfile = decode(bb, DEFAULT_ENCODING, pickCharBuffer()); try { if (log.isDebugEnabled()) { log.debug("#%d:get tmp file :%s", r, tmpfile); } return new FileInputStream(tmpfile); } catch (FileNotFoundException e) { throw new RuntimeException("can not find tmp file", e); } } else { long li = bb.order(ByteOrder.nativeOrder()).getLong(); if (li == len) { return new NativeInputStream(bb.getLong(), len); } else { InputStream rt = new NativeInputStream(bb.getLong(), li); li = bb.getLong(); while (li > 0) { rt = new SequenceInputStream(rt, new NativeInputStream(bb.getLong(), li)); li = bb.getLong(); } return rt; } } }
/** * @param b * @return */ public static UUID fromByte(byte[] b) { final ByteBuffer bb = ByteBuffer.wrap(b); long firstLong = bb.getLong(); long secondLong = bb.getLong(); return new UUID(firstLong, secondLong); }
public Data09(DatagramPacket p, Player player, long serverID) { ByteBuffer b = ByteBuffer.wrap(p.getData()); b.get(); b.getLong(); unknown1 = b.getLong(); this.player = player; this.serverID = serverID; }
public UUID compose(ByteBuffer bytes) { bytes = bytes.slice(); if (bytes.remaining() < 16) { return new UUID(0, 0); } return new UUID(bytes.getLong(), bytes.getLong()); }
/** * Reader factory method. Build a Node object (of the right type) by reading a block in the file. * * @param config Configuration of the History Tree * @param fc FileChannel to the history file, ALREADY SEEKED at the start of the node. * @return The node object * @throws IOException If there was an error reading from the file channel */ public static final HTNode readNode(HTConfig config, FileChannel fc) throws IOException { HTNode newNode = null; int res, i; ByteBuffer buffer = ByteBuffer.allocate(config.getBlockSize()); buffer.order(ByteOrder.LITTLE_ENDIAN); buffer.clear(); res = fc.read(buffer); assert (res == config.getBlockSize()); buffer.flip(); /* Read the common header part */ byte typeByte = buffer.get(); NodeType type = NodeType.fromByte(typeByte); long start = buffer.getLong(); long end = buffer.getLong(); int seqNb = buffer.getInt(); int parentSeqNb = buffer.getInt(); int intervalCount = buffer.getInt(); int stringSectionOffset = buffer.getInt(); buffer.get(); // TODO Used to be "isDone", to be removed from the header /* Now the rest of the header depends on the node type */ switch (type) { case CORE: /* Core nodes */ newNode = new CoreNode(config, seqNb, parentSeqNb, start); newNode.readSpecificHeader(buffer); break; case LEAF: /* Leaf nodes */ newNode = new LeafNode(config, seqNb, parentSeqNb, start); newNode.readSpecificHeader(buffer); break; default: /* Unrecognized node type */ throw new IOException(); } /* * At this point, we should be done reading the header and 'buffer' * should only have the intervals left */ for (i = 0; i < intervalCount; i++) { HTInterval interval = HTInterval.readFrom(buffer); newNode.fIntervals.add(interval); newNode.fSizeOfIntervalSection += interval.getIntervalSize(); } /* Assign the node's other information we have read previously */ newNode.fNodeEnd = end; newNode.fStringSectionOffset = stringSectionOffset; newNode.fIsOnDisk = true; return newNode; }
public static Authorization fromToken(SecretKeySpec key, String token) throws AuthenticationException { if (token == null) { throw new IllegalArgumentException("Token required"); } try { int hashSizeBytes = 16; Cipher decodingCipher = Cipher.getInstance("AES"); decodingCipher.init(Cipher.DECRYPT_MODE, key); ByteBuffer buffer = ByteBuffer.wrap(decodingCipher.doFinal(Hex.decodeHex(token.toCharArray()))); MessageDigest messageDigest = MessageDigest.getInstance("MD5"); byte[] foundHash = new byte[hashSizeBytes]; buffer.get(foundHash, 0, hashSizeBytes); byte[] hashInput = new byte[buffer.capacity() - hashSizeBytes]; buffer.get(hashInput); buffer.position(hashSizeBytes); byte[] calculatedHash = messageDigest.digest(hashInput); if (Arrays.equals(foundHash, calculatedHash)) { byte type = buffer.get(); Authorization authorization = null; long expires = buffer.getLong(); long uoid = buffer.getLong(); switch (type) { case ExplicitRightsAuthorization.ID: authorization = ExplicitRightsAuthorization.fromBuffer(buffer); break; case UserAuthorization.ID: authorization = UserAuthorization.fromBuffer(buffer); break; case SystemAuthorization.ID: authorization = SystemAuthorization.fromBuffer(buffer); break; case AnonymousAuthorization.ID: authorization = AnonymousAuthorization.fromBuffer(buffer); break; case AdminAuthorization.ID: authorization = AdminAuthorization.fromBuffer(buffer); break; default: throw new AuthenticationException("Unknown authorization type: " + type); } authorization.setUoid(uoid); authorization.setExpires(expires); if (authorization.getExpires().getTimeInMillis() < new GregorianCalendar().getTimeInMillis()) { throw new AuthenticationException("This token has expired"); } return authorization; } else { throw new AuthenticationException("Given token is corrupt"); } } catch (GeneralSecurityException e) { throw new AuthenticationException("Invalid token", e); } catch (DecoderException e) { throw new AuthenticationException(e); } }
public static UUID fromBytes(byte[] array) { if (array.length != 16) { throw new IllegalArgumentException("Illegal byte array length: " + array.length); } ByteBuffer byteBuffer = ByteBuffer.wrap(array); long mostSignificant = byteBuffer.getLong(); long leastSignificant = byteBuffer.getLong(); return new UUID(mostSignificant, leastSignificant); }
/** * Returns the clock and the count associated with the given counter id, or (0, 0) if no such * shard is present. */ @VisibleForTesting public ClockAndCount getClockAndCountOf(ByteBuffer context, CounterId id) { int position = findPositionOf(context, id); if (position == -1) return ClockAndCount.BLANK; long clock = context.getLong(position + CounterId.LENGTH); long count = context.getLong(position + CounterId.LENGTH + CLOCK_LENGTH); return ClockAndCount.create(clock, count); }
@Override // TODO replace on tweeter Snowflake public String getId() { if (null == this.uuid) { final ByteBuffer bb = ByteBuffer.wrap(this.id); final UUID u = new UUID(bb.getLong(), bb.getLong()); this.uuid = u.toString(); } return this.uuid; }
public ExtendedBpb(ByteBuffer bb) { super(bb); totalSectors = bb.getLong(TOTAL_SECTORS_OFFSET); mftLogicalCluster = bb.getLong(MFT_LOGICAL_CLUSTER_OFFSET); mftMirrorLogicalCluster = bb.getLong(MFT_MIRROR_LOGICAL_CLUSTER_OFFSET); clustersPerMftRecord = bb.get(CLUSTERS_PER_MFT_RECORD); clustersPerIndexBuffer = bb.get(CLUSTERS_PER_INDEX_BUFFER_OFFSET); volumeSerialNumber = bb.getLong(VOLUME_SERIAL_NUMBER_OFFSET); }
/** * This comparator WILL compare between xsd:decimal and the extending types * * @see org.mulgara.store.stringpool.SPComparator#compare(ByteBuffer, int, ByteBuffer, int) */ public int compare(ByteBuffer d1, int subtypeId1, ByteBuffer d2, int subtypeId2) { int c; if (isLong(d1) && isLong(d2)) { c = SPDecimalExtImpl.compare(d1.getLong(), d2.getLong()); } else { c = decode(d1).compareTo(decode(d2)); } if (c == 0) c = AbstractSPObject.compare(subtypeId1, subtypeId2); return c; }
public static ZipFile.EocdRecord parseZip64EocdRecord( RandomAccessFile raf, long eocdRecordOffset, int commentLength) throws IOException { raf.seek(eocdRecordOffset); final int signature = Integer.reverseBytes(raf.readInt()); if (signature != ZIP64_EOCD_RECORD_SIGNATURE) { throw new ZipException( "Invalid zip64 eocd record offset, sig=" + Integer.toHexString(signature) + " offset=" + eocdRecordOffset); } // The zip64 eocd record specifies its own size as an 8 byte integral type. It is variable // length because of the "zip64 extensible data sector" but that field is reserved for // pkware's proprietary use. We therefore disregard it altogether and treat the end of // central directory structure as fixed length. // // We also skip "version made by" (2 bytes) and "version needed to extract" (2 bytes) // fields. We perform additional validation at the ZipEntry level, where applicable. // // That's a total of 12 bytes to skip raf.skipBytes(12); byte[] zip64Eocd = new byte[ZIP64_EOCD_RECORD_EFFECTIVE_SIZE]; raf.readFully(zip64Eocd); ByteBuffer buf = ByteBuffer.wrap(zip64Eocd).order(ByteOrder.LITTLE_ENDIAN); try { int diskNumber = buf.getInt(); int diskWithCentralDirStart = buf.getInt(); long numEntries = buf.getLong(); long totalNumEntries = buf.getLong(); buf.getLong(); // Ignore the size of the central directory long centralDirOffset = buf.getLong(); if (numEntries != totalNumEntries || diskNumber != 0 || diskWithCentralDirStart != 0) { throw new ZipException( "Spanned archives not supported :" + " numEntries=" + numEntries + ", totalNumEntries=" + totalNumEntries + ", diskNumber=" + diskNumber + ", diskWithCentralDirStart=" + diskWithCentralDirStart); } return new ZipFile.EocdRecord(numEntries, centralDirOffset, commentLength); } catch (BufferUnderflowException bue) { ZipException zipException = new ZipException("Error parsing zip64 eocd record."); zipException.initCause(bue); throw zipException; } }
ColoredCoinsAssetTransfer(ByteBuffer buffer, byte transactionVersion) throws RiseException.NotValidException { super(buffer, transactionVersion); this.assetId = buffer.getLong(); this.quantityQNT = buffer.getLong(); this.comment = getVersion() == 0 ? Convert.readString( buffer, buffer.getShort(), Constants.MAX_ASSET_TRANSFER_COMMENT_LENGTH) : null; }
@Override public boolean decode(final byte[] rawDatas) { final ByteBuffer bb = ByteBuffer.wrap(rawDatas); this.m_eventId = bb.getLong(); this.m_invitedId = bb.getLong(); final byte[] tInvitedName = new byte[bb.get()]; bb.get(tInvitedName); this.m_invitedName = StringUtils.fromUTF8(tInvitedName); this.m_result = bb.get(); return true; }
public void onReceive(ByteBuffer b) { if (b.remaining() == 4) { Common.logError("invalid packet:"); byte[] data = new byte[b.remaining()]; b.get(data); Common.print_dump(data); // retry( TLMessage.keyAt( TLMessage.size() - 1) ); return; } try { if (b.getLong() == 0) { // auth_key_id b.getLong(); // message_id b.getInt(); // message length process(TL.deserialize(b)); } else { byte[] msg_key = new byte[16]; b.get(msg_key); byte[] data = new byte[b.remaining()]; b.get(data); synchronized (aes) { aes.prepare(false, msg_key, auth_key); data = aes.IGE(data, false); } ByteBuffer btmp = ByteBuffer.wrap(data); btmp.order(ByteOrder.LITTLE_ENDIAN); server_salt = btmp.getLong(); btmp.getLong(); // session_id cur_message_id = btmp.getLong(); // message_id cur_msg_seq = btmp.getInt(); // seq_no // if (cur_msg_seq > seqno) // seqno = cur_msg_seq + cur_msg_seq % 2; int bsize = btmp.getInt(); if (bsize < 0 || bsize > 1024 * 1024) { Common.print_dump(btmp.array()); Common.logError(new String(btmp.array())); Common.logError("FFFUUUUUUUUUUU!!!"); } b = BufferAlloc(bsize); btmp.get(b.array()); b.getInt(); ack_message(cur_msg_seq, cur_message_id); b.position(0); process(TL.deserialize(b)); send_accept(); } } catch (Exception e) { e.printStackTrace(); } }
public void decode(ByteBuffer buf) { type = Type.values()[buf.getInt()]; keySize = buf.getInt(); valueSize = buf.getInt(); keyCount = buf.getLong(); order = Order.values()[buf.getInt()]; distribution = Distribution.values()[buf.getInt()]; start = buf.getLong(); end = buf.getLong(); scanBufferSize = buf.getInt(); }
DigitalGoodsDelivery(ByteBuffer buffer, byte transactionVersion) throws RiseException.NotValidException { super(buffer, transactionVersion); this.purchaseId = buffer.getLong(); int length = buffer.getInt(); goodsIsText = length < 0; if (length < 0) { length &= Integer.MAX_VALUE; } this.goods = EncryptedData.readEncryptedData(buffer, length, Constants.MAX_DGS_GOODS_LENGTH); this.discountNQT = buffer.getLong(); }
public boolean next() throws IOException { for (; ; ) { if (buf == null || !buf.hasRemaining()) { if (input == null) { return false; } buf = input.readNext(); limit = buf == null ? 0 : buf.limit(); if (limit <= 0) { close(); return false; } } modificationTime = buf.getLong(); filesize = buf.getLong(); replication = buf.getInt(); final int nameLen = buf.getInt(); isDirectory = buf.get() != 0; numStripes = buf.getInt(); numRecoveryStripes = buf.getInt(); striperType = buf.getInt(); stripeSize = buf.getInt(); owner = buf.getInt(); group = buf.getInt(); mode = buf.getShort(); fileId = buf.getLong(); fileCount = isDirectory ? buf.getLong() : 0; dirCount = isDirectory ? buf.getLong() : 0; final int onameLen = buf.getInt(); final int gnameLen = buf.getInt(); owner &= 0xFFFFFFFFL; group &= 0xFFFFFFFFL; mode &= 0xFFFF; filename = readString(nameLen); if (owner == prevOwner && ownerName != null) { skip(onameLen); } else { prevOwner = owner; ownerName = readString(onameLen); } if (group == prevGroup && groupName != null) { skip(gnameLen); } else { prevGroup = group; groupName = readString(gnameLen); } if (nameLen > 0) { break; } } return true; }
/** * Factory method for Request and Response. It expects the bytes to be correctly formed so it's * possible that it throws underflow exceptions but you shouldn't be concerned about that since * that all bytes sent in should already be formatted correctly. * * @param bytes bytes to be converted. * @return Request or Response depending on the data. * @throws ClassNotFoundException if the Command or Answer can not be formed. * @throws */ public static Request parse(final byte[] bytes) throws ClassNotFoundException, UnsupportedVersionException { ByteBuffer buff = ByteBuffer.wrap(bytes); final byte ver = buff.get(); final Version version = Version.get(ver); if (version.ordinal() != Version.v1.ordinal() && version.ordinal() != Version.v3.ordinal()) { throw new UnsupportedVersionException( "This version is no longer supported: " + version.toString(), UnsupportedVersionException.IncompatibleVersion); } final byte reserved = buff.get(); // tossed away for now. final short flags = buff.getShort(); final boolean isRequest = (flags & FLAG_REQUEST) > 0; final long seq = buff.getLong(); // The size here is uncompressed size, if the data is compressed. final int size = buff.getInt(); final long mgmtId = buff.getLong(); final long agentId = buff.getLong(); long via; if (version.ordinal() == Version.v1.ordinal()) { via = buff.getLong(); } else { via = agentId; } if ((flags & FLAG_COMPRESSED) != 0) { buff = doDecompress(buff, size); } byte[] command = null; int offset = 0; if (buff.hasArray()) { command = buff.array(); offset = buff.arrayOffset() + buff.position(); } else { command = new byte[buff.remaining()]; buff.get(command); offset = 0; } final String content = new String(command, offset, command.length - offset); if (isRequest) { return new Request(version, seq, agentId, mgmtId, via, flags, content); } else { return new Response(Version.get(ver), seq, agentId, mgmtId, via, flags, content); } }
public static void main(final String[] args) throws IOException { final FileChannel receiveFileChannel = Common.createTmpFileChannel(); final ByteBuffer receiveByteBuffer = receiveFileChannel.map(FileChannel.MapMode.READ_WRITE, 0, MTU_LENGTH_DEFAULT); final DatagramChannel receiveDatagramChannel = DatagramChannel.open(); init(receiveDatagramChannel); receiveDatagramChannel.bind(new InetSocketAddress("localhost", 40124)); receiveDatagramChannel.connect(new InetSocketAddress("localhost", 40123)); final FileChannel sendFileChannel = Common.createTmpFileChannel(); final ByteBuffer sendByteBuffer = sendFileChannel.map(FileChannel.MapMode.READ_WRITE, 0, MTU_LENGTH_DEFAULT); final DatagramChannel sendDatagramChannel = DatagramChannel.open(); init(sendDatagramChannel); sendDatagramChannel.bind(new InetSocketAddress("localhost", 40125)); sendDatagramChannel.connect(new InetSocketAddress("localhost", 40126)); final AtomicBoolean running = new AtomicBoolean(true); SigInt.register(() -> running.set(false)); final int packetSize = SIZE_OF_LONG * 2; while (true) { boolean available = false; while (!available) { if (!running.get()) { return; } final long bytesReceived = receiveFileChannel.transferFrom(receiveDatagramChannel, 0, packetSize); if (packetSize == bytesReceived) { available = true; } } final long receivedSequenceNumber = receiveByteBuffer.getLong(0); final long receivedTimestamp = receiveByteBuffer.getLong(SIZE_OF_LONG); sendByteBuffer.putLong(0, receivedSequenceNumber); sendByteBuffer.putLong(SIZE_OF_LONG, receivedTimestamp); final long bytesSent = sendFileChannel.transferTo(0, packetSize, sendDatagramChannel); if (packetSize != bytesSent) { throw new IllegalStateException("Invalid bytes sent " + bytesSent); } } }
/** * Parses the zip64 end of central directory record locator. The locator must be placed * immediately before the end of central directory (eocd) record starting at {@code eocdOffset}. * * <p>The position of the file cursor for {@code raf} after a call to this method is undefined an * callers must reposition it after each call to this method. */ public static long parseZip64EocdRecordLocator(RandomAccessFile raf, long eocdOffset) throws IOException { // The spec stays curiously silent about whether a zip file with an EOCD record, // a zip64 locator and a zip64 eocd record is considered "empty". In our implementation, // we parse all records and read the counts from them instead of drawing any size or // layout based information. if (eocdOffset > ZIP64_LOCATOR_SIZE) { raf.seek(eocdOffset - ZIP64_LOCATOR_SIZE); if (Integer.reverseBytes(raf.readInt()) == ZIP64_LOCATOR_SIGNATURE) { byte[] zip64EocdLocator = new byte[ZIP64_LOCATOR_SIZE - 4]; raf.readFully(zip64EocdLocator); ByteBuffer buf = ByteBuffer.wrap(zip64EocdLocator).order(ByteOrder.LITTLE_ENDIAN); final int diskWithCentralDir = buf.getInt(); final long zip64EocdRecordOffset = buf.getLong(); final int numDisks = buf.getInt(); if (numDisks != 1 || diskWithCentralDir != 0) { throw new ZipException("Spanned archives not supported"); } return zip64EocdRecordOffset; } } return -1; }