[BACK]Return to aitmqtt.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitmqtt / src

Diff for /libaitmqtt/src/aitmqtt.c between versions 1.3.4.2 and 1.3.4.4

version 1.3.4.2, 2022/09/13 20:16:43 version 1.3.4.4, 2022/09/14 14:32:48
Line 80  mqtt_SetErr(int eno, char *estr, ...) Line 80  mqtt_SetErr(int eno, char *estr, ...)
         va_end(lst);          va_end(lst);
 }  }
   
 #pragma GCC visibility push(hidden)  
 /* _mqtt_readHEADER() read fixed header from MQTT message */  
 struct mqtthdr *  
 _mqtt_readHEADER(mqtt_msg_t * __restrict buf, u_char cmd, int *bytes, int *len)  
 {  
         struct mqtthdr *hdr;  
   
         if (!buf || !buf->msg_base || !buf->msg_len)  
                 return NULL;  
   
         hdr = (struct mqtthdr*) buf->msg_base;  
         if (hdr->mqtt_msg.type != cmd) {  
                 mqtt_SetErr(EINVAL, "Error:: wrong command #%d should be %d",   
                                 hdr->mqtt_msg.type, cmd);  
                 return NULL;  
         }  
   
         *len = mqtt_decodeLen(hdr->mqtt_len, bytes);  
         return hdr;  
 }  
 #pragma GCC visibility pop  
   
   
 /*  /*
  * mqtt_msgFree() Free MQTT message   * mqtt_msgFree() Free MQTT message
  *   *
  * @msg = Message buffer   * @msg = Message buffer
 * @all = !=0 Destroy entire message, if MQTT Message allocated with mqtt_msgAlloc() * @keepmsg = !=0 just free message content
  * return: none   * return: none
  */   */
 void  void
