update check

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "files.associations": {
+        "ryanmqttpublic.h": "c",
+        "mqttpacket.h": "c"
+    }
+}

common/RyanList.c

@@ -2,6 +2,9 @@
 
 #include "RyanList.h"
 
+// 此库为公共库，别的包也有使用
+#define __weak __attribute__((weak)) // 防止函数重定义, gcc / ARM编译器有效  IAR可以注释此行
+
 /**
  * @brief 在prev和next之前插入节点
  *
@@ -44,7 +47,7 @@ static void _RyanListDel_entry(RyanList_t *entry)
  *
  * @param list
  */
-void RyanMqttListInit(RyanList_t *list)
+__weak void RyanListInit(RyanList_t *list)
 {
     list->next = list;
     list->prev = list;
@@ -56,7 +59,7 @@ void RyanMqttListInit(RyanList_t *list)
  * @param node
  * @param list
  */
-void RyanListAdd(RyanList_t *node, RyanList_t *list)
+__weak void RyanListAdd(RyanList_t *node, RyanList_t *list)
 {
     _RyanListAdd(node, list, list->next);
 }
@@ -67,7 +70,7 @@ void RyanListAdd(RyanList_t *node, RyanList_t *list)
  * @param node
  * @param list
  */
-void RyanListAddTail(RyanList_t *node, RyanList_t *list)
+__weak void RyanListAddTail(RyanList_t *node, RyanList_t *list)
 {
     _RyanListAdd(node, list->prev, list);
 }
@@ -77,7 +80,7 @@ void RyanListAddTail(RyanList_t *node, RyanList_t *list)
  *
  * @param entry
  */
-void RyanListDel(RyanList_t *entry)
+__weak void RyanListDel(RyanList_t *entry)
 {
     _RyanListDel_entry(entry);
 }
@@ -87,10 +90,10 @@ void RyanListDel(RyanList_t *entry)
  *
  * @param entry
  */
-void RyanListDelInit(RyanList_t *entry)
+__weak void RyanListDelInit(RyanList_t *entry)
 {
     _RyanListDel_entry(entry);
-    RyanMqttListInit(entry);
+    RyanListInit(entry);
 }
 
 /**
@@ -99,7 +102,7 @@ void RyanListDelInit(RyanList_t *entry)
  * @param node
  * @param list
  */
-void RyanListMove(RyanList_t *node, RyanList_t *list)
+__weak void RyanListMove(RyanList_t *node, RyanList_t *list)
 {
     _RyanListDel_entry(node);
     RyanListAdd(node, list);
@@ -111,7 +114,7 @@ void RyanListMove(RyanList_t *node, RyanList_t *list)
  * @param node
  * @param list
  */
-void RyanListMoveTail(RyanList_t *node, RyanList_t *list)
+__weak void RyanListMoveTail(RyanList_t *node, RyanList_t *list)
 {
     _RyanListDel_entry(node);
     RyanListAddTail(node, list);
@@ -123,7 +126,7 @@ void RyanListMoveTail(RyanList_t *node, RyanList_t *list)
  * @param list
  * @return int
  */
-int RyanListIsEmpty(RyanList_t *list)
+__weak int RyanListIsEmpty(RyanList_t *list)
 {
     return list->next == list;
 }

common/RyanList.h

@@ -55,7 +55,7 @@ extern "C"
 
     /* extern variables-----------------------------------------------------------*/
 
-    extern void RyanMqttListInit(RyanList_t *list);
+    extern void RyanListInit(RyanList_t *list);
 
     extern void RyanListAdd(RyanList_t *node, RyanList_t *list);
     extern void RyanListAddTail(RyanList_t *node, RyanList_t *list);

common/RyanMqttLog.h

@@ -13,31 +13,6 @@ extern "C"
 
 #ifdef RT_USING_ULOG
 #include "ulog.h"
-#else
-#define ulog_d(TAG, ...)            \
-    {                               \
-        printf("%s", TAG);          \
-        printf(fmt, ##__VA_ARGS__); \
-        printf("\r\n");             \
-    }
-#define ulog_i(TAG, ...)            \
-    {                               \
-        printf("%s", TAG);          \
-        printf(fmt, ##__VA_ARGS__); \
-        printf("\r\n");             \
-    }
-#define ulog_w(TAG, ...)            \
-    {                               \
-        printf("%s", TAG);          \
-        printf(fmt, ##__VA_ARGS__); \
-        printf("\r\n");             \
-    }
-#define ulog_e(TAG, ...)            \
-    {                               \
-        printf("%s", TAG);          \
-        printf(fmt, ##__VA_ARGS__); \
-        printf("\r\n");             \
-    }
 #endif
 
     // 定义枚举类型

example/RyanMqtt.c

@@ -65,7 +65,6 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
 
     case RyanMqttEventConnected: // 不管有没有使能clearSession，都非常推荐在连接成功回调函数中订阅主题
         ulog_i(TAG, "mqtt连接成功回调");
-        RyanMqttSubscribe(client, "sub/#", QOS0);
         break;
 
     case RyanMqttEventDisconnected:

mqttclient/RyanMqttClient.c

@@ -53,19 +53,19 @@ RyanMqttError_e RyanMqttInit(RyanMqttClient_t **pClient)
 
     // 网络接口初始化
     client->network = (platformNetwork_t *)platformMemoryMalloc(sizeof(platformNetwork_t));
-    RyanMqttCheckCode(NULL != client->network, RyanMqttNotEnoughMemError, RyanMqttDestroy(client));
+    RyanMqttCheckCode(NULL != client->network, RyanMqttNotEnoughMemError, { RyanMqttDestroy(client); });
     memset(client->network, 0, sizeof(platformNetwork_t));
 
     client->config = (RyanMqttClientConfig_t *)platformMemoryMalloc(sizeof(RyanMqttClientConfig_t));
-    RyanMqttCheckCode(NULL != client->config, RyanMqttNotEnoughMemError, RyanMqttDestroy(client));
+    RyanMqttCheckCode(NULL != client->config, RyanMqttNotEnoughMemError, { RyanMqttDestroy(client); });
     memset(client->config, 0, sizeof(RyanMqttClientConfig_t));
 
     client->mqttThread = platformMemoryMalloc(sizeof(platformThread_t));
-    RyanMqttCheckCode(NULL != client->mqttThread, RyanMqttNotEnoughMemError, RyanMqttDestroy(client));
+    RyanMqttCheckCode(NULL != client->mqttThread, RyanMqttNotEnoughMemError, { RyanMqttDestroy(client); });
     memset(client->mqttThread, 0, sizeof(platformThread_t));
 
     client->sendBufLock = platformMemoryMalloc(sizeof(platformMutex_t));
-    RyanMqttCheckCode(NULL != client->sendBufLock, RyanMqttNotEnoughMemError, RyanMqttDestroy(client));
+    RyanMqttCheckCode(NULL != client->sendBufLock, RyanMqttNotEnoughMemError, { RyanMqttDestroy(client); });
     memset(client->sendBufLock, 0, sizeof(platformMutex_t));
 
     client->packetId = 1; // 控制报文必须包含一个非零的 16 位报文标识符
@@ -78,8 +78,8 @@ RyanMqttError_e RyanMqttInit(RyanMqttClient_t **pClient)
 
     platformMutexInit(client->config->userData, client->sendBufLock); // 初始化发送缓冲区互斥锁
 
-    RyanMqttListInit(&client->msgHandlerList);
-    RyanMqttListInit(&client->ackHandlerList);
+    RyanListInit(&client->msgHandlerList);
+    RyanListInit(&client->ackHandlerList);
     platformTimerInit(&client->keepaliveTimer);
 
     RyanMqttSetClientState(client, mqttInitState);
@@ -186,7 +186,6 @@ RyanMqttError_e RyanMqttStart(RyanMqttClient_t *client)
     RyanMqttCheck(NULL != client, RyanMqttParamInvalidError);
     RyanMqttCheck(mqttInitState == client->clientState, RyanMqttFailedError);
 
-    RyanMqttSetClientState(client, mqttStartState);
     // 连接成功，需要初始化 MQTT 线程
     result = platformThreadInit(client->config->userData,
                                 client->mqttThread,
@@ -195,9 +194,9 @@ RyanMqttError_e RyanMqttStart(RyanMqttClient_t *client)
                                 client,
                                 client->config->taskStack,
                                 client->config->taskPrio);
-    RyanMqttCheckCode(NULL == result, RyanMqttNotEnoughMemError,
-                      RyanMqttSetClientState(client, mqttInitState));
+    RyanMqttCheckCode(NULL == result, RyanMqttNotEnoughMemError, { RyanMqttSetClientState(client, mqttInitState); });
 
+    RyanMqttSetClientState(client, mqttStartState);
     return RyanMqttSuccessError;
 }
 
@@ -279,17 +278,16 @@ RyanMqttError_e RyanMqttSubscribe(RyanMqttClient_t *client, char *topic, RyanMqt
     packetId = RyanMqttGetNextPacketId(client);
 
     packetLen = MQTTSerialize_subscribe(client->config->sendBuffer, client->config->sendBufferSize, 0, packetId, 1, &topicName, &qos);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError,
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttMsgHandlerCreate(topic, strlen(topic), qos, &msgHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttAckHandlerCreate(client, SUBACK, packetId, packetLen, msgHandler, &ackHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                      platformMemoryFree(msgHandler);
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, {
+        platformMemoryFree(msgHandler);
+        platformMutexUnLock(client->config->userData, client->sendBufLock);
+    });
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
     // 确定节点是否已存在,存在就删除
@@ -300,8 +298,7 @@ RyanMqttError_e RyanMqttSubscribe(RyanMqttClient_t *client, char *topic, RyanMqt
     result = RyanMqttAckListAdd(client, ackHandler);
 
     result = RyanMqttSendPacket(client, ackHandler->packet, ackHandler->packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, RyanMqttAckHandlerDestroy(client, ackHandler));
-
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { RyanMqttAckHandlerDestroy(client, ackHandler); });
     return result;
 }
 
@@ -335,11 +332,11 @@ RyanMqttError_e RyanMqttUnSubscribe(RyanMqttClient_t *client, char *topic)
 
     packetLen = MQTTSerialize_unsubscribe(client->config->sendBuffer, client->config->sendBufferSize, 0, packetId, 1, &topicName);
     RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError,
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+                      { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttAckHandlerCreate(client, UNSUBACK, packetId, packetLen, msgHandler, &ackHandler);
     RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+                      { platformMutexUnLock(client->config->userData, client->sendBufLock); });
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
     // 确定节点是否已存在,存在就删除
@@ -350,7 +347,7 @@ RyanMqttError_e RyanMqttUnSubscribe(RyanMqttClient_t *client, char *topic)
     result = RyanMqttAckListAdd(client, ackHandler);
 
     result = RyanMqttSendPacket(client, ackHandler->packet, ackHandler->packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, RyanMqttAckHandlerDestroy(client, ackHandler));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { RyanMqttAckHandlerDestroy(client, ackHandler); });
 
     return result;
 }
@@ -392,7 +389,7 @@ RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *pay
         packetLen = MQTTSerialize_publish(client->config->sendBuffer, client->config->sendBufferSize, 0, qos, retain, packetId,
                                           topicName, payload, payloadLen);
         RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError,
-                          platformMutexUnLock(client->config->userData, client->sendBufLock));
+                          { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
         platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
@@ -406,16 +403,17 @@ RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *pay
     packetLen = MQTTSerialize_publish(client->config->sendBuffer, client->config->sendBufferSize, 0, qos, retain, packetId,
                                       topicName, payload, payloadLen);
     RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError,
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+                      { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttMsgHandlerCreate(topic, strlen(topic), qos, &msgHandler);
     RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+                      { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttAckHandlerCreate(client, (QOS1 == qos) ? PUBACK : PUBREC, packetId, packetLen, msgHandler, &ackHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                      platformMemoryFree(msgHandler);
-                      platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, {
+        platformMemoryFree(msgHandler);
+        platformMutexUnLock(client->config->userData, client->sendBufLock);
+    });
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
     // 确定节点是否已存在,存在就删除,理论上不会存在
@@ -426,8 +424,7 @@ RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *pay
     result = RyanMqttAckListAdd(client, ackHandler);
 
     result = RyanMqttSendPacket(client, ackHandler->packet, ackHandler->packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                      RyanMqttAckHandlerDestroy(client, ackHandler));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { RyanMqttAckHandlerDestroy(client, ackHandler); });
 
     // 提前设置重发标志位
     RyanMqttSetPublishDup(&ackHandler->packet[0], 1);
@@ -567,25 +564,25 @@ RyanMqttError_e RyanMqttSetConfig(RyanMqttClient_t *client, RyanMqttClientConfig
     RyanMqttCheck(2 < clientConfig->recvBufferSize && (RyanMqttMaxPayloadLen + 5) >= clientConfig->recvBufferSize, RyanMqttParamInvalidError);
     RyanMqttCheck(2 < clientConfig->sendBufferSize && (RyanMqttMaxPayloadLen + 5) >= clientConfig->sendBufferSize, RyanMqttParamInvalidError);
 
-    RyanMqttCheckCode(NULL != client->config, RyanMqttParamInvalidError, goto exit);
+    RyanMqttCheckCode(NULL != client->config, RyanMqttParamInvalidError, { goto exit; });
 
     result = setConfigValue(&client->config->clientId, clientConfig->clientId);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, goto exit);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { goto exit; });
 
     result = setConfigValue(&client->config->userName, clientConfig->userName);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, goto exit);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { goto exit; });
 
     result = setConfigValue(&client->config->password, clientConfig->password);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, goto exit);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { goto exit; });
 
     result = setConfigValue(&client->config->host, clientConfig->host);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, goto exit);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { goto exit; });
 
     result = setConfigValue(&client->config->port, clientConfig->port);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, goto exit);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { goto exit; });
 
     result = setConfigValue(&client->config->taskName, clientConfig->taskName);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, goto exit);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { goto exit; });
 
     client->config->taskPrio = clientConfig->taskPrio;
     client->config->taskStack = clientConfig->taskStack;
