IHOLL
/
squeezelite-esp32
镜像自地址 https://github.com/sle118/squeezelite-esp32


			
							12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361
							/*
Copyright (c) 2017-2021 Sebastien L
*/

#include "http_server_handlers.h"
#include "cJSON.h"
#include "cmd_system.h"
#include "esp_http_server.h"
#include "esp_system.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "squeezelite-ota.h"
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include "Configurator.h"
#include "accessors.h"
#include "argtable3/argtable3.h"
#include "esp_console.h"
#include "esp_vfs.h"
#include "messaging.h"
#include "network_status.h"
#include "network_wifi.h"
#include "platform_console.h"
#include "platform_esp32.h"
#include "sys/param.h"
#include "tools.h"
#include "pb_encode.h"
#include "pb_decode.h"
#include "Status.pb.h"
#define HTTP_STACK_SIZE (5 * 1024)
const char str_na[] = "N/A";
#define STR_OR_NA(s) s ? s : str_na
/* @brief tag used for ESP serial console messages */
static const char TAG[] = "httpd_handlers";
static const char* www_dir = "/spiffs/www";

SemaphoreHandle_t http_server_config_mutex = NULL;
extern RingbufHandle_t messaging;
#define AUTH_TOKEN_SIZE 50
typedef struct session_context {
    char* auth_token;
    bool authenticated;
    char* sess_ip_address;
    u16_t port;
} session_context_t;
extern cJSON* get_gpio_list(bool refresh);

union sockaddr_aligned {
    struct sockaddr sa;
    struct sockaddr_storage st;
    struct sockaddr_in sin;
    struct sockaddr_in6 sin6;
} aligned_sockaddr_t;
esp_err_t post_handler_buff_receive(httpd_req_t* req);
static const char redirect_payload1[] = "<html><head><title>Redirecting to Captive "
                                        "Portal</title><meta http-equiv='refresh' content='0; url=";
static const char redirect_payload2[] =
    "'></head><body><p>Please wait, refreshing.  If page does not refresh, click <a href='";
static const char redirect_payload3[] = "'>here</a> to login.</p></body></html>";

/**
 * @brief embedded binary data.
 * @see file "component.mk"
 * @see
 * https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html#embedding-binary-data
 */

esp_err_t redirect_processor(httpd_req_t* req, httpd_err_code_t error);

char* alloc_get_http_header(httpd_req_t* req, const char* key) {
    char* buf = NULL;
    size_t buf_len;

    /* Get header value string length and allocate memory for length + 1,
     * extra byte for null termination */
    buf_len = httpd_req_get_hdr_value_len(req, key) + 1;
    if (buf_len > 1) {
        buf = malloc_init_external(buf_len);
        /* Copy null terminated value string into buffer */
        if (httpd_req_get_hdr_value_str(req, "Host", buf, buf_len) == ESP_OK) {
            ESP_LOGD_LOC(TAG, "Found header => %s: %s", key, buf);
        }
    }
    return buf;
}

char* http_alloc_get_socket_address(httpd_req_t* req, u8_t local, in_port_t* portl) {

    socklen_t len;
    union sockaddr_aligned addr;
    len = sizeof(addr);
    ip_addr_t* ip_addr = NULL;
    char* ipstr = malloc_init_external(INET6_ADDRSTRLEN);
    typedef int (*getaddrname_fn_t)(int s, struct sockaddr* name, socklen_t* namelen);
    getaddrname_fn_t get_addr = NULL;

    int s = httpd_req_to_sockfd(req);
    if (s == -1) {
        free(ipstr);
        return strdup_psram("httpd_req_to_sockfd error");
    }
    ESP_LOGV_LOC(TAG, "httpd socket descriptor: %u", s);

    get_addr = local ? &lwip_getsockname : &lwip_getpeername;
    if (get_addr(s, (struct sockaddr*)&addr, &len) < 0) {
        ESP_LOGE_LOC(TAG, "Failed to retrieve socket address");
        sprintf(ipstr, "N/A (0.0.0.%u)", local);
    } else {
        if (addr.sin.sin_family != AF_INET) {
            ip_addr = (ip_addr_t*)&(addr.sin6.sin6_addr);
            inet_ntop(addr.sa.sa_family, ip_addr, ipstr, INET6_ADDRSTRLEN);
            ESP_LOGV_LOC(TAG, "Processing an IPV6 address : %s", ipstr);
            *portl = addr.sin6.sin6_port;
            unmap_ipv4_mapped_ipv6(ip_2_ip4(ip_addr), ip_2_ip6(ip_addr));
        } else {
            ip_addr = (ip_addr_t*)&(addr.sin.sin_addr);
            inet_ntop(addr.sa.sa_family, ip_addr, ipstr, INET6_ADDRSTRLEN);
            ESP_LOGV_LOC(TAG, "Processing an IPV6 address : %s", ipstr);
            *portl = addr.sin.sin_port;
        }
        inet_ntop(AF_INET, ip_addr, ipstr, INET6_ADDRSTRLEN);
        ESP_LOGV_LOC(TAG, "Retrieved ip address:port = %s:%u", ipstr, *portl);
    }
    return ipstr;
}
bool is_captive_portal_host_name(httpd_req_t* req) {
    const char* host_name = NULL;
    const char* ap_host_name = NULL;
    char* ap_ip_address = NULL;
    bool request_contains_hostname = false;
    esp_err_t hn_err = ESP_OK, err = ESP_OK;
    ESP_LOGD_LOC(TAG, "Getting adapter host name");
    if ((err = tcpip_adapter_get_hostname(TCPIP_ADAPTER_IF_STA, &host_name)) != ESP_OK) {
        ESP_LOGE_LOC(TAG, "Unable to get host name. Error: %s", esp_err_to_name(err));
    } else {
        ESP_LOGD_LOC(TAG, "Host name is %s", host_name);
    }

    ESP_LOGD_LOC(TAG, "Getting host name from request");
    char* req_host = alloc_get_http_header(req, "Host");

    if (tcpip_adapter_is_netif_up(TCPIP_ADAPTER_IF_AP)) {
        ESP_LOGD_LOC(TAG, "Soft AP is enabled. getting ip info");
        // Access point is up and running. Get the current IP address
        tcpip_adapter_ip_info_t ip_info;
        esp_err_t ap_ip_err = tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip_info);
        if (ap_ip_err != ESP_OK) {
            ESP_LOGE_LOC(
                TAG, "Unable to get local AP ip address. Error: %s", esp_err_to_name(ap_ip_err));
        } else {
            ESP_LOGD_LOC(TAG, "getting host name for TCPIP_ADAPTER_IF_AP");
            if ((hn_err = tcpip_adapter_get_hostname(TCPIP_ADAPTER_IF_AP, &ap_host_name)) !=
                ESP_OK) {
                ESP_LOGE_LOC(TAG, "Unable to get host name. Error: %s", esp_err_to_name(hn_err));
                err = err == ESP_OK ? hn_err : err;
            } else {
                ESP_LOGD_LOC(TAG, "Soft AP Host name is %s", ap_host_name);
            }

            ap_ip_address = malloc_init_external(IP4ADDR_STRLEN_MAX);
            memset(ap_ip_address, 0x00, IP4ADDR_STRLEN_MAX);
            if (ap_ip_address) {
                ESP_LOGD_LOC(TAG, "Converting soft ip address to string");
                ip4addr_ntoa_r(&ip_info.ip, ap_ip_address, IP4ADDR_STRLEN_MAX);
                ESP_LOGD_LOC(
                    TAG, "TCPIP_ADAPTER_IF_AP is up and has ip address %s ", ap_ip_address);
            }
        }
    }

    if ((request_contains_hostname = (host_name != NULL) && (req_host != NULL) &&
                                     strcasestr(req_host, host_name)) == true) {
        ESP_LOGD_LOC(TAG, "http request host = system host name %s", req_host);
    } else if ((request_contains_hostname = (ap_host_name != NULL) && (req_host != NULL) &&
                                            strcasestr(req_host, ap_host_name)) == true) {
        ESP_LOGD_LOC(TAG, "http request host = AP system host name %s", req_host);
    }

    FREE_AND_NULL(ap_ip_address);
    FREE_AND_NULL(req_host);

    return request_contains_hostname;
}

