Merge pull request #18 from mysterywolf/master

替换为rt_xxx

inc/umqtt.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2020, RT-Thread Development Team
+ * Copyright (c) 2006-2022, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -22,41 +22,41 @@ extern "C" {
 
 enum umqtt_client_state
 {
-    UMQTT_CS_IDLE             = 0x00000000,             /* idle state */ 
-    UMQTT_CS_LINKING          = 0x00000001,             /* connecting */ 
-    UMQTT_CS_LINKED           = 0x00000002,             /* connected */ 
-    UMQTT_CS_UNLINK           = 0x00000004,             /* offline */ 
-    UMQTT_CS_UNLINK_LINKING   = 0x00000008,             /* offline linking */ 
+    UMQTT_CS_IDLE             = 0x00000000,             /* idle state */
+    UMQTT_CS_LINKING          = 0x00000001,             /* connecting */
+    UMQTT_CS_LINKED           = 0x00000002,             /* connected */
+    UMQTT_CS_UNLINK           = 0x00000004,             /* offline */
+    UMQTT_CS_UNLINK_LINKING   = 0x00000008,             /* offline linking */
     UMQTT_CS_DISCONNECT       = 0x00000010,             /* reconnect failed */
 };
 
 enum umqtt_err_code
 {
-    UMQTT_OK                    = 0,                    /* no error code */ 
-    UMQTT_FAILED                = -1,                   /* function failed */ 
-    UMQTT_MEM_FULL              = -2,                   /* out of memory */ 
-    UMQTT_TIMEOUT               = -3,                   /* function timeout */ 
-    UMQTT_ENCODE_ERROR          = -4,                   /* encode error */ 
-    UMQTT_DECODE_ERROR          = -5,                   /* decode error */ 
-    UMQTT_SEND_TIMEOUT          = -6,                   /* send timeout */ 
+    UMQTT_OK                    = 0,                    /* no error code */
+    UMQTT_FAILED                = -1,                   /* function failed */
+    UMQTT_MEM_FULL              = -2,                   /* out of memory */
+    UMQTT_TIMEOUT               = -3,                   /* function timeout */
+    UMQTT_ENCODE_ERROR          = -4,                   /* encode error */
+    UMQTT_DECODE_ERROR          = -5,                   /* decode error */
+    UMQTT_SEND_TIMEOUT          = -6,                   /* send timeout */
     UMQTT_SEND_FAILED           = -7,                   /* send failed */
-    UMQTT_INPARAMS_NULL         = -8,                   /* input params is null */ 
+    UMQTT_INPARAMS_NULL         = -8,                   /* input params is null */
     UMQTT_BUFFER_TOO_SHORT      = -9,                   /* buff too short */
     UMQTT_READ_ERROR            = -10,                  /* read error */
     UMQTT_READ_FAILED           = -11,                  /* read failed */
     UMQTT_READ_TIMEOUT          = -12,
-    UMQTT_FIN_ACK               = -13,                  /* server send fin ack to client */ 
-    UMQTT_RECONNECT_FAILED      = -14,                  /* reconnect failed  */ 
+    UMQTT_FIN_ACK               = -13,                  /* server send fin ack to client */
+    UMQTT_RECONNECT_FAILED      = -14,                  /* reconnect failed  */
     UMQTT_SOCK_CONNECT_FAILED   = -15,
     UMQTT_DISCONNECT            = -16,
 };
 
 enum umqtt_evt
 {
-    UMQTT_EVT_LINK              = 0x00,                 /* link event */ 
-    UMQTT_EVT_ONLINE            = 0x01,                 /* online event */ 
-    UMQTT_EVT_OFFLINE           = 0x02,                 /* offline event */ 
-    UMQTT_EVT_HEARTBEAT         = 0x03,                 /* heartbeat event */ 
+    UMQTT_EVT_LINK              = 0x00,                 /* link event */
+    UMQTT_EVT_ONLINE            = 0x01,                 /* online event */
+    UMQTT_EVT_OFFLINE           = 0x02,                 /* offline event */
+    UMQTT_EVT_HEARTBEAT         = 0x03,                 /* heartbeat event */
 };
 
 enum umqtt_cmd
@@ -68,7 +68,7 @@ enum umqtt_cmd
 
     UMQTT_CMD_DISCONNECT        = 0x7E,                 /* close socket & mqtt disconnect */
     UMQTT_CMD_DEL_HANDLE        = 0x7F,
-#ifdef PKG_UMQTT_TEST_SHORT_KEEPALIVE_TIME 
+#ifdef PKG_UMQTT_TEST_SHORT_KEEPALIVE_TIME
     UMQTT_CMD_SET_CON_KP        = 0x80,
 #endif
 };
@@ -90,26 +90,26 @@ struct subtop_recv_handler
 
 struct umqtt_info
 {
-    rt_size_t send_size, recv_size;                     /* send/receive buffer size */ 
-    const char *uri;                                    /* complete URI (include: URI + URN) */ 
-    const char *client_id;                              /* client id */ 
+    rt_size_t send_size, recv_size;                     /* send/receive buffer size */
+    const char *uri;                                    /* complete URI (include: URI + URN) */
+    const char *client_id;                              /* client id */
     const char *lwt_topic;                              /* will topic */
-    const char *lwt_message;                            /* will message */ 
-    const char *user_name;                              /* user_name */ 
-    const char *password;                               /* password */ 
+    const char *lwt_message;                            /* will message */
+    const char *user_name;                              /* user_name */
+    const char *password;                               /* password */
     enum umqtt_qos lwt_qos;                             /* will qos */
     umqtt_subscribe_cb lwt_cb;                          /* will callback */
-    rt_uint8_t reconnect_max_num;                       /* reconnect max count */ 
-    rt_uint32_t reconnect_interval;                     /* reconnect interval time */ 
-    rt_uint8_t keepalive_max_num;                       /* keepalive max count */ 
-    rt_uint32_t keepalive_interval;                     /* keepalive interval */ 
-    rt_uint32_t recv_time_ms;                           /* receive timeout */ 
-    rt_uint32_t connect_time;                           /* connect timeout */ 
-    rt_uint32_t send_timeout;                           /* uplink_timeout  publish/subscribe/unsubscribe */ 
-    rt_uint32_t thread_stack_size;                      /* thread task stack size */ 
-    rt_uint8_t thread_priority;                         /* thread priority */ 
+    rt_uint8_t reconnect_max_num;                       /* reconnect max count */
+    rt_uint32_t reconnect_interval;                     /* reconnect interval time */
+    rt_uint8_t keepalive_max_num;                       /* keepalive max count */
+    rt_uint32_t keepalive_interval;                     /* keepalive interval */
+    rt_uint32_t recv_time_ms;                           /* receive timeout */
+    rt_uint32_t connect_time;                           /* connect timeout */
+    rt_uint32_t send_timeout;                           /* uplink_timeout  publish/subscribe/unsubscribe */
+    rt_uint32_t thread_stack_size;                      /* thread task stack size */
+    rt_uint8_t thread_priority;                         /* thread priority */
 #ifdef PKG_UMQTT_TEST_SHORT_KEEPALIVE_TIME
-    rt_uint16_t connect_keepalive_sec;                  /* connect information, keepalive second */    
+    rt_uint16_t connect_keepalive_sec;                  /* connect information, keepalive second */
 #endif
 };
 

inc/umqtt_cfg.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2020, RT-Thread Development Team
+ * Copyright (c) 2006-2022, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -13,11 +13,11 @@
 
 #define PKG_UMQTT_PROTOCOL_NAME                         ("MQTC")
 #define PKG_UMQTT_PROTOCOL_NAME_LEN                     (rt_strlen(PKG_UMQTT_PROTOCOL_NAME))
-#define PKG_UMQTT_PROTOCOL_LEVEL                        (4)             /* MQTT3.1.1 ver_lvl:4;  MQTT3.1 ver_lvl:3 */ 
+#define PKG_UMQTT_PROTOCOL_LEVEL                        (4)             /* MQTT3.1.1 ver_lvl:4;  MQTT3.1 ver_lvl:3 */
 
 #ifdef PKG_UMQTT_WILL_TOPIC_STRING
 #define UMQTT_WILL_TOPIC                                PKG_UMQTT_WILL_TOPIC_STRING
