Cppcheck - HTML report - GATE C/C++ Framework

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/net/mqttprotocols.h"
#include "gate/libraries.h"
#include "gate/streams.h"
#include "gate/results.h"
#include "gate/serializers.h"
#include "gate/debugging.h"


/* #include <mosquitto.h> */


gate_result_t gate_mqtt_write_byte(gate_stream_t* stream, gate_uint8_t value)
{
    return gate_stream_write(stream, (char const*)&value, 1, NULL);
}

gate_result_t gate_mqtt_write_word(gate_stream_t* stream, gate_uint16_t value)
{
    char buff[4];
    gate_size_t len = gate_serialize_uint16_b(buff, sizeof(buff), &value);
    return gate_stream_write_block(stream, buff, len, NULL);
}

gate_result_t gate_mqtt_write_length(gate_stream_t* stream, gate_size_t value)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t bufferused = 0;
    unsigned char encoded_char;

    while (GATE_SUCCEEDED(ret))
    {
        encoded_char = value % 128;
        value /= 128;
        if (value > 0)
        {
            encoded_char |= 128;
        }
        ret = gate_stream_write(stream, (char const*)&encoded_char, 1, NULL);
        if (value == 0)
        {
            /* all bits are encoded, we are done */
            break;
        }
    }
    return ret;
}

gate_result_t gate_mqtt_write_string(gate_stream_t* stream, char const* str, gate_size_t length)
{
    gate_uint16_t const len = (gate_uint16_t)length;
    gate_result_t ret = gate_mqtt_write_word(stream, len);
    if (GATE_SUCCEEDED(ret))
    {
        ret = gate_stream_write(stream, str, length, NULL);
    }
    return ret;
}

gate_result_t gate_mqtt_read_byte(gate_stream_t* stream, gate_uint8_t* value)
{
    char chr = 0;
    gate_size_t received = 0;
    gate_result_t ret = gate_stream_read(stream, &chr, 1, &received);
    if (GATE_SUCCEEDED(ret))
    {
        if (received != 1)
        {
            ret = GATE_RESULT_ENDOFSTREAM;
        }
        else
        {
            *value = (gate_uint8_t)chr;
        }
    }
    return ret;
}

gate_result_t gate_mqtt_read_word(gate_stream_t* stream, gate_uint16_t* value)
{
    char buff[2];
    gate_size_t received = 0;
    gate_result_t ret = gate_stream_read_block(stream, &buff[0], 2, &received);
    if (GATE_SUCCEEDED(ret))
    {
        if (received != 2)
        {
            ret = GATE_RESULT_ENDOFSTREAM;
        }
        else
        {
            gate_deserialize_uint16_b(buff, 2, value);
        }
    }
    return ret;
}
gate_result_t gate_mqtt_read_length(gate_stream_t* stream, gate_size_t* ptr_value)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_size_t value = 0;
    unsigned char b;
    gate_size_t len_received = 0;
    gate_size_t multiplier = 1;

    do
    {
        ret = gate_stream_read(stream, (char*)&b, 1, &len_received);
        GATE_BREAK_IF_FAILED(ret);
        if (len_received == 0)
        {
            ret = GATE_RESULT_ENDOFSTREAM;
            break;
        }
        value += (b & 127) * multiplier;
        multiplier *= 128;
        if (multiplier > 128 * 128 * 128)
        {
            ret = GATE_RESULT_INVALIDCONTENT;
            break;
        }
    } while ((b & 128) != 0);

    if (ptr_value)
    {
        *ptr_value = value;
    }
    return ret;
}
gate_result_t gate_mqtt_read_string(gate_stream_t* stream, gate_strbuilder_t* builder)
{
    char buffer[4096];<--- The scope of the variable 'buffer' can be reduced. [+]The scope of the variable 'buffer' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_size_t transferred = 0;
    gate_size_t received = 0;
    gate_uint16_t str_length = 0;
    gate_result_t ret = gate_mqtt_read_word(stream, &str_length);
    if (GATE_SUCCEEDED(ret))
    {
        while (transferred < str_length)
        {
            gate_size_t required = str_length - transferred;
            if (required > sizeof(buffer))
            {
                required = sizeof(buffer);
            }
            ret = gate_stream_read_block(stream, buffer, required, &received);
            GATE_BREAK_IF_FAILED(ret);
            gate_strbuilder_append_text(builder, buffer, received);
            if (received < required)
            {
                ret = GATE_RESULT_INVALIDCONTENT;
                break;
            }
            transferred += received;
        }
    }
    return ret;
}

