NOISSUE renamed control module

Author: aschweiz

main/fwupdater_wifi_tls.c main/iap_https.cmain/fwupdater_wifi_tls.c renamed to main/iap_https.c

@@ -1,5 +1,5 @@
 //
-//  fwupdater_wifi_tls.c
+//  iap_https.c
 //  esp32-ota-https
 //
 //  Updating the firmware over the air.
@@ -41,7 +41,7 @@
 #include "wifi_tls.h"
 #include "https_client.h"
 #include "iap.h"
-#include "fwupdater_wifi_tls.h"
+#include "iap_https.h"
 
 
 #define TAG "fwup_wifi"
@@ -51,7 +51,7 @@
 static struct wifi_tls_context_ *tls_context;
 
 // Module configuration.
-static fwupdater_wifi_tls_config_t *fwupdater_config;
+static iap_https_config_t *fwupdater_config;
 
 // The metadata request.
 static http_request_t http_metadata_request;
@@ -71,23 +71,23 @@ static int has_iap_session;
 static int has_new_firmware;
 static int total_nof_bytes_received;
 
-static void fwupdater_wifi_tls_periodic_check_timer_callback(TimerHandle_t xTimer);
-static void fwupdater_wifi_tls_task(void *pvParameter);
-static void fwupdater_wifi_tls_prepare_timer();
-static void fwupdater_wifi_tls_trigger_processing();
-static void fwupdater_wifi_tls_check_for_update();
-static void fwupdater_wifi_download_image();
+static void iap_https_periodic_check_timer_callback(TimerHandle_t xTimer);
+static void iap_https_task(void *pvParameter);
+static void iap_https_prepare_timer();
+static void iap_https_trigger_processing();
+static void iap_https_check_for_update();
+static void iap_https_download_image();
 
-http_continue_receiving_t fwupdater_metadata_headers_callback(struct http_request_ *request, int statusCode, int contentLength);
-http_continue_receiving_t fwupdater_metadata_body_callback(struct http_request_ *request, size_t bytesReceived);
-http_continue_receiving_t fwupdater_firmware_headers_callback(struct http_request_ *request, int statusCode, int contentLength);
-http_continue_receiving_t fwupdater_firmware_body_callback(struct http_request_ *request, size_t bytesReceived);
-void fwupdater_error_callback(struct http_request_ *request, http_error_t error, int additionalInfo);
+http_continue_receiving_t iap_https_metadata_headers_callback(struct http_request_ *request, int statusCode, int contentLength);
+http_continue_receiving_t iap_https_metadata_body_callback(struct http_request_ *request, size_t bytesReceived);
+http_continue_receiving_t iap_https_firmware_headers_callback(struct http_request_ *request, int statusCode, int contentLength);
+http_continue_receiving_t iap_https_firmware_body_callback(struct http_request_ *request, size_t bytesReceived);
+void iap_https_error_callback(struct http_request_ *request, http_error_t error, int additionalInfo);
 
 
-int fwupdater_wifi_tls_init(fwupdater_wifi_tls_config_t *config)
+int iap_https_init(iap_https_config_t *config)
 {
-    ESP_LOGD(TAG, "fwupdater_wifi_tls_init");
+    ESP_LOGD(TAG, "iap_https_init");
 
     iap_init();
 
@@ -112,69 +112,69 @@ int fwupdater_wifi_tls_init(fwupdater_wifi_tls_config_t *config)
     http_metadata_request.response_mode = HTTP_WAIT_FOR_COMPLETE_BODY;
     http_metadata_request.response_buffer_len = 512;
     http_metadata_request.response_buffer = malloc(http_metadata_request.response_buffer_len * sizeof(char));
-    http_metadata_request.error_callback = fwupdater_error_callback;
-    http_metadata_request.headers_callback = fwupdater_metadata_headers_callback;
-    http_metadata_request.body_callback = fwupdater_metadata_body_callback;
+    http_metadata_request.error_callback = iap_https_error_callback;
+    http_metadata_request.headers_callback = iap_https_metadata_headers_callback;
+    http_metadata_request.body_callback = iap_https_metadata_body_callback;
 
     http_firmware_data_request.verb = HTTP_GET;
     http_firmware_data_request.host = config->server_host_name;
     http_firmware_data_request.path = config->server_firmware_path;
     http_firmware_data_request.response_mode = HTTP_STREAM_BODY;
     http_firmware_data_request.response_buffer_len = 4096;
     http_firmware_data_request.response_buffer = malloc(http_firmware_data_request.response_buffer_len * sizeof(char));
-    http_firmware_data_request.error_callback = fwupdater_error_callback;
-    http_firmware_data_request.headers_callback = fwupdater_firmware_headers_callback;
-    http_firmware_data_request.body_callback = fwupdater_firmware_body_callback;
+    http_firmware_data_request.error_callback = iap_https_error_callback;
+    http_firmware_data_request.headers_callback = iap_https_firmware_headers_callback;
+    http_firmware_data_request.body_callback = iap_https_firmware_body_callback;
 
     // Start our processing task.
 
     event_group = xEventGroupCreate();
 
-    fwupdater_wifi_tls_prepare_timer();
+    iap_https_prepare_timer();
 
-    xTaskCreate(&fwupdater_wifi_tls_task, "fwup_wifi_task", 4096, NULL, 1, NULL);
+    xTaskCreate(&iap_https_task, "fwup_wifi_task", 4096, NULL, 1, NULL);
 
     return 0;
 }
 