-#else 
+#else
 #define UMQTT_WILL_TOPIC                                ("/umqtt/test")
 #endif
 
@@ -28,15 +28,15 @@
 #endif
 
 #define UMQTT_INFO_DEF_THREAD_TICK                      50
-#define UMQTT_MAX_PACKET_ID                             65535   
-#define UMQTT_INFO_DEF_UPLINK_TIMER_TICK                1000 
+#define UMQTT_MAX_PACKET_ID                             65535
+#define UMQTT_INFO_DEF_UPLINK_TIMER_TICK                1000
 
 #ifndef PKG_UMQTT_PUBLISH_RECON_MAX
 #define PKG_UMQTT_PUBLISH_RECON_MAX                     3
 #endif
 #ifndef PKG_UMQTT_QOS2_QUE_MAX
 #define PKG_UMQTT_QOS2_QUE_MAX                          1
-#endif            
+#endif
 #define PKG_UMQTT_RECPUBREC_INTERVAL_TIME               (2 * UMQTT_INFO_DEF_UPLINK_TIMER_TICK)
 
 #endif

inc/umqtt_internal.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2020, RT-Thread Development Team
+ * Copyright (c) 2006-2022, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -59,169 +59,169 @@ enum umqtt_connack_retcode
 
 union umqtt_pkgs_fix_header
 {
-    rt_uint8_t byte;                                /* header */ 
-    struct {        
-        rt_uint8_t retain: 1;                       /* reserved bits */ 
-        rt_uint8_t qos:    2;                       /* QoS, 0-Almost once; 1-Alteast once; 2-Exactly once */ 
-        rt_uint8_t dup:    1;                       /* dup flag */ 
-        rt_uint8_t type:   4;                       /* MQTT packet type */ 
+    rt_uint8_t byte;                                /* header */
+    struct {
+        rt_uint8_t retain: 1;                       /* reserved bits */
+        rt_uint8_t qos:    2;                       /* QoS, 0-Almost once; 1-Alteast once; 2-Exactly once */
+        rt_uint8_t dup:    1;                       /* dup flag */
+        rt_uint8_t type:   4;                       /* MQTT packet type */
     } bits;
 };
 union umqtt_pkgs_connect_sign
 {
     rt_uint8_t connect_sign;
     struct {
-        rt_uint8_t reserved:       1;               /* reserved bits */ 
-        rt_uint8_t clean_session:  1;               /* clean session bit */ 
-        rt_uint8_t will_flag:      1;               /* will flag bit */ 
-        rt_uint8_t will_Qos:       2;               /* will Qos bit */ 
-        rt_uint8_t will_retain:    1;               /* will retain bit */ 
-        rt_uint8_t password_flag:  1;               /* password flag bit */ 
-        rt_uint8_t username_flag:  1;               /* user name flag bit */ 
+        rt_uint8_t reserved:       1;               /* reserved bits */
+        rt_uint8_t clean_session:  1;               /* clean session bit */
+        rt_uint8_t will_flag:      1;               /* will flag bit */
+        rt_uint8_t will_Qos:       2;               /* will Qos bit */
+        rt_uint8_t will_retain:    1;               /* will retain bit */
+        rt_uint8_t password_flag:  1;               /* password flag bit */
+        rt_uint8_t username_flag:  1;               /* user name flag bit */
     } bits;
 };
 union umqtt_pkgs_connack_sign
 {
     rt_uint8_t connack_sign;
     struct {
-        rt_uint8_t sp:             1;               /* current session bit */ 
-        rt_uint8_t reserved:       7;               /* retain bit */ 
+        rt_uint8_t sp:             1;               /* current session bit */
+        rt_uint8_t reserved:       7;               /* retain bit */
     } bits;
 };
 union pkgs_request_qos
 {
     rt_uint8_t request_qos;
     struct {
-        rt_uint8_t qos:            2;               /* QoS - 0/1/2 */ 
-        rt_uint8_t reserved:       6;               /* retain bit */ 
+        rt_uint8_t qos:            2;               /* QoS - 0/1/2 */
+        rt_uint8_t reserved:       6;               /* retain bit */
     } bits;
 };
 struct sub_topic_filter
 {
-    rt_uint16_t filter_len;                         /* topic filter length */ 
-    const char *topic_filter;                       /* topic name filter */ 
-    union pkgs_request_qos req_qos;                 /* request QoS */ 
+    rt_uint16_t filter_len;                         /* topic filter length */
+    const char *topic_filter;                       /* topic name filter */
+    union pkgs_request_qos req_qos;                 /* request QoS */
 };
 struct unsub_topic_filter
 {
-    rt_uint16_t filter_len;                         /* topic filter length */ 
-    const char *topic_filter;                       /* topic filter */ 
+    rt_uint16_t filter_len;                         /* topic filter length */
+    const char *topic_filter;                       /* topic filter */
 };
 struct umqtt_pkgs_connect
 {
-    /* variable header */ 
-    rt_uint16_t protocol_name_len;                  /* protocol name length */ 
+    /* variable header */
+    rt_uint16_t protocol_name_len;                  /* protocol name length */
     const char *protocol_name;                      /* protocol name */
-    rt_uint8_t protocol_level;                      /* protocol level */ 
-    union umqtt_pkgs_connect_sign connect_flags;    /* connect flags */ 
-    rt_uint16_t keepalive_interval_sec;             /* keepalive interval second */ 
-    /* payload */ 
-    const char *client_id;                          /* client id */ 
-    const char *will_topic;                         /* will topic */ 
-    const char *will_message;                       /* will messagewill message */ 
-    const char *user_name;                          /* user name */ 
-    rt_uint16_t password_len;                       /* password length */ 
-    const char *password;                           /* password */ 
+    rt_uint8_t protocol_level;                      /* protocol level */
+    union umqtt_pkgs_connect_sign connect_flags;    /* connect flags */
+    rt_uint16_t keepalive_interval_sec;             /* keepalive interval second */
+    /* payload */
+    const char *client_id;                          /* client id */
+    const char *will_topic;                         /* will topic */
+    const char *will_message;                       /* will messagewill message */
+    const char *user_name;                          /* user name */
+    rt_uint16_t password_len;                       /* password length */
+    const char *password;                           /* password */
 };
 struct umqtt_pkgs_connack
 {
-    /* variable header */ 
-    union umqtt_pkgs_connack_sign connack_flags;    /* connect flags */ 
-    enum umqtt_connack_retcode ret_code;            /* connect return code */ 
-    /* payload = NULL */ 
+    /* variable header */
+    union umqtt_pkgs_connack_sign connack_flags;    /* connect flags */
+    enum umqtt_connack_retcode ret_code;            /* connect return code */
+    /* payload = NULL */
 };
 struct umqtt_pkgs_publish
-{   
-    /* variable header */ 
-    rt_uint16_t topic_name_len;                     /* topic name length */ 
-    const char *topic_name;                         /* topic name */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload */ 
-    const char *payload;                            /* active payload */ 
-    /* not packet datas */ 
-    rt_uint32_t payload_len;                        /* retain payload length */ 
+{
+    /* variable header */
+    rt_uint16_t topic_name_len;                     /* topic name length */
+    const char *topic_name;                         /* topic name */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload */
+    const char *payload;                            /* active payload */
+    /* not packet datas */
+    rt_uint32_t payload_len;                        /* retain payload length */
 };
 struct umqtt_pkgs_puback
 {
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload = NULL */ 
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload = NULL */
 };
-struct umqtt_pkgs_pubrec                            /* publish receive (QoS 2, step_1st) */ 
+struct umqtt_pkgs_pubrec                            /* publish receive (QoS 2, step_1st) */
 {
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload = NULL */ 
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload = NULL */
 };
-struct umqtt_pkgs_pubrel                            /* publish release (QoS 2, step_2nd) */ 
+struct umqtt_pkgs_pubrel                            /* publish release (QoS 2, step_2nd) */
 {
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload = NULL */ 
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload = NULL */
 };
-struct umqtt_pkgs_pubcomp                           /* publish complete (QoS 2, step_3rd) */ 
+struct umqtt_pkgs_pubcomp                           /* publish complete (QoS 2, step_3rd) */
 {
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload = NULL */ 
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload = NULL */
 };
-struct umqtt_pkgs_subscribe                         /* subscribe topic */ 
+struct umqtt_pkgs_subscribe                         /* subscribe topic */
 {
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload */ 
-    struct sub_topic_filter topic_filter[PKG_UMQTT_SUBRECV_DEF_LENGTH];          /* topic name filter arrays */ 
-    /* not payload datas */ 
-    rt_uint8_t topic_count;                         /* topic filter count */ 
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload */
+    struct sub_topic_filter topic_filter[PKG_UMQTT_SUBRECV_DEF_LENGTH];          /* topic name filter arrays */
+    /* not payload datas */
+    rt_uint8_t topic_count;                         /* topic filter count */
 };
-struct umqtt_pkgs_suback                            /* subscribe ack */ 
-{   
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload */ 
-    rt_uint8_t ret_qos[PKG_UMQTT_SUBRECV_DEF_LENGTH];   /* return code - enum Qos - 0/1/2 */ 
-    /* not payload datas */ 
-    rt_uint8_t topic_count;                         /* topic name count */ 
+struct umqtt_pkgs_suback                            /* subscribe ack */
+{
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload */
+    rt_uint8_t ret_qos[PKG_UMQTT_SUBRECV_DEF_LENGTH];   /* return code - enum Qos - 0/1/2 */
+    /* not payload datas */
+    rt_uint8_t topic_count;                         /* topic name count */
 };
-struct umqtt_pkgs_unsubscribe                       /* unsubscribe */ 
-{   
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload */ 
-    struct unsub_topic_filter topic_filter[PKG_UMQTT_SUBRECV_DEF_LENGTH];      /* topic name filter arrays */ 
-    /* not payload datas */ 
-    rt_uint8_t topic_count;                         /* topic name count */ 
+struct umqtt_pkgs_unsubscribe                       /* unsubscribe */
+{
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload */
+    struct unsub_topic_filter topic_filter[PKG_UMQTT_SUBRECV_DEF_LENGTH];      /* topic name filter arrays */
+    /* not payload datas */
+    rt_uint8_t topic_count;                         /* topic name count */
 };
-struct umqtt_pkgs_unsuback                          /* unsubscribe ack */ 
+struct umqtt_pkgs_unsuback                          /* unsubscribe ack */
 {
-    /* variable header */ 
-    rt_uint16_t packet_id;                          /* packet id */ 
-    /* payload = NULL */ 
+    /* variable header */
+    rt_uint16_t packet_id;                          /* packet id */
+    /* payload = NULL */
 };
-// struct pkgs_pingreq { }                          /* ping request = NULL */ 
-// struct pkgs_pingresp { }                         /* ping response = NULL */ 
-// struct pkgs_disconnect { }                       /* disconnect = NULL */ 
+// struct pkgs_pingreq { }                          /* ping request = NULL */
+// struct pkgs_pingresp { }                         /* ping response = NULL */
+// struct pkgs_disconnect { }                       /* disconnect = NULL */
 
-union umqtt_pkgs_msg                                /* mqtt message packet type */ 
+union umqtt_pkgs_msg                                /* mqtt message packet type */
 {
-    struct umqtt_pkgs_connect     connect;          /* connect */ 
-    struct umqtt_pkgs_connack     connack;          /* connack */ 
-    struct umqtt_pkgs_publish     publish;          /* publish */ 
-    struct umqtt_pkgs_puback      puback;           /* puback */ 
-    struct umqtt_pkgs_pubrec      pubrec;           /* publish receive (QoS 2, step_1st) */ 
-    struct umqtt_pkgs_pubrel      pubrel;           /* publish release (QoS 2, step_2nd) */ 
-    struct umqtt_pkgs_pubcomp     pubcomp;          /* publish complete (QoS 2, step_3rd) */ 
-    struct umqtt_pkgs_subscribe   subscribe;        /* subscribe topic */ 
-    struct umqtt_pkgs_suback      suback;           /* subscribe ack */ 
-    struct umqtt_pkgs_unsubscribe unsubscribe;      /* unsubscribe topic */ 
-    struct umqtt_pkgs_unsuback    unsuback;         /* unsubscribe ack */ 
+    struct umqtt_pkgs_connect     connect;          /* connect */
+    struct umqtt_pkgs_connack     connack;          /* connack */
+    struct umqtt_pkgs_publish     publish;          /* publish */
+    struct umqtt_pkgs_puback      puback;           /* puback */
+    struct umqtt_pkgs_pubrec      pubrec;           /* publish receive (QoS 2, step_1st) */
+    struct umqtt_pkgs_pubrel      pubrel;           /* publish release (QoS 2, step_2nd) */
+    struct umqtt_pkgs_pubcomp     pubcomp;          /* publish complete (QoS 2, step_3rd) */
+    struct umqtt_pkgs_subscribe   subscribe;        /* subscribe topic */
+    struct umqtt_pkgs_suback      suback;           /* subscribe ack */
+    struct umqtt_pkgs_unsubscribe unsubscribe;      /* unsubscribe topic */
+    struct umqtt_pkgs_unsuback    unsuback;         /* unsubscribe ack */
 };
 
 struct umqtt_msg
 {
-    union umqtt_pkgs_fix_header header;             /* fix header */ 
-    rt_uint32_t msg_len;                            /* message length */ 
-    union umqtt_pkgs_msg msg;                       /* retain payload message */ 
+    union umqtt_pkgs_fix_header header;             /* fix header */
+    rt_uint32_t msg_len;                            /* message length */
+    union umqtt_pkgs_msg msg;                       /* retain payload message */
 };
 
 /* umqtt package datas */
@@ -243,37 +243,37 @@ typedef struct umqtt_pkgs_connect MQTTPacket_connectData;
 
 static void umqtt_writeChar(unsigned char** pptr, char c)
 {
-	**pptr = c;
-	(*pptr)++;
+    **pptr = c;
+    (*pptr)++;
 }
 
 static char umqtt_readChar(unsigned char** pptr)
 {
-	char c = **pptr;
-	(*pptr)++;
-	return c;
+    char c = **pptr;
+    (*pptr)++;
+    return c;
 }
 
 static void umqtt_writeInt(unsigned char** pptr, int anInt)
 {
-	**pptr = (unsigned char)(anInt / 256);
-	(*pptr)++;
-	**pptr = (unsigned char)(anInt % 256);
-	(*pptr)++;
+    **pptr = (unsigned char)(anInt / 256);
+    (*pptr)++;
+    **pptr = (unsigned char)(anInt % 256);
+    (*pptr)++;
 }
 
 static int umqtt_readInt(unsigned char** pptr)
 {
-	unsigned char* ptr = *pptr;
-	int len = 256*(*ptr) + (*(ptr+1));
-	*pptr += 2;
-	return len;
+    unsigned char* ptr = *pptr;
+    int len = 256*(*ptr) + (*(ptr+1));
+    *pptr += 2;
+    return len;
 }
 
 static void umqtt_writeCString(unsigned char** pptr, const char* string)
 {
-	int len = 0;
-    if (string) 
+    int len = 0;
+    if (string)
     {
         len = strlen(string);
         umqtt_writeInt(pptr, len);
@@ -284,15 +284,15 @@ static void umqtt_writeCString(unsigned char** pptr, const char* string)
 
 static void umqtt_writeMQTTString(unsigned char** pptr, const char* string)
 {
-	int len = 0;
-    if (string) 
+    int len = 0;
+    if (string)
     {
         len = strlen(string);
         umqtt_writeInt(pptr, len);
         memcpy(*pptr, string, len);
         *pptr += len;
-    } 
-    else 
+    }
+    else
     {
         umqtt_writeInt(pptr, 0);
     }
@@ -302,12 +302,12 @@ static int umqtt_readlenstring(int *str_len, char **p_string, unsigned char **pp
 {
     int rc = 0;
 
-    if (enddata - (*pptr) > 1) 
+    if (enddata - (*pptr) > 1)
     {
         *str_len = umqtt_readInt(pptr);
-        if (&(*pptr)[*str_len] <= enddata) 
+        if (&(*pptr)[*str_len] <= enddata)
         {
-            *p_string = (char *)*pptr; 
+            *p_string = (char *)*pptr;
             *pptr += *str_len;
             rc = 1;
         }
@@ -317,60 +317,60 @@ static int umqtt_readlenstring(int *str_len, char **p_string, unsigned char **pp
 
 static int umqtt_pkgs_encode(unsigned char* buf, int length)
 {
-	int rc = 0;
-	do {
-		char d = length % 128;
-		length /= 128;
-		/* if there are more digits to encode, set the top bit of this digit */
-		if (length > 0)
-			d |= 0x80;
-		buf[rc++] = d;
-	} while (length > 0);
-	return rc;
+    int rc = 0;
+    do {
+        char d = length % 128;
+        length /= 128;
+        /* if there are more digits to encode, set the top bit of this digit */
+        if (length > 0)
+            d |= 0x80;
+        buf[rc++] = d;
+    } while (length > 0);
+    return rc;
 }
 
 static int umqtt_pkgs_decode(int (*getcharfn)(unsigned char*, int), int* value)
 {
-	unsigned char c;
-	int multiplier = 1;
-	int len = 0;
+    unsigned char c;
+    int multiplier = 1;
+    int len = 0;
 #define MAX_NO_OF_REMAINING_LENGTH_BYTES 4
 
-	*value = 0;
-	do
-	{
-		int rc = UMQTT_READ_ERROR;
-
-		if (++len > MAX_NO_OF_REMAINING_LENGTH_BYTES)
-		{
-			rc = UMQTT_READ_ERROR;	/* bad data */
-			goto exit;
-		}
-		rc = (*getcharfn)(&c, 1);
-		if (rc != 1)
-			goto exit;
-		*value += (c & 127) * multiplier;
-		multiplier *= 128;
-	} while ((c & 128) != 0);
+    *value = 0;
+    do
+    {
+        int rc = UMQTT_READ_ERROR;
+
+        if (++len > MAX_NO_OF_REMAINING_LENGTH_BYTES)
+        {
+            rc = UMQTT_READ_ERROR;  /* bad data */
+            goto exit;
+        }
+        rc = (*getcharfn)(&c, 1);
+        if (rc != 1)
+            goto exit;
+        *value += (c & 127) * multiplier;
+        multiplier *= 128;
+    } while ((c & 128) != 0);
 exit:
-	return len;
+    return len;
 }
 
 static int umqtt_pkgs_len(int rem_len)
 {
-	rem_len += 1; /* header byte */
-
-	/* now remaining_length field */
-	if (rem_len < 128)
-		rem_len += 1;
-	else if (rem_len < 16384)
-		rem_len += 2;
-	else if (rem_len < 2097151)
-		rem_len += 3;
-	else
-		rem_len += 4;
-
-	return rem_len;
+    rem_len += 1; /* header byte */
+
+    /* now remaining_length field */
+    if (rem_len < 128)
+        rem_len += 1;
+    else if (rem_len < 16384)
+        rem_len += 2;
+    else if (rem_len < 2097151)
+        rem_len += 3;
+    else
+        rem_len += 4;
+
+    return rem_len;
 }
 
 #ifdef __cplusplus

samples/umqtt_sample.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2020, RT-Thread Development Team
+ * Copyright (c) 2006-2022, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -24,7 +24,7 @@
 #include "umqtt.h"
 #include "umqtt_internal.h"
 
-// #define MQTT_URI                "tcp://test.mosquitto.org:1883" 
+// #define MQTT_URI                "tcp://test.mosquitto.org:1883"
 // #define MQTT_URI                "tcp://mq.tongxinmao.com:18831"
 #define MQTT_URI                "tcp://192.168.12.83:1883"
 #define MQTT_SUBTOPIC           "/umqtt/test"
@@ -86,7 +86,7 @@ static int umqtt_ex_start(int argc, char **argv)
     if (is_started)
     {
         LOG_E(" umqtt client is already connected.");
-        return -1;        
+        return -1;
     }
 
     struct umqtt_info umqtt_info = { 0 };
@@ -125,11 +125,11 @@ static int umqtt_ex_stop(int argc, char **argv)
     }
 
     is_started = 0;
-    
+
     umqtt_stop(m_umqtt_client);
     umqtt_delete(m_umqtt_client);
     m_umqtt_client = RT_NULL;
-    
+
     return 0;
 }
 
@@ -155,7 +155,7 @@ static int umqtt_ex_publish(int argc, char **argv)
         LOG_E("mqtt client is not connected.");
         return -1;
     }
-	
+
     if (argc == 4) {
         int _len = str_to_int(argv[2]);
         // LOG_D(" *argv[0]: %s, *argv[1]: %s, *argv[2]: %d, *argv[3]: %s ", argv[0], argv[1], _len, argv[3]);
@@ -177,8 +177,8 @@ static int umqtt_ex_subscribe(int argc, char **argv)
         LOG_E("umqtt_subscribe [topic]  --send an umqtt subscribe packet and wait for suback before returning.\n");
         return -1;
     }
-	
-	if (is_started == 0)
+
+    if (is_started == 0)
     {
         LOG_E("umqtt client is not connected.");
         return -1;
@@ -197,8 +197,8 @@ static int umqtt_ex_unsubscribe(int argc, char **argv)
         LOG_E("mqtt_unsubscribe [topic]  --send an mqtt unsubscribe packet and wait for suback before returning.\n");
         return -1;
     }
-	
-	if (is_started == 0)
+
+    if (is_started == 0)
     {
         LOG_E("mqtt client is not connected.");
         return -1;

src/pkgs/umqtt_pkgs_decode.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2020, RT-Thread Development Team
+ * Copyright (c) 2006-2022, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -25,16 +25,16 @@ static unsigned char* bufptr;
 
 static int bufchar(unsigned char* c, int count)
 {
-	int i;
-	for (i = 0; i < count; ++i)
-		*c = *bufptr++;
-	return count;
+    int i;
+    for (i = 0; i < count; ++i)
+        *c = *bufptr++;
+    return count;
 }
 
 static int umqtt_pkgs_decodeBuf(unsigned char* buf, int* value)
 {
-	bufptr = buf;
-	return umqtt_pkgs_decode(bufchar, value);
+    bufptr = buf;
+    return umqtt_pkgs_decode(bufchar, value);
 }
 
 static int MQTTDeserialize_publish(struct umqtt_msg *pub_msg, rt_uint8_t *buf, int buflen)
@@ -45,7 +45,7 @@ static int MQTTDeserialize_publish(struct umqtt_msg *pub_msg, rt_uint8_t *buf, i
     int mylen = 0;
 
     pub_msg->header.byte = umqtt_readChar(&curdata);
-    if (pub_msg->header.bits.type != UMQTT_TYPE_PUBLISH) 
+    if (pub_msg->header.bits.type != UMQTT_TYPE_PUBLISH)
     {
         LOG_E(" decode datas, is not publish type! type:%d", pub_msg->header.bits.type);
         rc = UMQTT_DECODE_ERROR;
@@ -54,18 +54,18 @@ static int MQTTDeserialize_publish(struct umqtt_msg *pub_msg, rt_uint8_t *buf, i
 
     curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen));
     enddata = curdata + mylen;
-    
-    if (!umqtt_readlenstring((int *)&(pub_msg->msg.publish.topic_name_len), &(pub_msg->msg.publish.topic_name), &curdata, enddata) 
-     || (enddata - curdata < 0)) 
-    {  
+
+    if (!umqtt_readlenstring((int *)&(pub_msg->msg.publish.topic_name_len), &(pub_msg->msg.publish.topic_name), &curdata, enddata)
+     || (enddata - curdata < 0))
+    {
         LOG_E(" decode publish, topic name error!");
         rc = UMQTT_DECODE_ERROR;
         goto exit;
     }
 
-    if (pub_msg->header.bits.qos > 0) 
+    if (pub_msg->header.bits.qos > 0)
         pub_msg->msg.publish.packet_id = umqtt_readInt(&curdata);
-    
+
     pub_msg->msg.publish.payload_len = enddata - curdata;
     pub_msg->msg.publish.payload = curdata;
 exit:
@@ -80,7 +80,7 @@ static int MQTTDeserialize_ack(struct umqtt_msg *puback_msg, rt_uint8_t *buf, in
     int mylen;
 
     puback_msg->header.byte = umqtt_readChar(&curdata);
-    
+
     curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen));
     enddata = curdata + mylen;
 
@@ -98,37 +98,37 @@ exit:
 static int umqtt_connack_decode(struct umqtt_pkgs_connack *connack_msg, rt_uint8_t* buf, int buflen)
 {
     MQTTHeader header = {0};
-	unsigned char* curdata = buf;
-	unsigned char* enddata = NULL;
-	int rc = 0;
-	int mylen;
+    unsigned char* curdata = buf;
+    unsigned char* enddata = NULL;
+    int rc = 0;
+    int mylen;
 
-	header.byte = umqtt_readChar(&curdata);
-	if (header.bits.type != UMQTT_TYPE_CONNACK)
+    header.byte = umqtt_readChar(&curdata);
+    if (header.bits.type != UMQTT_TYPE_CONNACK)
     {
         rc = UMQTT_FAILED;
         LOG_E(" not connack type!");
-		goto exit;
+        goto exit;
     }
 
-	curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen)); /* read remaining length */
-	enddata = curdata + mylen;
-	if (enddata - curdata < 2)
+    curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen)); /* read remaining length */
+    enddata = curdata + mylen;
+    if (enddata - curdata < 2)
     {
         LOG_D(" enddata:%d, curdata:%d, mylen:%d", enddata, curdata, mylen);
-		goto exit;
+        goto exit;
     }
 
     connack_msg->connack_flags.connack_sign = umqtt_readChar(&curdata);
     connack_msg->ret_code = umqtt_readChar(&curdata);
 exit:
-	return rc;
+    return rc;
 }
 
 
 // static int umqtt_pingresp_decode();
-/** 
- * parse the publish datas 
+/**
+ * parse the publish datas
  *
  * @param publish_msg the output datas
  * @param buf the input datas need to parse
@@ -141,8 +141,8 @@ static int umqtt_publish_decode(struct umqtt_msg *publish_msg, rt_uint8_t *buf,
 {
     return MQTTDeserialize_publish(publish_msg, buf, buflen);
 }
-/** 
- * parse the puback datas 
+/**
+ * parse the puback datas
  *
  * @param puback_msg the output datas
  * @param buf the input datas need to parse
@@ -155,12 +155,12 @@ static int umqtt_puback_decode(struct umqtt_msg *puback_msg, rt_uint8_t *buf, in
 {
     return MQTTDeserialize_ack(puback_msg, buf, buflen);
 }
-// static int umqtt_pubrec_decode();       // 
-// static int umqtt_pubrel_decode();       // 
-// static int umqtt_pubcomp_decode();      // 
+// static int umqtt_pubrec_decode();       //
+// static int umqtt_pubrel_decode();       //
+// static int umqtt_pubcomp_decode();      //
 
-/** 
- * parse the suback datas 
+/**
+ * parse the suback datas
  *
  * @param suback_msg the output datas
  * @param buf the input datas need to parse
@@ -171,46 +171,46 @@ static int umqtt_puback_decode(struct umqtt_msg *puback_msg, rt_uint8_t *buf, in
  */
 static int umqtt_suback_decode(struct umqtt_pkgs_suback *suback_msg, rt_uint8_t *buf, int buflen)
 {
-	MQTTHeader header = {0};
-	unsigned char* curdata = buf;
-	unsigned char* enddata = NULL;
-	int rc = 0;
-	int mylen;
-
-	header.byte = umqtt_readChar(&curdata);
-	if (header.bits.type != UMQTT_TYPE_SUBACK)
+    MQTTHeader header = {0};
+    unsigned char* curdata = buf;
+    unsigned char* enddata = NULL;
+    int rc = 0;
+    int mylen;
+
+    header.byte = umqtt_readChar(&curdata);
+    if (header.bits.type != UMQTT_TYPE_SUBACK)
     {
         rc = UMQTT_FAILED;
-		goto exit;
+        goto exit;
     }
 
-	curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen)); /* read remaining length */
-	enddata = curdata + mylen;
-	if (enddata - curdata < 2)
+    curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen)); /* read remaining length */
+    enddata = curdata + mylen;
+    if (enddata - curdata < 2)
     {
         rc = UMQTT_DECODE_ERROR;
-		goto exit;
+        goto exit;
     }
 
-	suback_msg->packet_id = umqtt_readInt(&curdata);
+    suback_msg->packet_id = umqtt_readInt(&curdata);
 
-	suback_msg->topic_count = 0;
-	while (curdata < enddata)
-	{
-		if (suback_msg->topic_count > PKG_UMQTT_SUBRECV_DEF_LENGTH) 
+    suback_msg->topic_count = 0;
+    while (curdata < enddata)
+    {
+        if (suback_msg->topic_count > PKG_UMQTT_SUBRECV_DEF_LENGTH)
         {
             rc = UMQTT_FAILED;
-			goto exit;
-		}
+            goto exit;
+        }
         suback_msg->ret_qos[(suback_msg->topic_count)++] = umqtt_readChar(&curdata);
-	}
+    }
 
 exit:
-	return rc;
+    return rc;
 }
 