gate_result_t gate_mqtt_read_string_length_skip_data(gate_stream_t* stream, gate_uint16_t* ptr_length)
{
    char buffer[4096];<--- The scope of the variable 'buffer' can be reduced. [+]The scope of the variable 'buffer' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_size_t transferred = 0;
    gate_size_t received = 0;
    gate_uint16_t str_length = 0;
    gate_result_t ret = gate_mqtt_read_word(stream, &str_length);
    if (GATE_SUCCEEDED(ret))
    {
        if (ptr_length)
        {
            *ptr_length = str_length;
        }
        while (transferred < str_length)
        {
            gate_size_t required = str_length - transferred;
            if (required > sizeof(buffer))
            {
                required = sizeof(buffer);
            }
            ret = gate_stream_read_block(stream, buffer, required, &received);
            GATE_BREAK_IF_FAILED(ret);
            if (received < required)
            {
                ret = GATE_RESULT_INVALIDCONTENT;
                break;
            }
            transferred += received;
        }
    }
    return ret;
}


static gate_result_t serialize_memstream_packet(
    gate_stream_t* output_stream,
    gate_mqtt_packet_type_t packet_type,
    unsigned char packet_flags,
    gate_memstream_t* memstream)
{
    gate_uint8_t const fixed_header_byte = (((gate_uint8_t)packet_type & 0x0f) << 4) | (packet_flags & 0x0f);
    char const* const ptr_content = gate_memstream_get_data(memstream);
    gate_size_t const content_size = gate_memstream_size(memstream);
    gate_result_t ret;

    do
    {
        ret = gate_mqtt_write_byte(output_stream, fixed_header_byte);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_mqtt_write_length(output_stream, content_size);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_stream_write_block(output_stream, ptr_content, content_size, NULL);
        GATE_BREAK_IF_FAILED(ret);
    } while (0);
    return ret;
}

static gate_result_t serialize_connect_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_memstream_impl_t data_memstream_impl;
    char data_memstream_buffer[4096];

    gate_memstream_t* const data_memstream = gate_memstream_create_static_unmanaged(&data_memstream_impl, data_memstream_buffer, sizeof(data_memstream_buffer), 0);
    gate_stream_t* const data_stream = (gate_stream_t*)data_memstream;

    do
    {
        /* var header */
        ret = gate_mqtt_write_string(data_stream, "MQTT", 4);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_mqtt_write_byte(data_stream, msg->content.connect.level);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_mqtt_write_byte(data_stream, msg->content.connect.flags);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_mqtt_write_word(data_stream, msg->content.connect.keep_alive);
        GATE_BREAK_IF_FAILED(ret);

        /* payload */
        ret = gate_mqtt_write_string(data_stream, msg->content.connect.client_id, msg->content.connect.client_id_len);
        GATE_BREAK_IF_FAILED(ret);
        if (GATE_FLAG_ENABLED(msg->content.connect.flags, GATE_MQTT_CONNECT_FLAG_WILLFLAG))
        {
            ret = gate_mqtt_write_string(data_stream, msg->content.connect.will_topic, msg->content.connect.will_topic_len);
            GATE_BREAK_IF_FAILED(ret);
            ret = gate_mqtt_write_string(data_stream, msg->content.connect.will_message, msg->content.connect.will_message_len);
            GATE_BREAK_IF_FAILED(ret);
        }
        if (GATE_FLAG_ENABLED(msg->content.connect.flags, GATE_MQTT_CONNECT_FLAG_USER))
        {
            ret = gate_mqtt_write_string(data_stream, msg->content.connect.user, msg->content.connect.user_len);
            GATE_BREAK_IF_FAILED(ret);
        }
        if (GATE_FLAG_ENABLED(msg->content.connect.flags, GATE_MQTT_CONNECT_FLAG_PASSWORD))
        {
            ret = gate_mqtt_write_string(data_stream, msg->content.connect.password, msg->content.connect.password_len);
            GATE_BREAK_IF_FAILED(ret);
        }

        /* build full packet */
        ret = serialize_memstream_packet(output_stream, gate_mqtt_packet_connect, msg->packet_flags, data_memstream);
    } while (0);
    return ret;
}

