feat: v1.8.5 (#164)

* Remove `note-c` before re-add
* Squashed 'src/note-c/' content from commit 693d3eb0

git-subtree-dir: src/note-c
git-subtree-split: 693d3eb0b10729548668cf770844be1011ec24bc

* Remove unneeded directories from `note-c`
* feat: v1.8.5
    Updated `note-c` dependency

Author: zfields

README.md

@@ -322,11 +322,11 @@ Inside the dev container:
    ```sh
    tio ~/.notestation/pid-<pid>_<hostname>/host_mcu_usb
    ```
-   
+
    > _**HINT:** The pseudo-tty devices are located in a folder related to the Notestattion reservations (e.g. `~/.notestation/pid-<pid>_<hostname>/<ptty_device>`)._
 
    > _**HINT:** The devices are named according to their function, for example `host_mcu_usb` is a connection to the host MCU USB._
-   
+
 ### Troubleshooting
 
 - Tailscale errors: Verify TS_AUTHKEY, restart containers.

library.properties

@@ -1,5 +1,5 @@
 name=Blues Wireless Notecard
-version=1.8.4
+version=1.8.5
 author=Blues
 maintainer=Blues <info@blues.com>
 sentence=An easy to use Notecard Library for Arduino.

src/NoteDefines.h

@@ -4,7 +4,7 @@
 // Define the version of the `note-arduino` library
 #define NOTE_ARDUINO_VERSION_MAJOR 1
 #define NOTE_ARDUINO_VERSION_MINOR 8
-#define NOTE_ARDUINO_VERSION_PATCH 4
+#define NOTE_ARDUINO_VERSION_PATCH 5
 
 #define NOTE_ARDUINO_VERSION NOTE_C_STRINGIZE(NOTE_ARDUINO_VERSION_MAJOR) "." NOTE_C_STRINGIZE(NOTE_ARDUINO_VERSION_MINOR) "." NOTE_C_STRINGIZE(NOTE_ARDUINO_VERSION_PATCH)
 

src/note-c/README.md

@@ -3,7 +3,7 @@
 # note-c
 
 The note-c C library for communicating with the
-[Blues Wireless][blues] Notecard via serial or I²C.
+[Blues Wireless][blues] Notecard via serial or I2C.
 
 This library allows you to control a Notecard by writing a C
 or C++ program. Your program may programmatically configure Notecard and send

src/note-c/n_atof.c

@@ -68,21 +68,22 @@
  */
 
 JNUMBER
-JAtoN(string, endPtr)
-const char *string;         /* A decimal ASCII floating-point number,
-                                 * optionally preceded by white space.
-                                 * Must have form "-I.FE-X", where I is the
-                                 * integer part of the mantissa, F is the
-                                 * fractional part of the mantissa, and X
-                                 * is the exponent.  Either of the signs
-                                 * may be "+", "-", or omitted.  Either I
-                                 * or F may be omitted, or both.  The decimal
-                                 * point isn't necessary unless F is present.
-                                 * The "E" may actually be an "e".  E and X
-                                 * may both be omitted (but not just one).
-                                 */
-char **endPtr;              /* If non-NULL, store terminating character's
-                                 * address here. */
+JAtoN(
+    const char *string, /* A decimal ASCII floating-point number,
+                         * optionally preceded by white space.
+                         * Must have form "-I.FE-X", where I is the
+                         * integer part of the mantissa, F is the
+                         * fractional part of the mantissa, and X
+                         * is the exponent.  Either of the signs
+                         * may be "+", "-", or omitted.  Either I
+                         * or F may be omitted, or both.  The decimal
+                         * point isn't necessary unless F is present.
+                         * The "E" may actually be an "e".  E and X
+                         * may both be omitted (but not just one).
+                         */
+    char **endPtr         /* If non-NULL, store terminating character's
+                           * address here. */
+)
 {
     int sign, expSign = FALSE;
     JNUMBER fraction;

src/note-c/n_cjson.c

@@ -362,12 +362,12 @@ NOTE_C_STATIC unsigned char* _ensure(printbuffer * const p, size_t needed)
         return NULL;
     }
 
+    needed += p->offset + 1;
     if (needed > INT_MAX) {
         /* sizes bigger than INT_MAX are currently not supported */
         return NULL;
     }
 
-    needed += p->offset + 1;
     if (needed <= p->length) {
         return p->buffer + p->offset;
     }
@@ -376,19 +376,8 @@ NOTE_C_STATIC unsigned char* _ensure(printbuffer * const p, size_t needed)
         return NULL;
     }
 
