Merge branch 'task/prov_improvements' into 'master'

app_wifi: Minor feature additions to provisioning workflow

See merge request app-frameworks/esp-rainmaker!294

Author: shahpiyushv

CHANGES.md

@@ -1,5 +1,12 @@
 # Changes
 
+## 25-Jan-2022 (app_wifi: Minor feature additions to provisioning workflow)
+
+Added a 30 minute timeout for Wi-Fi provisioning as a security measure. A device reboot will be
+required to restart provisioning after it times out. The value can changed using the
+`CONFIG_APP_WIFI_PROV_TIMEOUT_PERIOD` config option. A value of 0 will disable the timeout logic.
+`APP_WIFI_EVENT_PROV_TIMEOUT` event will be triggerd to indicate that the provisioning has timed out.
+
 ## 25-Jan-2022 (examples: Enable some security features and change order of component dirs)
 
 A couple of security features were added some time back, viz.

components/esp_rainmaker/include/esp_rmaker_user_mapping.h

@@ -25,6 +25,8 @@ typedef enum {
     ESP_RMAKER_USER_MAPPING_RESET = 0,
     /** Mapping has started */
     ESP_RMAKER_USER_MAPPING_STARTED,
+    /** Mapping request sent to cloud */
+    ESP_RMAKER_USER_MAPPING_REQ_SENT,
     /** Mapping is done */
     ESP_RMAKER_USER_MAPPING_DONE,
 } esp_rmaker_user_mapping_state_t;

components/esp_rainmaker/src/core/esp_rmaker_internal.h