@@ -612,13 +609,13 @@ RyanMqttError_e RyanMqttSetConfig(RyanMqttClient_t *client, RyanMqttClientConfig
     if (RyanTrue != client->config->recvBufferStaticFlag)
     {
         client->config->recvBuffer = (char *)platformMemoryMalloc(client->config->recvBufferSize);
-        RyanMqttCheckCode(NULL != client->config->recvBuffer, RyanMqttFailedError, goto exit);
+        RyanMqttCheckCode(NULL != client->config->recvBuffer, RyanMqttFailedError, { goto exit; });
     }
 
     if (RyanTrue != client->config->sendBufferStaticFlag)
     {
         client->config->sendBuffer = (char *)platformMemoryMalloc(client->config->sendBufferSize);
-        RyanMqttCheckCode(NULL != client->config->sendBuffer, RyanMqttFailedError, goto exit);
+        RyanMqttCheckCode(NULL != client->config->sendBuffer, RyanMqttFailedError, { goto exit; });
     }
     return RyanMqttSuccessError;
 
@@ -664,8 +661,7 @@ RyanMqttError_e RyanMqttSetLwt(RyanMqttClient_t *client, char *topicName, char *
     memcpy(client->lwtOptions->payload, payload, payloadLen);
 
     result = RyanMqttStringCopy(&client->lwtOptions->topic, topicName, strlen(topicName));
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                      platformMemoryFree(client->lwtOptions));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { platformMemoryFree(client->lwtOptions); });
 
     return RyanMqttSuccessError;
 }

