diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/mqtt/mqtt_encoder.c')
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/mqtt/mqtt_encoder.c | 457 |
1 files changed, 457 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/mqtt/mqtt_encoder.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/mqtt/mqtt_encoder.c new file mode 100644 index 0000000..74476f2 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/mqtt/mqtt_encoder.c @@ -0,0 +1,457 @@ +/** + * 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; + } +} |