-/** 
- * parse the unsuback datas 
+/**
+ * parse the unsuback datas
  *
  * @param unsuback_msg the output datas
  * @param buf the input datas need to parse
@@ -221,26 +221,26 @@ exit:
  */
 static int umqtt_unsuback_decode(struct umqtt_pkgs_unsuback *unsuback_msg, rt_uint8_t *buf, int buflen)
 {
-	unsigned char* curdata = buf;
-	unsigned char* enddata = NULL;
-	int rc = 0;
-	int mylen;
+    unsigned char* curdata = buf;
+    unsigned char* enddata = NULL;
+    int rc = 0;
+    int mylen;
 
-	curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen)); /* read remaining length */
-	enddata = curdata + mylen;
+    curdata += (rc = umqtt_pkgs_decodeBuf(curdata, &mylen)); /* read remaining length */
+    enddata = curdata + mylen;
 
-	if (enddata - curdata < 2)
+    if (enddata - curdata < 2)
     {
         rc = UMQTT_DECODE_ERROR;
-		goto exit;
+        goto exit;
     }
-	unsuback_msg->packet_id = umqtt_readInt(&curdata);
+    unsuback_msg->packet_id = umqtt_readInt(&curdata);
 
 exit:
-	return rc;
+    return rc;
 }
 
