chore: Adds pre-commit checks and introduce conventional commits

lib/include/mqtt5_client_priv.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -48,9 +48,10 @@ void esp_mqtt5_client_destory(esp_mqtt5_client_handle_t client);
 esp_err_t esp_mqtt5_client_publish_check(esp_mqtt5_client_handle_t client, int qos, int retain);
 esp_err_t esp_mqtt5_client_subscribe_check(esp_mqtt5_client_handle_t client, int qos);
 esp_err_t esp_mqtt5_create_default_config(esp_mqtt5_client_handle_t client);
-esp_err_t esp_mqtt5_get_publish_data(esp_mqtt5_client_handle_t client, uint8_t *msg_buf, size_t msg_read_len, char **msg_topic, size_t *msg_topic_len, char **msg_data, size_t *msg_data_len);
+esp_err_t esp_mqtt5_get_publish_data(esp_mqtt5_client_handle_t client, uint8_t *msg_buf, size_t msg_read_len,
+                                     char **msg_topic, size_t *msg_topic_len, char **msg_data, size_t *msg_data_len);
 #ifdef __cplusplus
 }
 #endif //__cplusplus
 
-#endif
+#endif

lib/include/mqtt5_msg.h

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 #ifndef MQTT5_MSG_H
 #define MQTT5_MSG_H
 #include <stdint.h>