/* Custom function to free context */
void free_ctx_func(void* ctx) {
    session_context_t* context = (session_context_t*)ctx;
    if (context) {
        ESP_LOGD(TAG, "Freeing up socket context");
        FREE_AND_NULL(context->auth_token);
        FREE_AND_NULL(context->sess_ip_address);
        free(context);
    }
}

session_context_t* get_session_context(httpd_req_t* req) {
    bool newConnection = false;
    if (!req->sess_ctx) {
        ESP_LOGD(TAG, "New connection context. Allocating session buffer");
        req->sess_ctx = malloc_init_external(sizeof(session_context_t));
        req->free_ctx = free_ctx_func;
        newConnection = true;
        // get the remote IP address only once per session
    }
    session_context_t* ctx_data = (session_context_t*)req->sess_ctx;
    FREE_AND_NULL(ctx_data->sess_ip_address);
    ctx_data->sess_ip_address = http_alloc_get_socket_address(req, 0, &ctx_data->port);
    if (newConnection) {
        ESP_LOGI(TAG, "serving %s to peer %s port %u", req->uri, ctx_data->sess_ip_address,
            ctx_data->port);
    }
    return (session_context_t*)req->sess_ctx;
}

bool is_user_authenticated(httpd_req_t* req) {
    session_context_t* ctx_data = get_session_context(req);

    if (ctx_data->authenticated) {
        ESP_LOGD_LOC(TAG, "User is authenticated.");
        return true;
    }

    ESP_LOGD(TAG, "Heap internal:%zu (min:%zu) external:%zu (min:%zu) dma:%zu (min:%zu)",
        heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
        heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL),
        heap_caps_get_free_size(MALLOC_CAP_SPIRAM),
        heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM), heap_caps_get_free_size(MALLOC_CAP_DMA),
        heap_caps_get_minimum_free_size(MALLOC_CAP_DMA));

    // todo:  ask for user to authenticate
    return false;
}

/* Copies the full path into destination buffer and returns
 * pointer to requested file name */
static const char* get_path_from_uri(char* dest, const char* uri, size_t destsize) {
    size_t pathlen = strlen(uri);
    memset(dest, 0x0, destsize);

    const char* quest = strchr(uri, '?');
    if (quest) {
        pathlen = MIN(pathlen, quest - uri);
    }
    const char* hash = strchr(uri, '#');
    if (hash) {
        pathlen = MIN(pathlen, hash - uri);
    }

    if (pathlen + 1 > destsize) {
        /* Full path string won't fit into destination buffer */
        return NULL;
    }

    strlcpy(dest, uri, pathlen + 1);

    // strip trailing blanks
    char* sr = dest + pathlen;
    while (*sr == ' ')
        *sr-- = '\0';

    char* last_fs = strchr(dest, '/');
    if (!last_fs) ESP_LOGD_LOC(TAG, "no / found in %s", dest);
    char* p = last_fs;
    while (p && *(++p) != '\0') {
        if (*p == '/') {
            last_fs = p;
        }
    }
    /* Return pointer to path, skipping the base */
    return last_fs ? ++last_fs : dest;
}

#define IS_FILE_EXT(filename, ext)                                                                 \
    (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)

/* Set HTTP response content type according to file extension */
static esp_err_t set_content_type_from_file(httpd_req_t* req, const char* filename) {
    if (strlen(filename) == 0) {
        // for root page, etc.
        return httpd_resp_set_type(req, HTTPD_TYPE_TEXT);
    } else if (IS_FILE_EXT(filename, ".pdf")) {
        return httpd_resp_set_type(req, "application/pdf");
    } else if (IS_FILE_EXT(filename, ".html")) {
        return httpd_resp_set_type(req, HTTPD_TYPE_TEXT);
    } else if (IS_FILE_EXT(filename, ".jpeg")) {
        return httpd_resp_set_type(req, "image/jpeg");
    } else if (IS_FILE_EXT(filename, ".png")) {
        return httpd_resp_set_type(req, "image/png");
    } else if (IS_FILE_EXT(filename, ".ico")) {
        return httpd_resp_set_type(req, "image/x-icon");
    } else if (IS_FILE_EXT(filename, ".css")) {
        return httpd_resp_set_type(req, "text/css");
    } else if (IS_FILE_EXT(filename, ".js")) {
        return httpd_resp_set_type(req, "text/javascript");
    } else if (IS_FILE_EXT(filename, ".json")) {
        return httpd_resp_set_type(req, HTTPD_TYPE_JSON);
    } else if (IS_FILE_EXT(filename, ".map")) {
        return httpd_resp_set_type(req, "map");
    } else if (IS_FILE_EXT(filename, ".pro")) {
        return httpd_resp_set_type(req, "application/octet-stream");
    }

    /* This is a limited set only */
    /* For any other type always set as plain text */
    return httpd_resp_set_type(req, "text/plain");
}
static esp_err_t set_content_type_from_req(httpd_req_t* req) {
    char filepath[FILE_PATH_MAX];
    const char* filename = get_path_from_uri(filepath, req->uri, sizeof(filepath));
    if (!filename) {
        ESP_LOGE_LOC(TAG, "Filename is too long");
        /* Respond with 500 Internal Server Error */
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filename too long");
        return ESP_FAIL;
    }

    /* If name has trailing '/', respond with directory contents */
    if (filename[strlen(filename) - 1] == '/' && strlen(filename) > 1) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Browsing files forbidden.");
        return ESP_FAIL;
    }
    set_content_type_from_file(req, filename);
    return ESP_OK;
}