static gate_result_t serialize_connect_ack_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_memstream_impl_t data_memstream_impl;
    char data_memstream_buffer[64];

    gate_memstream_t* const data_memstream = gate_memstream_create_static_unmanaged(&data_memstream_impl, data_memstream_buffer, sizeof(data_memstream_buffer), 0);
    gate_stream_t* const data_stream = (gate_stream_t*)data_memstream;

    do
    {
        /* var header */
        ret = gate_mqtt_write_byte(data_stream, msg->content.connect_ack.flags);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_mqtt_write_byte(data_stream, msg->content.connect_ack.return_code);
        GATE_BREAK_IF_FAILED(ret);

        /* build full packet */
        ret = serialize_memstream_packet(output_stream, gate_mqtt_packet_connect_ack, msg->packet_flags, data_memstream);
        GATE_BREAK_IF_FAILED(ret);

        /* succeeded */
    } while (0);
    return ret;
}

static gate_result_t serialize_pubish_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg)
{
    gate_result_t ret;
    gate_size_t written = 0;
    gate_memstream_t* data_memstream = NULL;
    gate_stream_t* data_stream;<--- The scope of the variable 'data_stream' can be reduced. [+]The scope of the variable 'data_stream' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    do
    {
        const gate_size_t content_len = msg->content.publish.data_len + msg->content.publish.topic_len + 5;
        data_memstream = gate_memstream_create(content_len);
        if (NULL == data_memstream)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        data_stream = (gate_stream_t*)data_memstream;


        /* var header */
        ret = gate_mqtt_write_string(data_stream, msg->content.publish.topic, msg->content.publish.topic_len);
        GATE_BREAK_IF_FAILED(ret);

        if (GATE_FLAG_ENABLED(msg->packet_flags, GATE_MQTT_FLAG_QOS1) || GATE_FLAG_ENABLED(msg->packet_flags, GATE_MQTT_FLAG_QOS2))
        {
            ret = gate_mqtt_write_word(data_stream, msg->content.publish.packet_identifier);
            GATE_BREAK_IF_FAILED(ret);
        }

        /* payload  */
        ret = gate_stream_write_block(data_stream, msg->content.publish.data, msg->content.publish.data_len, &written);
        GATE_BREAK_IF_FAILED(ret);

        /* build full packet */
        ret = serialize_memstream_packet(output_stream, gate_mqtt_packet_publish, msg->packet_flags, data_memstream);
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    if (data_memstream != NULL)
    {
        gate_object_release(data_memstream);
    }

    return ret;
}


static gate_result_t serialize_nocontent_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg)
{
    gate_memstream_impl_t data_memstream_impl;
    gate_memstream_t* data_memstream = gate_memstream_create_static_unmanaged(&data_memstream_impl, NULL, 0, 0);
    return serialize_memstream_packet(output_stream, msg->packet_type, msg->packet_flags, data_memstream);
}

static gate_result_t serialize_packet_identifier_only_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg, gate_uint16_t id)
{
    char buffer[16];
    gate_memstream_impl_t data_memstream_impl;
    gate_memstream_t* data_memstream = gate_memstream_create_static_unmanaged(&data_memstream_impl, buffer, sizeof(buffer), 0);

    gate_result_t result = gate_mqtt_write_word((gate_stream_t*)data_memstream, id);

    if (GATE_SUCCEEDED(result))
    {
        result = serialize_memstream_packet(output_stream, msg->packet_type, msg->packet_flags, data_memstream);
    }
    return result;
}