@@ -119,16 +124,26 @@ typedef struct {
 #define mqtt5_get_pubcomp_data mqtt5_get_puback_data
 
 uint16_t mqtt5_get_id(uint8_t *buffer, size_t length);
-char *mqtt5_get_publish_property_payload(uint8_t *buffer, size_t buffer_length, char **msg_topic, size_t *msg_topic_len, esp_mqtt5_publish_resp_property_t *resp_property, uint16_t *property_len, size_t *payload_len, mqtt5_user_property_handle_t *user_property);
+char *mqtt5_get_publish_property_payload(uint8_t *buffer, size_t buffer_length, char **msg_topic, size_t *msg_topic_len,
+                                         esp_mqtt5_publish_resp_property_t *resp_property, uint16_t *property_len, size_t *payload_len,
+                                         mqtt5_user_property_handle_t *user_property);
 char *mqtt5_get_suback_data(uint8_t *buffer, size_t *length, mqtt5_user_property_handle_t *user_property);
 char *mqtt5_get_puback_data(uint8_t *buffer, size_t *length, mqtt5_user_property_handle_t *user_property);
-mqtt_message_t *mqtt5_msg_connect(mqtt_connection_t *connection, mqtt_connect_info_t *info, esp_mqtt5_connection_property_storage_t *property, esp_mqtt5_connection_will_property_storage_t *will_property);
-mqtt_message_t *mqtt5_msg_publish(mqtt_connection_t *connection, const char *topic, const char *data, int data_length, int qos, int retain, uint16_t *message_id, const esp_mqtt5_publish_property_config_t *property, const char *resp_info);
-esp_err_t mqtt5_msg_parse_connack_property(uint8_t *buffer, size_t buffer_len, mqtt_connect_info_t *connection_info, esp_mqtt5_connection_property_storage_t *connection_property, esp_mqtt5_connection_server_resp_property_t *resp_property, int *reason_code, uint8_t *ack_flag, mqtt5_user_property_handle_t *user_property);
+mqtt_message_t *mqtt5_msg_connect(mqtt_connection_t *connection, mqtt_connect_info_t *info,
+                                  esp_mqtt5_connection_property_storage_t *property, esp_mqtt5_connection_will_property_storage_t *will_property);
+mqtt_message_t *mqtt5_msg_publish(mqtt_connection_t *connection, const char *topic, const char *data, int data_length,
+                                  int qos, int retain, uint16_t *message_id, const esp_mqtt5_publish_property_config_t *property, const char *resp_info);
+esp_err_t mqtt5_msg_parse_connack_property(uint8_t *buffer, size_t buffer_len, mqtt_connect_info_t *connection_info,
+                                           esp_mqtt5_connection_property_storage_t *connection_property,
+                                           esp_mqtt5_connection_server_resp_property_t *resp_property, int *reason_code, uint8_t *ack_flag,
+                                           mqtt5_user_property_handle_t *user_property);
 int mqtt5_msg_get_reason_code(uint8_t *buffer, size_t length);
-mqtt_message_t *mqtt5_msg_subscribe(mqtt_connection_t *connection, const esp_mqtt_topic_t *topic, int size, uint16_t *message_id, const esp_mqtt5_subscribe_property_config_t *property);
-mqtt_message_t *mqtt5_msg_unsubscribe(mqtt_connection_t *connection, const char *topic, uint16_t *message_id, const esp_mqtt5_unsubscribe_property_config_t *property);
-mqtt_message_t *mqtt5_msg_disconnect(mqtt_connection_t *connection, esp_mqtt5_disconnect_property_config_t *disconnect_property_info);
+mqtt_message_t *mqtt5_msg_subscribe(mqtt_connection_t *connection, const esp_mqtt_topic_t *topic, int size,
+                                    uint16_t *message_id, const esp_mqtt5_subscribe_property_config_t *property);
+mqtt_message_t *mqtt5_msg_unsubscribe(mqtt_connection_t *connection, const char *topic, uint16_t *message_id,
+                                      const esp_mqtt5_unsubscribe_property_config_t *property);
+mqtt_message_t *mqtt5_msg_disconnect(mqtt_connection_t *connection,
+                                     esp_mqtt5_disconnect_property_config_t *disconnect_property_info);
 mqtt_message_t *mqtt5_msg_pubcomp(mqtt_connection_t *connection, uint16_t message_id);
 mqtt_message_t *mqtt5_msg_pubrel(mqtt_connection_t *connection, uint16_t message_id);
 mqtt_message_t *mqtt5_msg_pubrec(mqtt_connection_t *connection, uint16_t message_id);
@@ -139,4 +154,3 @@ mqtt_message_t *mqtt5_msg_puback(mqtt_connection_t *connection, uint16_t message
 #endif
 
 #endif  /* MQTT5_MSG_H */
-

lib/include/mqtt_client_priv.h

@@ -102,7 +102,7 @@ typedef struct {
     int message_retransmit_timeout;
     uint64_t outbox_limit;
     esp_transport_handle_t transport;
-    struct ifreq * if_name;
+    struct ifreq *if_name;
     esp_transport_keep_alive_t tcp_keep_alive_cfg;
 } mqtt_config_storage_t;
 

lib/include/mqtt_config.h

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /*
  * This file is subject to the terms and conditions defined in
  * file 'LICENSE', which is part of this source code package.

lib/include/mqtt_msg.h

@@ -1,3 +1,9 @@
+/*
+ * SPDX-FileCopyrightText: 2014 Stephen Robinson
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
 #ifndef MQTT_MSG_H
 #define MQTT_MSG_H
 #include <stdint.h>
@@ -9,41 +15,10 @@
 extern "C" {
 #endif
 
-/*
-* Copyright (c) 2014, Stephen Robinson
-* 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.
-* 3. Neither the name of the copyright holder nor the names of its
-* contributors may be used to endorse or promote products derived
-* from this software without specific prior written permission.
-*
-* 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 HOLDER 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.
-*
-*/
 /* 7      6     5     4     3     2     1     0 */
 /*|      --- Message Type----     |  DUP Flag |    QoS Level    | Retain  | */
 /*                    Remaining Length                 */
 
-
 enum mqtt_message_type {
     MQTT_MSG_TYPE_CONNECT = 1,
     MQTT_MSG_TYPE_CONNACK = 2,
@@ -134,12 +109,14 @@ esp_err_t mqtt_msg_buffer_init(mqtt_connection_t *connection, int buffer_size);
 void mqtt_msg_buffer_destroy(mqtt_connection_t *connection);
 
 mqtt_message_t *mqtt_msg_connect(mqtt_connection_t *connection, mqtt_connect_info_t *info);
-mqtt_message_t *mqtt_msg_publish(mqtt_connection_t *connection, const char *topic, const char *data, int data_length, int qos, int retain, uint16_t *message_id);
+mqtt_message_t *mqtt_msg_publish(mqtt_connection_t *connection, const char *topic, const char *data, int data_length,
+                                 int qos, int retain, uint16_t *message_id);
 mqtt_message_t *mqtt_msg_puback(mqtt_connection_t *connection, uint16_t message_id);
 mqtt_message_t *mqtt_msg_pubrec(mqtt_connection_t *connection, uint16_t message_id);
 mqtt_message_t *mqtt_msg_pubrel(mqtt_connection_t *connection, uint16_t message_id);
 mqtt_message_t *mqtt_msg_pubcomp(mqtt_connection_t *connection, uint16_t message_id);
-mqtt_message_t *mqtt_msg_subscribe(mqtt_connection_t *connection, const esp_mqtt_topic_t topic_list[], int size, uint16_t *message_id) __attribute__((nonnull));
+mqtt_message_t *mqtt_msg_subscribe(mqtt_connection_t *connection, const esp_mqtt_topic_t topic_list[], int size,
+                                   uint16_t *message_id) __attribute__((nonnull));
 mqtt_message_t *mqtt_msg_unsubscribe(mqtt_connection_t *connection, const char *topic, uint16_t *message_id);
 mqtt_message_t *mqtt_msg_pingreq(mqtt_connection_t *connection);
 mqtt_message_t *mqtt_msg_pingresp(mqtt_connection_t *connection);
@@ -149,4 +126,3 @@ mqtt_message_t *mqtt_msg_disconnect(mqtt_connection_t *connection);
 #endif
 
 #endif  /* MQTT_MSG_H */
-

lib/include/mqtt_outbox.h

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /*
  * This file is subject to the terms and conditions defined in
  * file 'LICENSE', which is part of this source code package.

lib/include/platform.h

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /*
  * This file is subject to the terms and conditions defined in
  * file 'LICENSE', which is part of this source code package.

lib/include/platform_esp32_idf.h

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /*
  * This file is subject to the terms and conditions defined in
  * file 'LICENSE', which is part of this source code package.

lib/mqtt_msg.c

@@ -1,33 +1,8 @@
 /*
-* Copyright (c) 2014, Stephen Robinson
-* 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.
-* 3. Neither the name of the copyright holder nor the names of its
-* contributors may be used to endorse or promote products derived
-* from this software without specific prior written permission.
-*
-* 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 HOLDER 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.
-*
-*/
+ * SPDX-FileCopyrightText: 2014 Stephen Robinson
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
 #include <string.h>
 #include "mqtt_client.h"
 #include "mqtt_msg.h"
@@ -56,7 +31,6 @@ static int append_string(mqtt_connection_t *connection, const char *string, int
     connection->buffer[connection->outbound_message.length++] = len & 0xff;
     memcpy(connection->buffer + connection->outbound_message.length, string, len);
     connection->outbound_message.length += len;
-
     return len + 2;
 }
 
@@ -78,7 +52,6 @@ static uint16_t append_message_id(mqtt_connection_t *connection, uint16_t messag
 
     connection->buffer[connection->outbound_message.length++] = message_id >> 8;
     connection->buffer[connection->outbound_message.length++] = message_id & 0xff;
-
     return message_id;
 }
 
@@ -101,6 +74,7 @@ static mqtt_message_t *fini_message(mqtt_connection_t *connection, int type, int
     int total_length = message_length;
     int encoded_length = 0;
     uint8_t encoded_lens[4] = {0};
+
     // Check if we have fragmented message and update total_len
     if (connection->outbound_message.fragmented_msg_total_length) {
         total_length = connection->outbound_message.fragmented_msg_total_length - MQTT_MAX_FIXED_HEADER_SIZE;
@@ -108,12 +82,15 @@ static mqtt_message_t *fini_message(mqtt_connection_t *connection, int type, int
 
     // Encode MQTT message length
     int len_bytes = 0; // size of encoded message length
+
     do {
         encoded_length = total_length % 128;
         total_length /= 128;
+
         if (total_length > 0) {
             encoded_length |= 0x80;
         }
+
         encoded_lens[len_bytes] = encoded_length;
         len_bytes++;
     } while (total_length > 0);
@@ -129,7 +106,8 @@ static mqtt_message_t *fini_message(mqtt_connection_t *connection, int type, int
     connection->outbound_message.data = connection->buffer + offs;
     connection->outbound_message.fragmented_msg_data_offset -= offs;
     // type byte
-    connection->buffer[offs++] =  ((type & 0x0f) << 4) | ((dup & 1) << 3) | ((qos & 3) << 1) | (retain & 1);
+    connection->buffer[offs++] = ((type & 0x0f) << 4) | ((dup & 1) << 3) | ((qos & 3) << 1) | (retain & 1);
+
     // length bytes
     for (int j = 0; j < len_bytes; j++) {
         connection->buffer[offs++] = encoded_lens[j];
@@ -145,12 +123,15 @@ size_t mqtt_get_total_length(const uint8_t *buffer, size_t length, int *fixed_si
 
     for (i = 1; i < length; ++i) {
         totlen += (buffer[i] & 0x7f) << (7 * (i - 1));
+
         if ((buffer[i] & 0x80) == 0) {
             ++i;
             break;
         }
     }
+
     totlen += i;
+
     if (fixed_size_len) {
         *fixed_size_len = i;
     }
@@ -167,24 +148,27 @@ bool mqtt_header_complete(uint8_t *buffer, size_t buffer_length)
         if (i >= buffer_length) {
             return false;
         }
+
         if ((buffer[i] & 0x80) == 0) {
             ++i;
             break;
         }
     }
+
     // i is now the length of the fixed header
 
     if (i + 2 >= buffer_length) {
         return false;
     }
+
     topiclen = buffer[i++] << 8;
     topiclen |= buffer[i++];
-
     i += topiclen;
 
     if (mqtt_get_qos(buffer) > 0) {
         i += 2;
     }
+
     // i is now the length of the fixed + variable header
     return buffer_length >= i;
 }
@@ -204,6 +188,7 @@ char *mqtt_get_publish_topic(uint8_t *buffer, size_t *length)
     if (i + 2 >= *length) {
         return NULL;
     }
+
     topiclen = buffer[i++] << 8;
     topiclen |= buffer[i++];
 
@@ -225,16 +210,19 @@ char *mqtt_get_publish_data(uint8_t *buffer, size_t *length)
 
     for (i = 1; i < blength; ++i) {
         totlen += (buffer[i] & 0x7f) << (7 * (i - 1));
+
         if ((buffer[i] & 0x80) == 0) {
             ++i;
             break;
         }
     }
+
     totlen += i;
 
     if (i + 2 >= blength) {
         return NULL;
     }
+
     topiclen = buffer[i++] << 8;
     topiclen |= buffer[i++];
 
@@ -248,6 +236,7 @@ char *mqtt_get_publish_data(uint8_t *buffer, size_t *length)
         if (i + 2 >= blength) {
             return NULL;
         }
+
         i += 2;
     }
 
@@ -260,6 +249,7 @@ char *mqtt_get_publish_data(uint8_t *buffer, size_t *length)
     } else {
         *length = blength - i;
     }
+
     return (char *)(buffer + i);
 }
 
@@ -271,6 +261,7 @@ char *mqtt_get_suback_data(uint8_t *buffer, size_t *length)
         *length -= 4;
         return (char *)(buffer + 4);
     }
+
     *length = 0;
     return NULL;
 }
@@ -296,18 +287,21 @@ uint16_t mqtt_get_id(uint8_t *buffer, size_t length)
         if (i + 2 >= length) {
             return 0;
         }
+
         topiclen = buffer[i++] << 8;
         topiclen |= buffer[i++];
 
         if (i + topiclen > length) {
             return 0;
         }
+
         i += topiclen;
 
         if (mqtt_get_qos(buffer) > 0) {
             if (i + 2 > length) {
                 return 0;
             }
+
             //i += 2;
         } else {
             return 0;
@@ -315,6 +309,7 @@ uint16_t mqtt_get_id(uint8_t *buffer, size_t length)
 
         return (buffer[i] << 8) | buffer[i + 1];
     }
+
     case MQTT_MSG_TYPE_PUBACK:
     case MQTT_MSG_TYPE_PUBREC:
     case MQTT_MSG_TYPE_PUBREL:
@@ -339,10 +334,9 @@ uint16_t mqtt_get_id(uint8_t *buffer, size_t length)
 
 mqtt_message_t *mqtt_msg_connect(mqtt_connection_t *connection, mqtt_connect_info_t *info)
 {
-
     set_message_header_size(connection);
-
     int header_len;
+
     if (info->protocol_ver == MQTT_PROTOCOL_V_3_1) {
         header_len = MQTT_3_1_VARIABLE_HEADER_SIZE;
     } else {
@@ -352,9 +346,9 @@ mqtt_message_t *mqtt_msg_connect(mqtt_connection_t *connection, mqtt_connect_inf
     if (connection->outbound_message.length + header_len > connection->buffer_length) {
         return fail_message(connection);
     }
+
     char *variable_header = (char *)(connection->buffer + connection->outbound_message.length);
     connection->outbound_message.length += header_len;
-
     int header_idx = 0;
     variable_header[header_idx++] = 0;                              // Variable header length MSB
 
@@ -400,9 +394,11 @@ mqtt_message_t *mqtt_msg_connect(mqtt_connection_t *connection, mqtt_connect_inf
         }
 
         variable_header[flags_offset] |= MQTT_CONNECT_FLAG_WILL;
+
         if (info->will_retain) {
             variable_header[flags_offset] |= MQTT_CONNECT_FLAG_WILL_RETAIN;
         }
+
         variable_header[flags_offset] |= (info->will_qos & 3) << 3;
     }
 
@@ -436,7 +432,8 @@ mqtt_message_t *mqtt_msg_connect(mqtt_connection_t *connection, mqtt_connect_inf
     return fini_message(connection, MQTT_MSG_TYPE_CONNECT, 0, 0, 0);
 }
 
-mqtt_message_t *mqtt_msg_publish(mqtt_connection_t *connection, const char *topic, const char *data, int data_length, int qos, int retain, uint16_t *message_id)
+mqtt_message_t *mqtt_msg_publish(mqtt_connection_t *connection, const char *topic, const char *data, int data_length,
+                                 int qos, int retain, uint16_t *message_id)
 {
     set_message_header_size(connection);
 
@@ -464,55 +461,67 @@ mqtt_message_t *mqtt_msg_publish(mqtt_connection_t *connection, const char *topi
         if (connection->outbound_message.length + data_length > connection->buffer_length) {
             // Not enough size in buffer -> fragment this message
             connection->outbound_message.fragmented_msg_data_offset = connection->outbound_message.length;
-            memcpy(connection->buffer + connection->outbound_message.length, data, connection->buffer_length - connection->outbound_message.length);
+            memcpy(connection->buffer + connection->outbound_message.length, data,
+                   connection->buffer_length - connection->outbound_message.length);
             connection->outbound_message.length = connection->buffer_length;
-            connection->outbound_message.fragmented_msg_total_length = data_length + connection->outbound_message.fragmented_msg_data_offset;
+            connection->outbound_message.fragmented_msg_total_length = data_length +
+                                                                       connection->outbound_message.fragmented_msg_data_offset;
         } else {
             memcpy(connection->buffer + connection->outbound_message.length, data, data_length);
             connection->outbound_message.length += data_length;
             connection->outbound_message.fragmented_msg_total_length = 0;
         }
     }
+
     return fini_message(connection, MQTT_MSG_TYPE_PUBLISH, 0, qos, retain);
 }
 
 mqtt_message_t *mqtt_msg_puback(mqtt_connection_t *connection, uint16_t message_id)
 {
     set_message_header_size(connection);
+
     if (append_message_id(connection, message_id) == 0) {
         return fail_message(connection);
     }
+
     return fini_message(connection, MQTT_MSG_TYPE_PUBACK, 0, 0, 0);
 }
 
 mqtt_message_t *mqtt_msg_pubrec(mqtt_connection_t *connection, uint16_t message_id)
 {
     set_message_header_size(connection);
+
     if (append_message_id(connection, message_id) == 0) {
         return fail_message(connection);
     }
+
     return fini_message(connection, MQTT_MSG_TYPE_PUBREC, 0, 0, 0);
 }
 
 mqtt_message_t *mqtt_msg_pubrel(mqtt_connection_t *connection, uint16_t message_id)
 {
     set_message_header_size(connection);
+
     if (append_message_id(connection, message_id) == 0) {
         return fail_message(connection);
     }
+
     return fini_message(connection, MQTT_MSG_TYPE_PUBREL, 0, 1, 0);
 }
 
 mqtt_message_t *mqtt_msg_pubcomp(mqtt_connection_t *connection, uint16_t message_id)
 {
     set_message_header_size(connection);
+
     if (append_message_id(connection, message_id) == 0) {
         return fail_message(connection);
     }
+
     return fini_message(connection, MQTT_MSG_TYPE_PUBCOMP, 0, 0, 0);
 }
 
-mqtt_message_t *mqtt_msg_subscribe(mqtt_connection_t *connection, const esp_mqtt_topic_t topic_list[], int size, uint16_t *message_id)
+mqtt_message_t *mqtt_msg_subscribe(mqtt_connection_t *connection, const esp_mqtt_topic_t topic_list[], int size,
+                                   uint16_t *message_id)
 {
     set_message_header_size(connection);
 
@@ -532,6 +541,7 @@ mqtt_message_t *mqtt_msg_subscribe(mqtt_connection_t *connection, const esp_mqtt
         if (connection->outbound_message.length + 1 > connection->buffer_length) {
             return fail_message(connection);
         }
+
         connection->buffer[connection->outbound_message.length] = topic_list[topic_number].qos;
         connection->outbound_message.length ++;
     }
@@ -587,6 +597,7 @@ int mqtt_has_valid_msg_hdr(uint8_t *buffer, size_t length)
     if (length < 1) {
         return 0;
     }
+
     switch (mqtt_get_type(buffer)) {
     case MQTT_MSG_TYPE_CONNECT:
     case MQTT_MSG_TYPE_CONNACK:
@@ -599,10 +610,12 @@ int mqtt_has_valid_msg_hdr(uint8_t *buffer, size_t length)
     case MQTT_MSG_TYPE_PINGRESP:
     case MQTT_MSG_TYPE_DISCONNECT:
         return (buffer[0] & 0x0f) == 0;  /* all flag bits are 0 */
+
     case MQTT_MSG_TYPE_PUBREL:
     case MQTT_MSG_TYPE_SUBSCRIBE:
     case MQTT_MSG_TYPE_UNSUBSCRIBE:
         return (buffer[0] & 0x0f) == 0x02;  /* only bit 1 is set */
+
     case MQTT_MSG_TYPE_PUBLISH:
         qos = mqtt_get_qos(buffer);
         dup = mqtt_get_dup(buffer);
@@ -611,6 +624,7 @@ int mqtt_has_valid_msg_hdr(uint8_t *buffer, size_t length)
          * dup flag must be set to 0 for all qos=0 messages [MQTT-3.3.1-2]
          */
         return (qos < 3) && ((qos > 0) || (dup == 0));
+
     default:
         return 0;
     }
@@ -620,9 +634,11 @@ esp_err_t mqtt_msg_buffer_init(mqtt_connection_t *connection, int buffer_size)
 {
     memset(&connection->outbound_message, 0, sizeof(mqtt_message_t));
     connection->buffer = (uint8_t *)calloc(buffer_size, sizeof(uint8_t));
+
     if (!connection->buffer) {
         return ESP_ERR_NO_MEM;
     }
+
     connection->buffer_length = buffer_size;
     return ESP_OK;
 }
@@ -633,5 +649,3 @@ void mqtt_msg_buffer_destroy(mqtt_connection_t *connection)
         free(connection->buffer);
     }
 }
-
-

lib/mqtt_outbox.c

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 #include "mqtt_outbox.h"
 #include <stdint.h>
 #include <stdlib.h>
@@ -55,12 +60,15 @@ outbox_item_handle_t outbox_enqueue(outbox_handle_t outbox, outbox_message_handl
         return NULL;
     });
     memcpy(item->buffer, message->data, message->len);
+
     if (message->remaining_data) {
         memcpy(item->buffer + message->len, message->remaining_data, message->remaining_len);
     }
+
     STAILQ_INSERT_TAIL(outbox->list, item, next);
     outbox->size += item->len;
-    ESP_LOGD(TAG, "ENQUEUE msgid=%d, msg_type=%d, len=%d, size=%"PRIu64, message->msg_id, message->msg_type, message->len + message->remaining_len, outbox_get_size(outbox));
+    ESP_LOGD(TAG, "ENQUEUE msgid=%d, msg_type=%d, len=%d, size=%"PRIu64, message->msg_id, message->msg_type,
+             message->len + message->remaining_len, outbox_get_size(outbox));
     return item;
 }
 
@@ -83,6 +91,7 @@ outbox_item_handle_t outbox_dequeue(outbox_handle_t outbox, pending_state_t pend
             if (tick) {
                 *tick = item->tick;
             }
+
             return item;
         }
     }
