1: #include "global.h"
2:
3:
4: /* ------------------------------------------------------------------- */
5:
6: /*
7: * mqtt_msgCONNECT() Create CONNECT message
8: *
9: * @buf = Message buffer
10: * @csConnID = ConnectID
11: * @csUser = Username if !=NULL
12: * @csPass = Password for Username, only if csUser is set
13: * @csWillTopic = Will Topic if !=NULL Will Flags set into message
14: * @csWillMessage = Will Message, may be NULL
15: * @ClrSess = Clear Session subscriptions after disconnect
16: * @WillQOS = Will QOS if csWillTopic is set
17: * @WillRetain = Will Retain Will Message if csWillTopic is set
18: * return: -1 error or >-1 message size for send
19: */
20: int
21: mqtt_msgCONNECT(mqtt_msg_t * __restrict buf, const char *csConnID,
22: const char *csUser, const char *csPass,
23: const char *csWillTopic, const char *csWillMessage,
24: u_char ClrSess, u_char WillQOS, u_char WillRetain)
25: {
26: int siz = 0;
27: struct mqtthdr *hdr;
28: mqtthdr_var_t *var, *cid, *topic, *wmsg, *user, *pass;
29: mqtthdr_protover_t *proto;
30: mqtthdr_connflgs_t *flags;
31: mqtt_v_t *ka;
32:
33: if (!buf || !csConnID)
34: return -1;
35: if (strlen(csConnID) > 24) {
36: mqtt_SetErr(EINVAL, "Error:: invalid argument ConnID is too long (max 23 bytes)");
37: return -1;
38: }
39: if (csUser && strlen(csUser) > 13) {
40: mqtt_SetErr(EINVAL, "Error:: invalid argument Username is too long (max 12 bytes)");
41: return -1;
42: }
43: if (csPass && strlen(csPass) > 13) {
44: mqtt_SetErr(EINVAL, "Error:: invalid argument Password is too long (max 12 bytes)");
45: return -1;
46: }
47: if (WillQOS > MQTT_QOS_EXACTLY) {
48: mqtt_SetErr(EINVAL, "Error:: invalid argument WillQOS - unknown QOS value");
49: return -1;
50: }
51:
52: if (mqtt_msgRealloc(buf, BUFSIZ) == -1)
53: return -1;
54: else {
55: hdr = (struct mqtthdr *) (buf->msg_base + siz);
56: siz += sizeof(struct mqtthdr);
57: var = (mqtthdr_var_t*) (buf->msg_base + siz);
58: siz += 8;
59: proto = buf->msg_base + siz;
60: siz++;
61: flags = (mqtthdr_connflgs_t*) (buf->msg_base + siz);
62: siz++;
63: ka = (mqtt_v_t*) (buf->msg_base + siz);
64: siz += sizeof(mqtt_v_t);
65: }
66:
67: /* fixed header */
68: MQTTHDR_MSGINIT(hdr);
69: hdr->mqtt_msg.type = MQTT_TYPE_CONNECT;
70: *hdr->mqtt_len = 0;
71:
72: /* variable header */
73: var->var_sb.sb.l = 6;
74: memcpy(var->var_data, MQTT_CONN_STR, 6);
75:
76: *proto = MQTT_PROTO_VER;
77:
78: /* CONNECT header */
79: flags->clean_sess = ClrSess ? 1 : 0;
80: if (csUser) {
81: flags->username = 1;
82: flags->password = csPass ? 1 : 0;
83: } else {
84: flags->username = 0;
85: flags->password = 0;
86: }
87: if (csWillTopic) {
88: flags->will_flg = 1;
89: flags->will_qos = WillQOS;
90: flags->will_retain = WillRetain ? 1 : 0;
91: } else {
92: flags->will_flg = 0;
93: flags->will_qos = 0;
94: flags->will_retain = 0;
95: }
96:
97: ka->sb.l = MQTT_KEEPALIVE;
98:
99: /* ConnID */
100: cid = (mqtthdr_var_t*) (buf->msg_base + siz);
101: cid->var_sb.val = htons(strlen(csConnID));
102: siz += MQTTHDR_VAR_SIZEOF(cid);
103: memcpy(cid->var_data, csConnID, ntohs(cid->var_sb.val));
104:
105: /* If Will Flags setup */
106: if (csWillTopic) {
107: topic = (mqtthdr_var_t*) (buf->msg_base + siz);
108: topic->var_sb.val = htons(strlen(csWillTopic));
109: memcpy(topic->var_data, csWillTopic, ntohs(topic->var_sb.val));
110: siz += MQTTHDR_VAR_SIZEOF(topic);
111:
112: wmsg = (mqtthdr_var_t*) (buf->msg_base + siz);
113: if (csWillMessage) {
114: wmsg->var_sb.val = htons(strlen(csWillMessage));
115: memcpy(wmsg->var_data, csWillMessage, ntohs(wmsg->var_sb.val));
116: } else
117: wmsg->var_sb.val = 0;
118: siz += MQTTHDR_VAR_SIZEOF(wmsg);
119: }
120:
121: /* If defined Username & Password */
122: if (csUser) {
123: user = (mqtthdr_var_t*) (buf->msg_base + siz);
124: user->var_sb.val = htons(strlen(csUser));
125: memcpy(user->var_data, csUser, ntohs(user->var_sb.val));
126: siz += MQTTHDR_VAR_SIZEOF(user);
127:
128: if (csPass) {
129: pass = (mqtthdr_var_t*) (buf->msg_base + siz);
130: pass->var_sb.val = htons(strlen(csPass));
131: memcpy(pass->var_data, csPass, ntohs(pass->var_sb.val));
132: siz += MQTTHDR_VAR_SIZEOF(pass);
133: }
134: }
135:
136: *hdr->mqtt_len = mqtt_encodeLen(siz - sizeof(struct mqtthdr));
137: mqtt_msgRealloc(buf, siz);
138: return siz;
139: }
140:
141: /*
142: * mqtt_msgCONNACK() Create CONNACK message
143: *
144: * @buf = Message buffer
145: * @retcode = Return code
146: * return: -1 error or >-1 message size for send
147: */
148: int
149: mqtt_msgCONNACK(mqtt_msg_t * __restrict buf, u_char retcode)
150: {
151: int siz = 0;
152: struct mqtthdr *hdr;
153: mqtthdr_connack_t *ack;
154:
155: if (!buf)
156: return -1;
157: if (retcode > MQTT_RETCODE_DENIED) {
158: mqtt_SetErr(EINVAL, "Error:: invalid retcode");
159: return -1;
160: }
161:
162: if (mqtt_msgRealloc(buf, sizeof(struct mqtthdr) + sizeof(mqtthdr_connack_t)) == -1)
163: return -1;
164: else {
165: hdr = (struct mqtthdr *) (buf->msg_base + siz);
166: siz += sizeof(struct mqtthdr);
167: ack = (mqtthdr_connack_t*) (buf->msg_base + siz);
168: siz += sizeof(mqtthdr_connack_t);
169: }
170:
171: /* fixed header */
172: MQTTHDR_MSGINIT(hdr);
173: hdr->mqtt_msg.type = MQTT_TYPE_CONNACK;
174: *hdr->mqtt_len = sizeof(mqtthdr_connack_t);
175:
176: /* CONNACK header */
177: ack->reserved = 0;
178: ack->retcode = retcode;
179:
180: return siz;
181: }
182:
183: static int
184: _mqtt_msgSIMPLE_(mqtt_msg_t * __restrict buf, u_char cmd)
185: {
186: int siz = 0;
187: struct mqtthdr *hdr;
188:
189: if (!buf)
190: return -1;
191:
192: if (mqtt_msgRealloc(buf, sizeof(struct mqtthdr)) == -1)
193: return -1;
194: else {
195: hdr = (struct mqtthdr *) (buf->msg_base + siz);
196: siz += sizeof(struct mqtthdr);
197: }
198:
199: /* fixed header */
200: MQTTHDR_MSGINIT(hdr);
201: hdr->mqtt_msg.type = cmd;
202: *hdr->mqtt_len = 0;
203:
204: return siz;
205: }
206:
207: /*
208: * mqtt_msgPINGREQ() Create PINGREQ message
209: *
210: * @buf = Message buffer
211: * return: -1 error or >-1 message size for send
212: */
213: int
214: mqtt_msgPINGREQ(mqtt_msg_t * __restrict buf)
215: {
216: return _mqtt_msgSIMPLE_(buf, MQTT_TYPE_PINGREQ);
217: }
218:
219: /*
220: * mqtt_msgPINGRESP() Create PINGRESP message
221: *
222: * @buf = Message buffer
223: * return: -1 error or >-1 message size for send
224: */
225: int
226: mqtt_msgPINGRESP(mqtt_msg_t * __restrict buf)
227: {
228: return _mqtt_msgSIMPLE_(buf, MQTT_TYPE_PINGRESP);
229: }
230:
231: /*
232: * mqtt_msgDISCONNECT() Create DISCONNECT message
233: *
234: * @buf = Message buffer
235: * return: -1 error or >-1 message size for send
236: */
237: int
238: mqtt_msgDISCONNECT(mqtt_msg_t * __restrict buf)
239: {
240: return _mqtt_msgSIMPLE_(buf, MQTT_TYPE_DISCONNECT);
241: }
242:
243: /* ============= decode ============ */
244:
245: /*
246: * mqtt_readCONNECT() Read elements from CONNECT message
247: *
248: * @buf = Message buffer
249: * @kasec = Keep Alive in seconds for current connection
250: * @psConnID = ConnectID
251: * @connLen = ConnectID length
252: * @psUser = Username if !=NULL
253: * @userLen = Username length
254: * @psPass = Password for Username, only if csUser is set
255: * @passLen = Password length
256: * @psWillTopic = Will Topic if !=NULL Will Flags set into message
257: * @psWillMessage = Will Message, may be NULL
258: * return: .reserved == 1 is error or == 0 connection flags & msg ok
259: */
260: mqtthdr_connflgs_t
261: mqtt_readCONNECT(mqtt_msg_t * __restrict buf, u_short *kasec, char * __restrict psConnID, int connLen,
262: char * __restrict psUser, int userLen, char * __restrict psPass, int passLen,
263: char ** __restrict psWillTopic, char ** __restrict psWillMessage)
264: {
265: mqtthdr_connflgs_t flg = MQTT_CONNFLGS_INIT;
266: struct mqtthdr *hdr;
267: mqtthdr_var_t *var;
268: mqtt_v_t *ka;
269: mqtthdr_protover_t *proto;
270: int len, ret;
271: caddr_t pos;
272:
273: if (!buf || !buf->msg_base || !buf->msg_len || !psConnID || !connLen)
274: return flg;
275:
276: hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNECT, &ret, &len);
277: if (!hdr)
278: return flg;
279: if (len < 12) {
280: mqtt_SetErr(EINVAL, "Error:: short message length %d", len);
281: return flg;
282: } else {
283: pos = buf->msg_base + ret + 1;
284: var = (mqtthdr_var_t*) pos;
285: }
286: /* check init string & protocol */
287: if (var->var_sb.sb.l != 6 || strncmp(var->var_data, MQTT_CONN_STR, 6)) {
288: mqtt_SetErr(EINVAL, "Error:: invalid init string %.6s(%d)",
289: var->var_data, var->var_sb.sb.l);
290: return flg;
291: } else {
292: pos += var->var_sb.sb.l + sizeof(mqtt_v_t);
293: proto = (mqtthdr_protover_t*) pos;
294: }
295: if (*proto != MQTT_PROTO_VER) {
296: mqtt_SetErr(EINVAL, "Error:: invalid protocol version %d", *pos);
297: return flg;
298: } else
299: pos++;
300: flg = *(mqtthdr_connflgs_t*) pos;
301: pos++;
302: ka = (mqtt_v_t*) pos;
303: *kasec = ntohs(ka->val);
304: pos += sizeof(mqtt_v_t);
305:
306: len -= pos - (caddr_t) var;
307:
308: /* get ConnID */
309: var = (mqtthdr_var_t*) pos;
310: len -= MQTTHDR_VAR_SIZEOF(var);
311: if (len < 0) {
312: mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Connection ID %d", len);
313: flg.reserved = 1;
314: return flg;
315: } else {
316: memset(psConnID, 0, connLen--);
317: memcpy(psConnID, var->var_data, ntohs(var->var_sb.val) > connLen ? connLen : ntohs(var->var_sb.val));
318: pos += MQTTHDR_VAR_SIZEOF(var);
319: }
320:
321: /* get Willz */
322: if (flg.will_flg) {
323: var = (mqtthdr_var_t*) pos;
324: len -= MQTTHDR_VAR_SIZEOF(var);
325: if (len < 0) {
326: mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Will Topic %d", len);
327: flg.reserved = 1;
328: return flg;
329: } else {
330: if (psWillTopic) {
331: *psWillTopic = malloc(ntohs(var->var_sb.val) + 1);
332: if (!*psWillTopic) {
333: LOGERR;
334: flg.reserved = 1;
335: return flg;
336: } else
337: memset(*psWillTopic, 0, ntohs(var->var_sb.val) + 1);
338: memcpy(*psWillTopic, var->var_data, ntohs(var->var_sb.val));
339: }
340: pos += MQTTHDR_VAR_SIZEOF(var);
341: }
342:
343: var = (mqtthdr_var_t*) pos;
344: len -= MQTTHDR_VAR_SIZEOF(var);
345: if (len < 0) {
346: mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Will Message %d", len);
347: flg.reserved = 1;
348: return flg;
349: } else {
350: if (psWillMessage) {
351: *psWillMessage = malloc(ntohs(var->var_sb.val) + 1);
352: if (!*psWillMessage) {
353: LOGERR;
354: flg.reserved = 1;
355: return flg;
356: } else
357: memset(*psWillMessage, 0, ntohs(var->var_sb.val) + 1);
358: memcpy(*psWillMessage, var->var_data, ntohs(var->var_sb.val));
359: }
360: pos += MQTTHDR_VAR_SIZEOF(var);
361: }
362: }
363:
364: /* get User/Pass */
365: if (flg.username) {
366: var = (mqtthdr_var_t*) pos;
367: len -= MQTTHDR_VAR_SIZEOF(var);
368: if (len < 0) {
369: mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Username %d", len);
370: flg.reserved = 1;
371: return flg;
372: } else {
373: if (psUser && userLen) {
374: memset(psUser, 0, userLen--);
375: memcpy(psUser, var->var_data,
376: ntohs(var->var_sb.val) > userLen ? userLen : ntohs(var->var_sb.val));
377: }
378: pos += MQTTHDR_VAR_SIZEOF(var);
379: }
380: }
381: if (flg.password) {
382: var = (mqtthdr_var_t*) pos;
383: len -= MQTTHDR_VAR_SIZEOF(var);
384: if (len < 0) {
385: mqtt_SetErr(EINVAL, "Error:: unexpected EOM at Password %d", len);
386: flg.reserved = 1;
387: return flg;
388: } else {
389: if (psPass && passLen) {
390: memset(psPass, 0, passLen--);
391: memcpy(psPass, var->var_data,
392: ntohs(var->var_sb.val) > passLen ? passLen : ntohs(var->var_sb.val));
393: }
394: pos += MQTTHDR_VAR_SIZEOF(var);
395: }
396: }
397:
398: return flg;
399: }
400:
401: /*
402: * mqtt_readCONNACK() Read CONNACK message
403: *
404: * @buf = Message buffer
405: * return: -1 error or >-1 CONNECT message return code
406: */
407: u_char
408: mqtt_readCONNACK(mqtt_msg_t * __restrict buf)
409: {
410: int len, ret;
411: struct mqtthdr *hdr;
412: mqtthdr_connack_t *ack;
413: caddr_t pos;
414:
415: if (!buf || !buf->msg_base || !buf->msg_len)
416: return (u_char) -1;
417:
418: hdr = _mqtt_readHEADER(buf, MQTT_TYPE_CONNACK, &ret, &len);
419: if (!hdr)
420: return (u_char) -1;
421: if (len < sizeof(mqtthdr_connack_t)) {
422: mqtt_SetErr(EINVAL, "Error:: short message length %d", len);
423: return (u_char) -1;
424: } else {
425: pos = buf->msg_base + ret + 1;
426: ack = (mqtthdr_connack_t*) pos;
427: }
428:
429: if (ack->retcode > MQTT_RETCODE_DENIED) {
430: mqtt_SetErr(EINVAL, "Error:: invalid retcode %u", ack->retcode);
431: return (u_char) -1;
432: }
433:
434: return ack->retcode;
435: }
436:
437: /*
438: * mqtt_readDISCONNECT() Read DISCONNECT message
439: *
440: * @buf = Message buffer
441: * return: -1 error, 0 ok, >0 undefined result
442: */
443: int
444: mqtt_readDISCONNECT(mqtt_msg_t * __restrict buf)
445: {
446: int len, ret;
447: struct mqtthdr *hdr;
448:
449: hdr = _mqtt_readHEADER(buf, MQTT_TYPE_DISCONNECT, &ret, &len);
450: if (!hdr || ret != 1)
451: return -1;
452:
453: return len;
454: }
455:
456: /*
457: * mqtt_readPINGREQ() Read PINGREQ message
458: *
459: * @buf = Message buffer
460: * return: -1 error, 0 ok, >0 undefined result
461: */
462: int
463: mqtt_readPINGREQ(mqtt_msg_t * __restrict buf)
464: {
465: int len, ret;
466: struct mqtthdr *hdr;
467:
468: hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PINGREQ, &ret, &len);
469: if (!hdr || ret != 1)
470: return -1;
471:
472: return len;
473: }
474:
475: /*
476: * mqtt_readPINGRESP() Read PINGRESP message
477: *
478: * @buf = Message buffer
479: * return: -1 error, 0 ok, >0 undefined result
480: */
481: int
482: mqtt_readPINGRESP(mqtt_msg_t * __restrict buf)
483: {
484: int len, ret;
485: struct mqtthdr *hdr;
486:
487: hdr = _mqtt_readHEADER(buf, MQTT_TYPE_PINGRESP, &ret, &len);
488: if (!hdr || ret != 1)
489: return -1;
490:
491: return len;
492: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to conn.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / mqtt / src