-/** 
+/**
  * parse the data according to the format
  *
  * @param recv_buf the input, the raw buffer data, of the correct length determined by the remaining length field
@@ -253,15 +253,15 @@ exit:
 int umqtt_decode(rt_uint8_t *recv_buf, size_t recv_buf_len, struct umqtt_msg *message)
 {
     int _ret = 0;
-	rt_uint8_t* curdata = recv_buf;
+    rt_uint8_t* curdata = recv_buf;
     enum umqtt_type type;
-    if (message == RT_NULL) 
+    if (message == RT_NULL)
     {
         _ret = UMQTT_INPARAMS_NULL;
         LOG_E(" umqtt decode inparams null!");
         goto exit;
     }
-    
+
     message->header.byte = umqtt_readChar(&curdata);
     type = message->header.bits.type;
 

src/pkgs/umqtt_pkgs_encode.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2020, RT-Thread Development Team
+ * Copyright (c) 2006-2022, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -23,19 +23,19 @@
 static int MQTTSerialize_connectLength(MQTTPacket_connectData* options)
 {
     int len = 0;
-    if (options->protocol_level == 3)                                   /* MQTT V3.1 */ 
+    if (options->protocol_level == 3)                                   /* MQTT V3.1 */
         len = 12;                                                       /* variable depending on MQTT or MQIsdp */