@@ -107,6 +107,7 @@ esp_err_t esp_rmaker_handle_set_params(char *data, size_t data_len, esp_rmaker_r
 esp_err_t esp_rmaker_user_mapping_prov_init(void);
 esp_err_t esp_rmaker_user_mapping_prov_deinit(void);
 esp_err_t esp_rmaker_user_node_mapping_init(void);
+esp_err_t esp_rmaker_user_node_mapping_deinit(void);
 esp_err_t esp_rmaker_reset_user_node_mapping(void);
 esp_err_t esp_rmaker_init_local_ctrl_service(void);
 esp_err_t esp_rmaker_start_local_ctrl_service(const char *serv_name);

components/esp_rainmaker/src/core/esp_rmaker_user_mapping.c

@@ -16,6 +16,8 @@
 #include <esp_log.h>
 #include <esp_event.h>
 #include <nvs.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
 #include <wifi_provisioning/manager.h>
 #include <json_generator.h>
 #include <esp_rmaker_work_queue.h>
@@ -35,14 +37,21 @@ static const char *TAG = "esp_rmaker_user_mapping";
 #define USER_RESET_ID               "esp-rmaker"
 #define USER_RESET_KEY              "failed"
 
+/* A delay large enough to allow the tasks to get the semaphore, but small
+ * enough to prevent tasks getting blocked for long.
+ */
+#define SEMAPHORE_DELAY_MSEC         5000
+
 typedef struct {
     char *user_id;
     char *secret_key;
     int mqtt_msg_id;
+    bool sent;
 } esp_rmaker_user_mapping_data_t;
 
 static esp_rmaker_user_mapping_data_t *rmaker_user_mapping_data;
 esp_rmaker_user_mapping_state_t rmaker_user_mapping_state;
+SemaphoreHandle_t esp_rmaker_user_mapping_lock = NULL;
 
 static void esp_rmaker_user_mapping_cleanup_data(void)
 {
@@ -82,10 +91,13 @@ static void esp_rmaker_user_mapping_event_handler(void* arg, esp_event_base_t ev
          * has indeed reached the RainMaker cloud.
          */
         int msg_id = *((int *)event_data);
-        if (msg_id == rmaker_user_mapping_data->mqtt_msg_id) {
+        if (xSemaphoreTake(esp_rmaker_user_mapping_lock, SEMAPHORE_DELAY_MSEC/portTICK_PERIOD_MS) != pdTRUE) {
+            ESP_LOGE(TAG, "Failed to take semaphore.");
+            return;
+        }
+        if ((rmaker_user_mapping_data != NULL) && (msg_id == rmaker_user_mapping_data->mqtt_msg_id)) {
             ESP_LOGI(TAG, "User Node association message published successfully.");
-            esp_rmaker_user_mapping_data_t *data = (esp_rmaker_user_mapping_data_t *)arg;
-            if (data && (strcmp(data->user_id, USER_RESET_ID) == 0)) {
+            if (strcmp(rmaker_user_mapping_data->user_id, USER_RESET_ID) == 0) {
                 rmaker_user_mapping_state = ESP_RMAKER_USER_MAPPING_RESET;
                 esp_rmaker_post_event(RMAKER_EVENT_USER_NODE_MAPPING_RESET, NULL, 0);
             } else {
@@ -106,36 +118,47 @@ static void esp_rmaker_user_mapping_event_handler(void* arg, esp_event_base_t ev
             esp_event_handler_unregister(RMAKER_COMMON_EVENT, RMAKER_MQTT_EVENT_PUBLISHED,
                     &esp_rmaker_user_mapping_event_handler);
         }
+        xSemaphoreGive(esp_rmaker_user_mapping_lock);
     }
 }
 
 static void esp_rmaker_user_mapping_cb(void *priv_data)
 {
-    esp_rmaker_user_mapping_data_t *data = (esp_rmaker_user_mapping_data_t *)priv_data;
-    if (!data) {
+    if (xSemaphoreTake(esp_rmaker_user_mapping_lock, SEMAPHORE_DELAY_MSEC/portTICK_PERIOD_MS) != pdTRUE) {
+        ESP_LOGE(TAG, "Failed to take semaphore.");
+        return;
+    }
+    /* If there is no user node mapping data, or if the data is already sent, just return */
+    if (rmaker_user_mapping_data == NULL || rmaker_user_mapping_data->sent == true) {
+        xSemaphoreGive(esp_rmaker_user_mapping_lock);
         return;
     }
     esp_event_handler_register(RMAKER_COMMON_EVENT, RMAKER_MQTT_EVENT_PUBLISHED,
-            &esp_rmaker_user_mapping_event_handler, data);
+            &esp_rmaker_user_mapping_event_handler, NULL);
     char publish_payload[200];
     json_gen_str_t jstr;
     json_gen_str_start(&jstr, publish_payload, sizeof(publish_payload), NULL, NULL);
     json_gen_start_object(&jstr);
     char *node_id = esp_rmaker_get_node_id();
     json_gen_obj_set_string(&jstr, "node_id", node_id);
-    json_gen_obj_set_string(&jstr, "user_id", data->user_id);
-    json_gen_obj_set_string(&jstr, "secret_key", data->secret_key);
+    json_gen_obj_set_string(&jstr, "user_id", rmaker_user_mapping_data->user_id);
+    json_gen_obj_set_string(&jstr, "secret_key", rmaker_user_mapping_data->secret_key);
     if (esp_rmaker_user_node_mapping_get_state() != ESP_RMAKER_USER_MAPPING_DONE) {
         json_gen_obj_set_bool(&jstr, "reset", true);
     }
     json_gen_end_object(&jstr);
     json_gen_str_end(&jstr);
     char publish_topic[100];
     snprintf(publish_topic, sizeof(publish_topic), "node/%s/%s", node_id, USER_MAPPING_TOPIC_SUFFIX);
-    esp_err_t err = esp_rmaker_mqtt_publish(publish_topic, publish_payload, strlen(publish_payload), RMAKER_MQTT_QOS1, &data->mqtt_msg_id);
+    esp_err_t err = esp_rmaker_mqtt_publish(publish_topic, publish_payload, strlen(publish_payload), RMAKER_MQTT_QOS1, &rmaker_user_mapping_data->mqtt_msg_id);
+    ESP_LOGI(TAG, "MQTT Publish: %s", publish_payload);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "MQTT Publish Error %d", err);
+    } else {
+        rmaker_user_mapping_state = ESP_RMAKER_USER_MAPPING_REQ_SENT;
+        rmaker_user_mapping_data->sent = true;
     }
+    xSemaphoreGive(esp_rmaker_user_mapping_lock);
     return;
 }
 
@@ -175,20 +198,32 @@ static bool esp_rmaker_user_mapping_detect_reset(const char *user_id)
 
 esp_err_t esp_rmaker_start_user_node_mapping(char *user_id, char *secret_key)
 {
+    if (esp_rmaker_user_mapping_lock == NULL) {
+        ESP_LOGE(TAG, "User Node mapping not initialised.");
+        return ESP_FAIL;
+    }
+    if (xSemaphoreTake(esp_rmaker_user_mapping_lock, SEMAPHORE_DELAY_MSEC/portTICK_PERIOD_MS) != pdTRUE) {
+        ESP_LOGE(TAG, "Failed to take semaphore.");
+        return ESP_FAIL;
+    }
     if (rmaker_user_mapping_data) {
         esp_rmaker_user_mapping_cleanup_data();
     }
 
     rmaker_user_mapping_data = calloc(1, sizeof(esp_rmaker_user_mapping_data_t));
     if (!rmaker_user_mapping_data) {
-        return ESP_FAIL;
+        ESP_LOGE(TAG, "Failed to allocate memory for rmaker_user_mapping_data.");
+        xSemaphoreGive(esp_rmaker_user_mapping_lock);
+        return ESP_ERR_NO_MEM;
     }
     rmaker_user_mapping_data->user_id = strdup(user_id);
     if (!rmaker_user_mapping_data->user_id) {
+        ESP_LOGE(TAG, "Failed to allocate memory for user_id.");
         goto user_mapping_error;
     }
     rmaker_user_mapping_data->secret_key = strdup(secret_key);
     if (!rmaker_user_mapping_data->secret_key) {
+        ESP_LOGE(TAG, "Failed to allocate memory for secret_key.");
         goto user_mapping_error;
     }
     if (esp_rmaker_user_mapping_detect_reset(user_id)) {
@@ -197,14 +232,17 @@ esp_err_t esp_rmaker_start_user_node_mapping(char *user_id, char *secret_key)
     } else {
         rmaker_user_mapping_state = ESP_RMAKER_USER_MAPPING_DONE;
     }
-    if (esp_rmaker_work_queue_add_task(esp_rmaker_user_mapping_cb, rmaker_user_mapping_data) != ESP_OK) {
+    if (esp_rmaker_work_queue_add_task(esp_rmaker_user_mapping_cb, NULL) != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to queue user mapping task.");
         goto user_mapping_error;
     }
     esp_rmaker_user_mapping_prov_deinit();
+    xSemaphoreGive(esp_rmaker_user_mapping_lock);
     return ESP_OK;
 
 user_mapping_error:
     esp_rmaker_user_mapping_cleanup_data();
+    xSemaphoreGive(esp_rmaker_user_mapping_lock);
     return ESP_FAIL;
 }
 
@@ -311,5 +349,21 @@ esp_err_t esp_rmaker_user_node_mapping_init(void)
 #else
     rmaker_user_mapping_state = ESP_RMAKER_USER_MAPPING_DONE;
 #endif
+    if (!esp_rmaker_user_mapping_lock) {
+        esp_rmaker_user_mapping_lock = xSemaphoreCreateMutex();
+        if (!esp_rmaker_user_mapping_lock) {
+            ESP_LOGE(TAG, "Failed to create Mutex");
+            return ESP_FAIL;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t esp_rmaker_user_node_mapping_deinit(void)
+{
+    if (esp_rmaker_user_mapping_lock) {
+        vSemaphoreDelete(esp_rmaker_user_mapping_lock);
+        esp_rmaker_user_mapping_lock = NULL;
+    }
     return ESP_OK;
 }

examples/common/app_wifi/Kconfig.projbuild

@@ -25,10 +25,42 @@ menu "ESP RainMaker App Wi-Fi Provisioning"
         default 1 if APP_WIFI_PROV_TRANSPORT_SOFTAP
         default 2 if APP_WIFI_PROV_TRANSPORT_BLE
 
+    config APP_WIFI_RESET_PROV_ON_FAILURE
+        bool
+        default y
+        prompt "Reset provisioned credentials and state machine after session failure"
+        help
+            Enable reseting provisioned credentials and state machine after session failure.
+            This will restart the provisioning service after retries are exhausted.
+
+    config APP_WIFI_PROV_MAX_RETRY_CNT
+        int
+        default 5
+        prompt "Max retries before reseting provisioning state machine"
+        depends on APP_WIFI_RESET_PROV_ON_FAILURE
+        help
+            Set the Maximum retry to avoid reconnecting to an inexistent AP or if credentials
+            are misconfigured. Provisioned credentials are erased and internal state machine
+            is reset after this threshold is reached.
+
     config APP_WIFI_SHOW_DEMO_INTRO_TEXT
         bool "Show intro text for demos"
         default n
         help
             Show some intro text for demos in order to help users understand more about ESP RainMaker.
 
+    config APP_WIFI_PROV_TIMEOUT_PERIOD
+        int "Provisioning Timeout"
+        default 30
+        help
+            Timeout (in minutes) after which the provisioning will auto stop. A reboot will be required
+            to restart provisioning. It is always recommended to set this to some non zero value, especially
+            if you are not using PoP. Set to 0 if you do not want provisioning to auto stop.
+
+    config APP_WIFI_PROV_NAME_PREFIX
+        string "Provisioning Name Prefix"
+        default "PROV"
+        help
+            Provisioning Name Prefix.
+
 endmenu