// esp_err_t root_get_handler(httpd_req_t *req){
// 	esp_err_t err = ESP_OK;
//     ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
//     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
//     httpd_resp_set_hdr(req, "Accept-Encoding", "identity");

//     if(!is_user_authenticated(req)){
//     	// todo:  send password entry page and return
//     }
// 	int idx=-1;
// 	if((idx=resource_get_index("index.html"))>=0){
// 		const size_t file_size = (resource_map_end[idx] - resource_map_start[idx]);
// 		httpd_resp_set_hdr(req, "Content-Encoding", "gzip");
// 		err = set_content_type_from_req(req);
// 		if(err == ESP_OK){
// 			httpd_resp_send(req, (const char *)resource_map_start[idx], file_size);
// 		}
// 	}
//     else{
// 		httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "index.html not found");
// 	   return ESP_FAIL;
// 	}
// 	ESP_LOGD_LOC(TAG, "done serving [%s]", req->uri);
//     return err;
// }
static bool resolve_file_path(const char* uri, char* resolvedpath, size_t resolvedsize) {
    struct stat file_stat;

    // Assume the base path is the directory where files are served from
    // Generate the expected file path
    snprintf(resolvedpath, resolvedsize, "%s%s", www_dir, uri);

    // Check if file exists
    if (stat(resolvedpath, &file_stat) == 0) {
        // File exists
        return true;
    } else {
        // Check for compressed file
        strncat(resolvedpath, ".gz", resolvedsize - strlen(resolvedpath) - 1);
        if (stat(resolvedpath, &file_stat) == 0) {
            // Compressed file exists
            return true;
        }
    }

    // Neither uncompressed nor compressed file exists
    return false;
}
esp_err_t file_get_handler(httpd_req_t* req) {
    size_t sz;
    char filepath[FILE_PATH_MAX];
    struct stat file_stat={};

    httpd_resp_set_hdr(req, "Content-Encoding", "gzip");

    ESP_LOGD_LOC(TAG, "Serving file from [%s]", req->uri);
    const char* filename = get_path_from_uri(filepath, req->uri, sizeof(filepath));
    if (!filename) {
        ESP_LOGE_LOC(TAG, "Filename is too long");
        /* Respond with 500 Internal Server Error */
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filename too long");
        return ESP_FAIL;
    }
	   /* If name has trailing '/', respond with directory contents */
    if (filename[strlen(filename) - 1] == '/') {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Browsing files forbidden.");
        return ESP_FAIL;
    }
	if (strlen(filename) != 0 && IS_FILE_EXT(filename, ".map")) {
        return httpd_resp_sendstr(req, "");
    }
    if (!resolve_file_path(filename, filepath, sizeof(filepath))) {
        httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File not found");
        return ESP_FAIL;
    }
    esp_err_t err = set_content_type_from_file(req, filepath);
    if (err != ESP_OK) {
        return ESP_FAIL;
    }

    char* buffer = load_file(&sz,filepath);
    if (buffer) {
        if (sz == file_stat.st_size) {
            httpd_resp_send(req, buffer, sz);
        } else {
            ESP_LOGE(TAG, "Failed to read full file : %s", filepath);
            httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read full file");
            err = ESP_FAIL;
        }
        free(buffer);
    } else {
        ESP_LOGE(TAG, "Failed to allocate memory for file : %s", filepath);
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Server out of memory");
        err = ESP_FAIL;
    }
    return ESP_OK;
}

esp_err_t root_get_handler(httpd_req_t* req) {
    size_t sz;
    char filepath[FILE_PATH_MAX];
    esp_err_t err = ESP_OK;
    ESP_LOGD(TAG, "Serving [%s]", req->uri);

    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    httpd_resp_set_hdr(req, "Accept-Encoding", "identity");

    if (!is_user_authenticated(req)) {
        // TODO: Send password entry page and return
    }
    if (!resolve_file_path("index.html", filepath, sizeof(filepath))) {
        httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File not found");
        return ESP_FAIL;
    }
    err = set_content_type_from_file(req, filepath);
    if (err != ESP_OK) {
        return ESP_FAIL;
    }

    char* buffer = load_file(&sz,filepath);
    if (buffer) {
        httpd_resp_send(req, buffer, sz);
        free(buffer);
    } else {
        ESP_LOGE(TAG, "Failed to allocate memory for file : %s", filepath);
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Server out of memory");
        err = ESP_FAIL;
    }

    ESP_LOGD(TAG, "Done serving [%s]", req->uri);
    return err;
}

esp_err_t resource_filehandler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
	esp_err_t err = file_get_handler(req);
     ESP_LOGD_LOC(TAG, "Resource sending complete");
    return err;
}
esp_err_t ap_scan_handler(httpd_req_t* req) {
    const char empty[] = "{}";
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    network_async_scan();
    esp_err_t err = set_content_type_from_req(req);
    if (err == ESP_OK) {
        httpd_resp_send(req, (const char*)empty, HTTPD_RESP_USE_STRLEN);
    }
    return err;
}

