esp-idf download

// PUT wifi.txt ON SPIFFS
// FIRST LINE IS SSID
// NEXT LINE IS PASSWORD
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/unistd.h>

#include "esp_event.h"
#include "esp_http_client.h"
#include "esp_idf_version.h"
#include "esp_netif.h"
#include "esp_spiffs.h"
#include "esp_system.h"
#include "esp_tls.h"
#include "esp_wifi.h"
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/task.h"
#include "lwip/dns.h"
#include "lwip/inet.h"
#include "lwip/ip4_addr.h"
#include "nvs_flash.h"

#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT BIT1

EventGroupHandle_t wifi_event_group = NULL;
size_t wifi_retry_count = 0;

esp_err_t http_event_handler(esp_http_client_event_t* evt) {
    switch (evt->event_id) {
        case HTTP_EVENT_ERROR:
            break;
        case HTTP_EVENT_ON_CONNECTED:
            break;
        case HTTP_EVENT_HEADER_SENT:
            break;
        case HTTP_EVENT_ON_HEADER:
            break;
        case HTTP_EVENT_ON_DATA:
            if (evt->user_data) {
                FILE* f = (FILE*)evt->user_data;
                // The last byte in evt->user_data is kept for the NULL
                // character in case of out-of-bound access.
                fwrite(evt->data, 1, evt->data_len, f);
            }
            break;
        case HTTP_EVENT_ON_FINISH:
            if (evt->user_data) {
                fclose((FILE*)evt->user_data);
                puts("Download finished");
            }
            break;
        case HTTP_EVENT_DISCONNECTED:
            int mbedtls_err = 0;
            esp_tls_get_and_clear_last_error(
                (esp_tls_error_handle_t)evt->data, &mbedtls_err, NULL);
            break;
        case HTTP_EVENT_REDIRECT:
            esp_http_client_set_header(evt->client, "From", "[email protected]");
            esp_http_client_set_header(evt->client, "Accept", "text/html");
            esp_http_client_set_redirection(evt->client);
            break;
    }
    return ESP_OK;
}
void wifi_event_handler(void* arg, esp_event_base_t event_base,
                        int32_t event_id, void* event_data) {
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT &&
               event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (wifi_retry_count < 3) {
            esp_wifi_connect();
            ++wifi_retry_count;
        } else {
            xEventGroupSetBits(wifi_event_group, WIFI_FAIL_BIT);
        }
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        wifi_retry_count = 0;
        xEventGroupSetBits(wifi_event_group, WIFI_CONNECTED_BIT);
    }
}
static void http_download(const char* url, FILE* file) {
    esp_http_client_config_t config = {
        .url = url, .event_handler = http_event_handler, .user_data = file};
    esp_http_client_handle_t client = esp_http_client_init(&config);
    ESP_ERROR_CHECK(esp_http_client_perform(client));

    esp_http_client_cleanup(client);
}

void app_main() {

    char ssid[65];
    ssid[0] = 0;
    char pass[129];
    pass[0] = 0;

    esp_vfs_spiffs_conf_t conf = {.base_path = "/spiffs",
                                  .partition_label = NULL,
                                  .max_files = 5,
                                  .format_if_mount_failed = true};
    ESP_ERROR_CHECK(esp_vfs_spiffs_register(&conf));
    puts("Looking for /spiffs/wifi.txt");
    FILE* file = fopen("/spiffs/wifi.txt", "r");
    int loaded = 0;
    if (file != NULL) {
        // parse the file
        fgets(ssid, sizeof(ssid), file);
        char* sv = strchr(ssid, '\n');
        if (sv != NULL) *sv = '\0';
        sv = strchr(ssid, '\r');
        if (sv != NULL) *sv = '\0';
        fgets(pass, sizeof(pass), file);
        fclose(file);
        file = NULL;
        sv = strchr(pass, '\n');
        if (sv != NULL) *sv = '\0';
        sv = strchr(pass, '\r');
        if (sv != NULL) *sv = '\0';
        loaded = true;
    }
    if(!loaded) {
        puts("Put a wifi.txt file in SPIFFS. First line is SSID. Next line is password.");
        while(1) vTaskDelay(5);
    }
    nvs_flash_init();
    wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());

    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
        ESP_EVENT_ANY_ID,
        &wifi_event_handler,
        NULL,
        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
        IP_EVENT_STA_GOT_IP,
        &wifi_event_handler,
        NULL,
        &instance_got_ip));

    wifi_config_t wifi_config;
    memset(&wifi_config,0,sizeof(wifi_config));
    memcpy(wifi_config.sta.ssid,ssid,strlen(ssid)+1);
    memcpy(wifi_config.sta.password,pass,strlen(pass)+1);
    wifi_config.sta.threshold.authmode = WIFI_AUTH_WPA_WPA2_PSK;
    wifi_config.sta.sae_pwe_h2e = WPA3_SAE_PWE_BOTH;
    wifi_config.sta.sae_h2e_identifier[0]=0;
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );
    ESP_ERROR_CHECK(esp_wifi_start() );
    while(1) {
        EventBits_t bits = xEventGroupGetBits(wifi_event_group)&(WIFI_CONNECTED_BIT|WIFI_FAIL_BIT);
        if(bits==WIFI_CONNECTED_BIT) {
            puts("Connected");
            break;
        }
        if(bits==WIFI_FAIL_BIT) {
            puts("Unable to connect");
            while(1) vTaskDelay(5);
        }
    }
    static const char* url =
        "http://www.google.com/images/branding/googlelogo/1x/"
        "googlelogo_light_color_272x92dp.png";
    file = fopen("/spiffs/download.png", "wb");
    if (file == NULL) {
        puts("Unable to create download file");
        while (1) vTaskDelay(5);
    }
    http_download(url, file);
    file = fopen("/spiffs/download.png","rb");
    fseek(file,0,SEEK_END);
    size_t len = ftell(file);
    fclose(file);
    printf("download.png is %0.2fKB\n",((float)len)/1024.f);
}