@@ -96,7 +105,8 @@ esp_err_t outbox_delete_item(outbox_handle_t outbox, outbox_item_handle_t item_t
         if (item == item_to_delete) {
             STAILQ_REMOVE(outbox->list, item, outbox_item, next);
             outbox->size -= item->len;
-            ESP_LOGD(TAG, "DELETE_ITEM msgid=%d, msg_type=%d, remain size=%"PRIu64, item_to_delete->msg_id, item_to_delete->msg_type, outbox_get_size(outbox));
+            ESP_LOGD(TAG, "DELETE_ITEM msgid=%d, msg_type=%d, remain size=%"PRIu64, item_to_delete->msg_id,
+                     item_to_delete->msg_type, outbox_get_size(outbox));
             free(item->buffer);
             free(item);
             return ESP_OK;
@@ -114,6 +124,7 @@ uint8_t *outbox_item_get_data(outbox_item_handle_t item,  size_t *len, uint16_t
         *qos = item->msg_qos;
         return (uint8_t *)item->buffer;
     }
+
     return NULL;
 }
 
@@ -129,7 +140,6 @@ esp_err_t outbox_delete(outbox_handle_t outbox, int msg_id, int msg_type)
             free(item);
             return ESP_OK;
         }
-
     }
     return ESP_FAIL;
 }