esp_err_t console_cmd_get_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    /* if we can get the mutex, write the last version of the AP list */
    esp_err_t err = set_content_type_from_req(req);
    cJSON* cmdlist = get_cmd_list();
    char* json_buffer = cJSON_Print(cmdlist);
    if (json_buffer) {
        httpd_resp_send(req, (const char*)json_buffer, HTTPD_RESP_USE_STRLEN);
        free(json_buffer);
    } else {
        ESP_LOGD_LOC(TAG, "Error retrieving command json string. ");
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Unable to format command");
    }
    cJSON_Delete(cmdlist);
    ESP_LOGD_LOC(TAG, "done serving [%s]", req->uri);
    return err;
}
esp_err_t console_cmd_post_handler(httpd_req_t* req) {
    char success[] = "{\"Result\" : \"Success\" }";
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    // bool bOTA=false;
    // char * otaURL=NULL;
    esp_err_t err = post_handler_buff_receive(req);
    if (err != ESP_OK) {
        return err;
    }
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }

    char* command = ((rest_server_context_t*)(req->user_ctx))->scratch;

    cJSON* root = cJSON_Parse(command);
    if (root == NULL) {
        ESP_LOGE_LOC(TAG, "Parsing command. Received content was: %s", command);
        httpd_resp_send_err(
            req, HTTPD_400_BAD_REQUEST, "Malformed command json.  Unable to parse content.");
        return ESP_FAIL;
    }
    char* root_str = cJSON_Print(root);
    if (root_str != NULL) {
        ESP_LOGD(TAG, "Processing command item: \n%s", root_str);
        free(root_str);
    }
    cJSON* item = cJSON_GetObjectItemCaseSensitive(root, "command");
    if (!item) {
        ESP_LOGE_LOC(TAG, "Command not found. Received content was: %s", command);
        httpd_resp_send_err(
            req, HTTPD_400_BAD_REQUEST, "Malformed command json.  Unable to parse content.");
        err = ESP_FAIL;

    } else {
        // navigate to the first child of the config structure
        char* cmd = cJSON_GetStringValue(item);
        if (!console_push(cmd, strlen(cmd) + 1)) {
            httpd_resp_send_err(
                req, HTTPD_500_INTERNAL_SERVER_ERROR, "Unable to push command for execution");
        } else {
            httpd_resp_send(req, (const char*)success, strlen(success));
        }
    }

    ESP_LOGD_LOC(TAG, "done serving [%s]", req->uri);
    return err;
}


esp_err_t config_get_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = ESP_OK;

// err= set_content_type_from_req(req);
// if(err == ESP_OK){
// 	char * json = config_alloc_get_json(false);
// 	if(json==NULL){
// 		ESP_LOGD_LOC(TAG,  "Error retrieving config json string. ");
// 		httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Error retrieving configuration
// object"); 		err=ESP_FAIL;
// 	}
// 	else {
// 		ESP_LOGD_LOC(TAG,  "config json : %s",json );
// 		cJSON * gplist=get_gpio_list(false);
// 		char * gpliststr=cJSON_PrintUnformatted(gplist);
// 		httpd_resp_sendstr_chunk(req,"{ \"gpio\":");
// 		httpd_resp_sendstr_chunk(req,gpliststr);
// 		httpd_resp_sendstr_chunk(req,", \"config\":");
// 		httpd_resp_sendstr_chunk(req, (const char *)json);
// 		httpd_resp_sendstr_chunk(req,"}");
// 		httpd_resp_sendstr_chunk(req,NULL);
// 		free(gpliststr);
// 		free(json);
// 	}
// }
// TODO: Add support for the commented code
    return err;
}
esp_err_t post_handler_buff_receive(httpd_req_t* req) {
    esp_err_t err = ESP_OK;

    int total_len = req->content_len;
    int cur_len = 0;
    char* buf = ((rest_server_context_t*)(req->user_ctx))->scratch;
    int received = 0;
    if (total_len >= SCRATCH_BUFSIZE) {
        /* Respond with 500 Internal Server Error */
        ESP_LOGE_LOC(TAG, "Received content was too long. ");
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Content too long");
        err = ESP_FAIL;
    }
    while (err == ESP_OK && cur_len < total_len) {
        received = httpd_req_recv(req, buf + cur_len, total_len);
        if (received <= 0) {
            /* Respond with 500 Internal Server Error */
            ESP_LOGE_LOC(TAG, "Not all data was received. ");
            httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Not all data was received");
            err = ESP_FAIL;
        } else {
            cur_len += received;
        }
    }

    if (err == ESP_OK) {
        buf[total_len] = '\0';
    }
    return err;
}