mqttclient/RyanMqttPublic.h

@@ -13,19 +13,24 @@ extern "C"
 #include <string.h>
 #include <errno.h>
 
+#define DBG_ENABLE
+#define DBG_SECTION_NAME RyanMqttTag
+#define DBG_LEVEL LOG_LVL_WARNING
+#define DBG_COLOR
+
 #define RyanMqttMaxPacketId (0xFFFFU - 1U)  // 你允许的mqtt paketid最大值，协议标准为个非零的 16 位数
 #define RyanMqttMaxPayloadLen (268435455UL) // 你允许的mqtt可变报头和有效载荷最长长度。默认值为协议标准
 #define RyanMqttVersion ("0.0.1")
 
-#define RyanMqttCheck(EX, ErrorCode) RyanMqttCheckCode(EX, ErrorCode, NULL)
+#define RyanMqttCheck(EX, ErrorCode) RyanMqttCheckCode(EX, ErrorCode, { NULL; })
 
-#define RyanMqttCheckCode(EX, ErrorCode, code)                          \
-    if (!(EX))                                                          \
-    {                                                                   \
-        code;                                                           \
-        ulog_d(RyanMqttTag, "%s:%d ErrorCode: %d, strError: %s",        \
-               __FILE__, __LINE__, ErrorCode, RyanStrError(ErrorCode)); \
-        return ErrorCode;                                               \
+#define RyanMqttCheckCode(EX, ErrorCode, code)                         \
+    if (!(EX))                                                         \
+    {                                                                  \
+        {code};                                                        \
+        LOG_D("%s:%d ErrorCode: %d, strError: %s",                     \
+              __FILE__, __LINE__, ErrorCode, RyanStrError(ErrorCode)); \
+        return ErrorCode;                                              \
     }
 
     // 定义枚举类型

mqttclient/RyanMqttThread.c

@@ -1,3 +1,9 @@
+#define DBG_ENABLE
+
+#define DBG_SECTION_NAME RyanMqttTag
+#define DBG_LEVEL LOG_LVL_WARNING
+#define DBG_COLOR
+
 #include "RyanMqttPublic.h"
 #include "RyanMqttUtile.h"
 #include "RyanMqttThread.h"
@@ -25,7 +31,7 @@ RyanMqttError_e RyanMqttKeepalive(RyanMqttClient_t *client)
     // 心跳超时，断开连接
     connectState = RyanMqttKeepaliveTimeout;
     RyanMqttCheckCode(2 > client->keepaliveTimeoutCount, RyanMqttKeepaliveTimeout,
-                      RyanMqttEventMachine(client, RyanMqttEventDisconnected, (void *)&connectState));
+                      { RyanMqttEventMachine(client, RyanMqttEventDisconnected, (void *)&connectState); });
 
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     packetLen = MQTTSerialize_pingreq(client->config->sendBuffer, client->config->sendBufferSize);
@@ -91,7 +97,7 @@ static RyanMqttError_e RyanMqttPubackAndPubcompPacketHandler(RyanMqttClient_t *c
 
     // 可能会多次收到puback / pubcomp,仅在首次收到时触发发布成功回调函数
     result = RyanMqttAckListNodeFind(client, packetType, packetId, &ackHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_i(RyanMqttTag, "packetType: %d, packetId: %d", packetType, packetId));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { LOG_I("packetType: %d, packetId: %d", packetType, packetId); });
 
     RyanMqttEventMachine(client, RyanMqttEventPublished, (void *)ackHandler); // 回调函数
 
