[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.1 and 1.2

version 1.1, 2012/01/26 13:07:33 version 1.2, 2012/06/20 15:02:24
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 46  SUCH DAMAGE. Line 46  SUCH DAMAGE.
 #include "global.h"  #include "global.h"
   
   
 /* ------------------------------------------------------------------- */  
   
 /*  /*
  * mqtt_msgCONNECT() Create CONNECT message   * mqtt_msgCONNECT() Create CONNECT message
  *   *
  * @buf = Message buffer   * @buf = Message buffer
  * @csConnID = ConnectID   * @csConnID = ConnectID
 * @kasec = Keep alive timeout * @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
  * @csWillTopic = Will Topic if !=NULL Will Flags set into message   * @csWillTopic = Will Topic if !=NULL Will Flags set into message
Line 69  mqtt_msgCONNECT(mqtt_msg_t * __restrict buf, const cha Line 67  mqtt_msgCONNECT(mqtt_msg_t * __restrict buf, const cha
                 const char *csWillTopic, const char *csWillMessage,                   const char *csWillTopic, const char *csWillMessage, 
                 u_char ClrSess, u_char WillQOS, u_char WillRetain)                  u_char ClrSess, u_char WillQOS, u_char WillRetain)
 {  {
        int siz = 0;        int len, siz = 0;
         u_int n;
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
         mqtthdr_var_t *var, *cid, *topic, *wmsg, *user, *pass;          mqtthdr_var_t *var, *cid, *topic, *wmsg, *user, *pass;
         mqtthdr_protover_t *proto;          mqtthdr_protover_t *proto;
         mqtthdr_connflgs_t *flags;          mqtthdr_connflgs_t *flags;
         mqtt_len_t *ka;          mqtt_len_t *ka;
           void *data;
   
         if (!buf || !csConnID)          if (!buf || !csConnID)
                 return -1;                  return -1;
         if (strlen(csConnID) > 23) {          if (strlen(csConnID) > 23) {
                mqtt_SetErr(EINVAL, "Error:: invalid argument ConnID is too long (max 23 bytes)");                mqtt_SetErr(EINVAL, "Invalid argument ConnID is too long (max 23 bytes)");
                 return -1;                  return -1;
         }          }
         if (csUser && strlen(csUser) > 12) {          if (csUser && strlen(csUser) > 12) {
                mqtt_SetErr(EINVAL, "Error:: invalid argument Username is too long (max 12 bytes)");                mqtt_SetErr(EINVAL, "Invalid argument Username is too long (max 12 bytes)");
                 return -1;                  return -1;
         }          }
         if (csPass && strlen(csPass) > 12) {          if (csPass && strlen(csPass) > 12) {
                mqtt_SetErr(EINVAL, "Error:: invalid argument Password is too long (max 12 bytes)");                mqtt_SetErr(EINVAL, "Invalid argument Password is too long (max 12 bytes)");
                 return -1;                  return -1;
         }          }
         if (WillQOS > MQTT_QOS_EXACTLY) {          if (WillQOS > MQTT_QOS_EXACTLY) {
                mqtt_SetErr(EINVAL, "Error:: invalid argument WillQOS - unknown QOS value");                mqtt_SetErr(EINVAL, "Invalid argument WillQOS - unknown QOS value");
                 return -1;                  return -1;
         }          }
   
        if (mqtt_msgRealloc(buf, BUFSIZ) == -1)        /* calculate message size */
         len = 10 + sizeof(mqtt_len_t);                  /* connect arguments */
         len += sizeof(mqtt_len_t) + strlen(csConnID);   /* connect id */
         if (csUser && *csUser) {                        /* user/pass */
                 len += sizeof(mqtt_len_t) + strlen(csUser);
                 if (csPass)
                         len += sizeof(mqtt_len_t) + strlen(csPass);
         }
         if (csWillTopic && *csWillTopic) {              /* will messages */
                 len += sizeof(mqtt_len_t) + strlen(csWillTopic);
                 len += sizeof(mqtt_len_t) + (csWillMessage ? strlen(csWillMessage) : 0);
         }
 
         /* calculate header size */
         siz = sizeof(struct mqtthdr);                   /* mqtt fixed header */
         n = mqtt_encodeLen(len);                        /* message size */
         siz += mqtt_sizeLen(n) - 1;                     /* length size */
 
         if (mqtt_msgRealloc(buf, siz + len) == -1)
                 return -1;                  return -1;
         else {          else {
                hdr = (struct mqtthdr *) (buf->msg_base + siz);                data = buf->msg_base;
                siz += sizeof(struct mqtthdr);                hdr = (struct mqtthdr *) data;
                var = (mqtthdr_var_t*) (buf->msg_base + siz); 
                siz += 8; 
                proto = buf->msg_base + siz; 
                siz++; 
                flags = (mqtthdr_connflgs_t*) (buf->msg_base + siz); 
                siz++; 
                ka = (mqtt_len_t*) (buf->msg_base + siz); 
                siz += sizeof(mqtt_len_t); 
         }          }
   
         /* fixed header */          /* fixed header */
         MQTTHDR_MSGINIT(hdr);          MQTTHDR_MSGINIT(hdr);
         hdr->mqtt_msg.type = MQTT_TYPE_CONNECT;          hdr->mqtt_msg.type = MQTT_TYPE_CONNECT;
        *hdr->mqtt_len = 0;        *(u_int*) hdr->mqtt_len = n;
         data += siz;
   
         /* variable header */          /* variable header */
        var->var_sb.sb.l = 6;        var = (mqtthdr_var_t*) data;
        memcpy(var->var_data, MQTT_CONN_STR, 6);        var->var_sb.val = htons(strlen(MQTT_CONN_STR));
         memcpy(var->var_data, MQTT_CONN_STR, ntohs(var->var_sb.val));
         data += MQTTHDR_VAR_SIZEOF(var);
   
           /* protocol version */
           proto = (mqtthdr_protover_t*) data++;
         *proto = MQTT_PROTO_VER;          *proto = MQTT_PROTO_VER;
   
         /* CONNECT header */          /* CONNECT header */
           flags = (mqtthdr_connflgs_t*) data++;
         flags->clean_sess = ClrSess ? 1 : 0;          flags->clean_sess = ClrSess ? 1 : 0;
         if (csUser && *csUser) {          if (csUser && *csUser) {
                 flags->username = 1;                  flags->username = 1;
Line 140  mqtt_msgCONNECT(mqtt_msg_t * __restrict buf, const cha Line 156  mqtt_msgCONNECT(mqtt_msg_t * __restrict buf, const cha
                 flags->will_retain = 0;                  flags->will_retain = 0;
         }          }
   
           /* keep alive */
           ka = (mqtt_len_t*) data;
         ka->val = kasec ? htons(kasec) : htons(MQTT_KEEPALIVE);          ka->val = kasec ? htons(kasec) : htons(MQTT_KEEPALIVE);
           data += sizeof(mqtt_len_t);
   
         /* ConnID */          /* ConnID */
        cid = (mqtthdr_var_t*) (buf->msg_base + siz);        cid = (mqtthdr_var_t*) data;
         cid->var_sb.val = htons(strlen(csConnID));          cid->var_sb.val = htons(strlen(csConnID));
         siz += MQTTHDR_VAR_SIZEOF(cid);  
         memcpy(cid->var_data, csConnID, ntohs(cid->var_sb.val));          memcpy(cid->var_data, csConnID, ntohs(cid->var_sb.val));
           data += MQTTHDR_VAR_SIZEOF(cid);
   
         /* If Will Flags setup */          /* If Will Flags setup */
         if (csWillTopic && *csWillTopic) {          if (csWillTopic && *csWillTopic) {
                topic = (mqtthdr_var_t*) (buf->msg_base + siz);                topic = (mqtthdr_var_t*) data;
                 topic->var_sb.val = htons(strlen(csWillTopic));                  topic->var_sb.val = htons(strlen(csWillTopic));
                 memcpy(topic->var_data, csWillTopic, ntohs(topic->var_sb.val));                  memcpy(topic->var_data, csWillTopic, ntohs(topic->var_sb.val));
                siz += MQTTHDR_VAR_SIZEOF(topic);                data += MQTTHDR_VAR_SIZEOF(topic);
   
                wmsg = (mqtthdr_var_t*) (buf->msg_base + siz);                wmsg = (mqtthdr_var_t*) data;
                 if (csWillMessage && *csWillMessage) {                  if (csWillMessage && *csWillMessage) {
                         wmsg->var_sb.val = htons(strlen(csWillMessage));                          wmsg->var_sb.val = htons(strlen(csWillMessage));
                         memcpy(wmsg->var_data, csWillMessage, ntohs(wmsg->var_sb.val));                          memcpy(wmsg->var_data, csWillMessage, ntohs(wmsg->var_sb.val));
                 } else                  } else
                         wmsg->var_sb.val = 0;                          wmsg->var_sb.val = 0;
                siz += MQTTHDR_VAR_SIZEOF(wmsg);                data += MQTTHDR_VAR_SIZEOF(wmsg);
         }          }
   
         /* If defined Username & Password */          /* If defined Username & Password */
         if (csUser && *csUser) {          if (csUser && *csUser) {
                user = (mqtthdr_var_t*) (buf->msg_base + siz);                user = (mqtthdr_var_t*) data;
                 user->var_sb.val = htons(strlen(csUser));                  user->var_sb.val = htons(strlen(csUser));
                 memcpy(user->var_data, csUser, ntohs(user->var_sb.val));                  memcpy(user->var_data, csUser, ntohs(user->var_sb.val));
                siz += MQTTHDR_VAR_SIZEOF(user);                data += MQTTHDR_VAR_SIZEOF(user);
   
                 if (csPass && *csPass) {                  if (csPass && *csPass) {
                        pass = (mqtthdr_var_t*) (buf->msg_base + siz);                        pass = (mqtthdr_var_t*) data;
                         pass->var_sb.val = htons(strlen(csPass));                          pass->var_sb.val = htons(strlen(csPass));
                         memcpy(pass->var_data, csPass, ntohs(pass->var_sb.val));                          memcpy(pass->var_data, csPass, ntohs(pass->var_sb.val));
                        siz += MQTTHDR_VAR_SIZEOF(pass);                        data += MQTTHDR_VAR_SIZEOF(pass);
                 }                  }
         }          }
   
        *hdr->mqtt_len = mqtt_encodeLen(siz - sizeof(struct mqtthdr));        return siz + len;
        mqtt_msgRealloc(buf, siz); 
        return siz; 
 }  }
   
 /*  /*
Line 201  mqtt_msgCONNACK(mqtt_msg_t * __restrict buf, u_char re Line 218  mqtt_msgCONNACK(mqtt_msg_t * __restrict buf, u_char re
         if (!buf)          if (!buf)
                 return -1;                  return -1;
         if (retcode > MQTT_RETCODE_DENIED) {          if (retcode > MQTT_RETCODE_DENIED) {
                mqtt_SetErr(EINVAL, "Error:: invalid retcode");                mqtt_SetErr(EINVAL, "Invalid retcode");
                 return -1;                  return -1;
         }          }
   
Line 324  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 341  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
         if (!hdr)          if (!hdr)
                 return cack;                  return cack;
         if (len < 12) {          if (len < 12) {
                mqtt_SetErr(EINVAL, "Error:: 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;                  pos = buf->msg_base + ret + 1;
Line 332  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 349  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
         }          }
         /* 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 != 6 || strncmp((char*) var->var_data, MQTT_CONN_STR, 6)) {
                mqtt_SetErr(EINVAL, "Error:: 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;
Line 341  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 358  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 proto = (mqtthdr_protover_t*) pos;                  proto = (mqtthdr_protover_t*) pos;
         }          }
         if (*proto != MQTT_PROTO_VER) {          if (*proto != MQTT_PROTO_VER) {
                mqtt_SetErr(EINVAL, "Error:: invalid protocol version %d", *pos);                mqtt_SetErr(EINVAL, "Invalid protocol version %d", *pos);
                 cack.retcode = MQTT_RETCODE_REFUSE_VER;                  cack.retcode = MQTT_RETCODE_REFUSE_VER;
                 return cack;                  return cack;
         } else          } else
Line 358  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 375  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
         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 > 23) {
                mqtt_SetErr(EINVAL, "Error:: 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 {
Line 372  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 389  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 var = (mqtthdr_var_t*) pos;                  var = (mqtthdr_var_t*) pos;
                 len -= MQTTHDR_VAR_SIZEOF(var);                  len -= MQTTHDR_VAR_SIZEOF(var);
                 if (len < 0) {                  if (len < 0) {
                        mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Will Topic %d", len);                        mqtt_SetErr(EINVAL, "Unexpected EOM at Will Topic %d", len);
                         cack.retcode = MQTT_RETCODE_REFUSE_ID;                          cack.retcode = MQTT_RETCODE_REFUSE_ID;
                         return cack;                          return cack;
                 } else {                  } else {
Line 392  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 409  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 var = (mqtthdr_var_t*) pos;                  var = (mqtthdr_var_t*) pos;
                 len -= MQTTHDR_VAR_SIZEOF(var);                  len -= MQTTHDR_VAR_SIZEOF(var);
                 if (len < 0) {                  if (len < 0) {
                        mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Will Message %d", len);                        mqtt_SetErr(EINVAL, "Unexpected EOM at Will Message %d", len);
                         cack.retcode = MQTT_RETCODE_REFUSE_ID;                          cack.retcode = MQTT_RETCODE_REFUSE_ID;
                         return cack;                          return cack;
                 } else {                  } else {
Line 415  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 432  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 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 > 12) {                  if (len < 0 || var->var_sb.sb.l > 12) {
                        mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Username %d", len);                        mqtt_SetErr(EINVAL, "Unexpected EOM at Username %d", len);
                         cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;                          cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;
                         return cack;                          return cack;
                 } else {                  } else {
Line 431  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short  Line 448  mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short 
                 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 > 12) {                  if (len < 0 || var->var_sb.sb.l > 12) {
                        mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Password %d", len);                        mqtt_SetErr(EINVAL, "Unexpected EOM at Password %d", len);
                         cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;                          cack.retcode = MQTT_RETCODE_REFUSE_USERPASS;
                         return cack;                          return cack;
                 } else {                  } else {
Line 471  mqtt_readCONNACK(mqtt_msg_t * __restrict buf) Line 488  mqtt_readCONNACK(mqtt_msg_t * __restrict buf)
         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, "Error:: 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;                  pos = buf->msg_base + ret + 1;
Line 479  mqtt_readCONNACK(mqtt_msg_t * __restrict buf) Line 496  mqtt_readCONNACK(mqtt_msg_t * __restrict buf)
         }          }
   
         if (ack->retcode > MQTT_RETCODE_DENIED) {          if (ack->retcode > MQTT_RETCODE_DENIED) {
                mqtt_SetErr(EINVAL, "Error:: invalid retcode %u", ack->retcode);                mqtt_SetErr(EINVAL, "Invalid retcode %u", ack->retcode);
                 return (u_char) -1;                  return (u_char) -1;
         }          }
   
Removed from v.1.1  
changed lines
  Added in v.1.2

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