feat: User Agent support (#56)

rayozzie · zfields · web-flow · commit 73cf92069655 · 2021-07-29T14:09:42.000-05:00
* add preliminary User Agent support

* remove note-c before re-add

* Squashed 'src/note-c/' content from commit fa5dca9

git-subtree-dir: src/note-c
git-subtree-split: fa5dca95fcc84368fbad997df4b4b86274a67fbc

* feat: User Agent Unit-tests

Co-authored-by: Zachary J. Fields &lt;zachary_fields@yahoo.com&gt;
diff --git a/src/Notecard.cpp b/src/Notecard.cpp
@@ -190,6 +190,7 @@ Notecard::~Notecard (void)
 /**************************************************************************/
 void Notecard::begin(uint32_t i2caddress, uint32_t i2cmax, TwoWire &wirePort)
 {
+    NoteSetUserAgent((char *)"note-arduino");
     NoteSetFnDefault(malloc, free, delay, millis);
     noteI2c = make_note_i2c(&wirePort);
 
@@ -211,6 +212,7 @@ void Notecard::begin(uint32_t i2caddress, uint32_t i2cmax, TwoWire &wirePort)
 /**************************************************************************/
 void Notecard::begin(HardwareSerial &selectedSerialPort, int selectedSpeed)
 {
+    NoteSetUserAgent((char *)"note-arduino");
     NoteSetFnDefault(malloc, free, delay, millis);
     noteSerial = make_note_serial(&selectedSerialPort, selectedSpeed);
 
diff --git a/src/note-c/n_hooks.c b/src/note-c/n_hooks.c
@@ -500,6 +500,23 @@ void NoteUnlockNote()
     }
 }
 
+//**************************************************************************/
+/*!
+  @brief  Get the active interface's name
+  @returns A string
+*/
+/**************************************************************************/
+const char *NoteActiveInterface()
+{
+    switch (hookActiveInterface) {
+    case interfaceSerial:
+        return "serial";
+    case interfaceI2C:
+        return "i2c";
+    }
+    return "unknown";
+}
+
 //**************************************************************************/
 /*!
   @brief  Reset the Serial bus using the platform-specific hook.
@@ -618,8 +635,8 @@ const char *NoteI2CReceive(uint16_t DevAddress, uint8_t* pBuffer, uint16_t Size,
 /**************************************************************************/
 uint32_t NoteI2CAddress()
 {
-    if (i2cAddress == NOTE_I2C_ADDR_DEFAULT) {
-        return 0x17;
+    if (i2cAddress == 0) {
+        return NOTE_I2C_ADDR_DEFAULT;
     }
     return i2cAddress;
 }
@@ -646,12 +663,12 @@ uint32_t NoteI2CMax()
 {
     // Many Arduino libraries (such as ESP32) have a limit less than 32, so if the max isn't specified
     // we must assume the worst and segment the I2C messages into very tiny chunks.
-    if (i2cMax == NOTE_I2C_MAX_DEFAULT) {
-        return 30;
+    if (i2cMax == 0) {
+        return NOTE_I2C_MAX_DEFAULT;
     }
     // Note design specs
-    if (i2cMax > 127) {
-        i2cMax = 127;
+    if (i2cMax > NOTE_I2C_MAX_MAX) {
+        i2cMax = NOTE_I2C_MAX_MAX;
     }
     return i2cMax;
 }
diff --git a/src/note-c/n_lib.h b/src/note-c/n_lib.h
@@ -83,6 +83,7 @@ bool serialNoteReset(void);
 // Hooks
 void NoteLockNote(void);
 void NoteUnlockNote(void);
+const char *NoteActiveInterface(void);
 bool NoteSerialReset(void);
 void NoteSerialTransmit(uint8_t *, size_t, bool);
 bool NoteSerialAvailable(void);
diff --git a/src/note-c/n_request.c b/src/note-c/n_request.c
@@ -312,6 +312,21 @@ char *NoteRequestResponseJSON(char *reqJSON)
 
 }
 
+/**************************************************************************/
+/*!
+    @brief  Override-able method to return user agent object
+  @returns a `J` cJSON object with the user agent object.
+*/
+/**************************************************************************/
+#if defined(_MSC_VER)
+J *noteUserAgent()
+#else
+__attribute__((weak)) J *noteUserAgent()
+#endif
+{
+    return NULL;
+}
+
 /**************************************************************************/
 /*!
     @brief  Initiate a transaction to the Notecard and return the response.
@@ -331,8 +346,22 @@ J *NoteTransaction(J *req)
         return NULL;
     }
 
+    // Determine the request or command type
+    const char *reqType = JGetString(req, "req");
+    const char *cmdType = JGetString(req, "cmd");
+
+    // Add the user agent object if appropriate
+#ifndef NOTE_DISABLE_USER_AGENT
+    if (!JIsPresent(req, "body") && (strcmp(reqType, "hub.set") == 0 || strcmp(cmdType, "hub.set"))) {
+        J *body = noteUserAgent();
+        if (body != NULL) {
+            JAddItemToObject(req, "body", body);
+        }
+    }
+#endif
+
     // Determine whether or not a response will be expected, by virtue of "cmd" being present
-    bool noResponseExpected = (JGetString(req, "req")[0] == '\0' && JGetString(req, "cmd")[0] != '\0');
+    bool noResponseExpected = (reqType[0] == '\0' && cmdType[0] != '\0');
 
     // If a reset of the module is required for any reason, do it now.
     // We must do this before acquiring lock.
diff --git a/src/note-c/n_ua.c b/src/note-c/n_ua.c
@@ -0,0 +1,186 @@
+/*!
+ * @file n_ua.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#ifndef NOTE_LOWMEM
+
+#include "n_lib.h"
+
+// Override-able statics
+static char *n_agent = "note-c";
+static char *n_os_name = NULL;
+static char *n_os_platform = NULL;
+static char *n_os_family = NULL;
+static char *n_os_version = NULL;
+static int n_cpu_mem = 0;
+static int n_cpu_mhz = 0;
+static int n_cpu_cores = 0;
+static char *n_cpu_vendor = NULL;
+static char *n_cpu_name = NULL;
+
+/**************************************************************************/
+/*!
+    @brief  Method to return user agent object
+  @returns a `J` cJSON object with the user agent object.
+*/
+/**************************************************************************/
+J *noteUserAgent()
+{
+
+    J *ua = JCreateObject();
+    if (ua == NULL) {
+        return ua;
+    }
+
+#if defined(__cplusplus)
+#define PLUS " c++"
+#else
+#define PLUS ""
+#endif
+
+#if defined(__ICCARM__)
+    char *compiler = "iar arm" PLUS " " __VER__;
+#elif defined(__IAR_SYSTEMS_ICC__)
+    char *compiler = "iar" PLUS " " __VER__;
+#elif defined(__clang__)
+    char *compiler = "clang" PLUS " " __VERSION__;
+#elif defined(__GNUC__)
+    char *compiler = "gcc" PLUS " " __VERSION__;
+#elif defined(__ATOLLIC__) && defined(__GNUC__)
+    char *compiler = "atollic gcc" PLUS " " __VERSION__;
+#elif defined(_MSC_FULL_VER)
+    char *compiler = "msc" PLUS " " _MSC_FULL_VER;
+#elif defined(__STDC_VERSION___)
+    char *compiler = "STDC" PLUS " " __STDC_VERSION__;
+#else
+    char *compiler = "unknown" PLUS " " __VERSION__
+#endif
+
+#if defined(ARDUINO_ARCH_ARC32)
+    char *arch = "arc32";
+#elif defined(ARDUINO_ARCH_AVR)
+    char *arch = "avr";
+#elif defined(ARDUINO_ARCH_ESP32)
+    char *arch = "esp32";
+#elif defined(ARDUINO_ARCH_ESP8266)
+    char *arch = "esp8266";
+#elif defined(ARDUINO_ARCH_MBED)
+    char *arch = "mbed";
+#elif defined(ARDUINO_ARCH_MEGAAVR)
+    char *arch = "megaavr";
+#elif defined(ARDUINO_ARCH_NRF52840)
+    char *arch = "nrf52840";
+#elif defined(ARDUINO_ARCH_NRF52)
+    char *arch = "nrf52";
+#elif defined(ARDUINO_ARCH_NRF51)
+    char *arch = "nrf51";
+#elif defined(ARDUINO_ARCH_PIC32)
+    char *arch = "pic32";
+#elif defined(ARDUINO_ARCH_SAMD)
+    char *arch = "samd";
+#elif defined(ARDUINO_ARCH_SAM)
+    char *arch = "sam";
+#elif defined(ARDUINO_ARCH_SPRESENSE)
+    char *arch = "spresence";
+#elif defined(ARDUINO_ARCH_STM32F0)
+    char *arch = "stm32f0";
+#elif defined(ARDUINO_ARCH_STM32F1)
+    char *arch = "stm32f1";
+#elif defined(ARDUINO_ARCH_STM32F4)
+    char *arch = "stm32f4";
+#elif defined(ARDUINO_ARCH_STM32G0)
+    char *arch = "stm32g0";
+#elif defined(ARDUINO_ARCH_STM32L4)
+    char *arch = "stm32f4";
+#elif defined(ARDUINO_ARCH_STM32U5)
+    char *arch = "stm32u5";
+#elif defined(ARDUINO_ARCH_STM32)
+    char *arch = "stm32";
+#else
+    char *arch = "";
+#endif
+
+    JAddStringToObject(ua, "agent", n_agent);
+    JAddStringToObject(ua, "compiler", compiler);
+    JAddStringToObject(ua, "req_interface", NoteActiveInterface());
+
+    if (n_cpu_mem != 0) {
+        JAddNumberToObject(ua, "cpu_mem", n_cpu_mem);
+    }
+    if (n_cpu_mhz != 0) {
+        JAddNumberToObject(ua, "cpu_mhz", n_cpu_mhz);
+    }
+    if (n_cpu_cores != 0) {
+        JAddNumberToObject(ua, "cpu_cores", n_cpu_cores);
+    }
+    if (n_cpu_vendor != NULL) {
+        JAddStringToObject(ua, "cpu_vendor", n_cpu_vendor);
+    }
+    if (n_cpu_name != NULL) {
+        JAddStringToObject(ua, "cpu_name", n_cpu_name);
+    }
+
+    if (n_os_name != NULL) {
+        JAddStringToObject(ua, "os_name", n_os_name);
+    }
+    if (n_os_platform != NULL) {
+        JAddStringToObject(ua, "os_platform", n_os_platform);
+    }
+    if (n_os_family != NULL) {
+        JAddStringToObject(ua, "os_family", n_os_family);
+    }
+    if (n_os_version != NULL) {
+        JAddStringToObject(ua, "os_version", n_os_version);
+    }
+
+    return ua;
+
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set key UA fields from a higher level library context
+*/
+/**************************************************************************/
+void NoteSetUserAgent(char *agent)
+{
+    n_agent = agent;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set key UA fields from a higher level library context
+*/
+/**************************************************************************/
+void NoteSetUserAgentOS(char *os_name, char *os_platform, char *os_family, char *os_version)
+{
+    n_os_name = os_name;
+    n_os_platform = os_platform;
+    n_os_family = os_family;
+    n_os_version = os_version;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set key UA fields from a higher level library context
+*/
+/**************************************************************************/
+void NoteSetUserAgentCPU(int cpu_mem, int cpu_mhz, int cpu_cores, char *cpu_vendor, char *cpu_name)
+{
+    n_cpu_mem = cpu_mem;
+    n_cpu_mhz = cpu_mhz;
+    n_cpu_cores = cpu_cores;
+    n_cpu_vendor = cpu_vendor;
+    n_cpu_name = cpu_name;
+}
+
+#endif
diff --git a/src/note-c/note.h b/src/note-c/note.h
@@ -126,12 +126,22 @@ void NoteSetFnMutex(mutexFn lockI2Cfn, mutexFn unlockI2Cfn, mutexFn lockNotefn,
 void NoteSetFnDefault(mallocFn mallocfn, freeFn freefn, delayMsFn delayfn, getMsFn millisfn);
 void NoteSetFn(mallocFn mallocfn, freeFn freefn, delayMsFn delayfn, getMsFn millisfn);
 void NoteSetFnSerial(serialResetFn resetfn, serialTransmitFn writefn, serialAvailableFn availfn, serialReceiveFn readfn);
-#define NOTE_I2C_ADDR_DEFAULT 0
-#define NOTE_I2C_MAX_DEFAULT  0
+#define NOTE_I2C_ADDR_DEFAULT	0x17
+#ifndef NOTE_I2C_MAX_DEFAULT
+#define NOTE_I2C_MAX_DEFAULT	30
+#endif
+#ifndef NOTE_I2C_MAX_MAX
+#define NOTE_I2C_MAX_MAX		127
+#endif
 void NoteSetFnI2C(uint32_t i2caddr, uint32_t i2cmax, i2cResetFn resetfn, i2cTransmitFn transmitfn, i2cReceiveFn receivefn);
 void NoteSetFnDisabled(void);
 void NoteSetI2CAddress(uint32_t i2caddress);
 
+// User agent
+void NoteSetUserAgent(char *agent);
+void NoteSetUserAgentOS(char *os_name, char *os_platform, char *os_family, char *os_version);
+void NoteSetUserAgentCPU(int cpu_mem, int cpu_mhz, int cpu_cores, char *cpu_vendor, char *cpu_name);
+
 // Calls to the functions set above
 void NoteDebug(const char *message);
 void NoteDebugln(const char *message);
diff --git a/test/Notecard.test.cpp b/test/Notecard.test.cpp
diff --git a/test/mock/mock-note-c-note.c b/test/mock/mock-note-c-note.c
diff --git a/test/mock/mock-parameters.hpp b/test/mock/mock-parameters.hpp

Original file line number	Diff line number	Diff line change
`@@ -190,6 +190,7 @@ Notecard::~Notecard (void)`
`190`	`190`	`/**************************************************************************/`
`191`	`191`	`void Notecard::begin(uint32_t i2caddress, uint32_t i2cmax, TwoWire &wirePort)`
`192`	`192`	`{`
	`193`	`+ NoteSetUserAgent((char *)"note-arduino");`
`193`	`194`	`NoteSetFnDefault(malloc, free, delay, millis);`
`194`	`195`	`noteI2c = make_note_i2c(&wirePort);`
`195`	`196`
`@@ -211,6 +212,7 @@ void Notecard::begin(uint32_t i2caddress, uint32_t i2cmax, TwoWire &wirePort)`
`211`	`212`	`/**************************************************************************/`
`212`	`213`	`void Notecard::begin(HardwareSerial &selectedSerialPort, int selectedSpeed)`
`213`	`214`	`{`
	`215`	`+ NoteSetUserAgent((char *)"note-arduino");`
`214`	`216`	`NoteSetFnDefault(malloc, free, delay, millis);`
`215`	`217`	`noteSerial = make_note_serial(&selectedSerialPort, selectedSpeed);`
`216`	`218`
Original file line number	Diff line number	Diff line change
`@@ -500,6 +500,23 @@ void NoteUnlockNote()`
`500`	`500`	`}`
`501`	`501`	`}`
`502`	`502`
	`503`	`+//**************************************************************************/`
	`504`	`+/*!`
	`505`	`+ @brief Get the active interface's name`
	`506`	`+ @returns A string`
	`507`	`+*/`
	`508`	`+/**************************************************************************/`
	`509`	`+const char *NoteActiveInterface()`
	`510`	`+{`
	`511`	`+ switch (hookActiveInterface) {`
	`512`	`+ case interfaceSerial:`
	`513`	`+ return "serial";`
	`514`	`+ case interfaceI2C:`
	`515`	`+ return "i2c";`
	`516`	`+ }`
	`517`	`+ return "unknown";`
	`518`	`+}`
	`519`	`+`
`503`	`520`	`//**************************************************************************/`
`504`	`521`	`/*!`
`505`	`522`	`@brief Reset the Serial bus using the platform-specific hook.`
`@@ -618,8 +635,8 @@ const char NoteI2CReceive(uint16_t DevAddress, uint8_t pBuffer, uint16_t Size,`
`618`	`635`	`/**************************************************************************/`
`619`	`636`	`uint32_t NoteI2CAddress()`
`620`	`637`	`{`
`621`		`- if (i2cAddress == NOTE_I2C_ADDR_DEFAULT) {`
`622`		`- return 0x17;`
	`638`	`+ if (i2cAddress == 0) {`
	`639`	`+ return NOTE_I2C_ADDR_DEFAULT;`
`623`	`640`	`}`
`624`	`641`	`return i2cAddress;`
`625`	`642`	`}`
`@@ -646,12 +663,12 @@ uint32_t NoteI2CMax()`
`646`	`663`	`{`
`647`	`664`	`// Many Arduino libraries (such as ESP32) have a limit less than 32, so if the max isn't specified`
`648`	`665`	`// we must assume the worst and segment the I2C messages into very tiny chunks.`
`649`		`- if (i2cMax == NOTE_I2C_MAX_DEFAULT) {`
`650`		`- return 30;`
	`666`	`+ if (i2cMax == 0) {`
	`667`	`+ return NOTE_I2C_MAX_DEFAULT;`
`651`	`668`	`}`
`652`	`669`	`// Note design specs`
`653`		`- if (i2cMax > 127) {`
`654`		`- i2cMax = 127;`
	`670`	`+ if (i2cMax > NOTE_I2C_MAX_MAX) {`
	`671`	`+ i2cMax = NOTE_I2C_MAX_MAX;`
`655`	`672`	`}`
`656`	`673`	`return i2cMax;`
`657`	`674`	`}`