#include <Receiver.h>

Inheritance diagram for web::websocket::Receiver:

Collaboration diagram for web::websocket::Receiver:

Classes
union	MaskingKey

Public Member Functions
	Receiver (core::socket::stream::SocketConnection *socketConnection)

	Receiver (const Receiver &)=delete

Receiver &	operator= (const Receiver &)=delete

virtual	~Receiver ()

std::size_t	receive ()

Private Types
enum struct	ParserState { BEGIN , OPCODE , LENGTH , ELENGTH , MASKINGKEY , PAYLOAD , ERROR }

Private Member Functions
std::size_t	readOpcode ()

std::size_t	readLength ()

std::size_t	readELength ()

std::size_t	readMaskingKey ()

std::size_t	readPayload ()

virtual void	onMessageStart (int opCode)=0

virtual void	onMessageData (const char *chunk, uint64_t chunkLen)=0

virtual void	onMessageEnd ()=0

virtual void	onMessageError (uint16_t errnum)=0

std::size_t	readFrameData (char *chunk, std::size_t chunkLen)

void	reset ()

Private Attributes
enum web::websocket::Receiver::ParserState	parserState = ParserState::BEGIN

bool	fin = false

bool	continuation = false

bool	masked = false

uint8_t	opCode = 0

uint8_t	elengthNumBytes = 0

uint8_t	elengthNumBytesLeft = 0

uint64_t	payLoadNumBytes = 0

uint64_t	payLoadNumBytesLeft = 0

uint32_t	maskingKey = 0

MaskingKey	maskingKeyAsArray {}

uint8_t	maskingKeyNumBytes = 4

uint8_t	maskingKeyNumBytesLeft = 4

uint16_t	errorState = 0

char	elengthChunk [8] {}

char	maskingKeyChunk [4] {}

char	payloadChunk [16384] {}

core::socket::stream::SocketConnection *	socketConnection = nullptr

Detailed Description

Definition at line 64 of file Receiver.h.

Member Enumeration Documentation

◆ ParserState

enum struct web::websocket::Receiver::ParserState

strongprivate

Enumerator
BEGIN
OPCODE
LENGTH
ELENGTH
MASKINGKEY
PAYLOAD
ERROR

Definition at line 97 of file Receiver.h.

97{ BEGIN, OPCODE, LENGTH, ELENGTH, MASKINGKEY, PAYLOAD, ERROR } parserState = ParserState::BEGIN;

web::websocket::Receiver::ParserState::OPCODE

@ OPCODE

web::websocket::Receiver::ParserState::BEGIN

@ BEGIN

web::websocket::Receiver::ParserState::MASKINGKEY

@ MASKINGKEY

web::websocket::Receiver::ParserState::ELENGTH

@ ELENGTH

web::websocket::Receiver::ParserState::LENGTH

@ LENGTH

web::websocket::Receiver::ParserState::ERROR

@ ERROR

web::websocket::Receiver::ParserState::PAYLOAD

@ PAYLOAD

web::websocket::Receiver::parserState

enum web::websocket::Receiver::ParserState parserState

Constructor & Destructor Documentation

◆ Receiver() [1/2]

web::websocket::Receiver::Receiver ( core::socket::stream::SocketConnection * socketConnection )

Definition at line 58 of file Receiver.cpp.

59 : socketConnection(socketConnection) {

60 }

web::websocket::Receiver::socketConnection

core::socket::stream::SocketConnection * socketConnection

Definition Receiver.h:122

Referenced by web::websocket::SubProtocolContext::SubProtocolContext().

Here is the caller graph for this function:

◆ Receiver() [2/2]

web::websocket::Receiver::Receiver ( const Receiver & )

delete

◆ ~Receiver()

web::websocket::Receiver::~Receiver ( )

virtual

Definition at line 62 of file Receiver.cpp.

62 {

63 }

Member Function Documentation

◆ onMessageData()

virtual void web::websocket::Receiver::onMessageData	(	const char *	chunk,
		uint64_t	chunkLen )

privatepure virtual

Implemented in web::websocket::SocketContextUpgrade< SubProtocolT, RequestT, ResponseT >, web::websocket::SocketContextUpgrade< SubProtocol, web::http::client::Request, web::http::client::Response >, and web::websocket::SocketContextUpgrade< SubProtocol, web::http::server::Request, web::http::server::Response >.