esp_err_t configurator_post_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    bool bOTA = false;
    char* otaURL = NULL;
    esp_err_t err = post_handler_buff_receive(req);
    if (err != ESP_OK) {
        return err;
    }
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }

    char* buf = ((rest_server_context_t*)(req->user_ctx))->scratch;
    cJSON* root = cJSON_Parse(buf);
    if (root == NULL) {
        ESP_LOGE_LOC(TAG, "Parsing config json failed. Received content was: %s", buf);
        httpd_resp_send_err(
            req, HTTPD_400_BAD_REQUEST, "Malformed config json.  Unable to parse content.");
        return ESP_FAIL;
    }

    char* root_str = cJSON_Print(root);
    if (root_str != NULL) {
        ESP_LOGD(TAG, "Processing config item: \n%s", root_str);
        free(root_str);
    }

    cJSON* item = cJSON_GetObjectItemCaseSensitive(root, "config");
    if (!item) {
        ESP_LOGE_LOC(TAG, "Parsing config json failed. Received content was: %s", buf);
        httpd_resp_send_err(
            req, HTTPD_400_BAD_REQUEST, "Malformed config json.  Unable to parse content.");
        err = ESP_FAIL;
    } else {
        // navigate to the first child of the config structure
        if (item->child) item = item->child;
    }

    // while (item && err == ESP_OK)
    // {
    // 	cJSON *prev_item = item;
    // 	item=item->next;
    // 	char * entry_str = cJSON_Print(prev_item);
    // 	if(entry_str!=NULL){
    // 		ESP_LOGD_LOC(TAG, "Processing config item: \n%s", entry_str);
    // 		free(entry_str);
    // 	}

    // 	if(prev_item->string==NULL) {
    // 		ESP_LOGD_LOC(TAG,"Config value does not have a name");
    // 		httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Malformed config json.  Value does not
    // have a name."); 		err = ESP_FAIL;
    // 	}
    // 	if(err == ESP_OK){
    // 		ESP_LOGD_LOC(TAG,"Found config value name [%s]", prev_item->string);
    // 	nvs_type_t item_type=  config_get_item_type(prev_item);
    // 	if(item_type!=0){
    // 		void * val = config_safe_alloc_get_entry_value(item_type, prev_item);
    // 		if(val!=NULL){
    // 			if(strcmp(prev_item->string, "fwurl")==0) {
    // 				if(item_type!=NVS_TYPE_STR){
    // 					ESP_LOGE_LOC(TAG,"Firmware url should be type %d. Found type %d
    // instead.",NVS_TYPE_STR,item_type ); 					httpd_resp_send_err(req,
    // HTTPD_400_BAD_REQUEST,
    // "Malformed config json.  Wrong type for firmware URL."); 					err = ESP_FAIL;
    // 				}
    // 				else {
    // 					// we're getting a request to do an OTA from that URL
    // 					ESP_LOGW_LOC(TAG,   "Found OTA request!");
    // 					otaURL=strdup_psram(val);
    // 					bOTA=true;
    // 				}
    // 			}
    // 			else {
    // 				if(config_set_value(item_type, prev_item->string , val) != ESP_OK){
    // 					ESP_LOGE_LOC(TAG,"Unable to store value for [%s]", prev_item->string);
    // 					httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR , "Unable to store
    // config value"); 					err = ESP_FAIL;
    // 				}
    // 				else {
    // 					ESP_LOGD_LOC(TAG,"Successfully set value for [%s]",prev_item->string);
    // 				}
    // 			}
    // 			free(val);
    // 		}
    // 		else {
    // 			char messageBuffer[101]={};
    // 			ESP_LOGE_LOC(TAG,"Value not found for [%s]", prev_item->string);
    // 			snprintf(messageBuffer,sizeof(messageBuffer),"Malformed config json.  Missing value
    // for entry %s.",prev_item->string); 			httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
    // messageBuffer); 			err = ESP_FAIL;
    // 		}
    // 	}
    // 	else {
    // 		ESP_LOGE_LOC(TAG,"Unable to determine the type of config value [%s]",
    // prev_item->string); 		httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Malformed config
    // json. Missing value for entry."); 		err = ESP_FAIL;
    // 	}
    // }
    // }

    cJSON_Delete(root);
    if (bOTA) {

        if (is_recovery_running) {
            ESP_LOGW_LOC(TAG, "Starting process OTA for url %s", otaURL);
        } else {
            ESP_LOGW_LOC(TAG, "Restarting system to process OTA for url %s", otaURL);
        }

        network_reboot_ota(otaURL);
        free(otaURL);
    }
    return err;
}
esp_err_t configurator_get_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = ESP_OK;
    void* config = NULL;
    size_t datalen;

    err = set_content_type_from_req(req);

    if (err == ESP_OK) {
        config = configurator_alloc_get_config(&datalen);
        if (!config) {
            ESP_LOGE_LOC(TAG, "Unable to serialize configuration");
            httpd_resp_send_err(
                req, HTTPD_500_INTERNAL_SERVER_ERROR, "Unable to serialize configuration");
            err = ESP_FAIL;
        } else {
            httpd_resp_send(req, (const char*)config, datalen);
            free(config);
        }
    }

// if(err == ESP_OK){
// 	char * json = config_alloc_get_json(false);
// 	if(json==NULL){
// 		ESP_LOGD_LOC(TAG,  "Error retrieving config json string. ");
// 		httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Error retrieving configuration
// object"); 		err=ESP_FAIL;
// 	}
// 	else {
// 		ESP_LOGD_LOC(TAG,  "config json : %s",json );
// 		cJSON * gplist=get_gpio_list(false);
// 		char * gpliststr=cJSON_PrintUnformatted(gplist);
// 		httpd_resp_sendstr_chunk(req,"{ \"gpio\":");
// 		httpd_resp_sendstr_chunk(req,gpliststr);
// 		httpd_resp_sendstr_chunk(req,", \"config\":");
// 		httpd_resp_sendstr_chunk(req, (const char *)json);
// 		httpd_resp_sendstr_chunk(req,"}");
// 		httpd_resp_sendstr_chunk(req,NULL);
// 		free(gpliststr);
// 		free(json);
// 	}
// }
// TODO: Add support for the commented code
    return err;
}

