Example usage for io.netty.buffer ByteBuf getUnsignedInt

List of usage examples for io.netty.buffer ByteBuf getUnsignedInt

Introduction

In this page you can find the example usage for io.netty.buffer ByteBuf getUnsignedInt.

Prototype

public abstract long getUnsignedInt(int index);

Source Link

Document

Gets an unsigned 32-bit integer at the specified absolute index in this buffer.

Usage

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();
    }
}