-    else if (options->protocol_level == 4)                              /* MQTT V3.1.1 */ 
+    else if (options->protocol_level == 4)                              /* MQTT V3.1.1 */
         len = 10;
-    
+
     len += MQTTStrlen(options->client_id) + 2;
-    if (options->connect_flags.bits.will_flag) 
+    if (options->connect_flags.bits.will_flag)
         len += MQTTStrlen(options->will_topic) + 2 + MQTTStrlen(options->will_message) + 2;
-    
-    if (options->connect_flags.bits.password_flag) 
+
+    if (options->connect_flags.bits.password_flag)
     {
         len += MQTTStrlen(options->password) + 2;
-        if (options->connect_flags.bits.username_flag) 
+        if (options->connect_flags.bits.username_flag)
             len += MQTTStrlen(options->user_name) + 2;
     }
     return len;
@@ -45,26 +45,26 @@ static int MQTTSerialize_subscribeLength(struct umqtt_pkgs_subscribe *params)
 {
     int _cnt = 0;
     int len = 2;
-    if (params && (params->topic_count > 0)) 
+    if (params && (params->topic_count > 0))
     {
-        for (_cnt = 0; _cnt < params->topic_count; _cnt++) 
+        for (_cnt = 0; _cnt < params->topic_count; _cnt++)
             len += 2 + MQTTStrlen(params->topic_filter[_cnt].topic_filter) + 1;
-    } 
-    else 
+    }
+    else
         len = 0;
     return len;
 }
 
 static int MQTTSerialize_unsubscribeLength(struct umqtt_pkgs_unsubscribe *params)
 {
-	int i;
-	int len = 2;                                                        /* packetid */
-    if (params && (params->topic_count > 0)) 
+    int i;
+    int len = 2;                                                        /* packetid */
+    if (params && (params->topic_count > 0))
     {
         for (i = 0; i < params->topic_count; ++i)
             len += 2 + MQTTStrlen(params->topic_filter[i].topic_filter);/* length + topic*/
-    } 
-    else 
+    }
+    else
         len = 0;
     return len;
 }
