chore:update note-c (#45)

Author: bsatrom

src/note-c/CONTRIBUTING.md

@@ -18,7 +18,7 @@ clean up inconsistent whitespace )
 * by closing [issues][]
 * by reviewing patches
 
-[issues]: https://blues.github.com/note-c/issues
+[issues]: https://github.com/blues/note-c/issues
 
 ## Submitting an Issue
 

src/note-c/n_const.c

@@ -19,8 +19,10 @@ const char *c_true = "true";
 const char *c_nullstring = "";
 const char *c_newline = "\r\n";
 const char *c_mem = "mem";
-const char *c_timeout = "timeout";
+const char *c_iotimeout = "timeout {io}";
 const char *c_err = "err";
 const char *c_req = "req";
 const char *c_cmd = "cmd";
 const char *c_bad = "bad";
+const char *c_iobad = "bad {io}";
+const char *c_ioerr = "{io}";

src/note-c/n_helpers.c

@@ -29,7 +29,9 @@ static uint32_t timeBaseSetAtMs = 0;
 static JTIME timeBaseSec = 0;
 static bool timeBaseSetManually = false;
 static uint32_t suppressionTimerSecs = 10;
+static uint32_t refreshTimerSecs = 86400;
 static uint32_t timeTimer = 0;
+static uint32_t timeRefreshTimer = 0;
 static bool zoneStillUnavailable = true;
 static bool zoneForceRefresh = false;
 static char curZone[10] = {0};
@@ -100,6 +102,19 @@ JTIME NoteTime()
     return NoteTimeST();
 }
 
