[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.4

version 1.3.12.2, 2022/09/13 22:20:59 version 1.3.12.4, 2022/09/14 18:36:23
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 ============ */  
   
 /*  
  * mqtt_readCONNECT() Read elements from CONNECT message  
  *  
  * @buf = Message buffer  
  * @kasec = Keep Alive in seconds for current connection  
  * @psConnID = ConnectID  
  * @connLen = ConnectID length  
  * @psUser = Username if !=NULL  
  * @userLen = Username length  
  * @psPass = Password for Username, only if csUser is set  
  * @passLen = Password length  
  * @psWillTopic = Will Topic if !=NULL Will Flags set into message and must be free()  
  * @psWillMessage = Will Message, may be NULL if !NULL must be free() after use!  
  * return: .reserved == 1 is error or == 0 connection flags & msg ok  
  */  
 mqtthdr_connack_t  
 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 psWillTopic, char ** __restrict psWillMessage)  
 {  
         mqtthdr_connflgs_t flg = { MQTT_CONNFLGS_INIT };  
         mqtthdr_connack_t cack = { 1, MQTT_RETCODE_DENIED };  
         struct mqtthdr *hdr;  
         mqtthdr_var_t *var;  
         mqtt_len_t *ka;  
         int len, ret;  
         caddr_t pos;  
   
         if (!buf || !buf->msg_base || !buf->msg_len || !psConnID || !connLen)  
                 return cack;  
   
         hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNECT, &ret, &len);  
         if (!hdr)  
                 return cack;  
         if (len < 12) {  
                 mqtt_SetErr(EINVAL, "Short message length %d", len);  
                 return cack;  
         } else {  
                 pos = buf->msg_base + ret + 1;  
                 var = (mqtthdr_var_t*) pos;  
         }  
         /* check init string & protocol */  
         if (var->var_sb.sb.l != 6 || strncmp((char*) var->var_data, MQTT_CONN_STR, 6)) {  
                 mqtt_SetErr(EINVAL, "Invalid init string %.6s(%d)",   
                                 var->var_data, var->var_sb.sb.l);  
                 cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;  
                 return cack;  
         } else {  
                 pos += var->var_sb.sb.l + sizeof(mqtt_len_t);  
                 proto = (mqtthdr_protover_t*) pos;  
         }  
         if (*proto != MQTT_PROTO_VER) {  
                 mqtt_SetErr(EINVAL, "Invalid protocol version %d", *pos);  
                 cack.retcode = MQTT_RETCODE_REFUSE_VER;  
                 return cack;  
         } else  
                 pos++;  
         flg = *(mqtthdr_connflgs_t*) pos;  
         pos++;  
         ka = (mqtt_len_t*) pos;  
         *kasec = ntohs(ka->val);  
         pos += sizeof(mqtt_len_t);  
   
         len -= pos - (caddr_t) var;  
   
         /* get ConnID */  
         var = (mqtthdr_var_t*) pos;  
         len -= MQTTHDR_VAR_SIZEOF(var);  
         if (len < 0 || var->var_sb.sb.l > 23) {  
                 mqtt_SetErr(EINVAL, "Unexpected EOM at Connection ID %d", len);  
                 cack.retcode = MQTT_RETCODE_REFUSE_ID;  
                 return cack;  
         } else {  
                 memset(psConnID, 0, connLen--);  
                 memcpy(psConnID, var->var_data, ntohs(var->var_sb.val) > connLen ? connLen : ntohs(var->var_sb.val));  
                 pos += MQTTHDR_VAR_SIZEOF(var);  
         }  
   
         /* get Willz */  
         if (flg.will_flg) {  
                 var = (mqtthdr_var_t*) pos;  
                 len -= MQTTHDR_VAR_SIZEOF(var);  
                 if (len < 0) {  
                         mqtt_SetErr(EINVAL, "Unexpected EOM at Will Topic %d", len);  
                         cack.retcode = MQTT_RETCODE_REFUSE_ID;  
                         return cack;  
                 } else {  
                         if (psWillTopic) {  
                                 *psWillTopic = malloc(ntohs(var->var_sb.val) + 1);  
                                 if (!*psWillTopic) {  
                                         LOGERR;  
                                         cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;  
                                         return cack;  
                                 } else  
                                         memset(*psWillTopic, 0, ntohs(var->var_sb.val) + 1);  
                                 memcpy(*psWillTopic, var->var_data, ntohs(var->var_sb.val));  
                         }  
                         pos += MQTTHDR_VAR_SIZEOF(var);  
                 }  
   
                 var = (mqtthdr_var_t*) pos;  
                 len -= MQTTHDR_VAR_SIZEOF(var);  
                 if (len < 0) {  
                         mqtt_SetErr(EINVAL, "Unexpected EOM at Will Message %d", len);  
                         cack.retcode = MQTT_RETCODE_REFUSE_ID;  
                         return cack;  
                 } else {  
                         if (psWillMessage) {  
                                 *psWillMessage = malloc(ntohs(var->var_sb.val) + 1);  
                                 if (!*psWillMessage) {  
                                         LOGERR;  
                                         cack.retcode = MQTT_RETCODE_REFUSE_UNAVAIL;  
                                         return cack;  
                                 } else  
                                         memset(*psWillMessage, 0, ntohs(var->var_sb.val) + 1);  
                                 memcpy(*psWillMessage, var->var_data, ntohs(var->var_sb.val));  
                         }  
                         pos += MQTTHDR_VAR_SIZEOF(var);  
                 }  
         }  
   
         /* get User/Pass */  
         if (flg.username) {  
                 var = (mqtthdr_var_t*) pos;  
                 len -= MQTTHDR_VAR_SIZEOF(var);  
                 if (len < 0 || var->var_sb.sb.l > 12) {  
                         mqtt_SetErr(EINVAL, "Unexpected EOM at Username %d", len);  
                         cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;  
                         return cack;  
                 } else {  
                         if (psUser && userLen) {  
                                 memset(psUser, 0, userLen--);  
                                 memcpy(psUser, var->var_data,   
                                                 ntohs(var->var_sb.val) > userLen ? userLen : ntohs(var->var_sb.val));  
                         }  
                         pos += MQTTHDR_VAR_SIZEOF(var);  
                 }  
         }  
         if (flg.password) {  
                 var = (mqtthdr_var_t*) pos;  
                 len -= MQTTHDR_VAR_SIZEOF(var);  
                 if (len < 0 || var->var_sb.sb.l > 12) {  
                         mqtt_SetErr(EINVAL, "Unexpected EOM at Password %d", len);  
                         cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;  
                         return cack;  
                 } else {  
                         if (psPass && passLen) {  
                                 memset(psPass, 0, passLen--);  
                                 memcpy(psPass, var->var_data,   
                                                 ntohs(var->var_sb.val) > passLen ? passLen : ntohs(var->var_sb.val));  
                         }  
                         pos += MQTTHDR_VAR_SIZEOF(var);  
                 }  
         }  
   
         flg.reserved = 0;  
         cack.reserved = flg.flags;  
         cack.retcode = MQTT_RETCODE_ACCEPTED;  
         return cack;  
 }  
   
 /*  
  * mqtt_readCONNACK() Read CONNACK message  
  *  
  * @buf = Message buffer  
  * return: -1 error or >-1 CONNECT message return code  
  */  
 u_char  
 mqtt_readCONNACK(mqtt_msg_t * __restrict buf)  
 {  
         int len, ret;  
         struct mqtthdr *hdr;  
         mqtthdr_connack_t *ack;  
         caddr_t pos;  
   
         if (!buf || !buf->msg_base || !buf->msg_len)  
                 return (u_char) -1;  
   
         hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNACK, &ret, &len);  
         if (!hdr)  
                 return (u_char) -1;  
         if (len < sizeof(mqtthdr_connack_t)) {  
                 mqtt_SetErr(EINVAL, "Short message length %d", len);  
                 return (u_char) -1;  
         } else {  
                 pos = buf->msg_base + ret + 1;  
                 ack = (mqtthdr_connack_t*) pos;  
         }  
   
         if (ack->retcode > MQTT_RETCODE_DENIED) {  
                 mqtt_SetErr(EINVAL, "Invalid retcode %u", ack->retcode);  
                 return (u_char) -1;  
         }  
   
         return ack->retcode;  
 }  
   
 /*  
  * mqtt_readDISCONNECT() Read DISCONNECT message  
  *  
  * @buf = Message buffer  
  * return: -1 error, 0 ok, >0 undefined result  
  */  
 int  
 mqtt_readDISCONNECT(mqtt_msg_t * __restrict buf)  
 {  
         int len, ret;  
         struct mqtthdr *hdr;  
   
         hdr = _mqtt_readHEADER(buf, MQTT_TYPE_DISCONNECT, &ret, &len);  
         if (!hdr || ret != 1)  
                 return -1;  
   
         return len;  
 }  
   
 /*  
  * mqtt_readPINGREQ() Read PINGREQ message  
  *  
  * @buf = Message buffer  
  * return: -1 error, 0 ok, >0 undefined result  
  */  
 int  
 mqtt_readPINGREQ(mqtt_msg_t * __restrict buf)  
 {  
         int len, ret;  
         struct mqtthdr *hdr;  
   
         hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PINGREQ, &ret, &len);  
         if (!hdr || ret != 1)  
                 return -1;  
   
         return len;  
 }  
   
 /*  
  * mqtt_readPINGRESP() Read PINGRESP message  
  *  
  * @buf = Message buffer  
  * return: -1 error, 0 ok, >0 undefined result  
  */  
 int  
 mqtt_readPINGRESP(mqtt_msg_t * __restrict buf)  
 {  
         int len, ret;  
         struct mqtthdr *hdr;  
   
         hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PINGRESP, &ret, &len);  
         if (!hdr || ret != 1)  
                 return -1;  
   
         return len;  
 }  
 #endif  
Removed from v.1.3.12.2  
changed lines
  Added in v.1.3.12.4

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