static gate_result_t serialize_subscribe_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg)
{
    gate_result_t ret;
    gate_size_t written = 0;
    gate_memstream_t* data_memstream = NULL;
    gate_stream_t* data_stream;<--- The scope of the variable 'data_stream' can be reduced. [+]The scope of the variable 'data_stream' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_mqtt_subscription_t const* subscr;<--- The scope of the variable 'subscr' can be reduced. [+]The scope of the variable 'subscr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_uint16_t subscr_count;

    do
    {
        data_memstream = gate_memstream_create(128);
        if (NULL == data_memstream)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        data_stream = (gate_stream_t*)data_memstream;


        /* var header */
        ret = gate_mqtt_write_word(data_stream, msg->content.subscribe.packet_identifier);
        GATE_BREAK_IF_FAILED(ret);

        /* payload */
        subscr_count = msg->content.subscribe.topics_count;
        subscr = msg->content.subscribe.topics;
        for (; subscr_count > 0; --subscr_count, ++subscr)
        {
            ret = gate_mqtt_write_string(data_stream, subscr->topic, subscr->topic_len);
            GATE_BREAK_IF_FAILED(ret);

            ret = gate_mqtt_write_byte(data_stream, subscr->qos);
            GATE_BREAK_IF_FAILED(ret);
        }

        GATE_BREAK_IF_FAILED(ret);

        /* build full packet */
        ret = serialize_memstream_packet(output_stream, gate_mqtt_packet_subscribe, 0x02, data_memstream);
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    if (data_memstream != NULL)
    {
        gate_object_release(data_memstream);
    }

    return ret;
}

static gate_result_t serialize_subscribe_ack_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg)
{
    gate_result_t ret;
    gate_size_t written = 0;
    gate_memstream_t* data_memstream = NULL;
    gate_stream_t* data_stream;<--- The scope of the variable 'data_stream' can be reduced. [+]The scope of the variable 'data_stream' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_uint8_t const* ret_codes;<--- The scope of the variable 'ret_codes' can be reduced. [+]The scope of the variable 'ret_codes' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_uint16_t ret_codes_count;

    do
    {
        data_memstream = gate_memstream_create(128);
        if (NULL == data_memstream)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        data_stream = (gate_stream_t*)data_memstream;


        /* var header */
        ret = gate_mqtt_write_word(data_stream, msg->content.subscribe_ack.packet_identifier);
        GATE_BREAK_IF_FAILED(ret);

        /* payload */
        ret_codes_count = msg->content.subscribe_ack.ret_codes_count;
        ret_codes = msg->content.subscribe_ack.ret_codes;
        for (; ret_codes_count > 0; --ret_codes_count, ++ret_codes)
        {
            ret = gate_mqtt_write_byte(data_stream, *ret_codes);
            GATE_BREAK_IF_FAILED(ret);
        }

        GATE_BREAK_IF_FAILED(ret);

        /* build full packet */
        ret = serialize_memstream_packet(output_stream, gate_mqtt_packet_subscribe_ack, msg->packet_flags, data_memstream);
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    if (data_memstream != NULL)
    {
        gate_object_release(data_memstream);
    }

    return ret;
}

static gate_result_t serialize_unsubscribe_message(gate_stream_t* output_stream, gate_mqtt_message_t const* msg)
{
    gate_result_t ret;
    gate_size_t written = 0;
    gate_memstream_t* data_memstream = NULL;
    gate_stream_t* data_stream;<--- The scope of the variable 'data_stream' can be reduced. [+]The scope of the variable 'data_stream' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_mqtt_subscription_t const* subscr;<--- The scope of the variable 'subscr' can be reduced. [+]The scope of the variable 'subscr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_uint16_t subscr_count;

    do
    {
        data_memstream = gate_memstream_create(128);
        if (NULL == data_memstream)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        data_stream = (gate_stream_t*)data_memstream;


        /* var header */
        ret = gate_mqtt_write_word(data_stream, msg->content.subscribe.packet_identifier);
        GATE_BREAK_IF_FAILED(ret);

        /* payload */
        subscr_count = msg->content.unsubscribe.topics_count;
        subscr = msg->content.unsubscribe.topics;
        for (; subscr_count > 0; --subscr_count, ++subscr)
        {
            ret = gate_mqtt_write_string(data_stream, subscr->topic, subscr->topic_len);
            GATE_BREAK_IF_FAILED(ret);
        }

        GATE_BREAK_IF_FAILED(ret);

        /* build full packet */
        ret = serialize_memstream_packet(output_stream, gate_mqtt_packet_subscribe, msg->packet_flags, data_memstream);
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    if (data_memstream != NULL)
    {
        gate_object_release(data_memstream);
    }

    return ret;
}


gate_result_t gate_mqtt_send_message(gate_stream_t* mqtt_stream, gate_mqtt_message_t const* msg)
{
    if (!mqtt_stream || !msg)
    {
        return GATE_RESULT_INVALIDARG;
    }

    switch (msg->packet_type)
    {
    case gate_mqtt_packet_connect:			return serialize_connect_message(mqtt_stream, msg);
    case gate_mqtt_packet_connect_ack:		return serialize_connect_ack_message(mqtt_stream, msg);
    case gate_mqtt_packet_publish:			return serialize_pubish_message(mqtt_stream, msg);
    case gate_mqtt_packet_publish_ack:		return serialize_packet_identifier_only_message(mqtt_stream, msg, msg->content.publish_ack.packet_identifier);
    case gate_mqtt_packet_publish_receive:	return serialize_packet_identifier_only_message(mqtt_stream, msg, msg->content.publish_received.packet_identifier);
    case gate_mqtt_packet_publish_release:	return serialize_packet_identifier_only_message(mqtt_stream, msg, msg->content.publish_release.packet_identifier);
    case gate_mqtt_packet_publish_complete:	return serialize_packet_identifier_only_message(mqtt_stream, msg, msg->content.publish_complete.packet_identifier);
    case gate_mqtt_packet_subscribe:		return serialize_subscribe_message(mqtt_stream, msg);
    case gate_mqtt_packet_subscribe_ack:	return serialize_subscribe_ack_message(mqtt_stream, msg);
    case gate_mqtt_packet_unsubscribe:		return serialize_unsubscribe_message(mqtt_stream, msg);
    case gate_mqtt_packet_unsubscribe_ack:	return serialize_packet_identifier_only_message(mqtt_stream, msg, msg->content.unsubscribe_ack.packet_identifier);
    case gate_mqtt_packet_ping_request:		return serialize_nocontent_message(mqtt_stream, msg);
    case gate_mqtt_packet_ping_response:	return serialize_nocontent_message(mqtt_stream, msg);
    case gate_mqtt_packet_disconnect:		return serialize_nocontent_message(mqtt_stream, msg);
    default:								return GATE_RESULT_NOTSUPPORTED;
    }
}

static gate_result_t deserialize_connect(gate_memoryblock_t* block, gate_mqtt_message_t* msg)
{
    gate_result_t ret = GATE_RESULT_FAILED;

    do
    {
        gate_size_t offset;
        gate_strbuilder_t builder = GATE_INIT_EMPTY;
        char buffer[4096];
        gate_memstream_impl_t block_stream;
        char const* const ptr_block_content = (char const*)gate_memoryblock_get_content(block);
        gate_size_t const block_content_len = gate_memoryblock_get_size(block);

        gate_stream_t* const strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(
            &block_stream, ptr_block_content, block_content_len, block_content_len);

        if (strm == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        gate_strbuilder_create_static(&builder, buffer, sizeof(buffer), 0);

        ret = gate_mqtt_read_string(strm, &builder);
        GATE_BREAK_IF_FAILED(ret);

        if (gate_str_compare(gate_strbuilder_ptr(&builder, 0), gate_strbuilder_length(&builder), "MQTT", 4) != 0)
        {
            /* Not a valid MQTT connect message */
            ret = GATE_RESULT_INVALIDHEADER;
            break;
        }

        ret = gate_mqtt_read_byte(strm, &msg->content.connect.level);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_mqtt_read_byte(strm, &msg->content.connect.flags);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_mqtt_read_word(strm, &msg->content.connect.keep_alive);
        GATE_BREAK_IF_FAILED(ret);

        offset = 10;	/* payload starts at block offset 10: */

        /* read client id */
        gate_mqtt_read_string_length_skip_data(strm, &msg->content.connect.client_id_len);
        offset += 2;
        msg->content.connect.client_id = &ptr_block_content[offset];
        offset += msg->content.connect.client_id_len;

        if (GATE_FLAG_ENABLED(msg->content.connect.flags, GATE_MQTT_CONNECT_FLAG_WILLFLAG))
        {
            /* read optional will topic+content */
            gate_mqtt_read_string_length_skip_data(strm, &msg->content.connect.will_topic_len);
            offset += 2;
            msg->content.connect.will_topic = &ptr_block_content[offset];
            offset += msg->content.connect.will_topic_len;

            gate_mqtt_read_string_length_skip_data(strm, &msg->content.connect.will_message_len);
            offset += 2;
            msg->content.connect.will_message = &ptr_block_content[offset];
            offset += msg->content.connect.will_message_len;
        }

        if (GATE_FLAG_ENABLED(msg->content.connect.flags, GATE_MQTT_CONNECT_FLAG_USER))
        {
            /* read optional user string */
            gate_mqtt_read_string_length_skip_data(strm, &msg->content.connect.user_len);
            offset += 2;
            msg->content.connect.user = &ptr_block_content[offset];
            offset += msg->content.connect.user_len;
        }

        if (GATE_FLAG_ENABLED(msg->content.connect.flags, GATE_MQTT_CONNECT_FLAG_PASSWORD))
        {
            /* read optional will topic+content */
            gate_mqtt_read_string_length_skip_data(strm, &msg->content.connect.password_len);
            offset += 2;
            msg->content.connect.password = &ptr_block_content[offset];
            offset += msg->content.connect.password_len;
        }
    } while (0);

    return ret;
}


static gate_result_t deserialize_connect_ack(gate_memoryblock_t* block, gate_mqtt_message_t* msg)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_uint8_t ack_flags = 0;
    gate_uint8_t ret_code = 0;

    do
    {
        gate_memstream_impl_t block_stream;
        char const* const ptr_block_content = (char const*)gate_memoryblock_get_content(block);
        gate_size_t const block_content_len = gate_memoryblock_get_size(block);

        gate_stream_t* const strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(
            &block_stream, ptr_block_content, block_content_len, block_content_len);

        if (strm == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }


        if (block_content_len != 2)
        {
            ret = GATE_RESULT_INVALIDHEADER;
            break;
        }

        ret = gate_mqtt_read_byte(strm, &ack_flags);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_mqtt_read_byte(strm, &ret_code);
        GATE_BREAK_IF_FAILED(ret);

        msg->content.connect_ack.flags = ack_flags;
        msg->content.connect_ack.return_code = ret_code;
    } while (0);

    return ret;
}

static gate_result_t deserialize_package_identifier_only_message(gate_memoryblock_t* block, gate_uint16_t* ptr_packet_id)
{
    gate_result_t ret;
    void const* const ptr_block_data = gate_memoryblock_get_content(block);
    gate_size_t const block_len = gate_memoryblock_get_size(block);

    do
    {
        gate_memstream_impl_t data_strm;
        gate_stream_t* input_strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(
            &data_strm, ptr_block_data, block_len, block_len);
        if (input_strm == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_mqtt_read_word(input_strm, ptr_packet_id);
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    return ret;

}

static gate_result_t deserialize_publish(gate_memoryblock_t* block, gate_mqtt_message_t* msg)
{
    gate_result_t ret = GATE_RESULT_FAILED;

    do
    {
        gate_size_t offset;
        gate_memstream_impl_t block_stream;
        char const* const ptr_block_content = (char const*)gate_memoryblock_get_content(block);
        gate_size_t const block_content_len = gate_memoryblock_get_size(block);

        gate_stream_t* const strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(
            &block_stream, ptr_block_content, block_content_len, block_content_len);

        if (strm == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_mqtt_read_string_length_skip_data(strm, &msg->content.publish.topic_len);
        GATE_BREAK_IF_FAILED(ret);
        offset = 2;
        msg->content.publish.topic = &ptr_block_content[offset];
        offset += msg->content.publish.topic_len;

        if (GATE_FLAG_ENABLED(msg->packet_flags, GATE_MQTT_FLAG_QOS1) || GATE_FLAG_ENABLED(msg->packet_flags, GATE_MQTT_FLAG_QOS2))
        {
            ret = gate_mqtt_read_word(strm, &msg->content.publish.packet_identifier);
            GATE_BREAK_IF_FAILED(ret);
            offset += 2;
        }
        else
        {
            msg->content.publish.packet_identifier = 0;
        }

        msg->content.publish.data_len = (gate_uint32_t)(block_content_len - offset);
        msg->content.publish.data = &ptr_block_content[offset];

        /* success case reached */
    } while (0);

    return ret;
}

static gate_result_t deserialize_subscribe(gate_memoryblock_t* block, gate_mqtt_message_t* msg)
{
    gate_result_t ret = GATE_RESULT_FAILED;

    do
    {
        gate_size_t offset;
        gate_memstream_impl_t block_stream;
        char const* const ptr_block_content = (char const*)gate_memoryblock_get_content(block);
        gate_size_t const block_content_len = gate_memoryblock_get_size(block);

        gate_stream_t* const strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(
            &block_stream, ptr_block_content, block_content_len, block_content_len);

        if (strm == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_mqtt_read_word(strm, &msg->content.subscribe.packet_identifier);
        GATE_BREAK_IF_FAILED(ret);

        offset = 2;
        msg->content.subscribe.topics_count = 0;
        while ((gate_memstream_size(&block_stream) >= 4) && (msg->content.subscribe.topics_count < GATE_MQTT_ARRAY_MAX))
        {
            gate_mqtt_subscription_t* ptr_sub = &msg->content.subscribe.topics[msg->content.subscribe.topics_count];

            ret = gate_mqtt_read_string_length_skip_data(strm, &ptr_sub->topic_len);
            GATE_BREAK_IF_FAILED(ret);
            offset += 2;
            ptr_sub->topic = &ptr_block_content[offset];
            offset += ptr_sub->topic_len;

            ret = gate_mqtt_read_byte(strm, &ptr_sub->qos);
            GATE_BREAK_IF_FAILED(ret);
            offset += 1;

            ++msg->content.subscribe.topics_count;
        }
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    return ret;
}

static gate_result_t deserialize_subscribe_ack(gate_memoryblock_t* block, gate_mqtt_message_t* msg)
{
    gate_result_t ret = GATE_RESULT_FAILED;

    do
    {
        gate_size_t offset;
        gate_memstream_impl_t block_stream;
        char const* const ptr_block_content = (char const*)gate_memoryblock_get_content(block);
        gate_size_t const block_content_len = gate_memoryblock_get_size(block);

        gate_stream_t* const strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(
            &block_stream, ptr_block_content, block_content_len, block_content_len);

        if (strm == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_mqtt_read_word(strm, &msg->content.subscribe_ack.packet_identifier);
        GATE_BREAK_IF_FAILED(ret);

        offset = 2;
        msg->content.subscribe_ack.ret_codes_count = 0;
        while ((gate_memstream_size(&block_stream) > 0) && (msg->content.subscribe_ack.ret_codes_count < GATE_MQTT_ARRAY_MAX))
        {
            ret = gate_mqtt_read_byte(strm, &msg->content.subscribe_ack.ret_codes[msg->content.subscribe_ack.ret_codes_count]);
            GATE_BREAK_IF_FAILED(ret);

            ++msg->content.subscribe_ack.ret_codes_count;
        }
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    return ret;
}

static gate_result_t deserialize_unsubscribe(gate_memoryblock_t* block, gate_mqtt_message_t* msg)
{
    gate_result_t ret = GATE_RESULT_FAILED;

    do
    {
        gate_size_t offset;
        gate_memstream_impl_t block_stream;
        char const* const ptr_block_content = (char const*)gate_memoryblock_get_content(block);
        gate_size_t const block_content_len = gate_memoryblock_get_size(block);

        gate_stream_t* const strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(
            &block_stream, ptr_block_content, block_content_len, block_content_len);

        if (strm == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_mqtt_read_word(strm, &msg->content.unsubscribe.packet_identifier);
        GATE_BREAK_IF_FAILED(ret);

        offset = 2;
        msg->content.unsubscribe.topics_count = 0;
        while ((gate_memstream_size(&block_stream) >= 3) && (msg->content.unsubscribe.topics_count < GATE_MQTT_ARRAY_MAX))
        {
            gate_mqtt_subscription_t* ptr_sub = &msg->content.unsubscribe.topics[msg->content.unsubscribe.topics_count];

            ret = gate_mqtt_read_string_length_skip_data(strm, &ptr_sub->topic_len);
            GATE_BREAK_IF_FAILED(ret);
            offset += 2;
            ptr_sub->topic = &ptr_block_content[offset];
            offset += ptr_sub->topic_len;

            ptr_sub->qos = 0;

            ++msg->content.unsubscribe.topics_count;
        }
        GATE_BREAK_IF_FAILED(ret);

        /* success case reached */
    } while (0);

    return ret;
}


gate_result_t gate_mqtt_has_queued_message(gate_stream_t* mqtt_stream)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    char buffer[1024];
    char* ptr_buffer = &buffer[0];
    gate_size_t buffer_capacity = sizeof(buffer);
    gate_size_t returned;
    gate_memstream_impl_t memstrm;
    gate_stream_t* strm = NULL;

    do
    {
        gate_uint8_t fixed_header_byte = 0;
        gate_size_t fixed_header_contentlen = 0;
        gate_size_t remaining_bytes;
        gate_size_t fixed_header_length;
        gate_size_t total_packet_length;

        ret = gate_stream_peek(mqtt_stream, ptr_buffer, buffer_capacity, &returned);
        GATE_BREAK_IF_FAILED(ret);

        if (returned < 2)
        {
            ret = GATE_RESULT_ENDOFSTREAM;
            break;
        }

        strm = (gate_stream_t*)gate_memstream_create_static_unmanaged_readonly(&memstrm, ptr_buffer, returned, returned);
        if (!strm)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_mqtt_read_byte(strm, &fixed_header_byte);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_mqtt_read_length(strm, &fixed_header_contentlen);
        GATE_BREAK_IF_FAILED(ret);

        remaining_bytes = gate_memstream_size(&memstrm);
        GATE_DEBUG_ASSERT(returned >= remaining_bytes);
        fixed_header_length = returned - remaining_bytes;
        total_packet_length = fixed_header_length + fixed_header_contentlen;

        if (total_packet_length > buffer_capacity)
        {
            ptr_buffer = (char*)gate_mem_alloc(total_packet_length);
            if (ptr_buffer == NULL)
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
        }

        ret = gate_stream_peek(mqtt_stream, ptr_buffer, total_packet_length, &returned);
        GATE_BREAK_IF_FAILED(ret);

        if (returned < total_packet_length)
        {
            /* not enough bytes in stream to decode a full package */
            ret = GATE_RESULT_ENDOFSTREAM;
            break;
        }

        /* success case, we have a full packet in the stream */
        ret = GATE_RESULT_OK;
    } while (0);

    if ((ptr_buffer != NULL) && (ptr_buffer != &buffer[0]))
    {
        gate_mem_dealloc(ptr_buffer);
    }

    return ret;
}


gate_result_t gate_mqtt_receive_message(gate_stream_t* mqtt_stream, gate_mqtt_message_t* msg, gate_memoryblock_t** ptr_new_memblock)
{
    gate_result_t ret;
    gate_memoryblock_t* mem_block = NULL;

    do
    {
        gate_uint8_t fixed_header_byte = 0;
        gate_size_t fixed_header_len = 0;
        gate_uint64_t content_transferred = 0;

        if (!mqtt_stream || !msg || !ptr_new_memblock)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }

        ret = gate_mqtt_read_byte(mqtt_stream, &fixed_header_byte);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_mqtt_read_length(mqtt_stream, &fixed_header_len);
        GATE_BREAK_IF_FAILED(ret);

        msg->packet_type = (gate_mqtt_packet_type_t)((fixed_header_byte & 0xf0) >> 4);
        msg->packet_flags = fixed_header_byte & 0x0f;

        if (fixed_header_len > 0)
        {
            gate_memstream_impl_t memstream;

            mem_block = gate_memoryblock_create(fixed_header_len);
            if (NULL == mem_block)
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }

            if (NULL == gate_memstream_create_static_unmanaged(&memstream, gate_memoryblock_get_content(mem_block), gate_memoryblock_get_size(mem_block), 0))
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }

            ret = gate_stream_transfer_limit(mqtt_stream, fixed_header_len, (gate_stream_t*)&memstream, &content_transferred);
            GATE_BREAK_IF_FAILED(ret);
            if (content_transferred < fixed_header_len)
            {
                ret = GATE_RESULT_ENDOFSTREAM;
                break;
            }
        }

        switch (msg->packet_type)
        {
        case gate_mqtt_packet_connect:
            ret = deserialize_connect(mem_block, msg);
            break;
        case gate_mqtt_packet_connect_ack:
            ret = deserialize_connect_ack(mem_block, msg);
            break;
        case gate_mqtt_packet_publish:
            ret = deserialize_publish(mem_block, msg);
            break;
        case gate_mqtt_packet_publish_ack:
            ret = deserialize_package_identifier_only_message(mem_block, &msg->content.publish_ack.packet_identifier);
            break;
        case gate_mqtt_packet_publish_receive:
            ret = deserialize_package_identifier_only_message(mem_block, &msg->content.publish_received.packet_identifier);
            break;
        case gate_mqtt_packet_publish_release:
            ret = deserialize_package_identifier_only_message(mem_block, &msg->content.publish_release.packet_identifier);
            break;
        case gate_mqtt_packet_publish_complete:
            ret = deserialize_package_identifier_only_message(mem_block, &msg->content.publish_complete.packet_identifier);
            break;
        case gate_mqtt_packet_subscribe:
            ret = deserialize_subscribe(mem_block, msg);
            break;
        case gate_mqtt_packet_subscribe_ack:
            ret = deserialize_subscribe_ack(mem_block, msg);
            break;
        case gate_mqtt_packet_unsubscribe:
            ret = deserialize_unsubscribe(mem_block, msg);
            break;
        case gate_mqtt_packet_unsubscribe_ack:
            ret = deserialize_package_identifier_only_message(mem_block, &msg->content.unsubscribe_ack.packet_identifier);
            break;

        case gate_mqtt_packet_ping_request:
        case gate_mqtt_packet_ping_response:
        case gate_mqtt_packet_disconnect:
            /* no content to deserialize */
            break;
        default:
            ret = GATE_RESULT_NOTSUPPORTED;
            break;
        }
        GATE_BREAK_IF_FAILED(ret);

        if (ptr_new_memblock != NULL)
        {
            *ptr_new_memblock = mem_block;
            mem_block = NULL;
        }
    } while (0);

    if (mem_block)
    {
        gate_object_release(mem_block);
        mem_block = NULL;
    }

    return ret;
}
Cppcheck report - GATE C/C++ Framework: gate/net/mqttprotocols.c