◆ onMessageEnd()

virtual void web::websocket::Receiver::onMessageEnd ( )

privatepure virtual

Implemented in web::websocket::SocketContextUpgrade< SubProtocolT, RequestT, ResponseT >, web::websocket::SocketContextUpgrade< SubProtocol, web::http::client::Request, web::http::client::Response >, and web::websocket::SocketContextUpgrade< SubProtocol, web::http::server::Request, web::http::server::Response >.

◆ onMessageError()

virtual void web::websocket::Receiver::onMessageError ( uint16_t errnum )

privatepure virtual

Implemented in web::websocket::SocketContextUpgrade< SubProtocolT, RequestT, ResponseT >, web::websocket::SocketContextUpgrade< SubProtocol, web::http::client::Request, web::http::client::Response >, and web::websocket::SocketContextUpgrade< SubProtocol, web::http::server::Request, web::http::server::Response >.

◆ onMessageStart()

virtual void web::websocket::Receiver::onMessageStart ( int opCode )

privatepure virtual

Implemented in web::websocket::SocketContextUpgrade< SubProtocolT, RequestT, ResponseT >, web::websocket::SocketContextUpgrade< SubProtocol, web::http::client::Request, web::http::client::Response >, and web::websocket::SocketContextUpgrade< SubProtocol, web::http::server::Request, web::http::server::Response >.

◆ operator=()

Receiver & web::websocket::Receiver::operator= ( const Receiver & )

delete

◆ readELength()

std::size_t web::websocket::Receiver::readELength ( )

private

Definition at line 166 of file Receiver.cpp.

                                    {
        const std::size_t ret = readFrameData(elengthChunk, elengthNumBytesLeft);
 
        for (std::size_t i = 0; i < ret; i++) {
            payLoadNumBytes |= *reinterpret_cast<uint64_t*>(elengthChunk + i) << (elengthNumBytes - elengthNumBytesLeft) * 8;
 
            elengthNumBytesLeft--;
        }
 
        if (elengthNumBytesLeft == 0) {
            switch (elengthNumBytes) {
                case 2:
                    payLoadNumBytes = payLoadNumBytesLeft = be16toh(static_cast<uint16_t>(payLoadNumBytes));
                    break;
                case 8:
                    payLoadNumBytes = payLoadNumBytesLeft = be64toh(payLoadNumBytes);
                    break;
            }
 
            if ((payLoadNumBytes & static_cast<uint64_t>(0x01) << 63) != 0) {
                parserState = ParserState::ERROR;
                errorState = 1004;
            } else if (masked) {
                parserState = ParserState::MASKINGKEY;
            } else {
                parserState = ParserState::PAYLOAD;
            }
        }
 
        return ret;
    }

◆ readFrameData()

std::size_t web::websocket::Receiver::readFrameData	(	char *	chunk,
		std::size_t	chunkLen )

private

Definition at line 279 of file Receiver.cpp.

                                                                     {
        return socketConnection->readFromPeer(chunk, chunkLen);
    }

◆ readLength()

std::size_t web::websocket::Receiver::readLength ( )

private

Definition at line 128 of file Receiver.cpp.

                                   {
        char byte = 0;
        const std::size_t ret = readFrameData(&byte, 1);
 
        if (ret > 0) {
            const uint8_t lengthByte = static_cast<uint8_t>(byte);
 
            masked = (lengthByte & 0b10000000) != 0;
            payLoadNumBytes = payLoadNumBytesLeft = lengthByte & 0b01111111;
 
            if (payLoadNumBytes > 125) {
                switch (payLoadNumBytes) {
                    case 126:
                        elengthNumBytes = elengthNumBytesLeft = 2;
                        break;
                    case 127:
                        elengthNumBytes = elengthNumBytesLeft = 8;
                        break;
                }
                parserState = ParserState::ELENGTH;
                payLoadNumBytes = payLoadNumBytesLeft = 0;
            } else {
                if (masked) {
                    parserState = ParserState::MASKINGKEY;
                } else if (payLoadNumBytes > 0) {
                    parserState = ParserState::PAYLOAD;
                } else {
                    if (fin) {
                        onMessageEnd();
                    }
                    reset();
                }
            }
        }
 
        return ret;
    }

◆ readMaskingKey()

std::size_t web::websocket::Receiver::readMaskingKey ( )

