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

Diff for /libaitmqtt/src/pub.c between versions 1.1.1.1.2.3 and 1.2.2.2

version 1.1.1.1.2.3, 2012/04/27 15:15:12 version 1.2.2.2, 2012/06/28 09:01:42
Line 63  int Line 63  int
 mqtt_msgPUBLISH(mqtt_msg_t * __restrict buf, const char *csTopic, u_short msgID,   mqtt_msgPUBLISH(mqtt_msg_t * __restrict buf, const char *csTopic, u_short msgID, 
                 u_char Dup, u_char QOS, u_char Retain, const void *pData, int datlen)                  u_char Dup, u_char QOS, u_char Retain, const void *pData, int datlen)
 {  {
        int siz = 0;        int len, siz;
         u_int n, *l;
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
         mqtthdr_var_t *topic;          mqtthdr_var_t *topic;
         mqtt_len_t *mid;          mqtt_len_t *mid;
Line 80  mqtt_msgPUBLISH(mqtt_msg_t * __restrict buf, const cha Line 81  mqtt_msgPUBLISH(mqtt_msg_t * __restrict buf, const cha
                 return -1;                  return -1;
         }          }
   
        if (mqtt_msgRealloc(buf, MQTTMSG_MAX) == -1)        /* calculate message size */
         len = sizeof(mqtt_len_t) + strlen(csTopic);     /* topic */
         len += sizeof(mqtt_len_t);                      /* msgid */
         len += datlen;                                  /* data len */
 
         /* 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;
         }          }
   
           /* fixed header */
           MQTTHDR_MSGINIT(hdr);
           hdr->mqtt_msg.type = MQTT_TYPE_PUBLISH;
           hdr->mqtt_msg.qos = QOS;
           hdr->mqtt_msg.dup = Dup ? 1 : 0;
           hdr->mqtt_msg.retain = Retain ? 1 : 0;
           l = (u_int*) hdr->mqtt_len;
           *l = n;
           data += siz;
   
         /* variable header */          /* variable header */
        topic = (mqtthdr_var_t*) (buf->msg_base + siz);        topic = (mqtthdr_var_t*) data;
         topic->var_sb.val = htons(strlen(csTopic));          topic->var_sb.val = htons(strlen(csTopic));
         memcpy(topic->var_data, csTopic, ntohs(topic->var_sb.val));          memcpy(topic->var_data, csTopic, ntohs(topic->var_sb.val));
        siz += MQTTHDR_VAR_SIZEOF(topic);        data += MQTTHDR_VAR_SIZEOF(topic);
   
        mid = (mqtt_len_t*) (buf->msg_base + siz);        mid = (mqtt_len_t*) data;
         mid->val = htons(msgID);          mid->val = htons(msgID);
        siz += sizeof(mqtt_len_t);        data += sizeof(mqtt_len_t);
   
         /* load with data */          /* load with data */
        if (pData && datlen) {        if (pData && datlen)
                data = buf->msg_base + siz; 
                 memcpy(data, pData, datlen);                  memcpy(data, pData, datlen);
                 siz += datlen;  
         }  
   
        /* fixed header */        return siz + len;
        MQTTHDR_MSGINIT(hdr); 
        hdr->mqtt_msg.type = MQTT_TYPE_PUBLISH; 
        hdr->mqtt_msg.qos = QOS; 
        hdr->mqtt_msg.dup = Dup ? 1 : 0; 
        hdr->mqtt_msg.retain = Retain ? 1 : 0; 
        *hdr->mqtt_len = mqtt_encodeLen(siz - sizeof(struct mqtthdr)); 
 
        return siz; 
 }  }
   
 static int  static int
 _mqtt_msgPUB_(mqtt_msg_t * __restrict buf, u_char cmd, u_short msgID)  _mqtt_msgPUB_(mqtt_msg_t * __restrict buf, u_char cmd, u_short msgID)
 {  {
        int siz = 0;        int siz = sizeof(struct mqtthdr);
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
         mqtt_len_t *v;          mqtt_len_t *v;
   
Line 127  _mqtt_msgPUB_(mqtt_msg_t * __restrict buf, u_char cmd, Line 137  _mqtt_msgPUB_(mqtt_msg_t * __restrict buf, u_char cmd,
   
         if (mqtt_msgRealloc(buf, sizeof(struct mqtthdr) + sizeof(mqtt_len_t)) == -1)          if (mqtt_msgRealloc(buf, sizeof(struct mqtthdr) + sizeof(mqtt_len_t)) == -1)
                 return -1;                  return -1;
        else {        else
                hdr = (struct mqtthdr *) (buf->msg_base + siz);                hdr = (struct mqtthdr *) buf->msg_base;
                siz += sizeof(struct mqtthdr); 
                v = (mqtt_len_t*) (buf->msg_base + siz); 
                siz += sizeof(mqtt_len_t); 
        } 
   
         /* fixed header */          /* fixed header */
         MQTTHDR_MSGINIT(hdr);          MQTTHDR_MSGINIT(hdr);
Line 140  _mqtt_msgPUB_(mqtt_msg_t * __restrict buf, u_char cmd, Line 146  _mqtt_msgPUB_(mqtt_msg_t * __restrict buf, u_char cmd,
         *hdr->mqtt_len = sizeof(mqtt_len_t);          *hdr->mqtt_len = sizeof(mqtt_len_t);
   
         /* MessageID */          /* MessageID */
           v = (mqtt_len_t*) (buf->msg_base + siz);
         v->val = htons(msgID);          v->val = htons(msgID);
           siz += sizeof(mqtt_len_t);
   
         return siz;          return siz;
 }  }
Line 207  mqtt_msgPUBCOMP(mqtt_msg_t * __restrict buf, u_short m Line 215  mqtt_msgPUBCOMP(mqtt_msg_t * __restrict buf, u_short m
  * @psTopic = Topic   * @psTopic = Topic
  * @topicLen = Topic length   * @topicLen = Topic length
  * @msgID = MessageID   * @msgID = MessageID
 * @pData = Data buffer * @pData = Data buffer, may be NULL
 * @datLen = Data buffer length, if *datLen == 0 allocate memory for pData * return: -1 error or !=-1 allocated data buffer length
 * return: NULL error or !=NULL MQTT data buffer 
  */   */
void *int
 mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * __restrict psTopic, int topicLen,   mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * __restrict psTopic, int topicLen, 
                u_short *msgID, void * __restrict pData, int *datLen)                u_short *msgID, void ** __restrict pData)
 {  {
         int len, ret;          int len, ret;
         struct mqtthdr *hdr;          struct mqtthdr *hdr;
Line 222  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _ Line 229  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _
         caddr_t pos;          caddr_t pos;
   
         if (!buf || !psTopic || !msgID)          if (!buf || !psTopic || !msgID)
                return NULL;                return -1;
   
         hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PUBLISH, &ret, &len);          hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PUBLISH, &ret, &len);
         if (!hdr)          if (!hdr)
                return NULL;                return -1;
         pos = buf->msg_base + ret + 1;          pos = buf->msg_base + ret + 1;
         var = (mqtthdr_var_t*) pos;          var = (mqtthdr_var_t*) pos;
   
Line 234  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _ Line 241  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _
         len -= MQTTHDR_VAR_SIZEOF(var);          len -= MQTTHDR_VAR_SIZEOF(var);
         if (len < 0) {          if (len < 0) {
                 mqtt_SetErr(EINVAL, "Short message length %d", len);                  mqtt_SetErr(EINVAL, "Short message length %d", len);
                return NULL;                return -1;
         } else {          } else {
                 memset(psTopic, 0, topicLen--);                  memset(psTopic, 0, topicLen--);
                 memcpy(psTopic, var->var_data, ntohs(var->var_sb.val) > topicLen ?                   memcpy(psTopic, var->var_data, ntohs(var->var_sb.val) > topicLen ? 
Line 246  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _ Line 253  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _
         len -= sizeof(mqtt_len_t);          len -= sizeof(mqtt_len_t);
         if (len < 0) {          if (len < 0) {
                 mqtt_SetErr(EINVAL, "Short message length %d", len);                  mqtt_SetErr(EINVAL, "Short message length %d", len);
                return NULL;                return -1;
         } else {          } else {
                 *msgID = ntohs(v->val);                  *msgID = ntohs(v->val);
                 pos += sizeof(mqtt_len_t);                  pos += sizeof(mqtt_len_t);
Line 255  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _ Line 262  mqtt_readPUBLISH(mqtt_msg_t * __restrict buf, char * _
         /* data */          /* data */
         if (len < 0) {          if (len < 0) {
                 mqtt_SetErr(EINVAL, "Short message length %d", len);                  mqtt_SetErr(EINVAL, "Short message length %d", len);
                return NULL;                return -1;
        } else {        } else if (pData) {
                if (!*datLen || !pData) {                if (!(*pData = malloc(len + 1))) {
                        if (!(pData = malloc(len + 1))) {                        LOGERR;
                                LOGERR;                        return -1;
                                return NULL;                } else
                        } else {                        ((char*) (*pData))[len] = 0;
                                *datLen = len; 
                                ((char*) pData)[len] = 0; 
                        } 
                } 
   
                memset(pData, 0, *datLen);                memcpy(*pData, pos, len);
                if (len < *datLen) 
                        *datLen = len; 
                memcpy(pData, pos, *datLen); 
         }          }
   
        return pData;        return len;
 }  }
   
 /*  /*
Removed from v.1.1.1.1.2.3  
changed lines
  Added in v.1.2.2.2

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