List of usage examples for io.netty.buffer ByteBuf getUnsignedInt
public abstract long getUnsignedInt(int index);
From source file:com.cc.nettytest.proxy.decoder.CCLengthFieldBasedFrameDecoder.java
License:Apache License
@Override public Object decode(ChannelHandlerContext ctx, ByteBuf inBuffer) throws Exception { if (discardingTooLongFrame) { long bytesToDiscard = this.bytesToDiscard; int localBytesToDiscard = (int) Math.min(bytesToDiscard, inBuffer.readableBytes()); inBuffer.skipBytes(localBytesToDiscard); bytesToDiscard -= localBytesToDiscard; this.bytesToDiscard = bytesToDiscard; failIfNecessary(ctx, false);/*from w ww . ja v a 2s . c o m*/ return null; } if (inBuffer.readableBytes() < lengthFieldEndOffset) { return null; } int actualLengthFieldOffset = inBuffer.readerIndex() + lengthFieldOffset; long frameLength; switch (lengthFieldLength) { case 1: frameLength = inBuffer.getUnsignedByte(actualLengthFieldOffset); break; case 2: frameLength = inBuffer.getUnsignedShort(actualLengthFieldOffset); break; case 3: frameLength = inBuffer.getUnsignedMedium(actualLengthFieldOffset); break; case 4: frameLength = ByteBufUtil.swapInt((int) inBuffer.getUnsignedInt(actualLengthFieldOffset)); //SWAP FOR UIMANAGER break; case 8: frameLength = inBuffer.getLong(actualLengthFieldOffset); break; default: throw new Error("should not reach here"); } if (frameLength < 0) { inBuffer.skipBytes(lengthFieldEndOffset); throw new CorruptedFrameException("negative pre-adjustment length field: " + frameLength); } frameLength += lengthAdjustment + lengthFieldEndOffset; if (frameLength < lengthFieldEndOffset) { inBuffer.skipBytes(lengthFieldEndOffset); throw new CorruptedFrameException("Adjusted frame length (" + frameLength + ") is less " + "than lengthFieldEndOffset: " + lengthFieldEndOffset); } if (frameLength > maxFrameLength) { // Enter the discard mode and discard everything received so far. discardingTooLongFrame = true; tooLongFrameLength = frameLength; bytesToDiscard = frameLength - inBuffer.readableBytes(); inBuffer.skipBytes(inBuffer.readableBytes()); failIfNecessary(ctx, true); return null; } // never overflows because it's less than maxFrameLength int frameLengthInt = (int) frameLength; if (inBuffer.readableBytes() < frameLengthInt) { return null; } if (initialBytesToStrip > frameLengthInt) { inBuffer.skipBytes(frameLengthInt); throw new CorruptedFrameException("Adjusted frame length (" + frameLength + ") is less " + "than initialBytesToStrip: " + initialBytesToStrip); } inBuffer.skipBytes(initialBytesToStrip); // extract frame int readerIndex = inBuffer.readerIndex(); int actualFrameLength = frameLengthInt - initialBytesToStrip; ByteBuf frame = extractFrame(inBuffer, readerIndex, actualFrameLength); inBuffer.readerIndex(readerIndex + actualFrameLength); return frame; }
From source file:com.chat.common.netty.handler.decode.LengthFieldBasedFrameDecoder.java
License:Apache License
/** * Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is * capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to * decode the length field encoded differently. Note that this method must not modify the state of the specified * buffer (e.g. {@code readerIndex}, {@code writerIndex}, and the content of the buffer.) * * @throws DecoderException if failed to decode the specified region *///from w w w. j ava 2 s . c o m protected long getUnadjustedFrameLength(ByteBuf buf, int offset, int length, ByteOrder order) { buf = buf.order(order); long frameLength; switch (length) { case 1: frameLength = buf.getUnsignedByte(offset); break; case 2: frameLength = buf.getUnsignedShort(offset); break; case 3: frameLength = buf.getUnsignedMedium(offset); break; case 4: frameLength = buf.getUnsignedInt(offset); break; case 8: frameLength = buf.getLong(offset); break; default: throw new DecoderException( "unsupported lengthFieldLength: " + lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)"); } return frameLength; }
From source file:com.digitalpetri.opcua.stack.core.channel.headers.HeaderDecoder.java
License:Apache License
/** * Get the message length from a {@link ByteBuf} containing a {@link TcpMessageEncoder}. The reader index will not be * advanced./*from www . ja va 2 s . com*/ * * @param buffer {@link ByteBuf} to extract from. * @return The message length, which includes the size of the header. */ default int getMessageLength(ByteBuf buffer) { return Ints.checkedCast(buffer.getUnsignedInt(buffer.readerIndex() + HEADER_LENGTH_INDEX)); }
From source file:com.github.sadikovi.netflowlib.NetFlowReader.java
License:Apache License
/** Prepare header using provided input stream */ private NetFlowHeader prepareHeader() throws IOException { NetFlowHeader internalHeader;//from w w w . j a va 2 s . c o m int numBytesRead = 0; int lenRead = 0; ByteBuf buf; byte[] headerArray; // Read header depending on stream version (different from flow version) if (streamVersion == 1) { // Version 1 has static header // TODO: verify header size for stream version 1 lenRead = NetFlowHeader.S1_HEADER_SIZE - METADATA_LENGTH; internalHeader = new NetFlowHeader(streamVersion, byteOrder); } else { // Version 3 with dynamic header size headerArray = new byte[HEADER_OFFSET_LENGTH]; numBytesRead = in.read(headerArray, 0, HEADER_OFFSET_LENGTH); if (numBytesRead != HEADER_OFFSET_LENGTH) { throw new UnsupportedOperationException("Short read while loading header offset"); } buf = Unpooled.wrappedBuffer(headerArray).order(byteOrder); int headerSize = (int) buf.getUnsignedInt(0); if (headerSize <= 0) { throw new UnsupportedOperationException("Failed to load header of size " + headerSize); } // Actual header length, determine how many bytes to read lenRead = headerSize - METADATA_LENGTH - HEADER_OFFSET_LENGTH; internalHeader = new NetFlowHeader(streamVersion, byteOrder, headerSize); } // allocate buffer for length to read headerArray = new byte[lenRead]; numBytesRead = in.read(headerArray, 0, lenRead); if (numBytesRead != lenRead) { throw new UnsupportedOperationException("Short read while loading header data"); } // build buffer buf = Unpooled.wrappedBuffer(headerArray).order(byteOrder); // resolve stream version (either 1 or 3) if (streamVersion == 1) { internalHeader.setFlowVersion((short) buf.getUnsignedShort(0)); internalHeader.setStartCapture(buf.getUnsignedInt(2)); internalHeader.setEndCapture(buf.getUnsignedInt(6)); internalHeader.setHeaderFlags(buf.getUnsignedInt(10)); internalHeader.setRotation(buf.getUnsignedInt(14)); internalHeader.setNumFlows(buf.getUnsignedInt(18)); internalHeader.setNumDropped(buf.getUnsignedInt(22)); internalHeader.setNumMisordered(buf.getUnsignedInt(26)); // Read hostname fixed bytes byte[] hostnameBytes = new byte[NetFlowHeader.S1_HEADER_HN_LEN]; buf.getBytes(30, hostnameBytes, 0, hostnameBytes.length); internalHeader.setHostname(new String(hostnameBytes)); // Read comments fixed bytes byte[] commentsBytes = new byte[NetFlowHeader.S1_HEADER_CMNT_LEN]; buf.getBytes(30 + hostnameBytes.length, commentsBytes, 0, commentsBytes.length); internalHeader.setComments(new String(commentsBytes)); // Dereference arrays hostnameBytes = null; commentsBytes = null; } else { // Resolve TLV (type-length value) // Set decode pointer to first tlv int dp = 0; int left = lenRead; // Smallest TLV is 2+2+0 (null TLV) // tlv_t - TLV type, tlv_l - TLV length, tlv_v - TLV value int tlv_t = 0; int tlv_l = 0; int tlv_v = 0; // Byte array for holding Strings byte[] pr; while (left >= 4) { // Parse type, store in host byte order tlv_t = buf.getUnsignedShort(dp); dp += 2; left -= 2; // Parse len, store in host byte order tlv_l = buf.getUnsignedShort(dp); dp += 2; left -= 2; // Parse val tlv_v = dp; // Point decode buffer at next tlv dp += tlv_l; left -= tlv_l; // TLV length check if (left < 0) { break; } switch (tlv_t) { // FT_TLV_VENDOR case 0x1: internalHeader.setVendor(buf.getUnsignedShort(tlv_v)); break; // FT_TLV_EX_VER case 0x2: internalHeader.setFlowVersion((short) buf.getUnsignedShort(tlv_v)); break; // FT_TLV_AGG_VER case 0x3: internalHeader.setAggVersion(buf.getUnsignedByte(tlv_v)); break; // FT_TLV_AGG_METHOD case 0x4: internalHeader.setAggMethod(buf.getUnsignedByte(tlv_v)); break; // FT_TLV_EXPORTER_IP case 0x5: internalHeader.setExporterIP(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_CAP_START case 0x6: internalHeader.setStartCapture(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_CAP_END case 0x7: internalHeader.setEndCapture(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_HEADER_FLAGS case 0x8: internalHeader.setHeaderFlags(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_ROT_SCHEDULE case 0x9: internalHeader.setRotation(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_FLOW_COUNT case 0xA: internalHeader.setNumFlows(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_FLOW_LOST case 0xB: internalHeader.setNumDropped(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_FLOW_MISORDERED case 0xC: internalHeader.setNumMisordered(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_PKT_CORRUPT case 0xD: internalHeader.setNumCorrupt(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_SEQ_RESET case 0xE: internalHeader.setSeqReset(buf.getUnsignedInt(tlv_v)); break; // FT_TLV_CAP_HOSTNAME case 0xF: pr = new byte[tlv_l]; buf.getBytes(tlv_v, pr, 0, pr.length); // Expected null-terminated string if (pr[pr.length - 1] != 0) { throw new UnsupportedOperationException("Char sequence is not null-terminated"); } internalHeader.setHostname(new String(pr, 0, pr.length - 1)); break; // FT_TLV_COMMENTS case 0x10: pr = new byte[tlv_l]; buf.getBytes(tlv_v, pr, 0, pr.length); // Expected null-terminated string if (pr[pr.length - 1] != 0) { throw new UnsupportedOperationException("Char sequence is not null-terminated"); } internalHeader.setComments(new String(pr, 0, pr.length - 1)); break; // FT_TLV_IF_NAME case 0x11: // uint32_t, uint16_t, string: // - IP address of device // - ifIndex of interface // - interface name long ip = buf.getUnsignedInt(tlv_v); int ifIndex = buf.getUnsignedShort(tlv_v + 4); pr = new byte[tlv_l - 4 - 2]; buf.getBytes(tlv_v + 4 + 2, pr, 0, pr.length); if (pr[pr.length - 1] != 0) { throw new UnsupportedOperationException("Char sequence is not null-terminated"); } internalHeader.setInterfaceName(ip, ifIndex, new String(pr, 0, pr.length - 1)); break; // FT_TLV_IF_ALIAS case 0x12: // uint32_t, uint16_t, uint16_t, string: // - IP address of device // - ifIndex count // - ifIndex of interface (count times) // - alias name long aliasIP = buf.getUnsignedInt(tlv_v); int aliasIfIndexCnt = buf.getUnsignedShort(tlv_v + 4); int aliasIfIndex = buf.getUnsignedShort(tlv_v + 4 + 2); pr = new byte[tlv_l - 4 - 2 - 2]; buf.getBytes(tlv_v + 4 + 2 + 2, pr, 0, pr.length); if (pr[pr.length - 1] != 0) { throw new UnsupportedOperationException("Char sequence is not null-terminated"); } internalHeader.setInterfaceAlias(aliasIP, aliasIfIndexCnt, aliasIfIndex, new String(pr, 0, pr.length - 1)); break; // Case 0x0 default: break; } } if (buf != null && buf.refCnt() > 0) { buf.release(buf.refCnt()); } buf = null; pr = null; } return internalHeader; }
From source file:com.github.sadikovi.netflowlib.record.RecordMaterializer.java
License:Apache License
/** Read buffer bytes sequence for column offset */ public Object readField(Column column, ByteBuf buffer) { Class<?> type = column.getColumnType(); if (type.equals(Byte.class)) { return buffer.getByte(column.getColumnOffset()); } else if (type.equals(Short.class)) { return buffer.getUnsignedByte(column.getColumnOffset()); } else if (type.equals(Integer.class)) { return buffer.getUnsignedShort(column.getColumnOffset()); } else if (type.equals(Long.class)) { return buffer.getUnsignedInt(column.getColumnOffset()); } else {//from w w w . jav a 2s .c o m throw new UnsupportedOperationException("Unsupported read type " + type); } }
From source file:com.github.sadikovi.netflowlib.record.RecordMaterializer.java
License:Apache License
public void updateValueInspector(Column column, ByteBuf buffer, ValueInspector vi) { Class<?> type = column.getColumnType(); if (type.equals(Byte.class)) { vi.update(buffer.getByte(column.getColumnOffset())); } else if (type.equals(Short.class)) { vi.update(buffer.getUnsignedByte(column.getColumnOffset())); } else if (type.equals(Integer.class)) { vi.update(buffer.getUnsignedShort(column.getColumnOffset())); } else if (type.equals(Long.class)) { vi.update(buffer.getUnsignedInt(column.getColumnOffset())); } else {/*from ww w.j a va 2s . c o m*/ throw new UnsupportedOperationException("Unsupported read type " + type); } }
From source file:com.netty.test.LengthFieldBasedExFrameDecoder.java
License:Apache License
private long getFrameLength(ByteBuf in, int actualLengthFieldOffset) { in = in.order(byteOrder);/*www. ja v a 2 s . c o m*/ long frameLength; switch (lengthFieldLength) { case 1: frameLength = in.getUnsignedByte(actualLengthFieldOffset); break; case 2: frameLength = in.getUnsignedShort(actualLengthFieldOffset); break; case 3: frameLength = in.getUnsignedMedium(actualLengthFieldOffset); break; case 4: frameLength = in.getUnsignedInt(actualLengthFieldOffset); break; case 8: frameLength = in.getLong(actualLengthFieldOffset); break; default: throw new Error("should not reach here"); } return frameLength; }
From source file:com.shelf.messagepack.MessagePackFrameDecoder.java
License:Apache License
public long decodeLength(ByteBuf in, int offset) throws Exception { if (discardingTooLongFrame) { long bytesToDiscard = this.bytesToDiscard; int localBytesToDiscard = (int) Math.min(bytesToDiscard, in.readableBytes()); in.skipBytes(localBytesToDiscard); bytesToDiscard -= localBytesToDiscard; this.bytesToDiscard = bytesToDiscard; failIfNecessary(false);// www . j a va 2 s . co m } int readerIndex = in.readerIndex() + offset; short b = in.getUnsignedByte(readerIndex); int ubyte = b & 0xff; LOGGER.trace("message: " + toHex(ubyte)); switch (ubyte) { case NIL: return 1L; case FALSE: return 1L; case TRUE: return 1L; case BIN8: { short length = in.getUnsignedByte(readerIndex + 1); return 2L + length; } case BIN16: { int length = in.getUnsignedShort(readerIndex + 1); return 3L + length; } case BIN32: { long length = in.getUnsignedInt(readerIndex + 1); return 5L + length; } case EXT8: { short length = in.getUnsignedByte(readerIndex + 1); return 3L + length; } case EXT16: { int length = in.getUnsignedShort(readerIndex + 1); return 4L + length; } case EXT32: { long length = in.getUnsignedInt(readerIndex + 1); return 6L + length; } case FLOAT32: return 5L; case FLOAT64: return 9L; case UINT8: return 2L; case UINT16: return 3L; case UINT32: return 5L; case UINT64: return 9L; case INT8: return 2L; case INT16: return 3L; case INT32: return 5L; case INT64: return 9L; case FIXEXT1: return 3L; case FIXEXT2: return 4L; case FIXEXT4: return 6L; case FIXEXT8: return 10L; case FIXEXT16: return 18L; case STR8: { short length = in.getUnsignedByte(readerIndex + 1); return 2L + length; } case STR16: { int length = in.getUnsignedShort(readerIndex + 1); return 3L + length; } case STR32: { long length = in.getUnsignedInt(readerIndex + 1); return 5L + length; } case ARRAY16: { int elemCount = in.getUnsignedShort(readerIndex + 1); return getArraySize(in, 3, offset, elemCount); } case ARRAY32: { long elemCount = in.getUnsignedInt(readerIndex + 1); return getArraySize(in, 5, offset, elemCount); } case MAP16: { int elemCount = in.getUnsignedShort(readerIndex + 1); return getArraySize(in, 3, offset, elemCount * 2); } case MAP32: { long elemCount = in.getUnsignedInt(readerIndex + 1); return getArraySize(in, 5, offset, elemCount * 2); } default: if ((ubyte >> 7) == 0) { //positive fixint return 1L; } else if ((ubyte >> 4) == 0b1000) { //fixmap int elemCount = ubyte & 0b00001111; return getArraySize(in, 1, offset, elemCount * 2); } else if ((ubyte >> 4) == 0b1001) { //fixarray int elemCount = ubyte & 0b00001111; return getArraySize(in, 1, offset, elemCount); } else if ((ubyte >> 5) == 0b101) { //fixstr int length = ubyte & 0b00011111; return 1L + length; } else if ((ubyte >> 5) == 0b111) { //negative fixint return 1L; } else { throw new CorruptedFrameException("Unknown header byte of message: " + toHex(ubyte)); } } }
From source file:com.spotify.ffwd.protobuf.ProtobufDecoder.java
License:Apache License
private void decodeOne(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { final int version = (int) in.getUnsignedInt(0); final long totalLength = in.getUnsignedInt(4); if (totalLength > MAX_FRAME_SIZE) { log.error("Received frame with length (" + totalLength + ") larger than maximum allowed ( " + MAX_FRAME_SIZE + ")"); in.clear();/*from w ww. j a v a2 s . c o m*/ return; } // datagram underflow if (in.readableBytes() < totalLength) { log.error("Received frame of shorter length (" + in.readableBytes() + ") than reported (" + totalLength + ")"); in.clear(); return; } in.skipBytes(8); final Object frame; switch (version) { case 0: frame = decodeFrame0(in); break; default: throw new IllegalArgumentException("Unsupported protocol version: " + version); } if (frame != null) { out.add(frame); } }
From source file:com.spotify.ffwd.riemann.RiemannFrameDecoder.java
License:Apache License
@Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { if (in.readableBytes() < 4) { return;//from w w w.j a v a 2 s . c om } final long length = in.getUnsignedInt(0); if (length > MAX_SIZE) { throw new CorruptedFrameException( String.format("frame size (%s) larger than max (%d)", length, MAX_SIZE)); } final int intLength = (int) length; if (in.readableBytes() < (4 + length)) { return; } in.skipBytes(4); final ByteBuf frame = in.readBytes(intLength); try { out.add(serializer.parse0(frame)); } finally { frame.release(); } }