@@ -121,11 +127,11 @@ static RyanMqttError_e RyanMqttPubrelPacketHandler(RyanMqttClient_t *client)
     // 制作确认数据包并发送
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     packetLen = MQTTSerialize_ack(client->config->sendBuffer, client->config->sendBufferSize, PUBCOMP, 0, packetId);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 每次收到PUBREL都返回消息
     result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
     // 删除pubrel记录
@@ -174,11 +180,11 @@ static RyanMqttError_e RyanMqttPubrecPacketHandler(RyanMqttClient_t *client)
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     // 序列化发布释放报文
     packetLen = MQTTSerialize_ack(client->config->sendBuffer, client->config->sendBufferSize, PUBREL, 0, packetId);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 每次收到PUBREC都返回ack
     result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 只在首次收到pubrec, 并pubcomp不存在于ack链表时，才创建pubcmp到ack链表,再删除pubrec记录
     if (RyanTrue == fastFlag)
@@ -187,13 +193,14 @@ static RyanMqttError_e RyanMqttPubrecPacketHandler(RyanMqttClient_t *client)
                                           strlen(ackHandlerPubrec->msgHandler->topic),
                                           ackHandlerPubrec->msgHandler->qos, &msgHandler);
         RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                          platformMutexUnLock(client->config->userData, client->sendBufLock));
