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

Diff for /libaitmqtt/src/conn.c between versions 1.3.12.2 and 1.3.12.3

version 1.3.12.2, 2022/09/13 22:20:59 version 1.3.12.3, 2022/09/14 14:32:48
Line 50  SUCH DAMAGE. Line 50  SUCH DAMAGE.
  * mqtt_msgCONNECT() Create CONNECT message   * mqtt_msgCONNECT() Create CONNECT message
  *   *
  * @csConnID = ConnectID   * @csConnID = ConnectID
 * @Version = MQTT version * @Version = MQTT version, if =0 default version is 3.1.1
  * @KASec = Keep alive timeout, if =0 default timeout for MQTT   * @KASec = Keep alive timeout, if =0 default timeout for MQTT
  * @csUser = Username if !=NULL   * @csUser = Username if !=NULL
  * @csPass = Password for Username, only if csUser is set   * @csPass = Password for Username, only if csUser is set
Line 59  SUCH DAMAGE. Line 59  SUCH DAMAGE.
  * @ClrSess = Clear Session subscriptions after disconnect   * @ClrSess = Clear Session subscriptions after disconnect
  * @WillQOS = Will QOS if csWillTopic is set   * @WillQOS = Will QOS if csWillTopic is set
  * @WillRetain = Will Retain Will Message if csWillTopic is set   * @WillRetain = Will Retain Will Message if csWillTopic is set
 * return: NULL error or allocated connect message * return: NULL error or allocated CONNECT message
  */   */
 mqtt_msg_t *  mqtt_msg_t *
 mqtt_msgCONNECT(const char *csConnID, u_char Version, u_short KASec,   mqtt_msgCONNECT(const char *csConnID, u_char Version, u_short KASec, 
Line 83  mqtt_msgCONNECT(const char *csConnID, u_char Version,  Line 83  mqtt_msgCONNECT(const char *csConnID, u_char Version, 
                                 MQTT_CONNID_MAX - 1);                                  MQTT_CONNID_MAX - 1);
                 return NULL;                  return NULL;
         }          }
        if (Version < MQTT_PROTO_VER_3 || Version > MQTT_PROTO_VER_5) {        if (Version && (Version < MQTT_PROTO_VER_3 || Version > MQTT_PROTO_VER_5)) {
                 mqtt_SetErr(EINVAL, "Unsupported version");                  mqtt_SetErr(EINVAL, "Unsupported version");
                 return NULL;                  return NULL;
         }          }
