Memfault Firmware SDK 0.28.0 (Build 370105)

Author: Memfault Inc

CHANGES.md

@@ -1,3 +1,36 @@
+### Changes between Memfault SDK 0.28.0 and SDK 0.27.3 - Jan 4, 2022
+
+#### :rocket: New Features
+
+- Add support for setting string metrics, see
+  `memfault_metrics_heartbeat_set_string()` in
+  [`components/include/memfault/metrics/metrics.h`](components/include/memfault/metrics/metrics.h)
+  for the new API. See the [Memfault Docs](https://mflt.io/embedded-metrics) for
+  general information on using the metrics API.
+- Updated `memfault_metrics_heartbeat_debug_print()` to also print current timer
+  values, instead of showing `0`. See
+  [`components/include/memfault/metrics/metrics.h`](components/include/memfault/metrics/metrics.h)
+  for details
+
+#### :chart_with_upwards_trend: Improvements
+
+- Update the STM32 QP/C example ([`examples/qp`](examples/qp)) to compile and
+  run correctly now
+- Add intructions for exercising Memfault OTA in the ESP32 example, see the
+  "Testing OTA" section in
+  [`examples/esp32/README.md`](examples/esp32/README.md)
+- Update the Memfault HTTP client to URL-encode query params when checking for
+  OTA updates (in the case of Device properties containing reserved characters,
+  eg `+`). Update the ESP port to check for reserved characters in query params
+  and emit an error
+- Fix an outdated comment in `cmake/Memfault.cmake`, as reported in
+  [issue #21](https://github.com/memfault/memfault-firmware-sdk/issues/21)
+  (thank you @C47D !)
+
+#### :house: Internal
+
+- Update Python tests to use a mocked-out gdb instance
+
 ### Changes between Memfault SDK 0.27.3 and SDK 0.27.2 - Nov 22, 2021
 
 #### :chart_with_upwards_trend: Improvements

VERSION

@@ -1,2 +1,2 @@
-BUILD ID: 347225
-GIT COMMIT: 3f66c9c5e
+BUILD ID: 370105
+GIT COMMIT: 4641213bd

cmake/Memfault.cmake

@@ -7,7 +7,7 @@
 #
 # set(MEMFAULT_SDK_ROOT <The path to the root of the memfault-firmware-sdk repo>)
 # list(APPEND MEMFAULT_COMPONENTS <The SDK components to be used, i.e "core util">)
-# include(${MEMFAULT_SDK_ROOT}/cmake/MemfaultWorker.cmake)
+# include(${MEMFAULT_SDK_ROOT}/cmake/Memfault.cmake)
 # memfault_library(${MEMFAULT_SDK_ROOT} MEMFAULT_COMPONENTS
 #   MEMFAULT_COMPONENTS_SRCS MEMFAULT_COMPONENTS_INC_FOLDERS)
 #

components/http/src/memfault_http_utils.c

@@ -8,14 +8,25 @@
 
 #include "memfault/http/utils.h"
 
+#include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
+#include <stdint.h>
 
 #include "memfault/core/compiler.h"
+#include "memfault/core/debug_log.h"
+#include "memfault/core/math.h"
 #include "memfault/core/platform/device_info.h"
 #include "memfault/http/http_client.h"
 
+//! Default buffer size for the URL-encoded device info parameters. This may
+//! need to be set higher by the user if there are particularly long device info
+//! strings
+#ifndef MEMFAULT_DEVICE_INFO_URL_ENCODED_MAX_LEN
+#define MEMFAULT_DEVICE_INFO_URL_ENCODED_MAX_LEN (48)
+#endif
+
 static bool prv_write_msg(MfltHttpClientSendCb write_callback, void *ctx,
                           const char *msg, size_t msg_len, size_t max_len) {
   if (msg_len >= max_len) {
@@ -153,19 +164,49 @@ bool memfault_http_get_latest_ota_payload_url(MfltHttpClientSendCb write_callbac
 
   #define MEMFAULT_STATIC_STRLEN(s) (sizeof(s) - 1)
 
-  if (!prv_write_qparam(write_callback, ctx,
-                        DEVICE_SERIAL_QPARAM, MEMFAULT_STATIC_STRLEN(DEVICE_SERIAL_QPARAM),
-                        device_info.device_serial) ||
-      !prv_write_qparam(write_callback, ctx,
-                        HARDWARE_VERSION_QPARAM, MEMFAULT_STATIC_STRLEN(HARDWARE_VERSION_QPARAM),
-                        device_info.hardware_version) ||
-      !prv_write_qparam(write_callback, ctx,
-                        SOFTWARE_TYPE_QPARAM, MEMFAULT_STATIC_STRLEN(SOFTWARE_TYPE_QPARAM),
-                        device_info.software_type) ||
-      !prv_write_qparam(write_callback, ctx,
-                        CURRENT_VERSION_QPARAM, MEMFAULT_STATIC_STRLEN(CURRENT_VERSION_QPARAM),
-                        device_info.software_version)) {
-    return false;
+  const struct qparam_values_s {
+    const char *name;
+    size_t name_strlen;
+    const char *value;
+  } qparam_values[] = {
+    {
+      DEVICE_SERIAL_QPARAM,
+      MEMFAULT_STATIC_STRLEN(DEVICE_SERIAL_QPARAM),
+      device_info.device_serial,
+    },
+    {
+      HARDWARE_VERSION_QPARAM,
+      MEMFAULT_STATIC_STRLEN(HARDWARE_VERSION_QPARAM),
+      device_info.hardware_version,
+    },
+    {
+      SOFTWARE_TYPE_QPARAM,
+      MEMFAULT_STATIC_STRLEN(SOFTWARE_TYPE_QPARAM),
+      device_info.software_type,
+    },
+    {
+      CURRENT_VERSION_QPARAM,
+      MEMFAULT_STATIC_STRLEN(CURRENT_VERSION_QPARAM),
+      device_info.software_version,
+    },
+  };
+
+  // URL encode the qparam values before writing them
+  for (size_t i = 0; i < MEMFAULT_ARRAY_SIZE(qparam_values); i++) {
+    const struct qparam_values_s *qparam_value = &qparam_values[i];
+
+    char qparam_encoded_buffer[MEMFAULT_DEVICE_INFO_URL_ENCODED_MAX_LEN];
+    int rv = memfault_http_urlencode(qparam_value->value, strlen(qparam_value->value),
+                                     qparam_encoded_buffer, sizeof(qparam_encoded_buffer));
+    if (rv != 0) {
+      MEMFAULT_LOG_ERROR("Failed to URL encode qparam value: %s", qparam_value->value);
+      return false;
+    }
+
+    if (!prv_write_qparam(write_callback, ctx, qparam_value->name, qparam_value->name_strlen,
+                          qparam_encoded_buffer)) {
+      return false;
+    }
   }
 
   #define LATEST_REQUEST_LINE_END " HTTP/1.1\r\n"
@@ -619,3 +660,50 @@ bool memfault_http_get_ota_payload(MfltHttpClientSendCb write_callback, void *ct
 
   return prv_write_crlf(write_callback, ctx);
 }
+
+static bool prv_is_unreserved(char c) {
+  return isalnum((uint8_t)c) || c == '-' || c == '_' || c == '.' || c == '~';
+}
+
+bool memfault_http_needs_escape(const char *str, size_t len) {
+  for (size_t i = 0; i < len; i++) {
+    if (!prv_is_unreserved(str[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+int memfault_http_urlencode(const char *inbuf, size_t inbuf_len, char *outbuf, size_t outbuf_len) {
+  // null check
+  if (!inbuf || !outbuf || !inbuf_len || !outbuf_len) {
+    return -1;
+  }
+
+  while (inbuf_len--) {
+    if (outbuf_len < 2) {
+      // ran out of room before encoding the full input, error. there needs to
+      // be 1 spare character for null term
+      return -1;
+    }
+    char c = *inbuf++;
+    if (prv_is_unreserved(c)) {
+      *outbuf++ = c;
+      outbuf_len--;
+    } else {
+      if (outbuf_len < 4) {
+        // not enough room for encoded character and null term
+        return -1;
+      }
+      // paste encoding (+ null term)
+      snprintf(outbuf, 4, "%%%02X", (uint8_t)c);
+      outbuf += 3;
+      outbuf_len -= 3;
+    }
+  }
+
+  // null terminate
+  *outbuf = '\0';
+
+  return 0;
+}

components/include/memfault/core/compiler_armcc.h

@@ -37,6 +37,8 @@ extern "C" {
 #define MEMFAULT_STATIC_ASSERT(expr, msg) \
     enum {MEMFAULT_CONCAT(MEMFAULT_ASSERTION_AT_, __LINE__) = sizeof(char[(expr) ? 1 : -1])}
 
+#define MEMFAULT_DISABLE_WARNING(warning)
+
 #ifdef __cplusplus
 }
 #endif

components/include/memfault/core/compiler_gcc.h

@@ -79,6 +79,18 @@ extern "C" {
 #  define MEMFAULT_STATIC_ASSERT(cond, msg) _Static_assert(cond, msg)
 #endif
 
+// Macro for disabling specific warnings. There must be quotes in the argument
+// to expand correctly to eg _Pragma("GCC diagnostic ignored \"warning-name\"")
+// Example:
+// MEMFAULT_DISABLE_WARNING("-Wunused-macros")
+#if defined(__clang__)
+#define MEMFAULT_PRAGMA_PREFIX clang
+#else
+#define MEMFAULT_PRAGMA_PREFIX GCC
+#endif
+#define MEMFAULT_DISABLE_WARNING(warning) \
+  _Pragma(MEMFAULT_EXPAND_AND_QUOTE(MEMFAULT_PRAGMA_PREFIX diagnostic ignored warning))
+
 #ifdef __cplusplus
 }
 #endif

components/include/memfault/core/compiler_iar.h

@@ -36,6 +36,8 @@ extern "C" {
 
 #define MEMFAULT_STATIC_ASSERT(cond, msg) static_assert(cond, msg)
 
+#define MEMFAULT_DISABLE_WARNING(warning)
+
 #ifdef __cplusplus
 }
 #endif

components/include/memfault/core/compiler_ti_arm.h

@@ -72,6 +72,8 @@ static uint32_t __get_PSP(void) {
 #  define MEMFAULT_STATIC_ASSERT(cond, msg) _Static_assert(cond, msg)
 #endif
 
+#define MEMFAULT_DISABLE_WARNING(warning)
+
 #ifdef __cplusplus
 }
 #endif

components/include/memfault/http/utils.h

@@ -188,6 +188,24 @@ typedef struct {
 //! @return true if parse was successful and uri_info_out is populated, false  otherwise
 bool memfault_http_parse_uri(const char *uri, size_t uri_len, sMemfaultUriInfo *uri_info_out);
 
+//! Check if a string contains any characters that require URL escaping
+//!
+//! @param str the string to check
+//! @param len length of str
+//!
+//! @return true if any characters in str require URL escaping, false otherwise
+bool memfault_http_needs_escape(const char *str, size_t len);
+
+//! URL encode a string. See https://www.ietf.org/rfc/rfc3986.html#section-2.1
+//!
+//! @param inbuf String to encode; must be null-terminated
+//! @param[out] outbuf Endcoded string. Should be sized to fit possible encoding
+//! overhead, eg 3 * strlen(inbuf)
+//! @param outbuf_len Size of outbuf
+//!
+//! @return 0 if encoding was successful, non zero otherwise
+int memfault_http_urlencode(const char *inbuf, size_t inbuf_len, char *outbuf, size_t outbuf_len);
+
 #ifdef __cplusplus
 }
 #endif

components/include/memfault/metrics/ids_impl.h

@@ -18,17 +18,24 @@ extern "C" {
 #define MEMFAULT_METRICS_KEY_DEFINE_WITH_RANGE(key_name, value_type, _min, _max) \
   MEMFAULT_METRICS_KEY_DEFINE(key_name, value_type)
 
+#define MEMFAULT_METRICS_STRING_KEY_DEFINE(key_name, max_length) \
+  MEMFAULT_METRICS_KEY_DEFINE(key_name, _)
+
 #define MEMFAULT_METRICS_KEY_DEFINE(key_name, value_type) \
   extern const char * const g_memfault_metrics_id_##key_name;
 #include "memfault/metrics/heartbeat_config.def"
 #include MEMFAULT_METRICS_USER_HEARTBEAT_DEFS_FILE
 #undef MEMFAULT_METRICS_KEY_DEFINE
 #undef MEMFAULT_METRICS_KEY_DEFINE_WITH_RANGE
+#undef MEMFAULT_METRICS_STRING_KEY_DEFINE
 
 //! Generate an enum for all IDs (used for indexing into values)
 #define MEMFAULT_METRICS_KEY_DEFINE_WITH_RANGE(key_name, value_type, min_value, max_value) \
   MEMFAULT_METRICS_KEY_DEFINE(key_name, value_type)
 
+#define MEMFAULT_METRICS_STRING_KEY_DEFINE(key_name, max_length) \
+  MEMFAULT_METRICS_KEY_DEFINE(key_name, _)
+
 #define MEMFAULT_METRICS_KEY_DEFINE(key_name, value_type) \
   kMfltMetricsIndex_##key_name,
 
@@ -37,11 +44,13 @@ typedef enum MfltMetricsIndex {
   #include MEMFAULT_METRICS_USER_HEARTBEAT_DEFS_FILE
   #undef MEMFAULT_METRICS_KEY_DEFINE
   #undef MEMFAULT_METRICS_KEY_DEFINE_WITH_RANGE
+  #undef MEMFAULT_METRICS_STRING_KEY_DEFINE
 } eMfltMetricsIndex;
 
-#define _MEMFAULT_METRICS_KEY_DEFINE(key_name, value_type) \
+//! Stub define to detect accidental usage outside of the heartbeat config files
+#define MEMFAULT_METRICS_KEY_DEFINE_TRAP_() \
   MEMFAULT_STATIC_ASSERT(false, \
-    "MEMFAULT_METRICS_KEY_DEFINE should only be used in " MEMFAULT_METRICS_USER_HEARTBEAT_DEFS_FILE)
+    "MEMFAULT_METRICS_KEY_DEFINE should only be used in " MEMFAULT_METRICS_USER_HEARTBEAT_DEFS_FILE);
 
 //! NOTE: Access to a key should _always_ be made via the MEMFAULT_METRICS_KEY() macro to ensure source
 //! code compatibility with future APIs updates