Added NS filesystem and interface to application

Added interface for application to define file system interface.
Interface follows loosely the standard file system interface but with
constrains on what is possible on each operation. If application
callbacks are not set, functionality defaults to use standard
filesystem.

Converted Wi-SUN and Thread to use the new interface. Removed NVM TLV
lists from Wi-SUN and removed file version from Thread to unify and
simplify file system interface.

Author: Mika Leppänen

nanostack/ns_file_system.h

@@ -50,6 +50,109 @@ int ns_file_system_set_root_path(const char *root_path);
  */
 char *ns_file_system_get_root_path(void);
 
+/**
+ * \brief NS file handle
+ *
+ */
+typedef void *NS_FILE;
+
+/**
+ * File open callback
+ *
+ * Depending on underlying file system file open for read for non-existing
+ * files can return success. In that case file read will fail.
+ *
+ * \param filename filename
+ * \param mode can be either "r" or "w"
+ *
+ * \return file handle
+ * \return NULL on error
+ *
+ */
+typedef NS_FILE(*ns_file_open)(const char *filename, const char *mode);
+
+/**
+ * File close callback
+ *
+ * \param handle file handle
+ *
+ * \return 0 on success
+ * \return < 0 in case of errors
+ *
+ */
+typedef int (*ns_file_close)(NS_FILE *handle);
+
+/**
+ * File remove callback
+ *
+ * \param filename filename
+ *
+ * \return 0 on success
+ * \return < 0 in case of errors
+ *
+ */
+typedef int (*ns_file_remove)(const char *filename);
+
+/**
+ * File write callback
+ *
+ * Write is not stream write. The whole file is written from start to end
+ * and if function is called again, previous file content is replaced with
+ * new content.
+ *
+ * \param handle file handle
+ * \param buffer buffer
+ * \param buffer buffer size
+ *
+ * \return bytes written
+ *
+ */
+typedef size_t (*ns_file_write)(NS_FILE *handle, const void *buffer, size_t size);
+
+/**
+ * File read callback
+ *
+ * Read is not stream read. The whole file is read from start to end
+ * and if function is called again, read is started from start again.
+ *
+ * \param handle file handle
+ * \param buffer buffer
+ * \param size buffer size
+ *
+ * \return bytes written
+ *
+ */
+typedef size_t (*ns_file_read)(NS_FILE *handle, void *buffer, size_t size);
+
+/**
+ * File size callback
+ *
+ * Reads file size.
+ *
+ * \param handle file handle
+ * \param size file size
+ *
+ * \return 0 on success
+ * \return < 0 in case of reading file size is not supported
+ *
+ */
+typedef int (*ns_file_size)(NS_FILE *handle, size_t *size);
+
+/**
+ * File callbacks set
+ *
+ * Sets file handling callbacks to nanostack.
+ *
+ * \param open file open callback
+ * \param close file close callback
+ * \param remove file remove callback
+ * \param write file write callback
+ * \param read file read callback
+ * \param size file size callback
+ *
+ */
+void ns_file_system_callbacks_set(ns_file_open open, ns_file_close close, ns_file_remove remove, ns_file_write write, ns_file_read read, ns_file_size size);
+
 #ifdef __cplusplus
 }
 #endif

source/6LoWPAN/Thread/thread_nvm_store.c

@@ -34,7 +34,7 @@
 #include "nsconfig.h"
 
 #include <string.h>
-#include <stdio.h>
+#include "Service_Libs/utils/ns_file.h"
 #include "Core/include/ns_address_internal.h"
 #include "ns_file_system.h"
 #include "thread_config.h"
@@ -44,16 +44,13 @@
 
 #define TRACE_GROUP "tnvm"
 const char *FAST_DATA_FILE = "f_d";