Line 140  mqtt_msgCONNECT(const char *csConnID, u_char Version,  Line 140  mqtt_msgCONNECT(const char *csConnID, u_char Version, 
         data += MQTTHDR_VAR_SIZEOF(var);          data += MQTTHDR_VAR_SIZEOF(var);
   
         /* protocol version */          /* protocol version */
        *(u_char*) data++ = Version;        *(u_char*) data++ = Version ? Version : MQTT_PROTO_VER_311;
   
         /* CONNECT header */          /* CONNECT header */
         flags = (mqtthdr_connflgs_t*) data++;          flags = (mqtthdr_connflgs_t*) data++;
Line 206  mqtt_msgCONNECT(const char *csConnID, u_char Version,  Line 206  mqtt_msgCONNECT(const char *csConnID, u_char Version, 
   
         return msg;          return msg;
 }  }
#if 0
 /*  /*
  * mqtt_msgCONNACK() Create CONNACK message   * mqtt_msgCONNACK() Create CONNACK message
  *   *
  * @buf = Message buffer  
  * @retcode = Return code   * @retcode = Return code
 * return: -1 error or >-1 message size for send * return: NULL error or allocated CONNACK message
  */   */
 mqtt_msg_t *  mqtt_msg_t *
 mqtt_msgCONNACK(u_char retcode)  mqtt_msgCONNACK(u_char retcode)
 {  {
         int siz = 0;  
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
         mqtthdr_connack_t *ack;          mqtthdr_connack_t *ack;
         mqtt_msg_t *msg = NULL;          mqtt_msg_t *msg = NULL;
Line 230  mqtt_msgCONNACK(u_char retcode) Line 228  mqtt_msgCONNACK(u_char retcode)
         if (!(msg = mqtt_msgAlloc(sizeof(struct mqtthdr) + sizeof(mqtthdr_connack_t))))          if (!(msg = mqtt_msgAlloc(sizeof(struct mqtthdr) + sizeof(mqtthdr_connack_t))))
                 return NULL;                  return NULL;
         else {          else {
                hdr = (struct mqtthdr *) (buf->msg_base + siz);                hdr = (struct mqtthdr *) msg->msg_base;
                siz += sizeof(struct mqtthdr);                ack = (mqtthdr_connack_t*) msg->msg_base + sizeof(struct mqtthdr);
                ack = (mqtthdr_connack_t*) (buf->msg_base + siz); 
                siz += sizeof(mqtthdr_connack_t); 
         }          }
   
         /* fixed header */          /* fixed header */
         MQTTHDR_MSGINIT(hdr);  
         hdr->mqtt_msg.type = MQTT_TYPE_CONNACK;          hdr->mqtt_msg.type = MQTT_TYPE_CONNACK;
         *hdr->mqtt_len = sizeof(mqtthdr_connack_t);          *hdr->mqtt_len = sizeof(mqtthdr_connack_t);
   
Line 245  mqtt_msgCONNACK(u_char retcode) Line 240  mqtt_msgCONNACK(u_char retcode)
         ack->reserved = 0;          ack->reserved = 0;
         ack->retcode = retcode;          ack->retcode = retcode;
   
        return siz;        return msg;
 }  }
   
static intstatic mqtt_msg_t *
_mqtt_msgSIMPLE_(mqtt_msg_t * __restrict buf, u_char cmd)_mqtt_msgSIMPLE_(u_char cmd)
 {  {
         int siz = 0;  
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
           mqtt_msg_t *msg = NULL;
   
        if (!buf)        if (!(msg = mqtt_msgAlloc(sizeof(struct mqtthdr))))
                return -1;                return NULL;
         else
                 hdr = (struct mqtthdr *) msg->msg_base;
   
         if (mqtt_msgRealloc(buf, sizeof(struct mqtthdr)) == -1)  
                 return -1;  
         else {  
                 hdr = (struct mqtthdr *) (buf->msg_base + siz);  
                 siz += sizeof(struct mqtthdr);  
         }  
   
         /* fixed header */          /* fixed header */
         MQTTHDR_MSGINIT(hdr);  
         hdr->mqtt_msg.type = cmd;          hdr->mqtt_msg.type = cmd;
         *hdr->mqtt_len = 0;          *hdr->mqtt_len = 0;
   
        return siz;        return msg;
 }  }
   
 /*  /*
  * mqtt_msgPINGREQ() Create PINGREQ message   * mqtt_msgPINGREQ() Create PINGREQ message
  *   *
 * @buf = Message buffer * return: NULL error or allocated message
 * return: -1 error or >-1 message size for send 
  */   */
intmqtt_msg_t *
mqtt_msgPINGREQ(mqtt_msg_t * __restrict buf)mqtt_msgPINGREQ()
 {  {
        return _mqtt_msgSIMPLE_(buf, MQTT_TYPE_PINGREQ);        return _mqtt_msgSIMPLE_(MQTT_TYPE_PINGREQ);
 }  }
   
 /*  /*
  * mqtt_msgPINGRESP() Create PINGRESP message   * mqtt_msgPINGRESP() Create PINGRESP message
  *   *
 * @buf = Message buffer * return: NULL error or allocated message
 * return: -1 error or >-1 message size for send 
  */   */
intmqtt_msg_t *
mqtt_msgPINGRESP(mqtt_msg_t * __restrict buf)mqtt_msgPINGRESP()
 {  {
        return _mqtt_msgSIMPLE_(buf, MQTT_TYPE_PINGRESP);        return _mqtt_msgSIMPLE_(MQTT_TYPE_PINGRESP);
 }  }
   
 /*  /*
  * mqtt_msgDISCONNECT() Create DISCONNECT message   * mqtt_msgDISCONNECT() Create DISCONNECT message
  *   *
 * @buf = Message buffer * return: NULL error or allocated message
 * return: -1 error or >-1 message size for send 
  */   */
intmqtt_msg_t *
mqtt_msgDISCONNECT(mqtt_msg_t * __restrict buf)mqtt_msgDISCONNECT()
 {  {
        return _mqtt_msgSIMPLE_(buf, MQTT_TYPE_DISCONNECT);        return _mqtt_msgSIMPLE_(MQTT_TYPE_DISCONNECT);
 }  }
   
 /* ============= decode ============ */  /* ============= decode ============ */
   
   //#pragma GCC visibility push(hidden)
   /* _mqtt_readHEADER() read fixed header from MQTT message */
   static struct mqtthdr *
   _mqtt_readHEADER(mqtt_msg_t * __restrict buf, u_char cmd, int *len, caddr_t *next)
   {
           struct mqtthdr *hdr;
           int bytes;
   
           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;
           }
   
           if (len)
                   *len = mqtt_decodeLen(hdr->mqtt_len, &bytes);
   
           if (next)
                   *next = buf->msg_base + bytes + 1;
   
           return hdr;
   }
   //#pragma GCC visibility pop
   
 /*  /*
  * mqtt_readCONNECT() Read elements from CONNECT message   * mqtt_readCONNECT() Read elements from CONNECT message
  *   *
  * @buf = Message buffer   * @buf = Message buffer
 * @kasec = Keep Alive in seconds for current connection * @KASec = Keep Alive in seconds for current connection
  * @psConnID = ConnectID   * @psConnID = ConnectID
  * @connLen = ConnectID length   * @connLen = ConnectID length
  * @psUser = Username if !=NULL   * @psUser = Username if !=NULL
  * @userLen = Username length   * @userLen = Username length
  * @psPass = Password for Username, only if csUser is set   * @psPass = Password for Username, only if csUser is set
  * @passLen = Password length   * @passLen = Password length
 * @psWillTopic = Will Topic if !=NULL Will Flags set into message and must be free() * @psWillTopic = Will Topic if !=NULL Will Flags set into message and must be e_free()
 * @psWillMessage = Will Message, may be NULL if !NULL must be free() after use! * @psWillMessage = Will Message, may be NULL if !NULL must be e_free() after use!
  * return: .reserved == 1 is error or == 0 connection flags & msg ok   * return: .reserved == 1 is error or == 0 connection flags & msg ok
  */   */
 mqtthdr_connack_t  mqtthdr_connack_t
mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short *kasec, char * __restrict psConnID, int connLen, mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short *KASec, char * __restrict psConnID, int connLen, 
                 char * __restrict psUser, int userLen, char * __restrict psPass, int passLen,                    char * __restrict psUser, int userLen, char * __restrict psPass, int passLen,  
                 char ** __restrict psWillTopic, char ** __restrict psWillMessage)                  char ** __restrict psWillTopic, char ** __restrict psWillMessage)
 {  {
Line 335  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 349  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
         mqtthdr_var_t *var;          mqtthdr_var_t *var;
         mqtt_len_t *ka;          mqtt_len_t *ka;
        int len, ret;        int len;
         caddr_t pos;          caddr_t pos;
   
         if (!buf || !buf->msg_base || !buf->msg_len || !psConnID || !connLen)          if (!buf || !buf->msg_base || !buf->msg_len || !psConnID || !connLen)
                 return cack;                  return cack;
   
        hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNECT, &ret, &len);        hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNECT, &len, &pos);
         if (!hdr)          if (!hdr)
                 return cack;                  return cack;
         if (len < 12) {          if (len < 12) {
                 mqtt_SetErr(EINVAL, "Short message length %d", len);                  mqtt_SetErr(EINVAL, "Short message length %d", len);
                 return cack;                  return cack;
        } else {        } else
                pos = buf->msg_base + ret + 1; 
                 var = (mqtthdr_var_t*) pos;                  var = (mqtthdr_var_t*) pos;
        }
         /* check init string & protocol */          /* check init string & protocol */
        if (var->var_sb.sb.l != 6 || strncmp((char*) var->var_data, MQTT_CONN_STR, 6)) {        if (var->var_sb.sb.l == 4 && !strcmp((char*) var->var_data, MQTT_PROTO_STR))
                 pos += var->var_sb.sb.l + sizeof(mqtt_len_t);
         else if (var->var_sb.sb.l == 6 || strcmp((char*) var->var_data, MQTT_CONN_STR))
                 pos += var->var_sb.sb.l + sizeof(mqtt_len_t);
         else {
                 mqtt_SetErr(EINVAL, "Invalid init string %.6s(%d)",                   mqtt_SetErr(EINVAL, "Invalid init string %.6s(%d)", 
                                 var->var_data, var->var_sb.sb.l);                                  var->var_data, var->var_sb.sb.l);
                 cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;                  cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;
                 return cack;                  return cack;
         } else {  
                 pos += var->var_sb.sb.l + sizeof(mqtt_len_t);  
                 proto = (mqtthdr_protover_t*) pos;  
         }          }
        if (*proto != MQTT_PROTO_VER) {        switch (*pos) {
                mqtt_SetErr(EINVAL, "Invalid protocol version %d", *pos);                case MQTT_PROTO_VER_3:
                cack.retcode = MQTT_RETCODE_REFUSE_VER;                case MQTT_PROTO_VER_311:
                return cack;                case MQTT_PROTO_VER_5:
        } else                        pos++;
                pos++;                        break;
                 default:
                         mqtt_SetErr(EINVAL, "Invalid protocol version %d", *pos);
                         cack.retcode = MQTT_RETCODE_REFUSE_VER;
                         return cack;
         }
         flg = *(mqtthdr_connflgs_t*) pos;          flg = *(mqtthdr_connflgs_t*) pos;
         pos++;          pos++;
         ka = (mqtt_len_t*) pos;          ka = (mqtt_len_t*) pos;
        *kasec = ntohs(ka->val);        *KASec = ntohs(ka->val);
         pos += sizeof(mqtt_len_t);          pos += sizeof(mqtt_len_t);
   
         len -= pos - (caddr_t) var;          len -= pos - (caddr_t) var;