esp_err_t config_post_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    bool bOTA = false;
    char* otaURL = NULL;
    esp_err_t err = post_handler_buff_receive(req);
    if (err != ESP_OK) {
        return err;
    }
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }

    char* buf = ((rest_server_context_t*)(req->user_ctx))->scratch;
    cJSON* root = cJSON_Parse(buf);
    if (root == NULL) {
        ESP_LOGE_LOC(TAG, "Parsing config json failed. Received content was: %s", buf);
        httpd_resp_send_err(
            req, HTTPD_400_BAD_REQUEST, "Malformed config json.  Unable to parse content.");
        return ESP_FAIL;
    }

    char* root_str = cJSON_Print(root);
    if (root_str != NULL) {
        ESP_LOGD(TAG, "Processing config item: \n%s", root_str);
        free(root_str);
    }

    cJSON* item = cJSON_GetObjectItemCaseSensitive(root, "config");
    if (!item) {
        ESP_LOGE_LOC(TAG, "Parsing config json failed. Received content was: %s", buf);
        httpd_resp_send_err(
            req, HTTPD_400_BAD_REQUEST, "Malformed config json.  Unable to parse content.");
        err = ESP_FAIL;
    } else {
        // navigate to the first child of the config structure
        if (item->child) item = item->child;
    }

    // while (item && err == ESP_OK)
    // {
    // 	cJSON *prev_item = item;
    // 	item=item->next;
    // 	char * entry_str = cJSON_Print(prev_item);
    // 	if(entry_str!=NULL){
    // 		ESP_LOGD_LOC(TAG, "Processing config item: \n%s", entry_str);
    // 		free(entry_str);
    // 	}

    // 	if(prev_item->string==NULL) {
    // 		ESP_LOGD_LOC(TAG,"Config value does not have a name");
    // 		httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Malformed config json.  Value does not
    // have a name."); 		err = ESP_FAIL;
    // 	}
    // 	if(err == ESP_OK){
    // 		ESP_LOGD_LOC(TAG,"Found config value name [%s]", prev_item->string);
    // 	nvs_type_t item_type=  config_get_item_type(prev_item);
    // 	if(item_type!=0){
    // 		void * val = config_safe_alloc_get_entry_value(item_type, prev_item);
    // 		if(val!=NULL){
    // 			if(strcmp(prev_item->string, "fwurl")==0) {
    // 				if(item_type!=NVS_TYPE_STR){
    // 					ESP_LOGE_LOC(TAG,"Firmware url should be type %d. Found type %d
    // instead.",NVS_TYPE_STR,item_type ); 					httpd_resp_send_err(req,
    // HTTPD_400_BAD_REQUEST,
    // "Malformed config json.  Wrong type for firmware URL."); 					err = ESP_FAIL;
    // 				}
    // 				else {
    // 					// we're getting a request to do an OTA from that URL
    // 					ESP_LOGW_LOC(TAG,   "Found OTA request!");
    // 					otaURL=strdup_psram(val);
    // 					bOTA=true;
    // 				}
    // 			}
    // 			else {
    // 				if(config_set_value(item_type, prev_item->string , val) != ESP_OK){
    // 					ESP_LOGE_LOC(TAG,"Unable to store value for [%s]", prev_item->string);
    // 					httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR , "Unable to store
    // config value"); 					err = ESP_FAIL;
    // 				}
    // 				else {
    // 					ESP_LOGD_LOC(TAG,"Successfully set value for [%s]",prev_item->string);
    // 				}
    // 			}
    // 			free(val);
    // 		}
    // 		else {
    // 			char messageBuffer[101]={};
    // 			ESP_LOGE_LOC(TAG,"Value not found for [%s]", prev_item->string);
    // 			snprintf(messageBuffer,sizeof(messageBuffer),"Malformed config json.  Missing value
    // for entry %s.",prev_item->string); 			httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
    // messageBuffer); 			err = ESP_FAIL;
    // 		}
    // 	}
    // 	else {
    // 		ESP_LOGE_LOC(TAG,"Unable to determine the type of config value [%s]",
    // prev_item->string); 		httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Malformed config
    // json. Missing value for entry."); 		err = ESP_FAIL;
    // 	}
    // }
    // }
// TODO: Add support for the commented code

    if (err == ESP_OK) {
        httpd_resp_sendstr(req, "{ \"result\" : \"OK\" }");
        messaging_post_message(MESSAGING_INFO, MESSAGING_CLASS_SYSTEM, "Save Success");
    }
    cJSON_Delete(root);
    if (bOTA) {

        if (is_recovery_running) {
            ESP_LOGW_LOC(TAG, "Starting process OTA for url %s", otaURL);
        } else {
            ESP_LOGW_LOC(TAG, "Restarting system to process OTA for url %s", otaURL);
        }

        network_reboot_ota(otaURL);
        free(otaURL);
    }
    return err;
}
esp_err_t connect_post_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    char success[] = "{}";
    char* ssid = NULL;
    char* password = NULL;
    char* host_name = NULL;

    esp_err_t err = post_handler_buff_receive(req);
    if (err != ESP_OK) {
        return err;
    }
    err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }

    char* buf = ((rest_server_context_t*)(req->user_ctx))->scratch;
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    cJSON* root = cJSON_Parse(buf);

    if (root == NULL) {
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "JSON parsing error.");
        return ESP_FAIL;
    }

    cJSON* ssid_object = cJSON_GetObjectItem(root, "ssid");
    if (ssid_object != NULL) {
        ssid = strdup_psram(ssid_object->valuestring);
    }
    cJSON* password_object = cJSON_GetObjectItem(root, "pwd");
    if (password_object != NULL) {
        password = strdup_psram(password_object->valuestring);
    }
    cJSON* host_name_object = cJSON_GetObjectItem(root, "host_name");
    if (host_name_object != NULL) {
        host_name = strdup_psram(host_name_object->valuestring);
    }
    cJSON_Delete(root);

// if(host_name!=NULL){
// 	if(config_set_value(NVS_TYPE_STR, "host_name", host_name) != ESP_OK){
// 		ESP_LOGW_LOC(TAG,  "Unable to save host name configuration");
// 	}
// }
// TODO: Add support for the commented code

    if (ssid != NULL && strlen(ssid) <= MAX_SSID_SIZE && strlen(password) <= MAX_PASSWORD_SIZE) {
        network_async_connect(ssid, password);
        httpd_resp_send(req, (const char*)success, strlen(success));
    } else {
        httpd_resp_send_err(
            req, HTTPD_400_BAD_REQUEST, "Malformed json. Missing or invalid ssid/password.");
        err = ESP_FAIL;
    }
// FREE_AND_NULL(ssid);
// FREE_AND_NULL(password);
// FREE_AND_NULL(host_name);
// TODO: Add support for the commented code
    return err;
}
esp_err_t connect_delete_handler(httpd_req_t* req) {
    char success[] = "{}";
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }
    httpd_resp_send(req, (const char*)success, strlen(success));
    network_async_delete();

    return ESP_OK;
}
esp_err_t reboot_ota_post_handler(httpd_req_t* req) {
    char success[] = "{}";
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }

    httpd_resp_send(req, (const char*)success, strlen(success));
    network_async_reboot(OTA);
    return ESP_OK;
}
esp_err_t reboot_post_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    char success[] = "{}";
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }
    httpd_resp_send(req, (const char*)success, strlen(success));
    network_async_reboot(RESTART);
    return ESP_OK;
}
esp_err_t recovery_post_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    char success[] = "{}";
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }
    httpd_resp_send(req, (const char*)success, strlen(success));
    network_async_reboot(RECOVERY);
    return ESP_OK;
}