-int fwupdater_wifi_tls_check_now()
+int iap_https_check_now()
 {
-    ESP_LOGD(TAG, "fwupdater_wifi_tls_check_now");
-    fwupdater_wifi_tls_trigger_processing();
+    ESP_LOGD(TAG, "iap_https_check_now");
+    iap_https_trigger_processing();
     return 0;
 }
 
-int fwupdater_wifi_tls_update_in_progress()
+int iap_https_update_in_progress()
 {
     return has_iap_session;
 }
 
-int fwupdater_wifi_tls_new_firmware_installed()
+int iap_https_new_firmware_installed()
 {
     return has_new_firmware;
 }
 
-static void fwupdater_wifi_tls_periodic_check_timer_callback(TimerHandle_t xTimer)
+static void iap_https_periodic_check_timer_callback(TimerHandle_t xTimer)
 {
     xEventGroupSetBits(event_group, FWUP_CHECK_FOR_UPDATE);
 }
 
-static void fwupdater_wifi_tls_trigger_processing()
+static void iap_https_trigger_processing()
 {
-    ESP_LOGD(TAG, "fwupdater_wifi_tls_trigger_processing: checking flag");
+    ESP_LOGD(TAG, "iap_https_trigger_processing: checking flag");
 
     if (xEventGroupGetBits(event_group) & FWUP_CHECK_FOR_UPDATE) {
-        ESP_LOGD(TAG, "fwupdater_wifi_tls_trigger_processing: flag is already set");
+        ESP_LOGD(TAG, "iap_https_trigger_processing: flag is already set");
         return;
     }
 
-    ESP_LOGD(TAG, "fwupdater_wifi_tls_trigger_processing: flag is not set, setting it");
+    ESP_LOGD(TAG, "iap_https_trigger_processing: flag is not set, setting it");
 
     // Trigger processing in our task.
     xEventGroupSetBits(event_group, FWUP_CHECK_FOR_UPDATE);
 }
 
-static void fwupdater_wifi_tls_task(void *pvParameter)
+static void iap_https_task(void *pvParameter)
 {
     ESP_LOGI(TAG, "Firmware updater task started.");
 
@@ -200,49 +200,49 @@ static void fwupdater_wifi_tls_task(void *pvParameter)
 
         if (bits & FWUP_DOWNLOAD_IMAGE) {
             ESP_LOGI(TAG, "Firmware updater task will now download the new firmware image.");
-            fwupdater_wifi_download_image();
+            iap_https_download_image();
             xEventGroupClearBits(event_group, FWUP_DOWNLOAD_IMAGE);
 
         } else if (bits & FWUP_CHECK_FOR_UPDATE) {
             ESP_LOGI(TAG, "Firmware updater task checking for firmware update.");
-            fwupdater_wifi_tls_check_for_update();
+            iap_https_check_for_update();
 
             // If periodic OTA update checks are enabled, re-start the timer.
             // Clear the bit *after* resetting the timer to avoid the race condition
             // where the timer could have elapsed during the update check and we would
             // immediately check again.
 
-            fwupdater_wifi_tls_prepare_timer();
+            iap_https_prepare_timer();
             xEventGroupClearBits(event_group, FWUP_CHECK_FOR_UPDATE);
         }
     }
 }
 