private

Definition at line 198 of file Receiver.cpp.

                                       {
        const std::size_t ret = readFrameData(maskingKeyChunk, maskingKeyNumBytesLeft);
 
        for (std::size_t i = 0; i < ret; i++) {
            maskingKey |= static_cast<uint32_t>(*reinterpret_cast<unsigned char*>(maskingKeyChunk + i))
                          << (maskingKeyNumBytes - maskingKeyNumBytesLeft) * 8;
            maskingKeyNumBytesLeft--;
        }
 
        if (maskingKeyNumBytesLeft == 0) {
            maskingKeyAsArray = {.key = maskingKey};
 
            if (payLoadNumBytes > 0) {
                parserState = ParserState::PAYLOAD;
            } else {
                if (fin) {
                    onMessageEnd();
                }
                reset();
            }
        }
 
        return ret;
    }

◆ readOpcode()

std::size_t web::websocket::Receiver::readOpcode ( )

private

Definition at line 102 of file Receiver.cpp.

                                   {
        char byte = 0;
        const std::size_t ret = readFrameData(&byte, 1);
 
        if (ret > 0) {
            const uint8_t opCodeByte = static_cast<uint8_t>(byte);
 
            fin = (opCodeByte & 0b10000000) != 0;
            opCode = opCodeByte & 0b00001111;
 
            if (!continuation) {
                onMessageStart(opCode);
                parserState = ParserState::LENGTH;
            } else if (opCode == 0) {
                parserState = ParserState::LENGTH;
            } else {
                parserState = ParserState::ERROR;
                errorState = 1002;
                LOG(ERROR) << "WebSocket: Error opcode in continuation frame";
            }
            continuation = !fin;
        }
 
        return ret;
    }

◆ readPayload()

std::size_t web::websocket::Receiver::readPayload ( )

private

Definition at line 223 of file Receiver.cpp.

                                    {
        const std::size_t payloadChunkLeft = (MAX_PAYLOAD_JUNK_LEN <= payLoadNumBytesLeft) ? static_cast<std::size_t>(MAX_PAYLOAD_JUNK_LEN)
                                                                                           : static_cast<std::size_t>(payLoadNumBytesLeft);
 
        const std::size_t ret = readFrameData(payloadChunk, payloadChunkLeft);
 
        if (ret > 0) {
            const std::size_t payloadChunkLen = static_cast<std::size_t>(ret);
 
            if (masked) {
                for (std::size_t i = 0; i < payloadChunkLen; i++) {
                    *(payloadChunk + i) =
                        *(payloadChunk + i) ^ *(maskingKeyAsArray.keyAsArray + (i + payLoadNumBytes - payLoadNumBytesLeft) % 4);
                }
            }
 
            LOG(TRACE) << "WebSocket receive: Frame data\n" << utils::hexDump(payloadChunk, payloadChunkLen, 32, true);
 
            onMessageData(payloadChunk, payloadChunkLen);
 
            payLoadNumBytesLeft -= payloadChunkLen;
        }
 
        if (payLoadNumBytesLeft == 0) {
            if (fin) {
                onMessageEnd();
            }
            reset();
        }
 
        return ret;
    }

◆ receive()

std::size_t web::websocket::Receiver::receive ( )

Definition at line 65 of file Receiver.cpp.

                                {
        std::size_t ret = 0;
        std::size_t consumed = 0;
 
        // dumpFrame(chunk, chunkLen);
 
        do {
            switch (parserState) {
                case ParserState::BEGIN:
                    parserState = ParserState::OPCODE;
                    [[fallthrough]];
                case ParserState::OPCODE:
                    ret = readOpcode();
                    break;
                case ParserState::LENGTH:
                    ret = readLength();
                    break;
                case ParserState::ELENGTH:
                    ret = readELength();
                    break;
                case ParserState::MASKINGKEY:
                    ret = readMaskingKey();
                    break;
                case ParserState::PAYLOAD:
                    ret = readPayload();
                    break;
                case ParserState::ERROR:
                    onMessageError(errorState);
                    reset();
                    break;
            }
            consumed += ret;
        } while (ret > 0 && parserState != ParserState::BEGIN && parserState != ParserState::ERROR);
 
        return consumed;
    }

◆ reset()

void web::websocket::Receiver::reset ( )

private