esp_err_t flash_post_handler(httpd_req_t* req) {
    esp_err_t err = ESP_OK;
    if (is_recovery_running) {
        ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
        char success[] = "File uploaded. Flashing started.";
        if (!is_user_authenticated(req)) {
            // todo:  redirect to login page
            // return ESP_OK;
        }
        err = httpd_resp_set_type(req, HTTPD_TYPE_TEXT);
        if (err != ESP_OK) {
            return err;
        }
        char* binary_buffer = malloc_init_external(req->content_len);
        if (binary_buffer == NULL) {
            ESP_LOGE(TAG, "File too large : %d bytes", req->content_len);
            /* Respond with 400 Bad Request */
            httpd_resp_send_err(
                req, HTTPD_400_BAD_REQUEST, "Binary file too large. Unable to allocate memory!");
            return ESP_FAIL;
        }
        ESP_LOGI(TAG, "Receiving ota binary file");
        /* Retrieve the pointer to scratch buffer for temporary storage */
        char* buf = ((rest_server_context_t*)(req->user_ctx))->scratch;

        char* head = binary_buffer;
        int received;

        /* Content length of the request gives
         * the size of the file being uploaded */
        int remaining = req->content_len;

        while (remaining > 0) {

            ESP_LOGI(TAG, "Remaining size : %d", remaining);
            /* Receive the file part by part into a buffer */
            if ((received = httpd_req_recv(req, buf, MIN(remaining, SCRATCH_BUFSIZE))) <= 0) {
                if (received == HTTPD_SOCK_ERR_TIMEOUT) {
                    /* Retry if timeout occurred */
                    continue;
                }
// FREE_RESET(binary_buffer);
// TODO: Add support for the commented code
                ESP_LOGE(TAG, "File reception failed!");
                /* Respond with 500 Internal Server Error */
                httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
                err = ESP_FAIL;
                goto bail_out;
            }

            /* Write buffer content to file on storage */
            if (received) {
                memcpy(head, buf, received);
                head += received;
            }

            /* Keep track of remaining size of
             * the file left to be uploaded */
            remaining -= received;
        }

        /* Close file upon upload completion */
        ESP_LOGI(TAG, "File reception complete. Invoking OTA process.");
        err = start_ota(NULL, binary_buffer, req->content_len);
        if (err != ESP_OK) {
            httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "OTA processing failed");
            goto bail_out;
        }

        // todo:  handle this in ajax.  For now, just send the root page
        httpd_resp_send(req, (const char*)success, strlen(success));
    }
bail_out:

    return err;
}

char* get_ap_ip_address() {
    static char ap_ip_address[IP4ADDR_STRLEN_MAX] = {};

    tcpip_adapter_ip_info_t ip_info;
    esp_err_t err = ESP_OK;
    memset(ap_ip_address, 0x00, sizeof(ap_ip_address));

    ESP_LOGD_LOC(TAG, "checking if soft AP is enabled");
    if (tcpip_adapter_is_netif_up(TCPIP_ADAPTER_IF_AP)) {
        ESP_LOGD_LOC(TAG, "Soft AP is enabled. getting ip info");
        // Access point is up and running. Get the current IP address
        err = tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip_info);
        if (err != ESP_OK) {
            ESP_LOGE_LOC(TAG, "Unable to get local AP ip address. Error: %s", esp_err_to_name(err));
        } else {
            ESP_LOGV_LOC(TAG, "Converting soft ip address to string");
            ip4addr_ntoa_r(&ip_info.ip, ap_ip_address, IP4ADDR_STRLEN_MAX);
            ESP_LOGD_LOC(TAG, "TCPIP_ADAPTER_IF_AP is up and has ip address %s ", ap_ip_address);
        }
    } else {
        ESP_LOGD_LOC(TAG, "AP Is not enabled. Returning blank string");
    }
    return ap_ip_address;
}
esp_err_t process_redirect(httpd_req_t* req, const char* status) {
    const char location_prefix[] = "http://";
    char* ap_ip_address = get_ap_ip_address();
    char* remote_ip = NULL;
    in_port_t port = 0;
    char* redirect_url = NULL;

    ESP_LOGD_LOC(TAG, "Getting remote socket address");
    remote_ip = http_alloc_get_socket_address(req, 0, &port);

    size_t buf_size = strlen(redirect_payload1) + strlen(redirect_payload2) +
                      strlen(redirect_payload3) +
                      2 * (strlen(location_prefix) + strlen(ap_ip_address)) + 1;
    char* redirect = malloc_init_external(buf_size);

    if (strcasestr(status, "302")) {
        size_t url_buf_size = strlen(location_prefix) + strlen(ap_ip_address) + 1;
        redirect_url = malloc_init_external(url_buf_size);
        memset(redirect_url, 0x00, url_buf_size);
        snprintf(redirect_url, buf_size, "%s%s/", location_prefix, ap_ip_address);
        ESP_LOGW_LOC(
            TAG, "Redirecting host [%s] to %s (from uri %s)", remote_ip, redirect_url, req->uri);
        httpd_resp_set_hdr(req, "Location", redirect_url);
        snprintf(redirect, buf_size, "OK");
    } else {

        snprintf(redirect, buf_size, "%s%s%s%s%s%s%s", redirect_payload1, location_prefix,
            ap_ip_address, redirect_payload2, location_prefix, ap_ip_address, redirect_payload3);
        ESP_LOGW_LOC(TAG, "Responding to host [%s] (from uri %s) with redirect html page %s",
            remote_ip, req->uri, redirect);
    }

    httpd_resp_set_type(req, HTTPD_TYPE_TEXT);
    httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
    httpd_resp_set_status(req, status);
    httpd_resp_send(req, redirect, HTTPD_RESP_USE_STRLEN);
    FREE_AND_NULL(redirect);
    FREE_AND_NULL(redirect_url);
    FREE_AND_NULL(remote_ip);

    return ESP_OK;
}
esp_err_t redirect_200_ev_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "Processing known redirect url %s", req->uri);
    process_redirect(req, "200 OK");
    return ESP_OK;
}
esp_err_t redirect_processor(httpd_req_t* req, httpd_err_code_t error) {
    esp_err_t err = ESP_OK;
    const char* host_name = NULL;
    const char* ap_host_name = NULL;
    char* user_agent = NULL;
    char* remote_ip = NULL;
    char* sta_ip_address = NULL;
    char* ap_ip_address = get_ap_ip_address();
    char* socket_local_address = NULL;
    bool request_contains_hostname = false;
    bool request_contains_ap_ip_address = false;
    bool request_is_sta_ip_address = false;
    bool connected_to_ap_ip_interface = false;
    bool connected_to_sta_ip_interface = false;
    bool useragentiscaptivenetwork = false;

    in_port_t port = 0;
    ESP_LOGV_LOC(TAG, "Getting remote socket address");
    remote_ip = http_alloc_get_socket_address(req, 0, &port);

    ESP_LOGW_LOC(TAG, "%s requested invalid URL: [%s]", remote_ip, req->uri);
    if (network_status_lock_structure(portMAX_DELAY)) {
        sta_ip_address = strdup_psram(status.net.ip.ip);
        network_status_unlock_structure();
    } else {
        ESP_LOGE(TAG, "Unable to obtain local IP address from WiFi Manager.");
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, NULL);
    }

    ESP_LOGV_LOC(TAG, "Getting host name from request");
    char* req_host = alloc_get_http_header(req, "Host");

    user_agent = alloc_get_http_header(req, "User-Agent");
    if ((useragentiscaptivenetwork =
                (user_agent != NULL && strcasestr(user_agent, "CaptiveNetworkSupport")) == true)) {
        ESP_LOGW_LOC(TAG, "Found user agent that supports captive networks! [%s]", user_agent);
    }

    esp_err_t hn_err = ESP_OK;
    ESP_LOGV_LOC(TAG, "Getting adapter host name");
    if ((hn_err = tcpip_adapter_get_hostname(TCPIP_ADAPTER_IF_STA, &host_name)) != ESP_OK) {
        ESP_LOGE_LOC(TAG, "Unable to get host name. Error: %s", esp_err_to_name(hn_err));
        err = err == ESP_OK ? hn_err : err;
    } else {
        ESP_LOGV_LOC(TAG, "Host name is %s", host_name);
    }

    in_port_t loc_port = 0;
    ESP_LOGV_LOC(TAG, "Getting local socket address");
    socket_local_address = http_alloc_get_socket_address(req, 1, &loc_port);

    ESP_LOGD_LOC(TAG,
        "Peer IP: %s [port %u], System AP IP address: %s, System host: %s. Requested Host: [%s], "
        "uri [%s]",
        STR_OR_NA(remote_ip), port, STR_OR_NA(ap_ip_address), STR_OR_NA(host_name),
        STR_OR_NA(req_host), req->uri);
    /* captive portal functionality: redirect to access point IP for HOST that are not the access
     * point IP OR the STA IP */
    /* determine if Host is from the STA IP address */

    if ((request_contains_hostname = (host_name != NULL) && (req_host != NULL) &&
                                     strcasestr(req_host, host_name)) == true) {
        ESP_LOGD_LOC(TAG, "http request host = system host name %s", req_host);
    } else if ((request_contains_hostname = (ap_host_name != NULL) && (req_host != NULL) &&
                                            strcasestr(req_host, ap_host_name)) == true) {
        ESP_LOGD_LOC(TAG, "http request host = AP system host name %s", req_host);
    }
    if ((request_contains_ap_ip_address = (ap_ip_address != NULL) && (req_host != NULL) &&
                                          strcasestr(req_host, ap_ip_address)) == true) {
        ESP_LOGD_LOC(TAG, "http request host is access point ip address %s", req_host);
    }
    if ((connected_to_ap_ip_interface = (ap_ip_address != NULL) && (socket_local_address != NULL) &&
                                        strcasestr(socket_local_address, ap_ip_address)) == true) {
        ESP_LOGD_LOC(
            TAG, "http request is connected to access point interface IP %s", ap_ip_address);
    }
    if ((request_is_sta_ip_address = (sta_ip_address != NULL) && (req_host != NULL) &&
                                     strcasestr(req_host, sta_ip_address)) == true) {
        ESP_LOGD_LOC(TAG, "http request host is WiFi client ip address %s", req_host);
    }
    if ((connected_to_sta_ip_interface =
                (sta_ip_address != NULL) && (socket_local_address != NULL) &&
                strcasestr(sta_ip_address, socket_local_address)) == true) {
        ESP_LOGD_LOC(TAG, "http request is connected to WiFi client ip address %s", sta_ip_address);
    }

    if ((error == 0) || (error == HTTPD_404_NOT_FOUND && connected_to_ap_ip_interface &&
                            !(request_contains_ap_ip_address || request_contains_hostname))) {
        process_redirect(req, "302 Found");

    } else {
        ESP_LOGD_LOC(
            TAG, "URL not found, and not processing captive portal so throw regular 404 error");
        httpd_resp_send_err(req, error, NULL);
    }

    FREE_AND_NULL(socket_local_address);

    FREE_AND_NULL(req_host);
    FREE_AND_NULL(user_agent);

    FREE_AND_NULL(sta_ip_address);
    FREE_AND_NULL(remote_ip);
    return err;
}
esp_err_t redirect_ev_handler(httpd_req_t* req) { return redirect_processor(req, 0); }