@@ -75,148 +75,148 @@ static int MQTTSerialize_publishLength(int qos, struct umqtt_pkgs_publish *param
     len += 2 + params->topic_name_len + params->payload_len;
     if (qos > 0)
         len += 2;
-    
+
     return len;
 }
 
 static int MQTTSerialize_connect(unsigned char* buf, int buflen, MQTTPacket_connectData* options)
 {
-	unsigned char *ptr = buf;
-	MQTTHeader header = { 0 };
-	int len = 0;
-	int rc = -1;
+    unsigned char *ptr = buf;
+    MQTTHeader header = { 0 };
+    int len = 0;
+    int rc = -1;
 
-	if (umqtt_pkgs_len(len = MQTTSerialize_connectLength(options)) > buflen) 
+    if (umqtt_pkgs_len(len = MQTTSerialize_connectLength(options)) > buflen)
     {
-		rc = UMQTT_BUFFER_TOO_SHORT;
-		goto exit;
-	}
+        rc = UMQTT_BUFFER_TOO_SHORT;
+        goto exit;
+    }
 
-	header.byte = 0;
-	header.bits.type = UMQTT_TYPE_CONNECT;
-	umqtt_writeChar(&ptr, header.byte);                                 /* write header */
+    header.byte = 0;
+    header.bits.type = UMQTT_TYPE_CONNECT;
+    umqtt_writeChar(&ptr, header.byte);                                 /* write header */
 
-	ptr += umqtt_pkgs_encode(ptr, len);                                 /* write remaining length */
+    ptr += umqtt_pkgs_encode(ptr, len);                                 /* write remaining length */
 
-	if (options->protocol_level == 4) 
+    if (options->protocol_level == 4)
     {
-		umqtt_writeCString(&ptr, "MQTT");
-		umqtt_writeChar(&ptr, (char) 4);
-	} 
-    else 
+        umqtt_writeCString(&ptr, "MQTT");
+        umqtt_writeChar(&ptr, (char) 4);
+    }
+    else
     {
-		umqtt_writeCString(&ptr, "MQIsdp");
-		umqtt_writeChar(&ptr, (char) 3);
-	}
-
-	umqtt_writeChar(&ptr, options->connect_flags.connect_sign);
-	umqtt_writeInt(&ptr, options->keepalive_interval_sec);
-	// umqtt_writeInt(&ptr, PKG_UMQTT_CONNECT_KEEPALIVE_DEF_TIME);                                       /* ping interval max, 0xffff */ 
-	umqtt_writeMQTTString(&ptr, options->client_id);
-	if (options->connect_flags.bits.will_flag) 
+        umqtt_writeCString(&ptr, "MQIsdp");
+        umqtt_writeChar(&ptr, (char) 3);
+    }
+
+    umqtt_writeChar(&ptr, options->connect_flags.connect_sign);
+    umqtt_writeInt(&ptr, options->keepalive_interval_sec);
+    // umqtt_writeInt(&ptr, PKG_UMQTT_CONNECT_KEEPALIVE_DEF_TIME);                                       /* ping interval max, 0xffff */
+    umqtt_writeMQTTString(&ptr, options->client_id);
+    if (options->connect_flags.bits.will_flag)
     {
-		umqtt_writeMQTTString(&ptr, options->will_topic);
-		umqtt_writeMQTTString(&ptr, options->will_message);
-	}
+        umqtt_writeMQTTString(&ptr, options->will_topic);
+        umqtt_writeMQTTString(&ptr, options->will_message);
+    }
 
-	if (options->connect_flags.bits.username_flag)
-		umqtt_writeMQTTString(&ptr, options->user_name);
-	if (options->connect_flags.bits.password_flag)
-		umqtt_writeMQTTString(&ptr, options->password);
+    if (options->connect_flags.bits.username_flag)
+        umqtt_writeMQTTString(&ptr, options->user_name);
+    if (options->connect_flags.bits.password_flag)
+        umqtt_writeMQTTString(&ptr, options->password);
 
-	rc = ptr - buf;
+    rc = ptr - buf;
 
 exit:
-	return rc;
+    return rc;
 }
 
 static int MQTTSerialize_zero(unsigned char* buf, int buflen, unsigned char packettype)
 {
-	MQTTHeader header = { 0 };
-	int rc = -1;
-	unsigned char *ptr = buf;
+    MQTTHeader header = { 0 };
+    int rc = -1;
+    unsigned char *ptr = buf;
 
-	if (buflen < 2) 
+    if (buflen < 2)
     {
-		rc = UMQTT_BUFFER_TOO_SHORT;
-		goto exit;
-	}
-	header.byte = 0;
-	header.bits.type = packettype;
-	umqtt_writeChar(&ptr, header.byte);                                 /* write header */
-
-	ptr += umqtt_pkgs_encode(ptr, 0);                                   /* write remaining length */
-	rc = ptr - buf;
+        rc = UMQTT_BUFFER_TOO_SHORT;
+        goto exit;
+    }
+    header.byte = 0;
+    header.bits.type = packettype;
+    umqtt_writeChar(&ptr, header.byte);                                 /* write header */
+
+    ptr += umqtt_pkgs_encode(ptr, 0);                                   /* write remaining length */
+    rc = ptr - buf;
 exit:
     return rc;
 }
 
 static int MQTTSerialize_subscribe(unsigned char* buf, int buflen, struct umqtt_pkgs_subscribe *params)
 {
-	unsigned char *ptr = buf;
-	MQTTHeader header = { 0 };
-	int rem_len = 0;
-	int rc = 0;
-	int i = 0;
+    unsigned char *ptr = buf;
+    MQTTHeader header = { 0 };
+    int rem_len = 0;
+    int rc = 0;
+    int i = 0;
 
-	if (umqtt_pkgs_len(rem_len = MQTTSerialize_subscribeLength(params)) > buflen) 
+    if (umqtt_pkgs_len(rem_len = MQTTSerialize_subscribeLength(params)) > buflen)
     {
-		rc = UMQTT_BUFFER_TOO_SHORT;
-		goto exit;
-	}
+        rc = UMQTT_BUFFER_TOO_SHORT;
+        goto exit;
+    }
 
