owner-nrf52sdk/nRF5_SDK_15.2.0/components/iot/mqtt/mqtt_encoder.c

/**
 * Copyright (c) 2015 - 2018, Nordic Semiconductor ASA
 *
 * 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, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, 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.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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.
 *
 */
/** @file mqtt_encoder.c
 *
 * @brief Encoding functions needed to create packet to be sent to the broker.
 */


#include "mqtt_internal.h"

#if MQTT_CONFIG_LOG_ENABLED

#define NRF_LOG_MODULE_NAME mqtt_enc

#define NRF_LOG_LEVEL       MQTT_CONFIG_LOG_LEVEL
#define NRF_LOG_INFO_COLOR  MQTT_CONFIG_INFO_COLOR
#define NRF_LOG_DEBUG_COLOR MQTT_CONFIG_DEBUG_COLOR

#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();

#define MQTT_TRC     NRF_LOG_DEBUG                                                              /**< Used for getting trace of execution in the module. */
#define MQTT_ERR     NRF_LOG_ERROR                                                              /**< Used for logging errors in the module. */
#define MQTT_DUMP    NRF_LOG_HEXDUMP_DEBUG                                                      /**< Used for dumping octet information to get details of bond information etc. */

#define MQTT_ENTRY()                       MQTT_TRC(">> %s", __func__)
#define MQTT_EXIT()                        MQTT_TRC("<< %s", __func__)

#else // MQTT_CONFIG_LOG_ENABLED

#define MQTT_TRC(...)                                                                           /**< Disables traces. */
#define MQTT_DUMP(...)                                                                          /**< Disables dumping of octet streams. */
#define MQTT_ERR(...)                                                                           /**< Disables error logs. */

#define MQTT_ENTRY(...)
#define MQTT_EXIT(...)

#endif // MQTT_CONFIG_LOG_ENABLED

#define MQTT_3_1_0_PROTO_DESC_LEN     6
#define MQTT_3_1_1_PROTO_DESC_LEN     4

const uint8_t mqtt_3_1_0_proto_desc_str[MQTT_3_1_0_PROTO_DESC_LEN] = {'M', 'Q', 'I', 's', 'd', 'p'};
const uint8_t mqtt_3_1_1_proto_desc_str[MQTT_3_1_1_PROTO_DESC_LEN] = {'M', 'Q', 'T', 'T'};

const mqtt_utf8_t mqtt_3_1_0_proto_desc =
{
    .p_utf_str  = (uint8_t *)&mqtt_3_1_0_proto_desc_str[0],
    .utf_strlen = MQTT_3_1_0_PROTO_DESC_LEN
};

const mqtt_utf8_t mqtt_3_1_1_proto_desc =
{
    .p_utf_str  = (uint8_t *)&mqtt_3_1_1_proto_desc_str[0],
    .utf_strlen = MQTT_3_1_1_PROTO_DESC_LEN
};

uint32_t pack_uint8(uint8_t      val,
                    uint32_t     buffer_len,
                    uint8_t    * const buffer,
                    uint32_t   * const p_offset)
{
    uint32_t err_code = NRF_ERROR_DATA_SIZE;

    if (buffer_len > (*p_offset))
    {
        MQTT_TRC(">> %s V:%02x BL:%08x, B:%p, O:%08x", __func__,
                      val, buffer_len, buffer, (*p_offset));

        // Pack value.
        buffer[(*p_offset)] = val;

        // Increment offset.
        (*p_offset) += SIZE_OF_UINT8;

        // Indicate success.
        err_code = NRF_SUCCESS;
    }

    return err_code;
}


uint32_t pack_uint16(uint16_t     val,
                     uint32_t     buffer_len,
                     uint8_t    * const buffer,
                     uint32_t   * const p_offset)
{
    uint32_t err_code = NRF_ERROR_DATA_SIZE;

    if (buffer_len > (*p_offset))
    {
        const uint32_t available_len = buffer_len - (*p_offset);

        MQTT_TRC(">> %s V:%04x BL:%08x, B:%p, O:%08x A:%08x", __func__,
                      val, buffer_len, buffer, (*p_offset), available_len);

        if (available_len >= SIZE_OF_UINT16)
        {
            // Pack value.
            buffer[(*p_offset)]   = MSB_16(val);
            buffer[(*p_offset)+1] = LSB_16(val);

            // Increment offset.
            (*p_offset) += SIZE_OF_UINT16;

            // Indicate success.
            err_code = NRF_SUCCESS;
        }
    }

    return err_code;
}