-#define FAST_DATA_VERSION 1
 #define LINK_INFO_WRITE_DELAY 2
 #define LINK_INFO_SHORT_ADDR_NOT_SET 0xffff
 #define LINK_INFO_WRITE_DONE 0xffff
 
 const char *LINK_INFO_FILE = "l_i";
-#define LINK_INFO_DATA_VERSION 1
 
 const char *LEADER_INFO_FILE = "ld_i";
-#define LEADER_INFO_DATA_VERSION 1
 
 typedef struct {
     uint8_t mac[8];
@@ -67,18 +64,15 @@ typedef struct {
 } thread_nvm_store_link_info_t;
 
 const char *THREAD_NVM_ACTIVE_CONF_FILE = "a_c";
-#define ACTIVE_CONF_DATA_VERSION 1
 
 const char *DEVICE_CONF_FILE = "s_d";
-#define DEVICE_CONF_VERSION 1
 
 const char *THREAD_NVM_PENDING_CONF_FILE = "p_c";
-#define PENDING_CONF_DATA_VERSION 1
 
 static const char *thread_nvm_store_get_root_path(void);
 static int root_path_valid(void);
-static int thread_nvm_store_read(const char *file_name, void *data, uint32_t data_size, uint32_t *version);
-static int thread_nvm_store_write(const char *file_name, void *data, uint32_t data_size, uint32_t version);
+static int thread_nvm_store_read(const char *file_name, void *data, uint32_t data_size);
+static int thread_nvm_store_write(const char *file_name, void *data, uint32_t data_size);
 static void thread_nvm_store_create_path(char *fast_data_path, const char *file_name);
 static int thread_nvm_store_fast_data_save(thread_nvm_fast_data_t *fast_data_to_set);
 static int thread_nvm_store_all_counters_store(uint32_t mac_frame_counter, uint32_t mle_frame_counter, uint32_t seq_counter);
@@ -131,13 +125,12 @@ int thread_nvm_store_mleid_rloc_map_write(thread_nvm_mleid_rloc_map *mleid_rloc_
     }
     thread_nvm_store_create_path(lc_data_path, LEADER_INFO_FILE);
     tr_debug("writing to store rloc mapping info");
-    return thread_nvm_store_write(lc_data_path, mleid_rloc_map, sizeof(thread_nvm_mleid_rloc_map), LEADER_INFO_DATA_VERSION);
+    return thread_nvm_store_write(lc_data_path, mleid_rloc_map, sizeof(thread_nvm_mleid_rloc_map));
 }
 
 int thread_nvm_store_mleid_rloc_map_read(thread_nvm_mleid_rloc_map *mleid_rloc_map)
 {
     char lc_data_path[LEADER_INFO_STRING_LEN];
-    uint32_t version;
     if (NULL == mleid_rloc_map) {
         return THREAD_NVM_FILE_PARAMETER_INVALID;
     }
@@ -146,20 +139,14 @@ int thread_nvm_store_mleid_rloc_map_read(thread_nvm_mleid_rloc_map *mleid_rloc_m
     }
     thread_nvm_store_create_path(lc_data_path, LEADER_INFO_FILE);
 
-    int ret = thread_nvm_store_read(lc_data_path, mleid_rloc_map, sizeof(thread_nvm_mleid_rloc_map), &version);
+    int ret = thread_nvm_store_read(lc_data_path, mleid_rloc_map, sizeof(thread_nvm_mleid_rloc_map));
 
     if (THREAD_NVM_FILE_SUCCESS != ret) {
         tr_info("Leader data map read failed");
         thread_nvm_store_mleid_rloc_map_remove();
         return ret;
     }
 
-    if (LEADER_INFO_DATA_VERSION != version) {
-        tr_info("Leader data map version mismatch %"PRIu32, version);
-        thread_nvm_store_mleid_rloc_map_remove();
-        return THREAD_NVM_FILE_VERSION_WRONG;
-    }
-
     return ret;
 }
 
@@ -191,7 +178,7 @@ int thread_nvm_store_device_configuration_write(uint8_t *mac_ptr, uint8_t *mleid
     memcpy(d_c.mle_id, mleid_ptr, sizeof(d_c.mle_id));
     char device_conf_path[DEVICE_CONF_STRING_LEN];
     thread_nvm_store_create_path(device_conf_path, DEVICE_CONF_FILE);
-    return thread_nvm_store_write(device_conf_path, &d_c, sizeof(thread_nvm_device_conf_t), DEVICE_CONF_VERSION);
+    return thread_nvm_store_write(device_conf_path, &d_c, sizeof(thread_nvm_device_conf_t));
 }
 
 int thread_nvm_store_device_configuration_read(uint8_t *mac_ptr, uint8_t *mleid_ptr)
@@ -202,18 +189,12 @@ int thread_nvm_store_device_configuration_read(uint8_t *mac_ptr, uint8_t *mleid_
     }
     char device_conf_path[DEVICE_CONF_STRING_LEN];
     thread_nvm_store_create_path(device_conf_path, DEVICE_CONF_FILE);
-    uint32_t version;
     thread_nvm_device_conf_t d_c;
 
-    ret = thread_nvm_store_read(device_conf_path, &d_c, sizeof(thread_nvm_device_conf_t), &version);
+    ret = thread_nvm_store_read(device_conf_path, &d_c, sizeof(thread_nvm_device_conf_t));
     if (THREAD_NVM_FILE_SUCCESS == ret) {
-        if (THREAD_NVM_FILE_SUCCESS == ret && DEVICE_CONF_VERSION != version) {
-            tr_info("fast data version mismatch %"PRIu32, version);
-            ret = THREAD_NVM_FILE_VERSION_WRONG;
-        } else {
-            memcpy(mac_ptr, d_c.mac, sizeof(d_c.mac));
-            memcpy(mleid_ptr, d_c.mle_id, sizeof(d_c.mle_id));
-        }
+        memcpy(mac_ptr, d_c.mac, sizeof(d_c.mac));
+        memcpy(mleid_ptr, d_c.mle_id, sizeof(d_c.mle_id));
     }
     return ret;
 }
@@ -228,13 +209,12 @@ int thread_nvm_store_pending_configuration_write(void *data, uint16_t size)
         return THREAD_NVM_FILE_ROOT_PATH_INVALID;
     }
     thread_nvm_store_create_path(pc_data_path, THREAD_NVM_PENDING_CONF_FILE);
-    return thread_nvm_store_write(pc_data_path, data, size, PENDING_CONF_DATA_VERSION);
+    return thread_nvm_store_write(pc_data_path, data, size);
 }
 
 int thread_nvm_store_pending_configuration_read(void *data, uint16_t size)
 {
     char pc_data_path[PENDING_CONF_STRING_LEN];
-    uint32_t version;
     if (NULL == data) {
         return THREAD_NVM_FILE_PARAMETER_INVALID;
     }
@@ -243,11 +223,7 @@ int thread_nvm_store_pending_configuration_read(void *data, uint16_t size)
     }
     thread_nvm_store_create_path(pc_data_path, THREAD_NVM_PENDING_CONF_FILE);
 
-    int ret = thread_nvm_store_read(pc_data_path, data, size, &version);
-    if (THREAD_NVM_FILE_SUCCESS == ret && PENDING_CONF_DATA_VERSION != version) {
-        tr_info("Pending configuration version mismatch %"PRIu32, version);
-        return THREAD_NVM_FILE_VERSION_WRONG;
-    }
+    int ret = thread_nvm_store_read(pc_data_path, data, size);
     return ret;
 }
 
@@ -262,13 +238,12 @@ int thread_nvm_store_active_configuration_write(void *data, uint16_t data_size)
     }
 
     thread_nvm_store_create_path(ac_data_path, THREAD_NVM_ACTIVE_CONF_FILE);
-    return thread_nvm_store_write(ac_data_path, data, data_size, ACTIVE_CONF_DATA_VERSION);
+    return thread_nvm_store_write(ac_data_path, data, data_size);
 }
 
 int thread_nvm_store_active_configuration_read(void *data, uint16_t data_size)
 {
     char ac_data_path[ACTIVE_CONF_STRING_LEN];
-    uint32_t version;
     if (NULL == data) {
         return THREAD_NVM_FILE_PARAMETER_INVALID;
     }
@@ -277,11 +252,7 @@ int thread_nvm_store_active_configuration_read(void *data, uint16_t data_size)
     }
     thread_nvm_store_create_path(ac_data_path, THREAD_NVM_ACTIVE_CONF_FILE);
 
-    int ret = thread_nvm_store_read(ac_data_path, data, data_size, &version);
-    if (THREAD_NVM_FILE_SUCCESS == ret && ACTIVE_CONF_DATA_VERSION != version) {
-        tr_info("active configuration version mismatch %"PRIu32, version);
-        return THREAD_NVM_FILE_VERSION_WRONG;
-    }
+    int ret = thread_nvm_store_read(ac_data_path, data, data_size);
     return ret;
 }
 
@@ -399,12 +370,7 @@ int thread_nvm_store_fast_data_read(thread_nvm_fast_data_t *fast_data)
     if (root_path_valid()) {
         char fast_data_path[FAST_DATA_STRING_LEN];
         thread_nvm_store_create_path(fast_data_path, FAST_DATA_FILE);
-        uint32_t version;
-        ret = thread_nvm_store_read(fast_data_path, fast_data, sizeof(thread_nvm_fast_data_t), &version);
-        if (THREAD_NVM_FILE_SUCCESS == ret && FAST_DATA_VERSION != version) {
-            tr_info("fast data version mismatch %"PRIu32, version);
-            return THREAD_NVM_FILE_VERSION_WRONG;
-        }
+        ret = thread_nvm_store_read(fast_data_path, fast_data, sizeof(thread_nvm_fast_data_t));
     } else {
         fast_data->mac_frame_counter = cached_fast_data.mac_frame_counter;
         fast_data->mle_frame_counter = cached_fast_data.mle_frame_counter;
@@ -417,26 +383,19 @@ static int thread_nvm_store_fast_data_save(thread_nvm_fast_data_t *fast_data_to_
 {
     char fast_data_path[FAST_DATA_STRING_LEN];
     thread_nvm_store_create_path(fast_data_path, FAST_DATA_FILE);
-    return thread_nvm_store_write(fast_data_path, fast_data_to_set, sizeof(thread_nvm_fast_data_t), FAST_DATA_VERSION);
+    return thread_nvm_store_write(fast_data_path, fast_data_to_set, sizeof(thread_nvm_fast_data_t));
 }
 
-static int thread_nvm_store_write(const char *file_name, void *data, uint32_t data_size, uint32_t version)
+static int thread_nvm_store_write(const char *file_name, void *data, uint32_t data_size)
 {
-    FILE *fp = fopen(file_name, "w");
+    NS_FILE *fp = ns_fopen(file_name, "w");
     if (fp == NULL) {
         tr_error("NVM open error: %s", file_name);
         return THREAD_NVM_FILE_CANNOT_OPEN;
     }
 
-    size_t n_bytes = fwrite(&version, 1, sizeof(uint32_t), fp);
-    if (n_bytes != sizeof(uint32_t)) {
-        tr_warning("NVM version write error");
-        fclose(fp);
-        return THREAD_NVM_FILE_WRITE_ERROR;
-    }
-
-    n_bytes = fwrite(data, 1, data_size, fp);
-    fclose(fp);
+    size_t n_bytes = ns_fwrite(fp, data, data_size);
+    ns_fclose(fp);
     if (n_bytes != data_size) {
         tr_error("NVM write error %s", file_name);
         return THREAD_NVM_FILE_WRITE_ERROR;
@@ -446,23 +405,16 @@ static int thread_nvm_store_write(const char *file_name, void *data, uint32_t da
 }
 
 // returns 0 when ok
-static int thread_nvm_store_read(const char *file_name, void *data, uint32_t data_size, uint32_t *version)
+static int thread_nvm_store_read(const char *file_name, void *data, uint32_t data_size)
 {
-    FILE *fp = fopen(file_name, "r");
+    NS_FILE *fp = ns_fopen(file_name, "r");
     if (fp == NULL) {
         tr_warning("File not found: %s", file_name);
         return THREAD_NVM_FILE_CANNOT_OPEN;
     }
 
-    size_t n_bytes = fread(version, 1, sizeof(uint32_t), fp);
-    if (n_bytes != sizeof(uint32_t)) {
-        tr_warning("NVM version read error %s", file_name);
-        fclose(fp);
-        return THREAD_NVM_FILE_READ_ERROR;
-    }
-
-    n_bytes = fread(data, 1, data_size, fp);
-    fclose(fp);
+    size_t n_bytes = ns_fread(fp, data, data_size);
+    ns_fclose(fp);
     if (n_bytes != data_size) {
         tr_error("NVM read error %s", file_name);
         return THREAD_NVM_FILE_READ_ERROR;
@@ -488,8 +440,7 @@ int thread_nvm_store_link_info_read(void)
     strcpy(link_info_path, thread_nvm_store_get_root_path());
     strcat(link_info_path, LINK_INFO_FILE);
 
-    uint32_t version = 0;
-    status = thread_nvm_store_read(link_info_path, &nvm_link_info_tmp, sizeof(nvm_link_info_t), &version);
+    status = thread_nvm_store_read(link_info_path, &nvm_link_info_tmp, sizeof(nvm_link_info_t));
 
     if (status != THREAD_NVM_FILE_SUCCESS) {
         if (!memcmp(cached_link_info.nvm_link_info.mac, ADDR_UNSPECIFIED, 8) &&
@@ -499,9 +450,6 @@ int thread_nvm_store_link_info_read(void)
             return THREAD_NVM_FILE_READ_ERROR;
         }
         return status;
-    } else if (ACTIVE_CONF_DATA_VERSION != version) {
-        tr_info("link info version mismatch %"PRIu32, version);
-        return THREAD_NVM_FILE_VERSION_WRONG;
     }
     memcpy(cached_link_info.nvm_link_info.mac, nvm_link_info_tmp.mac, 8);
     cached_link_info.nvm_link_info.short_addr = nvm_link_info_tmp.short_addr;
@@ -597,7 +545,7 @@ static void thread_nvm_store_link_info_delayed_write(uint32_t seconds)
     strcpy(link_info_path, thread_nvm_store_get_root_path());
     strcat(link_info_path, LINK_INFO_FILE);
     tr_info("link info write parent mac: %s parent short addr: %"PRIu16, trace_array(cached_link_info.nvm_link_info.mac, 8), cached_link_info.nvm_link_info.short_addr);
-    thread_nvm_store_write(link_info_path, &cached_link_info.nvm_link_info, sizeof(nvm_link_info_t), LINK_INFO_DATA_VERSION);
+    thread_nvm_store_write(link_info_path, &cached_link_info.nvm_link_info, sizeof(nvm_link_info_t));
 }
 
 void thread_nvm_store_seconds_timer(uint32_t seconds)

source/6LoWPAN/ws/ws_pae_auth.c

@@ -28,6 +28,7 @@
 #include "eventOS_scheduler.h"
 #include "eventOS_event_timer.h"
 #include "ns_address.h"
+#include "Service_Libs/utils/ns_file.h"
 #include "NWK_INTERFACE/Include/protocol.h"
 #include "6LoWPAN/ws/ws_config.h"
 #include "Security/protocols/sec_prot_cfg.h"