master
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 * Copyright (C) Björn Stenberg, <bjorn@haxx.se>
10 *
11 * This software is licensed as described in the file COPYING, which
12 * you should have received as part of this distribution. The terms
13 * are also available at https://curl.se/docs/copyright.html.
14 *
15 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
16 * copies of the Software, and permit persons to whom the Software is
17 * furnished to do so, under the terms of the COPYING file.
18 *
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
21 *
22 * SPDX-License-Identifier: curl
23 *
24 ***************************************************************************/
25#include "curl_setup.h"
26#include "urldata.h"
28#ifndef CURL_DISABLE_MQTT
30#include "transfer.h"
31#include "sendf.h"
32#include "curl_trc.h"
33#include "progress.h"
34#include "mqtt.h"
35#include "select.h"
36#include "url.h"
37#include "escape.h"
38#include "rand.h"
39#include "cfilters.h"
40#include "connect.h"
42/* first byte is command.
43 second byte is for flags. */
44#define MQTT_MSG_CONNECT 0x10
45/* #define MQTT_MSG_CONNACK 0x20 */
46#define MQTT_MSG_PUBLISH 0x30
47#define MQTT_MSG_SUBSCRIBE 0x82
48#define MQTT_MSG_SUBACK 0x90
49#define MQTT_MSG_DISCONNECT 0xe0
50/* #define MQTT_MSG_PINGREQ 0xC0 */
51#define MQTT_MSG_PINGRESP 0xD0
53#define MQTT_CONNACK_LEN 2
54#define MQTT_SUBACK_LEN 3
55#define MQTT_CLIENTID_LEN 12 /* "curl0123abcd" */
57/* meta key for storing protocol meta at easy handle */
58#define CURL_META_MQTT_EASY "meta:proto:mqtt:easy"
59/* meta key for storing protocol meta at connection */
60#define CURL_META_MQTT_CONN "meta:proto:mqtt:conn"
62enum mqttstate {
63 MQTT_FIRST, /* 0 */
64 MQTT_REMAINING_LENGTH, /* 1 */
65 MQTT_CONNACK, /* 2 */
66 MQTT_SUBACK, /* 3 */
67 MQTT_SUBACK_COMING, /* 4 - the SUBACK remainder */
68 MQTT_PUBWAIT, /* 5 - wait for publish */
69 MQTT_PUB_REMAIN, /* 6 - wait for the remainder of the publish */
70 MQTT_POST_DRAIN, /* 7 - finish sending PUBLISH */
71 MQTT_DISCONNECT_DRAIN, /* 8 - finish sending DISCONNECT */
73 MQTT_NOSTATE /* 9 - never used an actual state */
74};
76struct mqtt_conn {
77 enum mqttstate state;
78 enum mqttstate nextstate; /* switch to this after remaining length is
79 done */
80 unsigned int packetid;
81};
83/* protocol-specific transfer-related data */
84struct MQTT {
85 struct dynbuf sendbuf;
86 /* when receiving */
87 struct dynbuf recvbuf;
88 size_t npacket; /* byte counter */
89 size_t remaining_length;
90 unsigned char pkt_hd[4]; /* for decoding the arriving packet length */
91 struct curltime lastTime; /* last time we sent or received data */
92 unsigned char firstbyte;
93 BIT(pingsent); /* 1 while we wait for ping response */
94};
96static void mqtt_easy_dtor(const void *key, size_t klen, void *entry)
97{
98 struct MQTT *mq = entry;
99 (void)key;
100 (void)klen;
101 curlx_dyn_free(&mq->sendbuf);
102 curlx_dyn_free(&mq->recvbuf);
103 curlx_free(mq);
104}
106static void mqtt_conn_dtor(const void *key, size_t klen, void *entry)
107{
108 (void)key;
109 (void)klen;
110 curlx_free(entry);
111}
113static CURLcode mqtt_setup_conn(struct Curl_easy *data,
114 struct connectdata *conn)
115{
116 /* setup MQTT specific meta data at easy handle and connection */
117 struct mqtt_conn *mqtt;
118 struct MQTT *mq;
120 mqtt = curlx_calloc(1, sizeof(*mqtt));
121 if(!mqtt ||
122 Curl_conn_meta_set(conn, CURL_META_MQTT_CONN, mqtt, mqtt_conn_dtor))
123 return CURLE_OUT_OF_MEMORY;
125 mq = curlx_calloc(1, sizeof(struct MQTT));
126 if(!mq)
127 return CURLE_OUT_OF_MEMORY;
128 curlx_dyn_init(&mq->recvbuf, DYN_MQTT_RECV);
129 curlx_dyn_init(&mq->sendbuf, DYN_MQTT_SEND);
130 if(Curl_meta_set(data, CURL_META_MQTT_EASY, mq, mqtt_easy_dtor))
131 return CURLE_OUT_OF_MEMORY;
132 return CURLE_OK;
133}
135static CURLcode mqtt_send(struct Curl_easy *data,
136 const char *buf, size_t len)
137{
138 size_t n;
139 CURLcode result;
140 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
142 if(!mq)
143 return CURLE_FAILED_INIT;
145 /* A new packet must not replace a previously queued packet tail. */
146 DEBUGASSERT(!curlx_dyn_len(&mq->sendbuf));
147 result = Curl_xfer_send(data, buf, len, FALSE, &n);
148 if(result)
149 return result;
150 mq->lastTime = *Curl_pgrs_now(data);
151 Curl_debug(data, CURLINFO_HEADER_OUT, buf, n);
152 if(len != n)
153 result = curlx_dyn_addn(&mq->sendbuf, &buf[n], len - n);
154 return result;
155}
157/* Send the queued tail, preserving any bytes that still cannot be sent. */
158static CURLcode mqtt_flush(struct Curl_easy *data)
159{
160 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
161 size_t len, n;
162 CURLcode result;
164 if(!mq)
165 return CURLE_FAILED_INIT;
166 len = curlx_dyn_len(&mq->sendbuf);
167 if(!len)
168 return CURLE_OK;
170 result = Curl_xfer_send(data, curlx_dyn_ptr(&mq->sendbuf), len, FALSE, &n);
171 if(result)
172 return result;
173 mq->lastTime = *Curl_pgrs_now(data);
174 Curl_debug(data, CURLINFO_HEADER_OUT, curlx_dyn_ptr(&mq->sendbuf), n);
175 return curlx_dyn_tail(&mq->sendbuf, len - n);
176}
178/* Generic function called by the multi interface to figure out what socket(s)
179 to wait for and for what actions during the DOING and PROTOCONNECT
180 states */
181static CURLcode mqtt_pollset(struct Curl_easy *data,
182 struct easy_pollset *ps)
183{
184 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
185 if(mq && curlx_dyn_len(&mq->sendbuf))
186 return Curl_pollset_add_out(data, ps, data->conn->sock[FIRSTSOCKET]);
187 return Curl_pollset_add_in(data, ps, data->conn->sock[FIRSTSOCKET]);
188}
190static int mqtt_encode_len(char *buf, size_t len)
191{
192 int i;
194 for(i = 0; (len > 0) && (i < 4); i++) {
195 unsigned char encoded;
196 encoded = len % 0x80;
197 len /= 0x80;
198 if(len)
199 encoded |= 0x80;
200 buf[i] = (char)encoded;
201 }
203 return i;
204}
206/* add the passwd to the CONNECT packet */
207static int add_passwd(const char *passwd, const size_t plen,
208 char *pkt, const size_t start, int remain_pos)
209{
210 /* magic number that need to be set properly */
211 const size_t conn_flags_pos = remain_pos + 8;
212 if(plen > 0xffff)
213 return 1;
215 /* set password flag */
216 pkt[conn_flags_pos] |= 0x40;
218 /* length of password provided */
219 pkt[start] = (char)((plen >> 8) & 0xFF);
220 pkt[start + 1] = (char)(plen & 0xFF);
221 memcpy(&pkt[start + 2], passwd, plen);
222 return 0;
223}
225/* add user to the CONNECT packet */
226static int add_user(const char *username, const size_t ulen,
227 unsigned char *pkt, const size_t start, int remain_pos)
228{
229 /* magic number that need to be set properly */
230 const size_t conn_flags_pos = remain_pos + 8;
231 if(ulen > 0xffff)
232 return 1;
234 /* set username flag */
235 pkt[conn_flags_pos] |= 0x80;
236 /* length of username provided */
237 pkt[start] = (unsigned char)((ulen >> 8) & 0xFF);
238 pkt[start + 1] = (unsigned char)(ulen & 0xFF);
239 memcpy(&pkt[start + 2], username, ulen);
240 return 0;
241}
243/* add client ID to the CONNECT packet */
244static int add_client_id(const char *client_id, const size_t client_id_len,
245 char *pkt, const size_t start)
246{
247 if(client_id_len != MQTT_CLIENTID_LEN)
248 return 1;
249 pkt[start] = 0x00;
250 pkt[start + 1] = MQTT_CLIENTID_LEN;
251 memcpy(&pkt[start + 2], client_id, MQTT_CLIENTID_LEN);
252 return 0;
253}
255/* Set initial values of CONNECT packet */
256static int init_connpack(char *packet, char *remain, int remain_pos)
257{
258 /* Fixed header starts */
259 /* packet type */
260 packet[0] = MQTT_MSG_CONNECT;
261 /* remaining length field */
262 memcpy(&packet[1], remain, remain_pos);
263 /* Fixed header ends */
265 /* Variable header starts */
266 /* protocol length */
267 packet[remain_pos + 1] = 0x00;
268 packet[remain_pos + 2] = 0x04;
269 /* protocol name */
270 packet[remain_pos + 3] = 'M';
271 packet[remain_pos + 4] = 'Q';
272 packet[remain_pos + 5] = 'T';
273 packet[remain_pos + 6] = 'T';
274 /* protocol level */
275 packet[remain_pos + 7] = 0x04;
276 /* CONNECT flag: CleanSession */
277 packet[remain_pos + 8] = 0x02;
278 /* keep-alive 0 = disabled */
279 packet[remain_pos + 9] = 0x00;
280 packet[remain_pos + 10] = 0x3c;
281 /* end of variable header */
282 return remain_pos + 10;
283}
285static CURLcode mqtt_connect(struct Curl_easy *data)
286{
287 CURLcode result = CURLE_OK;
288 int pos = 0;
289 int rc = 0;
290 /* remain length */
291 int remain_pos = 0;
292 char remain[4] = { 0 };
293 size_t packetlen = 0;
294 size_t start_user = 0;
295 size_t start_pwd = 0;
296 char client_id[MQTT_CLIENTID_LEN + 1] = "curl";
297 const size_t clen = CURL_CSTRLEN("curl");
298 char *packet = NULL;
300 /* extracting username from request */
301 struct Curl_creds *creds = data->state.creds;
302 const size_t ulen = creds ? strlen(creds->user) : 0;
303 const size_t plen = creds ? strlen(creds->passwd) : 0;
304 const size_t payloadlen = ulen + plen + MQTT_CLIENTID_LEN + 2 +
305 /* The plus 2s below are for the MSB and LSB describing the length of the
306 string to be added on the payload. Refer to spec 1.5.2 and 1.5.4 */
307 (ulen ? 2 : 0) +
308 (plen ? 2 : 0);
310 /* getting how much occupy the remain length */
311 remain_pos = mqtt_encode_len(remain, payloadlen + 10);
313 /* 10 length of variable header and 1 the first byte of the fixed header */
314 packetlen = payloadlen + 10 + remain_pos + 1;
316 /* allocating packet */
317 if(packetlen > 0xFFFFFFF)
318 return CURLE_WEIRD_SERVER_REPLY;
319 packet = curlx_calloc(1, packetlen);
320 if(!packet)
321 return CURLE_OUT_OF_MEMORY;
323 /* set initial values for the CONNECT packet */
324 pos = init_connpack(packet, remain, remain_pos);
326 result = Curl_rand_alnum(data, (unsigned char *)&client_id[clen],
327 MQTT_CLIENTID_LEN - clen + 1);
328 /* add client id */
329 rc = add_client_id(client_id, strlen(client_id), packet, pos + 1);
330 if(rc) {
331 failf(data, "Client ID length mismatched: [%zu]", strlen(client_id));
332 result = CURLE_WEIRD_SERVER_REPLY;
333 goto end;
334 }
335 infof(data, "Using client id '%s'", client_id);
337 /* position where the user payload starts */
338 start_user = pos + 3 + MQTT_CLIENTID_LEN;
339 /* position where the password payload starts */
340 start_pwd = start_user + ulen;
341 /* if username was provided, add it to the packet */
342 if(ulen) {
343 start_pwd += 2;
345 rc = add_user(creds->user, ulen,
346 (unsigned char *)packet, start_user, remain_pos);
347 if(rc) {
348 failf(data, "Username too long: [%zu]", ulen);
349 result = CURLE_WEIRD_SERVER_REPLY;
350 goto end;
351 }
352 }
354 /* if passwd was provided, add it to the packet */
355 if(plen) {
356 rc = add_passwd(creds->passwd, plen, packet, start_pwd, remain_pos);
357 if(rc) {
358 failf(data, "Password too long: [%zu]", plen);
359 result = CURLE_WEIRD_SERVER_REPLY;
360 goto end;
361 }
362 }
364 if(!result)
365 result = mqtt_send(data, packet, packetlen);
367end:
368 if(packet) {
369 curlx_memzero(packet, packetlen);
370 curlx_free(packet);
371 }
372 Curl_creds_unlink(&data->state.creds);
373 return result;
374}
376static CURLcode mqtt_disconnect(struct Curl_easy *data)
377{
378 return mqtt_send(data, "\xe0\x00", 2);
379}
381static CURLcode mqtt_recv_atleast(struct Curl_easy *data, size_t nbytes)
382{
383 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
384 size_t rlen;
385 CURLcode result;
387 if(!mq)
388 return CURLE_FAILED_INIT;
389 rlen = curlx_dyn_len(&mq->recvbuf);
391 if(rlen < nbytes) {
392 unsigned char readbuf[1024];
393 size_t nread;
395 DEBUGASSERT(nbytes - rlen < sizeof(readbuf));
396 result = Curl_xfer_recv(data, (char *)readbuf, nbytes - rlen, &nread);
397 if(result)
398 return result;
399 if(!nread) /* EOF */
400 return CURLE_RECV_ERROR;
401 if(curlx_dyn_addn(&mq->recvbuf, readbuf, nread))
402 return CURLE_OUT_OF_MEMORY;
403 rlen = curlx_dyn_len(&mq->recvbuf);
404 }
405 return (rlen >= nbytes) ? CURLE_OK : CURLE_AGAIN;
406}
408static void mqtt_recv_consume(struct Curl_easy *data, size_t nbytes)
409{
410 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
411 DEBUGASSERT(mq);
412 if(mq) {
413 size_t rlen = curlx_dyn_len(&mq->recvbuf);
414 if(rlen <= nbytes)
415 curlx_dyn_reset(&mq->recvbuf);
416 else
417 curlx_dyn_tail(&mq->recvbuf, rlen - nbytes);
418 }
419}
421static CURLcode mqtt_verify_connack(struct Curl_easy *data)
422{
423 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
424 CURLcode result;
425 const char *ptr;
427 DEBUGASSERT(mq);
428 if(!mq)
429 return CURLE_FAILED_INIT;
430 if(mq->remaining_length != 2) {
431 failf(data, "CONNACK expected Remaining Length 2, got %zu",
432 mq->remaining_length);
433 return CURLE_WEIRD_SERVER_REPLY;
434 }
436 result = mqtt_recv_atleast(data, MQTT_CONNACK_LEN);
437 if(result)
438 return result;
440 /* verify CONNACK */
441 DEBUGASSERT(curlx_dyn_len(&mq->recvbuf) >= MQTT_CONNACK_LEN);
442 ptr = curlx_dyn_ptr(&mq->recvbuf);
443 Curl_debug(data, CURLINFO_HEADER_IN, ptr, MQTT_CONNACK_LEN);
445 if(ptr[0] != 0x00 || ptr[1] != 0x00) {
446 failf(data, "Expected %02x%02x but got %02x%02x",
447 0x00U, 0x00U, (unsigned char)ptr[0], (unsigned char)ptr[1]);
448 curlx_dyn_reset(&mq->recvbuf);
449 return CURLE_WEIRD_SERVER_REPLY;
450 }
451 mqtt_recv_consume(data, MQTT_CONNACK_LEN);
452 return CURLE_OK;
453}
455static CURLcode mqtt_get_topic(struct Curl_easy *data,
456 char **topic, size_t *topiclen)
457{
458 const char *path = data->state.up.path;
459 CURLcode result = CURLE_URL_MALFORMAT;
460 if(strlen(path) > 1) {
461 result = Curl_urldecode(path + 1, 0, topic, topiclen, REJECT_CTRL);
462 if(!result && (*topiclen > 0xffff)) {
463 failf(data, "Too long MQTT topic");
464 result = CURLE_URL_MALFORMAT;
465 }
466 }
467 else
468 failf(data, "No MQTT topic found. Forgot to URL encode it?");
470 return result;
471}
473static CURLcode mqtt_subscribe(struct Curl_easy *data)
474{
475 CURLcode result = CURLE_OK;
476 char *topic = NULL;
477 size_t topiclen;
478 unsigned char *packet = NULL;
479 size_t packetlen;
480 char encodedsize[4];
481 size_t n;
482 struct connectdata *conn = data->conn;
483 struct mqtt_conn *mqtt = Curl_conn_meta_get(conn, CURL_META_MQTT_CONN);
485 if(!mqtt)
486 return CURLE_FAILED_INIT;
488 result = mqtt_get_topic(data, &topic, &topiclen);
489 if(result)
490 goto fail;
492 mqtt->packetid++;
494 packetlen = topiclen + 5; /* packetid + topic (has a two byte length field)
495 + 2 bytes topic length + QoS byte */
496 n = mqtt_encode_len((char *)encodedsize, packetlen);
497 packetlen += n + 1; /* add one for the control packet type byte */
499 packet = curlx_malloc(packetlen);
500 if(!packet) {
501 result = CURLE_OUT_OF_MEMORY;
502 goto fail;
503 }
505 packet[0] = MQTT_MSG_SUBSCRIBE;
506 memcpy(&packet[1], encodedsize, n);
507 packet[1 + n] = (mqtt->packetid >> 8) & 0xff;
508 packet[2 + n] = mqtt->packetid & 0xff;
509 packet[3 + n] = (topiclen >> 8) & 0xff;
510 packet[4 + n] = topiclen & 0xff;
511 memcpy(&packet[5 + n], topic, topiclen);
512 packet[5 + n + topiclen] = 0; /* QoS zero */
514 result = mqtt_send(data, (const char *)packet, packetlen);
516fail:
517 curlx_free(topic);
518 curlx_free(packet);
519 return result;
520}
522/*
523 * Called when the first byte was already read.
524 */
525static CURLcode mqtt_verify_suback(struct Curl_easy *data)
526{
527 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
528 struct connectdata *conn = data->conn;
529 struct mqtt_conn *mqtt = Curl_conn_meta_get(conn, CURL_META_MQTT_CONN);
530 CURLcode result;
531 const char *ptr;
533 if(!mqtt || !mq)
534 return CURLE_FAILED_INIT;
536 if(mq->remaining_length != 3) {
537 failf(data, "SUBACK expected Remaining Length 3, got %zu",
538 mq->remaining_length);
539 return CURLE_WEIRD_SERVER_REPLY;
540 }
542 result = mqtt_recv_atleast(data, MQTT_SUBACK_LEN);
543 if(result)
544 goto fail;
546 /* verify SUBACK */
547 DEBUGASSERT(curlx_dyn_len(&mq->recvbuf) >= MQTT_SUBACK_LEN);
548 ptr = curlx_dyn_ptr(&mq->recvbuf);
549 Curl_debug(data, CURLINFO_HEADER_IN, ptr, MQTT_SUBACK_LEN);
551 if(((unsigned char)ptr[0]) != ((mqtt->packetid >> 8) & 0xff) ||
552 ((unsigned char)ptr[1]) != (mqtt->packetid & 0xff) ||
553 ptr[2] != 0x00) {
554 curlx_dyn_reset(&mq->recvbuf);
555 result = CURLE_WEIRD_SERVER_REPLY;
556 goto fail;
557 }
558 mqtt_recv_consume(data, MQTT_SUBACK_LEN);
559fail:
560 return result;
561}
563#define MAX_MQTT_MESSAGE_SIZE 0xFFFFFFF
565static CURLcode mqtt_publish(struct Curl_easy *data)
566{
567 CURLcode result;
568 char *payload = data->set.postfields;
569 size_t payloadlen;
570 char *topic = NULL;
571 size_t topiclen;
572 unsigned char *pkt = NULL;
573 size_t i = 0;
574 size_t remaininglength;
575 size_t encodelen;
576 char encodedbytes[4];
577 curl_off_t postfieldsize = data->set.postfieldsize;
579 if(!payload) {
580 DEBUGF(infof(data, "mqtt_publish without payload, return bad arg"));
581 return CURLE_BAD_FUNCTION_ARGUMENT;
582 }
583 if(!curlx_sotouz_fits(postfieldsize, &payloadlen)) {
584 if(postfieldsize > 0) /* off_t does not fit into size_t */
585 return CURLE_BAD_FUNCTION_ARGUMENT;
586 payloadlen = strlen(payload);
587 }
589 result = mqtt_get_topic(data, &topic, &topiclen);
590 if(result)
591 goto fail;
593 /* silly check for silly analyzers. On 32-bit systems a payload length close
594 to 4GB can wrap, but it is impossible to have such a large buffer in
595 memory on those systems */
596 if((SIZE_MAX - topiclen - 2) < payloadlen) {
597 result = CURLE_TOO_LARGE;
598 goto fail;
599 }
601 remaininglength = payloadlen + 2 + topiclen;
602 encodelen = mqtt_encode_len(encodedbytes, remaininglength);
603 if(remaininglength > (MAX_MQTT_MESSAGE_SIZE - encodelen - 1)) {
604 result = CURLE_TOO_LARGE;
605 goto fail;
606 }
608 /* add the control byte and the encoded remaining length */
609 pkt = curlx_malloc(remaininglength + 1 + encodelen);
610 if(!pkt) {
611 result = CURLE_OUT_OF_MEMORY;
612 goto fail;
613 }
615 /* assemble packet */
616 pkt[i++] = MQTT_MSG_PUBLISH;
617 memcpy(&pkt[i], encodedbytes, encodelen);
618 i += encodelen;
619 pkt[i++] = (topiclen >> 8) & 0xff;
620 pkt[i++] = (topiclen & 0xff);
621 memcpy(&pkt[i], topic, topiclen);
622 i += topiclen;
623 memcpy(&pkt[i], payload, payloadlen);
624 i += payloadlen;
625 result = mqtt_send(data, (const char *)pkt, i);
627fail:
628 curlx_free(pkt);
629 curlx_free(topic);
630 return result;
631}
633/* return FALSE on success, TRUE on error */
634static bool mqtt_decode_len(size_t *lenp, const unsigned char *buf,
635 size_t buflen)
636{
637 size_t len = 0;
638 size_t mult = 1;
639 size_t i;
640 unsigned char encoded = 128;
642 for(i = 0; (i < buflen) && (encoded & 128); i++) {
643 if(i == 4)
644 return TRUE; /* bad size */
645 encoded = buf[i];
646 len += (encoded & 127) * mult;
647 mult *= 128;
648 }
649 if(encoded & 128)
650 /* truncated size */
651 return TRUE;
653 *lenp = len;
654 return FALSE;
655}
657#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
658static const char * const statenames[] = {
659 "MQTT_FIRST",
660 "MQTT_REMAINING_LENGTH",
661 "MQTT_CONNACK",
662 "MQTT_SUBACK",
663 "MQTT_SUBACK_COMING",
664 "MQTT_PUBWAIT",
665 "MQTT_PUB_REMAIN",
666 "MQTT_POST_DRAIN",
667 "MQTT_DISCONNECT_DRAIN",
669 "NOT A STATE"
670};
671#endif
673/* The only way to change state */
674static void mqstate(struct Curl_easy *data,
675 enum mqttstate state,
676 enum mqttstate nextstate) /* used if state == FIRST */
677{
678 struct connectdata *conn = data->conn;
679 struct mqtt_conn *mqtt = Curl_conn_meta_get(conn, CURL_META_MQTT_CONN);
680 DEBUGASSERT(mqtt);
681 if(!mqtt)
682 return;
683#ifdef DEBUGBUILD
684 infof(data, "%s (from %s) (next is %s)",
685 statenames[state],
686 statenames[mqtt->state],
687 (state == MQTT_FIRST) ? statenames[nextstate] : "");
688#endif
689 mqtt->state = state;
690 if(state == MQTT_FIRST)
691 mqtt->nextstate = nextstate;
692}
694static CURLcode mqtt_read_publish(struct Curl_easy *data, bool *done)
695{
696 CURLcode result = CURLE_OK;
697 struct connectdata *conn = data->conn;
698 size_t nread;
699 size_t remlen;
700 struct mqtt_conn *mqtt = Curl_conn_meta_get(conn, CURL_META_MQTT_CONN);
701 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
702 unsigned char packet;
704 DEBUGASSERT(mqtt);
705 if(!mqtt || !mq)
706 return CURLE_FAILED_INIT;
708 switch(mqtt->state) {
709MQTT_SUBACK_COMING:
710 case MQTT_SUBACK_COMING:
711 result = mqtt_verify_suback(data);
712 if(result)
713 break;
715 mqstate(data, MQTT_FIRST, MQTT_PUBWAIT);
716 break;
718 case MQTT_SUBACK:
719 case MQTT_PUBWAIT:
720 /* we are expecting PUBLISH or SUBACK */
721 packet = mq->firstbyte & 0xf0;
722 if(packet == MQTT_MSG_PUBLISH)
723 mqstate(data, MQTT_PUB_REMAIN, MQTT_NOSTATE);
724 else if(packet == MQTT_MSG_SUBACK) {
725 mqstate(data, MQTT_SUBACK_COMING, MQTT_NOSTATE);
726 goto MQTT_SUBACK_COMING;
727 }
728 else if(packet == MQTT_MSG_DISCONNECT) {
729 infof(data, "Got DISCONNECT");
730 *done = TRUE;
731 goto end;
732 }
733 else {
734 result = CURLE_WEIRD_SERVER_REPLY;
735 goto end;
736 }
738 /* -- switched state -- */
739 remlen = mq->remaining_length;
740 infof(data, "Remaining length: %zu bytes", remlen);
741 if(data->set.max_filesize &&
742 (curl_off_t)remlen > data->set.max_filesize) {
743 failf(data, "Maximum file size exceeded");
744 result = CURLE_FILESIZE_EXCEEDED;
745 goto end;
746 }
747 Curl_pgrsSetDownloadSize(data, remlen);
748 data->req.bytecount = 0;
749 data->req.size = remlen;
750 mq->npacket = remlen; /* get this many bytes */
751 FALLTHROUGH();
752 case MQTT_PUB_REMAIN: {
753 /* read rest of packet, but no more. Cap to buffer size */
754 char buffer[4 * 1024];
755 size_t rest = mq->npacket;
756 if(rest > sizeof(buffer))
757 rest = sizeof(buffer);
758 result = Curl_xfer_recv(data, buffer, rest, &nread);
759 if(result) {
760 if(result == CURLE_AGAIN) {
761 infof(data, "EEEE AAAAGAIN");
762 }
763 goto end;
764 }
765 if(!nread) {
766 infof(data, "server disconnected");
767 result = CURLE_PARTIAL_FILE;
768 goto end;
769 }
771 /* we received something */
772 mq->lastTime = *Curl_pgrs_now(data);
774 /* if QoS is set, message contains packet id */
775 result = Curl_client_write(data, CLIENTWRITE_BODY, buffer, nread);
776 if(result)
777 goto end;
779 mq->npacket -= nread;
780 if(!mq->npacket)
781 /* no more PUBLISH payload, back to subscribe wait state */
782 mqstate(data, MQTT_FIRST, MQTT_PUBWAIT);
783 break;
784 }
785 default:
786 DEBUGASSERT(NULL); /* illegal state */
787 result = CURLE_WEIRD_SERVER_REPLY;
788 goto end;
789 }
790end:
791 return result;
792}
794static CURLcode mqtt_do(struct Curl_easy *data, bool *done)
795{
796 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
797 CURLcode result = CURLE_OK;
798 *done = FALSE; /* unconditionally */
800 if(!mq)
801 return CURLE_FAILED_INIT;
802 mq->lastTime = *Curl_pgrs_now(data);
803 mq->pingsent = FALSE;
805 result = mqtt_connect(data);
806 if(result) {
807 failf(data, "Error %d sending MQTT CONNECT request", (int)result);
808 return result;
809 }
810 mqstate(data, MQTT_FIRST, MQTT_CONNACK);
811 return CURLE_OK;
812}
814static CURLcode mqtt_done(struct Curl_easy *data,
815 CURLcode status, bool premature)
816{
817 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
818 (void)status;
819 (void)premature;
820 if(mq) {
821 curlx_dyn_free(&mq->sendbuf);
822 curlx_dyn_free(&mq->recvbuf);
823 }
824 return CURLE_OK;
825}
827/* we ping regularly to avoid being disconnected by the server */
828static CURLcode mqtt_ping(struct Curl_easy *data)
829{
830 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
831 CURLcode result = CURLE_OK;
832 struct connectdata *conn = data->conn;
833 struct mqtt_conn *mqtt = Curl_conn_meta_get(conn, CURL_META_MQTT_CONN);
835 if(!mqtt || !mq)
836 return CURLE_FAILED_INIT;
838 if(mqtt->state == MQTT_FIRST &&
839 !mq->pingsent &&
840 data->set.upkeep_interval_ms > 0) {
841 struct curltime t = *Curl_pgrs_now(data);
842 timediff_t diff = curlx_ptimediff_ms(&t, &mq->lastTime);
844 if(diff > data->set.upkeep_interval_ms) {
845 /* 0xC0 is PINGREQ, and 0x00 is remaining length */
846 unsigned char packet[2] = { 0xC0, 0x00 };
847 size_t packetlen = sizeof(packet);
849 result = mqtt_send(data, (char *)packet, packetlen);
850 if(!result) {
851 mq->pingsent = TRUE;
852 }
853 infof(data, "mqtt_ping: sent ping request.");
854 }
855 }
856 return result;
857}
859static CURLcode mqtt_doing(struct Curl_easy *data, bool *done)
860{
861 struct MQTT *mq = Curl_meta_get(data, CURL_META_MQTT_EASY);
862 CURLcode result = CURLE_OK;
863 size_t nread;
864 unsigned char recvbyte;
865 struct mqtt_conn *mqtt = Curl_conn_meta_get(data->conn, CURL_META_MQTT_CONN);
867 if(!mqtt || !mq)
868 return CURLE_FAILED_INIT;
870 *done = FALSE;
872 if(curlx_dyn_len(&mq->sendbuf)) {
873 /* send the remainder of an outgoing packet */
874 result = mqtt_flush(data);
875 /* CURLE_OK can still mean a short write. Wait for writable progress
876 before sending another packet or processing a reply. */
877 if(result || curlx_dyn_len(&mq->sendbuf))
878 return result;
879 }
881 result = mqtt_ping(data);
882 /* Packet processing may send more output, so finish PINGREQ first. */
883 if(result || curlx_dyn_len(&mq->sendbuf))
884 return result;
886 infof(data, "mqtt_doing: state [%d]", (int)mqtt->state);
887 switch(mqtt->state) {
888 case MQTT_FIRST:
889 /* Read the initial byte only */
890 result = Curl_xfer_recv(data, (char *)&mq->firstbyte, 1, &nread);
891 if(result)
892 break;
893 else if(!nread) {
894 failf(data, "Connection disconnected");
895 *done = TRUE;
896 result = CURLE_RECV_ERROR;
897 break;
898 }
899 Curl_debug(data, CURLINFO_HEADER_IN, (const char *)&mq->firstbyte, 1);
901 /* we received something */
902 mq->lastTime = *Curl_pgrs_now(data);
904 /* remember the first byte */
905 mq->npacket = 0;
906 mqstate(data, MQTT_REMAINING_LENGTH, MQTT_NOSTATE);
907 FALLTHROUGH();
908 case MQTT_REMAINING_LENGTH:
909 do {
910 result = Curl_xfer_recv(data, (char *)&recvbyte, 1, &nread);
911 if(result || !nread)
912 break;
913 Curl_debug(data, CURLINFO_HEADER_IN, (const char *)&recvbyte, 1);
914 mq->pkt_hd[mq->npacket++] = recvbyte;
915 } while((recvbyte & 0x80) && (mq->npacket < 4));
916 if(!result && nread && (recvbyte & 0x80))
917 /* MQTT supports up to 127 * 128^0 + 127 * 128^1 + 127 * 128^2 +
918 127 * 128^3 bytes. server tried to send more */
919 result = CURLE_WEIRD_SERVER_REPLY;
920 if(result)
921 break;
922 if(mqtt_decode_len(&mq->remaining_length, mq->pkt_hd, mq->npacket)) {
923 result = CURLE_WEIRD_SERVER_REPLY;
924 break;
925 }
926 mq->npacket = 0;
927 /* PINGRESP and DISCONNECT must have remaining_length == 0 and
928 * reserved bits (low nibble) must be zero per MQTT 3.1.1
929 * sections 2.2.2, 3.13.1 and 3.14.1. Reject before state
930 * dispatch to prevent nextstate confusion. */
931 {
932 const unsigned char type = mq->firstbyte & 0xF0;
933 const unsigned char reserved = mq->firstbyte & 0x0F;
934 if((type == MQTT_MSG_DISCONNECT || type == MQTT_MSG_PINGRESP) &&
935 (mq->remaining_length || reserved)) {
936 failf(data,
937 "Broker sent malformed %s "
938 "(remaining_length=%zu, header byte=0x%02x)",
939 type == MQTT_MSG_DISCONNECT ? "DISCONNECT" : "PINGRESP",
940 mq->remaining_length, mq->firstbyte);
941 result = CURLE_WEIRD_SERVER_REPLY;
942 break;
943 }
944 }
945 if(mq->remaining_length) {
946 mqstate(data, mqtt->nextstate, MQTT_NOSTATE);
947 break;
948 }
949 mqstate(data, MQTT_FIRST, MQTT_FIRST);
951 if(mq->firstbyte == MQTT_MSG_DISCONNECT) {
952 infof(data, "Got DISCONNECT");
953 *done = TRUE;
954 }
956 /* ping response */
957 if(mq->firstbyte == MQTT_MSG_PINGRESP) {
958 infof(data, "Received ping response.");
959 mq->pingsent = FALSE;
960 mqstate(data, MQTT_FIRST, MQTT_PUBWAIT);
961 }
962 break;
963 case MQTT_CONNACK:
964 result = mqtt_verify_connack(data);
965 if(result)
966 break;
968 if(data->state.httpreq != HTTPREQ_POST) {
969 result = mqtt_subscribe(data);
970 if(!result)
971 mqstate(data, MQTT_FIRST, MQTT_SUBACK);
972 break;
973 }
975 result = mqtt_publish(data);
976 if(result)
977 break;
978 mqstate(data, MQTT_POST_DRAIN, MQTT_NOSTATE);
979 FALLTHROUGH();
980 case MQTT_POST_DRAIN:
981 /* PUBLISH must be complete before DISCONNECT can use the send buffer. */
982 if(curlx_dyn_len(&mq->sendbuf))
983 break;
984 result = mqtt_disconnect(data);
985 if(result)
986 break;
987 mqstate(data, MQTT_DISCONNECT_DRAIN, MQTT_NOSTATE);
988 FALLTHROUGH();
989 case MQTT_DISCONNECT_DRAIN:
990 /* Completing now would discard any DISCONNECT bytes still queued. */
991 if(!curlx_dyn_len(&mq->sendbuf))
992 *done = TRUE;
993 break;
995 case MQTT_SUBACK:
996 case MQTT_PUBWAIT:
997 case MQTT_PUB_REMAIN:
998 result = mqtt_read_publish(data, done);
999 break;
1001 default:
1002 failf(data, "State not handled yet");
1003 *done = TRUE;
1004 break;
1005 }
1007 if(result == CURLE_AGAIN)
1008 result = CURLE_OK;
1009 return result;
1010}
1012#ifdef USE_SSL
1014static CURLcode mqtts_connecting(struct Curl_easy *data, bool *done)
1015{
1016 struct connectdata *conn = data->conn;
1017 CURLcode result;
1019 result = Curl_conn_connect(data, FIRSTSOCKET, TRUE, done);
1020 if(result)
1021 connclose(conn);
1022 return result;
1023}
1025/*
1026 * MQTTS protocol.
1027 */
1028const struct Curl_protocol Curl_protocol_mqtts = {
1029 mqtt_setup_conn, /* setup_connection */
1030 ZERO_NULL, /* setup_filters */
1031 mqtt_do, /* do_it */
1032 mqtt_done, /* done */
1033 ZERO_NULL, /* do_more */
1034 ZERO_NULL, /* connect_it */
1035 mqtts_connecting, /* connecting */
1036 mqtt_doing, /* doing */
1037 ZERO_NULL, /* proto_pollset */
1038 mqtt_pollset, /* doing_pollset */
1039 ZERO_NULL, /* domore_pollset */
1040 ZERO_NULL, /* perform_pollset */
1041 ZERO_NULL, /* disconnect */
1042 ZERO_NULL, /* write_resp */
1043 ZERO_NULL, /* write_resp_hd */
1044 ZERO_NULL, /* connection_is_dead */
1045 ZERO_NULL, /* attach connection */
1046 ZERO_NULL, /* follow */
1047};
1049#endif
1051/*
1052 * MQTT protocol.
1053 */
1054const struct Curl_protocol Curl_protocol_mqtt = {
1055 mqtt_setup_conn, /* setup_connection */
1056 ZERO_NULL, /* setup_filters */
1057 mqtt_do, /* do_it */
1058 mqtt_done, /* done */
1059 ZERO_NULL, /* do_more */
1060 ZERO_NULL, /* connect_it */
1061 ZERO_NULL, /* connecting */
1062 mqtt_doing, /* doing */
1063 ZERO_NULL, /* proto_pollset */
1064 mqtt_pollset, /* doing_pollset */
1065 ZERO_NULL, /* domore_pollset */
1066 ZERO_NULL, /* perform_pollset */
1067 ZERO_NULL, /* disconnect */
1068 ZERO_NULL, /* write_resp */
1069 ZERO_NULL, /* write_resp_hd */
1070 ZERO_NULL, /* connection_is_dead */
1071 ZERO_NULL, /* attach connection */
1072 ZERO_NULL, /* follow */
1073};
1075#endif /* CURL_DISABLE_MQTT */
Diagnostics4 git calls · 30 ms
CallStatusSizeTime030 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200149 B · hit3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=149 git.response.cache=HIT git.response.duration_ms=3 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=149 git.pkt.payload.max=78 git.ls_refs.count=2 git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=25 git.response.bytes=293470 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=10 git.pkt.data=8 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=293470 git.pkt.payload.max=65516 git.sideband.band1.bytes=293354 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=87 git.pack.bytes=293354 git.pack.ofs_delta=0 git.pack.ref_delta=1 git.pack.chain.max=1 git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0 git.pack.full=86Open pack map
fetch2008.8 KiB · hit25 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=9022 git.response.cache=HIT git.response.duration_ms=25 git.fetch.wants=55ab72093dfb96ee71c3a11f7187d2a9f81f7c63 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=9022 git.pkt.payload.max=9001 git.sideband.band1.bytes=9000 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
- Ref
- refs/heads/master
- Commit
- 31c911efe5652725e930f4d2e60c9060e5f6646d
- cf-ray
- a5e19574e93bddf0
- Request
- c11701d3…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format