uint32_t pack_utf8_str(mqtt_utf8_t const * const p_str,
                       uint32_t                  buffer_len,
                       uint8_t           * const buffer,
                       uint32_t          * const p_offset)
{
    uint32_t err_code = NRF_ERROR_DATA_SIZE;

    if (buffer_len > (*p_offset))
    {
        const uint32_t available_len = buffer_len - (*p_offset);
        err_code                     = NRF_ERROR_NO_MEM;

        MQTT_TRC(">> %s USL:%08x BL:%08x, B:%p, O:%08x A:%08x", __func__,
                      GET_UT8STR_BUFFER_SIZE(p_str), buffer_len, buffer, (*p_offset), available_len);

        if (available_len >= GET_UT8STR_BUFFER_SIZE(p_str))
        {
            // Length followed by string.
            err_code = pack_uint16(p_str->utf_strlen, buffer_len, buffer, p_offset);

            if (err_code == NRF_SUCCESS)
            {
                 memcpy(&buffer[(*p_offset)], p_str->p_utf_str, p_str->utf_strlen);

                 (*p_offset) += p_str->utf_strlen;

                 err_code = NRF_SUCCESS;
            }
        }
    }

    return err_code;
}

uint32_t pack_bin_str(mqtt_binstr_t const * const p_str,
                      uint32_t                    buffer_len,
                      uint8_t             * const buffer,
                      uint32_t            * const p_offset)
{
    uint32_t err_code = NRF_ERROR_DATA_SIZE;

    if (buffer_len > (*p_offset))
    {
        const uint32_t available_len = buffer_len - (*p_offset);
        err_code                     = NRF_ERROR_NO_MEM;

        MQTT_TRC(">> %s BSL:%08x BL:%08x, B:%p, O:%08x A:%08x", __func__,
                      GET_BINSTR_BUFFER_SIZE(p_str), buffer_len, buffer, (*p_offset), available_len);

        if (available_len >= GET_BINSTR_BUFFER_SIZE(p_str))
        {
            memcpy(&buffer[(*p_offset)], p_str->p_bin_str, p_str->bin_strlen);

            (*p_offset) += p_str->bin_strlen;
            err_code = NRF_SUCCESS;
        }
    }

    return err_code;
}


void packet_length_encode(uint32_t remaining_length, uint8_t * p_buff, uint32_t * p_size)
{
    uint16_t         index  = 0;
    const uint32_t   offset = (*p_size);

    MQTT_TRC(">> RL:0x%08x O:%08x P:%p", remaining_length, offset, p_buff);

    do
    {
        if (p_buff != NULL)
        {
            p_buff[offset+index] = remaining_length % 0x80;
        }

        remaining_length /= 0x80;

        if (remaining_length > 0)
        {
            if (p_buff != NULL)
            {
                p_buff[offset+index] |=  0x80;
            }
        }

        index++;

    } while (remaining_length > 0);

    MQTT_TRC("<< RLS:0x%08x", index);

    *p_size += index;
}


uint32_t mqtt_encode_fixed_header(uint8_t message_type, uint32_t length, uint8_t ** pp_packet)
{
    uint32_t packet_length = 0xFFFFFFFF;

    if (MQTT_MAX_PAYLOAD_SIZE >= length)
    {
        uint32_t offset = 1;

        MQTT_TRC("<< %s MT:0x%02x L:0x%08x", __func__, message_type, length);
        packet_length_encode(length, NULL, &offset);

        MQTT_TRC("Remaining length size = %02x", offset);

        uint8_t * p_mqtt_header = ((*pp_packet) - offset);

        // Reset offset.
        offset = 0;
        UNUSED_VARIABLE(pack_uint8(message_type, MQTT_MAX_PACKET_LENGTH, p_mqtt_header, &offset));
        packet_length_encode(length, p_mqtt_header, &offset);

        (* pp_packet) = p_mqtt_header;

        packet_length = (length + offset);
    }

    return packet_length;
}


uint32_t zero_len_str_encode(uint32_t            buffer_len,
                             uint8_t     * const buffer,
                             uint32_t    * const offset)
{
    return pack_uint16(0x0000, buffer_len, buffer, offset);
}