+                          { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         // 创建一个 ACK 处理程序节点
         result = RyanMqttAckHandlerCreate(client, PUBCOMP, packetId, packetLen, msgHandler, &ackHandler);
-        RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                          platformMemoryFree(msgHandler);
-                          platformMutexUnLock(client->config->userData, client->sendBufLock));
+        RyanMqttCheckCode(
+            RyanMqttSuccessError == result, result,
+            { platformMemoryFree(msgHandler);
+             platformMutexUnLock(client->config->userData, client->sendBufLock); });
     }
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
@@ -243,11 +250,11 @@ static RyanMqttError_e RyanMqttPublishPacketHandler(RyanMqttClient_t *client)
         platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
         packetLen = MQTTSerialize_ack(client->config->sendBuffer, client->config->sendBufferSize, PUBACK, 0, msgData.packetId);
         RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError,
-                          platformMutexUnLock(client->config->userData, client->sendBufLock));
+                          { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
         RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                          platformMutexUnLock(client->config->userData, client->sendBufLock));
+                          { platformMutexUnLock(client->config->userData, client->sendBufLock); });
         platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
         deliverMsgFlag = RyanTrue;
@@ -265,22 +272,24 @@ static RyanMqttError_e RyanMqttPublishPacketHandler(RyanMqttClient_t *client)
         platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
         packetLen = MQTTSerialize_ack(client->config->sendBuffer, client->config->sendBufferSize, PUBREC, 0, msgData.packetId);
         RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError,
