updated lwmqtt

Author: 256dpi

Makefile

@@ -5,7 +5,7 @@ fmt:
 
 update:
 	rm -rf ./lwmqtt
-	git clone --branch v0.6.4 https://github.com/256dpi/lwmqtt.git ./lwmqtt
+	git clone --branch v0.7.0 https://github.com/256dpi/lwmqtt.git ./lwmqtt
 	mkdir -p ./src/lwmqtt
 	cp -r ./lwmqtt/src/*.c ./src/lwmqtt/
 	cp -r ./lwmqtt/src/*.h ./src/lwmqtt/

src/lwmqtt/client.c

@@ -22,6 +22,9 @@ void lwmqtt_init(lwmqtt_client_t *client, uint8_t *write_buf, size_t write_buf_s
   client->command_timer = NULL;
   client->timer_set = NULL;
   client->timer_get = NULL;
+
+  client->drop_overflow = false;
+  client->overflow_counter = NULL;
 }
 
 void lwmqtt_set_network(lwmqtt_client_t *client, void *ref, lwmqtt_network_read_t read, lwmqtt_network_write_t write) {
@@ -46,6 +49,11 @@ void lwmqtt_set_callback(lwmqtt_client_t *client, void *ref, lwmqtt_callback_t c
   client->callback = cb;
 }
 
+void lwmqtt_drop_overflow(lwmqtt_client_t *client, bool enabled, uint32_t *counter) {
+  client->drop_overflow = enabled;
+  client->overflow_counter = counter;
+}
+
 static uint16_t lwmqtt_get_next_packet_id(lwmqtt_client_t *client) {
   // check overflow
   if (client->last_packet_id == 65535) {
@@ -91,6 +99,36 @@ static lwmqtt_err_t lwmqtt_read_from_network(lwmqtt_client_t *client, size_t off
   return LWMQTT_SUCCESS;
 }
 
+static lwmqtt_err_t lwmqtt_drain_network(lwmqtt_client_t *client, size_t amount) {
+  // read while data is left
+  while (amount > 0) {
+    // check remaining time
+    int32_t remaining_time = client->timer_get(client->command_timer);
+    if (remaining_time <= 0) {
+      return LWMQTT_NETWORK_TIMEOUT;
+    }
+
+    // get max read
+    size_t max_read = amount;
+    if (max_read > client->read_buf_size) {
+      max_read = client->read_buf_size;
+    }
+
+    // read
+    size_t partial_read = 0;
+    lwmqtt_err_t err =
+        client->network_read(client->network, client->read_buf, max_read, &partial_read, (uint32_t)remaining_time);
+    if (err != LWMQTT_SUCCESS) {
+      return err;
+    }
+
+    // decrement counter
+    amount -= partial_read;
+  }
+
+  return LWMQTT_SUCCESS;
+}
+
 static lwmqtt_err_t lwmqtt_write_to_network(lwmqtt_client_t *client, size_t offset, size_t len) {
   // prepare counter
   size_t written = 0;
@@ -161,6 +199,26 @@ static lwmqtt_err_t lwmqtt_read_packet_in_buffer(lwmqtt_client_t *client, size_t
     return err;
   }
 
+  // handle overflow
+  if (client->drop_overflow && 1 + len + rem_len > client->read_buf_size) {
+    // drain network
+    err = lwmqtt_drain_network(client, rem_len);
+    if (err != LWMQTT_SUCCESS) {
+      return err;
+    }
+
+    // unset packet
+    *packet_type = LWMQTT_NO_PACKET;
+    *read = 0;
+
+    // increment if counter is available
+    if (client->overflow_counter != NULL) {
+      *client->overflow_counter += 1;
+    }
+
+    return LWMQTT_SUCCESS;
+  }
+
   // read the rest of the buffer if needed
   if (rem_len > 0) {
     err = lwmqtt_read_from_network(client, 1 + len, rem_len);

src/lwmqtt/helpers.c

@@ -2,10 +2,12 @@
 
 #include "helpers.h"
 
-uint8_t lwmqtt_read_bits(uint8_t byte, int pos, int num) { return (byte & (uint8_t)((~(0xFF << num)) << pos)) >> pos; }
+uint8_t lwmqtt_read_bits(uint8_t byte, int pos, int num) {
+  return (byte & (uint8_t)((~(0xFF << (uint8_t)num)) << (uint8_t)pos)) >> (uint8_t)pos;
+}
 
 void lwmqtt_write_bits(uint8_t *byte, uint8_t value, int pos, int num) {
-  *byte = (*byte & ~(uint8_t)((~(0xFF << num)) << pos)) | (value << pos);
+  *byte = (*byte & ~(uint8_t)((~(0xFFu << (uint8_t)num)) << (uint8_t)pos)) | (value << (uint8_t)pos);
 }
 
 lwmqtt_err_t lwmqtt_read_data(uint8_t **buf, const uint8_t *buf_end, uint8_t **data, size_t len) {
@@ -199,11 +201,11 @@ lwmqtt_err_t lwmqtt_read_varnum(uint8_t **buf, const uint8_t *buf_end, uint32_t
     byte = (*buf)[len - 1];
 
     // add byte to number
-    *varnum += (byte & 127) * multiplier;
+    *varnum += (byte & 127u) * multiplier;
 
     // increase multiplier
     multiplier *= 128;
-  } while ((byte & 128) != 0);
+  } while ((byte & 128u) != 0);
 
   // adjust pointer
   *buf += len;
@@ -235,7 +237,7 @@ lwmqtt_err_t lwmqtt_write_varnum(uint8_t **buf, const uint8_t *buf_end, uint32_t
 
     // set the top bit of this byte if there are more to encode
     if (varnum > 0) {
-      byte |= 0x80;
+      byte |= 0x80u;
     }
 
     // write byte

src/lwmqtt/lwmqtt.h

@@ -163,6 +163,9 @@ struct lwmqtt_client_t {
   void *command_timer;
   lwmqtt_timer_set_t timer_set;
   lwmqtt_timer_get_t timer_get;
+
+  bool drop_overflow;
+  uint32_t *overflow_counter;
 };
 
 /**
@@ -208,6 +211,16 @@ void lwmqtt_set_timers(lwmqtt_client_t *client, void *keep_alive_timer, void *co
  */
 void lwmqtt_set_callback(lwmqtt_client_t *client, void *ref, lwmqtt_callback_t cb);
 
+/**
+ * Will configure the client to drop packets that overflow the read buffer. If a counter is provided it will be
+ * incremented with each dropped packet.
+ *
+ * @param client - The client.
+ * @param enabled - Whether dropping is enabled.
+ * @param counter - The dropped packet counter.
+ */
+void lwmqtt_drop_overflow(lwmqtt_client_t *client, bool enabled, uint32_t *counter);
+
 /**
  * The object defining the last will of a client.
  */
@@ -271,7 +284,8 @@ lwmqtt_err_t lwmqtt_connect(lwmqtt_client_t *client, lwmqtt_options_t options, l
                             lwmqtt_return_code_t *return_code, uint32_t timeout);
 
 /**
- * Will send a publish packet and wait for all acks to complete.
+ * Will send a publish packet and wait for all acks to complete. If the encoded packet is bigger than the write buffer
+ * the function will return LWMQTT_BUFFER_TOO_SHORT without attempting to send the packet.
  *
  * Note: The message callback might be called with incoming messages as part of this call.
  *