Skip to content

Commit b72a94d

Browse files
256dpi256dpi
committed
updated lwmqtt
1 parent eae214b commit b72a94d

File tree

7 files changed

+184
-184
lines changed

7 files changed

+184
-184
lines changed

‎Makefile‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ fmt:
55

66
update:
77
rm -rf ./lwmqtt
8-
git clone --branch v0.8.0 https://github.com/256dpi/lwmqtt.git ./lwmqtt
8+
git clone --branch v0.9.0 https://github.com/256dpi/lwmqtt.git ./lwmqtt
99
mkdir -p ./src/lwmqtt
1010
cp -r ./lwmqtt/src/*.c ./src/lwmqtt/
1111
cp -r ./lwmqtt/src/*.h ./src/lwmqtt/

‎src/MQTTClient.cpp‎

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -344,7 +344,7 @@ bool MQTTClient::connect(const char clientID[], const char username[], const cha
344344
}
345345

346346
// prepare options
347-
lwmqtt_options_t options = lwmqtt_default_options;
347+
lwmqtt_connect_options_t options = lwmqtt_default_connect_options;
348348
options.keep_alive = this->keepAlive;
349349
options.clean_session = this->cleanSession;
350350
options.client_id = lwmqtt_string(clientID);
@@ -359,7 +359,12 @@ bool MQTTClient::connect(const char clientID[], const char username[], const cha
359359
}
360360

361361
// connect to broker
362-
this->_lastError = lwmqtt_connect(&this->client, options, this->will, &this->_returnCode, this->timeout);
362+
this->_lastError = lwmqtt_connect(&this->client, &options, this->will, this->timeout);
363+
364+
// copy return code
365+
this->_returnCode = options.return_code;
366+
367+
// handle error
363368
if (this->_lastError != LWMQTT_SUCCESS) {
364369
// close connection
365370
this->close();
@@ -387,7 +392,7 @@ bool MQTTClient::publish(const char topic[], const char payload[], int length, b
387392
message.qos = lwmqtt_qos_t(qos);
388393

389394
// publish message
390-
this->_lastError = lwmqtt_publish(&this->client, lwmqtt_string(topic), message, this->timeout, nullptr);
395+
this->_lastError = lwmqtt_publish(&this->client, nullptr, lwmqtt_string(topic), message, this->timeout);
391396
if (this->_lastError != LWMQTT_SUCCESS) {
392397
// close connection
393398
this->close();

‎src/lwmqtt/client.c‎

Lines changed: 115 additions & 112 deletions
Original file line numberDiff line numberDiff line change
@@ -143,8 +143,8 @@ static lwmqtt_err_t lwmqtt_write_to_network(lwmqtt_client_t *client, uint8_t *bu
143143

144144
// write
145145
size_t partial_write = 0;
146-
lwmqtt_err_t err = client->network_write(client->network, buf + written, len - written, &partial_write,
147-
(uint32_t)remaining_time);
146+
lwmqtt_err_t err =
147+
client->network_write(client->network, buf + written, len - written, &partial_write, (uint32_t)remaining_time);
148148
if (err != LWMQTT_SUCCESS) {
149149
return err;
150150
}
@@ -246,7 +246,7 @@ static lwmqtt_err_t lwmqtt_send_packet_in_buffer(lwmqtt_client_t *client, size_t
246246
return LWMQTT_SUCCESS;
247247
}
248248

249-
static lwmqtt_err_t lwmqtt_cycle(lwmqtt_client_t *client, size_t *read, lwmqtt_packet_type_t *packet_type) {
249+
static lwmqtt_err_t lwmqtt_cycle_once(lwmqtt_client_t *client, size_t *read, lwmqtt_packet_type_t *packet_type) {
250250
// read next packet from the network
251251
lwmqtt_err_t err = lwmqtt_read_packet_in_buffer(client, read, packet_type);
252252
if (err != LWMQTT_SUCCESS) {
@@ -288,7 +288,7 @@ static lwmqtt_err_t lwmqtt_cycle(lwmqtt_client_t *client, size_t *read, lwmqtt_p
288288

289289
// encode ack packet
290290
size_t len;
291-
err = lwmqtt_encode_ack(client->write_buf, client->write_buf_size, &len, ack_type, false, packet_id);
291+
err = lwmqtt_encode_ack(client->write_buf, client->write_buf_size, &len, ack_type, packet_id);
292292
if (err != LWMQTT_SUCCESS) {
293293
return err;
294294
}
@@ -305,16 +305,15 @@ static lwmqtt_err_t lwmqtt_cycle(lwmqtt_client_t *client, size_t *read, lwmqtt_p
305305
// handle pubrec packets
306306
case LWMQTT_PUBREC_PACKET: {
307307
// decode pubrec packet
308-
bool dup;
309308
uint16_t packet_id;
310-
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, LWMQTT_PUBREC_PACKET, &dup, &packet_id);
309+
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, LWMQTT_PUBREC_PACKET, &packet_id);
311310
if (err != LWMQTT_SUCCESS) {
312311
return err;
313312
}
314313

315314
// encode pubrel packet
316315
size_t len;
317-
err = lwmqtt_encode_ack(client->write_buf, client->write_buf_size, &len, LWMQTT_PUBREL_PACKET, 0, packet_id);
316+
err = lwmqtt_encode_ack(client->write_buf, client->write_buf_size, &len, LWMQTT_PUBREL_PACKET, packet_id);
318317
if (err != LWMQTT_SUCCESS) {
319318
return err;
320319
}
@@ -331,16 +330,15 @@ static lwmqtt_err_t lwmqtt_cycle(lwmqtt_client_t *client, size_t *read, lwmqtt_p
331330
// handle pubrel packets
332331
case LWMQTT_PUBREL_PACKET: {
333332
// decode pubrec packet
334-
bool dup;
335333
uint16_t packet_id;
336-
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, LWMQTT_PUBREL_PACKET, &dup, &packet_id);
334+
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, LWMQTT_PUBREL_PACKET, &packet_id);
337335
if (err != LWMQTT_SUCCESS) {
338336
return err;
339337
}
340338

341339
// encode pubcomp packet
342340
size_t len;
343-
err = lwmqtt_encode_ack(client->write_buf, client->write_buf_size, &len, LWMQTT_PUBCOMP_PACKET, 0, packet_id);
341+
err = lwmqtt_encode_ack(client->write_buf, client->write_buf_size, &len, LWMQTT_PUBCOMP_PACKET, packet_id);
344342
if (err != LWMQTT_SUCCESS) {
345343
return err;
346344
}
@@ -379,7 +377,7 @@ static lwmqtt_err_t lwmqtt_cycle_until(lwmqtt_client_t *client, lwmqtt_packet_ty
379377
// loop until timeout has been reached
380378
do {
381379
// do one cycle
382-
lwmqtt_err_t err = lwmqtt_cycle(client, &read, packet_type);
380+
lwmqtt_err_t err = lwmqtt_cycle_once(client, &read, packet_type);
383381
if (err != LWMQTT_SUCCESS) {
384382
return err;
385383
}
@@ -398,36 +396,29 @@ static lwmqtt_err_t lwmqtt_cycle_until(lwmqtt_client_t *client, lwmqtt_packet_ty
398396
return LWMQTT_SUCCESS;
399397
}
400398

401-
lwmqtt_err_t lwmqtt_yield(lwmqtt_client_t *client, size_t available, uint32_t timeout) {
402-
// set command timer
403-
client->timer_set(client->command_timer, timeout);
404-
405-
// cycle until timeout has been reached
406-
lwmqtt_packet_type_t packet_type = LWMQTT_NO_PACKET;
407-
lwmqtt_err_t err = lwmqtt_cycle_until(client, &packet_type, available, LWMQTT_NO_PACKET);
408-
if (err != LWMQTT_SUCCESS) {
409-
return err;
399+
lwmqtt_err_t lwmqtt_connect(lwmqtt_client_t *client, lwmqtt_connect_options_t *options, lwmqtt_will_t *will,
400+
uint32_t timeout) {
401+
// ensure default options
402+
static lwmqtt_connect_options_t def_options = lwmqtt_default_connect_options;
403+
if (options == NULL) {
404+
options = &def_options;
410405
}
411406

412-
return LWMQTT_SUCCESS;
413-
}
414-
415-
lwmqtt_err_t lwmqtt_connect(lwmqtt_client_t *client, lwmqtt_options_t options, lwmqtt_will_t *will,
416-
lwmqtt_return_code_t *return_code, uint32_t timeout) {
417407
// set command timer
418408
client->timer_set(client->command_timer, timeout);
419409

420410
// save keep alive interval
421-
client->keep_alive_interval = (uint32_t)(options.keep_alive) * 1000;
411+
client->keep_alive_interval = (uint32_t)(options->keep_alive) * 1000;
422412

423413
// set keep alive timer
424414
client->timer_set(client->keep_alive_timer, client->keep_alive_interval);
425415

426416
// reset pong pending flag
427417
client->pong_pending = false;
428418

429-
// initialize return code
430-
*return_code = LWMQTT_UNKNOWN_RETURN_CODE;
419+
// reset return code and session present
420+
options->return_code = LWMQTT_UNKNOWN_RETURN_CODE;
421+
options->session_present = false;
431422

432423
// encode connect packet
433424
size_t len;
@@ -452,20 +443,103 @@ lwmqtt_err_t lwmqtt_connect(lwmqtt_client_t *client, lwmqtt_options_t options, l
452443
}
453444

454445
// decode connack packet
455-
bool session_present;
456-
err = lwmqtt_decode_connack(client->read_buf, client->read_buf_size, &session_present, return_code);
446+
err =
447+
lwmqtt_decode_connack(client->read_buf, client->read_buf_size, &options->session_present, &options->return_code);
457448
if (err != LWMQTT_SUCCESS) {
458449
return err;
459450
}
460451

461452
// return error if connection was not accepted
462-
if (*return_code != LWMQTT_CONNECTION_ACCEPTED) {
453+
if (options->return_code != LWMQTT_CONNECTION_ACCEPTED) {
463454
return LWMQTT_CONNECTION_DENIED;
464455
}
465456

466457
return LWMQTT_SUCCESS;
467458
}
468459

460+
lwmqtt_err_t lwmqtt_publish(lwmqtt_client_t *client, lwmqtt_publish_options_t *options, lwmqtt_string_t topic,
461+
lwmqtt_message_t msg, uint32_t timeout) {
462+
// ensure default options
463+
static lwmqtt_publish_options_t def_options = lwmqtt_default_publish_options;
464+
if (options == NULL) {
465+
options = &def_options;
466+
}
467+
468+
// set command timer
469+
client->timer_set(client->command_timer, timeout);
470+
471+
// add packet id if at least qos 1
472+
bool dup = false;
473+
uint16_t packet_id = 0;
474+
if (msg.qos == LWMQTT_QOS1 || msg.qos == LWMQTT_QOS2) {
475+
if (options->dup_id != NULL && *options->dup_id > 0) {
476+
dup = true;
477+
packet_id = *options->dup_id;
478+
} else {
479+
packet_id = lwmqtt_get_next_packet_id(client);
480+
if (options->dup_id != NULL) {
481+
*options->dup_id = packet_id;
482+
}
483+
}
484+
}
485+
486+
// encode publish packet
487+
size_t len = 0;
488+
lwmqtt_err_t err = lwmqtt_encode_publish(client->write_buf, client->write_buf_size, &len, dup, packet_id, topic, msg);
489+
if (err != LWMQTT_SUCCESS) {
490+
return err;
491+
}
492+
493+
// send packet (without payload)
494+
err = lwmqtt_send_packet_in_buffer(client, len);
495+
if (err != LWMQTT_SUCCESS) {
496+
return err;
497+
}
498+
499+
// send payload if available
500+
if (msg.payload_len > 0) {
501+
err = lwmqtt_write_to_network(client, msg.payload, msg.payload_len);
502+
if (err != LWMQTT_SUCCESS) {
503+
return err;
504+
}
505+
}
506+
507+
// immediately return on qos zero
508+
if (msg.qos == LWMQTT_QOS0) {
509+
return LWMQTT_SUCCESS;
510+
}
511+
512+
// skip if requested
513+
if (options->skip_ack) {
514+
return LWMQTT_SUCCESS;
515+
}
516+
517+
// define ack packet
518+
lwmqtt_packet_type_t ack_type = LWMQTT_NO_PACKET;
519+
if (msg.qos == LWMQTT_QOS1) {
520+
ack_type = LWMQTT_PUBACK_PACKET;
521+
} else if (msg.qos == LWMQTT_QOS2) {
522+
ack_type = LWMQTT_PUBCOMP_PACKET;
523+
}
524+
525+
// wait for ack packet
526+
lwmqtt_packet_type_t packet_type = LWMQTT_NO_PACKET;
527+
err = lwmqtt_cycle_until(client, &packet_type, 0, ack_type);
528+
if (err != LWMQTT_SUCCESS) {
529+
return err;
530+
} else if (packet_type != ack_type) {
531+
return LWMQTT_MISSING_OR_WRONG_PACKET;
532+
}
533+
534+
// decode ack packet
535+
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, ack_type, &packet_id);
536+
if (err != LWMQTT_SUCCESS) {
537+
return err;
538+
}
539+
540+
return LWMQTT_SUCCESS;
541+
}
542+
469543
lwmqtt_err_t lwmqtt_subscribe(lwmqtt_client_t *client, int count, lwmqtt_string_t *topic_filter, lwmqtt_qos_t *qos,
470544
uint32_t timeout) {
471545
// set command timer
@@ -546,9 +620,8 @@ lwmqtt_err_t lwmqtt_unsubscribe(lwmqtt_client_t *client, int count, lwmqtt_strin
546620
}
547621

548622
// decode unsuback packet
549-
bool dup;
550623
uint16_t packet_id;
551-
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, LWMQTT_UNSUBACK_PACKET, &dup, &packet_id);
624+
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, LWMQTT_UNSUBACK_PACKET, &packet_id);
552625
if (err != LWMQTT_SUCCESS) {
553626
return err;
554627
}
@@ -560,103 +633,33 @@ lwmqtt_err_t lwmqtt_unsubscribe_one(lwmqtt_client_t *client, lwmqtt_string_t top
560633
return lwmqtt_unsubscribe(client, 1, &topic_filter, timeout);
561634
}
562635

563-
lwmqtt_err_t lwmqtt_publish(lwmqtt_client_t *client, lwmqtt_string_t topic, lwmqtt_message_t message, uint32_t timeout,
564-
lwmqtt_publish_options_t *options) {
565-
// ensure default options
566-
static lwmqtt_publish_options_t def_options = lwmqtt_default_publish_options;
567-
if (options == NULL) {
568-
options = &def_options;
569-
}
570-
636+
lwmqtt_err_t lwmqtt_disconnect(lwmqtt_client_t *client, uint32_t timeout) {
571637
// set command timer
572638
client->timer_set(client->command_timer, timeout);
573639

574-
// add packet id if at least qos 1
575-
bool dup = false;
576-
uint16_t packet_id = 0;
577-
if (message.qos == LWMQTT_QOS1 || message.qos == LWMQTT_QOS2) {
578-
if (options->dup_id != NULL && *options->dup_id > 0) {
579-
dup = true;
580-
packet_id = *options->dup_id;
581-
} else {
582-
packet_id = lwmqtt_get_next_packet_id(client);
583-
if (options->dup_id != NULL) {
584-
*options->dup_id = packet_id;
585-
}
586-
}
587-
}
588-
589-
// encode publish packet
590-
size_t len = 0;
591-
lwmqtt_err_t err =
592-
lwmqtt_encode_publish(client->write_buf, client->write_buf_size, &len, dup, packet_id, topic, message);
640+
// encode disconnect packet
641+
size_t len;
642+
lwmqtt_err_t err = lwmqtt_encode_zero(client->write_buf, client->write_buf_size, &len, LWMQTT_DISCONNECT_PACKET);
593643
if (err != LWMQTT_SUCCESS) {
594644
return err;
595645
}
596646

597-
// send packet (without payload)
647+
// send disconnected packet
598648
err = lwmqtt_send_packet_in_buffer(client, len);
599649
if (err != LWMQTT_SUCCESS) {
600650
return err;
601651
}
602652

603-
// send payload if available
604-
if (message.payload_len > 0) {
605-
err = lwmqtt_write_to_network(client, message.payload, message.payload_len);
606-
if (err != LWMQTT_SUCCESS) {
607-
return err;
608-
}
609-
}
610-
611-
// immediately return on qos zero
612-
if (message.qos == LWMQTT_QOS0) {
613-
return LWMQTT_SUCCESS;
614-
}
615-
616-
// skip if requested
617-
if (options->skip_ack) {
618-
return LWMQTT_SUCCESS;
619-
}
620-
621-
// define ack packet
622-
lwmqtt_packet_type_t ack_type = LWMQTT_NO_PACKET;
623-
if (message.qos == LWMQTT_QOS1) {
624-
ack_type = LWMQTT_PUBACK_PACKET;
625-
} else if (message.qos == LWMQTT_QOS2) {
626-
ack_type = LWMQTT_PUBCOMP_PACKET;
627-
}
628-
629-
// wait for ack packet
630-
lwmqtt_packet_type_t packet_type = LWMQTT_NO_PACKET;
631-
err = lwmqtt_cycle_until(client, &packet_type, 0, ack_type);
632-
if (err != LWMQTT_SUCCESS) {
633-
return err;
634-
} else if (packet_type != ack_type) {
635-
return LWMQTT_MISSING_OR_WRONG_PACKET;
636-
}
637-
638-
// decode ack packet
639-
err = lwmqtt_decode_ack(client->read_buf, client->read_buf_size, ack_type, &dup, &packet_id);
640-
if (err != LWMQTT_SUCCESS) {
641-
return err;
642-
}
643-
644653
return LWMQTT_SUCCESS;
645654
}
646655

647-
lwmqtt_err_t lwmqtt_disconnect(lwmqtt_client_t *client, uint32_t timeout) {
656+
lwmqtt_err_t lwmqtt_yield(lwmqtt_client_t *client, size_t available, uint32_t timeout) {
648657
// set command timer
649658
client->timer_set(client->command_timer, timeout);
650659

651-
// encode disconnect packet
652-
size_t len;
653-
lwmqtt_err_t err = lwmqtt_encode_zero(client->write_buf, client->write_buf_size, &len, LWMQTT_DISCONNECT_PACKET);
654-
if (err != LWMQTT_SUCCESS) {
655-
return err;
656-
}
657-
658-
// send disconnected packet
659-
err = lwmqtt_send_packet_in_buffer(client, len);
660+
// cycle until timeout has been reached
661+
lwmqtt_packet_type_t packet_type = LWMQTT_NO_PACKET;
662+
lwmqtt_err_t err = lwmqtt_cycle_until(client, &packet_type, available, LWMQTT_NO_PACKET);
660663
if (err != LWMQTT_SUCCESS) {
661664
return err;
662665
}

0 commit comments

Comments
 (0)