@@ -137,10 +147,12 @@ esp_err_t outbox_delete(outbox_handle_t outbox, int msg_id, int msg_type)
 esp_err_t outbox_set_pending(outbox_handle_t outbox, int msg_id, pending_state_t pending)
 {
     outbox_item_handle_t item = outbox_get(outbox, msg_id);
+
     if (item) {
         item->pending = pending;
         return ESP_OK;
     }
+
     return ESP_FAIL;
 }
 
@@ -149,16 +161,19 @@ pending_state_t outbox_item_get_pending(outbox_item_handle_t item)
     if (item) {
         return item->pending;
     }
+
     return QUEUED;
 }
 
 esp_err_t outbox_set_tick(outbox_handle_t outbox, int msg_id, outbox_tick_t tick)
 {
     outbox_item_handle_t item = outbox_get(outbox, msg_id);
+
     if (item) {
         item->tick = tick;
         return ESP_OK;
     }
+
     return ESP_FAIL;
 }
 
@@ -176,7 +191,6 @@ int outbox_delete_single_expired(outbox_handle_t outbox, outbox_tick_t current_t
             ESP_LOGD(TAG, "DELETE_SINGLE_EXPIRED msgid=%d, remain size=%"PRIu64, msg_id, outbox_get_size(outbox));
             return msg_id;
         }
