netty Architecture Docs
Home / Function/ decode() — netty Function Reference

decode() — netty Function Reference

Architecture documentation for the decode() function in SpdyFrameDecoder.java from the netty codebase.

Function java Buffer Allocators calls 4

Entity Profile

Dependency Diagram

graph TD
  d733ec80_8d45_78bf_73a3_4ca9a6e4e860["decode()"]
  d466aa70_56c1_4a3c_18e4_88294be3659b["SpdyFrameDecoder"]
  d733ec80_8d45_78bf_73a3_4ca9a6e4e860 -->|defined in| d466aa70_56c1_4a3c_18e4_88294be3659b
  fe196e54_3dae_3168_c8af_687feab92143["isValidFrameHeader()"]
  d733ec80_8d45_78bf_73a3_4ca9a6e4e860 -->|calls| fe196e54_3dae_3168_c8af_687feab92143
  6c4f3872_c344_d38c_316d_a3c0c6e0e836["isValidUnknownFrameHeader()"]
  d733ec80_8d45_78bf_73a3_4ca9a6e4e860 -->|calls| 6c4f3872_c344_d38c_316d_a3c0c6e0e836
  74ae8469_41de_63b7_e141_8a65d5c87108["hasFlag()"]
  d733ec80_8d45_78bf_73a3_4ca9a6e4e860 -->|calls| 74ae8469_41de_63b7_e141_8a65d5c87108
  eba2fe4a_1ab8_91df_a6a8_371a561c0e47["decodeUnknownFrame()"]
  d733ec80_8d45_78bf_73a3_4ca9a6e4e860 -->|calls| eba2fe4a_1ab8_91df_a6a8_371a561c0e47
  style d733ec80_8d45_78bf_73a3_4ca9a6e4e860 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyFrameDecoder.java lines 101–387

    public void decode(ByteBuf buffer) {
        boolean last;
        int statusCode;

        while (true) {
            switch(state) {
                case READ_COMMON_HEADER:
                    if (buffer.readableBytes() < SPDY_HEADER_SIZE) {
                        return;
                    }

                    int frameOffset  = buffer.readerIndex();
                    int flagsOffset  = frameOffset + SPDY_HEADER_FLAGS_OFFSET;
                    int lengthOffset = frameOffset + SPDY_HEADER_LENGTH_OFFSET;
                    buffer.skipBytes(SPDY_HEADER_SIZE);

                    boolean control = (buffer.getByte(frameOffset) & 0x80) != 0;

                    int version;
                    if (control) {
                        // Decode control frame common header
                        version = getUnsignedShort(buffer, frameOffset) & 0x7FFF;
                        frameType = getUnsignedShort(buffer, frameOffset + SPDY_HEADER_TYPE_OFFSET);
                        streamId = 0; // Default to session Stream-ID
                    } else {
                        // Decode data frame common header
                        version = spdyVersion; // Default to expected version
                        frameType = SPDY_DATA_FRAME;
                        streamId = getUnsignedInt(buffer, frameOffset);
                    }

                    flags  = buffer.getByte(flagsOffset);
                    length = getUnsignedMedium(buffer, lengthOffset);

                    // Check version first then validity
                    if (version != spdyVersion) {
                        state = State.FRAME_ERROR;
                        delegate.readFrameError("Invalid SPDY Version");
                    } else if (!isValidFrameHeader(streamId, frameType, flags, length)) {
                        state = State.FRAME_ERROR;
                        delegate.readFrameError("Invalid Frame Error");
                    } else if (isValidUnknownFrameHeader(streamId, frameType, flags, length)) {
                        state = State.READ_UNKNOWN_FRAME;
                    } else {
                        state = getNextState(frameType, length);
                    }
                    break;

                case READ_DATA_FRAME:
                    if (length == 0) {
                        state = State.READ_COMMON_HEADER;
                        delegate.readDataFrame(streamId, hasFlag(flags, SPDY_DATA_FLAG_FIN), Unpooled.buffer(0));
                        break;
                    }

                    // Generate data frames that do not exceed maxChunkSize
                    int dataLength = Math.min(maxChunkSize, length);

                    // Wait until entire frame is readable
                    if (buffer.readableBytes() < dataLength) {
                        return;
                    }

                    ByteBuf data = buffer.readRetainedSlice(dataLength);
                    length -= dataLength;

                    if (length == 0) {
                        state = State.READ_COMMON_HEADER;
                    }

                    last = length == 0 && hasFlag(flags, SPDY_DATA_FLAG_FIN);

                    delegate.readDataFrame(streamId, last, data);
                    break;

                case READ_SYN_STREAM_FRAME:
                    if (buffer.readableBytes() < 10) {
                        return;
                    }

                    int offset = buffer.readerIndex();

Domain

Subdomains

Defined In

Calls

Source

Frequently Asked Questions

What does decode() do?
decode() is a function in the netty codebase, defined in codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyFrameDecoder.java.
Where is decode() defined?
decode() is defined in codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyFrameDecoder.java at line 101.
What does decode() call?
decode() calls 4 function(s): decodeUnknownFrame, hasFlag, isValidFrameHeader, isValidUnknownFrameHeader.

Analyze Your Own Codebase

Get architecture documentation, dependency graphs, and domain analysis for your codebase in minutes.

Try Supermodel Free