-static void fwupdater_wifi_tls_prepare_timer()
+static void iap_https_prepare_timer()
 {
     // Make sure we have a timer if we need one and don't have one if we don't need one.
 
     if (fwupdater_config->polling_interval_s > 0) {
         if (!check_for_updates_timer) {
             // We need a timer but don't have one. Create it.
             BaseType_t autoReload = pdFALSE;
-            check_for_updates_timer = xTimerCreate("fwup_periodic_check", 1000, autoReload, NULL, fwupdater_wifi_tls_periodic_check_timer_callback);
+            check_for_updates_timer = xTimerCreate("fwup_periodic_check", 1000, autoReload, NULL, iap_https_periodic_check_timer_callback);
             if (!check_for_updates_timer) {
-                ESP_LOGE(TAG, "fwupdater_wifi_tls_prepare_timer: failed to create the fwup_periodic_check timer!");
+                ESP_LOGE(TAG, "iap_https_prepare_timer: failed to create the fwup_periodic_check timer!");
                 return;
             }
         }
 
         // We need and have a timer, so make sure it uses the correct interval, then start it.
 
         uint32_t timerMillisec = 1000 * fwupdater_config->polling_interval_s;
-        ESP_LOGD(TAG, "fwupdater_wifi_tls_prepare_timer: timer interval = %d ms", timerMillisec);
+        ESP_LOGD(TAG, "iap_https_prepare_timer: timer interval = %d ms", timerMillisec);
         TickType_t timerPeriod = pdMS_TO_TICKS(timerMillisec);
 
         xTimerChangePeriod(check_for_updates_timer, timerPeriod, pdMS_TO_TICKS(5000));
 
         if (pdFAIL == xTimerReset(check_for_updates_timer, pdMS_TO_TICKS(5000))) {
-            ESP_LOGE(TAG, "fwupdater_wifi_tls_prepare_timer: failed to start the fwup_periodic_check timer!");
+            ESP_LOGE(TAG, "iap_https_prepare_timer: failed to start the fwup_periodic_check timer!");
         }
 
         return;
@@ -256,28 +256,28 @@ static void fwupdater_wifi_tls_prepare_timer()
     }
 }
 
-static void fwupdater_wifi_tls_check_for_update()
+static void iap_https_check_for_update()
 {
-    ESP_LOGD(TAG, "fwupdater_wifi_tls_check_for_update");
+    ESP_LOGD(TAG, "iap_https_check_for_update");
 
     int tlsResult = wifi_tls_connect(tls_context);
     if (tlsResult) {
-        ESP_LOGE(TAG, "fwupdater_wifi_tls_check_for_update: failed to initiate SSL/TLS connection; wifi_tls_connect returned %d", tlsResult);
+        ESP_LOGE(TAG, "iap_https_check_for_update: failed to initiate SSL/TLS connection; wifi_tls_connect returned %d", tlsResult);
         return;
     }
 
     ESP_LOGI(TAG, "Requesting firmware metadata from server.");
     http_error_t httpResult = https_send_request(tls_context, &http_metadata_request);
     if (httpResult != HTTP_SUCCESS) {
-        ESP_LOGE(TAG, "fwupdater_wifi_tls_check_for_update: failed to send HTTPS metadata request; https_send_request returned %d", httpResult);
+        ESP_LOGE(TAG, "iap_https_check_for_update: failed to send HTTPS metadata request; https_send_request returned %d", httpResult);
     }
 }
 
-static void fwupdater_wifi_download_image()
+static void iap_https_download_image()
 {
     int tlsResult = wifi_tls_connect(tls_context);
     if (tlsResult) {
-        ESP_LOGE(TAG, "fwupdater_metadata_body_callback: failed to initiate SSL/TLS connection; wifi_tls_connect returned %d", tlsResult);
+        ESP_LOGE(TAG, "iap_https_download_image: failed to initiate SSL/TLS connection; wifi_tls_connect returned %d", tlsResult);
     }
 
     // Make sure we open a new IAP session in the callback.
@@ -286,13 +286,13 @@ static void fwupdater_wifi_download_image()
     ESP_LOGI(TAG, "Requesting firmware image '%s' from web server.", fwupdater_config->server_firmware_path);
     http_error_t httpResult = https_send_request(tls_context, &http_firmware_data_request);
     if (httpResult != HTTP_SUCCESS) {
-        ESP_LOGE(TAG, "fwupdater_wifi_tls_execute_check: failed to send HTTPS firmware image request; https_send_request returned %d", httpResult);
+        ESP_LOGE(TAG, "iap_https_download_image: failed to send HTTPS firmware image request; https_send_request returned %d", httpResult);
     }
 }
 