-
     }
     return msg_id;
 }
@@ -194,7 +208,6 @@ int outbox_delete_expired(outbox_handle_t outbox, outbox_tick_t current_tick, ou
             free(item);
             deleted_items ++;
         }
-
     }
     return deleted_items;
 }
@@ -210,7 +223,8 @@ void outbox_delete_all_items(outbox_handle_t outbox)
     STAILQ_FOREACH_SAFE(item, outbox->list, next, tmp) {
         STAILQ_REMOVE(outbox->list, item, outbox_item, next);
         outbox->size -= item->len;
-        ESP_LOGD(TAG, "DELETE_ALL_ITEMS msgid=%d, msg_type=%d, remain size=%"PRIu64, item->msg_id, item->msg_type, outbox_get_size(outbox));
+        ESP_LOGD(TAG, "DELETE_ALL_ITEMS msgid=%d, msg_type=%d, remain size=%"PRIu64, item->msg_id, item->msg_type,
+                 outbox_get_size(outbox));
         free(item->buffer);
         free(item);
     }

lib/platform_esp32_idf.c

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 #include "platform.h"
 
 #ifdef ESP_PLATFORM
@@ -24,14 +29,14 @@ char *platform_create_id_string(void)
 {
     char *id_string = calloc(1, MAX_ID_STRING);
     ESP_MEM_CHECK(TAG, id_string, return NULL);
-    #ifndef MAC_TYPE
+#ifndef MAC_TYPE
     ESP_LOGW(TAG, "Soc doesn't provide MAC, client could be disconnected in case of device with same name in the broker.");
     sprintf(id_string, "esp_mqtt_client_id");
-    #else
+#else
     uint8_t mac[6];
     esp_read_mac(mac, MAC_TYPE);
     sprintf(id_string, "ESP32_%02x%02X%02X", mac[3], mac[4], mac[5]);
-    #endif
+#endif
     return id_string;
 }
 
@@ -42,7 +47,7 @@ int platform_random(int max)
 
 uint64_t platform_tick_get_ms(void)
 {
-    return esp_timer_get_time()/(int64_t)1000;
+    return esp_timer_get_time() / (int64_t)1000;
 }
 
 #endif