+//**************************************************************************/
+/*!
+  @brief  Set the number of minutes between refreshes of the time
+          from the Notecard, to help minimize clock drift on this host.
+          Set this to 0 for no auto-refresh; it defaults to daily.
+  @returns Nothing
+*/
+/**************************************************************************/
+void NoteTimeRefreshMins(uint32_t mins)
+{
+    refreshTimerSecs = mins * 60;
+}
+
 //**************************************************************************/
 /*!
   @brief  Set the time.
@@ -201,9 +216,14 @@ JTIME NoteTimeST()
         timeBaseSetAtMs = nowMs;
     }
 
+    // If it's time to refresh the time, do so
+    if (refreshTimerSecs != 0 && timerExpiredSecs(&timeRefreshTimer, refreshTimerSecs)) {
+        timeTimer = 0;
+    }
+
     // If we haven't yet fetched the time, or if we still need the timezone, do so with a suppression
     // timer so that we don't hammer the module before it's had a chance to connect to the network to fetch time.
-    if (!timeBaseSetManually && (timeBaseSec == 0 || zoneStillUnavailable || zoneForceRefresh)) {
+    if (!timeBaseSetManually && (timeTimer == 0 || timeBaseSec == 0 || zoneStillUnavailable || zoneForceRefresh)) {
         if (timerExpiredSecs(&timeTimer, suppressionTimerSecs)) {
 
             // Request time and zone info from the card
@@ -213,10 +233,8 @@ JTIME NoteTimeST()
                     JTIME seconds = JGetInt(rsp, "time");
                     if (seconds != 0) {
 
-                        // Set the time if it hasn't yet been set
-                        if (timeBaseSec == 0) {
-                            setTime(seconds);
-                        }
+                        // Set the time
+                        setTime(seconds);
 
                         // Get the zone
                         char *z = JGetString(rsp, "zone");
@@ -246,7 +264,7 @@ JTIME NoteTimeST()
     }
 
     // Adjust the base time by the number of seconds that have elapsed since the base.
-    JTIME adjustedTime = timeBaseSec + ((nowMs - timeBaseSetAtMs) / 1000);
+    JTIME adjustedTime = timeBaseSec + (int32_t) (((int64_t) nowMs - (int64_t) timeBaseSetAtMs) / 1000);
 
     // Done
     return adjustedTime;

src/note-c/n_i2c.c

@@ -175,7 +175,7 @@ const char *i2cNoteTransaction(char *json, char **jsonResponse)
 #ifdef ERRDBG
             _Debug("reply to request didn't arrive from module in time\n");
 #endif
-            return ERRSTR("notecard request or response was lost",c_timeout);
+            return ERRSTR("request or response was lost {io}",c_iotimeout);
         }
 
         // Delay, simply waiting for the Note to process the request

src/note-c/n_lib.h

@@ -113,8 +113,8 @@ extern const char *c_newline;
 extern const char *c_mem;
 #define c_mem_len 3
 
-extern const char *c_timeout;
-#define c_timeout_len 7
+extern const char *c_iotimeout;
+#define c_iotimeout_len 12
 
 extern const char *c_err;
 #define c_err_len 3
@@ -128,6 +128,12 @@ extern const char *c_cmd;
 extern const char *c_bad;
 #define c_bad_len 3
 
+extern const char *c_iobad;
+#define c_iobad_len 8
+
+extern const char *c_ioerr;
+#define c_ioerr_len 4
+
 
 // Readability wrappers.  Anything starting with _ is simply calling the wrapper
 // function.

src/note-c/n_request.c

@@ -123,6 +123,70 @@ bool NoteRequest(J *req)
     return success;
 }
 
+/**************************************************************************/
+/*!
+    @brief  Send a request to the Notecard.
+            Frees the request structure from memory after sending the request.
+            Retries the request for up to the specified timeoutSeconds if there is
+            no response, or if the response indicates an io error.
+    @param   req
+               The `J` cJSON request object.
+             timeoutSeconds
+               Upper limit for retries if there is no response, or if the
+               response contains an io error.
+  @returns a boolean. Returns `true` if successful or `false` if an error
+            occurs, such as an out-of-memory or if an error was returned from
+            the transaction in the c_err field.
+*/
+/**************************************************************************/
+bool NoteRequestWithRetry(J *req, uint32_t timeoutSeconds)
+{
+    // Exit if null request.  This allows safe execution of the form NoteRequest(NoteNewRequest("xxx"))
+    if (req == NULL) {
+        return false;
+    }
+
+    J *rsp;
+
+    // Calculate expiry time in milliseconds
+    uint32_t expiresMs = _GetMs() + (timeoutSeconds * 1000);
+
+    while(true) {
+        // Execute the transaction
+        rsp = NoteTransaction(req);
+
+        // Loop if there is no response, or if there is an io error
+        if ( (rsp == NULL) || JContainsString(rsp, c_err, c_ioerr)) {
+
+            // Free error response
+            if (rsp != NULL) {
+                JDelete(rsp);
+            }
+        } else {
+
+            // Exit loop on non-null response without io error
+            break;
+        }
+
+        // Exit loop on timeout
+        if (_GetMs() >= expiresMs) {
+            break;
+        }
+    }
+
+    // Free the request
+    JDelete(req);
+
+    // If there is no response return false
+    if (rsp == NULL) {
+        return false;
+    }
+    // Check for a transaction error, and exit
+    bool success = JIsNullString(rsp, c_err);
+    JDelete(rsp);
+    return success;
+}
+
 /**************************************************************************/
 /*!
     @brief  Send a request to the Notecard and return the response.
@@ -150,6 +214,67 @@ J *NoteRequestResponse(J *req)
     return rsp;
 }
 
+/**************************************************************************/
+/*!
+    @brief  Send a request to the Notecard and return the response.
+            Frees the request structure from memory after sending the request.
+            Retries the request for up to the specified timeoutSeconds if there is
+            no response, or if the response indicates an io error.
+    @param   req
+               The `J` cJSON request object.
+             timeoutSeconds
+               Upper limit for retries if there is no response, or if the
+               response contains an io error.
+  @returns a `J` cJSON object with the response, or NULL if there is
+             insufficient memory.
+*/
+/**************************************************************************/
+J *NoteRequestResponseWithRetry(J *req, uint32_t timeoutSeconds)
+{
+    // Exit if null request.  This allows safe execution of the form NoteRequestResponse(NoteNewRequest("xxx"))
+    if (req == NULL) {
+        return NULL;
+    }
+
+    J *rsp;
+
+    // Calculate expiry time in milliseconds
+    uint32_t expiresMs = _GetMs() + (timeoutSeconds * 1000);
+
+    while(true) {
+        // Execute the transaction
+        rsp = NoteTransaction(req);
+
+        // Loop if there is no response, or if there is an io error
+        if ( (rsp == NULL) || JContainsString(rsp, c_err, c_ioerr)) {
+
+            // Free error response
+            if (rsp != NULL) {
+                JDelete(rsp);
+            }
+        } else {
+
+            // Exit loop on non-null response without io error
+            break;
+        }
+
+        // Exit loop on timeout
+        if (_GetMs() >= expiresMs) {
+            break;
+        }
+    }
+
+    // Free the request
+    JDelete(req);
+
+    if (rsp == NULL) {
+        return NULL;
+    }
+
+    // Return the response
+    return rsp;
+}
+
 /**************************************************************************/
 /*!
     @brief  Given a JSON string, send a request to the Notecard.
@@ -264,7 +389,7 @@ J *NoteTransaction(J *req)
         _Debug("invalid JSON: ");
         _Debug(responseJSON);
         _Free(responseJSON);
-        J *rsp = errDoc(ERRSTR("unrecognized response from card",c_bad));
+        J *rsp = errDoc(ERRSTR("unrecognized response from card {io}",c_iobad));
         _UnlockNote();
         return rsp;
     }

src/note-c/n_serial.c

@@ -60,7 +60,7 @@ const char *serialNoteTransaction(char *json, char **jsonResponse)
 #ifdef ERRDBG
             _Debug("reply to request didn't arrive from module in time\n");
 #endif
-            return ERRSTR("transaction timeout",c_timeout);
+            return ERRSTR("transaction timeout {io}",c_iotimeout);
         }
         _DelayMs(10);
     }
@@ -90,7 +90,7 @@ const char *serialNoteTransaction(char *json, char **jsonResponse)
                 _Debug("\n");
 #endif
                 _Free(jsonbuf);
-                return ERRSTR("transaction incomplete",c_timeout);
+                return ERRSTR("transaction incomplete {io}",c_iotimeout);
             }
             _DelayMs(1);
             continue;
@@ -103,7 +103,7 @@ const char *serialNoteTransaction(char *json, char **jsonResponse)
             _Debug("invalid data received on serial port from notecard\n");
 #endif
             _Free(jsonbuf);
-            return ERRSTR("serial communications error",c_timeout);
+            return ERRSTR("serial communications error {io}",c_iotimeout);
         }
 
         // Append into the json buffer

src/note-c/n_str.c

@@ -27,7 +27,11 @@
  * will be copied.  Always NUL terminates (unless siz == 0).
  * Returns strlen(src); if retval >= siz, truncation occurred.
  */