-	header.byte = 0;
-	header.bits.type = UMQTT_TYPE_SUBSCRIBE;
-	header.bits.dup = 0;
-	header.bits.qos = 1;
-	umqtt_writeChar(&ptr, header.byte);                                 /* write header */
+    header.byte = 0;
+    header.bits.type = UMQTT_TYPE_SUBSCRIBE;
+    header.bits.dup = 0;
+    header.bits.qos = 1;
+    umqtt_writeChar(&ptr, header.byte);                                 /* write header */
 
-	ptr += umqtt_pkgs_encode(ptr, rem_len);                             /* write remaining length */;
+    ptr += umqtt_pkgs_encode(ptr, rem_len);                             /* write remaining length */;
 
-	umqtt_writeInt(&ptr, params->packet_id);
+    umqtt_writeInt(&ptr, params->packet_id);
 
-	for (i = 0; i < params->topic_count; ++i) 
+    for (i = 0; i < params->topic_count; ++i)
     {
-		umqtt_writeMQTTString(&ptr, params->topic_filter[i].topic_filter);
-		umqtt_writeChar(&ptr, params->topic_filter[i].req_qos.request_qos);
-	}
+        umqtt_writeMQTTString(&ptr, params->topic_filter[i].topic_filter);
+        umqtt_writeChar(&ptr, params->topic_filter[i].req_qos.request_qos);
+    }
 
-	rc = ptr - buf;
+    rc = ptr - buf;
 
 exit:
-	return rc;
+    return rc;
 }
 
 static int MQTTSerialize_unsubscribe(unsigned char* buf, int buflen, struct umqtt_pkgs_unsubscribe *params)
 {
-	unsigned char *ptr = buf;
-	MQTTHeader header = { 0 };
-	int rem_len = 0;
-	int rc = 0;
-	int i = 0;
+    unsigned char *ptr = buf;
+    MQTTHeader header = { 0 };
+    int rem_len = 0;
+    int rc = 0;
+    int i = 0;
 
-	if (umqtt_pkgs_len(rem_len = MQTTSerialize_unsubscribeLength(params)) > buflen) 
+    if (umqtt_pkgs_len(rem_len = MQTTSerialize_unsubscribeLength(params)) > buflen)
     {
-		rc = UMQTT_BUFFER_TOO_SHORT;
-		goto exit;
-	}
+        rc = UMQTT_BUFFER_TOO_SHORT;
+        goto exit;
+    }
 
-	header.byte = 0;
-	header.bits.type = UMQTT_TYPE_UNSUBSCRIBE;
-	header.bits.dup = 0;
-	header.bits.qos = 1;
-	umqtt_writeChar(&ptr, header.byte);                                 /* write header */
+    header.byte = 0;
+    header.bits.type = UMQTT_TYPE_UNSUBSCRIBE;
+    header.bits.dup = 0;
+    header.bits.qos = 1;
+    umqtt_writeChar(&ptr, header.byte);                                 /* write header */
 
-	ptr += umqtt_pkgs_encode(ptr, rem_len);                             /* write remaining length */;
+    ptr += umqtt_pkgs_encode(ptr, rem_len);                             /* write remaining length */;
 
-	umqtt_writeInt(&ptr, params->packet_id);
+    umqtt_writeInt(&ptr, params->packet_id);
 
-	for (i = 0; i < params->topic_count; ++i)
-		umqtt_writeCString(&ptr, params->topic_filter[i].topic_filter);
+    for (i = 0; i < params->topic_count; ++i)
+        umqtt_writeCString(&ptr, params->topic_filter[i].topic_filter);
 
-	rc = ptr - buf;
+    rc = ptr - buf;
 exit:
-	return rc;
+    return rc;
 }
 
 static int MQTTSerialize_publish(unsigned char* buf, int buflen, int dup, int qos, struct umqtt_pkgs_publish *message)
@@ -226,21 +226,21 @@ static int MQTTSerialize_publish(unsigned char* buf, int buflen, int dup, int qo
     int rem_len = 0;
     int rc = 0;
 
-    if (umqtt_pkgs_len(rem_len = MQTTSerialize_publishLength(qos, message)) > buflen) 
+    if (umqtt_pkgs_len(rem_len = MQTTSerialize_publishLength(qos, message)) > buflen)
     {
         rc = UMQTT_BUFFER_TOO_SHORT;
         goto exit;
     }
-    
+
     header.bits.type = UMQTT_TYPE_PUBLISH;
     header.bits.dup = dup;
     header.bits.qos = qos;
     umqtt_writeChar(&ptr, header.byte);
     ptr += umqtt_pkgs_encode(ptr, rem_len);
 
-	umqtt_writeCString(&ptr, message->topic_name);
+    umqtt_writeCString(&ptr, message->topic_name);
 
-    if (qos > 0) 
+    if (qos > 0)
         umqtt_writeInt(&ptr, message->packet_id);
 
     memcpy(ptr, message->payload, message->payload_len);
@@ -257,7 +257,7 @@ static int MQTTSerialize_ack(unsigned char *buf, int buflen, unsigned char packe
     int rc = 0;
     unsigned char *ptr = buf;
 
-    if (buflen < 4) 
+    if (buflen < 4)
     {
         rc = UMQTT_BUFFER_TOO_SHORT;
         goto exit;
@@ -274,7 +274,7 @@ exit:
     return rc;
 }
 
-/** 
+/**
  * packaging the connect data
  *
  * @param buf the output send buf, result of the package
@@ -284,12 +284,12 @@ exit:
  * @return <=0: failed or other error
  *         >0: package data length
  */
-static int umqtt_connect_encode(rt_uint8_t *send_buf, size_t send_len, struct umqtt_pkgs_connect *params) 
+static int umqtt_connect_encode(rt_uint8_t *send_buf, size_t send_len, struct umqtt_pkgs_connect *params)
 {
     return MQTTSerialize_connect(send_buf, send_len, params);
 }
 
-/** 
+/**
  * packaging the disconnect data
  *
  * @param buf the output send buf, result of the package
@@ -303,7 +303,7 @@ static int umqtt_disconnect_encode(rt_uint8_t *send_buf, size_t send_len)
     return MQTTSerialize_zero(send_buf, send_len, UMQTT_TYPE_DISCONNECT);
 }
 
-/** 
+/**
  * packaging the pingreq data
  *
  * @param buf the output send buf, result of the package
@@ -317,7 +317,7 @@ static int umqtt_pingreq_encode(rt_uint8_t *send_buf, size_t send_len)
     return MQTTSerialize_zero(send_buf, send_len, UMQTT_TYPE_PINGREQ);
 }
 
-/** 
+/**
  * packaging the puback data
  *
  * @param buf the output send buf, result of the package
@@ -332,7 +332,7 @@ static int umqtt_publish_encode(unsigned char *buf, int buflen, int dup, int qos
     return MQTTSerialize_publish(buf, buflen, dup, qos, message);
 }
 
-/** 
+/**
  * packaging the puback data
  *
  * @param buf the output send buf, result of the package
@@ -348,7 +348,7 @@ static int umqtt_puback_encode(unsigned char *buf, int buflen, unsigned short pa
 }
 // static int umqtt_pubrec_encode();
 
-/** 
+/**
  * packaging the pubcomp data
  *
  * @param buf the output send buf, result of the package
@@ -364,7 +364,7 @@ static int umqtt_pubrel_encode(unsigned char *buf, int buflen, unsigned char dup
     return MQTTSerialize_ack(buf, buflen, UMQTT_TYPE_PUBREL, dup, packetid);
 }
 
-/** 
+/**
  * packaging the pubcomp data
  *
  * @param buf the output send buf, result of the package
@@ -379,7 +379,7 @@ static int umqtt_pubcomp_encode(unsigned char *buf, int buflen, unsigned short p
     return MQTTSerialize_ack(buf, buflen, UMQTT_TYPE_PUBCOMP, 0, packetid);
 }
 
-/** 
+/**
  * packaging the subscribe data
  *
  * @param send_buf the output send buf, result of the package
@@ -394,7 +394,7 @@ static int umqtt_subscribe_encode(rt_uint8_t *send_buf, size_t send_len, struct
     return MQTTSerialize_subscribe(send_buf, send_len, params);
 }
 
-/** 
+/**
  * packaging the unsubscribe data
  *
  * @param send_buf the output send buf, result of the package
@@ -409,7 +409,7 @@ static int umqtt_unsubscribe_encode(rt_uint8_t *send_buf, size_t send_len, struc
     return MQTTSerialize_unsubscribe(send_buf, send_len, params);
 }
 
-/** 
+/**
  * packaging the data according to the format
  *
  * @param type the input packaging type

src/trans/umqtt_transport.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2020, RT-Thread Development Team
+ * Copyright (c) 2006-2022, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -66,23 +66,23 @@ static int umqtt_resolve_uri(const char *umqtt_uri, struct addrinfo **res)
     uri_len = strlen(uri);
 
     /* strip protocol(tcp or ssl) */
-    if (strncmp(uri, "tcp://", 6) == 0) 
+    if (strncmp(uri, "tcp://", 6) == 0)
     {
         host_addr = uri + 6;
-    } 
-    else if (strncmp(uri, "ssl://", 6) == 0) 
+    }
+    else if (strncmp(uri, "ssl://", 6) == 0)
     {
         host_addr = uri + 6;
     // } else if (strncmp(uri, "ws://", 5) == 0) {
-    } 
-    else 
+    }
+    else
     {
         rc = UMQTT_INPARAMS_NULL;
         goto exit;
     }
 
     if (host_addr[0] == '[')    /* ipv6 address */