-                          platformMutexUnLock(client->config->userData, client->sendBufLock));
+                          { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
         RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                          platformMutexUnLock(client->config->userData, client->sendBufLock));
+                          { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         if (RyanTrue == fastFlag)
         {
             result = RyanMqttMsgHandlerCreate(topicName.lenstring.data, topicName.lenstring.len, msgData.qos, &msgHandler);
-            RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                              platformMutexUnLock(client->config->userData, client->sendBufLock));
+            RyanMqttCheckCode(RyanMqttSuccessError == result, result, {
+                platformMutexUnLock(client->config->userData, client->sendBufLock);
+            });
 
             result = RyanMqttAckHandlerCreate(client, PUBREL, msgData.packetId, packetLen, msgHandler, &ackHandler);
-            RyanMqttCheckCode(RyanMqttSuccessError == result, result,
-                              platformMemoryFree(msgHandler);
-                              platformMutexUnLock(client->config->userData, client->sendBufLock));
+            RyanMqttCheckCode(RyanMqttSuccessError == result, result, {
+                platformMemoryFree(msgHandler);
+                platformMutexUnLock(client->config->userData, client->sendBufLock);
+            });
         }
         platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
@@ -412,7 +421,7 @@ RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *pac
 
     // 填充联合体标头信息
     header.byte = client->config->recvBuffer[0];
-    // ulog_i(RyanMqttTag, "packetType: %d", header.bits.type);
+    LOG_I("packetType: %d", header.bits.type);
     RyanMqttCheck(CONNECT <= header.bits.type && DISCONNECT >= header.bits.type, result);
 
     // 2.读取mqtt报文剩余长度。 这本身是可变的
@@ -422,7 +431,7 @@ RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *pac
     // 将剩余长度编码成mqtt报文，并放入接收缓冲区,如果消息长度超过缓冲区长度则抛弃此次数据
     fixedHeaderLen += MQTTPacket_encode(client->config->recvBuffer + fixedHeaderLen, payloadLen);
     RyanMqttCheckCode((fixedHeaderLen + payloadLen) <= client->config->recvBufferSize, RyanMqttRecvBufToShortError,
-                      RyanMqttRecvPacket(client, client->config->recvBuffer, payloadLen));
+                      { RyanMqttRecvPacket(client, client->config->recvBuffer, payloadLen); });
 
     // 3.读取mqtt载荷数据并放到读取缓冲区
     if (payloadLen > 0)