void connect_request_encode(const mqtt_client_t *  p_client,
                            uint8_t             ** pp_packet,
                            uint32_t            *  p_packet_length)
{
    uint32_t    err_code;
    uint32_t    offset        = 0;
    uint8_t   * p_payload     = &p_client->p_packet[MQTT_FIXED_HEADER_EXTENDED_SIZE];
    uint8_t     connect_flags = p_client->clean_session << 1; // Clean session always.

    const mqtt_utf8_t * p_mqtt_proto_desc;
    if (p_client->protocol_version == MQTT_VERSION_3_1_1)
    {
        p_mqtt_proto_desc = &mqtt_3_1_1_proto_desc;
    }
    else
    {
        p_mqtt_proto_desc = &mqtt_3_1_0_proto_desc;
    }

    memset(p_payload, 0, MQTT_MAX_PACKET_LENGTH);

    // Pack protocol description.
    MQTT_TRC("Encoding Protocol Description. Str:%s Size:%08x.",
                  p_mqtt_proto_desc->p_utf_str,
                  p_mqtt_proto_desc->utf_strlen);

    err_code = pack_utf8_str(p_mqtt_proto_desc,
                             MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                             p_payload,
                             &offset);

    if (err_code == NRF_SUCCESS)
    {
        MQTT_TRC("Encoding Protocol Version %02x.", p_client->protocol_version);
        // Pack protocol version.
        err_code = pack_uint8(p_client->protocol_version,
                              MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                              p_payload,
                              &offset);
    }

    // Remember position of connect flag and
    // leave one byte for it to be packed once we determine its value.
    const uint32_t connect_flag_offset = MQTT_FIXED_HEADER_EXTENDED_SIZE + offset;
    offset++;

    if (err_code == NRF_SUCCESS)
    {
        MQTT_TRC("Encoding Keep Alive Time %04x.", MQTT_KEEPALIVE);
        // Pack keep alive time.
        err_code = pack_uint16(MQTT_KEEPALIVE,
                               MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                               p_payload,
                               &offset);
    }

    if (err_code == NRF_SUCCESS)
    {
        MQTT_TRC("Encoding Client Id. Str:%s Size:%08x.",
                      p_client->client_id.p_utf_str,
                      p_client->client_id.utf_strlen);

        // Pack client id
        err_code = pack_utf8_str(&p_client->client_id,
                                 MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                                 p_payload,
                                 &offset);
    }

    if (err_code == NRF_SUCCESS)
    {
        // Pack will topic and QoS
        if (p_client->p_will_topic != NULL)
        {
            MQTT_TRC("Encoding Will Topic. Str:%s Size:%08x.",
                          p_client->p_will_topic->topic.p_utf_str,
                          p_client->p_will_topic->topic.utf_strlen);

            // Set Will topic in connect flags.
            connect_flags |= MQTT_CONNECT_FLAG_WILL_TOPIC;

            err_code = pack_utf8_str(&p_client->p_will_topic->topic,
                                      MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                                      p_payload,
                                      &offset);

            if (err_code == NRF_SUCCESS)
            {
                // QoS is always 1 as of now.
                connect_flags |= ((p_client->p_will_topic->qos & 0x03) << 3);
                connect_flags |= p_client->will_retain << 5;

                if (p_client->p_will_message != NULL)
                {
                    MQTT_TRC("Encoding Will Message. Str:%s Size:%08x.",
                                  p_client->p_will_message->p_utf_str,
                                  p_client->p_will_message->utf_strlen);

                    err_code = pack_utf8_str(p_client->p_will_message,
                                             MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                                             p_payload,
                                             &offset);
                }
                else
                {
                    MQTT_TRC("Encoding Zero Length Will Message.");
                    err_code = zero_len_str_encode(MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                                                   p_payload,
                                                   &offset);
                }
            }
        }
    }

    if (err_code == NRF_SUCCESS)
    {
        // Pack Username if any.
        if (p_client->p_user_name != NULL)
        {
            connect_flags |= MQTT_CONNECT_FLAG_USERNAME;

            MQTT_TRC("Encoding Username. Str:%s, Size:%08x.",
                          p_client->p_user_name->p_utf_str,
                          p_client->p_user_name->utf_strlen);

            err_code = pack_utf8_str(p_client->p_user_name,
                                     MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                                     p_payload,
                                     &offset);

            if (err_code == NRF_SUCCESS)
            {
                // Pack Password if any.
                if (p_client->p_password != NULL)
                {
                    MQTT_TRC("Encoding Password. Str:%s Size:%08x.",
                                  p_client->p_password->p_utf_str,
                                  p_client->p_password->utf_strlen);

                     connect_flags |= MQTT_CONNECT_FLAG_PASSWORD;
                     err_code = pack_utf8_str(p_client->p_password,
                                              MQTT_MAX_VARIABLE_HEADER_N_PAYLOAD,
                                              p_payload,
                                              &offset);
                }
            }
        }
    }

    if (err_code == NRF_SUCCESS)
    {
        // Pack the connect flags.
        p_client->p_packet[connect_flag_offset] = connect_flags;

        const uint8_t message_type = MQTT_MESSAGES_OPTIONS(MQTT_PKT_TYPE_CONNECT,
                                                           0,  // Duplicate flag not set.
                                                           0,  // QoS not set.
                                                           0); // Retain not set.

        offset = mqtt_encode_fixed_header(message_type,
                                          offset,
                                          &p_payload);

        (*p_packet_length) = offset;
        (*pp_packet)       = p_payload;
    }
    else
    {
        (*p_packet_length) = 0;
        (*pp_packet)       = NULL;
    }
}