mirror of
https://github.com/jomjol/AI-on-the-edge-device.git
synced 2025-12-11 22:16:56 +03:00
303 lines
9.8 KiB
C++
303 lines
9.8 KiB
C++
#include "server_main.h"
|
|
|
|
#include <string>
|
|
|
|
#include "server_help.h"
|
|
|
|
#include "time_sntp.h"
|
|
|
|
|
|
httpd_handle_t server = NULL;
|
|
|
|
|
|
std::string starttime = "";
|
|
|
|
|
|
/* An HTTP GET handler */
|
|
esp_err_t hello_get_handler(httpd_req_t *req)
|
|
{
|
|
char* buf;
|
|
size_t buf_len;
|
|
printf("req uri:\n");
|
|
printf(req->uri);
|
|
printf("\n");
|
|
|
|
/* 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, "Host") + 1;
|
|
if (buf_len > 1) {
|
|
buf = (char*) malloc(buf_len);
|
|
/* Copy null terminated value string into buffer */
|
|
if (httpd_req_get_hdr_value_str(req, "Host", buf, buf_len) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Found header => Host: %s", buf);
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
buf_len = httpd_req_get_hdr_value_len(req, "Test-Header-2") + 1;
|
|
if (buf_len > 1) {
|
|
buf = (char*) malloc(buf_len);
|
|
if (httpd_req_get_hdr_value_str(req, "Test-Header-2", buf, buf_len) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Found header => Test-Header-2: %s", buf);
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
buf_len = httpd_req_get_hdr_value_len(req, "Test-Header-1") + 1;
|
|
if (buf_len > 1) {
|
|
buf = (char*) malloc(buf_len);
|
|
if (httpd_req_get_hdr_value_str(req, "Test-Header-1", buf, buf_len) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Found header => Test-Header-1: %s", buf);
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
/* Read URL query string length and allocate memory for length + 1,
|
|
* extra byte for null termination */
|
|
buf_len = httpd_req_get_url_query_len(req) + 1;
|
|
if (buf_len > 1) {
|
|
buf = (char*) malloc(buf_len);
|
|
if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Found URL query => %s", buf);
|
|
char param[32];
|
|
/* Get value of expected key from query string */
|
|
if (httpd_query_key_value(buf, "query1", param, sizeof(param)) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Found URL query parameter => query1=%s", param);
|
|
}
|
|
if (httpd_query_key_value(buf, "query3", param, sizeof(param)) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Found URL query parameter => query3=%s", param);
|
|
}
|
|
if (httpd_query_key_value(buf, "query2", param, sizeof(param)) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Found URL query parameter => query2=%s", param);
|
|
}
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
/* Set some custom headers */
|
|
httpd_resp_set_hdr(req, "Custom-Header-1", "Custom-Value-1");
|
|
httpd_resp_set_hdr(req, "Custom-Header-2", "Custom-Value-2");
|
|
|
|
/* Send response with custom headers and body set as the
|
|
* string passed in user context*/
|
|
const char* resp_str = (const char*) req->user_ctx;
|
|
httpd_resp_send(req, resp_str, strlen(resp_str));
|
|
|
|
/* After sending the HTTP response the old HTTP request
|
|
* headers are lost. Check if HTTP request headers can be read now. */
|
|
if (httpd_req_get_hdr_value_len(req, "Host") == 0) {
|
|
ESP_LOGI(TAG, "Request headers lost");
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t starttime_get_handler(httpd_req_t *req)
|
|
{
|
|
httpd_resp_send(req, starttime.c_str(), strlen(starttime.c_str()));
|
|
/* Respond with an empty chunk to signal HTTP response completion */
|
|
httpd_resp_send_chunk(req, NULL, 0);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t hello_main_handler(httpd_req_t *req)
|
|
{
|
|
char filepath[50];
|
|
struct stat file_stat;
|
|
printf("uri: %s\n", req->uri);
|
|
|
|
char *base_path = (char*) req->user_ctx;
|
|
std::string filetosend(base_path);
|
|
|
|
const char *filename = get_path_from_uri(filepath, base_path,
|
|
req->uri - 1, sizeof(filepath));
|
|
printf("1 uri: %s, filename: %s, filepath: %s\n", req->uri, filename, filepath);
|
|
|
|
if ((strcmp(req->uri, "/") == 0))
|
|
{
|
|
filetosend = filetosend + "/html/index.html";
|
|
}
|
|
else
|
|
{
|
|
filetosend = filetosend + "/html" + std::string(req->uri);
|
|
}
|
|
|
|
printf("File to upload: %s\n", filetosend.c_str());
|
|
|
|
if (!filename) {
|
|
ESP_LOGE(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 (stat(filetosend.c_str(), &file_stat) == -1) {
|
|
/* If file not present on SPIFFS check if URI
|
|
* corresponds to one of the hardcoded paths */
|
|
ESP_LOGE(TAG, "Failed to stat file : %s", filetosend.c_str());
|
|
/* Respond with 404 Not Found */
|
|
httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File does not exist");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
esp_err_t res = send_file(req, filetosend, &file_stat);
|
|
if (res != ESP_OK)
|
|
return res;
|
|
|
|
/* Respond with an empty chunk to signal HTTP response completion */
|
|
httpd_resp_send_chunk(req, NULL, 0);
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
|
|
esp_err_t img_tmp_handler(httpd_req_t *req)
|
|
{
|
|
char filepath[50];
|
|
struct stat file_stat;
|
|
printf("uri: %s\n", req->uri);
|
|
|
|
char *base_path = (char*) req->user_ctx;
|
|
std::string filetosend(base_path);
|
|
|
|
const char *filename = get_path_from_uri(filepath, base_path,
|
|
req->uri + sizeof("/img_tmp") - 1, sizeof(filepath));
|
|
printf("1 uri: %s, filename: %s, filepath: %s\n", req->uri, filename, filepath);
|
|
|
|
filetosend = filetosend + "/img_tmp/" + std::string(filename);
|
|
printf("File to upload: %s\n", filetosend.c_str());
|
|
|
|
if (!filename) {
|
|
ESP_LOGE(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 (stat(filetosend.c_str(), &file_stat) == -1) {
|
|
/* If file not present on SPIFFS check if URI
|
|
* corresponds to one of the hardcoded paths */
|
|
ESP_LOGE(TAG, "Failed to stat file : %s", filetosend.c_str());
|
|
/* Respond with 404 Not Found */
|
|
httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File does not exist");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
esp_err_t res = send_file(req, filetosend, &file_stat);
|
|
if (res != ESP_OK)
|
|
return res;
|
|
|
|
/* Respond with an empty chunk to signal HTTP response completion */
|
|
httpd_resp_send_chunk(req, NULL, 0);
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
|
|
void register_server_main_uri(httpd_handle_t server, const char *base_path)
|
|
{
|
|
httpd_uri_t starttime_tmp_handle = {
|
|
.uri = "/starttime", // Match all URIs of type /path/to/file
|
|
.method = HTTP_GET,
|
|
.handler = starttime_get_handler,
|
|
.user_ctx = NULL // Pass server data as context
|
|
};
|
|
httpd_register_uri_handler(server, &starttime_tmp_handle);
|
|
|
|
|
|
httpd_uri_t img_tmp_handle = {
|
|
.uri = "/img_tmp/*", // Match all URIs of type /path/to/file
|
|
.method = HTTP_GET,
|
|
.handler = img_tmp_handler,
|
|
.user_ctx = (void*) base_path // Pass server data as context
|
|
};
|
|
httpd_register_uri_handler(server, &img_tmp_handle);
|
|
|
|
|
|
httpd_uri_t main_rest_handle = {
|
|
.uri = "/*", // Match all URIs of type /path/to/file
|
|
.method = HTTP_GET,
|
|
.handler = hello_main_handler,
|
|
.user_ctx = (void*) base_path // Pass server data as context
|
|
};
|
|
httpd_register_uri_handler(server, &main_rest_handle);
|
|
}
|
|
|
|
|
|
|
|
httpd_handle_t start_webserver(void)
|
|
{
|
|
httpd_handle_t server = NULL;
|
|
httpd_config_t config = { };
|
|
|
|
config.task_priority = tskIDLE_PRIORITY+5;
|
|
config.stack_size = 16384;
|
|
config.core_id = tskNO_AFFINITY;
|
|
config.server_port = 80;
|
|
config.ctrl_port = 32768;
|
|
config.max_open_sockets = 7;
|
|
config.max_uri_handlers = 24;
|
|
config.max_resp_headers = 8;
|
|
config.backlog_conn = 5;
|
|
config.lru_purge_enable = false;
|
|
config.recv_wait_timeout = 30; // default: 5
|
|
config.send_wait_timeout = 30; // default: 5
|
|
config.global_user_ctx = NULL;
|
|
config.global_user_ctx_free_fn = NULL;
|
|
config.global_transport_ctx = NULL;
|
|
config.global_transport_ctx_free_fn = NULL;
|
|
config.open_fn = NULL;
|
|
config.close_fn = NULL;
|
|
// config.uri_match_fn = NULL;
|
|
config.uri_match_fn = httpd_uri_match_wildcard;
|
|
|
|
|
|
httpd_uri_t hll = {};
|
|
hll.uri = "/hello";
|
|
hll.method = HTTP_GET;
|
|
hll.handler = hello_get_handler;
|
|
hll.user_ctx = (void*) "Hello World!";
|
|
|
|
|
|
starttime = gettimestring("%Y%m%d-%H%M%S");
|
|
|
|
// 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, &hll);
|
|
return server;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Error starting server!");
|
|
return NULL;
|
|
}
|
|
|
|
void stop_webserver(httpd_handle_t server)
|
|
{
|
|
httpd_stop(server);
|
|
}
|
|
|
|
|
|
void disconnect_handler(void* arg, esp_event_base_t event_base,
|
|
int32_t event_id, void* event_data)
|
|
{
|
|
httpd_handle_t* server = (httpd_handle_t*) arg;
|
|
if (*server) {
|
|
ESP_LOGI(TAG, "Stopping webserver");
|
|
stop_webserver(*server);
|
|
*server = NULL;
|
|
}
|
|
}
|
|
|
|
void connect_handler(void* arg, esp_event_base_t event_base,
|
|
int32_t event_id, void* event_data)
|
|
{
|
|
httpd_handle_t* server = (httpd_handle_t*) arg;
|
|
if (*server == NULL) {
|
|
ESP_LOGI(TAG, "Starting webserver");
|
|
*server = start_webserver();
|
|
}
|
|
}
|
|
|
|
|