+#if defined(_MSC_VER)
+size_t strlcpy(char *dst, const char *src, size_t siz)
+#else
 __attribute__((weak)) size_t strlcpy(char *dst, const char *src, size_t siz)
+#endif
 {
     char *d = dst;
     const char *s = src;
@@ -61,7 +65,11 @@ __attribute__((weak)) size_t strlcpy(char *dst, const char *src, size_t siz)
  * Returns strlen(src) + MIN(siz, strlen(initial dst)).
  * If retval >= siz, truncation occurred.
  */
+#if defined(_MSC_VER)
+size_t strlcat(char *dst, const char *src, size_t siz)
+#else
 __attribute__((weak)) size_t strlcat(char *dst, const char *src, size_t siz)
+#endif
 {
     char *d = dst;
     const char *s = src;

src/note-c/note.h

@@ -103,6 +103,7 @@ void NoteResetRequired(void);
 J *NoteNewRequest(const char *request);
 J *NoteNewCommand(const char *request);
 J *NoteRequestResponse(J *req);
+J *NoteRequestResponseWithRetry(J *req, uint32_t timeoutSeconds);
 char *NoteRequestResponseJSON(char *reqJSON);
 void NoteSuspendTransactionDebug(void);
 void NoteResumeTransactionDebug(void);
@@ -113,6 +114,7 @@ void NoteResumeTransactionDebug(void);
 #define SYNCSTATUS_LEVEL_ALL          -1
 bool NoteDebugSyncStatus(int pollFrequencyMs, int maxLevel);
 bool NoteRequest(J *req);
+bool NoteRequestWithRetry(J *req, uint32_t timeoutms);
 #define NoteResponseError(rsp) (!JIsNullString(rsp, "err"))
 #define NoteResponseErrorContains(rsp, errstr) (JContainsString(rsp, "err", errstr))
 #define NoteDeleteResponse(rsp) JDelete(rsp)
@@ -206,6 +208,7 @@ bool NoteTimeValid(void);
 bool NoteTimeValidST(void);
 JTIME NoteTime(void);
 JTIME NoteTimeST(void);
+void NoteTimeRefreshMins(uint32_t mins);
 void NoteTimeSet(JTIME secondsUTC, int offset, char *zone, char *country, char *area);
 bool NoteLocalTimeST(uint16_t *retYear, uint8_t *retMonth, uint8_t *retDay, uint8_t *retHour, uint8_t *retMinute, uint8_t *retSecond, char **retWeekday, char **retZone);
 bool NoteRegion(char **retCountry, char **retArea, char **retZone, int *retZoneOffset);