-    {  
+    {
         host_addr += 1;
         ptr = strstr(host_addr, "]");
         if (!ptr) {
@@ -104,23 +104,23 @@ static int umqtt_resolve_uri(const char *umqtt_uri, struct addrinfo **res)
         strncpy(port_str, host_addr + host_addr_len + 2, port_len);
         port_str[port_len] = '\0';
         // LOG_D("ipv6 address port: %s", port_str);
-    } 
+    }
     else    /* ipv4 or domain. */
-    {                    
+    {
         ptr = strstr(host_addr, ":");
-        if (!ptr) 
+        if (!ptr)
         {
             rc = UMQTT_INPARAMS_NULL;
             goto exit;
         }
         host_addr_len = ptr - host_addr;
-        if ((host_addr_len < 1) || (host_addr_len > uri_len)) 
+        if ((host_addr_len < 1) || (host_addr_len > uri_len))
         {
             rc = UMQTT_INPARAMS_NULL;
             goto exit;
         }
         port_len = uri_len - 6 - host_addr_len - 1;
-        if ((port_len >= 6) || (port_len < 1)) 
+        if ((port_len >= 6) || (port_len < 1))
         {
             rc = UMQTT_INPARAMS_NULL;
             goto exit;
@@ -136,19 +136,19 @@ static int umqtt_resolve_uri(const char *umqtt_uri, struct addrinfo **res)
         /* resolve the host name. */
         host_addr_new = rt_malloc(host_addr_len + 1);
 
-        if (!host_addr_new) 
+        if (!host_addr_new)
         {
             rc = UMQTT_MEM_FULL;
             goto exit;
         }
 
-        memcpy(host_addr_new, host_addr, host_addr_len);
+        rt_memcpy(host_addr_new, host_addr, host_addr_len);
         host_addr_new[host_addr_len] = '\0';
 
-        memset(&hint, 0, sizeof(hint));
+        rt_memset(&hint, 0, sizeof(hint));
 
         ret = getaddrinfo(host_addr_new, port_str, &hint, res);
-        if (ret != 0) 
+        if (ret != 0)
         {
             LOG_E("getaddrinfo err: %d '%s'", ret, host_addr_new);
             rc = UMQTT_FAILED;
@@ -157,7 +157,7 @@ static int umqtt_resolve_uri(const char *umqtt_uri, struct addrinfo **res)
     }
 
 exit:
-    if (host_addr_new != RT_NULL) 
+    if (host_addr_new != RT_NULL)
     {
         rt_free(host_addr_new);
         host_addr_new = RT_NULL;
@@ -165,7 +165,7 @@ exit:
     return rc;
 }
 
-/** 
+/**
  * TCP/TLS Connection Complete for configured transport
  *
  * @param uri the input server URI address
@@ -178,17 +178,17 @@ int umqtt_trans_connect(const char *uri, int *sock)
 {
     int _ret = 0;
     struct addrinfo *addr_res = RT_NULL;
-    
+
     *sock = -1;
     _ret = umqtt_resolve_uri(uri, &addr_res);
-    if ((_ret < 0) || (addr_res == RT_NULL)) 
+    if ((_ret < 0) || (addr_res == RT_NULL))
     {
         LOG_E("resolve uri err");
         _ret = UMQTT_FAILED;
         goto exit;
     }
 
-    if ((*sock = socket(addr_res->ai_family, SOCK_STREAM, UMQTT_SOCKET_PROTOCOL)) < 0) 
+    if ((*sock = socket(addr_res->ai_family, SOCK_STREAM, UMQTT_SOCKET_PROTOCOL)) < 0)
     {
         LOG_E("create socket error!");
         _ret = UMQTT_FAILED;
@@ -196,14 +196,14 @@ int umqtt_trans_connect(const char *uri, int *sock)
     }
 
     _ret = ioctlsocket(*sock, FIONBIO, 0);
-    if (_ret < 0) 
+    if (_ret < 0)
     {
         LOG_E(" iocontrol socket error!");
         _ret = UMQTT_FAILED;
         goto exit;
     }
 
-    if ((_ret = connect(*sock, addr_res->ai_addr, addr_res->ai_addrlen)) < 0) 
+    if ((_ret = connect(*sock, addr_res->ai_addr, addr_res->ai_addrlen)) < 0)
     {
         LOG_E(" connect err!");
         closesocket(*sock);
@@ -220,7 +220,7 @@ exit:
     return _ret;
 }
 
-/** 
+/**
  * TCP/TLS transport disconnection requests on configured transport.
  *
  * @param sock the input socket
@@ -232,12 +232,12 @@ int umqtt_trans_disconnect(int sock)
 {
     int _ret = 0;
     _ret = closesocket(sock);
-    if (_ret < 0) 
+    if (_ret < 0)
         return -errno;
     return _ret;
 }
 
-/** 
+/**
  * TCP/TLS send datas on configured transport.
  *
  * @param sock the input socket
@@ -252,10 +252,10 @@ int umqtt_trans_send(int sock, const rt_uint8_t *send_buf, rt_uint32_t buf_len,
 {
     int _ret = 0;
     rt_uint32_t offset = 0U;
-    while (offset < buf_len) 
+    while (offset < buf_len)
     {
         _ret = send(sock, send_buf + offset, buf_len - offset, 0);
-        if (_ret < 0) 
+        if (_ret < 0)
             return -errno;
         offset += _ret;
     }
@@ -263,7 +263,7 @@ int umqtt_trans_send(int sock, const rt_uint8_t *send_buf, rt_uint32_t buf_len,
     return _ret;
 }
 
-/** 
+/**
  * TCP/TLS receive datas on configured transport.
  *
  * @param sock the input socket