Line 378  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 397  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
         /* get ConnID */          /* get ConnID */
         var = (mqtthdr_var_t*) pos;          var = (mqtthdr_var_t*) pos;
         len -= MQTTHDR_VAR_SIZEOF(var);          len -= MQTTHDR_VAR_SIZEOF(var);
        if (len < 0 || var->var_sb.sb.l > 23) {        if (len < 0 || var->var_sb.sb.l >= MQTT_CONNID_MAX) {
                 mqtt_SetErr(EINVAL, "Unexpected EOM at Connection ID %d", len);                  mqtt_SetErr(EINVAL, "Unexpected EOM at Connection ID %d", len);
                 cack.retcode = MQTT_RETCODE_REFUSE_ID;                  cack.retcode = MQTT_RETCODE_REFUSE_ID;
                 return cack;                  return cack;
         } else {          } else {
                 memset(psConnID, 0, connLen--);                  memset(psConnID, 0, connLen--);
                memcpy(psConnID, var->var_data, ntohs(var->var_sb.val) > connLen ? connLen : ntohs(var->var_sb.val));                memcpy(psConnID, var->var_data, 
                                 ntohs(var->var_sb.val) > connLen ? connLen : ntohs(var->var_sb.val));
                 pos += MQTTHDR_VAR_SIZEOF(var);                  pos += MQTTHDR_VAR_SIZEOF(var);
         }          }
   