mqtt_msgFree(mqtt_msg_t ** __restrict msg, int all)mqtt_msgFree(mqtt_msg_t ** __restrict msg, int keepmsg)
 {  {
         if (msg && *msg) {          if (msg && *msg) {
                 if ((*msg)->msg_base) {                  if ((*msg)->msg_base) {
                        free((*msg)->msg_base);                        e_free((*msg)->msg_base);
                         (*msg)->msg_base = NULL;                          (*msg)->msg_base = NULL;
                 }                  }
                if (all) {                if (!keepmsg) {
                        free(*msg);                        e_free(*msg);
                         *msg = NULL;                          *msg = NULL;
                 } else                  } else
                         (*msg)->msg_len ^= (*msg)->msg_len;                          (*msg)->msg_len ^= (*msg)->msg_len;
Line 137  mqtt_msgAlloc(u_int len) Line 115  mqtt_msgAlloc(u_int len)
 {  {
         mqtt_msg_t *m = NULL;          mqtt_msg_t *m = NULL;
   
        m = malloc(sizeof(mqtt_msg_t));        m = e_malloc(sizeof(mqtt_msg_t));
         if (!m) {          if (!m) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 146  mqtt_msgAlloc(u_int len) Line 124  mqtt_msgAlloc(u_int len)
   
         if (len) {          if (len) {
                 m->msg_len = len;                  m->msg_len = len;
                m->msg_base = malloc(m->msg_len);                m->msg_base = e_malloc(m->msg_len);
                 if (!m->msg_base) {                  if (!m->msg_base) {
                         LOGERR;                          LOGERR;
                        free(m);                        e_free(m);
                         return NULL;                          return NULL;
                 } else                  } else
                         memset(m->msg_base, 0, m->msg_len);                          memset(m->msg_base, 0, m->msg_len);
Line 177  mqtt_msgRealloc(mqtt_msg_t * __restrict msg, u_int len Line 155  mqtt_msgRealloc(mqtt_msg_t * __restrict msg, u_int len
         if (len <= msg->msg_len)          if (len <= msg->msg_len)
                 return len;                  return len;
   
        p = realloc(msg->msg_base, len);        p = e_realloc(msg->msg_base, len);
         if (!p) {          if (!p) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 201  mqtt_msgDup(mqtt_msg_t * __restrict msg) Line 179  mqtt_msgDup(mqtt_msg_t * __restrict msg)
 {  {
         mqtt_msg_t *m = NULL;          mqtt_msg_t *m = NULL;
   
        m = malloc(sizeof(mqtt_msg_t));        m = e_malloc(sizeof(mqtt_msg_t));
         if (!m) {          if (!m) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 210  mqtt_msgDup(mqtt_msg_t * __restrict msg) Line 188  mqtt_msgDup(mqtt_msg_t * __restrict msg)
   
         if (msg->msg_len) {          if (msg->msg_len) {
                 m->msg_len = msg->msg_len;                  m->msg_len = msg->msg_len;
                m->msg_base = malloc(m->msg_len);                m->msg_base = e_malloc(m->msg_len);
                 if (!m->msg_base) {                  if (!m->msg_base) {
                         LOGERR;                          LOGERR;
                        free(m);                        e_free(m);
                         return NULL;                          return NULL;
                 } else                  } else
                         memcpy(m->msg_base, msg->msg_base, m->msg_len);                          memcpy(m->msg_base, msg->msg_base, m->msg_len);
Line 345  mqtt_strs2subs(const char **csStr, u_short strnum, u_c Line 323  mqtt_strs2subs(const char **csStr, u_short strnum, u_c
                         (!strnum || (strnum && items < strnum)) && *strs;                           (!strnum || (strnum && items < strnum)) && *strs; 
                         items++, strs++);                          items++, strs++);
   
        if (!(v = malloc((items + 1) * sizeof(mqtt_subscr_t)))) {        if (!(v = e_malloc((items + 1) * sizeof(mqtt_subscr_t)))) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
         } else          } else
Line 353  mqtt_strs2subs(const char **csStr, u_short strnum, u_c Line 331  mqtt_strs2subs(const char **csStr, u_short strnum, u_c
   
         for (i = 0; i < items; i++) {          for (i = 0; i < items; i++) {
                 v[i].sub_topic.msg_len = strlen(csStr[i]);                  v[i].sub_topic.msg_len = strlen(csStr[i]);
                v[i].sub_topic.msg_base = (u_char*) strdup(csStr[i]);                v[i].sub_topic.msg_base = (u_char*) e_strdup(csStr[i]);
                 if (qoses && qoses[i] < MQTT_QOS_RESERVED)                  if (qoses && qoses[i] < MQTT_QOS_RESERVED)
                         v[i].sub_ret = qoses[i];                          v[i].sub_ret = qoses[i];
         }          }
Line 376  mqtt_subFree(mqtt_subscr_t ** __restrict subs) Line 354  mqtt_subFree(mqtt_subscr_t ** __restrict subs)
                 return;                  return;
   
         for (v = *subs; v->sub_topic.msg_base; v++) {          for (v = *subs; v->sub_topic.msg_base; v++) {
                free(v->sub_topic.msg_base);                e_free(v->sub_topic.msg_base);
                 v->sub_topic.msg_base = NULL;                  v->sub_topic.msg_base = NULL;
                 v->sub_topic.msg_len = 0;                  v->sub_topic.msg_len = 0;
   
                 if (v->sub_value.msg_base) {                  if (v->sub_value.msg_base) {
                        free(v->sub_value.msg_base);                        e_free(v->sub_value.msg_base);
                         v->sub_value.msg_base = NULL;                          v->sub_value.msg_base = NULL;
                         v->sub_value.msg_len = 0;                          v->sub_value.msg_len = 0;
                 }                  }
         }          }
   
        free(*subs);        e_free(*subs);
         *subs = NULL;          *subs = NULL;
 }  }
   
Line 402  mqtt_subAlloc(u_short num) Line 380  mqtt_subAlloc(u_short num)
 {  {
         mqtt_subscr_t *s = NULL;          mqtt_subscr_t *s = NULL;
   
        s = malloc((num + 1) * sizeof(mqtt_subscr_t));        s = e_malloc((num + 1) * sizeof(mqtt_subscr_t));
         if (!s) {          if (!s) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 434  mqtt_subRealloc(mqtt_subscr_t ** __restrict subs, u_sh Line 412  mqtt_subRealloc(mqtt_subscr_t ** __restrict subs, u_sh
         if (i == num)          if (i == num)
                 return *subs;                  return *subs;
   
        s = realloc(*subs, (num + 1) * sizeof(mqtt_subscr_t));        s = e_realloc(*subs, (num + 1) * sizeof(mqtt_subscr_t));
         if (!s) {          if (!s) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 460  mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs Line 438  mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
                 return NULL;                  return NULL;
   
         if (src->sub_topic.msg_base) {          if (src->sub_topic.msg_base) {
                dst->sub_topic.msg_base = malloc(src->sub_topic.msg_len + 1);                dst->sub_topic.msg_base = e_malloc(src->sub_topic.msg_len + 1);
                 if (!dst->sub_topic.msg_base) {                  if (!dst->sub_topic.msg_base) {
                         LOGERR;                          LOGERR;
                         memset(dst, 0, sizeof(mqtt_subscr_t));                          memset(dst, 0, sizeof(mqtt_subscr_t));
Line 477  mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs Line 455  mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
         }          }
   
         if (src->sub_value.msg_base) {          if (src->sub_value.msg_base) {
                dst->sub_value.msg_base = malloc(src->sub_value.msg_len + 1);                dst->sub_value.msg_base = e_malloc(src->sub_value.msg_len + 1);
                 if (!dst->sub_value.msg_base) {                  if (!dst->sub_value.msg_base) {
                         LOGERR;                          LOGERR;
                         if (dst->sub_topic.msg_base)                          if (dst->sub_topic.msg_base)
                                free(dst->sub_topic.msg_base);                                e_free(dst->sub_topic.msg_base);
                         memset(dst, 0, sizeof(mqtt_subscr_t));                          memset(dst, 0, sizeof(mqtt_subscr_t));
                         return NULL;                          return NULL;
                 } else {                  } else {
Removed from v.1.3.4.2  
changed lines
  Added in v.1.3.4.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>