-    /* calculate new buffer size */
-    if (needed > (INT_MAX / 2)) {
-        /* overflow of int, use INT_MAX if possible */
-        if (needed <= INT_MAX) {
-            newsize = INT_MAX;
-        } else {
-            return NULL;
-        }
-    } else {
-        newsize = needed * 2;
-    }
-
     /* otherwise reallocate manually */
+    newsize = (ALLOC_CHUNK * ((needed / ALLOC_CHUNK) + ((needed % ALLOC_CHUNK) > 0)));  // chunked, linear calculation for new buffer to reduce memory waste
     newbuffer = (unsigned char*)_Malloc(newsize);
     if (!newbuffer) {
         _Free(p->buffer);
@@ -1819,9 +1808,12 @@ NOTE_C_STATIC Jbool _add_item_to_array(J *array, J *item)
 N_CJSON_PUBLIC(void) JAddItemToArray(J *array, J *item)
 {
     if (array == NULL || item == NULL) {
+        JDelete(item);
         return;
     }
-    _add_item_to_array(array, item);
+    if (!_add_item_to_array(array, item)) {
+        JDelete(item);
+    }
 }
 
 #if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
@@ -1874,34 +1866,46 @@ NOTE_C_STATIC Jbool _add_item_to_object(J * const object, const char * const str
 N_CJSON_PUBLIC(void) JAddItemToObject(J *object, const char *string, J *item)
 {
     if (object == NULL || string == NULL || item == NULL) {
+        JDelete(item);
         return;
     }
-    _add_item_to_object(object, string, item, false);
+    if (!_add_item_to_object(object, string, item, false)) {
+        JDelete(item);
+    }
 }
 
 /* Add an item to an object with constant string as key */
 N_CJSON_PUBLIC(void) JAddItemToObjectCS(J *object, const char *string, J *item)
 {
     if (object == NULL || string == NULL || item == NULL) {
+        JDelete(item);
         return;
     }
-    _add_item_to_object(object, string, item, true);
+    if (!_add_item_to_object(object, string, item, true)) {
+        JDelete(item);
+    }
 }
 
 N_CJSON_PUBLIC(void) JAddItemReferenceToArray(J *array, J *item)
 {
     if (array == NULL || item == NULL) {
         return;
     }
-    _add_item_to_array(array, _create_reference(item));
+    J *ref = _create_reference(item);
+    if (!_add_item_to_array(array, ref)) {
+        JDelete(ref);
+    }
 }
 
 N_CJSON_PUBLIC(void) JAddItemReferenceToObject(J *object, const char *string, J *item)
 {
     if (object == NULL || string == NULL || item == NULL) {
         return;
     }
-    _add_item_to_object(object, string, _create_reference(item), false);
+    J *ref = _create_reference(item);
+    if (!_add_item_to_object(object, string, ref, false)) {
+        JDelete(ref);
+    }
 }
 
 N_CJSON_PUBLIC(J*) JAddTrueToObject(J * const object, const char * const name)
@@ -2170,18 +2174,22 @@ N_CJSON_PUBLIC(void) JDeleteItemFromObjectCaseSensitive(J *object, const char *s
 N_CJSON_PUBLIC(void) JInsertItemInArray(J *array, int which, J *newitem)
 {
     if (array == NULL || newitem == NULL) {
+        JDelete(newitem);
         return;
     }
 
     J *after_inserted = NULL;
 
     if (which < 0) {
+        JDelete(newitem);
         return;
     }
 
     after_inserted = _get_array_item(array, (size_t)which);
     if (after_inserted == NULL) {
-        _add_item_to_array(array, newitem);
+        if (!_add_item_to_array(array, newitem)) {
+            JDelete(newitem);
+        }
         return;
     }
 
@@ -2228,14 +2236,18 @@ N_CJSON_PUBLIC(Jbool) JReplaceItemViaPointer(J * const parent, J * const item, J
 N_CJSON_PUBLIC(void) JReplaceItemInArray(J *array, int which, J *newitem)
 {
     if (array == NULL || newitem == NULL) {
+        JDelete(newitem);
         return;
     }
 
     if (which < 0) {
+        JDelete(newitem);
         return;
     }
 
-    JReplaceItemViaPointer(array, _get_array_item(array, (size_t)which), newitem);
+    if (!JReplaceItemViaPointer(array, _get_array_item(array, (size_t)which), newitem)) {
+        JDelete(newitem);
+    }
 }
 
 NOTE_C_STATIC Jbool _replace_item_in_object(J *object, const char *string, J *replacement, Jbool case_sensitive)
@@ -2244,32 +2256,48 @@ NOTE_C_STATIC Jbool _replace_item_in_object(J *object, const char *string, J *re
         return false;
     }
 
+    J *existing = _get_object_item(object, string, case_sensitive);
+    if (existing == NULL) {
+        return false;
+    }
+
+    char *new_key = (char*)_j_strdup((const unsigned char*)string);
+    if (new_key == NULL) {
+        return false;
+    }
+
     /* replace the name in the replacement */
     if (!(replacement->type & JStringIsConst) && (replacement->string != NULL)) {
         _Free(replacement->string);
     }
-    replacement->string = (char*)_j_strdup((const unsigned char*)string);
+    replacement->string = new_key;
     replacement->type &= ~JStringIsConst;
 
-    JReplaceItemViaPointer(object, _get_object_item(object, string, case_sensitive), replacement);
+    JReplaceItemViaPointer(object, existing, replacement);
 
     return true;
 }
 
 N_CJSON_PUBLIC(void) JReplaceItemInObject(J *object, const char *string, J *newitem)
 {
     if (object == NULL || newitem == NULL) {
+        JDelete(newitem);
         return;
     }
-    _replace_item_in_object(object, string, newitem, false);
+    if (!_replace_item_in_object(object, string, newitem, false)) {
+        JDelete(newitem);
+    }
 }
 
 N_CJSON_PUBLIC(void) JReplaceItemInObjectCaseSensitive(J *object, const char *string, J *newitem)
 {
     if (object == NULL || newitem == NULL) {
+        JDelete(newitem);
         return;
     }
-    _replace_item_in_object(object, string, newitem, true);
+    if (!_replace_item_in_object(object, string, newitem, true)) {
+        JDelete(newitem);
+    }
 }
 
 N_CJSON_PUBLIC(J *) JCreateTrue(void)

src/note-c/n_cjson_helpers.c

@@ -229,7 +229,7 @@ bool JAddBinaryToObject(J *json, const char *fieldName, const void *binaryData,
         return false;
     }
     JAddItemToObject(json, fieldName, stringItem);
-    return true;
+    return JIsPresent(json, fieldName);
 }
 
 bool JGetBinaryFromObject(J *json, const char *fieldName, uint8_t **retBinaryData, uint32_t *retBinaryDataLen)

src/note-c/n_cobs.c

@@ -244,20 +244,26 @@ uint32_t _cobsEncodedLength(const uint8_t *ptr, uint32_t length)
 
   @param  length Length of the data to encode
 
-  @return The max length required to encode the data
+  @return The max length required to encode the data (including EOP byte)
+
+  @note  Worst case is input with no zero bytes (no EOP markers to replace).
+         The COBS encoder always emits 1 initial code byte, then 1 additional
+         code byte for every 254 data bytes processed:
+
+           codeBytes = floor(length / 254) + 1
+
+         IMPORTANT: This is NOT ceil(length / 254). They differ at exact
+         multiples of 254. Example: encoding 254 non-zero bytes produces
+         code byte 0xFF, 254 data bytes, then a final code byte 0x01.
+         That's 2 code bytes, but ceil(254/254) = 1 (wrong).
 
-  @note  Since the contents of the buffer are unknown, then we must assume
-          that the entire buffer has no end-of-packet markers. This would
-          require the injection of overhead bytes (as opposed to the
-          replacement of end-of-packet markers with overhead bytes) at
-          intervals of 255, thus producing the worst case scenario.
   @note  An additional byte is added for the EOP (end-of-packet) marker.
  */
 /**************************************************************************/
 uint32_t _cobsEncodedMaxLength(uint32_t length)
 {
-    const uint32_t overheadBytes = (length == 0) + ((length != 0) * ((length / COBS_MAX_PACKET_SIZE) + ((length % COBS_MAX_PACKET_SIZE) > 0)));
-    return (length + overheadBytes + COBS_EOP_OVERHEAD);
+    const uint32_t codeBytes = (length / COBS_MAX_PACKET_SIZE) + 1;
+    return (length + codeBytes + COBS_EOP_OVERHEAD);
 }
 
 //**************************************************************************/
@@ -267,36 +273,40 @@ uint32_t _cobsEncodedMaxLength(uint32_t length)
 
   @param  bufLen Length of the buffer in bytes
 
-  @return the length of unencoded data
+  @return the length of unencoded data that is guaranteed to fit when
+          COBS-encoded into bufLen bytes (including EOP)
+
+  @note  The COBS encoder always emits 1 initial code byte, then 1 additional
+         code byte for every 254 data bytes. Therefore:
+
+           codeBytes(u) = floor(u / 254) + 1
+
+         IMPORTANT: This is NOT ceil(u / 254). They differ at exact multiples
+         of 254. Example: encoding 254 non-zero bytes produces code 0xFF,
+         254 data bytes, then final code 0x01 -- that's 2 code bytes, but
+         ceil(254/254) = 1 (wrong).
 
-  @note  An additional byte for the EOP (end-of-packet) marker is assumed.
+         Buffer requirement: bufLen >= u + floor(u/254) + 1 + 1(EOP)
+                                     = u + floor(u/254) + 2
+
+         Inversion: find max u where u + floor(u/254) <= t, with t = bufLen-2.
+         Substituting u = 254q + r (0 <= r <= 253): 255q + r <= t.
+
+         Closed form:  u = t - floor((t + 1) / 255)
+
+         Proof: Let t+1 = 255k + j (0 <= j <= 254), so u = 254k + j - 1.
+           j >= 1: floor(u/254)=k, u+floor(u/254) = 255k+j-1 = t. Exact fit.
+           j = 0:  u=254(k-1)+253, floor(u/254)=k-1, sum = t-1. One byte slack.
+         In both cases u+1 would exceed t, confirming u is the maximum.
+
+  @see _cobsEncodedMaxLength()
  */
 /**************************************************************************/
 uint32_t _cobsGuaranteedFit(uint32_t bufLen)
 {
-    // encodedLen = unencodedLen + codeBytesLen
-    // e = u + c (e = encoded (sorry Euler), and c = code bytes (sorry Einstein))
-    // u = e - c
-    // c = ⌈u / 254⌉ (the ceiling of u divided by 254)
-    //
-    // Rearranging the ceiling equation:
-    // (c - 1) < u / 254 <= c
-    // 254(c - 1) < u <= 254c
-    //
-    // Substitute u from first equation:
-    // 254(c - 1) < e - c <= 254c
-    // 254c - 254 < e - c <= 254c
-    // 255c < e + 254 AND e <= 255c
-    //
-    // Thus:
-    // e <= 255c < e + 254
-    // e / 255 <= c < (e + 254) / 255
-    //
-    // Knowing that c is an integer, we can express c as:
-    // c = ⌊(e + 254) / 255⌋ (the floor of (e + 254) divided by 255)
-    //
-    // Substitute c back into the original equation for u:
-    // u = e - ⌊(e + 254) / 255⌋
-    const uint32_t encodedLen = (bufLen == 0) + ((bufLen != 0) * (bufLen - COBS_EOP_OVERHEAD));
-    return (encodedLen - ((encodedLen + COBS_MAX_PACKET_SIZE) / 255));
+    if (bufLen <= 2) {
+        return 0;
+    }
+    const uint32_t t = bufLen - 2;
+    return (t - ((t + 1) / 255));
 }