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, 2011 | Copyright 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; |
} |
} |
|
|