Return to pub.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / mqtt / src

Annotation of mqtt/src/pub.c, revision 1.1.2.4

1.1.2.1   misho       1: #include "global.h"
                      2: 
                      3: 
                      4: /* ------------------------------------------------------------------- */
                      5: 
1.1.2.2   misho       6: /*
                      7:  * mqtt_msgPUBLISH() Create PUBLISH message
                      8:  *
                      9:  * @buf = Message buffer
                     10:  * @csTopic = Publish topic
                     11:  * @msgID = MessageID >0, if QOS != MQTT_QOS_ONCE
                     12:  * @Dup = Duplicate message
                     13:  * @QOS = QoS
1.1.2.4 ! misho      14:  * @Retain = Retain message
1.1.2.2   misho      15:  * return: -1 error or >-1 message size for send
                     16:  */
                     17: int
                     18: mqtt_msgPUBLISH(mqtt_msg_t * __restrict buf, const char *csTopic, u_short msgID, 
1.1.2.4 ! misho      19:                u_char Dup, u_char QOS, u_char Retain)
1.1.2.2   misho      20: {
                     21:        int siz = 0;
                     22:        struct mqtthdr *hdr;
                     23:        mqtthdr_var_t *topic;
                     24:        mqtt_v_t *mid;
                     25: 
                     26:        if (!buf || !csTopic)
                     27:                return -1;
                     28:        if (QOS > MQTT_QOS_EXACTLY) {
                     29:                mqtt_SetErr(EINVAL, "Error:: invalid QoS parameter");
                     30:                return -1;
                     31:        }
                     32:        if (!msgID && QOS != MQTT_QOS_ONCE) {
                     33:                mqtt_SetErr(EINVAL, "Error:: invalid MessageID parameter must be >0");
                     34:                return -1;
                     35:        }
                     36: 
                     37:        if (mqtt_msgRealloc(buf, MQTTMSG_MAX) == -1)
                     38:                return -1;
                     39:        else {
                     40:                hdr = (struct mqtthdr *) (buf->msg_base + siz);
                     41:                siz += sizeof(struct mqtthdr);
                     42:        }
                     43: 
                     44:        /* variable header */
                     45: 
                     46:        topic = (mqtthdr_var_t*) (buf->msg_base + siz);
                     47:        topic->var_sb.val = htons(strlen(csTopic));
                     48:        memcpy(topic->var_data, csTopic, ntohs(topic->var_sb.val));
                     49:        siz += MQTTHDR_VAR_SIZEOF(topic);
                     50: 
                     51:        mid = (mqtt_v_t*) (buf->msg_base + siz);
                     52:        mid->val = htons(msgID);
                     53:        siz += sizeof(mqtt_v_t);
                     54: 
                     55:        /* fixed header */
                     56: 
                     57:        hdr->mqtt_msg.type = MQTT_TYPE_PUBLISH;
                     58:        hdr->mqtt_msg.qos = QOS;
                     59:        hdr->mqtt_msg.dup = Dup ? 1 : 0;
1.1.2.4 ! misho      60:        hdr->mqtt_msg.retain = Retain ? 1 : 0;
1.1.2.2   misho      61:        *hdr->mqtt_len = mqtt_encodeLen(siz - sizeof(struct mqtthdr));
                     62: 
                     63:        mqtt_msgRealloc(buf, siz);
                     64:        return siz;
                     65: }
                     66: 
                     67: static int
                     68: _mqtt_msgPUB_(mqtt_msg_t * __restrict buf, u_char cmd, u_short msgID)
                     69: {
                     70:        int siz = 0;
                     71:        struct mqtthdr *hdr;
                     72:        mqtt_v_t *v;
                     73: 
                     74:        if (!buf)
                     75:                return -1;
                     76: 
                     77:        if (mqtt_msgRealloc(buf, sizeof(struct mqtthdr) + sizeof(mqtt_v_t)) == -1)
                     78:                return -1;
                     79:        else {
                     80:                hdr = (struct mqtthdr *) (buf->msg_base + siz);
                     81:                siz += sizeof(struct mqtthdr);
                     82:                v = (mqtt_v_t*) (buf->msg_base + siz);
                     83:                siz += sizeof(mqtt_v_t);
                     84:        }
                     85: 
                     86:        /* fixed header */
                     87:        hdr->mqtt_msg.type = cmd;
                     88:        *hdr->mqtt_len = sizeof(mqtt_v_t);
                     89: 
                     90:        /* MessageID */
                     91:        v->val = htons(msgID);
                     92: 
                     93:        return siz;
                     94: }
                     95: 
                     96: /*
                     97:  * mqtt_msgPUBACK() Create PUBACK message
                     98:  *
                     99:  * @buf = Message buffer
                    100:  * @msgID = MessageID
                    101:  * return: -1 error or >-1 message size for send
                    102:  */
                    103: inline int
                    104: mqtt_msgPUBACK(mqtt_msg_t * __restrict buf, u_short msgID)
                    105: {
                    106:        return _mqtt_msgPUB_(buf, MQTT_TYPE_PUBACK, msgID);
                    107: }
                    108: 
                    109: /*
                    110:  * mqtt_msgPUBREC() Create PUBREC message
                    111:  *
                    112:  * @buf = Message buffer
                    113:  * @msgID = MessageID
                    114:  * return: -1 error or >-1 message size for send
                    115:  */
                    116: inline int
                    117: mqtt_msgPUBREC(mqtt_msg_t * __restrict buf, u_short msgID)
                    118: {
                    119:        return _mqtt_msgPUB_(buf, MQTT_TYPE_PUBREC, msgID);
                    120: }
                    121: 
                    122: /*
                    123:  * mqtt_msgPUBREL() Create PUBREL message
                    124:  *
                    125:  * @buf = Message buffer
                    126:  * @msgID = MessageID
                    127:  * return: -1 error or >-1 message size for send
                    128:  */
                    129: inline int
                    130: mqtt_msgPUBREL(mqtt_msg_t * __restrict buf, u_short msgID)
                    131: {
                    132:        return _mqtt_msgPUB_(buf, MQTT_TYPE_PUBREL, msgID);
                    133: }
                    134: 
                    135: /*
                    136:  * mqtt_msgPUBCOMP() Create PUBCOMP message
                    137:  *
                    138:  * @buf = Message buffer
                    139:  * @msgID = MessageID
                    140:  * return: -1 error or >-1 message size for send
                    141:  */
                    142: inline int
                    143: mqtt_msgPUBCOMP(mqtt_msg_t * __restrict buf, u_short msgID)
                    144: {
                    145:        return _mqtt_msgPUB_(buf, MQTT_TYPE_PUBCOMP, msgID);
                    146: }