Not a valid DAV response about webdavserver HOT 12 OPEN

#include <driver/timer.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <nvs_flash.h>
#include <stdio.h>
#include <esp_log.h>

#include <esp_http_server.h>
#include <esp_wifi.h>

#include <string>
#include <sstream>

#define CONFIG_WIFI_SSID       "WIFI_SSID"
#define CONFIG_WIFI_PASSWORD   "password"

static const char *TAG = "httpd chunk test";

static httpd_handle_t server = NULL;

static esp_err_t sendHEAD(httpd_req_t *req)
{
    httpd_resp_set_status(req, "200 OK");

    httpd_resp_send_chunk(req, NULL, 0);
    return ESP_OK;
}

static esp_err_t sendPROPFIND(httpd_req_t *req)
{
    httpd_resp_set_status(req, "207 Multi-Status");
    httpd_resp_set_type(req, "application/xml; charset=\"utf-8\"");
    httpd_resp_set_hdr(req, "DAV", "2");
    httpd_resp_set_hdr(req, "Allow", "PROPFIND,OPTIONS,DELETE,COPY,MOVE,HEAD,POST,PUT,GET");

    httpd_resp_send_chunk(req, "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", HTTPD_RESP_USE_STRLEN);
    httpd_resp_send_chunk(req, "<multistatus xmlns=\"DAV:\">\n", HTTPD_RESP_USE_STRLEN);

    // s << "<response>\n";
    // s << "<href>/</href>";
    // s << "<propstat><prop>\n";

    // s << "<displayname></displayname>";
    // s << "<getlastmodified>Wed, 16 Nov 02:14:28 GMT</getlastmodified>";
    // s << "<getetag>0</getetag>";
    // s << "<resourcetype>";
    // s << "<collection/>";
    // s << "</resourcetype>";

    // s << "</prop>\n";
    // s << "<status>HTTP/1.1 200 OK</status>";
    // s << "</propstat></response>\n";

    // httpd_resp_send_chunk(req, s.str().c_str(), HTTPD_RESP_USE_STRLEN);

    int i = 0;
    while ( i++ < 20)
    {
        //httpd_resp_send_chunk(req, ("This is chunck #" + std::to_string(i) + "<br/>\n").c_str(), -1);

        std::ostringstream s;
        s << "<response>\n";
        s << "<href>file" << std::to_string(i) << ".txt</href>";
        s << "<propstat><prop>\n";

        s << "<displayname>file" << std::to_string(i) << ".txt</displayname>";
        s << "<getlastmodified>Wed, 16 Nov 02:14:28 GMT</getlastmodified>";
        s << "<getetag>0</getetag>";
        s << "<resourcetype>";
        // s << "<collection/>";
        s << "</resourcetype>";

        s << "</prop>\n";
        s << "<status>HTTP/1.1 200 OK</status>";
        s << "</propstat></response>\n";

        httpd_resp_send_chunk(req, s.str().c_str(), HTTPD_RESP_USE_STRLEN);
    }

    httpd_resp_send_chunk(req, "</multistatus>\n", HTTPD_RESP_USE_STRLEN);

    httpd_resp_send_chunk(req, NULL, 0);
    return ESP_OK;
}

static httpd_uri_t http_head = {
    .uri        = "/",
    .method     = HTTP_HEAD,
    .handler    = sendHEAD,
    .user_ctx   = NULL
};

static httpd_uri_t http_propfind = {
    .uri        = "/",
    .method     = HTTP_PROPFIND,
    .handler    = sendPROPFIND,
    .user_ctx   = NULL
};

httpd_handle_t http_start_webserver(void)
{
    httpd_handle_t server = NULL;
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();

    // Start the httpd server
    ESP_LOGI(TAG, "Starting server on port: '%d'", config.server_port);
    if (httpd_start(&server, &config) == ESP_OK) {
        // Set URI handlers
        ESP_LOGI(TAG, "Registering URI handlers");
        httpd_register_uri_handler(server, &http_head);
        httpd_register_uri_handler(server, &http_propfind);
        return server;
    }

    ESP_LOGI(TAG, "Error starting server!");
    return NULL;
}

void http_stop_webserver(httpd_handle_t server)
{
    // Stop the httpd server
    httpd_stop(server);
}

static esp_err_t wifi_event_handler(void *ctx, system_event_t *event)
{
    switch(event->event_id) {
    case SYSTEM_EVENT_STA_START:
        ESP_LOGI(TAG, "SYSTEM_EVENT_STA_START");
        ESP_ERROR_CHECK(esp_wifi_connect());
        break;
    case SYSTEM_EVENT_STA_GOT_IP:

        ip4_addr_t ip4;
        ip4.addr = event->event_info.got_ip.ip_info.ip.addr;

        ESP_LOGI(TAG, "SYSTEM_EVENT_STA_GOT_IP");
        ESP_LOGI(TAG, "Got IP: '%s'", ip4addr_ntoa(&ip4));

        /* Start the web server */
        if (server == NULL) {
            server = http_start_webserver();
        }
        break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
        ESP_LOGI(TAG, "SYSTEM_EVENT_STA_DISCONNECTED");
        ESP_ERROR_CHECK(esp_wifi_connect());

        /* Stop the web server */
        if (server) {
            http_stop_webserver(server);
            server = NULL;
        }
        break;
    default:
        break;
    }
    return ESP_OK;
}

void wifi_initialise()
{
    tcpip_adapter_init();
    ESP_ERROR_CHECK(esp_event_loop_init(wifi_event_handler, NULL));
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));

    wifi_config_t wifi_config;
    memset(&wifi_config, 0, sizeof(wifi_config));

    strlcpy((char *)wifi_config.sta.ssid, CONFIG_WIFI_SSID, sizeof(wifi_config.sta.ssid));
    strlcpy((char *)wifi_config.sta.password, CONFIG_WIFI_PASSWORD, sizeof(wifi_config.sta.password));

    ESP_LOGI(TAG, "Setting WiFi configuration SSID %s...", wifi_config.sta.ssid);
    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());
}

extern "C"
{
    void app_main()
    {
        ESP_ERROR_CHECK(nvs_flash_init());
        wifi_initialise();
    }
}