bugfixes: Fixed some API failures

Author: shahpiyushv

components/esp_rainmaker/src/core/esp_rmaker_core.c

@@ -348,7 +348,15 @@ static void esp_rmaker_task(void *param)
     esp_rmaker_priv_data->state = ESP_RMAKER_STATE_STARTING;
     esp_err_t err;
     wifi_event_group = xEventGroupCreate();
-    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &esp_rmaker_event_handler, esp_rmaker_priv_data)); 
+    if (!wifi_event_group) {
+        ESP_LOGE(TAG, "Failed to create event group. Aborting");
+        goto rmaker_err;
+    }
+    err = esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &esp_rmaker_event_handler, esp_rmaker_priv_data);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to register event handler. Error: %d. Aborting", err);
+        goto rmaker_err;
+    }
     /* Assisted claiming needs to be done before Wi-Fi connection */
 #ifdef CONFIG_ESP_RMAKER_ASSISTED_CLAIM
     if (esp_rmaker_priv_data->need_claim) {
@@ -357,7 +365,8 @@ static void esp_rmaker_task(void *param)
         if (err != ESP_OK) {
             esp_rmaker_post_event(RMAKER_EVENT_CLAIM_FAILED, NULL, 0);
             ESP_LOGE(TAG, "esp_rmaker_self_claim_perform() returned %d. Aborting", err);
-            vTaskDelete(NULL);
+            esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &esp_rmaker_event_handler);
+            goto rmaker_err;
         }
         esp_rmaker_priv_data->claim_data = NULL;
         esp_rmaker_post_event(RMAKER_EVENT_CLAIM_SUCCESSFUL, NULL, 0);
@@ -366,6 +375,8 @@ static void esp_rmaker_task(void *param)
     /* Wait for Wi-Fi connection */
     xEventGroupWaitBits(wifi_event_group, WIFI_CONNECTED_EVENT, false, true, portMAX_DELAY);
     vEventGroupDelete(wifi_event_group);
+    wifi_event_group = NULL;
+    esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &esp_rmaker_event_handler);
 
     if (esp_rmaker_priv_data->enable_time_sync) {
 #ifdef CONFIG_MBEDTLS_HAVE_TIME_DATE
@@ -380,7 +391,7 @@ static void esp_rmaker_task(void *param)
         if (err != ESP_OK) {
             esp_rmaker_post_event(RMAKER_EVENT_CLAIM_FAILED, NULL, 0);
             ESP_LOGE(TAG, "esp_rmaker_self_claim_perform() returned %d. Aborting", err);
-            vTaskDelete(NULL);
+            goto rmaker_err;
         }
         esp_rmaker_priv_data->claim_data = NULL;
         esp_rmaker_post_event(RMAKER_EVENT_CLAIM_SUCCESSFUL, NULL, 0);
@@ -391,20 +402,20 @@ static void esp_rmaker_task(void *param)
         esp_rmaker_priv_data->mqtt_config = esp_rmaker_get_mqtt_config();
         if (!esp_rmaker_priv_data->mqtt_config) {
             ESP_LOGE(TAG, "Failed to initialise MQTT Config after claiming. Aborting");
-            vTaskDelete(NULL);
+            goto rmaker_err;
         }
         err = esp_rmaker_mqtt_init(esp_rmaker_priv_data->mqtt_config);
         if (err != ESP_OK) {
             ESP_LOGE(TAG, "esp_rmaker_mqtt_init() returned %d. Aborting", err);
-            vTaskDelete(NULL);
+            goto rmaker_err;
         }
         esp_rmaker_priv_data->need_claim = false;
     }
 #endif /* ESP_RMAKER_CLAIM_ENABLED */
     err = esp_rmaker_mqtt_connect();
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "esp_rmaker_mqtt_connect() returned %d. Aborting", err);
-        vTaskDelete(NULL);
+        goto rmaker_err;
     }
     esp_rmaker_priv_data->mqtt_connected = true;
     esp_rmaker_priv_data->state = ESP_RMAKER_STATE_STARTED;
@@ -424,6 +435,11 @@ static void esp_rmaker_task(void *param)
 rmaker_end:
     esp_rmaker_mqtt_disconnect();
     esp_rmaker_priv_data->mqtt_connected = false;
+rmaker_err:
+    if (wifi_event_group) {
+        vEventGroupDelete(wifi_event_group);
+    }
+    wifi_event_group = NULL;
     esp_rmaker_priv_data->state = ESP_RMAKER_STATE_INIT_DONE;
     vTaskDelete(NULL);
 }

components/esp_rainmaker/src/core/esp_rmaker_device.c

@@ -57,6 +57,7 @@ static esp_rmaker_device_t *__esp_rmaker_device_create(const char *name, const c
 {
     if (!name) {
         ESP_LOGE(TAG, "%s name is mandatory", is_service ? "Service":"Device");
+        return NULL;
     }
     _esp_rmaker_device_t *_device = calloc(1, sizeof(_esp_rmaker_device_t));
     if (!_device) {
@@ -97,7 +98,7 @@ esp_rmaker_device_t *esp_rmaker_service_create(const char *name, const char *typ
 esp_err_t esp_rmaker_device_add_param(const esp_rmaker_device_t *device, const esp_rmaker_param_t *param)
 {
     if (!device || !param) {
-        ESP_LOGE(TAG, "Device or Parameter handle cannot be NULL");
+        ESP_LOGE(TAG, "Device or Param handle cannot be NULL");
         return ESP_ERR_INVALID_ARG;
     }
     _esp_rmaker_device_t *_device = (_esp_rmaker_device_t *)device;
@@ -199,6 +200,7 @@ esp_err_t esp_rmaker_device_assign_primary_param(const esp_rmaker_device_t *devi
 {
     if (!device || !param) {
         ESP_LOGE(TAG,"Device or Param handle cannot be NULL");
+        return ESP_ERR_INVALID_ARG;
     }
     ((_esp_rmaker_device_t *)device)->primary = (_esp_rmaker_param_t *)param;
     return ESP_OK;

components/esp_rainmaker/src/core/esp_rmaker_node.c

@@ -185,16 +185,23 @@ esp_err_t esp_rmaker_node_add_attribute(const esp_rmaker_node_t *node, const cha
     while(attr && attr->next) {
         if (strcmp(attr->name, attr_name) == 0) {
             ESP_LOGE(TAG, "Node attribute with name %s already exists.", attr_name);
+            return ESP_FAIL;
         }
         attr = attr->next;
     }
     esp_rmaker_attr_t *new_attr = calloc(1, sizeof(esp_rmaker_attr_t));
     if (!new_attr) {
         ESP_LOGE(TAG, "Failed to create node attribute %s.", attr_name);
-        return ESP_FAIL;
+        return ESP_ERR_NO_MEM;
     }
     new_attr->name = strdup(attr_name);
     new_attr->value = strdup(value);
+    if (!new_attr->name || !new_attr->value) {
+        ESP_LOGE(TAG, "Failed to allocate memory for name/value for attribute %s.", attr_name);
+        esp_rmaker_attribute_delete(new_attr);
+        return ESP_ERR_NO_MEM;
+    }
+
     if (attr) {
         attr->next = new_attr;
     } else {

components/esp_rainmaker/src/core/esp_rmaker_param.c

@@ -394,6 +394,7 @@ esp_rmaker_param_t *esp_rmaker_param_create(const char *param_name, const char *
 {
     if (!param_name) {
         ESP_LOGE(TAG, "Param name is mandatory");
+        return NULL;
     }
     _esp_rmaker_param_t *param = calloc(1, sizeof(_esp_rmaker_param_t));
     if (!param) {