@@ -596,24 +605,24 @@ RyanMqttError_e RyanMqttConnect(RyanMqttClient_t *client)
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     // 序列化mqtt的CONNECT报文
     packetLen = MQTTSerialize_connect(client->config->sendBuffer, client->config->sendBufferSize, &connectData);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 发送序列化mqtt的CONNECT报文
     result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 等待报文
     // mqtt规范 服务端接收到connect报文后，服务端发送给客户端的第一个报文必须是 CONNACK
     result = RyanMqttReadPacketHandler(client, &packetType);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, platformMutexUnLock(client->config->userData, client->sendBufLock));
-    RyanMqttCheckCode(CONNACK == packetType, RyanMqttConnectDisconnected, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(CONNACK == packetType, RyanMqttConnectDisconnected, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 解析CONNACK报文
     result = MQTTDeserialize_connack(&sessionPresent, &connackRc, client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheckCode(1 == result, RyanMqttDeserializePacketError, platformMutexUnLock(client->config->userData, client->sendBufLock));
+    RyanMqttCheckCode(1 == result, RyanMqttDeserializePacketError, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
-    // ulog_w(TAG, "result: %d, packetLen: %d, packetType: %d connackRc: %d", result, packetLen, packetType, connackRc);
+    LOG_I("result: %d, packetLen: %d, packetType: %d connackRc: %d", result, packetLen, packetType, connackRc);
 
     return connackRc;
 }
@@ -649,9 +658,10 @@ void RyanMqttEventMachine(RyanMqttClient_t *client, RyanMqttEventId_e eventId, v
         RyanMqttSetClientState(client, mqttDisconnectState); // 将客户端状态设置为断开连接
         break;
 
-    case RyanMqttEventReconnectBefore: // 接收到数据事件
+    case RyanMqttEventReconnectBefore: // 重连前回调
         RyanMqttSetClientState(client, mqttReconnectState);
         break;
+        
     default:
         break;
     }
@@ -682,25 +692,25 @@ void RyanMqttThread(void *argument)
         {
 
         case mqttStartState: // 开始状态状态
-            ulog_w(RyanMqttTag, "初始化状态，开始连接");
+            LOG_I("初始化状态，开始连接");
             result = RyanMqttConnect(client);
             RyanMqttEventMachine(client, RyanMqttConnectAccepted == result ? RyanMqttEventConnected : RyanMqttEventDisconnected,
                                  (void *)&result);
             break;
 
         case mqttConnectState: // 连接状态
-            // ulog_w(RyanMqttTag, "连接状态");
+            LOG_I("连接状态");
             result = RyanMqttReadPacketHandler(client, NULL);
             RyanMqttAckListScan(client, 1);
             RyanMqttKeepalive(client);
             break;
 
         case mqttDisconnectState: // 断开连接状态
-            ulog_w(RyanMqttTag, "断开连接状态");
+            LOG_I("断开连接状态");
             if (RyanTrue != client->config->autoReconnectFlag) // 没有使能自动连接就休眠线程
                 platformThreadStop(client->config->userData, client->mqttThread);
 
-            ulog_w(RyanMqttTag, "触发自动连接，%dms后开始连接\r\n", client->config->reconnectTimeout);
+            LOG_I("触发自动连接，%dms后开始连接\r\n", client->config->reconnectTimeout);
             platformDelay(client->config->reconnectTimeout);
             RyanMqttEventMachine(client, RyanMqttEventReconnectBefore, NULL); // 给上层触发重新连接前事件
 

mqttclient/RyanMqttUtile.c

@@ -358,11 +358,11 @@ RyanMqttError_e RyanMqttMsgHandlerCreate(char *topic, uint16_t topicLen, RyanMqt
     memset(msgHandler, 0, sizeof(RyanMqttMsgHandler_t));
 
     // 初始化链表
-    RyanMqttListInit(&msgHandler->list);
+    RyanListInit(&msgHandler->list);
 
     msgHandler->qos = qos;
     result = RyanMqttStringCopy(&msgHandler->topic, topic, topicLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, RyanMqttNotEnoughMemError, platformMemoryFree(msgHandler); msgHandler = NULL);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, RyanMqttNotEnoughMemError, {platformMemoryFree(msgHandler); msgHandler = NULL; });
 
     *pMsgHandler = msgHandler;
     return RyanMqttSuccessError;
@@ -481,7 +481,7 @@ RyanMqttError_e RyanMqttAckHandlerCreate(RyanMqttClient_t *client, enum msgTypes
     RyanMqttCheck(NULL != ackHandler, RyanMqttNotEnoughMemError);
     memset(ackHandler, 0, sizeof(RyanMqttAckHandler_t) + packetLen);
 
-    RyanMqttListInit(&ackHandler->list);
+    RyanListInit(&ackHandler->list);
     platformTimerCutdown(&ackHandler->timer, client->config->ackTimeout); // 超时内没有响应将被销毁或重新发送
 
     ackHandler->repeatCount = 0;

platform/rtthread/platformNetwork.c → rtthread/platformNetwork.c

@@ -17,9 +17,9 @@ RyanMqttError_e platformNetworkConnect(void *userData, platformNetwork_t *platfo
     RyanMqttError_e result = RyanMqttSuccessError;
     struct addrinfo *addrList = NULL;
     struct addrinfo hints = {
-        .ai_family = AF_UNSPEC,
-        .ai_socktype = SOCK_STREAM,
-        .ai_protocol = IPPROTO_TCP};
+        .ai_family = AF_UNSPEC,     // 指定返回地址的地址族
+        .ai_socktype = SOCK_STREAM, // 指定返回地址的地址族
+        .ai_protocol = IPPROTO_IP}; // 指定socket的协议
 
     if (getaddrinfo(host, port, &hints, &addrList) != 0)
     {
@@ -27,6 +27,9 @@ RyanMqttError_e platformNetworkConnect(void *userData, platformNetwork_t *platfo
         goto exit;
     }
 
+    if (NULL == addrList)
+        goto exit;
+
     platformNetwork->socket = socket(addrList->ai_family, addrList->ai_socktype, addrList->ai_protocol);
     if (platformNetwork->socket < 0)
     {
@@ -89,8 +92,7 @@ RyanMqttError_e platformNetworkRecvAsync(void *userData, platformNetwork_t *plat
         setsockopt(platformNetwork->socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)); // 设置接收超时
 
         recvResult = recv(platformNetwork->socket, recvBuf, recvLen - offset, 0);
-
-        if (recvResult < 0) // 小于零，表示错误，个别错误不代表socket错误
+        if (recvResult < 0)
         {
             if ((errno == EAGAIN ||      // 套接字已标记为非阻塞，而接收操作被阻塞或者接收超时
                  errno == EWOULDBLOCK || // 发送时套接字发送缓冲区已满，或接收时套接字接收缓冲区为空
@@ -152,10 +154,8 @@ RyanMqttError_e platformNetworkSendAsync(void *userData, platformNetwork_t *plat
         setsockopt(platformNetwork->socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(struct timeval)); // 设置发送超时
 
         sendResult = send(platformNetwork->socket, sendBuf, sendLen - offset, 0);
-
-        if (sendResult < 0) // 小于零，表示错误，个别错误不代表socket错误
+        if (sendResult < 0)
         {
-            // 下列3种表示没问题,但需要推出发送
             if ((errno == EAGAIN ||      // 套接字已标记为非阻塞，而接收操作被阻塞或者接收超时
                  errno == EWOULDBLOCK || // 发送时套接字发送缓冲区已满，或接收时套接字接收缓冲区为空
                  errno == EINTR))        // 操作被信号中断

platform/rtthread/platformSystem.c → rtthread/platformSystem.c

@@ -1,12 +1,6 @@
 
 #include "platformSystem.h"
 
-// 存放未初始化
-// #define ccmBss __attribute__((section(".ccmbss")))
-
-// ccmBss static struct rt_thread mqttThreadHandle;
-// ccmBss static char mqttThreadStack[512 * 4];
-
 void *platformMemoryMalloc(size_t size)
 {
     return rt_malloc(size);

platform/rtthread/platformTimer.c → rtthread/platformTimer.c

@@ -4,8 +4,8 @@
 
 /**
  * @brief 自系统启动以来的毫秒时间戳
- * 
- * @return uint32_t 
+ *
+ * @return uint32_t
  */
 uint32_t platformUptimeMs(void)
 {