1: /*************************************************************************
2: * (C) 2011 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
6: * $Id: aitmqtt.c,v 1.3.4.6 2022/09/16 04:14:03 misho Exp $
7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004 - 2022
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: #pragma GCC visibility push(hidden)
50:
51: int mqtt_Errno;
52: char mqtt_Error[STRSIZ];
53:
54: #pragma GCC visibility pop
55:
56: // mqtt_GetErrno() Get error code of last operation
57: int
58: mqtt_GetErrno()
59: {
60: return mqtt_Errno;
61: }
62:
63: // mqtt_GetError() Get error text of last operation
64: const char *
65: mqtt_GetError()
66: {
67: return mqtt_Error;
68: }
69:
70: // mqtt_SetErr() Set error to variables for internal use!!!
71: void
72: mqtt_SetErr(int eno, char *estr, ...)
73: {
74: va_list lst;
75:
76: mqtt_Errno = eno;
77: memset(mqtt_Error, 0, sizeof mqtt_Error);
78: va_start(lst, estr);
79: vsnprintf(mqtt_Error, sizeof mqtt_Error, estr, lst);
80: va_end(lst);
81: }
82:
83:
84: /*
85: * mqtt_msgFree() Free MQTT message
86: *
87: * @msg = Message buffer
88: * @keepmsg = !=0 just free message content
89: * return: none
90: */
91: void
92: mqtt_msgFree(mqtt_msg_t ** __restrict msg, int keepmsg)
93: {
94: if (msg && *msg) {
95: if ((*msg)->msg_base) {
96: e_free((*msg)->msg_base);
97: (*msg)->msg_base = NULL;
98: }
99: if (!keepmsg) {
100: e_free(*msg);
101: *msg = NULL;
102: } else
103: (*msg)->msg_len ^= (*msg)->msg_len;
104: }
105: }
106:
107: /*
108: * mqtt_msgAlloc() Allocate memory for MQTT Message
109: *
110: * @len = >0 Allocate buffer with length
111: * return: NULL error or Message, after use must call mqtt_msgFree() with all!=0
112: */
113: mqtt_msg_t *
114: mqtt_msgAlloc(u_int len)
115: {
116: mqtt_msg_t *m = NULL;
117:
118: m = e_malloc(sizeof(mqtt_msg_t));
119: if (!m) {
120: LOGERR;
121: return NULL;
122: } else
123: memset(m, 0, sizeof(mqtt_msg_t));
124:
125: if (len) {
126: m->msg_len = len;
127: m->msg_base = e_malloc(m->msg_len);
128: if (!m->msg_base) {
129: LOGERR;
130: e_free(m);
131: return NULL;
132: } else
133: memset(m->msg_base, 0, m->msg_len);
134: }
135:
136: return m;
137: }
138:
139: /*
140: * mqtt_msgRealloc() Reallocate MQTT message buffer
141: *
142: * @msg = MQTT message
143: * @len = new length
144: * return: -1 error or >-1 old buffer length
145: */
146: int
147: mqtt_msgRealloc(mqtt_msg_t * __restrict msg, u_int len)
148: {
149: void *p = NULL;
150: int ret = 0;
151:
152: if (!msg)
153: return -1;
154:
155: if (len <= msg->msg_len)
156: return len;
157:
158: p = e_realloc(msg->msg_base, len);
159: if (!p) {
160: LOGERR;
161: return -1;
162: }
163:
164: ret = msg->msg_len;
165: msg->msg_len = len;
166: msg->msg_base = p;
167:
168: return ret;
169: }
170:
171: /*
172: * mqtt_msgDup() - Duplicate message buffer
173: *
174: * @msg = Message
175: * return: NULL error or !=NULL duplicated message, after use must call mqtt_msgFree() with all!=0
176: */
177: mqtt_msg_t *
178: mqtt_msgDup(mqtt_msg_t * __restrict msg)
179: {
180: mqtt_msg_t *m = NULL;
181:
182: m = e_malloc(sizeof(mqtt_msg_t));
183: if (!m) {
184: LOGERR;
185: return NULL;
186: } else
187: memset(m, 0, sizeof(mqtt_msg_t));
188:
189: if (msg->msg_len) {
190: m->msg_len = msg->msg_len;
191: m->msg_base = e_malloc(m->msg_len);
192: if (!m->msg_base) {
193: LOGERR;
194: e_free(m);
195: return NULL;
196: } else
197: memcpy(m->msg_base, msg->msg_base, m->msg_len);
198: }
199:
200: return m;
201: }
202:
203: /*
204: * mqtt_encodeLen() Encode number to MQTT length field
205: *
206: * @num = number for encode
207: * return: -1 error or >-1 length
208: */
209: u_int
210: mqtt_encodeLen(u_int num)
211: {
212: register u_int dig, i;
213: u_int ret = 0;
214:
215: if (num > MQTT_DATA_MAX)
216: return (u_int) -1;
217:
218: for (i = 0; i < sizeof ret && num > 0; i++) {
219: dig = num % 0x80;
220: num /= 0x80;
221: if (num > 0)
222: dig |= 0x80;
223:
224: *((u_char*) &ret + i) = (u_char) dig;
225: }
226:
227: return ret;
228: }
229:
230: /*
231: * mqtt_decodeLen() Decode length from MQTT packet
232: *
233: * @len = length from MQTT header
234: * @n = sizeof bytes, if !=NULL
235: * return: -1 error, >-1 length of message
236: */
237: u_int
238: mqtt_decodeLen(void * __restrict len, int * __restrict n)
239: {
240: register u_int i, dig, mul;
241: u_int ret = 0;
242: u_char *p = (u_char*) len;
243:
244: if (!len)
245: return (u_int) -1;
246:
247: for (mul = 1, i = 0; i < sizeof ret; i++, mul *= 0x80) {
248: dig = p[i];
249: ret += (dig & 0x7f) * mul;
250:
251: if (!(dig & 0x80))
252: break;
253: }
254:
255: if (n)
256: *n = (char) (i & 0x7f) + 1;
257:
258: return ret;
259: }
260:
261: /*
262: * mqtt_sizeLen Return sizeof len field
263: *
264: * @len = length
265: * return: -1 error, >-1 sizeof len in bytes
266: */
267: char
268: mqtt_sizeLen(u_int len)
269: {
270: register char i;
271: u_char *p = (u_char*) &len;
272:
273: if (len > 0xffffff7f)
274: return -1;
275:
276: for (i = 0; i < sizeof len; i++)
277: if (!(*(p + i) & 0x80))
278: break;
279:
280: return ++i;
281: }
282:
283: /*
284: * mqtt_pktLen() - Get total packet length
285: *
286: * @hdr = MQTT packet header
287: * return: packet length
288: */
289: u_int
290: mqtt_pktLen(struct mqtthdr * __restrict hdr)
291: {
292: int siz, n = 0;
293:
294: if (!hdr)
295: return 0;
296:
297: siz = mqtt_decodeLen(hdr->mqtt_len, &n);
298: siz += sizeof(struct mqtthdr) + n - 1;
299:
300: return siz;
301: }
302:
303: /*
304: * mqtt_str2subs Create MQTT subscribe variable from string(s)
305: *
306: * @csStr = null terminated string array
307: * @strnum = copy at most number of strings elements, ==0 till NULL element
308: * @qoses = QoS elements applied to subscribe variable,
309: * count of elements must be equal with csStr elements
310: * return: NULL error or != subscribe variables array, must be free after use with mqtt_freeSub()
311: */
312: mqtt_subscr_t *
313: mqtt_strs2subs(const char **csStr, u_short strnum, u_char *qoses)
314: {
315: mqtt_subscr_t *v;
316: register int i, items;
317: const char **strs;
318:
319: if (!csStr)
320: return NULL;
321:
322: for (items = 0, strs = csStr;
323: (!strnum || (strnum && items < strnum)) && *strs;
324: items++, strs++);
325:
326: if (!(v = e_malloc((items + 1) * sizeof(mqtt_subscr_t)))) {
327: LOGERR;
328: return NULL;
329: } else
330: memset(v, 0, (items + 1) * sizeof(mqtt_subscr_t));
331:
332: for (i = 0; i < items; i++) {
333: v[i].sub_topic.msg_len = strlen(csStr[i]);
334: v[i].sub_topic.msg_base = (u_char*) e_strdup(csStr[i]);
335: if (qoses && qoses[i] < MQTT_QOS_RESERVED)
336: v[i].sub_qos = qoses[i];
337: }
338:
339: return v;
340: }
341:
342: /*
343: * mqtt_subFree() Free array from subscribe variables
344: *
345: * @subs = Subscribe variables
346: * return: none
347: */
348: void
349: mqtt_subFree(mqtt_subscr_t ** __restrict subs)
350: {
351: mqtt_subscr_t *v;
352:
353: if (!subs)
354: return;
355:
356: for (v = *subs; v->sub_topic.msg_base; v++) {
357: e_free(v->sub_topic.msg_base);
358: v->sub_topic.msg_base = NULL;
359: v->sub_topic.msg_len = 0;
360:
361: if (v->sub_value.msg_base) {
362: e_free(v->sub_value.msg_base);
363: v->sub_value.msg_base = NULL;
364: v->sub_value.msg_len = 0;
365: }
366: }
367:
368: e_free(*subs);
369: *subs = NULL;
370: }
371:
372: /*
373: * mqtt_subAlloc() Create array from subscribe variables
374: *
375: * @num = Number of elements
376: * return: NULL error or subscribe array, after use must call mqtt_subFree()
377: */
378: mqtt_subscr_t *
379: mqtt_subAlloc(u_short num)
380: {
381: mqtt_subscr_t *s = NULL;
382:
383: s = e_malloc((num + 1) * sizeof(mqtt_subscr_t));
384: if (!s) {
385: LOGERR;
386: return NULL;
387: } else
388: memset(s, 0, (num + 1) * sizeof(mqtt_subscr_t));
389:
390: return s;
391: }
392:
393: /*
394: * mqtt_subRealloc() Reallocate array from subscribe variables
395: *
396: * @subs = Subscribe array
397: * @num = Number of elements
398: * return: NULL error or subscribe array, after use must call mqtt_subFree()
399: */
400: mqtt_subscr_t *
401: mqtt_subRealloc(mqtt_subscr_t ** __restrict subs, u_short num)
402: {
403: mqtt_subscr_t *ss, *s = NULL;
404: register int i;
405:
406: if (!subs)
407: return NULL;
408:
409: for (i = 0, ss = *subs; ss; i++, ss++);
410: if (i == num)
411: return *subs;
412:
413: s = e_realloc(*subs, (num + 1) * sizeof(mqtt_subscr_t));
414: if (!s) {
415: LOGERR;
416: return NULL;
417: } else {
418: memset(s + num, 0, sizeof(mqtt_subscr_t));
419: *subs = s;
420: }
421:
422: return *subs;
423: }
424:
425: /*
426: * mqtt_subCopy() - Copy subscription structure to another one
427: *
428: * @dst = destination subscription
429: * @src = source subscription
430: * return: =NULL error or !=NULL successful copied a structure
431: */
432: mqtt_subscr_t *
433: mqtt_subCopy(mqtt_subscr_t * __restrict dst, mqtt_subscr_t * __restrict src)
434: {
435: if (!dst || !src)
436: return NULL;
437:
438: if (src->sub_topic.msg_base) {
439: dst->sub_topic.msg_base = e_malloc(src->sub_topic.msg_len + 1);
440: if (!dst->sub_topic.msg_base) {
441: LOGERR;
442: memset(dst, 0, sizeof(mqtt_subscr_t));
443: return NULL;
444: } else {
445: dst->sub_topic.msg_len = src->sub_topic.msg_len;
446: ((char*) dst->sub_topic.msg_base)[dst->sub_topic.msg_len] = 0;
447: memcpy(dst->sub_topic.msg_base, src->sub_topic.msg_base,
448: dst->sub_topic.msg_len);
449: }
450: } else {
451: dst->sub_topic.msg_base = NULL;
452: dst->sub_topic.msg_len = 0;
453: }
454:
455: if (src->sub_value.msg_base) {
456: dst->sub_value.msg_base = e_malloc(src->sub_value.msg_len + 1);
457: if (!dst->sub_value.msg_base) {
458: LOGERR;
459: if (dst->sub_topic.msg_base)
460: e_free(dst->sub_topic.msg_base);
461: memset(dst, 0, sizeof(mqtt_subscr_t));
462: return NULL;
463: } else {
464: dst->sub_value.msg_len = src->sub_value.msg_len;
465: ((char*) dst->sub_value.msg_base)[dst->sub_value.msg_len] = 0;
466: memcpy(dst->sub_value.msg_base, src->sub_value.msg_base,
467: dst->sub_value.msg_len);
468: }
469: } else {
470: dst->sub_value.msg_base = NULL;
471: dst->sub_value.msg_len = 0;
472: }
473:
474: dst->sub_qos = src->sub_qos;
475: return dst;
476: }
477:
478:
479: /*
480: * mqtt_expandTopic() - Expanding topic to regular expression
481: *
482: * @csInput = Input topic
483: * @psRegEx = Output to regular expression
484: * @regexLen = Length of psRegEx
485: * @BOL = Begin of Line, if =0 not added
486: * @EOL = End of Line, if =0 not appended
487: * return: -1 error, 0 nothing expanded or >0 expanded bytes
488: */
489: int
490: mqtt_expandTopic(const char *csInput, char * __restrict psRegEx, int regexLen, u_char BOL, u_char EOL)
491: {
492: int ret = 0;
493: register int i;
494: char *pos, *s;
495: const char reROM[] = "[](){}^$\\-|?.+*";
496:
497: if (!csInput || !psRegEx || regexLen < 1)
498: return -1;
499: else
500: memset(psRegEx, 0, regexLen);
501:
502: /* check # */
503: for (i = 0, pos = (char*) csInput; *pos && i < 2; pos++)
504: if (*pos == '#')
505: i++;
506: if (i == 2) {
507: mqtt_SetErr(EINVAL, "Syntax error, multiple occurrences of #..#");
508: return -1;
509: }
510: if (i == 1 && (pos = strrchr(csInput, '#')))
511: if ((pos != csInput && *(pos - 1) != '/') || *(pos + 1)) {
512: mqtt_SetErr(EINVAL, "Syntax error, bad format of #");
513: return -1;
514: }
515: /* check + */
516: for (pos = (char*) csInput; *pos && (pos = strchr(pos, '+')); pos++)
517: if ((pos != csInput && *(pos - 1) != '/') || (*(pos + 1) && *(pos + 1) != '/')) {
518: mqtt_SetErr(EINVAL, "Syntax error, bad format of +");
519: return -1;
520: }
521:
522: /* BUILD REGEX */
523: s = psRegEx;
524: if (BOL) {
525: *s++ = '^';
526: ret++;
527: }
528: for (pos = (char*) csInput; s < psRegEx + regexLen && *pos; s++, pos++) {
529: if (*pos == '#') {
530: strlcat(s, ".*", regexLen - (s - psRegEx));
531: s++;
532: ret++;
533: break;
534: }
535: if (*pos == '+') {
536: if (*(pos + 1)) {
537: strlcat(s, ".*", regexLen - (s - psRegEx));
538: s++;
539: ret++;
540: continue;
541: } else {
542: strlcat(s, ".*/", regexLen - (s - psRegEx));
543: ret += 2;
544: break;
545: }
546: }
547: for (i = 0; i < sizeof reROM - 1; i++)
548: if (*pos == reROM[i] && regexLen - (s - psRegEx) - 1 > 0) {
549: *s++ = '\\';
550: ret++;
551: break;
552: }
553:
554: *s = *pos;
555: }
556: if (EOL) {
557: strlcat(psRegEx, "$", regexLen);
558: ret++;
559: }
560:
561: return ret;
562: }
563:
564: /*
565: * mqtt_sqlTopic() - Expanding topic to SQL search string
566: *
567: * @csInput = Input topic
568: * @psSQL = Output to SQL search string
569: * @sqlLen = Length of psSQL
570: * return: -1 error, 0 changed bytes
571: */
572: int
573: mqtt_sqlTopic(const char *csInput, char * __restrict psSQL, int sqlLen)
574: {
575: int ret = 0;
576: register int i;
577: char *pos, *s;
578:
579: if (!csInput || !psSQL || sqlLen < 1)
580: return -1;
581: else
582: memset(psSQL, 0, sqlLen);
583:
584: /* check # */
585: for (i = 0, pos = (char*) csInput; *pos && i < 2; pos++)
586: if (*pos == '#')
587: i++;
588: if (i == 2) {
589: mqtt_SetErr(EINVAL, "Syntax error, multiple occurrences of #..#");
590: return -1;
591: }
592: if (i == 1 && (pos = strrchr(csInput, '#')))
593: if ((pos != csInput && *(pos - 1) != '/') || *(pos + 1)) {
594: mqtt_SetErr(EINVAL, "Syntax error, bad format of #");
595: return -1;
596: }
597: /* check + */
598: for (pos = (char*) csInput; *pos && (pos = strchr(pos, '+')); pos++)
599: if ((pos != csInput && *(pos - 1) != '/') || (*(pos + 1) && *(pos + 1) != '/')) {
600: mqtt_SetErr(EINVAL, "Syntax error, bad format of +");
601: return -1;
602: }
603:
604: /* BUILD SEARCH STRING */
605: s = psSQL;
606: for (pos = (char*) csInput; s < psSQL + sqlLen && *pos; s++, pos++) {
607: if (*pos == '#') {
608: *s = '%';
609: s++;
610: ret++;
611: break;
612: }
613: if (*pos == '+') {
614: if (*(pos + 1)) {
615: *s = '%';
616: ret++;
617: continue;
618: } else {
619: strlcat(s, "%/", sqlLen - (s - psSQL));
620: ret += 2;
621: break;
622: }
623: }
624: /*
625: for (i = 0; i < sizeof reROM - 1; i++)
626: if (*pos == reROM[i] && regexLen - (s - psRegEx) - 1 > 0) {
627: *s++ = '\\';
628: ret++;
629: break;
630: }
631: */
632:
633: *s = *pos;
634: }
635:
636: return ret;
637: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aitmqtt.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitmqtt / src