PYFW-401: Mutex of LFS can be locked in wlan_read_file or mod_ssl_rea…

…d_file

esp32/application.mk

@@ -185,6 +185,7 @@ APP_UTIL_SRC_C = $(addprefix util/,\
 	mpsleep.c \
 	timeutils.c \
 	esp32chipinfo.c \
+	pycom_general_util.c \
 	)
 
 APP_FATFS_SRC_C = $(addprefix fatfs/src/,\

esp32/mods/modussl.c

@@ -27,22 +27,16 @@
 #include "modusocket.h"
 #include "modussl.h"
 #include "mptask.h"
+#include "pycom_general_util.h"
 
-#include "ff.h"
-#include "lfs.h"
-#include "extmod/vfs.h"
-
-#include "mptask.h"
 /******************************************************************************
  DEFINE CONSTANTS
  ******************************************************************************/
-#define FILE_READ_SIZE                              256
 #define DEFAULT_SSL_READ_TIMEOUT                    10 //sec
 
 /******************************************************************************
  DECLARE PRIVATE FUNCTIONS
  ******************************************************************************/
-static char *mod_ssl_read_file (const char *file_path, vstr_t *vstr);
 
 /******************************************************************************
  DECLARE PRIVATE DATA
@@ -176,79 +170,6 @@ static int32_t mod_ssl_setup_socket (mp_obj_ssl_socket_t *ssl_sock, const char *
     return 0;
 }
 
-static char *mod_ssl_read_file (const char *file_path, vstr_t *vstr) {
-    vstr_init(vstr, FILE_READ_SIZE);
-    char *filebuf = vstr->buf;
-    mp_uint_t actualsize;
-    mp_uint_t totalsize = 0;
-    static const TCHAR *path_relative;
-
-    if(isLittleFs(file_path))
-    {
-        vfs_lfs_struct_t* littlefs = lookup_path_littlefs(file_path, &path_relative);
-        if (littlefs == NULL) {
-            return NULL;
-        }
-
-        lfs_file_t fp;
-
-        xSemaphoreTake(littlefs->mutex, portMAX_DELAY);
-
-        int res = lfs_file_open(&littlefs->lfs, &fp, path_relative, LFS_O_RDONLY);
-        if(res < LFS_ERR_OK)
-        {
-            return NULL;
-        }
-
-        while (true) {
-            actualsize = lfs_file_read(&littlefs->lfs, &fp, filebuf, FILE_READ_SIZE);
-            if (actualsize < LFS_ERR_OK) {
-                return NULL;
-            }
-            totalsize += actualsize;
-            if (actualsize < FILE_READ_SIZE) {
-                break;
-            } else {
-                filebuf = vstr_extend(vstr, FILE_READ_SIZE);
-            }
-        }
-        lfs_file_close(&littlefs->lfs, &fp);
-
-        xSemaphoreGive(littlefs->mutex);
-
-    }
-    else
-    {
-        FATFS *fs = lookup_path_fatfs(file_path, &path_relative);
-        if (fs == NULL) {
-            return NULL;
-        }
-        FIL fp;
-        FRESULT res = f_open(fs, &fp, path_relative, FA_READ);
-        if (res != FR_OK) {
-            return NULL;
-        }
-
-        while (true) {
-            FRESULT res = f_read(&fp, filebuf, FILE_READ_SIZE, (UINT *)&actualsize);
-            if (res != FR_OK) {
-                f_close(&fp);
-                return NULL;
-            }
-            totalsize += actualsize;
-            if (actualsize < FILE_READ_SIZE) {
-                break;
-            } else {
-                filebuf = vstr_extend(vstr, FILE_READ_SIZE);
-            }
-        }
-        f_close(&fp);
-    }
-
-    vstr->len = totalsize;
-    vstr_null_terminated_str(vstr);
-    return vstr->buf;
-}
 
 /******************************************************************************/
 // Micro Python bindings; SSL class
@@ -310,7 +231,7 @@ STATIC mp_obj_t mod_ssl_wrap_socket(mp_uint_t n_args, const mp_obj_t *pos_args,
 
     const char *ca_cert = NULL;
     if (cafile_path) {
-        ca_cert = mod_ssl_read_file(cafile_path, &ssl_sock->vstr_ca);
+        ca_cert = pycom_util_read_file(cafile_path, &ssl_sock->vstr_ca);
         if(ca_cert == NULL) {
             nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "CA file not found"));
         }
@@ -319,11 +240,11 @@ STATIC mp_obj_t mod_ssl_wrap_socket(mp_uint_t n_args, const mp_obj_t *pos_args,
     const char *client_cert = NULL;
     const char *client_key = NULL;
     if (certfile_path && keyfile_path) {
-        client_cert = mod_ssl_read_file(certfile_path, &ssl_sock->vstr_ca);
+        client_cert = pycom_util_read_file(certfile_path, &ssl_sock->vstr_ca);
         if(client_cert == NULL) {
             nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "certificate file not found"));
         }
-        client_key = mod_ssl_read_file(keyfile_path, &ssl_sock->vstr_ca);
+        client_key = pycom_util_read_file(keyfile_path, &ssl_sock->vstr_ca);
         if(client_key == NULL) {
             nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "key file not found"));
         }

esp32/mods/modwlan.c

@@ -29,9 +29,6 @@
 #include "esp_wifi.h"
 #include "esp_wifi_types.h"
 #include "esp_event_loop.h"
-#include "ff.h"
-#include "lfs.h"
-#include "vfs_littlefs.h"
 #include "esp_wpa2.h"
 #include "esp_smartconfig.h"
 
@@ -58,6 +55,7 @@
 #include "mpirq.h"
 #include "mptask.h"
 #include "pycom_config.h"
+#include "pycom_general_util.h"
 
 /******************************************************************************
  DEFINE TYPES
@@ -67,7 +65,6 @@
  DEFINE CONSTANTS
  ******************************************************************************/
 
-#define FILE_READ_SIZE                      256
 #define BSSID_MAX_SIZE                        6
 #define MAX_WLAN_KEY_SIZE                    65
 #define MAX_AP_CONNECTED_STA                4
@@ -164,7 +161,6 @@ STATIC void wlan_set_antenna (uint8_t antenna);
 static esp_err_t wlan_event_handler(void *ctx, system_event_t *event);
 STATIC void wlan_do_connect (const char* ssid, const char* bssid, const wifi_auth_mode_t auth, const char* key, int32_t timeout, const wlan_wpa2_ent_obj_t * const wpa2_ent, const char *hostname, uint8_t channel);
 static void wlan_init_wlan_recover_params(void);
-static char *wlan_read_file (const char *file_path, vstr_t *vstr);
 static void wlan_timer_callback( TimerHandle_t xTimer );
 static void wlan_validate_country(const char * country);
 static void wlan_validate_country_policy(uint8_t policy);
@@ -746,7 +742,7 @@ STATIC void wlan_do_connect (const char* ssid, const char* bssid, const wifi_aut
     if (auth == WIFI_AUTH_WPA2_ENTERPRISE) {
         // CA Certificate is not mandatory
         if (wpa2_ent->ca_certs_path != NULL) {
-            if (wlan_read_file(wpa2_ent->ca_certs_path, &wlan_obj.vstr_ca)) {
+            if (pycom_util_read_file(wpa2_ent->ca_certs_path, &wlan_obj.vstr_ca)) {
                 if (ESP_OK != esp_wifi_sta_wpa2_ent_set_ca_cert((unsigned char*)wlan_obj.vstr_ca.buf, (int)wlan_obj.vstr_ca.len)) {
                     goto os_error;
                 }
@@ -757,7 +753,7 @@ STATIC void wlan_do_connect (const char* ssid, const char* bssid, const wifi_aut
 
         // client certificate is necessary only in EAP-TLS method, this is ensured by wlan_validate_certificates() function
         if (wpa2_ent->client_key_path != NULL && wpa2_ent->client_cert_path != NULL) {
-            if (wlan_read_file(wpa2_ent->client_key_path, &wlan_obj.vstr_key) && wlan_read_file(wpa2_ent->client_cert_path, &wlan_obj.vstr_cert)) {
+            if (pycom_util_read_file(wpa2_ent->client_key_path, &wlan_obj.vstr_key) && pycom_util_read_file(wpa2_ent->client_cert_path, &wlan_obj.vstr_cert)) {
                 if (ESP_OK != esp_wifi_sta_wpa2_ent_set_cert_key((unsigned char*)wlan_obj.vstr_cert.buf, (int)wlan_obj.vstr_cert.len,
                                                                  (unsigned char*)wlan_obj.vstr_key.buf, (int)wlan_obj.vstr_key.len, NULL, 0)) {
                     goto os_error;
@@ -822,78 +818,6 @@ STATIC void wlan_do_connect (const char* ssid, const char* bssid, const wifi_aut
     nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
 }
 
-STATIC char *wlan_read_file (const char *file_path, vstr_t *vstr) {
-    vstr_init(vstr, FILE_READ_SIZE);
-    char *filebuf = vstr->buf;
-    mp_uint_t actualsize;
-    mp_uint_t totalsize = 0;
-    static const TCHAR *path_relative;
-
-    if(isLittleFs(file_path))
-    {
-        vfs_lfs_struct_t* littlefs = lookup_path_littlefs(file_path, &path_relative);
-        if (littlefs == NULL) {
-            return NULL;
-        }
-
-        xSemaphoreTake(littlefs->mutex, portMAX_DELAY);
-
-        lfs_file_t fp;
-        int res = lfs_file_open(&littlefs->lfs, &fp, path_relative, LFS_O_RDONLY);
-        if(res < LFS_ERR_OK)
-        {
-            return NULL;
-        }
-
-        while (true) {
-            actualsize = lfs_file_read(&littlefs->lfs, &fp, filebuf, FILE_READ_SIZE);
-            if (actualsize < LFS_ERR_OK) {
-                return NULL;
-            }
-            totalsize += actualsize;
-            if (actualsize < FILE_READ_SIZE) {
-                break;
-            } else {
-                filebuf = vstr_extend(vstr, FILE_READ_SIZE);
-            }
-        }
-        lfs_file_close(&littlefs->lfs, &fp);
-
-        xSemaphoreGive(littlefs->mutex);
-
-    }
-    else
-    {
-        FATFS *fs = lookup_path_fatfs(file_path, &path_relative);
-        if (fs == NULL) {
-            return NULL;
-        }
-        FIL fp;
-        FRESULT res = f_open(fs, &fp, path_relative, FA_READ);
-        if (res != FR_OK) {
-            return NULL;
-        }
-
-        while (true) {
-            FRESULT res = f_read(&fp, filebuf, FILE_READ_SIZE, (UINT *)&actualsize);
-            if (res != FR_OK) {
-                f_close(&fp);
-                return NULL;
-            }
-            totalsize += actualsize;
-            if (actualsize < FILE_READ_SIZE) {
-                break;
-            } else {
-                filebuf = vstr_extend(vstr, FILE_READ_SIZE);
-            }
-        }
-        f_close(&fp);
-    }
-
-    vstr->len = totalsize;
-    vstr_null_terminated_str(vstr);
-    return vstr->buf;
-}
 
 static void wlan_init_wlan_recover_params(void)
 {

esp32/util/pycom_general_util.c

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2019, Pycom Limited.
+ *
+ * This software is licensed under the GNU GPL version 3 or any
+ * later version, with permitted additional terms. For more information
+ * see the Pycom Licence v1.0 document supplied with this file, or
+ * available at https://www.pycom.io/opensource/licensing
+ */
+
+#include <string.h>
+
+#include "freertos/FreeRTOS.h"
+
+#include "py/mpconfig.h"
+#include "py/runtime.h"
+#include "mptask.h"
+#include "pycom_general_util.h"
+
+
+/******************************************************************************
+ DEFINE CONSTANTS
+ ******************************************************************************/
+#define FILE_READ_SIZE                              256
+
+/******************************************************************************
+ DEFINE PUBLIC FUNCTIONS
+ ******************************************************************************/
+char *pycom_util_read_file (const char *file_path, vstr_t *vstr) {
+    vstr_init(vstr, FILE_READ_SIZE);
+    char *filebuf = vstr->buf;
+    mp_uint_t actualsize;
+    mp_uint_t totalsize = 0;
+    static const TCHAR *path_relative;
+    // THis is needed to be able to clean the VSTR if any error occurred
+    bool error = false;
+
+    if(isLittleFs(file_path)) {
+
+        vfs_lfs_struct_t* littlefs = lookup_path_littlefs(file_path, &path_relative);
+        if (littlefs == NULL) {
+            error = true;
+        }
+        else {
+
+            lfs_file_t fp;
+
+            xSemaphoreTake(littlefs->mutex, portMAX_DELAY);
+
+            int res = lfs_file_open(&littlefs->lfs, &fp, path_relative, LFS_O_RDONLY);
+            if(res < LFS_ERR_OK) {
+                error = true;
+            }
+            else {
+                while (error == false) {
+                    actualsize = lfs_file_read(&littlefs->lfs, &fp, filebuf, FILE_READ_SIZE);
+                    if (actualsize < LFS_ERR_OK) {
+                        error = true;
+                    }
+                    else {
+                        totalsize += actualsize;
+                        if (actualsize < FILE_READ_SIZE) {
+                            break;
+                        } else {
+                            filebuf = vstr_extend(vstr, FILE_READ_SIZE);
+                        }
+                    }
+                }
+
+                lfs_file_close(&littlefs->lfs, &fp);
+            }
+
+            xSemaphoreGive(littlefs->mutex);
+        }
+    }
+    else
+    {
+        FATFS *fs = lookup_path_fatfs(file_path, &path_relative);
+        if (fs == NULL) {
+            error = true;
+        }
+        else {
+            FIL fp;
+            FRESULT res = f_open(fs, &fp, path_relative, FA_READ);
+            if (res != FR_OK) {
+                error = true;
+            }
+            else {
+                while (error == false) {
+                    FRESULT res = f_read(&fp, filebuf, FILE_READ_SIZE, (UINT *)&actualsize);
+                    if (res != FR_OK) {
+                        f_close(&fp);
+                        error = true;
+                    }
+                    else {
+                        totalsize += actualsize;
+                        if (actualsize < FILE_READ_SIZE) {
+                            break;
+                        } else {
+                            filebuf = vstr_extend(vstr, FILE_READ_SIZE);
+                        }
+                    }
+                }
+                f_close(&fp);
+            }
+        }
+    }
+
+    if(error == true) {
+        vstr_clear(vstr);
+        return NULL;
+    }
+    else {
+        vstr->len = totalsize;
+        vstr_null_terminated_str(vstr);
+        return vstr->buf;
+    }
+}