Definition at line 256 of file Receiver.cpp.

                         {
        parserState = ParserState::BEGIN;
 
        fin = false;
        continuation = false;
        masked = false;
 
        opCode = 0;
 
        elengthNumBytes = 0;
        elengthNumBytesLeft = 0;
 
        payLoadNumBytes = 0;
        payLoadNumBytesLeft = 0;
 
        maskingKey = 0;
        maskingKeyAsArray = {.key = 0};
        maskingKeyNumBytes = 4;
        maskingKeyNumBytesLeft = 4;
 
        errorState = 0;
    }

Member Data Documentation

◆ continuation

bool web::websocket::Receiver::continuation = false

private

Definition at line 100 of file Receiver.h.

◆ elengthChunk

char web::websocket::Receiver::elengthChunk[8] {}

private

Definition at line 118 of file Receiver.h.

118{};

◆ elengthNumBytes

uint8_t web::websocket::Receiver::elengthNumBytes = 0

private

Definition at line 105 of file Receiver.h.

◆ elengthNumBytesLeft

uint8_t web::websocket::Receiver::elengthNumBytesLeft = 0

private

Definition at line 106 of file Receiver.h.

◆ errorState

uint16_t web::websocket::Receiver::errorState = 0

private

Definition at line 116 of file Receiver.h.

◆ fin

bool web::websocket::Receiver::fin = false

private

Definition at line 99 of file Receiver.h.

◆ masked

bool web::websocket::Receiver::masked = false

private

Definition at line 101 of file Receiver.h.

◆ maskingKey

uint32_t web::websocket::Receiver::maskingKey = 0

private

Definition at line 111 of file Receiver.h.

◆ maskingKeyAsArray

MaskingKey web::websocket::Receiver::maskingKeyAsArray {}

private

Definition at line 112 of file Receiver.h.

112{};

◆ maskingKeyChunk

char web::websocket::Receiver::maskingKeyChunk[4] {}

private

Definition at line 119 of file Receiver.h.

119{};

◆ maskingKeyNumBytes

uint8_t web::websocket::Receiver::maskingKeyNumBytes = 4

private

Definition at line 113 of file Receiver.h.

◆ maskingKeyNumBytesLeft

uint8_t web::websocket::Receiver::maskingKeyNumBytesLeft = 4

private

Definition at line 114 of file Receiver.h.

◆ opCode

uint8_t web::websocket::Receiver::opCode = 0

private

Definition at line 103 of file Receiver.h.

◆ parserState

enum web::websocket::Receiver::ParserState web::websocket::Receiver::parserState = ParserState::BEGIN

private

◆ payloadChunk

char web::websocket::Receiver::payloadChunk[16384] {}

private

Definition at line 120 of file Receiver.h.

120{};

◆ payLoadNumBytes

uint64_t web::websocket::Receiver::payLoadNumBytes = 0

private

Definition at line 108 of file Receiver.h.

◆ payLoadNumBytesLeft

uint64_t web::websocket::Receiver::payLoadNumBytesLeft = 0

private

Definition at line 109 of file Receiver.h.

◆ socketConnection

core::socket::stream::SocketConnection* web::websocket::Receiver::socketConnection = nullptr

private

Definition at line 122 of file Receiver.h.

The documentation for this class was generated from the following files:

web/websocket/Receiver.h
web/websocket/Receiver.cpp

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ParserState

Constructor & Destructor Documentation

◆ Receiver() [1/2]

◆ Receiver() [2/2]

◆ ~Receiver()

Member Function Documentation

◆ onMessageData()

◆ onMessageEnd()

◆ onMessageError()

◆ onMessageStart()

◆ operator=()

◆ readELength()

◆ readFrameData()

◆ readLength()

◆ readMaskingKey()

◆ readOpcode()

◆ readPayload()

◆ receive()

◆ reset()

Member Data Documentation

◆ continuation

◆ elengthChunk

◆ elengthNumBytes

◆ elengthNumBytesLeft

◆ errorState

◆ fin

◆ masked

◆ maskingKey

◆ maskingKeyAsArray

◆ maskingKeyChunk

◆ maskingKeyNumBytes

◆ maskingKeyNumBytesLeft

◆ opCode

◆ parserState

◆ payloadChunk

◆ payLoadNumBytes

◆ payLoadNumBytesLeft

◆ socketConnection