version 1.3, 2013/05/30 09:18:33
|
version 1.3.4.4, 2022/09/14 14:32:48
|
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, 2012, 2013 | Copyright 2004 - 2022 |
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 80 mqtt_SetErr(int eno, char *estr, ...)
|
Line 80 mqtt_SetErr(int eno, char *estr, ...)
|
va_end(lst); |
va_end(lst); |
} |
} |
|
|
#pragma GCC visibility push(hidden) |
|
/* _mqtt_readHEADER() read fixed header from MQTT message */ |
|
struct mqtthdr * |
|
_mqtt_readHEADER(mqtt_msg_t * __restrict buf, u_char cmd, int *bytes, int *len) |
|
{ |
|
struct mqtthdr *hdr; |
|
|
|
if (!buf || !buf->msg_base || !buf->msg_len) |
|
return NULL; |
|
|
|
hdr = (struct mqtthdr*) buf->msg_base; |
|
if (hdr->mqtt_msg.type != cmd) { |
|
mqtt_SetErr(EINVAL, "Error:: wrong command #%d should be %d", |
|
hdr->mqtt_msg.type, cmd); |
|
return NULL; |
|
} |
|
|
|
*len = mqtt_decodeLen(hdr->mqtt_len, bytes); |
|
return hdr; |
|
} |
|
#pragma GCC visibility pop |
|
|
|
|
|
/* |
/* |
* mqtt_msgFree() Free MQTT message |
* mqtt_msgFree() Free MQTT message |
* |
* |
* @msg = Message buffer |
* @msg = Message buffer |
* @all = !=0 Destroy entire message, if MQTT Message allocated with mqtt_msgAlloc() | * @keepmsg = !=0 just free message content |
* return: none |
* return: none |
*/ |
*/ |
void |
void |
mqtt_msgFree(mqtt_msg_t ** __restrict msg, int all) | mqtt_msgFree(mqtt_msg_t ** __restrict msg, int keepmsg) |
{ |
{ |
if (msg && *msg) { |
if (msg && *msg) { |
if ((*msg)->msg_base) { |
if ((*msg)->msg_base) { |
free((*msg)->msg_base); | e_free((*msg)->msg_base); |
(*msg)->msg_base = NULL; |
(*msg)->msg_base = NULL; |
} |
} |
if (all) { | if (!keepmsg) { |
free(*msg); | e_free(*msg); |
*msg = NULL; |
*msg = NULL; |
} else |
} else |
(*msg)->msg_len ^= (*msg)->msg_len; |
(*msg)->msg_len ^= (*msg)->msg_len; |
Line 133 mqtt_msgFree(mqtt_msg_t ** __restrict msg, int all)
|
Line 111 mqtt_msgFree(mqtt_msg_t ** __restrict msg, int all)
|
* return: NULL error or Message, after use must call mqtt_msgFree() with all!=0 |
* return: NULL error or Message, after use must call mqtt_msgFree() with all!=0 |
*/ |
*/ |
mqtt_msg_t * |
mqtt_msg_t * |
mqtt_msgAlloc(u_short len) | mqtt_msgAlloc(u_int len) |
{ |
{ |
mqtt_msg_t *m = NULL; |
mqtt_msg_t *m = NULL; |
|
|
m = malloc(sizeof(mqtt_msg_t)); | m = e_malloc(sizeof(mqtt_msg_t)); |
if (!m) { |
if (!m) { |
LOGERR; |
LOGERR; |
return NULL; |
return NULL; |
Line 146 mqtt_msgAlloc(u_short len)
|
Line 124 mqtt_msgAlloc(u_short len)
|
|
|
if (len) { |
if (len) { |
m->msg_len = len; |
m->msg_len = len; |
m->msg_base = malloc(m->msg_len); | m->msg_base = e_malloc(m->msg_len); |
if (!m->msg_base) { |
if (!m->msg_base) { |
LOGERR; |
LOGERR; |
free(m); | e_free(m); |
return NULL; |
return NULL; |
} else |
} else |
memset(m->msg_base, 0, m->msg_len); |
memset(m->msg_base, 0, m->msg_len); |
Line 166 mqtt_msgAlloc(u_short len)
|
Line 144 mqtt_msgAlloc(u_short len)
|
* return: -1 error or >-1 old buffer length |
* return: -1 error or >-1 old buffer length |
*/ |
*/ |
int |
int |
mqtt_msgRealloc(mqtt_msg_t * __restrict msg, u_short len) | mqtt_msgRealloc(mqtt_msg_t * __restrict msg, u_int len) |
{ |
{ |
void *p = NULL; |
void *p = NULL; |
int ret = 0; |
int ret = 0; |
Line 177 mqtt_msgRealloc(mqtt_msg_t * __restrict msg, u_short l
|
Line 155 mqtt_msgRealloc(mqtt_msg_t * __restrict msg, u_short l
|
if (len <= msg->msg_len) |
if (len <= msg->msg_len) |
return len; |
return len; |
|
|
p = realloc(msg->msg_base, len); | p = e_realloc(msg->msg_base, len); |
if (!p) { |
if (!p) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
Line 201 mqtt_msgDup(mqtt_msg_t * __restrict msg)
|
Line 179 mqtt_msgDup(mqtt_msg_t * __restrict msg)
|
{ |
{ |
mqtt_msg_t *m = NULL; |
mqtt_msg_t *m = NULL; |
|
|
m = malloc(sizeof(mqtt_msg_t)); | m = e_malloc(sizeof(mqtt_msg_t)); |
if (!m) { |
if (!m) { |
LOGERR; |
LOGERR; |
return NULL; |
return NULL; |
Line 210 mqtt_msgDup(mqtt_msg_t * __restrict msg)
|
Line 188 mqtt_msgDup(mqtt_msg_t * __restrict msg)
|
|
|
if (msg->msg_len) { |
if (msg->msg_len) { |
m->msg_len = msg->msg_len; |
m->msg_len = msg->msg_len; |
m->msg_base = malloc(m->msg_len); | m->msg_base = e_malloc(m->msg_len); |
if (!m->msg_base) { |
if (!m->msg_base) { |
LOGERR; |
LOGERR; |
free(m); | e_free(m); |
return NULL; |
return NULL; |
} else |
} else |
memcpy(m->msg_base, msg->msg_base, m->msg_len); |
memcpy(m->msg_base, msg->msg_base, m->msg_len); |
Line 234 mqtt_encodeLen(u_int num)
|
Line 212 mqtt_encodeLen(u_int num)
|
register u_int dig, i; |
register u_int dig, i; |
u_int ret = 0; |
u_int ret = 0; |
|
|
if (num > 268435455) | if (num > MQTT_DATA_MAX) |
return (u_int) -1; |
return (u_int) -1; |
|
|
for (i = 0; i < sizeof ret && num > 0; i++) { |
for (i = 0; i < sizeof ret && num > 0; i++) { |
Line 276 mqtt_decodeLen(void * __restrict len, int * __restrict
|
Line 254 mqtt_decodeLen(void * __restrict len, int * __restrict
|
|
|
if (n) |
if (n) |
*n = (char) (i & 0x7f) + 1; |
*n = (char) (i & 0x7f) + 1; |
|
|
return ret; |
return ret; |
} |
} |
|
|
Line 325 mqtt_pktLen(struct mqtthdr * __restrict hdr)
|
Line 304 mqtt_pktLen(struct mqtthdr * __restrict hdr)
|
* mqtt_str2subs Create MQTT subscribe variable from string(s) |
* mqtt_str2subs Create MQTT subscribe variable from string(s) |
* |
* |
* @csStr = null terminated string array |
* @csStr = null terminated string array |
* @strnum = copy at most number of strings elements | * @strnum = copy at most number of strings elements, ==0 till NULL element |
* @qoses = QoS elements applied to subscribe variable, |
* @qoses = QoS elements applied to subscribe variable, |
* count of elements must be equal with csStr elements |
* count of elements must be equal with csStr elements |
* return: NULL error or != subscribe variables array, must be free after use with mqtt_freeSub() |
* return: NULL error or != subscribe variables array, must be free after use with mqtt_freeSub() |
*/ |
*/ |
mqtt_subscr_t * |
mqtt_subscr_t * |
mqtt_str2subs(const char **csStr, u_short strnum, u_char *qoses) | mqtt_strs2subs(const char **csStr, u_short strnum, u_char *qoses) |
{ |
{ |
mqtt_subscr_t *v; |
mqtt_subscr_t *v; |
register int i, items; |
register int i, items; |
Line 344 mqtt_str2subs(const char **csStr, u_short strnum, u_ch
|
Line 323 mqtt_str2subs(const char **csStr, u_short strnum, u_ch
|
(!strnum || (strnum && items < strnum)) && *strs; |
(!strnum || (strnum && items < strnum)) && *strs; |
items++, strs++); |
items++, strs++); |
|
|
if (!(v = malloc((items + 1) * sizeof(mqtt_subscr_t)))) { | if (!(v = e_malloc((items + 1) * sizeof(mqtt_subscr_t)))) { |
LOGERR; |
LOGERR; |
return NULL; |
return NULL; |
} else |
} else |
Line 352 mqtt_str2subs(const char **csStr, u_short strnum, u_ch
|
Line 331 mqtt_str2subs(const char **csStr, u_short strnum, u_ch
|
|
|
for (i = 0; i < items; i++) { |
for (i = 0; i < items; i++) { |
v[i].sub_topic.msg_len = strlen(csStr[i]); |
v[i].sub_topic.msg_len = strlen(csStr[i]); |
v[i].sub_topic.msg_base = (u_char*) strdup(csStr[i]); | v[i].sub_topic.msg_base = (u_char*) e_strdup(csStr[i]); |
if (qoses && qoses[i] < MQTT_QOS_RESERVED) |
if (qoses && qoses[i] < MQTT_QOS_RESERVED) |
v[i].sub_ret = qoses[i]; |
v[i].sub_ret = qoses[i]; |
} |
} |
Line 375 mqtt_subFree(mqtt_subscr_t ** __restrict subs)
|
Line 354 mqtt_subFree(mqtt_subscr_t ** __restrict subs)
|
return; |
return; |
|
|
for (v = *subs; v->sub_topic.msg_base; v++) { |
for (v = *subs; v->sub_topic.msg_base; v++) { |
free(v->sub_topic.msg_base); | e_free(v->sub_topic.msg_base); |
v->sub_topic.msg_base = NULL; |
v->sub_topic.msg_base = NULL; |
v->sub_topic.msg_len = 0; |
v->sub_topic.msg_len = 0; |
|
|
if (v->sub_value.msg_base) { |
if (v->sub_value.msg_base) { |
free(v->sub_value.msg_base); | e_free(v->sub_value.msg_base); |
v->sub_value.msg_base = NULL; |
v->sub_value.msg_base = NULL; |
v->sub_value.msg_len = 0; |
v->sub_value.msg_len = 0; |
} |
} |
} |
} |
|
|
free(*subs); | e_free(*subs); |
*subs = NULL; |
*subs = NULL; |
} |
} |
|
|
Line 401 mqtt_subAlloc(u_short num)
|
Line 380 mqtt_subAlloc(u_short num)
|
{ |
{ |
mqtt_subscr_t *s = NULL; |
mqtt_subscr_t *s = NULL; |
|
|
s = malloc((num + 1) * sizeof(mqtt_subscr_t)); | s = e_malloc((num + 1) * sizeof(mqtt_subscr_t)); |
if (!s) { |
if (!s) { |
LOGERR; |
LOGERR; |
return NULL; |
return NULL; |
Line 421 mqtt_subAlloc(u_short num)
|
Line 400 mqtt_subAlloc(u_short num)
|
mqtt_subscr_t * |
mqtt_subscr_t * |
mqtt_subRealloc(mqtt_subscr_t ** __restrict subs, u_short num) |
mqtt_subRealloc(mqtt_subscr_t ** __restrict subs, u_short num) |
{ |
{ |
mqtt_subscr_t *s = NULL; | mqtt_subscr_t *ss, *s = NULL; |
| register int i; |
|
|
if (!subs) |
if (!subs) |
return NULL; |
return NULL; |
|
|
s = realloc(*subs, (num + 1) * sizeof(mqtt_subscr_t)); | for (i = 0, ss = *subs; ss; i++, ss++); |
| if (i < num) |
| return NULL; |
| if (i == num) |
| return *subs; |
| |
| s = e_realloc(*subs, (num + 1) * sizeof(mqtt_subscr_t)); |
if (!s) { |
if (!s) { |
LOGERR; |
LOGERR; |
return NULL; |
return NULL; |
Line 452 mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
|
Line 438 mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
|
return NULL; |
return NULL; |
|
|
if (src->sub_topic.msg_base) { |
if (src->sub_topic.msg_base) { |
dst->sub_topic.msg_base = malloc(src->sub_topic.msg_len + 1); | dst->sub_topic.msg_base = e_malloc(src->sub_topic.msg_len + 1); |
if (!dst->sub_topic.msg_base) { |
if (!dst->sub_topic.msg_base) { |
LOGERR; |
LOGERR; |
memset(dst, 0, sizeof(mqtt_subscr_t)); |
memset(dst, 0, sizeof(mqtt_subscr_t)); |
Line 464 mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
|
Line 450 mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
|
dst->sub_topic.msg_len); |
dst->sub_topic.msg_len); |
} |
} |
} else { |
} else { |
/* |
|
if (dst->sub_topic.msg_base) |
|
free(dst->sub_topic.msg_base); |
|
*/ |
|
dst->sub_topic.msg_base = NULL; |
dst->sub_topic.msg_base = NULL; |
dst->sub_topic.msg_len = 0; |
dst->sub_topic.msg_len = 0; |
} |
} |
|
|
if (src->sub_value.msg_base) { |
if (src->sub_value.msg_base) { |
dst->sub_value.msg_base = malloc(src->sub_value.msg_len + 1); | dst->sub_value.msg_base = e_malloc(src->sub_value.msg_len + 1); |
if (!dst->sub_value.msg_base) { |
if (!dst->sub_value.msg_base) { |
LOGERR; |
LOGERR; |
if (dst->sub_topic.msg_base) |
if (dst->sub_topic.msg_base) |
free(dst->sub_topic.msg_base); | e_free(dst->sub_topic.msg_base); |
memset(dst, 0, sizeof(mqtt_subscr_t)); |
memset(dst, 0, sizeof(mqtt_subscr_t)); |
return NULL; |
return NULL; |
} else { |
} else { |
Line 486 mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
|
Line 469 mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subs
|
dst->sub_value.msg_len); |
dst->sub_value.msg_len); |
} |
} |
} else { |
} else { |
/* |
|
if (dst->sub_value.msg_base) |
|
free(dst->sub_value.msg_base); |
|
*/ |
|
dst->sub_value.msg_base = NULL; |
dst->sub_value.msg_base = NULL; |
dst->sub_value.msg_len = 0; |
dst->sub_value.msg_len = 0; |
} |
} |