esp_err_t messages_get_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = set_content_type_from_req(req);
    if (err != ESP_OK) {
        return err;
    }
    cJSON* json_messages = messaging_retrieve_messages(messaging);
    if (json_messages != NULL) {
        char* json_text = cJSON_Print(json_messages);
        httpd_resp_send(req, (const char*)json_text, strlen(json_text));
        free(json_text);
        cJSON_Delete(json_messages);
    } else {
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Unable to retrieve messages");
    }
    return ESP_OK;
}

esp_err_t status_get_handler(httpd_req_t* req) {
    ESP_LOGD_LOC(TAG, "serving [%s]", req->uri);
    if (!is_user_authenticated(req)) {
        // todo:  redirect to login page
        // return ESP_OK;
    }
    esp_err_t err = httpd_resp_set_type(req, "application/octet-stream");
    if (err != ESP_OK) {
        return err;
    }

    ESP_LOGD(TAG, "Creating binding");
    pb_ostream_t filestream = {&out_http_binding, req, SIZE_MAX, 0};
    ESP_LOGD(TAG, "Starting encode");
    if (!pb_encode(&filestream, sys_Config_fields, (void*)&status)) {
        ESP_LOGE(TAG, "Encoding failed: %s\n", PB_GET_ERROR(&filestream));
        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, PB_GET_ERROR(&filestream));
    }
    else {
        ESP_LOGD(TAG, "Encoded size: %d", filestream.bytes_written);
        if (filestream.bytes_written == 0) {
            ESP_LOGE(TAG, "Empty status!");
            httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Empty status!");
        }
    }

    // update status for next status call
    network_async_update_status();

    return ESP_OK;
}

esp_err_t err_handler(httpd_req_t* req, httpd_err_code_t error) {
    esp_err_t err = ESP_OK;

    if (error != HTTPD_404_NOT_FOUND) {
        err = httpd_resp_send_err(req, error, NULL);
    } else {
        err = redirect_processor(req, error);
    }

    return err;
}