-http_continue_receiving_t fwupdater_metadata_body_callback(struct http_request_ *request, size_t bytesReceived)
+http_continue_receiving_t iap_https_metadata_body_callback(struct http_request_ *request, size_t bytesReceived)
 {
-    ESP_LOGD(TAG, "fwupdater_metadata_body_callback");
+    ESP_LOGD(TAG, "iap_https_metadata_body_callback");
 
     // --- Process the metadata information ---
 
@@ -301,7 +301,7 @@ http_continue_receiving_t fwupdater_metadata_body_callback(struct http_request_
     if (!http_parse_key_value_int(request->response_buffer, "INTERVAL=", &intervalSeconds)) {
         ESP_LOGD(TAG, "[INTERVAL=] '%d'", intervalSeconds);
         if (intervalSeconds != fwupdater_config->polling_interval_s) {
-            ESP_LOGD(TAG, "fwupdater_metadata_body_callback: polling interval changed from %d s to %d s",
+            ESP_LOGD(TAG, "iap_https_metadata_body_callback: polling interval changed from %d s to %d s",
                      fwupdater_config->polling_interval_s, intervalSeconds);
             fwupdater_config->polling_interval_s = intervalSeconds;
         }
@@ -311,7 +311,7 @@ http_continue_receiving_t fwupdater_metadata_body_callback(struct http_request_
     if (!http_parse_key_value_int(request->response_buffer, "VERSION=", &version)) {
         ESP_LOGD(TAG, "[VERSION=] '%d'", version);
     } else {
-        ESP_LOGW(TAG, "fwupdater_metadata_body_callback: firmware version not provided, skipping firmware update");
+        ESP_LOGW(TAG, "iap_https_metadata_body_callback: firmware version not provided, skipping firmware update");
         return HTTP_STOP_RECEIVING;
     }
 
@@ -320,19 +320,19 @@ http_continue_receiving_t fwupdater_metadata_body_callback(struct http_request_
         ESP_LOGD(TAG, "[FILE=] '%s'", fileName);
         strncpy(fwupdater_config->server_firmware_path, fileName, sizeof(fwupdater_config->server_firmware_path) / sizeof(char));
     } else {
-        ESP_LOGW(TAG, "fwupdater_metadata_body_callback: firmware file name not provided, skipping firmware update");
+        ESP_LOGW(TAG, "iap_https_metadata_body_callback: firmware file name not provided, skipping firmware update");
         return HTTP_STOP_RECEIVING;
     }
 
 
     // --- Check if the version on the server is the same as the currently installed version ---
 
     if (version == SOFTWARE_VERSION) {
-        ESP_LOGD(TAG, "fwupdater_metadata_body_callback: we're up-to-date!");
+        ESP_LOGD(TAG, "iap_https_metadata_body_callback: we're up-to-date!");
         return HTTP_STOP_RECEIVING;
     }
 
-    ESP_LOGD(TAG, "fwupdater_metadata_body_callback: our version is %d, the version on the server is %d", SOFTWARE_VERSION, version);
+    ESP_LOGD(TAG, "iap_https_metadata_body_callback: our version is %d, the version on the server is %d", SOFTWARE_VERSION, version);
 
     // --- Request the firmware image ---
 
@@ -341,20 +341,20 @@ http_continue_receiving_t fwupdater_metadata_body_callback(struct http_request_
     return HTTP_STOP_RECEIVING;
 }
 
-http_continue_receiving_t fwupdater_firmware_body_callback(struct http_request_ *request, size_t bytesReceived)
+http_continue_receiving_t iap_https_firmware_body_callback(struct http_request_ *request, size_t bytesReceived)
 {
-    ESP_LOGD(TAG, "fwupdater_firmware_body_callback");
+    ESP_LOGD(TAG, "iap_https_firmware_body_callback");
 
     // The first time we receive the callback, we neet to start the IAP session.
     if (!has_iap_session) {
-        ESP_LOGD(TAG, "fwupdater_firmware_body_callback: starting IPA session.");
+        ESP_LOGD(TAG, "iap_https_firmware_body_callback: starting IPA session.");
         iap_err_t result = iap_begin();
         if (result == IAP_ERR_SESSION_ALREADY_OPEN) {
             iap_abort();
             result = iap_begin();
         }
         if (result != IAP_OK) {
-            ESP_LOGE(TAG, "fwupdater_firmware_body_callback: iap_begin failed (%d)!", result);
+            ESP_LOGE(TAG, "iap_https_firmware_body_callback: iap_begin failed (%d)!", result);
             return HTTP_STOP_RECEIVING;
         }
         total_nof_bytes_received = 0;
@@ -366,7 +366,7 @@ http_continue_receiving_t fwupdater_firmware_body_callback(struct http_request_
         iap_err_t result = iap_write((uint8_t*)request->response_buffer, bytesReceived);
         total_nof_bytes_received += bytesReceived;
         if (result != IAP_OK) {
-            ESP_LOGE(TAG, "fwupdater_firmware_body_callback: write failed (%d), aborting firmware update!", result);
+            ESP_LOGE(TAG, "iap_https_firmware_body_callback: write failed (%d), aborting firmware update!", result);
             iap_abort();
             return HTTP_STOP_RECEIVING;
         }
@@ -376,13 +376,13 @@ http_continue_receiving_t fwupdater_firmware_body_callback(struct http_request_
     // After all data has been received, we get one last callback (with bytesReceived == 0).
     // If this happens, we need to finish the IAP session and, if configured, reboot the device.
 
-    ESP_LOGD(TAG, "fwupdater_firmware_body_callback: all data received (%d bytes), closing session", total_nof_bytes_received);
+    ESP_LOGD(TAG, "iap_https_firmware_body_callback: all data received (%d bytes), closing session", total_nof_bytes_received);
     has_iap_session = 0;
 
     if (total_nof_bytes_received > 0) {
         iap_err_t result = iap_commit();
         if (result != IAP_OK) {
-            ESP_LOGE(TAG, "fwupdater_firmware_body_callback: closing the session has failed (%d)!", result);
+            ESP_LOGE(TAG, "iap_https_firmware_body_callback: closing the session has failed (%d)!", result);
         }
 
         has_new_firmware = 1;
@@ -394,28 +394,28 @@ http_continue_receiving_t fwupdater_firmware_body_callback(struct http_request_
         }
 
     } else {
-        ESP_LOGE(TAG, "fwupdater_firmware_body_callback: something's not OK - the new firmware image is empty!");
+        ESP_LOGE(TAG, "iap_https_firmware_body_callback: something's not OK - the new firmware image is empty!");
         iap_abort();
     }
 
     return HTTP_STOP_RECEIVING;
 }
 
-http_continue_receiving_t fwupdater_metadata_headers_callback(struct http_request_ *request, int statusCode, int contentLength)
+http_continue_receiving_t iap_https_metadata_headers_callback(struct http_request_ *request, int statusCode, int contentLength)
 {
-    ESP_LOGD(TAG, "fwupdater_metadata_headers_callback");
+    ESP_LOGD(TAG, "iap_https_metadata_headers_callback");
     return HTTP_CONTINUE_RECEIVING;
 }
 
-http_continue_receiving_t fwupdater_firmware_headers_callback(struct http_request_ *request, int statusCode, int contentLength)
+http_continue_receiving_t iap_https_firmware_headers_callback(struct http_request_ *request, int statusCode, int contentLength)
 {
-    ESP_LOGD(TAG, "fwupdater_firmware_headers_callback");
+    ESP_LOGD(TAG, "iap_https_firmware_headers_callback");
     return HTTP_CONTINUE_RECEIVING;
 }
 
-void fwupdater_error_callback(struct http_request_ *request, http_error_t error, int additionalInfo)
+void iap_https_error_callback(struct http_request_ *request, http_error_t error, int additionalInfo)
 {
-    ESP_LOGE(TAG, "fwupdater_error_callback: error=%d additionalInfo=%d", error, additionalInfo);
+    ESP_LOGE(TAG, "iap_https_error_callback: error=%d additionalInfo=%d", error, additionalInfo);
 
     if (error == HTTP_ERR_NON_200_STATUS_CODE) {
         switch (additionalInfo) {