Line 398  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 418  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                         return cack;                          return cack;
                 } else {                  } else {
                         if (psWillTopic) {                          if (psWillTopic) {
                                *psWillTopic = malloc(ntohs(var->var_sb.val) + 1);                                *psWillTopic = e_malloc(ntohs(var->var_sb.val) + 1);
                                 if (!*psWillTopic) {                                  if (!*psWillTopic) {
                                         LOGERR;                                          LOGERR;
                                         cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;                                          cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;
Line 414  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 434  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 len -= MQTTHDR_VAR_SIZEOF(var);                  len -= MQTTHDR_VAR_SIZEOF(var);
                 if (len < 0) {                  if (len < 0) {
                         mqtt_SetErr(EINVAL, "Unexpected EOM at Will Message %d", len);                          mqtt_SetErr(EINVAL, "Unexpected EOM at Will Message %d", len);
                           e_free(psWillTopic);
                         cack.retcode = MQTT_RETCODE_REFUSE_ID;                          cack.retcode = MQTT_RETCODE_REFUSE_ID;
                         return cack;                          return cack;
                 } else {                  } else {
                         if (psWillMessage) {                          if (psWillMessage) {
                                *psWillMessage = malloc(ntohs(var->var_sb.val) + 1);                                *psWillMessage = e_malloc(ntohs(var->var_sb.val) + 1);
                                 if (!*psWillMessage) {                                  if (!*psWillMessage) {
                                         LOGERR;                                          LOGERR;
                                           e_free(psWillTopic);
                                         cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;                                          cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;
                                         return cack;                                          return cack;
                                 } else                                  } else
Line 437  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 459  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 len -= MQTTHDR_VAR_SIZEOF(var);                  len -= MQTTHDR_VAR_SIZEOF(var);
                 if (len < 0 || var->var_sb.sb.l > 12) {                  if (len < 0 || var->var_sb.sb.l > 12) {
                         mqtt_SetErr(EINVAL, "Unexpected EOM at Username %d", len);                          mqtt_SetErr(EINVAL, "Unexpected EOM at Username %d", len);
                           if (flg.will_flg) {
                                   if (psWillTopic)
                                           e_free(psWillTopic);
                                   if (psWillMessage)
                                           e_free(psWillMessage);
                           }
                         cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;                          cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;
                         return cack;                          return cack;
                 } else {                  } else {
Line 453  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 481  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 len -= MQTTHDR_VAR_SIZEOF(var);                  len -= MQTTHDR_VAR_SIZEOF(var);
                 if (len < 0 || var->var_sb.sb.l > 12) {                  if (len < 0 || var->var_sb.sb.l > 12) {
                         mqtt_SetErr(EINVAL, "Unexpected EOM at Password %d", len);                          mqtt_SetErr(EINVAL, "Unexpected EOM at Password %d", len);
                           if (flg.will_flg) {
                                   if (psWillTopic)
                                           e_free(psWillTopic);
                                   if (psWillMessage)
                                           e_free(psWillMessage);
                           }
                         cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;                          cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;
                         return cack;                          return cack;
                 } else {                  } else {
Line 480  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 514  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
 u_char  u_char
 mqtt_readCONNACK(mqtt_msg_t * __restrict buf)  mqtt_readCONNACK(mqtt_msg_t * __restrict buf)
 {  {
        int len, ret;        int len;
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
         mqtthdr_connack_t *ack;          mqtthdr_connack_t *ack;
         caddr_t pos;          caddr_t pos;
Line 488  mqtt_readCONNACK(mqtt_msg_t * __restrict buf) Line 522  mqtt_readCONNACK(mqtt_msg_t * __restrict buf)
         if (!buf || !buf->msg_base || !buf->msg_len)          if (!buf || !buf->msg_base || !buf->msg_len)
                 return (u_char) -1;                  return (u_char) -1;
   
        hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNACK, &ret, &len);        hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNACK, &len, &pos);
         if (!hdr)          if (!hdr)
                 return (u_char) -1;                  return (u_char) -1;
         if (len < sizeof(mqtthdr_connack_t)) {          if (len < sizeof(mqtthdr_connack_t)) {
                 mqtt_SetErr(EINVAL, "Short message length %d", len);                  mqtt_SetErr(EINVAL, "Short message length %d", len);
                 return (u_char) -1;                  return (u_char) -1;
        } else {        } else
                pos = buf->msg_base + ret + 1; 
                 ack = (mqtthdr_connack_t*) pos;                  ack = (mqtthdr_connack_t*) pos;
         }  
   
         if (ack->retcode > MQTT_RETCODE_DENIED) {          if (ack->retcode > MQTT_RETCODE_DENIED) {
                 mqtt_SetErr(EINVAL, "Invalid retcode %u", ack->retcode);                  mqtt_SetErr(EINVAL, "Invalid retcode %u", ack->retcode);
Line 516  mqtt_readCONNACK(mqtt_msg_t * __restrict buf) Line 548  mqtt_readCONNACK(mqtt_msg_t * __restrict buf)
 int  int
 mqtt_readDISCONNECT(mqtt_msg_t * __restrict buf)  mqtt_readDISCONNECT(mqtt_msg_t * __restrict buf)
 {  {
        int len, ret;        int len;
        struct mqtthdr *hdr; 
   
        hdr = _mqtt_readHEADER(buf, MQTT_TYPE_DISCONNECT, &ret, &len);        if (!_mqtt_readHEADER(buf, MQTT_TYPE_DISCONNECT, &len, NULL))
        if (!hdr || ret != 1) 
                 return -1;                  return -1;
   
         return len;          return len;
Line 535  mqtt_readDISCONNECT(mqtt_msg_t * __restrict buf) Line 565  mqtt_readDISCONNECT(mqtt_msg_t * __restrict buf)
 int  int
 mqtt_readPINGREQ(mqtt_msg_t * __restrict buf)  mqtt_readPINGREQ(mqtt_msg_t * __restrict buf)
 {  {
        int len, ret;        int len;
        struct mqtthdr *hdr; 
   
        hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PINGREQ, &ret, &len);        if (!_mqtt_readHEADER(buf, MQTT_TYPE_PINGREQ, &len, NULL))
        if (!hdr || ret != 1) 
                 return -1;                  return -1;
   
         return len;          return len;
Line 554  mqtt_readPINGREQ(mqtt_msg_t * __restrict buf) Line 582  mqtt_readPINGREQ(mqtt_msg_t * __restrict buf)
 int  int
 mqtt_readPINGRESP(mqtt_msg_t * __restrict buf)  mqtt_readPINGRESP(mqtt_msg_t * __restrict buf)
 {  {
        int len, ret;        int len;
        struct mqtthdr *hdr; 
   
        hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PINGRESP, &ret, &len);        if (!_mqtt_readHEADER(buf, MQTT_TYPE_PINGRESP, &len, NULL))
        if (!hdr || ret != 1) 
                 return -1;                  return -1;
   
         return len;          return len;
 }  }
 #endif  
Removed from v.1.3.12.2  
changed lines
  Added in v.1.3.12.3

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