From b2cf7e001baf52fad8c61fb53ec1ef6afca9fc89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dominik=20Madar=C3=A1sz?= Date: Mon, 18 Jan 2021 17:40:47 +0100 Subject: [PATCH] deps: add flecs-dash --- code/apps/server/CMakeLists.txt | 28 +- code/apps/server/source/main.c | 14 + code/apps/server/source/world/world.c | 2 + code/vendors/flecs/flecs_components_http.c | 94 + code/vendors/flecs/flecs_components_http.h | 121 + code/vendors/flecs/flecs_dash.c | 271 + code/vendors/flecs/flecs_dash.h | 158 + code/vendors/flecs/flecs_json.c | 561 + code/vendors/flecs/flecs_json.h | 116 + code/vendors/flecs/flecs_monitor.c | 479 + code/vendors/flecs/flecs_monitor.h | 70 + code/vendors/flecs/flecs_os_api_posix.c | 152 + code/vendors/flecs/flecs_os_api_posix.h | 3 + code/vendors/flecs/flecs_player.c | 126 + code/vendors/flecs/flecs_player.h | 88 + code/vendors/flecs/flecs_rest.c | 414 + code/vendors/flecs/flecs_rest.h | 95 + code/vendors/flecs/flecs_systems_civetweb.c | 23477 ++++++++++++++++ code/vendors/flecs/flecs_systems_civetweb.h | 88 + flecs-dash/etc/apps/browser/browser.js | 97 + .../etc/apps/browser/component_properties.js | 13 + .../etc/apps/browser/component_search.js | 48 + .../etc/apps/browser/entity_component.js | 20 + flecs-dash/etc/apps/browser/entity_data.js | 64 + flecs-dash/etc/apps/browser/entity_editor.js | 128 + flecs-dash/etc/apps/browser/entity_kind.js | 36 + flecs-dash/etc/apps/browser/entity_search.js | 45 + flecs-dash/etc/apps/browser/entity_table.js | 85 + flecs-dash/etc/apps/browser/entity_tag.js | 16 + flecs-dash/etc/apps/browser/entity_tree.js | 207 + .../etc/apps/browser/entity_tree_item.js | 121 + flecs-dash/etc/apps/browser/property_value.js | 43 + flecs-dash/etc/apps/browser/style.css | 420 + .../etc/apps/overview/delta_time_graph.js | 122 + flecs-dash/etc/apps/overview/entity_graph.js | 116 + .../etc/apps/overview/operation_graph.js | 149 + flecs-dash/etc/apps/overview/overview.js | 190 + .../etc/apps/overview/performance_graph.js | 149 + flecs-dash/etc/apps/overview/table_graph.js | 140 + flecs-dash/etc/apps/systems/style.css | 187 + flecs-dash/etc/apps/systems/system.js | 48 + .../etc/apps/systems/system_component.js | 31 + .../etc/apps/systems/system_entity_graph.js | 125 + .../etc/apps/systems/system_time_graph.js | 170 + flecs-dash/etc/apps/systems/systems.js | 173 + flecs-dash/etc/css/style.css | 253 + flecs-dash/etc/favicon.png | Bin 0 -> 22408 bytes flecs-dash/etc/images/add.png | Bin 0 -> 778 bytes flecs-dash/etc/images/bar_chart.png | Bin 0 -> 781 bytes flecs-dash/etc/images/clock.png | Bin 0 -> 2653 bytes flecs-dash/etc/images/close.png | Bin 0 -> 1497 bytes flecs-dash/etc/images/delete.png | Bin 0 -> 1121 bytes flecs-dash/etc/images/flecs.png | Bin 0 -> 16661 bytes flecs-dash/etc/images/layers.png | Bin 0 -> 769 bytes flecs-dash/etc/images/nav.png | Bin 0 -> 937 bytes flecs-dash/etc/images/pause.png | Bin 0 -> 897 bytes flecs-dash/etc/images/play.png | Bin 0 -> 1379 bytes flecs-dash/etc/images/save.png | Bin 0 -> 351 bytes flecs-dash/etc/images/stop.png | Bin 0 -> 867 bytes flecs-dash/etc/images/sync.png | Bin 0 -> 2067 bytes flecs-dash/etc/images/table.png | Bin 0 -> 1201 bytes flecs-dash/etc/images/tree.png | Bin 0 -> 120 bytes flecs-dash/etc/images/usage.png | Bin 0 -> 1161 bytes flecs-dash/etc/index.html | 27 + flecs-dash/etc/js/app.js | 136 + flecs-dash/etc/js/appcontent.js | 18 + flecs-dash/etc/js/perf_summary.js | 182 + flecs-dash/etc/js/periodic_request.js | 36 + flecs-dash/etc/js/play_controls.js | 69 + flecs-dash/etc/js/sidebar-button.js | 46 + flecs-dash/etc/js/sidebar.js | 59 + flecs-dash/etc/js/vue.js | 6 + 72 files changed, 30126 insertions(+), 6 deletions(-) create mode 100644 code/vendors/flecs/flecs_components_http.c create mode 100644 code/vendors/flecs/flecs_components_http.h create mode 100644 code/vendors/flecs/flecs_dash.c create mode 100644 code/vendors/flecs/flecs_dash.h create mode 100644 code/vendors/flecs/flecs_json.c create mode 100644 code/vendors/flecs/flecs_json.h create mode 100644 code/vendors/flecs/flecs_monitor.c create mode 100644 code/vendors/flecs/flecs_monitor.h create mode 100644 code/vendors/flecs/flecs_os_api_posix.c create mode 100644 code/vendors/flecs/flecs_os_api_posix.h create mode 100644 code/vendors/flecs/flecs_player.c create mode 100644 code/vendors/flecs/flecs_player.h create mode 100644 code/vendors/flecs/flecs_rest.c create mode 100644 code/vendors/flecs/flecs_rest.h create mode 100644 code/vendors/flecs/flecs_systems_civetweb.c create mode 100644 code/vendors/flecs/flecs_systems_civetweb.h create mode 100644 flecs-dash/etc/apps/browser/browser.js create mode 100644 flecs-dash/etc/apps/browser/component_properties.js create mode 100644 flecs-dash/etc/apps/browser/component_search.js create mode 100644 flecs-dash/etc/apps/browser/entity_component.js create mode 100644 flecs-dash/etc/apps/browser/entity_data.js create mode 100644 flecs-dash/etc/apps/browser/entity_editor.js create mode 100644 flecs-dash/etc/apps/browser/entity_kind.js create mode 100644 flecs-dash/etc/apps/browser/entity_search.js create mode 100644 flecs-dash/etc/apps/browser/entity_table.js create mode 100644 flecs-dash/etc/apps/browser/entity_tag.js create mode 100644 flecs-dash/etc/apps/browser/entity_tree.js create mode 100644 flecs-dash/etc/apps/browser/entity_tree_item.js create mode 100644 flecs-dash/etc/apps/browser/property_value.js create mode 100644 flecs-dash/etc/apps/browser/style.css create mode 100644 flecs-dash/etc/apps/overview/delta_time_graph.js create mode 100644 flecs-dash/etc/apps/overview/entity_graph.js create mode 100644 flecs-dash/etc/apps/overview/operation_graph.js create mode 100644 flecs-dash/etc/apps/overview/overview.js create mode 100644 flecs-dash/etc/apps/overview/performance_graph.js create mode 100644 flecs-dash/etc/apps/overview/table_graph.js create mode 100644 flecs-dash/etc/apps/systems/style.css create mode 100644 flecs-dash/etc/apps/systems/system.js create mode 100644 flecs-dash/etc/apps/systems/system_component.js create mode 100644 flecs-dash/etc/apps/systems/system_entity_graph.js create mode 100644 flecs-dash/etc/apps/systems/system_time_graph.js create mode 100644 flecs-dash/etc/apps/systems/systems.js create mode 100644 flecs-dash/etc/css/style.css create mode 100644 flecs-dash/etc/favicon.png create mode 100644 flecs-dash/etc/images/add.png create mode 100644 flecs-dash/etc/images/bar_chart.png create mode 100644 flecs-dash/etc/images/clock.png create mode 100644 flecs-dash/etc/images/close.png create mode 100644 flecs-dash/etc/images/delete.png create mode 100644 flecs-dash/etc/images/flecs.png create mode 100644 flecs-dash/etc/images/layers.png create mode 100644 flecs-dash/etc/images/nav.png create mode 100644 flecs-dash/etc/images/pause.png create mode 100644 flecs-dash/etc/images/play.png create mode 100644 flecs-dash/etc/images/save.png create mode 100644 flecs-dash/etc/images/stop.png create mode 100644 flecs-dash/etc/images/sync.png create mode 100644 flecs-dash/etc/images/table.png create mode 100644 flecs-dash/etc/images/tree.png create mode 100644 flecs-dash/etc/images/usage.png create mode 100644 flecs-dash/etc/index.html create mode 100644 flecs-dash/etc/js/app.js create mode 100644 flecs-dash/etc/js/appcontent.js create mode 100644 flecs-dash/etc/js/perf_summary.js create mode 100644 flecs-dash/etc/js/periodic_request.js create mode 100644 flecs-dash/etc/js/play_controls.js create mode 100644 flecs-dash/etc/js/sidebar-button.js create mode 100644 flecs-dash/etc/js/sidebar.js create mode 100644 flecs-dash/etc/js/vue.js diff --git a/code/apps/server/CMakeLists.txt b/code/apps/server/CMakeLists.txt index 14c7fd2..029d926 100644 --- a/code/apps/server/CMakeLists.txt +++ b/code/apps/server/CMakeLists.txt @@ -19,6 +19,12 @@ add_executable(eco2d-server header/components/general.h header/components/controllers.h + ../../common/signal_handling.c + ../../common/signal_handling.h + + ../../common/assets.h + ../../common/assets.c + ../../vendors/cwpack/cwpack.c ../../vendors/cwpack/cwpack.h @@ -26,12 +32,22 @@ add_executable(eco2d-server ../../vendors/flecs/flecs.h ../../vendors/flecs/flecs_meta.c ../../vendors/flecs/flecs_meta.h - - ../../common/signal_handling.c - ../../common/signal_handling.h - - ../../common/assets.h - ../../common/assets.c + ../../vendors/flecs/flecs_json.h + ../../vendors/flecs/flecs_json.c + ../../vendors/flecs/flecs_rest.h + ../../vendors/flecs/flecs_rest.c + ../../vendors/flecs/flecs_monitor.h + ../../vendors/flecs/flecs_monitor.c + ../../vendors/flecs/flecs_player.h + ../../vendors/flecs/flecs_player.c + ../../vendors/flecs/flecs_dash.h + ../../vendors/flecs/flecs_dash.c + ../../vendors/flecs/flecs_components_http.h + ../../vendors/flecs/flecs_components_http.c + ../../vendors/flecs/flecs_systems_civetweb.h + ../../vendors/flecs/flecs_systems_civetweb.c + ../../vendors/flecs/flecs_os_api_posix.h + ../../vendors/flecs/flecs_os_api_posix.c ) include_directories(eco2d-server header) diff --git a/code/apps/server/source/main.c b/code/apps/server/source/main.c index 5d08ef0..5f785bd 100644 --- a/code/apps/server/source/main.c +++ b/code/apps/server/source/main.c @@ -7,6 +7,11 @@ #include "utils/options.h" #include "signal_handling.h" +#include "flecs/flecs.h" +#include "flecs/flecs_dash.h" +#include "flecs/flecs_systems_civetweb.h" +#include "flecs/flecs_os_api_posix.h" + #define DEFAULT_WORLD_SEED 302097 #define DEFAULT_BLOCK_SIZE 64 /* amount of units within a block (single axis) */ #define DEFAULT_CHUNK_SIZE 3 /* amount of blocks within a chunk (single axis) */ @@ -59,10 +64,19 @@ int main(int argc, char** argv) { } sighandler_register(); + posix_set_os_api(); zpl_printf("[INFO] Generating world of size: %d x %d\n", world_size, world_size); IF(world_init(seed, block_size, chunk_size, world_size)); + /* server dashboard */ + { + ECS_IMPORT(world_ecs(), FlecsDash); + ECS_IMPORT(world_ecs(), FlecsSystemsCivetweb); + + ecs_set(world_ecs(), 0, EcsDashServer, {.port = 27001}); + } + zpl_printf("[INFO] Initializing network...\n"); IF(network_init()); IF(network_server_start("0.0.0.0", 27000)); diff --git a/code/apps/server/source/world/world.c b/code/apps/server/source/world/world.c index 16caedc..e2315ed 100644 --- a/code/apps/server/source/world/world.c +++ b/code/apps/server/source/world/world.c @@ -70,6 +70,8 @@ int32_t world_init(int32_t seed, uint16_t block_size, uint16_t chunk_size, uint1 world.ecs = ecs_init(); ecs_set_entity_range(world.ecs, 0, UINT32_MAX); + ecs_set_threads(world.ecs, 4); + ecs_set_target_fps(world.ecs, 60); world.tracker = librg_world_create(); diff --git a/code/vendors/flecs/flecs_components_http.c b/code/vendors/flecs/flecs_components_http.c new file mode 100644 index 0000000..ff7a73b --- /dev/null +++ b/code/vendors/flecs/flecs_components_http.c @@ -0,0 +1,94 @@ +#ifndef FLECS_COMPONENTS_HTTP_IMPL +#include "flecs_components_http.h" +#endif + +static +void decode( + char *str) +{ + char ch, *ptr, *dst = str; + + for (ptr = str; (ch = *ptr); ptr++) { + if (ch == '%') { + if (ptr[1] == '2' && ptr[2] == '0') { + dst[0] = ' '; + dst ++; + ptr += 2; + } + } else { + dst[0] = ptr[0]; + dst ++; + } + } + + dst[0] = '\0'; +} + +size_t ecs_http_get_query_param( + const char *query, + const char *name, + char *buffer, + size_t len) +{ + if (!query) { + return 0; + } + + const char *cur, *start = query, *value = NULL; + char ch; + int arg_len = strlen(name); + + for (cur = query; (ch = *cur); cur ++) { + if (ch == '=') { + if (cur - start >= 256) { + /* Ignore, key is too long */ + } else { + int32_t key_len = cur - start; + cur ++; + value = cur; + while ((ch = *cur) && ch != '&') { + cur ++; + } + + if (!ch || ch == '&') { + /* Check if requested key matches */ + if (arg_len == key_len && !strncmp(name, start, key_len)) { + size_t size; + if (cur - value < (int32_t)len) { + size = cur - value; + } else { + size = len - 1; + } + + memcpy(buffer, value, size); + buffer[size] = '\0'; + + decode(buffer); + + return cur - value; + } + } + + start = cur + 1; + } + } + } + + return 0; +} + +void FlecsComponentsHttpImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsComponentsHttp); + + ECS_IMPORT(world, FlecsMeta); + + ecs_set_name_prefix(world, "EcsHttp"); + + ECS_META(world, EcsHttpServer); + ECS_META(world, EcsHttpEndpoint); + + ECS_SET_COMPONENT(EcsHttpServer); + ECS_SET_COMPONENT(EcsHttpEndpoint); +} diff --git a/code/vendors/flecs/flecs_components_http.h b/code/vendors/flecs/flecs_components_http.h new file mode 100644 index 0000000..5205e67 --- /dev/null +++ b/code/vendors/flecs/flecs_components_http.h @@ -0,0 +1,121 @@ +#define flecs_components_http_STATIC +#ifndef FLECS_COMPONENTS_HTTP_H +#define FLECS_COMPONENTS_HTTP_H + +/* + ) + (.) + .|. + | | + _.--| |--._ + .-'; ;`-'& ; `&. + \ & ; & &_/ + |"""---...---"""| + \ | | | | | | | / + `---.|.|.|.---' + + * This file is generated by bake.lang.c for your convenience. Headers of + * dependencies will automatically show up in this file. Include bake_config.h + * in your main project file. Do not edit! */ + +#ifndef FLECS_COMPONENTS_HTTP_BAKE_CONFIG_H +#define FLECS_COMPONENTS_HTTP_BAKE_CONFIG_H + +/* Headers of public dependencies */ +#include +#include + +/* Convenience macro for exporting symbols */ +#ifndef flecs_components_http_STATIC +#if flecs_components_http_EXPORTS && (defined(_MSC_VER) || defined(__MINGW32__)) + #define FLECS_COMPONENTS_HTTP_API __declspec(dllexport) +#elif flecs_components_http_EXPORTS + #define FLECS_COMPONENTS_HTTP_API __attribute__((__visibility__("default"))) +#elif defined _MSC_VER + #define FLECS_COMPONENTS_HTTP_API __declspec(dllimport) +#else + #define FLECS_COMPONENTS_HTTP_API +#endif +#else + #define FLECS_COMPONENTS_HTTP_API +#endif + +#endif + + +ECS_ENUM(EcsHttpMethod, { + EcsHttpGet, + EcsHttpPost, + EcsHttpPut, + EcsHttpDelete, + EcsHttpMethodUnknown +}); + +struct EcsHttpEndpoint; + +typedef struct EcsHttpRequest { + const char *url; + const char *relative_url; + const char *params; + void *ctx; + EcsHttpMethod method; + ecs_entity_t server; +} EcsHttpRequest; + +ECS_STRUCT(EcsHttpReply, { + char *header; + char *body; + int status; + bool is_file; +}); + +typedef bool (*EcsHttpServiceAction)( + ecs_world_t *world, + ecs_entity_t entity, + struct EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply); + +ECS_STRUCT(EcsHttpServer, { + uint16_t port; +}); + +ECS_STRUCT(EcsHttpEndpoint, { + char *url; + void *ctx; + bool synchronous; + +ECS_PRIVATE + EcsHttpServiceAction action; +}); + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct FlecsComponentsHttp { + ECS_DECLARE_COMPONENT(EcsHttpServer); + ECS_DECLARE_COMPONENT(EcsHttpEndpoint); +} FlecsComponentsHttp; + +FLECS_COMPONENTS_HTTP_API +void FlecsComponentsHttpImport( + ecs_world_t *world); + +/* Utility to get parameter from query string */ +FLECS_COMPONENTS_HTTP_API +size_t ecs_http_get_query_param( + const char *query, + const char *name, + char *buffer, + size_t len); + +#define FlecsComponentsHttpImportHandles(handles)\ + ECS_IMPORT_COMPONENT(handles, EcsHttpServer);\ + ECS_IMPORT_COMPONENT(handles, EcsHttpEndpoint); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/code/vendors/flecs/flecs_dash.c b/code/vendors/flecs/flecs_dash.c new file mode 100644 index 0000000..583371a --- /dev/null +++ b/code/vendors/flecs/flecs_dash.c @@ -0,0 +1,271 @@ +#ifndef FLECS_DASH_IMPL +#include "flecs_dash.h" +#endif + + +static +void EcsUpdateFps(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + EcsFps *world_fps = ecs_column(it, EcsFps, 1); + + const ecs_world_info_t *info = ecs_get_world_info(world); + world_fps->value = 1.0 / info->delta_time_raw; + world_fps->count += world_fps->value; + world_fps->target = info->target_fps; +} + +static +void EcsUpdateLoad(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + EcsLoad *world_load = ecs_column(it, EcsLoad, 1); + + const ecs_world_info_t *info = ecs_get_world_info(world); + + world_load->total_time_count += info->delta_time_raw; + world_load->frame_time_count = info->frame_time_total; + world_load->system_time_count = info->system_time_total; + world_load->merge_time_count = info->merge_time_total; +} + +static +void EcsUpdateTick(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + EcsTick *world_tick = ecs_column(it, EcsTick, 1); + + const ecs_world_info_t *info = ecs_get_world_info(world); + world_tick->count = info->frame_count_total; +} + +static +void EcsUpdateClock(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + EcsWorldClock *world_clock = ecs_column(it, EcsWorldClock, 1); + + const ecs_world_info_t *info = ecs_get_world_info(world); + world_clock->world_time = info->world_time_total; + world_clock->world_time_raw = 0; +} + +void FlecsDashMonitorImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsDashMonitor); + + ECS_IMPORT(world, FlecsMeta); + + ecs_set_name_prefix(world, "Ecs"); + + ECS_META(world, EcsFps); + ECS_META(world, EcsLoad); + ECS_META(world, EcsTick); + ECS_META(world, EcsWorldClock); + + /* System for keeping track of world stats */ + ecs_set(world, EcsWorld, EcsFps, {0}); + ECS_SYSTEM(world, EcsUpdateFps, EcsOnLoad, flecs.core.World:Fps); + + ecs_set(world, EcsWorld, EcsLoad, {0}); + ECS_SYSTEM(world, EcsUpdateLoad, EcsOnLoad, flecs.core.World:Load); + + ecs_set(world, EcsWorld, EcsTick, {0}); + ECS_SYSTEM(world, EcsUpdateTick, EcsOnLoad, flecs.core.World:Tick); + + ecs_set(world, EcsWorld, EcsWorldClock, {0}); + ECS_SYSTEM(world, EcsUpdateClock, EcsOnLoad, flecs.core.World:WorldClock); +} + +static +bool request_this( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + ecs_entity_t server = ecs_get_parent_w_entity(world, entity, 0); + if (server) { + ecs_strbuf_t buf = ECS_STRBUF_INIT; + char *path = ecs_get_fullpath(world, server); + ecs_strbuf_append(&buf, "{\"server_id\":\"%s\"}", path); + ecs_os_free(path); + reply->body = ecs_strbuf_get(&buf); + return true; + } else { + reply->body = ecs_os_strdup("{\"server_id\":\"unknown\"}"); + return false; + } +} + +static +bool request_files( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + const char *file = request->relative_url; + char path[1024]; + + if (!file || !strlen(file)) { + file = "index.html"; + } + + char *etc_path = ecs_os_module_to_etc("flecs.dash"); + + sprintf(path, "%s/%s", etc_path, file); + + FILE *f = fopen(path, "r"); + if (!f) { + return false; + } else { + fclose(f); + } + + reply->body = ecs_os_strdup(path); + reply->is_file = true; + + ecs_os_free(etc_path); + + return true; +} + +static +bool request_player( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + const char *cmd = request->relative_url; + + ecs_entity_t ecs_typeid(EcsPlayer) = ecs_lookup_fullpath( + world, "flecs.player.Player"); + + if (ecs_typeid(EcsPlayer)) { + EcsPlayer *player = ecs_get_mut(world, EcsWorld, EcsPlayer, NULL); + + if (!strcmp(cmd, "play")) { + player->state = EcsPlayerPlay; + } else if (!strcmp(cmd, "pause")) { + player->state = EcsPlayerPause; + } else if (!strcmp(cmd, "stop")) { + player->state = EcsPlayerStop; + } + + ecs_modified(world, EcsWorld, EcsPlayer); + } + + return true; +} + +static +void RunServer(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + EcsDashServer *server = ecs_column(it, EcsDashServer, 1); + + ecs_entity_t ecs_typeid(EcsHttpEndpoint) = ecs_column_entity(it, 2); + ecs_entity_t ecs_typeid(EcsRestServer) = ecs_column_entity(it, 3); + ecs_entity_t ecs_typeid(EcsMonitorServer) = ecs_column_entity(it, 4); + ecs_entity_t ecs_typeid(EcsDashApp) = ecs_column_entity(it, 5); + ecs_entity_t EcsDashInitialized = ecs_column_entity(it, 6); + + int32_t i; + for (i = 0; i < it->count; i ++) { + ecs_entity_t e = it->entities[i]; + EcsDashServer *s = &server[i]; + + /* Create REST & monitor server */ + ecs_set(world, e, EcsRestServer, {.port = s->port}); + ecs_set(world, e, EcsMonitorServer, {.port = s->port}); + + if (ecs_has_entity(world, e, EcsDashInitialized)) { + /* Don't add endpoints again if already initialized */ + continue; + } + + /* Add endpoint to server for serving up files */ + ecs_entity_t e_files = ecs_new_w_entity(world, ECS_CHILDOF | e); + ecs_set(world, e_files, EcsName, {"e_files"}); + ecs_set(world, e_files, EcsHttpEndpoint, { + .url = "", + .action = request_files}); + + /* Add endpoint to server that returns entity id of server */ + ecs_entity_t e_this = ecs_new_w_entity(world, ECS_CHILDOF | e); + ecs_set(world, e_this, EcsName, {"e_this"}); + ecs_set(world, e_this, EcsHttpEndpoint, { + .url = "this", + .action = request_this}); + + /* Add endpoint to server that returns entity id of server */ + ecs_entity_t e_player = ecs_new_w_entity(world, ECS_CHILDOF | e); + ecs_set(world, e_player, EcsName, {"e_player"}); + ecs_set(world, e_player, EcsHttpEndpoint, { + .url = "player", + .action = request_player, + .synchronous = true}); + + /* Add browser app */ + ecs_entity_t dash_overview = ecs_new_w_entity(world, ECS_CHILDOF | e); + ecs_set(world, dash_overview, EcsName, {"overview"}); + ecs_set(world, dash_overview, EcsDashApp, { + .path = "etc/apps/overview", + .icon = "images/usage.png" + }); + + ecs_entity_t dash_systems = ecs_new_w_entity(world, ECS_CHILDOF | e); + ecs_set(world, dash_systems, EcsName, {"systems"}); + ecs_set(world, dash_systems, EcsDashApp, { + .path = "etc/apps/systems", + .icon = "images/layers.png" + }); + + ecs_entity_t dash_browser = ecs_new_w_entity(world, ECS_CHILDOF | e); + ecs_set(world, dash_browser, EcsName, {"browser"}); + ecs_set(world, dash_browser, EcsDashApp, { + .path = "etc/apps/browser", + .icon = "images/tree.png" + }); + + /* Prevent initializing the server again */ + ecs_add_entity(world, e, EcsDashInitialized); + } +} + +void FlecsDashImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsDash); + + ECS_IMPORT(world, FlecsMonitor); + ECS_IMPORT(world, FlecsDashMonitor); + + ECS_IMPORT(world, FlecsMeta); + ECS_IMPORT(world, FlecsPlayer); + ECS_IMPORT(world, FlecsComponentsHttp); + ECS_IMPORT(world, FlecsRest); + + ecs_set_name_prefix(world, "EcsDash"); + + ECS_META(world, EcsDashServer); + ECS_META(world, EcsDashApp); + + ECS_TAG(world, EcsDashInitialized); + + ECS_SYSTEM(world, RunServer, EcsOnSet, Server, + :flecs.components.http.Endpoint, + :flecs.rest.Server, + :flecs.monitor.Server, + :App, + :Initialized); + + ECS_EXPORT_COMPONENT(EcsDashServer); + ECS_EXPORT_COMPONENT(EcsDashApp); +} diff --git a/code/vendors/flecs/flecs_dash.h b/code/vendors/flecs/flecs_dash.h new file mode 100644 index 0000000..a770f9d --- /dev/null +++ b/code/vendors/flecs/flecs_dash.h @@ -0,0 +1,158 @@ +#define flecs_dash_STATIC +#ifndef FLECS_DASH_H +#define FLECS_DASH_H + +/* This generated file contains includes for project dependencies */ +/* + ) + (.) + .|. + | | + _.--| |--._ + .-'; ;`-'& ; `&. + \ & ; & &_/ + |"""---...---"""| + \ | | | | | | | / + `---.|.|.|.---' + + * This file is generated by bake.lang.c for your convenience. Headers of + * dependencies will automatically show up in this file. Include bake_config.h + * in your main project file. Do not edit! */ + +#ifndef FLECS_DASH_BAKE_CONFIG_H +#define FLECS_DASH_BAKE_CONFIG_H + +/* Headers of public dependencies */ +#include +#include +#include +#include +#include +#include + +/* Convenience macro for exporting symbols */ +#ifndef flecs_dash_STATIC +#if flecs_dash_EXPORTS && (defined(_MSC_VER) || defined(__MINGW32__)) + #define FLECS_DASH_API __declspec(dllexport) +#elif flecs_dash_EXPORTS + #define FLECS_DASH_API __attribute__((__visibility__("default"))) +#elif defined _MSC_VER + #define FLECS_DASH_API __declspec(dllimport) +#else + #define FLECS_DASH_API +#endif +#else + #define FLECS_DASH_API +#endif + +#endif + +#ifndef FLECS_DASH_MONITOR_H +#define FLECS_DASH_MONITOR_H + +/* This generated file contains includes for project dependencies */ + +ECS_STRUCT(EcsFps, { + double value; + double count; + double target; +}); + +ECS_STRUCT(EcsTick, { + double count; +}); + +ECS_STRUCT(EcsLoad, { + double total_time_count; + double frame_time_count; + double system_time_count; + double merge_time_count; +}); + +ECS_STRUCT(EcsWorldClock, { + double world_time; + double world_time_raw; +}); + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct FlecsDashMonitor { + ECS_DECLARE_COMPONENT(EcsFps); +} FlecsDashMonitor; + +FLECS_DASH_API +void FlecsDashMonitorImport( + ecs_world_t *world); + +#define FlecsDashMonitorImportHandles(handles)\ + ECS_IMPORT_COMPONENT(handles, EcsFps); + +#ifdef __cplusplus +} +#endif + +#endif + + +//////////////////////////////////////////////////////////////////////////////// +//// Module implementation +//////////////////////////////////////////////////////////////////////////////// + +ECS_STRUCT(EcsDashServer, { + int16_t port; +}); + +ECS_STRUCT(EcsDashApp, { + char *path; + char *icon; +}); + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct FlecsDash { + ECS_DECLARE_COMPONENT(EcsDashServer); + ECS_DECLARE_COMPONENT(EcsDashApp); +} FlecsDash; + +FLECS_DASH_API +void FlecsDashImport( + ecs_world_t *world); + +#define FlecsDashImportHandles(handles)\ + ECS_IMPORT_COMPONENT(handles, EcsDashServer);\ + ECS_IMPORT_COMPONENT(handles, EcsDashApp) + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +#ifndef FLECS_NO_CPP + +namespace flecs { + +class dash : public FlecsDash { +public: + using Server = EcsDashServer; + using App = EcsDashApp; + + dash(flecs::world& world) { + FlecsDashImport(world.c_ptr()); + + flecs::module(world, "flecs::dash"); + + flecs::component(world, "flecs::dash::Server"); + flecs::component(world, "flecs::dash::App"); + } +}; + +} + +#endif // FLECS_NO_CPP +#endif // __cplusplus + +#endif diff --git a/code/vendors/flecs/flecs_json.c b/code/vendors/flecs/flecs_json.c new file mode 100644 index 0000000..dcfb9b5 --- /dev/null +++ b/code/vendors/flecs/flecs_json.c @@ -0,0 +1,561 @@ +#ifndef FLECS_JSON_IMPL +#include "flecs_json.h" +#endif + +/* Simple serializer to turn values into strings. Use this code as a template + * for when implementing a new serializer. */ + +static +void json_ser_type( + ecs_world_t *world, + ecs_vector_t *ser, + const void *base, + ecs_strbuf_t *str); + +static +void json_ser_type_op( + ecs_world_t *world, + ecs_type_op_t *op, + const void *base, + ecs_strbuf_t *str); + +/* Serialize a primitive value */ +static +void json_ser_primitive( + ecs_world_t *world, + ecs_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + const char *bool_str[] = { "false", "true" }; + + switch(op->is.primitive) { + case EcsBool: + ecs_strbuf_appendstr(str, bool_str[(int)*(bool*)base]); + break; + case EcsChar: + ecs_strbuf_appendstrn(str, "\"", 1); + ecs_strbuf_appendstrn(str, (char*)base, 1); + ecs_strbuf_appendstrn(str, "\"", 1); + break; + case EcsByte: + ecs_strbuf_append(str, "%u", *(uint8_t*)base); + break; + case EcsU8: + ecs_strbuf_append(str, "%u", *(uint8_t*)base); + break; + case EcsU16: + ecs_strbuf_append(str, "%u", *(uint16_t*)base); + break; + case EcsU32: + ecs_strbuf_append(str, "%u", *(uint32_t*)base); + break; + case EcsU64: + ecs_strbuf_append(str, "%u", *(uint64_t*)base); + break; + case EcsI8: + ecs_strbuf_append(str, "%d", *(int8_t*)base); + break; + case EcsI16: + ecs_strbuf_append(str, "%d", *(int16_t*)base); + break; + case EcsI32: + ecs_strbuf_append(str, "%d", *(int32_t*)base); + break; + case EcsI64: + ecs_strbuf_append(str, "%d", *(int64_t*)base); + break; + case EcsF32: + ecs_strbuf_append(str, "%f", *(float*)base); + break; + case EcsF64: + ecs_strbuf_append(str, "%f", *(double*)base); + break; + case EcsIPtr: + ecs_strbuf_append(str, "%i", *(intptr_t*)base); + break; + case EcsUPtr: + ecs_strbuf_append(str, "%u", *(uintptr_t*)base); + break; + case EcsString: { + char *value = *(char**)base; + if (value) { + ecs_strbuf_appendstrn(str, "\"", 1); + ecs_strbuf_appendstr(str, value); + ecs_strbuf_appendstrn(str, "\"", 1); + } else { + ecs_strbuf_appendstr(str, "null"); + } + break; + } + case EcsEntity: + ecs_strbuf_appendstrn(str, "\"", 1); + ecs_strbuf_appendstr(str, ecs_get_name(world, *(ecs_entity_t*)base)); + ecs_strbuf_appendstrn(str, "\"", 1); + break; + } +} + +/* Serialize enumeration */ +static +void json_ser_enum( + ecs_world_t *world, + ecs_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + const EcsEnum *enum_type = ecs_get_ref_w_entity(world, &op->is.constant, 0, 0); + ecs_assert(enum_type != NULL, ECS_INVALID_PARAMETER, NULL); + + int32_t value = *(int32_t*)base; + + /* Enumeration constants are stored in a map that is keyed on the + * enumeration value. */ + char **constant = ecs_map_get(enum_type->constants, char*, value); + ecs_assert(constant != NULL, ECS_INVALID_PARAMETER, NULL); + + ecs_strbuf_appendstrn(str, "\"", 1); + ecs_strbuf_appendstr(str, *constant); + ecs_strbuf_appendstrn(str, "\"", 1); +} + +/* Serialize bitmask */ +static +void json_ser_bitmask( + ecs_world_t *world, + ecs_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + const EcsBitmask *bitmask_type = ecs_get_ref_w_entity(world, &op->is.constant, 0, 0); + ecs_assert(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL); + + int32_t value = *(int32_t*)base; + ecs_map_key_t key; + char **constant; + + ecs_strbuf_list_push(str, "[", ","); + + /* Multiple flags can be set at a given time. Iterate through all the flags + * and append the ones that are set. */ + ecs_map_iter_t it = ecs_map_iter(bitmask_type->constants); + while ((constant = ecs_map_next(&it, char*, &key))) { + if ((value & key) == key) { + ecs_strbuf_list_append(str, "\"%s\"", *constant); + } + } + + ecs_strbuf_list_pop(str, "]"); +} + +/* Serialize elements of a contiguous array */ +static +void json_ser_elements( + ecs_world_t *world, + ecs_vector_t *elem_ops, + const void *base, + int32_t elem_count, + int32_t elem_size, + ecs_strbuf_t *str) +{ + ecs_strbuf_list_push(str, "[", ","); + + const void *ptr = base; + + int i; + for (i = 0; i < elem_count; i ++) { + ecs_strbuf_list_next(str); + json_ser_type(world, elem_ops, ptr, str); + ptr = ECS_OFFSET(ptr, elem_size); + } + + ecs_strbuf_list_pop(str, "]"); +} + +/* Serialize array */ +static +void json_ser_array( + ecs_world_t *world, + ecs_type_op_t *op, + void *base, + ecs_strbuf_t *str) +{ + const EcsMetaTypeSerializer *ser = ecs_get_ref_w_entity(world, &op->is.collection, 0, 0); + ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL); + + json_ser_elements(world, ser->ops, base, op->count, op->size, str); +} + +/* Serialize vector */ +static +void json_ser_vector( + ecs_world_t *world, + ecs_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + ecs_vector_t *value = *(ecs_vector_t**)base; + + int32_t count = ecs_vector_count(value); + void *array = ecs_vector_first_t(value, op->size, op->alignment); + + const EcsMetaTypeSerializer *ser = ecs_get_ref_w_entity(world, &op->is.collection, 0, 0); + ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_vector_t *elem_ops = ser->ops; + + ecs_type_op_t *elem_op_hdr = (ecs_type_op_t*)ecs_vector_first(elem_ops, ecs_type_op_t); + ecs_assert(elem_op_hdr != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(elem_op_hdr->kind == EcsOpHeader, ECS_INTERNAL_ERROR, NULL); + size_t elem_size = elem_op_hdr->size; + + /* Serialize contiguous buffer of vector */ + json_ser_elements(world, elem_ops, array, count, elem_size, str); +} + +/* Serialize map */ +static +void json_ser_map( + ecs_world_t *world, + ecs_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + ecs_map_t *value = *(ecs_map_t**)base; + + const EcsMetaTypeSerializer *key_ser = ecs_get_ref_w_entity(world, &op->is.map.key, 0, 0); + ecs_assert(key_ser != NULL, ECS_INTERNAL_ERROR, NULL); + + const EcsMetaTypeSerializer *elem_ser = ecs_get_ref_w_entity(world, &op->is.map.element, 0, 0); + ecs_assert(elem_ser != NULL, ECS_INTERNAL_ERROR, NULL); + + /* 2 instructions, one for the header */ + ecs_assert(ecs_vector_count(key_ser->ops) == 2, ECS_INTERNAL_ERROR, NULL); + + ecs_type_op_t *key_op = ecs_vector_first(key_ser->ops, ecs_type_op_t); + ecs_assert(key_op->kind == EcsOpHeader, ECS_INTERNAL_ERROR, NULL); + key_op = &key_op[1]; + + ecs_map_iter_t it = ecs_map_iter(value); + ecs_map_key_t key; + void *ptr; + + ecs_strbuf_list_push(str, "{", ","); + + while ((ptr = _ecs_map_next(&it, 0, &key))) { + ecs_strbuf_list_next(str); + ecs_strbuf_appendstrn(str, "\"", 1); + json_ser_type_op(world, key_op, (void*)&key, str); + ecs_strbuf_appendstrn(str, "\"", 1); + ecs_strbuf_appendstr(str, ":"); + json_ser_type(world, elem_ser->ops, ptr, str); + + key = 0; + } + + ecs_strbuf_list_pop(str, "}"); +} + +/* Forward serialization to the different type kinds */ +static +void json_ser_type_op( + ecs_world_t *world, + ecs_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + switch(op->kind) { + case EcsOpHeader: + case EcsOpPush: + case EcsOpPop: + /* Should not be parsed as single op */ + ecs_abort(ECS_INVALID_PARAMETER, NULL); + break; + case EcsOpPrimitive: + json_ser_primitive(world, op, ECS_OFFSET(base, op->offset), str); + break; + case EcsOpEnum: + json_ser_enum(world, op, ECS_OFFSET(base, op->offset), str); + break; + case EcsOpBitmask: + json_ser_bitmask(world, op, ECS_OFFSET(base, op->offset), str); + break; + case EcsOpArray: + json_ser_array(world, op, ECS_OFFSET(base, op->offset), str); + break; + case EcsOpVector: + json_ser_vector(world, op, ECS_OFFSET(base, op->offset), str); + break; + case EcsOpMap: + json_ser_map(world, op, ECS_OFFSET(base, op->offset), str); + break; + } +} + +/* Iterate over the type ops of a type */ +static +void json_ser_type( + ecs_world_t *world, + ecs_vector_t *ser, + const void *base, + ecs_strbuf_t *str) +{ + ecs_type_op_t *ops = (ecs_type_op_t*)ecs_vector_first(ser, ecs_type_op_t); + int32_t count = ecs_vector_count(ser); + + for (int i = 0; i < count; i ++) { + ecs_type_op_t *op = &ops[i]; + + if (op->name) { + if (op->kind != EcsOpHeader) { + ecs_strbuf_list_next(str); + } + + ecs_strbuf_append(str, "\"%s\":", op->name); + } + + switch(op->kind) { + case EcsOpHeader: + break; + case EcsOpPush: + ecs_strbuf_list_push(str, "{", ","); + break; + case EcsOpPop: + ecs_strbuf_list_pop(str, "}"); + break; + default: + json_ser_type_op(world, op, base, str); + break; + } + } +} + +char* ecs_ptr_to_json( + ecs_world_t *world, + ecs_entity_t type, + void* ptr) +{ + ecs_entity_t ecs_typeid(EcsMetaTypeSerializer) = ecs_lookup(world, "EcsMetaTypeSerializer"); + const EcsMetaTypeSerializer *ser = ecs_get(world, type, EcsMetaTypeSerializer); + ecs_assert(ser != NULL, ECS_INVALID_PARAMETER, NULL); + + ecs_strbuf_t str = ECS_STRBUF_INIT; + json_ser_type(world, ser->ops, ptr, &str); + return ecs_strbuf_get(&str); +} + +void json_ser_column( + ecs_world_t *world, + const EcsMetaTypeSerializer *ser, + void *ptr, + int32_t count, + ecs_strbuf_t *str) +{ + ecs_vector_t *ops = ser->ops; + ecs_type_op_t *hdr = ecs_vector_first(ops, ecs_type_op_t); + ecs_assert(hdr->kind == EcsOpHeader, ECS_INTERNAL_ERROR, NULL); + int32_t size = hdr->size; + + ecs_strbuf_list_push(str, "[", ","); + + int i; + for (i = 0; i < count; i ++) { + ecs_strbuf_list_next(str); + json_ser_type(world, ops, ptr, str); + ptr = ECS_OFFSET(ptr, size); + } + + ecs_strbuf_list_pop(str, "]"); +} + +static +void serialize_type( + ecs_world_t *world, + ecs_type_t type, + ecs_strbuf_t *str) +{ + ecs_strbuf_list_push(str, "[", ","); + + int i, count = ecs_vector_count(type); + ecs_entity_t *comps = ecs_vector_first(type, ecs_entity_t); + for (i = 0; i < count; i ++) { + ecs_entity_t comp = comps[i]; + bool has_role = (comp & ECS_COMPONENT_MASK) != comp; + ecs_entity_t comp_e = comp & ECS_COMPONENT_MASK; + + if (has_role) { + ecs_strbuf_list_next(str); + ecs_strbuf_list_push(str, "[", ","); + ecs_strbuf_list_append(str, "\"%s\"", ecs_role_str(comp)); + } + + if (ECS_HAS_ROLE(comp, TRAIT)) { + ecs_entity_t hi = ecs_entity_t_hi(comp_e); + char *hi_path = ecs_get_fullpath(world, hi); + ecs_strbuf_list_append(str, "\"%s\"", hi_path); + ecs_os_free(hi_path); + comp_e = ecs_entity_t_lo(comp_e); + } + + char *comp_path = ecs_get_fullpath(world, comp_e); + if (comp_path) { + ecs_strbuf_list_append(str, "\"%s\"", comp_path); + } else { + ecs_strbuf_list_append(str, "%d", (int32_t)comp); + } + + if (has_role) { + ecs_strbuf_list_pop(str, "]"); + } + + ecs_os_free(comp_path); + } + + ecs_strbuf_list_pop(str, "]"); +} + +char* ecs_type_to_json( + ecs_world_t *world, + ecs_type_t type) +{ + ecs_strbuf_t str = ECS_STRBUF_INIT; + serialize_type(world, type, &str); + return ecs_strbuf_get(&str); +} + +char* ecs_iter_to_json( + ecs_world_t *world, + ecs_iter_t *it, + ecs_iter_next_action_t iter_next, + ecs_type_t select) +{ + ecs_strbuf_t str = ECS_STRBUF_INIT; + ecs_entity_t ecs_typeid(EcsMetaTypeSerializer) = + ecs_lookup_fullpath(world, "flecs.meta.MetaTypeSerializer"); + ecs_assert(ecs_typeid(EcsMetaTypeSerializer) != 0, ECS_INTERNAL_ERROR, NULL); + + ecs_strbuf_list_push(&str, "[", ","); + + while (iter_next(it)) { + ecs_type_t table_type = ecs_iter_type(it); + ecs_entity_t *comps = ecs_vector_first(table_type, ecs_entity_t); + int32_t i, count = ecs_vector_count(table_type); + + if (!it->count) { + continue; + } + + ecs_strbuf_list_next(&str); + ecs_strbuf_list_push(&str, "{", ","); + + /* Serialize type */ + ecs_strbuf_list_appendstr(&str, "\"type\":"); + serialize_type(world, table_type, &str); + + /* Add entity identifiers */ + ecs_strbuf_list_appendstr(&str, "\"entities\":"); + ecs_strbuf_list_push(&str, "[", ","); + for (i = 0; i < it->count; i ++) { + ecs_strbuf_list_append(&str, "%d", (int32_t)it->entities[i]); + } + ecs_strbuf_list_pop(&str, "]"); + + /* Serialize data */ + ecs_strbuf_list_appendstr(&str, "\"data\":"); + ecs_strbuf_list_push(&str, "{", ","); + + for (i = 0; i < count; i ++) { + if (select) { + if (!ecs_type_has_entity(world, select, comps[i])) { + continue; + } + } + const EcsMetaTypeSerializer *ser = ecs_get( + world, comps[i], EcsMetaTypeSerializer); + + /* Don't serialize if there's no metadata for component */ + if (!ser) { + continue; + } + + char *comp_path = ecs_get_fullpath(world, comps[i]); + ecs_strbuf_list_append(&str, "\"%s\":", comp_path); + ecs_os_free(comp_path); + + json_ser_column( + world, ser, ecs_table_column(it, i), it->count, &str); + } + + ecs_strbuf_list_pop(&str, "}"); + ecs_strbuf_list_pop(&str, "}"); + } + + ecs_strbuf_list_pop(&str, "]"); + + return ecs_strbuf_get(&str); +} + +char* ecs_entity_to_json( + ecs_world_t *world, + ecs_entity_t entity, + ecs_type_t select) +{ + ecs_strbuf_t str = ECS_STRBUF_INIT; + ecs_entity_t ecs_typeid(EcsMetaTypeSerializer) = + ecs_lookup_fullpath(world, "flecs.meta.MetaTypeSerializer"); + ecs_assert(ecs_typeid(EcsMetaTypeSerializer) != 0, ECS_INTERNAL_ERROR, NULL); + + ecs_strbuf_list_push(&str, "{", ","); + + /* Serialize type */ + ecs_type_t type = ecs_get_type(world, entity); + ecs_strbuf_list_appendstr(&str, "\"type\":"); + serialize_type(world, type, &str); + + /* Serialize entity id */ + ecs_strbuf_list_append(&str, "\"entity\":%d", (int32_t)entity); + + /* Serialize entity path */ + char *path = ecs_get_fullpath(world, entity); + ecs_strbuf_list_append(&str, "\"path\":\"%s\"", path); + ecs_os_free(path); + + /* Serialize data */ + if (type) { + ecs_strbuf_list_appendstr(&str, "\"data\":"); + ecs_strbuf_list_push(&str, "{", ","); + + int i, count = ecs_vector_count(type); + ecs_entity_t *comps = ecs_vector_first(type, ecs_entity_t); + for (i = 0; i < count; i ++) { + if (select) { + if (!ecs_type_has_entity(world, select, comps[i])) { + continue; + } + } + + const EcsMetaTypeSerializer *ser = ecs_get( + world, comps[i], EcsMetaTypeSerializer); + + /* Don't serialize if there's no metadata for component */ + if (!ser) { + continue; + } + + char *comp_path = ecs_get_fullpath(world, comps[i]); + ecs_strbuf_list_append(&str, "\"%s\":", comp_path); + ecs_os_free(comp_path); + + const void *comp_ptr = ecs_get_w_entity(world, entity, comps[i]); + ecs_assert(comp_ptr != NULL, ECS_INTERNAL_ERROR, NULL); + + json_ser_type(world, ser->ops, comp_ptr, &str); + } + + ecs_strbuf_list_pop(&str, "}"); + } + + ecs_strbuf_list_pop(&str, "}"); + + return ecs_strbuf_get(&str); +} \ No newline at end of file diff --git a/code/vendors/flecs/flecs_json.h b/code/vendors/flecs/flecs_json.h new file mode 100644 index 0000000..c196355 --- /dev/null +++ b/code/vendors/flecs/flecs_json.h @@ -0,0 +1,116 @@ +#define flecs_json_STATIC +#ifndef FLECS_JSON_H +#define FLECS_JSON_H + +/* This generated file contains includes for project dependencies */ +/* + ) + (.) + .|. + | | + _.--| |--._ + .-'; ;`-'& ; `&. + \ & ; & &_/ + |"""---...---"""| + \ | | | | | | | / + `---.|.|.|.---' + + * This file is generated by bake.lang.c for your convenience. Headers of + * dependencies will automatically show up in this file. Include bake_config.h + * in your main project file. Do not edit! */ + +#ifndef FLECS_JSON_BAKE_CONFIG_H +#define FLECS_JSON_BAKE_CONFIG_H + +/* Headers of public dependencies */ +#include +#include + +/* Convenience macro for exporting symbols */ +#ifndef flecs_json_STATIC +#if flecs_json_EXPORTS && (defined(_MSC_VER) || defined(__MINGW32__)) + #define FLECS_JSON_API __declspec(dllexport) +#elif flecs_json_EXPORTS + #define FLECS_JSON_API __attribute__((__visibility__("default"))) +#elif defined _MSC_VER + #define FLECS_JSON_API __declspec(dllimport) +#else + #define FLECS_JSON_API +#endif +#else + #define FLECS_JSON_API +#endif + +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +FLECS_JSON_API +char* ecs_ptr_to_json( + ecs_world_t *world, + ecs_entity_t type, + void *ptr); + +FLECS_JSON_API +char* ecs_entity_to_json( + ecs_world_t *world, + ecs_entity_t e, + ecs_type_t select); + +FLECS_JSON_API +char* ecs_iter_to_json( + ecs_world_t *world, + ecs_iter_t *it, + ecs_iter_next_action_t iter_next, + ecs_type_t select); + +FLECS_JSON_API +char* ecs_type_to_json( + ecs_world_t *world, + ecs_type_t type); + +#ifdef __cplusplus +} +#endif + + +#ifdef __cplusplus + +namespace flecs { + +template +std::string to_json(flecs::world& world, flecs::entity_t type, T& data) { + char *str = ecs_ptr_to_json(world.c_ptr(), type, &data); + std::string result = std::string(str); + free(str); + return result; +} + +template +std::string to_json(flecs::world& world, flecs::entity type, T& data) { + return to_json(world, type.id(), data); +} + +template +std::string to_json(flecs::world& world, T& data) { + entity_t type = _::component_info::s_entity; + return flecs::to_json(world, type, data); +} + +template <> +inline std::string to_json(flecs::world& world, flecs::entity& entity) { + char *str = ecs_entity_to_json(world.c_ptr(), entity.id(), nullptr); + std::string result = std::string(str); + free(str); + return result; +} + +} + +#endif + +#endif + diff --git a/code/vendors/flecs/flecs_monitor.c b/code/vendors/flecs/flecs_monitor.c new file mode 100644 index 0000000..e2b5659 --- /dev/null +++ b/code/vendors/flecs/flecs_monitor.c @@ -0,0 +1,479 @@ +#ifndef FLECS_MONITOR_IMPL +#include "flecs_monitor.h" +#endif + +typedef struct WorldStats { + ecs_world_stats_t stats; +} WorldStats; + +typedef struct DeltaTime { + ecs_gauge_t frame; + ecs_gauge_t minute; + int32_t t_frame; + int32_t t_minute; +} DeltaTime; + +typedef struct PipelineStats { + ecs_pipeline_stats_t stats; +} PipelineStats; + +static ECS_COMPONENT_DECLARE(WorldStats); +static ECS_COMPONENT_DECLARE(DeltaTime); +static ECS_COMPONENT_DECLARE(PipelineStats); + +static void add_float_array( + ecs_strbuf_t *r, + int32_t t_start, + const float *values, + float scale) +{ + ecs_strbuf_list_push(r, "[", ","); + + int32_t i; + for (i = 0; i < ECS_STAT_WINDOW; i ++) { + int32_t t = (t_start + i + 1) % ECS_STAT_WINDOW; + ecs_strbuf_list_append(r, "%f", values[t] / scale); + } + + ecs_strbuf_list_pop(r, "]"); +} + +static void add_gauge( + ecs_strbuf_t *r, + const char *name, + int32_t t, + const ecs_gauge_t *m, + bool min_max, + float scale) +{ + ecs_strbuf_list_append(r, "\"%s\":", name); + ecs_strbuf_list_push(r, "{", ","); + ecs_strbuf_list_append(r, "\"avg\":"); + add_float_array(r, t, m->avg, scale); + + if (min_max) { + ecs_strbuf_list_append(r, "\"min\":"); + add_float_array(r, t, m->min, scale); + ecs_strbuf_list_append(r, "\"max\":"); + add_float_array(r, t, m->max, scale); + } + + ecs_strbuf_list_pop(r, "}"); +} + +static void add_counter( + ecs_strbuf_t *r, + const char *name, + int32_t t, + const ecs_counter_t *m, + bool min_max, + float scale) +{ + add_gauge(r, name, t, &m->rate, min_max, scale); +} + +#define add_current(r, name, t, m, scale)\ + _add_current(r, name, t, (ecs_gauge_t*)m, scale) + +static void _add_current( + ecs_strbuf_t *r, + const char *name, + int32_t t, + const ecs_gauge_t *m, + float scale) +{ + ecs_strbuf_list_append(r, "\"%s\":%f", name, m->avg[t] / scale); +} + +static void add_world_stats( + ecs_world_t *world, + const ecs_world_info_t *info, + ecs_strbuf_t *r) +{ + const WorldStats *s = ecs_get(world, ecs_typeid(WorldStats), WorldStats); + if (!s) { + return; + } + + const DeltaTime *s_dt = ecs_get(world, ecs_typeid(DeltaTime), DeltaTime); + if (!s_dt) { + return; + } + + const ecs_world_stats_t *stats = &s->stats; + int32_t t = stats->t; + + float df = stats->frame_count_total.rate.avg[t]; + if (df == 0.0) { + return; + } + + ecs_strbuf_list_appendstr(r, "\"world\":"); + ecs_strbuf_list_push(r, "{", ","); + + ecs_strbuf_list_appendstr(r, "\"current\":"); + ecs_strbuf_list_push(r, "{", ","); + add_current(r, "entity_count", t, &stats->entity_count, 1.0); + add_current(r, "component_count", t, &stats->component_count, 1.0); + add_current(r, "query_count", t, &stats->query_count, 1.0); + add_current(r, "system_count", t, &stats->system_count, 1.0); + add_current(r, "table_count", t, &stats->table_count, 1.0); + add_current(r, "empty_table_count", t, &stats->empty_table_count, 1.0); + add_current(r, "singleton_table_count", t, &stats->singleton_table_count, 1.0); + add_current(r, "matched_table_count", t, &stats->matched_table_count, 1.0); + add_current(r, "matched_entity_count", t, &stats->matched_entity_count, 1.0); + add_current(r, "systems_ran", t, &stats->systems_ran_frame, df); + add_current(r, "new_count", t, &stats->new_count, 1.0); + add_current(r, "bulk_new_count", t, &stats->bulk_new_count, 1.0); + add_current(r, "delete_count", t, &stats->delete_count, 1.0); + add_current(r, "clear_count", t, &stats->clear_count, 1.0); + add_current(r, "add_count", t, &stats->add_count, 1.0); + add_current(r, "remove_count", t, &stats->remove_count, 1.0); + add_current(r, "set_count", t, &stats->set_count, 1.0); + add_current(r, "discard_count", t, &stats->discard_count, 1.0); + ecs_strbuf_list_pop(r, "}"); + + ecs_strbuf_list_appendstr(r, "\"history_1m\":"); + ecs_strbuf_list_push(r, "{", ","); + add_gauge(r, "fps", t, &stats->fps, false, 1.0); + add_gauge(r, "delta_time", t, &s_dt->minute, true, 1.0); + add_counter(r, "frame_time_total", t, &stats->frame_time_total, false, df); + add_counter(r, "system_time_total", t, &stats->system_time_total, false, df); + add_counter(r, "merge_time_total", t, &stats->merge_time_total, false, df); + add_gauge(r, "entity_count", t, &stats->entity_count, false, 1.0); + add_gauge(r, "matched_entity_count", t, &stats->matched_entity_count, false, 1.0); + add_gauge(r, "table_count", t, &stats->table_count, false, 1.0); + add_gauge(r, "empty_table_count", t, &stats->empty_table_count, false, 1.0); + add_gauge(r, "singleton_table_count", t, &stats->singleton_table_count, false, 1.0); + add_gauge(r, "matched_table_count", t, &stats->matched_table_count, false, 1.0); + add_counter(r, "new_count", t, &stats->new_count, false, 1.0); + add_counter(r, "bulk_new_count", t, &stats->bulk_new_count, false, 1.0); + add_counter(r, "delete_count", t, &stats->delete_count, false, 1.0); + add_counter(r, "clear_count", t, &stats->clear_count, false, 1.0); + add_counter(r, "add_count", t, &stats->add_count, false, 1.0); + add_counter(r, "remove_count", t, &stats->remove_count, false, 1.0); + add_counter(r, "set_count", t, &stats->set_count, false, 1.0); + add_counter(r, "discard_count", t, &stats->discard_count, false, 1.0); + ecs_strbuf_list_pop(r, "}"); + + ecs_strbuf_list_pop(r, "}"); +} + +static void add_signature( + ecs_world_t *world, + ecs_strbuf_t *r, + ecs_entity_t system) +{ + const EcsQuery *q = ecs_get(world, system, EcsQuery); + if (q) { + ecs_strbuf_list_append(r, "\"signature\":"); + ecs_strbuf_list_push(r, "[", ","); + + ecs_sig_t *sig = ecs_query_get_sig(q->query); + + ecs_sig_column_t *columns = + ecs_vector_first(sig->columns, ecs_sig_column_t); + int32_t i, count = ecs_vector_count(sig->columns); + + for (i = 0; i < count; i ++) { + ecs_sig_column_t *col = &columns[i]; + + if (col->oper_kind != EcsOperOr) { + ecs_entity_t component = col->is.component; + + ecs_strbuf_list_next(r); + ecs_strbuf_list_push(r, "{", ","); + + if (component & ECS_TRAIT) { + ecs_entity_t + lo = ecs_entity_t_lo(component & ECS_COMPONENT_MASK), + hi = ecs_entity_t_hi(component & ECS_COMPONENT_MASK); + + const char + *lo_name = ecs_get_name(world, lo), + *hi_name = ecs_get_name(world, hi); + + if (!hi) { + ecs_strbuf_list_append(r, "\"name\":\"TRAIT | %s\"", lo_name); + } else { + if (lo_name) { + ecs_strbuf_list_append(r, "\"name\":\"%s FOR %s\"", + hi_name, lo_name); + } else { + ecs_strbuf_list_append(r, "\"name\":\"%s FOR %u\"", + hi_name, (uint32_t)lo); + } + } + } else { + ecs_strbuf_list_append(r, "\"name\":\"%s\"", + ecs_get_name(world, col->is.component)); + } + + ecs_entity_t actual = ecs_get_typeid(world, component); + if (!ecs_has(world, actual, EcsComponent)) { + ecs_strbuf_list_append(r, "\"tag\":true"); + } + + if (col->inout_kind == EcsIn) { + ecs_strbuf_list_append(r, "\"const\":true"); + } + + if (col->oper_kind == EcsOperNot) { + ecs_strbuf_list_append(r, "\"exclude\":true"); + } + + if (col->from_kind != EcsFromOwned && + col->from_kind != EcsFromAny && + col->from_kind != EcsFromShared && + col->from_kind != EcsFromEmpty) + { + ecs_strbuf_list_append(r, "\"ref\":true"); + } + + if (col->from_kind == EcsFromEmpty) { + ecs_strbuf_list_append(r, "\"empty\":true"); + } + + if (col->from_kind == EcsFromEntity && col->source == component) { + ecs_strbuf_list_append(r, "\"singleton\":true"); + } + + if (col->from_kind == EcsFromParent || col->from_kind == EcsCascade) { + ecs_strbuf_list_append(r, "\"parent\":true"); + } + + ecs_strbuf_list_pop(r, "}"); + } + } + + ecs_strbuf_list_pop(r, "]"); + } +} + +static void add_system( + ecs_world_t *world, + ecs_strbuf_t *r, + const ecs_pipeline_stats_t *stats, + ecs_entity_t system, + float df) +{ + ecs_system_stats_t *s = ecs_map_get( + stats->system_stats, ecs_system_stats_t, system); + + ecs_strbuf_list_next(r); + ecs_strbuf_list_push(r, "{", ","); + ecs_strbuf_list_append(r, "\"name\":\"%s\"", ecs_get_name(world, system)); + + ecs_entity_t module = ecs_get_parent_w_entity(world, system, EcsModule); + if (module) { + char *module_name = ecs_get_fullpath(world, module); + ecs_strbuf_list_append(r, "\"module\":\"%s\"", module_name); + ecs_os_free(module_name); + } + + add_signature(world, r, system); + + if (s) { + int32_t t = s->query_stats.t; + ecs_strbuf_list_appendstr(r, "\"current\":"); + ecs_strbuf_list_push(r, "{", ","); + add_current(r, "matched_table_count", t, &s->query_stats.matched_table_count, 1.0); + add_current(r, "matched_empty_table_count", t, &s->query_stats.matched_empty_table_count, 1.0); + add_current(r, "matched_entity_count", t, &s->query_stats.matched_entity_count, 1.0); + add_current(r, "time_spent", t, &s->time_spent, df); + add_current(r, "invoke_count", t, &s->invoke_count, df); + add_current(r, "active", t, &s->active, 1.0); + add_current(r, "enabled", t, &s->enabled, 1.0); + ecs_strbuf_list_pop(r, "}"); + + ecs_strbuf_list_appendstr(r, "\"history_1m\":"); + ecs_strbuf_list_push(r, "{", ","); + add_gauge(r, "matched_table_count", t, &s->query_stats.matched_table_count, false, 1.0); + add_gauge(r, "matched_empty_table_count", t, &s->query_stats.matched_empty_table_count, false, 1.0); + add_gauge(r, "matched_entity_count", t, &s->query_stats.matched_entity_count, false, 1.0); + add_counter(r, "time_spent", t, &s->time_spent, false, 1.0); + add_counter(r, "invoke_count", t, &s->invoke_count, false, 1.0); + add_gauge(r, "active", t, &s->active, false, 1.0); + add_gauge(r, "enabled", t, &s->enabled, false, 1.0); + ecs_strbuf_list_pop(r, "}"); + } + + ecs_strbuf_list_pop(r, "}"); +} + +static void add_pipeline_stats( + ecs_world_t *world, + const ecs_world_info_t *info, + ecs_strbuf_t *r) +{ + /* Get number of frames passed in interval */ + const WorldStats *ws = ecs_get(world, ecs_typeid(WorldStats), WorldStats); + if (!ws) { + return; + } + + const ecs_world_stats_t *wstats = &ws->stats; + int32_t t = wstats->t; + float df = wstats->frame_count_total.rate.avg[t]; + if (df == 0.0) { + return; + } + + const PipelineStats *s = ecs_get(world, + ecs_typeid(PipelineStats), PipelineStats); + if (!s) { + return; + } + + const ecs_pipeline_stats_t *stats = &s->stats; + int32_t i, count = ecs_vector_count(stats->systems); + ecs_entity_t *systems = ecs_vector_first(stats->systems, ecs_entity_t); + + ecs_strbuf_list_appendstr(r, "\"pipeline\":"); + ecs_strbuf_list_push(r, "{", ","); + + add_current(r, "fps", t, &wstats->fps, 1.0); + add_current(r, "frame_time_total", t, &wstats->frame_time_total, df); + add_current(r, "system_time_total", t, &wstats->system_time_total, df); + add_current(r, "merge_time_total", t, &wstats->merge_time_total, df); + + ecs_strbuf_list_appendstr(r, "\"systems\":"); + ecs_strbuf_list_push(r, "[", ","); + for (i = 0; i < count; i ++) { + if (systems[i]) { + add_system(world, r, stats, systems[i], df); + } else { + /* Merge */ + ecs_strbuf_list_appendstr(r, "null"); + } + } + ecs_strbuf_list_pop(r, "]"); + + ecs_strbuf_list_pop(r, "}"); +} + +static bool endpoint_world( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + ecs_strbuf_t r = ECS_STRBUF_INIT; + + const ecs_world_info_t *info = ecs_get_world_info(world); + + ecs_strbuf_list_push(&r, "{", ","); + + ecs_strbuf_list_append(&r, "\"target_fps\":%f", info->target_fps); + + char param[256]; + if (ecs_http_get_query_param( + request->params, "world", param, sizeof(param)) && + !strcmp(param, "yes")) + { + add_world_stats(world, info, &r); + } + + if (ecs_http_get_query_param( + request->params, "pipeline", param, sizeof(param)) && + !strcmp(param, "yes")) + { + add_pipeline_stats(world, info, &r); + } + + ecs_strbuf_list_pop(&r, "}"); + + reply->body = ecs_strbuf_get(&r); + + return true; +} + +static void CollectWorldStats(ecs_iter_t *it) { + WorldStats *s = ecs_column(it, WorldStats, 1); + ecs_get_world_stats(it->world, &s->stats); +} + +static void CollectPipelineStats(ecs_iter_t *it) { + PipelineStats *s = ecs_column(it, PipelineStats, 1); + ecs_get_pipeline_stats(it->world, ecs_get_pipeline(it->world), &s->stats); +} + +static void RecordDeltaTime(ecs_iter_t *it) { + DeltaTime *s = ecs_column(it, DeltaTime, 1); + int32_t t_frame = s->t_frame; + s->frame.min[t_frame] = it->delta_time; + s->frame.avg[t_frame] = it->delta_time; + s->frame.max[t_frame] = it->delta_time; + s->t_frame = (t_frame + 1) % ECS_STAT_WINDOW; +} + +static void CollectDeltaTime(ecs_iter_t *it) { + DeltaTime *s = ecs_column(it, DeltaTime, 1); + ecs_gauge_reduce(&s->minute, s->t_minute, &s->frame, s->t_frame); + s->t_minute = (s->t_minute + 1) % ECS_STAT_WINDOW; +} + +static void RunServer(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsMonitorServer *server = ecs_column(it, EcsMonitorServer, 1); + ecs_entity_t ecs_typeid(EcsHttpServer) = ecs_column_entity(it, 2); + ecs_entity_t ecs_typeid(EcsHttpEndpoint) = ecs_column_entity(it, 3); + + int32_t i; + for (i = 0; i < it->count; i ++) { + ecs_entity_t e = it->entities[i]; + + ecs_set(world, e, EcsHttpServer, {.port = server[i].port}); + + /* Add endpoint to server that returns entity id of server */ + ecs_entity_t e_metrics = ecs_new_w_entity(world, ECS_CHILDOF | e); + ecs_set(world, e_metrics, EcsName, {"e_metrics"}); + ecs_set(world, e_metrics, EcsHttpEndpoint, { + .url = "metrics", + .action = endpoint_world, + .synchronous = true}); + } +} + +void FlecsMonitorImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsMonitor); + + ECS_IMPORT(world, FlecsMeta); + ECS_IMPORT(world, FlecsComponentsHttp); + + ecs_set_name_prefix(world, "EcsMonitor"); + + ECS_META(world, EcsMonitorServer); + + /* Private components */ + ECS_COMPONENT_DEFINE(world, WorldStats); + ECS_COMPONENT_DEFINE(world, DeltaTime); + ECS_COMPONENT_DEFINE(world, PipelineStats); + + ECS_SYSTEM(world, RunServer, EcsOnSet, Server, + :flecs.components.http.Server, + :flecs.components.http.Endpoint); + + ECS_SYSTEM(world, CollectWorldStats, EcsOnLoad, $WorldStats); + ECS_SYSTEM(world, CollectPipelineStats, EcsOnLoad, $PipelineStats); + ECS_SYSTEM(world, RecordDeltaTime, EcsOnLoad, $DeltaTime); + ECS_SYSTEM(world, CollectDeltaTime, EcsOnLoad, $DeltaTime); + + /* Collect statistics once per second */ + ecs_set_interval(world, CollectWorldStats, 1.0); + ecs_set_interval(world, CollectPipelineStats, 1.0); + ecs_set_interval(world, CollectDeltaTime, 1.0); + + /* Initialize singleton entities for statistics components */ + ecs_set_ptr(world, ecs_typeid(WorldStats), WorldStats, NULL); + ecs_set_ptr(world, ecs_typeid(PipelineStats), PipelineStats, NULL); + ecs_set_ptr(world, ecs_typeid(DeltaTime), DeltaTime, NULL); + + ECS_EXPORT_COMPONENT(EcsMonitorServer); + + /* Enable system time monitoring */ + ecs_measure_system_time(world, true); +} diff --git a/code/vendors/flecs/flecs_monitor.h b/code/vendors/flecs/flecs_monitor.h new file mode 100644 index 0000000..cfc3bf5 --- /dev/null +++ b/code/vendors/flecs/flecs_monitor.h @@ -0,0 +1,70 @@ +#define flecs_monitor_STATIC +#ifndef FLECS_MONITOR_H +#define FLECS_MONITOR_H + +/* This generated file contains includes for project dependencies */ +/* + ) + (.) + .|. + | | + _.--| |--._ + .-'; ;`-'& ; `&. + \ & ; & &_/ + |"""---...---"""| + \ | | | | | | | / + `---.|.|.|.---' + + * This file is generated by bake.lang.c for your convenience. Headers of + * dependencies will automatically show up in this file. Include bake_config.h + * in your main project file. Do not edit! */ + +#ifndef FLECS_MONITOR_BAKE_CONFIG_H +#define FLECS_MONITOR_BAKE_CONFIG_H + +/* Headers of public dependencies */ +#include +#include +#include + +/* Convenience macro for exporting symbols */ +#ifndef flecs_monitor_STATIC +#if flecs_monitor_EXPORTS && (defined(_MSC_VER) || defined(__MINGW32__)) + #define FLECS_MONITOR_API __declspec(dllexport) +#elif flecs_monitor_EXPORTS + #define FLECS_MONITOR_API __attribute__((__visibility__("default"))) +#elif defined _MSC_VER + #define FLECS_MONITOR_API __declspec(dllimport) +#else + #define FLECS_MONITOR_API +#endif +#else + #define FLECS_MONITOR_API +#endif + +#endif + + +ECS_STRUCT(EcsMonitorServer, { + int16_t port; +}); + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct FlecsMonitor { + ECS_DECLARE_COMPONENT(EcsMonitorServer); +} FlecsMonitor; + +FLECS_MONITOR_API void FlecsMonitorImport( + ecs_world_t *world); + +#define FlecsMonitorImportHandles(handles) \ + ECS_IMPORT_COMPONENT(handles, EcsMonitorServer); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/code/vendors/flecs/flecs_os_api_posix.c b/code/vendors/flecs/flecs_os_api_posix.c new file mode 100644 index 0000000..4b6599d --- /dev/null +++ b/code/vendors/flecs/flecs_os_api_posix.c @@ -0,0 +1,152 @@ +#include "flecs_os_api_posix.h" + +#include + +#include "flecs/flecs.h" + +static +ecs_os_thread_t posix_thread_new( + ecs_os_thread_callback_t callback, + void *arg) +{ + pthread_t *thread = ecs_os_malloc(sizeof(pthread_t)); + int r; + + if ((r = pthread_create (thread, NULL, callback, arg))) { + abort(); + } + + return (ecs_os_thread_t)(uintptr_t)thread; +} + +static +void* posix_thread_join( + ecs_os_thread_t thread) +{ + void *arg; + pthread_t *thr = (pthread_t*)(uintptr_t)thread; + pthread_join(*thr, &arg); + ecs_os_free(thr); + return arg; +} + +static +int32_t posix_ainc(int32_t *count) { + int value; +#ifdef __GNUC__ + value = __sync_add_and_fetch (count, 1); + return value; +#else + /* Unsupported */ + abort(); +#endif +} + +static +int32_t posix_adec(int32_t *count) { + int value; +#ifdef __GNUC__ + value = __sync_sub_and_fetch (count, 1); + return value; +#else + /* Unsupported */ + abort(); +#endif +} + +static +ecs_os_mutex_t posix_mutex_new(void) { + pthread_mutex_t *mutex = ecs_os_malloc(sizeof(pthread_mutex_t)); + if (pthread_mutex_init(mutex, NULL)) { + abort(); + } + return (ecs_os_mutex_t)(uintptr_t)mutex; +} + +static +void posix_mutex_free(ecs_os_mutex_t m) { + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + pthread_mutex_destroy(mutex); + ecs_os_free(mutex); +} + +static +void posix_mutex_lock(ecs_os_mutex_t m) { + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + if (pthread_mutex_lock(mutex)) { + abort(); + } +} + +static +void posix_mutex_unlock(ecs_os_mutex_t m) { + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + if (pthread_mutex_unlock(mutex)) { + abort(); + } +} + +static +ecs_os_cond_t posix_cond_new(void) { + pthread_cond_t *cond = ecs_os_malloc(sizeof(pthread_cond_t)); + if (pthread_cond_init(cond, NULL)) { + abort(); + } + return (ecs_os_cond_t)(uintptr_t)cond; +} + +static +void posix_cond_free(ecs_os_cond_t c) { + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + if (pthread_cond_destroy(cond)) { + abort(); + } + ecs_os_free(cond); +} + +static +void posix_cond_signal(ecs_os_cond_t c) { + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + if (pthread_cond_signal(cond)) { + abort(); + } +} + +static +void posix_cond_broadcast(ecs_os_cond_t c) { + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + if (pthread_cond_broadcast(cond)) { + abort(); + } +} + +static +void posix_cond_wait(ecs_os_cond_t c, ecs_os_mutex_t m) { + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + if (pthread_cond_wait(cond, mutex)) { + abort(); + } +} + +void posix_set_os_api(void) { + ecs_os_set_api_defaults(); + + ecs_os_api_t api = ecs_os_api; + + api.thread_new_ = posix_thread_new; + api.thread_join_ = posix_thread_join; + api.ainc_ = posix_ainc; + api.adec_ = posix_adec; + api.mutex_new_ = posix_mutex_new; + api.mutex_free_ = posix_mutex_free; + api.mutex_lock_ = posix_mutex_lock; + api.mutex_unlock_ = posix_mutex_unlock; + api.cond_new_ = posix_cond_new; + api.cond_free_ = posix_cond_free; + api.cond_signal_ = posix_cond_signal; + api.cond_broadcast_ = posix_cond_broadcast; + api.cond_wait_ = posix_cond_wait; + + ecs_os_set_api(&api); +} diff --git a/code/vendors/flecs/flecs_os_api_posix.h b/code/vendors/flecs/flecs_os_api_posix.h new file mode 100644 index 0000000..5d06fdd --- /dev/null +++ b/code/vendors/flecs/flecs_os_api_posix.h @@ -0,0 +1,3 @@ +#pragma once + +void posix_set_os_api(void); diff --git a/code/vendors/flecs/flecs_player.c b/code/vendors/flecs/flecs_player.c new file mode 100644 index 0000000..6983f91 --- /dev/null +++ b/code/vendors/flecs/flecs_player.c @@ -0,0 +1,126 @@ +#ifndef FLECS_PLAYER_IMPL +#include "flecs_player.h" +#endif + +static +void player_start( + ecs_world_t *world, + void *ctx) +{ + ecs_ref_t *ref = ctx; + EcsPlayer *player = (EcsPlayer*)ecs_get_ref_w_entity(world, ref, 0, 0); + ecs_assert(player != NULL, ECS_INTERNAL_ERROR, NULL); + + player->snapshot = ecs_snapshot_take(world); + player->time_scale = 1.0; + + ecs_set_time_scale(world, 1.0); + ecs_set_pipeline(world, player->play_pipeline); + + ecs_os_free(ref); +} + +static +void player_stop( + ecs_world_t *world, + void *ctx) +{ + ecs_ref_t *ref = ctx; + EcsPlayer *player = (EcsPlayer*)ecs_get_ref_w_entity(world, ref, 0, 0); + ecs_assert(player != NULL, ECS_INTERNAL_ERROR, NULL); + + if (player->snapshot) { + ecs_snapshot_restore(world, player->snapshot); + + player = (EcsPlayer*)ecs_get_ref_w_entity(world, ref, 0, 0); + ecs_set_time_scale(world, 0); + ecs_reset_clock(world); + player->time_scale = 0; + player->state = EcsPlayerStop; + player->prev_state = EcsPlayerStop; + } + + player->snapshot = NULL; + ecs_set_pipeline(world, player->stop_pipeline); + + ecs_os_free(ref); +} + +static +void EcsSetPlayer(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + EcsPlayer *player = ecs_column(it, EcsPlayer, 1); + ecs_entity_t ecs_typeid(EcsPlayer) = ecs_column_entity(it, 1); + + int32_t i; + for (i = 0; i < it->count; i ++) { + EcsPlayerState prev_state = player[i].prev_state; + EcsPlayerState state = player[i].state; + + if (prev_state != state) { + switch(player[i].state) { + case EcsPlayerPause: + player[i].time_scale = 0; + break; + case EcsPlayerPlay: + if (prev_state == EcsPlayerStop) { + ecs_ref_t *ref = ecs_os_calloc(sizeof(ecs_ref_t)); + ecs_get_ref(world, ref, it->entities[i], EcsPlayer); + ecs_run_post_frame(it->world, player_start, ref); + } else { + player[i].time_scale = 1.0; + } + break; + case EcsPlayerStop: + if (prev_state != EcsPlayerStop) { + ecs_ref_t *ref = ecs_os_calloc(sizeof(ecs_ref_t)); + ecs_get_ref(world, ref, it->entities[i], EcsPlayer); + ecs_run_post_frame(world, player_stop, ref); + } + player[i].time_scale = 0; + break; + default: + break; + } + } + + player[i].prev_state = state; + + ecs_set_time_scale(it->world, player[i].time_scale); + } +} + +void FlecsPlayerImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsPlayer); + + ECS_IMPORT(world, FlecsMeta); + + ecs_set_name_prefix(world, "Ecs"); + + ECS_META(world, EcsPlayerState); + ECS_META(world, EcsPlayer); + ECS_META(world, EcsTargetFps); + + ECS_PIPELINE(world, StopPipeline, + flecs.pipeline.PreFrame, + flecs.pipeline.OnLoad, + flecs.pipeline.PostLoad, + flecs.pipeline.PreStore, + flecs.pipeline.OnStore, + flecs.pipeline.PostFrame); + + ECS_SYSTEM(world, EcsSetPlayer, EcsOnSet, EcsPlayer); + + ecs_set(world, EcsWorld, EcsPlayer, { + .state = EcsPlayerPlay, + .prev_state = EcsPlayerStop, + .time_scale = 1, + .play_pipeline = ecs_get_pipeline(world), + .stop_pipeline = StopPipeline + }); + + ECS_EXPORT_COMPONENT(EcsPlayer); +} diff --git a/code/vendors/flecs/flecs_player.h b/code/vendors/flecs/flecs_player.h new file mode 100644 index 0000000..7dbd88f --- /dev/null +++ b/code/vendors/flecs/flecs_player.h @@ -0,0 +1,88 @@ +#define flecs_player_STATIC +#ifndef FLECS_PLAYER_H +#define FLECS_PLAYER_H + +/* This generated file contains includes for project dependencies */ +/* + ) + (.) + .|. + | | + _.--| |--._ + .-'; ;`-'& ; `&. + \ & ; & &_/ + |"""---...---"""| + \ | | | | | | | / + `---.|.|.|.---' + + * This file is generated by bake.lang.c for your convenience. Headers of + * dependencies will automatically show up in this file. Include bake_config.h + * in your main project file. Do not edit! */ + +#ifndef FLECS_PLAYER_BAKE_CONFIG_H +#define FLECS_PLAYER_BAKE_CONFIG_H + +/* Headers of public dependencies */ +#include +#include + +/* Convenience macro for exporting symbols */ +#ifndef flecs_player_STATIC +#if flecs_player_EXPORTS && (defined(_MSC_VER) || defined(__MINGW32__)) + #define FLECS_PLAYER_API __declspec(dllexport) +#elif flecs_player_EXPORTS + #define FLECS_PLAYER_API __attribute__((__visibility__("default"))) +#elif defined _MSC_VER + #define FLECS_PLAYER_API __declspec(dllimport) +#else + #define FLECS_PLAYER_API +#endif +#else + #define FLECS_PLAYER_API +#endif + +#endif + + +ECS_ENUM(EcsPlayerState, { + EcsPlayerPlay, + EcsPlayerPause, + EcsPlayerStop +}); + +ECS_STRUCT(EcsPlayer, { + EcsPlayerState state; + EcsPlayerState prev_state; + float time_scale; + ecs_entity_t play_pipeline; + ecs_entity_t stop_pipeline; + +ECS_PRIVATE + ecs_snapshot_t *snapshot; +}); + +ECS_STRUCT(EcsTargetFps, { + float target_fps; +}); + + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct FlecsPlayer { + ECS_DECLARE_COMPONENT(EcsPlayer); +} FlecsPlayer; + +FLECS_PLAYER_API +void FlecsPlayerImport( + ecs_world_t *world); + +#define FlecsPlayerImportHandles(handles)\ + ECS_IMPORT_COMPONENT(handles, EcsPlayer); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/code/vendors/flecs/flecs_rest.c b/code/vendors/flecs/flecs_rest.c new file mode 100644 index 0000000..cd048de --- /dev/null +++ b/code/vendors/flecs/flecs_rest.c @@ -0,0 +1,414 @@ +#ifndef FLECS_REST_IMPL +#include "flecs_rest.h" +#endif +#include +#include + +static +bool parse_filter( + ecs_world_t *world, + EcsHttpRequest *request, + ecs_filter_t *filter) +{ + char buffer[1024]; + + if (ecs_http_get_query_param( + request->params, "include", buffer, sizeof(buffer))) + { + filter->include = ecs_type_from_str(world, buffer); + filter->include_kind = EcsMatchAny; + if (!filter->include) { + return false; + } + } + + if (ecs_http_get_query_param( + request->params, "exclude", buffer, sizeof(buffer))) + { + filter->exclude = ecs_type_from_str(world, buffer); + if (!filter->exclude) { + return false; + } + } + + return true; +} + +static +bool parse_select( + ecs_world_t *world, + EcsHttpRequest *request, + ecs_type_t *select) +{ + char buffer[1024]; + + *select = NULL; + + if (ecs_http_get_query_param( + request->params, "select", buffer, sizeof(buffer))) + { + *select = ecs_type_from_str(world, buffer); + if (!*select) { + return false; + } + } + + return true; +} + +static +bool parse_entity( + ecs_world_t *world, + EcsHttpRequest *request, + ecs_entity_t *e_out) +{ + ecs_entity_t e = 0; + + if (request->relative_url && strlen(request->relative_url)) { + /* Request scope of entity */ + const char *name = request->relative_url; + + /* If name starts with a number, lookup by entity id */ + if (isdigit(name[0])) { + e = atoi(name); + } else { + e = ecs_lookup_path_w_sep(world, 0, name, "/", NULL); + if (!e) { + return false; + } + } + } + + *e_out = e; + + return true; +} + +static +bool endpoint_filter( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + ecs_filter_t filter = { }; + ecs_type_t select = NULL; + + if (!parse_filter(world, request, &filter)) { + return false; + } + + if (!parse_select(world, request, &select)) { + return false; + } + + ecs_iter_t it = ecs_filter_iter(world, &filter); + + reply->body = ecs_iter_to_json(world, &it, ecs_filter_next, select); + + return true; +} + +static +bool endpoint_scope( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + ecs_entity_t e = 0; + ecs_filter_t filter = { }; + ecs_type_t select = NULL; + + if (!parse_entity(world, request, &e)) { + return false; + } + + if (!parse_filter(world, request, &filter)) { + return false; + } + + if (!parse_select(world, request, &select)) { + return false; + } + + ecs_iter_t it = ecs_scope_iter_w_filter(world, e, &filter); + + reply->body = ecs_iter_to_json(world, &it, ecs_scope_next, select); + + return true; +} + +static +bool endpoint_entity_new( + ecs_world_t *world, + EcsHttpReply *reply, + const char *name, + ecs_type_t select) +{ + ecs_entity_t e = ecs_new_from_path(world, 0, name); + if (select) { + ecs_add_type(world, e, select); + } + + return true; +} + +static +bool endpoint_entity_add( + ecs_world_t *world, + EcsHttpReply *reply, + ecs_entity_t e, + ecs_type_t select) +{ + if (select) { + ecs_add_type(world, e, select); + } + + return true; +} + +static +bool endpoint_entity_remove( + ecs_world_t *world, + EcsHttpReply *reply, + ecs_entity_t e, + ecs_type_t select) +{ + if (select) { + ecs_remove_type(world, e, select); + } else { + ecs_delete(world, e); + } + + return true; +} + +static +bool endpoint_entity_get( + ecs_world_t *world, + EcsHttpReply *reply, + ecs_entity_t e, + ecs_type_t select) +{ + reply->body = ecs_entity_to_json(world, e, select); + return true; +} + +static +bool endpoint_entity( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + ecs_entity_t e = 0; + ecs_type_t select = NULL; + + if (!parse_select(world, request, &select)) { + return false; + } + + if (request->method == EcsHttpPost) { + return endpoint_entity_new(world, reply, request->relative_url, select); + } + + if (!parse_entity(world, request, &e)) { + return false; + } + + if (request->method == EcsHttpGet) { + return endpoint_entity_get(world, reply, e, select); + } else if (request->method == EcsHttpDelete) { + return endpoint_entity_remove(world, reply, e, select); + } else if (request->method == EcsHttpPut) { + return endpoint_entity_add(world, reply, e, select); + } + + return false; +} + +static +void serialize_browse_info( + ecs_world_t *world, + ecs_entity_t parent, + ecs_entity_t e, + ecs_strbuf_t *str) +{ + ecs_strbuf_list_append(str, "\"id\":%u", (int32_t)e); + + char *type = ecs_type_to_json(world, ecs_get_type(world, e)); + ecs_strbuf_list_append(str, "\"type\":%s", type); + + const char *name = ecs_get_name(world, e); + if (name) { + ecs_strbuf_list_append(str, "\"name\":\"%s\"", name); + + char *fullpath = ecs_get_fullpath(world, e); + ecs_strbuf_list_append(str, "\"path\":\"%s\"", fullpath); + } + + int32_t child_count = ecs_get_child_count(world, e); + ecs_strbuf_list_append(str, "\"child_count\":%u", child_count); +} + +static +bool endpoint_browse( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + ecs_filter_t filter = { }; + ecs_entity_t e; + + if (!parse_entity(world, request, &e)) { + return false; + } + + if (!parse_filter(world, request, &filter)) { + return false; + } + + ecs_iter_t it = ecs_scope_iter_w_filter(world, e, &filter); + ecs_strbuf_t str = ECS_STRBUF_INIT; + + ecs_strbuf_list_push(&str, "[", ","); + while (ecs_scope_next(&it)) { + int32_t i; + for (i = 0; i < it.count; i ++) { + ecs_strbuf_list_next(&str); + ecs_strbuf_list_push(&str, "{", ","); + serialize_browse_info(world, e, it.entities[i], &str); + ecs_strbuf_list_pop(&str, "}"); + } + } + ecs_strbuf_list_pop(&str, "]"); + + reply->body = ecs_strbuf_get(&str); + + return true; +} + +static +bool endpoint_info( + ecs_world_t *world, + ecs_entity_t entity, + EcsHttpEndpoint *endpoint, + EcsHttpRequest *request, + EcsHttpReply *reply) +{ + ecs_entity_t e; + + if (!parse_entity(world, request, &e)) { + return false; + } + + ecs_strbuf_t str = ECS_STRBUF_INIT; + ecs_strbuf_list_push(&str, "{", ","); + serialize_browse_info(world, e, e, &str); + ecs_strbuf_list_pop(&str, "}"); + + reply->body = ecs_strbuf_get(&str); + + return true; +} + +static +void EcsRestSetServer(ecs_iter_t *it) { + EcsRestServer *server_data = ecs_column(it, EcsRestServer, 1); + ecs_entity_t ecs_typeid(EcsHttpServer) = ecs_column_entity(it, 2); + ecs_entity_t ecs_typeid(EcsHttpEndpoint) = ecs_column_entity(it, 3); + ecs_entity_t EcsRestInitialized = ecs_column_entity(it, 4); + + ecs_world_t *world = it->world; + + int i; + for (i = 0; i < it->count; i ++) { + ecs_entity_t server = it->entities[i]; + + // Get filtered list of entities + ecs_set(world, server, EcsHttpServer, {.port = server_data[i].port}); + + if (ecs_has_entity(world, server, EcsRestInitialized)) { + /* Don't add endpoints more than once */ + continue; + } + + ecs_entity_t e_filter = ecs_new_w_entity(world, ECS_CHILDOF | server); + ecs_set(world, e_filter, EcsName, {"e_filter"}); + ecs_set(world, e_filter, EcsHttpEndpoint, { + .url = "filter", + .action = endpoint_filter, + .synchronous = true, + .ctx = NULL + }); + + // Get filtered list of children + ecs_entity_t e_scope = ecs_new_w_entity(world, ECS_CHILDOF | server); + ecs_set(world, e_scope, EcsName, {"e_scope"}); + ecs_set(world, e_scope, EcsHttpEndpoint, { + .url = "scope", + .action = endpoint_scope, + .synchronous = true, + .ctx = NULL + }); + + // Get component data for single entity + ecs_entity_t e_entity = ecs_new_w_entity(world, ECS_CHILDOF | server); + ecs_set(world, e_entity, EcsName, {"e_entity"}); + ecs_set(world, e_entity, EcsHttpEndpoint, { + .url = "entity", + .action = endpoint_entity, + .synchronous = true, + .ctx = NULL + }); + + // Browse entity information + ecs_entity_t e_browse = ecs_new_w_entity(world, ECS_CHILDOF | server); + ecs_set(world, e_browse, EcsName, {"e_browse"}); + ecs_set(world, e_browse, EcsHttpEndpoint, { + .url = "browse", + .action = endpoint_browse, + .synchronous = true, + .ctx = NULL + }); + + // Browse entity information for single entity + ecs_entity_t e_info = ecs_new_w_entity(world, ECS_CHILDOF | server); + ecs_set(world, e_info, EcsName, {"e_info"}); + ecs_set(world, e_info, EcsHttpEndpoint, { + .url = "info", + .action = endpoint_info, + .synchronous = true, + .ctx = NULL + }); + + ecs_add_entity(world, server, EcsRestInitialized); + } +} + +void FlecsRestImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsRest); + + ecs_set_name_prefix(world, "EcsRest"); + + ECS_IMPORT(world, FlecsMeta); + ECS_IMPORT(world, FlecsComponentsHttp); + + ECS_META(world, EcsRestServer); + ECS_TAG(world, EcsRestInitialized); + + ECS_SYSTEM(world, EcsRestSetServer, EcsOnSet, Server, + :flecs.components.http.Server, + :flecs.components.http.Endpoint, + :Initialized); + + ECS_EXPORT_COMPONENT(EcsRestServer); +} diff --git a/code/vendors/flecs/flecs_rest.h b/code/vendors/flecs/flecs_rest.h new file mode 100644 index 0000000..1035407 --- /dev/null +++ b/code/vendors/flecs/flecs_rest.h @@ -0,0 +1,95 @@ +#define flecs_rest_STATIC +#ifndef FLECS_SYSTEMS_REST_H +#define FLECS_SYSTEMS_REST_H + +/* This generated file contains includes for project dependencies */ +/* + ) + (.) + .|. + | | + _.--| |--._ + .-'; ;`-'& ; `&. + \ & ; & &_/ + |"""---...---"""| + \ | | | | | | | / + `---.|.|.|.---' + + * This file is generated by bake.lang.c for your convenience. Headers of + * dependencies will automatically show up in this file. Include bake_config.h + * in your main project file. Do not edit! */ + +#ifndef FLECS_REST_BAKE_CONFIG_H +#define FLECS_REST_BAKE_CONFIG_H + +/* Headers of public dependencies */ +#include +#include +#include +#include + +/* Convenience macro for exporting symbols */ +#ifndef flecs_rest_STATIC +#if flecs_rest_EXPORTS && (defined(_MSC_VER) || defined(__MINGW32__)) + #define FLECS_REST_API __declspec(dllexport) +#elif flecs_rest_EXPORTS + #define FLECS_REST_API __attribute__((__visibility__("default"))) +#elif defined _MSC_VER + #define FLECS_REST_API __declspec(dllimport) +#else + #define FLECS_REST_API +#endif +#else + #define FLECS_REST_API +#endif + +#endif + + +ECS_STRUCT(EcsRestServer, { + int16_t port; +}); + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct FlecsRest { + ECS_DECLARE_COMPONENT(EcsRestServer); +} FlecsRest; + +FLECS_REST_API +void FlecsRestImport( + ecs_world_t *world); + +#define FlecsRestImportHandles(handles) \ + ECS_IMPORT_COMPONENT(handles, EcsRestServer); + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +#ifndef FLECS_NO_CPP + +namespace flecs { + +class rest : public FlecsRest { +public: + using Server = EcsRestServer; + + rest(flecs::world& world) { + FlecsRestImport(world.c_ptr()); + + flecs::module(world, "flecs::rest"); + + flecs::component(world, "Server"); + } +}; + +} + +#endif // FLECS_NO_CPP +#endif // __cplusplus + +#endif diff --git a/code/vendors/flecs/flecs_systems_civetweb.c b/code/vendors/flecs/flecs_systems_civetweb.c new file mode 100644 index 0000000..04f9d0e --- /dev/null +++ b/code/vendors/flecs/flecs_systems_civetweb.c @@ -0,0 +1,23477 @@ +#ifndef FLECS_SYSTEMS_CIVETWEB_IMPL +#include "flecs_systems_civetweb.h" +#endif +#include +/* Copyright (c) 2013-2018 the Civetweb developers + * Copyright (c) 2004-2013 Sergey Lyubka + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef CIVETWEB_HEADER_INCLUDED +#define CIVETWEB_HEADER_INCLUDED + +#define CIVETWEB_VERSION "1.12" +#define CIVETWEB_VERSION_MAJOR (1) +#define CIVETWEB_VERSION_MINOR (12) +#define CIVETWEB_VERSION_PATCH (0) + +#ifndef CIVETWEB_API +#if defined(_WIN32) +#if defined(CIVETWEB_DLL_EXPORTS) +#define CIVETWEB_API __declspec(dllexport) +#elif defined(CIVETWEB_DLL_IMPORTS) +#define CIVETWEB_API __declspec(dllimport) +#else +#define CIVETWEB_API +#endif +#elif __GNUC__ >= 4 +#define CIVETWEB_API __attribute__((visibility("default"))) +#else +#define CIVETWEB_API +#endif +#endif + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + + +/* Init Features */ +enum { + MG_FEATURES_DEFAULT = 0x0u, + + /* Support files from local directories */ + /* Will only work, if NO_FILES is not set. */ + MG_FEATURES_FILES = 0x1u, + + /* Support transport layer security (TLS). */ + /* SSL is still often used synonymously for TLS. */ + /* Will only work, if NO_SSL is not set. */ + MG_FEATURES_TLS = 0x2u, + MG_FEATURES_SSL = 0x2u, + + /* Support common gateway interface (CGI). */ + /* Will only work, if NO_CGI is not set. */ + MG_FEATURES_CGI = 0x4u, + + /* Support IPv6. */ + /* Will only work, if USE_IPV6 is set. */ + MG_FEATURES_IPV6 = 0x8u, + + /* Support WebSocket protocol. */ + /* Will only work, if USE_WEBSOCKET is set. */ + MG_FEATURES_WEBSOCKET = 0x10u, + + /* Support server side Lua scripting. */ + /* Will only work, if USE_LUA is set. */ + MG_FEATURES_LUA = 0x20u, + + /* Support server side JavaScript scripting. */ + /* Will only work, if USE_DUKTAPE is set. */ + MG_FEATURES_SSJS = 0x40u, + + /* Provide data required for caching files. */ + /* Will only work, if NO_CACHING is not set. */ + MG_FEATURES_CACHE = 0x80u, + + /* Collect server status information. */ + /* Will only work, if USE_SERVER_STATS is set. */ + MG_FEATURES_STATS = 0x100u, + + /* Support on-the-fly compression. */ + /* Will only work, if USE_ZLIB is set. */ + MG_FEATURES_COMPRESSION = 0x200u, + + /* Collect server status information. */ + /* Will only work, if USE_SERVER_STATS is set. */ + MG_FEATURES_ALL = 0xFFFFu +}; + + +/* Initialize this library. This should be called once before any other + * function from this library. This function is not guaranteed to be + * thread safe. + * Parameters: + * features: bit mask for features to be initialized. + * Note: The TLS libraries (like OpenSSL) is initialized + * only if the MG_FEATURES_TLS bit is set. + * Currently the other bits do not influence + * initialization, but this may change in future + * versions. + * Return value: + * initialized features + * 0: error + */ +CIVETWEB_API unsigned mg_init_library(unsigned features); + + +/* Un-initialize this library. + * Return value: + * 0: error + */ +CIVETWEB_API unsigned mg_exit_library(void); + + +struct mg_context; /* Handle for the HTTP service itself */ +struct mg_connection; /* Handle for the individual connection */ + + +/* Maximum number of headers */ +#define MG_MAX_HEADERS (64) + +struct mg_header { + const char *name; /* HTTP header name */ + const char *value; /* HTTP header value */ +}; + + +/* This structure contains information about the HTTP request. */ +struct mg_request_info { + const char *request_method; /* "GET", "POST", etc */ + const char *request_uri; /* URL-decoded URI (absolute or relative, + * as in the request) */ + const char *local_uri; /* URL-decoded URI (relative). Can be NULL + * if the request_uri does not address a + * resource at the server host. */ +#if defined(MG_LEGACY_INTERFACE) /* 2017-02-04, deprecated 2014-09-14 */ + const char *uri; /* Deprecated: use local_uri instead */ +#endif + const char *http_version; /* E.g. "1.0", "1.1" */ + const char *query_string; /* URL part after '?', not including '?', or + NULL */ + const char *remote_user; /* Authenticated user, or NULL if no auth + used */ + char remote_addr[48]; /* Client's IP address as a string. */ + + long long content_length; /* Length (in bytes) of the request body, + can be -1 if no length was given. */ + int remote_port; /* Client's port */ + int is_ssl; /* 1 if SSL-ed, 0 if not */ + void *user_data; /* User data pointer passed to mg_start() */ + void *conn_data; /* Connection-specific user data */ + + int num_headers; /* Number of HTTP headers */ + struct mg_header + http_headers[MG_MAX_HEADERS]; /* Allocate maximum headers */ + + struct mg_client_cert *client_cert; /* Client certificate information */ + + const char *acceptedWebSocketSubprotocol; /* websocket subprotocol, + * accepted during handshake */ +}; + + +/* This structure contains information about the HTTP request. */ +/* This structure may be extended in future versions. */ +struct mg_response_info { + int status_code; /* E.g. 200 */ + const char *status_text; /* E.g. "OK" */ + const char *http_version; /* E.g. "1.0", "1.1" */ + + long long content_length; /* Length (in bytes) of the request body, + can be -1 if no length was given. */ + + int num_headers; /* Number of HTTP headers */ + struct mg_header + http_headers[MG_MAX_HEADERS]; /* Allocate maximum headers */ +}; + + +/* Client certificate information (part of mg_request_info) */ +/* New nomenclature. */ +struct mg_client_cert { + void *peer_cert; + const char *subject; + const char *issuer; + const char *serial; + const char *finger; +}; + +#if defined(MG_LEGACY_INTERFACE) /* 2017-10-05 */ +/* Old nomenclature. */ +struct client_cert { + const char *subject; + const char *issuer; + const char *serial; + const char *finger; +}; +#endif + + +/* This structure needs to be passed to mg_start(), to let civetweb know + which callbacks to invoke. For a detailed description, see + https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md */ +struct mg_callbacks { + /* Called when civetweb has received new HTTP request. + If the callback returns one, it must process the request + by sending valid HTTP headers and a body. Civetweb will not do + any further processing. Otherwise it must return zero. + Note that since V1.7 the "begin_request" function is called + before an authorization check. If an authorization check is + required, use a request_handler instead. + Return value: + 0: civetweb will process the request itself. In this case, + the callback must not send any data to the client. + 1-999: callback already processed the request. Civetweb will + not send any data after the callback returned. The + return code is stored as a HTTP status code for the + access log. */ + int (*begin_request)(struct mg_connection *); + + /* Called when civetweb has finished processing request. */ + void (*end_request)(const struct mg_connection *, int reply_status_code); + + /* Called when civetweb is about to log a message. If callback returns + non-zero, civetweb does not log anything. */ + int (*log_message)(const struct mg_connection *, const char *message); + + /* Called when civetweb is about to log access. If callback returns + non-zero, civetweb does not log anything. */ + int (*log_access)(const struct mg_connection *, const char *message); + + /* Called when civetweb initializes SSL library. + Parameters: + user_data: parameter user_data passed when starting the server. + Return value: + 0: civetweb will set up the SSL certificate. + 1: civetweb assumes the callback already set up the certificate. + -1: initializing ssl fails. */ + int (*init_ssl)(void *ssl_context, void *user_data); + + /* Called when civetweb is about to create or free a SSL_CTX. + Parameters: + ssl_ctx: SSL_CTX pointer. NULL at creation time, Not NULL when mg_context + will be freed + user_data: parameter user_data passed when starting the server. + Return value: + 0: civetweb will continue to create the context, just as if the + callback would not be present. + The value in *ssl_ctx when the function returns is ignored. + 1: civetweb will copy the value from *ssl_ctx to the civetweb context + and doesn't create its own. + -1: initializing ssl fails.*/ + int (*external_ssl_ctx)(void **ssl_ctx, void *user_data); + +#if defined(MG_LEGACY_INTERFACE) /* 2015-08-19 */ + /* Called when websocket request is received, before websocket handshake. + Return value: + 0: civetweb proceeds with websocket handshake. + 1: connection is closed immediately. + This callback is deprecated: Use mg_set_websocket_handler instead. */ + int (*websocket_connect)(const struct mg_connection *); + + /* Called when websocket handshake is successfully completed, and + connection is ready for data exchange. + This callback is deprecated: Use mg_set_websocket_handler instead. */ + void (*websocket_ready)(struct mg_connection *); + + /* Called when data frame has been received from the client. + Parameters: + bits: first byte of the websocket frame, see websocket RFC at + http://tools.ietf.org/html/rfc6455, section 5.2 + data, data_len: payload, with mask (if any) already applied. + Return value: + 1: keep this websocket connection open. + 0: close this websocket connection. + This callback is deprecated: Use mg_set_websocket_handler instead. */ + int (*websocket_data)(struct mg_connection *, + int bits, + char *data, + size_t data_len); +#endif /* MG_LEGACY_INTERFACE */ + + /* Called when civetweb is closing a connection. The per-context mutex is + locked when this is invoked. + + Websockets: + Before mg_set_websocket_handler has been added, it was primarily useful + for noting when a websocket is closing, and used to remove it from any + application-maintained list of clients. + Using this callback for websocket connections is deprecated: Use + mg_set_websocket_handler instead. + + Connection specific data: + If memory has been allocated for the connection specific user data + (mg_request_info->conn_data, mg_get_user_connection_data), + this is the last chance to free it. + */ + void (*connection_close)(const struct mg_connection *); + + /* Called when civetweb is about to serve Lua server page, if + Lua support is enabled. + Parameters: + conn: current connection. + lua_context: "lua_State *" pointer. */ + void (*init_lua)(const struct mg_connection *conn, void *lua_context); + +#if defined(MG_LEGACY_INTERFACE) /* 2016-05-14 */ + /* Called when civetweb has uploaded a file to a temporary directory as a + result of mg_upload() call. + Note that mg_upload is deprecated. Use mg_handle_form_request instead. + Parameters: + file_name: full path name to the uploaded file. */ + void (*upload)(struct mg_connection *, const char *file_name); +#endif + + /* Called when civetweb is about to send HTTP error to the client. + Implementing this callback allows to create custom error pages. + Parameters: + conn: current connection. + status: HTTP error status code. + errmsg: error message text. + Return value: + 1: run civetweb error handler. + 0: callback already handled the error. */ + int (*http_error)(struct mg_connection *conn, + int status, + const char *errmsg); + + /* Called after civetweb context has been created, before requests + are processed. + Parameters: + ctx: context handle */ + void (*init_context)(const struct mg_context *ctx); + + /* Called when civetweb context is deleted. + Parameters: + ctx: context handle */ + void (*exit_context)(const struct mg_context *ctx); + + /* Called when a new worker thread is initialized. + * Parameters: + * ctx: context handle + * thread_type: + * 0 indicates the master thread + * 1 indicates a worker thread handling client connections + * 2 indicates an internal helper thread (timer thread) + * Return value: + * This function returns a user supplied pointer. The pointer is assigned + * to the thread and can be obtained from the mg_connection object using + * mg_get_thread_pointer in all server callbacks. Note: A connection and + * a thread are not directly related. Threads will serve several different + * connections, and data from a single connection may call different + * callbacks using different threads. The thread pointer can be obtained + * in a callback handler, but should not be stored beyond the scope of + * one call to one callback. + */ + void *(*init_thread)(const struct mg_context *ctx, int thread_type); + + /* Called when a worker exits. + * The parameters "ctx" and "thread_type" correspond to the "init_thread" + * call. The "thread_pointer" parameter is the value returned by + * "init_thread". + */ + void (*exit_thread)(const struct mg_context *ctx, + int thread_type, + void *thread_pointer); + + + /* Called when initializing a new connection object. + * Can be used to initialize the connection specific user data + * (mg_request_info->conn_data, mg_get_user_connection_data). + * When the callback is called, it is not yet known if a + * valid HTTP(S) request will be made. + * Parameters: + * conn: not yet fully initialized connection object + * conn_data: output parameter, set to initialize the + * connection specific user data + * Return value: + * must be 0 + * Otherwise, the result is undefined + */ + int (*init_connection)(const struct mg_connection *conn, void **conn_data); +}; + + +/* Start web server. + + Parameters: + callbacks: mg_callbacks structure with user-defined callbacks. + options: NULL terminated list of option_name, option_value pairs that + specify Civetweb configuration parameters. + + Side-effects: on UNIX, ignores SIGCHLD and SIGPIPE signals. If custom + processing is required for these, signal handlers must be set up + after calling mg_start(). + + + Example: + const char *options[] = { + "document_root", "/var/www", + "listening_ports", "80,443s", + NULL + }; + struct mg_context *ctx = mg_start(&my_func, NULL, options); + + Refer to https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md + for the list of valid option and their possible values. + + Return: + web server context, or NULL on error. */ +CIVETWEB_API struct mg_context *mg_start(const struct mg_callbacks *callbacks, + void *user_data, + const char **configuration_options); + + +/* Stop the web server. + + Must be called last, when an application wants to stop the web server and + release all associated resources. This function blocks until all Civetweb + threads are stopped. Context pointer becomes invalid. */ +CIVETWEB_API void mg_stop(struct mg_context *); + + +#if defined(MG_EXPERIMENTAL_INTERFACES) +/* Add an additional domain to an already running web server. + * + * Parameters: + * ctx: Context handle of a server started by mg_start. + * options: NULL terminated list of option_name, option_value pairs that + * specify CivetWeb configuration parameters. + * + * Return: + * < 0 in case of an error + * -1 for a parameter error + * -2 invalid options + * -3 initializing SSL failed + * -4 mandatory domain option missing + * -5 duplicate domain + * -6 out of memory + * > 0 index / handle of a new domain + */ +CIVETWEB_API int mg_start_domain(struct mg_context *ctx, + const char **configuration_options); +#endif + + +/* mg_request_handler + + Called when a new request comes in. This callback is URI based + and configured with mg_set_request_handler(). + + Parameters: + conn: current connection information. + cbdata: the callback data configured with mg_set_request_handler(). + Returns: + 0: the handler could not handle the request, so fall through. + 1 - 999: the handler processed the request. The return code is + stored as a HTTP status code for the access log. */ +typedef int (*mg_request_handler)(struct mg_connection *conn, void *cbdata); + + +/* mg_set_request_handler + + Sets or removes a URI mapping for a request handler. + This function uses mg_lock_context internally. + + URI's are ordered and prefixed URI's are supported. For example, + consider two URIs: /a/b and /a + /a matches /a + /a/b matches /a/b + /a/c matches /a + + Parameters: + ctx: server context + uri: the URI (exact or pattern) for the handler + handler: the callback handler to use when the URI is requested. + If NULL, an already registered handler for this URI will + be removed. + The URI used to remove a handler must match exactly the + one used to register it (not only a pattern match). + cbdata: the callback data to give to the handler when it is called. */ +CIVETWEB_API void mg_set_request_handler(struct mg_context *ctx, + const char *uri, + mg_request_handler handler, + void *cbdata); + + +/* Callback types for websocket handlers in C/C++. + + mg_websocket_connect_handler + Is called when the client intends to establish a websocket connection, + before websocket handshake. + Return value: + 0: civetweb proceeds with websocket handshake. + 1: connection is closed immediately. + + mg_websocket_ready_handler + Is called when websocket handshake is successfully completed, and + connection is ready for data exchange. + + mg_websocket_data_handler + Is called when a data frame has been received from the client. + Parameters: + bits: first byte of the websocket frame, see websocket RFC at + http://tools.ietf.org/html/rfc6455, section 5.2 + data, data_len: payload, with mask (if any) already applied. + Return value: + 1: keep this websocket connection open. + 0: close this websocket connection. + + mg_connection_close_handler + Is called, when the connection is closed.*/ +typedef int (*mg_websocket_connect_handler)(const struct mg_connection *, + void *); +typedef void (*mg_websocket_ready_handler)(struct mg_connection *, void *); +typedef int (*mg_websocket_data_handler)(struct mg_connection *, + int, + char *, + size_t, + void *); +typedef void (*mg_websocket_close_handler)(const struct mg_connection *, + void *); + +/* struct mg_websocket_subprotocols + * + * List of accepted subprotocols + */ +struct mg_websocket_subprotocols { + int nb_subprotocols; + char **subprotocols; +}; + +/* mg_set_websocket_handler + + Set or remove handler functions for websocket connections. + This function works similar to mg_set_request_handler - see there. */ +CIVETWEB_API void +mg_set_websocket_handler(struct mg_context *ctx, + const char *uri, + mg_websocket_connect_handler connect_handler, + mg_websocket_ready_handler ready_handler, + mg_websocket_data_handler data_handler, + mg_websocket_close_handler close_handler, + void *cbdata); + +/* mg_set_websocket_handler + + Set or remove handler functions for websocket connections. + This function works similar to mg_set_request_handler - see there. */ +CIVETWEB_API void mg_set_websocket_handler_with_subprotocols( + struct mg_context *ctx, + const char *uri, + struct mg_websocket_subprotocols *subprotocols, + mg_websocket_connect_handler connect_handler, + mg_websocket_ready_handler ready_handler, + mg_websocket_data_handler data_handler, + mg_websocket_close_handler close_handler, + void *cbdata); + + +/* mg_authorization_handler + + Callback function definition for mg_set_auth_handler + + Parameters: + conn: current connection information. + cbdata: the callback data configured with mg_set_request_handler(). + Returns: + 0: access denied + 1: access granted + */ +typedef int (*mg_authorization_handler)(struct mg_connection *conn, + void *cbdata); + + +/* mg_set_auth_handler + + Sets or removes a URI mapping for an authorization handler. + This function works similar to mg_set_request_handler - see there. */ +CIVETWEB_API void mg_set_auth_handler(struct mg_context *ctx, + const char *uri, + mg_authorization_handler handler, + void *cbdata); + + +/* Get the value of particular configuration parameter. + The value returned is read-only. Civetweb does not allow changing + configuration at run time. + If given parameter name is not valid, NULL is returned. For valid + names, return value is guaranteed to be non-NULL. If parameter is not + set, zero-length string is returned. */ +CIVETWEB_API const char *mg_get_option(const struct mg_context *ctx, + const char *name); + + +/* Get context from connection. */ +CIVETWEB_API struct mg_context * +mg_get_context(const struct mg_connection *conn); + + +/* Get user data passed to mg_start from context. */ +CIVETWEB_API void *mg_get_user_data(const struct mg_context *ctx); + + +/* Get user defined thread pointer for server threads (see init_thread). */ +CIVETWEB_API void *mg_get_thread_pointer(const struct mg_connection *conn); + + +/* Set user data for the current connection. */ +/* Note: This function is deprecated. Use the init_connection callback + instead to initialize the user connection data pointer. It is + reccomended to supply a pointer to some user defined data structure + as conn_data initializer in init_connection. In case it is required + to change some data after the init_connection call, store another + data pointer in the user defined data structure and modify that + pointer. In either case, after the init_connection callback, only + calls to mg_get_user_connection_data should be required. */ +CIVETWEB_API void mg_set_user_connection_data(struct mg_connection *conn, + void *data); + + +/* Get user data set for the current connection. */ +CIVETWEB_API void * +mg_get_user_connection_data(const struct mg_connection *conn); + + +/* Get a formatted link corresponding to the current request + + Parameters: + conn: current connection information. + buf: string buffer (out) + buflen: length of the string buffer + Returns: + <0: error + >=0: ok */ +CIVETWEB_API int +mg_get_request_link(const struct mg_connection *conn, char *buf, size_t buflen); + + +#if defined(MG_LEGACY_INTERFACE) /* 2014-02-21 */ +/* Return array of strings that represent valid configuration options. + For each option, option name and default value is returned, i.e. the + number of entries in the array equals to number_of_options x 2. + Array is NULL terminated. */ +/* Deprecated: Use mg_get_valid_options instead. */ +CIVETWEB_API const char **mg_get_valid_option_names(void); +#endif + + +struct mg_option { + const char *name; + int type; + const char *default_value; +}; + +/* Old nomenclature */ +#if defined(MG_LEGACY_INTERFACE) /* 2017-10-05 */ +enum { + CONFIG_TYPE_UNKNOWN = 0x0, + CONFIG_TYPE_NUMBER = 0x1, + CONFIG_TYPE_STRING = 0x2, + CONFIG_TYPE_FILE = 0x3, + CONFIG_TYPE_DIRECTORY = 0x4, + CONFIG_TYPE_BOOLEAN = 0x5, + CONFIG_TYPE_EXT_PATTERN = 0x6, + CONFIG_TYPE_STRING_LIST = 0x7, + CONFIG_TYPE_STRING_MULTILINE = 0x8 +}; +#endif + +/* New nomenclature */ +enum { + MG_CONFIG_TYPE_UNKNOWN = 0x0, + MG_CONFIG_TYPE_NUMBER = 0x1, + MG_CONFIG_TYPE_STRING = 0x2, + MG_CONFIG_TYPE_FILE = 0x3, + MG_CONFIG_TYPE_DIRECTORY = 0x4, + MG_CONFIG_TYPE_BOOLEAN = 0x5, + MG_CONFIG_TYPE_EXT_PATTERN = 0x6, + MG_CONFIG_TYPE_STRING_LIST = 0x7, + MG_CONFIG_TYPE_STRING_MULTILINE = 0x8, + MG_CONFIG_TYPE_YES_NO_OPTIONAL = 0x9 +}; + +/* Return array of struct mg_option, representing all valid configuration + options of civetweb.c. + The array is terminated by a NULL name option. */ +CIVETWEB_API const struct mg_option *mg_get_valid_options(void); + + +struct mg_server_port { + int protocol; /* 1 = IPv4, 2 = IPv6, 3 = both */ + int port; /* port number */ + int is_ssl; /* https port: 0 = no, 1 = yes */ + int is_redirect; /* redirect all requests: 0 = no, 1 = yes */ + int _reserved1; + int _reserved2; + int _reserved3; + int _reserved4; +}; + +/* Legacy name */ +#define mg_server_ports mg_server_port + + +/* Get the list of ports that civetweb is listening on. + The parameter size is the size of the ports array in elements. + The caller is responsibility to allocate the required memory. + This function returns the number of struct mg_server_port elements + filled in, or <0 in case of an error. */ +CIVETWEB_API int mg_get_server_ports(const struct mg_context *ctx, + int size, + struct mg_server_port *ports); + + +#if defined(MG_LEGACY_INTERFACE) /* 2017-04-02 */ +/* Deprecated: Use mg_get_server_ports instead. */ +CIVETWEB_API size_t mg_get_ports(const struct mg_context *ctx, + size_t size, + int *ports, + int *ssl); +#endif + + +/* Add, edit or delete the entry in the passwords file. + * + * This function allows an application to manipulate .htpasswd files on the + * fly by adding, deleting and changing user records. This is one of the + * several ways of implementing authentication on the server side. For another, + * cookie-based way please refer to the examples/chat in the source tree. + * + * Parameter: + * passwords_file_name: Path and name of a file storing multiple passwords + * realm: HTTP authentication realm (authentication domain) name + * user: User name + * password: + * If password is not NULL, entry modified or added. + * If password is NULL, entry is deleted. + * + * Return: + * 1 on success, 0 on error. + */ +CIVETWEB_API int mg_modify_passwords_file(const char *passwords_file_name, + const char *realm, + const char *user, + const char *password); + + +/* Return information associated with the request. + * Use this function to implement a server and get data about a request + * from a HTTP/HTTPS client. + * Note: Before CivetWeb 1.10, this function could be used to read + * a response from a server, when implementing a client, although the + * values were never returned in appropriate mg_request_info elements. + * It is strongly advised to use mg_get_response_info for clients. + */ +CIVETWEB_API const struct mg_request_info * +mg_get_request_info(const struct mg_connection *); + + +/* Return information associated with a HTTP/HTTPS response. + * Use this function in a client, to check the response from + * the server. */ +CIVETWEB_API const struct mg_response_info * +mg_get_response_info(const struct mg_connection *); + + +/* Send data to the client. + Return: + 0 when the connection has been closed + -1 on error + >0 number of bytes written on success */ +CIVETWEB_API int mg_write(struct mg_connection *, const void *buf, size_t len); + + +/* Send data to a websocket client wrapped in a websocket frame. Uses + mg_lock_connection to ensure that the transmission is not interrupted, + i.e., when the application is proactively communicating and responding to + a request simultaneously. + + Send data to a websocket client wrapped in a websocket frame. + This function is available when civetweb is compiled with -DUSE_WEBSOCKET + + Return: + 0 when the connection has been closed + -1 on error + >0 number of bytes written on success */ +CIVETWEB_API int mg_websocket_write(struct mg_connection *conn, + int opcode, + const char *data, + size_t data_len); + + +/* Send data to a websocket server wrapped in a masked websocket frame. Uses + mg_lock_connection to ensure that the transmission is not interrupted, + i.e., when the application is proactively communicating and responding to + a request simultaneously. + + Send data to a websocket server wrapped in a masked websocket frame. + This function is available when civetweb is compiled with -DUSE_WEBSOCKET + + Return: + 0 when the connection has been closed + -1 on error + >0 number of bytes written on success */ +CIVETWEB_API int mg_websocket_client_write(struct mg_connection *conn, + int opcode, + const char *data, + size_t data_len); + + +/* Blocks until unique access is obtained to this connection. Intended for use + with websockets only. + Invoke this before mg_write or mg_printf when communicating with a + websocket if your code has server-initiated communication as well as + communication in direct response to a message. */ +CIVETWEB_API void mg_lock_connection(struct mg_connection *conn); +CIVETWEB_API void mg_unlock_connection(struct mg_connection *conn); + + +#if defined(MG_LEGACY_INTERFACE) /* 2014-06-21 */ +#define mg_lock mg_lock_connection +#define mg_unlock mg_unlock_connection +#endif + + +/* Lock server context. This lock may be used to protect resources + that are shared between different connection/worker threads. */ +CIVETWEB_API void mg_lock_context(struct mg_context *ctx); +CIVETWEB_API void mg_unlock_context(struct mg_context *ctx); + + +/* Opcodes, from http://tools.ietf.org/html/rfc6455 */ +#if defined(MG_LEGACY_INTERFACE) /* 2017-10-05 */ +enum { + WEBSOCKET_OPCODE_CONTINUATION = 0x0, + WEBSOCKET_OPCODE_TEXT = 0x1, + WEBSOCKET_OPCODE_BINARY = 0x2, + WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8, + WEBSOCKET_OPCODE_PING = 0x9, + WEBSOCKET_OPCODE_PONG = 0xa +}; +#endif + +/* New nomenclature */ +enum { + MG_WEBSOCKET_OPCODE_CONTINUATION = 0x0, + MG_WEBSOCKET_OPCODE_TEXT = 0x1, + MG_WEBSOCKET_OPCODE_BINARY = 0x2, + MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8, + MG_WEBSOCKET_OPCODE_PING = 0x9, + MG_WEBSOCKET_OPCODE_PONG = 0xa +}; + +/* Macros for enabling compiler-specific checks for printf-like arguments. */ +#undef PRINTF_FORMAT_STRING +#if defined(_MSC_VER) && _MSC_VER >= 1400 +#include +#if defined(_MSC_VER) && _MSC_VER > 1400 +#define PRINTF_FORMAT_STRING(s) _Printf_format_string_ s +#else +#define PRINTF_FORMAT_STRING(s) __format_string s +#endif +#else +#define PRINTF_FORMAT_STRING(s) s +#endif + +#ifdef __GNUC__ +#define PRINTF_ARGS(x, y) __attribute__((format(printf, x, y))) +#else +#define PRINTF_ARGS(x, y) +#endif + + +/* Send data to the client using printf() semantics. + Works exactly like mg_write(), but allows to do message formatting. */ +CIVETWEB_API int mg_printf(struct mg_connection *, + PRINTF_FORMAT_STRING(const char *fmt), + ...) PRINTF_ARGS(2, 3); + + +/* Send a part of the message body, if chunked transfer encoding is set. + * Only use this function after sending a complete HTTP request or response + * header with "Transfer-Encoding: chunked" set. */ +CIVETWEB_API int mg_send_chunk(struct mg_connection *conn, + const char *chunk, + unsigned int chunk_len); + + +/* Send contents of the entire file together with HTTP headers. + * Parameters: + * conn: Current connection information. + * path: Full path to the file to send. + * This function has been superseded by mg_send_mime_file + */ +CIVETWEB_API void mg_send_file(struct mg_connection *conn, const char *path); + + +/* Send contents of the file without HTTP headers. + * The code must send a valid HTTP response header before using this function. + * + * Parameters: + * conn: Current connection information. + * path: Full path to the file to send. + * + * Return: + * < 0 Error + */ +CIVETWEB_API int mg_send_file_body(struct mg_connection *conn, + const char *path); + + +/* Send HTTP error reply. */ +CIVETWEB_API int mg_send_http_error(struct mg_connection *conn, + int status_code, + PRINTF_FORMAT_STRING(const char *fmt), + ...) PRINTF_ARGS(3, 4); + + +/* Send "HTTP 200 OK" response header. + * After calling this function, use mg_write or mg_send_chunk to send the + * response body. + * Parameters: + * conn: Current connection handle. + * mime_type: Set Content-Type for the following content. + * content_length: Size of the following content, if content_length >= 0. + * Will set transfer-encoding to chunked, if set to -1. + * Return: + * < 0 Error + */ +CIVETWEB_API int mg_send_http_ok(struct mg_connection *conn, + const char *mime_type, + long long content_length); + + +/* Send "HTTP 30x" redirect response. + * The response has content-size zero: do not send any body data after calling + * this function. + * Parameters: + * conn: Current connection handle. + * target_url: New location. + * redirect_code: HTTP redirect type. Could be 301, 302, 303, 307, 308. + * Return: + * < 0 Error (-1 send error, -2 parameter error) + */ +CIVETWEB_API int mg_send_http_redirect(struct mg_connection *conn, + const char *target_url, + int redirect_code); + + +/* Send HTTP digest access authentication request. + * Browsers will send a user name and password in their next request, showing + * an authentication dialog if the password is not stored. + * Parameters: + * conn: Current connection handle. + * realm: Authentication realm. If NULL is supplied, the sever domain + * set in the authentication_domain configuration is used. + * Return: + * < 0 Error + */ +CIVETWEB_API int +mg_send_digest_access_authentication_request(struct mg_connection *conn, + const char *realm); + + +/* Check if the current request has a valid authentication token set. + * A file is used to provide a list of valid user names, realms and + * password hashes. The file can be created and modified using the + * mg_modify_passwords_file API function. + * Parameters: + * conn: Current connection handle. + * realm: Authentication realm. If NULL is supplied, the sever domain + * set in the authentication_domain configuration is used. + * filename: Path and name of a file storing multiple password hashes. + * Return: + * > 0 Valid authentication + * 0 Invalid authentication + * < 0 Error (all values < 0 should be considered as invalid + * authentication, future error codes will have negative + * numbers) + * -1 Parameter error + * -2 File not found + */ +CIVETWEB_API int +mg_check_digest_access_authentication(struct mg_connection *conn, + const char *realm, + const char *filename); + + +/* Send contents of the entire file together with HTTP headers. + * Parameters: + * conn: Current connection handle. + * path: Full path to the file to send. + * mime_type: Content-Type for file. NULL will cause the type to be + * looked up by the file extension. + */ +CIVETWEB_API void mg_send_mime_file(struct mg_connection *conn, + const char *path, + const char *mime_type); + + +/* Send contents of the entire file together with HTTP headers. + Parameters: + conn: Current connection information. + path: Full path to the file to send. + mime_type: Content-Type for file. NULL will cause the type to be + looked up by the file extension. + additional_headers: Additional custom header fields appended to the header. + Each header should start with an X-, to ensure it is + not included twice. + NULL does not append anything. +*/ +CIVETWEB_API void mg_send_mime_file2(struct mg_connection *conn, + const char *path, + const char *mime_type, + const char *additional_headers); + + +/* Store body data into a file. */ +CIVETWEB_API long long mg_store_body(struct mg_connection *conn, + const char *path); +/* Read entire request body and store it in a file "path". + Return: + < 0 Error + >= 0 Number of bytes stored in file "path". +*/ + + +/* Read data from the remote end, return number of bytes read. + Return: + 0 connection has been closed by peer. No more data could be read. + < 0 read error. No more data could be read from the connection. + > 0 number of bytes read into the buffer. */ +CIVETWEB_API int mg_read(struct mg_connection *, void *buf, size_t len); + + +/* Get the value of particular HTTP header. + + This is a helper function. It traverses request_info->http_headers array, + and if the header is present in the array, returns its value. If it is + not present, NULL is returned. */ +CIVETWEB_API const char *mg_get_header(const struct mg_connection *, + const char *name); + + +/* Get a value of particular form variable. + + Parameters: + data: pointer to form-uri-encoded buffer. This could be either POST data, + or request_info.query_string. + data_len: length of the encoded data. + var_name: variable name to decode from the buffer + dst: destination buffer for the decoded variable + dst_len: length of the destination buffer + + Return: + On success, length of the decoded variable. + On error: + -1 (variable not found). + -2 (destination buffer is NULL, zero length or too small to hold the + decoded variable). + + Destination buffer is guaranteed to be '\0' - terminated if it is not + NULL or zero length. */ +CIVETWEB_API int mg_get_var(const char *data, + size_t data_len, + const char *var_name, + char *dst, + size_t dst_len); + + +/* Get a value of particular form variable. + + Parameters: + data: pointer to form-uri-encoded buffer. This could be either POST data, + or request_info.query_string. + data_len: length of the encoded data. + var_name: variable name to decode from the buffer + dst: destination buffer for the decoded variable + dst_len: length of the destination buffer + occurrence: which occurrence of the variable, 0 is the first, 1 the + second... + this makes it possible to parse a query like + b=x&a=y&a=z which will have occurrence values b:0, a:0 and a:1 + + Return: + On success, length of the decoded variable. + On error: + -1 (variable not found). + -2 (destination buffer is NULL, zero length or too small to hold the + decoded variable). + + Destination buffer is guaranteed to be '\0' - terminated if it is not + NULL or zero length. */ +CIVETWEB_API int mg_get_var2(const char *data, + size_t data_len, + const char *var_name, + char *dst, + size_t dst_len, + size_t occurrence); + + +/* Fetch value of certain cookie variable into the destination buffer. + + Destination buffer is guaranteed to be '\0' - terminated. In case of + failure, dst[0] == '\0'. Note that RFC allows many occurrences of the same + parameter. This function returns only first occurrence. + + Return: + On success, value length. + On error: + -1 (either "Cookie:" header is not present at all or the requested + parameter is not found). + -2 (destination buffer is NULL, zero length or too small to hold the + value). */ +CIVETWEB_API int mg_get_cookie(const char *cookie, + const char *var_name, + char *buf, + size_t buf_len); + + +/* Download data from the remote web server. + host: host name to connect to, e.g. "foo.com", or "10.12.40.1". + port: port number, e.g. 80. + use_ssl: whether to use SSL connection. + error_buffer, error_buffer_size: error message placeholder. + request_fmt,...: HTTP request. + Return: + On success, valid pointer to the new connection, suitable for mg_read(). + On error, NULL. error_buffer contains error message. + Example: + char ebuf[100]; + struct mg_connection *conn; + conn = mg_download("google.com", 80, 0, ebuf, sizeof(ebuf), + "%s", "GET / HTTP/1.0\r\nHost: google.com\r\n\r\n"); + */ +CIVETWEB_API struct mg_connection * +mg_download(const char *host, + int port, + int use_ssl, + char *error_buffer, + size_t error_buffer_size, + PRINTF_FORMAT_STRING(const char *request_fmt), + ...) PRINTF_ARGS(6, 7); + + +/* Close the connection opened by mg_download(). */ +CIVETWEB_API void mg_close_connection(struct mg_connection *conn); + + +#if defined(MG_LEGACY_INTERFACE) /* 2016-05-14 */ +/* File upload functionality. Each uploaded file gets saved into a temporary + file and MG_UPLOAD event is sent. + Return number of uploaded files. + Deprecated: Use mg_handle_form_request instead. */ +CIVETWEB_API int mg_upload(struct mg_connection *conn, + const char *destination_dir); +#endif + + +/* This structure contains callback functions for handling form fields. + It is used as an argument to mg_handle_form_request. */ +struct mg_form_data_handler { + /* This callback function is called, if a new field has been found. + * The return value of this callback is used to define how the field + * should be processed. + * + * Parameters: + * key: Name of the field ("name" property of the HTML input field). + * filename: Name of a file to upload, at the client computer. + * Only set for input fields of type "file", otherwise NULL. + * path: Output parameter: File name (incl. path) to store the file + * at the server computer. Only used if FORM_FIELD_STORAGE_STORE + * is returned by this callback. Existing files will be + * overwritten. + * pathlen: Length of the buffer for path. + * user_data: Value of the member user_data of mg_form_data_handler + * + * Return value: + * The callback must return the intended storage for this field + * (See FORM_FIELD_STORAGE_*). + */ + int (*field_found)(const char *key, + const char *filename, + char *path, + size_t pathlen, + void *user_data); + + /* If the "field_found" callback returned FORM_FIELD_STORAGE_GET, + * this callback will receive the field data. + * + * Parameters: + * key: Name of the field ("name" property of the HTML input field). + * value: Value of the input field. + * user_data: Value of the member user_data of mg_form_data_handler + * + * Return value: + * The return code determines how the server should continue processing + * the current request (See MG_FORM_FIELD_HANDLE_*). + */ + int (*field_get)(const char *key, + const char *value, + size_t valuelen, + void *user_data); + + /* If the "field_found" callback returned FORM_FIELD_STORAGE_STORE, + * the data will be stored into a file. If the file has been written + * successfully, this callback will be called. This callback will + * not be called for only partially uploaded files. The + * mg_handle_form_request function will either store the file completely + * and call this callback, or it will remove any partial content and + * not call this callback function. + * + * Parameters: + * path: Path of the file stored at the server. + * file_size: Size of the stored file in bytes. + * user_data: Value of the member user_data of mg_form_data_handler + * + * Return value: + * The return code determines how the server should continue processing + * the current request (See MG_FORM_FIELD_HANDLE_*). + */ + int (*field_store)(const char *path, long long file_size, void *user_data); + + /* User supplied argument, passed to all callback functions. */ + void *user_data; +}; + + +/* Return values definition for the "field_found" callback in + * mg_form_data_handler. */ +#if defined(MG_LEGACY_INTERFACE) /* 2017-10-05 */ +enum { + /* Skip this field (neither get nor store it). Continue with the + * next field. */ + FORM_FIELD_STORAGE_SKIP = 0x0, + /* Get the field value. */ + FORM_FIELD_STORAGE_GET = 0x1, + /* Store the field value into a file. */ + FORM_FIELD_STORAGE_STORE = 0x2, + /* Stop parsing this request. Skip the remaining fields. */ + FORM_FIELD_STORAGE_ABORT = 0x10 +}; +#endif +/* New nomenclature */ +enum { + /* Skip this field (neither get nor store it). Continue with the + * next field. */ + MG_FORM_FIELD_STORAGE_SKIP = 0x0, + /* Get the field value. */ + MG_FORM_FIELD_STORAGE_GET = 0x1, + /* Store the field value into a file. */ + MG_FORM_FIELD_STORAGE_STORE = 0x2, + /* Stop parsing this request. Skip the remaining fields. */ + MG_FORM_FIELD_STORAGE_ABORT = 0x10 +}; + +/* Return values for "field_get" and "field_store" */ +enum { + /* Only "field_get": If there is more data in this field, get the next + * chunk. Otherwise: handle the next field. */ + MG_FORM_FIELD_HANDLE_GET = 0x1, + /* Handle the next field */ + MG_FORM_FIELD_HANDLE_NEXT = 0x8, + /* Stop parsing this request */ + MG_FORM_FIELD_HANDLE_ABORT = 0x10 +}; + + +/* Process form data. + * Returns the number of fields handled, or < 0 in case of an error. + * Note: It is possible that several fields are already handled successfully + * (e.g., stored into files), before the request handling is stopped with an + * error. In this case a number < 0 is returned as well. + * In any case, it is the duty of the caller to remove files once they are + * no longer required. */ +CIVETWEB_API int mg_handle_form_request(struct mg_connection *conn, + struct mg_form_data_handler *fdh); + + +/* Convenience function -- create detached thread. + Return: 0 on success, non-0 on error. */ +typedef void *(*mg_thread_func_t)(void *); +CIVETWEB_API int mg_start_thread(mg_thread_func_t f, void *p); + + +/* Return builtin mime type for the given file name. + For unrecognized extensions, "text/plain" is returned. */ +CIVETWEB_API const char *mg_get_builtin_mime_type(const char *file_name); + + +/* Get text representation of HTTP status code. */ +CIVETWEB_API const char * +mg_get_response_code_text(const struct mg_connection *conn, int response_code); + + +/* Return CivetWeb version. */ +CIVETWEB_API const char *mg_version(void); + + +/* URL-decode input buffer into destination buffer. + 0-terminate the destination buffer. + form-url-encoded data differs from URI encoding in a way that it + uses '+' as character for space, see RFC 1866 section 8.2.1 + http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt + Return: length of the decoded data, or -1 if dst buffer is too small. */ +CIVETWEB_API int mg_url_decode(const char *src, + int src_len, + char *dst, + int dst_len, + int is_form_url_encoded); + + +/* URL-encode input buffer into destination buffer. + returns the length of the resulting buffer or -1 + is the buffer is too small. */ +CIVETWEB_API int mg_url_encode(const char *src, char *dst, size_t dst_len); + + +/* MD5 hash given strings. + Buffer 'buf' must be 33 bytes long. Varargs is a NULL terminated list of + ASCIIz strings. When function returns, buf will contain human-readable + MD5 hash. Example: + char buf[33]; + mg_md5(buf, "aa", "bb", NULL); */ +CIVETWEB_API char *mg_md5(char buf[33], ...); + + +/* Print error message to the opened error log stream. + This utilizes the provided logging configuration. + conn: connection (not used for sending data, but to get perameters) + fmt: format string without the line return + ...: variable argument list + Example: + mg_cry(conn,"i like %s", "logging"); */ +CIVETWEB_API void mg_cry(const struct mg_connection *conn, + PRINTF_FORMAT_STRING(const char *fmt), + ...) PRINTF_ARGS(2, 3); + + +/* utility methods to compare two buffers, case insensitive. */ +CIVETWEB_API int mg_strcasecmp(const char *s1, const char *s2); +CIVETWEB_API int mg_strncasecmp(const char *s1, const char *s2, size_t len); + + +/* Connect to a websocket as a client + Parameters: + host: host to connect to, i.e. "echo.websocket.org" or "192.168.1.1" or + "localhost" + port: server port + use_ssl: make a secure connection to server + error_buffer, error_buffer_size: buffer for an error message + path: server path you are trying to connect to, i.e. if connection to + localhost/app, path should be "/app" + origin: value of the Origin HTTP header + data_func: callback that should be used when data is received from the + server + user_data: user supplied argument + + Return: + On success, valid mg_connection object. + On error, NULL. Se error_buffer for details. +*/ +CIVETWEB_API struct mg_connection * +mg_connect_websocket_client(const char *host, + int port, + int use_ssl, + char *error_buffer, + size_t error_buffer_size, + const char *path, + const char *origin, + mg_websocket_data_handler data_func, + mg_websocket_close_handler close_func, + void *user_data); + + +/* Connect to a TCP server as a client (can be used to connect to a HTTP server) + Parameters: + host: host to connect to, i.e. "www.wikipedia.org" or "192.168.1.1" or + "localhost" + port: server port + use_ssl: make a secure connection to server + error_buffer, error_buffer_size: buffer for an error message + + Return: + On success, valid mg_connection object. + On error, NULL. Se error_buffer for details. +*/ +CIVETWEB_API struct mg_connection *mg_connect_client(const char *host, + int port, + int use_ssl, + char *error_buffer, + size_t error_buffer_size); + + +struct mg_client_options { + const char *host; + int port; + const char *client_cert; + const char *server_cert; + const char *host_name; + /* TODO: add more data */ +}; + + +CIVETWEB_API struct mg_connection * +mg_connect_client_secure(const struct mg_client_options *client_options, + char *error_buffer, + size_t error_buffer_size); + + +enum { TIMEOUT_INFINITE = -1 }; +enum { MG_TIMEOUT_INFINITE = -1 }; + +/* Wait for a response from the server + Parameters: + conn: connection + ebuf, ebuf_len: error message placeholder. + timeout: time to wait for a response in milliseconds (if < 0 then wait + forever) + + Return: + On success, >= 0 + On error/timeout, < 0 +*/ +CIVETWEB_API int mg_get_response(struct mg_connection *conn, + char *ebuf, + size_t ebuf_len, + int timeout); + + +/* Check which features where set when the civetweb library has been compiled. + The function explicitly addresses compile time defines used when building + the library - it does not mean, the feature has been initialized using a + mg_init_library call. + mg_check_feature can be called anytime, even before mg_init_library has + been called. + + Parameters: + feature: specifies which feature should be checked + The value is a bit mask. The individual bits are defined as: + 1 serve files (NO_FILES not set) + 2 support HTTPS (NO_SSL not set) + 4 support CGI (NO_CGI not set) + 8 support IPv6 (USE_IPV6 set) + 16 support WebSocket (USE_WEBSOCKET set) + 32 support Lua scripts and Lua server pages (USE_LUA is set) + 64 support server side JavaScript (USE_DUKTAPE is set) + 128 support caching (NO_CACHING not set) + 256 support server statistics (USE_SERVER_STATS is set) + The result is undefined, if bits are set that do not represent a + defined feature (currently: feature >= 512). + The result is undefined, if no bit is set (feature == 0). + + Return: + If feature is available, the corresponding bit is set + If feature is not available, the bit is 0 +*/ +CIVETWEB_API unsigned mg_check_feature(unsigned feature); + + +/* Get information on the system. Useful for support requests. + Parameters: + buffer: Store system information as string here. + buflen: Length of buffer (including a byte required for a terminating 0). + Return: + Available size of system information, exluding a terminating 0. + The information is complete, if the return value is smaller than buflen. + The result is a JSON formatted string, the exact content may vary. + Note: + It is possible to determine the required buflen, by first calling this + function with buffer = NULL and buflen = NULL. The required buflen is + one byte more than the returned value. +*/ +CIVETWEB_API int mg_get_system_info(char *buffer, int buflen); + + +/* Get context information. Useful for server diagnosis. + Parameters: + ctx: Context handle + buffer: Store context information here. + buflen: Length of buffer (including a byte required for a terminating 0). + Return: + Available size of system information, exluding a terminating 0. + The information is complete, if the return value is smaller than buflen. + The result is a JSON formatted string, the exact content may vary. + Note: + It is possible to determine the required buflen, by first calling this + function with buffer = NULL and buflen = NULL. The required buflen is + one byte more than the returned value. However, since the available + context information changes, you should allocate a few bytes more. +*/ +CIVETWEB_API int +mg_get_context_info(const struct mg_context *ctx, char *buffer, int buflen); + + +#ifdef MG_EXPERIMENTAL_INTERFACES +/* Get connection information. Useful for server diagnosis. + Parameters: + ctx: Context handle + idx: Connection index + buffer: Store context information here. + buflen: Length of buffer (including a byte required for a terminating 0). + Return: + Available size of system information, exluding a terminating 0. + The information is complete, if the return value is smaller than buflen. + The result is a JSON formatted string, the exact content may vary. + Note: + It is possible to determine the required buflen, by first calling this + function with buffer = NULL and buflen = NULL. The required buflen is + one byte more than the returned value. However, since the available + context information changes, you should allocate a few bytes more. +*/ +CIVETWEB_API int mg_get_connection_info(const struct mg_context *ctx, + int idx, + char *buffer, + int buflen); +#endif + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* CIVETWEB_HEADER_INCLUDED */ + +#define INIT_REQUEST_COUNT (8) + +/* Server data allocated on heap (not in ECS). This ensures the pointer is + * stable and cannot change due to data moving around. */ +typedef struct CivetServerData { + struct mg_context *server; + + /* Port number of server */ + int16_t port; + + /* Cache endpoints defined in ECS, so we won't need to access the ECS system + * when receiving a request, which would not be thread safe as civetweb does + * not provide the option to manually control threading. */ + ecs_vector_t *endpoints; + ecs_vector_t *endpoint_entities; + + /* Number of requests waiting */ + int requests_waiting; + + /* Access to ECS world */ + ecs_world_t *world; +} CivetServerData; + +/* ECS server component only contains a pointer to the heap structure */ +typedef struct EcsCivetServer { + CivetServerData *server_data; +} EcsCivetServer; + +typedef struct EndpointEvalCtx { + EcsHttpRequest request; + CivetServerData *server_data; +} EndpointEvalCtx; + +static +EcsHttpMethod method_from_str( + const char *method) +{ + if (!strcmp(method, "GET")) return EcsHttpGet; + else if (!strcmp(method, "POST")) return EcsHttpPost; + else if (!strcmp(method, "PUT")) return EcsHttpPut; + else if (!strcmp(method, "DELETE")) return EcsHttpDelete; + else return EcsHttpMethodUnknown; +} + +static +int CbLogMessage( + const struct mg_connection *conn, + const char *msg) +{ + printf("civetweb: %s\n", (char*)msg); + return 1; +} + +static +int CbWsConnect( + const struct mg_connection *conn, + void *cbdata) +{ + return 1; +} + +static +void CbWsReady( + struct mg_connection *conn, + void *cbdata) +{ +} + +static +int CbWsData( + struct mg_connection *conn, + int bits, + char *data, + size_t len, + void *cbdata) +{ + return 1; +} + +static +void CbWsClose( + const struct mg_connection *conn, + void *cbdata) +{ +} + +static +void do_reply( + struct mg_connection *conn, + uint16_t status, + char *header, + char *body) +{ + ecs_strbuf_t buf = ECS_STRBUF_INIT; + ecs_strbuf_append(&buf, "HTTP/1.1 %d OK\r\nAccess-Control-Allow-Origin: *\r\n", status); + if (header) { + ecs_strbuf_appendstr_zerocpy(&buf, header); + } + ecs_strbuf_appendstr(&buf, "\r\n"); + if (body) ecs_strbuf_appendstr_zerocpy(&buf, body); + char *msg = ecs_strbuf_get(&buf); + mg_write(conn, msg, strlen(msg)); + free(msg); +} + +static +bool eval_endpoints(EndpointEvalCtx *ctx) { + EcsHttpReply reply = {.status = 200}; + EcsHttpRequest *request = &ctx->request; + CivetServerData *server_data = ctx->server_data; + struct mg_connection *conn = request->ctx; + const char *r_url = request->url; + bool handled = false; + if (r_url[0] == '/') r_url ++; + + EcsHttpEndpoint *buffer = ecs_vector_first(server_data->endpoints, EcsHttpEndpoint); + ecs_entity_t *entity_buffer = ecs_vector_first(server_data->endpoint_entities, ecs_entity_t); + uint32_t i, count = ecs_vector_count(server_data->endpoints); + + for (i = 0; i < count; i ++) { + EcsHttpEndpoint *endpoint = &buffer[i]; + char *e_url = endpoint->url; + if (e_url[0] == '/') e_url ++; + uint32_t e_url_len = strlen(e_url); + + if (!strncmp(e_url, r_url, e_url_len)) { + const char *orig_r_url = r_url; + r_url = r_url + e_url_len; + + if (!r_url[0] || r_url[0] == '/' || r_url == orig_r_url) { + ecs_entity_t entity = entity_buffer[i]; + ecs_world_t *world = server_data->world; + if (r_url[0]) { + if (r_url != orig_r_url) { + request->relative_url = r_url + 1; + } else { + request->relative_url = r_url; + } + } else { + request->relative_url = ""; + } + + ecs_trace_2("civet: 201: endpoint '/%s' matched", e_url); + + handled = endpoint->action(world, entity, endpoint, request, &reply); + + if (handled) { + if (reply.is_file) { + mg_send_file(conn, reply.body); + } else { + do_reply(conn, reply.status, reply.header, reply.body); + } + break; + } + } else { + continue; + } + } + } + + return handled; +} + +static +int CbOnRequest( + struct mg_connection *conn, + void *cbdata) +{ + const struct mg_request_info *req_info = mg_get_request_info(conn); + EcsHttpMethod method = method_from_str(req_info->request_method); + CivetServerData *server_data = cbdata; + + EndpointEvalCtx eval_ctx = { + .request = { + .method = method, + .url = req_info->local_uri, + .params = req_info->query_string, + .ctx = conn + }, + .server_data = server_data + }; + + ecs_trace_2("civet: %s: uri=%s query=%s", + req_info->request_method, req_info->local_uri, req_info->query_string); + + /* Evaluate request for all endpoints for this server */ + ecs_begin_wait(server_data->world); + ecs_lock(server_data->world); + ecs_end_wait(server_data->world); + + bool handled = eval_endpoints(&eval_ctx); + ecs_unlock(server_data->world); + + if (!handled) { + do_reply(conn, 404, NULL, NULL); + ecs_trace_2("civet: 404: no endpoint found"); + } + + return 1; +} + +static +void CivetDeinit(ecs_iter_t *it) { + EcsCivetServer *c = ecs_column(it, EcsCivetServer, 1); + + int i; + for (i = 0; i < it->count; i ++) { + CivetServerData *data = c[i].server_data; + mg_stop(data->server); + ecs_os_free(data); + } +} + +static +void CivetSet(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + EcsHttpServer *server = ecs_column(it, EcsHttpServer, 1); + EcsCivetServer *civet_server = ecs_column(it, EcsCivetServer, 2); + ecs_entity_t ecs_typeid(EcsCivetServer) = ecs_column_entity(it, 2); + + int i; + for (i = 0; i < it->count; i ++) { + /* If this server already exists, check if it uses the same port. If not + * it must be recreated. */ + if (civet_server) { + CivetServerData *data = civet_server[i].server_data; + if (data->port == server[i].port) { + /* Ports are the same, no changes needed */ + continue; + } else { + /* Ports are not the same, need to recreate server */ + mg_stop(data->server); + ecs_os_free(data); + } + } + + char port[15]; + sprintf(port, "%u", server[i].port); + + const char *options[] = { + "document_root", ".", + "listening_ports", port, + "request_timeout_ms", "10000", + "error_log_file", "error.log", + "enable_auth_domain_check", "no", +#if defined(__linux__) + "allow_sendfile_call", "true", +#endif + NULL}; + + if (!mg_check_feature(8)) { + /* IPv6 not supported */ + } + + if (!mg_check_feature(16)) { + /* Websockets not supported */ + } + + if (!mg_check_feature(2)) { + /* SSL not supported */ + } + + /* Start CivetWeb web server */ + struct mg_callbacks callbacks; + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.log_message = CbLogMessage; + + /* Add server object to entity */ + CivetServerData *server_data = ecs_os_malloc(sizeof(CivetServerData)); + ecs_assert(server_data != NULL, ECS_OUT_OF_MEMORY, NULL); + + ecs_trace_1("civet: starting server on port %u", server[i].port); + + server_data->world = world; + server_data->server = mg_start(&callbacks, server_data, options); + server_data->endpoints = ecs_vector_new(EcsHttpEndpoint, 0); + server_data->endpoint_entities = ecs_vector_new(ecs_entity_t, 0); + server_data->requests_waiting = 0; + server_data->port = server[i].port; + + /* Add component with Civetweb data */ + ecs_set(world, it->entities[i], EcsCivetServer, { + .server_data = server_data + }); + + /* Set handler for requests */ + mg_set_request_handler(server_data->server, "**", CbOnRequest, server_data); + + /* Set websocket handlers */ + mg_set_websocket_handler( + server_data->server, "/", CbWsConnect, CbWsReady, CbWsData, + CbWsClose, server_data); + } +} + +static +void CivetUnset(ecs_iter_t *it) { + EcsCivetServer *civet_server = ecs_column(it, EcsCivetServer, 1); + + int32_t i; + for (i = 0; i < it->count; i ++) { + CivetServerData *data = civet_server[i].server_data; + mg_stop(data->server); + ecs_vector_free(data->endpoints); + ecs_vector_free(data->endpoint_entities); + ecs_os_free(data); + } +} + +static +ecs_entity_t find_server( + ecs_world_t *world, + ecs_entity_t ep, + ecs_entity_t server) +{ + ecs_type_t type = ecs_get_type(world, ep); + ecs_entity_t *array = ecs_vector_first(type, ecs_entity_t); + uint32_t i, count = ecs_vector_count(type); + + for (i = 0; i < count; i ++) { + ecs_entity_t e = array[i]; + if (e & ECS_CHILDOF) { + if (ecs_has_entity(world, e & ECS_COMPONENT_MASK, server)) { + return e & ECS_COMPONENT_MASK; + } + } + } + + return 0; +} + +static +void CivetRegisterEndpoint(ecs_iter_t *it) { + EcsHttpEndpoint *ep = ecs_column(it, EcsHttpEndpoint, 1); + ecs_entity_t server_component_handle = ecs_column_entity(it, 2); + + int i; + for (i = 0; i < it->count; i ++) { + ecs_entity_t entity = it->entities[i]; + + ecs_entity_t server = find_server(it->world, entity, server_component_handle); + if (server) { + const EcsCivetServer *c = ecs_get_w_entity( + it->world, server, server_component_handle); + + CivetServerData *data = c->server_data; + + EcsHttpEndpoint *new_ep = ecs_vector_add(&data->endpoints, EcsHttpEndpoint); + *new_ep = ep[i]; + ecs_entity_t *new_entity = ecs_vector_add(&data->endpoint_entities, ecs_entity_t); + *new_entity = entity; + } else { + ecs_os_warn("no server found for endpoint '%s'", ep->url); + } + } +} + +void FlecsSystemsCivetwebImport( + ecs_world_t *world) +{ + ECS_IMPORT(world, FlecsComponentsHttp); + + ecs_set_name_prefix(world, "EcsCivet"); + + ECS_MODULE(world, FlecsSystemsCivetweb); + + ECS_COMPONENT(world, EcsCivetServer); + + ECS_SYSTEM(world, CivetSet, EcsOnSet, + flecs.components.http.Server, + ?Server, + SYSTEM:Hidden); + + ECS_SYSTEM(world, CivetUnset, EcsUnSet, + Server, + SYSTEM:Hidden); + + ECS_SYSTEM(world, CivetRegisterEndpoint, EcsOnSet, + flecs.components.http.Endpoint, + :Server, + SYSTEM:Hidden); + + ECS_TRIGGER(world, CivetDeinit, EcsOnRemove, Server); + + ecs_enable_locking(world, true); +} +/* Copyright (c) 2013-2018 the Civetweb developers + * Copyright (c) 2004-2013 Sergey Lyubka + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#if defined(__GNUC__) || defined(__MINGW32__) +#define GCC_VERSION \ + (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) +#if GCC_VERSION >= 40500 +/* gcc diagnostic pragmas available */ +#define GCC_DIAGNOSTIC +#endif +#endif + +#if defined(GCC_DIAGNOSTIC) +/* Disable unused macros warnings - not all defines are required + * for all systems and all compilers. */ +#pragma GCC diagnostic ignored "-Wunused-macros" +/* A padding warning is just plain useless */ +#pragma GCC diagnostic ignored "-Wpadded" +#endif + +#if defined(__clang__) /* GCC does not (yet) support this pragma */ +/* We must set some flags for the headers we include. These flags + * are reserved ids according to C99, so we need to disable a + * warning for that. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wreserved-id-macro" +#endif + +#if defined(_WIN32) +#if !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS /* Disable deprecation warning in VS2005 */ +#endif +#if !defined(_WIN32_WINNT) /* defined for tdm-gcc so we can use getnameinfo */ +#define _WIN32_WINNT 0x0501 +#endif +#else +#if !defined(_GNU_SOURCE) +#define _GNU_SOURCE /* for setgroups(), pthread_setname_np() */ +#endif +#if defined(__linux__) && !defined(_XOPEN_SOURCE) +#define _XOPEN_SOURCE 600 /* For flockfile() on Linux */ +#endif +#if defined(__LSB_VERSION__) +#define NEED_TIMEGM +#define NO_THREAD_NAME +#endif +#if !defined(_LARGEFILE_SOURCE) +#define _LARGEFILE_SOURCE /* For fseeko(), ftello() */ +#endif +#if !defined(_FILE_OFFSET_BITS) +#define _FILE_OFFSET_BITS 64 /* Use 64-bit file offsets by default */ +#endif +#if !defined(__STDC_FORMAT_MACROS) +#define __STDC_FORMAT_MACROS /* wants this for C++ */ +#endif +#if !defined(__STDC_LIMIT_MACROS) +#define __STDC_LIMIT_MACROS /* C++ wants that for INT64_MAX */ +#endif +#if !defined(_DARWIN_UNLIMITED_SELECT) +#define _DARWIN_UNLIMITED_SELECT +#endif +#if defined(__sun) +#define __EXTENSIONS__ /* to expose flockfile and friends in stdio.h */ +#define __inline inline /* not recognized on older compiler versions */ +#endif +#endif + +#if defined(__clang__) +/* Enable reserved-id-macro warning again. */ +#pragma GCC diagnostic pop +#endif + + +#if defined(USE_LUA) +#define USE_TIMERS +#endif + +#if defined(_MSC_VER) +/* 'type cast' : conversion from 'int' to 'HANDLE' of greater size */ +#pragma warning(disable : 4306) +/* conditional expression is constant: introduced by FD_SET(..) */ +#pragma warning(disable : 4127) +/* non-constant aggregate initializer: issued due to missing C99 support */ +#pragma warning(disable : 4204) +/* padding added after data member */ +#pragma warning(disable : 4820) +/* not defined as a preprocessor macro, replacing with '0' for '#if/#elif' */ +#pragma warning(disable : 4668) +/* no function prototype given: converting '()' to '(void)' */ +#pragma warning(disable : 4255) +/* function has been selected for automatic inline expansion */ +#pragma warning(disable : 4711) +#endif + + +/* This code uses static_assert to check some conditions. + * Unfortunately some compilers still do not support it, so we have a + * replacement function here. */ +#if defined(__STDC_VERSION__) && __STDC_VERSION__ > 201100L +#define mg_static_assert _Static_assert +#elif defined(__cplusplus) && __cplusplus >= 201103L +#define mg_static_assert static_assert +#else +char static_assert_replacement[1]; +#define mg_static_assert(cond, txt) \ + extern char static_assert_replacement[(cond) ? 1 : -1] +#endif + +mg_static_assert(sizeof(int) == 4 || sizeof(int) == 8, + "int data type size check"); +mg_static_assert(sizeof(void *) == 4 || sizeof(void *) == 8, + "pointer data type size check"); +mg_static_assert(sizeof(void *) >= sizeof(int), "data type size check"); + + +/* Alternative queue is well tested and should be the new default */ +#if defined(NO_ALTERNATIVE_QUEUE) +#if defined(ALTERNATIVE_QUEUE) +#error "Define ALTERNATIVE_QUEUE or NO_ALTERNATIVE_QUEUE or none, but not both" +#endif +#else +#define ALTERNATIVE_QUEUE +#endif + + +/* DTL -- including winsock2.h works better if lean and mean */ +#if !defined(WIN32_LEAN_AND_MEAN) +#define WIN32_LEAN_AND_MEAN +#endif + +#if defined(__SYMBIAN32__) +/* According to https://en.wikipedia.org/wiki/Symbian#History, + * Symbian is no longer maintained since 2014-01-01. + * Recent versions of CivetWeb are no longer tested for Symbian. + * It makes no sense, to support an abandoned operating system. + */ +#error "Symbian is no longer maintained. CivetWeb no longer supports Symbian." +#define NO_SSL /* SSL is not supported */ +#define NO_CGI /* CGI is not supported */ +#define PATH_MAX FILENAME_MAX +#endif /* __SYMBIAN32__ */ + + +#if !defined(CIVETWEB_HEADER_INCLUDED) +/* Include the header file here, so the CivetWeb interface is defined for the + * entire implementation, including the following forward definitions. */ +#endif + +#if !defined(DEBUG_TRACE) +#if defined(DEBUG) +static void DEBUG_TRACE_FUNC(const char *func, + unsigned line, + PRINTF_FORMAT_STRING(const char *fmt), + ...) PRINTF_ARGS(3, 4); + +#define DEBUG_TRACE(fmt, ...) \ + DEBUG_TRACE_FUNC(__func__, __LINE__, fmt, __VA_ARGS__) + +#define NEED_DEBUG_TRACE_FUNC + +#else +#define DEBUG_TRACE(fmt, ...) \ + do { \ + } while (0) +#endif /* DEBUG */ +#endif /* DEBUG_TRACE */ + + +#if !defined(DEBUG_ASSERT) +#if defined(DEBUG) +#define DEBUG_ASSERT(cond) \ + do { \ + if (!(cond)) { \ + DEBUG_TRACE("ASSERTION FAILED: %s", #cond); \ + exit(2); /* Exit with error */ \ + } \ + } while (0) +#else +#define DEBUG_ASSERT(cond) +#endif /* DEBUG */ +#endif + + +#if defined(__GNUC__) && defined(GCC_INSTRUMENTATION) +void __cyg_profile_func_enter(void *this_fn, void *call_site) + __attribute__((no_instrument_function)); + +void __cyg_profile_func_exit(void *this_fn, void *call_site) + __attribute__((no_instrument_function)); + +void +__cyg_profile_func_enter(void *this_fn, void *call_site) +{ + if ((void *)this_fn != (void *)printf) { + printf("E %p %p\n", this_fn, call_site); + } +} + +void +__cyg_profile_func_exit(void *this_fn, void *call_site) +{ + if ((void *)this_fn != (void *)printf) { + printf("X %p %p\n", this_fn, call_site); + } +} +#endif + + +#if !defined(IGNORE_UNUSED_RESULT) +#define IGNORE_UNUSED_RESULT(a) ((void)((a) && 1)) +#endif + + +#if defined(__GNUC__) || defined(__MINGW32__) + +/* GCC unused function attribute seems fundamentally broken. + * Several attempts to tell the compiler "THIS FUNCTION MAY BE USED + * OR UNUSED" for individual functions failed. + * Either the compiler creates an "unused-function" warning if a + * function is not marked with __attribute__((unused)). + * On the other hand, if the function is marked with this attribute, + * but is used, the compiler raises a completely idiotic + * "used-but-marked-unused" warning - and + * #pragma GCC diagnostic ignored "-Wused-but-marked-unused" + * raises error: unknown option after "#pragma GCC diagnostic". + * Disable this warning completely, until the GCC guys sober up + * again. + */ + +#pragma GCC diagnostic ignored "-Wunused-function" + +#define FUNCTION_MAY_BE_UNUSED /* __attribute__((unused)) */ + +#else +#define FUNCTION_MAY_BE_UNUSED +#endif + + +/* Some ANSI #includes are not available on Windows CE */ +#if !defined(_WIN32_WCE) +#include +#include +#include +#include +#include +#endif /* !_WIN32_WCE */ + + +#if defined(__clang__) +/* When using -Weverything, clang does not accept it's own headers + * in a release build configuration. Disable what is too much in + * -Weverything. */ +#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" +#endif + +#if defined(__GNUC__) || defined(__MINGW32__) +/* Who on earth came to the conclusion, using __DATE__ should rise + * an "expansion of date or time macro is not reproducible" + * warning. That's exactly what was intended by using this macro. + * Just disable this nonsense warning. */ + +/* And disabling them does not work either: + * #pragma clang diagnostic ignored "-Wno-error=date-time" + * #pragma clang diagnostic ignored "-Wdate-time" + * So we just have to disable ALL warnings for some lines + * of code. + * This seems to be a known GCC bug, not resolved since 2012: + * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53431 + */ +#endif + + +#if defined(__MACH__) /* Apple OSX section */ + +#if defined(__clang__) +#if (__clang_major__ == 3) && ((__clang_minor__ == 7) || (__clang_minor__ == 8)) +/* Avoid warnings for Xcode 7. It seems it does no longer exist in Xcode 8 */ +#pragma clang diagnostic ignored "-Wno-reserved-id-macro" +#pragma clang diagnostic ignored "-Wno-keyword-macro" +#endif +#endif + +#define CLOCK_MONOTONIC (1) +#define CLOCK_REALTIME (2) + +#include +#include +#include +#include +#include + +/* clock_gettime is not implemented on OSX prior to 10.12 */ +static int +_civet_clock_gettime(int clk_id, struct timespec *t) +{ + memset(t, 0, sizeof(*t)); + if (clk_id == CLOCK_REALTIME) { + struct timeval now; + int rv = gettimeofday(&now, NULL); + if (rv) { + return rv; + } + t->tv_sec = now.tv_sec; + t->tv_nsec = now.tv_usec * 1000; + return 0; + + } else if (clk_id == CLOCK_MONOTONIC) { + static uint64_t clock_start_time = 0; + static mach_timebase_info_data_t timebase_ifo = {0, 0}; + + uint64_t now = mach_absolute_time(); + + if (clock_start_time == 0) { + kern_return_t mach_status = mach_timebase_info(&timebase_ifo); + DEBUG_ASSERT(mach_status == KERN_SUCCESS); + + /* appease "unused variable" warning for release builds */ + (void)mach_status; + + clock_start_time = now; + } + + now = (uint64_t)((double)(now - clock_start_time) + * (double)timebase_ifo.numer + / (double)timebase_ifo.denom); + + t->tv_sec = now / 1000000000; + t->tv_nsec = now % 1000000000; + return 0; + } + return -1; /* EINVAL - Clock ID is unknown */ +} + +#ifdef __MACH__ +#include +#endif + +/* if clock_gettime is declared, then __CLOCK_AVAILABILITY will be defined */ +#if defined(__CLOCK_AVAILABILITY) +/* If we compiled with Mac OSX 10.12 or later, then clock_gettime will be + * declared but it may be NULL at runtime. So we need to check before using + * it. */ +static int +_civet_safe_clock_gettime(int clk_id, struct timespec *t) +{ + if (clock_gettime) { + return clock_gettime(clk_id, t); + } + return _civet_clock_gettime(clk_id, t); +} +#define clock_gettime _civet_safe_clock_gettime +#else +#define clock_gettime _civet_clock_gettime +#endif + +#endif + + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef __MACH__ +#include +#endif + +/********************************************************************/ +/* CivetWeb configuration defines */ +/********************************************************************/ + +/* Maximum number of threads that can be configured. + * The number of threads actually created depends on the "num_threads" + * configuration parameter, but this is the upper limit. */ +#if !defined(MAX_WORKER_THREADS) +#define MAX_WORKER_THREADS (1024 * 64) /* in threads (count) */ +#endif + +/* Timeout interval for select/poll calls. + * The timeouts depend on "*_timeout_ms" configuration values, but long + * timeouts are split into timouts as small as SOCKET_TIMEOUT_QUANTUM. + * This reduces the time required to stop the server. */ +#if !defined(SOCKET_TIMEOUT_QUANTUM) +#define SOCKET_TIMEOUT_QUANTUM (2000) /* in ms */ +#endif + +/* Do not try to compress files smaller than this limit. */ +#if !defined(MG_FILE_COMPRESSION_SIZE_LIMIT) +#define MG_FILE_COMPRESSION_SIZE_LIMIT (1024) /* in bytes */ +#endif + +#if !defined(PASSWORDS_FILE_NAME) +#define PASSWORDS_FILE_NAME ".htpasswd" +#endif + +/* Initial buffer size for all CGI environment variables. In case there is + * not enough space, another block is allocated. */ +#if !defined(CGI_ENVIRONMENT_SIZE) +#define CGI_ENVIRONMENT_SIZE (4096) /* in bytes */ +#endif + +/* Maximum number of environment variables. */ +#if !defined(MAX_CGI_ENVIR_VARS) +#define MAX_CGI_ENVIR_VARS (256) /* in variables (count) */ +#endif + +/* General purpose buffer size. */ +#if !defined(MG_BUF_LEN) /* in bytes */ +#define MG_BUF_LEN (1024 * 8) +#endif + +/* Size of the accepted socket queue (in case the old queue implementation + * is used). */ +#if !defined(MGSQLEN) +#define MGSQLEN (20) /* count */ +#endif + + +/********************************************************************/ + +/* Helper makros */ +#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0])) + +/* Standard defines */ +#if !defined(INT64_MAX) +#define INT64_MAX (9223372036854775807) +#endif + +#define SHUTDOWN_RD (0) +#define SHUTDOWN_WR (1) +#define SHUTDOWN_BOTH (2) + +mg_static_assert(MAX_WORKER_THREADS >= 1, + "worker threads must be a positive number"); + +mg_static_assert(sizeof(size_t) == 4 || sizeof(size_t) == 8, + "size_t data type size check"); + +#if defined(_WIN32) /* WINDOWS include block */ +#include +#include /* DTL add for SO_EXCLUSIVE */ +#include + +typedef const char *SOCK_OPT_TYPE; + +#if !defined(PATH_MAX) +#define W_PATH_MAX (MAX_PATH) +/* at most three UTF-8 chars per wchar_t */ +#define PATH_MAX (W_PATH_MAX * 3) +#else +#define W_PATH_MAX ((PATH_MAX + 2) / 3) +#endif + +mg_static_assert(PATH_MAX >= 1, "path length must be a positive number"); + +#if !defined(_IN_PORT_T) +#if !defined(in_port_t) +#define in_port_t u_short +#endif +#endif + +#if !defined(_WIN32_WCE) +#include +#include +#include +#else /* _WIN32_WCE */ +#define NO_CGI /* WinCE has no pipes */ +#define NO_POPEN /* WinCE has no popen */ + +typedef long off_t; + +#define errno ((int)(GetLastError())) +#define strerror(x) (_ultoa(x, (char *)_alloca(sizeof(x) * 3), 10)) +#endif /* _WIN32_WCE */ + +#define MAKEUQUAD(lo, hi) \ + ((uint64_t)(((uint32_t)(lo)) | ((uint64_t)((uint32_t)(hi))) << 32)) +#define RATE_DIFF (10000000) /* 100 nsecs */ +#define EPOCH_DIFF (MAKEUQUAD(0xd53e8000, 0x019db1de)) +#define SYS2UNIX_TIME(lo, hi) \ + ((time_t)((MAKEUQUAD((lo), (hi)) - EPOCH_DIFF) / RATE_DIFF)) + +/* Visual Studio 6 does not know __func__ or __FUNCTION__ + * The rest of MS compilers use __FUNCTION__, not C99 __func__ + * Also use _strtoui64 on modern M$ compilers */ +#if defined(_MSC_VER) +#if (_MSC_VER < 1300) +#define STRX(x) #x +#define STR(x) STRX(x) +#define __func__ __FILE__ ":" STR(__LINE__) +#define strtoull(x, y, z) ((unsigned __int64)_atoi64(x)) +#define strtoll(x, y, z) (_atoi64(x)) +#else +#define __func__ __FUNCTION__ +#define strtoull(x, y, z) (_strtoui64(x, y, z)) +#define strtoll(x, y, z) (_strtoi64(x, y, z)) +#endif +#endif /* _MSC_VER */ + +#define ERRNO ((int)(GetLastError())) +#define NO_SOCKLEN_T + +#if defined(_WIN64) || defined(__MINGW64__) +#if !defined(SSL_LIB) +#define SSL_LIB "ssleay64.dll" +#endif +#if !defined(CRYPTO_LIB) +#define CRYPTO_LIB "libeay64.dll" +#endif +#else +#if !defined(SSL_LIB) +#define SSL_LIB "ssleay32.dll" +#endif +#if !defined(CRYPTO_LIB) +#define CRYPTO_LIB "libeay32.dll" +#endif +#endif + +#define O_NONBLOCK (0) +#if !defined(W_OK) +#define W_OK (2) /* http://msdn.microsoft.com/en-us/library/1w06ktdy.aspx */ +#endif +#define _POSIX_ +#define INT64_FMT "I64d" +#define UINT64_FMT "I64u" + +#define WINCDECL __cdecl +#define vsnprintf_impl _vsnprintf +#define access _access +#define mg_sleep(x) (Sleep(x)) + +#define pipe(x) _pipe(x, MG_BUF_LEN, _O_BINARY) +#if !defined(popen) +#define popen(x, y) (_popen(x, y)) +#endif +#if !defined(pclose) +#define pclose(x) (_pclose(x)) +#endif +#define close(x) (_close(x)) +#define dlsym(x, y) (GetProcAddress((HINSTANCE)(x), (y))) +#define RTLD_LAZY (0) +#define fseeko(x, y, z) ((_lseeki64(_fileno(x), (y), (z)) == -1) ? -1 : 0) +#define fdopen(x, y) (_fdopen((x), (y))) +#define write(x, y, z) (_write((x), (y), (unsigned)z)) +#define read(x, y, z) (_read((x), (y), (unsigned)z)) +#define flockfile(x) ((void)pthread_mutex_lock(&global_log_file_lock)) +#define funlockfile(x) ((void)pthread_mutex_unlock(&global_log_file_lock)) +#define sleep(x) (Sleep((x)*1000)) +#define rmdir(x) (_rmdir(x)) +#if defined(_WIN64) || !defined(__MINGW32__) +/* Only MinGW 32 bit is missing this function */ +#define timegm(x) (_mkgmtime(x)) +#else +time_t timegm(struct tm *tm); +#define NEED_TIMEGM +#endif + + +#if !defined(fileno) +#define fileno(x) (_fileno(x)) +#endif /* !fileno MINGW #defines fileno */ + +typedef struct { + CRITICAL_SECTION sec; /* Immovable */ +} pthread_mutex_t; +typedef DWORD pthread_key_t; +typedef HANDLE pthread_t; +typedef struct { + pthread_mutex_t threadIdSec; + struct mg_workerTLS *waiting_thread; /* The chain of threads */ +} pthread_cond_t; + +#if !defined(__clockid_t_defined) +typedef DWORD clockid_t; +#endif +#if !defined(CLOCK_MONOTONIC) +#define CLOCK_MONOTONIC (1) +#endif +#if !defined(CLOCK_REALTIME) +#define CLOCK_REALTIME (2) +#endif +#if !defined(CLOCK_THREAD) +#define CLOCK_THREAD (3) +#endif +#if !defined(CLOCK_PROCESS) +#define CLOCK_PROCESS (4) +#endif + + +#if defined(_MSC_VER) && (_MSC_VER >= 1900) +#define _TIMESPEC_DEFINED +#endif +#if !defined(_TIMESPEC_DEFINED) +struct timespec { + time_t tv_sec; /* seconds */ + long tv_nsec; /* nanoseconds */ +}; +#endif + +#if !defined(WIN_PTHREADS_TIME_H) +#define MUST_IMPLEMENT_CLOCK_GETTIME +#endif + +#if defined(MUST_IMPLEMENT_CLOCK_GETTIME) +#define clock_gettime mg_clock_gettime +static int +clock_gettime(clockid_t clk_id, struct timespec *tp) +{ + FILETIME ft; + ULARGE_INTEGER li, li2; + BOOL ok = FALSE; + double d; + static double perfcnt_per_sec = 0.0; + static BOOL initialized = FALSE; + + if (!initialized) { + QueryPerformanceFrequency((LARGE_INTEGER *)&li); + perfcnt_per_sec = 1.0 / li.QuadPart; + initialized = TRUE; + } + + if (tp) { + memset(tp, 0, sizeof(*tp)); + + if (clk_id == CLOCK_REALTIME) { + + /* BEGIN: CLOCK_REALTIME = wall clock (date and time) */ + GetSystemTimeAsFileTime(&ft); + li.LowPart = ft.dwLowDateTime; + li.HighPart = ft.dwHighDateTime; + li.QuadPart -= 116444736000000000; /* 1.1.1970 in filedate */ + tp->tv_sec = (time_t)(li.QuadPart / 10000000); + tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100; + ok = TRUE; + /* END: CLOCK_REALTIME */ + + } else if (clk_id == CLOCK_MONOTONIC) { + + /* BEGIN: CLOCK_MONOTONIC = stopwatch (time differences) */ + QueryPerformanceCounter((LARGE_INTEGER *)&li); + d = li.QuadPart * perfcnt_per_sec; + tp->tv_sec = (time_t)d; + d -= (double)tp->tv_sec; + tp->tv_nsec = (long)(d * 1.0E9); + ok = TRUE; + /* END: CLOCK_MONOTONIC */ + + } else if (clk_id == CLOCK_THREAD) { + + /* BEGIN: CLOCK_THREAD = CPU usage of thread */ + FILETIME t_create, t_exit, t_kernel, t_user; + if (GetThreadTimes(GetCurrentThread(), + &t_create, + &t_exit, + &t_kernel, + &t_user)) { + li.LowPart = t_user.dwLowDateTime; + li.HighPart = t_user.dwHighDateTime; + li2.LowPart = t_kernel.dwLowDateTime; + li2.HighPart = t_kernel.dwHighDateTime; + li.QuadPart += li2.QuadPart; + tp->tv_sec = (time_t)(li.QuadPart / 10000000); + tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100; + ok = TRUE; + } + /* END: CLOCK_THREAD */ + + } else if (clk_id == CLOCK_PROCESS) { + + /* BEGIN: CLOCK_PROCESS = CPU usage of process */ + FILETIME t_create, t_exit, t_kernel, t_user; + if (GetProcessTimes(GetCurrentProcess(), + &t_create, + &t_exit, + &t_kernel, + &t_user)) { + li.LowPart = t_user.dwLowDateTime; + li.HighPart = t_user.dwHighDateTime; + li2.LowPart = t_kernel.dwLowDateTime; + li2.HighPart = t_kernel.dwHighDateTime; + li.QuadPart += li2.QuadPart; + tp->tv_sec = (time_t)(li.QuadPart / 10000000); + tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100; + ok = TRUE; + } + /* END: CLOCK_PROCESS */ + + } else { + + /* BEGIN: unknown clock */ + /* ok = FALSE; already set by init */ + /* END: unknown clock */ + } + } + + return ok ? 0 : -1; +} +#endif + + +#define pid_t HANDLE /* MINGW typedefs pid_t to int. Using #define here. */ + +static int pthread_mutex_lock(pthread_mutex_t *); +static int pthread_mutex_unlock(pthread_mutex_t *); +static void path_to_unicode(const struct mg_connection *conn, + const char *path, + wchar_t *wbuf, + size_t wbuf_len); + +/* All file operations need to be rewritten to solve #246. */ + +struct mg_file; + +static const char * +mg_fgets(char *buf, size_t size, struct mg_file *filep, char **p); + + +/* POSIX dirent interface */ +struct dirent { + char d_name[PATH_MAX]; +}; + +typedef struct DIR { + HANDLE handle; + WIN32_FIND_DATAW info; + struct dirent result; +} DIR; + +#if defined(HAVE_POLL) +#define mg_pollfd pollfd +#else +struct mg_pollfd { + SOCKET fd; + short events; + short revents; +}; +#endif + +/* Mark required libraries */ +#if defined(_MSC_VER) +#pragma comment(lib, "Ws2_32.lib") +#endif + +#else /* defined(_WIN32) - WINDOWS vs UNIX include block */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef const void *SOCK_OPT_TYPE; + +#if defined(ANDROID) +typedef unsigned short int in_port_t; +#endif + +#include +#include +#include +#include +#define vsnprintf_impl vsnprintf + +#if !defined(NO_SSL_DL) && !defined(NO_SSL) +#include +#endif +#include +#if defined(__MACH__) +#define SSL_LIB "libssl.dylib" +#define CRYPTO_LIB "libcrypto.dylib" +#else +#if !defined(SSL_LIB) +#define SSL_LIB "libssl.so" +#endif +#if !defined(CRYPTO_LIB) +#define CRYPTO_LIB "libcrypto.so" +#endif +#endif +#if !defined(O_BINARY) +#define O_BINARY (0) +#endif /* O_BINARY */ +#define closesocket(a) (close(a)) +#define mg_mkdir(conn, path, mode) (mkdir(path, mode)) +#define mg_remove(conn, x) (remove(x)) +#define mg_sleep(x) (usleep((x)*1000)) +#define mg_opendir(conn, x) (opendir(x)) +#define mg_closedir(x) (closedir(x)) +#define mg_readdir(x) (readdir(x)) +#define ERRNO (errno) +#define INVALID_SOCKET (-1) +#define INT64_FMT PRId64 +#define UINT64_FMT PRIu64 +typedef int SOCKET; +#define WINCDECL + +#if defined(__hpux) +/* HPUX 11 does not have monotonic, fall back to realtime */ +#if !defined(CLOCK_MONOTONIC) +#define CLOCK_MONOTONIC CLOCK_REALTIME +#endif + +/* HPUX defines socklen_t incorrectly as size_t which is 64bit on + * Itanium. Without defining _XOPEN_SOURCE or _XOPEN_SOURCE_EXTENDED + * the prototypes use int* rather than socklen_t* which matches the + * actual library expectation. When called with the wrong size arg + * accept() returns a zero client inet addr and check_acl() always + * fails. Since socklen_t is widely used below, just force replace + * their typedef with int. - DTL + */ +#define socklen_t int +#endif /* hpux */ + +#define mg_pollfd pollfd + +#endif /* defined(_WIN32) - WINDOWS vs UNIX include block */ + +/* Maximum queue length for pending connections. This value is passed as + * parameter to the "listen" socket call. */ +#if !defined(SOMAXCONN) +/* This symbol may be defined in winsock2.h so this must after that include */ +#define SOMAXCONN (100) /* in pending connections (count) */ +#endif + +/* In case our C library is missing "timegm", provide an implementation */ +#if defined(NEED_TIMEGM) +static inline int +is_leap(int y) +{ + return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0; +} + +static inline int +count_leap(int y) +{ + return (y - 1969) / 4 - (y - 1901) / 100 + (y - 1601) / 400; +} + +time_t +timegm(struct tm *tm) +{ + static const unsigned short ydays[] = { + 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}; + int year = tm->tm_year + 1900; + int mon = tm->tm_mon; + int mday = tm->tm_mday - 1; + int hour = tm->tm_hour; + int min = tm->tm_min; + int sec = tm->tm_sec; + + if (year < 1970 || mon < 0 || mon > 11 || mday < 0 + || (mday >= ydays[mon + 1] - ydays[mon] + + (mon == 1 && is_leap(year) ? 1 : 0)) + || hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 || sec > 60) + return -1; + + time_t res = year - 1970; + res *= 365; + res += mday; + res += ydays[mon] + (mon > 1 && is_leap(year) ? 1 : 0); + res += count_leap(year); + + res *= 24; + res += hour; + res *= 60; + res += min; + res *= 60; + res += sec; + return res; +} +#endif /* NEED_TIMEGM */ + + +/* va_copy should always be a macro, C99 and C++11 - DTL */ +#if !defined(va_copy) +#define va_copy(x, y) ((x) = (y)) +#endif + + +#if defined(_WIN32) +/* Create substitutes for POSIX functions in Win32. */ + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif + + +static pthread_mutex_t global_log_file_lock; + +FUNCTION_MAY_BE_UNUSED +static DWORD +pthread_self(void) +{ + return GetCurrentThreadId(); +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_key_create( + pthread_key_t *key, + void (*_ignored)(void *) /* destructor not supported for Windows */ +) +{ + (void)_ignored; + + if ((key != 0)) { + *key = TlsAlloc(); + return (*key != TLS_OUT_OF_INDEXES) ? 0 : -1; + } + return -2; +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_key_delete(pthread_key_t key) +{ + return TlsFree(key) ? 0 : 1; +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_setspecific(pthread_key_t key, void *value) +{ + return TlsSetValue(key, value) ? 0 : 1; +} + + +FUNCTION_MAY_BE_UNUSED +static void * +pthread_getspecific(pthread_key_t key) +{ + return TlsGetValue(key); +} + +#if defined(GCC_DIAGNOSTIC) +/* Enable unused function warning again */ +#pragma GCC diagnostic pop +#endif + +static struct pthread_mutex_undefined_struct *pthread_mutex_attr = NULL; +#else +static pthread_mutexattr_t pthread_mutex_attr; +#endif /* _WIN32 */ + + +#if defined(_WIN32_WCE) +/* Create substitutes for POSIX functions in Win32. */ + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif + + +FUNCTION_MAY_BE_UNUSED +static time_t +time(time_t *ptime) +{ + time_t t; + SYSTEMTIME st; + FILETIME ft; + + GetSystemTime(&st); + SystemTimeToFileTime(&st, &ft); + t = SYS2UNIX_TIME(ft.dwLowDateTime, ft.dwHighDateTime); + + if (ptime != NULL) { + *ptime = t; + } + + return t; +} + + +FUNCTION_MAY_BE_UNUSED +static struct tm * +localtime_s(const time_t *ptime, struct tm *ptm) +{ + int64_t t = ((int64_t)*ptime) * RATE_DIFF + EPOCH_DIFF; + FILETIME ft, lft; + SYSTEMTIME st; + TIME_ZONE_INFORMATION tzinfo; + + if (ptm == NULL) { + return NULL; + } + + *(int64_t *)&ft = t; + FileTimeToLocalFileTime(&ft, &lft); + FileTimeToSystemTime(&lft, &st); + ptm->tm_year = st.wYear - 1900; + ptm->tm_mon = st.wMonth - 1; + ptm->tm_wday = st.wDayOfWeek; + ptm->tm_mday = st.wDay; + ptm->tm_hour = st.wHour; + ptm->tm_min = st.wMinute; + ptm->tm_sec = st.wSecond; + ptm->tm_yday = 0; /* hope nobody uses this */ + ptm->tm_isdst = + (GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_DAYLIGHT) ? 1 : 0; + + return ptm; +} + + +FUNCTION_MAY_BE_UNUSED +static struct tm * +gmtime_s(const time_t *ptime, struct tm *ptm) +{ + /* FIXME(lsm): fix this. */ + return localtime_s(ptime, ptm); +} + + +static int mg_atomic_inc(volatile int *addr); +static struct tm tm_array[MAX_WORKER_THREADS]; +static int tm_index = 0; + + +FUNCTION_MAY_BE_UNUSED +static struct tm * +localtime(const time_t *ptime) +{ + int i = mg_atomic_inc(&tm_index) % (sizeof(tm_array) / sizeof(tm_array[0])); + return localtime_s(ptime, tm_array + i); +} + + +FUNCTION_MAY_BE_UNUSED +static struct tm * +gmtime(const time_t *ptime) +{ + int i = mg_atomic_inc(&tm_index) % ARRAY_SIZE(tm_array); + return gmtime_s(ptime, tm_array + i); +} + + +FUNCTION_MAY_BE_UNUSED +static size_t +strftime(char *dst, size_t dst_size, const char *fmt, const struct tm *tm) +{ + /* TODO: (void)mg_snprintf(NULL, dst, dst_size, "implement strftime() + * for WinCE"); */ + return 0; +} + +#define _beginthreadex(psec, stack, func, prm, flags, ptid) \ + (uintptr_t) CreateThread(psec, stack, func, prm, flags, ptid) + +#define remove(f) mg_remove(NULL, f) + + +FUNCTION_MAY_BE_UNUSED +static int +rename(const char *a, const char *b) +{ + wchar_t wa[W_PATH_MAX]; + wchar_t wb[W_PATH_MAX]; + path_to_unicode(NULL, a, wa, ARRAY_SIZE(wa)); + path_to_unicode(NULL, b, wb, ARRAY_SIZE(wb)); + + return MoveFileW(wa, wb) ? 0 : -1; +} + + +struct stat { + int64_t st_size; + time_t st_mtime; +}; + + +FUNCTION_MAY_BE_UNUSED +static int +stat(const char *name, struct stat *st) +{ + wchar_t wbuf[W_PATH_MAX]; + WIN32_FILE_ATTRIBUTE_DATA attr; + time_t creation_time, write_time; + + path_to_unicode(NULL, name, wbuf, ARRAY_SIZE(wbuf)); + memset(&attr, 0, sizeof(attr)); + + GetFileAttributesExW(wbuf, GetFileExInfoStandard, &attr); + st->st_size = + (((int64_t)attr.nFileSizeHigh) << 32) + (int64_t)attr.nFileSizeLow; + + write_time = SYS2UNIX_TIME(attr.ftLastWriteTime.dwLowDateTime, + attr.ftLastWriteTime.dwHighDateTime); + creation_time = SYS2UNIX_TIME(attr.ftCreationTime.dwLowDateTime, + attr.ftCreationTime.dwHighDateTime); + + if (creation_time > write_time) { + st->st_mtime = creation_time; + } else { + st->st_mtime = write_time; + } + return 0; +} + +#define access(x, a) 1 /* not required anyway */ + +/* WinCE-TODO: define stat, remove, rename, _rmdir, _lseeki64 */ +/* Values from errno.h in Windows SDK (Visual Studio). */ +#define EEXIST 17 +#define EACCES 13 +#define ENOENT 2 + +#if defined(GCC_DIAGNOSTIC) +/* Enable unused function warning again */ +#pragma GCC diagnostic pop +#endif + +#endif /* defined(_WIN32_WCE) */ + + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif /* defined(GCC_DIAGNOSTIC) */ +#if defined(__clang__) +/* Show no warning in case system functions are not used. */ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunused-function" +#endif + +static pthread_mutex_t global_lock_mutex; + + +FUNCTION_MAY_BE_UNUSED +static void +mg_global_lock(void) +{ + (void)pthread_mutex_lock(&global_lock_mutex); +} + + +FUNCTION_MAY_BE_UNUSED +static void +mg_global_unlock(void) +{ + (void)pthread_mutex_unlock(&global_lock_mutex); +} + + +FUNCTION_MAY_BE_UNUSED +static int +mg_atomic_inc(volatile int *addr) +{ + int ret; +#if defined(_WIN32) && !defined(NO_ATOMICS) + /* Depending on the SDK, this function uses either + * (volatile unsigned int *) or (volatile LONG *), + * so whatever you use, the other SDK is likely to raise a warning. */ + ret = InterlockedIncrement((volatile long *)addr); +#elif defined(__GNUC__) \ + && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0))) \ + && !defined(NO_ATOMICS) + ret = __sync_add_and_fetch(addr, 1); +#else + mg_global_lock(); + ret = (++(*addr)); + mg_global_unlock(); +#endif + return ret; +} + + +FUNCTION_MAY_BE_UNUSED +static int +mg_atomic_dec(volatile int *addr) +{ + int ret; +#if defined(_WIN32) && !defined(NO_ATOMICS) + /* Depending on the SDK, this function uses either + * (volatile unsigned int *) or (volatile LONG *), + * so whatever you use, the other SDK is likely to raise a warning. */ + ret = InterlockedDecrement((volatile long *)addr); +#elif defined(__GNUC__) \ + && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0))) \ + && !defined(NO_ATOMICS) + ret = __sync_sub_and_fetch(addr, 1); +#else + mg_global_lock(); + ret = (--(*addr)); + mg_global_unlock(); +#endif + return ret; +} + + +#if defined(USE_SERVER_STATS) +static int64_t +mg_atomic_add(volatile int64_t *addr, int64_t value) +{ + int64_t ret; +#if defined(_WIN64) && !defined(NO_ATOMICS) + ret = InterlockedAdd64(addr, value); +#elif defined(__GNUC__) \ + && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0))) \ + && !defined(NO_ATOMICS) + ret = __sync_add_and_fetch(addr, value); +#else + mg_global_lock(); + *addr += value; + ret = (*addr); + mg_global_unlock(); +#endif + return ret; +} +#endif + + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic pop +#endif /* defined(GCC_DIAGNOSTIC) */ +#if defined(__clang__) +/* Show no warning in case system functions are not used. */ +#pragma clang diagnostic pop +#endif + + +#if defined(USE_SERVER_STATS) + +struct mg_memory_stat { + volatile int64_t totalMemUsed; + volatile int64_t maxMemUsed; + volatile int blockCount; +}; + + +static struct mg_memory_stat *get_memory_stat(struct mg_context *ctx); + + +static void * +mg_malloc_ex(size_t size, + struct mg_context *ctx, + const char *file, + unsigned line) +{ + void *data = malloc(size + 2 * sizeof(uintptr_t)); + void *memory = 0; + struct mg_memory_stat *mstat = get_memory_stat(ctx); + +#if defined(MEMORY_DEBUGGING) + char mallocStr[256]; +#else + (void)file; + (void)line; +#endif + + if (data) { + int64_t mmem = mg_atomic_add(&mstat->totalMemUsed, (int64_t)size); + if (mmem > mstat->maxMemUsed) { + /* could use atomic compare exchange, but this + * seems overkill for statistics data */ + mstat->maxMemUsed = mmem; + } + + mg_atomic_inc(&mstat->blockCount); + ((uintptr_t *)data)[0] = size; + ((uintptr_t *)data)[1] = (uintptr_t)mstat; + memory = (void *)(((char *)data) + 2 * sizeof(uintptr_t)); + } + +#if defined(MEMORY_DEBUGGING) + sprintf(mallocStr, + "MEM: %p %5lu alloc %7lu %4lu --- %s:%u\n", + memory, + (unsigned long)size, + (unsigned long)mstat->totalMemUsed, + (unsigned long)mstat->blockCount, + file, + line); +#if defined(_WIN32) + OutputDebugStringA(mallocStr); +#else + DEBUG_TRACE("%s", mallocStr); +#endif +#endif + + return memory; +} + + +static void * +mg_calloc_ex(size_t count, + size_t size, + struct mg_context *ctx, + const char *file, + unsigned line) +{ + void *data = mg_malloc_ex(size * count, ctx, file, line); + + if (data) { + memset(data, 0, size * count); + } + return data; +} + + +static void +mg_free_ex(void *memory, const char *file, unsigned line) +{ + void *data = (void *)(((char *)memory) - 2 * sizeof(uintptr_t)); + + +#if defined(MEMORY_DEBUGGING) + char mallocStr[256]; +#else + (void)file; + (void)line; +#endif + + if (memory) { + uintptr_t size = ((uintptr_t *)data)[0]; + struct mg_memory_stat *mstat = + (struct mg_memory_stat *)(((uintptr_t *)data)[1]); + mg_atomic_add(&mstat->totalMemUsed, -(int64_t)size); + mg_atomic_dec(&mstat->blockCount); +#if defined(MEMORY_DEBUGGING) + sprintf(mallocStr, + "MEM: %p %5lu free %7lu %4lu --- %s:%u\n", + memory, + (unsigned long)size, + (unsigned long)mstat->totalMemUsed, + (unsigned long)mstat->blockCount, + file, + line); +#if defined(_WIN32) + OutputDebugStringA(mallocStr); +#else + DEBUG_TRACE("%s", mallocStr); +#endif +#endif + free(data); + } +} + + +static void * +mg_realloc_ex(void *memory, + size_t newsize, + struct mg_context *ctx, + const char *file, + unsigned line) +{ + void *data; + void *_realloc; + uintptr_t oldsize; + +#if defined(MEMORY_DEBUGGING) + char mallocStr[256]; +#else + (void)file; + (void)line; +#endif + + if (newsize) { + if (memory) { + /* Reallocate existing block */ + struct mg_memory_stat *mstat; + data = (void *)(((char *)memory) - 2 * sizeof(uintptr_t)); + oldsize = ((uintptr_t *)data)[0]; + mstat = (struct mg_memory_stat *)((uintptr_t *)data)[1]; + _realloc = realloc(data, newsize + 2 * sizeof(uintptr_t)); + if (_realloc) { + data = _realloc; + mg_atomic_add(&mstat->totalMemUsed, -(int64_t)oldsize); +#if defined(MEMORY_DEBUGGING) + sprintf(mallocStr, + "MEM: %p %5lu r-free %7lu %4lu --- %s:%u\n", + memory, + (unsigned long)oldsize, + (unsigned long)mstat->totalMemUsed, + (unsigned long)mstat->blockCount, + file, + line); +#if defined(_WIN32) + OutputDebugStringA(mallocStr); +#else + DEBUG_TRACE("%s", mallocStr); +#endif +#endif + mg_atomic_add(&mstat->totalMemUsed, (int64_t)newsize); +#if defined(MEMORY_DEBUGGING) + sprintf(mallocStr, + "MEM: %p %5lu r-alloc %7lu %4lu --- %s:%u\n", + memory, + (unsigned long)newsize, + (unsigned long)mstat->totalMemUsed, + (unsigned long)mstat->blockCount, + file, + line); +#if defined(_WIN32) + OutputDebugStringA(mallocStr); +#else + DEBUG_TRACE("%s", mallocStr); +#endif +#endif + *(uintptr_t *)data = newsize; + data = (void *)(((char *)data) + 2 * sizeof(uintptr_t)); + } else { +#if defined(MEMORY_DEBUGGING) +#if defined(_WIN32) + OutputDebugStringA("MEM: realloc failed\n"); +#else + DEBUG_TRACE("%s", "MEM: realloc failed\n"); +#endif +#endif + return _realloc; + } + } else { + /* Allocate new block */ + data = mg_malloc_ex(newsize, ctx, file, line); + } + } else { + /* Free existing block */ + data = 0; + mg_free_ex(memory, file, line); + } + + return data; +} + +#define mg_malloc(a) mg_malloc_ex(a, NULL, __FILE__, __LINE__) +#define mg_calloc(a, b) mg_calloc_ex(a, b, NULL, __FILE__, __LINE__) +#define mg_realloc(a, b) mg_realloc_ex(a, b, NULL, __FILE__, __LINE__) +#define mg_free(a) mg_free_ex(a, __FILE__, __LINE__) + +#define mg_malloc_ctx(a, c) mg_malloc_ex(a, c, __FILE__, __LINE__) +#define mg_calloc_ctx(a, b, c) mg_calloc_ex(a, b, c, __FILE__, __LINE__) +#define mg_realloc_ctx(a, b, c) mg_realloc_ex(a, b, c, __FILE__, __LINE__) + +#else /* USE_SERVER_STATS */ + +static __inline void * +mg_malloc(size_t a) +{ + return malloc(a); +} + +static __inline void * +mg_calloc(size_t a, size_t b) +{ + return calloc(a, b); +} + +static __inline void * +mg_realloc(void *a, size_t b) +{ + return realloc(a, b); +} + +static __inline void +mg_free(void *a) +{ + free(a); +} + +#define mg_malloc_ctx(a, c) mg_malloc(a) +#define mg_calloc_ctx(a, b, c) mg_calloc(a, b) +#define mg_realloc_ctx(a, b, c) mg_realloc(a, b) +#define mg_free_ctx(a, c) mg_free(a) + +#endif /* USE_SERVER_STATS */ + + +static void mg_vsnprintf(const struct mg_connection *conn, + int *truncated, + char *buf, + size_t buflen, + const char *fmt, + va_list ap); + +static void mg_snprintf(const struct mg_connection *conn, + int *truncated, + char *buf, + size_t buflen, + PRINTF_FORMAT_STRING(const char *fmt), + ...) PRINTF_ARGS(5, 6); + +/* This following lines are just meant as a reminder to use the mg-functions + * for memory management */ +#if defined(malloc) +#undef malloc +#endif +#if defined(calloc) +#undef calloc +#endif +#if defined(realloc) +#undef realloc +#endif +#if defined(free) +#undef free +#endif +#if defined(snprintf) +#undef snprintf +#endif +#if defined(vsnprintf) +#undef vsnprintf +#endif +#define malloc DO_NOT_USE_THIS_FUNCTION__USE_mg_malloc +#define calloc DO_NOT_USE_THIS_FUNCTION__USE_mg_calloc +#define realloc DO_NOT_USE_THIS_FUNCTION__USE_mg_realloc +#define free DO_NOT_USE_THIS_FUNCTION__USE_mg_free +#define snprintf DO_NOT_USE_THIS_FUNCTION__USE_mg_snprintf +#if defined(_WIN32) +/* vsnprintf must not be used in any system, + * but this define only works well for Windows. */ +#define vsnprintf DO_NOT_USE_THIS_FUNCTION__USE_mg_vsnprintf +#endif + + +/* mg_init_library counter */ +static int mg_init_library_called = 0; + +#if !defined(NO_SSL) +static int mg_ssl_initialized = 0; +#endif + +static pthread_key_t sTlsKey; /* Thread local storage index */ +static int thread_idx_max = 0; + +#if defined(MG_LEGACY_INTERFACE) +#define MG_ALLOW_USING_GET_REQUEST_INFO_FOR_RESPONSE +#endif + +struct mg_workerTLS { + int is_master; + unsigned long thread_idx; + void *user_ptr; +#if defined(_WIN32) + HANDLE pthread_cond_helper_mutex; + struct mg_workerTLS *next_waiting_thread; +#endif +#if defined(MG_ALLOW_USING_GET_REQUEST_INFO_FOR_RESPONSE) + char txtbuf[4]; +#endif +}; + + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif /* defined(GCC_DIAGNOSTIC) */ +#if defined(__clang__) +/* Show no warning in case system functions are not used. */ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunused-function" +#endif + + +/* Get a unique thread ID as unsigned long, independent from the data type + * of thread IDs defined by the operating system API. + * If two calls to mg_current_thread_id return the same value, they calls + * are done from the same thread. If they return different values, they are + * done from different threads. (Provided this function is used in the same + * process context and threads are not repeatedly created and deleted, but + * CivetWeb does not do that). + * This function must match the signature required for SSL id callbacks: + * CRYPTO_set_id_callback + */ +FUNCTION_MAY_BE_UNUSED +static unsigned long +mg_current_thread_id(void) +{ +#if defined(_WIN32) + return GetCurrentThreadId(); +#else + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunreachable-code" +/* For every compiler, either "sizeof(pthread_t) > sizeof(unsigned long)" + * or not, so one of the two conditions will be unreachable by construction. + * Unfortunately the C standard does not define a way to check this at + * compile time, since the #if preprocessor conditions can not use the sizeof + * operator as an argument. */ +#endif + + if (sizeof(pthread_t) > sizeof(unsigned long)) { + /* This is the problematic case for CRYPTO_set_id_callback: + * The OS pthread_t can not be cast to unsigned long. */ + struct mg_workerTLS *tls = + (struct mg_workerTLS *)pthread_getspecific(sTlsKey); + if (tls == NULL) { + /* SSL called from an unknown thread: Create some thread index. + */ + tls = (struct mg_workerTLS *)mg_malloc(sizeof(struct mg_workerTLS)); + tls->is_master = -2; /* -2 means "3rd party thread" */ + tls->thread_idx = (unsigned)mg_atomic_inc(&thread_idx_max); + pthread_setspecific(sTlsKey, tls); + } + return tls->thread_idx; + } else { + /* pthread_t may be any data type, so a simple cast to unsigned long + * can rise a warning/error, depending on the platform. + * Here memcpy is used as an anything-to-anything cast. */ + unsigned long ret = 0; + pthread_t t = pthread_self(); + memcpy(&ret, &t, sizeof(pthread_t)); + return ret; + } + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +#endif +} + + +FUNCTION_MAY_BE_UNUSED +static uint64_t +mg_get_current_time_ns(void) +{ + struct timespec tsnow; + clock_gettime(CLOCK_REALTIME, &tsnow); + return (((uint64_t)tsnow.tv_sec) * 1000000000) + (uint64_t)tsnow.tv_nsec; +} + + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic pop +#endif /* defined(GCC_DIAGNOSTIC) */ +#if defined(__clang__) +/* Show no warning in case system functions are not used. */ +#pragma clang diagnostic pop +#endif + + +#if defined(NEED_DEBUG_TRACE_FUNC) +static void +DEBUG_TRACE_FUNC(const char *func, unsigned line, const char *fmt, ...) +{ + va_list args; + uint64_t nsnow; + static uint64_t nslast; + struct timespec tsnow; + + /* Get some operating system independent thread id */ + unsigned long thread_id = mg_current_thread_id(); + + clock_gettime(CLOCK_REALTIME, &tsnow); + nsnow = ((uint64_t)tsnow.tv_sec) * ((uint64_t)1000000000) + + ((uint64_t)tsnow.tv_nsec); + + if (!nslast) { + nslast = nsnow; + } + + flockfile(stdout); + printf("*** %lu.%09lu %12" INT64_FMT " %lu %s:%u: ", + (unsigned long)tsnow.tv_sec, + (unsigned long)tsnow.tv_nsec, + nsnow - nslast, + thread_id, + func, + line); + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + putchar('\n'); + fflush(stdout); + funlockfile(stdout); + nslast = nsnow; +} +#endif /* NEED_DEBUG_TRACE_FUNC */ + + +#define MD5_STATIC static +/* + * This an amalgamation of md5.c and md5.h into a single file + * with all static declaration to reduce linker conflicts + * in Civetweb. + * + * The MD5_STATIC declaration was added to facilitate static + * inclusion. + * No Face Press, LLC + */ + +/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.h is L. Peter Deutsch + . Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Removed support for non-ANSI compilers; removed + references to Ghostscript; clarified derivation from RFC 1321; + now handles byte order either statically or dynamically. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5); + added conditionalization for C++ compilation from Martin + Purschke . + 1999-05-03 lpd Original version. + */ + +#if !defined(md5_INCLUDED) +#define md5_INCLUDED + +/* + * This package supports both compile-time and run-time determination of CPU + * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be + * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is + * defined as non-zero, the code will be compiled to run only on big-endian + * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to + * run on either big- or little-endian CPUs, but will run slightly less + * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined. + */ + +typedef unsigned char md5_byte_t; /* 8-bit byte */ +typedef unsigned int md5_word_t; /* 32-bit word */ + +/* Define the state of the MD5 Algorithm. */ +typedef struct md5_state_s { + md5_word_t count[2]; /* message length in bits, lsw first */ + md5_word_t abcd[4]; /* digest buffer */ + md5_byte_t buf[64]; /* accumulate block */ +} md5_state_t; + +#if defined(__cplusplus) +extern "C" { +#endif + +/* Initialize the algorithm. */ +MD5_STATIC void md5_init(md5_state_t *pms); + +/* Append a string to the message. */ +MD5_STATIC void +md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes); + +/* Finish the message and return the digest. */ +MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16]); + +#if defined(__cplusplus) +} /* end extern "C" */ +#endif + +#endif /* md5_INCLUDED */ + +/* + Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved. + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + L. Peter Deutsch + ghost@aladdin.com + + */ +/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.c is L. Peter Deutsch + . Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order + either statically or dynamically; added missing #include + in library. + 2002-03-11 lpd Corrected argument list for main(), and added int return + type, in test program and T value program. + 2002-02-21 lpd Added missing #include in test program. + 2000-07-03 lpd Patched to eliminate warnings about "constant is + unsigned in ANSI C, signed in traditional"; made test program + self-checking. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5). + 1999-05-03 lpd Original version. + */ + +#if !defined(MD5_STATIC) +#include +#endif + +#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */ +#if defined(ARCH_IS_BIG_ENDIAN) +#define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1) +#else +#define BYTE_ORDER (0) +#endif + +#define T_MASK ((md5_word_t)~0) +#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) +#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) +#define T3 (0x242070db) +#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) +#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) +#define T6 (0x4787c62a) +#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) +#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) +#define T9 (0x698098d8) +#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) +#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) +#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) +#define T13 (0x6b901122) +#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) +#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) +#define T16 (0x49b40821) +#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) +#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) +#define T19 (0x265e5a51) +#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) +#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) +#define T22 (0x02441453) +#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) +#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) +#define T25 (0x21e1cde6) +#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) +#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) +#define T28 (0x455a14ed) +#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) +#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) +#define T31 (0x676f02d9) +#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) +#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) +#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) +#define T35 (0x6d9d6122) +#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) +#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) +#define T38 (0x4bdecfa9) +#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) +#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) +#define T41 (0x289b7ec6) +#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) +#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) +#define T44 (0x04881d05) +#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) +#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) +#define T47 (0x1fa27cf8) +#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) +#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) +#define T50 (0x432aff97) +#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) +#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) +#define T53 (0x655b59c3) +#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) +#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) +#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) +#define T57 (0x6fa87e4f) +#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) +#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) +#define T60 (0x4e0811a1) +#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) +#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) +#define T63 (0x2ad7d2bb) +#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) + +static void +md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/) +{ + md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], + d = pms->abcd[3]; + md5_word_t t; +#if BYTE_ORDER > 0 + /* Define storage only for big-endian CPUs. */ + md5_word_t X[16]; +#else + /* Define storage for little-endian or both types of CPUs. */ + md5_word_t xbuf[16]; + const md5_word_t *X; +#endif + + { +#if BYTE_ORDER == 0 + /* + * Determine dynamically whether this is a big-endian or + * little-endian machine, since we can use a more efficient + * algorithm on the latter. + */ + static const int w = 1; + + if (*((const md5_byte_t *)&w)) /* dynamic little-endian */ +#endif +#if BYTE_ORDER <= 0 /* little-endian */ + { + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if (!((data - (const md5_byte_t *)0) & 3)) { + /* data are properly aligned, a direct assignment is possible */ + /* cast through a (void *) should avoid a compiler warning, + see + https://github.com/bel2125/civetweb/issues/94#issuecomment-98112861 + */ + X = (const md5_word_t *)(const void *)data; + } else { + /* not aligned */ + memcpy(xbuf, data, 64); + X = xbuf; + } + } +#endif +#if BYTE_ORDER == 0 + else /* dynamic big-endian */ +#endif +#if BYTE_ORDER >= 0 /* big-endian */ + { + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const md5_byte_t *xp = data; + int i; + +#if BYTE_ORDER == 0 + X = xbuf; /* (dynamic only) */ +#else +#define xbuf X /* (static only) */ +#endif + for (i = 0; i < 16; ++i, xp += 4) + xbuf[i] = (md5_word_t)(xp[0]) + (md5_word_t)(xp[1] << 8) + + (md5_word_t)(xp[2] << 16) + + (md5_word_t)(xp[3] << 24); + } +#endif + } + +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + +/* Round 1. */ +/* Let [abcd k s i] denote the operation + a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ +#define F(x, y, z) (((x) & (y)) | (~(x) & (z))) +#define SET(a, b, c, d, k, s, Ti) \ + t = a + F(b, c, d) + X[k] + Ti; \ + a = ROTATE_LEFT(t, s) + b + + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 7, T1); + SET(d, a, b, c, 1, 12, T2); + SET(c, d, a, b, 2, 17, T3); + SET(b, c, d, a, 3, 22, T4); + SET(a, b, c, d, 4, 7, T5); + SET(d, a, b, c, 5, 12, T6); + SET(c, d, a, b, 6, 17, T7); + SET(b, c, d, a, 7, 22, T8); + SET(a, b, c, d, 8, 7, T9); + SET(d, a, b, c, 9, 12, T10); + SET(c, d, a, b, 10, 17, T11); + SET(b, c, d, a, 11, 22, T12); + SET(a, b, c, d, 12, 7, T13); + SET(d, a, b, c, 13, 12, T14); + SET(c, d, a, b, 14, 17, T15); + SET(b, c, d, a, 15, 22, T16); +#undef SET + +/* Round 2. */ +/* Let [abcd k s i] denote the operation + a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ +#define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) +#define SET(a, b, c, d, k, s, Ti) \ + t = a + G(b, c, d) + X[k] + Ti; \ + a = ROTATE_LEFT(t, s) + b + + /* Do the following 16 operations. */ + SET(a, b, c, d, 1, 5, T17); + SET(d, a, b, c, 6, 9, T18); + SET(c, d, a, b, 11, 14, T19); + SET(b, c, d, a, 0, 20, T20); + SET(a, b, c, d, 5, 5, T21); + SET(d, a, b, c, 10, 9, T22); + SET(c, d, a, b, 15, 14, T23); + SET(b, c, d, a, 4, 20, T24); + SET(a, b, c, d, 9, 5, T25); + SET(d, a, b, c, 14, 9, T26); + SET(c, d, a, b, 3, 14, T27); + SET(b, c, d, a, 8, 20, T28); + SET(a, b, c, d, 13, 5, T29); + SET(d, a, b, c, 2, 9, T30); + SET(c, d, a, b, 7, 14, T31); + SET(b, c, d, a, 12, 20, T32); +#undef SET + +/* Round 3. */ +/* Let [abcd k s t] denote the operation + a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define SET(a, b, c, d, k, s, Ti) \ + t = a + H(b, c, d) + X[k] + Ti; \ + a = ROTATE_LEFT(t, s) + b + + /* Do the following 16 operations. */ + SET(a, b, c, d, 5, 4, T33); + SET(d, a, b, c, 8, 11, T34); + SET(c, d, a, b, 11, 16, T35); + SET(b, c, d, a, 14, 23, T36); + SET(a, b, c, d, 1, 4, T37); + SET(d, a, b, c, 4, 11, T38); + SET(c, d, a, b, 7, 16, T39); + SET(b, c, d, a, 10, 23, T40); + SET(a, b, c, d, 13, 4, T41); + SET(d, a, b, c, 0, 11, T42); + SET(c, d, a, b, 3, 16, T43); + SET(b, c, d, a, 6, 23, T44); + SET(a, b, c, d, 9, 4, T45); + SET(d, a, b, c, 12, 11, T46); + SET(c, d, a, b, 15, 16, T47); + SET(b, c, d, a, 2, 23, T48); +#undef SET + +/* Round 4. */ +/* Let [abcd k s t] denote the operation + a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ +#define I(x, y, z) ((y) ^ ((x) | ~(z))) +#define SET(a, b, c, d, k, s, Ti) \ + t = a + I(b, c, d) + X[k] + Ti; \ + a = ROTATE_LEFT(t, s) + b + + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 6, T49); + SET(d, a, b, c, 7, 10, T50); + SET(c, d, a, b, 14, 15, T51); + SET(b, c, d, a, 5, 21, T52); + SET(a, b, c, d, 12, 6, T53); + SET(d, a, b, c, 3, 10, T54); + SET(c, d, a, b, 10, 15, T55); + SET(b, c, d, a, 1, 21, T56); + SET(a, b, c, d, 8, 6, T57); + SET(d, a, b, c, 15, 10, T58); + SET(c, d, a, b, 6, 15, T59); + SET(b, c, d, a, 13, 21, T60); + SET(a, b, c, d, 4, 6, T61); + SET(d, a, b, c, 11, 10, T62); + SET(c, d, a, b, 2, 15, T63); + SET(b, c, d, a, 9, 21, T64); +#undef SET + + /* Then perform the following additions. (That is increment each + of the four registers by the value it had before this block + was started.) */ + pms->abcd[0] += a; + pms->abcd[1] += b; + pms->abcd[2] += c; + pms->abcd[3] += d; +} + +MD5_STATIC void +md5_init(md5_state_t *pms) +{ + pms->count[0] = pms->count[1] = 0; + pms->abcd[0] = 0x67452301; + pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + pms->abcd[3] = 0x10325476; +} + +MD5_STATIC void +md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes) +{ + const md5_byte_t *p = data; + size_t left = nbytes; + size_t offset = (pms->count[0] >> 3) & 63; + md5_word_t nbits = (md5_word_t)(nbytes << 3); + + if (nbytes <= 0) + return; + + /* Update the message length. */ + pms->count[1] += (md5_word_t)(nbytes >> 29); + pms->count[0] += nbits; + if (pms->count[0] < nbits) + pms->count[1]++; + + /* Process an initial partial block. */ + if (offset) { + size_t copy = (offset + nbytes > 64 ? 64 - offset : nbytes); + + memcpy(pms->buf + offset, p, copy); + if (offset + copy < 64) + return; + p += copy; + left -= copy; + md5_process(pms, pms->buf); + } + + /* Process full blocks. */ + for (; left >= 64; p += 64, left -= 64) + md5_process(pms, p); + + /* Process a final partial block. */ + if (left) + memcpy(pms->buf, p, left); +} + +MD5_STATIC void +md5_finish(md5_state_t *pms, md5_byte_t digest[16]) +{ + static const md5_byte_t pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + md5_byte_t data[8]; + int i; + + /* Save the length before padding. */ + for (i = 0; i < 8; ++i) + data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3)); + /* Pad to 56 bytes mod 64. */ + md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); + /* Append the length. */ + md5_append(pms, data, 8); + for (i = 0; i < 16; ++i) + digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3)); +} + + +/* End of md5.inl */ + +/* Darwin prior to 7.0 and Win32 do not have socklen_t */ +#if defined(NO_SOCKLEN_T) +typedef int socklen_t; +#endif /* NO_SOCKLEN_T */ + +#define IP_ADDR_STR_LEN (50) /* IPv6 hex string is 46 chars */ + +#if !defined(MSG_NOSIGNAL) +#define MSG_NOSIGNAL (0) +#endif + + +#if defined(NO_SSL) +typedef struct SSL SSL; /* dummy for SSL argument to push/pull */ +typedef struct SSL_CTX SSL_CTX; +#else +#if defined(NO_SSL_DL) +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(WOLFSSL_VERSION) +/* Additional defines for WolfSSL, see + * https://github.com/civetweb/civetweb/issues/583 */ +#include "wolfssl_extras.inl" +#endif + +#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) +/* If OpenSSL headers are included, automatically select the API version */ +#if !defined(OPENSSL_API_1_1) +#define OPENSSL_API_1_1 +#endif +#define OPENSSL_REMOVE_THREAD_STATE() +#else +#define OPENSSL_REMOVE_THREAD_STATE() ERR_remove_thread_state(NULL) +#endif + +#else + +/* SSL loaded dynamically from DLL. + * I put the prototypes here to be independent from OpenSSL source + * installation. */ + +typedef struct ssl_st SSL; +typedef struct ssl_method_st SSL_METHOD; +typedef struct ssl_ctx_st SSL_CTX; +typedef struct x509_store_ctx_st X509_STORE_CTX; +typedef struct x509_name X509_NAME; +typedef struct asn1_integer ASN1_INTEGER; +typedef struct bignum BIGNUM; +typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS; +typedef struct evp_md EVP_MD; +typedef struct x509 X509; + + +#define SSL_CTRL_OPTIONS (32) +#define SSL_CTRL_CLEAR_OPTIONS (77) +#define SSL_CTRL_SET_ECDH_AUTO (94) + +#define OPENSSL_INIT_NO_LOAD_SSL_STRINGS 0x00100000L +#define OPENSSL_INIT_LOAD_SSL_STRINGS 0x00200000L +#define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L + +#define SSL_VERIFY_NONE (0) +#define SSL_VERIFY_PEER (1) +#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT (2) +#define SSL_VERIFY_CLIENT_ONCE (4) + +#define SSL_OP_ALL (0x80000BFFul) + +#define SSL_OP_NO_SSLv2 (0x01000000ul) +#define SSL_OP_NO_SSLv3 (0x02000000ul) +#define SSL_OP_NO_TLSv1 (0x04000000ul) +#define SSL_OP_NO_TLSv1_2 (0x08000000ul) +#define SSL_OP_NO_TLSv1_1 (0x10000000ul) +#define SSL_OP_NO_TLSv1_3 (0x20000000ul) +#define SSL_OP_SINGLE_DH_USE (0x00100000ul) +#define SSL_OP_CIPHER_SERVER_PREFERENCE (0x00400000ul) +#define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (0x00010000ul) +#define SSL_OP_NO_COMPRESSION (0x00020000ul) +#define SSL_OP_NO_RENEGOTIATION (0x40000000ul) + +#define SSL_CB_HANDSHAKE_START (0x10) +#define SSL_CB_HANDSHAKE_DONE (0x20) + +#define SSL_ERROR_NONE (0) +#define SSL_ERROR_SSL (1) +#define SSL_ERROR_WANT_READ (2) +#define SSL_ERROR_WANT_WRITE (3) +#define SSL_ERROR_WANT_X509_LOOKUP (4) +#define SSL_ERROR_SYSCALL (5) /* see errno */ +#define SSL_ERROR_ZERO_RETURN (6) +#define SSL_ERROR_WANT_CONNECT (7) +#define SSL_ERROR_WANT_ACCEPT (8) + +#define TLSEXT_TYPE_server_name (0) +#define TLSEXT_NAMETYPE_host_name (0) +#define SSL_TLSEXT_ERR_OK (0) +#define SSL_TLSEXT_ERR_ALERT_WARNING (1) +#define SSL_TLSEXT_ERR_ALERT_FATAL (2) +#define SSL_TLSEXT_ERR_NOACK (3) + +struct ssl_func { + const char *name; /* SSL function name */ + void (*ptr)(void); /* Function pointer */ +}; + + +#if defined(OPENSSL_API_1_1) + +#define SSL_free (*(void (*)(SSL *))ssl_sw[0].ptr) +#define SSL_accept (*(int (*)(SSL *))ssl_sw[1].ptr) +#define SSL_connect (*(int (*)(SSL *))ssl_sw[2].ptr) +#define SSL_read (*(int (*)(SSL *, void *, int))ssl_sw[3].ptr) +#define SSL_write (*(int (*)(SSL *, const void *, int))ssl_sw[4].ptr) +#define SSL_get_error (*(int (*)(SSL *, int))ssl_sw[5].ptr) +#define SSL_set_fd (*(int (*)(SSL *, SOCKET))ssl_sw[6].ptr) +#define SSL_new (*(SSL * (*)(SSL_CTX *)) ssl_sw[7].ptr) +#define SSL_CTX_new (*(SSL_CTX * (*)(SSL_METHOD *)) ssl_sw[8].ptr) +#define TLS_server_method (*(SSL_METHOD * (*)(void)) ssl_sw[9].ptr) +#define OPENSSL_init_ssl \ + (*(int (*)(uint64_t opts, \ + const OPENSSL_INIT_SETTINGS *settings))ssl_sw[10] \ + .ptr) +#define SSL_CTX_use_PrivateKey_file \ + (*(int (*)(SSL_CTX *, const char *, int))ssl_sw[11].ptr) +#define SSL_CTX_use_certificate_file \ + (*(int (*)(SSL_CTX *, const char *, int))ssl_sw[12].ptr) +#define SSL_CTX_set_default_passwd_cb \ + (*(void (*)(SSL_CTX *, mg_callback_t))ssl_sw[13].ptr) +#define SSL_CTX_free (*(void (*)(SSL_CTX *))ssl_sw[14].ptr) +#define SSL_CTX_use_certificate_chain_file \ + (*(int (*)(SSL_CTX *, const char *))ssl_sw[15].ptr) +#define TLS_client_method (*(SSL_METHOD * (*)(void)) ssl_sw[16].ptr) +#define SSL_pending (*(int (*)(SSL *))ssl_sw[17].ptr) +#define SSL_CTX_set_verify \ + (*(void (*)(SSL_CTX *, \ + int, \ + int (*verify_callback)(int, X509_STORE_CTX *)))ssl_sw[18] \ + .ptr) +#define SSL_shutdown (*(int (*)(SSL *))ssl_sw[19].ptr) +#define SSL_CTX_load_verify_locations \ + (*(int (*)(SSL_CTX *, const char *, const char *))ssl_sw[20].ptr) +#define SSL_CTX_set_default_verify_paths (*(int (*)(SSL_CTX *))ssl_sw[21].ptr) +#define SSL_CTX_set_verify_depth (*(void (*)(SSL_CTX *, int))ssl_sw[22].ptr) +#define SSL_get_peer_certificate (*(X509 * (*)(SSL *)) ssl_sw[23].ptr) +#define SSL_get_version (*(const char *(*)(SSL *))ssl_sw[24].ptr) +#define SSL_get_current_cipher (*(SSL_CIPHER * (*)(SSL *)) ssl_sw[25].ptr) +#define SSL_CIPHER_get_name \ + (*(const char *(*)(const SSL_CIPHER *))ssl_sw[26].ptr) +#define SSL_CTX_check_private_key (*(int (*)(SSL_CTX *))ssl_sw[27].ptr) +#define SSL_CTX_set_session_id_context \ + (*(int (*)(SSL_CTX *, const unsigned char *, unsigned int))ssl_sw[28].ptr) +#define SSL_CTX_ctrl (*(long (*)(SSL_CTX *, int, long, void *))ssl_sw[29].ptr) +#define SSL_CTX_set_cipher_list \ + (*(int (*)(SSL_CTX *, const char *))ssl_sw[30].ptr) +#define SSL_CTX_set_options \ + (*(unsigned long (*)(SSL_CTX *, unsigned long))ssl_sw[31].ptr) +#define SSL_CTX_set_info_callback \ + (*(void (*)(SSL_CTX * ctx, void (*callback)(const SSL *, int, int))) \ + ssl_sw[32] \ + .ptr) +#define SSL_get_ex_data (*(char *(*)(const SSL *, int))ssl_sw[33].ptr) +#define SSL_set_ex_data (*(void (*)(SSL *, int, char *))ssl_sw[34].ptr) +#define SSL_CTX_callback_ctrl \ + (*(long (*)(SSL_CTX *, int, void (*)(void)))ssl_sw[35].ptr) +#define SSL_get_servername \ + (*(const char *(*)(const SSL *, int type))ssl_sw[36].ptr) +#define SSL_set_SSL_CTX (*(SSL_CTX * (*)(SSL *, SSL_CTX *)) ssl_sw[37].ptr) +#define SSL_ctrl (*(long (*)(SSL *, int, long, void *))ssl_sw[38].ptr) + +#define SSL_CTX_clear_options(ctx, op) \ + SSL_CTX_ctrl((ctx), SSL_CTRL_CLEAR_OPTIONS, (op), NULL) +#define SSL_CTX_set_ecdh_auto(ctx, onoff) \ + SSL_CTX_ctrl(ctx, SSL_CTRL_SET_ECDH_AUTO, onoff, NULL) + +#define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB 53 +#define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG 54 +#define SSL_CTRL_SET_TLSEXT_HOSTNAME 55 +#define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \ + SSL_CTX_callback_ctrl(ctx, \ + SSL_CTRL_SET_TLSEXT_SERVERNAME_CB, \ + (void (*)(void))cb) +#define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \ + SSL_CTX_ctrl(ctx, SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG, 0, (void *)arg) +#define SSL_set_tlsext_host_name(ctx, arg) \ + SSL_ctrl(ctx, SSL_CTRL_SET_TLSEXT_HOSTNAME, 0, (void *)arg) + +#define X509_get_notBefore(x) ((x)->cert_info->validity->notBefore) +#define X509_get_notAfter(x) ((x)->cert_info->validity->notAfter) + +#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg)) +#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0)) + +#define ERR_get_error (*(unsigned long (*)(void))crypto_sw[0].ptr) +#define ERR_error_string (*(char *(*)(unsigned long, char *))crypto_sw[1].ptr) +#define CONF_modules_unload (*(void (*)(int))crypto_sw[2].ptr) +#define X509_free (*(void (*)(X509 *))crypto_sw[3].ptr) +#define X509_get_subject_name (*(X509_NAME * (*)(X509 *)) crypto_sw[4].ptr) +#define X509_get_issuer_name (*(X509_NAME * (*)(X509 *)) crypto_sw[5].ptr) +#define X509_NAME_oneline \ + (*(char *(*)(X509_NAME *, char *, int))crypto_sw[6].ptr) +#define X509_get_serialNumber (*(ASN1_INTEGER * (*)(X509 *)) crypto_sw[7].ptr) +#define EVP_get_digestbyname \ + (*(const EVP_MD *(*)(const char *))crypto_sw[8].ptr) +#define EVP_Digest \ + (*(int (*)( \ + const void *, size_t, void *, unsigned int *, const EVP_MD *, void *)) \ + crypto_sw[9] \ + .ptr) +#define i2d_X509 (*(int (*)(X509 *, unsigned char **))crypto_sw[10].ptr) +#define BN_bn2hex (*(char *(*)(const BIGNUM *a))crypto_sw[11].ptr) +#define ASN1_INTEGER_to_BN \ + (*(BIGNUM * (*)(const ASN1_INTEGER *ai, BIGNUM *bn)) crypto_sw[12].ptr) +#define BN_free (*(void (*)(const BIGNUM *a))crypto_sw[13].ptr) +#define CRYPTO_free (*(void (*)(void *addr))crypto_sw[14].ptr) +#define ERR_clear_error (*(void (*)(void))crypto_sw[15].ptr) + +#define OPENSSL_free(a) CRYPTO_free(a) + +#define OPENSSL_REMOVE_THREAD_STATE() + +/* init_ssl_ctx() function updates this array. + * It loads SSL library dynamically and changes NULLs to the actual addresses + * of respective functions. The macros above (like SSL_connect()) are really + * just calling these functions indirectly via the pointer. */ +static struct ssl_func ssl_sw[] = {{"SSL_free", NULL}, + {"SSL_accept", NULL}, + {"SSL_connect", NULL}, + {"SSL_read", NULL}, + {"SSL_write", NULL}, + {"SSL_get_error", NULL}, + {"SSL_set_fd", NULL}, + {"SSL_new", NULL}, + {"SSL_CTX_new", NULL}, + {"TLS_server_method", NULL}, + {"OPENSSL_init_ssl", NULL}, + {"SSL_CTX_use_PrivateKey_file", NULL}, + {"SSL_CTX_use_certificate_file", NULL}, + {"SSL_CTX_set_default_passwd_cb", NULL}, + {"SSL_CTX_free", NULL}, + {"SSL_CTX_use_certificate_chain_file", NULL}, + {"TLS_client_method", NULL}, + {"SSL_pending", NULL}, + {"SSL_CTX_set_verify", NULL}, + {"SSL_shutdown", NULL}, + {"SSL_CTX_load_verify_locations", NULL}, + {"SSL_CTX_set_default_verify_paths", NULL}, + {"SSL_CTX_set_verify_depth", NULL}, + {"SSL_get_peer_certificate", NULL}, + {"SSL_get_version", NULL}, + {"SSL_get_current_cipher", NULL}, + {"SSL_CIPHER_get_name", NULL}, + {"SSL_CTX_check_private_key", NULL}, + {"SSL_CTX_set_session_id_context", NULL}, + {"SSL_CTX_ctrl", NULL}, + {"SSL_CTX_set_cipher_list", NULL}, + {"SSL_CTX_set_options", NULL}, + {"SSL_CTX_set_info_callback", NULL}, + {"SSL_get_ex_data", NULL}, + {"SSL_set_ex_data", NULL}, + {"SSL_CTX_callback_ctrl", NULL}, + {"SSL_get_servername", NULL}, + {"SSL_set_SSL_CTX", NULL}, + {"SSL_ctrl", NULL}, + {NULL, NULL}}; + + +/* Similar array as ssl_sw. These functions could be located in different + * lib. */ +static struct ssl_func crypto_sw[] = {{"ERR_get_error", NULL}, + {"ERR_error_string", NULL}, + {"CONF_modules_unload", NULL}, + {"X509_free", NULL}, + {"X509_get_subject_name", NULL}, + {"X509_get_issuer_name", NULL}, + {"X509_NAME_oneline", NULL}, + {"X509_get_serialNumber", NULL}, + {"EVP_get_digestbyname", NULL}, + {"EVP_Digest", NULL}, + {"i2d_X509", NULL}, + {"BN_bn2hex", NULL}, + {"ASN1_INTEGER_to_BN", NULL}, + {"BN_free", NULL}, + {"CRYPTO_free", NULL}, + {"ERR_clear_error", NULL}, + {NULL, NULL}}; +#else + +#define SSL_free (*(void (*)(SSL *))ssl_sw[0].ptr) +#define SSL_accept (*(int (*)(SSL *))ssl_sw[1].ptr) +#define SSL_connect (*(int (*)(SSL *))ssl_sw[2].ptr) +#define SSL_read (*(int (*)(SSL *, void *, int))ssl_sw[3].ptr) +#define SSL_write (*(int (*)(SSL *, const void *, int))ssl_sw[4].ptr) +#define SSL_get_error (*(int (*)(SSL *, int))ssl_sw[5].ptr) +#define SSL_set_fd (*(int (*)(SSL *, SOCKET))ssl_sw[6].ptr) +#define SSL_new (*(SSL * (*)(SSL_CTX *)) ssl_sw[7].ptr) +#define SSL_CTX_new (*(SSL_CTX * (*)(SSL_METHOD *)) ssl_sw[8].ptr) +#define SSLv23_server_method (*(SSL_METHOD * (*)(void)) ssl_sw[9].ptr) +#define SSL_library_init (*(int (*)(void))ssl_sw[10].ptr) +#define SSL_CTX_use_PrivateKey_file \ + (*(int (*)(SSL_CTX *, const char *, int))ssl_sw[11].ptr) +#define SSL_CTX_use_certificate_file \ + (*(int (*)(SSL_CTX *, const char *, int))ssl_sw[12].ptr) +#define SSL_CTX_set_default_passwd_cb \ + (*(void (*)(SSL_CTX *, mg_callback_t))ssl_sw[13].ptr) +#define SSL_CTX_free (*(void (*)(SSL_CTX *))ssl_sw[14].ptr) +#define SSL_load_error_strings (*(void (*)(void))ssl_sw[15].ptr) +#define SSL_CTX_use_certificate_chain_file \ + (*(int (*)(SSL_CTX *, const char *))ssl_sw[16].ptr) +#define SSLv23_client_method (*(SSL_METHOD * (*)(void)) ssl_sw[17].ptr) +#define SSL_pending (*(int (*)(SSL *))ssl_sw[18].ptr) +#define SSL_CTX_set_verify \ + (*(void (*)(SSL_CTX *, \ + int, \ + int (*verify_callback)(int, X509_STORE_CTX *)))ssl_sw[19] \ + .ptr) +#define SSL_shutdown (*(int (*)(SSL *))ssl_sw[20].ptr) +#define SSL_CTX_load_verify_locations \ + (*(int (*)(SSL_CTX *, const char *, const char *))ssl_sw[21].ptr) +#define SSL_CTX_set_default_verify_paths (*(int (*)(SSL_CTX *))ssl_sw[22].ptr) +#define SSL_CTX_set_verify_depth (*(void (*)(SSL_CTX *, int))ssl_sw[23].ptr) +#define SSL_get_peer_certificate (*(X509 * (*)(SSL *)) ssl_sw[24].ptr) +#define SSL_get_version (*(const char *(*)(SSL *))ssl_sw[25].ptr) +#define SSL_get_current_cipher (*(SSL_CIPHER * (*)(SSL *)) ssl_sw[26].ptr) +#define SSL_CIPHER_get_name \ + (*(const char *(*)(const SSL_CIPHER *))ssl_sw[27].ptr) +#define SSL_CTX_check_private_key (*(int (*)(SSL_CTX *))ssl_sw[28].ptr) +#define SSL_CTX_set_session_id_context \ + (*(int (*)(SSL_CTX *, const unsigned char *, unsigned int))ssl_sw[29].ptr) +#define SSL_CTX_ctrl (*(long (*)(SSL_CTX *, int, long, void *))ssl_sw[30].ptr) +#define SSL_CTX_set_cipher_list \ + (*(int (*)(SSL_CTX *, const char *))ssl_sw[31].ptr) +#define SSL_CTX_set_info_callback \ + (*(void (*)(SSL_CTX *, void (*callback)(const SSL *, int, int)))ssl_sw[32] \ + .ptr) +#define SSL_get_ex_data (*(char *(*)(const SSL *, int))ssl_sw[33].ptr) +#define SSL_set_ex_data (*(void (*)(SSL *, int, char *))ssl_sw[34].ptr) +#define SSL_CTX_callback_ctrl \ + (*(long (*)(SSL_CTX *, int, void (*)(void)))ssl_sw[35].ptr) +#define SSL_get_servername \ + (*(const char *(*)(const SSL *, int type))ssl_sw[36].ptr) +#define SSL_set_SSL_CTX (*(SSL_CTX * (*)(SSL *, SSL_CTX *)) ssl_sw[37].ptr) +#define SSL_ctrl (*(long (*)(SSL *, int, long, void *))ssl_sw[38].ptr) + +#define SSL_CTX_set_options(ctx, op) \ + SSL_CTX_ctrl((ctx), SSL_CTRL_OPTIONS, (op), NULL) +#define SSL_CTX_clear_options(ctx, op) \ + SSL_CTX_ctrl((ctx), SSL_CTRL_CLEAR_OPTIONS, (op), NULL) +#define SSL_CTX_set_ecdh_auto(ctx, onoff) \ + SSL_CTX_ctrl(ctx, SSL_CTRL_SET_ECDH_AUTO, onoff, NULL) + +#define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB 53 +#define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG 54 +#define SSL_CTRL_SET_TLSEXT_HOSTNAME 55 +#define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \ + SSL_CTX_callback_ctrl(ctx, \ + SSL_CTRL_SET_TLSEXT_SERVERNAME_CB, \ + (void (*)(void))cb) +#define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \ + SSL_CTX_ctrl(ctx, SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG, 0, (void *)arg) +#define SSL_set_tlsext_host_name(ctx, arg) \ + SSL_ctrl(ctx, SSL_CTRL_SET_TLSEXT_HOSTNAME, 0, (void *)arg) + +#define X509_get_notBefore(x) ((x)->cert_info->validity->notBefore) +#define X509_get_notAfter(x) ((x)->cert_info->validity->notAfter) + +#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg)) +#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0)) + +#define CRYPTO_num_locks (*(int (*)(void))crypto_sw[0].ptr) +#define CRYPTO_set_locking_callback \ + (*(void (*)(void (*)(int, int, const char *, int)))crypto_sw[1].ptr) +#define CRYPTO_set_id_callback \ + (*(void (*)(unsigned long (*)(void)))crypto_sw[2].ptr) +#define ERR_get_error (*(unsigned long (*)(void))crypto_sw[3].ptr) +#define ERR_error_string (*(char *(*)(unsigned long, char *))crypto_sw[4].ptr) +#define ERR_remove_state (*(void (*)(unsigned long))crypto_sw[5].ptr) +#define ERR_free_strings (*(void (*)(void))crypto_sw[6].ptr) +#define ENGINE_cleanup (*(void (*)(void))crypto_sw[7].ptr) +#define CONF_modules_unload (*(void (*)(int))crypto_sw[8].ptr) +#define CRYPTO_cleanup_all_ex_data (*(void (*)(void))crypto_sw[9].ptr) +#define EVP_cleanup (*(void (*)(void))crypto_sw[10].ptr) +#define X509_free (*(void (*)(X509 *))crypto_sw[11].ptr) +#define X509_get_subject_name (*(X509_NAME * (*)(X509 *)) crypto_sw[12].ptr) +#define X509_get_issuer_name (*(X509_NAME * (*)(X509 *)) crypto_sw[13].ptr) +#define X509_NAME_oneline \ + (*(char *(*)(X509_NAME *, char *, int))crypto_sw[14].ptr) +#define X509_get_serialNumber (*(ASN1_INTEGER * (*)(X509 *)) crypto_sw[15].ptr) +#define i2c_ASN1_INTEGER \ + (*(int (*)(ASN1_INTEGER *, unsigned char **))crypto_sw[16].ptr) +#define EVP_get_digestbyname \ + (*(const EVP_MD *(*)(const char *))crypto_sw[17].ptr) +#define EVP_Digest \ + (*(int (*)( \ + const void *, size_t, void *, unsigned int *, const EVP_MD *, void *)) \ + crypto_sw[18] \ + .ptr) +#define i2d_X509 (*(int (*)(X509 *, unsigned char **))crypto_sw[19].ptr) +#define BN_bn2hex (*(char *(*)(const BIGNUM *a))crypto_sw[20].ptr) +#define ASN1_INTEGER_to_BN \ + (*(BIGNUM * (*)(const ASN1_INTEGER *ai, BIGNUM *bn)) crypto_sw[21].ptr) +#define BN_free (*(void (*)(const BIGNUM *a))crypto_sw[22].ptr) +#define CRYPTO_free (*(void (*)(void *addr))crypto_sw[23].ptr) +#define ERR_clear_error (*(void (*)(void))crypto_sw[24].ptr) + +#define OPENSSL_free(a) CRYPTO_free(a) + +/* use here ERR_remove_state, + * while on some platforms function is not included into library due to + * deprication */ +#define OPENSSL_REMOVE_THREAD_STATE() ERR_remove_state(0) + +/* init_ssl_ctx() function updates this array. + * It loads SSL library dynamically and changes NULLs to the actual addresses + * of respective functions. The macros above (like SSL_connect()) are really + * just calling these functions indirectly via the pointer. */ +static struct ssl_func ssl_sw[] = {{"SSL_free", NULL}, + {"SSL_accept", NULL}, + {"SSL_connect", NULL}, + {"SSL_read", NULL}, + {"SSL_write", NULL}, + {"SSL_get_error", NULL}, + {"SSL_set_fd", NULL}, + {"SSL_new", NULL}, + {"SSL_CTX_new", NULL}, + {"SSLv23_server_method", NULL}, + {"SSL_library_init", NULL}, + {"SSL_CTX_use_PrivateKey_file", NULL}, + {"SSL_CTX_use_certificate_file", NULL}, + {"SSL_CTX_set_default_passwd_cb", NULL}, + {"SSL_CTX_free", NULL}, + {"SSL_load_error_strings", NULL}, + {"SSL_CTX_use_certificate_chain_file", NULL}, + {"SSLv23_client_method", NULL}, + {"SSL_pending", NULL}, + {"SSL_CTX_set_verify", NULL}, + {"SSL_shutdown", NULL}, + {"SSL_CTX_load_verify_locations", NULL}, + {"SSL_CTX_set_default_verify_paths", NULL}, + {"SSL_CTX_set_verify_depth", NULL}, + {"SSL_get_peer_certificate", NULL}, + {"SSL_get_version", NULL}, + {"SSL_get_current_cipher", NULL}, + {"SSL_CIPHER_get_name", NULL}, + {"SSL_CTX_check_private_key", NULL}, + {"SSL_CTX_set_session_id_context", NULL}, + {"SSL_CTX_ctrl", NULL}, + {"SSL_CTX_set_cipher_list", NULL}, + {"SSL_CTX_set_info_callback", NULL}, + {"SSL_get_ex_data", NULL}, + {"SSL_set_ex_data", NULL}, + {"SSL_CTX_callback_ctrl", NULL}, + {"SSL_get_servername", NULL}, + {"SSL_set_SSL_CTX", NULL}, + {"SSL_ctrl", NULL}, + {NULL, NULL}}; + + +/* Similar array as ssl_sw. These functions could be located in different + * lib. */ +static struct ssl_func crypto_sw[] = {{"CRYPTO_num_locks", NULL}, + {"CRYPTO_set_locking_callback", NULL}, + {"CRYPTO_set_id_callback", NULL}, + {"ERR_get_error", NULL}, + {"ERR_error_string", NULL}, + {"ERR_remove_state", NULL}, + {"ERR_free_strings", NULL}, + {"ENGINE_cleanup", NULL}, + {"CONF_modules_unload", NULL}, + {"CRYPTO_cleanup_all_ex_data", NULL}, + {"EVP_cleanup", NULL}, + {"X509_free", NULL}, + {"X509_get_subject_name", NULL}, + {"X509_get_issuer_name", NULL}, + {"X509_NAME_oneline", NULL}, + {"X509_get_serialNumber", NULL}, + {"i2c_ASN1_INTEGER", NULL}, + {"EVP_get_digestbyname", NULL}, + {"EVP_Digest", NULL}, + {"i2d_X509", NULL}, + {"BN_bn2hex", NULL}, + {"ASN1_INTEGER_to_BN", NULL}, + {"BN_free", NULL}, + {"CRYPTO_free", NULL}, + {"ERR_clear_error", NULL}, + {NULL, NULL}}; +#endif /* OPENSSL_API_1_1 */ +#endif /* NO_SSL_DL */ +#endif /* NO_SSL */ + + +#if !defined(NO_CACHING) +static const char month_names[][4] = {"Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec"}; +#endif /* !NO_CACHING */ + +/* Unified socket address. For IPv6 support, add IPv6 address structure in + * the + * union u. */ +union usa { + struct sockaddr sa; + struct sockaddr_in sin; +#if defined(USE_IPV6) + struct sockaddr_in6 sin6; +#endif +}; + +/* Describes a string (chunk of memory). */ +struct vec { + const char *ptr; + size_t len; +}; + +struct mg_file_stat { + /* File properties filled by mg_stat: */ + uint64_t size; + time_t last_modified; + int is_directory; /* Set to 1 if mg_stat is called for a directory */ + int is_gzipped; /* Set to 1 if the content is gzipped, in which + * case we need a "Content-Eencoding: gzip" header */ + int location; /* 0 = nowhere, 1 = on disk, 2 = in memory */ +}; + +struct mg_file_in_memory { + char *p; + uint32_t pos; + char mode; +}; + +struct mg_file_access { + /* File properties filled by mg_fopen: */ + FILE *fp; +#if defined(MG_USE_OPEN_FILE) + /* TODO (low): Remove obsolete "file in memory" implementation. + * In an "early 2017" discussion at Google groups + * https://groups.google.com/forum/#!topic/civetweb/h9HT4CmeYqI + * we decided to get rid of this feature (after some fade-out + * phase). */ + const char *membuf; +#endif +}; + +struct mg_file { + struct mg_file_stat stat; + struct mg_file_access access; +}; + +#if defined(MG_USE_OPEN_FILE) + +#define STRUCT_FILE_INITIALIZER \ + { \ + {(uint64_t)0, (time_t)0, 0, 0, 0}, \ + { \ + (FILE *)NULL, (const char *)NULL \ + } \ + } + +#else + +#define STRUCT_FILE_INITIALIZER \ + { \ + {(uint64_t)0, (time_t)0, 0, 0, 0}, \ + { \ + (FILE *)NULL \ + } \ + } + +#endif + + +/* Describes listening socket, or socket which was accept()-ed by the master + * thread and queued for future handling by the worker thread. */ +struct socket { + SOCKET sock; /* Listening socket */ + union usa lsa; /* Local socket address */ + union usa rsa; /* Remote socket address */ + unsigned char is_ssl; /* Is port SSL-ed */ + unsigned char ssl_redir; /* Is port supposed to redirect everything to SSL + * port */ + unsigned char in_use; /* 0: invalid, 1: valid, 2: free */ +}; + + +/* Enum const for all options must be in sync with + * static struct mg_option config_options[] + * This is tested in the unit test (test/private.c) + * "Private Config Options" + */ +enum { + /* Once for each server */ + LISTENING_PORTS, + NUM_THREADS, + RUN_AS_USER, + CONFIG_TCP_NODELAY, /* Prepended CONFIG_ to avoid conflict with the + * socket option typedef TCP_NODELAY. */ + MAX_REQUEST_SIZE, + LINGER_TIMEOUT, +#if defined(__linux__) + ALLOW_SENDFILE_CALL, +#endif +#if defined(_WIN32) + CASE_SENSITIVE_FILES, +#endif + THROTTLE, + ACCESS_LOG_FILE, + ERROR_LOG_FILE, + ENABLE_KEEP_ALIVE, + REQUEST_TIMEOUT, + KEEP_ALIVE_TIMEOUT, +#if defined(USE_WEBSOCKET) + WEBSOCKET_TIMEOUT, + ENABLE_WEBSOCKET_PING_PONG, +#endif + DECODE_URL, +#if defined(USE_LUA) + LUA_BACKGROUND_SCRIPT, + LUA_BACKGROUND_SCRIPT_PARAMS, +#endif +#if defined(USE_TIMERS) + CGI_TIMEOUT, +#endif + + /* Once for each domain */ + DOCUMENT_ROOT, + CGI_EXTENSIONS, + CGI_ENVIRONMENT, + PUT_DELETE_PASSWORDS_FILE, + CGI_INTERPRETER, + PROTECT_URI, + AUTHENTICATION_DOMAIN, + ENABLE_AUTH_DOMAIN_CHECK, + SSI_EXTENSIONS, + ENABLE_DIRECTORY_LISTING, + GLOBAL_PASSWORDS_FILE, + INDEX_FILES, + ACCESS_CONTROL_LIST, + EXTRA_MIME_TYPES, + SSL_CERTIFICATE, + SSL_CERTIFICATE_CHAIN, + URL_REWRITE_PATTERN, + HIDE_FILES, + SSL_DO_VERIFY_PEER, + SSL_CA_PATH, + SSL_CA_FILE, + SSL_VERIFY_DEPTH, + SSL_DEFAULT_VERIFY_PATHS, + SSL_CIPHER_LIST, + SSL_PROTOCOL_VERSION, + SSL_SHORT_TRUST, + +#if defined(USE_LUA) + LUA_PRELOAD_FILE, + LUA_SCRIPT_EXTENSIONS, + LUA_SERVER_PAGE_EXTENSIONS, +#if defined(MG_EXPERIMENTAL_INTERFACES) + LUA_DEBUG_PARAMS, +#endif +#endif +#if defined(USE_DUKTAPE) + DUKTAPE_SCRIPT_EXTENSIONS, +#endif + +#if defined(USE_WEBSOCKET) + WEBSOCKET_ROOT, +#endif +#if defined(USE_LUA) && defined(USE_WEBSOCKET) + LUA_WEBSOCKET_EXTENSIONS, +#endif + + ACCESS_CONTROL_ALLOW_ORIGIN, + ACCESS_CONTROL_ALLOW_METHODS, + ACCESS_CONTROL_ALLOW_HEADERS, + ERROR_PAGES, +#if !defined(NO_CACHING) + STATIC_FILE_MAX_AGE, +#endif +#if !defined(NO_SSL) + STRICT_HTTPS_MAX_AGE, +#endif + ADDITIONAL_HEADER, + ALLOW_INDEX_SCRIPT_SUB_RES, +#if defined(DAEMONIZE) + ENABLE_DAEMONIZE, +#endif + + NUM_OPTIONS +}; + + +/* Config option name, config types, default value. + * Must be in the same order as the enum const above. + */ +static const struct mg_option config_options[] = { + + /* Once for each server */ + {"listening_ports", MG_CONFIG_TYPE_STRING_LIST, "8080"}, + {"num_threads", MG_CONFIG_TYPE_NUMBER, "50"}, + {"run_as_user", MG_CONFIG_TYPE_STRING, NULL}, + {"tcp_nodelay", MG_CONFIG_TYPE_NUMBER, "0"}, + {"max_request_size", MG_CONFIG_TYPE_NUMBER, "16384"}, + {"linger_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL}, +#if defined(__linux__) + {"allow_sendfile_call", MG_CONFIG_TYPE_BOOLEAN, "yes"}, +#endif +#if defined(_WIN32) + {"case_sensitive", MG_CONFIG_TYPE_BOOLEAN, "no"}, +#endif + {"throttle", MG_CONFIG_TYPE_STRING_LIST, NULL}, + {"access_log_file", MG_CONFIG_TYPE_FILE, NULL}, + {"error_log_file", MG_CONFIG_TYPE_FILE, NULL}, + {"enable_keep_alive", MG_CONFIG_TYPE_BOOLEAN, "no"}, + {"request_timeout_ms", MG_CONFIG_TYPE_NUMBER, "30000"}, + {"keep_alive_timeout_ms", MG_CONFIG_TYPE_NUMBER, "500"}, +#if defined(USE_WEBSOCKET) + {"websocket_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL}, + {"enable_websocket_ping_pong", MG_CONFIG_TYPE_BOOLEAN, "no"}, +#endif + {"decode_url", MG_CONFIG_TYPE_BOOLEAN, "yes"}, +#if defined(USE_LUA) + {"lua_background_script", MG_CONFIG_TYPE_FILE, NULL}, + {"lua_background_script_params", MG_CONFIG_TYPE_STRING_LIST, NULL}, +#endif +#if defined(USE_TIMERS) + {"cgi_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL}, +#endif + + /* Once for each domain */ + {"document_root", MG_CONFIG_TYPE_DIRECTORY, NULL}, + {"cgi_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.cgi$|**.pl$|**.php$"}, + {"cgi_environment", MG_CONFIG_TYPE_STRING_LIST, NULL}, + {"put_delete_auth_file", MG_CONFIG_TYPE_FILE, NULL}, + {"cgi_interpreter", MG_CONFIG_TYPE_FILE, NULL}, + {"protect_uri", MG_CONFIG_TYPE_STRING_LIST, NULL}, + {"authentication_domain", MG_CONFIG_TYPE_STRING, "mydomain.com"}, + {"enable_auth_domain_check", MG_CONFIG_TYPE_BOOLEAN, "yes"}, + {"ssi_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.shtml$|**.shtm$"}, + {"enable_directory_listing", MG_CONFIG_TYPE_BOOLEAN, "yes"}, + {"global_auth_file", MG_CONFIG_TYPE_FILE, NULL}, + {"index_files", + MG_CONFIG_TYPE_STRING_LIST, +#if defined(USE_LUA) + "index.xhtml,index.html,index.htm," + "index.lp,index.lsp,index.lua,index.cgi," + "index.shtml,index.php"}, +#else + "index.xhtml,index.html,index.htm,index.cgi,index.shtml,index.php"}, +#endif + {"access_control_list", MG_CONFIG_TYPE_STRING_LIST, NULL}, + {"extra_mime_types", MG_CONFIG_TYPE_STRING_LIST, NULL}, + {"ssl_certificate", MG_CONFIG_TYPE_FILE, NULL}, + {"ssl_certificate_chain", MG_CONFIG_TYPE_FILE, NULL}, + {"url_rewrite_patterns", MG_CONFIG_TYPE_STRING_LIST, NULL}, + {"hide_files_patterns", MG_CONFIG_TYPE_EXT_PATTERN, NULL}, + + {"ssl_verify_peer", MG_CONFIG_TYPE_YES_NO_OPTIONAL, "no"}, + + {"ssl_ca_path", MG_CONFIG_TYPE_DIRECTORY, NULL}, + {"ssl_ca_file", MG_CONFIG_TYPE_FILE, NULL}, + {"ssl_verify_depth", MG_CONFIG_TYPE_NUMBER, "9"}, + {"ssl_default_verify_paths", MG_CONFIG_TYPE_BOOLEAN, "yes"}, + {"ssl_cipher_list", MG_CONFIG_TYPE_STRING, NULL}, + {"ssl_protocol_version", MG_CONFIG_TYPE_NUMBER, "0"}, + {"ssl_short_trust", MG_CONFIG_TYPE_BOOLEAN, "no"}, + +#if defined(USE_LUA) + {"lua_preload_file", MG_CONFIG_TYPE_FILE, NULL}, + {"lua_script_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lua$"}, + {"lua_server_page_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lp$|**.lsp$"}, +#if defined(MG_EXPERIMENTAL_INTERFACES) + {"lua_debug", MG_CONFIG_TYPE_STRING, NULL}, +#endif +#endif +#if defined(USE_DUKTAPE) + /* The support for duktape is still in alpha version state. + * The name of this config option might change. */ + {"duktape_script_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.ssjs$"}, +#endif + +#if defined(USE_WEBSOCKET) + {"websocket_root", MG_CONFIG_TYPE_DIRECTORY, NULL}, +#endif +#if defined(USE_LUA) && defined(USE_WEBSOCKET) + {"lua_websocket_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lua$"}, +#endif + {"access_control_allow_origin", MG_CONFIG_TYPE_STRING, "*"}, + {"access_control_allow_methods", MG_CONFIG_TYPE_STRING, "*"}, + {"access_control_allow_headers", MG_CONFIG_TYPE_STRING, "*"}, + {"error_pages", MG_CONFIG_TYPE_DIRECTORY, NULL}, +#if !defined(NO_CACHING) + {"static_file_max_age", MG_CONFIG_TYPE_NUMBER, "3600"}, +#endif +#if !defined(NO_SSL) + {"strict_transport_security_max_age", MG_CONFIG_TYPE_NUMBER, NULL}, +#endif + {"additional_header", MG_CONFIG_TYPE_STRING_MULTILINE, NULL}, + {"allow_index_script_resource", MG_CONFIG_TYPE_BOOLEAN, "no"}, +#if defined(DAEMONIZE) + {"daemonize", MG_CONFIG_TYPE_BOOLEAN, "no"}, +#endif + + {NULL, MG_CONFIG_TYPE_UNKNOWN, NULL}}; + + +/* Check if the config_options and the corresponding enum have compatible + * sizes. */ +mg_static_assert((sizeof(config_options) / sizeof(config_options[0])) + == (NUM_OPTIONS + 1), + "config_options and enum not sync"); + + +enum { REQUEST_HANDLER, WEBSOCKET_HANDLER, AUTH_HANDLER }; + + +struct mg_handler_info { + /* Name/Pattern of the URI. */ + char *uri; + size_t uri_len; + + /* handler type */ + int handler_type; + + /* Handler for http/https or authorization requests. */ + mg_request_handler handler; + unsigned int refcount; + pthread_mutex_t refcount_mutex; /* Protects refcount */ + pthread_cond_t + refcount_cond; /* Signaled when handler refcount is decremented */ + + /* Handler for ws/wss (websocket) requests. */ + mg_websocket_connect_handler connect_handler; + mg_websocket_ready_handler ready_handler; + mg_websocket_data_handler data_handler; + mg_websocket_close_handler close_handler; + + /* accepted subprotocols for ws/wss requests. */ + struct mg_websocket_subprotocols *subprotocols; + + /* Handler for authorization requests */ + mg_authorization_handler auth_handler; + + /* User supplied argument for the handler function. */ + void *cbdata; + + /* next handler in a linked list */ + struct mg_handler_info *next; +}; + + +enum { + CONTEXT_INVALID, + CONTEXT_SERVER, + CONTEXT_HTTP_CLIENT, + CONTEXT_WS_CLIENT +}; + + +struct mg_domain_context { + SSL_CTX *ssl_ctx; /* SSL context */ + char *config[NUM_OPTIONS]; /* Civetweb configuration parameters */ + struct mg_handler_info *handlers; /* linked list of uri handlers */ + + /* Server nonce */ + uint64_t auth_nonce_mask; /* Mask for all nonce values */ + unsigned long nonce_count; /* Used nonces, used for authentication */ + +#if defined(USE_LUA) && defined(USE_WEBSOCKET) + /* linked list of shared lua websockets */ + struct mg_shared_lua_websocket_list *shared_lua_websockets; +#endif + + /* Linked list of domains */ + struct mg_domain_context *next; +}; + + +struct mg_context { + + /* Part 1 - Physical context: + * This holds threads, ports, timeouts, ... + * set for the entire server, independent from the + * addressed hostname. + */ + + /* Connection related */ + int context_type; /* See CONTEXT_* above */ + + struct socket *listening_sockets; + struct mg_pollfd *listening_socket_fds; + unsigned int num_listening_sockets; + + struct mg_connection *worker_connections; /* The connection struct, pre- + * allocated for each worker */ + +#if defined(USE_SERVER_STATS) + int active_connections; + int max_connections; + int64_t total_connections; + int64_t total_requests; + int64_t total_data_read; + int64_t total_data_written; +#endif + + /* Thread related */ + volatile int stop_flag; /* Should we stop event loop */ + pthread_mutex_t thread_mutex; /* Protects (max|num)_threads */ + + pthread_t masterthreadid; /* The master thread ID */ + unsigned int + cfg_worker_threads; /* The number of configured worker threads. */ + pthread_t *worker_threadids; /* The worker thread IDs */ + +/* Connection to thread dispatching */ +#if defined(ALTERNATIVE_QUEUE) + struct socket *client_socks; + void **client_wait_events; +#else + struct socket queue[MGSQLEN]; /* Accepted sockets */ + volatile int sq_head; /* Head of the socket queue */ + volatile int sq_tail; /* Tail of the socket queue */ + pthread_cond_t sq_full; /* Signaled when socket is produced */ + pthread_cond_t sq_empty; /* Signaled when socket is consumed */ +#endif + + /* Memory related */ + unsigned int max_request_size; /* The max request size */ + +#if defined(USE_SERVER_STATS) + struct mg_memory_stat ctx_memory; +#endif + + /* Operating system related */ + char *systemName; /* What operating system is running */ + time_t start_time; /* Server start time, used for authentication + * and for diagnstics. */ + +#if defined(USE_TIMERS) + struct ttimers *timers; +#endif + +/* Lua specific: Background operations and shared websockets */ +#if defined(USE_LUA) + void *lua_background_state; +#endif + + /* Server nonce */ + pthread_mutex_t nonce_mutex; /* Protects nonce_count */ + + /* Server callbacks */ + struct mg_callbacks callbacks; /* User-defined callback function */ + void *user_data; /* User-defined data */ + + /* Part 2 - Logical domain: + * This holds hostname, TLS certificate, document root, ... + * set for a domain hosted at the server. + * There may be multiple domains hosted at one physical server. + * The default domain "dd" is the first element of a list of + * domains. + */ + struct mg_domain_context dd; /* default domain */ +}; + + +#if defined(USE_SERVER_STATS) +static struct mg_memory_stat mg_common_memory = {0, 0, 0}; + +static struct mg_memory_stat * +get_memory_stat(struct mg_context *ctx) +{ + if (ctx) { + return &(ctx->ctx_memory); + } + return &mg_common_memory; +} +#endif + +enum { + CONNECTION_TYPE_INVALID, + CONNECTION_TYPE_REQUEST, + CONNECTION_TYPE_RESPONSE +}; + +struct mg_connection { + int connection_type; /* see CONNECTION_TYPE_* above */ + + struct mg_request_info request_info; + struct mg_response_info response_info; + + struct mg_context *phys_ctx; + struct mg_domain_context *dom_ctx; + +#if defined(USE_SERVER_STATS) + int conn_state; /* 0 = undef, numerical value may change in different + * versions. For the current definition, see + * mg_get_connection_info_impl */ +#endif + + const char *host; /* Host (HTTP/1.1 header or SNI) */ + SSL *ssl; /* SSL descriptor */ + struct socket client; /* Connected client */ + time_t conn_birth_time; /* Time (wall clock) when connection was + * established */ + struct timespec req_time; /* Time (since system start) when the request + * was received */ + int64_t num_bytes_sent; /* Total bytes sent to client */ + int64_t content_len; /* How many bytes of content can be read + * !is_chunked: Content-Length header value + * or -1 (until connection closed, + * not allowed for a request) + * is_chunked: >= 0, appended gradually + */ + int64_t consumed_content; /* How many bytes of content have been read */ + int is_chunked; /* Transfer-Encoding is chunked: + * 0 = not chunked, + * 1 = chunked, not yet, or some data read, + * 2 = chunked, has error, + * 3 = chunked, all data read except trailer, + * 4 = chunked, all data read + */ + char *buf; /* Buffer for received data */ + char *path_info; /* PATH_INFO part of the URL */ + + int must_close; /* 1 if connection must be closed */ + int accept_gzip; /* 1 if gzip encoding is accepted */ + int in_error_handler; /* 1 if in handler for user defined error + * pages */ +#if defined(USE_WEBSOCKET) + int in_websocket_handling; /* 1 if in read_websocket */ +#endif + int handled_requests; /* Number of requests handled by this connection + */ + int buf_size; /* Buffer size */ + int request_len; /* Size of the request + headers in a buffer */ + int data_len; /* Total size of data in a buffer */ + int status_code; /* HTTP reply status code, e.g. 200 */ + int throttle; /* Throttling, bytes/sec. <= 0 means no + * throttle */ + + time_t last_throttle_time; /* Last time throttled data was sent */ + int last_throttle_bytes; /* Bytes sent this second */ + pthread_mutex_t mutex; /* Used by mg_(un)lock_connection to ensure + * atomic transmissions for websockets */ +#if defined(USE_LUA) && defined(USE_WEBSOCKET) + void *lua_websocket_state; /* Lua_State for a websocket connection */ +#endif + + void *tls_user_ptr; /* User defined pointer in thread local storage, + * for quick access */ +}; + + +/* Directory entry */ +struct de { + struct mg_connection *conn; + char *file_name; + struct mg_file_stat file; +}; + + +#if defined(USE_WEBSOCKET) +static int is_websocket_protocol(const struct mg_connection *conn); +#else +#define is_websocket_protocol(conn) (0) +#endif + + +#define mg_cry_internal(conn, fmt, ...) \ + mg_cry_internal_wrap(conn, NULL, __func__, __LINE__, fmt, __VA_ARGS__) + +#define mg_cry_ctx_internal(ctx, fmt, ...) \ + mg_cry_internal_wrap(NULL, ctx, __func__, __LINE__, fmt, __VA_ARGS__) + +static void mg_cry_internal_wrap(const struct mg_connection *conn, + struct mg_context *ctx, + const char *func, + unsigned line, + const char *fmt, + ...) PRINTF_ARGS(5, 6); + + +#if !defined(NO_THREAD_NAME) +#if defined(_WIN32) && defined(_MSC_VER) +/* Set the thread name for debugging purposes in Visual Studio + * http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx + */ +#pragma pack(push, 8) +typedef struct tagTHREADNAME_INFO { + DWORD dwType; /* Must be 0x1000. */ + LPCSTR szName; /* Pointer to name (in user addr space). */ + DWORD dwThreadID; /* Thread ID (-1=caller thread). */ + DWORD dwFlags; /* Reserved for future use, must be zero. */ +} THREADNAME_INFO; +#pragma pack(pop) + +#elif defined(__linux__) + +#include +#include +#if defined(ALTERNATIVE_QUEUE) +#include +#endif /* ALTERNATIVE_QUEUE */ + + +#if defined(ALTERNATIVE_QUEUE) + +static void * +event_create(void) +{ + int evhdl = eventfd(0, EFD_CLOEXEC); + int *ret; + + if (evhdl == -1) { + /* Linux uses -1 on error, Windows NULL. */ + /* However, Linux does not return 0 on success either. */ + return 0; + } + + ret = (int *)mg_malloc(sizeof(int)); + if (ret) { + *ret = evhdl; + } else { + (void)close(evhdl); + } + + return (void *)ret; +} + + +static int +event_wait(void *eventhdl) +{ + uint64_t u; + int evhdl, s; + + if (!eventhdl) { + /* error */ + return 0; + } + evhdl = *(int *)eventhdl; + + s = (int)read(evhdl, &u, sizeof(u)); + if (s != sizeof(u)) { + /* error */ + return 0; + } + (void)u; /* the value is not required */ + return 1; +} + + +static int +event_signal(void *eventhdl) +{ + uint64_t u = 1; + int evhdl, s; + + if (!eventhdl) { + /* error */ + return 0; + } + evhdl = *(int *)eventhdl; + + s = (int)write(evhdl, &u, sizeof(u)); + if (s != sizeof(u)) { + /* error */ + return 0; + } + return 1; +} + + +static void +event_destroy(void *eventhdl) +{ + int evhdl; + + if (!eventhdl) { + /* error */ + return; + } + evhdl = *(int *)eventhdl; + + close(evhdl); + mg_free(eventhdl); +} + + +#endif + +#endif + + +#if !defined(__linux__) && !defined(_WIN32) && defined(ALTERNATIVE_QUEUE) + +struct posix_event { + pthread_mutex_t mutex; + pthread_cond_t cond; + int signaled; +}; + + +static void * +event_create(void) +{ + struct posix_event *ret = mg_malloc(sizeof(struct posix_event)); + if (ret == 0) { + /* out of memory */ + return 0; + } + if (0 != pthread_mutex_init(&(ret->mutex), NULL)) { + /* pthread mutex not available */ + mg_free(ret); + return 0; + } + if (0 != pthread_cond_init(&(ret->cond), NULL)) { + /* pthread cond not available */ + pthread_mutex_destroy(&(ret->mutex)); + mg_free(ret); + return 0; + } + ret->signaled = 0; + return (void *)ret; +} + + +static int +event_wait(void *eventhdl) +{ + struct posix_event *ev = (struct posix_event *)eventhdl; + pthread_mutex_lock(&(ev->mutex)); + while (!ev->signaled) { + pthread_cond_wait(&(ev->cond), &(ev->mutex)); + } + ev->signaled = 0; + pthread_mutex_unlock(&(ev->mutex)); + return 1; +} + + +static int +event_signal(void *eventhdl) +{ + struct posix_event *ev = (struct posix_event *)eventhdl; + pthread_mutex_lock(&(ev->mutex)); + pthread_cond_signal(&(ev->cond)); + ev->signaled = 1; + pthread_mutex_unlock(&(ev->mutex)); + return 1; +} + + +static void +event_destroy(void *eventhdl) +{ + struct posix_event *ev = (struct posix_event *)eventhdl; + pthread_cond_destroy(&(ev->cond)); + pthread_mutex_destroy(&(ev->mutex)); + mg_free(ev); +} +#endif + + +static void +mg_set_thread_name(const char *name) +{ + char threadName[16 + 1]; /* 16 = Max. thread length in Linux/OSX/.. */ + + mg_snprintf( + NULL, NULL, threadName, sizeof(threadName), "civetweb-%s", name); + +#if defined(_WIN32) +#if defined(_MSC_VER) + /* Windows and Visual Studio Compiler */ + __try { + THREADNAME_INFO info; + info.dwType = 0x1000; + info.szName = threadName; + info.dwThreadID = ~0U; + info.dwFlags = 0; + + RaiseException(0x406D1388, + 0, + sizeof(info) / sizeof(ULONG_PTR), + (ULONG_PTR *)&info); + } __except (EXCEPTION_EXECUTE_HANDLER) { + } +#elif defined(__MINGW32__) +/* No option known to set thread name for MinGW */ +#endif +#elif defined(_GNU_SOURCE) && defined(__GLIBC__) \ + && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 12))) +/* pthread_setname_np first appeared in glibc in version 2.12*/ +#if defined(__MACH__) + /* OS X only current thread name can be changed */ + (void)pthread_setname_np(threadName); +#else + (void)pthread_setname_np(pthread_self(), threadName); +#endif +#elif defined(__linux__) + /* on linux we can use the old prctl function */ + (void)prctl(PR_SET_NAME, threadName, 0, 0, 0); +#endif +} +#else /* !defined(NO_THREAD_NAME) */ +void +mg_set_thread_name(const char *threadName) +{ +} +#endif + + +#if defined(MG_LEGACY_INTERFACE) +const char ** +mg_get_valid_option_names(void) +{ + /* This function is deprecated. Use mg_get_valid_options instead. */ + static const char + *data[2 * sizeof(config_options) / sizeof(config_options[0])] = {0}; + int i; + + for (i = 0; config_options[i].name != NULL; i++) { + data[i * 2] = config_options[i].name; + data[i * 2 + 1] = config_options[i].default_value; + } + + return data; +} +#endif + + +const struct mg_option * +mg_get_valid_options(void) +{ + return config_options; +} + + +/* Do not open file (used in is_file_in_memory) */ +#define MG_FOPEN_MODE_NONE (0) + +/* Open file for read only access */ +#define MG_FOPEN_MODE_READ (1) + +/* Open file for writing, create and overwrite */ +#define MG_FOPEN_MODE_WRITE (2) + +/* Open file for writing, create and append */ +#define MG_FOPEN_MODE_APPEND (4) + + +/* If a file is in memory, set all "stat" members and the membuf pointer of + * output filep and return 1, otherwise return 0 and don't modify anything. + */ +static int +open_file_in_memory(const struct mg_connection *conn, + const char *path, + struct mg_file *filep, + int mode) +{ +#if defined(MG_USE_OPEN_FILE) + + size_t size = 0; + const char *buf = NULL; + if (!conn) { + return 0; + } + + if ((mode != MG_FOPEN_MODE_NONE) && (mode != MG_FOPEN_MODE_READ)) { + return 0; + } + + if (conn->phys_ctx->callbacks.open_file) { + buf = conn->phys_ctx->callbacks.open_file(conn, path, &size); + if (buf != NULL) { + if (filep == NULL) { + /* This is a file in memory, but we cannot store the + * properties + * now. + * Called from "is_file_in_memory" function. */ + return 1; + } + + /* NOTE: override filep->size only on success. Otherwise, it + * might + * break constructs like if (!mg_stat() || !mg_fopen()) ... */ + filep->access.membuf = buf; + filep->access.fp = NULL; + + /* Size was set by the callback */ + filep->stat.size = size; + + /* Assume the data may change during runtime by setting + * last_modified = now */ + filep->stat.last_modified = time(NULL); + + filep->stat.is_directory = 0; + filep->stat.is_gzipped = 0; + } + } + + return (buf != NULL); + +#else + (void)conn; + (void)path; + (void)filep; + (void)mode; + + return 0; + +#endif +} + + +static int +is_file_in_memory(const struct mg_connection *conn, const char *path) +{ + return open_file_in_memory(conn, path, NULL, MG_FOPEN_MODE_NONE); +} + + +static int +is_file_opened(const struct mg_file_access *fileacc) +{ + if (!fileacc) { + return 0; + } + +#if defined(MG_USE_OPEN_FILE) + return (fileacc->membuf != NULL) || (fileacc->fp != NULL); +#else + return (fileacc->fp != NULL); +#endif +} + + +static int mg_stat(const struct mg_connection *conn, + const char *path, + struct mg_file_stat *filep); + + +/* mg_fopen will open a file either in memory or on the disk. + * The input parameter path is a string in UTF-8 encoding. + * The input parameter mode is MG_FOPEN_MODE_* + * On success, either fp or membuf will be set in the output + * struct file. All status members will also be set. + * The function returns 1 on success, 0 on error. */ +static int +mg_fopen(const struct mg_connection *conn, + const char *path, + int mode, + struct mg_file *filep) +{ + int found; + + if (!filep) { + return 0; + } + filep->access.fp = NULL; +#if defined(MG_USE_OPEN_FILE) + filep->access.membuf = NULL; +#endif + + if (!is_file_in_memory(conn, path)) { + + /* filep is initialized in mg_stat: all fields with memset to, + * some fields like size and modification date with values */ + found = mg_stat(conn, path, &(filep->stat)); + + if ((mode == MG_FOPEN_MODE_READ) && (!found)) { + /* file does not exist and will not be created */ + return 0; + } + +#if defined(_WIN32) + { + wchar_t wbuf[W_PATH_MAX]; + path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf)); + switch (mode) { + case MG_FOPEN_MODE_READ: + filep->access.fp = _wfopen(wbuf, L"rb"); + break; + case MG_FOPEN_MODE_WRITE: + filep->access.fp = _wfopen(wbuf, L"wb"); + break; + case MG_FOPEN_MODE_APPEND: + filep->access.fp = _wfopen(wbuf, L"ab"); + break; + } + } +#else + /* Linux et al already use unicode. No need to convert. */ + switch (mode) { + case MG_FOPEN_MODE_READ: + filep->access.fp = fopen(path, "r"); + break; + case MG_FOPEN_MODE_WRITE: + filep->access.fp = fopen(path, "w"); + break; + case MG_FOPEN_MODE_APPEND: + filep->access.fp = fopen(path, "a"); + break; + } + +#endif + if (!found) { + /* File did not exist before fopen was called. + * Maybe it has been created now. Get stat info + * like creation time now. */ + found = mg_stat(conn, path, &(filep->stat)); + (void)found; + } + + /* file is on disk */ + return (filep->access.fp != NULL); + + } else { +#if defined(MG_USE_OPEN_FILE) + /* is_file_in_memory returned true */ + if (open_file_in_memory(conn, path, filep, mode)) { + /* file is in memory */ + return (filep->access.membuf != NULL); + } +#endif + } + + /* Open failed */ + return 0; +} + + +/* return 0 on success, just like fclose */ +static int +mg_fclose(struct mg_file_access *fileacc) +{ + int ret = -1; + if (fileacc != NULL) { + if (fileacc->fp != NULL) { + ret = fclose(fileacc->fp); +#if defined(MG_USE_OPEN_FILE) + } else if (fileacc->membuf != NULL) { + ret = 0; +#endif + } + /* reset all members of fileacc */ + memset(fileacc, 0, sizeof(*fileacc)); + } + return ret; +} + + +static void +mg_strlcpy(register char *dst, register const char *src, size_t n) +{ + for (; *src != '\0' && n > 1; n--) { + *dst++ = *src++; + } + *dst = '\0'; +} + + +static int +lowercase(const char *s) +{ + return tolower((unsigned char)*s); +} + + +int +mg_strncasecmp(const char *s1, const char *s2, size_t len) +{ + int diff = 0; + + if (len > 0) { + do { + diff = lowercase(s1++) - lowercase(s2++); + } while (diff == 0 && s1[-1] != '\0' && --len > 0); + } + + return diff; +} + + +int +mg_strcasecmp(const char *s1, const char *s2) +{ + int diff; + + do { + diff = lowercase(s1++) - lowercase(s2++); + } while (diff == 0 && s1[-1] != '\0'); + + return diff; +} + + +static char * +mg_strndup_ctx(const char *ptr, size_t len, struct mg_context *ctx) +{ + char *p; + (void)ctx; /* Avoid Visual Studio warning if USE_SERVER_STATS is not + * defined */ + + if ((p = (char *)mg_malloc_ctx(len + 1, ctx)) != NULL) { + mg_strlcpy(p, ptr, len + 1); + } + + return p; +} + + +static char * +mg_strdup_ctx(const char *str, struct mg_context *ctx) +{ + return mg_strndup_ctx(str, strlen(str), ctx); +} + +static char * +mg_strdup(const char *str) +{ + return mg_strndup_ctx(str, strlen(str), NULL); +} + + +static const char * +mg_strcasestr(const char *big_str, const char *small_str) +{ + size_t i, big_len = strlen(big_str), small_len = strlen(small_str); + + if (big_len >= small_len) { + for (i = 0; i <= (big_len - small_len); i++) { + if (mg_strncasecmp(big_str + i, small_str, small_len) == 0) { + return big_str + i; + } + } + } + + return NULL; +} + + +/* Return null terminated string of given maximum length. + * Report errors if length is exceeded. */ +static void +mg_vsnprintf(const struct mg_connection *conn, + int *truncated, + char *buf, + size_t buflen, + const char *fmt, + va_list ap) +{ + int n, ok; + + if (buflen == 0) { + if (truncated) { + *truncated = 1; + } + return; + } + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wformat-nonliteral" +/* Using fmt as a non-literal is intended here, since it is mostly called + * indirectly by mg_snprintf */ +#endif + + n = (int)vsnprintf_impl(buf, buflen, fmt, ap); + ok = (n >= 0) && ((size_t)n < buflen); + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + + if (ok) { + if (truncated) { + *truncated = 0; + } + } else { + if (truncated) { + *truncated = 1; + } + mg_cry_internal(conn, + "truncating vsnprintf buffer: [%.*s]", + (int)((buflen > 200) ? 200 : (buflen - 1)), + buf); + n = (int)buflen - 1; + } + buf[n] = '\0'; +} + + +static void +mg_snprintf(const struct mg_connection *conn, + int *truncated, + char *buf, + size_t buflen, + const char *fmt, + ...) +{ + va_list ap; + + va_start(ap, fmt); + mg_vsnprintf(conn, truncated, buf, buflen, fmt, ap); + va_end(ap); +} + + +static int +get_option_index(const char *name) +{ + int i; + + for (i = 0; config_options[i].name != NULL; i++) { + if (strcmp(config_options[i].name, name) == 0) { + return i; + } + } + return -1; +} + + +const char * +mg_get_option(const struct mg_context *ctx, const char *name) +{ + int i; + if ((i = get_option_index(name)) == -1) { + return NULL; + } else if (!ctx || ctx->dd.config[i] == NULL) { + return ""; + } else { + return ctx->dd.config[i]; + } +} + +#define mg_get_option DO_NOT_USE_THIS_FUNCTION_INTERNALLY__access_directly + +struct mg_context * +mg_get_context(const struct mg_connection *conn) +{ + return (conn == NULL) ? (struct mg_context *)NULL : (conn->phys_ctx); +} + + +void * +mg_get_user_data(const struct mg_context *ctx) +{ + return (ctx == NULL) ? NULL : ctx->user_data; +} + + +void * +mg_get_thread_pointer(const struct mg_connection *conn) +{ + /* both methods should return the same pointer */ + if (conn) { + /* quick access, in case conn is known */ + return conn->tls_user_ptr; + } else { + /* otherwise get pointer from thread local storage (TLS) */ + struct mg_workerTLS *tls = + (struct mg_workerTLS *)pthread_getspecific(sTlsKey); + return tls->user_ptr; + } +} + + +void +mg_set_user_connection_data(struct mg_connection *conn, void *data) +{ + if (conn != NULL) { + conn->request_info.conn_data = data; + } +} + + +void * +mg_get_user_connection_data(const struct mg_connection *conn) +{ + if (conn != NULL) { + return conn->request_info.conn_data; + } + return NULL; +} + + +#if defined(MG_LEGACY_INTERFACE) +/* Deprecated: Use mg_get_server_ports instead. */ +size_t +mg_get_ports(const struct mg_context *ctx, size_t size, int *ports, int *ssl) +{ + size_t i; + if (!ctx) { + return 0; + } + for (i = 0; i < size && i < ctx->num_listening_sockets; i++) { + ssl[i] = ctx->listening_sockets[i].is_ssl; + ports[i] = +#if defined(USE_IPV6) + (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6) + ? ntohs(ctx->listening_sockets[i].lsa.sin6.sin6_port) + : +#endif + ntohs(ctx->listening_sockets[i].lsa.sin.sin_port); + } + return i; +} +#endif + + +int +mg_get_server_ports(const struct mg_context *ctx, + int size, + struct mg_server_port *ports) +{ + int i, cnt = 0; + + if (size <= 0) { + return -1; + } + memset(ports, 0, sizeof(*ports) * (size_t)size); + if (!ctx) { + return -1; + } + if (!ctx->listening_sockets) { + return -1; + } + + for (i = 0; (i < size) && (i < (int)ctx->num_listening_sockets); i++) { + + ports[cnt].port = +#if defined(USE_IPV6) + (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6) + ? ntohs(ctx->listening_sockets[i].lsa.sin6.sin6_port) + : +#endif + ntohs(ctx->listening_sockets[i].lsa.sin.sin_port); + ports[cnt].is_ssl = ctx->listening_sockets[i].is_ssl; + ports[cnt].is_redirect = ctx->listening_sockets[i].ssl_redir; + + if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET) { + /* IPv4 */ + ports[cnt].protocol = 1; + cnt++; + } else if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6) { + /* IPv6 */ + ports[cnt].protocol = 3; + cnt++; + } + } + + return cnt; +} + + +static void +sockaddr_to_string(char *buf, size_t len, const union usa *usa) +{ + buf[0] = '\0'; + + if (!usa) { + return; + } + + if (usa->sa.sa_family == AF_INET) { + getnameinfo(&usa->sa, + sizeof(usa->sin), + buf, + (unsigned)len, + NULL, + 0, + NI_NUMERICHOST); + } +#if defined(USE_IPV6) + else if (usa->sa.sa_family == AF_INET6) { + getnameinfo(&usa->sa, + sizeof(usa->sin6), + buf, + (unsigned)len, + NULL, + 0, + NI_NUMERICHOST); + } +#endif +} + + +/* Convert time_t to a string. According to RFC2616, Sec 14.18, this must be + * included in all responses other than 100, 101, 5xx. */ +static void +gmt_time_string(char *buf, size_t buf_len, time_t *t) +{ +#if !defined(REENTRANT_TIME) + struct tm *tm; + + tm = ((t != NULL) ? gmtime(t) : NULL); + if (tm != NULL) { +#else + struct tm _tm; + struct tm *tm = &_tm; + + if (t != NULL) { + gmtime_r(t, tm); +#endif + strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", tm); + } else { + mg_strlcpy(buf, "Thu, 01 Jan 1970 00:00:00 GMT", buf_len); + buf[buf_len - 1] = '\0'; + } +} + + +/* difftime for struct timespec. Return value is in seconds. */ +static double +mg_difftimespec(const struct timespec *ts_now, const struct timespec *ts_before) +{ + return (double)(ts_now->tv_nsec - ts_before->tv_nsec) * 1.0E-9 + + (double)(ts_now->tv_sec - ts_before->tv_sec); +} + + +#if defined(MG_EXTERNAL_FUNCTION_mg_cry_internal_impl) +static void mg_cry_internal_impl(const struct mg_connection *conn, + const char *func, + unsigned line, + const char *fmt, + va_list ap); +#include "external_mg_cry_internal_impl.inl" +#else + +/* Print error message to the opened error log stream. */ +static void +mg_cry_internal_impl(const struct mg_connection *conn, + const char *func, + unsigned line, + const char *fmt, + va_list ap) +{ + char buf[MG_BUF_LEN], src_addr[IP_ADDR_STR_LEN]; + struct mg_file fi; + time_t timestamp; + + /* Unused, in the RELEASE build */ + (void)func; + (void)line; + +#if defined(GCC_DIAGNOSTIC) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +#endif + + IGNORE_UNUSED_RESULT(vsnprintf_impl(buf, sizeof(buf), fmt, ap)); + +#if defined(GCC_DIAGNOSTIC) +#pragma GCC diagnostic pop +#endif + + buf[sizeof(buf) - 1] = 0; + + DEBUG_TRACE("mg_cry called from %s:%u: %s", func, line, buf); + + if (!conn) { + puts(buf); + return; + } + + /* Do not lock when getting the callback value, here and below. + * I suppose this is fine, since function cannot disappear in the + * same way string option can. */ + if ((conn->phys_ctx->callbacks.log_message == NULL) + || (conn->phys_ctx->callbacks.log_message(conn, buf) == 0)) { + + if (conn->dom_ctx->config[ERROR_LOG_FILE] != NULL) { + if (mg_fopen(conn, + conn->dom_ctx->config[ERROR_LOG_FILE], + MG_FOPEN_MODE_APPEND, + &fi) + == 0) { + fi.access.fp = NULL; + } + } else { + fi.access.fp = NULL; + } + + if (fi.access.fp != NULL) { + flockfile(fi.access.fp); + timestamp = time(NULL); + + sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa); + fprintf(fi.access.fp, + "[%010lu] [error] [client %s] ", + (unsigned long)timestamp, + src_addr); + + if (conn->request_info.request_method != NULL) { + fprintf(fi.access.fp, + "%s %s: ", + conn->request_info.request_method, + conn->request_info.request_uri + ? conn->request_info.request_uri + : ""); + } + + fprintf(fi.access.fp, "%s", buf); + fputc('\n', fi.access.fp); + fflush(fi.access.fp); + funlockfile(fi.access.fp); + (void)mg_fclose(&fi.access); /* Ignore errors. We can't call + * mg_cry here anyway ;-) */ + } + } +} + +#endif /* Externally provided function */ + + +/* Construct fake connection structure. Used for logging, if connection + * is not applicable at the moment of logging. */ +static struct mg_connection * +fake_connection(struct mg_connection *fc, struct mg_context *ctx) +{ + static const struct mg_connection conn_zero = {0}; + *fc = conn_zero; + fc->phys_ctx = ctx; + fc->dom_ctx = &(ctx->dd); + return fc; +} + + +static void +mg_cry_internal_wrap(const struct mg_connection *conn, + struct mg_context *ctx, + const char *func, + unsigned line, + const char *fmt, + ...) +{ + va_list ap; + va_start(ap, fmt); + if (!conn && ctx) { + struct mg_connection fc; + mg_cry_internal_impl(fake_connection(&fc, ctx), func, line, fmt, ap); + } else { + mg_cry_internal_impl(conn, func, line, fmt, ap); + } + va_end(ap); +} + + +void +mg_cry(const struct mg_connection *conn, const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + mg_cry_internal_impl(conn, "user", 0, fmt, ap); + va_end(ap); +} + + +#define mg_cry DO_NOT_USE_THIS_FUNCTION__USE_mg_cry_internal + + +const char * +mg_version(void) +{ + return CIVETWEB_VERSION; +} + + +const struct mg_request_info * +mg_get_request_info(const struct mg_connection *conn) +{ + if (!conn) { + return NULL; + } +#if defined(MG_ALLOW_USING_GET_REQUEST_INFO_FOR_RESPONSE) + if (conn->connection_type == CONNECTION_TYPE_RESPONSE) { + char txt[16]; + struct mg_workerTLS *tls = + (struct mg_workerTLS *)pthread_getspecific(sTlsKey); + + sprintf(txt, "%03i", conn->response_info.status_code); + if (strlen(txt) == 3) { + memcpy(tls->txtbuf, txt, 4); + } else { + strcpy(tls->txtbuf, "ERR"); + } + + ((struct mg_connection *)conn)->request_info.local_uri = + ((struct mg_connection *)conn)->request_info.request_uri = + tls->txtbuf; /* use thread safe buffer */ + + ((struct mg_connection *)conn)->request_info.num_headers = + conn->response_info.num_headers; + memcpy(((struct mg_connection *)conn)->request_info.http_headers, + conn->response_info.http_headers, + sizeof(conn->response_info.http_headers)); + } else +#endif + if (conn->connection_type != CONNECTION_TYPE_REQUEST) { + return NULL; + } + return &conn->request_info; +} + + +const struct mg_response_info * +mg_get_response_info(const struct mg_connection *conn) +{ + if (!conn) { + return NULL; + } + if (conn->connection_type != CONNECTION_TYPE_RESPONSE) { + return NULL; + } + return &conn->response_info; +} + + +static const char * +get_proto_name(const struct mg_connection *conn) +{ +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunreachable-code" +/* Depending on USE_WEBSOCKET and NO_SSL, some oft the protocols might be + * not supported. Clang raises an "unreachable code" warning for parts of ?: + * unreachable, but splitting into four different #ifdef clauses here is more + * complicated. + */ +#endif + + const struct mg_request_info *ri = &conn->request_info; + + const char *proto = + (is_websocket_protocol(conn) ? (ri->is_ssl ? "wss" : "ws") + : (ri->is_ssl ? "https" : "http")); + + return proto; + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif +} + + +int +mg_get_request_link(const struct mg_connection *conn, char *buf, size_t buflen) +{ + if ((buflen < 1) || (buf == 0) || (conn == 0)) { + return -1; + } else { + + int truncated = 0; + const struct mg_request_info *ri = &conn->request_info; + + const char *proto = get_proto_name(conn); + + if (ri->local_uri == NULL) { + return -1; + } + + if ((ri->request_uri != NULL) + && (0 != strcmp(ri->local_uri, ri->request_uri))) { + /* The request uri is different from the local uri. + * This is usually if an absolute URI, including server + * name has been provided. */ + mg_snprintf(conn, + &truncated, + buf, + buflen, + "%s://%s", + proto, + ri->request_uri); + if (truncated) { + return -1; + } + return 0; + + } else { + + /* The common case is a relative URI, so we have to + * construct an absolute URI from server name and port */ + +#if defined(USE_IPV6) + int is_ipv6 = (conn->client.lsa.sa.sa_family == AF_INET6); + int port = is_ipv6 ? htons(conn->client.lsa.sin6.sin6_port) + : htons(conn->client.lsa.sin.sin_port); +#else + int port = htons(conn->client.lsa.sin.sin_port); +#endif + int def_port = ri->is_ssl ? 443 : 80; + int auth_domain_check_enabled = + conn->dom_ctx->config[ENABLE_AUTH_DOMAIN_CHECK] + && (!mg_strcasecmp( + conn->dom_ctx->config[ENABLE_AUTH_DOMAIN_CHECK], "yes")); + const char *server_domain = + conn->dom_ctx->config[AUTHENTICATION_DOMAIN]; + + char portstr[16]; + char server_ip[48]; + + if (port != def_port) { + sprintf(portstr, ":%u", (unsigned)port); + } else { + portstr[0] = 0; + } + + if (!auth_domain_check_enabled || !server_domain) { + + sockaddr_to_string(server_ip, + sizeof(server_ip), + &conn->client.lsa); + + server_domain = server_ip; + } + + mg_snprintf(conn, + &truncated, + buf, + buflen, + "%s://%s%s%s", + proto, + server_domain, + portstr, + ri->local_uri); + if (truncated) { + return -1; + } + return 0; + } + } +} + +/* Skip the characters until one of the delimiters characters found. + * 0-terminate resulting word. Skip the delimiter and following whitespaces. + * Advance pointer to buffer to the next word. Return found 0-terminated + * word. + * Delimiters can be quoted with quotechar. */ +static char * +skip_quoted(char **buf, + const char *delimiters, + const char *whitespace, + char quotechar) +{ + char *p, *begin_word, *end_word, *end_whitespace; + + begin_word = *buf; + end_word = begin_word + strcspn(begin_word, delimiters); + + /* Check for quotechar */ + if (end_word > begin_word) { + p = end_word - 1; + while (*p == quotechar) { + /* While the delimiter is quoted, look for the next delimiter. + */ + /* This happens, e.g., in calls from parse_auth_header, + * if the user name contains a " character. */ + + /* If there is anything beyond end_word, copy it. */ + if (*end_word != '\0') { + size_t end_off = strcspn(end_word + 1, delimiters); + memmove(p, end_word, end_off + 1); + p += end_off; /* p must correspond to end_word - 1 */ + end_word += end_off + 1; + } else { + *p = '\0'; + break; + } + } + for (p++; p < end_word; p++) { + *p = '\0'; + } + } + + if (*end_word == '\0') { + *buf = end_word; + } else { + +#if defined(GCC_DIAGNOSTIC) +/* Disable spurious conversion warning for GCC */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wsign-conversion" +#endif /* defined(GCC_DIAGNOSTIC) */ + + end_whitespace = end_word + strspn(&end_word[1], whitespace) + 1; + +#if defined(GCC_DIAGNOSTIC) +#pragma GCC diagnostic pop +#endif /* defined(GCC_DIAGNOSTIC) */ + + for (p = end_word; p < end_whitespace; p++) { + *p = '\0'; + } + + *buf = end_whitespace; + } + + return begin_word; +} + + +/* Return HTTP header value, or NULL if not found. */ +static const char * +get_header(const struct mg_header *hdr, int num_hdr, const char *name) +{ + int i; + for (i = 0; i < num_hdr; i++) { + if (!mg_strcasecmp(name, hdr[i].name)) { + return hdr[i].value; + } + } + + return NULL; +} + + +#if defined(USE_WEBSOCKET) +/* Retrieve requested HTTP header multiple values, and return the number of + * found occurrences */ +static int +get_req_headers(const struct mg_request_info *ri, + const char *name, + const char **output, + int output_max_size) +{ + int i; + int cnt = 0; + if (ri) { + for (i = 0; i < ri->num_headers && cnt < output_max_size; i++) { + if (!mg_strcasecmp(name, ri->http_headers[i].name)) { + output[cnt++] = ri->http_headers[i].value; + } + } + } + return cnt; +} +#endif + + +const char * +mg_get_header(const struct mg_connection *conn, const char *name) +{ + if (!conn) { + return NULL; + } + + if (conn->connection_type == CONNECTION_TYPE_REQUEST) { + return get_header(conn->request_info.http_headers, + conn->request_info.num_headers, + name); + } + if (conn->connection_type == CONNECTION_TYPE_RESPONSE) { + return get_header(conn->response_info.http_headers, + conn->response_info.num_headers, + name); + } + return NULL; +} + + +static const char * +get_http_version(const struct mg_connection *conn) +{ + if (!conn) { + return NULL; + } + + if (conn->connection_type == CONNECTION_TYPE_REQUEST) { + return conn->request_info.http_version; + } + if (conn->connection_type == CONNECTION_TYPE_RESPONSE) { + return conn->response_info.http_version; + } + return NULL; +} + + +/* A helper function for traversing a comma separated list of values. + * It returns a list pointer shifted to the next value, or NULL if the end + * of the list found. + * Value is stored in val vector. If value has form "x=y", then eq_val + * vector is initialized to point to the "y" part, and val vector length + * is adjusted to point only to "x". */ +static const char * +next_option(const char *list, struct vec *val, struct vec *eq_val) +{ + int end; + +reparse: + if (val == NULL || list == NULL || *list == '\0') { + /* End of the list */ + return NULL; + } + + /* Skip over leading LWS */ + while (*list == ' ' || *list == '\t') + list++; + + val->ptr = list; + if ((list = strchr(val->ptr, ',')) != NULL) { + /* Comma found. Store length and shift the list ptr */ + val->len = ((size_t)(list - val->ptr)); + list++; + } else { + /* This value is the last one */ + list = val->ptr + strlen(val->ptr); + val->len = ((size_t)(list - val->ptr)); + } + + /* Adjust length for trailing LWS */ + end = (int)val->len - 1; + while (end >= 0 && ((val->ptr[end] == ' ') || (val->ptr[end] == '\t'))) + end--; + val->len = (size_t)(end) + (size_t)(1); + + if (val->len == 0) { + /* Ignore any empty entries. */ + goto reparse; + } + + if (eq_val != NULL) { + /* Value has form "x=y", adjust pointers and lengths + * so that val points to "x", and eq_val points to "y". */ + eq_val->len = 0; + eq_val->ptr = (const char *)memchr(val->ptr, '=', val->len); + if (eq_val->ptr != NULL) { + eq_val->ptr++; /* Skip over '=' character */ + eq_val->len = ((size_t)(val->ptr - eq_val->ptr)) + val->len; + val->len = ((size_t)(eq_val->ptr - val->ptr)) - 1; + } + } + + return list; +} + + +/* A helper function for checking if a comma separated list of values + * contains + * the given option (case insensitvely). + * 'header' can be NULL, in which case false is returned. */ +static int +header_has_option(const char *header, const char *option) +{ + struct vec opt_vec; + struct vec eq_vec; + + DEBUG_ASSERT(option != NULL); + DEBUG_ASSERT(option[0] != '\0'); + + while ((header = next_option(header, &opt_vec, &eq_vec)) != NULL) { + if (mg_strncasecmp(option, opt_vec.ptr, opt_vec.len) == 0) + return 1; + } + + return 0; +} + + +/* Perform case-insensitive match of string against pattern */ +static ptrdiff_t +match_prefix(const char *pattern, size_t pattern_len, const char *str) +{ + const char *or_str; + ptrdiff_t i, j, len, res; + + if ((or_str = (const char *)memchr(pattern, '|', pattern_len)) != NULL) { + res = match_prefix(pattern, (size_t)(or_str - pattern), str); + return (res > 0) ? res + : match_prefix(or_str + 1, + (size_t)((pattern + pattern_len) + - (or_str + 1)), + str); + } + + for (i = 0, j = 0; (i < (ptrdiff_t)pattern_len); i++, j++) { + if ((pattern[i] == '?') && (str[j] != '\0')) { + continue; + } else if (pattern[i] == '$') { + return (str[j] == '\0') ? j : -1; + } else if (pattern[i] == '*') { + i++; + if (pattern[i] == '*') { + i++; + len = strlen(str + j); + } else { + len = strcspn(str + j, "/"); + } + if (i == (ptrdiff_t)pattern_len) { + return j + len; + } + do { + res = match_prefix(pattern + i, pattern_len - i, str + j + len); + } while (res == -1 && len-- > 0); + return (res == -1) ? -1 : j + res + len; + } else if (lowercase(&pattern[i]) != lowercase(&str[j])) { + return -1; + } + } + return (ptrdiff_t)j; +} + + +/* HTTP 1.1 assumes keep alive if "Connection:" header is not set + * This function must tolerate situations when connection info is not + * set up, for example if request parsing failed. */ +static int +should_keep_alive(const struct mg_connection *conn) +{ + const char *http_version; + const char *header; + + /* First satisfy needs of the server */ + if ((conn == NULL) || conn->must_close) { + /* Close, if civetweb framework needs to close */ + return 0; + } + + if (mg_strcasecmp(conn->dom_ctx->config[ENABLE_KEEP_ALIVE], "yes") != 0) { + /* Close, if keep alive is not enabled */ + return 0; + } + + /* Check explicit wish of the client */ + header = mg_get_header(conn, "Connection"); + if (header) { + /* If there is a connection header from the client, obey */ + if (header_has_option(header, "keep-alive")) { + return 1; + } + return 0; + } + + /* Use default of the standard */ + http_version = get_http_version(conn); + if (http_version && (0 == strcmp(http_version, "1.1"))) { + /* HTTP 1.1 default is keep alive */ + return 1; + } + + /* HTTP 1.0 (and earlier) default is to close the connection */ + return 0; +} + + +static int +should_decode_url(const struct mg_connection *conn) +{ + if (!conn || !conn->dom_ctx) { + return 0; + } + + return (mg_strcasecmp(conn->dom_ctx->config[DECODE_URL], "yes") == 0); +} + + +static const char * +suggest_connection_header(const struct mg_connection *conn) +{ + return should_keep_alive(conn) ? "keep-alive" : "close"; +} + + +static int +send_no_cache_header(struct mg_connection *conn) +{ + /* Send all current and obsolete cache opt-out directives. */ + return mg_printf(conn, + "Cache-Control: no-cache, no-store, " + "must-revalidate, private, max-age=0\r\n" + "Pragma: no-cache\r\n" + "Expires: 0\r\n"); +} + + +static int +send_static_cache_header(struct mg_connection *conn) +{ +#if !defined(NO_CACHING) + /* Read the server config to check how long a file may be cached. + * The configuration is in seconds. */ + int max_age = atoi(conn->dom_ctx->config[STATIC_FILE_MAX_AGE]); + if (max_age <= 0) { + /* 0 means "do not cache". All values <0 are reserved + * and may be used differently in the future. */ + /* If a file should not be cached, do not only send + * max-age=0, but also pragmas and Expires headers. */ + return send_no_cache_header(conn); + } + + /* Use "Cache-Control: max-age" instead of "Expires" header. + * Reason: see https://www.mnot.net/blog/2007/05/15/expires_max-age */ + /* See also https://www.mnot.net/cache_docs/ */ + /* According to RFC 2616, Section 14.21, caching times should not exceed + * one year. A year with 365 days corresponds to 31536000 seconds, a + * leap + * year to 31622400 seconds. For the moment, we just send whatever has + * been configured, still the behavior for >1 year should be considered + * as undefined. */ + return mg_printf(conn, "Cache-Control: max-age=%u\r\n", (unsigned)max_age); +#else /* NO_CACHING */ + return send_no_cache_header(conn); +#endif /* !NO_CACHING */ +} + + +static int +send_additional_header(struct mg_connection *conn) +{ + int i = 0; + const char *header = conn->dom_ctx->config[ADDITIONAL_HEADER]; + +#if !defined(NO_SSL) + if (conn->dom_ctx->config[STRICT_HTTPS_MAX_AGE]) { + int max_age = atoi(conn->dom_ctx->config[STRICT_HTTPS_MAX_AGE]); + if (max_age >= 0) { + i += mg_printf(conn, + "Strict-Transport-Security: max-age=%u\r\n", + (unsigned)max_age); + } + } +#endif + + if (header && header[0]) { + i += mg_printf(conn, "%s\r\n", header); + } + + return i; +} + + +static void handle_file_based_request(struct mg_connection *conn, + const char *path, + struct mg_file *filep); + + +const char * +mg_get_response_code_text(const struct mg_connection *conn, int response_code) +{ + /* See IANA HTTP status code assignment: + * http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml + */ + + switch (response_code) { + /* RFC2616 Section 10.1 - Informational 1xx */ + case 100: + return "Continue"; /* RFC2616 Section 10.1.1 */ + case 101: + return "Switching Protocols"; /* RFC2616 Section 10.1.2 */ + case 102: + return "Processing"; /* RFC2518 Section 10.1 */ + + /* RFC2616 Section 10.2 - Successful 2xx */ + case 200: + return "OK"; /* RFC2616 Section 10.2.1 */ + case 201: + return "Created"; /* RFC2616 Section 10.2.2 */ + case 202: + return "Accepted"; /* RFC2616 Section 10.2.3 */ + case 203: + return "Non-Authoritative Information"; /* RFC2616 Section 10.2.4 */ + case 204: + return "No Content"; /* RFC2616 Section 10.2.5 */ + case 205: + return "Reset Content"; /* RFC2616 Section 10.2.6 */ + case 206: + return "Partial Content"; /* RFC2616 Section 10.2.7 */ + case 207: + return "Multi-Status"; /* RFC2518 Section 10.2, RFC4918 Section 11.1 + */ + case 208: + return "Already Reported"; /* RFC5842 Section 7.1 */ + + case 226: + return "IM used"; /* RFC3229 Section 10.4.1 */ + + /* RFC2616 Section 10.3 - Redirection 3xx */ + case 300: + return "Multiple Choices"; /* RFC2616 Section 10.3.1 */ + case 301: + return "Moved Permanently"; /* RFC2616 Section 10.3.2 */ + case 302: + return "Found"; /* RFC2616 Section 10.3.3 */ + case 303: + return "See Other"; /* RFC2616 Section 10.3.4 */ + case 304: + return "Not Modified"; /* RFC2616 Section 10.3.5 */ + case 305: + return "Use Proxy"; /* RFC2616 Section 10.3.6 */ + case 307: + return "Temporary Redirect"; /* RFC2616 Section 10.3.8 */ + case 308: + return "Permanent Redirect"; /* RFC7238 Section 3 */ + + /* RFC2616 Section 10.4 - Client Error 4xx */ + case 400: + return "Bad Request"; /* RFC2616 Section 10.4.1 */ + case 401: + return "Unauthorized"; /* RFC2616 Section 10.4.2 */ + case 402: + return "Payment Required"; /* RFC2616 Section 10.4.3 */ + case 403: + return "Forbidden"; /* RFC2616 Section 10.4.4 */ + case 404: + return "Not Found"; /* RFC2616 Section 10.4.5 */ + case 405: + return "Method Not Allowed"; /* RFC2616 Section 10.4.6 */ + case 406: + return "Not Acceptable"; /* RFC2616 Section 10.4.7 */ + case 407: + return "Proxy Authentication Required"; /* RFC2616 Section 10.4.8 */ + case 408: + return "Request Time-out"; /* RFC2616 Section 10.4.9 */ + case 409: + return "Conflict"; /* RFC2616 Section 10.4.10 */ + case 410: + return "Gone"; /* RFC2616 Section 10.4.11 */ + case 411: + return "Length Required"; /* RFC2616 Section 10.4.12 */ + case 412: + return "Precondition Failed"; /* RFC2616 Section 10.4.13 */ + case 413: + return "Request Entity Too Large"; /* RFC2616 Section 10.4.14 */ + case 414: + return "Request-URI Too Large"; /* RFC2616 Section 10.4.15 */ + case 415: + return "Unsupported Media Type"; /* RFC2616 Section 10.4.16 */ + case 416: + return "Requested range not satisfiable"; /* RFC2616 Section 10.4.17 + */ + case 417: + return "Expectation Failed"; /* RFC2616 Section 10.4.18 */ + + case 421: + return "Misdirected Request"; /* RFC7540 Section 9.1.2 */ + case 422: + return "Unproccessable entity"; /* RFC2518 Section 10.3, RFC4918 + * Section 11.2 */ + case 423: + return "Locked"; /* RFC2518 Section 10.4, RFC4918 Section 11.3 */ + case 424: + return "Failed Dependency"; /* RFC2518 Section 10.5, RFC4918 + * Section 11.4 */ + + case 426: + return "Upgrade Required"; /* RFC 2817 Section 4 */ + + case 428: + return "Precondition Required"; /* RFC 6585, Section 3 */ + case 429: + return "Too Many Requests"; /* RFC 6585, Section 4 */ + + case 431: + return "Request Header Fields Too Large"; /* RFC 6585, Section 5 */ + + case 451: + return "Unavailable For Legal Reasons"; /* draft-tbray-http-legally-restricted-status-05, + * Section 3 */ + + /* RFC2616 Section 10.5 - Server Error 5xx */ + case 500: + return "Internal Server Error"; /* RFC2616 Section 10.5.1 */ + case 501: + return "Not Implemented"; /* RFC2616 Section 10.5.2 */ + case 502: + return "Bad Gateway"; /* RFC2616 Section 10.5.3 */ + case 503: + return "Service Unavailable"; /* RFC2616 Section 10.5.4 */ + case 504: + return "Gateway Time-out"; /* RFC2616 Section 10.5.5 */ + case 505: + return "HTTP Version not supported"; /* RFC2616 Section 10.5.6 */ + case 506: + return "Variant Also Negotiates"; /* RFC 2295, Section 8.1 */ + case 507: + return "Insufficient Storage"; /* RFC2518 Section 10.6, RFC4918 + * Section 11.5 */ + case 508: + return "Loop Detected"; /* RFC5842 Section 7.1 */ + + case 510: + return "Not Extended"; /* RFC 2774, Section 7 */ + case 511: + return "Network Authentication Required"; /* RFC 6585, Section 6 */ + + /* Other status codes, not shown in the IANA HTTP status code + * assignment. + * E.g., "de facto" standards due to common use, ... */ + case 418: + return "I am a teapot"; /* RFC2324 Section 2.3.2 */ + case 419: + return "Authentication Timeout"; /* common use */ + case 420: + return "Enhance Your Calm"; /* common use */ + case 440: + return "Login Timeout"; /* common use */ + case 509: + return "Bandwidth Limit Exceeded"; /* common use */ + + default: + /* This error code is unknown. This should not happen. */ + if (conn) { + mg_cry_internal(conn, + "Unknown HTTP response code: %u", + response_code); + } + + /* Return at least a category according to RFC 2616 Section 10. */ + if (response_code >= 100 && response_code < 200) { + /* Unknown informational status code */ + return "Information"; + } + if (response_code >= 200 && response_code < 300) { + /* Unknown success code */ + return "Success"; + } + if (response_code >= 300 && response_code < 400) { + /* Unknown redirection code */ + return "Redirection"; + } + if (response_code >= 400 && response_code < 500) { + /* Unknown request error code */ + return "Client Error"; + } + if (response_code >= 500 && response_code < 600) { + /* Unknown server error code */ + return "Server Error"; + } + + /* Response code not even within reasonable range */ + return ""; + } +} + + +static int +mg_send_http_error_impl(struct mg_connection *conn, + int status, + const char *fmt, + va_list args) +{ + char errmsg_buf[MG_BUF_LEN]; + char path_buf[PATH_MAX]; + va_list ap; + int len, i, page_handler_found, scope, truncated, has_body; + char date[64]; + time_t curtime = time(NULL); + const char *error_handler = NULL; + struct mg_file error_page_file = STRUCT_FILE_INITIALIZER; + const char *error_page_file_ext, *tstr; + int handled_by_callback = 0; + + const char *status_text = mg_get_response_code_text(conn, status); + + if ((conn == NULL) || (fmt == NULL)) { + return -2; + } + + /* Set status (for log) */ + conn->status_code = status; + + /* Errors 1xx, 204 and 304 MUST NOT send a body */ + has_body = ((status > 199) && (status != 204) && (status != 304)); + + /* Prepare message in buf, if required */ + if (has_body + || (!conn->in_error_handler + && (conn->phys_ctx->callbacks.http_error != NULL))) { + /* Store error message in errmsg_buf */ + va_copy(ap, args); + mg_vsnprintf(conn, NULL, errmsg_buf, sizeof(errmsg_buf), fmt, ap); + va_end(ap); + /* In a debug build, print all html errors */ + DEBUG_TRACE("Error %i - [%s]", status, errmsg_buf); + } + + /* If there is a http_error callback, call it. + * But don't do it recursively, if callback calls mg_send_http_error again. + */ + if (!conn->in_error_handler + && (conn->phys_ctx->callbacks.http_error != NULL)) { + /* Mark in_error_handler to avoid recursion and call user callback. */ + conn->in_error_handler = 1; + handled_by_callback = + (conn->phys_ctx->callbacks.http_error(conn, status, errmsg_buf) + == 0); + conn->in_error_handler = 0; + } + + if (!handled_by_callback) { + /* Check for recursion */ + if (conn->in_error_handler) { + DEBUG_TRACE( + "Recursion when handling error %u - fall back to default", + status); + } else { + /* Send user defined error pages, if defined */ + error_handler = conn->dom_ctx->config[ERROR_PAGES]; + error_page_file_ext = conn->dom_ctx->config[INDEX_FILES]; + page_handler_found = 0; + + if (error_handler != NULL) { + for (scope = 1; (scope <= 3) && !page_handler_found; scope++) { + switch (scope) { + case 1: /* Handler for specific error, e.g. 404 error */ + mg_snprintf(conn, + &truncated, + path_buf, + sizeof(path_buf) - 32, + "%serror%03u.", + error_handler, + status); + break; + case 2: /* Handler for error group, e.g., 5xx error + * handler + * for all server errors (500-599) */ + mg_snprintf(conn, + &truncated, + path_buf, + sizeof(path_buf) - 32, + "%serror%01uxx.", + error_handler, + status / 100); + break; + default: /* Handler for all errors */ + mg_snprintf(conn, + &truncated, + path_buf, + sizeof(path_buf) - 32, + "%serror.", + error_handler); + break; + } + + /* String truncation in buf may only occur if + * error_handler is too long. This string is + * from the config, not from a client. */ + (void)truncated; + + len = (int)strlen(path_buf); + + tstr = strchr(error_page_file_ext, '.'); + + while (tstr) { + for (i = 1; + (i < 32) && (tstr[i] != 0) && (tstr[i] != ','); + i++) { + /* buffer overrun is not possible here, since + * (i < 32) && (len < sizeof(path_buf) - 32) + * ==> (i + len) < sizeof(path_buf) */ + path_buf[len + i - 1] = tstr[i]; + } + /* buffer overrun is not possible here, since + * (i <= 32) && (len < sizeof(path_buf) - 32) + * ==> (i + len) <= sizeof(path_buf) */ + path_buf[len + i - 1] = 0; + + if (mg_stat(conn, path_buf, &error_page_file.stat)) { + DEBUG_TRACE("Check error page %s - found", + path_buf); + page_handler_found = 1; + break; + } + DEBUG_TRACE("Check error page %s - not found", + path_buf); + + tstr = strchr(tstr + i, '.'); + } + } + } + + if (page_handler_found) { + conn->in_error_handler = 1; + handle_file_based_request(conn, path_buf, &error_page_file); + conn->in_error_handler = 0; + return 0; + } + } + + /* No custom error page. Send default error page. */ + gmt_time_string(date, sizeof(date), &curtime); + + conn->must_close = 1; + mg_printf(conn, "HTTP/1.1 %d %s\r\n", status, status_text); + send_no_cache_header(conn); + send_additional_header(conn); + if (has_body) { + mg_printf(conn, + "%s", + "Content-Type: text/plain; charset=utf-8\r\n"); + } + mg_printf(conn, + "Date: %s\r\n" + "Connection: close\r\n\r\n", + date); + + /* HTTP responses 1xx, 204 and 304 MUST NOT send a body */ + if (has_body) { + /* For other errors, send a generic error message. */ + mg_printf(conn, "Error %d: %s\n", status, status_text); + mg_write(conn, errmsg_buf, strlen(errmsg_buf)); + + } else { + /* No body allowed. Close the connection. */ + DEBUG_TRACE("Error %i", status); + } + } + return 0; +} + + +int +mg_send_http_error(struct mg_connection *conn, int status, const char *fmt, ...) +{ + va_list ap; + int ret; + + va_start(ap, fmt); + ret = mg_send_http_error_impl(conn, status, fmt, ap); + va_end(ap); + + return ret; +} + + +int +mg_send_http_ok(struct mg_connection *conn, + const char *mime_type, + long long content_length) +{ + char date[64]; + time_t curtime = time(NULL); + + if ((mime_type == NULL) || (*mime_type == 0)) { + /* Parameter error */ + return -2; + } + + gmt_time_string(date, sizeof(date), &curtime); + + mg_printf(conn, + "HTTP/1.1 200 OK\r\n" + "Content-Type: %s\r\n" + "Date: %s\r\n" + "Connection: %s\r\n", + mime_type, + date, + suggest_connection_header(conn)); + + send_no_cache_header(conn); + send_additional_header(conn); + if (content_length < 0) { + mg_printf(conn, "Transfer-Encoding: chunked\r\n\r\n"); + } else { + mg_printf(conn, + "Content-Length: %" UINT64_FMT "\r\n\r\n", + (uint64_t)content_length); + } + + return 0; +} + + +int +mg_send_http_redirect(struct mg_connection *conn, + const char *target_url, + int redirect_code) +{ + /* Send a 30x redirect response. + * + * Redirect types (status codes): + * + * Status | Perm/Temp | Method | Version + * 301 | permanent | POST->GET undefined | HTTP/1.0 + * 302 | temporary | POST->GET undefined | HTTP/1.0 + * 303 | temporary | always use GET | HTTP/1.1 + * 307 | temporary | always keep method | HTTP/1.1 + * 308 | permanent | always keep method | HTTP/1.1 + */ + const char *redirect_text; + int ret; + size_t content_len = 0; + char reply[MG_BUF_LEN]; + + /* In case redirect_code=0, use 307. */ + if (redirect_code == 0) { + redirect_code = 307; + } + + /* In case redirect_code is none of the above, return error. */ + if ((redirect_code != 301) && (redirect_code != 302) + && (redirect_code != 303) && (redirect_code != 307) + && (redirect_code != 308)) { + /* Parameter error */ + return -2; + } + + /* Get proper text for response code */ + redirect_text = mg_get_response_code_text(conn, redirect_code); + + /* If target_url is not defined, redirect to "/". */ + if ((target_url == NULL) || (*target_url == 0)) { + target_url = "/"; + } + +#if defined(MG_SEND_REDIRECT_BODY) + /* TODO: condition name? */ + + /* Prepare a response body with a hyperlink. + * + * According to RFC2616 (and RFC1945 before): + * Unless the request method was HEAD, the entity of the + * response SHOULD contain a short hypertext note with a hyperlink to + * the new URI(s). + * + * However, this response body is not useful in M2M communication. + * Probably the original reason in the RFC was, clients not supporting + * a 30x HTTP redirect could still show the HTML page and let the user + * press the link. Since current browsers support 30x HTTP, the additional + * HTML body does not seem to make sense anymore. + * + * The new RFC7231 (Section 6.4) does no longer recommend it ("SHOULD"), + * but it only notes: + * The server's response payload usually contains a short + * hypertext note with a hyperlink to the new URI(s). + * + * Deactivated by default. If you need the 30x body, set the define. + */ + mg_snprintf( + conn, + NULL /* ignore truncation */, + reply, + sizeof(reply), + "%s%s", + redirect_text, + target_url, + target_url); + content_len = strlen(reply); +#else + reply[0] = 0; +#endif + + /* Do not send any additional header. For all other options, + * including caching, there are suitable defaults. */ + ret = mg_printf(conn, + "HTTP/1.1 %i %s\r\n" + "Location: %s\r\n" + "Content-Length: %u\r\n" + "Connection: %s\r\n\r\n", + redirect_code, + redirect_text, + target_url, + (unsigned int)content_len, + suggest_connection_header(conn)); + + /* Send response body */ + if (ret > 0) { + /* ... unless it is a HEAD request */ + if (0 != strcmp(conn->request_info.request_method, "HEAD")) { + ret = mg_write(conn, reply, content_len); + } + } + + return (ret > 0) ? ret : -1; +} + + +#if defined(_WIN32) +/* Create substitutes for POSIX functions in Win32. */ + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif + + +static int +pthread_mutex_init(pthread_mutex_t *mutex, void *unused) +{ + (void)unused; + /* Always initialize as PTHREAD_MUTEX_RECURSIVE */ + InitializeCriticalSection(&mutex->sec); + return 0; +} + + +static int +pthread_mutex_destroy(pthread_mutex_t *mutex) +{ + DeleteCriticalSection(&mutex->sec); + return 0; +} + + +static int +pthread_mutex_lock(pthread_mutex_t *mutex) +{ + EnterCriticalSection(&mutex->sec); + return 0; +} + + +static int +pthread_mutex_unlock(pthread_mutex_t *mutex) +{ + LeaveCriticalSection(&mutex->sec); + return 0; +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_cond_init(pthread_cond_t *cv, const void *unused) +{ + (void)unused; + (void)pthread_mutex_init(&cv->threadIdSec, &pthread_mutex_attr); + cv->waiting_thread = NULL; + return 0; +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_cond_timedwait(pthread_cond_t *cv, + pthread_mutex_t *mutex, + FUNCTION_MAY_BE_UNUSED const struct timespec *abstime) +{ + struct mg_workerTLS **ptls, + *tls = (struct mg_workerTLS *)pthread_getspecific(sTlsKey); + int ok; + int64_t nsnow, nswaitabs, nswaitrel; + DWORD mswaitrel; + + pthread_mutex_lock(&cv->threadIdSec); + /* Add this thread to cv's waiting list */ + ptls = &cv->waiting_thread; + for (; *ptls != NULL; ptls = &(*ptls)->next_waiting_thread) + ; + tls->next_waiting_thread = NULL; + *ptls = tls; + pthread_mutex_unlock(&cv->threadIdSec); + + if (abstime) { + nsnow = mg_get_current_time_ns(); + nswaitabs = + (((int64_t)abstime->tv_sec) * 1000000000) + abstime->tv_nsec; + nswaitrel = nswaitabs - nsnow; + if (nswaitrel < 0) { + nswaitrel = 0; + } + mswaitrel = (DWORD)(nswaitrel / 1000000); + } else { + mswaitrel = (DWORD)INFINITE; + } + + pthread_mutex_unlock(mutex); + ok = (WAIT_OBJECT_0 + == WaitForSingleObject(tls->pthread_cond_helper_mutex, mswaitrel)); + if (!ok) { + ok = 1; + pthread_mutex_lock(&cv->threadIdSec); + ptls = &cv->waiting_thread; + for (; *ptls != NULL; ptls = &(*ptls)->next_waiting_thread) { + if (*ptls == tls) { + *ptls = tls->next_waiting_thread; + ok = 0; + break; + } + } + pthread_mutex_unlock(&cv->threadIdSec); + if (ok) { + WaitForSingleObject(tls->pthread_cond_helper_mutex, + (DWORD)INFINITE); + } + } + /* This thread has been removed from cv's waiting list */ + pthread_mutex_lock(mutex); + + return ok ? 0 : -1; +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex) +{ + return pthread_cond_timedwait(cv, mutex, NULL); +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_cond_signal(pthread_cond_t *cv) +{ + HANDLE wkup = NULL; + BOOL ok = FALSE; + + pthread_mutex_lock(&cv->threadIdSec); + if (cv->waiting_thread) { + wkup = cv->waiting_thread->pthread_cond_helper_mutex; + cv->waiting_thread = cv->waiting_thread->next_waiting_thread; + + ok = SetEvent(wkup); + DEBUG_ASSERT(ok); + } + pthread_mutex_unlock(&cv->threadIdSec); + + return ok ? 0 : 1; +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_cond_broadcast(pthread_cond_t *cv) +{ + pthread_mutex_lock(&cv->threadIdSec); + while (cv->waiting_thread) { + pthread_cond_signal(cv); + } + pthread_mutex_unlock(&cv->threadIdSec); + + return 0; +} + + +FUNCTION_MAY_BE_UNUSED +static int +pthread_cond_destroy(pthread_cond_t *cv) +{ + pthread_mutex_lock(&cv->threadIdSec); + DEBUG_ASSERT(cv->waiting_thread == NULL); + pthread_mutex_unlock(&cv->threadIdSec); + pthread_mutex_destroy(&cv->threadIdSec); + + return 0; +} + + +#if defined(ALTERNATIVE_QUEUE) +FUNCTION_MAY_BE_UNUSED +static void * +event_create(void) +{ + return (void *)CreateEvent(NULL, FALSE, FALSE, NULL); +} + + +FUNCTION_MAY_BE_UNUSED +static int +event_wait(void *eventhdl) +{ + int res = WaitForSingleObject((HANDLE)eventhdl, (DWORD)INFINITE); + return (res == WAIT_OBJECT_0); +} + + +FUNCTION_MAY_BE_UNUSED +static int +event_signal(void *eventhdl) +{ + return (int)SetEvent((HANDLE)eventhdl); +} + + +FUNCTION_MAY_BE_UNUSED +static void +event_destroy(void *eventhdl) +{ + CloseHandle((HANDLE)eventhdl); +} +#endif + + +#if defined(GCC_DIAGNOSTIC) +/* Enable unused function warning again */ +#pragma GCC diagnostic pop +#endif + + +/* For Windows, change all slashes to backslashes in path names. */ +static void +change_slashes_to_backslashes(char *path) +{ + int i; + + for (i = 0; path[i] != '\0'; i++) { + if (path[i] == '/') { + path[i] = '\\'; + } + + /* remove double backslash (check i > 0 to preserve UNC paths, + * like \\server\file.txt) */ + if ((path[i] == '\\') && (i > 0)) { + while ((path[i + 1] == '\\') || (path[i + 1] == '/')) { + (void)memmove(path + i + 1, path + i + 2, strlen(path + i + 1)); + } + } + } +} + + +static int +mg_wcscasecmp(const wchar_t *s1, const wchar_t *s2) +{ + int diff; + + do { + diff = ((*s1 >= L'A') && (*s1 <= L'Z') ? (*s1 - L'A' + L'a') : *s1) + - ((*s2 >= L'A') && (*s2 <= L'Z') ? (*s2 - L'A' + L'a') : *s2); + s1++; + s2++; + } while ((diff == 0) && (s1[-1] != L'\0')); + + return diff; +} + + +/* Encode 'path' which is assumed UTF-8 string, into UNICODE string. + * wbuf and wbuf_len is a target buffer and its length. */ +static void +path_to_unicode(const struct mg_connection *conn, + const char *path, + wchar_t *wbuf, + size_t wbuf_len) +{ + char buf[PATH_MAX], buf2[PATH_MAX]; + wchar_t wbuf2[W_PATH_MAX + 1]; + DWORD long_len, err; + int (*fcompare)(const wchar_t *, const wchar_t *) = mg_wcscasecmp; + + mg_strlcpy(buf, path, sizeof(buf)); + change_slashes_to_backslashes(buf); + + /* Convert to Unicode and back. If doubly-converted string does not + * match the original, something is fishy, reject. */ + memset(wbuf, 0, wbuf_len * sizeof(wchar_t)); + MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int)wbuf_len); + WideCharToMultiByte( + CP_UTF8, 0, wbuf, (int)wbuf_len, buf2, sizeof(buf2), NULL, NULL); + if (strcmp(buf, buf2) != 0) { + wbuf[0] = L'\0'; + } + + /* Windows file systems are not case sensitive, but you can still use + * uppercase and lowercase letters (on all modern file systems). + * The server can check if the URI uses the same upper/lowercase + * letters an the file system, effectively making Windows servers + * case sensitive (like Linux servers are). It is still not possible + * to use two files with the same name in different cases on Windows + * (like /a and /A) - this would be possible in Linux. + * As a default, Windows is not case sensitive, but the case sensitive + * file name check can be activated by an additional configuration. */ + if (conn) { + if (conn->dom_ctx->config[CASE_SENSITIVE_FILES] + && !mg_strcasecmp(conn->dom_ctx->config[CASE_SENSITIVE_FILES], + "yes")) { + /* Use case sensitive compare function */ + fcompare = wcscmp; + } + } + (void)conn; /* conn is currently unused */ + +#if !defined(_WIN32_WCE) + /* Only accept a full file path, not a Windows short (8.3) path. */ + memset(wbuf2, 0, ARRAY_SIZE(wbuf2) * sizeof(wchar_t)); + long_len = GetLongPathNameW(wbuf, wbuf2, ARRAY_SIZE(wbuf2) - 1); + if (long_len == 0) { + err = GetLastError(); + if (err == ERROR_FILE_NOT_FOUND) { + /* File does not exist. This is not always a problem here. */ + return; + } + } + if ((long_len >= ARRAY_SIZE(wbuf2)) || (fcompare(wbuf, wbuf2) != 0)) { + /* Short name is used. */ + wbuf[0] = L'\0'; + } +#else + (void)long_len; + (void)wbuf2; + (void)err; + + if (strchr(path, '~')) { + wbuf[0] = L'\0'; + } +#endif +} + + +static int +mg_stat(const struct mg_connection *conn, + const char *path, + struct mg_file_stat *filep) +{ + wchar_t wbuf[W_PATH_MAX]; + WIN32_FILE_ATTRIBUTE_DATA info; + time_t creation_time; + size_t len; + + if (!filep) { + return 0; + } + memset(filep, 0, sizeof(*filep)); + + if (conn && is_file_in_memory(conn, path)) { + /* filep->is_directory = 0; filep->gzipped = 0; .. already done by + * memset */ + + /* Quick fix (for 1.9.x): */ + /* mg_stat must fill all fields, also for files in memory */ + struct mg_file tmp_file = STRUCT_FILE_INITIALIZER; + open_file_in_memory(conn, path, &tmp_file, MG_FOPEN_MODE_NONE); + filep->size = tmp_file.stat.size; + filep->location = 2; + /* TODO: for 1.10: restructure how files in memory are handled */ + + /* The "file in memory" feature is a candidate for deletion. + * Please join the discussion at + * https://groups.google.com/forum/#!topic/civetweb/h9HT4CmeYqI + */ + + filep->last_modified = time(NULL); /* TODO */ + /* last_modified = now ... assumes the file may change during + * runtime, + * so every mg_fopen call may return different data */ + /* last_modified = conn->phys_ctx.start_time; + * May be used it the data does not change during runtime. This + * allows + * browser caching. Since we do not know, we have to assume the file + * in memory may change. */ + return 1; + } + + path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf)); + /* Windows happily opens files with some garbage at the end of file name. + * For example, fopen("a.cgi ", "r") on Windows successfully opens + * "a.cgi", despite one would expect an error back. */ + len = strlen(path); + if ((len > 0) && (path[len - 1] != ' ') && (path[len - 1] != '.') + && (GetFileAttributesExW(wbuf, GetFileExInfoStandard, &info) != 0)) { + filep->size = MAKEUQUAD(info.nFileSizeLow, info.nFileSizeHigh); + filep->last_modified = + SYS2UNIX_TIME(info.ftLastWriteTime.dwLowDateTime, + info.ftLastWriteTime.dwHighDateTime); + + /* On Windows, the file creation time can be higher than the + * modification time, e.g. when a file is copied. + * Since the Last-Modified timestamp is used for caching + * it should be based on the most recent timestamp. */ + creation_time = SYS2UNIX_TIME(info.ftCreationTime.dwLowDateTime, + info.ftCreationTime.dwHighDateTime); + if (creation_time > filep->last_modified) { + filep->last_modified = creation_time; + } + + filep->is_directory = info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY; + return 1; + } + + return 0; +} + + +static int +mg_remove(const struct mg_connection *conn, const char *path) +{ + wchar_t wbuf[W_PATH_MAX]; + path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf)); + return DeleteFileW(wbuf) ? 0 : -1; +} + + +static int +mg_mkdir(const struct mg_connection *conn, const char *path, int mode) +{ + wchar_t wbuf[W_PATH_MAX]; + (void)mode; + path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf)); + return CreateDirectoryW(wbuf, NULL) ? 0 : -1; +} + + +/* Create substitutes for POSIX functions in Win32. */ + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif + + +/* Implementation of POSIX opendir/closedir/readdir for Windows. */ +FUNCTION_MAY_BE_UNUSED +static DIR * +mg_opendir(const struct mg_connection *conn, const char *name) +{ + DIR *dir = NULL; + wchar_t wpath[W_PATH_MAX]; + DWORD attrs; + + if (name == NULL) { + SetLastError(ERROR_BAD_ARGUMENTS); + } else if ((dir = (DIR *)mg_malloc(sizeof(*dir))) == NULL) { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + } else { + path_to_unicode(conn, name, wpath, ARRAY_SIZE(wpath)); + attrs = GetFileAttributesW(wpath); + if ((wcslen(wpath) + 2 < ARRAY_SIZE(wpath)) && (attrs != 0xFFFFFFFF) + && ((attrs & FILE_ATTRIBUTE_DIRECTORY) != 0)) { + (void)wcscat(wpath, L"\\*"); + dir->handle = FindFirstFileW(wpath, &dir->info); + dir->result.d_name[0] = '\0'; + } else { + mg_free(dir); + dir = NULL; + } + } + + return dir; +} + + +FUNCTION_MAY_BE_UNUSED +static int +mg_closedir(DIR *dir) +{ + int result = 0; + + if (dir != NULL) { + if (dir->handle != INVALID_HANDLE_VALUE) + result = FindClose(dir->handle) ? 0 : -1; + + mg_free(dir); + } else { + result = -1; + SetLastError(ERROR_BAD_ARGUMENTS); + } + + return result; +} + + +FUNCTION_MAY_BE_UNUSED +static struct dirent * +mg_readdir(DIR *dir) +{ + struct dirent *result = 0; + + if (dir) { + if (dir->handle != INVALID_HANDLE_VALUE) { + result = &dir->result; + (void)WideCharToMultiByte(CP_UTF8, + 0, + dir->info.cFileName, + -1, + result->d_name, + sizeof(result->d_name), + NULL, + NULL); + + if (!FindNextFileW(dir->handle, &dir->info)) { + (void)FindClose(dir->handle); + dir->handle = INVALID_HANDLE_VALUE; + } + + } else { + SetLastError(ERROR_FILE_NOT_FOUND); + } + } else { + SetLastError(ERROR_BAD_ARGUMENTS); + } + + return result; +} + + +#if !defined(HAVE_POLL) +#undef POLLIN +#undef POLLPRI +#undef POLLOUT +#define POLLIN (1) /* Data ready - read will not block. */ +#define POLLPRI (2) /* Priority data ready. */ +#define POLLOUT (4) /* Send queue not full - write will not block. */ + +FUNCTION_MAY_BE_UNUSED +static int +poll(struct mg_pollfd *pfd, unsigned int n, int milliseconds) +{ + struct timeval tv; + fd_set rset; + fd_set wset; + unsigned int i; + int result; + SOCKET maxfd = 0; + + memset(&tv, 0, sizeof(tv)); + tv.tv_sec = milliseconds / 1000; + tv.tv_usec = (milliseconds % 1000) * 1000; + FD_ZERO(&rset); + FD_ZERO(&wset); + + for (i = 0; i < n; i++) { + if (pfd[i].events & POLLIN) { + FD_SET(pfd[i].fd, &rset); + } + if (pfd[i].events & POLLOUT) { + FD_SET(pfd[i].fd, &wset); + } + pfd[i].revents = 0; + + if (pfd[i].fd > maxfd) { + maxfd = pfd[i].fd; + } + } + + if ((result = select((int)maxfd + 1, &rset, &wset, NULL, &tv)) > 0) { + for (i = 0; i < n; i++) { + if (FD_ISSET(pfd[i].fd, &rset)) { + pfd[i].revents |= POLLIN; + } + if (FD_ISSET(pfd[i].fd, &wset)) { + pfd[i].revents |= POLLOUT; + } + } + } + + /* We should subtract the time used in select from remaining + * "milliseconds", in particular if called from mg_poll with a + * timeout quantum. + * Unfortunately, the remaining time is not stored in "tv" in all + * implementations, so the result in "tv" must be considered undefined. + * See http://man7.org/linux/man-pages/man2/select.2.html */ + + return result; +} +#endif /* HAVE_POLL */ + + +#if defined(GCC_DIAGNOSTIC) +/* Enable unused function warning again */ +#pragma GCC diagnostic pop +#endif + + +static void +set_close_on_exec(SOCKET sock, + const struct mg_connection *conn /* may be null */, + struct mg_context *ctx /* may be null */) +{ + (void)conn; /* Unused. */ + (void)ctx; +#if defined(_WIN32_WCE) + (void)sock; +#else + (void)SetHandleInformation((HANDLE)(intptr_t)sock, HANDLE_FLAG_INHERIT, 0); +#endif +} + + +int +mg_start_thread(mg_thread_func_t f, void *p) +{ +#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) + /* Compile-time option to control stack size, e.g. + * -DUSE_STACK_SIZE=16384 + */ + return ((_beginthread((void(__cdecl *)(void *))f, USE_STACK_SIZE, p) + == ((uintptr_t)(-1L))) + ? -1 + : 0); +#else + return ( + (_beginthread((void(__cdecl *)(void *))f, 0, p) == ((uintptr_t)(-1L))) + ? -1 + : 0); +#endif /* defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) */ +} + + +/* Start a thread storing the thread context. */ +static int +mg_start_thread_with_id(unsigned(__stdcall *f)(void *), + void *p, + pthread_t *threadidptr) +{ + uintptr_t uip; + HANDLE threadhandle; + int result = -1; + + uip = _beginthreadex(NULL, 0, f, p, 0, NULL); + threadhandle = (HANDLE)uip; + if ((uip != 0) && (threadidptr != NULL)) { + *threadidptr = threadhandle; + result = 0; + } + + return result; +} + + +/* Wait for a thread to finish. */ +static int +mg_join_thread(pthread_t threadid) +{ + int result; + DWORD dwevent; + + result = -1; + dwevent = WaitForSingleObject(threadid, (DWORD)INFINITE); + if (dwevent == WAIT_FAILED) { + DEBUG_TRACE("WaitForSingleObject() failed, error %d", ERRNO); + } else { + if (dwevent == WAIT_OBJECT_0) { + CloseHandle(threadid); + result = 0; + } + } + + return result; +} + +#if !defined(NO_SSL_DL) && !defined(NO_SSL) +/* If SSL is loaded dynamically, dlopen/dlclose is required. */ +/* Create substitutes for POSIX functions in Win32. */ + +#if defined(GCC_DIAGNOSTIC) +/* Show no warning in case system functions are not used. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif + + +FUNCTION_MAY_BE_UNUSED +static HANDLE +dlopen(const char *dll_name, int flags) +{ + wchar_t wbuf[W_PATH_MAX]; + (void)flags; + path_to_unicode(NULL, dll_name, wbuf, ARRAY_SIZE(wbuf)); + return LoadLibraryW(wbuf); +} + + +FUNCTION_MAY_BE_UNUSED +static int +dlclose(void *handle) +{ + int result; + + if (FreeLibrary((HMODULE)handle) != 0) { + result = 0; + } else { + result = -1; + } + + return result; +} + + +#if defined(GCC_DIAGNOSTIC) +/* Enable unused function warning again */ +#pragma GCC diagnostic pop +#endif + +#endif + + +#if !defined(NO_CGI) +#define SIGKILL (0) + + +static int +kill(pid_t pid, int sig_num) +{ + (void)TerminateProcess((HANDLE)pid, (UINT)sig_num); + (void)CloseHandle((HANDLE)pid); + return 0; +} + + +#if !defined(WNOHANG) +#define WNOHANG (1) +#endif + + +static pid_t +waitpid(pid_t pid, int *status, int flags) +{ + DWORD timeout = INFINITE; + DWORD waitres; + + (void)status; /* Currently not used by any client here */ + + if ((flags | WNOHANG) == WNOHANG) { + timeout = 0; + } + + waitres = WaitForSingleObject((HANDLE)pid, timeout); + if (waitres == WAIT_OBJECT_0) { + return pid; + } + if (waitres == WAIT_TIMEOUT) { + return 0; + } + return (pid_t)-1; +} + + +static void +trim_trailing_whitespaces(char *s) +{ + char *e = s + strlen(s); + while ((e > s) && isspace((unsigned char)e[-1])) { + *(--e) = '\0'; + } +} + + +static pid_t +spawn_process(struct mg_connection *conn, + const char *prog, + char *envblk, + char *envp[], + int fdin[2], + int fdout[2], + int fderr[2], + const char *dir) +{ + HANDLE me; + char *p, *interp, full_interp[PATH_MAX], full_dir[PATH_MAX], + cmdline[PATH_MAX], buf[PATH_MAX]; + int truncated; + struct mg_file file = STRUCT_FILE_INITIALIZER; + STARTUPINFOA si; + PROCESS_INFORMATION pi = {0}; + + (void)envp; + + memset(&si, 0, sizeof(si)); + si.cb = sizeof(si); + + si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; + si.wShowWindow = SW_HIDE; + + me = GetCurrentProcess(); + DuplicateHandle(me, + (HANDLE)_get_osfhandle(fdin[0]), + me, + &si.hStdInput, + 0, + TRUE, + DUPLICATE_SAME_ACCESS); + DuplicateHandle(me, + (HANDLE)_get_osfhandle(fdout[1]), + me, + &si.hStdOutput, + 0, + TRUE, + DUPLICATE_SAME_ACCESS); + DuplicateHandle(me, + (HANDLE)_get_osfhandle(fderr[1]), + me, + &si.hStdError, + 0, + TRUE, + DUPLICATE_SAME_ACCESS); + + /* Mark handles that should not be inherited. See + * https://msdn.microsoft.com/en-us/library/windows/desktop/ms682499%28v=vs.85%29.aspx + */ + SetHandleInformation((HANDLE)_get_osfhandle(fdin[1]), + HANDLE_FLAG_INHERIT, + 0); + SetHandleInformation((HANDLE)_get_osfhandle(fdout[0]), + HANDLE_FLAG_INHERIT, + 0); + SetHandleInformation((HANDLE)_get_osfhandle(fderr[0]), + HANDLE_FLAG_INHERIT, + 0); + + /* If CGI file is a script, try to read the interpreter line */ + interp = conn->dom_ctx->config[CGI_INTERPRETER]; + if (interp == NULL) { + buf[0] = buf[1] = '\0'; + + /* Read the first line of the script into the buffer */ + mg_snprintf( + conn, &truncated, cmdline, sizeof(cmdline), "%s/%s", dir, prog); + + if (truncated) { + pi.hProcess = (pid_t)-1; + goto spawn_cleanup; + } + + if (mg_fopen(conn, cmdline, MG_FOPEN_MODE_READ, &file)) { +#if defined(MG_USE_OPEN_FILE) + p = (char *)file.access.membuf; +#else + p = (char *)NULL; +#endif + mg_fgets(buf, sizeof(buf), &file, &p); + (void)mg_fclose(&file.access); /* ignore error on read only file */ + buf[sizeof(buf) - 1] = '\0'; + } + + if ((buf[0] == '#') && (buf[1] == '!')) { + trim_trailing_whitespaces(buf + 2); + } else { + buf[2] = '\0'; + } + interp = buf + 2; + } + + if (interp[0] != '\0') { + GetFullPathNameA(interp, sizeof(full_interp), full_interp, NULL); + interp = full_interp; + } + GetFullPathNameA(dir, sizeof(full_dir), full_dir, NULL); + + if (interp[0] != '\0') { + mg_snprintf(conn, + &truncated, + cmdline, + sizeof(cmdline), + "\"%s\" \"%s\\%s\"", + interp, + full_dir, + prog); + } else { + mg_snprintf(conn, + &truncated, + cmdline, + sizeof(cmdline), + "\"%s\\%s\"", + full_dir, + prog); + } + + if (truncated) { + pi.hProcess = (pid_t)-1; + goto spawn_cleanup; + } + + DEBUG_TRACE("Running [%s]", cmdline); + if (CreateProcessA(NULL, + cmdline, + NULL, + NULL, + TRUE, + CREATE_NEW_PROCESS_GROUP, + envblk, + NULL, + &si, + &pi) + == 0) { + mg_cry_internal( + conn, "%s: CreateProcess(%s): %ld", __func__, cmdline, (long)ERRNO); + pi.hProcess = (pid_t)-1; + /* goto spawn_cleanup; */ + } + +spawn_cleanup: + (void)CloseHandle(si.hStdOutput); + (void)CloseHandle(si.hStdError); + (void)CloseHandle(si.hStdInput); + if (pi.hThread != NULL) { + (void)CloseHandle(pi.hThread); + } + + return (pid_t)pi.hProcess; +} +#endif /* !NO_CGI */ + + +static int +set_blocking_mode(SOCKET sock) +{ + unsigned long non_blocking = 0; + return ioctlsocket(sock, (long)FIONBIO, &non_blocking); +} + +static int +set_non_blocking_mode(SOCKET sock) +{ + unsigned long non_blocking = 1; + return ioctlsocket(sock, (long)FIONBIO, &non_blocking); +} + +#else + +static int +mg_stat(const struct mg_connection *conn, + const char *path, + struct mg_file_stat *filep) +{ + struct stat st; + if (!filep) { + return 0; + } + memset(filep, 0, sizeof(*filep)); + + if (conn && is_file_in_memory(conn, path)) { + + /* Quick fix (for 1.9.x): */ + /* mg_stat must fill all fields, also for files in memory */ + struct mg_file tmp_file = STRUCT_FILE_INITIALIZER; + open_file_in_memory(conn, path, &tmp_file, MG_FOPEN_MODE_NONE); + filep->size = tmp_file.stat.size; + filep->last_modified = time(NULL); + filep->location = 2; + /* TODO: remove legacy "files in memory" feature */ + + return 1; + } + + if (0 == stat(path, &st)) { + filep->size = (uint64_t)(st.st_size); + filep->last_modified = st.st_mtime; + filep->is_directory = S_ISDIR(st.st_mode); + return 1; + } + + return 0; +} + + +static void +set_close_on_exec(int fd, + const struct mg_connection *conn /* may be null */, + struct mg_context *ctx /* may be null */) +{ + if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) { + if (conn || ctx) { + struct mg_connection fc; + mg_cry_internal((conn ? conn : fake_connection(&fc, ctx)), + "%s: fcntl(F_SETFD FD_CLOEXEC) failed: %s", + __func__, + strerror(ERRNO)); + } + } +} + + +int +mg_start_thread(mg_thread_func_t func, void *param) +{ + pthread_t thread_id; + pthread_attr_t attr; + int result; + + (void)pthread_attr_init(&attr); + (void)pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + +#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) + /* Compile-time option to control stack size, + * e.g. -DUSE_STACK_SIZE=16384 */ + (void)pthread_attr_setstacksize(&attr, USE_STACK_SIZE); +#endif /* defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) */ + + result = pthread_create(&thread_id, &attr, func, param); + pthread_attr_destroy(&attr); + + return result; +} + + +/* Start a thread storing the thread context. */ +static int +mg_start_thread_with_id(mg_thread_func_t func, + void *param, + pthread_t *threadidptr) +{ + pthread_t thread_id; + pthread_attr_t attr; + int result; + + (void)pthread_attr_init(&attr); + +#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) + /* Compile-time option to control stack size, + * e.g. -DUSE_STACK_SIZE=16384 */ + (void)pthread_attr_setstacksize(&attr, USE_STACK_SIZE); +#endif /* defined(USE_STACK_SIZE) && USE_STACK_SIZE > 1 */ + + result = pthread_create(&thread_id, &attr, func, param); + pthread_attr_destroy(&attr); + if ((result == 0) && (threadidptr != NULL)) { + *threadidptr = thread_id; + } + return result; +} + + +/* Wait for a thread to finish. */ +static int +mg_join_thread(pthread_t threadid) +{ + int result; + + result = pthread_join(threadid, NULL); + return result; +} + + +#if !defined(NO_CGI) +static pid_t +spawn_process(struct mg_connection *conn, + const char *prog, + char *envblk, + char *envp[], + int fdin[2], + int fdout[2], + int fderr[2], + const char *dir) +{ + pid_t pid; + const char *interp; + + (void)envblk; + + if ((pid = fork()) == -1) { + /* Parent */ + mg_cry_internal(conn, "%s: fork(): %s", __func__, strerror(ERRNO)); + } else if (pid != 0) { + /* Make sure children close parent-side descriptors. + * The caller will close the child-side immediately. */ + set_close_on_exec(fdin[1], conn, NULL); /* stdin write */ + set_close_on_exec(fdout[0], conn, NULL); /* stdout read */ + set_close_on_exec(fderr[0], conn, NULL); /* stderr read */ + } else { + /* Child */ + if (chdir(dir) != 0) { + mg_cry_internal( + conn, "%s: chdir(%s): %s", __func__, dir, strerror(ERRNO)); + } else if (dup2(fdin[0], 0) == -1) { + mg_cry_internal(conn, + "%s: dup2(%d, 0): %s", + __func__, + fdin[0], + strerror(ERRNO)); + } else if (dup2(fdout[1], 1) == -1) { + mg_cry_internal(conn, + "%s: dup2(%d, 1): %s", + __func__, + fdout[1], + strerror(ERRNO)); + } else if (dup2(fderr[1], 2) == -1) { + mg_cry_internal(conn, + "%s: dup2(%d, 2): %s", + __func__, + fderr[1], + strerror(ERRNO)); + } else { + struct sigaction sa; + + /* Keep stderr and stdout in two different pipes. + * Stdout will be sent back to the client, + * stderr should go into a server error log. */ + (void)close(fdin[0]); + (void)close(fdout[1]); + (void)close(fderr[1]); + + /* Close write end fdin and read end fdout and fderr */ + (void)close(fdin[1]); + (void)close(fdout[0]); + (void)close(fderr[0]); + + /* After exec, all signal handlers are restored to their default + * values, with one exception of SIGCHLD. According to + * POSIX.1-2001 and Linux's implementation, SIGCHLD's handler + * will leave unchanged after exec if it was set to be ignored. + * Restore it to default action. */ + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = SIG_DFL; + sigaction(SIGCHLD, &sa, NULL); + + interp = conn->dom_ctx->config[CGI_INTERPRETER]; + if (interp == NULL) { + (void)execle(prog, prog, NULL, envp); + mg_cry_internal(conn, + "%s: execle(%s): %s", + __func__, + prog, + strerror(ERRNO)); + } else { + (void)execle(interp, interp, prog, NULL, envp); + mg_cry_internal(conn, + "%s: execle(%s %s): %s", + __func__, + interp, + prog, + strerror(ERRNO)); + } + } + exit(EXIT_FAILURE); + } + + return pid; +} +#endif /* !NO_CGI */ + + +static int +set_non_blocking_mode(SOCKET sock) +{ + int flags = fcntl(sock, F_GETFL, 0); + if (flags < 0) { + return -1; + } + + if (fcntl(sock, F_SETFL, (flags | O_NONBLOCK)) < 0) { + return -1; + } + return 0; +} + +static int +set_blocking_mode(SOCKET sock) +{ + int flags = fcntl(sock, F_GETFL, 0); + if (flags < 0) { + return -1; + } + + if (fcntl(sock, F_SETFL, flags & (~(int)(O_NONBLOCK))) < 0) { + return -1; + } + return 0; +} +#endif /* _WIN32 / else */ + +/* End of initial operating system specific define block. */ + + +/* Get a random number (independent of C rand function) */ +static uint64_t +get_random(void) +{ + static uint64_t lfsr = 0; /* Linear feedback shift register */ + static uint64_t lcg = 0; /* Linear congruential generator */ + uint64_t now = mg_get_current_time_ns(); + + if (lfsr == 0) { + /* lfsr will be only 0 if has not been initialized, + * so this code is called only once. */ + lfsr = mg_get_current_time_ns(); + lcg = mg_get_current_time_ns(); + } else { + /* Get the next step of both random number generators. */ + lfsr = (lfsr >> 1) + | ((((lfsr >> 0) ^ (lfsr >> 1) ^ (lfsr >> 3) ^ (lfsr >> 4)) & 1) + << 63); + lcg = lcg * 6364136223846793005LL + 1442695040888963407LL; + } + + /* Combining two pseudo-random number generators and a high resolution + * part + * of the current server time will make it hard (impossible?) to guess + * the + * next number. */ + return (lfsr ^ lcg ^ now); +} + + +static int +mg_poll(struct mg_pollfd *pfd, + unsigned int n, + int milliseconds, + volatile int *stop_server) +{ + /* Call poll, but only for a maximum time of a few seconds. + * This will allow to stop the server after some seconds, instead + * of having to wait for a long socket timeout. */ + int ms_now = SOCKET_TIMEOUT_QUANTUM; /* Sleep quantum in ms */ + + do { + int result; + + if (*stop_server) { + /* Shut down signal */ + return -2; + } + + if ((milliseconds >= 0) && (milliseconds < ms_now)) { + ms_now = milliseconds; + } + + result = poll(pfd, n, ms_now); + if (result != 0) { + /* Poll returned either success (1) or error (-1). + * Forward both to the caller. */ + return result; + } + + /* Poll returned timeout (0). */ + if (milliseconds > 0) { + milliseconds -= ms_now; + } + + } while (milliseconds != 0); + + /* timeout: return 0 */ + return 0; +} + + +/* Write data to the IO channel - opened file descriptor, socket or SSL + * descriptor. + * Return value: + * >=0 .. number of bytes successfully written + * -1 .. timeout + * -2 .. error + */ +static int +push_inner(struct mg_context *ctx, + FILE *fp, + SOCKET sock, + SSL *ssl, + const char *buf, + int len, + double timeout) +{ + uint64_t start = 0, now = 0, timeout_ns = 0; + int n, err; + unsigned ms_wait = SOCKET_TIMEOUT_QUANTUM; /* Sleep quantum in ms */ + +#if defined(_WIN32) + typedef int len_t; +#else + typedef size_t len_t; +#endif + + if (timeout > 0) { + now = mg_get_current_time_ns(); + start = now; + timeout_ns = (uint64_t)(timeout * 1.0E9); + } + + if (ctx == NULL) { + return -2; + } + +#if defined(NO_SSL) + if (ssl) { + return -2; + } +#endif + + /* Try to read until it succeeds, fails, times out, or the server + * shuts down. */ + for (;;) { + +#if !defined(NO_SSL) + if (ssl != NULL) { + n = SSL_write(ssl, buf, len); + if (n <= 0) { + err = SSL_get_error(ssl, n); + if ((err == SSL_ERROR_SYSCALL) && (n == -1)) { + err = ERRNO; + } else if ((err == SSL_ERROR_WANT_READ) + || (err == SSL_ERROR_WANT_WRITE)) { + n = 0; + } else { + DEBUG_TRACE("SSL_write() failed, error %d", err); + return -2; + } + } else { + err = 0; + } + } else +#endif + if (fp != NULL) { + n = (int)fwrite(buf, 1, (size_t)len, fp); + if (ferror(fp)) { + n = -1; + err = ERRNO; + } else { + err = 0; + } + } else { + n = (int)send(sock, buf, (len_t)len, MSG_NOSIGNAL); + err = (n < 0) ? ERRNO : 0; +#if defined(_WIN32) + if (err == WSAEWOULDBLOCK) { + err = 0; + n = 0; + } +#else + if (err == EWOULDBLOCK) { + err = 0; + n = 0; + } +#endif + if (n < 0) { + /* shutdown of the socket at client side */ + return -2; + } + } + + if (ctx->stop_flag) { + return -2; + } + + if ((n > 0) || ((n == 0) && (len == 0))) { + /* some data has been read, or no data was requested */ + return n; + } + if (n < 0) { + /* socket error - check errno */ + DEBUG_TRACE("send() failed, error %d", err); + + /* TODO (mid): error handling depending on the error code. + * These codes are different between Windows and Linux. + * Currently there is no problem with failing send calls, + * if there is a reproducible situation, it should be + * investigated in detail. + */ + return -2; + } + + /* Only in case n=0 (timeout), repeat calling the write function */ + + /* If send failed, wait before retry */ + if (fp != NULL) { + /* For files, just wait a fixed time. + * Maybe it helps, maybe not. */ + mg_sleep(5); + } else { + /* For sockets, wait for the socket using poll */ + struct mg_pollfd pfd[1]; + int pollres; + + pfd[0].fd = sock; + pfd[0].events = POLLOUT; + pollres = mg_poll(pfd, 1, (int)(ms_wait), &(ctx->stop_flag)); + if (ctx->stop_flag) { + return -2; + } + if (pollres > 0) { + continue; + } + } + + if (timeout > 0) { + now = mg_get_current_time_ns(); + if ((now - start) > timeout_ns) { + /* Timeout */ + break; + } + } + } + + (void)err; /* Avoid unused warning if NO_SSL is set and DEBUG_TRACE is not + used */ + + return -1; +} + + +static int +push_all(struct mg_context *ctx, + FILE *fp, + SOCKET sock, + SSL *ssl, + const char *buf, + int len) +{ + double timeout = -1.0; + int n, nwritten = 0; + + if (ctx == NULL) { + return -1; + } + + if (ctx->dd.config[REQUEST_TIMEOUT]) { + timeout = atoi(ctx->dd.config[REQUEST_TIMEOUT]) / 1000.0; + } + + while ((len > 0) && (ctx->stop_flag == 0)) { + n = push_inner(ctx, fp, sock, ssl, buf + nwritten, len, timeout); + if (n < 0) { + if (nwritten == 0) { + nwritten = -1; /* Propagate the error */ + } + break; + } else if (n == 0) { + break; /* No more data to write */ + } else { + nwritten += n; + len -= n; + } + } + + return nwritten; +} + + +/* Read from IO channel - opened file descriptor, socket, or SSL descriptor. + * Return value: + * >=0 .. number of bytes successfully read + * -1 .. timeout + * -2 .. error + */ +static int +pull_inner(FILE *fp, + struct mg_connection *conn, + char *buf, + int len, + double timeout) +{ + int nread, err = 0; + +#if defined(_WIN32) + typedef int len_t; +#else + typedef size_t len_t; +#endif +#if !defined(NO_SSL) + int ssl_pending; +#endif + + /* We need an additional wait loop around this, because in some cases + * with TLSwe may get data from the socket but not from SSL_read. + * In this case we need to repeat at least once. + */ + + if (fp != NULL) { +#if !defined(_WIN32_WCE) + /* Use read() instead of fread(), because if we're reading from the + * CGI pipe, fread() may block until IO buffer is filled up. We + * cannot afford to block and must pass all read bytes immediately + * to the client. */ + nread = (int)read(fileno(fp), buf, (size_t)len); +#else + /* WinCE does not support CGI pipes */ + nread = (int)fread(buf, 1, (size_t)len, fp); +#endif + err = (nread < 0) ? ERRNO : 0; + if ((nread == 0) && (len > 0)) { + /* Should get data, but got EOL */ + return -2; + } + +#if !defined(NO_SSL) + } else if ((conn->ssl != NULL) + && ((ssl_pending = SSL_pending(conn->ssl)) > 0)) { + /* We already know there is no more data buffered in conn->buf + * but there is more available in the SSL layer. So don't poll + * conn->client.sock yet. */ + if (ssl_pending > len) { + ssl_pending = len; + } + nread = SSL_read(conn->ssl, buf, ssl_pending); + if (nread <= 0) { + err = SSL_get_error(conn->ssl, nread); + if ((err == SSL_ERROR_SYSCALL) && (nread == -1)) { + err = ERRNO; + } else if ((err == SSL_ERROR_WANT_READ) + || (err == SSL_ERROR_WANT_WRITE)) { + nread = 0; + } else { + /* All errors should return -2 */ + DEBUG_TRACE("SSL_read() failed, error %d", err); + return -2; + } + + ERR_clear_error(); + } else { + err = 0; + } + + } else if (conn->ssl != NULL) { + + struct mg_pollfd pfd[1]; + int pollres; + + pfd[0].fd = conn->client.sock; + pfd[0].events = POLLIN; + pollres = mg_poll(pfd, + 1, + (int)(timeout * 1000.0), + &(conn->phys_ctx->stop_flag)); + if (conn->phys_ctx->stop_flag) { + return -2; + } + if (pollres > 0) { + nread = SSL_read(conn->ssl, buf, len); + if (nread <= 0) { + err = SSL_get_error(conn->ssl, nread); + if ((err == SSL_ERROR_SYSCALL) && (nread == -1)) { + err = ERRNO; + } else if ((err == SSL_ERROR_WANT_READ) + || (err == SSL_ERROR_WANT_WRITE)) { + nread = 0; + } else { + DEBUG_TRACE("SSL_read() failed, error %d", err); + return -2; + } + } else { + err = 0; + } + ERR_clear_error(); + } else if (pollres < 0) { + /* Error */ + return -2; + } else { + /* pollres = 0 means timeout */ + nread = 0; + } +#endif + + } else { + struct mg_pollfd pfd[1]; + int pollres; + + pfd[0].fd = conn->client.sock; + pfd[0].events = POLLIN; + pollres = mg_poll(pfd, + 1, + (int)(timeout * 1000.0), + &(conn->phys_ctx->stop_flag)); + if (conn->phys_ctx->stop_flag) { + return -2; + } + if (pollres > 0) { + nread = (int)recv(conn->client.sock, buf, (len_t)len, 0); + err = (nread < 0) ? ERRNO : 0; + if (nread <= 0) { + /* shutdown of the socket at client side */ + return -2; + } + } else if (pollres < 0) { + /* error callint poll */ + return -2; + } else { + /* pollres = 0 means timeout */ + nread = 0; + } + } + + if (conn->phys_ctx->stop_flag) { + return -2; + } + + if ((nread > 0) || ((nread == 0) && (len == 0))) { + /* some data has been read, or no data was requested */ + return nread; + } + + if (nread < 0) { +/* socket error - check errno */ +#if defined(_WIN32) + if (err == WSAEWOULDBLOCK) { + /* TODO (low): check if this is still required */ + /* standard case if called from close_socket_gracefully */ + return -2; + } else if (err == WSAETIMEDOUT) { + /* TODO (low): check if this is still required */ + /* timeout is handled by the while loop */ + return 0; + } else if (err == WSAECONNABORTED) { + /* See https://www.chilkatsoft.com/p/p_299.asp */ + return -2; + } else { + DEBUG_TRACE("recv() failed, error %d", err); + return -2; + } +#else + /* TODO: POSIX returns either EAGAIN or EWOULDBLOCK in both cases, + * if the timeout is reached and if the socket was set to non- + * blocking in close_socket_gracefully, so we can not distinguish + * here. We have to wait for the timeout in both cases for now. + */ + if ((err == EAGAIN) || (err == EWOULDBLOCK) || (err == EINTR)) { + /* TODO (low): check if this is still required */ + /* EAGAIN/EWOULDBLOCK: + * standard case if called from close_socket_gracefully + * => should return -1 */ + /* or timeout occurred + * => the code must stay in the while loop */ + + /* EINTR can be generated on a socket with a timeout set even + * when SA_RESTART is effective for all relevant signals + * (see signal(7)). + * => stay in the while loop */ + } else { + DEBUG_TRACE("recv() failed, error %d", err); + return -2; + } +#endif + } + + /* Timeout occurred, but no data available. */ + return -1; +} + + +static int +pull_all(FILE *fp, struct mg_connection *conn, char *buf, int len) +{ + int n, nread = 0; + double timeout = -1.0; + uint64_t start_time = 0, now = 0, timeout_ns = 0; + + if (conn->dom_ctx->config[REQUEST_TIMEOUT]) { + timeout = atoi(conn->dom_ctx->config[REQUEST_TIMEOUT]) / 1000.0; + } + if (timeout >= 0.0) { + start_time = mg_get_current_time_ns(); + timeout_ns = (uint64_t)(timeout * 1.0E9); + } + + while ((len > 0) && (conn->phys_ctx->stop_flag == 0)) { + n = pull_inner(fp, conn, buf + nread, len, timeout); + if (n == -2) { + if (nread == 0) { + nread = -1; /* Propagate the error */ + } + break; + } else if (n == -1) { + /* timeout */ + if (timeout >= 0.0) { + now = mg_get_current_time_ns(); + if ((now - start_time) <= timeout_ns) { + continue; + } + } + break; + } else if (n == 0) { + break; /* No more data to read */ + } else { + nread += n; + len -= n; + } + } + + return nread; +} + + +static void +discard_unread_request_data(struct mg_connection *conn) +{ + char buf[MG_BUF_LEN]; + + while (mg_read(conn, buf, sizeof(buf)) > 0) + ; +} + + +static int +mg_read_inner(struct mg_connection *conn, void *buf, size_t len) +{ + int64_t content_len, n, buffered_len, nread; + int64_t len64 = + (int64_t)((len > INT_MAX) ? INT_MAX : len); /* since the return value is + * int, we may not read more + * bytes */ + const char *body; + + if (conn == NULL) { + return 0; + } + + /* If Content-Length is not set for a response with body data, + * we do not know in advance how much data should be read. */ + content_len = conn->content_len; + if (content_len < 0) { + /* The body data is completed when the connection is closed. */ + content_len = INT64_MAX; + } + + nread = 0; + if (conn->consumed_content < content_len) { + /* Adjust number of bytes to read. */ + int64_t left_to_read = content_len - conn->consumed_content; + if (left_to_read < len64) { + /* Do not read more than the total content length of the + * request. + */ + len64 = left_to_read; + } + + /* Return buffered data */ + buffered_len = (int64_t)(conn->data_len) - (int64_t)conn->request_len + - conn->consumed_content; + if (buffered_len > 0) { + if (len64 < buffered_len) { + buffered_len = len64; + } + body = conn->buf + conn->request_len + conn->consumed_content; + memcpy(buf, body, (size_t)buffered_len); + len64 -= buffered_len; + conn->consumed_content += buffered_len; + nread += buffered_len; + buf = (char *)buf + buffered_len; + } + + /* We have returned all buffered data. Read new data from the remote + * socket. + */ + if ((n = pull_all(NULL, conn, (char *)buf, (int)len64)) >= 0) { + conn->consumed_content += n; + nread += n; + } else { + nread = ((nread > 0) ? nread : n); + } + } + return (int)nread; +} + + +int +mg_read(struct mg_connection *conn, void *buf, size_t len) +{ + if (len > INT_MAX) { + len = INT_MAX; + } + + if (conn == NULL) { + return 0; + } + + if (conn->is_chunked) { + size_t all_read = 0; + + while (len > 0) { + if (conn->is_chunked >= 3) { + /* No more data left to read */ + return 0; + } + if (conn->is_chunked != 1) { + /* Has error */ + return -1; + } + + if (conn->consumed_content != conn->content_len) { + /* copy from the current chunk */ + int read_ret = mg_read_inner(conn, (char *)buf + all_read, len); + + if (read_ret < 1) { + /* read error */ + conn->is_chunked = 2; + return -1; + } + + all_read += (size_t)read_ret; + len -= (size_t)read_ret; + + if (conn->consumed_content == conn->content_len) { + /* Add data bytes in the current chunk have been read, + * so we are expecting \r\n now. */ + char x[2]; + conn->content_len += 2; + if ((mg_read_inner(conn, x, 2) != 2) || (x[0] != '\r') + || (x[1] != '\n')) { + /* Protocol violation */ + conn->is_chunked = 2; + return -1; + } + } + + } else { + /* fetch a new chunk */ + size_t i; + char lenbuf[64]; + char *end = NULL; + unsigned long chunkSize = 0; + + for (i = 0; i < (sizeof(lenbuf) - 1); i++) { + conn->content_len++; + if (mg_read_inner(conn, lenbuf + i, 1) != 1) { + lenbuf[i] = 0; + } + if ((i > 0) && (lenbuf[i] == '\r') + && (lenbuf[i - 1] != '\r')) { + continue; + } + if ((i > 1) && (lenbuf[i] == '\n') + && (lenbuf[i - 1] == '\r')) { + lenbuf[i + 1] = 0; + chunkSize = strtoul(lenbuf, &end, 16); + if (chunkSize == 0) { + /* regular end of content */ + conn->is_chunked = 3; + } + break; + } + if (!isxdigit((unsigned char)lenbuf[i])) { + /* illegal character for chunk length */ + conn->is_chunked = 2; + return -1; + } + } + if ((end == NULL) || (*end != '\r')) { + /* chunksize not set correctly */ + conn->is_chunked = 2; + return -1; + } + if (chunkSize == 0) { + /* try discarding trailer for keep-alive */ + conn->content_len += 2; + if ((mg_read_inner(conn, lenbuf, 2) == 2) + && (lenbuf[0] == '\r') && (lenbuf[1] == '\n')) { + conn->is_chunked = 4; + } + break; + } + + /* append a new chunk */ + conn->content_len += chunkSize; + } + } + + return (int)all_read; + } + return mg_read_inner(conn, buf, len); +} + + +int +mg_write(struct mg_connection *conn, const void *buf, size_t len) +{ + time_t now; + int n, total, allowed; + + if (conn == NULL) { + return 0; + } + if (len > INT_MAX) { + return -1; + } + + if (conn->throttle > 0) { + if ((now = time(NULL)) != conn->last_throttle_time) { + conn->last_throttle_time = now; + conn->last_throttle_bytes = 0; + } + allowed = conn->throttle - conn->last_throttle_bytes; + if (allowed > (int)len) { + allowed = (int)len; + } + if ((total = push_all(conn->phys_ctx, + NULL, + conn->client.sock, + conn->ssl, + (const char *)buf, + allowed)) + == allowed) { + buf = (const char *)buf + total; + conn->last_throttle_bytes += total; + while ((total < (int)len) && (conn->phys_ctx->stop_flag == 0)) { + allowed = (conn->throttle > ((int)len - total)) + ? (int)len - total + : conn->throttle; + if ((n = push_all(conn->phys_ctx, + NULL, + conn->client.sock, + conn->ssl, + (const char *)buf, + allowed)) + != allowed) { + break; + } + sleep(1); + conn->last_throttle_bytes = allowed; + conn->last_throttle_time = time(NULL); + buf = (const char *)buf + n; + total += n; + } + } + } else { + total = push_all(conn->phys_ctx, + NULL, + conn->client.sock, + conn->ssl, + (const char *)buf, + (int)len); + } + if (total > 0) { + conn->num_bytes_sent += total; + } + return total; +} + + +/* Send a chunk, if "Transfer-Encoding: chunked" is used */ +int +mg_send_chunk(struct mg_connection *conn, + const char *chunk, + unsigned int chunk_len) +{ + char lenbuf[16]; + size_t lenbuf_len; + int ret; + int t; + + /* First store the length information in a text buffer. */ + sprintf(lenbuf, "%x\r\n", chunk_len); + lenbuf_len = strlen(lenbuf); + + /* Then send length information, chunk and terminating \r\n. */ + ret = mg_write(conn, lenbuf, lenbuf_len); + if (ret != (int)lenbuf_len) { + return -1; + } + t = ret; + + ret = mg_write(conn, chunk, chunk_len); + if (ret != (int)chunk_len) { + return -1; + } + t += ret; + + ret = mg_write(conn, "\r\n", 2); + if (ret != 2) { + return -1; + } + t += ret; + + return t; +} + + +#if defined(GCC_DIAGNOSTIC) +/* This block forwards format strings to printf implementations, + * so we need to disable the format-nonliteral warning. */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +#endif + + +/* Alternative alloc_vprintf() for non-compliant C runtimes */ +static int +alloc_vprintf2(char **buf, const char *fmt, va_list ap) +{ + va_list ap_copy; + size_t size = MG_BUF_LEN / 4; + int len = -1; + + *buf = NULL; + while (len < 0) { + if (*buf) { + mg_free(*buf); + } + + size *= 4; + *buf = (char *)mg_malloc(size); + if (!*buf) { + break; + } + + va_copy(ap_copy, ap); + len = vsnprintf_impl(*buf, size - 1, fmt, ap_copy); + va_end(ap_copy); + (*buf)[size - 1] = 0; + } + + return len; +} + + +/* Print message to buffer. If buffer is large enough to hold the message, + * return buffer. If buffer is to small, allocate large enough buffer on + * heap, + * and return allocated buffer. */ +static int +alloc_vprintf(char **out_buf, + char *prealloc_buf, + size_t prealloc_size, + const char *fmt, + va_list ap) +{ + va_list ap_copy; + int len; + + /* Windows is not standard-compliant, and vsnprintf() returns -1 if + * buffer is too small. Also, older versions of msvcrt.dll do not have + * _vscprintf(). However, if size is 0, vsnprintf() behaves correctly. + * Therefore, we make two passes: on first pass, get required message + * length. + * On second pass, actually print the message. */ + va_copy(ap_copy, ap); + len = vsnprintf_impl(NULL, 0, fmt, ap_copy); + va_end(ap_copy); + + if (len < 0) { + /* C runtime is not standard compliant, vsnprintf() returned -1. + * Switch to alternative code path that uses incremental + * allocations. + */ + va_copy(ap_copy, ap); + len = alloc_vprintf2(out_buf, fmt, ap_copy); + va_end(ap_copy); + + } else if ((size_t)(len) >= prealloc_size) { + /* The pre-allocated buffer not large enough. */ + /* Allocate a new buffer. */ + *out_buf = (char *)mg_malloc((size_t)(len) + 1); + if (!*out_buf) { + /* Allocation failed. Return -1 as "out of memory" error. */ + return -1; + } + /* Buffer allocation successful. Store the string there. */ + va_copy(ap_copy, ap); + IGNORE_UNUSED_RESULT( + vsnprintf_impl(*out_buf, (size_t)(len) + 1, fmt, ap_copy)); + va_end(ap_copy); + + } else { + /* The pre-allocated buffer is large enough. + * Use it to store the string and return the address. */ + va_copy(ap_copy, ap); + IGNORE_UNUSED_RESULT( + vsnprintf_impl(prealloc_buf, prealloc_size, fmt, ap_copy)); + va_end(ap_copy); + *out_buf = prealloc_buf; + } + + return len; +} + + +#if defined(GCC_DIAGNOSTIC) +/* Enable format-nonliteral warning again. */ +#pragma GCC diagnostic pop +#endif + + +static int +mg_vprintf(struct mg_connection *conn, const char *fmt, va_list ap) +{ + char mem[MG_BUF_LEN]; + char *buf = NULL; + int len; + + if ((len = alloc_vprintf(&buf, mem, sizeof(mem), fmt, ap)) > 0) { + len = mg_write(conn, buf, (size_t)len); + } + if (buf != mem) { + mg_free(buf); + } + + return len; +} + + +int +mg_printf(struct mg_connection *conn, const char *fmt, ...) +{ + va_list ap; + int result; + + va_start(ap, fmt); + result = mg_vprintf(conn, fmt, ap); + va_end(ap); + + return result; +} + + +int +mg_url_decode(const char *src, + int src_len, + char *dst, + int dst_len, + int is_form_url_encoded) +{ + int i, j, a, b; +#define HEXTOI(x) (isdigit(x) ? (x - '0') : (x - 'W')) + + for (i = j = 0; (i < src_len) && (j < (dst_len - 1)); i++, j++) { + if ((i < src_len - 2) && (src[i] == '%') + && isxdigit((unsigned char)src[i + 1]) + && isxdigit((unsigned char)src[i + 2])) { + a = tolower((unsigned char)src[i + 1]); + b = tolower((unsigned char)src[i + 2]); + dst[j] = (char)((HEXTOI(a) << 4) | HEXTOI(b)); + i += 2; + } else if (is_form_url_encoded && (src[i] == '+')) { + dst[j] = ' '; + } else { + dst[j] = src[i]; + } + } + + dst[j] = '\0'; /* Null-terminate the destination */ + + return (i >= src_len) ? j : -1; +} + + +int +mg_get_var(const char *data, + size_t data_len, + const char *name, + char *dst, + size_t dst_len) +{ + return mg_get_var2(data, data_len, name, dst, dst_len, 0); +} + + +int +mg_get_var2(const char *data, + size_t data_len, + const char *name, + char *dst, + size_t dst_len, + size_t occurrence) +{ + const char *p, *e, *s; + size_t name_len; + int len; + + if ((dst == NULL) || (dst_len == 0)) { + len = -2; + } else if ((data == NULL) || (name == NULL) || (data_len == 0)) { + len = -1; + dst[0] = '\0'; + } else { + name_len = strlen(name); + e = data + data_len; + len = -1; + dst[0] = '\0'; + + /* data is "var1=val1&var2=val2...". Find variable first */ + for (p = data; p + name_len < e; p++) { + if (((p == data) || (p[-1] == '&')) && (p[name_len] == '=') + && !mg_strncasecmp(name, p, name_len) && 0 == occurrence--) { + /* Point p to variable value */ + p += name_len + 1; + + /* Point s to the end of the value */ + s = (const char *)memchr(p, '&', (size_t)(e - p)); + if (s == NULL) { + s = e; + } + DEBUG_ASSERT(s >= p); + if (s < p) { + return -3; + } + + /* Decode variable into destination buffer */ + len = mg_url_decode(p, (int)(s - p), dst, (int)dst_len, 1); + + /* Redirect error code from -1 to -2 (destination buffer too + * small). */ + if (len == -1) { + len = -2; + } + break; + } + } + } + + return len; +} + + +/* HCP24: some changes to compare hole var_name */ +int +mg_get_cookie(const char *cookie_header, + const char *var_name, + char *dst, + size_t dst_size) +{ + const char *s, *p, *end; + int name_len, len = -1; + + if ((dst == NULL) || (dst_size == 0)) { + return -2; + } + + dst[0] = '\0'; + if ((var_name == NULL) || ((s = cookie_header) == NULL)) { + return -1; + } + + name_len = (int)strlen(var_name); + end = s + strlen(s); + for (; (s = mg_strcasestr(s, var_name)) != NULL; s += name_len) { + if (s[name_len] == '=') { + /* HCP24: now check is it a substring or a full cookie name */ + if ((s == cookie_header) || (s[-1] == ' ')) { + s += name_len + 1; + if ((p = strchr(s, ' ')) == NULL) { + p = end; + } + if (p[-1] == ';') { + p--; + } + if ((*s == '"') && (p[-1] == '"') && (p > s + 1)) { + s++; + p--; + } + if ((size_t)(p - s) < dst_size) { + len = (int)(p - s); + mg_strlcpy(dst, s, (size_t)len + 1); + } else { + len = -3; + } + break; + } + } + } + return len; +} + + +#if defined(USE_WEBSOCKET) || defined(USE_LUA) +static void +base64_encode(const unsigned char *src, int src_len, char *dst) +{ + static const char *b64 = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + int i, j, a, b, c; + + for (i = j = 0; i < src_len; i += 3) { + a = src[i]; + b = ((i + 1) >= src_len) ? 0 : src[i + 1]; + c = ((i + 2) >= src_len) ? 0 : src[i + 2]; + + dst[j++] = b64[a >> 2]; + dst[j++] = b64[((a & 3) << 4) | (b >> 4)]; + if (i + 1 < src_len) { + dst[j++] = b64[(b & 15) << 2 | (c >> 6)]; + } + if (i + 2 < src_len) { + dst[j++] = b64[c & 63]; + } + } + while (j % 4 != 0) { + dst[j++] = '='; + } + dst[j++] = '\0'; +} +#endif + + +#if defined(USE_LUA) +static unsigned char +b64reverse(char letter) +{ + if ((letter >= 'A') && (letter <= 'Z')) { + return letter - 'A'; + } + if ((letter >= 'a') && (letter <= 'z')) { + return letter - 'a' + 26; + } + if ((letter >= '0') && (letter <= '9')) { + return letter - '0' + 52; + } + if (letter == '+') { + return 62; + } + if (letter == '/') { + return 63; + } + if (letter == '=') { + return 255; /* normal end */ + } + return 254; /* error */ +} + + +static int +base64_decode(const unsigned char *src, int src_len, char *dst, size_t *dst_len) +{ + int i; + unsigned char a, b, c, d; + + *dst_len = 0; + + for (i = 0; i < src_len; i += 4) { + a = b64reverse(src[i]); + if (a >= 254) { + return i; + } + + b = b64reverse(((i + 1) >= src_len) ? 0 : src[i + 1]); + if (b >= 254) { + return i + 1; + } + + c = b64reverse(((i + 2) >= src_len) ? 0 : src[i + 2]); + if (c == 254) { + return i + 2; + } + + d = b64reverse(((i + 3) >= src_len) ? 0 : src[i + 3]); + if (d == 254) { + return i + 3; + } + + dst[(*dst_len)++] = (a << 2) + (b >> 4); + if (c != 255) { + dst[(*dst_len)++] = (b << 4) + (c >> 2); + if (d != 255) { + dst[(*dst_len)++] = (c << 6) + d; + } + } + } + return -1; +} +#endif + + +static int +is_put_or_delete_method(const struct mg_connection *conn) +{ + if (conn) { + const char *s = conn->request_info.request_method; + return (s != NULL) + && (!strcmp(s, "PUT") || !strcmp(s, "DELETE") + || !strcmp(s, "MKCOL") || !strcmp(s, "PATCH")); + } + return 0; +} + + +#if !defined(NO_FILES) +static int +extention_matches_script( + struct mg_connection *conn, /* in: request (must be valid) */ + const char *filename /* in: filename (must be valid) */ +) +{ +#if !defined(NO_CGI) + if (match_prefix(conn->dom_ctx->config[CGI_EXTENSIONS], + strlen(conn->dom_ctx->config[CGI_EXTENSIONS]), + filename) + > 0) { + return 1; + } +#endif +#if defined(USE_LUA) + if (match_prefix(conn->dom_ctx->config[LUA_SCRIPT_EXTENSIONS], + strlen(conn->dom_ctx->config[LUA_SCRIPT_EXTENSIONS]), + filename) + > 0) { + return 1; + } +#endif +#if defined(USE_DUKTAPE) + if (match_prefix(conn->dom_ctx->config[DUKTAPE_SCRIPT_EXTENSIONS], + strlen(conn->dom_ctx->config[DUKTAPE_SCRIPT_EXTENSIONS]), + filename) + > 0) { + return 1; + } +#endif + /* filename and conn could be unused, if all preocessor conditions + * are false (no script language supported). */ + (void)filename; + (void)conn; + + return 0; +} + + +/* For given directory path, substitute it to valid index file. + * Return 1 if index file has been found, 0 if not found. + * If the file is found, it's stats is returned in stp. */ +static int +substitute_index_file(struct mg_connection *conn, + char *path, + size_t path_len, + struct mg_file_stat *filestat) +{ + const char *list = conn->dom_ctx->config[INDEX_FILES]; + struct vec filename_vec; + size_t n = strlen(path); + int found = 0; + + /* The 'path' given to us points to the directory. Remove all trailing + * directory separator characters from the end of the path, and + * then append single directory separator character. */ + while ((n > 0) && (path[n - 1] == '/')) { + n--; + } + path[n] = '/'; + + /* Traverse index files list. For each entry, append it to the given + * path and see if the file exists. If it exists, break the loop */ + while ((list = next_option(list, &filename_vec, NULL)) != NULL) { + /* Ignore too long entries that may overflow path buffer */ + if ((filename_vec.len + 1) > (path_len - (n + 1))) { + continue; + } + + /* Prepare full path to the index file */ + mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1); + + /* Does it exist? */ + if (mg_stat(conn, path, filestat)) { + /* Yes it does, break the loop */ + found = 1; + break; + } + } + + /* If no index file exists, restore directory path */ + if (!found) { + path[n] = '\0'; + } + + return found; +} +#endif + + +static void +interpret_uri(struct mg_connection *conn, /* in/out: request (must be valid) */ + char *filename, /* out: filename */ + size_t filename_buf_len, /* in: size of filename buffer */ + struct mg_file_stat *filestat, /* out: file status structure */ + int *is_found, /* out: file found (directly) */ + int *is_script_resource, /* out: handled by a script? */ + int *is_websocket_request, /* out: websocket connetion? */ + int *is_put_or_delete_request /* out: put/delete a file? */ +) +{ + char const *accept_encoding; + +#if !defined(NO_FILES) + const char *uri = conn->request_info.local_uri; + const char *root = conn->dom_ctx->config[DOCUMENT_ROOT]; + const char *rewrite; + struct vec a, b; + ptrdiff_t match_len; + char gz_path[PATH_MAX]; + int truncated; +#if !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE) + char *tmp_str; + size_t tmp_str_len, sep_pos; + int allow_substitute_script_subresources; +#endif +#else + (void)filename_buf_len; /* unused if NO_FILES is defined */ +#endif + + /* Step 1: Set all initially unknown outputs to zero */ + memset(filestat, 0, sizeof(*filestat)); + *filename = 0; + *is_found = 0; + *is_script_resource = 0; + + /* Step 2: Check if the request attempts to modify the file system */ + *is_put_or_delete_request = is_put_or_delete_method(conn); + +/* Step 3: Check if it is a websocket request, and modify the document + * root if required */ +#if defined(USE_WEBSOCKET) + *is_websocket_request = is_websocket_protocol(conn); +#if !defined(NO_FILES) + if (*is_websocket_request && conn->dom_ctx->config[WEBSOCKET_ROOT]) { + root = conn->dom_ctx->config[WEBSOCKET_ROOT]; + } +#endif /* !NO_FILES */ +#else /* USE_WEBSOCKET */ + *is_websocket_request = 0; +#endif /* USE_WEBSOCKET */ + + /* Step 4: Check if gzip encoded response is allowed */ + conn->accept_gzip = 0; + if ((accept_encoding = mg_get_header(conn, "Accept-Encoding")) != NULL) { + if (strstr(accept_encoding, "gzip") != NULL) { + conn->accept_gzip = 1; + } + } + +#if !defined(NO_FILES) + /* Step 5: If there is no root directory, don't look for files. */ + /* Note that root == NULL is a regular use case here. This occurs, + * if all requests are handled by callbacks, so the WEBSOCKET_ROOT + * config is not required. */ + if (root == NULL) { + /* all file related outputs have already been set to 0, just return + */ + return; + } + + /* Step 6: Determine the local file path from the root path and the + * request uri. */ + /* Using filename_buf_len - 1 because memmove() for PATH_INFO may shift + * part of the path one byte on the right. */ + mg_snprintf( + conn, &truncated, filename, filename_buf_len - 1, "%s%s", root, uri); + + if (truncated) { + goto interpret_cleanup; + } + + /* Step 7: URI rewriting */ + rewrite = conn->dom_ctx->config[URL_REWRITE_PATTERN]; + while ((rewrite = next_option(rewrite, &a, &b)) != NULL) { + if ((match_len = match_prefix(a.ptr, a.len, uri)) > 0) { + mg_snprintf(conn, + &truncated, + filename, + filename_buf_len - 1, + "%.*s%s", + (int)b.len, + b.ptr, + uri + match_len); + break; + } + } + + if (truncated) { + goto interpret_cleanup; + } + + /* Step 8: Check if the file exists at the server */ + /* Local file path and name, corresponding to requested URI + * is now stored in "filename" variable. */ + if (mg_stat(conn, filename, filestat)) { + int uri_len = (int)strlen(uri); + int is_uri_end_slash = (uri_len > 0) && (uri[uri_len - 1] == '/'); + + /* 8.1: File exists. */ + *is_found = 1; + + /* 8.2: Check if it is a script type. */ + if (extention_matches_script(conn, filename)) { + /* The request addresses a CGI resource, Lua script or + * server-side javascript. + * The URI corresponds to the script itself (like + * /path/script.cgi), and there is no additional resource + * path (like /path/script.cgi/something). + * Requests that modify (replace or delete) a resource, like + * PUT and DELETE requests, should replace/delete the script + * file. + * Requests that read or write from/to a resource, like GET and + * POST requests, should call the script and return the + * generated response. */ + *is_script_resource = (!*is_put_or_delete_request); + } + + /* 8.3: If the request target is a directory, there could be + * a substitute file (index.html, index.cgi, ...). */ + if (filestat->is_directory && is_uri_end_slash) { + /* Use a local copy here, since substitute_index_file will + * change the content of the file status */ + struct mg_file_stat tmp_filestat; + memset(&tmp_filestat, 0, sizeof(tmp_filestat)); + + if (substitute_index_file( + conn, filename, filename_buf_len, &tmp_filestat)) { + + /* Substitute file found. Copy stat to the output, then + * check if the file is a script file */ + *filestat = tmp_filestat; + + if (extention_matches_script(conn, filename)) { + /* Substitute file is a script file */ + *is_script_resource = 1; + } else { + /* Substitute file is a regular file */ + *is_script_resource = 0; + *is_found = (mg_stat(conn, filename, filestat) ? 1 : 0); + } + } + /* If there is no substitute file, the server could return + * a directory listing in a later step */ + } + return; + } + + /* Step 9: Check for zipped files: */ + /* If we can't find the actual file, look for the file + * with the same name but a .gz extension. If we find it, + * use that and set the gzipped flag in the file struct + * to indicate that the response need to have the content- + * encoding: gzip header. + * We can only do this if the browser declares support. */ + if (conn->accept_gzip) { + mg_snprintf( + conn, &truncated, gz_path, sizeof(gz_path), "%s.gz", filename); + + if (truncated) { + goto interpret_cleanup; + } + + if (mg_stat(conn, gz_path, filestat)) { + if (filestat) { + filestat->is_gzipped = 1; + *is_found = 1; + } + /* Currently gz files can not be scripts. */ + return; + } + } + +#if !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE) + /* Step 10: Script resources may handle sub-resources */ + /* Support PATH_INFO for CGI scripts. */ + tmp_str_len = strlen(filename); + tmp_str = (char *)mg_malloc_ctx(tmp_str_len + PATH_MAX + 1, conn->phys_ctx); + if (!tmp_str) { + /* Out of memory */ + goto interpret_cleanup; + } + memcpy(tmp_str, filename, tmp_str_len + 1); + + /* Check config, if index scripts may have sub-resources */ + allow_substitute_script_subresources = + !mg_strcasecmp(conn->dom_ctx->config[ALLOW_INDEX_SCRIPT_SUB_RES], + "yes"); + + sep_pos = tmp_str_len; + while (sep_pos > 0) { + sep_pos--; + if (tmp_str[sep_pos] == '/') { + int is_script = 0, does_exist = 0; + + tmp_str[sep_pos] = 0; + if (tmp_str[0]) { + is_script = extention_matches_script(conn, tmp_str); + does_exist = mg_stat(conn, tmp_str, filestat); + } + + if (does_exist && is_script) { + filename[sep_pos] = 0; + memmove(filename + sep_pos + 2, + filename + sep_pos + 1, + strlen(filename + sep_pos + 1) + 1); + conn->path_info = filename + sep_pos + 1; + filename[sep_pos + 1] = '/'; + *is_script_resource = 1; + *is_found = 1; + break; + } + + if (allow_substitute_script_subresources) { + if (substitute_index_file( + conn, tmp_str, tmp_str_len + PATH_MAX, filestat)) { + + /* some intermediate directory has an index file */ + if (extention_matches_script(conn, tmp_str)) { + + char *tmp_str2; + + DEBUG_TRACE("Substitute script %s serving path %s", + tmp_str, + filename); + + /* this index file is a script */ + tmp_str2 = mg_strdup_ctx(filename + sep_pos + 1, + conn->phys_ctx); + mg_snprintf(conn, + &truncated, + filename, + filename_buf_len, + "%s//%s", + tmp_str, + tmp_str2); + mg_free(tmp_str2); + + if (truncated) { + mg_free(tmp_str); + goto interpret_cleanup; + } + sep_pos = strlen(tmp_str); + filename[sep_pos] = 0; + conn->path_info = filename + sep_pos + 1; + *is_script_resource = 1; + *is_found = 1; + break; + + } else { + + DEBUG_TRACE("Substitute file %s serving path %s", + tmp_str, + filename); + + /* non-script files will not have sub-resources */ + filename[sep_pos] = 0; + conn->path_info = 0; + *is_script_resource = 0; + *is_found = 0; + break; + } + } + } + + tmp_str[sep_pos] = '/'; + } + } + + mg_free(tmp_str); + +#endif /* !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE) */ +#endif /* !defined(NO_FILES) */ + return; + +#if !defined(NO_FILES) +/* Reset all outputs */ +interpret_cleanup: + memset(filestat, 0, sizeof(*filestat)); + *filename = 0; + *is_found = 0; + *is_script_resource = 0; + *is_websocket_request = 0; + *is_put_or_delete_request = 0; +#endif /* !defined(NO_FILES) */ +} + + +/* Check whether full request is buffered. Return: + * -1 if request or response is malformed + * 0 if request or response is not yet fully buffered + * >0 actual request length, including last \r\n\r\n */ +static int +get_http_header_len(const char *buf, int buflen) +{ + int i; + for (i = 0; i < buflen; i++) { + /* Do an unsigned comparison in some conditions below */ + const unsigned char c = (unsigned char)buf[i]; + + if ((c < 128) && ((char)c != '\r') && ((char)c != '\n') + && !isprint(c)) { + /* abort scan as soon as one malformed character is found */ + return -1; + } + + if (i < buflen - 1) { + if ((buf[i] == '\n') && (buf[i + 1] == '\n')) { + /* Two newline, no carriage return - not standard compliant, + * but + * it + * should be accepted */ + return i + 2; + } + } + + if (i < buflen - 3) { + if ((buf[i] == '\r') && (buf[i + 1] == '\n') && (buf[i + 2] == '\r') + && (buf[i + 3] == '\n')) { + /* Two \r\n - standard compliant */ + return i + 4; + } + } + } + + return 0; +} + + +#if !defined(NO_CACHING) +/* Convert month to the month number. Return -1 on error, or month number */ +static int +get_month_index(const char *s) +{ + size_t i; + + for (i = 0; i < ARRAY_SIZE(month_names); i++) { + if (!strcmp(s, month_names[i])) { + return (int)i; + } + } + + return -1; +} + + +/* Parse UTC date-time string, and return the corresponding time_t value. */ +static time_t +parse_date_string(const char *datetime) +{ + char month_str[32] = {0}; + int second, minute, hour, day, month, year; + time_t result = (time_t)0; + struct tm tm; + + if ((sscanf(datetime, + "%d/%3s/%d %d:%d:%d", + &day, + month_str, + &year, + &hour, + &minute, + &second) + == 6) + || (sscanf(datetime, + "%d %3s %d %d:%d:%d", + &day, + month_str, + &year, + &hour, + &minute, + &second) + == 6) + || (sscanf(datetime, + "%*3s, %d %3s %d %d:%d:%d", + &day, + month_str, + &year, + &hour, + &minute, + &second) + == 6) + || (sscanf(datetime, + "%d-%3s-%d %d:%d:%d", + &day, + month_str, + &year, + &hour, + &minute, + &second) + == 6)) { + month = get_month_index(month_str); + if ((month >= 0) && (year >= 1970)) { + memset(&tm, 0, sizeof(tm)); + tm.tm_year = year - 1900; + tm.tm_mon = month; + tm.tm_mday = day; + tm.tm_hour = hour; + tm.tm_min = minute; + tm.tm_sec = second; + result = timegm(&tm); + } + } + + return result; +} +#endif /* !NO_CACHING */ + + +/* Protect against directory disclosure attack by removing '..', + * excessive '/' and '\' characters */ +static void +remove_double_dots_and_double_slashes(char *s) +{ + char *p = s; + + while ((s[0] == '.') && (s[1] == '.')) { + s++; + } + + while (*s != '\0') { + *p++ = *s++; + if ((s[-1] == '/') || (s[-1] == '\\')) { + /* Skip all following slashes, backslashes and double-dots */ + while (s[0] != '\0') { + if ((s[0] == '/') || (s[0] == '\\')) { + s++; + } else if ((s[0] == '.') && (s[1] == '.')) { + s += 2; + } else { + break; + } + } + } + } + *p = '\0'; +} + + +static const struct { + const char *extension; + size_t ext_len; + const char *mime_type; +} builtin_mime_types[] = { + /* IANA registered MIME types + * (http://www.iana.org/assignments/media-types) + * application types */ + {".doc", 4, "application/msword"}, + {".eps", 4, "application/postscript"}, + {".exe", 4, "application/octet-stream"}, + {".js", 3, "application/javascript"}, + {".json", 5, "application/json"}, + {".pdf", 4, "application/pdf"}, + {".ps", 3, "application/postscript"}, + {".rtf", 4, "application/rtf"}, + {".xhtml", 6, "application/xhtml+xml"}, + {".xsl", 4, "application/xml"}, + {".xslt", 5, "application/xml"}, + + /* fonts */ + {".ttf", 4, "application/font-sfnt"}, + {".cff", 4, "application/font-sfnt"}, + {".otf", 4, "application/font-sfnt"}, + {".aat", 4, "application/font-sfnt"}, + {".sil", 4, "application/font-sfnt"}, + {".pfr", 4, "application/font-tdpfr"}, + {".woff", 5, "application/font-woff"}, + + /* audio */ + {".mp3", 4, "audio/mpeg"}, + {".oga", 4, "audio/ogg"}, + {".ogg", 4, "audio/ogg"}, + + /* image */ + {".gif", 4, "image/gif"}, + {".ief", 4, "image/ief"}, + {".jpeg", 5, "image/jpeg"}, + {".jpg", 4, "image/jpeg"}, + {".jpm", 4, "image/jpm"}, + {".jpx", 4, "image/jpx"}, + {".png", 4, "image/png"}, + {".svg", 4, "image/svg+xml"}, + {".tif", 4, "image/tiff"}, + {".tiff", 5, "image/tiff"}, + + /* model */ + {".wrl", 4, "model/vrml"}, + + /* text */ + {".css", 4, "text/css"}, + {".csv", 4, "text/csv"}, + {".htm", 4, "text/html"}, + {".html", 5, "text/html"}, + {".sgm", 4, "text/sgml"}, + {".shtm", 5, "text/html"}, + {".shtml", 6, "text/html"}, + {".txt", 4, "text/plain"}, + {".xml", 4, "text/xml"}, + + /* video */ + {".mov", 4, "video/quicktime"}, + {".mp4", 4, "video/mp4"}, + {".mpeg", 5, "video/mpeg"}, + {".mpg", 4, "video/mpeg"}, + {".ogv", 4, "video/ogg"}, + {".qt", 3, "video/quicktime"}, + + /* not registered types + * (http://reference.sitepoint.com/html/mime-types-full, + * http://www.hansenb.pdx.edu/DMKB/dict/tutorials/mime_typ.php, ..) */ + {".arj", 4, "application/x-arj-compressed"}, + {".gz", 3, "application/x-gunzip"}, + {".rar", 4, "application/x-arj-compressed"}, + {".swf", 4, "application/x-shockwave-flash"}, + {".tar", 4, "application/x-tar"}, + {".tgz", 4, "application/x-tar-gz"}, + {".torrent", 8, "application/x-bittorrent"}, + {".ppt", 4, "application/x-mspowerpoint"}, + {".xls", 4, "application/x-msexcel"}, + {".zip", 4, "application/x-zip-compressed"}, + {".aac", + 4, + "audio/aac"}, /* http://en.wikipedia.org/wiki/Advanced_Audio_Coding */ + {".aif", 4, "audio/x-aif"}, + {".m3u", 4, "audio/x-mpegurl"}, + {".mid", 4, "audio/x-midi"}, + {".ra", 3, "audio/x-pn-realaudio"}, + {".ram", 4, "audio/x-pn-realaudio"}, + {".wav", 4, "audio/x-wav"}, + {".bmp", 4, "image/bmp"}, + {".ico", 4, "image/x-icon"}, + {".pct", 4, "image/x-pct"}, + {".pict", 5, "image/pict"}, + {".rgb", 4, "image/x-rgb"}, + {".webm", 5, "video/webm"}, /* http://en.wikipedia.org/wiki/WebM */ + {".asf", 4, "video/x-ms-asf"}, + {".avi", 4, "video/x-msvideo"}, + {".m4v", 4, "video/x-m4v"}, + {NULL, 0, NULL}}; + + +const char * +mg_get_builtin_mime_type(const char *path) +{ + const char *ext; + size_t i, path_len; + + path_len = strlen(path); + + for (i = 0; builtin_mime_types[i].extension != NULL; i++) { + ext = path + (path_len - builtin_mime_types[i].ext_len); + if ((path_len > builtin_mime_types[i].ext_len) + && (mg_strcasecmp(ext, builtin_mime_types[i].extension) == 0)) { + return builtin_mime_types[i].mime_type; + } + } + + return "text/plain"; +} + + +/* Look at the "path" extension and figure what mime type it has. + * Store mime type in the vector. */ +static void +get_mime_type(struct mg_connection *conn, const char *path, struct vec *vec) +{ + struct vec ext_vec, mime_vec; + const char *list, *ext; + size_t path_len; + + path_len = strlen(path); + + if ((conn == NULL) || (vec == NULL)) { + if (vec != NULL) { + memset(vec, '\0', sizeof(struct vec)); + } + return; + } + + /* Scan user-defined mime types first, in case user wants to + * override default mime types. */ + list = conn->dom_ctx->config[EXTRA_MIME_TYPES]; + while ((list = next_option(list, &ext_vec, &mime_vec)) != NULL) { + /* ext now points to the path suffix */ + ext = path + path_len - ext_vec.len; + if (mg_strncasecmp(ext, ext_vec.ptr, ext_vec.len) == 0) { + *vec = mime_vec; + return; + } + } + + vec->ptr = mg_get_builtin_mime_type(path); + vec->len = strlen(vec->ptr); +} + + +/* Stringify binary data. Output buffer must be twice as big as input, + * because each byte takes 2 bytes in string representation */ +static void +bin2str(char *to, const unsigned char *p, size_t len) +{ + static const char *hex = "0123456789abcdef"; + + for (; len--; p++) { + *to++ = hex[p[0] >> 4]; + *to++ = hex[p[0] & 0x0f]; + } + *to = '\0'; +} + + +/* Return stringified MD5 hash for list of strings. Buffer must be 33 bytes. + */ +char * +mg_md5(char buf[33], ...) +{ + md5_byte_t hash[16]; + const char *p; + va_list ap; + md5_state_t ctx; + + md5_init(&ctx); + + va_start(ap, buf); + while ((p = va_arg(ap, const char *)) != NULL) { + md5_append(&ctx, (const md5_byte_t *)p, strlen(p)); + } + va_end(ap); + + md5_finish(&ctx, hash); + bin2str(buf, hash, sizeof(hash)); + return buf; +} + + +/* Check the user's password, return 1 if OK */ +static int +check_password(const char *method, + const char *ha1, + const char *uri, + const char *nonce, + const char *nc, + const char *cnonce, + const char *qop, + const char *response) +{ + char ha2[32 + 1], expected_response[32 + 1]; + + /* Some of the parameters may be NULL */ + if ((method == NULL) || (nonce == NULL) || (nc == NULL) || (cnonce == NULL) + || (qop == NULL) || (response == NULL)) { + return 0; + } + + /* NOTE(lsm): due to a bug in MSIE, we do not compare the URI */ + if (strlen(response) != 32) { + return 0; + } + + mg_md5(ha2, method, ":", uri, NULL); + mg_md5(expected_response, + ha1, + ":", + nonce, + ":", + nc, + ":", + cnonce, + ":", + qop, + ":", + ha2, + NULL); + + return mg_strcasecmp(response, expected_response) == 0; +} + + +/* Use the global passwords file, if specified by auth_gpass option, + * or search for .htpasswd in the requested directory. */ +static void +open_auth_file(struct mg_connection *conn, + const char *path, + struct mg_file *filep) +{ + if ((conn != NULL) && (conn->dom_ctx != NULL)) { + char name[PATH_MAX]; + const char *p, *e, + *gpass = conn->dom_ctx->config[GLOBAL_PASSWORDS_FILE]; + int truncated; + + if (gpass != NULL) { + /* Use global passwords file */ + if (!mg_fopen(conn, gpass, MG_FOPEN_MODE_READ, filep)) { +#if defined(DEBUG) + /* Use mg_cry_internal here, since gpass has been configured. */ + mg_cry_internal(conn, "fopen(%s): %s", gpass, strerror(ERRNO)); +#endif + } + /* Important: using local struct mg_file to test path for + * is_directory flag. If filep is used, mg_stat() makes it + * appear as if auth file was opened. + * TODO(mid): Check if this is still required after rewriting + * mg_stat */ + } else if (mg_stat(conn, path, &filep->stat) + && filep->stat.is_directory) { + mg_snprintf(conn, + &truncated, + name, + sizeof(name), + "%s/%s", + path, + PASSWORDS_FILE_NAME); + + if (truncated || !mg_fopen(conn, name, MG_FOPEN_MODE_READ, filep)) { +#if defined(DEBUG) + /* Don't use mg_cry_internal here, but only a trace, since this + * is + * a typical case. It will occur for every directory + * without a password file. */ + DEBUG_TRACE("fopen(%s): %s", name, strerror(ERRNO)); +#endif + } + } else { + /* Try to find .htpasswd in requested directory. */ + for (p = path, e = p + strlen(p) - 1; e > p; e--) { + if (e[0] == '/') { + break; + } + } + mg_snprintf(conn, + &truncated, + name, + sizeof(name), + "%.*s/%s", + (int)(e - p), + p, + PASSWORDS_FILE_NAME); + + if (truncated || !mg_fopen(conn, name, MG_FOPEN_MODE_READ, filep)) { +#if defined(DEBUG) + /* Don't use mg_cry_internal here, but only a trace, since this + * is + * a typical case. It will occur for every directory + * without a password file. */ + DEBUG_TRACE("fopen(%s): %s", name, strerror(ERRNO)); +#endif + } + } + } +} + + +/* Parsed Authorization header */ +struct ah { + char *user, *uri, *cnonce, *response, *qop, *nc, *nonce; +}; + + +/* Return 1 on success. Always initializes the ah structure. */ +static int +parse_auth_header(struct mg_connection *conn, + char *buf, + size_t buf_size, + struct ah *ah) +{ + char *name, *value, *s; + const char *auth_header; + uint64_t nonce; + + if (!ah || !conn) { + return 0; + } + + (void)memset(ah, 0, sizeof(*ah)); + if (((auth_header = mg_get_header(conn, "Authorization")) == NULL) + || mg_strncasecmp(auth_header, "Digest ", 7) != 0) { + return 0; + } + + /* Make modifiable copy of the auth header */ + (void)mg_strlcpy(buf, auth_header + 7, buf_size); + s = buf; + + /* Parse authorization header */ + for (;;) { + /* Gobble initial spaces */ + while (isspace((unsigned char)*s)) { + s++; + } + name = skip_quoted(&s, "=", " ", 0); + /* Value is either quote-delimited, or ends at first comma or space. + */ + if (s[0] == '\"') { + s++; + value = skip_quoted(&s, "\"", " ", '\\'); + if (s[0] == ',') { + s++; + } + } else { + value = skip_quoted(&s, ", ", " ", 0); /* IE uses commas, FF uses + * spaces */ + } + if (*name == '\0') { + break; + } + + if (!strcmp(name, "username")) { + ah->user = value; + } else if (!strcmp(name, "cnonce")) { + ah->cnonce = value; + } else if (!strcmp(name, "response")) { + ah->response = value; + } else if (!strcmp(name, "uri")) { + ah->uri = value; + } else if (!strcmp(name, "qop")) { + ah->qop = value; + } else if (!strcmp(name, "nc")) { + ah->nc = value; + } else if (!strcmp(name, "nonce")) { + ah->nonce = value; + } + } + +#if !defined(NO_NONCE_CHECK) + /* Read the nonce from the response. */ + if (ah->nonce == NULL) { + return 0; + } + s = NULL; + nonce = strtoull(ah->nonce, &s, 10); + if ((s == NULL) || (*s != 0)) { + return 0; + } + + /* Convert the nonce from the client to a number. */ + nonce ^= conn->dom_ctx->auth_nonce_mask; + + /* The converted number corresponds to the time the nounce has been + * created. This should not be earlier than the server start. */ + /* Server side nonce check is valuable in all situations but one: + * if the server restarts frequently, but the client should not see + * that, so the server should accept nonces from previous starts. */ + /* However, the reasonable default is to not accept a nonce from a + * previous start, so if anyone changed the access rights between + * two restarts, a new login is required. */ + if (nonce < (uint64_t)conn->phys_ctx->start_time) { + /* nonce is from a previous start of the server and no longer valid + * (replay attack?) */ + return 0; + } + /* Check if the nonce is too high, so it has not (yet) been used by the + * server. */ + if (nonce >= ((uint64_t)conn->phys_ctx->start_time + + conn->dom_ctx->nonce_count)) { + return 0; + } +#else + (void)nonce; +#endif + + /* CGI needs it as REMOTE_USER */ + if (ah->user != NULL) { + conn->request_info.remote_user = + mg_strdup_ctx(ah->user, conn->phys_ctx); + } else { + return 0; + } + + return 1; +} + + +static const char * +mg_fgets(char *buf, size_t size, struct mg_file *filep, char **p) +{ +#if defined(MG_USE_OPEN_FILE) + const char *eof; + size_t len; + const char *memend; +#else + (void)p; /* parameter is unused */ +#endif + + if (!filep) { + return NULL; + } + +#if defined(MG_USE_OPEN_FILE) + if ((filep->access.membuf != NULL) && (*p != NULL)) { + memend = (const char *)&filep->access.membuf[filep->stat.size]; + /* Search for \n from p till the end of stream */ + eof = (char *)memchr(*p, '\n', (size_t)(memend - *p)); + if (eof != NULL) { + eof += 1; /* Include \n */ + } else { + eof = memend; /* Copy remaining data */ + } + len = + ((size_t)(eof - *p) > (size - 1)) ? (size - 1) : (size_t)(eof - *p); + memcpy(buf, *p, len); + buf[len] = '\0'; + *p += len; + return len ? eof : NULL; + } else /* filep->access.fp block below */ +#endif + if (filep->access.fp != NULL) { + return fgets(buf, (int)size, filep->access.fp); + } else { + return NULL; + } +} + +/* Define the initial recursion depth for procesesing htpasswd files that + * include other htpasswd + * (or even the same) files. It is not difficult to provide a file or files + * s.t. they force civetweb + * to infinitely recurse and then crash. + */ +#define INITIAL_DEPTH 9 +#if INITIAL_DEPTH <= 0 +#error Bad INITIAL_DEPTH for recursion, set to at least 1 +#endif + +struct read_auth_file_struct { + struct mg_connection *conn; + struct ah ah; + const char *domain; + char buf[256 + 256 + 40]; + const char *f_user; + const char *f_domain; + const char *f_ha1; +}; + + +static int +read_auth_file(struct mg_file *filep, + struct read_auth_file_struct *workdata, + int depth) +{ + char *p = NULL /* init if MG_USE_OPEN_FILE is not set */; + int is_authorized = 0; + struct mg_file fp; + size_t l; + + if (!filep || !workdata || (0 == depth)) { + return 0; + } + +/* Loop over passwords file */ +#if defined(MG_USE_OPEN_FILE) + p = (char *)filep->access.membuf; +#endif + while (mg_fgets(workdata->buf, sizeof(workdata->buf), filep, &p) != NULL) { + l = strlen(workdata->buf); + while (l > 0) { + if (isspace((unsigned char)workdata->buf[l - 1]) + || iscntrl((unsigned char)workdata->buf[l - 1])) { + l--; + workdata->buf[l] = 0; + } else + break; + } + if (l < 1) { + continue; + } + + workdata->f_user = workdata->buf; + + if (workdata->f_user[0] == ':') { + /* user names may not contain a ':' and may not be empty, + * so lines starting with ':' may be used for a special purpose + */ + if (workdata->f_user[1] == '#') { + /* :# is a comment */ + continue; + } else if (!strncmp(workdata->f_user + 1, "include=", 8)) { + if (mg_fopen(workdata->conn, + workdata->f_user + 9, + MG_FOPEN_MODE_READ, + &fp)) { + is_authorized = read_auth_file(&fp, workdata, depth - 1); + (void)mg_fclose( + &fp.access); /* ignore error on read only file */ + + /* No need to continue processing files once we have a + * match, since nothing will reset it back + * to 0. + */ + if (is_authorized) { + return is_authorized; + } + } else { + mg_cry_internal(workdata->conn, + "%s: cannot open authorization file: %s", + __func__, + workdata->buf); + } + continue; + } + /* everything is invalid for the moment (might change in the + * future) */ + mg_cry_internal(workdata->conn, + "%s: syntax error in authorization file: %s", + __func__, + workdata->buf); + continue; + } + + workdata->f_domain = strchr(workdata->f_user, ':'); + if (workdata->f_domain == NULL) { + mg_cry_internal(workdata->conn, + "%s: syntax error in authorization file: %s", + __func__, + workdata->buf); + continue; + } + *(char *)(workdata->f_domain) = 0; + (workdata->f_domain)++; + + workdata->f_ha1 = strchr(workdata->f_domain, ':'); + if (workdata->f_ha1 == NULL) { + mg_cry_internal(workdata->conn, + "%s: syntax error in authorization file: %s", + __func__, + workdata->buf); + continue; + } + *(char *)(workdata->f_ha1) = 0; + (workdata->f_ha1)++; + + if (!strcmp(workdata->ah.user, workdata->f_user) + && !strcmp(workdata->domain, workdata->f_domain)) { + return check_password(workdata->conn->request_info.request_method, + workdata->f_ha1, + workdata->ah.uri, + workdata->ah.nonce, + workdata->ah.nc, + workdata->ah.cnonce, + workdata->ah.qop, + workdata->ah.response); + } + } + + return is_authorized; +} + + +/* Authorize against the opened passwords file. Return 1 if authorized. */ +static int +authorize(struct mg_connection *conn, struct mg_file *filep, const char *realm) +{ + struct read_auth_file_struct workdata; + char buf[MG_BUF_LEN]; + + if (!conn || !conn->dom_ctx) { + return 0; + } + + memset(&workdata, 0, sizeof(workdata)); + workdata.conn = conn; + + if (!parse_auth_header(conn, buf, sizeof(buf), &workdata.ah)) { + return 0; + } + + if (realm) { + workdata.domain = realm; + } else { + workdata.domain = conn->dom_ctx->config[AUTHENTICATION_DOMAIN]; + } + + return read_auth_file(filep, &workdata, INITIAL_DEPTH); +} + + +/* Public function to check http digest authentication header */ +int +mg_check_digest_access_authentication(struct mg_connection *conn, + const char *realm, + const char *filename) +{ + struct mg_file file = STRUCT_FILE_INITIALIZER; + int auth; + + if (!conn || !filename) { + return -1; + } + if (!mg_fopen(conn, filename, MG_FOPEN_MODE_READ, &file)) { + return -2; + } + + auth = authorize(conn, &file, realm); + + mg_fclose(&file.access); + + return auth; +} + + +/* Return 1 if request is authorised, 0 otherwise. */ +static int +check_authorization(struct mg_connection *conn, const char *path) +{ + char fname[PATH_MAX]; + struct vec uri_vec, filename_vec; + const char *list; + struct mg_file file = STRUCT_FILE_INITIALIZER; + int authorized = 1, truncated; + + if (!conn || !conn->dom_ctx) { + return 0; + } + + list = conn->dom_ctx->config[PROTECT_URI]; + while ((list = next_option(list, &uri_vec, &filename_vec)) != NULL) { + if (!memcmp(conn->request_info.local_uri, uri_vec.ptr, uri_vec.len)) { + mg_snprintf(conn, + &truncated, + fname, + sizeof(fname), + "%.*s", + (int)filename_vec.len, + filename_vec.ptr); + + if (truncated + || !mg_fopen(conn, fname, MG_FOPEN_MODE_READ, &file)) { + mg_cry_internal(conn, + "%s: cannot open %s: %s", + __func__, + fname, + strerror(errno)); + } + break; + } + } + + if (!is_file_opened(&file.access)) { + open_auth_file(conn, path, &file); + } + + if (is_file_opened(&file.access)) { + authorized = authorize(conn, &file, NULL); + (void)mg_fclose(&file.access); /* ignore error on read only file */ + } + + return authorized; +} + + +/* Internal function. Assumes conn is valid */ +static void +send_authorization_request(struct mg_connection *conn, const char *realm) +{ + char date[64]; + time_t curtime = time(NULL); + uint64_t nonce = (uint64_t)(conn->phys_ctx->start_time); + + if (!realm) { + realm = conn->dom_ctx->config[AUTHENTICATION_DOMAIN]; + } + + (void)pthread_mutex_lock(&conn->phys_ctx->nonce_mutex); + nonce += conn->dom_ctx->nonce_count; + ++conn->dom_ctx->nonce_count; + (void)pthread_mutex_unlock(&conn->phys_ctx->nonce_mutex); + + nonce ^= conn->dom_ctx->auth_nonce_mask; + conn->status_code = 401; + conn->must_close = 1; + + gmt_time_string(date, sizeof(date), &curtime); + + mg_printf(conn, "HTTP/1.1 401 Unauthorized\r\n"); + send_no_cache_header(conn); + send_additional_header(conn); + mg_printf(conn, + "Date: %s\r\n" + "Connection: %s\r\n" + "Content-Length: 0\r\n" + "WWW-Authenticate: Digest qop=\"auth\", realm=\"%s\", " + "nonce=\"%" UINT64_FMT "\"\r\n\r\n", + date, + suggest_connection_header(conn), + realm, + nonce); +} + + +/* Interface function. Parameters are provided by the user, so do + * at least some basic checks. + */ +int +mg_send_digest_access_authentication_request(struct mg_connection *conn, + const char *realm) +{ + if (conn && conn->dom_ctx) { + send_authorization_request(conn, realm); + return 0; + } + return -1; +} + + +#if !defined(NO_FILES) +static int +is_authorized_for_put(struct mg_connection *conn) +{ + if (conn) { + struct mg_file file = STRUCT_FILE_INITIALIZER; + const char *passfile = conn->dom_ctx->config[PUT_DELETE_PASSWORDS_FILE]; + int ret = 0; + + if (passfile != NULL + && mg_fopen(conn, passfile, MG_FOPEN_MODE_READ, &file)) { + ret = authorize(conn, &file, NULL); + (void)mg_fclose(&file.access); /* ignore error on read only file */ + } + + return ret; + } + return 0; +} +#endif + + +int +mg_modify_passwords_file(const char *fname, + const char *domain, + const char *user, + const char *pass) +{ + int found, i; + char line[512], u[512] = "", d[512] = "", ha1[33], tmp[PATH_MAX + 8]; + FILE *fp, *fp2; + + found = 0; + fp = fp2 = NULL; + + /* Regard empty password as no password - remove user record. */ + if ((pass != NULL) && (pass[0] == '\0')) { + pass = NULL; + } + + /* Other arguments must not be empty */ + if ((fname == NULL) || (domain == NULL) || (user == NULL)) { + return 0; + } + + /* Using the given file format, user name and domain must not contain + * ':' + */ + if (strchr(user, ':') != NULL) { + return 0; + } + if (strchr(domain, ':') != NULL) { + return 0; + } + + /* Do not allow control characters like newline in user name and domain. + * Do not allow excessively long names either. */ + for (i = 0; ((i < 255) && (user[i] != 0)); i++) { + if (iscntrl((unsigned char)user[i])) { + return 0; + } + } + if (user[i]) { + return 0; + } + for (i = 0; ((i < 255) && (domain[i] != 0)); i++) { + if (iscntrl((unsigned char)domain[i])) { + return 0; + } + } + if (domain[i]) { + return 0; + } + + /* The maximum length of the path to the password file is limited */ + if ((strlen(fname) + 4) >= PATH_MAX) { + return 0; + } + + /* Create a temporary file name. Length has been checked before. */ + strcpy(tmp, fname); + strcat(tmp, ".tmp"); + + /* Create the file if does not exist */ + /* Use of fopen here is OK, since fname is only ASCII */ + if ((fp = fopen(fname, "a+")) != NULL) { + (void)fclose(fp); + } + + /* Open the given file and temporary file */ + if ((fp = fopen(fname, "r")) == NULL) { + return 0; + } else if ((fp2 = fopen(tmp, "w+")) == NULL) { + fclose(fp); + return 0; + } + + /* Copy the stuff to temporary file */ + while (fgets(line, sizeof(line), fp) != NULL) { + if (sscanf(line, "%255[^:]:%255[^:]:%*s", u, d) != 2) { + continue; + } + u[255] = 0; + d[255] = 0; + + if (!strcmp(u, user) && !strcmp(d, domain)) { + found++; + if (pass != NULL) { + mg_md5(ha1, user, ":", domain, ":", pass, NULL); + fprintf(fp2, "%s:%s:%s\n", user, domain, ha1); + } + } else { + fprintf(fp2, "%s", line); + } + } + + /* If new user, just add it */ + if (!found && (pass != NULL)) { + mg_md5(ha1, user, ":", domain, ":", pass, NULL); + fprintf(fp2, "%s:%s:%s\n", user, domain, ha1); + } + + /* Close files */ + fclose(fp); + fclose(fp2); + + /* Put the temp file in place of real file */ + IGNORE_UNUSED_RESULT(remove(fname)); + IGNORE_UNUSED_RESULT(rename(tmp, fname)); + + return 1; +} + + +static int +is_valid_port(unsigned long port) +{ + return (port <= 0xffff); +} + + +static int +mg_inet_pton(int af, const char *src, void *dst, size_t dstlen) +{ + struct addrinfo hints, *res, *ressave; + int func_ret = 0; + int gai_ret; + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = af; + + gai_ret = getaddrinfo(src, NULL, &hints, &res); + if (gai_ret != 0) { + /* gai_strerror could be used to convert gai_ret to a string */ + /* POSIX return values: see + * http://pubs.opengroup.org/onlinepubs/9699919799/functions/freeaddrinfo.html + */ + /* Windows return values: see + * https://msdn.microsoft.com/en-us/library/windows/desktop/ms738520%28v=vs.85%29.aspx + */ + return 0; + } + + ressave = res; + + while (res) { + if (dstlen >= (size_t)res->ai_addrlen) { + memcpy(dst, res->ai_addr, res->ai_addrlen); + func_ret = 1; + } + res = res->ai_next; + } + + freeaddrinfo(ressave); + return func_ret; +} + + +static int +connect_socket(struct mg_context *ctx /* may be NULL */, + const char *host, + int port, + int use_ssl, + char *ebuf, + size_t ebuf_len, + SOCKET *sock /* output: socket, must not be NULL */, + union usa *sa /* output: socket address, must not be NULL */ +) +{ + int ip_ver = 0; + int conn_ret = -1; + int sockerr = 0; + *sock = INVALID_SOCKET; + memset(sa, 0, sizeof(*sa)); + + if (ebuf_len > 0) { + *ebuf = 0; + } + + if (host == NULL) { + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "%s", + "NULL host"); + return 0; + } + + if ((port <= 0) || !is_valid_port((unsigned)port)) { + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "%s", + "invalid port"); + return 0; + } + +#if !defined(NO_SSL) +#if !defined(NO_SSL_DL) +#if defined(OPENSSL_API_1_1) + if (use_ssl && (TLS_client_method == NULL)) { + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "%s", + "SSL is not initialized"); + return 0; + } +#else + if (use_ssl && (SSLv23_client_method == NULL)) { + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "%s", + "SSL is not initialized"); + return 0; + } + +#endif /* OPENSSL_API_1_1 */ +#else + (void)use_ssl; +#endif /* NO_SSL_DL */ +#else + (void)use_ssl; +#endif /* !defined(NO_SSL) */ + + if (mg_inet_pton(AF_INET, host, &sa->sin, sizeof(sa->sin))) { + sa->sin.sin_family = AF_INET; + sa->sin.sin_port = htons((uint16_t)port); + ip_ver = 4; +#if defined(USE_IPV6) + } else if (mg_inet_pton(AF_INET6, host, &sa->sin6, sizeof(sa->sin6))) { + sa->sin6.sin6_family = AF_INET6; + sa->sin6.sin6_port = htons((uint16_t)port); + ip_ver = 6; + } else if (host[0] == '[') { + /* While getaddrinfo on Windows will work with [::1], + * getaddrinfo on Linux only works with ::1 (without []). */ + size_t l = strlen(host + 1); + char *h = (l > 1) ? mg_strdup_ctx(host + 1, ctx) : NULL; + if (h) { + h[l - 1] = 0; + if (mg_inet_pton(AF_INET6, h, &sa->sin6, sizeof(sa->sin6))) { + sa->sin6.sin6_family = AF_INET6; + sa->sin6.sin6_port = htons((uint16_t)port); + ip_ver = 6; + } + mg_free(h); + } +#endif + } + + if (ip_ver == 0) { + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "%s", + "host not found"); + return 0; + } + + if (ip_ver == 4) { + *sock = socket(PF_INET, SOCK_STREAM, 0); + } +#if defined(USE_IPV6) + else if (ip_ver == 6) { + *sock = socket(PF_INET6, SOCK_STREAM, 0); + } +#endif + + if (*sock == INVALID_SOCKET) { + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "socket(): %s", + strerror(ERRNO)); + return 0; + } + + if (0 != set_non_blocking_mode(*sock)) { + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "Cannot set socket to non-blocking: %s", + strerror(ERRNO)); + closesocket(*sock); + *sock = INVALID_SOCKET; + return 0; + } + + set_close_on_exec(*sock, NULL, ctx); + + if (ip_ver == 4) { + /* connected with IPv4 */ + conn_ret = connect(*sock, + (struct sockaddr *)((void *)&sa->sin), + sizeof(sa->sin)); + } +#if defined(USE_IPV6) + else if (ip_ver == 6) { + /* connected with IPv6 */ + conn_ret = connect(*sock, + (struct sockaddr *)((void *)&sa->sin6), + sizeof(sa->sin6)); + } +#endif + + if (conn_ret != 0) { + sockerr = ERRNO; + } + +#if defined(_WIN32) + if ((conn_ret != 0) && (sockerr == WSAEWOULDBLOCK)) { +#else + if ((conn_ret != 0) && (sockerr == EINPROGRESS)) { +#endif + /* Data for getsockopt */ + void *psockerr = &sockerr; + int ret; + +#if defined(_WIN32) + int len = (int)sizeof(sockerr); +#else + socklen_t len = (socklen_t)sizeof(sockerr); +#endif + + /* Data for poll */ + struct mg_pollfd pfd[1]; + int pollres; + int ms_wait = 10000; /* 10 second timeout */ + int nonstop = 0; + + /* For a non-blocking socket, the connect sequence is: + * 1) call connect (will not block) + * 2) wait until the socket is ready for writing (select or poll) + * 3) check connection state with getsockopt + */ + pfd[0].fd = *sock; + pfd[0].events = POLLOUT; + pollres = mg_poll(pfd, 1, ms_wait, ctx ? &(ctx->stop_flag) : &nonstop); + + if (pollres != 1) { + /* Not connected */ + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "connect(%s:%d): timeout", + host, + port); + closesocket(*sock); + *sock = INVALID_SOCKET; + return 0; + } + +#if defined(_WIN32) + ret = getsockopt(*sock, SOL_SOCKET, SO_ERROR, (char *)psockerr, &len); +#else + ret = getsockopt(*sock, SOL_SOCKET, SO_ERROR, psockerr, &len); +#endif + + if ((ret == 0) && (sockerr == 0)) { + conn_ret = 0; + } + } + + if (conn_ret != 0) { + /* Not connected */ + mg_snprintf(NULL, + NULL, /* No truncation check for ebuf */ + ebuf, + ebuf_len, + "connect(%s:%d): error %s", + host, + port, + strerror(sockerr)); + closesocket(*sock); + *sock = INVALID_SOCKET; + return 0; + } + + return 1; +} + + +int +mg_url_encode(const char *src, char *dst, size_t dst_len) +{ + static const char *dont_escape = "._-$,;~()"; + static const char *hex = "0123456789abcdef"; + char *pos = dst; + const char *end = dst + dst_len - 1; + + for (; ((*src != '\0') && (pos < end)); src++, pos++) { + if (isalnum((unsigned char)*src) + || (strchr(dont_escape, *src) != NULL)) { + *pos = *src; + } else if (pos + 2 < end) { + pos[0] = '%'; + pos[1] = hex[(unsigned char)*src >> 4]; + pos[2] = hex[(unsigned char)*src & 0xf]; + pos += 2; + } else { + break; + } + } + + *pos = '\0'; + return (*src == '\0') ? (int)(pos - dst) : -1; +} + +/* Return 0 on success, non-zero if an error occurs. */ + +static int +print_dir_entry(struct de *de) +{ + size_t namesize, escsize, i; + char *href, *esc, *p; + char size[64], mod[64]; +#if defined(REENTRANT_TIME) + struct tm _tm; + struct tm *tm = &_tm; +#else + struct tm *tm; +#endif + + /* Estimate worst case size for encoding and escaping */ + namesize = strlen(de->file_name) + 1; + escsize = de->file_name[strcspn(de->file_name, "&<>")] ? namesize * 5 : 0; + href = (char *)mg_malloc(namesize * 3 + escsize); + if (href == NULL) { + return -1; + } + mg_url_encode(de->file_name, href, namesize * 3); + esc = NULL; + if (escsize > 0) { + /* HTML escaping needed */ + esc = href + namesize * 3; + for (i = 0, p = esc; de->file_name[i]; i++, p += strlen(p)) { + mg_strlcpy(p, de->file_name + i, 2); + if (*p == '&') { + strcpy(p, "&"); + } else if (*p == '<') { + strcpy(p, "<"); + } else if (*p == '>') { + strcpy(p, ">"); + } + } + } + + if (de->file.is_directory) { + mg_snprintf(de->conn, + NULL, /* Buffer is big enough */ + size, + sizeof(size), + "%s", + "[DIRECTORY]"); + } else { + /* We use (signed) cast below because MSVC 6 compiler cannot + * convert unsigned __int64 to double. Sigh. */ + if (de->file.size < 1024) { + mg_snprintf(de->conn, + NULL, /* Buffer is big enough */ + size, + sizeof(size), + "%d", + (int)de->file.size); + } else if (de->file.size < 0x100000) { + mg_snprintf(de->conn, + NULL, /* Buffer is big enough */ + size, + sizeof(size), + "%.1fk", + (double)de->file.size / 1024.0); + } else if (de->file.size < 0x40000000) { + mg_snprintf(de->conn, + NULL, /* Buffer is big enough */ + size, + sizeof(size), + "%.1fM", + (double)de->file.size / 1048576); + } else { + mg_snprintf(de->conn, + NULL, /* Buffer is big enough */ + size, + sizeof(size), + "%.1fG", + (double)de->file.size / 1073741824); + } + } + + /* Note: mg_snprintf will not cause a buffer overflow above. + * So, string truncation checks are not required here. */ + +#if defined(REENTRANT_TIME) + localtime_r(&de->file.last_modified, tm); +#else + tm = localtime(&de->file.last_modified); +#endif + if (tm != NULL) { + strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", tm); + } else { + mg_strlcpy(mod, "01-Jan-1970 00:00", sizeof(mod)); + mod[sizeof(mod) - 1] = '\0'; + } + mg_printf(de->conn, + "%s%s" + " %s  %s\n", + href, + de->file.is_directory ? "/" : "", + esc ? esc : de->file_name, + de->file.is_directory ? "/" : "", + mod, + size); + mg_free(href); + return 0; +} + + +/* This function is called from send_directory() and used for + * sorting directory entries by size, or name, or modification time. + * On windows, __cdecl specification is needed in case if project is built + * with __stdcall convention. qsort always requires __cdels callback. */ +static int WINCDECL +compare_dir_entries(const void *p1, const void *p2) +{ + if (p1 && p2) { + const struct de *a = (const struct de *)p1, *b = (const struct de *)p2; + const char *query_string = a->conn->request_info.query_string; + int cmp_result = 0; + + if ((query_string == NULL) || (query_string[0] == '\0')) { + query_string = "n"; + } + + if (a->file.is_directory && !b->file.is_directory) { + return -1; /* Always put directories on top */ + } else if (!a->file.is_directory && b->file.is_directory) { + return 1; /* Always put directories on top */ + } else if (*query_string == 'n') { + cmp_result = strcmp(a->file_name, b->file_name); + } else if (*query_string == 's') { + cmp_result = (a->file.size == b->file.size) + ? 0 + : ((a->file.size > b->file.size) ? 1 : -1); + } else if (*query_string == 'd') { + cmp_result = + (a->file.last_modified == b->file.last_modified) + ? 0 + : ((a->file.last_modified > b->file.last_modified) ? 1 + : -1); + } + + return (query_string[1] == 'd') ? -cmp_result : cmp_result; + } + return 0; +} + + +static int +must_hide_file(struct mg_connection *conn, const char *path) +{ + if (conn && conn->dom_ctx) { + const char *pw_pattern = "**" PASSWORDS_FILE_NAME "$"; + const char *pattern = conn->dom_ctx->config[HIDE_FILES]; + return (match_prefix(pw_pattern, strlen(pw_pattern), path) > 0) + || ((pattern != NULL) + && (match_prefix(pattern, strlen(pattern), path) > 0)); + } + return 0; +} + + +static int +scan_directory(struct mg_connection *conn, + const char *dir, + void *data, + int (*cb)(struct de *, void *)) +{ + char path[PATH_MAX]; + struct dirent *dp; + DIR *dirp; + struct de de; + int truncated; + + if ((dirp = mg_opendir(conn, dir)) == NULL) { + return 0; + } else { + de.conn = conn; + + while ((dp = mg_readdir(dirp)) != NULL) { + /* Do not show current dir and hidden files */ + if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..") + || must_hide_file(conn, dp->d_name)) { + continue; + } + + mg_snprintf( + conn, &truncated, path, sizeof(path), "%s/%s", dir, dp->d_name); + + /* If we don't memset stat structure to zero, mtime will have + * garbage and strftime() will segfault later on in + * print_dir_entry(). memset is required only if mg_stat() + * fails. For more details, see + * http://code.google.com/p/mongoose/issues/detail?id=79 */ + memset(&de.file, 0, sizeof(de.file)); + + if (truncated) { + /* If the path is not complete, skip processing. */ + continue; + } + + if (!mg_stat(conn, path, &de.file)) { + mg_cry_internal(conn, + "%s: mg_stat(%s) failed: %s", + __func__, + path, + strerror(ERRNO)); + } + de.file_name = dp->d_name; + cb(&de, data); + } + (void)mg_closedir(dirp); + } + return 1; +} + + +#if !defined(NO_FILES) +static int +remove_directory(struct mg_connection *conn, const char *dir) +{ + char path[PATH_MAX]; + struct dirent *dp; + DIR *dirp; + struct de de; + int truncated; + int ok = 1; + + if ((dirp = mg_opendir(conn, dir)) == NULL) { + return 0; + } else { + de.conn = conn; + + while ((dp = mg_readdir(dirp)) != NULL) { + /* Do not show current dir (but show hidden files as they will + * also be removed) */ + if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) { + continue; + } + + mg_snprintf( + conn, &truncated, path, sizeof(path), "%s/%s", dir, dp->d_name); + + /* If we don't memset stat structure to zero, mtime will have + * garbage and strftime() will segfault later on in + * print_dir_entry(). memset is required only if mg_stat() + * fails. For more details, see + * http://code.google.com/p/mongoose/issues/detail?id=79 */ + memset(&de.file, 0, sizeof(de.file)); + + if (truncated) { + /* Do not delete anything shorter */ + ok = 0; + continue; + } + + if (!mg_stat(conn, path, &de.file)) { + mg_cry_internal(conn, + "%s: mg_stat(%s) failed: %s", + __func__, + path, + strerror(ERRNO)); + ok = 0; + } + + if (de.file.is_directory) { + if (remove_directory(conn, path) == 0) { + ok = 0; + } + } else { + /* This will fail file is the file is in memory */ + if (mg_remove(conn, path) == 0) { + ok = 0; + } + } + } + (void)mg_closedir(dirp); + + IGNORE_UNUSED_RESULT(rmdir(dir)); + } + + return ok; +} +#endif + + +struct dir_scan_data { + struct de *entries; + unsigned int num_entries; + unsigned int arr_size; +}; + + +/* Behaves like realloc(), but frees original pointer on failure */ +static void * +realloc2(void *ptr, size_t size) +{ + void *new_ptr = mg_realloc(ptr, size); + if (new_ptr == NULL) { + mg_free(ptr); + } + return new_ptr; +} + + +static int +dir_scan_callback(struct de *de, void *data) +{ + struct dir_scan_data *dsd = (struct dir_scan_data *)data; + + if ((dsd->entries == NULL) || (dsd->num_entries >= dsd->arr_size)) { + dsd->arr_size *= 2; + dsd->entries = + (struct de *)realloc2(dsd->entries, + dsd->arr_size * sizeof(dsd->entries[0])); + } + if (dsd->entries == NULL) { + /* TODO(lsm, low): propagate an error to the caller */ + dsd->num_entries = 0; + } else { + dsd->entries[dsd->num_entries].file_name = mg_strdup(de->file_name); + dsd->entries[dsd->num_entries].file = de->file; + dsd->entries[dsd->num_entries].conn = de->conn; + dsd->num_entries++; + } + + return 0; +} + + +static void +handle_directory_request(struct mg_connection *conn, const char *dir) +{ + unsigned int i; + int sort_direction; + struct dir_scan_data data = {NULL, 0, 128}; + char date[64], *esc, *p; + const char *title; + time_t curtime = time(NULL); + + if (!scan_directory(conn, dir, &data, dir_scan_callback)) { + mg_send_http_error(conn, + 500, + "Error: Cannot open directory\nopendir(%s): %s", + dir, + strerror(ERRNO)); + return; + } + + gmt_time_string(date, sizeof(date), &curtime); + + if (!conn) { + return; + } + + esc = NULL; + title = conn->request_info.local_uri; + if (title[strcspn(title, "&<>")]) { + /* HTML escaping needed */ + esc = (char *)mg_malloc(strlen(title) * 5 + 1); + if (esc) { + for (i = 0, p = esc; title[i]; i++, p += strlen(p)) { + mg_strlcpy(p, title + i, 2); + if (*p == '&') { + strcpy(p, "&"); + } else if (*p == '<') { + strcpy(p, "<"); + } else if (*p == '>') { + strcpy(p, ">"); + } + } + } else { + title = ""; + } + } + + sort_direction = ((conn->request_info.query_string != NULL) + && (conn->request_info.query_string[0] != '\0') + && (conn->request_info.query_string[1] == 'd')) + ? 'a' + : 'd'; + + conn->must_close = 1; + mg_printf(conn, "HTTP/1.1 200 OK\r\n"); + send_static_cache_header(conn); + send_additional_header(conn); + mg_printf(conn, + "Date: %s\r\n" + "Connection: close\r\n" + "Content-Type: text/html; charset=utf-8\r\n\r\n", + date); + mg_printf(conn, + "Index of %s" + "" + "

Index of %s

"
+	          ""
+	          ""
+	          ""
+	          "",
+	          esc ? esc : title,
+	          esc ? esc : title,
+	          sort_direction,
+	          sort_direction,
+	          sort_direction);
+	mg_free(esc);
+
+	/* Print first entry - link to a parent directory */
+	mg_printf(conn,
+	          ""
+	          "\n",
+	          "..",
+	          "Parent directory",
+	          "-",
+	          "-");
+
+	/* Sort and print directory entries */
+	if (data.entries != NULL) {
+		qsort(data.entries,
+		      (size_t)data.num_entries,
+		      sizeof(data.entries[0]),
+		      compare_dir_entries);
+		for (i = 0; i < data.num_entries; i++) {
+			print_dir_entry(&data.entries[i]);
+			mg_free(data.entries[i].file_name);
+		}
+		mg_free(data.entries);
+	}
+
+	mg_printf(conn, "%s", "
NameModifiedSize
%s %s  %s
"); + conn->status_code = 200; +} + + +/* Send len bytes from the opened file to the client. */ +static void +send_file_data(struct mg_connection *conn, + struct mg_file *filep, + int64_t offset, + int64_t len) +{ + char buf[MG_BUF_LEN]; + int to_read, num_read, num_written; + int64_t size; + + if (!filep || !conn) { + return; + } + + /* Sanity check the offset */ + size = (filep->stat.size > INT64_MAX) ? INT64_MAX + : (int64_t)(filep->stat.size); + offset = (offset < 0) ? 0 : ((offset > size) ? size : offset); + +#if defined(MG_USE_OPEN_FILE) + if ((len > 0) && (filep->access.membuf != NULL) && (size > 0)) { + /* file stored in memory */ + if (len > size - offset) { + len = size - offset; + } + mg_write(conn, filep->access.membuf + offset, (size_t)len); + } else /* else block below */ +#endif + if (len > 0 && filep->access.fp != NULL) { +/* file stored on disk */ +#if defined(__linux__) + /* sendfile is only available for Linux */ + if ((conn->ssl == 0) && (conn->throttle == 0) + && (!mg_strcasecmp(conn->dom_ctx->config[ALLOW_SENDFILE_CALL], + "yes"))) { + off_t sf_offs = (off_t)offset; + ssize_t sf_sent; + int sf_file = fileno(filep->access.fp); + int loop_cnt = 0; + + do { + /* 2147479552 (0x7FFFF000) is a limit found by experiment on + * 64 bit Linux (2^31 minus one memory page of 4k?). */ + size_t sf_tosend = + (size_t)((len < 0x7FFFF000) ? len : 0x7FFFF000); + sf_sent = + sendfile(conn->client.sock, sf_file, &sf_offs, sf_tosend); + if (sf_sent > 0) { + len -= sf_sent; + offset += sf_sent; + } else if (loop_cnt == 0) { + /* This file can not be sent using sendfile. + * This might be the case for pseudo-files in the + * /sys/ and /proc/ file system. + * Use the regular user mode copy code instead. */ + break; + } else if (sf_sent == 0) { + /* No error, but 0 bytes sent. May be EOF? */ + return; + } + loop_cnt++; + + } while ((len > 0) && (sf_sent >= 0)); + + if (sf_sent > 0) { + return; /* OK */ + } + + /* sf_sent<0 means error, thus fall back to the classic way */ + /* This is always the case, if sf_file is not a "normal" file, + * e.g., for sending data from the output of a CGI process. */ + offset = (int64_t)sf_offs; + } +#endif + if ((offset > 0) && (fseeko(filep->access.fp, offset, SEEK_SET) != 0)) { + mg_cry_internal(conn, + "%s: fseeko() failed: %s", + __func__, + strerror(ERRNO)); + mg_send_http_error( + conn, + 500, + "%s", + "Error: Unable to access file at requested position."); + } else { + while (len > 0) { + /* Calculate how much to read from the file in the buffer */ + to_read = sizeof(buf); + if ((int64_t)to_read > len) { + to_read = (int)len; + } + + /* Read from file, exit the loop on error */ + if ((num_read = + (int)fread(buf, 1, (size_t)to_read, filep->access.fp)) + <= 0) { + break; + } + + /* Send read bytes to the client, exit the loop on error */ + if ((num_written = mg_write(conn, buf, (size_t)num_read)) + != num_read) { + break; + } + + /* Both read and were successful, adjust counters */ + len -= num_written; + } + } + } +} + + +static int +parse_range_header(const char *header, int64_t *a, int64_t *b) +{ + return sscanf(header, "bytes=%" INT64_FMT "-%" INT64_FMT, a, b); +} + + +static void +construct_etag(char *buf, size_t buf_len, const struct mg_file_stat *filestat) +{ + if ((filestat != NULL) && (buf != NULL)) { + mg_snprintf(NULL, + NULL, /* All calls to construct_etag use 64 byte buffer */ + buf, + buf_len, + "\"%lx.%" INT64_FMT "\"", + (unsigned long)filestat->last_modified, + filestat->size); + } +} + + +static void +fclose_on_exec(struct mg_file_access *filep, struct mg_connection *conn) +{ + if (filep != NULL && filep->fp != NULL) { +#if defined(_WIN32) + (void)conn; /* Unused. */ +#else + if (fcntl(fileno(filep->fp), F_SETFD, FD_CLOEXEC) != 0) { + mg_cry_internal(conn, + "%s: fcntl(F_SETFD FD_CLOEXEC) failed: %s", + __func__, + strerror(ERRNO)); + } +#endif + } +} + + +#if defined(USE_ZLIB) +#include "mod_zlib.inl" +#endif + + +static void +handle_static_file_request(struct mg_connection *conn, + const char *path, + struct mg_file *filep, + const char *mime_type, + const char *additional_headers) +{ + char date[64], lm[64], etag[64]; + char range[128]; /* large enough, so there will be no overflow */ + const char *msg = "OK"; + const char *range_hdr; + time_t curtime = time(NULL); + int64_t cl, r1, r2; + struct vec mime_vec; + int n, truncated; + char gz_path[PATH_MAX]; + const char *encoding = ""; + const char *origin_hdr; + const char *cors_orig_cfg; + const char *cors1, *cors2, *cors3; + int is_head_request; + +#if defined(USE_ZLIB) + /* Compression is allowed, unless there is a reason not to use compression. + * If the file is already compressed, too small or a "range" request was + * made, on the fly compression is not possible. */ + int allow_on_the_fly_compression = 1; +#endif + + if ((conn == NULL) || (conn->dom_ctx == NULL) || (filep == NULL)) { + return; + } + + is_head_request = !strcmp(conn->request_info.request_method, "HEAD"); + + if (mime_type == NULL) { + get_mime_type(conn, path, &mime_vec); + } else { + mime_vec.ptr = mime_type; + mime_vec.len = strlen(mime_type); + } + if (filep->stat.size > INT64_MAX) { + mg_send_http_error(conn, + 500, + "Error: File size is too large to send\n%" INT64_FMT, + filep->stat.size); + return; + } + cl = (int64_t)filep->stat.size; + conn->status_code = 200; + range[0] = '\0'; + +#if defined(USE_ZLIB) + /* if this file is in fact a pre-gzipped file, rewrite its filename + * it's important to rewrite the filename after resolving + * the mime type from it, to preserve the actual file's type */ + if (!conn->accept_gzip) { + allow_on_the_fly_compression = 0; + } +#endif + + /* Check if there is a range header */ + range_hdr = mg_get_header(conn, "Range"); + + /* For gzipped files, add *.gz */ + if (filep->stat.is_gzipped) { + mg_snprintf(conn, &truncated, gz_path, sizeof(gz_path), "%s.gz", path); + + if (truncated) { + mg_send_http_error(conn, + 500, + "Error: Path of zipped file too long (%s)", + path); + return; + } + + path = gz_path; + encoding = "Content-Encoding: gzip\r\n"; + +#if defined(USE_ZLIB) + /* File is already compressed. No "on the fly" compression. */ + allow_on_the_fly_compression = 0; +#endif + } else if ((conn->accept_gzip) && (range_hdr == NULL) + && (filep->stat.size >= MG_FILE_COMPRESSION_SIZE_LIMIT)) { + struct mg_file_stat file_stat; + + mg_snprintf(conn, &truncated, gz_path, sizeof(gz_path), "%s.gz", path); + + if (!truncated && mg_stat(conn, gz_path, &file_stat) + && !file_stat.is_directory) { + file_stat.is_gzipped = 1; + filep->stat = file_stat; + cl = (int64_t)filep->stat.size; + path = gz_path; + encoding = "Content-Encoding: gzip\r\n"; + +#if defined(USE_ZLIB) + /* File is already compressed. No "on the fly" compression. */ + allow_on_the_fly_compression = 0; +#endif + } + } + + if (!mg_fopen(conn, path, MG_FOPEN_MODE_READ, filep)) { + mg_send_http_error(conn, + 500, + "Error: Cannot open file\nfopen(%s): %s", + path, + strerror(ERRNO)); + return; + } + + fclose_on_exec(&filep->access, conn); + + /* If "Range" request was made: parse header, send only selected part + * of the file. */ + r1 = r2 = 0; + if ((range_hdr != NULL) + && ((n = parse_range_header(range_hdr, &r1, &r2)) > 0) && (r1 >= 0) + && (r2 >= 0)) { + /* actually, range requests don't play well with a pre-gzipped + * file (since the range is specified in the uncompressed space) */ + if (filep->stat.is_gzipped) { + mg_send_http_error( + conn, + 416, /* 416 = Range Not Satisfiable */ + "%s", + "Error: Range requests in gzipped files are not supported"); + (void)mg_fclose( + &filep->access); /* ignore error on read only file */ + return; + } + conn->status_code = 206; + cl = (n == 2) ? (((r2 > cl) ? cl : r2) - r1 + 1) : (cl - r1); + mg_snprintf(conn, + NULL, /* range buffer is big enough */ + range, + sizeof(range), + "Content-Range: bytes " + "%" INT64_FMT "-%" INT64_FMT "/%" INT64_FMT "\r\n", + r1, + r1 + cl - 1, + filep->stat.size); + msg = "Partial Content"; + +#if defined(USE_ZLIB) + /* Do not compress ranges. */ + allow_on_the_fly_compression = 0; +#endif + } + +/* Do not compress small files. Small files do not benefit from file + * compression, but there is still some overhead. */ +#if defined(USE_ZLIB) + if (filep->stat.size < MG_FILE_COMPRESSION_SIZE_LIMIT) { + /* File is below the size limit. */ + allow_on_the_fly_compression = 0; + } +#endif + + /* Standard CORS header */ + cors_orig_cfg = conn->dom_ctx->config[ACCESS_CONTROL_ALLOW_ORIGIN]; + origin_hdr = mg_get_header(conn, "Origin"); + if (cors_orig_cfg && *cors_orig_cfg && origin_hdr) { + /* Cross-origin resource sharing (CORS), see + * http://www.html5rocks.com/en/tutorials/cors/, + * http://www.html5rocks.com/static/images/cors_server_flowchart.png + * - + * preflight is not supported for files. */ + cors1 = "Access-Control-Allow-Origin: "; + cors2 = cors_orig_cfg; + cors3 = "\r\n"; + } else { + cors1 = cors2 = cors3 = ""; + } + + /* Prepare Etag, Date, Last-Modified headers. Must be in UTC, + * according to + * http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3 */ + gmt_time_string(date, sizeof(date), &curtime); + gmt_time_string(lm, sizeof(lm), &filep->stat.last_modified); + construct_etag(etag, sizeof(etag), &filep->stat); + + /* Send header */ + (void)mg_printf(conn, + "HTTP/1.1 %d %s\r\n" + "%s%s%s" /* CORS */ + "Date: %s\r\n" + "Last-Modified: %s\r\n" + "Etag: %s\r\n" + "Content-Type: %.*s\r\n" + "Connection: %s\r\n", + conn->status_code, + msg, + cors1, + cors2, + cors3, + date, + lm, + etag, + (int)mime_vec.len, + mime_vec.ptr, + suggest_connection_header(conn)); + send_static_cache_header(conn); + send_additional_header(conn); + +#if defined(USE_ZLIB) + /* On the fly compression allowed */ + if (allow_on_the_fly_compression) { + /* For on the fly compression, we don't know the content size in + * advance, so we have to use chunked encoding */ + (void)mg_printf(conn, + "Content-Encoding: gzip\r\n" + "Transfer-Encoding: chunked\r\n"); + } else +#endif + { + /* Without on-the-fly compression, we know the content-length + * and we can use ranges (with on-the-fly compression we cannot). + * So we send these response headers only in this case. */ + (void)mg_printf(conn, + "Content-Length: %" INT64_FMT "\r\n" + "Accept-Ranges: bytes\r\n" + "%s" /* range */ + "%s" /* encoding */, + cl, + range, + encoding); + } + + /* The previous code must not add any header starting with X- to make + * sure no one of the additional_headers is included twice */ + if (additional_headers != NULL) { + (void)mg_printf(conn, + "%.*s\r\n\r\n", + (int)strlen(additional_headers), + additional_headers); + } else { + (void)mg_printf(conn, "\r\n"); + } + + if (!is_head_request) { +#if defined(USE_ZLIB) + if (allow_on_the_fly_compression) { + /* Compress and send */ + send_compressed_data(conn, filep); + } else +#endif + { + /* Send file directly */ + send_file_data(conn, filep, r1, cl); + } + } + (void)mg_fclose(&filep->access); /* ignore error on read only file */ +} + + +int +mg_send_file_body(struct mg_connection *conn, const char *path) +{ + struct mg_file file = STRUCT_FILE_INITIALIZER; + if (!mg_fopen(conn, path, MG_FOPEN_MODE_READ, &file)) { + return -1; + } + fclose_on_exec(&file.access, conn); + send_file_data(conn, &file, 0, INT64_MAX); + (void)mg_fclose(&file.access); /* Ignore errors for readonly files */ + return 0; /* >= 0 for OK */ +} + + +#if !defined(NO_CACHING) +/* Return True if we should reply 304 Not Modified. */ +static int +is_not_modified(const struct mg_connection *conn, + const struct mg_file_stat *filestat) +{ + char etag[64]; + const char *ims = mg_get_header(conn, "If-Modified-Since"); + const char *inm = mg_get_header(conn, "If-None-Match"); + construct_etag(etag, sizeof(etag), filestat); + + return ((inm != NULL) && !mg_strcasecmp(etag, inm)) + || ((ims != NULL) + && (filestat->last_modified <= parse_date_string(ims))); +} + +static void +handle_not_modified_static_file_request(struct mg_connection *conn, + struct mg_file *filep) +{ + char date[64], lm[64], etag[64]; + time_t curtime = time(NULL); + + if ((conn == NULL) || (filep == NULL)) { + return; + } + conn->status_code = 304; + gmt_time_string(date, sizeof(date), &curtime); + gmt_time_string(lm, sizeof(lm), &filep->stat.last_modified); + construct_etag(etag, sizeof(etag), &filep->stat); + + (void)mg_printf(conn, + "HTTP/1.1 %d %s\r\n" + "Date: %s\r\n", + conn->status_code, + mg_get_response_code_text(conn, conn->status_code), + date); + send_static_cache_header(conn); + send_additional_header(conn); + (void)mg_printf(conn, + "Last-Modified: %s\r\n" + "Etag: %s\r\n" + "Connection: %s\r\n" + "\r\n", + lm, + etag, + suggest_connection_header(conn)); +} +#endif + + +void +mg_send_file(struct mg_connection *conn, const char *path) +{ + mg_send_mime_file2(conn, path, NULL, NULL); +} + + +void +mg_send_mime_file(struct mg_connection *conn, + const char *path, + const char *mime_type) +{ + mg_send_mime_file2(conn, path, mime_type, NULL); +} + + +void +mg_send_mime_file2(struct mg_connection *conn, + const char *path, + const char *mime_type, + const char *additional_headers) +{ + struct mg_file file = STRUCT_FILE_INITIALIZER; + + if (!conn) { + /* No conn */ + return; + } + + if (mg_stat(conn, path, &file.stat)) { +#if !defined(NO_CACHING) + if (is_not_modified(conn, &file.stat)) { + /* Send 304 "Not Modified" - this must not send any body data */ + handle_not_modified_static_file_request(conn, &file); + } else +#endif /* NO_CACHING */ + if (file.stat.is_directory) { + if (!mg_strcasecmp(conn->dom_ctx->config[ENABLE_DIRECTORY_LISTING], + "yes")) { + handle_directory_request(conn, path); + } else { + mg_send_http_error(conn, + 403, + "%s", + "Error: Directory listing denied"); + } + } else { + handle_static_file_request( + conn, path, &file, mime_type, additional_headers); + } + } else { + mg_send_http_error(conn, 404, "%s", "Error: File not found"); + } +} + + +/* For a given PUT path, create all intermediate subdirectories. + * Return 0 if the path itself is a directory. + * Return 1 if the path leads to a file. + * Return -1 for if the path is too long. + * Return -2 if path can not be created. + */ +static int +put_dir(struct mg_connection *conn, const char *path) +{ + char buf[PATH_MAX]; + const char *s, *p; + struct mg_file file = STRUCT_FILE_INITIALIZER; + size_t len; + int res = 1; + + for (s = p = path + 2; (p = strchr(s, '/')) != NULL; s = ++p) { + len = (size_t)(p - path); + if (len >= sizeof(buf)) { + /* path too long */ + res = -1; + break; + } + memcpy(buf, path, len); + buf[len] = '\0'; + + /* Try to create intermediate directory */ + DEBUG_TRACE("mkdir(%s)", buf); + if (!mg_stat(conn, buf, &file.stat) && mg_mkdir(conn, buf, 0755) != 0) { + /* path does not exixt and can not be created */ + res = -2; + break; + } + + /* Is path itself a directory? */ + if (p[1] == '\0') { + res = 0; + } + } + + return res; +} + + +static void +remove_bad_file(const struct mg_connection *conn, const char *path) +{ + int r = mg_remove(conn, path); + if (r != 0) { + mg_cry_internal(conn, + "%s: Cannot remove invalid file %s", + __func__, + path); + } +} + + +long long +mg_store_body(struct mg_connection *conn, const char *path) +{ + char buf[MG_BUF_LEN]; + long long len = 0; + int ret, n; + struct mg_file fi; + + if (conn->consumed_content != 0) { + mg_cry_internal(conn, "%s: Contents already consumed", __func__); + return -11; + } + + ret = put_dir(conn, path); + if (ret < 0) { + /* -1 for path too long, + * -2 for path can not be created. */ + return ret; + } + if (ret != 1) { + /* Return 0 means, path itself is a directory. */ + return 0; + } + + if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fi) == 0) { + return -12; + } + + ret = mg_read(conn, buf, sizeof(buf)); + while (ret > 0) { + n = (int)fwrite(buf, 1, (size_t)ret, fi.access.fp); + if (n != ret) { + (void)mg_fclose( + &fi.access); /* File is bad and will be removed anyway. */ + remove_bad_file(conn, path); + return -13; + } + len += ret; + ret = mg_read(conn, buf, sizeof(buf)); + } + + /* File is open for writing. If fclose fails, there was probably an + * error flushing the buffer to disk, so the file on disk might be + * broken. Delete it and return an error to the caller. */ + if (mg_fclose(&fi.access) != 0) { + remove_bad_file(conn, path); + return -14; + } + + return len; +} + + +/* Parse a buffer: + * Forward the string pointer till the end of a word, then + * terminate it and forward till the begin of the next word. + */ +static int +skip_to_end_of_word_and_terminate(char **ppw, int eol) +{ + /* Forward until a space is found - use isgraph here */ + /* See http://www.cplusplus.com/reference/cctype/ */ + while (isgraph((unsigned char)**ppw)) { + (*ppw)++; + } + + /* Check end of word */ + if (eol) { + /* must be a end of line */ + if ((**ppw != '\r') && (**ppw != '\n')) { + return -1; + } + } else { + /* must be a end of a word, but not a line */ + if (**ppw != ' ') { + return -1; + } + } + + /* Terminate and forward to the next word */ + do { + **ppw = 0; + (*ppw)++; + } while (isspace((unsigned char)**ppw)); + + /* Check after term */ + if (!eol) { + /* if it's not the end of line, there must be a next word */ + if (!isgraph((unsigned char)**ppw)) { + return -1; + } + } + + /* ok */ + return 1; +} + + +/* Parse HTTP headers from the given buffer, advance buf pointer + * to the point where parsing stopped. + * All parameters must be valid pointers (not NULL). + * Return <0 on error. */ +static int +parse_http_headers(char **buf, struct mg_header hdr[MG_MAX_HEADERS]) +{ + int i; + int num_headers = 0; + + for (i = 0; i < (int)MG_MAX_HEADERS; i++) { + char *dp = *buf; + while ((*dp != ':') && (*dp >= 33) && (*dp <= 126)) { + dp++; + } + if (dp == *buf) { + /* End of headers reached. */ + break; + } + if (*dp != ':') { + /* This is not a valid field. */ + return -1; + } + + /* End of header key (*dp == ':') */ + /* Truncate here and set the key name */ + *dp = 0; + hdr[i].name = *buf; + do { + dp++; + } while (*dp == ' '); + + /* The rest of the line is the value */ + hdr[i].value = dp; + *buf = dp + strcspn(dp, "\r\n"); + if (((*buf)[0] != '\r') || ((*buf)[1] != '\n')) { + *buf = NULL; + } + + num_headers = i + 1; + if (*buf) { + (*buf)[0] = 0; + (*buf)[1] = 0; + *buf += 2; + } else { + *buf = dp; + break; + } + + if ((*buf)[0] == '\r') { + /* This is the end of the header */ + break; + } + } + return num_headers; +} + + +struct mg_http_method_info { + const char *name; + int request_has_body; + int response_has_body; + int is_safe; + int is_idempotent; + int is_cacheable; +}; + + +/* https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods */ +static struct mg_http_method_info http_methods[] = { + /* HTTP (RFC 2616) */ + {"GET", 0, 1, 1, 1, 1}, + {"POST", 1, 1, 0, 0, 0}, + {"PUT", 1, 0, 0, 1, 0}, + {"DELETE", 0, 0, 0, 1, 0}, + {"HEAD", 0, 0, 1, 1, 1}, + {"OPTIONS", 0, 0, 1, 1, 0}, + {"CONNECT", 1, 1, 0, 0, 0}, + /* TRACE method (RFC 2616) is not supported for security reasons */ + + /* PATCH method (RFC 5789) */ + {"PATCH", 1, 0, 0, 0, 0}, + /* PATCH method only allowed for CGI/Lua/LSP and callbacks. */ + + /* WEBDAV (RFC 2518) */ + {"PROPFIND", 0, 1, 1, 1, 0}, + /* http://www.webdav.org/specs/rfc4918.html, 9.1: + * Some PROPFIND results MAY be cached, with care, + * as there is no cache validation mechanism for + * most properties. This method is both safe and + * idempotent (see Section 9.1 of [RFC2616]). */ + {"MKCOL", 0, 0, 0, 1, 0}, + /* http://www.webdav.org/specs/rfc4918.html, 9.1: + * When MKCOL is invoked without a request body, + * the newly created collection SHOULD have no + * members. A MKCOL request message may contain + * a message body. The precise behavior of a MKCOL + * request when the body is present is undefined, + * ... ==> We do not support MKCOL with body data. + * This method is idempotent, but not safe (see + * Section 9.1 of [RFC2616]). Responses to this + * method MUST NOT be cached. */ + + /* Unsupported WEBDAV Methods: */ + /* PROPPATCH, COPY, MOVE, LOCK, UNLOCK (RFC 2518) */ + /* + 11 methods from RFC 3253 */ + /* ORDERPATCH (RFC 3648) */ + /* ACL (RFC 3744) */ + /* SEARCH (RFC 5323) */ + /* + MicroSoft extensions + * https://msdn.microsoft.com/en-us/library/aa142917.aspx */ + + /* REPORT method (RFC 3253) */ + {"REPORT", 1, 1, 1, 1, 1}, + /* REPORT method only allowed for CGI/Lua/LSP and callbacks. */ + /* It was defined for WEBDAV in RFC 3253, Sec. 3.6 + * (https://tools.ietf.org/html/rfc3253#section-3.6), but seems + * to be useful for REST in case a "GET request with body" is + * required. */ + + {NULL, 0, 0, 0, 0, 0} + /* end of list */ +}; + + +static const struct mg_http_method_info * +get_http_method_info(const char *method) +{ + /* Check if the method is known to the server. The list of all known + * HTTP methods can be found here at + * http://www.iana.org/assignments/http-methods/http-methods.xhtml + */ + const struct mg_http_method_info *m = http_methods; + + while (m->name) { + if (!strcmp(m->name, method)) { + return m; + } + m++; + } + return NULL; +} + + +static int +is_valid_http_method(const char *method) +{ + return (get_http_method_info(method) != NULL); +} + + +/* Parse HTTP request, fill in mg_request_info structure. + * This function modifies the buffer by NUL-terminating + * HTTP request components, header names and header values. + * Parameters: + * buf (in/out): pointer to the HTTP header to parse and split + * len (in): length of HTTP header buffer + * re (out): parsed header as mg_request_info + * buf and ri must be valid pointers (not NULL), len>0. + * Returns <0 on error. */ +static int +parse_http_request(char *buf, int len, struct mg_request_info *ri) +{ + int request_length; + int init_skip = 0; + + /* Reset attributes. DO NOT TOUCH is_ssl, remote_addr, + * remote_port */ + ri->remote_user = ri->request_method = ri->request_uri = ri->http_version = + NULL; + ri->num_headers = 0; + + /* RFC says that all initial whitespaces should be ingored */ + /* This included all leading \r and \n (isspace) */ + /* See table: http://www.cplusplus.com/reference/cctype/ */ + while ((len > 0) && isspace((unsigned char)*buf)) { + buf++; + len--; + init_skip++; + } + + if (len == 0) { + /* Incomplete request */ + return 0; + } + + /* Control characters are not allowed, including zero */ + if (iscntrl((unsigned char)*buf)) { + return -1; + } + + /* Find end of HTTP header */ + request_length = get_http_header_len(buf, len); + if (request_length <= 0) { + return request_length; + } + buf[request_length - 1] = '\0'; + + if ((*buf == 0) || (*buf == '\r') || (*buf == '\n')) { + return -1; + } + + /* The first word has to be the HTTP method */ + ri->request_method = buf; + + if (skip_to_end_of_word_and_terminate(&buf, 0) <= 0) { + return -1; + } + + /* Check for a valid http method */ + if (!is_valid_http_method(ri->request_method)) { + return -1; + } + + /* The second word is the URI */ + ri->request_uri = buf; + + if (skip_to_end_of_word_and_terminate(&buf, 0) <= 0) { + return -1; + } + + /* Next would be the HTTP version */ + ri->http_version = buf; + + if (skip_to_end_of_word_and_terminate(&buf, 1) <= 0) { + return -1; + } + + /* Check for a valid HTTP version key */ + if (strncmp(ri->http_version, "HTTP/", 5) != 0) { + /* Invalid request */ + return -1; + } + ri->http_version += 5; + + + /* Parse all HTTP headers */ + ri->num_headers = parse_http_headers(&buf, ri->http_headers); + if (ri->num_headers < 0) { + /* Error while parsing headers */ + return -1; + } + + return request_length + init_skip; +} + + +static int +parse_http_response(char *buf, int len, struct mg_response_info *ri) +{ + int response_length; + int init_skip = 0; + char *tmp, *tmp2; + long l; + + /* Initialize elements. */ + ri->http_version = ri->status_text = NULL; + ri->num_headers = ri->status_code = 0; + + /* RFC says that all initial whitespaces should be ingored */ + /* This included all leading \r and \n (isspace) */ + /* See table: http://www.cplusplus.com/reference/cctype/ */ + while ((len > 0) && isspace((unsigned char)*buf)) { + buf++; + len--; + init_skip++; + } + + if (len == 0) { + /* Incomplete request */ + return 0; + } + + /* Control characters are not allowed, including zero */ + if (iscntrl((unsigned char)*buf)) { + return -1; + } + + /* Find end of HTTP header */ + response_length = get_http_header_len(buf, len); + if (response_length <= 0) { + return response_length; + } + buf[response_length - 1] = '\0'; + + if ((*buf == 0) || (*buf == '\r') || (*buf == '\n')) { + return -1; + } + + /* The first word is the HTTP version */ + /* Check for a valid HTTP version key */ + if (strncmp(buf, "HTTP/", 5) != 0) { + /* Invalid request */ + return -1; + } + buf += 5; + if (!isgraph((unsigned char)buf[0])) { + /* Invalid request */ + return -1; + } + ri->http_version = buf; + + if (skip_to_end_of_word_and_terminate(&buf, 0) <= 0) { + return -1; + } + + /* The second word is the status as a number */ + tmp = buf; + + if (skip_to_end_of_word_and_terminate(&buf, 0) <= 0) { + return -1; + } + + l = strtol(tmp, &tmp2, 10); + if ((l < 100) || (l >= 1000) || ((tmp2 - tmp) != 3) || (*tmp2 != 0)) { + /* Everything else but a 3 digit code is invalid */ + return -1; + } + ri->status_code = (int)l; + + /* The rest of the line is the status text */ + ri->status_text = buf; + + /* Find end of status text */ + /* isgraph or isspace = isprint */ + while (isprint((unsigned char)*buf)) { + buf++; + } + if ((*buf != '\r') && (*buf != '\n')) { + return -1; + } + /* Terminate string and forward buf to next line */ + do { + *buf = 0; + buf++; + } while (isspace((unsigned char)*buf)); + + + /* Parse all HTTP headers */ + ri->num_headers = parse_http_headers(&buf, ri->http_headers); + if (ri->num_headers < 0) { + /* Error while parsing headers */ + return -1; + } + + return response_length + init_skip; +} + + +/* Keep reading the input (either opened file descriptor fd, or socket sock, + * or SSL descriptor ssl) into buffer buf, until \r\n\r\n appears in the + * buffer (which marks the end of HTTP request). Buffer buf may already + * have some data. The length of the data is stored in nread. + * Upon every read operation, increase nread by the number of bytes read. */ +static int +read_message(FILE *fp, + struct mg_connection *conn, + char *buf, + int bufsiz, + int *nread) +{ + int request_len, n = 0; + struct timespec last_action_time; + double request_timeout; + + if (!conn) { + return 0; + } + + memset(&last_action_time, 0, sizeof(last_action_time)); + + if (conn->dom_ctx->config[REQUEST_TIMEOUT]) { + /* value of request_timeout is in seconds, config in milliseconds */ + request_timeout = atof(conn->dom_ctx->config[REQUEST_TIMEOUT]) / 1000.0; + } else { + request_timeout = -1.0; + } + if (conn->handled_requests > 0) { + if (conn->dom_ctx->config[KEEP_ALIVE_TIMEOUT]) { + request_timeout = + atof(conn->dom_ctx->config[KEEP_ALIVE_TIMEOUT]) / 1000.0; + } + } + + request_len = get_http_header_len(buf, *nread); + + while (request_len == 0) { + /* Full request not yet received */ + if (conn->phys_ctx->stop_flag != 0) { + /* Server is to be stopped. */ + return -1; + } + + if (*nread >= bufsiz) { + /* Request too long */ + return -2; + } + + n = pull_inner( + fp, conn, buf + *nread, bufsiz - *nread, request_timeout); + if (n == -2) { + /* Receive error */ + return -1; + } + + /* update clock after every read request */ + clock_gettime(CLOCK_MONOTONIC, &last_action_time); + + if (n > 0) { + *nread += n; + request_len = get_http_header_len(buf, *nread); + } else { + request_len = 0; + } + + if ((request_len == 0) && (request_timeout >= 0)) { + if (mg_difftimespec(&last_action_time, &(conn->req_time)) + > request_timeout) { + /* Timeout */ + return -1; + } + } + } + + return request_len; +} + + +#if !defined(NO_CGI) || !defined(NO_FILES) +static int +forward_body_data(struct mg_connection *conn, FILE *fp, SOCKET sock, SSL *ssl) +{ + const char *expect; + char buf[MG_BUF_LEN]; + int success = 0; + + if (!conn) { + return 0; + } + + expect = mg_get_header(conn, "Expect"); + DEBUG_ASSERT(fp != NULL); + if (!fp) { + mg_send_http_error(conn, 500, "%s", "Error: NULL File"); + return 0; + } + + if ((expect != NULL) && (mg_strcasecmp(expect, "100-continue") != 0)) { + /* Client sent an "Expect: xyz" header and xyz is not 100-continue. + */ + mg_send_http_error(conn, + 417, + "Error: Can not fulfill expectation %s", + expect); + } else { + if (expect != NULL) { + (void)mg_printf(conn, "%s", "HTTP/1.1 100 Continue\r\n\r\n"); + conn->status_code = 100; + } else { + conn->status_code = 200; + } + + DEBUG_ASSERT(conn->consumed_content == 0); + + if (conn->consumed_content != 0) { + mg_send_http_error(conn, 500, "%s", "Error: Size mismatch"); + return 0; + } + + for (;;) { + int nread = mg_read(conn, buf, sizeof(buf)); + if (nread <= 0) { + success = (nread == 0); + break; + } + if (push_all(conn->phys_ctx, fp, sock, ssl, buf, nread) != nread) { + break; + } + } + + /* Each error code path in this function must send an error */ + if (!success) { + /* NOTE: Maybe some data has already been sent. */ + /* TODO (low): If some data has been sent, a correct error + * reply can no longer be sent, so just close the connection */ + mg_send_http_error(conn, 500, "%s", ""); + } + } + + return success; +} +#endif + + +#if defined(USE_TIMERS) + +#define TIMER_API static +#include "timer.inl" + +#endif /* USE_TIMERS */ + + +#if !defined(NO_CGI) +/* This structure helps to create an environment for the spawned CGI + * program. + * Environment is an array of "VARIABLE=VALUE\0" ASCIIZ strings, + * last element must be NULL. + * However, on Windows there is a requirement that all these + * VARIABLE=VALUE\0 + * strings must reside in a contiguous buffer. The end of the buffer is + * marked by two '\0' characters. + * We satisfy both worlds: we create an envp array (which is vars), all + * entries are actually pointers inside buf. */ +struct cgi_environment { + struct mg_connection *conn; + /* Data block */ + char *buf; /* Environment buffer */ + size_t buflen; /* Space available in buf */ + size_t bufused; /* Space taken in buf */ + /* Index block */ + char **var; /* char **envp */ + size_t varlen; /* Number of variables available in var */ + size_t varused; /* Number of variables stored in var */ +}; + + +static void addenv(struct cgi_environment *env, + PRINTF_FORMAT_STRING(const char *fmt), + ...) PRINTF_ARGS(2, 3); + +/* Append VARIABLE=VALUE\0 string to the buffer, and add a respective + * pointer into the vars array. Assumes env != NULL and fmt != NULL. */ +static void +addenv(struct cgi_environment *env, const char *fmt, ...) +{ + size_t i, n, space; + int truncated = 0; + char *added; + va_list ap; + + if ((env->varlen - env->varused) < 2) { + mg_cry_internal(env->conn, + "%s: Cannot register CGI variable [%s]", + __func__, + fmt); + return; + } + + /* Calculate how much space is left in the buffer */ + space = (env->buflen - env->bufused); + + do { + /* Space for "\0\0" is always needed. */ + if (space <= 2) { + /* Allocate new buffer */ + n = env->buflen + CGI_ENVIRONMENT_SIZE; + added = (char *)mg_realloc_ctx(env->buf, n, env->conn->phys_ctx); + if (!added) { + /* Out of memory */ + mg_cry_internal( + env->conn, + "%s: Cannot allocate memory for CGI variable [%s]", + __func__, + fmt); + return; + } + /* Retarget pointers */ + env->buf = added; + env->buflen = n; + for (i = 0, n = 0; i < env->varused; i++) { + env->var[i] = added + n; + n += strlen(added + n) + 1; + } + space = (env->buflen - env->bufused); + } + + /* Make a pointer to the free space int the buffer */ + added = env->buf + env->bufused; + + /* Copy VARIABLE=VALUE\0 string into the free space */ + va_start(ap, fmt); + mg_vsnprintf(env->conn, &truncated, added, space - 1, fmt, ap); + va_end(ap); + + /* Do not add truncated strings to the environment */ + if (truncated) { + /* Reallocate the buffer */ + space = 0; + } + } while (truncated); + + /* Calculate number of bytes added to the environment */ + n = strlen(added) + 1; + env->bufused += n; + + /* Append a pointer to the added string into the envp array */ + env->var[env->varused] = added; + env->varused++; +} + +/* Return 0 on success, non-zero if an error occurs. */ + +static int +prepare_cgi_environment(struct mg_connection *conn, + const char *prog, + struct cgi_environment *env) +{ + const char *s; + struct vec var_vec; + char *p, src_addr[IP_ADDR_STR_LEN], http_var_name[128]; + int i, truncated, uri_len; + + if ((conn == NULL) || (prog == NULL) || (env == NULL)) { + return -1; + } + + env->conn = conn; + env->buflen = CGI_ENVIRONMENT_SIZE; + env->bufused = 0; + env->buf = (char *)mg_malloc_ctx(env->buflen, conn->phys_ctx); + if (env->buf == NULL) { + mg_cry_internal(conn, + "%s: Not enough memory for environmental buffer", + __func__); + return -1; + } + env->varlen = MAX_CGI_ENVIR_VARS; + env->varused = 0; + env->var = + (char **)mg_malloc_ctx(env->varlen * sizeof(char *), conn->phys_ctx); + if (env->var == NULL) { + mg_cry_internal(conn, + "%s: Not enough memory for environmental variables", + __func__); + mg_free(env->buf); + return -1; + } + + addenv(env, "SERVER_NAME=%s", conn->dom_ctx->config[AUTHENTICATION_DOMAIN]); + addenv(env, "SERVER_ROOT=%s", conn->dom_ctx->config[DOCUMENT_ROOT]); + addenv(env, "DOCUMENT_ROOT=%s", conn->dom_ctx->config[DOCUMENT_ROOT]); + addenv(env, "SERVER_SOFTWARE=CivetWeb/%s", mg_version()); + + /* Prepare the environment block */ + addenv(env, "%s", "GATEWAY_INTERFACE=CGI/1.1"); + addenv(env, "%s", "SERVER_PROTOCOL=HTTP/1.1"); + addenv(env, "%s", "REDIRECT_STATUS=200"); /* For PHP */ + +#if defined(USE_IPV6) + if (conn->client.lsa.sa.sa_family == AF_INET6) { + addenv(env, "SERVER_PORT=%d", ntohs(conn->client.lsa.sin6.sin6_port)); + } else +#endif + { + addenv(env, "SERVER_PORT=%d", ntohs(conn->client.lsa.sin.sin_port)); + } + + sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa); + addenv(env, "REMOTE_ADDR=%s", src_addr); + + addenv(env, "REQUEST_METHOD=%s", conn->request_info.request_method); + addenv(env, "REMOTE_PORT=%d", conn->request_info.remote_port); + + addenv(env, "REQUEST_URI=%s", conn->request_info.request_uri); + addenv(env, "LOCAL_URI=%s", conn->request_info.local_uri); + + /* SCRIPT_NAME */ + uri_len = (int)strlen(conn->request_info.local_uri); + if (conn->path_info == NULL) { + if (conn->request_info.local_uri[uri_len - 1] != '/') { + /* URI: /path_to_script/script.cgi */ + addenv(env, "SCRIPT_NAME=%s", conn->request_info.local_uri); + } else { + /* URI: /path_to_script/ ... using index.cgi */ + const char *index_file = strrchr(prog, '/'); + if (index_file) { + addenv(env, + "SCRIPT_NAME=%s%s", + conn->request_info.local_uri, + index_file + 1); + } + } + } else { + /* URI: /path_to_script/script.cgi/path_info */ + addenv(env, + "SCRIPT_NAME=%.*s", + uri_len - (int)strlen(conn->path_info), + conn->request_info.local_uri); + } + + addenv(env, "SCRIPT_FILENAME=%s", prog); + if (conn->path_info == NULL) { + addenv(env, "PATH_TRANSLATED=%s", conn->dom_ctx->config[DOCUMENT_ROOT]); + } else { + addenv(env, + "PATH_TRANSLATED=%s%s", + conn->dom_ctx->config[DOCUMENT_ROOT], + conn->path_info); + } + + addenv(env, "HTTPS=%s", (conn->ssl == NULL) ? "off" : "on"); + + if ((s = mg_get_header(conn, "Content-Type")) != NULL) { + addenv(env, "CONTENT_TYPE=%s", s); + } + if (conn->request_info.query_string != NULL) { + addenv(env, "QUERY_STRING=%s", conn->request_info.query_string); + } + if ((s = mg_get_header(conn, "Content-Length")) != NULL) { + addenv(env, "CONTENT_LENGTH=%s", s); + } + if ((s = getenv("PATH")) != NULL) { + addenv(env, "PATH=%s", s); + } + if (conn->path_info != NULL) { + addenv(env, "PATH_INFO=%s", conn->path_info); + } + + if (conn->status_code > 0) { + /* CGI error handler should show the status code */ + addenv(env, "STATUS=%d", conn->status_code); + } + +#if defined(_WIN32) + if ((s = getenv("COMSPEC")) != NULL) { + addenv(env, "COMSPEC=%s", s); + } + if ((s = getenv("SYSTEMROOT")) != NULL) { + addenv(env, "SYSTEMROOT=%s", s); + } + if ((s = getenv("SystemDrive")) != NULL) { + addenv(env, "SystemDrive=%s", s); + } + if ((s = getenv("ProgramFiles")) != NULL) { + addenv(env, "ProgramFiles=%s", s); + } + if ((s = getenv("ProgramFiles(x86)")) != NULL) { + addenv(env, "ProgramFiles(x86)=%s", s); + } +#else + if ((s = getenv("LD_LIBRARY_PATH")) != NULL) { + addenv(env, "LD_LIBRARY_PATH=%s", s); + } +#endif /* _WIN32 */ + + if ((s = getenv("PERLLIB")) != NULL) { + addenv(env, "PERLLIB=%s", s); + } + + if (conn->request_info.remote_user != NULL) { + addenv(env, "REMOTE_USER=%s", conn->request_info.remote_user); + addenv(env, "%s", "AUTH_TYPE=Digest"); + } + + /* Add all headers as HTTP_* variables */ + for (i = 0; i < conn->request_info.num_headers; i++) { + + (void)mg_snprintf(conn, + &truncated, + http_var_name, + sizeof(http_var_name), + "HTTP_%s", + conn->request_info.http_headers[i].name); + + if (truncated) { + mg_cry_internal(conn, + "%s: HTTP header variable too long [%s]", + __func__, + conn->request_info.http_headers[i].name); + continue; + } + + /* Convert variable name into uppercase, and change - to _ */ + for (p = http_var_name; *p != '\0'; p++) { + if (*p == '-') { + *p = '_'; + } + *p = (char)toupper((unsigned char)*p); + } + + addenv(env, + "%s=%s", + http_var_name, + conn->request_info.http_headers[i].value); + } + + /* Add user-specified variables */ + s = conn->dom_ctx->config[CGI_ENVIRONMENT]; + while ((s = next_option(s, &var_vec, NULL)) != NULL) { + addenv(env, "%.*s", (int)var_vec.len, var_vec.ptr); + } + + env->var[env->varused] = NULL; + env->buf[env->bufused] = '\0'; + + return 0; +} + + +/* Data for CGI process control: PID and number of references */ +struct process_control_data { + pid_t pid; + int references; +}; + +static int +abort_process(void *data) +{ + /* Waitpid checks for child status and won't work for a pid that does not + * identify a child of the current process. Thus, if the pid is reused, + * we will not affect a different process. */ + struct process_control_data *proc = (struct process_control_data *)data; + int status = 0; + int refs; + pid_t ret_pid; + + ret_pid = waitpid(proc->pid, &status, WNOHANG); + if ((ret_pid != (pid_t)-1) && (status == 0)) { + /* Stop child process */ + DEBUG_TRACE("CGI timer: Stop child process %p\n", proc->pid); + kill(proc->pid, SIGABRT); + + /* Wait until process is terminated (don't leave zombies) */ + while (waitpid(proc->pid, &status, 0) != (pid_t)-1) /* nop */ + ; + } else { + DEBUG_TRACE("CGI timer: Child process %p already stopped\n", proc->pid); + } + /* Dec reference counter */ + refs = mg_atomic_dec(&proc->references); + if (refs == 0) { + /* no more references - free data */ + mg_free(data); + } + + return 0; +} + + +/* Local (static) function assumes all arguments are valid. */ +static void +handle_cgi_request(struct mg_connection *conn, const char *prog) +{ + char *buf; + size_t buflen; + int headers_len, data_len, i, truncated; + int fdin[2] = {-1, -1}, fdout[2] = {-1, -1}, fderr[2] = {-1, -1}; + const char *status, *status_text, *connection_state; + char *pbuf, dir[PATH_MAX], *p; + struct mg_request_info ri; + struct cgi_environment blk; + FILE *in = NULL, *out = NULL, *err = NULL; + struct mg_file fout = STRUCT_FILE_INITIALIZER; + pid_t pid = (pid_t)-1; + struct process_control_data *proc = NULL; + +#if defined(USE_TIMERS) + double cgi_timeout = -1.0; + if (conn->dom_ctx->config[CGI_TIMEOUT]) { + /* Get timeout in seconds */ + cgi_timeout = atof(conn->dom_ctx->config[CGI_TIMEOUT]) * 0.001; + } +#endif + + buf = NULL; + buflen = conn->phys_ctx->max_request_size; + i = prepare_cgi_environment(conn, prog, &blk); + if (i != 0) { + blk.buf = NULL; + blk.var = NULL; + goto done; + } + + /* CGI must be executed in its own directory. 'dir' must point to the + * directory containing executable program, 'p' must point to the + * executable program name relative to 'dir'. */ + (void)mg_snprintf(conn, &truncated, dir, sizeof(dir), "%s", prog); + + if (truncated) { + mg_cry_internal(conn, "Error: CGI program \"%s\": Path too long", prog); + mg_send_http_error(conn, 500, "Error: %s", "CGI path too long"); + goto done; + } + + if ((p = strrchr(dir, '/')) != NULL) { + *p++ = '\0'; + } else { + dir[0] = '.'; + dir[1] = '\0'; + p = (char *)prog; + } + + if ((pipe(fdin) != 0) || (pipe(fdout) != 0) || (pipe(fderr) != 0)) { + status = strerror(ERRNO); + mg_cry_internal( + conn, + "Error: CGI program \"%s\": Can not create CGI pipes: %s", + prog, + status); + mg_send_http_error(conn, + 500, + "Error: Cannot create CGI pipe: %s", + status); + goto done; + } + + proc = (struct process_control_data *) + mg_malloc_ctx(sizeof(struct process_control_data), conn->phys_ctx); + if (proc == NULL) { + mg_cry_internal(conn, "Error: CGI program \"%s\": Out or memory", prog); + mg_send_http_error(conn, 500, "Error: Out of memory [%s]", prog); + goto done; + } + + DEBUG_TRACE("CGI: spawn %s %s\n", dir, p); + pid = spawn_process(conn, p, blk.buf, blk.var, fdin, fdout, fderr, dir); + + if (pid == (pid_t)-1) { + status = strerror(ERRNO); + mg_cry_internal( + conn, + "Error: CGI program \"%s\": Can not spawn CGI process: %s", + prog, + status); + mg_send_http_error(conn, + 500, + "Error: Cannot spawn CGI process [%s]: %s", + prog, + status); + mg_free(proc); + proc = NULL; + goto done; + } + + /* Store data in shared process_control_data */ + proc->pid = pid; + proc->references = 1; + +#if defined(USE_TIMERS) + if (cgi_timeout > 0.0) { + proc->references = 2; + + // Start a timer for CGI + timer_add(conn->phys_ctx, + cgi_timeout /* in seconds */, + 0.0, + 1, + abort_process, + (void *)proc); + } +#endif + + /* Parent closes only one side of the pipes. + * If we don't mark them as closed, close() attempt before + * return from this function throws an exception on Windows. + * Windows does not like when closed descriptor is closed again. */ + (void)close(fdin[0]); + (void)close(fdout[1]); + (void)close(fderr[1]); + fdin[0] = fdout[1] = fderr[1] = -1; + + if (((in = fdopen(fdin[1], "wb")) == NULL) + || ((out = fdopen(fdout[0], "rb")) == NULL) + || ((err = fdopen(fderr[0], "rb")) == NULL)) { + status = strerror(ERRNO); + mg_cry_internal(conn, + "Error: CGI program \"%s\": Can not open fd: %s", + prog, + status); + mg_send_http_error(conn, + 500, + "Error: CGI can not open fd\nfdopen: %s", + status); + goto done; + } + + setbuf(in, NULL); + setbuf(out, NULL); + setbuf(err, NULL); + fout.access.fp = out; + + if ((conn->content_len != 0) || (conn->is_chunked)) { + DEBUG_TRACE("CGI: send body data (%" INT64_FMT ")\n", + conn->content_len); + + /* This is a POST/PUT request, or another request with body data. */ + if (!forward_body_data(conn, in, INVALID_SOCKET, NULL)) { + /* Error sending the body data */ + mg_cry_internal( + conn, + "Error: CGI program \"%s\": Forward body data failed", + prog); + goto done; + } + } + + /* Close so child gets an EOF. */ + fclose(in); + in = NULL; + fdin[1] = -1; + + /* Now read CGI reply into a buffer. We need to set correct + * status code, thus we need to see all HTTP headers first. + * Do not send anything back to client, until we buffer in all + * HTTP headers. */ + data_len = 0; + buf = (char *)mg_malloc_ctx(buflen, conn->phys_ctx); + if (buf == NULL) { + mg_send_http_error(conn, + 500, + "Error: Not enough memory for CGI buffer (%u bytes)", + (unsigned int)buflen); + mg_cry_internal( + conn, + "Error: CGI program \"%s\": Not enough memory for buffer (%u " + "bytes)", + prog, + (unsigned int)buflen); + goto done; + } + + DEBUG_TRACE("CGI: %s", "wait for response"); + headers_len = read_message(out, conn, buf, (int)buflen, &data_len); + DEBUG_TRACE("CGI: response: %li", (signed long)headers_len); + + if (headers_len <= 0) { + + /* Could not parse the CGI response. Check if some error message on + * stderr. */ + i = pull_all(err, conn, buf, (int)buflen); + if (i > 0) { + /* CGI program explicitly sent an error */ + /* Write the error message to the internal log */ + mg_cry_internal(conn, + "Error: CGI program \"%s\" sent error " + "message: [%.*s]", + prog, + i, + buf); + /* Don't send the error message back to the client */ + mg_send_http_error(conn, + 500, + "Error: CGI program \"%s\" failed.", + prog); + } else { + /* CGI program did not explicitly send an error, but a broken + * respon header */ + mg_cry_internal(conn, + "Error: CGI program sent malformed or too big " + "(>%u bytes) HTTP headers: [%.*s]", + (unsigned)buflen, + data_len, + buf); + + mg_send_http_error(conn, + 500, + "Error: CGI program sent malformed or too big " + "(>%u bytes) HTTP headers: [%.*s]", + (unsigned)buflen, + data_len, + buf); + } + + /* in both cases, abort processing CGI */ + goto done; + } + + pbuf = buf; + buf[headers_len - 1] = '\0'; + ri.num_headers = parse_http_headers(&pbuf, ri.http_headers); + + /* Make up and send the status line */ + status_text = "OK"; + if ((status = get_header(ri.http_headers, ri.num_headers, "Status")) + != NULL) { + conn->status_code = atoi(status); + status_text = status; + while (isdigit((unsigned char)*status_text) || *status_text == ' ') { + status_text++; + } + } else if (get_header(ri.http_headers, ri.num_headers, "Location") + != NULL) { + conn->status_code = 307; + } else { + conn->status_code = 200; + } + connection_state = + get_header(ri.http_headers, ri.num_headers, "Connection"); + if (!header_has_option(connection_state, "keep-alive")) { + conn->must_close = 1; + } + + DEBUG_TRACE("CGI: response %u %s", conn->status_code, status_text); + + (void)mg_printf(conn, "HTTP/1.1 %d %s\r\n", conn->status_code, status_text); + + /* Send headers */ + for (i = 0; i < ri.num_headers; i++) { + mg_printf(conn, + "%s: %s\r\n", + ri.http_headers[i].name, + ri.http_headers[i].value); + } + mg_write(conn, "\r\n", 2); + + /* Send chunk of data that may have been read after the headers */ + mg_write(conn, buf + headers_len, (size_t)(data_len - headers_len)); + + /* Read the rest of CGI output and send to the client */ + DEBUG_TRACE("CGI: %s", "forward all data"); + send_file_data(conn, &fout, 0, INT64_MAX); + DEBUG_TRACE("CGI: %s", "all data sent"); + +done: + mg_free(blk.var); + mg_free(blk.buf); + + if (pid != (pid_t)-1) { + abort_process((void *)proc); + } + + if (fdin[0] != -1) { + close(fdin[0]); + } + if (fdout[1] != -1) { + close(fdout[1]); + } + if (fderr[1] != -1) { + close(fderr[1]); + } + + if (in != NULL) { + fclose(in); + } else if (fdin[1] != -1) { + close(fdin[1]); + } + + if (out != NULL) { + fclose(out); + } else if (fdout[0] != -1) { + close(fdout[0]); + } + + if (err != NULL) { + fclose(err); + } else if (fderr[0] != -1) { + close(fderr[0]); + } + + mg_free(buf); +} +#endif /* !NO_CGI */ + + +#if !defined(NO_FILES) +static void +mkcol(struct mg_connection *conn, const char *path) +{ + int rc, body_len; + struct de de; + char date[64]; + time_t curtime = time(NULL); + + if (conn == NULL) { + return; + } + + /* TODO (mid): Check the mg_send_http_error situations in this function + */ + + memset(&de.file, 0, sizeof(de.file)); + if (!mg_stat(conn, path, &de.file)) { + mg_cry_internal(conn, + "%s: mg_stat(%s) failed: %s", + __func__, + path, + strerror(ERRNO)); + } + + if (de.file.last_modified) { + /* TODO (mid): This check does not seem to make any sense ! */ + /* TODO (mid): Add a webdav unit test first, before changing + * anything here. */ + mg_send_http_error( + conn, 405, "Error: mkcol(%s): %s", path, strerror(ERRNO)); + return; + } + + body_len = conn->data_len - conn->request_len; + if (body_len > 0) { + mg_send_http_error( + conn, 415, "Error: mkcol(%s): %s", path, strerror(ERRNO)); + return; + } + + rc = mg_mkdir(conn, path, 0755); + + if (rc == 0) { + conn->status_code = 201; + gmt_time_string(date, sizeof(date), &curtime); + mg_printf(conn, + "HTTP/1.1 %d Created\r\n" + "Date: %s\r\n", + conn->status_code, + date); + send_static_cache_header(conn); + send_additional_header(conn); + mg_printf(conn, + "Content-Length: 0\r\n" + "Connection: %s\r\n\r\n", + suggest_connection_header(conn)); + } else { + if (errno == EEXIST) { + mg_send_http_error( + conn, 405, "Error: mkcol(%s): %s", path, strerror(ERRNO)); + } else if (errno == EACCES) { + mg_send_http_error( + conn, 403, "Error: mkcol(%s): %s", path, strerror(ERRNO)); + } else if (errno == ENOENT) { + mg_send_http_error( + conn, 409, "Error: mkcol(%s): %s", path, strerror(ERRNO)); + } else { + mg_send_http_error( + conn, 500, "fopen(%s): %s", path, strerror(ERRNO)); + } + } +} + + +static void +put_file(struct mg_connection *conn, const char *path) +{ + struct mg_file file = STRUCT_FILE_INITIALIZER; + const char *range; + int64_t r1, r2; + int rc; + char date[64]; + time_t curtime = time(NULL); + + if (conn == NULL) { + return; + } + + if (mg_stat(conn, path, &file.stat)) { + /* File already exists */ + conn->status_code = 200; + + if (file.stat.is_directory) { + /* This is an already existing directory, + * so there is nothing to do for the server. */ + rc = 0; + + } else { + /* File exists and is not a directory. */ + /* Can it be replaced? */ + +#if defined(MG_USE_OPEN_FILE) + if (file.access.membuf != NULL) { + /* This is an "in-memory" file, that can not be replaced */ + mg_send_http_error(conn, + 405, + "Error: Put not possible\nReplacing %s " + "is not supported", + path); + return; + } +#endif + + /* Check if the server may write this file */ + if (access(path, W_OK) == 0) { + /* Access granted */ + conn->status_code = 200; + rc = 1; + } else { + mg_send_http_error( + conn, + 403, + "Error: Put not possible\nReplacing %s is not allowed", + path); + return; + } + } + } else { + /* File should be created */ + conn->status_code = 201; + rc = put_dir(conn, path); + } + + if (rc == 0) { + /* put_dir returns 0 if path is a directory */ + gmt_time_string(date, sizeof(date), &curtime); + mg_printf(conn, + "HTTP/1.1 %d %s\r\n", + conn->status_code, + mg_get_response_code_text(NULL, conn->status_code)); + send_no_cache_header(conn); + send_additional_header(conn); + mg_printf(conn, + "Date: %s\r\n" + "Content-Length: 0\r\n" + "Connection: %s\r\n\r\n", + date, + suggest_connection_header(conn)); + + /* Request to create a directory has been fulfilled successfully. + * No need to put a file. */ + return; + } + + if (rc == -1) { + /* put_dir returns -1 if the path is too long */ + mg_send_http_error(conn, + 414, + "Error: Path too long\nput_dir(%s): %s", + path, + strerror(ERRNO)); + return; + } + + if (rc == -2) { + /* put_dir returns -2 if the directory can not be created */ + mg_send_http_error(conn, + 500, + "Error: Can not create directory\nput_dir(%s): %s", + path, + strerror(ERRNO)); + return; + } + + /* A file should be created or overwritten. */ + /* Currently CivetWeb does not nead read+write access. */ + if (!mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &file) + || file.access.fp == NULL) { + (void)mg_fclose(&file.access); + mg_send_http_error(conn, + 500, + "Error: Can not create file\nfopen(%s): %s", + path, + strerror(ERRNO)); + return; + } + + fclose_on_exec(&file.access, conn); + range = mg_get_header(conn, "Content-Range"); + r1 = r2 = 0; + if ((range != NULL) && parse_range_header(range, &r1, &r2) > 0) { + conn->status_code = 206; /* Partial content */ + fseeko(file.access.fp, r1, SEEK_SET); + } + + if (!forward_body_data(conn, file.access.fp, INVALID_SOCKET, NULL)) { + /* forward_body_data failed. + * The error code has already been sent to the client, + * and conn->status_code is already set. */ + (void)mg_fclose(&file.access); + return; + } + + if (mg_fclose(&file.access) != 0) { + /* fclose failed. This might have different reasons, but a likely + * one is "no space on disk", http 507. */ + conn->status_code = 507; + } + + gmt_time_string(date, sizeof(date), &curtime); + mg_printf(conn, + "HTTP/1.1 %d %s\r\n", + conn->status_code, + mg_get_response_code_text(NULL, conn->status_code)); + send_no_cache_header(conn); + send_additional_header(conn); + mg_printf(conn, + "Date: %s\r\n" + "Content-Length: 0\r\n" + "Connection: %s\r\n\r\n", + date, + suggest_connection_header(conn)); +} + + +static void +delete_file(struct mg_connection *conn, const char *path) +{ + struct de de; + memset(&de.file, 0, sizeof(de.file)); + if (!mg_stat(conn, path, &de.file)) { + /* mg_stat returns 0 if the file does not exist */ + mg_send_http_error(conn, + 404, + "Error: Cannot delete file\nFile %s not found", + path); + return; + } + +#if 0 /* Ignore if a file in memory is inside a folder */ + if (de.access.membuf != NULL) { + /* the file is cached in memory */ + mg_send_http_error( + conn, + 405, + "Error: Delete not possible\nDeleting %s is not supported", + path); + return; + } +#endif + + if (de.file.is_directory) { + if (remove_directory(conn, path)) { + /* Delete is successful: Return 204 without content. */ + mg_send_http_error(conn, 204, "%s", ""); + } else { + /* Delete is not successful: Return 500 (Server error). */ + mg_send_http_error(conn, 500, "Error: Could not delete %s", path); + } + return; + } + + /* This is an existing file (not a directory). + * Check if write permission is granted. */ + if (access(path, W_OK) != 0) { + /* File is read only */ + mg_send_http_error( + conn, + 403, + "Error: Delete not possible\nDeleting %s is not allowed", + path); + return; + } + + /* Try to delete it. */ + if (mg_remove(conn, path) == 0) { + /* Delete was successful: Return 204 without content. */ + mg_send_http_error(conn, 204, "%s", ""); + } else { + /* Delete not successful (file locked). */ + mg_send_http_error(conn, + 423, + "Error: Cannot delete file\nremove(%s): %s", + path, + strerror(ERRNO)); + } +} +#endif /* !NO_FILES */ + + +static void +send_ssi_file(struct mg_connection *, const char *, struct mg_file *, int); + + +static void +do_ssi_include(struct mg_connection *conn, + const char *ssi, + char *tag, + int include_level) +{ + char file_name[MG_BUF_LEN], path[512], *p; + struct mg_file file = STRUCT_FILE_INITIALIZER; + size_t len; + int truncated = 0; + + if (conn == NULL) { + return; + } + + /* sscanf() is safe here, since send_ssi_file() also uses buffer + * of size MG_BUF_LEN to get the tag. So strlen(tag) is + * always < MG_BUF_LEN. */ + if (sscanf(tag, " virtual=\"%511[^\"]\"", file_name) == 1) { + /* File name is relative to the webserver root */ + file_name[511] = 0; + (void)mg_snprintf(conn, + &truncated, + path, + sizeof(path), + "%s/%s", + conn->dom_ctx->config[DOCUMENT_ROOT], + file_name); + + } else if (sscanf(tag, " abspath=\"%511[^\"]\"", file_name) == 1) { + /* File name is relative to the webserver working directory + * or it is absolute system path */ + file_name[511] = 0; + (void) + mg_snprintf(conn, &truncated, path, sizeof(path), "%s", file_name); + + } else if ((sscanf(tag, " file=\"%511[^\"]\"", file_name) == 1) + || (sscanf(tag, " \"%511[^\"]\"", file_name) == 1)) { + /* File name is relative to the currect document */ + file_name[511] = 0; + (void)mg_snprintf(conn, &truncated, path, sizeof(path), "%s", ssi); + + if (!truncated) { + if ((p = strrchr(path, '/')) != NULL) { + p[1] = '\0'; + } + len = strlen(path); + (void)mg_snprintf(conn, + &truncated, + path + len, + sizeof(path) - len, + "%s", + file_name); + } + + } else { + mg_cry_internal(conn, "Bad SSI #include: [%s]", tag); + return; + } + + if (truncated) { + mg_cry_internal(conn, "SSI #include path length overflow: [%s]", tag); + return; + } + + if (!mg_fopen(conn, path, MG_FOPEN_MODE_READ, &file)) { + mg_cry_internal(conn, + "Cannot open SSI #include: [%s]: fopen(%s): %s", + tag, + path, + strerror(ERRNO)); + } else { + fclose_on_exec(&file.access, conn); + if (match_prefix(conn->dom_ctx->config[SSI_EXTENSIONS], + strlen(conn->dom_ctx->config[SSI_EXTENSIONS]), + path) + > 0) { + send_ssi_file(conn, path, &file, include_level + 1); + } else { + send_file_data(conn, &file, 0, INT64_MAX); + } + (void)mg_fclose(&file.access); /* Ignore errors for readonly files */ + } +} + + +#if !defined(NO_POPEN) +static void +do_ssi_exec(struct mg_connection *conn, char *tag) +{ + char cmd[1024] = ""; + struct mg_file file = STRUCT_FILE_INITIALIZER; + + if (sscanf(tag, " \"%1023[^\"]\"", cmd) != 1) { + mg_cry_internal(conn, "Bad SSI #exec: [%s]", tag); + } else { + cmd[1023] = 0; + if ((file.access.fp = popen(cmd, "r")) == NULL) { + mg_cry_internal(conn, + "Cannot SSI #exec: [%s]: %s", + cmd, + strerror(ERRNO)); + } else { + send_file_data(conn, &file, 0, INT64_MAX); + pclose(file.access.fp); + } + } +} +#endif /* !NO_POPEN */ + + +static int +mg_fgetc(struct mg_file *filep, int offset) +{ + (void)offset; /* unused in case MG_USE_OPEN_FILE is set */ + + if (filep == NULL) { + return EOF; + } +#if defined(MG_USE_OPEN_FILE) + if ((filep->access.membuf != NULL) && (offset >= 0) + && (((unsigned int)(offset)) < filep->stat.size)) { + return ((const unsigned char *)filep->access.membuf)[offset]; + } else /* else block below */ +#endif + if (filep->access.fp != NULL) { + return fgetc(filep->access.fp); + } else { + return EOF; + } +} + + +static void +send_ssi_file(struct mg_connection *conn, + const char *path, + struct mg_file *filep, + int include_level) +{ + char buf[MG_BUF_LEN]; + int ch, offset, len, in_tag, in_ssi_tag; + + if (include_level > 10) { + mg_cry_internal(conn, "SSI #include level is too deep (%s)", path); + return; + } + + in_tag = in_ssi_tag = len = offset = 0; + + /* Read file, byte by byte, and look for SSI include tags */ + while ((ch = mg_fgetc(filep, offset++)) != EOF) { + + if (in_tag) { + /* We are in a tag, either SSI tag or html tag */ + + if (ch == '>') { + /* Tag is closing */ + buf[len++] = '>'; + + if (in_ssi_tag) { + /* Handle SSI tag */ + buf[len] = 0; + + if ((len > 12) && !memcmp(buf + 5, "include", 7)) { + do_ssi_include(conn, path, buf + 12, include_level + 1); +#if !defined(NO_POPEN) + } else if ((len > 9) && !memcmp(buf + 5, "exec", 4)) { + do_ssi_exec(conn, buf + 9); +#endif /* !NO_POPEN */ + } else { + mg_cry_internal(conn, + "%s: unknown SSI " + "command: \"%s\"", + path, + buf); + } + len = 0; + in_ssi_tag = in_tag = 0; + + } else { + /* Not an SSI tag */ + /* Flush buffer */ + (void)mg_write(conn, buf, (size_t)len); + len = 0; + in_tag = 0; + } + + } else { + /* Tag is still open */ + buf[len++] = (char)(ch & 0xff); + + if ((len == 5) && !memcmp(buf, "12kkiTMs085cn2rjXXJ{J%qVZWthv>@B8T!44G#* zO1|acb_`oG8|z6obCfL+Sljf{HKANQ?#RFJ8ux;R%*s)(N2s%j(j8f8P}#%GWwyR` z!as|8{x4YtGMH7qhh~jU3^Driu;QkDX~IYc!;{pOH2upvxU-@=$+qa-6 z`B_I_l+o29yyXUV``*|^+@~U}Z~2Cht19?=nRim=Z~1>rWu4ze*d@wLWx@wp6X|Oo z&|KCnqFr`8uCr6BxSuQNPyR zxJe4KTczFH{K<8Vf_@`GRk|{Iir0UX;vW zSrY*f`2ksmNwn3-<3b#u=j>t+1<_Etn>s_sIg}sN6{Q!2Rz%`~N8#HHs+1JV&%dVl z9!yx-Kd*R5)e!Dm`Y>}VbsZdK*M2?tq<`t5DN3OOmifhIE3YeEGu_iuO68C}J7#JA zx!{Z}TE?hHet7KpwpxBP-+#UcOh$`qj7$%S9%-q8E_nF{DC(%}Zsl)8T$8LCQsbC1 zLDgh>*b#4|aG43bD*?Bx8a>^|&IN4qnhr)iq53}c35#iOw3VvF%Q)nRjD!)zTyWxEqDG<(m`(?IshgVxy>Bzm&9Cb~z2jf#J{Z%}7} zOl+EZdvE3;azi1=Y{Z40M-<~>jB$3f@`EI=^S+%g@a+${e0s(TM5x6M)HZ;-jqaPGAeYJe=XS$+O2CwlYhHUgf{PY&vD#~& zE{lZU0=#7@{KRZU@(f3jbEeb$u>PCwc*xC>^lj`DBa4wKIT0s$&Ww5nn3t8(Wp=X1jr#PioP#%2JlS= z?J5lctkFs^tB@$%IU`j$lCzc8OHY$Rf4vS7=aQp2*M=`cBLIHpc~lK;ITK*UJpF`! zo)a|>misb~p5BQ_}#h2H<919si3G@zPZz5x?rw=C$kSNPVBw}W4V*)?js{b(& zp}>1g=|TL+@asNZNz? z2)%?NEU_+vHB04?zkqNS{MY9&41;D|vj*a+WY=-QeW3vBjQq@psE)ZmEAO}kz<hDTj;PD9En1C=_CDMu5-B< zo;Pr_nSHHjQ19&)b3d5OBwYR$a2RZ!1)8m*|EfC4>eyTNwX+i8=^3M4w;km8X^WC+ zD8o@Rd|r-y3I!ct=nzLy>CtW4XykjOAP8@*~hNxW7`N_*0G_)AkZ44QM!% zyY@lkt&^T9)(cxCj0vp7h3w6c?)8G(<4vs^_zllf{)N|0q*Jj!Tk`LC&swiuPzn)ny1e$1UV zF4i*45%MoWLn43Uz85?#QKkiBf^%E)cc2R)ZE$l>LP#DB5f->;*(Dzhxk4iu z7;B@=VyO1OYG;M^!X_q@Hxz%>YH=_Ie(tU(jfVpOVM4U5y~6dcNSd~zV1S?rgI_dD zpiN3N2W%Js;O_RJd!CdvaG5z=jR%4@(Q3=Ff%x_hE$To~K(64pu7~819{_KJD#(=bzyl1d}$edbiP**L;+uK{vh5X}C@bS0BXJ~k( zFt!2p0taNN%4SAIqi-M#>ZUWeMi5fA{#2teEF1Vr z4P!~qK9^;$HX4b->W$agA`z6e*HJ>6&1~aAqpg3?Smdn zRd!tc${l`^!A6cny}nB~&@sw2G_Ky(n0~K*2pY(QLdNTQ0GI1`?rs4D@@P4>K#Ta8 zrpU#l`Vm^CF|qgCE~y)V4b;6gI8>nO2Ro-cgSIFXlOVNKeXmT*g*+Z*i##4kS&L>AB5?{zuL2wX#Gs{aG?#f`*(oxl zJ|#04J>6k!^b1?mOUvh3#15+Wk(dJ0eejsG77jyZ=VQlZv@OCeC`&&{AIB_!(mBWB zi=`>wFDA~$f~(H}=psevWhOSmZyKW<;!uBI$}YYJ=#vM#BI@frGpU|97cOjJ%_Jt4 z#Y+=P;!$!dM$8-wdwk_Ef}AxPsI;GdbDy8Ft+=fx)}4F6dJ5Pb;?Ohg5;=AYYlg zCjk9|uoqNF7QZ+v9q!x%y{HDiX~Z= zAVdy(z=di1QC5p!d~G~H}J>AC=}ck?0{oifM-6Ui=V700={o+rZdmCE0GMT<|L-MU^g z=eo0C7%1j&gH#(rxa%&`p#oURYA=$Rtfi@0(j3eJ<_o*e=11v3yk28I_t={1fc{hW z`$H+g(bdbqpDg8oesCC7z*j}dU46IpKki$0dGB+6z~w%3N&aZGrt#z`rz;Im{irr4 z5>XlTtaSP+=vTCDv!$sO#_X@oVz#^w48cjSOLTf+?Ui{j+qSx0IH^aVf%X&z%&c0N z^D$L2XQIscJUrbK28#uu^JbYPQqjo;mIT>qX>Kth z8ZR#qm$gp{zP7XL}a#9Zi!n^fiu{hh-p+V!1%q;!wza1?)3hIJ*4PP z_C<)-6_Wy!S{Na>_Ub&aztus->NXM;h81Uc(lXvgtOKJm4 zuYX->z4|=3$*2Q6NITOcWL^`kazLej65~e!lG$S#pqDcey%NR<# z>RxISG|j9lFaO5!$-{6*E5FCvU^Z4AosGJsY#|Q-IvCUyylwq4A13Z*tnBWHIBXZHvG4-+S?ZR zc{Kg1!xK=d9AlH)%?FiL`sxF5SMB?5JyrGd3!nMM47WCUx+%2-coEH0<2dQj_h)sI zlpowt;})6pi7tVPUdssJ@LqTMr1xgBH-L&LX1FmCcWn%)h$oDqZJ$OT5x`*{t>s+H z?9|rIB1*NDf84>35p$XEoi$K33#eGfc&F)$xeN@?nu$+<$RYds9e&4PA>-W?9_Jt5 z2YGPiDh_c~iJxBtw6D#+N{WnTE&5?k>hP?>6#UF#;InET2ZZIY z0=%vs#PLcL0xcNqWdiNt{FrG@&&wY2Oz-raj~|UKQY|Clu2?EAac0sD79n!OiT6q7 zj~ppD(}TI-+#}75mG+k$oj=lIt8!@bT2J(OiQSKqeUcw5p7NN8W82vgc0f>Q%`@nA zp7fR^?t8}BCSI4Go42JgvpfOwq=}(FiF4Q>ljLRna54g>b7BNvj*k9R`!vpJy3E_9 zD*HlNU{94HKo(LFU+nwwO(lLUHanf;gvwr?jc0Nx&6r2;N(65dwg@~uaUgnwU*g>P z?voy@fK1%xpZSDk+x7ks9b#8zO)xKP>F`2BPpmoBUJOptNl;!n_w}1oAvk98&veD^ z?R}}f@i`2F7E?EL82F1JcVWGoA8G!sU|YmmI63Du&I8bbPd%tF*clyA*A9{d|-mF1(CP51(4xol_Nh7EvF^kyYg>Kn`8FT^oFNKQ%m1|sIX^hEY2D!QtPNYo3+^z z)EN4f+etqD6nQOo$GTaXaRr*$^O_cg6{q+)ZFc58>>$q2gJCO#0Pv5_Pm2%qAI`!< z>PF(XaMBsbQFtb!+_Kk%4kD{S`tqB9Li$$htFuY`=;ZaW#z-xGflgKR7)@v&8`$<$ z=+?3gh9juk7DUNs&f@d{FhT}s8#X!Pn*5d%Lp^<8(8}PIwqR@$fJ9-ZB!t{AI^NIi-C{*8iZaCT#YsuxoPfP76TDW&+H+oTyUq(= zI!Sk=@D?ZI!g!)bVDdoMI|C!`v1G9&nDz3(B8eB)$UWQ}C`Wn$dCF+;latEl(dLgv zIB2L_ND!{|*E7+dS+3U6FoKuafi;nK98tBF+SqUs9dXDny$>Bc?w3K{9lPQIM}cSd^)@gp=Mhxy!lzn0*`n24M{eqV09zWZVAFg5={L{j6_kudzYNyZfNtJ$XMh!+3g zalfix=Zq55g5!L7qM)@SP(vwVYC@bcw60}e+aYp3$S^`w`RgF2e zvqd@RI`t=VPc0}7Y0M3s_9Ni<3wR@u!d6WUfi>|0`dwHm63?#*wyKwCjIGoRj|9-Y z4m0`fbsOkXm-sGz8X8XU6qZujAWIO2UGL?v^M{h!!sh;jGzDy(!)qkjlN7PtVASzX zTZsoq8Sa#z7YGj(98)4XZX`JiG`$(PRD&FWC6=q7#3cl&-Xk33dnB#oz>BBqU!kN{b%1a1(#_UYM?Qfj>+V_o&1N`}d z*$u;KSAe!LwL5c1AIHHvd?=Be!cr8`8|E&+jyZP!NkDpE1P@A(5(zx`8Gb8i7z_W! zk;M*p=NB(qg57fBlii_X7C=K;+vGQ1KVse`ypUXU|NcwjOOVuEFq0P<3;zLp@Jh(^ z4+aZyi$uNXpb0@Uus#xsqS>Dz=JO5*5y#4s#9_czYUDc>=x&|$_=S(AAS%LYK6sX^ zAU}k0AUN-A4nO<35y}LDtU;fu2L&5C(H0|xc!Fz*{yC<`=U2%e}IBodq`&W*HSg>iMHFF zvfU;85O-yMy~Ijsomu*C)N9{VNSmlWa%Yr~EOx}l#{hkIth zgxdg8jm)c{@0U;y^n86}xg6r!h(U3L*cXj`4EF5Uv>Xoj6Z1xQK5AXMY!vl8>3cDg z5!sxr%02X&Mc1@~(W2@0vyOK*#R7?=gcVni zV6uF6u(Mfc4=iXPad+Nr#j0MwH;w<|cI#Ko?Ud-&*Hbwnt~-l`J&O5t%c0~m{f@o!QRJ3B~Ann~UtlIG|r zy#k7Jc*=dB_7JWNDwBS$w2#H@a1q&$G~IS^n~tl+Xxhny#17;yY}5)-^L^xq2SYdz zIsiO6Uf%X?sb%0TE84{MEcG>+884_Ns}irm`~%4%rR2H7%F+RTH?c!AT~*M2&AR%? z@CQ-R#yyH&qcY2uMdI%aUbJy~h@=qa8sq(mOwPM8GJ=@DHp%3C*!354?mvCw6^>OG zfoXTn0b=e&v&GluiQ4&i0k*H_ga+{^d&h5eStF2JM8Q8{a*h1lERvrJYkr2u?&Jup zxKU8Ninj2@JD#Aw%AygtrJ7=#!Eg}tZSeMCbsyPz#v{X5AFI4sfDO7KNL{msm;TNlvE9Ogb3vXZ|Sa%dq{`}}M# zK>T&@SF|N$G%;EX^Q3g^qU%;&h^BRZ6~->WEOhc^7*1&3QWC@dE8=~u!xr^6fFa7f zDDesXtZs~PMoRDoolDZm6@sAuRbGqyD|_Q?gyJ$Mv`-LIyQJ7OmS}qwwCKPB%&sws zsGp)8xE%bA-xGJlmOu!290EX&*2$oCn~0GR>;clggrOnkqlXn8ECaTt4D4;28oWo~ zToxjLuAF13Vw$AW*6`p*^>DG^Jq?%K4T)GiFHpO4 z#iiPpu21hK6PeX1c|Tl({=1@5s}3Lx(}#f?WB&Sh%c~l!h_z0}*+SG3HR$%&ugTha z^Vg07U)~P~9~@NIRa-757&E8}`DUo6h$KG_Vtd{u*LwQ$!Bq?qLUi%!D%+f|au6GK z);v2jARcAJSzn6(e11#c|^=w;l;LLbZBB(AEe*`2Mz2{MN!_Knl8}*BgwcOh`w^DWDii$jo z;61yxkpy+&1{ivUxW-IEYFuvWAEPpSSd989>p^1QEqq2Vj#N6fzFz9XpBI$!Ea!?O zT2QJR7y7?5E(9foehf}#AmbA9`^G_RA@;^w_PuUA3Qi?rr`Cay zTIB3pa;i2v=Ju}P=T0*S`bY9RyblJ(iP?yIYU@Pq^gv!2YYm9iq_@mHS9K`#l~l%L z`efhJGeBxOuVYr@z=1c9Mg|Usi5BMLkEd~r)!MXQe+fp`h{pGX82jdV(O66vQW9st znUWJ0=p?J{x9+yN{v3!VF8s9}8@)e2a5NhnJi?4Px4TUN3erW`!@>Awa7w5_=)UT8Utw!3b8=dKJ)c)$~ct z<9akV$j+r4CdO)P#t@moxH1Wu)J;wD3jx1uat07`+KAWktn!Gs;_)h2!QXBDxH$V_ z`Q|*d?vvzSjjkH>U+Lr0fc58?uDrBa_?ei?)(q|AMeZz}>1 z4qmPh35L0g8H*-_^l!_qe1one0YjSaNfV)=!ZWLhHCK?4QaR#D3DrODA^j3{?r^>rn!DUz@)j zw=lVy^GdfH;fkDx(Gx|}L4A_DPX)geA|}pxI?ry#OiyMccR&|w+5Hc{Tg8aZNEN)>l6lfhT8Bp1%8>YFn((r#DVXWt3+|?}5kBhptG~(dj)0u7 zjKO0?bR@pSgr#Cxq3-1*YHqGM;q~goY>`74Fh98Ek5cA^bPx?wU>`AX)>gG~YKhlL zR#}a3Ua)(o>Bn)N#AS-Urt1jw1cfzS( z!r3`>p182@7@0_C!ENLR$fq(=T|g+~{Y_{Pw@Mqe3Fd~Ytnh9%yQ`DiaWgL6k2c%pJown#6 z5G)1;`}jIE2}UJ8xc=TBShV5V9rmQ#cS-=8ZM7%MoqJ0)n^@Rlg?7Ry-a`E`r^F8K z<{2Jv+Bru8r;Y^Pru#OMY#gp)AL8)KnT`WB#B~?c*++bg(n_SPX_E!iU}U@}kj28y zc_`yqPd8k(pFLNPcAv?;+rWEGHS~v=Xi_A^c;&40QWbw=&(IPm9is3a0gA=)qtzwJ z3`NthaIt^6Q@=?teBUSsl}s#@wvP7Y)w#SV*bcfbx#QQQOWSIudbo0E>tl1dLN_8d z2nyd5Zft^fqv7pzIc_}v7^d>qa>?v7VP8pjYD*`lXBwZTBey`{C z=b`hBa`H@^I#dHRsMyJ^Lm1grLsVA4N!T*G5<=uQ02(n*v-2hqK6+XfZ)mC(BEWTs z)$)(imJ?Eqc%%kc_H+h!P$JzF5qls^P*Wd5$Z}bHo!U0OY}5+@muw!`J|(IM16qGL zqrNetToH!$py)Z@VTSV?Js(P&gK%5*iZnxXbluF{gA9}3APW(=_E5O+6P5!vthr2H z5(QqFYmq?`sm_&*aEUX@cDcbl?IZVImdCUjG{MpQllD>f>L^fqeJ5-H)kq9?QgYe| zV>lVpQZ+Nc632)9kGiJ*{%Yx5FW4JoUhdr5$sIf_B^Eau_)x}_&qKY>4KfA!19*_X zrfYm&zq~rQ3dFvVlx4zi7To4){?}%B$1)MT?sVFGeJ0CL1q%@^<7$z(-HG80Vx{*L zAaiQpu6G$LP_H?OD-*k?PuZNa+^)POFHi)2h$p6)?{Up}Juu-WIL)86Be1O=@PW4#A;9uxHnHeh|W{kQKlM{3;)eWzX!M&(ES@q9(4D zo0UINQ=ZrwWVfT-1=Nz%pA_g{lErUYceOHE!|E(EtD)y7z1h*!&$L0}E*O}@%%|)1 z%il7e%+QurU_e7yo?DiMht|t`-1Pn1PZ5&{#dg8oPLMc2ONoE<^$iai-|TQA{g8s0 zID$AA4o32z2f{^9QiW~nW$nFb)h=?wIO`{nvH@SXR~X1*n}ak@Wwr%b&b8?!>lEOc z&(@raOdH5qMT@Aa(M~zjnKFAd@`UQO1sTJlA5&y=W@g4ba%9;s8s~~ti$uAg(K4FH zi=~Ob;v#1?AZ*PZejAS;yz?(nxE&eI%tA;0g`a<%cE0MF4&#Zo+wiuFRHGcponJ+F zr^9=Vs;RIuh^v9F;%ebKz6QqkW>r&p6>&2dRI`+h_U#6+5sYh)0*Vr)a7lrsg>+rm;+trkzI-f?jD0lX>nn*+md3Jea@)uj@yzZcMlLDey}iDkQ-&#)eneHH@NEw>31b z@pYsKx}6gvk>#HLk{ZE=r-d5#mv)2Y6PGc)qSe$DcijU%!nk^IL+GNo<>04zydqzP0({`y8`7LC|H94> z)eseAGaGZ*^BvbYv}f~>{I-YO$M!bPN_|WcF^dyt=b-r+64E~Vt}I2o|4fjZcsunC zz`s@bEplhIbT~$5e{8gPj`;|ya;p~-ebarW8=Jw8!$A`F6z;;e`)i*xk7H#xiCcjM z9GQ?<=kA!XZpdzatYB+6*H!3G+>e@~$(1e_gU5h=s>S&a(Ag5p!7lTHK5$vgC`Pc# za%-wbv8ru{=asy~6SE(lXBuNc^(JpCT=wtV z^X+>e*ZAozm^__cee+}-{{2=Usw-&#vFlQgCTardy{P9|fqao;&Y$ToxC}abQrW8Z z?%fuXpBZRK!J2lxh76f@NYpp!hA}#~&$pfFB&l)I4VUc1?(QMmpSNAnq6#GOSijed zC04QD6hkf@?L>#gbcge0FiEeWp_#B}^%U_GAQoX{t`9zd2a3yu=7m| zXA3O2#`GEOMcxx=2r)Tt<>KbdW!N~DcWGq&~(<^w^M zGta4fbR_M4_>!EM1H|ErHRIa0l3CtY;qJWov|iuu?q*zjpDfmv2H{1>eCLfl|KKDh zA06_P`^=c+5E}c-L%zTVR@D$K^?y~x0hZGf!w1p#p43e8OqYSXWc6JQpxqRGld|K| zZ|2zt8rhv@muS)iS|}eL{?5GX{pIp`;Ri=EL<=t(j+u(rQkvg9nlq@{3h+^~c16=L zj;Sz&Ulv!Td348$Kay|qfuyu?>NF2w?6-KY|9Sg83-T{)@i{J`Qtd_LzZXWIZ|TLW IM2!OeAGenY8~^|S literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/layers.png b/flecs-dash/etc/images/layers.png new file mode 100644 index 0000000000000000000000000000000000000000..3c0baf3b1fcf7b73a7301248d13c3b92b7940b1f GIT binary patch literal 769 zcmV+c1OEJpP)=t!w}$Q2rphh2tx<~UW71&03i%v2oORTLI`0PLKucH48z66 z#U}u%@;vqI`QP3Bz5u{E;B$VbrIb=iDW#OsbqNz3V85kt!zPXaaD-d!>Py(gg&#Y^ zc1u?mo?_wG&9T?gu;CWo>E0`>wejkrjN2{!dDz3upLc?z zp=v!bL)Cg>hN|_%3{{JW8LAc%GgK`kW~f?7%uuz6n4xMRF+=iL)gJt$XOWHag;|_VVHEMYG#Le zs%Chrr)s9>P__Q^B~&dZW&u@0%zCPZn4#(%58HJP8+eLo0aZs`F|mo~n6_mIckvZ) zf;$CN9c9JDF3tg8u+=KVV=R2%CH`G*s`g(o@#H6Go#B2PJ52G~?|X*Hl2P@tFEKI2 zTfgtcXtOl#;InSM$NG{`^`tK`v4vCJ`hbmg)%7Q&uh=Q3>S14E;sIv*bubnoU+C8Y zj|!;To0yp3rG72&q>UNwW2Rq+gHv^QVt&%EbL_T?u!S!=HVjoqAZGVIVY5|+DcT!r!Pu16$))TY7a;n~VV%AeN#H^=kh*?k75VM}DA!a>QL(F=rhM4744KWL; z8e$evHN-5WYKU1$)y~9BDW#NBN-3q3QcB+dG%-tQgaxz200000NkvXXu0mjf0%TxG literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/nav.png b/flecs-dash/etc/images/nav.png new file mode 100644 index 0000000000000000000000000000000000000000..3dea50894f1bf3f99bef5404b48a1a3ef3195ed5 GIT binary patch literal 937 zcmeAS@N?(olHy`uVBq!ia0vp^9w5xY1|&n@ZgvM!jKx9jP7LeL$-D$|0#YM9(|mmy zw18|51|~)!24;{FAY^FIWMBca85q=nGy?F!5O~yx{A(5FO z5hW46K32*3xq68y`AMmI6}bf<1q?P7RzPNMYDuC(MQ%=Bu~mhw5?F;5kPQ;nS5g2g zDap1~itr6kaLzAERWQ{v(KAr8<5EyiuqjGOvkG!?gK7uzY?U%fN(!v>^~=l4^~#O) z@{7{-4J|D#^$m>ljf`}GDs+o0^GXscbn}XpA%?)raY-#sF3Kz@$;{7F0GXSZlwVq6 ztE2?72o50bEXhnm*pycc^%l^B`XCv7Lp=k1xYzt zW_HPXZvRVPR7}+i7dn;4ei7K~G~Ko_jZMVqBP)yXXZ}CT$%m>R^vLrkeke!?XkZdq zz`&~Ez{rKhY!G{~>z%Lgu9G`=p4oL$a@ow+^H#6g74dz;(s`N}?B^`?&rmU5z`|!U zi8J8#w)3ume>#p83P%2HwekGvwRpGw)zZJ}=CxD*>@EJx_VH+LQInVmqs7Vp`X>$4 zPl|XfT%SECNPCJOWxmA_7W6G6GUUDgr{2PHtGm zzsK~G&2`3bW68*AdsWQKZ#CFB9yX9UUU+3;So`g(0&|w>oc@0GtgQIMh6x2%B)K?v z*||6b+1WTm*_k*bkIQn%9tYacCmkRnBfh}H;+ez60-r{uM;aF<$H~e5dKsCvJb&e5 zyXf57u*sQm_O{#?(pOooK4={J|K6^bI@iAcJ#OOr{C3-f!Y%&63c3~DEq#ms?rKrW l+$EA8h#qW+z~mR+!NmXZj)`i1feI+$d%F6$taD0e0svcDDscb+ literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/pause.png b/flecs-dash/etc/images/pause.png new file mode 100644 index 0000000000000000000000000000000000000000..760cc559a618b9b84157e7c9bc23dc596fb0e7c0 GIT binary patch literal 897 zcmeAS@N?(olHy`uVBq!ia0vp^2_VeD1|%QND7OGojKx9jP7LeL$-D$|0#YM9(|mmy zw18|51|~)!24;{FAY^FIWMBca85q=nGy?DdeyTSmVA(5FO z5hW46K32*3xq68y`AMmI6}bf<1q?P7RzPNMYDuC(MQ%=Bu~mhw5?F;5kPQ;nS5g2g zDap1~itr6kaLzAERWQ{v(KAr8<5EyiuqjGOvkG!?gK7uzY?U%fN(!v>^~=l4^~#O) z@{7{-4J|D#^$m>ljf`}GDs+o0^GXscbn}XpA%?)raY-#sF3Kz@$;{7F0GXSZlwVq6 ztE2?72o50bEXhnm*pycc^%l^B`XCv7Lp=k1xYp+CA)w&Uz`)3ao$+Bk)B3ONvDd#=e(L*dBmeh!{Qmv>{>Cz& z-_FF8Q~P-rgXb1mjtyVWzGhOnSf+5`n)!O}2`;xA8KUp+(Q^>WWgmu$*szBbA`lDdeyTSmVA(5FO z5hW46K32*3xq68y`AMmI6}bf<1q?P7RzPNMYDuC(MQ%=Bu~mhw5?F;5kPQ;nS5g2g zDap1~itr6kaLzAERWQ{v(KAr8<5EyiuqjGOvkG!?gK7uzY?U%fN(!v>^~=l4^~#O) z@{7{-4J|D#^$m>ljf`}GDs+o0^GXscbn}XpA%?)raY-#sF3Kz@$;{7F0GXSZlwVq6 ztE2?72o50bEXhnm*pycc^%l^B`XCv7Lp=k1xYTK&@(Ax4xG2=!p1NZHQP=h1I$F040 za2{{4E;1{Pw`0tKeaFTcD^+PEY7!s+h%o3k2> zW!8kPUVSs?o6murF7~XPOd)2o&kEY=o#cJ*zWCza7b0FZ3pg0J-TUvk_~MRPK5F{g zpZVCYo%Z+Li&gjEShr_w{gt{mZvMC5e_z*@Y8PLUDL6be>eAz=wQlmfo39^!xS=rE z;G4@DhIyZ5g&z5CzWK*3_vJ*xZ#QpG)N?rZXGYYe^zMnF-3)#l*W1pxhWRq3)$dN_@+da%QEj?bnH4r*1ou z<-}0`boYs>ds$o4W+|;!Wh^qcxgrvImh-{g1!|k3L>0=Lf5b=nazD8Hz${5QTZ_p; z(8cZA6qW*|9kcBhDP||_h+o$$Mhr}o(5)#*p<4X`wSSE448fdE#zia zIIy4f#P@>xOWr?kzJ1H7;jl;Ch35yGECM|JHg3*`^?d*m*ft>peN*@J(@`T7nw8;gKbx*FZn?&fVb`Qg_sA{$V# zg-5TbY{n$!MXuh{Dgu0tG6pVAJupLdR+&TO#Yw7iB4@1@oXL4aw1bK)Pgg&ebxsLQ0LL!>WdHyG literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/save.png b/flecs-dash/etc/images/save.png new file mode 100644 index 0000000000000000000000000000000000000000..0eb5680e1d61f8481b914277bba095cf196b27bb GIT binary patch literal 351 zcmeAS@N?(olHy`uVBq!ia0vp^9w5xY1|&n@Zgyv2U{v#TaSW+oe0xJsfGJU+?V$qC zAq9?Ns}r9%o9EQezjIfSqnPWQy2T0g=L`1D?VPmhcX;0S+H||T=M#758CfU+!J_LG zS`4Aej47fGt0ppR;&Q0-_~)QpwMq=iz3Rab$-2Nwr9r2Gfr&$*;S(b(kOVVf#DXyG zsKsmTZfCf^ohJEWUGD!MZ})yX!B%qhnQdMD%F@UNt6Z}OY|d3F3|U(5Zn(4Wvba;! z%~Mja;}!YC01x>uNXD*`IY{isWvOo^`^(x;@$}Wx?dby16L}mTz0PBYE~i z-(6RiG3U+5{?6lYZ72VvzvY+L-Lxy;a_iUmmdKI;Vst0IbK2C;$Ke literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/stop.png b/flecs-dash/etc/images/stop.png new file mode 100644 index 0000000000000000000000000000000000000000..5a988dd44e79867c2ee765d9d16b536ea6d19632 GIT binary patch literal 867 zcmeAS@N?(olHy`uVBq!ia0vp^2_VeD1|%QND7OGojKx9jP7LeL$-D$|0#YM9(|mmy zw18|51|~)!24;{FAY^FIWMBca85q=nGy?DdeyTSmVA(5FO z5hW46K32*3xq68y`AMmI6}bf<1q?P7RzPNMYDuC(MQ%=Bu~mhw5?F;5kPQ;nS5g2g zDap1~itr6kaLzAERWQ{v(KAr8<5EyiuqjGOvkG!?gK7uzY?U%fN(!v>^~=l4^~#O) z@{7{-4J|D#^$m>ljf`}GDs+o0^GXscbn}XpA%?)raY-#sF3Kz@$;{7F0GXSZlwVq6 ztE2?72o50bEXhnm*pycc^%l^B`XCv7Lp=k1xY_nlGe;6vCSwmn})GDZX=G%iAcjpn{7hE5b-*+Bf6i6)640E zlgl|Q(N#!gXo@IClS^``h*R%Yz4gA&^Ld`%@BjOK|KIQL`~N(j&y&mWq^ZLYFaQA5 zUFlRGd88{I6(#xGZ>EkW4X5Js@&6g-i__0lxm9}@3H$BX>|yS=OacKwNzIk& z;F}1VIp-0z*$*yQC@~jtwp!<5P}H2t7j50>_12Al?sEjg%(VI5-Oe`~HP*&oEJd2? zUJTX2z~O^gPkLY(MFCx2suUYC!0N`nIJx9@xlvJv}p1HPU-HGEzpA)$XnFHOt$& z>OPOpmyG4n3h@ zE9*kdjdbJ9VIQvgo7TXlsLBL%rx~J^zeXP;B=vCZ!{f1$I$)Eyd8xdm;f-HeZg{?t$%`_Yw9Beg+Iz;$g zhCXIzM?}X#Mt>f8>2M_VA>*XkA@I?*e)S+WV$9(V9t!lRXI>4=B>5ds&#~#(5HA${ zTU*xBH@20Dp5~n;AGy#omcL&j5R_({&HvQw{V{4kZk8*_!ARZwu39xVHU@Z){f^S1 zOzz1sLI07G#jYJo$4<_h&qp5ET(5K#wEMl!ueI@}v|xUsBY*@vQSp^jvS`0vMg0yH2mAHJa-v z+7yZo1! zT$@Hd?BwckK7t#sUB7;Ps&J`Tzo?lU<=F`r)k;NN2EIjR8*@|C1@nmgM$s^|325mLQv#rZO-i9SLZ=)?a_df-z zb^b!EwW(W^Zdd>Zo90urYL-JecOE_CG7!+?wWXXObq0q}1+CN|RDmmTgesttL0~HT x63*ixW^438zM}j%;c8k;a*S4#Rw7PiRT(E`HoR&6sZjBYb#?ZnRy&4f{0F$WV#5Fc literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/table.png b/flecs-dash/etc/images/table.png new file mode 100644 index 0000000000000000000000000000000000000000..406e041eea75dec9317fa612c4582b18a98e7f17 GIT binary patch literal 1201 zcmeAS@N?(olHy`uVBq!ia0vp^AwV3!!3HGTe+69!QjEnx?oJHr&dIz4$)rYjruq6Z zXaU(A3`~qd49p-UK*-RZ$-n|;Gcc$DX$A)71&j#U1x#?+kOjl#h zD=EpgRf_NpP;kyKN>wn`Gto0pvg1-vP_QXVNwW%aaf50H@@$ndN=gc>^!3Zj%k|2Q z_413-^$jg8E%gnI^o@*kfhu&1EAvVcD|GXUl_7?}%yCIAPA@U0iuodr630H;HaUD? zoRHh(kn}yYciVNm@il)$0*;>!o?!b(5PTJ&r{&dp3VNt-+%GA z{M+AX=es?h-`xF|_fGF@TKTLD4uu8=rpU&tl?TtJ6^9qkTVWrvfAPNM`@G-!ut)#u z{Pi$v>#v2!k8b18Ix*X8Z&3ZZxPQxhFY7Dr5qb4mwMXqm{F#2PwbPrd?fyBgVApMy zUhCMqH!xoRip0ES$D>O0qXZILvmVv@{<$;j%nhFfHGjTu4NAYia;@mE9I@nN&j-`E z{9h+=Z}~Ip@-LRAQ0|iT`SE8aIc&(PZO>cqO8i3ki!&RxI{p5B?2H0KhJvItL&+Ka zC5*f($;=IXKU+-}G^XS*Trk`}fz4z>4=;n&Gx19eY?C%JIvoGwp$zmF*mE2T1*$A* z&z(_%<>Sm7mrrl zuKKa0ZhcPwmOk$N+p6vc{Jo|B^3eL=x8EoBtzB~|l3ROAi0Q}Wa&jv+2XUX+v-fhE z@MfRvbrA63nR! TzxK(_1Qh_Du6{1-oD!MDD1 literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/tree.png b/flecs-dash/etc/images/tree.png new file mode 100644 index 0000000000000000000000000000000000000000..bb6367a73fbb548afb7b4024dc4419aca9908347 GIT binary patch literal 120 zcmeAS@N?(olHy`uVBq!ia0vp^2_Vb}Bp6OT_L>T$m`Z~Df*BafCZDwc@(ev)978G? z&mK1vWMJT7GL(66UzKkkvs9J)whSqOlLt~>*%#W(C<=LRXdv~&-+D$W`>#zM8BC>@ Qgh57ny85}Sb4q9e0NeW_Z~y=R literal 0 HcmV?d00001 diff --git a/flecs-dash/etc/images/usage.png b/flecs-dash/etc/images/usage.png new file mode 100644 index 0000000000000000000000000000000000000000..1fbb26e05d613a2f9279e33b2d359f6b5d2686f8 GIT binary patch literal 1161 zcmeAS@N?(olHy`uVBq!ia0vp^2_VeD3?#3*wSy!M2l#}z0_p!l92{)Xoe%VeV@Z%- zFoS?|@#@9-HaykqZ~wn+AyIxm+x_?V`7G(d2FEwcaI}A(+`s?&_U6OOHT=CFzgH0H zKJ5_xT<3gr{cMx?*Sl4crys1D&d0#OY~tzS7*fIb_WJdrM?NAf57gMrg&dvYHl2Ks zGx_uH{a55yS}kobnf3MF$GhiCeCIXq-fdmlnWELZ+Q)4AaeptdE`F6x?MXUIgW2j@ zBG-N33g4p@D*PjM>lW90TncY@F}^64(-v9B5crEVwpUG3)?wSN3m0ETg>Wb6zgE~5 z)!M@)aF*>+;k*+Tj9WH!9QF)0bojDR&pzP~!!=nAquEzD6Rh}E-zqkLabu0?WjAZ~ znIa@4`pa}PFS~&3;+RGE4>)d7+Ph|DBg0m)+Fcz}7PWu9a*TH~&)#Pp6E?pvGZA?7 zvo&vhKF8O0nF+Ne0$PE~Z!d2)P~P=rpTNu8i%ttWoq4$_!s%dmzaHrIDR#F`gz>T@}rmv(*X&$2}`?#ptIau)3_wk(2^4S@gG5#P8MDZ~JvU|E`~I@Y+0H=lRqo@fSvRv%O4z zNZq={acyP5g?o-SjTZjX72p=`N^3tV>9n)w?-}RLNX45bQ|9x0%yc@KbK-xFuZ#4B z)Q!$6$p=?oU(>ANJzMXal;A3}qXwNC*;O$9pJX=$EYC&&s>YI<{`~XJ^~M_PBO!B2$L>zTL{R8QavRJmKqE za(TbS)D?+IPLcbL-sr15@}NYre`}$@`CDl`?NUkEJS%c;we{WV@@n(UDEg+~v&F;m z!gbC4Mj + + Flecs Dash + + + + + + + +
+ + + +
+ + + + + + + + + + + + diff --git a/flecs-dash/etc/js/app.js b/flecs-dash/etc/js/app.js new file mode 100644 index 0000000..848c46d --- /dev/null +++ b/flecs-dash/etc/js/app.js @@ -0,0 +1,136 @@ + +Vue.config.devtools = true; + +var app = new Vue({ + el: '#app', + methods: { + // Request + request(method, url, onmsg, onloadend) { + const Http = new XMLHttpRequest(); + + Http.open(method, "http://" + url); + if (onloadend) { + Http.onloadend = function() { onloadend(Http); }; + } + Http.send(); + Http.onreadystatechange = (e)=>{ + if (Http.readyState == 4) { + if (Http.responseText && Http.responseText.length) { + if (onmsg) { + onmsg(JSON.parse(Http.responseText)); + } + } + } + } + }, + + // Request to own server + request_self(method, url, onmsg, onloadend) { + this.request(method, this.host + "/" + url, onmsg, onloadend); + }, + + set_host(host) { + this.host = host; + this.init(); + }, + + get(url, onmsg, onloadend) { + this.request_self("GET", url, onmsg, onloadend); + }, + + put(url, onmsg, onloadend) { + this.request_self("PUT", url, onmsg, onloadend); + }, + + post(url, onmsg, onloadend) { + this.request_self("POST", url, onmsg, onloadend); + }, + + delete(url, onmsg, onloadend) { + this.request_self("DELETE", url, onmsg, onloadend); + }, + + path_to_url(path) { + return path.replace(/\./g, "/"); + }, + + // Initialize application, send initial request for id of self + init() { + this.get("this", (msg) => { + this.server_id = msg.server_id; + this.get("scope/" + this.path_to_url(this.server_id) + "?include=flecs.dash.App", (msg) => { + this.apps = msg; + }); + }); + }, + + // Anything that needs to appen periodically + refresh() { }, + + // App select event selects a different application + app_select(event) { + this.app_load(event.name); + }, + + import(url) { + var app = document.getElementById(url); + if (!app) { + app = document.createElement("script"); + app.setAttribute("id", url); + app.setAttribute("src", url); + document.body.appendChild(app); + + return false + } else { + return true; + } + }, + + component_loaded(id) { + return Vue.options.components[id] != undefined; + }, + + // Load app resources + app_load(app_id) { + if (this.import("apps/" + app_id + "/" + app_id + ".js")) { + this.app_loaded(app_id); + } + }, + + // App is loaded + app_loaded(app_id, dependencies) { + var dependencies_resolved = true; + + // Load dependent components if any + if (dependencies) { + dependencies.forEach(d => { + if (!this.component_loaded(d.name)) { + app.import(d.url); + dependencies_resolved = false; + } + }); + } + + // If all dependencies are resolved, just load the app + if (dependencies_resolved) { + this.app = app_id; + } else { + // If not all dependencies are loaded, try again in a little bit + window.setTimeout(function() { + this.app_loaded(app_id, dependencies); + }.bind(this), 32); + } + } + }, + data: { + host: window.location.host, + app: "", + apps: [], + server_id: "" + } +}); + +window.onload = function() { + app.init(); + window.setInterval(app.refresh, 1000); +} diff --git a/flecs-dash/etc/js/appcontent.js b/flecs-dash/etc/js/appcontent.js new file mode 100644 index 0000000..b132394 --- /dev/null +++ b/flecs-dash/etc/js/appcontent.js @@ -0,0 +1,18 @@ +Vue.component('appcontent', { + props: ['world', 'app'], + render: function(h) { + if (!this.app || this.app === "") { + return h('div'); + } else { + return h('div', { + attrs: {class: "content"} + }, [ + h('app-' + this.app, { + props: { + world: this.world + } + }) + ]); + } + } +}); diff --git a/flecs-dash/etc/js/perf_summary.js b/flecs-dash/etc/js/perf_summary.js new file mode 100644 index 0000000..76ab283 --- /dev/null +++ b/flecs-dash/etc/js/perf_summary.js @@ -0,0 +1,182 @@ + +Vue.component('perf-fps', { + props: ['data'], + data: function() { + return { + last_tick: 0, + last_fps: 0, + last_update: 0, + last_result: 0 + } + }, + computed: { + fps() { + if (!this.data) { + return 0; + } + + var d = new Date(); + var t = d.getTime(); + + if (t - this.last_update < 1000) { + return this.last_result; + } + + this.last_update = t; + + const fps = this.data.data["flecs.dash.monitor.Fps"]; + const tick = this.data.data["flecs.dash.monitor.Tick"]; + + let result = (fps.count - this.last_fps) / (tick.count - this.last_tick); + + this.last_fps = fps.count; + this.last_tick = tick.count; + + if (result < 0) { + result = 0; + } + + if (result > 1000000) { + this.last_result = (result / 1000000).toFixed(2) + "M"; + } else + if (result > 1000) { + this.last_result = (result / 1000).toFixed(2) + "K"; + } else if (result > 100) { + this.last_result = result.toFixed(0); + } else { + this.last_result = result.toFixed(1); + } + + return this.last_result; + }, + css() { + if (!this.data) { + return ""; + } + + const fps = this.data.data["flecs.dash.monitor.Fps"]; + if (this.fps >= fps.target * 0.9) { + return "perf-fps-ok"; + } + } + }, + template: ` +
+
+ {{ fps }} + FPS +
+
+ ` +}); + +Vue.component('perf-load', { + props: ['data'], + data: function() { + return { + last_total: 0, + last_frame: 0 + } + }, + computed: { + load() { + if (!this.data) { + return 100; + } + + const load = this.data.data["flecs.dash.monitor.Load"]; + + let result = (load.frame_time_count - this.last_frame) / (load.total_time_count - this.last_total); + this.last_frame = load.frame_time_count; + this.last_total = load.total_time_count; + + if (result < 0) { + result = 0; + } + + if (!result) { + result = 1; + } + + return (result * 100); + }, + css() { + return ""; + } + }, + template: ` +
+ + + + + + + + + + Load +
+ ` +}); + +Vue.component('perf-clock', { + props: ['data'], + methods: { + digit(num) { + if (num < 10) { + return "0" + num; + } else { + return num; + } + } + }, + computed: { + clock() { + if (!this.data) { + return "00:00:00.00"; + } + + const clock = this.data.data["flecs.dash.monitor.WorldClock"]; + + let hours = Math.floor(clock.world_time / 3600); + let minutes = Math.floor((clock.world_time - hours * 3600) / 60); + let seconds = Math.floor(clock.world_time - hours * 3600 - minutes * 60); + let remainder = Math.floor((clock.world_time - Math.floor(clock.world_time)) * 10); + + return this.digit(hours) + ":" + this.digit(minutes) + ":" + + this.digit(seconds) + "." + remainder; + }, + css() { + if (!this.data) { + return ""; + } + + const clock = this.data.data["flecs.dash.monitor.WorldClock"]; + if (clock.world_time != 0) { + return "perf-clock-active"; + } else { + return ""; + } + } + }, + template: ` +
+ {{ clock }} + +
+ ` +}); + +Vue.component('perf-summary', { + props: ['data'], + template: ` +
+ +
+ + +
+
+ ` +}); diff --git a/flecs-dash/etc/js/periodic_request.js b/flecs-dash/etc/js/periodic_request.js new file mode 100644 index 0000000..c6011cc --- /dev/null +++ b/flecs-dash/etc/js/periodic_request.js @@ -0,0 +1,36 @@ + +class PeriodicRequest { + constructor(interval, callback, err_callback) { + this.error = false; + this.timer = undefined; + this.result = undefined; + this.interval = interval; + this.callback = callback; + this.err_callback = err_callback; + } + + request(url) { + app.get(url, (msg) => { + this.result = msg; + this.error = false; + this.callback(msg); + }, (Http) => { + if (!Http.status || Http.status >= 400) { + this.err_callback(Http.status); + this.error = true; + } + }); + } + + stopRequesting() { + this.result = undefined; + clearInterval(this.timer); + } + + startRequesting(url) { + this.stopRequesting(); + this.timer = window.setInterval(function() { + this.request(url); + }.bind(this), this.interval); + } +} diff --git a/flecs-dash/etc/js/play_controls.js b/flecs-dash/etc/js/play_controls.js new file mode 100644 index 0000000..3924eea --- /dev/null +++ b/flecs-dash/etc/js/play_controls.js @@ -0,0 +1,69 @@ + +Vue.component('play-button', { + props: ["state", "icon"], + methods: { + clicked: function() { + this.$emit('click', {event: this.icon}); + }, + css() { + let result = "play-button"; + if (this.state == this.icon) { + result += " player-active"; + } + return result; + } + }, + template: ` +
+ +
+ ` +}); + +Vue.component('play-controls', { + mounted: function() { + this.request.startRequesting("entity/flecs/core/World"); + }, + beforeDestroy: function() { + this.stopRequesting(); + }, + data: function() { + return { + state: undefined, + request: new PeriodicRequest(100, this.on_recv_world, this.on_recv_err), + data: undefined + } + }, + methods: { + play: function(e) { + this.state = e.event; + app.put("player/" + e.event, (msg) => { }); + }, + on_recv_world(data) { + this.data = data; + if (!this.state) { + const state = this.data.data["flecs.player.Player"]; + if (state.state == "EcsPlayerPlay") { + this.state = "play"; + } else if (state.state == "EcsPlayerStop") { + this.state = "stop"; + } else if (state.state == "EcsPlayerPause") { + this.state = "pause"; + } + } + }, + on_recv_err() { + this.state = undefined; + } + }, + template: ` +
+
+ + + +
+ +
+ ` + }); diff --git a/flecs-dash/etc/js/sidebar-button.js b/flecs-dash/etc/js/sidebar-button.js new file mode 100644 index 0000000..d5ee4ca --- /dev/null +++ b/flecs-dash/etc/js/sidebar-button.js @@ -0,0 +1,46 @@ +Vue.component('sidebar-button', { + props: { + app: String, + icon: String, + active_app: String + }, + data: function() { + return { + hover: false + } + }, + methods: { + selector_css() { + let result = "sidebar-selector"; + if (this.app == this.active_app) { + result += " sidebar-selector-active"; + } else if (this.hover) { + result += " sidebar-selector-hover"; + } + return result; + }, + button_css() { + return "sidebar-button"; + }, + select_app: function() { + this.$emit('select-app', {name: this.app}); + }, + set_hover(hover) { + this.hover = hover; + } + }, + template: ` +
+
+
+ +
+ + +
+
+ ` +}); diff --git a/flecs-dash/etc/js/sidebar.js b/flecs-dash/etc/js/sidebar.js new file mode 100644 index 0000000..707d2e5 --- /dev/null +++ b/flecs-dash/etc/js/sidebar.js @@ -0,0 +1,59 @@ +Vue.component('sidebar', { + props: { + app: String, + apps: Array + }, + methods: { + select_app(event) { + this.$emit("app-select", event); + } + }, + computed: { + app_names: function() { + let ids = []; + + if (!this.apps) { + return; + } + + this.apps.forEach((table) => { + if (table.data && table.data.Name) { + table.data.Name.forEach((app) => { + ids.push(app.value); + }); + } + }); + + return ids; + }, + app_icons: function() { + let ids = []; + + if (!this.apps) { + return; + } + + this.apps.forEach((table) => { + if (table.data && table.data["flecs.dash.App"]) { + table.data["flecs.dash.App"].forEach((app) => { + ids.push(app.icon); + }); + } + }); + + return ids; + } + }, + template: ` +
+ + +
+ ` +}); + \ No newline at end of file diff --git a/flecs-dash/etc/js/vue.js b/flecs-dash/etc/js/vue.js new file mode 100644 index 0000000..41094e0 --- /dev/null +++ b/flecs-dash/etc/js/vue.js @@ -0,0 +1,6 @@ +/*! + * Vue.js v2.6.12 + * (c) 2014-2020 Evan You + * Released under the MIT License. + */ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e=e||self).Vue=t()}(this,function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n0,Z=J&&J.indexOf("edge/")>0,G=(J&&J.indexOf("android"),J&&/iphone|ipad|ipod|ios/.test(J)||"ios"===K),X=(J&&/chrome\/\d+/.test(J),J&&/phantomjs/.test(J),J&&J.match(/firefox\/(\d+)/)),Y={}.watch,Q=!1;if(z)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===B&&(B=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),B},ne=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=he(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=he(f.text+u):""!==u&&s.push(he(u)):st(u)&&st(f)?s[l]=he(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c;if(Array.isArray(e)||"string"==typeof e)for(r=new Array(e.length),i=0,a=e.length;idocument.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;onon&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},fn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},fn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},fn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},fn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&$e(!1);var o=function(o){i.push(o);var a=Me(o,t,n,e);xe(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);$e(!0)}(e,t.props),t.methods&&function(e,t){e.$options.props;for(var n in t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props,i=(e.$options.methods,n.length);for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=De($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;xe(t,"$attrs",o&&o.attrs||e,null,!0),xe(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&($e(!1),Object.keys(t).forEach(function(n){xe(e,n,t[n])}),$e(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=ke,e.prototype.$delete=Ae,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate)try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;iparseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:De,defineReactive:xe},e.set=ke,e.delete=Ae,e.nextTick=Ye,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=De(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var En=p("style,class"),Nn=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&Nn(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(q&&!W&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=q?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML=""+o+"";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=z&&!W,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ei(e){Ti(function(){Ti(e)})}function Ni(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;ov?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o-1,a.selected!==o&&(a.selected=o);else if(N(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!N(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var o in i)t[b(o)]=i[o];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=z?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=ve),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&z?Yn(e):void 0,t)},z&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo,go={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},_o=function(e){return(yo=yo||document.createElement("div")).innerHTML=e,yo.textContent},bo=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),$o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),wo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Co=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,xo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ko="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ao="((?:"+ko+"\\:)?"+ko+")",Oo=new RegExp("^<"+Ao),So=/^\s*(\/?)>/,To=new RegExp("^<\\/"+Ao+"[^>]*>"),Eo=/^]+>/i,No=/^",""":'"',"&":"&"," ":"\n"," ":"\t","'":"'"},Io=/&(?:lt|gt|quot|amp|#39);/g,Fo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Po=p("pre,textarea",!0),Ro=function(e,t){return e&&Po(e)&&"\n"===t[0]};function Ho(e,t){var n=t?Fo:Io;return e.replace(n,function(e){return Mo[e]})}var Bo,Uo,zo,Vo,Ko,Jo,qo,Wo,Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/\s+/g,sa=g(_o),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Bo=t.warn||Sr,Jo=t.isPreTag||T,qo=t.mustUseProp||T,Wo=t.getTagNamespace||T;t.isReservedTag;zo=Tr(t.modules,"transformNode"),Vo=Tr(t.modules,"preTransformNode"),Ko=Tr(t.modules,"postTransformNode"),Uo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Jo(e.tag)&&(c=!1);for(var f=0;f]*>)","i")),p=e.replace(f,function(e,n,r){return u=r.length,Do(l)||"noscript"===l||(n=n.replace(//g,"$1").replace(//g,"$1")),Ro(l,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-p.length,e=p,A(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(No.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(jo.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(Eo);if(m){C(m[0].length);continue}var y=e.match(To);if(y){var g=c;C(y[0].length),A(y[1],g,c);continue}var _=x();if(_){k(_),Ro(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(To.test($)||Oo.test($)||No.test($)||jo.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(Oo);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(So))&&(r=e.match(xo)||e.match(Co));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function k(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&wo(n)&&A(r),s(n)&&r===n&&A(n));for(var u=a(n)||!!c,l=e.attrs.length,f=new Array(l),p=0;p=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}A()}(e,{warn:Bo,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||Wo(e);q&&"svg"===p&&(o=function(e){for(var t=[],n=0;nc&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Er(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Er(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Er(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Er(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:bo,mustUseProp:jn,canBeLeftOpenTag:$o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ea={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Na=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Na("$event.target !== $event.currentTarget"),ctrl:Na("!$event.ctrlKey"),shift:Na("!$event.shiftKey"),alt:Na("!$event.altKey"),meta:Na("!$event.metaKey"),left:Na("'button' in $event && $event.button !== 0"),middle:Na("'button' in $event && $event.button !== 1"),right:Na("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(ja[s])o+=ja[s],Ta[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=Na(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+"($event)":n?"return ("+e.value+")($event)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Ea[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r':'
',ts.innerHTML.indexOf(" ")>0}var os=!!z&&is(!1),as=!!z&&is(!0),ss=g(function(e){var t=Yn(e);return t&&t.innerHTML}),cs=wn.prototype.$mount;return wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ss(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=rs(r,{outputSourceRange:!1,shouldDecodeNewlines:os,shouldDecodeNewlinesForHref:as,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return cs.call(this,e,t)},wn.compile=rs,wn}); \ No newline at end of file