diff --git a/README.md b/README.md index 26fea59..07fa2ea 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,49 @@ -# OpenAirProject AirQuality / Dust Meter +# OpenAirProject AirQuality / Dust / CO2 / Distance - Meter + GPIO and OLED Display + +The current implementation of this code contains support for additional +hardware like: + +- CO2 sensor: MH-Z19 (can be calibrated via + + http:///trigger?func=calibrate + +- OLED display: SSD 1306 + +- Ultrasonic distance sensor: HC SR04 + +- GPIO: 4 ports in with counter via + + http:///status + +- GPIO 4 ports out with trigger via + + http:///trigger?delay=<0|ms>&gpio=<0-3>&value=<0|1> + +Further these changes and additions have been made: + +- FIX WIFI instability + +- Add Device ID to DHCP-Client-Hostname + +- Show collected values in realtime on web frontend + +- Add disable / enable single hardware components via web frontend + +- Add configurable offsets for humidity, temperature and altitude via web frontend + +- Add HTTP-GET publisher with basic auth + +- Some Pinouts have been changed: + +- - Button is now on Pin 0 (button on ESP32 board), low active (configurable) + +- - RGB LED has been reduced to channel blue on Pin 2 (LED on ESP32 board, configurable) + +- - Pins for heater and fan have been set to unused (-1) by default + +- - No need for RTS/CTS pin assignment on RS232 ports + +## The following description is outdated ## ## Features diff --git a/components/oap-aws/awsiot.c b/components/oap-aws/awsiot.c index ff100ff..8c2fd74 100644 --- a/components/oap-aws/awsiot.c +++ b/components/oap-aws/awsiot.c @@ -36,6 +36,7 @@ #include "oap_common.h" #include "oap_debug.h" #include "oap_publisher.h" +#include "oap_storage.h" #include "bootwifi.h" static const char *TAG = "awsiot"; @@ -102,9 +103,9 @@ static esp_err_t awsiot_rest_post(oap_measurement_t* meas, oap_sensor_config_t * if (meas->env) { cJSON* weather = cJSON_CreateObject(); cJSON_AddItemToObject(results, "weather", weather); - cJSON_AddNumberToObject(weather, "temp", meas->env->temp); - cJSON_AddNumberToObject(weather, "pressure", meas->env->pressure); - cJSON_AddNumberToObject(weather, "humidity", meas->env->humidity); + cJSON_AddNumberToObject(weather, "temp", meas->env->bmx280.temp); + cJSON_AddNumberToObject(weather, "pressure", meas->env->bmx280.pressure); + cJSON_AddNumberToObject(weather, "humidity", meas->env->bmx280.humidity); cJSON_AddNumberToObject(weather, "sensor", meas->env->sensor_idx); } else { cJSON_AddNullToObject(results, "weather"); @@ -113,9 +114,9 @@ static esp_err_t awsiot_rest_post(oap_measurement_t* meas, oap_sensor_config_t * if (meas->env_int) { cJSON* internal = cJSON_CreateObject(); cJSON_AddItemToObject(results, "internal", internal); - cJSON_AddNumberToObject(internal, "temp", meas->env_int->temp); - cJSON_AddNumberToObject(internal, "pressure", meas->env_int->pressure); - cJSON_AddNumberToObject(internal, "humidity", meas->env_int->humidity); + cJSON_AddNumberToObject(internal, "temp", meas->env_int->bmx280.temp); + cJSON_AddNumberToObject(internal, "pressure", meas->env_int->bmx280.pressure); + cJSON_AddNumberToObject(internal, "humidity", meas->env_int->bmx280.humidity); cJSON_AddNumberToObject(internal, "sensor", meas->env_int->sensor_idx); } else { cJSON_AddNullToObject(results, "internal"); @@ -132,13 +133,6 @@ static esp_err_t awsiot_rest_post(oap_measurement_t* meas, oap_sensor_config_t * return res; } -static void set_config_str_field(char** field, char* value) { - if (*field) { - free(*field); - } - *field = str_dup(value); -} - static esp_err_t awsiot_configure(cJSON* awsiot) { awsiot_config.configured = 0; diff --git a/components/oap-common/default_config.json b/components/oap-common/default_config.json index d123a75..47f51cd 100644 --- a/components/oap-common/default_config.json +++ b/components/oap-common/default_config.json @@ -4,7 +4,8 @@ "password": "", "ip": "", "gw": "", - "netmask": "" + "netmask": "", + "sensorId": "" }, "thingspeak": { "enabled": 0, @@ -20,15 +21,28 @@ }, "sensor" : { "config" : { - "indoor" : 0, + "pms_enabled" : 0, + "bmx280_enabled": 0, + "mhz19_enabled" : 0, + "hcsr04_enabled": 0, + "ssd1306_enabled": 0, + "gpio_enabled" : 1, + "indoor" : 1, "led" : 1, - "fan" : 1, - "heater" : 1, + "fan" : 0, + "heater" : 0, "measTime" : 60, "warmUpTime": 30, "measInterval": 300, "test" : 0, - "measStrategy": 0 + "measStrategy" : 0, + "altitude" : 573, + "tempOffset" : 0, + "humidityOffset" : 0 } + }, + "http_get_publisher": { + "enabled": 0, + "url": "https:///pushvals.cgi" } -} \ No newline at end of file +} diff --git a/components/oap-common/include/oap_common.h b/components/oap-common/include/oap_common.h index 1728714..b7d186e 100644 --- a/components/oap-common/include/oap_common.h +++ b/components/oap-common/include/oap_common.h @@ -34,6 +34,8 @@ #include "esp_log.h" #include "freertos/FreeRTOS.h" +#include "esp_request.h" + //to silence eclipse errors typedef unsigned short uint16_t; @@ -47,6 +49,14 @@ void oap_reboot(char* cause); long oap_epoch_sec(); long oap_epoch_sec_valid(); +typedef struct { + double *data; + size_t size; + unsigned int lastpos; + double sum; +} sma_data_t; + + //from esp-arduino /** @@ -67,5 +77,9 @@ uint32_t micros(); uint32_t millis(); void delay(uint32_t); void delayMicroseconds(uint32_t us); - +void set_gpio(uint8_t gpio, uint8_t enabled); +void configure_gpio(uint8_t gpio); +void req_set_user_agent(request_t* req); +double sma_generator (sma_data_t *sma, double value); +int64_t get_time_millis(); #endif /* MAIN_COMMON_COMMON_H_ */ diff --git a/components/oap-common/include/oap_data.h b/components/oap-common/include/oap_data.h index 643b4cb..7a43b12 100644 --- a/components/oap-common/include/oap_data.h +++ b/components/oap-common/include/oap_data.h @@ -26,11 +26,19 @@ #include "oap_data_pm.h" #include "oap_data_env.h" +// FIXME this stuff has to be generalized typedef struct { pm_data_t* pm; pm_data_t* pm_aux; env_data_t* env; env_data_t* env_int; + env_data_t* co2; + env_data_t* distance1; + env_data_t* distance2; + env_data_t* gpio1; + env_data_t* gpio2; + env_data_t* gpio3; + env_data_t* gpio4; long int local_time; } oap_measurement_t; @@ -45,7 +53,23 @@ typedef struct { int meas_interval; int meas_strategy; //interval, continuos, etc int test; + int altitude; + int tempOffset; + int humidityOffset; + int pms_enabled; + int hcsr04_enabled; + int bmx280_enabled; + int gpio_enabled; + int ssd1306_enabled; + int mhz19_enabled; + int gpio_udp_enabled; } oap_sensor_config_t; +typedef struct { + env_data_t env_data; + long timestamp; +} env_data_record_t; + +extern env_data_record_t last_env_data[]; #endif /* COMPONENTS_OAP_COMMON_INCLUDE_OAP_DATA_H_ */ diff --git a/components/oap-common/include/oap_data_env.h b/components/oap-common/include/oap_data_env.h index 3666a5b..a970d45 100644 --- a/components/oap-common/include/oap_data_env.h +++ b/components/oap-common/include/oap_data_env.h @@ -23,11 +23,43 @@ #ifndef COMPONENTS_OAP_COMMON_INCLUDE_OAP_DATA_ENV_H_ #define COMPONENTS_OAP_COMMON_INCLUDE_OAP_DATA_ENV_H_ +typedef enum { + sensor_bmx280 = 0, + sensor_mhz19, + sensor_hcsr04, + sensor_gpio +} sensor_type_t; + typedef struct { - double temp; - double pressure; - double humidity; uint8_t sensor_idx; + sensor_type_t sensor_type; + + union { + struct { + double temp; + double pressure; + double sealevel; + double humidity; + uint32_t altitude; + } bmx280; + struct { + double temp; + uint32_t co2; + } mhz19; + struct { + uint32_t distance; + } hcsr04; + struct { + int val; + int64_t GPIlastLow; + int64_t GPIlastHigh; + int64_t GPICounter; + int64_t GPICountDelta; + int64_t GPOlastOut; + int64_t GPOtriggerLength; + int8_t GPOlastVal; + } gpio; + }; } env_data_t; #endif /* COMPONENTS_OAP_COMMON_INCLUDE_OAP_DATA_ENV_H_ */ diff --git a/components/oap-common/include/oap_debug.h b/components/oap-common/include/oap_debug.h index 672c685..d798f00 100644 --- a/components/oap-common/include/oap_debug.h +++ b/components/oap-common/include/oap_debug.h @@ -35,3 +35,4 @@ size_t avg_free_heap_size(); void log_task_stack(const char* task); void log_heap_size(const char* msg); void reduce_heap_size_to(size_t size); +void hexdump(const unsigned char *data, int len); diff --git a/components/oap-common/include/oap_storage.h b/components/oap-common/include/oap_storage.h index ac17e6a..ed3f379 100644 --- a/components/oap-common/include/oap_storage.h +++ b/components/oap-common/include/oap_storage.h @@ -26,6 +26,20 @@ #include #include "cJSON.h" +/** + * @brief get a mac based system name + */ +void get_generic_name(char *name); + +/** + * @brief get allocated string from string + */ +void set_config_str_field(char** field, char* value); + +/** + * @brief initialise config + */ +void storage_clean(); /** * @brief initialise storage and config diff --git a/components/oap-common/include/oap_version.h b/components/oap-common/include/oap_version.h index 375a318..62fb540 100644 --- a/components/oap-common/include/oap_version.h +++ b/components/oap-common/include/oap_version.h @@ -37,8 +37,8 @@ #include "esp_err.h" #define OAP_VER_MAJOR 1 -#define OAP_VER_MINOR 2 -#define OAP_VER_PATCH 0 +#define OAP_VER_MINOR 4 +#define OAP_VER_PATCH 29 typedef struct { uint8_t major; diff --git a/components/oap-common/oap_common.c b/components/oap-common/oap_common.c index 7aa6e5c..0183c58 100644 --- a/components/oap-common/oap_common.c +++ b/components/oap-common/oap_common.c @@ -30,15 +30,17 @@ #include "esp_log.h" #include "esp_system.h" #include "freertos/task.h" +#include "driver/gpio.h" static const long FEB22_2017 = 1487795557; +static const char *TAG="oap"; static int _reboot_in_progress = 0; int is_reboot_in_progress() { return _reboot_in_progress; } void oap_reboot(char* cause) { - ESP_LOGW("oap", "REBOOT ON DEMAND (%s)", cause); + ESP_LOGW(TAG, "REBOOT ON DEMAND (%s)", cause); _reboot_in_progress = 1; esp_restart(); } @@ -105,4 +107,43 @@ void IRAM_ATTR delayMicroseconds(uint32_t us) } } +void set_gpio(uint8_t gpio, uint8_t enabled) { + if (gpio > 0) { + ESP_LOGD(TAG, "set pin %d => %d", gpio, enabled); + gpio_set_level(gpio, enabled); + } +} + +void configure_gpio(uint8_t gpio) { + if (gpio > 0) { + ESP_LOGD(TAG, "configure pin %d as output", gpio); + gpio_pad_select_gpio(gpio); + ESP_ERROR_CHECK(gpio_set_direction(gpio, GPIO_MODE_OUTPUT)); + ESP_ERROR_CHECK(gpio_set_pull_mode(gpio, GPIO_PULLDOWN_ONLY)); + } +} + +void req_set_user_agent(request_t* req) { + char agent[80]; + sprintf(agent, "User-Agent: OAP-ESP32/%s", oap_version_str()); + req_setopt(req, REQ_SET_HEADER, agent); +} + +double sma_generator (sma_data_t *sma, double value) { + sma->sum += value; + sma->data[sma->lastpos%sma->size] = value; + sma->lastpos++; + unsigned int size=sma->size; + if(sma->lastpos >= sma->size) { + sma->sum -= sma->data[sma->lastpos%sma->size]; + } else { + size=sma->lastpos; + } + return sma->sum/size; +} +int64_t get_time_millis() { + struct timeval tv; + gettimeofday(&tv, NULL); + return (tv.tv_sec * 1000LL + (tv.tv_usec / 1000LL)); +} diff --git a/components/oap-common/oap_debug.c b/components/oap-common/oap_debug.c index 6fc3d14..c42f0c3 100644 --- a/components/oap-common/oap_debug.c +++ b/components/oap-common/oap_debug.c @@ -154,3 +154,12 @@ void heap_log_free(heap_log* log) { ESP_LOGD("debug", "----------> leaked : %d", xPortGetFreeHeapSize() - initial_heap); } } + +void hexdump(const unsigned char *data, int len) { + char str[80]; + str[0]=0; + for(int i=0;i #include "cJSON.h" #include +#include "oap_common.h" extern const uint8_t default_config_json_start[] asm("_binary_default_config_json_start"); extern const uint8_t default_config_json_end[] asm("_binary_default_config_json_end"); @@ -245,6 +246,14 @@ void storage_set_bigblob(const char* key, void* value, size_t length) { //----------- config -------------- +void set_config_str_field(char** field, char* value) { + if (*field) { + free(*field); + } + *field = str_dup(value); +} + + cJSON* storage_get_config(const char* module) { if (!_config) { ESP_LOGE(TAG, "call storage_init_config() first!"); @@ -316,6 +325,15 @@ static char* default_config() { return str; } +void get_generic_name(char *name) { + //generate unique SSID + uint8_t mac[6]; + esp_efuse_mac_get_default(mac); + //ESP_LOGD(tag, "MAC= %02X:%02X:%02X:%02X:%02X:%02X",mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]); + //using full MAC would be the best but I'm not sure if it is safe (if someone has wifi with MAC filtering) + sprintf(name, "OAP-%02X%02X%02X%02X", mac[0], mac[1], mac[4], mac[5]); +} + static void storage_init_config() { char* str = NULL; ESP_LOGD(TAG, "get config"); @@ -354,6 +372,12 @@ static void storage_init_config() { ESP_LOGE(TAG,"default config is not a proper json\n%s", str); abort(); } else { + char id[32]; + get_generic_name(id); + ESP_LOGW(TAG, "sensor id not configured, using %s", id); + cJSON_ReplaceItemInObject(cJSON_GetObjectItem(def_config,"wifi"), "sensorId", cJSON_CreateString(id)); + free(str); + str=cJSON_Print(def_config); ESP_LOGD(TAG,"default config\n%s",str); } free(str); diff --git a/components/oap-http-get-publisher/component.mk b/components/oap-http-get-publisher/component.mk new file mode 100644 index 0000000..5548fec --- /dev/null +++ b/components/oap-http-get-publisher/component.mk @@ -0,0 +1,9 @@ +# +# Main component makefile. +# +# This Makefile can be left empty. By default, it will take the sources in the +# src/ directory, compile them and link them into lib(subdirectory_name).a +# in the build directory. This behaviour is entirely configurable, +# please read the ESP-IDF documents if you need to do this. +# +COMPONENT_EMBED_TXTFILES = lets-encrypt-x3-cross-signed.pem diff --git a/components/oap-http-get-publisher/http_get_publisher.c b/components/oap-http-get-publisher/http_get_publisher.c new file mode 100644 index 0000000..0b5189b --- /dev/null +++ b/components/oap-http-get-publisher/http_get_publisher.c @@ -0,0 +1,144 @@ +/* + * baycom.de + * + * Created on: Jan 4, 2018 + * Author: Deti + * + * This file is part of OpenAirProject-ESP32. + * + * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * OpenAirProject-ESP32 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with OpenAirProject-ESP32. If not, see . + */ + +#include "http_get_publisher.h" + +#include "oap_common.h" +#include "oap_storage.h" +#include "oap_debug.h" +#include "esp_request.h" +#include "bootwifi.h" +#include "cJSON.h" + +extern const uint8_t _root_ca_pem_start[] asm("_binary_lets_encrypt_x3_cross_signed_pem_start"); +extern const uint8_t _root_ca_pem_end[] asm("_binary_lets_encrypt_x3_cross_signed_pem_end"); + +static const char *TAG = "http_get_publisher"; + +static char* url = NULL; +static char* sensorId = NULL; +static int _configured = 0; + +static esp_err_t http_get(char* uri, oap_measurement_t* meas) { + char* payload = malloc(512); + if (!payload) return NULL; + sprintf(payload, "%s?item=%s&type=oap", uri, sensorId); + + if (meas->pm) { + sprintf(payload, "%s&pm1_0=%d&pm2_5=%d&pm10=%d", payload, + meas->pm->pm1_0, + meas->pm->pm2_5, + meas->pm->pm10); + } + + if (meas->env) { + sprintf(payload, "%s&temp=%.1f&pressure=%.1f&humidity=%.0f", payload, + meas->env->bmx280.temp, + meas->env->bmx280.sealevel, + meas->env->bmx280.humidity); + } + if (meas->co2) { + sprintf(payload, "%s&co2=%d", payload, + meas->co2->mhz19.co2); + } + if (meas->distance1) { + sprintf(payload, "%s&distance1=%d", payload, + meas->distance1->hcsr04.distance); + } + if (meas->distance2) { + sprintf(payload, "%s&distance2=%d", payload, + meas->distance2->hcsr04.distance); + } + + request_t* req = req_new(payload); + if (!req) { + return ESP_FAIL; + } + ESP_LOGD(TAG, "request payload: %s", payload); + req_setopt(req, REQ_SET_METHOD, "GET"); + req_setopt(req, REQ_SET_HEADER, HTTP_HEADER_CONNECTION_CLOSE); + req_set_user_agent(req); + + req->ca_cert = req_parse_x509_crt((unsigned char*)_root_ca_pem_start, _root_ca_pem_end-_root_ca_pem_start); + + int response_code = req_perform(req); + req_clean(req); + free(payload); + if (response_code == 200) { + ESP_LOGI(TAG, "update succeeded"); + return ESP_OK; + } else { + ESP_LOGW(TAG, "update failed (response code: %d)", response_code); + return ESP_FAIL; + } + +} + +static esp_err_t http_get_publisher_configure(cJSON* config) { + _configured = 0; + ESP_LOGI(TAG, "http_get_publisher_configure"); + if (!config) { + ESP_LOGI(TAG, "config not found"); + return ESP_FAIL; + } + + cJSON* field; + if ((field = cJSON_GetObjectItem(cJSON_GetObjectItem(config,"wifi"), "sensorId")) && field->valuestring && strlen(field->valuestring)) { + set_config_str_field(&sensorId, field->valuestring); + } else { + ESP_LOGW(TAG, "sensorId not configured"); + return ESP_FAIL; + } + if ((field = cJSON_GetObjectItem(cJSON_GetObjectItem(config,"http_get_publisher"), "url")) && field->valuestring) { + set_config_str_field(&url, field->valuestring); + } else { + ESP_LOGW(TAG, "url not configured"); + return ESP_FAIL; + } + if (!(field = cJSON_GetObjectItem(cJSON_GetObjectItem(config,"http_get_publisher"), "enabled")) || !field->valueint) { + ESP_LOGI(TAG, "client disabled"); + return ESP_FAIL; + } + _configured = 1; + return ESP_OK; +} + +static esp_err_t http_get_publisher_send(oap_measurement_t* meas, oap_sensor_config_t* oap_sensor_config) { + if (!_configured) { + ESP_LOGE(TAG, "http_get_publisher not configured"); + return ESP_FAIL; + } + esp_err_t ret; + if ((ret = wifi_connected_wait_for(5000)) != ESP_OK) { + ESP_LOGW(TAG, "no connectivity, skip"); + return ret; + } + + ret = http_get(url, meas); + return ret; +} + +oap_publisher_t http_get_publisher = { + .name = "http_get_publisher", + .configure = http_get_publisher_configure, + .publish = &http_get_publisher_send +}; diff --git a/components/oap-wifi/cpanel.h b/components/oap-http-get-publisher/include/http_get_publisher.h similarity index 72% rename from components/oap-wifi/cpanel.h rename to components/oap-http-get-publisher/include/http_get_publisher.h index c7fd293..a5c3f59 100644 --- a/components/oap-wifi/cpanel.h +++ b/components/oap-http-get-publisher/include/http_get_publisher.h @@ -1,8 +1,8 @@ /* - * cpanel.h + * http.h * - * Created on: Oct 5, 2017 - * Author: kris + * Created on: Jan 4, 2018 + * Author: Deti * * This file is part of OpenAirProject-ESP32. * @@ -20,13 +20,13 @@ * along with OpenAirProject-ESP32. If not, see . */ -#ifndef COMPONENTS_BOOTWIFI_CPANEL_H_ -#define COMPONENTS_BOOTWIFI_CPANEL_H_ +#ifndef COMPONENTS_HTTP_GET_PUBLISHER_H_ +#define COMPONENTS_HTTP_GET_PUBLISHER_H_ +#include "esp_err.h" +#include "oap_publisher.h" -#include "mongoose.h" -void cpanel_event_handler(struct mg_connection *nc, int ev, void *evData); +oap_publisher_t http_get_publisher; - -#endif /* COMPONENTS_BOOTWIFI_CPANEL_H_ */ +#endif diff --git a/components/oap-http-get-publisher/lets-encrypt-x3-cross-signed.pem b/components/oap-http-get-publisher/lets-encrypt-x3-cross-signed.pem new file mode 100644 index 0000000..0002462 --- /dev/null +++ b/components/oap-http-get-publisher/lets-encrypt-x3-cross-signed.pem @@ -0,0 +1,27 @@ +-----BEGIN CERTIFICATE----- +MIIEkjCCA3qgAwIBAgIQCgFBQgAAAVOFc2oLheynCDANBgkqhkiG9w0BAQsFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTE2MDMxNzE2NDA0NloXDTIxMDMxNzE2NDA0Nlow +SjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUxldCdzIEVuY3J5cHQxIzAhBgNVBAMT +GkxldCdzIEVuY3J5cHQgQXV0aG9yaXR5IFgzMIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEAnNMM8FrlLke3cl03g7NoYzDq1zUmGSXhvb418XCSL7e4S0EF +q6meNQhY7LEqxGiHC6PjdeTm86dicbp5gWAf15Gan/PQeGdxyGkOlZHP/uaZ6WA8 +SMx+yk13EiSdRxta67nsHjcAHJyse6cF6s5K671B5TaYucv9bTyWaN8jKkKQDIZ0 +Z8h/pZq4UmEUEz9l6YKHy9v6Dlb2honzhT+Xhq+w3Brvaw2VFn3EK6BlspkENnWA +a6xK8xuQSXgvopZPKiAlKQTGdMDQMc2PMTiVFrqoM7hD8bEfwzB/onkxEz0tNvjj +/PIzark5McWvxI0NHWQWM6r6hCm21AvA2H3DkwIDAQABo4IBfTCCAXkwEgYDVR0T +AQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAYYwfwYIKwYBBQUHAQEEczBxMDIG +CCsGAQUFBzABhiZodHRwOi8vaXNyZy50cnVzdGlkLm9jc3AuaWRlbnRydXN0LmNv +bTA7BggrBgEFBQcwAoYvaHR0cDovL2FwcHMuaWRlbnRydXN0LmNvbS9yb290cy9k +c3Ryb290Y2F4My5wN2MwHwYDVR0jBBgwFoAUxKexpHsscfrb4UuQdf/EFWCFiRAw +VAYDVR0gBE0wSzAIBgZngQwBAgEwPwYLKwYBBAGC3xMBAQEwMDAuBggrBgEFBQcC +ARYiaHR0cDovL2Nwcy5yb290LXgxLmxldHNlbmNyeXB0Lm9yZzA8BgNVHR8ENTAz +MDGgL6AthitodHRwOi8vY3JsLmlkZW50cnVzdC5jb20vRFNUUk9PVENBWDNDUkwu +Y3JsMB0GA1UdDgQWBBSoSmpjBH3duubRObemRWXv86jsoTANBgkqhkiG9w0BAQsF +AAOCAQEA3TPXEfNjWDjdGBX7CVW+dla5cEilaUcne8IkCJLxWh9KEik3JHRRHGJo +uM2VcGfl96S8TihRzZvoroed6ti6WqEBmtzw3Wodatg+VyOeph4EYpr/1wXKtx8/ +wApIvJSwtmVi4MFU5aMqrSDE6ea73Mj2tcMyo5jMd6jmeWUHK8so/joWUoHOUgwu +X4Po1QYz+3dszkDqMp4fklxBwXRsW10KXzPMTZ+sOPAveyxindmjkW8lGy+QsRlG +PfZ+G6Z6h7mjem0Y+iWlkYcV4PIWL1iwBi8saCbGS5jN2p8M+X+Q7UNKEkROb3N6 +KOqkqm57TH2H3eDJAkSnh6/DNFu0Qg== +-----END CERTIFICATE----- diff --git a/components/oap-http/esp_request.c b/components/oap-http/esp_request.c index 29f4596..ff19f43 100644 --- a/components/oap-http/esp_request.c +++ b/components/oap-http/esp_request.c @@ -26,6 +26,7 @@ #include "mbedtls/ctr_drbg.h" #include "mbedtls/error.h" #include "mbedtls/certs.h" +#include "mbedtls/base64.h" #include "freertos/FreeRTOS.h" #include "freertos/queue.h" @@ -104,13 +105,28 @@ static int resolve_dns(const char *host, struct sockaddr_in *ip) { static char *http_auth_basic_encode(const char *username, const char *password) { + char inputstr[64]; + char *outstr = NULL; + size_t olen; + sprintf(inputstr,"%.30s:%.30s", username, password); +// ESP_LOGD(TAG, "http_auth_basic_encode: %s", inputstr); + + mbedtls_base64_encode( (unsigned char*)outstr, 0, &olen, (unsigned char*)inputstr, strlen(inputstr)); + outstr = (char *)malloc(olen+1+22); + sprintf(outstr, "Authorization: Basic "); + + if(!mbedtls_base64_encode( (unsigned char*)outstr+21, olen, &olen, (unsigned char*)inputstr, strlen(inputstr))) { +// ESP_LOGD(TAG, "http_auth_basic_encode: %s", outstr); + return outstr; + } + free(outstr); return NULL; } static int nossl_connect(request_t *req) { - int socket; + int sock; struct sockaddr_in remote_ip; struct timeval tv; req_list_t *host, *port, *timeout; @@ -125,8 +141,8 @@ static int nossl_connect(request_t *req) } } - socket = socket(PF_INET, SOCK_STREAM, 0); - REQ_CHECK(socket < 0, "socket failed", return -1); + sock = socket(PF_INET, SOCK_STREAM, 0); + REQ_CHECK(sock < 0, "socket failed", return -1); port = req_list_get_key(req->opt, "port"); if(port == NULL) @@ -141,16 +157,16 @@ static int nossl_connect(request_t *req) tv.tv_sec = atoi(timeout->value); } tv.tv_usec = 0; - setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); ESP_LOGD(TAG, "[sock=%d],connecting to server IP:%s,Port:%s...", - socket, ipaddr_ntoa((const ip_addr_t*)&remote_ip.sin_addr.s_addr), (char*)port->value); - if(connect(socket, (struct sockaddr *)(&remote_ip), sizeof(struct sockaddr)) != 0) { - close(socket); + sock, ipaddr_ntoa((const ip_addr_t*)&remote_ip.sin_addr.s_addr), (char*)port->value); + if(connect(sock, (struct sockaddr *)(&remote_ip), sizeof(struct sockaddr)) != 0) { + close(sock); return -1; } - req->socket = socket; - return socket; + req->socket = sock; + return sock; } void req_free_x509_crt(mbedtls_x509_crt* crt) { diff --git a/components/oap-hw-bmx280/Kconfig b/components/oap-hw-bmx280/Kconfig index 44deec5..5bd894b 100644 --- a/components/oap-hw-bmx280/Kconfig +++ b/components/oap-hw-bmx280/Kconfig @@ -1,13 +1,14 @@ menu "OAP BMx280 Sensor" config OAP_BMX280_ENABLED - int "enable bmx280 sensor" - default 1 + bool "enable bmx280 sensor" + default y help todo config OAP_BMX280_ADDRESS hex "i2c address" + depends on OAP_BMX280_ENABLED default 0x76 help Default address for bmx280 sensor is 0x76, it can be set to 0x77 by pulling up SDO pin. @@ -15,12 +16,14 @@ config OAP_BMX280_ADDRESS config OAP_BMX280_I2C_NUM int "i2c interface number" + depends on OAP_BMX280_ENABLED default 0 help todo config OAP_BMX280_I2C_SDA_PIN int "gpio SDA pin" + depends on OAP_BMX280_ENABLED default 25 help be careful with choosing gpio. i2c pins must be R/W. @@ -28,18 +31,20 @@ config OAP_BMX280_I2C_SDA_PIN config OAP_BMX280_I2C_SCL_PIN int "SCL pin" + depends on OAP_BMX280_ENABLED default 26 help see help for SDA pin config OAP_BMX280_ENABLED_AUX - int "enable internal bmx280 sensor" - default 0 + bool "enable internal bmx280 sensor" + default n help todo config OAP_BMX280_ADDRESS_AUX hex "i2c address of internal sensor" + depends on OAP_BMX280_ENABLED_AUX default 0x77 help If both external and internal sensor use the same i2c bus, they must be configured to use @@ -49,12 +54,14 @@ config OAP_BMX280_ADDRESS_AUX config OAP_BMX280_I2C_NUM_AUX int "i2c interface number for internal sensor" + depends on OAP_BMX280_ENABLED_AUX default 0 help if both sensors use the same bus (default), sda/scl pins are ignored. config OAP_BMX280_I2C_SDA_PIN_AUX int "gpio SDA pin" + depends on OAP_BMX280_ENABLED_AUX default 25 help be careful with choosing gpio. i2c pins must be R/W. @@ -62,6 +69,7 @@ config OAP_BMX280_I2C_SDA_PIN_AUX config OAP_BMX280_I2C_SCL_PIN_AUX int "SCL pin" + depends on OAP_BMX280_ENABLED_AUX default 26 help see help for SDA pin diff --git a/components/oap-hw-bmx280/bmx280.c b/components/oap-hw-bmx280/bmx280.c index 650a6c0..b528fb0 100644 --- a/components/oap-hw-bmx280/bmx280.c +++ b/components/oap-hw-bmx280/bmx280.c @@ -26,6 +26,8 @@ #include #include #include +#include + #include "sdkconfig.h" #include "oap_common.h" #include "oap_debug.h" @@ -34,6 +36,29 @@ static char* TAG = "bmx280"; + +static double getHumidityForTemp(double srcHumidity, double temp, double temp2) { + double a = 7.5, b = 237.3; + double mw = 18.016; + double Rstar = 8314.3; + + if(temp < 0) { + a=7.6; + b=240.7; + } + double sdd = 6.1078 * pow(10, (a*temp)/(b+temp)); + double dd = srcHumidity/100 * sdd; + double af = pow(10,5) * mw/Rstar * dd/ ( temp + 273.15); + return 100 * (temp2 + 273.15) * Rstar * af/(pow(10,5) * mw * 6.1078 * pow(10, (a*temp2)/(b+temp2))); +} + +static float getPressureAtSeaLevel(float altitude, float pressure) { + float gradient = 0.0065; + float tempAtSea = 15.0; + tempAtSea += 273.15; // °C to K + return pressure / pow((1 - gradient * altitude / tempAtSea), (0.03416 / gradient)); +} + esp_err_t bmx280_measurement_loop(bmx280_config_t* bmx280_config) { i2c_comm_t i2c_comm = { .i2c_num = bmx280_config->i2c_num, @@ -46,7 +71,8 @@ esp_err_t bmx280_measurement_loop(bmx280_config_t* bmx280_config) { }; env_data_t result = { - .sensor_idx = bmx280_config->sensor_idx + .sensor_idx = bmx280_config->sensor_idx, + .sensor_type = sensor_bmx280 }; // TODO strangely, if this is executed inside main task, LEDC fails to initialise properly PWM (and blinks in funny ways)... easy to reproduce. @@ -55,7 +81,11 @@ esp_err_t bmx280_measurement_loop(bmx280_config_t* bmx280_config) { while(1) { log_task_stack(TAG); if ((ret = BME280_read(&bmx280_sensor, &result)) == ESP_OK) { - ESP_LOGD(TAG,"sensor (%d) => Temperature : %.2f C, Pressure: %.2f hPa, Humidity %.2f", result.sensor_idx, result.temp, result.pressure, result.humidity); + result.bmx280.sealevel = getPressureAtSeaLevel(bmx280_config->altitude, result.bmx280.pressure); + ESP_LOGD(TAG,"sensor (%d) => Temperature : %.2f C, Pressure: %.2f hPa, Pressure: %.2f hPa @ %dm,Humidity %.2f", result.sensor_idx, result.bmx280.temp, result.bmx280.pressure, result.bmx280.sealevel, bmx280_config->altitude, result.bmx280.humidity); + result.bmx280.humidity = getHumidityForTemp(result.bmx280.humidity, result.bmx280.temp, result.bmx280.temp + bmx280_config->tempOffset); + result.bmx280.temp += bmx280_config->tempOffset; + result.bmx280.humidity += bmx280_config->humidityOffset; if (bmx280_config->callback) { bmx280_config->callback(&result); } @@ -94,12 +124,12 @@ esp_err_t bmx280_i2c_setup(bmx280_config_t* config) { i2c_conf.scl_io_num = config->scl_pin;//CONFIG_OAP_BMX280_I2C_SCL_PIN; i2c_conf.sda_pullup_en = GPIO_PULLUP_ENABLE; i2c_conf.scl_pullup_en = GPIO_PULLUP_ENABLE; - i2c_conf.master.clk_speed = 100000; + i2c_conf.master.clk_speed = 1000000; esp_err_t res; if ((res = i2c_param_config(config->i2c_num, &i2c_conf)) != ESP_OK) return res; - ESP_LOGD(TAG, "install I2C driver (bus %d)", config->i2c_num); + ESP_LOGD(TAG, "install I2C driver (bus %d, sda %d, scl %d)", config->i2c_num, i2c_conf.sda_io_num, i2c_conf.scl_io_num); res = i2c_driver_install(config->i2c_num, I2C_MODE_MASTER, 0, 0, 0); if (res == ESP_OK) { i2c_drivers[config->i2c_num] = 1; @@ -120,20 +150,26 @@ esp_err_t bmx280_init(bmx280_config_t* bmx280_config) { esp_err_t bmx280_set_hardware_config(bmx280_config_t* bmx280_config, uint8_t sensor_idx) { switch (sensor_idx) { case 0: - if (!OAP_BMX280_ENABLED) return ESP_FAIL; +#ifdef CONFIG_OAP_BMX280_ENABLED bmx280_config->sensor_idx = 0; - bmx280_config->i2c_num = OAP_BMX280_I2C_NUM; - bmx280_config->device_addr = OAP_BMX280_ADDRESS; - bmx280_config->sda_pin = OAP_BMX280_I2C_SDA_PIN; - bmx280_config->scl_pin = OAP_BMX280_I2C_SCL_PIN; + bmx280_config->i2c_num = CONFIG_OAP_BMX280_I2C_NUM; + bmx280_config->device_addr = CONFIG_OAP_BMX280_ADDRESS; + bmx280_config->sda_pin = CONFIG_OAP_BMX280_I2C_SDA_PIN; + bmx280_config->scl_pin = CONFIG_OAP_BMX280_I2C_SCL_PIN; +#else + return ESP_FAIL; +#endif return ESP_OK; case 1: - if (!OAP_BMX280_ENABLED_AUX) return ESP_FAIL; +#ifdef CONFIG_OAP_BMX280_ENABLED_AUX bmx280_config->sensor_idx = 1; - bmx280_config->i2c_num = OAP_BMX280_I2C_NUM_AUX; - bmx280_config->device_addr = OAP_BMX280_ADDRESS_AUX; - bmx280_config->sda_pin = OAP_BMX280_I2C_SDA_PIN_AUX; - bmx280_config->scl_pin = OAP_BMX280_I2C_SCL_PIN_AUX; + bmx280_config->i2c_num = CONFIG_OAP_BMX280_I2C_NUM_AUX; + bmx280_config->device_addr = CONFIG_OAP_BMX280_ADDRESS_AUX; + bmx280_config->sda_pin = CONFIG_OAP_BMX280_I2C_SDA_PIN_AUX; + bmx280_config->scl_pin = CONFIG_OAP_BMX280_I2C_SCL_PIN_AUX; +#else + return ESP_FAIL; +#endif return ESP_OK; default: return ESP_FAIL; diff --git a/components/oap-hw-bmx280/i2c_bme280.c b/components/oap-hw-bmx280/i2c_bme280.c index 768e71b..f3f3293 100755 --- a/components/oap-hw-bmx280/i2c_bme280.c +++ b/components/oap-hw-bmx280/i2c_bme280.c @@ -77,7 +77,7 @@ static esp_err_t read_i2c(i2c_comm_t* comm, uint8_t reg, uint8_t* data, int len) cmd = i2c_cmd_link_create(); CONT_IF_I2C_OK("r6", comm, i2c_master_start(cmd)); CONT_IF_I2C_OK("r7", comm, i2c_master_write_byte(cmd, (comm->device_addr << 1) | I2C_MASTER_READ, 1)); - CONT_IF_I2C_OK("r8", comm, i2c_master_read(cmd,data+i,1,1)); //ACK is must! + CONT_IF_I2C_OK("r8", comm, i2c_master_read_byte(cmd,data+i,1)); //ACK is must! CONT_IF_I2C_OK("r9", comm, i2c_master_stop(cmd)); CONT_IF_I2C_OK("r10",comm, i2c_master_cmd_begin(comm->i2c_num, cmd, 2000/portTICK_PERIOD_MS)); i2c_cmd_link_delete(cmd); @@ -225,12 +225,12 @@ esp_err_t BME280_read(bme280_sensor_t* bme280_sensor, env_data_t* result){ temp_reading_t temp_reading = BME280_compensate_T_double(&bme280_sensor->calib, temp_raw); - result->temp = temp_reading.temp;//Celsius - result->pressure = BME280_compensate_P_double(&bme280_sensor->calib, temp_reading.t_fine, pres_raw) / 100.0; //hPA + result->bmx280.temp = temp_reading.temp;//Celsius + result->bmx280.pressure = BME280_compensate_P_double(&bme280_sensor->calib, temp_reading.t_fine, pres_raw) / 100.0; //hPA if (bme280_sensor->chip_type == CHIP_TYPE_BME) { - result->humidity = BME280_compensate_H_double(&bme280_sensor->calib, temp_reading.t_fine, hum_raw);// pct + result->bmx280.humidity = BME280_compensate_H_double(&bme280_sensor->calib, temp_reading.t_fine, hum_raw);// pct } else { - result->humidity = HUMIDITY_MEAS_UNSUPPORTED; + result->bmx280.humidity = HUMIDITY_MEAS_UNSUPPORTED; } return ESP_OK; @@ -240,7 +240,7 @@ esp_err_t BME280_verify_chip(bme280_sensor_t* bme280_sensor) { uint8_t chipID = 0; uint8_t attempt = 0; while (read_i2c(&bme280_sensor->i2c_comm, BME280_CHIP_ID_REG, &chipID,1) != ESP_OK && attempt++ < 5) { - ESP_LOGW(TAG, "[%x] failed to read chip id (attempt %d)", bme280_sensor->i2c_comm.device_addr, attempt) + ESP_LOGW(TAG, "[%x] failed to read chip id (attempt %d)", bme280_sensor->i2c_comm.device_addr, attempt); vTaskDelay(20/portTICK_PERIOD_MS); } diff --git a/components/oap-hw-bmx280/include/bmx280.h b/components/oap-hw-bmx280/include/bmx280.h index 37fd961..8002508 100644 --- a/components/oap-hw-bmx280/include/bmx280.h +++ b/components/oap-hw-bmx280/include/bmx280.h @@ -26,17 +26,7 @@ #include "oap_common.h" #include "oap_data_env.h" -#define OAP_BMX280_ENABLED CONFIG_OAP_BMX280_ENABLED -#define OAP_BMX280_I2C_NUM CONFIG_OAP_BMX280_I2C_NUM -#define OAP_BMX280_ADDRESS CONFIG_OAP_BMX280_ADDRESS -#define OAP_BMX280_I2C_SDA_PIN CONFIG_OAP_BMX280_I2C_SDA_PIN -#define OAP_BMX280_I2C_SCL_PIN CONFIG_OAP_BMX280_I2C_SCL_PIN - -#define OAP_BMX280_ENABLED_AUX CONFIG_OAP_BMX280_ENABLED_AUX -#define OAP_BMX280_I2C_NUM_AUX CONFIG_OAP_BMX280_I2C_NUM_AUX -#define OAP_BMX280_ADDRESS_AUX CONFIG_OAP_BMX280_ADDRESS_AUX -#define OAP_BMX280_I2C_SDA_PIN_AUX CONFIG_OAP_BMX280_I2C_SDA_PIN_AUX -#define OAP_BMX280_I2C_SCL_PIN_AUX CONFIG_OAP_BMX280_I2C_SCL_PIN_AUX +#define HW_BMX280_DEVICES_MAX 2 typedef void(*env_callback)(env_data_t*); @@ -49,7 +39,9 @@ typedef struct bmx280_config_t { uint8_t sensor_idx; //sensor number (0 - 1) uint32_t interval; env_callback callback; - + int32_t altitude; + int32_t tempOffset; + int32_t humidityOffset; } bmx280_config_t; esp_err_t bmx280_init(bmx280_config_t* config); diff --git a/components/oap-hw-ext/Kconfig b/components/oap-hw-ext/Kconfig index e7d000e..2fbe8a8 100644 --- a/components/oap-hw-ext/Kconfig +++ b/components/oap-hw-ext/Kconfig @@ -2,26 +2,32 @@ menu "OAP Peripherals" config OAP_LED_R_PIN int "led Red pin" - default 12 + default -1 help ESP32 R/W gpio config OAP_LED_G_PIN int "led Green pin" - default 27 + default -1 help ESP32 R/W gpio config OAP_LED_B_PIN int "led Blue pin" - default 14 + default 2 help ESP32 R/W gpio config OAP_BTN_0_PIN int "button pin" - default 35 + default 0 + help + ESP32 gpio + +config OAP_BTN_0_ACTIVE_LOW + bool "Active low" + default y help ESP32 gpio -endmenu \ No newline at end of file +endmenu diff --git a/components/oap-hw-ext/ctrl_btn.c b/components/oap-hw-ext/ctrl_btn.c index 2e48cf5..68c4df5 100644 --- a/components/oap-hw-ext/ctrl_btn.c +++ b/components/oap-hw-ext/ctrl_btn.c @@ -39,6 +39,7 @@ typedef struct { uint8_t gpio_num; + uint8_t gpio_val; uint32_t timestamp; } gpio_event_t; @@ -56,7 +57,8 @@ static void IRAM_ATTR gpio_isr_handler(void* arg) last_click = t; gpio_event_t gpio_evt = { .gpio_num = (uint8_t)(uint32_t)arg, - .timestamp = t + .gpio_val = !gpio_get_level(CONFIG_OAP_BTN_0_PIN), + .timestamp = t }; xQueueSendFromISR(gpio_evt_queue, &gpio_evt, NULL); } @@ -65,17 +67,29 @@ static void gpio_watchdog_task() { gpio_event_t gpio_evt; int count = 0; uint32_t first_click = 0; + uint32_t last_down = 0; while(1) { if (xQueueReceive(gpio_evt_queue, &gpio_evt, 1000)) { _callback(SINGLE_CLICK); //20 sec to perform the action - if (!first_click || gpio_evt.timestamp - first_click > 20000) { - first_click = gpio_evt.timestamp; - count = 0; + if(gpio_evt.gpio_val) { + if (!first_click || gpio_evt.timestamp - first_click > 20000) { + first_click = gpio_evt.timestamp; + count = 0; + } + count++; + last_down = gpio_evt.timestamp; + ESP_LOGD(TAG, "click gpio[%d] [%d in sequence]",gpio_evt.gpio_num, count); + } else { + if (last_down && gpio_evt.timestamp - last_down > 5000) { + ESP_LOGD(TAG, "long press gpio[%d] [%d in sequence]",gpio_evt.gpio_num, count); + _callback(LONG_PRESS); + first_click=0; + last_down=0; + count=0; + } } - count++; - ESP_LOGD(TAG, "click gpio[%d] [%d in sequence]",gpio_evt.gpio_num, count); //due to flickering we cannot precisely count all clicks anyway if (count == 10) { @@ -94,16 +108,23 @@ esp_err_t btn_configure(btn_callback_f callback) { _callback = callback; gpio_evt_queue = xQueueCreate(10, sizeof(gpio_event_t)); gpio_pad_select_gpio(CONFIG_OAP_BTN_0_PIN); + gpio_set_direction(CONFIG_OAP_BTN_0_PIN, GPIO_MODE_INPUT); +#ifdef CONFIG_OAP_BTN_0_ACTIVE_LOW + gpio_set_pull_mode(CONFIG_OAP_BTN_0_PIN, GPIO_PULLUP_ONLY); +#else gpio_set_pull_mode(CONFIG_OAP_BTN_0_PIN, GPIO_PULLDOWN_ONLY); - gpio_set_intr_type(CONFIG_OAP_BTN_0_PIN, GPIO_INTR_POSEDGE); - gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT); +#endif + gpio_set_intr_type(CONFIG_OAP_BTN_0_PIN, GPIO_INTR_ANYEDGE); gpio_isr_handler_add(CONFIG_OAP_BTN_0_PIN, gpio_isr_handler, (void*) CONFIG_OAP_BTN_0_PIN); xTaskCreate((TaskFunction_t)gpio_watchdog_task, "gpio_watchdog_task", 1024*2, NULL, DEFAULT_TASK_PRIORITY+2, NULL); return ESP_OK; //TODO handle errors } bool is_ap_mode_pressed() { +#ifdef CONFIG_OAP_BTN_0_ACTIVE_LOW + return !gpio_get_level(CONFIG_OAP_BTN_0_PIN); +#else return gpio_get_level(CONFIG_OAP_BTN_0_PIN); +#endif } - diff --git a/components/oap-hw-ext/include/ctrl_btn.h b/components/oap-hw-ext/include/ctrl_btn.h index 5e39c1a..736419c 100644 --- a/components/oap-hw-ext/include/ctrl_btn.h +++ b/components/oap-hw-ext/include/ctrl_btn.h @@ -26,7 +26,8 @@ typedef enum { SINGLE_CLICK, MANY_CLICKS, - TOO_MANY_CLICKS + TOO_MANY_CLICKS, + LONG_PRESS } btn_action_t; typedef void(*btn_callback_f)(btn_action_t); diff --git a/components/oap-hw-ext/rgb_led.c b/components/oap-hw-ext/rgb_led.c index 9d2245c..9469e20 100644 --- a/components/oap-hw-ext/rgb_led.c +++ b/components/oap-hw-ext/rgb_led.c @@ -45,7 +45,7 @@ static ledc_mode_t speed_mode = LEDC_HIGH_SPEED_MODE; static ledc_timer_config_t ledc_timer = { //set timer counter bit number - .bit_num = LEDC_TIMER_10_BIT, + .duty_resolution = LEDC_TIMER_10_BIT, //set frequency of pwm .freq_hz = 5000, //timer mode, @@ -70,12 +70,14 @@ void set_color(rgb_color_t color) { esp_err_t res; int duty; for (int c = 0; c < 3; c++) { - duty = calc_duty(color,c); - if ((res = ledc_set_duty(speed_mode, c, duty)) != ESP_OK) { - ESP_LOGW(TAG, "ledc_set_duty(%d,%d,%d) error %d", speed_mode, c, duty, res); - } - if ((res = ledc_update_duty(speed_mode, c)) != ESP_OK) { - ESP_LOGW(TAG, "ledc_update_duty(%d,%d) error %d", speed_mode, c, res); + if(led_gpio[c] != -1) { + duty = calc_duty(color,c); + if ((res = ledc_set_duty(speed_mode, c, duty)) != ESP_OK) { + ESP_LOGW(TAG, "ledc_set_duty(%d,%d,%d) error %d", speed_mode, c, duty, res); + } + if ((res = ledc_update_duty(speed_mode, c)) != ESP_OK) { + ESP_LOGW(TAG, "ledc_update_duty(%d,%d) error %d", speed_mode, c, res); + } } } } @@ -84,18 +86,20 @@ void fade_to_color(rgb_color_t color, int time) { esp_err_t res; int duty; for (int c = 0; c < 3; c++) { - duty = calc_duty(color,c); - if ((res = ledc_set_fade_with_time(speed_mode, c, duty,time)) != ESP_OK) { - ESP_LOGW(TAG, "ledc_set_fade_with_time(%d,%d,%d,%d) error %d", speed_mode, c, duty, time, res); - } - if ((res = ledc_fade_start(speed_mode, c, LEDC_FADE_NO_WAIT)) != ESP_OK) { - ESP_LOGW(TAG, "ledc_fade_start(%d,%d) error %d", c, LEDC_FADE_NO_WAIT, res); + if(led_gpio[c] != -1) { + duty = calc_duty(color,c); + if ((res = ledc_set_fade_with_time(speed_mode, c, duty,time)) != ESP_OK) { + ESP_LOGW(TAG, "ledc_set_fade_with_time(%d,%d,%d,%d) error %d", speed_mode, c, duty, time, res); + } + if ((res = ledc_fade_start(speed_mode, c, LEDC_FADE_NO_WAIT)) != ESP_OK) { + ESP_LOGW(TAG, "ledc_fade_start(%d,%d) error %d", c, LEDC_FADE_NO_WAIT, res); + } } } } static void setup_ledc() { - MAX_DUTY = pow(2,ledc_timer.bit_num)-1; + MAX_DUTY = pow(2,ledc_timer.duty_resolution)-1; ledc_timer_config(&ledc_timer); ledc_channel_config_t ledc_channel = { @@ -112,11 +116,13 @@ static void setup_ledc() { }; for (int c = 0; c < 3; c++) { - ledc_channel.channel = c; //LEDC_CHANNEL_0 to LEDC_CHANNEL_2 - ledc_channel.gpio_num = led_gpio[c]; - ledc_channel.duty = 0; - gpio_intr_disable(led_gpio[c]); - ledc_channel_config(&ledc_channel); + if(led_gpio[c] != -1) { + ledc_channel.channel = c; //LEDC_CHANNEL_0 to LEDC_CHANNEL_2 + ledc_channel.gpio_num = led_gpio[c]; + ledc_channel.duty = 0; + gpio_intr_disable(led_gpio[c]); + ledc_channel_config(&ledc_channel); + } } //initialize fade service. ledc_fade_func_install(0); @@ -169,7 +175,9 @@ void led_init(int enabled, xQueueHandle _cmd_queue) xTaskCreate(led_cycle, "led_cycle", 1024*2, NULL, DEFAULT_TASK_PRIORITY+1, NULL); } else { for (int c = 0; c < 3; c++) { - if (led_gpio[c] > 0) gpio_set_pull_mode(led_gpio[c], GPIO_PULLDOWN_ONLY); + if (led_gpio[c] != -1) { + gpio_set_pull_mode(led_gpio[c], GPIO_PULLDOWN_ONLY); + } } } } diff --git a/components/oap-hw-gpio/Kconfig b/components/oap-hw-gpio/Kconfig new file mode 100644 index 0000000..be873ef --- /dev/null +++ b/components/oap-hw-gpio/Kconfig @@ -0,0 +1,89 @@ +menu "OAP Generic GPIO" + +config OAP_GPIO_0_ENABLED + bool "enable GPIO #0" + default n + help + todo + +config OAP_GPIO_OUTPUT0_PIN + int "GPIO #0 output PIN" + depends on OAP_GPIO_0_ENABLED + default 5 + help + todo + +config OAP_GPIO_INPUT0_PIN + int "GPIO #0 input PIN" + depends on OAP_GPIO_0_ENABLED + default 21 + help + todo + +config OAP_GPIO_1_ENABLED + bool "enable GPIO #1" + default n + help + todo + +config OAP_GPIO_OUTPUT1_PIN + int "GPIO #1 output PIN" + depends on OAP_GPIO_1_ENABLED + default 12 + help + todo + +config OAP_GPIO_INPUT1_PIN + int "GPIO #1 input PIN" + depends on OAP_GPIO_1_ENABLED + default 22 + help + todo + +config OAP_GPIO_2_ENABLED + bool "enable GPIO #2" + default n + help + todo + +config OAP_GPIO_OUTPUT2_PIN + int "GPIO #2 output PIN" + depends on OAP_GPIO_2_ENABLED + default 18 + help + todo + +config OAP_GPIO_INPUT2_PIN + int "GPIO #2 input PIN" + depends on OAP_GPIO_2_ENABLED + default 36 + help + todo + +config OAP_GPIO_3_ENABLED + bool "enable GPIO #3" + default n + help + todo + +config OAP_GPIO_OUTPUT3_PIN + int "GPIO #3 output PIN" + depends on OAP_GPIO_3_ENABLED + default 19 + help + todo + +config OAP_GPIO_INPUT3_PIN + int "GPIO #3 input PIN" + depends on OAP_GPIO_3_ENABLED + default 39 + help + todo + +config OAP_GPIO_UDP_ENABLED + bool "enable GPIO UDP Server" + default n + help + todo + +endmenu diff --git a/components/oap-hw-gpio/component.mk b/components/oap-hw-gpio/component.mk new file mode 100644 index 0000000..61f8990 --- /dev/null +++ b/components/oap-hw-gpio/component.mk @@ -0,0 +1,8 @@ +# +# Main component makefile. +# +# This Makefile can be left empty. By default, it will take the sources in the +# src/ directory, compile them and link them into lib(subdirectory_name).a +# in the build directory. This behaviour is entirely configurable, +# please read the ESP-IDF documents if you need to do this. +# diff --git a/components/oap-hw-gpio/hw_gpio.c b/components/oap-hw-gpio/hw_gpio.c new file mode 100644 index 0000000..755102e --- /dev/null +++ b/components/oap-hw-gpio/hw_gpio.c @@ -0,0 +1,323 @@ +/* + * hw_gpio.c + * + * Created on: Jan 4, 2018 + * Author: Deti + * + * This file is part of OpenAirProject-ESP32. + * + * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * OpenAirProject-ESP32 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with OpenAirProject-ESP32. If not, see . + */ + +#include +#include +#include +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "driver/gpio.h" +#include "driver/pcnt.h" +#include "esp_log.h" +#include "hw_gpio.h" +#include "oap_debug.h" +#include "oap_data_env.h" + +#define ESP_INTR_FLAG_DEFAULT 0 + +static const char* TAG = "hw_gpio"; + +typedef struct { + uint8_t gpio_num; + uint8_t gpio_val; + int64_t timestamp; + int sensor_idx; +} gpio_event_t; + +typedef struct { + uint8_t value; + int64_t delay; +} cmd_event_t; + +static hw_gpio_config_t *hw_gpio_get_config(int idx) +{ + if(idx >= 0 && idx < HW_GPIO_DEVICES_MAX) { + return hw_gpio_cfg+idx; + } + return NULL; +} + +static void publish(hw_gpio_config_t* config) +{ + if (config->callback) { + env_data_t result = { + .sensor_idx = config->sensor_idx, + .sensor_type = sensor_gpio, + .gpio.GPIlastHigh=config->GPIlastHigh, + .gpio.GPIlastLow=config->GPIlastLow, + .gpio.GPICounter=config->GPICounter, + .gpio.GPICountDelta=config->GPICounter-config->GPICountLast, + .gpio.GPOlastOut=config->GPOlastOut, + .gpio.GPOlastVal=config->GPOlastVal, + .gpio.GPOtriggerLength=config->GPOtriggerLength + }; + config->GPICountLast=config->GPICounter; + config->callback(&result); + } +} + +esp_err_t hw_gpio_send_trigger(hw_gpio_config_t* config, int value, int delay) +{ + gpio_set_level(config->output_pin, value); + config->GPOtriggerLength=delay; + config->GPOlastVal=value; + config->GPOlastOut=get_time_millis(); + publish(config); + return ESP_OK; +} + +esp_err_t hw_gpio_queue_trigger(int sensor_idx, int value, int delay) +{ + ESP_LOGI(TAG,"hw_gpio_queue_trigger: %d %d %d", sensor_idx, value, delay); + hw_gpio_config_t *config=hw_gpio_get_config(sensor_idx); + if(config) { + cmd_event_t cmd={.value = value, .delay =delay}; + xQueueSend(config->cmd_evt_queue, &cmd, 10 / portTICK_RATE_MS); + return ESP_OK; + } + return ESP_FAIL; +} + +static void IRAM_ATTR hw_gpio_isr_handler(void* arg) +{ + hw_gpio_config_t* config=(hw_gpio_config_t*) arg; + + gpio_event_t hw_gpio_evt = { + .gpio_num = config->input_pin, + .gpio_val = gpio_get_level(config->input_pin), + .sensor_idx = config->sensor_idx + }; + if(hw_gpio_evt.gpio_val) { + config->GPICounter++; + } + xQueueSendFromISR(config->gpio_evt_queue, &hw_gpio_evt, NULL); +} + +#ifdef PCNT +typedef struct { + int unit; // the PCNT unit that originated an interrupt + uint32_t status; // information on the event type that caused the interrupt +} pcnt_evt_t; + +static void IRAM_ATTR pcnt_intr_handler(void *arg) +{ + hw_gpio_config_t* config=(hw_gpio_config_t*) arg; + uint32_t intr_status = PCNT.int_st.val; + int i; + pcnt_evt_t evt; + portBASE_TYPE HPTaskAwoken = pdFALSE; + + for (i = 0; i < PCNT_UNIT_MAX; i++) { + if (intr_status & (BIT(i))) { + evt.unit = i; + /* Save the PCNT event type that caused an interrupt + to pass it to the main program */ + evt.status = PCNT.status_unit[i].val; + if(evt.status == PCNT_STATUS_H_LIM_M) { + pcnt_counter_clear(PCNT_UNIT_0); + } + PCNT.int_clr.val = BIT(i); + xQueueSendFromISR(config->pcnt_evt_queue, &evt, &HPTaskAwoken); + if (HPTaskAwoken == pdTRUE) { + portYIELD_FROM_ISR(); + } + } + } +} +#endif +static void hw_gpio_task(hw_gpio_config_t* config) { + gpio_event_t hw_gpio_evt; + cmd_event_t cmd_evt; + while(1) { + if(config->enabled) { + if (xQueueReceive(config->gpio_evt_queue, &hw_gpio_evt, 10 / portTICK_PERIOD_MS)) { +// ESP_LOGD(TAG, "%d/%d v:%d t:%d", config->sensor_idx, hw_gpio_evt.sensor_idx, hw_gpio_evt.gpio_val, hw_gpio_evt.timestamp); + if (config->callback) { + int64_t ms=get_time_millis(); + if(hw_gpio_evt.gpio_val) { + config->GPIlastHigh=ms; + } else { + config->GPIlastLow=ms; + } + if((ms - config->lastPublish) > 1000) { + config->lastPublish = ms; + publish(config); + } + } + } + if (xQueueReceive(config->cmd_evt_queue, &cmd_evt, 10 / portTICK_PERIOD_MS)) { + hw_gpio_send_trigger(config, cmd_evt.value, cmd_evt.delay); + } +#ifdef PCNT + pcnt_evt_t evt; + portBASE_TYPE res = xQueueReceive(config->pcnt_evt_queue, &evt, 10 / portTICK_PERIOD_MS); + if (res == pdTRUE) { + int16_t count = 0; + pcnt_get_counter_value(PCNT_UNIT_0, &count); + ESP_LOGD(TAG, "Event PCNT unit[%d]; cnt: %d", evt.unit, count); + if (evt.status & PCNT_STATUS_THRES1_M) { + ESP_LOGD(TAG, "THRES1 EVT"); + } + if (evt.status & PCNT_STATUS_THRES0_M) { + ESP_LOGD(TAG, "THRES0 EVT"); + } + if (evt.status & PCNT_STATUS_L_LIM_M) { + ESP_LOGD(TAG, "L_LIM EVT"); + } + if (evt.status & PCNT_STATUS_H_LIM_M) { + ESP_LOGD(TAG, "H_LIM EVT"); + } + if (evt.status & PCNT_STATUS_ZERO_M) { + ESP_LOGD(TAG, "ZERO EVT"); + } + } else { + pcnt_get_counter_value(PCNT_UNIT_0, &count); + printf("Current counter value :%d", count); + } +#endif + if(config->GPOtriggerLength && (get_time_millis()-config->GPOlastOut) >= config->GPOtriggerLength) { + config->GPOlastVal=!config->GPOlastVal; + config->GPOlastOut=get_time_millis(); + gpio_set_level(config->output_pin, config->GPOlastVal); + config->GPOtriggerLength=0; + publish(config); + } + } + if (config->interval > 0) { + delay(config->interval); + } else { + break; + } + } + vTaskDelete(NULL); +} + +esp_err_t hw_gpio_enable(hw_gpio_config_t* config, uint8_t enabled) { + ESP_LOGI(TAG,"enable(%d)",enabled); + config->enabled = enabled; + return ESP_OK; //todo +} + +esp_err_t hw_gpio_init(hw_gpio_config_t* config) { + hw_gpio_enable(config, 0); + + char task_name[100]; + sprintf(task_name, "gpio_sensor_%d", config->sensor_idx); + config->gpio_evt_queue = xQueueCreate(10, sizeof(gpio_event_t)); + config->cmd_evt_queue = xQueueCreate(10, sizeof(cmd_event_t)); + + gpio_pad_select_gpio(config->input_pin); + gpio_set_direction(config->input_pin, GPIO_MODE_INPUT); + gpio_set_pull_mode(config->input_pin, GPIO_PULLDOWN_ONLY); + gpio_set_intr_type(config->input_pin, GPIO_INTR_ANYEDGE); + +#ifdef PCNT + config->pcnt_evt_queue = xQueueCreate(10, sizeof(pcnt_evt_t)); + pcnt_config_t pcnt_config = { + .pulse_gpio_num = config->input_pin, + .ctrl_gpio_num = -1, + .channel = PCNT_CHANNEL_0, + .unit = PCNT_UNIT_0, + .pos_mode = PCNT_COUNT_INC, + .neg_mode = PCNT_COUNT_INC, + .lctrl_mode = PCNT_MODE_KEEP, + .hctrl_mode = PCNT_MODE_KEEP, + .counter_h_lim = 32767, + .counter_l_lim = 0, + }; + pcnt_unit_config(&pcnt_config); + + pcnt_set_filter_value(PCNT_UNIT_0, 100); + pcnt_filter_enable(PCNT_UNIT_0); + +// pcnt_set_event_value(PCNT_UNIT_0, PCNT_EVT_THRES_1, 20); +// pcnt_event_enable(PCNT_UNIT_0, PCNT_EVT_THRES_1); + pcnt_set_event_value(PCNT_UNIT_0, PCNT_EVT_THRES_0, 10); + pcnt_event_enable(PCNT_UNIT_0, PCNT_EVT_THRES_0); + + /* Enable events on zero, maximum and minimum limit values */ +// pcnt_event_enable(PCNT_UNIT_0, PCNT_EVT_ZERO); + pcnt_event_enable(PCNT_UNIT_0, PCNT_EVT_H_LIM); +// pcnt_event_enable(PCNT_UNIT_0, PCNT_EVT_L_LIM); + + /* Initialize PCNT's counter */ + pcnt_counter_pause(PCNT_UNIT_0); + pcnt_counter_clear(PCNT_UNIT_0); + + /* Register ISR handler and enable interrupts for PCNT unit */ + pcnt_isr_register(pcnt_intr_handler, config, 0, NULL); + pcnt_intr_enable(PCNT_UNIT_0); + + /* Everything is set up, now go to counting */ + pcnt_counter_resume(PCNT_UNIT_0); +#endif + gpio_pad_select_gpio(config->output_pin); + gpio_set_direction(config->output_pin, GPIO_MODE_OUTPUT); + gpio_set_level(config->output_pin, 0); + + ESP_LOGD(TAG, "init output pin: %d input pin: %d", config->output_pin, config->input_pin); + gpio_isr_handler_add(config->input_pin, hw_gpio_isr_handler, config); + + //2kb leaves ~ 240 bytes free (depend on logs, printfs etc) + xTaskCreate((TaskFunction_t)hw_gpio_task, task_name, 1024*3, config, DEFAULT_TASK_PRIORITY, NULL); + return ESP_OK; //todo +} + +esp_err_t hw_gpio_set_hardware_config(hw_gpio_config_t* config, uint8_t sensor_idx) { + config->sensor_idx = sensor_idx; + switch(sensor_idx) { + case 5: +#ifdef CONFIG_OAP_GPIO_0_ENABLED + config->output_pin = CONFIG_OAP_GPIO_OUTPUT0_PIN; + config->input_pin = CONFIG_OAP_GPIO_INPUT0_PIN; +#else + return ESP_FAIL; +#endif + break; + case 6: +#ifdef CONFIG_OAP_GPIO_1_ENABLED + config->output_pin = CONFIG_OAP_GPIO_OUTPUT1_PIN; + config->input_pin = CONFIG_OAP_GPIO_INPUT1_PIN; +#else + return ESP_FAIL; +#endif + break; + case 7: +#ifdef CONFIG_OAP_GPIO_2_ENABLED + config->output_pin = CONFIG_OAP_GPIO_OUTPUT2_PIN; + config->input_pin = CONFIG_OAP_GPIO_INPUT2_PIN; +#else + return ESP_FAIL; +#endif + break; + case 8: +#ifdef CONFIG_OAP_GPIO_3_ENABLED + config->output_pin = CONFIG_OAP_GPIO_OUTPUT3_PIN; + config->input_pin = CONFIG_OAP_GPIO_INPUT3_PIN; +#else + return ESP_FAIL; +#endif + break; + } + return ESP_OK; +} diff --git a/components/oap-hw-gpio/include/hw_gpio.h b/components/oap-hw-gpio/include/hw_gpio.h new file mode 100644 index 0000000..e71f235 --- /dev/null +++ b/components/oap-hw-gpio/include/hw_gpio.h @@ -0,0 +1,71 @@ +/* + * mhz19.h + * + * Created on: Jan 4, 2018 + * Author: Deti + * + * This file is part of OpenAirProject-ESP32. + * + * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * OpenAirProject-ESP32 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with OpenAirProject-ESP32. If not, see . + */ + +#ifndef MAIN_HW_GPIO_H_ +#define MAIN_HW_GPIO_H_ + +#include "oap_common.h" +#include "oap_data_env.h" + +#define HW_GPIO_DEVICES_MAX 4 + +typedef void(*env_callback)(env_data_t*); + +typedef struct { + uint8_t enabled; //internal, read-only + uint8_t sensor_idx; + uint32_t interval; + env_callback callback; + uint8_t output_pin; + uint8_t input_pin; + QueueHandle_t gpio_evt_queue; + QueueHandle_t pcnt_evt_queue; + QueueHandle_t cmd_evt_queue; + int64_t GPIlastLow; + int64_t GPIlastHigh; + int64_t GPOlastOut; + int64_t GPICounter; + int64_t GPICountLast; + int64_t GPICountDelta; + int32_t GPOtriggerLength; + int8_t GPOlastVal; + int64_t lastPublish; +} hw_gpio_config_t; + +extern hw_gpio_config_t hw_gpio_cfg[]; + +esp_err_t hw_gpio_init(hw_gpio_config_t* config); + +/** + * enable/disable sensor. + */ +esp_err_t hw_gpio_enable(hw_gpio_config_t* config, uint8_t enabled); +/** + * fill config based on hardware configuration + */ +esp_err_t hw_gpio_set_hardware_config(hw_gpio_config_t* config, uint8_t sensor_idx); +/** + * trigger output of gpio + */ +esp_err_t hw_gpio_queue_trigger(int sensor_idx, int value, int delay); + +#endif /* MAIN_MHZ19_H_ */ diff --git a/components/oap-hw-gpio/include/udp_server.h b/components/oap-hw-gpio/include/udp_server.h new file mode 100644 index 0000000..0957f73 --- /dev/null +++ b/components/oap-hw-gpio/include/udp_server.h @@ -0,0 +1,21 @@ +#ifndef UDPServer_h +#define UDPServer_h + +#include +#include +#include +#include +#include +#include + +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" + +#include "esp_system.h" +#include "esp_spi_flash.h" +#include "esp_wifi.h" +#include "esp_event_loop.h" + +esp_err_t udp_server(); + +#endif /* UDPServer_h */ diff --git a/components/oap-hw-gpio/udp_server.c b/components/oap-hw-gpio/udp_server.c new file mode 100644 index 0000000..85bd746 --- /dev/null +++ b/components/oap-hw-gpio/udp_server.c @@ -0,0 +1,149 @@ +#include "udp_server.h" +#include "hw_gpio.h" + +#ifdef CONFIG_OAP_GPIO_UDP_ENABLED + +#define PORT_NUMBER 6789 +#define BUFLEN 512 + +#ifdef XML_LARGE_SIZE +# if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400 +# define XML_FMT_INT_MOD "I64" +# else +# define XML_FMT_INT_MOD "ll" +# endif +#else +# define XML_FMT_INT_MOD "l" +#endif + +#ifdef XML_UNICODE_WCHAR_T +# define XML_FMT_STR "ls" +#else +# define XML_FMT_STR "s" +#endif + +static char tag[]="udpserver"; +int mysocket; +typedef struct { + int depth; + int gpio; + int value; + int delay; +} gpio_vals_t; + +int get_socket_error_code(int socket) +{ + int result; + u32_t optlen = sizeof(int); + if(getsockopt(socket, SOL_SOCKET, SO_ERROR, &result, &optlen) == -1) { + ESP_LOGE(tag, "getsockopt failed"); + return -1; + } + return result; + +} + +int show_socket_error_reason(int socket) +{ + int err = get_socket_error_code(socket); + ESP_LOGW(tag, "socket error %d %s", err, strerror(err)); + return err; +} + +void close_socket(int socket) +{ + close(socket); +} + +static void XMLCALL startElement(void *userData, const XML_Char *name, const XML_Char **attr) +{ + gpio_vals_t *gpiovals = (gpio_vals_t *)userData; + + if(!strcasecmp(name, "gpio")) { + int valid=0; + for (int i = 0; attr[i]; i += 2) { + const char *an=attr[i]; + const char *av=attr[i+1]; + if(!strcasecmp(an, "num")) { + gpiovals->gpio=atoi(av); + valid++; + }else if(!strcasecmp(an, "delay")) { + gpiovals->delay=atoi(av); + valid++; + }else if(!strcasecmp(an, "value")) { + gpiovals->value=atoi(av); + valid++; + } + } + if(valid==3) { + hw_gpio_queue_trigger(gpiovals->gpio, gpiovals->value, gpiovals->delay); + } + } +// ESP_LOGI(tag, "gpio: %d delay: %d value: %d", gpiovals->gpio, gpiovals->delay, gpiovals->value); + gpiovals->depth++; +} + +static void XMLCALL endElement(void *userData, const XML_Char *name) +{ + gpio_vals_t *gpiovals = (gpio_vals_t *)userData; + gpiovals->depth--; +} + + +// UDP Listener +esp_err_t udp_server() +{ + struct sockaddr_in si_other; + + unsigned int slen = sizeof(si_other),recv_len; + char buf[BUFLEN]; + + // bind to socket + ESP_LOGI(tag, "bind_udp_server port:%d", PORT_NUMBER); + mysocket = socket(AF_INET, SOCK_DGRAM, 0); + if (mysocket < 0) { + show_socket_error_reason(mysocket); + return ESP_FAIL; + } + struct sockaddr_in server_addr; + server_addr.sin_family = AF_INET; + server_addr.sin_port = htons(PORT_NUMBER); + server_addr.sin_addr.s_addr = htonl(INADDR_ANY); + if (bind(mysocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) { + show_socket_error_reason(mysocket); + close(mysocket); + return ESP_FAIL; + } else { + ESP_LOGI(tag,"socket created without errors"); + while(1) { +//c ESP_LOGI(tag,"Waiting for incoming data"); + memset(buf,0,BUFLEN); + + if ((recv_len = recvfrom(mysocket, buf, BUFLEN, 0, (struct sockaddr *) &si_other, &slen)) == -1) { + ESP_LOGE(tag,"recvfrom"); + } + +// ESP_LOGI(tag,"Received packet from %s:%d\n", inet_ntoa(si_other.sin_addr), ntohs(si_other.sin_port)); +// ESP_LOGI(tag,"Data: %s -- %d\n" , buf, recv_len); + + if ((recv_len + 1) < BUFLEN) { + buf[recv_len + 1] = '\0'; + XML_Parser parser = XML_ParserCreate(NULL); + gpio_vals_t gpiovals; + XML_SetUserData(parser, &gpiovals); + XML_SetElementHandler(parser, startElement, endElement); + if (XML_Parse(parser, buf, (int)recv_len, 1) == XML_STATUS_ERROR) { + ESP_LOGE(tag, "Parse error at line %" XML_FMT_INT_MOD "u:\n%" XML_FMT_STR "\n", + XML_GetCurrentLineNumber(parser), + XML_ErrorString(XML_GetErrorCode(parser))); + } else { + } + XML_ParserFree(parser); + } + } + close(mysocket); + return ESP_FAIL; + } + return ESP_OK; +} +#endif diff --git a/components/oap-hw-hc-sr04/Kconfig b/components/oap-hw-hc-sr04/Kconfig new file mode 100644 index 0000000..c5c0e9c --- /dev/null +++ b/components/oap-hw-hc-sr04/Kconfig @@ -0,0 +1,43 @@ +menu "OAP HC-SR04 distance sensor" + +config OAP_HCSR04_0_ENABLED + bool "enable ultrasonic distance sensor #0 SR-HC04" + default y + help + todo + +config OAP_HCSR04_TRIGGER0_PIN + int "Trigger 0 output PIN" + depends on OAP_HCSR04_0_ENABLED + default 32 + help + todo + +config OAP_HCSR04_ECHO0_PIN + int "Echo 0 input PIN" + depends on OAP_HCSR04_0_ENABLED + default 34 + help + todo + +config OAP_HCSR04_1_ENABLED + bool "enable ultrasonic dinstance sensor #1 SR-HC04" + default y + help + todo + +config OAP_HCSR04_TRIGGER1_PIN + int "Trigger 1 output PIN" + depends on OAP_HCSR04_1_ENABLED + default 33 + help + todo + +config OAP_HCSR04_ECHO1_PIN + int "Echo 1 input PIN" + depends on OAP_HCSR04_1_ENABLED + default 35 + help + todo + +endmenu diff --git a/components/oap-hw-hc-sr04/component.mk b/components/oap-hw-hc-sr04/component.mk new file mode 100644 index 0000000..61f8990 --- /dev/null +++ b/components/oap-hw-hc-sr04/component.mk @@ -0,0 +1,8 @@ +# +# Main component makefile. +# +# This Makefile can be left empty. By default, it will take the sources in the +# src/ directory, compile them and link them into lib(subdirectory_name).a +# in the build directory. This behaviour is entirely configurable, +# please read the ESP-IDF documents if you need to do this. +# diff --git a/components/oap-hw-hc-sr04/hcsr04.c b/components/oap-hw-hc-sr04/hcsr04.c new file mode 100644 index 0000000..e51b7e0 --- /dev/null +++ b/components/oap-hw-hc-sr04/hcsr04.c @@ -0,0 +1,183 @@ +/* + * hcsr04.c + * + * Created on: Jan 4, 2018 + * Author: Deti + * + * This file is part of OpenAirProject-ESP32. + * + * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * OpenAirProject-ESP32 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with OpenAirProject-ESP32. If not, see . + */ + +#include +#include +#include +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "driver/gpio.h" +#include "esp_log.h" +#include "hcsr04.h" +#include "oap_debug.h" +#include "oap_data_env.h" + +#define ESP_INTR_FLAG_DEFAULT 0 + +static const char* TAG = "hcsr04"; + +typedef struct { + uint8_t gpio_num; + uint8_t gpio_val; + uint32_t timestamp; + int sensor_idx; +} hcsr04_event_t; + +static double calc_dist(int time_diff) { + return 100*((time_diff/1000000.0)*340.29)/2; +} + +static void send_trigger(hcsr04_config_t* config) { + gpio_set_level(config->trigger_pin, 1); + ets_delay_us(10); + gpio_set_level(config->trigger_pin, 0); + config->state=WAITFORECHO; +} + +static void IRAM_ATTR hcsr04_isr_handler(void* arg) +{ + hcsr04_config_t* config=(hcsr04_config_t*) arg; + + hcsr04_event_t hcsr04_evt = { + .gpio_num = config->echo_pin, + .gpio_val = gpio_get_level(config->echo_pin), + .timestamp = system_get_time(), + .sensor_idx = config->sensor_idx + }; + xQueueSendFromISR(config->hcsr04_evt_queue, &hcsr04_evt, NULL); +} + +static void hcsr04_task(hcsr04_config_t* config) { + hcsr04_event_t gpio_evt; + uint32_t startpulse=0; + uint32_t endpulse=0; +// send_trigger(config); + while(1) { + if(config->enabled) { + if (xQueueReceive(config->hcsr04_evt_queue, &gpio_evt, 100)) { + ESP_LOGD(TAG, "%d/%d s:%d v:%d t:%d", config->sensor_idx, gpio_evt.sensor_idx, config->state, gpio_evt.gpio_val, gpio_evt.timestamp); + switch(config->state) { + case WAITFORECHO: + if(gpio_evt.gpio_val) { + startpulse=gpio_evt.timestamp; + config->state = RECEIVE; + ESP_LOGD(TAG, "sensor: %d state: %d start pulse", config->sensor_idx, config->state); + } else { + ESP_LOGD(TAG, "sensor: %d state: %d invalid val: %d", config->sensor_idx, config->state, gpio_evt.gpio_val); + } + break; + case RECEIVE: + if(!gpio_evt.gpio_val) { + endpulse=gpio_evt.timestamp; + double distance = calc_dist(endpulse-startpulse); + ESP_LOGD(TAG, "sensor: %d difference: %d distance: %.2f", config->sensor_idx, endpulse-startpulse, distance); + if (distance <= 400 && config->callback) { + env_data_t result = { + .sensor_idx = config->sensor_idx, + .sensor_type = sensor_hcsr04, + .hcsr04.distance = sma_generator(&config->sma, distance) + }; + config->callback(&result); + } + config->state = IDLE; + } else { + ESP_LOGD(TAG, "sensor: %d state: %d invalid val: %d", config->sensor_idx, config->state, gpio_evt.gpio_val); + } + break; + case IDLE: + break; + + } + } else { + ESP_LOGD(TAG, "sensor: %d ping", config->sensor_idx); + send_trigger(config); + } + } + + if (config->interval > 0) { + delay(config->interval); + } else { + break; + } + } + vTaskDelete(NULL); +} + +esp_err_t hcsr04_enable(hcsr04_config_t* config, uint8_t enabled) { + ESP_LOGI(TAG,"enable(%d)",enabled); + config->enabled = enabled; + return ESP_OK; //todo +} + +esp_err_t hcsr04_init(hcsr04_config_t* config) { + hcsr04_enable(config, 0); + + char task_name[100]; + sprintf(task_name, "hcsr04_sensor_%d", config->sensor_idx); + config->hcsr04_evt_queue = xQueueCreate(10, sizeof(hcsr04_event_t)); + + gpio_pad_select_gpio(config->echo_pin); + gpio_set_direction(config->echo_pin, GPIO_MODE_INPUT); + gpio_set_pull_mode(config->echo_pin, GPIO_PULLDOWN_ONLY); + gpio_set_intr_type(config->echo_pin, GPIO_INTR_ANYEDGE); + + gpio_pad_select_gpio(config->trigger_pin); + gpio_set_direction(config->trigger_pin, GPIO_MODE_OUTPUT); + gpio_set_level(config->trigger_pin, 0); + + config->state = IDLE; + ESP_LOGD(TAG, "init Trigger: %d Echo: %d", config->trigger_pin, config->echo_pin); + gpio_isr_handler_add(config->echo_pin, hcsr04_isr_handler, config); + + //2kb leaves ~ 240 bytes free (depend on logs, printfs etc) + xTaskCreate((TaskFunction_t)hcsr04_task, task_name, 1024*3, config, DEFAULT_TASK_PRIORITY, NULL); + return ESP_OK; //todo +} + +#define SMA_SIZE 5 +esp_err_t hcsr04_set_hardware_config(hcsr04_config_t* config, uint8_t sensor_idx) { + config->sensor_idx = sensor_idx; + switch(sensor_idx) { + case 3: +#ifdef CONFIG_OAP_HCSR04_0_ENABLED + config->trigger_pin = CONFIG_OAP_HCSR04_TRIGGER0_PIN; + config->echo_pin = CONFIG_OAP_HCSR04_ECHO0_PIN; +#else + return ESP_FAIL; +#endif + break; + case 4: +#ifdef CONFIG_OAP_HCSR04_1_ENABLED + config->trigger_pin = CONFIG_OAP_HCSR04_TRIGGER1_PIN; + config->echo_pin = CONFIG_OAP_HCSR04_ECHO1_PIN; +#else + return ESP_FAIL; +#endif + break; + } + memset(&config->sma, 0, sizeof(sma_data_t)); + config->sma.data = (double *)malloc(SMA_SIZE*sizeof(double)); + memset((void*)config->sma.data, 0, SMA_SIZE*sizeof(double)); + config->sma.size=(size_t)SMA_SIZE; + return ESP_OK; +} diff --git a/components/oap-hw-hc-sr04/include/hcsr04.h b/components/oap-hw-hc-sr04/include/hcsr04.h new file mode 100644 index 0000000..43f0312 --- /dev/null +++ b/components/oap-hw-hc-sr04/include/hcsr04.h @@ -0,0 +1,67 @@ +/* + * mhz19.h + * + * Created on: Jan 4, 2018 + * Author: Deti + * + * This file is part of OpenAirProject-ESP32. + * + * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * OpenAirProject-ESP32 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with OpenAirProject-ESP32. If not, see . + */ + +#ifndef MAIN_HCSR04_H_ +#define MAIN_HCSR04_H_ + +#include "oap_common.h" +#include "oap_data_env.h" + +#define HW_HCSR04_DEVICES_MAX 2 + +typedef void(*env_callback)(env_data_t*); + +typedef enum { + IDLE = 0, + WAITFORECHO, + RECEIVE +} hcsr04_state_t; + +typedef struct { + uint8_t enabled; //internal, read-only + uint8_t sensor_idx; + uint32_t interval; + env_callback callback; + uint8_t trigger_pin; + uint8_t echo_pin; + hcsr04_state_t state; + QueueHandle_t hcsr04_evt_queue; + sma_data_t sma; +} hcsr04_config_t; + +/** + * pm samples data is send to the queue. + */ +esp_err_t hcsr04_init(hcsr04_config_t* config); + +/** + * enable/disable sensor. + */ +esp_err_t hcsr04_enable(hcsr04_config_t* config, uint8_t enabled); + + +/** + * fill config based on hardware configuration + */ +esp_err_t hcsr04_set_hardware_config(hcsr04_config_t* config, uint8_t sensor_idx); + +#endif /* MAIN_MHZ19_H_ */ diff --git a/components/oap-hw-mhz19/Kconfig b/components/oap-hw-mhz19/Kconfig new file mode 100644 index 0000000..4685710 --- /dev/null +++ b/components/oap-hw-mhz19/Kconfig @@ -0,0 +1,30 @@ +menu "OAP MH-Z19 CO2 Sensor" + +config OAP_MH_ENABLED + bool "enable MH-Z19 CO2 Sensor" + default y + help + todo + +config OAP_MH_UART_NUM + hex "uart num" + depends on OAP_MH_ENABLED + default 2 + help + todo + +config OAP_MH_UART_RXD_PIN + int "RX gpio" + depends on OAP_MH_ENABLED + default 16 + help + GPIO pin connected to sensor RX line. This pin can be R/O (>=34). + +config OAP_MH_UART_TXD_PIN + int "TX gpio" + depends on OAP_MH_ENABLED + default 17 + help + GPIO pin connected to sensor TX line. + +endmenu diff --git a/components/oap-hw-mhz19/component.mk b/components/oap-hw-mhz19/component.mk new file mode 100644 index 0000000..61f8990 --- /dev/null +++ b/components/oap-hw-mhz19/component.mk @@ -0,0 +1,8 @@ +# +# Main component makefile. +# +# This Makefile can be left empty. By default, it will take the sources in the +# src/ directory, compile them and link them into lib(subdirectory_name).a +# in the build directory. This behaviour is entirely configurable, +# please read the ESP-IDF documents if you need to do this. +# diff --git a/components/oap-hw-mhz19/include/mhz19.h b/components/oap-hw-mhz19/include/mhz19.h new file mode 100644 index 0000000..041f1f9 --- /dev/null +++ b/components/oap-hw-mhz19/include/mhz19.h @@ -0,0 +1,63 @@ +/* + * mhz19.h + * + * Created on: Jan 4, 2018 + * Author: Deti + * + * This file is part of OpenAirProject-ESP32. + * + * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * OpenAirProject-ESP32 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with OpenAirProject-ESP32. If not, see . + */ + +#ifndef MAIN_MHZ19_H_ +#define MAIN_MHZ19_H_ + +#include "oap_common.h" +#include "oap_data_env.h" +#include "driver/uart.h" + +#define HW_MHZ19_DEVICES_MAX 1 + +typedef void(*env_callback)(env_data_t*); + +typedef struct { + uint8_t indoor; + uint8_t enabled; //internal, read-only + uint8_t sensor_idx; + uint32_t interval; + env_callback callback; + uart_port_t uart_num; + uint8_t uart_txd_pin; + uint8_t uart_rxd_pin; + sma_data_t sma; +} mhz19_config_t; + +extern mhz19_config_t mhz19_cfg[]; + +esp_err_t mhz19_init(mhz19_config_t* config); + +/** + * enable/disable sensor. + */ +esp_err_t mhz19_enable(mhz19_config_t* config, uint8_t enabled); + + +esp_err_t mhz19_calibrate(mhz19_config_t* config); + +/** + * fill config based on hardware configuration + */ +esp_err_t mhz19_set_hardware_config(mhz19_config_t* config, uint8_t sensor_idx); + +#endif /* MAIN_MHZ19_H_ */ diff --git a/components/oap-hw-mhz19/mhz19.c b/components/oap-hw-mhz19/mhz19.c new file mode 100644 index 0000000..c824cb9 --- /dev/null +++ b/components/oap-hw-mhz19/mhz19.c @@ -0,0 +1,188 @@ +/* + * mhz19.c + * + * Created on: Jan 4, 2018 + * Author: Deti + * + * This file is part of OpenAirProject-ESP32. + * + * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * OpenAirProject-ESP32 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with OpenAirProject-ESP32. If not, see . + */ + +#include +#include +#include +#include +#include "freertos/FreeRTOS.h" +#include "driver/gpio.h" +#include "driver/uart.h" +#include "soc/uart_struct.h" +#include "esp_log.h" +#include "mhz19.h" +#include "oap_debug.h" +#include "oap_data_env.h" + +#define OAP_MHZ_UART_BUF_SIZE (128) + +static const char* TAG = "mhz19"; + +esp_err_t mhz19_init_uart(mhz19_config_t* config) { + //configure UART + uart_config_t uart_config = { + .baud_rate = 9600, + .data_bits = UART_DATA_8_BITS, + .parity = UART_PARITY_DISABLE, + .stop_bits = UART_STOP_BITS_1, + .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, + .rx_flow_ctrl_thresh = 122, + }; + esp_err_t ret; + if ((ret = uart_param_config(config->uart_num, &uart_config)) != ESP_OK) { + return ret; + } + + if ((ret = uart_set_pin(config->uart_num, config->uart_txd_pin, config->uart_rxd_pin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE)) != ESP_OK) { + return ret; + } + //Install UART driver( We don't need an event queue here) + + ret = uart_driver_install(config->uart_num, OAP_MHZ_UART_BUF_SIZE * 2, 0, 0, NULL,0); + return ret; +} + +static int mhz19_check(uint8_t *packet) { + unsigned char checksum=0; + for(int i=1; i<8; i++) { + checksum += packet[i]; + } + checksum = 0xff-checksum; + checksum += 1; + if(packet[8]!=checksum) { + packet[8]=checksum; + return 0; + } + return 1; +} + +typedef enum { + MH_Z19_READ_GAS_CONCENTRATION = 0x86, + MH_Z19_CALIBRATE_ZERO_POINT = 0x87, + MH_Z19_CALIBRATE_SPAN_POINT = 0x88, + MH_Z19_ABC_LOGIC = 0x79, + MH_Z19_SENSOR_DETECTION_RANGE = 0x99 +} mhz19_cmd_t; + +static int mhz19_cmd(mhz19_config_t* config, mhz19_cmd_t cmd, uint32_t val) { + uint8_t packet[9] = {0xff, 0x01, cmd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + switch(cmd) { + case MH_Z19_SENSOR_DETECTION_RANGE: + case MH_Z19_CALIBRATE_SPAN_POINT: + packet[3] = val >>8; + packet[4] = val & 255; + break; + case MH_Z19_ABC_LOGIC: + packet[3] = val?0xa0:0x00; + break; + case MH_Z19_CALIBRATE_ZERO_POINT: + case MH_Z19_READ_GAS_CONCENTRATION: + break; + } + mhz19_check(packet); + + return uart_write_bytes(config->uart_num, (const char *)packet, sizeof(packet));; +} + +static esp_err_t mhz19_cmd_gc(mhz19_config_t* config) { + if (config->enabled) { + int len=mhz19_cmd(config, MH_Z19_READ_GAS_CONCENTRATION, 0); + if(len == 9){ + uint8_t data[32]; + len = uart_read_bytes(config->uart_num, data, sizeof(data), 100 / portTICK_RATE_MS); + if(len == 9 && mhz19_check(data)){ + if(data[0]==0xff && data[1]==0x86) { + int co2val=(data[2]<<8) | data[3]; + int t=data[4]-40; + int s=data[5]; + int u=(data[6]<<8) | data[7]; + ESP_LOGD(TAG, "CO2: %d T:%d S:%d U:%d",co2val, t, s, u); + if (config->callback && co2val > 410 && co2val < 3000) { + env_data_t result = { + .sensor_idx = config->sensor_idx, + .sensor_type = sensor_mhz19, + .mhz19.temp = t, + .mhz19.co2 = sma_generator(&config->sma, co2val) + }; + config->callback(&result); + } + } + } + } + } + return ESP_OK; +} + +static void mhz19_task(mhz19_config_t* config) { + while(1) { + mhz19_cmd_gc(config); + if (config->interval > 0) { + delay(config->interval); + } else { + break; + } + } + vTaskDelete(NULL); +} + +esp_err_t mhz19_enable(mhz19_config_t* config, uint8_t enabled) { + ESP_LOGI(TAG,"enable(%d)",enabled); + config->enabled = enabled; + return ESP_OK; //todo +} + +esp_err_t mhz19_calibrate(mhz19_config_t* config) { + mhz19_cmd(config, MH_Z19_ABC_LOGIC, 0x0); + return mhz19_cmd(config, MH_Z19_CALIBRATE_ZERO_POINT, 0)==9?ESP_OK:ESP_FAIL; +} + +esp_err_t mhz19_init(mhz19_config_t* config) { + mhz19_enable(config, 0); + mhz19_init_uart(config); + + char task_name[100]; + sprintf(task_name, "mhz19_sensor_%d", config->sensor_idx); + + // set ABC logic on (0xa0) / off (0x00) + mhz19_cmd(config, MH_Z19_ABC_LOGIC, 0xa0); + + //2kb leaves ~ 240 bytes free (depend on logs, printfs etc) + xTaskCreate((TaskFunction_t)mhz19_task, task_name, 1024*3, config, DEFAULT_TASK_PRIORITY, NULL); + return ESP_OK; //todo +} +#define SMA_SIZE 60 +esp_err_t mhz19_set_hardware_config(mhz19_config_t* config, uint8_t sensor_idx) { +#ifdef CONFIG_OAP_MH_ENABLED + config->sensor_idx = sensor_idx; + config->uart_num = CONFIG_OAP_MH_UART_NUM; + config->uart_txd_pin = CONFIG_OAP_MH_UART_TXD_PIN; + config->uart_rxd_pin = CONFIG_OAP_MH_UART_RXD_PIN; + memset(&config->sma, 0, sizeof(sma_data_t)); + config->sma.data = (double *)malloc(SMA_SIZE*sizeof(double)); + memset((void*)config->sma.data, 0, SMA_SIZE*sizeof(double)); + config->sma.size=(size_t)SMA_SIZE; + return ESP_OK; +#else + return ESP_FAIL; +#endif +} diff --git a/components/oap-hw-pmsx003/Kconfig b/components/oap-hw-pmsx003/Kconfig index a6974ce..8be2abd 100644 --- a/components/oap-hw-pmsx003/Kconfig +++ b/components/oap-hw-pmsx003/Kconfig @@ -1,81 +1,71 @@ menu "OAP PMSx003 Sensor" +config OAP_PM_UART_ENABLE + bool "PM0 enable" + default y + help + todo + config OAP_PM_UART_NUM hex "uart num" + depends on OAP_PM_UART_ENABLE default 1 help todo config OAP_PM_SENSOR_CONTROL_PIN int "sensor set gpio" + depends on OAP_PM_UART_ENABLE default 10 help R/W GPIO pin connected to sensor SET line - it enables/disables sensor. config OAP_PM_UART_RXD_PIN int "RX gpio" + depends on OAP_PM_UART_ENABLE default 13 help GPIO pin connected to sensor RX line. This pin can be R/O (>=34). config OAP_PM_UART_TXD_PIN int "TX gpio" + depends on OAP_PM_UART_ENABLE default 5 help Any gpio pin (no need to connect this line) -config OAP_PM_UART_RTS_PIN - int "RTS gpio" - default 18 - help - Any gpio pin (no need to connect this line) - -config OAP_PM_UART_CTS_PIN - int "CTS gpio" - default 19 - help - Any gpio pin (no need to connect this line) - -config OAP_PM_ENABLED_AUX - int "enable secondary PM sensor" - default 0 +config OAP_PM_UART_AUX_ENABLE + bool "PM1 enable" + default n help todo config OAP_PM_UART_NUM_AUX hex "AUX uart num" + depends on OAP_PM_UART_AUX_ENABLE default 2 help todo config OAP_PM_SENSOR_CONTROL_PIN_AUX int "AUX sensor set gpio" + depends on OAP_PM_UART_AUX_ENABLE default 2 help R/W GPIO pin connected to sensor SET line - it enables/disables sensor. config OAP_PM_UART_RXD_PIN_AUX int "AUX RX gpio" + depends on OAP_PM_UART_AUX_ENABLE default 15 help GPIO pin connected to sensor RX line. This pin can be R/O (>=34). config OAP_PM_UART_TXD_PIN_AUX int "AUX TX gpio" + depends on OAP_PM_UART_AUX_ENABLE default 5 help Any gpio pin (no need to connect this line) -config OAP_PM_UART_RTS_PIN_AUX - int "AUX RTS gpio" - default 18 - help - Any gpio pin (no need to connect this line) - -config OAP_PM_UART_CTS_PIN_AUX - int "AUX CTS gpio" - default 19 - help - Any gpio pin (no need to connect this line) - endmenu \ No newline at end of file diff --git a/components/oap-hw-pmsx003/include/pmsx003.h b/components/oap-hw-pmsx003/include/pmsx003.h index 68d1b47..cf98ae0 100644 --- a/components/oap-hw-pmsx003/include/pmsx003.h +++ b/components/oap-hw-pmsx003/include/pmsx003.h @@ -36,8 +36,6 @@ typedef struct { uart_port_t uart_num; uint8_t uart_txd_pin; uint8_t uart_rxd_pin; - uint8_t uart_rts_pin; - uint8_t uart_cts_pin; } pmsx003_config_t; /** diff --git a/components/oap-hw-pmsx003/pmsx003.c b/components/oap-hw-pmsx003/pmsx003.c index 00ae311..b229261 100644 --- a/components/oap-hw-pmsx003/pmsx003.c +++ b/components/oap-hw-pmsx003/pmsx003.c @@ -31,6 +31,7 @@ #include "esp_log.h" #include "pmsx003.h" #include "oap_debug.h" +#include "oap_common.h" /* * Driver for Plantower PMS3003 / PMS5003 / PMS7003 dust sensors. @@ -52,34 +53,23 @@ esp_err_t pms_init_uart(pmsx003_config_t* config) { }; esp_err_t ret; if ((ret = uart_param_config(config->uart_num, &uart_config)) != ESP_OK) { + ESP_LOGE(TAG,"uart_param_config: %d", ret); return ret; } - if ((ret = uart_set_pin(config->uart_num, config->uart_txd_pin, config->uart_rxd_pin, config->uart_rts_pin, config->uart_cts_pin)) != ESP_OK) { + if ((ret = uart_set_pin(config->uart_num, config->uart_txd_pin, config->uart_rxd_pin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE)) != ESP_OK) { + ESP_LOGE(TAG,"uart_set_pin: %d", ret); return ret; } //Install UART driver( We don't need an event queue here) ret = uart_driver_install(config->uart_num, OAP_PM_UART_BUF_SIZE * 2, 0, 0, NULL,0); + if(ret != ESP_OK) { + ESP_LOGE(TAG,"uart_driver_install: %d", ret); + } return ret; } -static void configure_gpio(uint8_t gpio) { - if (gpio > 0) { - ESP_LOGD(TAG, "configure pin %d as output", gpio); - gpio_pad_select_gpio(gpio); - ESP_ERROR_CHECK(gpio_set_direction(gpio, GPIO_MODE_OUTPUT)); - ESP_ERROR_CHECK(gpio_set_pull_mode(gpio, GPIO_PULLDOWN_ONLY)); - } -} - -static void set_gpio(uint8_t gpio, uint8_t enabled) { - if (gpio > 0) { - ESP_LOGD(TAG, "set pin %d => %d", gpio, enabled); - gpio_set_level(gpio, enabled); - } -} - void pms_init_gpio(pmsx003_config_t* config) { configure_gpio(config->set_pin); } @@ -124,8 +114,8 @@ esp_err_t pmsx003_enable(pmsx003_config_t* config, uint8_t enabled) { ESP_LOGI(TAG,"enable(%d)",enabled); config->enabled = enabled; set_gpio(config->set_pin, enabled); - //if (config->heater_enabled) set_gpio(config->heater_pin, enabled); - //if (config->fan_enabled) set_gpio(config->fan_pin, enabled); +// if (config->heater_enabled) set_gpio(config->heater_pin, enabled); +// if (config->fan_enabled) set_gpio(config->fan_pin, enabled); return ESP_OK; //todo } @@ -144,23 +134,27 @@ esp_err_t pmsx003_init(pmsx003_config_t* config) { esp_err_t pmsx003_set_hardware_config(pmsx003_config_t* config, uint8_t sensor_idx) { if (sensor_idx == 0) { +#ifdef CONFIG_OAP_PM_UART_ENABLE config->sensor_idx = 0; config->set_pin = CONFIG_OAP_PM_SENSOR_CONTROL_PIN; config->uart_num = CONFIG_OAP_PM_UART_NUM; config->uart_txd_pin = CONFIG_OAP_PM_UART_TXD_PIN; config->uart_rxd_pin = CONFIG_OAP_PM_UART_RXD_PIN; - config->uart_rts_pin = CONFIG_OAP_PM_UART_RTS_PIN; - config->uart_cts_pin = CONFIG_OAP_PM_UART_CTS_PIN; return ESP_OK; - } else if (sensor_idx == 1 && CONFIG_OAP_PM_ENABLED_AUX) { +#else + return ESP_FAIL; +#endif + } else if (sensor_idx == 1) { +#ifdef CONFIG_OAP_PM_UART_AUX_ENABLE config->sensor_idx = 1; config->set_pin = CONFIG_OAP_PM_SENSOR_CONTROL_PIN_AUX; config->uart_num = CONFIG_OAP_PM_UART_NUM_AUX; config->uart_txd_pin = CONFIG_OAP_PM_UART_TXD_PIN_AUX; config->uart_rxd_pin = CONFIG_OAP_PM_UART_RXD_PIN_AUX; - config->uart_rts_pin = CONFIG_OAP_PM_UART_RTS_PIN_AUX; - config->uart_cts_pin = CONFIG_OAP_PM_UART_CTS_PIN_AUX; return ESP_OK; +#else + return ESP_FAIL; +#endif } else { return ESP_FAIL; } diff --git a/components/oap-hw-ssd1306/Kconfig b/components/oap-hw-ssd1306/Kconfig new file mode 100644 index 0000000..420a1aa --- /dev/null +++ b/components/oap-hw-ssd1306/Kconfig @@ -0,0 +1,8 @@ +menu "OAP SDD1306 OLED Display" + +config OAP_SDD1306_ENABLED + bool "enable SDD1306 OLED Display" + default y + help + todo +endmenu \ No newline at end of file diff --git a/components/oap-hw-ssd1306/component.mk b/components/oap-hw-ssd1306/component.mk new file mode 100644 index 0000000..61f8990 --- /dev/null +++ b/components/oap-hw-ssd1306/component.mk @@ -0,0 +1,8 @@ +# +# Main component makefile. +# +# This Makefile can be left empty. By default, it will take the sources in the +# src/ directory, compile them and link them into lib(subdirectory_name).a +# in the build directory. This behaviour is entirely configurable, +# please read the ESP-IDF documents if you need to do this. +# diff --git a/components/oap-hw-ssd1306/font8x8_basic.h b/components/oap-hw-ssd1306/font8x8_basic.h new file mode 100644 index 0000000..574171e --- /dev/null +++ b/components/oap-hw-ssd1306/font8x8_basic.h @@ -0,0 +1,174 @@ +/* + * font8x8_basic.h + * + * Created on: 2017/05/03 + * Author: yanbe + */ + +#ifndef MAIN_FONT8X8_BASIC_H_ +#define MAIN_FONT8X8_BASIC_H_ + +/* + Constant: font8x8_basic_tr + Contains an 90 digree transposed 8x8 font map for unicode points + U+0000 - U+007F (basic latin) + + To make it easy to use with SSD1306's GDDRAM mapping and API, + this constant is an 90 degree transposed. + The original version written by Marcel Sondaar is availble at: + https://github.com/dhepper/font8x8/blob/master/font8x8_basic.h + + Conversion is done via following procedure: + + for (int code = 0; code < 128; code++) { + uint8_t trans[8]; + for (int w = 0; w < 8; w++) { + trans[w] = 0x00; + for (int b = 0; b < 8; b++) { + trans[w] |= ((font8x8_basic[code][b] & (1 << w)) >> w) << b; + } + } + + for (int w = 0; w < 8; w++) { + if (w == 0) { printf(" { "); } + printf("0x%.2X", trans[w]); + if (w < 7) { printf(", "); } + if (w == 7) { printf(" }, // U+00%.2X (%c)\n", code, code); } + } + } +*/ + +uint8_t font8x8_basic_tr[128][8] = { + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0000 (nul) + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0001 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0002 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0003 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0004 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0005 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0006 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0007 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0008 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0009 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+000A + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+000B + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+000C + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+000D + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+000E + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+000F + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0010 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0011 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0012 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0013 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0014 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0015 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0016 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0017 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0018 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0019 + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+001A + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+001B + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+001C + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+001D + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+001E + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+001F + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0020 (space) + { 0x00, 0x00, 0x06, 0x5F, 0x5F, 0x06, 0x00, 0x00 }, // U+0021 (!) + { 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x00, 0x00 }, // U+0022 (") + { 0x14, 0x7F, 0x7F, 0x14, 0x7F, 0x7F, 0x14, 0x00 }, // U+0023 (#) + { 0x24, 0x2E, 0x6B, 0x6B, 0x3A, 0x12, 0x00, 0x00 }, // U+0024 ($) + { 0x46, 0x66, 0x30, 0x18, 0x0C, 0x66, 0x62, 0x00 }, // U+0025 (%) + { 0x30, 0x7A, 0x4F, 0x5D, 0x37, 0x7A, 0x48, 0x00 }, // U+0026 (&) + { 0x04, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }, // U+0027 (') + { 0x00, 0x1C, 0x3E, 0x63, 0x41, 0x00, 0x00, 0x00 }, // U+0028 (() + { 0x00, 0x41, 0x63, 0x3E, 0x1C, 0x00, 0x00, 0x00 }, // U+0029 ()) + { 0x08, 0x2A, 0x3E, 0x1C, 0x1C, 0x3E, 0x2A, 0x08 }, // U+002A (*) + { 0x08, 0x08, 0x3E, 0x3E, 0x08, 0x08, 0x00, 0x00 }, // U+002B (+) + { 0x00, 0x80, 0xE0, 0x60, 0x00, 0x00, 0x00, 0x00 }, // U+002C (,) + { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00 }, // U+002D (-) + { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00 }, // U+002E (.) + { 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00 }, // U+002F (/) + { 0x3E, 0x7F, 0x71, 0x59, 0x4D, 0x7F, 0x3E, 0x00 }, // U+0030 (0) + { 0x40, 0x42, 0x7F, 0x7F, 0x40, 0x40, 0x00, 0x00 }, // U+0031 (1) + { 0x62, 0x73, 0x59, 0x49, 0x6F, 0x66, 0x00, 0x00 }, // U+0032 (2) + { 0x22, 0x63, 0x49, 0x49, 0x7F, 0x36, 0x00, 0x00 }, // U+0033 (3) + { 0x18, 0x1C, 0x16, 0x53, 0x7F, 0x7F, 0x50, 0x00 }, // U+0034 (4) + { 0x27, 0x67, 0x45, 0x45, 0x7D, 0x39, 0x00, 0x00 }, // U+0035 (5) + { 0x3C, 0x7E, 0x4B, 0x49, 0x79, 0x30, 0x00, 0x00 }, // U+0036 (6) + { 0x03, 0x03, 0x71, 0x79, 0x0F, 0x07, 0x00, 0x00 }, // U+0037 (7) + { 0x36, 0x7F, 0x49, 0x49, 0x7F, 0x36, 0x00, 0x00 }, // U+0038 (8) + { 0x06, 0x4F, 0x49, 0x69, 0x3F, 0x1E, 0x00, 0x00 }, // U+0039 (9) + { 0x00, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00 }, // U+003A (:) + { 0x00, 0x80, 0xE6, 0x66, 0x00, 0x00, 0x00, 0x00 }, // U+003B (;) + { 0x08, 0x1C, 0x36, 0x63, 0x41, 0x00, 0x00, 0x00 }, // U+003C (<) + { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00 }, // U+003D (=) + { 0x00, 0x41, 0x63, 0x36, 0x1C, 0x08, 0x00, 0x00 }, // U+003E (>) + { 0x02, 0x03, 0x51, 0x59, 0x0F, 0x06, 0x00, 0x00 }, // U+003F (?) + { 0x3E, 0x7F, 0x41, 0x5D, 0x5D, 0x1F, 0x1E, 0x00 }, // U+0040 (@) + { 0x7C, 0x7E, 0x13, 0x13, 0x7E, 0x7C, 0x00, 0x00 }, // U+0041 (A) + { 0x41, 0x7F, 0x7F, 0x49, 0x49, 0x7F, 0x36, 0x00 }, // U+0042 (B) + { 0x1C, 0x3E, 0x63, 0x41, 0x41, 0x63, 0x22, 0x00 }, // U+0043 (C) + { 0x41, 0x7F, 0x7F, 0x41, 0x63, 0x3E, 0x1C, 0x00 }, // U+0044 (D) + { 0x41, 0x7F, 0x7F, 0x49, 0x5D, 0x41, 0x63, 0x00 }, // U+0045 (E) + { 0x41, 0x7F, 0x7F, 0x49, 0x1D, 0x01, 0x03, 0x00 }, // U+0046 (F) + { 0x1C, 0x3E, 0x63, 0x41, 0x51, 0x73, 0x72, 0x00 }, // U+0047 (G) + { 0x7F, 0x7F, 0x08, 0x08, 0x7F, 0x7F, 0x00, 0x00 }, // U+0048 (H) + { 0x00, 0x41, 0x7F, 0x7F, 0x41, 0x00, 0x00, 0x00 }, // U+0049 (I) + { 0x30, 0x70, 0x40, 0x41, 0x7F, 0x3F, 0x01, 0x00 }, // U+004A (J) + { 0x41, 0x7F, 0x7F, 0x08, 0x1C, 0x77, 0x63, 0x00 }, // U+004B (K) + { 0x41, 0x7F, 0x7F, 0x41, 0x40, 0x60, 0x70, 0x00 }, // U+004C (L) + { 0x7F, 0x7F, 0x0E, 0x1C, 0x0E, 0x7F, 0x7F, 0x00 }, // U+004D (M) + { 0x7F, 0x7F, 0x06, 0x0C, 0x18, 0x7F, 0x7F, 0x00 }, // U+004E (N) + { 0x1C, 0x3E, 0x63, 0x41, 0x63, 0x3E, 0x1C, 0x00 }, // U+004F (O) + { 0x41, 0x7F, 0x7F, 0x49, 0x09, 0x0F, 0x06, 0x00 }, // U+0050 (P) + { 0x1E, 0x3F, 0x21, 0x71, 0x7F, 0x5E, 0x00, 0x00 }, // U+0051 (Q) + { 0x41, 0x7F, 0x7F, 0x09, 0x19, 0x7F, 0x66, 0x00 }, // U+0052 (R) + { 0x26, 0x6F, 0x4D, 0x59, 0x73, 0x32, 0x00, 0x00 }, // U+0053 (S) + { 0x03, 0x41, 0x7F, 0x7F, 0x41, 0x03, 0x00, 0x00 }, // U+0054 (T) + { 0x7F, 0x7F, 0x40, 0x40, 0x7F, 0x7F, 0x00, 0x00 }, // U+0055 (U) + { 0x1F, 0x3F, 0x60, 0x60, 0x3F, 0x1F, 0x00, 0x00 }, // U+0056 (V) + { 0x7F, 0x7F, 0x30, 0x18, 0x30, 0x7F, 0x7F, 0x00 }, // U+0057 (W) + { 0x43, 0x67, 0x3C, 0x18, 0x3C, 0x67, 0x43, 0x00 }, // U+0058 (X) + { 0x07, 0x4F, 0x78, 0x78, 0x4F, 0x07, 0x00, 0x00 }, // U+0059 (Y) + { 0x47, 0x63, 0x71, 0x59, 0x4D, 0x67, 0x73, 0x00 }, // U+005A (Z) + { 0x00, 0x7F, 0x7F, 0x41, 0x41, 0x00, 0x00, 0x00 }, // U+005B ([) + { 0x01, 0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00 }, // U+005C (\) + { 0x00, 0x41, 0x41, 0x7F, 0x7F, 0x00, 0x00, 0x00 }, // U+005D (]) + { 0x08, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x08, 0x00 }, // U+005E (^) + { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, // U+005F (_) + { 0x00, 0x00, 0x03, 0x07, 0x04, 0x00, 0x00, 0x00 }, // U+0060 (`) + { 0x20, 0x74, 0x54, 0x54, 0x3C, 0x78, 0x40, 0x00 }, // U+0061 (a) + { 0x41, 0x7F, 0x3F, 0x48, 0x48, 0x78, 0x30, 0x00 }, // U+0062 (b) + { 0x38, 0x7C, 0x44, 0x44, 0x6C, 0x28, 0x00, 0x00 }, // U+0063 (c) + { 0x30, 0x78, 0x48, 0x49, 0x3F, 0x7F, 0x40, 0x00 }, // U+0064 (d) + { 0x38, 0x7C, 0x54, 0x54, 0x5C, 0x18, 0x00, 0x00 }, // U+0065 (e) + { 0x48, 0x7E, 0x7F, 0x49, 0x03, 0x02, 0x00, 0x00 }, // U+0066 (f) + { 0x98, 0xBC, 0xA4, 0xA4, 0xF8, 0x7C, 0x04, 0x00 }, // U+0067 (g) + { 0x41, 0x7F, 0x7F, 0x08, 0x04, 0x7C, 0x78, 0x00 }, // U+0068 (h) + { 0x00, 0x44, 0x7D, 0x7D, 0x40, 0x00, 0x00, 0x00 }, // U+0069 (i) + { 0x60, 0xE0, 0x80, 0x80, 0xFD, 0x7D, 0x00, 0x00 }, // U+006A (j) + { 0x41, 0x7F, 0x7F, 0x10, 0x38, 0x6C, 0x44, 0x00 }, // U+006B (k) + { 0x00, 0x41, 0x7F, 0x7F, 0x40, 0x00, 0x00, 0x00 }, // U+006C (l) + { 0x7C, 0x7C, 0x18, 0x38, 0x1C, 0x7C, 0x78, 0x00 }, // U+006D (m) + { 0x7C, 0x7C, 0x04, 0x04, 0x7C, 0x78, 0x00, 0x00 }, // U+006E (n) + { 0x38, 0x7C, 0x44, 0x44, 0x7C, 0x38, 0x00, 0x00 }, // U+006F (o) + { 0x84, 0xFC, 0xF8, 0xA4, 0x24, 0x3C, 0x18, 0x00 }, // U+0070 (p) + { 0x18, 0x3C, 0x24, 0xA4, 0xF8, 0xFC, 0x84, 0x00 }, // U+0071 (q) + { 0x44, 0x7C, 0x78, 0x4C, 0x04, 0x1C, 0x18, 0x00 }, // U+0072 (r) + { 0x48, 0x5C, 0x54, 0x54, 0x74, 0x24, 0x00, 0x00 }, // U+0073 (s) + { 0x00, 0x04, 0x3E, 0x7F, 0x44, 0x24, 0x00, 0x00 }, // U+0074 (t) + { 0x3C, 0x7C, 0x40, 0x40, 0x3C, 0x7C, 0x40, 0x00 }, // U+0075 (u) + { 0x1C, 0x3C, 0x60, 0x60, 0x3C, 0x1C, 0x00, 0x00 }, // U+0076 (v) + { 0x3C, 0x7C, 0x70, 0x38, 0x70, 0x7C, 0x3C, 0x00 }, // U+0077 (w) + { 0x44, 0x6C, 0x38, 0x10, 0x38, 0x6C, 0x44, 0x00 }, // U+0078 (x) + { 0x9C, 0xBC, 0xA0, 0xA0, 0xFC, 0x7C, 0x00, 0x00 }, // U+0079 (y) + { 0x4C, 0x64, 0x74, 0x5C, 0x4C, 0x64, 0x00, 0x00 }, // U+007A (z) + { 0x08, 0x08, 0x3E, 0x77, 0x41, 0x41, 0x00, 0x00 }, // U+007B ({) + { 0x00, 0x00, 0x00, 0x77, 0x77, 0x00, 0x00, 0x00 }, // U+007C (|) + { 0x41, 0x41, 0x77, 0x3E, 0x08, 0x08, 0x00, 0x00 }, // U+007D (}) + { 0x02, 0x03, 0x01, 0x03, 0x02, 0x03, 0x01, 0x00 }, // U+007E (~) + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } // U+007F +}; + +#endif /* MAIN_FONT8X8_BASIC_H_ */ + + diff --git a/components/oap-hw-ssd1306/include/ssd1366.h b/components/oap-hw-ssd1306/include/ssd1366.h new file mode 100644 index 0000000..095f092 --- /dev/null +++ b/components/oap-hw-ssd1306/include/ssd1366.h @@ -0,0 +1,53 @@ +#ifndef MAIN_SSD1366_H_ +#define MAIN_SSD1366_H_ + +// Following definitions are bollowed from +// http://robotcantalk.blogspot.com/2015/03/interfacing-arduino-with-ssd1306-driven.html + +// SLA (0x3C) + WRITE_MODE (0x00) = 0x78 (0b01111000) +#define OLED_I2C_ADDRESS 0x3C + +// Control byte +#define OLED_CONTROL_BYTE_CMD_SINGLE 0x80 +#define OLED_CONTROL_BYTE_CMD_STREAM 0x00 +#define OLED_CONTROL_BYTE_DATA_STREAM 0x40 + +// Fundamental commands (pg.28) +#define OLED_CMD_SET_CONTRAST 0x81 // follow with 0x7F +#define OLED_CMD_DISPLAY_RAM 0xA4 +#define OLED_CMD_DISPLAY_ALLON 0xA5 +#define OLED_CMD_DISPLAY_NORMAL 0xA6 +#define OLED_CMD_DISPLAY_INVERTED 0xA7 +#define OLED_CMD_DISPLAY_OFF 0xAE +#define OLED_CMD_DISPLAY_ON 0xAF + +// Addressing Command Table (pg.30) +#define OLED_CMD_SET_MEMORY_ADDR_MODE 0x20 // follow with 0x00 = HORZ mode = Behave like a KS108 graphic LCD +#define OLED_CMD_SET_COLUMN_RANGE 0x21 // can be used only in HORZ/VERT mode - follow with 0x00 and 0x7F = COL127 +#define OLED_CMD_SET_PAGE_RANGE 0x22 // can be used only in HORZ/VERT mode - follow with 0x00 and 0x07 = PAGE7 + +// Hardware Config (pg.31) +#define OLED_CMD_SET_DISPLAY_START_LINE 0x40 +#define OLED_CMD_SET_SEGMENT_REMAP 0xA1 +#define OLED_CMD_SET_MUX_RATIO 0xA8 // follow with 0x3F = 64 MUX +#define OLED_CMD_SET_COM_SCAN_MODE 0xC8 +#define OLED_CMD_SET_DISPLAY_OFFSET 0xD3 // follow with 0x00 +#define OLED_CMD_SET_COM_PIN_MAP 0xDA // follow with 0x12 +#define OLED_CMD_NOP 0xE3 // NOP + +// Timing and Driving Scheme (pg.32) +#define OLED_CMD_SET_DISPLAY_CLK_DIV 0xD5 // follow with 0x80 +#define OLED_CMD_SET_PRECHARGE 0xD9 // follow with 0xF1 +#define OLED_CMD_SET_VCOMH_DESELCT 0xDB // follow with 0x30 + +// Charge Pump (pg.62) +#define OLED_CMD_SET_CHARGE_PUMP 0x8D // follow with 0x14 + +void ssd1306_init(); +void ssd1306_display_clear(void); +void ssd1306_contrast(void); +void ssd1306_display_text(const char *text); + + + +#endif /* MAIN_SSD1366_H_ */ \ No newline at end of file diff --git a/components/oap-hw-ssd1306/ssd1306.c b/components/oap-hw-ssd1306/ssd1306.c new file mode 100644 index 0000000..b1f8e66 --- /dev/null +++ b/components/oap-hw-ssd1306/ssd1306.c @@ -0,0 +1,108 @@ +#include + +#include "driver/gpio.h" +#include "driver/i2c.h" +#include "esp_err.h" +#include "esp_log.h" +#include "freertos/task.h" + +#include "ssd1366.h" +#include "font8x8_basic.h" + +#define tag "SSD1306" + +void ssd1306_init() { + esp_err_t espRc; + + i2c_cmd_handle_t cmd = i2c_cmd_link_create(); + + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (OLED_I2C_ADDRESS << 1) | I2C_MASTER_WRITE, true); + i2c_master_write_byte(cmd, OLED_CONTROL_BYTE_CMD_STREAM, true); + + i2c_master_write_byte(cmd, OLED_CMD_SET_CHARGE_PUMP, true); + i2c_master_write_byte(cmd, 0x14, true); + + i2c_master_write_byte(cmd, OLED_CMD_SET_SEGMENT_REMAP, true); // reverse left-right mapping + i2c_master_write_byte(cmd, OLED_CMD_SET_COM_SCAN_MODE, true); // reverse up-bottom mapping + + i2c_master_write_byte(cmd, OLED_CMD_DISPLAY_ON, true); + i2c_master_stop(cmd); + + espRc = i2c_master_cmd_begin(I2C_NUM_0, cmd, 10/portTICK_PERIOD_MS); + if (espRc == ESP_OK) { + ESP_LOGI(tag, "OLED configured successfully"); + } else { + ESP_LOGE(tag, "OLED configuration failed. code: 0x%.2X", espRc); + } + i2c_cmd_link_delete(cmd); +} + +void ssd1306_display_clear(void ) { + i2c_cmd_handle_t cmd; + + uint8_t zero[128]; + memset(zero, 0, sizeof(zero)); + for (uint8_t i = 0; i < 8; i++) { + cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (OLED_I2C_ADDRESS << 1) | I2C_MASTER_WRITE, true); + i2c_master_write_byte(cmd, OLED_CONTROL_BYTE_CMD_SINGLE, true); + i2c_master_write_byte(cmd, 0xB0 | i, true); + + i2c_master_write_byte(cmd, OLED_CONTROL_BYTE_DATA_STREAM, true); + i2c_master_write(cmd, zero, 128, true); + i2c_master_stop(cmd); + i2c_master_cmd_begin(I2C_NUM_0, cmd, 10/portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + } +} + +void ssd1306_display_text(const char *text) { + uint8_t text_len = strlen(text); + + i2c_cmd_handle_t cmd; + + uint8_t cur_page = 0; + + cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (OLED_I2C_ADDRESS << 1) | I2C_MASTER_WRITE, true); + + i2c_master_write_byte(cmd, OLED_CONTROL_BYTE_CMD_STREAM, true); + i2c_master_write_byte(cmd, 0x00, true); // reset column + i2c_master_write_byte(cmd, 0x10, true); + i2c_master_write_byte(cmd, 0xB0 | cur_page, true); // reset page + + i2c_master_stop(cmd); + i2c_master_cmd_begin(I2C_NUM_0, cmd, 10/portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + + for (uint8_t i = 0; i < text_len; i++) { + if (text[i] == '\n') { + cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (OLED_I2C_ADDRESS << 1) | I2C_MASTER_WRITE, true); + + i2c_master_write_byte(cmd, OLED_CONTROL_BYTE_CMD_STREAM, true); + i2c_master_write_byte(cmd, 0x00, true); // reset column + i2c_master_write_byte(cmd, 0x10, true); + i2c_master_write_byte(cmd, 0xB0 | ++cur_page, true); // increment page + + i2c_master_stop(cmd); + i2c_master_cmd_begin(I2C_NUM_0, cmd, 10/portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + } else { + cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, (OLED_I2C_ADDRESS << 1) | I2C_MASTER_WRITE, true); + + i2c_master_write_byte(cmd, OLED_CONTROL_BYTE_DATA_STREAM, true); + i2c_master_write(cmd, font8x8_basic_tr[(uint8_t)text[i]], 8, true); + + i2c_master_stop(cmd); + i2c_master_cmd_begin(I2C_NUM_0, cmd, 10/portTICK_PERIOD_MS); + i2c_cmd_link_delete(cmd); + } + } +} diff --git a/components/oap-meter/Kconfig b/components/oap-meter/Kconfig index 8daedd6..8babe10 100644 --- a/components/oap-meter/Kconfig +++ b/components/oap-meter/Kconfig @@ -9,13 +9,13 @@ config OAP_PM_SAMPLE_BUF_SIZE config OAP_HEATER_CONTROL_PIN int "external heater gpio" - default 21 + default -1 help optional GPIO pin to control a heater. It mirrors state of SET gpio. (0 = none) config OAP_FAN_CONTROL_PIN int "external fan gpio" - default 22 + default -1 help optional GPIO pin to control an additional fan. It mirrors state of SET gpio. (0 = none) diff --git a/components/oap-meter/include/pm_meter.h b/components/oap-meter/include/pm_meter.h index c3760ed..9afd0a2 100644 --- a/components/oap-meter/include/pm_meter.h +++ b/components/oap-meter/include/pm_meter.h @@ -36,6 +36,7 @@ pm_meter_aux_t pm_meter_aux; typedef struct { uint8_t count; pm_data_t pm_data[2]; + long timestamp; } pm_data_pair_t; typedef enum { @@ -74,6 +75,6 @@ typedef struct { pm_meter_stop_f stop; } pm_meter_t; - +extern pm_data_pair_t pm_data_array; #endif /* MAIN_MEAS_H_ */ diff --git a/components/oap-meter/meas_intervals.c b/components/oap-meter/meas_intervals.c index af0603d..b0d7c0c 100644 --- a/components/oap-meter/meas_intervals.c +++ b/components/oap-meter/meas_intervals.c @@ -129,6 +129,7 @@ static void task() { } if (ok) { + pm_data_pair.timestamp = oap_epoch_sec(); _callback(PM_METER_RESULT,&pm_data_pair); } diff --git a/components/oap-ota/Kconfig b/components/oap-ota/Kconfig index 008e728..ab0ec74 100644 --- a/components/oap-ota/Kconfig +++ b/components/oap-ota/Kconfig @@ -1,8 +1,8 @@ menu "OAP OTA updates" config OAP_OTA_ENABLED - int "enable OTA updates" - default 1 + bool "enable OTA updates" + default y help enable automatic over-the-air updates diff --git a/components/oap-ota/component.mk b/components/oap-ota/component.mk index 5ee3370..155141c 100644 --- a/components/oap-ota/component.mk +++ b/components/oap-ota/component.mk @@ -12,3 +12,6 @@ # openairproject.com (CloudFront) COMPONENT_EMBED_TXTFILES = comodo_ca.pem + +# lets encrypt signed sites +# COMPONENT_EMBED_TXTFILES = lets-encrypt-x3-cross-signed.pem diff --git a/components/oap-ota/lets-encrypt-x3-cross-signed.pem b/components/oap-ota/lets-encrypt-x3-cross-signed.pem new file mode 100644 index 0000000..0002462 --- /dev/null +++ b/components/oap-ota/lets-encrypt-x3-cross-signed.pem @@ -0,0 +1,27 @@ +-----BEGIN CERTIFICATE----- +MIIEkjCCA3qgAwIBAgIQCgFBQgAAAVOFc2oLheynCDANBgkqhkiG9w0BAQsFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTE2MDMxNzE2NDA0NloXDTIxMDMxNzE2NDA0Nlow +SjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUxldCdzIEVuY3J5cHQxIzAhBgNVBAMT +GkxldCdzIEVuY3J5cHQgQXV0aG9yaXR5IFgzMIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEAnNMM8FrlLke3cl03g7NoYzDq1zUmGSXhvb418XCSL7e4S0EF +q6meNQhY7LEqxGiHC6PjdeTm86dicbp5gWAf15Gan/PQeGdxyGkOlZHP/uaZ6WA8 +SMx+yk13EiSdRxta67nsHjcAHJyse6cF6s5K671B5TaYucv9bTyWaN8jKkKQDIZ0 +Z8h/pZq4UmEUEz9l6YKHy9v6Dlb2honzhT+Xhq+w3Brvaw2VFn3EK6BlspkENnWA +a6xK8xuQSXgvopZPKiAlKQTGdMDQMc2PMTiVFrqoM7hD8bEfwzB/onkxEz0tNvjj +/PIzark5McWvxI0NHWQWM6r6hCm21AvA2H3DkwIDAQABo4IBfTCCAXkwEgYDVR0T +AQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAYYwfwYIKwYBBQUHAQEEczBxMDIG +CCsGAQUFBzABhiZodHRwOi8vaXNyZy50cnVzdGlkLm9jc3AuaWRlbnRydXN0LmNv +bTA7BggrBgEFBQcwAoYvaHR0cDovL2FwcHMuaWRlbnRydXN0LmNvbS9yb290cy9k +c3Ryb290Y2F4My5wN2MwHwYDVR0jBBgwFoAUxKexpHsscfrb4UuQdf/EFWCFiRAw +VAYDVR0gBE0wSzAIBgZngQwBAgEwPwYLKwYBBAGC3xMBAQEwMDAuBggrBgEFBQcC +ARYiaHR0cDovL2Nwcy5yb290LXgxLmxldHNlbmNyeXB0Lm9yZzA8BgNVHR8ENTAz +MDGgL6AthitodHRwOi8vY3JsLmlkZW50cnVzdC5jb20vRFNUUk9PVENBWDNDUkwu +Y3JsMB0GA1UdDgQWBBSoSmpjBH3duubRObemRWXv86jsoTANBgkqhkiG9w0BAQsF +AAOCAQEA3TPXEfNjWDjdGBX7CVW+dla5cEilaUcne8IkCJLxWh9KEik3JHRRHGJo +uM2VcGfl96S8TihRzZvoroed6ti6WqEBmtzw3Wodatg+VyOeph4EYpr/1wXKtx8/ +wApIvJSwtmVi4MFU5aMqrSDE6ea73Mj2tcMyo5jMd6jmeWUHK8so/joWUoHOUgwu +X4Po1QYz+3dszkDqMp4fklxBwXRsW10KXzPMTZ+sOPAveyxindmjkW8lGy+QsRlG +PfZ+G6Z6h7mjem0Y+iWlkYcV4PIWL1iwBi8saCbGS5jN2p8M+X+Q7UNKEkROb3N6 +KOqkqm57TH2H3eDJAkSnh6/DNFu0Qg== +-----END CERTIFICATE----- diff --git a/components/oap-ota/ota.c b/components/oap-ota/ota.c index 764f2ec..1ee4bee 100644 --- a/components/oap-ota/ota.c +++ b/components/oap-ota/ota.c @@ -43,8 +43,10 @@ #define TAG "ota" -extern const uint8_t _root_ca_pem_start[] asm("_binary_comodo_ca_pem_start"); -extern const uint8_t _root_ca_pem_end[] asm("_binary_comodo_ca_pem_end"); +//extern const uint8_t _root_ca_pem_start[] asm("_binary_comodo_ca_pem_start"); +//extern const uint8_t _root_ca_pem_end[] asm("_binary_comodo_ca_pem_end"); +extern const uint8_t _root_ca_pem_start[] asm("_binary_lets_encrypt_x3_cross_signed_pem_start"); +extern const uint8_t _root_ca_pem_end[] asm("_binary_lets_encrypt_x3_cross_signed_pem_end"); void sha_to_hexstr(unsigned char hash[32], unsigned char hex[64]) { for (int i = 0; i < 32; i++) { @@ -171,7 +173,8 @@ esp_err_t fetch_last_ota_info(ota_config_t* ota_config, ota_info_t* ota_info) req_setopt(req, REQ_SET_HEADER, HTTP_HEADER_CONNECTION_CLOSE); req_setopt(req, REQ_FUNC_DOWNLOAD_CB, get_ota_status_callback); - + req_set_user_agent(req); + int status = req_perform(req); req_clean(req); @@ -222,6 +225,7 @@ static esp_err_t download_ota_binary(ota_config_t* ota_config, ota_info_t* ota_i req_setopt(req, REQ_SET_HEADER, "Connection: close"); req_setopt(req, REQ_FUNC_DOWNLOAD_CB, download_ota_binary_callback); + req_set_user_agent(req); mbedtls_sha256_context sha_context; mbedtls_sha256_init(&sha_context); diff --git a/components/oap-thingspk/thing_speak.c b/components/oap-thingspk/thing_speak.c index c4a608a..c9df1ec 100644 --- a/components/oap-thingspk/thing_speak.c +++ b/components/oap-thingspk/thing_speak.c @@ -36,13 +36,6 @@ static const char *TAG = "thingspk"; static char* apikey = NULL; static int _configured = 0; -static void set_config_str_field(char** field, char* value) { - if (*field) { - free(*field); - } - *field = str_dup(value); -} - static char* prepare_thingspeak_payload(oap_measurement_t* meas) { char* payload = malloc(512); if (!payload) return NULL; @@ -57,9 +50,9 @@ static char* prepare_thingspeak_payload(oap_measurement_t* meas) { if (meas->env) { sprintf(payload, "%s&field4=%.2f&field5=%.2f&field6=%.2f", payload, - meas->env->temp, - meas->env->pressure, - meas->env->humidity); + meas->env->bmx280.temp, + meas->env->bmx280.pressure, + meas->env->bmx280.humidity); } //memory metrics diff --git a/components/oap-wifi/bootwifi.c b/components/oap-wifi/bootwifi.c index 07177a7..507eeb2 100644 --- a/components/oap-wifi/bootwifi.c +++ b/components/oap-wifi/bootwifi.c @@ -27,13 +27,13 @@ #include #include #include +#include "cJSON.h" #include "bootwifi.h" #include "sdkconfig.h" -#include "apps/sntp/sntp.h" +#include #include "oap_common.h" +#include "oap_storage.h" #include "freertos/event_groups.h" -#include "server.h" -#include "cpanel.h" /** * based on https://github.com/nkolban/esp32-snippets/tree/master/networking/bootwifi @@ -72,10 +72,9 @@ wifi_config_t ap_config = { // Forward declarations static int _sntp_initialised = 0; -static void become_access_point(); -static void restore_wifi_setup(); static char tag[] = "wifi"; +static char *hostname = NULL; /* FreeRTOS event group to signal when we are connected & ready to make a request */ static EventGroupHandle_t wifi_event_group = NULL; @@ -177,6 +176,10 @@ static esp_err_t esp32_wifi_eventHandler(void *ctx, system_event_t *event) { } //WARNING - we cannot rely on this event, sometimes it doesn't got triggered + case SYSTEM_EVENT_STA_START: { + esp_wifi_connect(); + break; + } case SYSTEM_EVENT_STA_DISCONNECTED: { wifi_state_change(false, false); /* @@ -191,7 +194,7 @@ static esp_err_t esp32_wifi_eventHandler(void *ctx, system_event_t *event) { */ if (!oap_wifi_config.ap_mode) { ESP_LOGI(tag, "reconnect"); - restore_wifi_setup(); + esp_wifi_connect(); } break; } @@ -239,6 +242,7 @@ static esp_err_t esp32_wifi_eventHandler(void *ctx, system_event_t *event) { return ESP_OK; } + esp_err_t wifi_configure(cJSON* wifi, wifi_state_callback_f wifi_state_callback) { memset(&oap_wifi_config, 0, sizeof(oc_wifi_t)); oap_wifi_config.callback = wifi_state_callback; @@ -263,7 +267,9 @@ esp_err_t wifi_configure(cJSON* wifi, wifi_state_callback_f wifi_state_callback) if ((field = cJSON_GetObjectItem(wifi, "netmask"))) { inet_pton(AF_INET, field->valuestring, &oap_wifi_config.ipInfo.netmask); } - + if ((field = cJSON_GetObjectItem(wifi, "sensorId")) && field->valuestring && strlen(field->valuestring)) { + set_config_str_field(&hostname, field->valuestring); + } ESP_LOGD(tag, "wifi.ssid: %s", oap_wifi_config.ssid); ESP_LOGD(tag, "wifi.pass.lenght: [%d]", strlen(oap_wifi_config.password)); @@ -276,6 +282,24 @@ esp_err_t wifi_configure(cJSON* wifi, wifi_state_callback_f wifi_state_callback) return ESP_OK; } +static void station_watcher() { + int retry_counter=0; + ESP_LOGI(tag, "station_watcher started"); + while(1) { + if(retry_counter < 6) { + if(wifi_disconnected_wait_for(10) == ESP_OK) { + retry_counter++; + ESP_LOGW(tag, "WIFI disconnected since %ds, retry #%d", retry_counter * 10, retry_counter); + } else { + retry_counter=0; + } + } else { + oap_reboot("WIFI disconnected, retries exceeded, restarting"); + } + delay(10000); + } +} + static void become_station() { ESP_LOGD(tag, "- Connecting to access point \"%s\" ...", oap_wifi_config.ssid); assert(strlen(oap_wifi_config.ssid) > 0); @@ -289,45 +313,37 @@ static void become_station() { tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA); } - ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); - wifi_config_t sta_config; - sta_config.sta.bssid_set = 0; - memcpy(sta_config.sta.ssid, oap_wifi_config.ssid, SSID_SIZE); - memcpy(sta_config.sta.password, oap_wifi_config.password, PASSWORD_SIZE); - ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta_config)); - ESP_ERROR_CHECK(esp_wifi_start()); - ESP_ERROR_CHECK(esp_wifi_connect());//FIXERR 0x3006 : ESP_ERR_WIFI_CONN (happens after reboot via control panel) + ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); + wifi_config_t sta_config = {0}; + sta_config.sta.bssid_set = 0; + memcpy(sta_config.sta.ssid, oap_wifi_config.ssid, SSID_SIZE); + memcpy(sta_config.sta.password, oap_wifi_config.password, PASSWORD_SIZE); + ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta_config)); + ESP_ERROR_CHECK(esp_wifi_start()); + esp_err_t err = tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, hostname); + if (err){ + ESP_LOGI(tag, "tcpip_adapter_set_hostname failed, rc=%d", err); + } + xTaskCreate(station_watcher, "station_watcher", 2*1024, NULL, DEFAULT_TASK_PRIORITY, NULL); } static void become_access_point() { ESP_LOGD(tag, "- Starting being an access point ..."); ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP)); - //generate unique SSID - uint8_t mac[6]; - esp_efuse_mac_get_default(mac); - //ESP_LOGD(tag, "MAC= %02X:%02X:%02X:%02X:%02X:%02X",mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]); - //using full MAC would be the best but I'm not sure if it is safe (if someone has wifi with MAC filtering) - sprintf((char*)ap_config.ap.ssid, "OpenAirProject-%02X%02X%02X%02X", mac[0], mac[1], mac[4], mac[5]); + get_generic_name((char *)ap_config.ap.ssid); ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &ap_config)); ESP_ERROR_CHECK(esp_wifi_start()); } -static void restore_wifi_setup() { - if (oap_wifi_config.ap_mode) { - become_access_point(); - } else { - become_station(); - } -} - static void init_wifi() { tcpip_adapter_init(); ESP_ERROR_CHECK(esp_event_loop_init(esp32_wifi_eventHandler, NULL)); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); ESP_ERROR_CHECK(esp_wifi_init(&cfg)); ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM)); + ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE)); } void wifi_boot() { @@ -338,7 +354,11 @@ void wifi_boot() { init_wifi(); } - restore_wifi_setup(); + if (oap_wifi_config.ap_mode) { + become_access_point(); + } else { + become_station(); + } } esp_err_t wifi_disconnected_wait_for(uint32_t ms) { diff --git a/components/oap-wifi/cpanel.c b/components/oap-wifi/cpanel.c deleted file mode 100644 index 5804b78..0000000 --- a/components/oap-wifi/cpanel.c +++ /dev/null @@ -1,125 +0,0 @@ -/* - * cpanel.c - * - * Created on: Oct 5, 2017 - * Author: kris - * - * This file is part of OpenAirProject-ESP32. - * - * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * OpenAirProject-ESP32 is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with OpenAirProject-ESP32. If not, see . - */ - -#include "oap_common.h" -#include "mongoose.h" -#include "cJSON.h" -#include "oap_storage.h" - -#define tag "cpanel" - -extern const uint8_t index_html_start[] asm("_binary_index_html_start"); -extern const uint8_t index_html_end[] asm("_binary_index_html_end"); - -static char *mgStrToStr(struct mg_str mgStr) { - char *retStr = (char *) malloc(mgStr.len + 1); - memcpy(retStr, mgStr.p, mgStr.len); - retStr[mgStr.len] = 0; - return retStr; -} // mgStrToStr - -static void handler_index(struct mg_connection *nc) { - size_t resp_size = index_html_end-index_html_start; - mg_send_head(nc, 200, resp_size, "Content-Type: text/html"); - mg_send(nc, index_html_start, resp_size); - ESP_LOGD(tag, "served %d bytes", resp_size); -} - -static void handler_get_config(struct mg_connection *nc, struct http_message *message) { - ESP_LOGD(tag, "handler_get_config"); - cJSON* config = storage_get_config_to_update(); - char* json = cJSON_Print(config); - char* headers = malloc(200); - sprintf(headers, "Content-Type: application/json\r\nX-Version: %s", oap_version_str()); - mg_send_head(nc, 200, strlen(json), headers); - mg_send(nc, json, strlen(json)); - free(headers); - free(json); -} - -static void handler_reboot(struct mg_connection *nc) { - mg_send_head(nc, 200, 0, "Content-Type: text/plain"); - oap_reboot("requested by user"); -} - -static void handler_set_config(struct mg_connection *nc, struct http_message *message) { - ESP_LOGD(tag, "handler_set_config"); - char *body = mgStrToStr(message->body); - cJSON* config = cJSON_Parse(body); - free(body); - if (config) { - storage_update_config(config); - handler_get_config(nc, message); - } else { - mg_http_send_error(nc, 500, "invalid config"); - } - cJSON_Delete(config); -} - -/** - * Handle mongoose events. These are mostly requests to process incoming - * browser requests. The ones we handle are: - * GET / - Send the enter details page. - * GET /set - Set the connection info (REST request). - * POST /ssidSelected - Set the connection info (HTML FORM). - */ -void cpanel_event_handler(struct mg_connection *nc, int ev, void *evData) { - ESP_LOGV(tag, "- Event: %d", ev); - uint8_t handled = 0; - switch (ev) { - case MG_EV_HTTP_REQUEST: { - struct http_message *message = (struct http_message *) evData; - - //mg_str is not terminated with '\0' - char *uri = mgStrToStr(message->uri); - char *method = mgStrToStr(message->method); - - ESP_LOGD(tag, "%s %s", method, uri); - - if (strcmp(uri, "/") == 0) { - handler_index(nc); - handled = 1; - } - if (strcmp(uri, "/reboot") == 0) { - handler_reboot(nc); - handled = 1; - } - if(strcmp(uri, "/config") == 0) { - if (strcmp(method, "GET") == 0) { - handler_get_config(nc, message); - handled = 1; - } else if (strcmp(method, "POST") == 0) { - handler_set_config(nc, message); - handled = 1; - } - } - - if (!handled) { - mg_send_head(nc, 404, 0, "Content-Type: text/plain"); - } - nc->flags |= MG_F_SEND_AND_CLOSE; - free(uri); - free(method); - break; - } - } -} diff --git a/components/oap-wifi/include/server_cpanel.h b/components/oap-wifi/include/server_cpanel.h deleted file mode 100644 index b9a613a..0000000 --- a/components/oap-wifi/include/server_cpanel.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * server_cpanel.h - * - * Created on: Oct 5, 2017 - * Author: kris - * - * This file is part of OpenAirProject-ESP32. - * - * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * OpenAirProject-ESP32 is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with OpenAirProject-ESP32. If not, see . - */ - -#ifndef COMPONENTS_BOOTWIFI_INCLUDE_SERVER_CPANEL_H_ -#define COMPONENTS_BOOTWIFI_INCLUDE_SERVER_CPANEL_H_ - -#include - -void cpanel_wifi_handler(bool connected, bool ap_mode); - - -#endif /* COMPONENTS_BOOTWIFI_INCLUDE_SERVER_CPANEL_H_ */ diff --git a/components/oap-wifi/include/web.h b/components/oap-wifi/include/web.h new file mode 100644 index 0000000..08ca24d --- /dev/null +++ b/components/oap-wifi/include/web.h @@ -0,0 +1,12 @@ +#ifndef COMPONENTS_BOOTWIFI_INCLUDE_WEB_H_ +#define COMPONENTS_BOOTWIFI_INCLUDE_WEB_H_ + +#undef HTTP_GET +#undef HTTP_POST +#include + +httpd_handle_t start_webserver(void); +void stop_webserver(httpd_handle_t server); +void web_wifi_handler(bool connected, bool ap_mode); + +#endif /* COMPONENTS_BOOTWIFI_INCLUDE_WEB_H_ */ diff --git a/components/oap-wifi/index.html b/components/oap-wifi/index.html index 2086da0..67733df 100644 --- a/components/oap-wifi/index.html +++ b/components/oap-wifi/index.html @@ -1,6 +1,8 @@ + + OAP Sensor @@ -96,7 +98,12 @@

OpenAirProject Sensor

+
+
+ Current Data + +
WiFi @@ -124,6 +131,11 @@

OpenAirProject SensorNetmask + + + + +

@@ -136,6 +148,35 @@

OpenAirProject Sensor Measurement + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -181,6 +222,32 @@

OpenAirProject SensorMeasurement strategy (adv) + + + + + + + + + + + + + +

+ +
+ HTTP-Get-Publisher + + + + + + + + +
@@ -364,6 +431,66 @@

OpenAirProject Sensor + \ No newline at end of file diff --git a/components/oap-wifi/mongoose.c b/components/oap-wifi/mongoose.c deleted file mode 100644 index 2f63930..0000000 --- a/components/oap-wifi/mongoose.c +++ /dev/null @@ -1,14898 +0,0 @@ -#include "mongoose.h" - -int mg_invalid_socket=0; //kris - -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/internal.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_INTERNAL_H_ -#define CS_MONGOOSE_SRC_INTERNAL_H_ - -#ifndef MG_MALLOC -#define MG_MALLOC malloc -#endif - -#ifndef MG_CALLOC -#define MG_CALLOC calloc -#endif - -#ifndef MG_REALLOC -#define MG_REALLOC realloc -#endif - -#ifndef MG_FREE -#define MG_FREE free -#endif - -#ifndef MBUF_REALLOC -#define MBUF_REALLOC MG_REALLOC -#endif - -#ifndef MBUF_FREE -#define MBUF_FREE MG_FREE -#endif - -#define MG_SET_PTRPTR(_ptr, _v) \ - do { \ - if (_ptr) *(_ptr) = _v; \ - } while (0) - -#ifndef MG_INTERNAL -#define MG_INTERNAL static -#endif - -#ifdef PICOTCP -#define NO_LIBC -#define MG_DISABLE_PFS -#endif - -/* Amalgamated: #include "mongoose/src/net.h" */ -/* Amalgamated: #include "mongoose/src/http.h" */ -/* Amalgamated: #include "common/cs_dbg.h" */ - -#define MG_CTL_MSG_MESSAGE_SIZE 8192 - -/* internals that need to be accessible in unit tests */ -MG_INTERNAL struct mg_connection *mg_do_connect(struct mg_connection *nc, - int proto, - union socket_address *sa); - -MG_INTERNAL int mg_parse_address(const char *str, union socket_address *sa, - int *proto, char *host, size_t host_len); -MG_INTERNAL void mg_call(struct mg_connection *nc, - mg_event_handler_t ev_handler, int ev, void *ev_data); -void mg_forward(struct mg_connection *from, struct mg_connection *to); -MG_INTERNAL void mg_add_conn(struct mg_mgr *mgr, struct mg_connection *c); -MG_INTERNAL void mg_remove_conn(struct mg_connection *c); -MG_INTERNAL struct mg_connection *mg_create_connection( - struct mg_mgr *mgr, mg_event_handler_t callback, - struct mg_add_sock_opts opts); -#ifdef _WIN32 -/* Retur value is the same as for MultiByteToWideChar. */ -int to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len); -#endif - -struct ctl_msg { - mg_event_handler_t callback; - char message[MG_CTL_MSG_MESSAGE_SIZE]; -}; - -#if MG_ENABLE_MQTT -struct mg_mqtt_message; -MG_INTERNAL int parse_mqtt(struct mbuf *io, struct mg_mqtt_message *mm); -#endif - -/* Forward declarations for testing. */ -extern void *(*test_malloc)(size_t size); -extern void *(*test_calloc)(size_t count, size_t size); - -#ifndef MIN -#define MIN(a, b) ((a) < (b) ? (a) : (b)) -#endif - -#if MG_ENABLE_HTTP -struct mg_serve_http_opts; - -/* - * Reassemble the content of the buffer (buf, blen) which should be - * in the HTTP chunked encoding, by collapsing data chunks to the - * beginning of the buffer. - * - * If chunks get reassembled, modify hm->body to point to the reassembled - * body and fire MG_EV_HTTP_CHUNK event. If handler sets MG_F_DELETE_CHUNK - * in nc->flags, delete reassembled body from the mbuf. - * - * Return reassembled body size. - */ -MG_INTERNAL size_t mg_handle_chunked(struct mg_connection *nc, - struct http_message *hm, char *buf, - size_t blen); - -MG_INTERNAL int mg_http_common_url_parse(const char *url, const char *schema, - const char *schema_tls, int *use_ssl, - char **user, char **pass, char **addr, - int *port_i, const char **path); - -#if MG_ENABLE_FILESYSTEM -MG_INTERNAL int mg_uri_to_local_path(struct http_message *hm, - const struct mg_serve_http_opts *opts, - char **local_path, - struct mg_str *remainder); -MG_INTERNAL time_t mg_parse_date_string(const char *datetime); -MG_INTERNAL int mg_is_not_modified(struct http_message *hm, cs_stat_t *st); -#endif -#if MG_ENABLE_HTTP_CGI -MG_INTERNAL void mg_handle_cgi(struct mg_connection *nc, const char *prog, - const struct mg_str *path_info, - const struct http_message *hm, - const struct mg_serve_http_opts *opts); -struct mg_http_proto_data_cgi; -MG_INTERNAL void mg_http_free_proto_data_cgi(struct mg_http_proto_data_cgi *d); -#endif -#if MG_ENABLE_HTTP_SSI -MG_INTERNAL void mg_handle_ssi_request(struct mg_connection *nc, - struct http_message *hm, - const char *path, - const struct mg_serve_http_opts *opts); -#endif -#if MG_ENABLE_HTTP_WEBDAV -MG_INTERNAL int mg_is_dav_request(const struct mg_str *s); -MG_INTERNAL void mg_handle_propfind(struct mg_connection *nc, const char *path, - cs_stat_t *stp, struct http_message *hm, - struct mg_serve_http_opts *opts); -MG_INTERNAL void mg_handle_lock(struct mg_connection *nc, const char *path); -MG_INTERNAL void mg_handle_mkcol(struct mg_connection *nc, const char *path, - struct http_message *hm); -MG_INTERNAL void mg_handle_move(struct mg_connection *c, - const struct mg_serve_http_opts *opts, - const char *path, struct http_message *hm); -MG_INTERNAL void mg_handle_delete(struct mg_connection *nc, - const struct mg_serve_http_opts *opts, - const char *path); -MG_INTERNAL void mg_handle_put(struct mg_connection *nc, const char *path, - struct http_message *hm); -#endif -#if MG_ENABLE_HTTP_WEBSOCKET -MG_INTERNAL void mg_ws_handler(struct mg_connection *nc, int ev, void *ev_data); -MG_INTERNAL void mg_ws_handshake(struct mg_connection *nc, - const struct mg_str *key); -#endif -#endif /* MG_ENABLE_HTTP */ - -MG_INTERNAL int mg_get_errno(void); - -MG_INTERNAL void mg_close_conn(struct mg_connection *conn); - -MG_INTERNAL int mg_http_common_url_parse(const char *url, const char *schema, - const char *schema_tls, int *use_ssl, - char **user, char **pass, char **addr, - int *port_i, const char **path); - -#if MG_ENABLE_SNTP -MG_INTERNAL int mg_sntp_parse_reply(const char *buf, int len, - struct mg_sntp_message *msg); -#endif - -#endif /* CS_MONGOOSE_SRC_INTERNAL_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/cs_dbg.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_CS_DBG_H_ -#define CS_COMMON_CS_DBG_H_ - -/* Amalgamated: #include "common/platform.h" */ - -#if CS_ENABLE_STDIO -#include -#endif - -#ifndef CS_ENABLE_DEBUG -#define CS_ENABLE_DEBUG 0 -#endif - -#ifndef CS_LOG_ENABLE_TS_DIFF -#define CS_LOG_ENABLE_TS_DIFF 0 -#endif - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -enum cs_log_level { - LL_NONE = -1, - LL_ERROR = 0, - LL_WARN = 1, - LL_INFO = 2, - LL_DEBUG = 3, - LL_VERBOSE_DEBUG = 4, - - _LL_MIN = -2, - _LL_MAX = 5, -}; - -void cs_log_set_level(enum cs_log_level level); - -#if CS_ENABLE_STDIO - -void cs_log_set_file(FILE *file); -extern enum cs_log_level cs_log_level; -void cs_log_print_prefix(const char *func); -void cs_log_printf(const char *fmt, ...); - -#define LOG(l, x) \ - do { \ - if (cs_log_level >= l) { \ - cs_log_print_prefix(__func__); \ - cs_log_printf x; \ - } \ - } while (0) - -#ifndef CS_NDEBUG - -#define DBG(x) \ - do { \ - if (cs_log_level >= LL_VERBOSE_DEBUG) { \ - cs_log_print_prefix(__func__); \ - cs_log_printf x; \ - } \ - } while (0) - -#else /* NDEBUG */ - -#define DBG(x) - -#endif - -#else /* CS_ENABLE_STDIO */ - -#define LOG(l, x) -#define DBG(x) - -#endif - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_CS_DBG_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/cs_dbg.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "common/cs_dbg.h" */ - -#include -#include - -/* Amalgamated: #include "common/cs_time.h" */ - -enum cs_log_level cs_log_level WEAK = -#if CS_ENABLE_DEBUG - LL_VERBOSE_DEBUG; -#else - LL_ERROR; -#endif - -#if CS_ENABLE_STDIO - -FILE *cs_log_file WEAK = NULL; - -#if CS_LOG_ENABLE_TS_DIFF -double cs_log_ts WEAK; -#endif - -void cs_log_print_prefix(const char *func) WEAK; -void cs_log_print_prefix(const char *func) { - char prefix[21]; - strncpy(prefix, func, 20); - prefix[20] = '\0'; - if (cs_log_file == NULL) cs_log_file = stderr; - fprintf(cs_log_file, "%-20s ", prefix); -#if CS_LOG_ENABLE_TS_DIFF - { - double now = cs_time(); - fprintf(cs_log_file, "%7u ", (unsigned int) ((now - cs_log_ts) * 1000000)); - cs_log_ts = now; - } -#endif -} - -void cs_log_printf(const char *fmt, ...) WEAK; -void cs_log_printf(const char *fmt, ...) { - va_list ap; - va_start(ap, fmt); - vfprintf(cs_log_file, fmt, ap); - va_end(ap); - fputc('\n', cs_log_file); - fflush(cs_log_file); -} - -void cs_log_set_file(FILE *file) WEAK; -void cs_log_set_file(FILE *file) { - cs_log_file = file; -} - -#endif /* CS_ENABLE_STDIO */ - -void cs_log_set_level(enum cs_log_level level) WEAK; -void cs_log_set_level(enum cs_log_level level) { - cs_log_level = level; -#if CS_LOG_ENABLE_TS_DIFF && CS_ENABLE_STDIO - cs_log_ts = cs_time(); -#endif -} -#ifdef MG_MODULE_LINES -#line 1 "common/base64.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#ifndef EXCLUDE_COMMON - -/* Amalgamated: #include "common/base64.h" */ - -#include - -/* Amalgamated: #include "common/cs_dbg.h" */ - -/* ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ */ - -#define NUM_UPPERCASES ('Z' - 'A' + 1) -#define NUM_LETTERS (NUM_UPPERCASES * 2) -#define NUM_DIGITS ('9' - '0' + 1) - -/* - * Emit a base64 code char. - * - * Doesn't use memory, thus it's safe to use to safely dump memory in crashdumps - */ -static void cs_base64_emit_code(struct cs_base64_ctx *ctx, int v) { - if (v < NUM_UPPERCASES) { - ctx->b64_putc(v + 'A', ctx->user_data); - } else if (v < (NUM_LETTERS)) { - ctx->b64_putc(v - NUM_UPPERCASES + 'a', ctx->user_data); - } else if (v < (NUM_LETTERS + NUM_DIGITS)) { - ctx->b64_putc(v - NUM_LETTERS + '0', ctx->user_data); - } else { - ctx->b64_putc(v - NUM_LETTERS - NUM_DIGITS == 0 ? '+' : '/', - ctx->user_data); - } -} - -static void cs_base64_emit_chunk(struct cs_base64_ctx *ctx) { - int a, b, c; - - a = ctx->chunk[0]; - b = ctx->chunk[1]; - c = ctx->chunk[2]; - - cs_base64_emit_code(ctx, a >> 2); - cs_base64_emit_code(ctx, ((a & 3) << 4) | (b >> 4)); - if (ctx->chunk_size > 1) { - cs_base64_emit_code(ctx, (b & 15) << 2 | (c >> 6)); - } - if (ctx->chunk_size > 2) { - cs_base64_emit_code(ctx, c & 63); - } -} - -void cs_base64_init(struct cs_base64_ctx *ctx, cs_base64_putc_t b64_putc, - void *user_data) { - ctx->chunk_size = 0; - ctx->b64_putc = b64_putc; - ctx->user_data = user_data; -} - -void cs_base64_update(struct cs_base64_ctx *ctx, const char *str, size_t len) { - const unsigned char *src = (const unsigned char *) str; - size_t i; - for (i = 0; i < len; i++) { - ctx->chunk[ctx->chunk_size++] = src[i]; - if (ctx->chunk_size == 3) { - cs_base64_emit_chunk(ctx); - ctx->chunk_size = 0; - } - } -} - -void cs_base64_finish(struct cs_base64_ctx *ctx) { - if (ctx->chunk_size > 0) { - int i; - memset(&ctx->chunk[ctx->chunk_size], 0, 3 - ctx->chunk_size); - cs_base64_emit_chunk(ctx); - for (i = 0; i < (3 - ctx->chunk_size); i++) { - ctx->b64_putc('=', ctx->user_data); - } - } -} - -#define BASE64_ENCODE_BODY \ - 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]; \ - \ - BASE64_OUT(b64[a >> 2]); \ - BASE64_OUT(b64[((a & 3) << 4) | (b >> 4)]); \ - if (i + 1 < src_len) { \ - BASE64_OUT(b64[(b & 15) << 2 | (c >> 6)]); \ - } \ - if (i + 2 < src_len) { \ - BASE64_OUT(b64[c & 63]); \ - } \ - } \ - \ - while (j % 4 != 0) { \ - BASE64_OUT('='); \ - } \ - BASE64_FLUSH() - -#define BASE64_OUT(ch) \ - do { \ - dst[j++] = (ch); \ - } while (0) - -#define BASE64_FLUSH() \ - do { \ - dst[j++] = '\0'; \ - } while (0) - -void cs_base64_encode(const unsigned char *src, int src_len, char *dst) { - BASE64_ENCODE_BODY; -} - -#undef BASE64_OUT -#undef BASE64_FLUSH - -#if CS_ENABLE_STDIO -#define BASE64_OUT(ch) \ - do { \ - fprintf(f, "%c", (ch)); \ - j++; \ - } while (0) - -#define BASE64_FLUSH() - -void cs_fprint_base64(FILE *f, const unsigned char *src, int src_len) { - BASE64_ENCODE_BODY; -} - -#undef BASE64_OUT -#undef BASE64_FLUSH -#endif /* CS_ENABLE_STDIO */ - -/* Convert one byte of encoded base64 input stream to 6-bit chunk */ -static unsigned char from_b64(unsigned char ch) { - /* Inverse lookup map */ - static const unsigned char tab[128] = { - 255, 255, 255, 255, - 255, 255, 255, 255, /* 0 */ - 255, 255, 255, 255, - 255, 255, 255, 255, /* 8 */ - 255, 255, 255, 255, - 255, 255, 255, 255, /* 16 */ - 255, 255, 255, 255, - 255, 255, 255, 255, /* 24 */ - 255, 255, 255, 255, - 255, 255, 255, 255, /* 32 */ - 255, 255, 255, 62, - 255, 255, 255, 63, /* 40 */ - 52, 53, 54, 55, - 56, 57, 58, 59, /* 48 */ - 60, 61, 255, 255, - 255, 200, 255, 255, /* 56 '=' is 200, on index 61 */ - 255, 0, 1, 2, - 3, 4, 5, 6, /* 64 */ - 7, 8, 9, 10, - 11, 12, 13, 14, /* 72 */ - 15, 16, 17, 18, - 19, 20, 21, 22, /* 80 */ - 23, 24, 25, 255, - 255, 255, 255, 255, /* 88 */ - 255, 26, 27, 28, - 29, 30, 31, 32, /* 96 */ - 33, 34, 35, 36, - 37, 38, 39, 40, /* 104 */ - 41, 42, 43, 44, - 45, 46, 47, 48, /* 112 */ - 49, 50, 51, 255, - 255, 255, 255, 255, /* 120 */ - }; - return tab[ch & 127]; -} - -int cs_base64_decode(const unsigned char *s, int len, char *dst, int *dec_len) { - unsigned char a, b, c, d; - int orig_len = len; - char *orig_dst = dst; - while (len >= 4 && (a = from_b64(s[0])) != 255 && - (b = from_b64(s[1])) != 255 && (c = from_b64(s[2])) != 255 && - (d = from_b64(s[3])) != 255) { - s += 4; - len -= 4; - if (a == 200 || b == 200) break; /* '=' can't be there */ - *dst++ = a << 2 | b >> 4; - if (c == 200) break; - *dst++ = b << 4 | c >> 2; - if (d == 200) break; - *dst++ = c << 6 | d; - } - *dst = 0; - if (dec_len != NULL) *dec_len = (dst - orig_dst); - return orig_len - len; -} - -#endif /* EXCLUDE_COMMON */ -#ifdef MG_MODULE_LINES -#line 1 "common/cs_dirent.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_CS_DIRENT_H_ -#define CS_COMMON_CS_DIRENT_H_ - -#include - -/* Amalgamated: #include "common/platform.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#ifdef CS_DEFINE_DIRENT -typedef struct { int dummy; } DIR; - -struct dirent { - int d_ino; -#ifdef _WIN32 - char d_name[MAX_PATH]; -#else - /* TODO(rojer): Use PATH_MAX but make sure it's sane on every platform */ - char d_name[256]; -#endif -}; - -DIR *opendir(const char *dir_name); -int closedir(DIR *dir); -struct dirent *readdir(DIR *dir); -#endif /* CS_DEFINE_DIRENT */ - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_CS_DIRENT_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/cs_dirent.c" -#endif -/* - * Copyright (c) 2015 Cesanta Software Limited - * All rights reserved - */ - -#ifndef EXCLUDE_COMMON - -/* Amalgamated: #include "common/cs_dirent.h" */ - -/* - * This file contains POSIX opendir/closedir/readdir API implementation - * for systems which do not natively support it (e.g. Windows). - */ - -#ifndef MG_FREE -#define MG_FREE free -#endif - -#ifndef MG_MALLOC -#define MG_MALLOC malloc -#endif - -#ifdef _WIN32 -struct win32_dir { - DIR d; - HANDLE handle; - WIN32_FIND_DATAW info; - struct dirent result; -}; - -DIR *opendir(const char *name) { - struct win32_dir *dir = NULL; - wchar_t wpath[MAX_PATH]; - DWORD attrs; - - if (name == NULL) { - SetLastError(ERROR_BAD_ARGUMENTS); - } else if ((dir = (struct win32_dir *) MG_MALLOC(sizeof(*dir))) == NULL) { - SetLastError(ERROR_NOT_ENOUGH_MEMORY); - } else { - to_wchar(name, wpath, ARRAY_SIZE(wpath)); - attrs = GetFileAttributesW(wpath); - if (attrs != 0xFFFFFFFF && (attrs & FILE_ATTRIBUTE_DIRECTORY)) { - (void) wcscat(wpath, L"\\*"); - dir->handle = FindFirstFileW(wpath, &dir->info); - dir->result.d_name[0] = '\0'; - } else { - MG_FREE(dir); - dir = NULL; - } - } - - return (DIR *) dir; -} - -int closedir(DIR *d) { - struct win32_dir *dir = (struct win32_dir *) d; - 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; -} - -struct dirent *readdir(DIR *d) { - struct win32_dir *dir = (struct win32_dir *) d; - struct dirent *result = NULL; - - if (dir) { - memset(&dir->result, 0, sizeof(dir->result)); - 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; -} -#endif - -#endif /* EXCLUDE_COMMON */ - -/* ISO C requires a translation unit to contain at least one declaration */ -typedef int cs_dirent_dummy; -#ifdef MG_MODULE_LINES -#line 1 "common/cs_time.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "common/cs_time.h" */ - -#ifndef _WIN32 -#include -/* - * There is no sys/time.h on ARMCC. - */ -#if !(defined(__ARMCC_VERSION) || defined(__ICCARM__)) && \ - !defined(__TI_COMPILER_VERSION__) && \ - (!defined(CS_PLATFORM) || CS_PLATFORM != CS_P_NXP_LPC) -#include -#endif -#else -#include -#endif - -double cs_time(void) WEAK; -double cs_time(void) { - double now; -#ifndef _WIN32 - struct timeval tv; - if (gettimeofday(&tv, NULL /* tz */) != 0) return 0; - now = (double) tv.tv_sec + (((double) tv.tv_usec) / 1000000.0); -#else - SYSTEMTIME sysnow; - FILETIME ftime; - GetLocalTime(&sysnow); - SystemTimeToFileTime(&sysnow, &ftime); - /* - * 1. VC 6.0 doesn't support conversion uint64 -> double, so, using int64 - * This should not cause a problems in this (21th) century - * 2. Windows FILETIME is a number of 100-nanosecond intervals since January - * 1, 1601 while time_t is a number of _seconds_ since January 1, 1970 UTC, - * thus, we need to convert to seconds and adjust amount (subtract 11644473600 - * seconds) - */ - now = (double) (((int64_t) ftime.dwLowDateTime + - ((int64_t) ftime.dwHighDateTime << 32)) / - 10000000.0) - - 11644473600; -#endif /* _WIN32 */ - return now; -} -#ifdef MG_MODULE_LINES -#line 1 "common/cs_endian.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_CS_ENDIAN_H_ -#define CS_COMMON_CS_ENDIAN_H_ - -/* - * clang with std=-c99 uses __LITTLE_ENDIAN, by default - * while for ex, RTOS gcc - LITTLE_ENDIAN, by default - * it depends on __USE_BSD, but let's have everything - */ -#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER) -#define BYTE_ORDER __BYTE_ORDER -#ifndef LITTLE_ENDIAN -#define LITTLE_ENDIAN __LITTLE_ENDIAN -#endif /* LITTLE_ENDIAN */ -#ifndef BIG_ENDIAN -#define BIG_ENDIAN __LITTLE_ENDIAN -#endif /* BIG_ENDIAN */ -#endif /* BYTE_ORDER */ - -#endif /* CS_COMMON_CS_ENDIAN_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/md5.c" -#endif -/* - * This code implements the MD5 message-digest algorithm. - * The algorithm is due to Ron Rivest. This code was - * written by Colin Plumb in 1993, no copyright is claimed. - * This code is in the public domain; do with it what you wish. - * - * Equivalent code is available from RSA Data Security, Inc. - * This code has been tested against that, and is equivalent, - * except that you don't need to include two pages of legalese - * with every copy. - * - * To compute the message digest of a chunk of bytes, declare an - * MD5Context structure, pass it to MD5Init, call MD5Update as - * needed on buffers full of bytes, and then call MD5Final, which - * will fill a supplied 16-byte array with the digest. - */ - -/* Amalgamated: #include "common/md5.h" */ -/* Amalgamated: #include "common/str_util.h" */ - -#if !defined(EXCLUDE_COMMON) -#if !DISABLE_MD5 - -/* Amalgamated: #include "common/cs_endian.h" */ - -static void byteReverse(unsigned char *buf, unsigned longs) { -/* Forrest: MD5 expect LITTLE_ENDIAN, swap if BIG_ENDIAN */ -#if BYTE_ORDER == BIG_ENDIAN - do { - uint32_t t = (uint32_t)((unsigned) buf[3] << 8 | buf[2]) << 16 | - ((unsigned) buf[1] << 8 | buf[0]); - *(uint32_t *) buf = t; - buf += 4; - } while (--longs); -#else - (void) buf; - (void) longs; -#endif -} - -#define F1(x, y, z) (z ^ (x & (y ^ z))) -#define F2(x, y, z) F1(z, x, y) -#define F3(x, y, z) (x ^ y ^ z) -#define F4(x, y, z) (y ^ (x | ~z)) - -#define MD5STEP(f, w, x, y, z, data, s) \ - (w += f(x, y, z) + data, w = w << s | w >> (32 - s), w += x) - -/* - * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious - * initialization constants. - */ -void MD5_Init(MD5_CTX *ctx) { - ctx->buf[0] = 0x67452301; - ctx->buf[1] = 0xefcdab89; - ctx->buf[2] = 0x98badcfe; - ctx->buf[3] = 0x10325476; - - ctx->bits[0] = 0; - ctx->bits[1] = 0; -} - -static void MD5Transform(uint32_t buf[4], uint32_t const in[16]) { - register uint32_t a, b, c, d; - - a = buf[0]; - b = buf[1]; - c = buf[2]; - d = buf[3]; - - MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); - MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); - MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); - MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); - MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); - MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); - MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); - MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); - MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); - MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); - MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); - MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); - MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); - MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); - MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); - MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); - - MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); - MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); - MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); - MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); - MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); - MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); - MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); - MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); - MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); - MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); - MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); - MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); - MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); - MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); - MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); - MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); - - MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); - MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); - MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); - MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); - MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); - MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); - MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); - MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); - MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); - MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); - MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); - MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); - MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); - MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); - MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); - MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); - - MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); - MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); - MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); - MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); - MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); - MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); - MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); - MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); - MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); - MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); - MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); - MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); - MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); - MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); - MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); - MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); - - buf[0] += a; - buf[1] += b; - buf[2] += c; - buf[3] += d; -} - -void MD5_Update(MD5_CTX *ctx, const unsigned char *buf, size_t len) { - uint32_t t; - - t = ctx->bits[0]; - if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) ctx->bits[1]++; - ctx->bits[1] += (uint32_t) len >> 29; - - t = (t >> 3) & 0x3f; - - if (t) { - unsigned char *p = (unsigned char *) ctx->in + t; - - t = 64 - t; - if (len < t) { - memcpy(p, buf, len); - return; - } - memcpy(p, buf, t); - byteReverse(ctx->in, 16); - MD5Transform(ctx->buf, (uint32_t *) ctx->in); - buf += t; - len -= t; - } - - while (len >= 64) { - memcpy(ctx->in, buf, 64); - byteReverse(ctx->in, 16); - MD5Transform(ctx->buf, (uint32_t *) ctx->in); - buf += 64; - len -= 64; - } - - memcpy(ctx->in, buf, len); -} - -void MD5_Final(unsigned char digest[16], MD5_CTX *ctx) { - unsigned count; - unsigned char *p; - uint32_t *a; - - count = (ctx->bits[0] >> 3) & 0x3F; - - p = ctx->in + count; - *p++ = 0x80; - count = 64 - 1 - count; - if (count < 8) { - memset(p, 0, count); - byteReverse(ctx->in, 16); - MD5Transform(ctx->buf, (uint32_t *) ctx->in); - memset(ctx->in, 0, 56); - } else { - memset(p, 0, count - 8); - } - byteReverse(ctx->in, 14); - - a = (uint32_t *) ctx->in; - a[14] = ctx->bits[0]; - a[15] = ctx->bits[1]; - - MD5Transform(ctx->buf, (uint32_t *) ctx->in); - byteReverse((unsigned char *) ctx->buf, 4); - memcpy(digest, ctx->buf, 16); - memset((char *) ctx, 0, sizeof(*ctx)); -} -#endif /* DISABLE_MD5 */ - -char *cs_md5(char buf[33], ...) { - unsigned char hash[16]; - const unsigned char *p; - va_list ap; - MD5_CTX ctx; - - MD5_Init(&ctx); - - va_start(ap, buf); - while ((p = va_arg(ap, const unsigned char *) ) != NULL) { - size_t len = va_arg(ap, size_t); - MD5_Update(&ctx, p, len); - } - va_end(ap); - - MD5_Final(hash, &ctx); - cs_to_hex(buf, hash, sizeof(hash)); - - return buf; -} - -#endif /* EXCLUDE_COMMON */ -#ifdef MG_MODULE_LINES -#line 1 "common/mbuf.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#ifndef EXCLUDE_COMMON - -#include -#include -/* Amalgamated: #include "common/mbuf.h" */ - -#ifndef MBUF_REALLOC -#define MBUF_REALLOC realloc -#endif - -#ifndef MBUF_FREE -#define MBUF_FREE free -#endif - -void mbuf_init(struct mbuf *mbuf, size_t initial_size) WEAK; -void mbuf_init(struct mbuf *mbuf, size_t initial_size) { - mbuf->len = mbuf->size = 0; - mbuf->buf = NULL; - mbuf_resize(mbuf, initial_size); -} - -void mbuf_free(struct mbuf *mbuf) WEAK; -void mbuf_free(struct mbuf *mbuf) { - if (mbuf->buf != NULL) { - MBUF_FREE(mbuf->buf); - mbuf_init(mbuf, 0); - } -} - -void mbuf_resize(struct mbuf *a, size_t new_size) WEAK; -void mbuf_resize(struct mbuf *a, size_t new_size) { - if (new_size > a->size || (new_size < a->size && new_size >= a->len)) { - char *buf = (char *) MBUF_REALLOC(a->buf, new_size); - /* - * In case realloc fails, there's not much we can do, except keep things as - * they are. Note that NULL is a valid return value from realloc when - * size == 0, but that is covered too. - */ - if (buf == NULL && new_size != 0) return; - a->buf = buf; - a->size = new_size; - } -} - -void mbuf_trim(struct mbuf *mbuf) WEAK; -void mbuf_trim(struct mbuf *mbuf) { - mbuf_resize(mbuf, mbuf->len); -} - -size_t mbuf_insert(struct mbuf *a, size_t off, const void *buf, size_t) WEAK; -size_t mbuf_insert(struct mbuf *a, size_t off, const void *buf, size_t len) { - char *p = NULL; - - assert(a != NULL); - assert(a->len <= a->size); - assert(off <= a->len); - - /* check overflow */ - if (~(size_t) 0 - (size_t) a->buf < len) return 0; - - if (a->len + len <= a->size) { - memmove(a->buf + off + len, a->buf + off, a->len - off); - if (buf != NULL) { - memcpy(a->buf + off, buf, len); - } - a->len += len; - } else { - size_t new_size = (size_t)((a->len + len) * MBUF_SIZE_MULTIPLIER); - if ((p = (char *) MBUF_REALLOC(a->buf, new_size)) != NULL) { - a->buf = p; - memmove(a->buf + off + len, a->buf + off, a->len - off); - if (buf != NULL) memcpy(a->buf + off, buf, len); - a->len += len; - a->size = new_size; - } else { - len = 0; - } - } - - return len; -} - -size_t mbuf_append(struct mbuf *a, const void *buf, size_t len) WEAK; -size_t mbuf_append(struct mbuf *a, const void *buf, size_t len) { - return mbuf_insert(a, a->len, buf, len); -} - -void mbuf_remove(struct mbuf *mb, size_t n) WEAK; -void mbuf_remove(struct mbuf *mb, size_t n) { - if (n > 0 && n <= mb->len) { - memmove(mb->buf, mb->buf + n, mb->len - n); - mb->len -= n; - } -} - -#endif /* EXCLUDE_COMMON */ -#ifdef MG_MODULE_LINES -#line 1 "common/mg_str.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "common/mg_str.h" */ - -#include -#include - -int mg_ncasecmp(const char *s1, const char *s2, size_t len) WEAK; - -struct mg_str mg_mk_str(const char *s) WEAK; -struct mg_str mg_mk_str(const char *s) { - struct mg_str ret = {s, 0}; - if (s != NULL) ret.len = strlen(s); - return ret; -} - -struct mg_str mg_mk_str_n(const char *s, size_t len) WEAK; -struct mg_str mg_mk_str_n(const char *s, size_t len) { - struct mg_str ret = {s, len}; - return ret; -} - -int mg_vcmp(const struct mg_str *str1, const char *str2) WEAK; -int mg_vcmp(const struct mg_str *str1, const char *str2) { - size_t n2 = strlen(str2), n1 = str1->len; - int r = memcmp(str1->p, str2, (n1 < n2) ? n1 : n2); - if (r == 0) { - return n1 - n2; - } - return r; -} - -int mg_vcasecmp(const struct mg_str *str1, const char *str2) WEAK; -int mg_vcasecmp(const struct mg_str *str1, const char *str2) { - size_t n2 = strlen(str2), n1 = str1->len; - int r = mg_ncasecmp(str1->p, str2, (n1 < n2) ? n1 : n2); - if (r == 0) { - return n1 - n2; - } - return r; -} - -struct mg_str mg_strdup(const struct mg_str s) WEAK; -struct mg_str mg_strdup(const struct mg_str s) { - struct mg_str r = {NULL, 0}; - if (s.len > 0 && s.p != NULL) { - r.p = (char *) malloc(s.len); - if (r.p != NULL) { - memcpy((char *) r.p, s.p, s.len); - r.len = s.len; - } - } - return r; -} - -int mg_strcmp(const struct mg_str str1, const struct mg_str str2) WEAK; -int mg_strcmp(const struct mg_str str1, const struct mg_str str2) { - size_t i = 0; - while (i < str1.len && i < str2.len) { - if (str1.p[i] < str2.p[i]) return -1; - if (str1.p[i] > str2.p[i]) return 1; - i++; - } - if (i < str1.len) return 1; - if (i < str2.len) return -1; - return 0; -} - -int mg_strncmp(const struct mg_str, const struct mg_str, size_t n) WEAK; -int mg_strncmp(const struct mg_str str1, const struct mg_str str2, size_t n) { - struct mg_str s1 = str1; - struct mg_str s2 = str2; - - if (s1.len > n) { - s1.len = n; - } - if (s2.len > n) { - s2.len = n; - } - return mg_strcmp(s1, s2); -} -#ifdef MG_MODULE_LINES -#line 1 "common/sha1.c" -#endif -/* Copyright(c) By Steve Reid */ -/* 100% Public Domain */ - -/* Amalgamated: #include "common/sha1.h" */ - -#if !DISABLE_SHA1 && !defined(EXCLUDE_COMMON) - -/* Amalgamated: #include "common/cs_endian.h" */ - -#define SHA1HANDSOFF -#if defined(__sun) -/* Amalgamated: #include "common/solarisfixes.h" */ -#endif - -union char64long16 { - unsigned char c[64]; - uint32_t l[16]; -}; - -#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) - -static uint32_t blk0(union char64long16 *block, int i) { -/* Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN */ -#if BYTE_ORDER == LITTLE_ENDIAN - block->l[i] = - (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF); -#endif - return block->l[i]; -} - -/* Avoid redefine warning (ARM /usr/include/sys/ucontext.h define R0~R4) */ -#undef blk -#undef R0 -#undef R1 -#undef R2 -#undef R3 -#undef R4 - -#define blk(i) \ - (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ - block->l[(i + 2) & 15] ^ block->l[i & 15], \ - 1)) -#define R0(v, w, x, y, z, i) \ - z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); \ - w = rol(w, 30); -#define R1(v, w, x, y, z, i) \ - z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ - w = rol(w, 30); -#define R2(v, w, x, y, z, i) \ - z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ - w = rol(w, 30); -#define R3(v, w, x, y, z, i) \ - z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ - w = rol(w, 30); -#define R4(v, w, x, y, z, i) \ - z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ - w = rol(w, 30); - -void cs_sha1_transform(uint32_t state[5], const unsigned char buffer[64]) { - uint32_t a, b, c, d, e; - union char64long16 block[1]; - - memcpy(block, buffer, 64); - a = state[0]; - b = state[1]; - c = state[2]; - d = state[3]; - e = state[4]; - R0(a, b, c, d, e, 0); - R0(e, a, b, c, d, 1); - R0(d, e, a, b, c, 2); - R0(c, d, e, a, b, 3); - R0(b, c, d, e, a, 4); - R0(a, b, c, d, e, 5); - R0(e, a, b, c, d, 6); - R0(d, e, a, b, c, 7); - R0(c, d, e, a, b, 8); - R0(b, c, d, e, a, 9); - R0(a, b, c, d, e, 10); - R0(e, a, b, c, d, 11); - R0(d, e, a, b, c, 12); - R0(c, d, e, a, b, 13); - R0(b, c, d, e, a, 14); - R0(a, b, c, d, e, 15); - R1(e, a, b, c, d, 16); - R1(d, e, a, b, c, 17); - R1(c, d, e, a, b, 18); - R1(b, c, d, e, a, 19); - R2(a, b, c, d, e, 20); - R2(e, a, b, c, d, 21); - R2(d, e, a, b, c, 22); - R2(c, d, e, a, b, 23); - R2(b, c, d, e, a, 24); - R2(a, b, c, d, e, 25); - R2(e, a, b, c, d, 26); - R2(d, e, a, b, c, 27); - R2(c, d, e, a, b, 28); - R2(b, c, d, e, a, 29); - R2(a, b, c, d, e, 30); - R2(e, a, b, c, d, 31); - R2(d, e, a, b, c, 32); - R2(c, d, e, a, b, 33); - R2(b, c, d, e, a, 34); - R2(a, b, c, d, e, 35); - R2(e, a, b, c, d, 36); - R2(d, e, a, b, c, 37); - R2(c, d, e, a, b, 38); - R2(b, c, d, e, a, 39); - R3(a, b, c, d, e, 40); - R3(e, a, b, c, d, 41); - R3(d, e, a, b, c, 42); - R3(c, d, e, a, b, 43); - R3(b, c, d, e, a, 44); - R3(a, b, c, d, e, 45); - R3(e, a, b, c, d, 46); - R3(d, e, a, b, c, 47); - R3(c, d, e, a, b, 48); - R3(b, c, d, e, a, 49); - R3(a, b, c, d, e, 50); - R3(e, a, b, c, d, 51); - R3(d, e, a, b, c, 52); - R3(c, d, e, a, b, 53); - R3(b, c, d, e, a, 54); - R3(a, b, c, d, e, 55); - R3(e, a, b, c, d, 56); - R3(d, e, a, b, c, 57); - R3(c, d, e, a, b, 58); - R3(b, c, d, e, a, 59); - R4(a, b, c, d, e, 60); - R4(e, a, b, c, d, 61); - R4(d, e, a, b, c, 62); - R4(c, d, e, a, b, 63); - R4(b, c, d, e, a, 64); - R4(a, b, c, d, e, 65); - R4(e, a, b, c, d, 66); - R4(d, e, a, b, c, 67); - R4(c, d, e, a, b, 68); - R4(b, c, d, e, a, 69); - R4(a, b, c, d, e, 70); - R4(e, a, b, c, d, 71); - R4(d, e, a, b, c, 72); - R4(c, d, e, a, b, 73); - R4(b, c, d, e, a, 74); - R4(a, b, c, d, e, 75); - R4(e, a, b, c, d, 76); - R4(d, e, a, b, c, 77); - R4(c, d, e, a, b, 78); - R4(b, c, d, e, a, 79); - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - state[4] += e; - /* Erase working structures. The order of operations is important, - * used to ensure that compiler doesn't optimize those out. */ - memset(block, 0, sizeof(block)); - a = b = c = d = e = 0; - (void) a; - (void) b; - (void) c; - (void) d; - (void) e; -} - -void cs_sha1_init(cs_sha1_ctx *context) { - context->state[0] = 0x67452301; - context->state[1] = 0xEFCDAB89; - context->state[2] = 0x98BADCFE; - context->state[3] = 0x10325476; - context->state[4] = 0xC3D2E1F0; - context->count[0] = context->count[1] = 0; -} - -void cs_sha1_update(cs_sha1_ctx *context, const unsigned char *data, - uint32_t len) { - uint32_t i, j; - - j = context->count[0]; - if ((context->count[0] += len << 3) < j) context->count[1]++; - context->count[1] += (len >> 29); - j = (j >> 3) & 63; - if ((j + len) > 63) { - memcpy(&context->buffer[j], data, (i = 64 - j)); - cs_sha1_transform(context->state, context->buffer); - for (; i + 63 < len; i += 64) { - cs_sha1_transform(context->state, &data[i]); - } - j = 0; - } else - i = 0; - memcpy(&context->buffer[j], &data[i], len - i); -} - -void cs_sha1_final(unsigned char digest[20], cs_sha1_ctx *context) { - unsigned i; - unsigned char finalcount[8], c; - - for (i = 0; i < 8; i++) { - finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >> - ((3 - (i & 3)) * 8)) & - 255); - } - c = 0200; - cs_sha1_update(context, &c, 1); - while ((context->count[0] & 504) != 448) { - c = 0000; - cs_sha1_update(context, &c, 1); - } - cs_sha1_update(context, finalcount, 8); - for (i = 0; i < 20; i++) { - digest[i] = - (unsigned char) ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); - } - memset(context, '\0', sizeof(*context)); - memset(&finalcount, '\0', sizeof(finalcount)); -} - -void cs_hmac_sha1(const unsigned char *key, size_t keylen, - const unsigned char *data, size_t datalen, - unsigned char out[20]) { - cs_sha1_ctx ctx; - unsigned char buf1[64], buf2[64], tmp_key[20], i; - - if (keylen > sizeof(buf1)) { - cs_sha1_init(&ctx); - cs_sha1_update(&ctx, key, keylen); - cs_sha1_final(tmp_key, &ctx); - key = tmp_key; - keylen = sizeof(tmp_key); - } - - memset(buf1, 0, sizeof(buf1)); - memset(buf2, 0, sizeof(buf2)); - memcpy(buf1, key, keylen); - memcpy(buf2, key, keylen); - - for (i = 0; i < sizeof(buf1); i++) { - buf1[i] ^= 0x36; - buf2[i] ^= 0x5c; - } - - cs_sha1_init(&ctx); - cs_sha1_update(&ctx, buf1, sizeof(buf1)); - cs_sha1_update(&ctx, data, datalen); - cs_sha1_final(out, &ctx); - - cs_sha1_init(&ctx); - cs_sha1_update(&ctx, buf2, sizeof(buf2)); - cs_sha1_update(&ctx, out, 20); - cs_sha1_final(out, &ctx); -} - -#endif /* EXCLUDE_COMMON */ -#ifdef MG_MODULE_LINES -#line 1 "common/str_util.c" -#endif -/* - * Copyright (c) 2015 Cesanta Software Limited - * All rights reserved - */ - -#ifndef EXCLUDE_COMMON - -/* Amalgamated: #include "common/platform.h" */ -/* Amalgamated: #include "common/str_util.h" */ - -#ifndef C_DISABLE_BUILTIN_SNPRINTF -#define C_DISABLE_BUILTIN_SNPRINTF 0 -#endif - -#ifndef MG_MALLOC -#define MG_MALLOC malloc -#endif - -#ifndef MG_FREE -#define MG_FREE free -#endif - -size_t c_strnlen(const char *s, size_t maxlen) WEAK; -size_t c_strnlen(const char *s, size_t maxlen) { - size_t l = 0; - for (; l < maxlen && s[l] != '\0'; l++) { - } - return l; -} - -#define C_SNPRINTF_APPEND_CHAR(ch) \ - do { \ - if (i < (int) buf_size) buf[i] = ch; \ - i++; \ - } while (0) - -#define C_SNPRINTF_FLAG_ZERO 1 - -#if C_DISABLE_BUILTIN_SNPRINTF -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) WEAK; -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) { - return vsnprintf(buf, buf_size, fmt, ap); -} -#else -static int c_itoa(char *buf, size_t buf_size, int64_t num, int base, int flags, - int field_width) { - char tmp[40]; - int i = 0, k = 0, neg = 0; - - if (num < 0) { - neg++; - num = -num; - } - - /* Print into temporary buffer - in reverse order */ - do { - int rem = num % base; - if (rem < 10) { - tmp[k++] = '0' + rem; - } else { - tmp[k++] = 'a' + (rem - 10); - } - num /= base; - } while (num > 0); - - /* Zero padding */ - if (flags && C_SNPRINTF_FLAG_ZERO) { - while (k < field_width && k < (int) sizeof(tmp) - 1) { - tmp[k++] = '0'; - } - } - - /* And sign */ - if (neg) { - tmp[k++] = '-'; - } - - /* Now output */ - while (--k >= 0) { - C_SNPRINTF_APPEND_CHAR(tmp[k]); - } - - return i; -} - -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) WEAK; -int c_vsnprintf(char *buf, size_t buf_size, const char *fmt, va_list ap) { - int ch, i = 0, len_mod, flags, precision, field_width; - - while ((ch = *fmt++) != '\0') { - if (ch != '%') { - C_SNPRINTF_APPEND_CHAR(ch); - } else { - /* - * Conversion specification: - * zero or more flags (one of: # 0 - + ') - * an optional minimum field width (digits) - * an optional precision (. followed by digits, or *) - * an optional length modifier (one of: hh h l ll L q j z t) - * conversion specifier (one of: d i o u x X e E f F g G a A c s p n) - */ - flags = field_width = precision = len_mod = 0; - - /* Flags. only zero-pad flag is supported. */ - if (*fmt == '0') { - flags |= C_SNPRINTF_FLAG_ZERO; - } - - /* Field width */ - while (*fmt >= '0' && *fmt <= '9') { - field_width *= 10; - field_width += *fmt++ - '0'; - } - /* Dynamic field width */ - if (*fmt == '*') { - field_width = va_arg(ap, int); - fmt++; - } - - /* Precision */ - if (*fmt == '.') { - fmt++; - if (*fmt == '*') { - precision = va_arg(ap, int); - fmt++; - } else { - while (*fmt >= '0' && *fmt <= '9') { - precision *= 10; - precision += *fmt++ - '0'; - } - } - } - - /* Length modifier */ - switch (*fmt) { - case 'h': - case 'l': - case 'L': - case 'I': - case 'q': - case 'j': - case 'z': - case 't': - len_mod = *fmt++; - if (*fmt == 'h') { - len_mod = 'H'; - fmt++; - } - if (*fmt == 'l') { - len_mod = 'q'; - fmt++; - } - break; - } - - ch = *fmt++; - if (ch == 's') { - const char *s = va_arg(ap, const char *); /* Always fetch parameter */ - int j; - int pad = field_width - (precision >= 0 ? c_strnlen(s, precision) : 0); - for (j = 0; j < pad; j++) { - C_SNPRINTF_APPEND_CHAR(' '); - } - - /* `s` may be NULL in case of %.*s */ - if (s != NULL) { - /* Ignore negative and 0 precisions */ - for (j = 0; (precision <= 0 || j < precision) && s[j] != '\0'; j++) { - C_SNPRINTF_APPEND_CHAR(s[j]); - } - } - } else if (ch == 'c') { - ch = va_arg(ap, int); /* Always fetch parameter */ - C_SNPRINTF_APPEND_CHAR(ch); - } else if (ch == 'd' && len_mod == 0) { - i += c_itoa(buf + i, buf_size - i, va_arg(ap, int), 10, flags, - field_width); - } else if (ch == 'd' && len_mod == 'l') { - i += c_itoa(buf + i, buf_size - i, va_arg(ap, long), 10, flags, - field_width); -#ifdef SSIZE_MAX - } else if (ch == 'd' && len_mod == 'z') { - i += c_itoa(buf + i, buf_size - i, va_arg(ap, ssize_t), 10, flags, - field_width); -#endif - } else if (ch == 'd' && len_mod == 'q') { - i += c_itoa(buf + i, buf_size - i, va_arg(ap, int64_t), 10, flags, - field_width); - } else if ((ch == 'x' || ch == 'u') && len_mod == 0) { - i += c_itoa(buf + i, buf_size - i, va_arg(ap, unsigned), - ch == 'x' ? 16 : 10, flags, field_width); - } else if ((ch == 'x' || ch == 'u') && len_mod == 'l') { - i += c_itoa(buf + i, buf_size - i, va_arg(ap, unsigned long), - ch == 'x' ? 16 : 10, flags, field_width); - } else if ((ch == 'x' || ch == 'u') && len_mod == 'z') { - i += c_itoa(buf + i, buf_size - i, va_arg(ap, size_t), - ch == 'x' ? 16 : 10, flags, field_width); - } else if (ch == 'p') { - unsigned long num = (unsigned long) (uintptr_t) va_arg(ap, void *); - C_SNPRINTF_APPEND_CHAR('0'); - C_SNPRINTF_APPEND_CHAR('x'); - i += c_itoa(buf + i, buf_size - i, num, 16, flags, 0); - } else { -#ifndef NO_LIBC - /* - * TODO(lsm): abort is not nice in a library, remove it - * Also, ESP8266 SDK doesn't have it - */ - abort(); -#endif - } - } - } - - /* Zero-terminate the result */ - if (buf_size > 0) { - buf[i < (int) buf_size ? i : (int) buf_size - 1] = '\0'; - } - - return i; -} -#endif - -int c_snprintf(char *buf, size_t buf_size, const char *fmt, ...) WEAK; -int c_snprintf(char *buf, size_t buf_size, const char *fmt, ...) { - int result; - va_list ap; - va_start(ap, fmt); - result = c_vsnprintf(buf, buf_size, fmt, ap); - va_end(ap); - return result; -} - -#ifdef _WIN32 -int to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len) { - int ret; - char buf[MAX_PATH * 2], buf2[MAX_PATH * 2], *p; - - strncpy(buf, path, sizeof(buf)); - buf[sizeof(buf) - 1] = '\0'; - - /* Trim trailing slashes. Leave backslash for paths like "X:\" */ - p = buf + strlen(buf) - 1; - while (p > buf && p[-1] != ':' && (p[0] == '\\' || p[0] == '/')) *p-- = '\0'; - - memset(wbuf, 0, wbuf_len * sizeof(wchar_t)); - ret = MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len); - - /* - * Convert back to Unicode. If doubly-converted string does not match the - * original, something is fishy, reject. - */ - WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2), - NULL, NULL); - if (strcmp(buf, buf2) != 0) { - wbuf[0] = L'\0'; - ret = 0; - } - - return ret; -} -#endif /* _WIN32 */ - -/* The simplest O(mn) algorithm. Better implementation are GPLed */ -const char *c_strnstr(const char *s, const char *find, size_t slen) WEAK; -const char *c_strnstr(const char *s, const char *find, size_t slen) { - size_t find_length = strlen(find); - size_t i; - - for (i = 0; i < slen; i++) { - if (i + find_length > slen) { - return NULL; - } - - if (strncmp(&s[i], find, find_length) == 0) { - return &s[i]; - } - } - - return NULL; -} - -#if CS_ENABLE_STRDUP -char *strdup(const char *src) WEAK; -char *strdup(const char *src) { - size_t len = strlen(src) + 1; - char *ret = malloc(len); - if (ret != NULL) { - strcpy(ret, src); - } - return ret; -} -#endif - -void cs_to_hex(char *to, const unsigned char *p, size_t len) WEAK; -void cs_to_hex(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'; -} - -static int fourbit(int ch) { - if (ch >= '0' && ch <= '9') { - return ch - '0'; - } else if (ch >= 'a' && ch <= 'f') { - return ch - 'a' + 10; - } else if (ch >= 'A' && ch <= 'F') { - return ch - 'A' + 10; - } - return 0; -} - -void cs_from_hex(char *to, const char *p, size_t len) WEAK; -void cs_from_hex(char *to, const char *p, size_t len) { - size_t i; - - for (i = 0; i < len; i += 2) { - *to++ = (fourbit(p[i]) << 4) + fourbit(p[i + 1]); - } - *to = '\0'; -} - -#if CS_ENABLE_TO64 -int64_t cs_to64(const char *s) WEAK; -int64_t cs_to64(const char *s) { - int64_t result = 0; - int64_t neg = 1; - while (*s && isspace((unsigned char) *s)) s++; - if (*s == '-') { - neg = -1; - s++; - } - while (isdigit((unsigned char) *s)) { - result *= 10; - result += (*s - '0'); - s++; - } - return result * neg; -} -#endif - -static int str_util_lowercase(const char *s) { - return tolower(*(const unsigned char *) s); -} - -int mg_ncasecmp(const char *s1, const char *s2, size_t len) WEAK; -int mg_ncasecmp(const char *s1, const char *s2, size_t len) { - int diff = 0; - - if (len > 0) do { - diff = str_util_lowercase(s1++) - str_util_lowercase(s2++); - } while (diff == 0 && s1[-1] != '\0' && --len > 0); - - return diff; -} - -int mg_casecmp(const char *s1, const char *s2) WEAK; -int mg_casecmp(const char *s1, const char *s2) { - return mg_ncasecmp(s1, s2, (size_t) ~0); -} - -int mg_asprintf(char **buf, size_t size, const char *fmt, ...) WEAK; -int mg_asprintf(char **buf, size_t size, const char *fmt, ...) { - int ret; - va_list ap; - va_start(ap, fmt); - ret = mg_avprintf(buf, size, fmt, ap); - va_end(ap); - return ret; -} - -int mg_avprintf(char **buf, size_t size, const char *fmt, va_list ap) WEAK; -int mg_avprintf(char **buf, size_t size, const char *fmt, va_list ap) { - va_list ap_copy; - int len; - - va_copy(ap_copy, ap); - len = vsnprintf(*buf, size, fmt, ap_copy); - va_end(ap_copy); - - if (len < 0) { - /* eCos and Windows are not standard-compliant and return -1 when - * the buffer is too small. Keep allocating larger buffers until we - * succeed or out of memory. */ - *buf = NULL; /* LCOV_EXCL_START */ - while (len < 0) { - MG_FREE(*buf); - size *= 2; - if ((*buf = (char *) MG_MALLOC(size)) == NULL) break; - va_copy(ap_copy, ap); - len = vsnprintf(*buf, size, fmt, ap_copy); - va_end(ap_copy); - } - /* LCOV_EXCL_STOP */ - } else if (len >= (int) size) { - /* Standard-compliant code path. Allocate a buffer that is large enough. */ - if ((*buf = (char *) MG_MALLOC(len + 1)) == NULL) { - len = -1; /* LCOV_EXCL_LINE */ - } else { /* LCOV_EXCL_LINE */ - va_copy(ap_copy, ap); - len = vsnprintf(*buf, len + 1, fmt, ap_copy); - va_end(ap_copy); - } - } - - return len; -} - -#endif /* EXCLUDE_COMMON */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/tun.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_TUN_H_ -#define CS_MONGOOSE_SRC_TUN_H_ - -#if MG_ENABLE_TUN - -/* Amalgamated: #include "mongoose/src/net.h" */ -/* Amalgamated: #include "common/mg_str.h" */ - -#ifndef MG_TUN_RECONNECT_INTERVAL -#define MG_TUN_RECONNECT_INTERVAL 1 -#endif - -#define MG_TUN_PROTO_NAME "mg_tun" - -#define MG_TUN_DATA_FRAME 0x0 -#define MG_TUN_F_END_STREAM 0x1 - -/* - * MG TUN frame format is loosely based on HTTP/2. - * However since the communication happens via WebSocket - * there is no need to encode the frame length, since that's - * solved by WebSocket framing. - * - * TODO(mkm): Detailed description of the protocol. - */ -struct mg_tun_frame { - uint8_t type; - uint8_t flags; - uint32_t stream_id; /* opaque stream identifier */ - struct mg_str body; -}; - -struct mg_tun_ssl_opts { -#if MG_ENABLE_SSL - const char *ssl_cert; - const char *ssl_key; - const char *ssl_ca_cert; -#else - int dummy; /* some compilers don't like empty structs */ -#endif -}; - -struct mg_tun_client { - struct mg_mgr *mgr; - struct mg_iface *iface; - const char *disp_url; - struct mg_tun_ssl_opts ssl; - - uint32_t last_stream_id; /* stream id of most recently accepted connection */ - - struct mg_connection *disp; - struct mg_connection *listener; - struct mg_connection *reconnect; -}; - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -struct mg_connection *mg_tun_bind_opt(struct mg_mgr *mgr, - const char *dispatcher, - mg_event_handler_t handler, - struct mg_bind_opts opts); - -int mg_tun_parse_frame(void *data, size_t len, struct mg_tun_frame *frame); - -void mg_tun_send_frame(struct mg_connection *ws, uint32_t stream_id, - uint8_t type, uint8_t flags, struct mg_str msg); - -void mg_tun_destroy_client(struct mg_tun_client *client); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_TUN */ - -#endif /* CS_MONGOOSE_SRC_TUN_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - * - * This software is dual-licensed: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. For the terms of this - * license, see . - * - * You are free to use this software under the terms of the GNU General - * Public License, but WITHOUT ANY WARRANTY; without even the implied - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * Alternatively, you can license this software under a commercial - * license, as set out in . - */ - -/* Amalgamated: #include "common/cs_time.h" */ -/* Amalgamated: #include "mongoose/src/dns.h" */ -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/resolv.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ -/* Amalgamated: #include "mongoose/src/tun.h" */ - -#define MG_MAX_HOST_LEN 200 - -#define MG_COPY_COMMON_CONNECTION_OPTIONS(dst, src) \ - memcpy(dst, src, sizeof(*dst)); - -/* Which flags can be pre-set by the user at connection creation time. */ -#define _MG_ALLOWED_CONNECT_FLAGS_MASK \ - (MG_F_USER_1 | MG_F_USER_2 | MG_F_USER_3 | MG_F_USER_4 | MG_F_USER_5 | \ - MG_F_USER_6 | MG_F_WEBSOCKET_NO_DEFRAG | MG_F_ENABLE_BROADCAST) -/* Which flags should be modifiable by user's callbacks. */ -#define _MG_CALLBACK_MODIFIABLE_FLAGS_MASK \ - (MG_F_USER_1 | MG_F_USER_2 | MG_F_USER_3 | MG_F_USER_4 | MG_F_USER_5 | \ - MG_F_USER_6 | MG_F_WEBSOCKET_NO_DEFRAG | MG_F_SEND_AND_CLOSE | \ - MG_F_CLOSE_IMMEDIATELY | MG_F_IS_WEBSOCKET | MG_F_DELETE_CHUNK) - -#ifndef intptr_t -#define intptr_t long -#endif - -MG_INTERNAL void mg_add_conn(struct mg_mgr *mgr, struct mg_connection *c) { - DBG(("%p %p", mgr, c)); - c->mgr = mgr; - c->next = mgr->active_connections; - mgr->active_connections = c; - c->prev = NULL; - if (c->next != NULL) c->next->prev = c; - if (c->sock != INVALID_SOCKET) { - c->iface->vtable->add_conn(c); - } -} - -MG_INTERNAL void mg_remove_conn(struct mg_connection *conn) { - if (conn->prev == NULL) conn->mgr->active_connections = conn->next; - if (conn->prev) conn->prev->next = conn->next; - if (conn->next) conn->next->prev = conn->prev; - conn->iface->vtable->remove_conn(conn); -} - -MG_INTERNAL void mg_call(struct mg_connection *nc, - mg_event_handler_t ev_handler, int ev, void *ev_data) { - if (ev_handler == NULL) { - /* - * If protocol handler is specified, call it. Otherwise, call user-specified - * event handler. - */ - ev_handler = nc->proto_handler ? nc->proto_handler : nc->handler; - } - if (ev != MG_EV_POLL) { - DBG(("%p %s ev=%d ev_data=%p flags=%lu rmbl=%d smbl=%d", nc, - ev_handler == nc->handler ? "user" : "proto", ev, ev_data, nc->flags, - (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len)); - } - -#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP - /* LCOV_EXCL_START */ - if (nc->mgr->hexdump_file != NULL && ev != MG_EV_POLL && - ev != MG_EV_SEND /* handled separately */) { - if (ev == MG_EV_RECV) { - mg_hexdump_connection(nc, nc->mgr->hexdump_file, nc->recv_mbuf.buf, - *(int *) ev_data, ev); - } else { - mg_hexdump_connection(nc, nc->mgr->hexdump_file, NULL, 0, ev); - } - } -/* LCOV_EXCL_STOP */ -#endif - if (ev_handler != NULL) { - unsigned long flags_before = nc->flags; - size_t recv_mbuf_before = nc->recv_mbuf.len, recved; - ev_handler(nc, ev, ev_data); - recved = (recv_mbuf_before - nc->recv_mbuf.len); - /* Prevent user handler from fiddling with system flags. */ - if (ev_handler == nc->handler && nc->flags != flags_before) { - nc->flags = (flags_before & ~_MG_CALLBACK_MODIFIABLE_FLAGS_MASK) | - (nc->flags & _MG_CALLBACK_MODIFIABLE_FLAGS_MASK); - } - if (recved > 0 && !(nc->flags & MG_F_UDP)) { - nc->iface->vtable->recved(nc, recved); - } - } - if (ev != MG_EV_POLL) { - DBG(("%p after %s flags=%lu rmbl=%d smbl=%d", nc, - ev_handler == nc->handler ? "user" : "proto", nc->flags, - (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len)); - } -} - -void mg_if_timer(struct mg_connection *c, double now) { - if (c->ev_timer_time > 0 && now >= c->ev_timer_time) { - double old_value = c->ev_timer_time; - mg_call(c, NULL, MG_EV_TIMER, &now); - /* - * To prevent timer firing all the time, reset the timer after delivery. - * However, in case user sets it to new value, do not reset. - */ - if (c->ev_timer_time == old_value) { - c->ev_timer_time = 0; - } - } -} - -void mg_if_poll(struct mg_connection *nc, time_t now) { - if (!(nc->flags & MG_F_SSL) || (nc->flags & MG_F_SSL_HANDSHAKE_DONE)) { - mg_call(nc, NULL, MG_EV_POLL, &now); - } -} - -static void mg_destroy_conn(struct mg_connection *conn, int destroy_if) { - if (destroy_if) conn->iface->vtable->destroy_conn(conn); - if (conn->proto_data != NULL && conn->proto_data_destructor != NULL) { - conn->proto_data_destructor(conn->proto_data); - } -#if MG_ENABLE_SSL - mg_ssl_if_conn_free(conn); -#endif - mbuf_free(&conn->recv_mbuf); - mbuf_free(&conn->send_mbuf); - - memset(conn, 0, sizeof(*conn)); - MG_FREE(conn); -} - -void mg_close_conn(struct mg_connection *conn) { - DBG(("%p %lu %d", conn, conn->flags, conn->sock)); - mg_remove_conn(conn); - conn->iface->vtable->destroy_conn(conn); - mg_call(conn, NULL, MG_EV_CLOSE, NULL); - mg_destroy_conn(conn, 0 /* destroy_if */); -} - -void mg_mgr_init(struct mg_mgr *m, void *user_data) { - struct mg_mgr_init_opts opts; - memset(&opts, 0, sizeof(opts)); - mg_mgr_init_opt(m, user_data, opts); -} - -void mg_mgr_init_opt(struct mg_mgr *m, void *user_data, - struct mg_mgr_init_opts opts) { - memset(m, 0, sizeof(*m)); -#if MG_ENABLE_BROADCAST - m->ctl[0] = m->ctl[1] = INVALID_SOCKET; -#endif - m->user_data = user_data; - -#ifdef _WIN32 - { - WSADATA data; - WSAStartup(MAKEWORD(2, 2), &data); - } -#elif defined(__unix__) - /* Ignore SIGPIPE signal, so if client cancels the request, it - * won't kill the whole process. */ - signal(SIGPIPE, SIG_IGN); -#endif - -#if MG_ENABLE_SSL - { - static int init_done; - if (!init_done) { - mg_ssl_if_init(); - init_done++; - } - } -#endif - { - int i; - if (opts.num_ifaces == 0) { - opts.num_ifaces = mg_num_ifaces; - opts.ifaces = mg_ifaces; - } - if (opts.main_iface != NULL) { - opts.ifaces[MG_MAIN_IFACE] = opts.main_iface; - } - m->num_ifaces = opts.num_ifaces; - m->ifaces = - (struct mg_iface **) MG_MALLOC(sizeof(*m->ifaces) * opts.num_ifaces); - for (i = 0; i < mg_num_ifaces; i++) { - m->ifaces[i] = mg_if_create_iface(opts.ifaces[i], m); - m->ifaces[i]->vtable->init(m->ifaces[i]); - } - } - DBG(("==================================")); - DBG(("init mgr=%p", m)); -} - -#if MG_ENABLE_JAVASCRIPT -static enum v7_err mg_send_js(struct v7 *v7, v7_val_t *res) { - v7_val_t arg0 = v7_arg(v7, 0); - v7_val_t arg1 = v7_arg(v7, 1); - struct mg_connection *c = (struct mg_connection *) v7_get_ptr(v7, arg0); - size_t len = 0; - - if (v7_is_string(arg1)) { - const char *data = v7_get_string(v7, &arg1, &len); - mg_send(c, data, len); - } - - *res = v7_mk_number(v7, len); - - return V7_OK; -} - -enum v7_err mg_enable_javascript(struct mg_mgr *m, struct v7 *v7, - const char *init_file_name) { - v7_val_t v; - m->v7 = v7; - v7_set_method(v7, v7_get_global(v7), "mg_send", mg_send_js); - return v7_exec_file(v7, init_file_name, &v); -} -#endif - -void mg_mgr_free(struct mg_mgr *m) { - struct mg_connection *conn, *tmp_conn; - - DBG(("%p", m)); - if (m == NULL) return; - /* Do one last poll, see https://github.com/cesanta/mongoose/issues/286 */ - mg_mgr_poll(m, 0); - -#if MG_ENABLE_BROADCAST - if (m->ctl[0] != INVALID_SOCKET) closesocket(m->ctl[0]); - if (m->ctl[1] != INVALID_SOCKET) closesocket(m->ctl[1]); - m->ctl[0] = m->ctl[1] = INVALID_SOCKET; -#endif - - for (conn = m->active_connections; conn != NULL; conn = tmp_conn) { - tmp_conn = conn->next; - mg_close_conn(conn); - } - - { - int i; - for (i = 0; i < m->num_ifaces; i++) { - m->ifaces[i]->vtable->free(m->ifaces[i]); - MG_FREE(m->ifaces[i]); - } - MG_FREE(m->ifaces); - } -} - -time_t mg_mgr_poll(struct mg_mgr *m, int timeout_ms) { - int i; - time_t now = 0; /* oh GCC, seriously ? */ - - if (m->num_ifaces == 0) { - LOG(LL_ERROR, ("cannot poll: no interfaces")); - return 0; - } - - for (i = 0; i < m->num_ifaces; i++) { - now = m->ifaces[i]->vtable->poll(m->ifaces[i], timeout_ms); - } - return now; -} - -int mg_vprintf(struct mg_connection *nc, const char *fmt, va_list ap) { - char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem; - int len; - - if ((len = mg_avprintf(&buf, sizeof(mem), fmt, ap)) > 0) { - mg_send(nc, buf, len); - } - if (buf != mem && buf != NULL) { - MG_FREE(buf); /* LCOV_EXCL_LINE */ - } /* LCOV_EXCL_LINE */ - - return len; -} - -int mg_printf(struct mg_connection *conn, const char *fmt, ...) { - int len; - va_list ap; - va_start(ap, fmt); - len = mg_vprintf(conn, fmt, ap); - va_end(ap); - return len; -} - -#if MG_ENABLE_SYNC_RESOLVER -/* TODO(lsm): use non-blocking resolver */ -static int mg_resolve2(const char *host, struct in_addr *ina) { -#if MG_ENABLE_GETADDRINFO - int rv = 0; - struct addrinfo hints, *servinfo, *p; - struct sockaddr_in *h = NULL; - memset(&hints, 0, sizeof hints); - hints.ai_family = AF_INET; - hints.ai_socktype = SOCK_STREAM; - if ((rv = getaddrinfo(host, NULL, NULL, &servinfo)) != 0) { - DBG(("getaddrinfo(%s) failed: %s", host, strerror(mg_get_errno()))); - return 0; - } - for (p = servinfo; p != NULL; p = p->ai_next) { - memcpy(&h, &p->ai_addr, sizeof(struct sockaddr_in *)); - memcpy(ina, &h->sin_addr, sizeof(ina)); - } - freeaddrinfo(servinfo); - return 1; -#else - struct hostent *he; - if ((he = gethostbyname(host)) == NULL) { - DBG(("gethostbyname(%s) failed: %s", host, strerror(mg_get_errno()))); - } else { - memcpy(ina, he->h_addr_list[0], sizeof(*ina)); - return 1; - } - return 0; -#endif /* MG_ENABLE_GETADDRINFO */ -} - -int mg_resolve(const char *host, char *buf, size_t n) { - struct in_addr ad; - return mg_resolve2(host, &ad) ? snprintf(buf, n, "%s", inet_ntoa(ad)) : 0; -} -#endif /* MG_ENABLE_SYNC_RESOLVER */ - -MG_INTERNAL struct mg_connection *mg_create_connection_base( - struct mg_mgr *mgr, mg_event_handler_t callback, - struct mg_add_sock_opts opts) { - struct mg_connection *conn; - - if ((conn = (struct mg_connection *) MG_CALLOC(1, sizeof(*conn))) != NULL) { - conn->sock = INVALID_SOCKET; - conn->handler = callback; - conn->mgr = mgr; - conn->last_io_time = (time_t) mg_time(); - conn->iface = - (opts.iface != NULL ? opts.iface : mgr->ifaces[MG_MAIN_IFACE]); - conn->flags = opts.flags & _MG_ALLOWED_CONNECT_FLAGS_MASK; - conn->user_data = opts.user_data; - /* - * SIZE_MAX is defined as a long long constant in - * system headers on some platforms and so it - * doesn't compile with pedantic ansi flags. - */ - conn->recv_mbuf_limit = ~0; - } else { - MG_SET_PTRPTR(opts.error_string, "failed to create connection"); - } - - return conn; -} - -MG_INTERNAL struct mg_connection *mg_create_connection( - struct mg_mgr *mgr, mg_event_handler_t callback, - struct mg_add_sock_opts opts) { - struct mg_connection *conn = mg_create_connection_base(mgr, callback, opts); - - if (conn != NULL && !conn->iface->vtable->create_conn(conn)) { - MG_FREE(conn); - conn = NULL; - } - if (conn == NULL) { - MG_SET_PTRPTR(opts.error_string, "failed to init connection"); - } - - return conn; -} - -/* - * Address format: [PROTO://][HOST]:PORT - * - * HOST could be IPv4/IPv6 address or a host name. - * `host` is a destination buffer to hold parsed HOST part. Shoud be at least - * MG_MAX_HOST_LEN bytes long. - * `proto` is a returned socket type, either SOCK_STREAM or SOCK_DGRAM - * - * Return: - * -1 on parse error - * 0 if HOST needs DNS lookup - * >0 length of the address string - */ -MG_INTERNAL int mg_parse_address(const char *str, union socket_address *sa, - int *proto, char *host, size_t host_len) { - unsigned int a, b, c, d, port = 0; - int ch, len = 0; -#if MG_ENABLE_IPV6 - char buf[100]; -#endif - - /* - * MacOS needs that. If we do not zero it, subsequent bind() will fail. - * Also, all-zeroes in the socket address means binding to all addresses - * for both IPv4 and IPv6 (INADDR_ANY and IN6ADDR_ANY_INIT). - */ - memset(sa, 0, sizeof(*sa)); - sa->sin.sin_family = AF_INET; - - *proto = SOCK_STREAM; - - if (strncmp(str, "udp://", 6) == 0) { - str += 6; - *proto = SOCK_DGRAM; - } else if (strncmp(str, "tcp://", 6) == 0) { - str += 6; - } - - if (sscanf(str, "%u.%u.%u.%u:%u%n", &a, &b, &c, &d, &port, &len) == 5) { - /* Bind to a specific IPv4 address, e.g. 192.168.1.5:8080 */ - sa->sin.sin_addr.s_addr = - htonl(((uint32_t) a << 24) | ((uint32_t) b << 16) | c << 8 | d); - sa->sin.sin_port = htons((uint16_t) port); -#if MG_ENABLE_IPV6 - } else if (sscanf(str, "[%99[^]]]:%u%n", buf, &port, &len) == 2 && - inet_pton(AF_INET6, buf, &sa->sin6.sin6_addr)) { - /* IPv6 address, e.g. [3ffe:2a00:100:7031::1]:8080 */ - sa->sin6.sin6_family = AF_INET6; - sa->sin.sin_port = htons((uint16_t) port); -#endif -#if MG_ENABLE_ASYNC_RESOLVER - } else if (strlen(str) < host_len && - sscanf(str, "%[^ :]:%u%n", host, &port, &len) == 2) { - sa->sin.sin_port = htons((uint16_t) port); - if (mg_resolve_from_hosts_file(host, sa) != 0) { - /* - * if resolving from hosts file failed and the host - * we are trying to resolve is `localhost` - we should - * try to resolve it using `gethostbyname` and do not try - * to resolve it via DNS server if gethostbyname has failed too - */ - if (mg_ncasecmp(host, "localhost", 9) != 0) { - return 0; - } - -#if MG_ENABLE_SYNC_RESOLVER - if (!mg_resolve2(host, &sa->sin.sin_addr)) { - return -1; - } -#else - return -1; -#endif - } -#endif - } else if (sscanf(str, ":%u%n", &port, &len) == 1 || - sscanf(str, "%u%n", &port, &len) == 1) { - /* If only port is specified, bind to IPv4, INADDR_ANY */ - sa->sin.sin_port = htons((uint16_t) port); - } else { - return -1; - } - - /* Required for MG_ENABLE_ASYNC_RESOLVER=0 */ - (void) host; - (void) host_len; - - ch = str[len]; /* Character that follows the address */ - return port < 0xffffUL && (ch == '\0' || ch == ',' || isspace(ch)) ? len : -1; -} - -struct mg_connection *mg_if_accept_new_conn(struct mg_connection *lc) { - struct mg_add_sock_opts opts; - struct mg_connection *nc; - memset(&opts, 0, sizeof(opts)); - nc = mg_create_connection(lc->mgr, lc->handler, opts); - if (nc == NULL) return NULL; - nc->listener = lc; - nc->proto_handler = lc->proto_handler; - nc->user_data = lc->user_data; - nc->recv_mbuf_limit = lc->recv_mbuf_limit; - nc->iface = lc->iface; - if (lc->flags & MG_F_SSL) nc->flags |= MG_F_SSL; - mg_add_conn(nc->mgr, nc); - DBG(("%p %p %d %d", lc, nc, nc->sock, (int) nc->flags)); - return nc; -} - -void mg_if_accept_tcp_cb(struct mg_connection *nc, union socket_address *sa, - size_t sa_len) { - (void) sa_len; - nc->sa = *sa; - mg_call(nc, NULL, MG_EV_ACCEPT, &nc->sa); -} - -void mg_send(struct mg_connection *nc, const void *buf, int len) { - nc->last_io_time = (time_t) mg_time(); - if (nc->flags & MG_F_UDP) { - nc->iface->vtable->udp_send(nc, buf, len); - } else { - nc->iface->vtable->tcp_send(nc, buf, len); - } -#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP - if (nc->mgr && nc->mgr->hexdump_file != NULL) { - mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, len, MG_EV_SEND); - } -#endif -} - -void mg_if_sent_cb(struct mg_connection *nc, int num_sent) { - if (num_sent < 0) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } - mg_call(nc, NULL, MG_EV_SEND, &num_sent); -} - -MG_INTERNAL void mg_recv_common(struct mg_connection *nc, void *buf, int len, - int own) { - DBG(("%p %d %u", nc, len, (unsigned int) nc->recv_mbuf.len)); - if (nc->flags & MG_F_CLOSE_IMMEDIATELY) { - DBG(("%p discarded %d bytes", nc, len)); - /* - * This connection will not survive next poll. Do not deliver events, - * send data to /dev/null without acking. - */ - if (own) { - MG_FREE(buf); - } - return; - } - nc->last_io_time = (time_t) mg_time(); - if (!own) { - mbuf_append(&nc->recv_mbuf, buf, len); - } else if (nc->recv_mbuf.len == 0) { - /* Adopt buf as recv_mbuf's backing store. */ - mbuf_free(&nc->recv_mbuf); - nc->recv_mbuf.buf = (char *) buf; - nc->recv_mbuf.size = nc->recv_mbuf.len = len; - } else { - mbuf_append(&nc->recv_mbuf, buf, len); - MG_FREE(buf); - } - mg_call(nc, NULL, MG_EV_RECV, &len); -} - -void mg_if_recv_tcp_cb(struct mg_connection *nc, void *buf, int len, int own) { - mg_recv_common(nc, buf, len, own); -} - -void mg_if_recv_udp_cb(struct mg_connection *nc, void *buf, int len, - union socket_address *sa, size_t sa_len) { - assert(nc->flags & MG_F_UDP); - DBG(("%p %u", nc, (unsigned int) len)); - if (nc->flags & MG_F_LISTENING) { - struct mg_connection *lc = nc; - /* - * Do we have an existing connection for this source? - * This is very inefficient for long connection lists. - */ - for (nc = mg_next(lc->mgr, NULL); nc != NULL; nc = mg_next(lc->mgr, nc)) { - if (memcmp(&nc->sa.sa, &sa->sa, sa_len) == 0 && nc->listener == lc) { - break; - } - } - if (nc == NULL) { - struct mg_add_sock_opts opts; - memset(&opts, 0, sizeof(opts)); - /* Create fake connection w/out sock initialization */ - nc = mg_create_connection_base(lc->mgr, lc->handler, opts); - if (nc != NULL) { - nc->sock = lc->sock; - nc->listener = lc; - nc->sa = *sa; - nc->proto_handler = lc->proto_handler; - nc->user_data = lc->user_data; - nc->recv_mbuf_limit = lc->recv_mbuf_limit; - nc->flags = MG_F_UDP; - /* - * Long-lived UDP "connections" i.e. interactions that involve more - * than one request and response are rare, most are transactional: - * response is sent and the "connection" is closed. Or - should be. - * But users (including ourselves) tend to forget about that part, - * because UDP is connectionless and one does not think about - * processing a UDP request as handling a connection that needs to be - * closed. Thus, we begin with SEND_AND_CLOSE flag set, which should - * be a reasonable default for most use cases, but it is possible to - * turn it off the connection should be kept alive after processing. - */ - nc->flags |= MG_F_SEND_AND_CLOSE; - mg_add_conn(lc->mgr, nc); - mg_call(nc, NULL, MG_EV_ACCEPT, &nc->sa); - } else { - DBG(("OOM")); - /* No return here, we still need to drop on the floor */ - } - } - } - if (nc != NULL) { - mg_recv_common(nc, buf, len, 1); - } else { - /* Drop on the floor. */ - MG_FREE(buf); - nc->iface->vtable->recved(nc, len); - } -} - -/* - * Schedules an async connect for a resolved address and proto. - * Called from two places: `mg_connect_opt()` and from async resolver. - * When called from the async resolver, it must trigger `MG_EV_CONNECT` event - * with a failure flag to indicate connection failure. - */ -MG_INTERNAL struct mg_connection *mg_do_connect(struct mg_connection *nc, - int proto, - union socket_address *sa) { - DBG(("%p %s://%s:%hu", nc, proto == SOCK_DGRAM ? "udp" : "tcp", - inet_ntoa(sa->sin.sin_addr), ntohs(sa->sin.sin_port))); - - nc->flags |= MG_F_CONNECTING; - if (proto == SOCK_DGRAM) { - nc->iface->vtable->connect_udp(nc); - } else { - nc->iface->vtable->connect_tcp(nc, sa); - } - mg_add_conn(nc->mgr, nc); - return nc; -} - -void mg_if_connect_cb(struct mg_connection *nc, int err) { - DBG(("%p connect, err=%d", nc, err)); - nc->flags &= ~MG_F_CONNECTING; - if (err != 0) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } - mg_call(nc, NULL, MG_EV_CONNECT, &err); -} - -#if MG_ENABLE_ASYNC_RESOLVER -/* - * Callback for the async resolver on mg_connect_opt() call. - * Main task of this function is to trigger MG_EV_CONNECT event with - * either failure (and dealloc the connection) - * or success (and proceed with connect() - */ -static void resolve_cb(struct mg_dns_message *msg, void *data, - enum mg_resolve_err e) { - struct mg_connection *nc = (struct mg_connection *) data; - int i; - int failure = -1; - - nc->flags &= ~MG_F_RESOLVING; - if (msg != NULL) { - /* - * Take the first DNS A answer and run... - */ - for (i = 0; i < msg->num_answers; i++) { - if (msg->answers[i].rtype == MG_DNS_A_RECORD) { - /* - * Async resolver guarantees that there is at least one answer. - * TODO(lsm): handle IPv6 answers too - */ - mg_dns_parse_record_data(msg, &msg->answers[i], &nc->sa.sin.sin_addr, - 4); - mg_do_connect(nc, nc->flags & MG_F_UDP ? SOCK_DGRAM : SOCK_STREAM, - &nc->sa); - return; - } - } - } - - if (e == MG_RESOLVE_TIMEOUT) { - double now = mg_time(); - mg_call(nc, NULL, MG_EV_TIMER, &now); - } - - /* - * If we get there was no MG_DNS_A_RECORD in the answer - */ - mg_call(nc, NULL, MG_EV_CONNECT, &failure); - mg_call(nc, NULL, MG_EV_CLOSE, NULL); - mg_destroy_conn(nc, 1 /* destroy_if */); -} -#endif - -struct mg_connection *mg_connect(struct mg_mgr *mgr, const char *address, - mg_event_handler_t callback) { - struct mg_connect_opts opts; - memset(&opts, 0, sizeof(opts)); - return mg_connect_opt(mgr, address, callback, opts); -} - -struct mg_connection *mg_connect_opt(struct mg_mgr *mgr, const char *address, - mg_event_handler_t callback, - struct mg_connect_opts opts) { - struct mg_connection *nc = NULL; - int proto, rc; - struct mg_add_sock_opts add_sock_opts; - char host[MG_MAX_HOST_LEN]; - - MG_COPY_COMMON_CONNECTION_OPTIONS(&add_sock_opts, &opts); - - if ((nc = mg_create_connection(mgr, callback, add_sock_opts)) == NULL) { - return NULL; - } - - if ((rc = mg_parse_address(address, &nc->sa, &proto, host, sizeof(host))) < - 0) { - /* Address is malformed */ - MG_SET_PTRPTR(opts.error_string, "cannot parse address"); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; - } - - nc->flags |= opts.flags & _MG_ALLOWED_CONNECT_FLAGS_MASK; - nc->flags |= (proto == SOCK_DGRAM) ? MG_F_UDP : 0; - nc->user_data = opts.user_data; - -#if MG_ENABLE_SSL - DBG(("%p %s %s,%s,%s", nc, address, (opts.ssl_cert ? opts.ssl_cert : "-"), - (opts.ssl_key ? opts.ssl_key : "-"), - (opts.ssl_ca_cert ? opts.ssl_ca_cert : "-"))); - - if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL) { - const char *err_msg = NULL; - struct mg_ssl_if_conn_params params; - if (nc->flags & MG_F_UDP) { - MG_SET_PTRPTR(opts.error_string, "SSL for UDP is not supported"); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; - } - memset(¶ms, 0, sizeof(params)); - params.cert = opts.ssl_cert; - params.key = opts.ssl_key; - params.ca_cert = opts.ssl_ca_cert; - params.cipher_suites = opts.ssl_cipher_suites; - if (opts.ssl_ca_cert != NULL) { - if (opts.ssl_server_name != NULL) { - if (strcmp(opts.ssl_server_name, "*") != 0) { - params.server_name = opts.ssl_server_name; - } - } else if (rc == 0) { /* If it's a DNS name, use host. */ - params.server_name = host; - } - } - if (mg_ssl_if_conn_init(nc, ¶ms, &err_msg) != MG_SSL_OK) { - MG_SET_PTRPTR(opts.error_string, err_msg); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; - } - nc->flags |= MG_F_SSL; - } -#endif /* MG_ENABLE_SSL */ - - if (rc == 0) { -#if MG_ENABLE_ASYNC_RESOLVER - /* - * DNS resolution is required for host. - * mg_parse_address() fills port in nc->sa, which we pass to resolve_cb() - */ - struct mg_connection *dns_conn = NULL; - struct mg_resolve_async_opts o; - memset(&o, 0, sizeof(o)); - o.dns_conn = &dns_conn; - if (mg_resolve_async_opt(nc->mgr, host, MG_DNS_A_RECORD, resolve_cb, nc, - o) != 0) { - MG_SET_PTRPTR(opts.error_string, "cannot schedule DNS lookup"); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; - } - nc->priv_2 = dns_conn; - nc->flags |= MG_F_RESOLVING; - return nc; -#else - MG_SET_PTRPTR(opts.error_string, "Resolver is disabled"); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; -#endif - } else { - /* Address is parsed and resolved to IP. proceed with connect() */ - return mg_do_connect(nc, proto, &nc->sa); - } -} - -struct mg_connection *mg_bind(struct mg_mgr *srv, const char *address, - mg_event_handler_t event_handler) { - struct mg_bind_opts opts; - memset(&opts, 0, sizeof(opts)); - return mg_bind_opt(srv, address, event_handler, opts); -} - -struct mg_connection *mg_bind_opt(struct mg_mgr *mgr, const char *address, - mg_event_handler_t callback, - struct mg_bind_opts opts) { - union socket_address sa; - struct mg_connection *nc = NULL; - int proto, rc; - struct mg_add_sock_opts add_sock_opts; - char host[MG_MAX_HOST_LEN]; - - MG_COPY_COMMON_CONNECTION_OPTIONS(&add_sock_opts, &opts); - -#if MG_ENABLE_TUN - if (mg_strncmp(mg_mk_str(address), mg_mk_str("ws://"), 5) == 0 || - mg_strncmp(mg_mk_str(address), mg_mk_str("wss://"), 6) == 0) { - return mg_tun_bind_opt(mgr, address, callback, opts); - } -#endif - - if (mg_parse_address(address, &sa, &proto, host, sizeof(host)) <= 0) { - MG_SET_PTRPTR(opts.error_string, "cannot parse address"); - return NULL; - } - - nc = mg_create_connection(mgr, callback, add_sock_opts); - if (nc == NULL) { - return NULL; - } - - nc->sa = sa; - nc->flags |= MG_F_LISTENING; - if (proto == SOCK_DGRAM) nc->flags |= MG_F_UDP; - -#if MG_ENABLE_SSL - DBG(("%p %s %s,%s,%s", nc, address, (opts.ssl_cert ? opts.ssl_cert : "-"), - (opts.ssl_key ? opts.ssl_key : "-"), - (opts.ssl_ca_cert ? opts.ssl_ca_cert : "-"))); - - if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL) { - const char *err_msg = NULL; - struct mg_ssl_if_conn_params params; - if (nc->flags & MG_F_UDP) { - MG_SET_PTRPTR(opts.error_string, "SSL for UDP is not supported"); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; - } - memset(¶ms, 0, sizeof(params)); - params.cert = opts.ssl_cert; - params.key = opts.ssl_key; - params.ca_cert = opts.ssl_ca_cert; - params.cipher_suites = opts.ssl_cipher_suites; - if (mg_ssl_if_conn_init(nc, ¶ms, &err_msg) != MG_SSL_OK) { - MG_SET_PTRPTR(opts.error_string, err_msg); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; - } - nc->flags |= MG_F_SSL; - } -#endif /* MG_ENABLE_SSL */ - - if (nc->flags & MG_F_UDP) { - rc = nc->iface->vtable->listen_udp(nc, &nc->sa); - } else { - rc = nc->iface->vtable->listen_tcp(nc, &nc->sa); - } - if (rc != 0) { - DBG(("Failed to open listener: %d", rc)); - MG_SET_PTRPTR(opts.error_string, "failed to open listener"); - mg_destroy_conn(nc, 1 /* destroy_if */); - return NULL; - } - mg_add_conn(nc->mgr, nc); - - return nc; -} - -struct mg_connection *mg_next(struct mg_mgr *s, struct mg_connection *conn) { - return conn == NULL ? s->active_connections : conn->next; -} - -#if MG_ENABLE_BROADCAST -void mg_broadcast(struct mg_mgr *mgr, mg_event_handler_t cb, void *data, - size_t len) { - struct ctl_msg ctl_msg; - - /* - * Mongoose manager has a socketpair, `struct mg_mgr::ctl`, - * where `mg_broadcast()` pushes the message. - * `mg_mgr_poll()` wakes up, reads a message from the socket pair, and calls - * specified callback for each connection. Thus the callback function executes - * in event manager thread. - */ - if (mgr->ctl[0] != INVALID_SOCKET && data != NULL && - len < sizeof(ctl_msg.message)) { - size_t dummy; - - ctl_msg.callback = cb; - memcpy(ctl_msg.message, data, len); - dummy = MG_SEND_FUNC(mgr->ctl[0], (char *) &ctl_msg, - offsetof(struct ctl_msg, message) + len, 0); - dummy = MG_RECV_FUNC(mgr->ctl[0], (char *) &len, 1, 0); - (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */ - } -} -#endif /* MG_ENABLE_BROADCAST */ - -static int isbyte(int n) { - return n >= 0 && n <= 255; -} - -static int parse_net(const char *spec, uint32_t *net, uint32_t *mask) { - int n, a, b, c, d, slash = 32, len = 0; - - if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 || - sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) && - isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) && slash >= 0 && - slash < 33) { - len = n; - *net = - ((uint32_t) a << 24) | ((uint32_t) b << 16) | ((uint32_t) c << 8) | d; - *mask = slash ? 0xffffffffU << (32 - slash) : 0; - } - - return len; -} - -int mg_check_ip_acl(const char *acl, uint32_t remote_ip) { - int allowed, flag; - uint32_t net, mask; - struct mg_str vec; - - /* If any ACL is set, deny by default */ - allowed = (acl == NULL || *acl == '\0') ? '+' : '-'; - - while ((acl = mg_next_comma_list_entry(acl, &vec, NULL)) != NULL) { - flag = vec.p[0]; - if ((flag != '+' && flag != '-') || - parse_net(&vec.p[1], &net, &mask) == 0) { - return -1; - } - - if (net == (remote_ip & mask)) { - allowed = flag; - } - } - - DBG(("%08x %c", remote_ip, allowed)); - return allowed == '+'; -} - -/* Move data from one connection to another */ -void mg_forward(struct mg_connection *from, struct mg_connection *to) { - mg_send(to, from->recv_mbuf.buf, from->recv_mbuf.len); - mbuf_remove(&from->recv_mbuf, from->recv_mbuf.len); -} - -double mg_set_timer(struct mg_connection *c, double timestamp) { - double result = c->ev_timer_time; - c->ev_timer_time = timestamp; - /* - * If this connection is resolving, it's not in the list of active - * connections, so not processed yet. It has a DNS resolver connection - * linked to it. Set up a timer for the DNS connection. - */ - DBG(("%p %p %d -> %lu", c, c->priv_2, c->flags & MG_F_RESOLVING, - (unsigned long) timestamp)); - if ((c->flags & MG_F_RESOLVING) && c->priv_2 != NULL) { - ((struct mg_connection *) c->priv_2)->ev_timer_time = timestamp; - } - return result; -} - -void mg_sock_set(struct mg_connection *nc, sock_t sock) { - if (sock != INVALID_SOCKET) { - nc->iface->vtable->sock_set(nc, sock); - } -} - -void mg_if_get_conn_addr(struct mg_connection *nc, int remote, - union socket_address *sa) { - nc->iface->vtable->get_conn_addr(nc, remote, sa); -} - -struct mg_connection *mg_add_sock_opt(struct mg_mgr *s, sock_t sock, - mg_event_handler_t callback, - struct mg_add_sock_opts opts) { - struct mg_connection *nc = mg_create_connection_base(s, callback, opts); - if (nc != NULL) { - mg_sock_set(nc, sock); - mg_add_conn(nc->mgr, nc); - } - return nc; -} - -struct mg_connection *mg_add_sock(struct mg_mgr *s, sock_t sock, - mg_event_handler_t callback) { - struct mg_add_sock_opts opts; - memset(&opts, 0, sizeof(opts)); - return mg_add_sock_opt(s, sock, callback, opts); -} - -double mg_time(void) { - return cs_time(); -} -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net_if_socket.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_NET_IF_SOCKET_H_ -#define CS_MONGOOSE_SRC_NET_IF_SOCKET_H_ - -/* Amalgamated: #include "mongoose/src/net_if.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#ifndef MG_ENABLE_NET_IF_SOCKET -#define MG_ENABLE_NET_IF_SOCKET MG_NET_IF == MG_NET_IF_SOCKET -#endif - -extern struct mg_iface_vtable mg_socket_iface_vtable; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_MONGOOSE_SRC_NET_IF_SOCKET_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net_if_tun.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_NET_IF_TUN_H_ -#define CS_MONGOOSE_SRC_NET_IF_TUN_H_ - -#if MG_ENABLE_TUN - -/* Amalgamated: #include "mongoose/src/net_if.h" */ - -struct mg_tun_client; - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -extern struct mg_iface_vtable mg_tun_iface_vtable; - -struct mg_connection *mg_tun_if_find_conn(struct mg_tun_client *client, - uint32_t stream_id); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_TUN */ - -#endif /* CS_MONGOOSE_SRC_NET_IF_TUN_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net_if.c" -#endif -/* Amalgamated: #include "mongoose/src/net_if.h" */ -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/net_if_socket.h" */ -/* Amalgamated: #include "mongoose/src/net_if_tun.h" */ - -extern struct mg_iface_vtable mg_default_iface_vtable; - -#if MG_ENABLE_TUN -struct mg_iface_vtable *mg_ifaces[] = {&mg_default_iface_vtable, - &mg_tun_iface_vtable}; -#else -struct mg_iface_vtable *mg_ifaces[] = {&mg_default_iface_vtable}; -#endif - -int mg_num_ifaces = (int) (sizeof(mg_ifaces) / sizeof(mg_ifaces[0])); - -struct mg_iface *mg_if_create_iface(struct mg_iface_vtable *vtable, - struct mg_mgr *mgr) { - struct mg_iface *iface = (struct mg_iface *) MG_CALLOC(1, sizeof(*iface)); - iface->mgr = mgr; - iface->data = NULL; - iface->vtable = vtable; - return iface; -} - -struct mg_iface *mg_find_iface(struct mg_mgr *mgr, - struct mg_iface_vtable *vtable, - struct mg_iface *from) { - int i = 0; - if (from != NULL) { - for (i = 0; i < mgr->num_ifaces; i++) { - if (mgr->ifaces[i] == from) { - i++; - break; - } - } - } - - for (; i < mgr->num_ifaces; i++) { - if (mgr->ifaces[i]->vtable == vtable) { - return mgr->ifaces[i]; - } - } - return NULL; -} -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net_if_socket.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_NET_IF_SOCKET - -/* Amalgamated: #include "mongoose/src/net_if_socket.h" */ -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ - -#define MG_TCP_RECV_BUFFER_SIZE 1024 -#define MG_UDP_RECV_BUFFER_SIZE 1500 - -static sock_t mg_open_listening_socket(union socket_address *sa, int type, - int proto); -#if MG_ENABLE_SSL -static void mg_ssl_begin(struct mg_connection *nc); -#endif - -void mg_set_non_blocking_mode(sock_t sock) { -#ifdef _WIN32 - unsigned long on = 1; - ioctlsocket(sock, FIONBIO, &on); -#else - int flags = fcntl(sock, F_GETFL, 0); - fcntl(sock, F_SETFL, flags | O_NONBLOCK); -#endif -} - -static int mg_is_error(int n) { - int err = mg_get_errno(); - return (n < 0 && err != EINPROGRESS && err != EWOULDBLOCK -#ifndef WINCE - && err != EAGAIN && err != EINTR -#endif -#ifdef _WIN32 - && WSAGetLastError() != WSAEINTR && - WSAGetLastError() != WSAEWOULDBLOCK -#endif - ); -} - -void mg_socket_if_connect_tcp(struct mg_connection *nc, - const union socket_address *sa) { - int rc, proto = 0; - nc->sock = socket(AF_INET, SOCK_STREAM, proto); - if (nc->sock == INVALID_SOCKET) { - nc->err = mg_get_errno() ? mg_get_errno() : 1; - return; - } -#if !defined(MG_ESP8266) - mg_set_non_blocking_mode(nc->sock); -#endif - rc = connect(nc->sock, &sa->sa, sizeof(sa->sin)); - nc->err = mg_is_error(rc) ? mg_get_errno() : 0; - DBG(("%p sock %d rc %d errno %d err %d", nc, nc->sock, rc, mg_get_errno(), - nc->err)); -} - -void mg_socket_if_connect_udp(struct mg_connection *nc) { - nc->sock = socket(AF_INET, SOCK_DGRAM, 0); - if (nc->sock == INVALID_SOCKET) { - nc->err = mg_get_errno() ? mg_get_errno() : 1; - return; - } - if (nc->flags & MG_F_ENABLE_BROADCAST) { - int optval = 1; - setsockopt(nc->sock, SOL_SOCKET, SO_BROADCAST, (const char *) &optval, - sizeof(optval)); - } - nc->err = 0; -} - -int mg_socket_if_listen_tcp(struct mg_connection *nc, - union socket_address *sa) { - int proto = 0; - sock_t sock = mg_open_listening_socket(sa, SOCK_STREAM, proto); - if (sock == INVALID_SOCKET) { - return (mg_get_errno() ? mg_get_errno() : 1); - } - mg_sock_set(nc, sock); - return 0; -} - -int mg_socket_if_listen_udp(struct mg_connection *nc, - union socket_address *sa) { - sock_t sock = mg_open_listening_socket(sa, SOCK_DGRAM, 0); - if (sock == INVALID_SOCKET) return (mg_get_errno() ? mg_get_errno() : 1); - mg_sock_set(nc, sock); - return 0; -} - -void mg_socket_if_tcp_send(struct mg_connection *nc, const void *buf, - size_t len) { - mbuf_append(&nc->send_mbuf, buf, len); -} - -void mg_socket_if_udp_send(struct mg_connection *nc, const void *buf, - size_t len) { - mbuf_append(&nc->send_mbuf, buf, len); -} - -void mg_socket_if_recved(struct mg_connection *nc, size_t len) { - (void) nc; - (void) len; -} - -int mg_socket_if_create_conn(struct mg_connection *nc) { - (void) nc; - return 1; -} - -void mg_socket_if_destroy_conn(struct mg_connection *nc) { - if (nc->sock == INVALID_SOCKET) return; - if (!(nc->flags & MG_F_UDP)) { - closesocket(nc->sock); - } else { - /* Only close outgoing UDP sockets or listeners. */ - if (nc->listener == NULL) closesocket(nc->sock); - } - nc->sock = INVALID_SOCKET; -} - -static int mg_accept_conn(struct mg_connection *lc) { - struct mg_connection *nc; - union socket_address sa; - socklen_t sa_len = sizeof(sa); - /* NOTE(lsm): on Windows, sock is always > FD_SETSIZE */ - sock_t sock = accept(lc->sock, &sa.sa, &sa_len); - if (sock == INVALID_SOCKET) { - if (mg_is_error(-1)) DBG(("%p: failed to accept: %d", lc, mg_get_errno())); - mg_invalid_socket = 1; //kris - return 0; - } - nc = mg_if_accept_new_conn(lc); - if (nc == NULL) { - closesocket(sock); - return 0; - } - DBG(("%p conn from %s:%d", nc, inet_ntoa(sa.sin.sin_addr), - ntohs(sa.sin.sin_port))); - mg_sock_set(nc, sock); -#if MG_ENABLE_SSL - if (lc->flags & MG_F_SSL) { - if (mg_ssl_if_conn_accept(nc, lc) != MG_SSL_OK) mg_close_conn(nc); - } else -#endif - { - mg_if_accept_tcp_cb(nc, &sa, sa_len); - } - return 1; -} - -/* 'sa' must be an initialized address to bind to */ -static sock_t mg_open_listening_socket(union socket_address *sa, int type, - int proto) { - socklen_t sa_len = - (sa->sa.sa_family == AF_INET) ? sizeof(sa->sin) : sizeof(sa->sin6); - sock_t sock = INVALID_SOCKET; -#if !MG_LWIP - int on = 1; -#endif - - if ((sock = socket(sa->sa.sa_family, type, proto)) != INVALID_SOCKET && -#if !MG_LWIP /* LWIP doesn't support either */ -#if defined(_WIN32) && defined(SO_EXCLUSIVEADDRUSE) && !defined(WINCE) - /* "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE" http://goo.gl/RmrFTm */ - !setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (void *) &on, - sizeof(on)) && -#endif - -#if !defined(_WIN32) || !defined(SO_EXCLUSIVEADDRUSE) - /* - * SO_RESUSEADDR is not enabled on Windows because the semantics of - * SO_REUSEADDR on UNIX and Windows is different. On Windows, - * SO_REUSEADDR allows to bind a socket to a port without error even if - * the port is already open by another program. This is not the behavior - * SO_REUSEADDR was designed for, and leads to hard-to-track failure - * scenarios. Therefore, SO_REUSEADDR was disabled on Windows unless - * SO_EXCLUSIVEADDRUSE is supported and set on a socket. - */ - !setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *) &on, sizeof(on)) && -#endif -#endif /* !MG_LWIP */ - - !bind(sock, &sa->sa, sa_len) && - (type == SOCK_DGRAM || listen(sock, SOMAXCONN) == 0)) { -#if !MG_LWIP - mg_set_non_blocking_mode(sock); - /* In case port was set to 0, get the real port number */ - (void) getsockname(sock, &sa->sa, &sa_len); -#endif - } else if (sock != INVALID_SOCKET) { - closesocket(sock); - sock = INVALID_SOCKET; - } - - return sock; -} - -static void mg_write_to_socket(struct mg_connection *nc) { - struct mbuf *io = &nc->send_mbuf; - int n = 0; - -#if MG_LWIP - /* With LWIP we don't know if the socket is ready */ - if (io->len == 0) return; -#endif - - assert(io->len > 0); - - if (nc->flags & MG_F_UDP) { - int n = - sendto(nc->sock, io->buf, io->len, 0, &nc->sa.sa, sizeof(nc->sa.sin)); - DBG(("%p %d %d %d %s:%hu", nc, nc->sock, n, mg_get_errno(), - inet_ntoa(nc->sa.sin.sin_addr), ntohs(nc->sa.sin.sin_port))); - if (n > 0) { - mbuf_remove(io, n); - mg_if_sent_cb(nc, n); - } - return; - } - -#if MG_ENABLE_SSL - if (nc->flags & MG_F_SSL) { - if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) { - n = mg_ssl_if_write(nc, io->buf, io->len); - DBG(("%p %d bytes -> %d (SSL)", nc, n, nc->sock)); - if (n < 0) { - if (n != MG_SSL_WANT_READ && n != MG_SSL_WANT_WRITE) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } - return; - } else { - /* Successful SSL operation, clear off SSL wait flags */ - nc->flags &= ~(MG_F_WANT_READ | MG_F_WANT_WRITE); - } - } else { - mg_ssl_begin(nc); - return; - } - } else -#endif - { - n = (int) MG_SEND_FUNC(nc->sock, io->buf, io->len, 0); - DBG(("%p %d bytes -> %d", nc, n, nc->sock)); - if (n < 0 && mg_is_error(n)) { - /* Something went wrong, drop the connection. */ - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - return; - } - } - - if (n > 0) { - mbuf_remove(io, n); - mg_if_sent_cb(nc, n); - } -} - -MG_INTERNAL size_t recv_avail_size(struct mg_connection *conn, size_t max) { - size_t avail; - if (conn->recv_mbuf_limit < conn->recv_mbuf.len) return 0; - avail = conn->recv_mbuf_limit - conn->recv_mbuf.len; - return avail > max ? max : avail; -} - -static void mg_handle_tcp_read(struct mg_connection *conn) { - int n = 0; - char *buf = (char *) MG_MALLOC(MG_TCP_RECV_BUFFER_SIZE); - - if (buf == NULL) { - DBG(("OOM")); - return; - } - -#if MG_ENABLE_SSL - if (conn->flags & MG_F_SSL) { - if (conn->flags & MG_F_SSL_HANDSHAKE_DONE) { - /* SSL library may have more bytes ready to read than we ask to read. - * Therefore, read in a loop until we read everything. Without the loop, - * we skip to the next select() cycle which can just timeout. */ - while ((n = mg_ssl_if_read(conn, buf, MG_TCP_RECV_BUFFER_SIZE)) > 0) { - DBG(("%p %d bytes <- %d (SSL)", conn, n, conn->sock)); - mg_if_recv_tcp_cb(conn, buf, n, 1 /* own */); - buf = NULL; - if (conn->flags & MG_F_CLOSE_IMMEDIATELY) break; - /* buf has been freed, we need a new one. */ - buf = (char *) MG_MALLOC(MG_TCP_RECV_BUFFER_SIZE); - if (buf == NULL) break; - } - MG_FREE(buf); - if (n < 0 && n != MG_SSL_WANT_READ) conn->flags |= MG_F_CLOSE_IMMEDIATELY; - } else { - MG_FREE(buf); - mg_ssl_begin(conn); - return; - } - } else -#endif - { - n = (int) MG_RECV_FUNC(conn->sock, buf, - recv_avail_size(conn, MG_TCP_RECV_BUFFER_SIZE), 0); - DBG(("%p %d bytes (PLAIN) <- %d", conn, n, conn->sock)); - if (n > 0) { - mg_if_recv_tcp_cb(conn, buf, n, 1 /* own */); - } else { - MG_FREE(buf); - } - if (n == 0) { - /* Orderly shutdown of the socket, try flushing output. */ - conn->flags |= MG_F_SEND_AND_CLOSE; - } else if (mg_is_error(n)) { - conn->flags |= MG_F_CLOSE_IMMEDIATELY; - } - } -} - -static int mg_recvfrom(struct mg_connection *nc, union socket_address *sa, - socklen_t *sa_len, char **buf) { - int n; - *buf = (char *) MG_MALLOC(MG_UDP_RECV_BUFFER_SIZE); - if (*buf == NULL) { - DBG(("Out of memory")); - return -ENOMEM; - } - n = recvfrom(nc->sock, *buf, MG_UDP_RECV_BUFFER_SIZE, 0, &sa->sa, sa_len); - if (n <= 0) { - DBG(("%p recvfrom: %s", nc, strerror(mg_get_errno()))); - MG_FREE(*buf); - } - return n; -} - -static void mg_handle_udp_read(struct mg_connection *nc) { - char *buf = NULL; - union socket_address sa; - socklen_t sa_len = sizeof(sa); - int n = mg_recvfrom(nc, &sa, &sa_len, &buf); - DBG(("%p %d bytes from %s:%d", nc, n, inet_ntoa(nc->sa.sin.sin_addr), - ntohs(nc->sa.sin.sin_port))); - mg_if_recv_udp_cb(nc, buf, n, &sa, sa_len); -} - -#if MG_ENABLE_SSL -static void mg_ssl_begin(struct mg_connection *nc) { - int server_side = (nc->listener != NULL); - enum mg_ssl_if_result res = mg_ssl_if_handshake(nc); - DBG(("%p %d res %d", nc, server_side, res)); - - if (res == MG_SSL_OK) { - nc->flags |= MG_F_SSL_HANDSHAKE_DONE; - nc->flags &= ~(MG_F_WANT_READ | MG_F_WANT_WRITE); - - if (server_side) { - union socket_address sa; - socklen_t sa_len = sizeof(sa); - (void) getpeername(nc->sock, &sa.sa, &sa_len); - mg_if_accept_tcp_cb(nc, &sa, sa_len); - } else { - mg_if_connect_cb(nc, 0); - } - } else if (res != MG_SSL_WANT_READ && res != MG_SSL_WANT_WRITE) { - if (!server_side) { - mg_if_connect_cb(nc, res); - } - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } -} -#endif /* MG_ENABLE_SSL */ - -#define _MG_F_FD_CAN_READ 1 -#define _MG_F_FD_CAN_WRITE 1 << 1 -#define _MG_F_FD_ERROR 1 << 2 - -void mg_mgr_handle_conn(struct mg_connection *nc, int fd_flags, double now) { - int worth_logging = - fd_flags != 0 || (nc->flags & (MG_F_WANT_READ | MG_F_WANT_WRITE)); - if (worth_logging) { - DBG(("%p fd=%d fd_flags=%d nc_flags=%lu rmbl=%d smbl=%d", nc, nc->sock, - fd_flags, nc->flags, (int) nc->recv_mbuf.len, - (int) nc->send_mbuf.len)); - } - - if (nc->flags & MG_F_CONNECTING) { - if (fd_flags != 0) { - int err = 0; -#if !defined(MG_ESP8266) - if (!(nc->flags & MG_F_UDP)) { - socklen_t len = sizeof(err); - int ret = - getsockopt(nc->sock, SOL_SOCKET, SO_ERROR, (char *) &err, &len); - if (ret != 0) { - err = 1; - } else if (err == EAGAIN || err == EWOULDBLOCK) { - err = 0; - } - } -#else - /* - * On ESP8266 we use blocking connect. - */ - err = nc->err; -#endif -#if MG_ENABLE_SSL - if ((nc->flags & MG_F_SSL) && err == 0) { - mg_ssl_begin(nc); - } else { - mg_if_connect_cb(nc, err); - } -#else - mg_if_connect_cb(nc, err); -#endif - } else if (nc->err != 0) { - mg_if_connect_cb(nc, nc->err); - } - } - - if (fd_flags & _MG_F_FD_CAN_READ) { - if (nc->flags & MG_F_UDP) { - mg_handle_udp_read(nc); - } else { - if (nc->flags & MG_F_LISTENING) { - /* - * We're not looping here, and accepting just one connection at - * a time. The reason is that eCos does not respect non-blocking - * flag on a listening socket and hangs in a loop. - */ - mg_accept_conn(nc); - } else { - mg_handle_tcp_read(nc); - } - } - } - - if (!(nc->flags & MG_F_CLOSE_IMMEDIATELY)) { - if ((fd_flags & _MG_F_FD_CAN_WRITE) && nc->send_mbuf.len > 0) { - mg_write_to_socket(nc); - } - mg_if_poll(nc, (time_t) now); - mg_if_timer(nc, now); - } - - if (worth_logging) { - DBG(("%p after fd=%d nc_flags=%lu rmbl=%d smbl=%d", nc, nc->sock, nc->flags, - (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len)); - } -} - -#if MG_ENABLE_BROADCAST -static void mg_mgr_handle_ctl_sock(struct mg_mgr *mgr) { - struct ctl_msg ctl_msg; - int len = - (int) MG_RECV_FUNC(mgr->ctl[1], (char *) &ctl_msg, sizeof(ctl_msg), 0); - size_t dummy = MG_SEND_FUNC(mgr->ctl[1], ctl_msg.message, 1, 0); - DBG(("read %d from ctl socket", len)); - (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */ - if (len >= (int) sizeof(ctl_msg.callback) && ctl_msg.callback != NULL) { - struct mg_connection *nc; - for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) { - ctl_msg.callback(nc, MG_EV_POLL, ctl_msg.message); - } - } -} -#endif - -/* Associate a socket to a connection. */ -void mg_socket_if_sock_set(struct mg_connection *nc, sock_t sock) { - mg_set_non_blocking_mode(sock); - mg_set_close_on_exec(sock); - nc->sock = sock; - DBG(("%p %d", nc, sock)); -} - -void mg_socket_if_init(struct mg_iface *iface) { - (void) iface; - DBG(("%p using select()", iface->mgr)); -#if MG_ENABLE_BROADCAST - do { - mg_socketpair(iface->mgr->ctl, SOCK_DGRAM); - } while (iface->mgr->ctl[0] == INVALID_SOCKET); -#endif -} - -void mg_socket_if_free(struct mg_iface *iface) { - (void) iface; -} - -void mg_socket_if_add_conn(struct mg_connection *nc) { - (void) nc; -} - -void mg_socket_if_remove_conn(struct mg_connection *nc) { - (void) nc; -} - -void mg_add_to_set(sock_t sock, fd_set *set, sock_t *max_fd) { - if (sock != INVALID_SOCKET -#ifdef __unix__ - && sock < FD_SETSIZE -#endif - ) { - FD_SET(sock, set); - if (*max_fd == INVALID_SOCKET || sock > *max_fd) { - *max_fd = sock; - } - } -} - -time_t mg_socket_if_poll(struct mg_iface *iface, int timeout_ms) { - struct mg_mgr *mgr = iface->mgr; - double now = mg_time(); - double min_timer; - struct mg_connection *nc, *tmp; - struct timeval tv; - fd_set read_set, write_set, err_set; - sock_t max_fd = INVALID_SOCKET; - int num_fds, num_ev, num_timers = 0; -#ifdef __unix__ - int try_dup = 1; -#endif - - FD_ZERO(&read_set); - FD_ZERO(&write_set); - FD_ZERO(&err_set); -#if MG_ENABLE_BROADCAST - mg_add_to_set(mgr->ctl[1], &read_set, &max_fd); -#endif - - /* - * Note: it is ok to have connections with sock == INVALID_SOCKET in the list, - * e.g. timer-only "connections". - */ - min_timer = 0; - for (nc = mgr->active_connections, num_fds = 0; nc != NULL; nc = tmp) { - tmp = nc->next; - - if (nc->sock != INVALID_SOCKET) { - num_fds++; - -#ifdef __unix__ - /* A hack to make sure all our file descriptos fit into FD_SETSIZE. */ - if (nc->sock >= FD_SETSIZE && try_dup) { - int new_sock = dup(nc->sock); - if (new_sock >= 0 && new_sock < FD_SETSIZE) { - closesocket(nc->sock); - DBG(("new sock %d -> %d", nc->sock, new_sock)); - nc->sock = new_sock; - } else { - try_dup = 0; - } - } -#endif - - if (!(nc->flags & MG_F_WANT_WRITE) && - nc->recv_mbuf.len < nc->recv_mbuf_limit && - (!(nc->flags & MG_F_UDP) || nc->listener == NULL)) { - mg_add_to_set(nc->sock, &read_set, &max_fd); - } - - if (((nc->flags & MG_F_CONNECTING) && !(nc->flags & MG_F_WANT_READ)) || - (nc->send_mbuf.len > 0 && !(nc->flags & MG_F_CONNECTING))) { - mg_add_to_set(nc->sock, &write_set, &max_fd); - mg_add_to_set(nc->sock, &err_set, &max_fd); - } - } - - if (nc->ev_timer_time > 0) { - if (num_timers == 0 || nc->ev_timer_time < min_timer) { - min_timer = nc->ev_timer_time; - } - num_timers++; - } - } - - /* - * If there is a timer to be fired earlier than the requested timeout, - * adjust the timeout. - */ - if (num_timers > 0) { - double timer_timeout_ms = (min_timer - mg_time()) * 1000 + 1 /* rounding */; - if (timer_timeout_ms < timeout_ms) { - timeout_ms = (int) timer_timeout_ms; - } - } - if (timeout_ms < 0) timeout_ms = 0; - - tv.tv_sec = timeout_ms / 1000; - tv.tv_usec = (timeout_ms % 1000) * 1000; - - num_ev = select((int) max_fd + 1, &read_set, &write_set, &err_set, &tv); - now = mg_time(); -#if 0 - DBG(("select @ %ld num_ev=%d of %d, timeout=%d", (long) now, num_ev, num_fds, - timeout_ms)); -#endif - -#if MG_ENABLE_BROADCAST - if (num_ev > 0 && mgr->ctl[1] != INVALID_SOCKET && - FD_ISSET(mgr->ctl[1], &read_set)) { - mg_mgr_handle_ctl_sock(mgr); - } -#endif - - for (nc = mgr->active_connections; nc != NULL; nc = tmp) { - int fd_flags = 0; - if (nc->sock != INVALID_SOCKET) { - if (num_ev > 0) { - fd_flags = (FD_ISSET(nc->sock, &read_set) && - (!(nc->flags & MG_F_UDP) || nc->listener == NULL) - ? _MG_F_FD_CAN_READ - : 0) | - (FD_ISSET(nc->sock, &write_set) ? _MG_F_FD_CAN_WRITE : 0) | - (FD_ISSET(nc->sock, &err_set) ? _MG_F_FD_ERROR : 0); - } -#if MG_LWIP - /* With LWIP socket emulation layer, we don't get write events for UDP */ - if ((nc->flags & MG_F_UDP) && nc->listener == NULL) { - fd_flags |= _MG_F_FD_CAN_WRITE; - } -#endif - } - tmp = nc->next; - mg_mgr_handle_conn(nc, fd_flags, now); - } - - for (nc = mgr->active_connections; nc != NULL; nc = tmp) { - tmp = nc->next; - if ((nc->flags & MG_F_CLOSE_IMMEDIATELY) || - (nc->send_mbuf.len == 0 && (nc->flags & MG_F_SEND_AND_CLOSE))) { - mg_close_conn(nc); - } - } - - return (time_t) now; -} - -#if MG_ENABLE_BROADCAST -int mg_socketpair(sock_t sp[2], int sock_type) { - union socket_address sa; - sock_t sock; - socklen_t len = sizeof(sa.sin); - int ret = 0; - - sock = sp[0] = sp[1] = INVALID_SOCKET; - - (void) memset(&sa, 0, sizeof(sa)); - sa.sin.sin_family = AF_INET; - sa.sin.sin_port = htons(0); - sa.sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */ - - if ((sock = socket(AF_INET, sock_type, 0)) == INVALID_SOCKET) { - } else if (bind(sock, &sa.sa, len) != 0) { - } else if (sock_type == SOCK_STREAM && listen(sock, 1) != 0) { - } else if (getsockname(sock, &sa.sa, &len) != 0) { - } else if ((sp[0] = socket(AF_INET, sock_type, 0)) == INVALID_SOCKET) { - } else if (connect(sp[0], &sa.sa, len) != 0) { - } else if (sock_type == SOCK_DGRAM && - (getsockname(sp[0], &sa.sa, &len) != 0 || - connect(sock, &sa.sa, len) != 0)) { - } else if ((sp[1] = (sock_type == SOCK_DGRAM ? sock - : accept(sock, &sa.sa, &len))) == - INVALID_SOCKET) { - } else { - mg_set_close_on_exec(sp[0]); - mg_set_close_on_exec(sp[1]); - if (sock_type == SOCK_STREAM) closesocket(sock); - ret = 1; - } - - if (!ret) { - if (sp[0] != INVALID_SOCKET) closesocket(sp[0]); - if (sp[1] != INVALID_SOCKET) closesocket(sp[1]); - if (sock != INVALID_SOCKET) closesocket(sock); - sock = sp[0] = sp[1] = INVALID_SOCKET; - } - - return ret; -} -#endif /* MG_ENABLE_BROADCAST */ - -static void mg_sock_get_addr(sock_t sock, int remote, - union socket_address *sa) { - socklen_t slen = sizeof(*sa); - memset(sa, 0, slen); - if (remote) { - getpeername(sock, &sa->sa, &slen); - } else { - getsockname(sock, &sa->sa, &slen); - } -} - -void mg_sock_to_str(sock_t sock, char *buf, size_t len, int flags) { - union socket_address sa; - mg_sock_get_addr(sock, flags & MG_SOCK_STRINGIFY_REMOTE, &sa); - mg_sock_addr_to_str(&sa, buf, len, flags); -} - -void mg_socket_if_get_conn_addr(struct mg_connection *nc, int remote, - union socket_address *sa) { - mg_sock_get_addr(nc->sock, remote, sa); -} - -/* clang-format off */ -#define MG_SOCKET_IFACE_VTABLE \ - { \ - mg_socket_if_init, \ - mg_socket_if_free, \ - mg_socket_if_add_conn, \ - mg_socket_if_remove_conn, \ - mg_socket_if_poll, \ - mg_socket_if_listen_tcp, \ - mg_socket_if_listen_udp, \ - mg_socket_if_connect_tcp, \ - mg_socket_if_connect_udp, \ - mg_socket_if_tcp_send, \ - mg_socket_if_udp_send, \ - mg_socket_if_recved, \ - mg_socket_if_create_conn, \ - mg_socket_if_destroy_conn, \ - mg_socket_if_sock_set, \ - mg_socket_if_get_conn_addr, \ - } -/* clang-format on */ - -struct mg_iface_vtable mg_socket_iface_vtable = MG_SOCKET_IFACE_VTABLE; -#if MG_NET_IF == MG_NET_IF_SOCKET -struct mg_iface_vtable mg_default_iface_vtable = MG_SOCKET_IFACE_VTABLE; -#endif - -#endif /* MG_ENABLE_NET_IF_SOCKET */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net_if_tun.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_TUN - -/* Amalgamated: #include "common/cs_dbg.h" */ -/* Amalgamated: #include "common/cs_time.h" */ -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/net_if_tun.h" */ -/* Amalgamated: #include "mongoose/src/tun.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ - -#define MG_TCP_RECV_BUFFER_SIZE 1024 -#define MG_UDP_RECV_BUFFER_SIZE 1500 - -void mg_tun_if_connect_tcp(struct mg_connection *nc, - const union socket_address *sa) { - (void) nc; - (void) sa; -} - -void mg_tun_if_connect_udp(struct mg_connection *nc) { - (void) nc; -} - -int mg_tun_if_listen_tcp(struct mg_connection *nc, union socket_address *sa) { - (void) nc; - (void) sa; - return 0; -} - -int mg_tun_if_listen_udp(struct mg_connection *nc, union socket_address *sa) { - (void) nc; - (void) sa; - return -1; -} - -void mg_tun_if_tcp_send(struct mg_connection *nc, const void *buf, size_t len) { - struct mg_tun_client *client = (struct mg_tun_client *) nc->iface->data; - uint32_t stream_id = (uint32_t)(uintptr_t) nc->mgr_data; - struct mg_str msg = {(char *) buf, len}; -#if MG_ENABLE_HEXDUMP - char hex[512]; - mg_hexdump(buf, len, hex, sizeof(hex)); - LOG(LL_DEBUG, ("sending to stream %zu:\n%s", stream_id, hex)); -#endif - - mg_tun_send_frame(client->disp, stream_id, MG_TUN_DATA_FRAME, 0, msg); -} - -void mg_tun_if_udp_send(struct mg_connection *nc, const void *buf, size_t len) { - (void) nc; - (void) buf; - (void) len; -} - -void mg_tun_if_recved(struct mg_connection *nc, size_t len) { - (void) nc; - (void) len; -} - -int mg_tun_if_create_conn(struct mg_connection *nc) { - (void) nc; - return 1; -} - -void mg_tun_if_destroy_conn(struct mg_connection *nc) { - struct mg_tun_client *client = (struct mg_tun_client *) nc->iface->data; - - if (nc->flags & MG_F_LISTENING) { - mg_tun_destroy_client(client); - } else if (client->disp) { - uint32_t stream_id = (uint32_t)(uintptr_t) nc->mgr_data; - struct mg_str msg = {NULL, 0}; - - LOG(LL_DEBUG, ("closing %zu:", stream_id)); - mg_tun_send_frame(client->disp, stream_id, MG_TUN_DATA_FRAME, - MG_TUN_F_END_STREAM, msg); - } -} - -/* Associate a socket to a connection. */ -void mg_tun_if_sock_set(struct mg_connection *nc, sock_t sock) { - (void) nc; - (void) sock; -} - -void mg_tun_if_init(struct mg_iface *iface) { - (void) iface; -} - -void mg_tun_if_free(struct mg_iface *iface) { - (void) iface; -} - -void mg_tun_if_add_conn(struct mg_connection *nc) { - nc->sock = INVALID_SOCKET; -} - -void mg_tun_if_remove_conn(struct mg_connection *nc) { - (void) nc; -} - -time_t mg_tun_if_poll(struct mg_iface *iface, int timeout_ms) { - (void) iface; - (void) timeout_ms; - return (time_t) cs_time(); -} - -void mg_tun_if_get_conn_addr(struct mg_connection *nc, int remote, - union socket_address *sa) { - (void) nc; - (void) remote; - (void) sa; -} - -struct mg_connection *mg_tun_if_find_conn(struct mg_tun_client *client, - uint32_t stream_id) { - struct mg_connection *nc = NULL; - - for (nc = client->mgr->active_connections; nc != NULL; nc = nc->next) { - if (nc->iface != client->iface || (nc->flags & MG_F_LISTENING)) { - continue; - } - if (stream_id == (uint32_t)(uintptr_t) nc->mgr_data) { - return nc; - } - } - - if (stream_id > client->last_stream_id) { - /* create a new connection */ - LOG(LL_DEBUG, ("new stream 0x%lx, accepting", stream_id)); - nc = mg_if_accept_new_conn(client->listener); - nc->mgr_data = (void *) (uintptr_t) stream_id; - client->last_stream_id = stream_id; - } else { - LOG(LL_DEBUG, ("Ignoring stream 0x%lx (last_stream_id 0x%lx)", stream_id, - client->last_stream_id)); - } - - return nc; -} - -/* clang-format off */ -#define MG_TUN_IFACE_VTABLE \ - { \ - mg_tun_if_init, \ - mg_tun_if_free, \ - mg_tun_if_add_conn, \ - mg_tun_if_remove_conn, \ - mg_tun_if_poll, \ - mg_tun_if_listen_tcp, \ - mg_tun_if_listen_udp, \ - mg_tun_if_connect_tcp, \ - mg_tun_if_connect_udp, \ - mg_tun_if_tcp_send, \ - mg_tun_if_udp_send, \ - mg_tun_if_recved, \ - mg_tun_if_create_conn, \ - mg_tun_if_destroy_conn, \ - mg_tun_if_sock_set, \ - mg_tun_if_get_conn_addr, \ - } -/* clang-format on */ - -struct mg_iface_vtable mg_tun_iface_vtable = MG_TUN_IFACE_VTABLE; - -#endif /* MG_ENABLE_TUN */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/ssl_if_openssl.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_OPENSSL - -#ifdef __APPLE__ -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#endif - -#include - -struct mg_ssl_if_ctx { - SSL *ssl; - SSL_CTX *ssl_ctx; -}; - -void mg_ssl_if_init() { - SSL_library_init(); -} - -enum mg_ssl_if_result mg_ssl_if_conn_accept(struct mg_connection *nc, - struct mg_connection *lc) { - struct mg_ssl_if_ctx *ctx = - (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx)); - struct mg_ssl_if_ctx *lc_ctx = (struct mg_ssl_if_ctx *) lc->ssl_if_data; - nc->ssl_if_data = ctx; - if (ctx == NULL || lc_ctx == NULL) return MG_SSL_ERROR; - ctx->ssl_ctx = lc_ctx->ssl_ctx; - if ((ctx->ssl = SSL_new(ctx->ssl_ctx)) == NULL) { - return MG_SSL_ERROR; - } - return MG_SSL_OK; -} - -static enum mg_ssl_if_result mg_use_cert(SSL_CTX *ctx, const char *cert, - const char *key, const char **err_msg); -static enum mg_ssl_if_result mg_use_ca_cert(SSL_CTX *ctx, const char *cert); -static enum mg_ssl_if_result mg_set_cipher_list(SSL_CTX *ctx, const char *cl); - -enum mg_ssl_if_result mg_ssl_if_conn_init( - struct mg_connection *nc, const struct mg_ssl_if_conn_params *params, - const char **err_msg) { - struct mg_ssl_if_ctx *ctx = - (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx)); - DBG(("%p %s,%s,%s", nc, (params->cert ? params->cert : ""), - (params->key ? params->key : ""), - (params->ca_cert ? params->ca_cert : ""))); - if (ctx == NULL) { - MG_SET_PTRPTR(err_msg, "Out of memory"); - return MG_SSL_ERROR; - } - nc->ssl_if_data = ctx; - if (nc->flags & MG_F_LISTENING) { - ctx->ssl_ctx = SSL_CTX_new(SSLv23_server_method()); - } else { - ctx->ssl_ctx = SSL_CTX_new(SSLv23_client_method()); - } - if (ctx->ssl_ctx == NULL) { - MG_SET_PTRPTR(err_msg, "Failed to create SSL context"); - return MG_SSL_ERROR; - } - - if (params->cert != NULL && - mg_use_cert(ctx->ssl_ctx, params->cert, params->key, err_msg) != - MG_SSL_OK) { - return MG_SSL_ERROR; - } - - if (params->ca_cert != NULL && - mg_use_ca_cert(ctx->ssl_ctx, params->ca_cert) != MG_SSL_OK) { - MG_SET_PTRPTR(err_msg, "Invalid SSL CA cert"); - return MG_SSL_ERROR; - } - - if (params->server_name != NULL) { -#ifdef KR_VERSION - SSL_CTX_kr_set_verify_name(ctx->ssl_ctx, params->server_name); -#else -/* TODO(rojer): Implement server name verification on OpenSSL. */ -#endif - } - - if (mg_set_cipher_list(ctx->ssl_ctx, params->cipher_suites) != MG_SSL_OK) { - MG_SET_PTRPTR(err_msg, "Invalid cipher suite list"); - return MG_SSL_ERROR; - } - - if (!(nc->flags & MG_F_LISTENING) && - (ctx->ssl = SSL_new(ctx->ssl_ctx)) == NULL) { - MG_SET_PTRPTR(err_msg, "Failed to create SSL session"); - return MG_SSL_ERROR; - } - - nc->flags |= MG_F_SSL; - - return MG_SSL_OK; -} - -static enum mg_ssl_if_result mg_ssl_if_ssl_err(struct mg_connection *nc, - int res) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - int err = SSL_get_error(ctx->ssl, res); - if (err == SSL_ERROR_WANT_READ) return MG_SSL_WANT_READ; - if (err == SSL_ERROR_WANT_WRITE) return MG_SSL_WANT_WRITE; - DBG(("%p %p SSL error: %d %d", nc, ctx->ssl_ctx, res, err)); - nc->err = err; - return MG_SSL_ERROR; -} - -enum mg_ssl_if_result mg_ssl_if_handshake(struct mg_connection *nc) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - int server_side = (nc->listener != NULL); - int res; - /* If descriptor is not yet set, do it now. */ - if (SSL_get_fd(ctx->ssl) < 0) { - if (SSL_set_fd(ctx->ssl, nc->sock) != 1) return MG_SSL_ERROR; - } - res = server_side ? SSL_accept(ctx->ssl) : SSL_connect(ctx->ssl); - if (res != 1) return mg_ssl_if_ssl_err(nc, res); - return MG_SSL_OK; -} - -int mg_ssl_if_read(struct mg_connection *nc, void *buf, size_t buf_size) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - int n = SSL_read(ctx->ssl, buf, buf_size); - DBG(("%p %d -> %d", nc, (int) buf_size, n)); - if (n < 0) return mg_ssl_if_ssl_err(nc, n); - if (n == 0) nc->flags |= MG_F_CLOSE_IMMEDIATELY; - return n; -} - -int mg_ssl_if_write(struct mg_connection *nc, const void *data, size_t len) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - int n = SSL_write(ctx->ssl, data, len); - DBG(("%p %d -> %d", nc, (int) len, n)); - if (n <= 0) return mg_ssl_if_ssl_err(nc, n); - return n; -} - -void mg_ssl_if_conn_free(struct mg_connection *nc) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - if (ctx == NULL) return; - nc->ssl_if_data = NULL; - if (ctx->ssl != NULL) SSL_free(ctx->ssl); - if (ctx->ssl_ctx != NULL && nc->listener == NULL) SSL_CTX_free(ctx->ssl_ctx); - memset(ctx, 0, sizeof(*ctx)); - MG_FREE(ctx); -} - -/* - * Cipher suite options used for TLS negotiation. - * https://wiki.mozilla.org/Security/Server_Side_TLS#Recommended_configurations - */ -static const char mg_s_cipher_list[] = -#if defined(MG_SSL_CRYPTO_MODERN) - "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:" - "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:" - "DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:" - "ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:" - "ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:" - "ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:" - "DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:" - "DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:" - "!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK" -#elif defined(MG_SSL_CRYPTO_OLD) - "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:" - "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:" - "DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:" - "ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:" - "ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:" - "ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:" - "DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:" - "DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:ECDHE-RSA-DES-CBC3-SHA:" - "ECDHE-ECDSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:" - "AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:DES-CBC3-SHA:" - "HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:" - "!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA" -#else /* Default - intermediate. */ - "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:" - "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:" - "DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:" - "ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:" - "ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:" - "ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:" - "DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:" - "DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:" - "AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:" - "DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:" - "!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA" -#endif - ; - -/* - * Default DH params for PFS cipher negotiation. This is a 2048-bit group. - * Will be used if none are provided by the user in the certificate file. - */ -#if !MG_DISABLE_PFS && !defined(KR_VERSION) -static const char mg_s_default_dh_params[] = - "\ ------BEGIN DH PARAMETERS-----\n\ -MIIBCAKCAQEAlvbgD/qh9znWIlGFcV0zdltD7rq8FeShIqIhkQ0C7hYFThrBvF2E\n\ -Z9bmgaP+sfQwGpVlv9mtaWjvERbu6mEG7JTkgmVUJrUt/wiRzwTaCXBqZkdUO8Tq\n\ -+E6VOEQAilstG90ikN1Tfo+K6+X68XkRUIlgawBTKuvKVwBhuvlqTGerOtnXWnrt\n\ -ym//hd3cd5PBYGBix0i7oR4xdghvfR2WLVu0LgdThTBb6XP7gLd19cQ1JuBtAajZ\n\ -wMuPn7qlUkEFDIkAZy59/Hue/H2Q2vU/JsvVhHWCQBL4F1ofEAt50il6ZxR1QfFK\n\ -9VGKDC4oOgm9DlxwwBoC2FjqmvQlqVV3kwIBAg==\n\ ------END DH PARAMETERS-----\n"; -#endif - -static enum mg_ssl_if_result mg_use_ca_cert(SSL_CTX *ctx, const char *cert) { - if (cert == NULL || strcmp(cert, "*") == 0) { - return MG_SSL_OK; - } - SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0); - return SSL_CTX_load_verify_locations(ctx, cert, NULL) == 1 ? MG_SSL_OK - : MG_SSL_ERROR; -} - -static enum mg_ssl_if_result mg_use_cert(SSL_CTX *ctx, const char *cert, - const char *key, - const char **err_msg) { - if (key == NULL) key = cert; - if (cert == NULL || cert[0] == '\0' || key == NULL || key[0] == '\0') { - return MG_SSL_OK; - } else if (SSL_CTX_use_certificate_file(ctx, cert, 1) == 0) { - MG_SET_PTRPTR(err_msg, "Invalid SSL cert"); - return MG_SSL_ERROR; - } else if (SSL_CTX_use_PrivateKey_file(ctx, key, 1) == 0) { - MG_SET_PTRPTR(err_msg, "Invalid SSL key"); - return MG_SSL_ERROR; - } else if (SSL_CTX_use_certificate_chain_file(ctx, cert) == 0) { - MG_SET_PTRPTR(err_msg, "Invalid CA bundle"); - return MG_SSL_ERROR; - } else { - SSL_CTX_set_mode(ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER); -#if !MG_DISABLE_PFS && !defined(KR_VERSION) - BIO *bio = NULL; - DH *dh = NULL; - - /* Try to read DH parameters from the cert/key file. */ - bio = BIO_new_file(cert, "r"); - if (bio != NULL) { - dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); - BIO_free(bio); - } - /* - * If there are no DH params in the file, fall back to hard-coded ones. - * Not ideal, but better than nothing. - */ - if (dh == NULL) { - bio = BIO_new_mem_buf((void *) mg_s_default_dh_params, -1); - dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); - BIO_free(bio); - } - if (dh != NULL) { - SSL_CTX_set_tmp_dh(ctx, dh); - SSL_CTX_set_options(ctx, SSL_OP_SINGLE_DH_USE); - DH_free(dh); - } -#if OPENSSL_VERSION_NUMBER > 0x10002000L - SSL_CTX_set_ecdh_auto(ctx, 1); -#endif -#endif - } - return MG_SSL_OK; -} - -static enum mg_ssl_if_result mg_set_cipher_list(SSL_CTX *ctx, const char *cl) { - return (SSL_CTX_set_cipher_list(ctx, cl ? cl : mg_s_cipher_list) == 1 - ? MG_SSL_OK - : MG_SSL_ERROR); -} - -const char *mg_set_ssl(struct mg_connection *nc, const char *cert, - const char *ca_cert) { - const char *err_msg = NULL; - struct mg_ssl_if_conn_params params; - memset(¶ms, 0, sizeof(params)); - params.cert = cert; - params.ca_cert = ca_cert; - if (mg_ssl_if_conn_init(nc, ¶ms, &err_msg) != MG_SSL_OK) { - return err_msg; - } - return NULL; -} - -#endif /* MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_OPENSSL */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/ssl_if_mbedtls.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_MBEDTLS - -#include -#include -#include -#include -#include - -static void mg_ssl_mbed_log(void *ctx, int level, const char *file, int line, - const char *str) { - enum cs_log_level cs_level; - switch (level) { - case 1: - cs_level = LL_ERROR; - break; - case 2: - case 3: - cs_level = LL_DEBUG; - break; - default: - cs_level = LL_VERBOSE_DEBUG; - } - /* mbedTLS passes strings with \n at the end, strip it. */ - LOG(cs_level, ("%p %.*s", ctx, (int) (strlen(str) - 1), str)); - (void) file; - (void) line; -} - -struct mg_ssl_if_ctx { - mbedtls_ssl_config *conf; - mbedtls_ssl_context *ssl; - mbedtls_x509_crt *cert; - mbedtls_pk_context *key; - mbedtls_x509_crt *ca_cert; - struct mbuf cipher_suites; -}; - -/* Must be provided by the platform. ctx is struct mg_connection. */ -extern int mg_ssl_if_mbed_random(void *ctx, unsigned char *buf, size_t len); - -void mg_ssl_if_init() { -} - -enum mg_ssl_if_result mg_ssl_if_conn_accept(struct mg_connection *nc, - struct mg_connection *lc) { - struct mg_ssl_if_ctx *ctx = - (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx)); - struct mg_ssl_if_ctx *lc_ctx = (struct mg_ssl_if_ctx *) lc->ssl_if_data; - nc->ssl_if_data = ctx; - if (ctx == NULL || lc_ctx == NULL) return MG_SSL_ERROR; - ctx->ssl = MG_CALLOC(1, sizeof(*ctx->ssl)); - if (mbedtls_ssl_setup(ctx->ssl, lc_ctx->conf) != 0) { - return MG_SSL_ERROR; - } - return MG_SSL_OK; -} - -static enum mg_ssl_if_result mg_use_cert(struct mg_ssl_if_ctx *ctx, - const char *cert, const char *key, - const char **err_msg); -static enum mg_ssl_if_result mg_use_ca_cert(struct mg_ssl_if_ctx *ctx, - const char *cert); -static enum mg_ssl_if_result mg_set_cipher_list(struct mg_ssl_if_ctx *ctx, - const char *ciphers); - -enum mg_ssl_if_result mg_ssl_if_conn_init( - struct mg_connection *nc, const struct mg_ssl_if_conn_params *params, - const char **err_msg) { - struct mg_ssl_if_ctx *ctx = - (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx)); - DBG(("%p %s,%s,%s", nc, (params->cert ? params->cert : ""), - (params->key ? params->key : ""), - (params->ca_cert ? params->ca_cert : ""))); - - if (ctx == NULL) { - MG_SET_PTRPTR(err_msg, "Out of memory"); - return MG_SSL_ERROR; - } - nc->ssl_if_data = ctx; - ctx->conf = MG_CALLOC(1, sizeof(*ctx->conf)); - mbuf_init(&ctx->cipher_suites, 0); - mbedtls_ssl_config_init(ctx->conf); - mbedtls_ssl_conf_dbg(ctx->conf, mg_ssl_mbed_log, nc); - if (mbedtls_ssl_config_defaults( - ctx->conf, (nc->flags & MG_F_LISTENING ? MBEDTLS_SSL_IS_SERVER - : MBEDTLS_SSL_IS_CLIENT), - MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT) != 0) { - MG_SET_PTRPTR(err_msg, "Failed to init SSL config"); - return MG_SSL_ERROR; - } - /* TLS 1.2 and up */ - mbedtls_ssl_conf_min_version(ctx->conf, MBEDTLS_SSL_MAJOR_VERSION_3, - MBEDTLS_SSL_MINOR_VERSION_3); - mbedtls_ssl_conf_rng(ctx->conf, mg_ssl_if_mbed_random, nc); - - if (params->cert != NULL && - mg_use_cert(ctx, params->cert, params->key, err_msg) != MG_SSL_OK) { - return MG_SSL_ERROR; - } - - if (params->ca_cert != NULL && - mg_use_ca_cert(ctx, params->ca_cert) != MG_SSL_OK) { - MG_SET_PTRPTR(err_msg, "Invalid SSL CA cert"); - return MG_SSL_ERROR; - } - - if (mg_set_cipher_list(ctx, params->cipher_suites) != MG_SSL_OK) { - MG_SET_PTRPTR(err_msg, "Invalid cipher suite list"); - return MG_SSL_ERROR; - } - - if (!(nc->flags & MG_F_LISTENING)) { - ctx->ssl = MG_CALLOC(1, sizeof(*ctx->ssl)); - mbedtls_ssl_init(ctx->ssl); - if (mbedtls_ssl_setup(ctx->ssl, ctx->conf) != 0) { - MG_SET_PTRPTR(err_msg, "Failed to create SSL session"); - return MG_SSL_ERROR; - } - if (params->server_name != NULL && - mbedtls_ssl_set_hostname(ctx->ssl, params->server_name) != 0) { - return MG_SSL_ERROR; - } - } - - nc->flags |= MG_F_SSL; - - return MG_SSL_OK; -} - -#if MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL -int ssl_socket_send(void *ctx, const unsigned char *buf, size_t len); -int ssl_socket_recv(void *ctx, unsigned char *buf, size_t len); -#else -static int ssl_socket_send(void *ctx, const unsigned char *buf, size_t len) { - struct mg_connection *nc = (struct mg_connection *) ctx; - int n = (int) MG_SEND_FUNC(nc->sock, buf, len, 0); - LOG(LL_DEBUG, ("%p %d -> %d", nc, (int) len, n)); - if (n >= 0) return n; - n = mg_get_errno(); - return ((n == EAGAIN || n == EINPROGRESS) ? MBEDTLS_ERR_SSL_WANT_WRITE : -1); -} - -static int ssl_socket_recv(void *ctx, unsigned char *buf, size_t len) { - struct mg_connection *nc = (struct mg_connection *) ctx; - int n = (int) MG_RECV_FUNC(nc->sock, buf, len, 0); - LOG(LL_DEBUG, ("%p %d <- %d", nc, (int) len, n)); - if (n >= 0) return n; - n = mg_get_errno(); - return ((n == EAGAIN || n == EINPROGRESS) ? MBEDTLS_ERR_SSL_WANT_READ : -1); -} -#endif - -static enum mg_ssl_if_result mg_ssl_if_mbed_err(struct mg_connection *nc, - int ret) { - if (ret == MBEDTLS_ERR_SSL_WANT_READ) return MG_SSL_WANT_READ; - if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) return MG_SSL_WANT_WRITE; - if (ret != - MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { /* CLOSE_NOTIFY = Normal shutdown */ - LOG(LL_ERROR, ("%p SSL error: %d", nc, ret)); - } - nc->err = ret; - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - return MG_SSL_ERROR; -} - -static void mg_ssl_if_mbed_free_certs_and_keys(struct mg_ssl_if_ctx *ctx) { - if (ctx->cert != NULL) { - mbedtls_x509_crt_free(ctx->cert); - MG_FREE(ctx->cert); - ctx->cert = NULL; - mbedtls_pk_free(ctx->key); - MG_FREE(ctx->key); - ctx->key = NULL; - } - if (ctx->ca_cert != NULL) { - mbedtls_ssl_conf_ca_chain(ctx->conf, NULL, NULL); - mbedtls_x509_crt_free(ctx->ca_cert); - MG_FREE(ctx->ca_cert); - ctx->ca_cert = NULL; - } -} - -enum mg_ssl_if_result mg_ssl_if_handshake(struct mg_connection *nc) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - int err; - /* If bio is not yet set, do it now. */ - if (ctx->ssl->p_bio == NULL) { - mbedtls_ssl_set_bio(ctx->ssl, nc, ssl_socket_send, ssl_socket_recv, NULL); - } - err = mbedtls_ssl_handshake(ctx->ssl); - if (err != 0) return mg_ssl_if_mbed_err(nc, err); -#ifdef MG_SSL_IF_MBEDTLS_FREE_CERTS - /* - * Free the peer certificate, we don't need it after handshake. - * Note that this effectively disables renegotiation. - */ - mbedtls_x509_crt_free(ctx->ssl->session->peer_cert); - mbedtls_free(ctx->ssl->session->peer_cert); - ctx->ssl->session->peer_cert = NULL; - /* On a client connection we can also free our own and CA certs. */ - if (nc->listener == NULL) { - if (ctx->conf->key_cert != NULL) { - /* Note that this assumes one key_cert entry, which matches our init. */ - MG_FREE(ctx->conf->key_cert); - ctx->conf->key_cert = NULL; - } - mbedtls_ssl_conf_ca_chain(ctx->conf, NULL, NULL); - mg_ssl_if_mbed_free_certs_and_keys(ctx); - } -#endif - return MG_SSL_OK; -} - -int mg_ssl_if_read(struct mg_connection *nc, void *buf, size_t buf_size) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - int n = mbedtls_ssl_read(ctx->ssl, buf, buf_size); - DBG(("%p %d -> %d", nc, (int) buf_size, n)); - if (n < 0) return mg_ssl_if_mbed_err(nc, n); - if (n == 0) nc->flags |= MG_F_CLOSE_IMMEDIATELY; - return n; -} - -int mg_ssl_if_write(struct mg_connection *nc, const void *data, size_t len) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - int n = mbedtls_ssl_write(ctx->ssl, data, len); - DBG(("%p %d -> %d", nc, (int) len, n)); - if (n < 0) return mg_ssl_if_mbed_err(nc, n); - return n; -} - -void mg_ssl_if_conn_free(struct mg_connection *nc) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - if (ctx == NULL) return; - nc->ssl_if_data = NULL; - if (ctx->ssl != NULL) { - mbedtls_ssl_free(ctx->ssl); - MG_FREE(ctx->ssl); - } - mg_ssl_if_mbed_free_certs_and_keys(ctx); - if (ctx->conf != NULL) { - mbedtls_ssl_config_free(ctx->conf); - MG_FREE(ctx->conf); - } - mbuf_free(&ctx->cipher_suites); - memset(ctx, 0, sizeof(*ctx)); - MG_FREE(ctx); -} - -static enum mg_ssl_if_result mg_use_ca_cert(struct mg_ssl_if_ctx *ctx, - const char *ca_cert) { - if (ca_cert == NULL || strcmp(ca_cert, "*") == 0) { - return MG_SSL_OK; - } - ctx->ca_cert = MG_CALLOC(1, sizeof(*ctx->ca_cert)); - mbedtls_x509_crt_init(ctx->ca_cert); - if (mbedtls_x509_crt_parse_file(ctx->ca_cert, ca_cert) != 0) { - return MG_SSL_ERROR; - } - mbedtls_ssl_conf_ca_chain(ctx->conf, ctx->ca_cert, NULL); - mbedtls_ssl_conf_authmode(ctx->conf, MBEDTLS_SSL_VERIFY_REQUIRED); - return MG_SSL_OK; -} - -static enum mg_ssl_if_result mg_use_cert(struct mg_ssl_if_ctx *ctx, - const char *cert, const char *key, - const char **err_msg) { - if (key == NULL) key = cert; - if (cert == NULL || cert[0] == '\0' || key == NULL || key[0] == '\0') { - return MG_SSL_OK; - } - ctx->cert = MG_CALLOC(1, sizeof(*ctx->cert)); - mbedtls_x509_crt_init(ctx->cert); - ctx->key = MG_CALLOC(1, sizeof(*ctx->key)); - mbedtls_pk_init(ctx->key); - if (mbedtls_x509_crt_parse_file(ctx->cert, cert) != 0) { - MG_SET_PTRPTR(err_msg, "Invalid SSL cert"); - return MG_SSL_ERROR; - } - if (mbedtls_pk_parse_keyfile(ctx->key, key, NULL) != 0) { - MG_SET_PTRPTR(err_msg, "Invalid SSL key"); - return MG_SSL_ERROR; - } - if (mbedtls_ssl_conf_own_cert(ctx->conf, ctx->cert, ctx->key) != 0) { - MG_SET_PTRPTR(err_msg, "Invalid SSL key or cert"); - return MG_SSL_ERROR; - } - return MG_SSL_OK; -} - -static const int mg_s_cipher_list[] = { - MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, - MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, - MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, - MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, - MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, - MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, - MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, - MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, - MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, - MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, - MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256, - MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256, - MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA, 0}; - -/* - * Ciphers can be specified as a colon-separated list of cipher suite names. - * These can be found in - * https://github.com/ARMmbed/mbedtls/blob/development/library/ssl_ciphersuites.c#L267 - * E.g.: TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-256-CCM - */ -static enum mg_ssl_if_result mg_set_cipher_list(struct mg_ssl_if_ctx *ctx, - const char *ciphers) { - if (ciphers != NULL) { - int l, id; - const char *s = ciphers; - char *e, tmp[50]; - while (s != NULL) { - e = strchr(s, ':'); - l = (e != NULL ? (e - s) : (int) strlen(s)); - strncpy(tmp, s, l); - tmp[l] = '\0'; - id = mbedtls_ssl_get_ciphersuite_id(tmp); - DBG(("%s -> %04x", tmp, id)); - if (id != 0) { - mbuf_append(&ctx->cipher_suites, &id, sizeof(id)); - } - s = (e != NULL ? e + 1 : NULL); - } - if (ctx->cipher_suites.len == 0) return MG_SSL_ERROR; - id = 0; - mbuf_append(&ctx->cipher_suites, &id, sizeof(id)); - mbedtls_ssl_conf_ciphersuites(ctx->conf, - (const int *) ctx->cipher_suites.buf); - } else { - mbedtls_ssl_conf_ciphersuites(ctx->conf, mg_s_cipher_list); - } - return MG_SSL_OK; -} - -const char *mg_set_ssl(struct mg_connection *nc, const char *cert, - const char *ca_cert) { - const char *err_msg = NULL; - struct mg_ssl_if_conn_params params; - memset(¶ms, 0, sizeof(params)); - params.cert = cert; - params.ca_cert = ca_cert; - if (mg_ssl_if_conn_init(nc, ¶ms, &err_msg) != MG_SSL_OK) { - return err_msg; - } - return NULL; -} - -/* Lazy RNG. Warning: it would be a bad idea to do this in production! */ -#ifdef MG_SSL_MBED_DUMMY_RANDOM -int mg_ssl_if_mbed_random(void *ctx, unsigned char *buf, size_t len) { - (void) ctx; - while (len--) *buf++ = rand(); - return 0; -} -#endif - -#endif /* MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_MBEDTLS */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/uri.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/uri.h" */ - -/* - * scan string until `sep`, keeping track of component boundaries in `res`. - * - * `p` will point to the char after the separator or it will be `end`. - */ -static void parse_uri_component(const char **p, const char *end, char sep, - struct mg_str *res) { - res->p = *p; - for (; *p < end; (*p)++) { - if (**p == sep) { - break; - } - } - res->len = (*p) - res->p; - if (*p < end) (*p)++; -} - -int mg_parse_uri(struct mg_str uri, struct mg_str *scheme, - struct mg_str *user_info, struct mg_str *host, - unsigned int *port, struct mg_str *path, struct mg_str *query, - struct mg_str *fragment) { - struct mg_str rscheme = {0, 0}, ruser_info = {0, 0}, rhost = {0, 0}, - rpath = {0, 0}, rquery = {0, 0}, rfragment = {0, 0}; - unsigned int rport = 0; - enum { - P_START, - P_SCHEME_OR_PORT, - P_USER_INFO, - P_HOST, - P_PORT, - P_REST - } state = P_START; - - const char *p = uri.p, *end = p + uri.len; - while (p < end) { - switch (state) { - case P_START: - /* - * expecting on of: - * - `scheme://xxxx` - * - `xxxx:port` - * - `xxxx/path` - */ - for (; p < end; p++) { - if (*p == ':') { - state = P_SCHEME_OR_PORT; - break; - } else if (*p == '/') { - state = P_REST; - break; - } - } - if (state == P_START || state == P_REST) { - rhost.p = uri.p; - rhost.len = p - uri.p; - } - break; - case P_SCHEME_OR_PORT: - if (end - p >= 3 && strncmp(p, "://", 3) == 0) { - rscheme.p = uri.p; - rscheme.len = p - uri.p; - state = P_USER_INFO; - p += 2; /* point to last separator char */ - } else { - rhost.p = uri.p; - rhost.len = p - uri.p; - state = P_PORT; - } - break; - case P_USER_INFO: - p++; - ruser_info.p = p; - for (; p < end; p++) { - if (*p == '@') { - state = P_HOST; - break; - } else if (*p == '/') { - break; - } - } - if (p == end || *p == '/') { - /* backtrack and parse as host */ - state = P_HOST; - p = ruser_info.p; - } - ruser_info.len = p - ruser_info.p; - break; - case P_HOST: - if (*p == '@') p++; - rhost.p = p; - for (; p < end; p++) { - if (*p == ':') { - state = P_PORT; - break; - } else if (*p == '/') { - state = P_REST; - break; - } - } - rhost.len = p - rhost.p; - break; - case P_PORT: - p++; - for (; p < end; p++) { - if (*p == '/') { - state = P_REST; - break; - } - rport *= 10; - rport += *p - '0'; - } - break; - case P_REST: - /* `p` points to separator. `path` includes the separator */ - parse_uri_component(&p, end, '?', &rpath); - parse_uri_component(&p, end, '#', &rquery); - parse_uri_component(&p, end, '\0', &rfragment); - break; - } - } - - if (scheme != 0) *scheme = rscheme; - if (user_info != 0) *user_info = ruser_info; - if (host != 0) *host = rhost; - if (port != 0) *port = rport; - if (path != 0) *path = rpath; - if (query != 0) *query = rquery; - if (fragment != 0) *fragment = rfragment; - - return 0; -} - -/* Normalize the URI path. Remove/resolve "." and "..". */ -int mg_normalize_uri_path(const struct mg_str *in, struct mg_str *out) { - const char *s = in->p, *se = s + in->len; - char *cp = (char *) out->p, *d; - - if (in->len == 0 || *s != '/') { - out->len = 0; - return 0; - } - - d = cp; - - while (s < se) { - const char *next = s; - struct mg_str component; - parse_uri_component(&next, se, '/', &component); - if (mg_vcmp(&component, ".") == 0) { - /* Yum. */ - } else if (mg_vcmp(&component, "..") == 0) { - /* Backtrack to previous slash. */ - if (d > cp + 1 && *(d - 1) == '/') d--; - while (d > cp && *(d - 1) != '/') d--; - } else { - memmove(d, s, next - s); - d += next - s; - } - s = next; - } - if (d == cp) *d++ = '/'; - - out->p = cp; - out->len = d - cp; - return 1; -} -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_HTTP - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ -/* Amalgamated: #include "common/sha1.h" */ -/* Amalgamated: #include "common/md5.h" */ - -static const char *mg_version_header = "Mongoose/" MG_VERSION; - -enum mg_http_proto_data_type { DATA_NONE, DATA_FILE, DATA_PUT }; - -struct mg_http_proto_data_file { - FILE *fp; /* Opened file. */ - int64_t cl; /* Content-Length. How many bytes to send. */ - int64_t sent; /* How many bytes have been already sent. */ - int keepalive; /* Keep connection open after sending. */ - enum mg_http_proto_data_type type; -}; - -#if MG_ENABLE_HTTP_CGI -struct mg_http_proto_data_cgi { - struct mg_connection *cgi_nc; -}; -#endif - -struct mg_http_proto_data_chuncked { - int64_t body_len; /* How many bytes of chunked body was reassembled. */ -}; - -struct mg_http_endpoint { - struct mg_http_endpoint *next; - const char *name; - size_t name_len; - mg_event_handler_t handler; -}; - -enum mg_http_multipart_stream_state { - MPS_BEGIN, - MPS_WAITING_FOR_BOUNDARY, - MPS_WAITING_FOR_CHUNK, - MPS_GOT_CHUNK, - MPS_GOT_BOUNDARY, - MPS_FINALIZE, - MPS_FINISHED -}; - -struct mg_http_multipart_stream { - const char *boundary; - int boundary_len; - const char *var_name; - const char *file_name; - void *user_data; - int prev_io_len; - enum mg_http_multipart_stream_state state; - int processing_part; -}; - -struct mg_reverse_proxy_data { - struct mg_connection *linked_conn; -}; - -struct mg_http_proto_data { -#if MG_ENABLE_FILESYSTEM - struct mg_http_proto_data_file file; -#endif -#if MG_ENABLE_HTTP_CGI - struct mg_http_proto_data_cgi cgi; -#endif -#if MG_ENABLE_HTTP_STREAMING_MULTIPART - struct mg_http_multipart_stream mp_stream; -#endif - struct mg_http_proto_data_chuncked chunk; - struct mg_http_endpoint *endpoints; - mg_event_handler_t endpoint_handler; - struct mg_reverse_proxy_data reverse_proxy_data; -}; - -static void mg_http_conn_destructor(void *proto_data); -struct mg_connection *mg_connect_http_base( - struct mg_mgr *mgr, mg_event_handler_t ev_handler, - struct mg_connect_opts opts, const char *schema, const char *schema_ssl, - const char *url, const char **path, char **user, char **pass, char **addr); - -static struct mg_http_proto_data *mg_http_get_proto_data( - struct mg_connection *c) { - if (c->proto_data == NULL) { - c->proto_data = MG_CALLOC(1, sizeof(struct mg_http_proto_data)); - c->proto_data_destructor = mg_http_conn_destructor; - } - - return (struct mg_http_proto_data *) c->proto_data; -} - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART -static void mg_http_free_proto_data_mp_stream( - struct mg_http_multipart_stream *mp) { - free((void *) mp->boundary); - free((void *) mp->var_name); - free((void *) mp->file_name); - memset(mp, 0, sizeof(*mp)); -} -#endif - -#if MG_ENABLE_FILESYSTEM -static void mg_http_free_proto_data_file(struct mg_http_proto_data_file *d) { - if (d != NULL) { - if (d->fp != NULL) { - fclose(d->fp); - } - memset(d, 0, sizeof(struct mg_http_proto_data_file)); - } -} -#endif - -static void mg_http_free_proto_data_endpoints(struct mg_http_endpoint **ep) { - struct mg_http_endpoint *current = *ep; - - while (current != NULL) { - struct mg_http_endpoint *tmp = current->next; - free((void *) current->name); - free(current); - current = tmp; - } - - ep = NULL; -} - -static void mg_http_free_reverse_proxy_data(struct mg_reverse_proxy_data *rpd) { - if (rpd->linked_conn != NULL) { - /* - * Connection has linked one, we have to unlink & close it - * since _this_ connection is going to die and - * it doesn't make sense to keep another one - */ - struct mg_http_proto_data *pd = mg_http_get_proto_data(rpd->linked_conn); - if (pd->reverse_proxy_data.linked_conn != NULL) { - pd->reverse_proxy_data.linked_conn->flags |= MG_F_SEND_AND_CLOSE; - pd->reverse_proxy_data.linked_conn = NULL; - } - rpd->linked_conn = NULL; - } -} - -static void mg_http_conn_destructor(void *proto_data) { - struct mg_http_proto_data *pd = (struct mg_http_proto_data *) proto_data; -#if MG_ENABLE_FILESYSTEM - mg_http_free_proto_data_file(&pd->file); -#endif -#if MG_ENABLE_HTTP_CGI - mg_http_free_proto_data_cgi(&pd->cgi); -#endif -#if MG_ENABLE_HTTP_STREAMING_MULTIPART - mg_http_free_proto_data_mp_stream(&pd->mp_stream); -#endif - mg_http_free_proto_data_endpoints(&pd->endpoints); - mg_http_free_reverse_proxy_data(&pd->reverse_proxy_data); - free(proto_data); -} - -#if MG_ENABLE_FILESYSTEM - -#define MIME_ENTRY(_ext, _type) \ - { _ext, sizeof(_ext) - 1, _type } -static const struct { - const char *extension; - size_t ext_len; - const char *mime_type; -} mg_static_builtin_mime_types[] = { - MIME_ENTRY("html", "text/html"), - MIME_ENTRY("html", "text/html"), - MIME_ENTRY("htm", "text/html"), - MIME_ENTRY("shtm", "text/html"), - MIME_ENTRY("shtml", "text/html"), - MIME_ENTRY("css", "text/css"), - MIME_ENTRY("js", "application/x-javascript"), - MIME_ENTRY("ico", "image/x-icon"), - MIME_ENTRY("gif", "image/gif"), - MIME_ENTRY("jpg", "image/jpeg"), - MIME_ENTRY("jpeg", "image/jpeg"), - MIME_ENTRY("png", "image/png"), - MIME_ENTRY("svg", "image/svg+xml"), - MIME_ENTRY("txt", "text/plain"), - MIME_ENTRY("torrent", "application/x-bittorrent"), - MIME_ENTRY("wav", "audio/x-wav"), - MIME_ENTRY("mp3", "audio/x-mp3"), - MIME_ENTRY("mid", "audio/mid"), - MIME_ENTRY("m3u", "audio/x-mpegurl"), - MIME_ENTRY("ogg", "application/ogg"), - MIME_ENTRY("ram", "audio/x-pn-realaudio"), - MIME_ENTRY("xml", "text/xml"), - MIME_ENTRY("ttf", "application/x-font-ttf"), - MIME_ENTRY("json", "application/json"), - MIME_ENTRY("xslt", "application/xml"), - MIME_ENTRY("xsl", "application/xml"), - MIME_ENTRY("ra", "audio/x-pn-realaudio"), - MIME_ENTRY("doc", "application/msword"), - MIME_ENTRY("exe", "application/octet-stream"), - MIME_ENTRY("zip", "application/x-zip-compressed"), - MIME_ENTRY("xls", "application/excel"), - MIME_ENTRY("tgz", "application/x-tar-gz"), - MIME_ENTRY("tar", "application/x-tar"), - MIME_ENTRY("gz", "application/x-gunzip"), - MIME_ENTRY("arj", "application/x-arj-compressed"), - MIME_ENTRY("rar", "application/x-rar-compressed"), - MIME_ENTRY("rtf", "application/rtf"), - MIME_ENTRY("pdf", "application/pdf"), - MIME_ENTRY("swf", "application/x-shockwave-flash"), - MIME_ENTRY("mpg", "video/mpeg"), - MIME_ENTRY("webm", "video/webm"), - MIME_ENTRY("mpeg", "video/mpeg"), - MIME_ENTRY("mov", "video/quicktime"), - MIME_ENTRY("mp4", "video/mp4"), - MIME_ENTRY("m4v", "video/x-m4v"), - MIME_ENTRY("asf", "video/x-ms-asf"), - MIME_ENTRY("avi", "video/x-msvideo"), - MIME_ENTRY("bmp", "image/bmp"), - {NULL, 0, NULL}}; - -static struct mg_str mg_get_mime_type(const char *path, const char *dflt, - const struct mg_serve_http_opts *opts) { - const char *ext, *overrides; - size_t i, path_len; - struct mg_str r, k, v; - - path_len = strlen(path); - - overrides = opts->custom_mime_types; - while ((overrides = mg_next_comma_list_entry(overrides, &k, &v)) != NULL) { - ext = path + (path_len - k.len); - if (path_len > k.len && mg_vcasecmp(&k, ext) == 0) { - return v; - } - } - - for (i = 0; mg_static_builtin_mime_types[i].extension != NULL; i++) { - ext = path + (path_len - mg_static_builtin_mime_types[i].ext_len); - if (path_len > mg_static_builtin_mime_types[i].ext_len && ext[-1] == '.' && - mg_casecmp(ext, mg_static_builtin_mime_types[i].extension) == 0) { - r.p = mg_static_builtin_mime_types[i].mime_type; - r.len = strlen(r.p); - return r; - } - } - - r.p = dflt; - r.len = strlen(r.p); - return r; -} -#endif - -/* - * Check whether full request is buffered. Return: - * -1 if request is malformed - * 0 if request is not yet fully buffered - * >0 actual request length, including last \r\n\r\n - */ -static int mg_http_get_request_len(const char *s, int buf_len) { - const unsigned char *buf = (unsigned char *) s; - int i; - - for (i = 0; i < buf_len; i++) { - if (!isprint(buf[i]) && buf[i] != '\r' && buf[i] != '\n' && buf[i] < 128) { - return -1; - } else if (buf[i] == '\n' && i + 1 < buf_len && buf[i + 1] == '\n') { - return i + 2; - } else if (buf[i] == '\n' && i + 2 < buf_len && buf[i + 1] == '\r' && - buf[i + 2] == '\n') { - return i + 3; - } - } - - return 0; -} - -static const char *mg_http_parse_headers(const char *s, const char *end, - int len, struct http_message *req) { - int i = 0; - while (i < (int) ARRAY_SIZE(req->header_names) - 1) { - struct mg_str *k = &req->header_names[i], *v = &req->header_values[i]; - - s = mg_skip(s, end, ": ", k); - s = mg_skip(s, end, "\r\n", v); - - while (v->len > 0 && v->p[v->len - 1] == ' ') { - v->len--; /* Trim trailing spaces in header value */ - } - - /* - * If header value is empty - skip it and go to next (if any). - * NOTE: Do not add it to headers_values because such addition changes API - * behaviour - */ - if (k->len != 0 && v->len == 0) { - continue; - } - - if (k->len == 0 || v->len == 0) { - k->p = v->p = NULL; - k->len = v->len = 0; - break; - } - - if (!mg_ncasecmp(k->p, "Content-Length", 14)) { - req->body.len = (size_t) to64(v->p); - req->message.len = len + req->body.len; - } - - i++; - } - - return s; -} - -int mg_parse_http(const char *s, int n, struct http_message *hm, int is_req) { - const char *end, *qs; - int len = mg_http_get_request_len(s, n); - - if (len <= 0) return len; - - memset(hm, 0, sizeof(*hm)); - hm->message.p = s; - hm->body.p = s + len; - hm->message.len = hm->body.len = (size_t) ~0; - end = s + len; - - /* Request is fully buffered. Skip leading whitespaces. */ - while (s < end && isspace(*(unsigned char *) s)) s++; - - if (is_req) { - /* Parse request line: method, URI, proto */ - s = mg_skip(s, end, " ", &hm->method); - s = mg_skip(s, end, " ", &hm->uri); - s = mg_skip(s, end, "\r\n", &hm->proto); - if (hm->uri.p <= hm->method.p || hm->proto.p <= hm->uri.p) return -1; - - /* If URI contains '?' character, initialize query_string */ - if ((qs = (char *) memchr(hm->uri.p, '?', hm->uri.len)) != NULL) { - hm->query_string.p = qs + 1; - hm->query_string.len = &hm->uri.p[hm->uri.len] - (qs + 1); - hm->uri.len = qs - hm->uri.p; - } - } else { - s = mg_skip(s, end, " ", &hm->proto); - if (end - s < 4 || s[3] != ' ') return -1; - hm->resp_code = atoi(s); - if (hm->resp_code < 100 || hm->resp_code >= 600) return -1; - s += 4; - s = mg_skip(s, end, "\r\n", &hm->resp_status_msg); - } - - s = mg_http_parse_headers(s, end, len, hm); - - /* - * mg_parse_http() is used to parse both HTTP requests and HTTP - * responses. If HTTP response does not have Content-Length set, then - * body is read until socket is closed, i.e. body.len is infinite (~0). - * - * For HTTP requests though, according to - * http://tools.ietf.org/html/rfc7231#section-8.1.3, - * only POST and PUT methods have defined body semantics. - * Therefore, if Content-Length is not specified and methods are - * not one of PUT or POST, set body length to 0. - * - * So, - * if it is HTTP request, and Content-Length is not set, - * and method is not (PUT or POST) then reset body length to zero. - */ - if (hm->body.len == (size_t) ~0 && is_req && - mg_vcasecmp(&hm->method, "PUT") != 0 && - mg_vcasecmp(&hm->method, "POST") != 0) { - hm->body.len = 0; - hm->message.len = len; - } - - return len; -} - -struct mg_str *mg_get_http_header(struct http_message *hm, const char *name) { - size_t i, len = strlen(name); - - for (i = 0; hm->header_names[i].len > 0; i++) { - struct mg_str *h = &hm->header_names[i], *v = &hm->header_values[i]; - if (h->p != NULL && h->len == len && !mg_ncasecmp(h->p, name, len)) - return v; - } - - return NULL; -} - -#if MG_ENABLE_FILESYSTEM -static void mg_http_transfer_file_data(struct mg_connection *nc) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - char buf[MG_MAX_HTTP_SEND_MBUF]; - size_t n = 0, to_read = 0, left = (size_t)(pd->file.cl - pd->file.sent); - - if (pd->file.type == DATA_FILE) { - struct mbuf *io = &nc->send_mbuf; - if (io->len < sizeof(buf)) { - to_read = sizeof(buf) - io->len; - } - - if (left > 0 && to_read > left) { - to_read = left; - } - - if (to_read == 0) { - /* Rate limiting. send_mbuf is too full, wait until it's drained. */ - } else if (pd->file.sent < pd->file.cl && - (n = fread(buf, 1, to_read, pd->file.fp)) > 0) { - mg_send(nc, buf, n); - pd->file.sent += n; - } else { - if (!pd->file.keepalive) nc->flags |= MG_F_SEND_AND_CLOSE; - mg_http_free_proto_data_file(&pd->file); - } - } else if (pd->file.type == DATA_PUT) { - struct mbuf *io = &nc->recv_mbuf; - size_t to_write = left <= 0 ? 0 : left < io->len ? (size_t) left : io->len; - size_t n = fwrite(io->buf, 1, to_write, pd->file.fp); - if (n > 0) { - mbuf_remove(io, n); - pd->file.sent += n; - } - if (n == 0 || pd->file.sent >= pd->file.cl) { - if (!pd->file.keepalive) nc->flags |= MG_F_SEND_AND_CLOSE; - mg_http_free_proto_data_file(&pd->file); - } - } -#if MG_ENABLE_HTTP_CGI - else if (pd->cgi.cgi_nc != NULL) { - /* This is POST data that needs to be forwarded to the CGI process */ - if (pd->cgi.cgi_nc != NULL) { - mg_forward(nc, pd->cgi.cgi_nc); - } else { - nc->flags |= MG_F_SEND_AND_CLOSE; - } - } -#endif -} -#endif /* MG_ENABLE_FILESYSTEM */ - -/* - * Parse chunked-encoded buffer. Return 0 if the buffer is not encoded, or - * if it's incomplete. If the chunk is fully buffered, return total number of - * bytes in a chunk, and store data in `data`, `data_len`. - */ -static size_t mg_http_parse_chunk(char *buf, size_t len, char **chunk_data, - size_t *chunk_len) { - unsigned char *s = (unsigned char *) buf; - size_t n = 0; /* scanned chunk length */ - size_t i = 0; /* index in s */ - - /* Scan chunk length. That should be a hexadecimal number. */ - while (i < len && isxdigit(s[i])) { - n *= 16; - n += (s[i] >= '0' && s[i] <= '9') ? s[i] - '0' : tolower(s[i]) - 'a' + 10; - i++; - } - - /* Skip new line */ - if (i == 0 || i + 2 > len || s[i] != '\r' || s[i + 1] != '\n') { - return 0; - } - i += 2; - - /* Record where the data is */ - *chunk_data = (char *) s + i; - *chunk_len = n; - - /* Skip data */ - i += n; - - /* Skip new line */ - if (i == 0 || i + 2 > len || s[i] != '\r' || s[i + 1] != '\n') { - return 0; - } - return i + 2; -} - -MG_INTERNAL size_t mg_handle_chunked(struct mg_connection *nc, - struct http_message *hm, char *buf, - size_t blen) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - char *data; - size_t i, n, data_len, body_len, zero_chunk_received = 0; - /* Find out piece of received data that is not yet reassembled */ - body_len = (size_t) pd->chunk.body_len; - assert(blen >= body_len); - - /* Traverse all fully buffered chunks */ - for (i = body_len; - (n = mg_http_parse_chunk(buf + i, blen - i, &data, &data_len)) > 0; - i += n) { - /* Collapse chunk data to the rest of HTTP body */ - memmove(buf + body_len, data, data_len); - body_len += data_len; - hm->body.len = body_len; - - if (data_len == 0) { - zero_chunk_received = 1; - i += n; - break; - } - } - - if (i > body_len) { - /* Shift unparsed content to the parsed body */ - assert(i <= blen); - memmove(buf + body_len, buf + i, blen - i); - memset(buf + body_len + blen - i, 0, i - body_len); - nc->recv_mbuf.len -= i - body_len; - pd->chunk.body_len = body_len; - - /* Send MG_EV_HTTP_CHUNK event */ - nc->flags &= ~MG_F_DELETE_CHUNK; - mg_call(nc, nc->handler, MG_EV_HTTP_CHUNK, hm); - - /* Delete processed data if user set MG_F_DELETE_CHUNK flag */ - if (nc->flags & MG_F_DELETE_CHUNK) { - memset(buf, 0, body_len); - memmove(buf, buf + body_len, blen - i); - nc->recv_mbuf.len -= body_len; - hm->body.len = 0; - pd->chunk.body_len = 0; - } - - if (zero_chunk_received) { - hm->message.len = (size_t) pd->chunk.body_len + blen - i; - } - } - - return body_len; -} - -static mg_event_handler_t mg_http_get_endpoint_handler( - struct mg_connection *nc, struct mg_str *uri_path) { - struct mg_http_proto_data *pd; - mg_event_handler_t ret = NULL; - int matched, matched_max = 0; - struct mg_http_endpoint *ep; - - if (nc == NULL) { - return NULL; - } - - pd = mg_http_get_proto_data(nc); - - ep = pd->endpoints; - while (ep != NULL) { - const struct mg_str name_s = {ep->name, ep->name_len}; - if ((matched = mg_match_prefix_n(name_s, *uri_path)) != -1) { - if (matched > matched_max) { - /* Looking for the longest suitable handler */ - ret = ep->handler; - matched_max = matched; - } - } - - ep = ep->next; - } - - return ret; -} - -static void mg_http_call_endpoint_handler(struct mg_connection *nc, int ev, - struct http_message *hm) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - - if (pd->endpoint_handler == NULL || ev == MG_EV_HTTP_REQUEST) { - pd->endpoint_handler = - ev == MG_EV_HTTP_REQUEST - ? mg_http_get_endpoint_handler(nc->listener, &hm->uri) - : NULL; - } - mg_call(nc, pd->endpoint_handler ? pd->endpoint_handler : nc->handler, ev, - hm); -} - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART -static void mg_http_multipart_continue(struct mg_connection *nc); - -static void mg_http_multipart_begin(struct mg_connection *nc, - struct http_message *hm, int req_len); - -#endif - -/* - * lx106 compiler has a bug (TODO(mkm) report and insert tracking bug here) - * If a big structure is declared in a big function, lx106 gcc will make it - * even bigger (round up to 4k, from 700 bytes of actual size). - */ -#ifdef __xtensa__ -static void mg_http_handler2(struct mg_connection *nc, int ev, void *ev_data, - struct http_message *hm) __attribute__((noinline)); - -void mg_http_handler(struct mg_connection *nc, int ev, void *ev_data) { - struct http_message hm; - mg_http_handler2(nc, ev, ev_data, &hm); -} - -static void mg_http_handler2(struct mg_connection *nc, int ev, void *ev_data, - struct http_message *hm) { -#else /* !__XTENSA__ */ -void mg_http_handler(struct mg_connection *nc, int ev, void *ev_data) { - struct http_message shm; - struct http_message *hm = &shm; -#endif /* __XTENSA__ */ - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - struct mbuf *io = &nc->recv_mbuf; - int req_len; - const int is_req = (nc->listener != NULL); -#if MG_ENABLE_HTTP_WEBSOCKET - struct mg_str *vec; -#endif - if (ev == MG_EV_CLOSE) { -#if MG_ENABLE_HTTP_STREAMING_MULTIPART - if (pd->mp_stream.boundary != NULL) { - /* - * Multipart message is in progress, but connection is closed. - * Finish part and request with an error flag. - */ - struct mg_http_multipart_part mp; - memset(&mp, 0, sizeof(mp)); - mp.status = -1; - mp.var_name = pd->mp_stream.var_name; - mp.file_name = pd->mp_stream.file_name; - mg_call(nc, (pd->endpoint_handler ? pd->endpoint_handler : nc->handler), - MG_EV_HTTP_PART_END, &mp); - mp.var_name = NULL; - mp.file_name = NULL; - mg_call(nc, (pd->endpoint_handler ? pd->endpoint_handler : nc->handler), - MG_EV_HTTP_MULTIPART_REQUEST_END, &mp); - } else -#endif - if (io->len > 0 && mg_parse_http(io->buf, io->len, hm, is_req) > 0) { - /* - * For HTTP messages without Content-Length, always send HTTP message - * before MG_EV_CLOSE message. - */ - int ev2 = is_req ? MG_EV_HTTP_REQUEST : MG_EV_HTTP_REPLY; - hm->message.len = io->len; - hm->body.len = io->buf + io->len - hm->body.p; - mg_http_call_endpoint_handler(nc, ev2, hm); - } - } - -#if MG_ENABLE_FILESYSTEM - if (pd->file.fp != NULL) { - mg_http_transfer_file_data(nc); - } -#endif - - mg_call(nc, nc->handler, ev, ev_data); - - if (ev == MG_EV_RECV) { - struct mg_str *s; - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART - if (pd->mp_stream.boundary != NULL) { - mg_http_multipart_continue(nc); - return; - } -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */ - - req_len = mg_parse_http(io->buf, io->len, hm, is_req); - - if (req_len > 0 && - (s = mg_get_http_header(hm, "Transfer-Encoding")) != NULL && - mg_vcasecmp(s, "chunked") == 0) { - mg_handle_chunked(nc, hm, io->buf + req_len, io->len - req_len); - } - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART - if (req_len > 0 && (s = mg_get_http_header(hm, "Content-Type")) != NULL && - s->len >= 9 && strncmp(s->p, "multipart", 9) == 0) { - mg_http_multipart_begin(nc, hm, req_len); - mg_http_multipart_continue(nc); - return; - } -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */ - - /* TODO(alashkin): refactor this ifelseifelseifelseifelse */ - if ((req_len < 0 || - (req_len == 0 && io->len >= MG_MAX_HTTP_REQUEST_SIZE))) { - DBG(("invalid request")); - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } else if (req_len == 0) { - /* Do nothing, request is not yet fully buffered */ - } -#if MG_ENABLE_HTTP_WEBSOCKET - else if (nc->listener == NULL && - mg_get_http_header(hm, "Sec-WebSocket-Accept")) { - /* We're websocket client, got handshake response from server. */ - /* TODO(lsm): check the validity of accept Sec-WebSocket-Accept */ - mbuf_remove(io, req_len); - nc->proto_handler = mg_ws_handler; - nc->flags |= MG_F_IS_WEBSOCKET; - mg_call(nc, nc->handler, MG_EV_WEBSOCKET_HANDSHAKE_DONE, NULL); - mg_ws_handler(nc, MG_EV_RECV, ev_data); - } else if (nc->listener != NULL && - (vec = mg_get_http_header(hm, "Sec-WebSocket-Key")) != NULL) { - mg_event_handler_t handler; - - /* This is a websocket request. Switch protocol handlers. */ - mbuf_remove(io, req_len); - nc->proto_handler = mg_ws_handler; - nc->flags |= MG_F_IS_WEBSOCKET; - - /* - * If we have a handler set up with mg_register_http_endpoint(), - * deliver subsequent websocket events to this handler after the - * protocol switch. - */ - handler = mg_http_get_endpoint_handler(nc->listener, &hm->uri); - if (handler != NULL) { - nc->handler = handler; - } - - /* Send handshake */ - mg_call(nc, nc->handler, MG_EV_WEBSOCKET_HANDSHAKE_REQUEST, hm); - if (!(nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_SEND_AND_CLOSE))) { - if (nc->send_mbuf.len == 0) { - mg_ws_handshake(nc, vec); - } - mg_call(nc, nc->handler, MG_EV_WEBSOCKET_HANDSHAKE_DONE, NULL); - mg_ws_handler(nc, MG_EV_RECV, ev_data); - } - } -#endif /* MG_ENABLE_HTTP_WEBSOCKET */ - else if (hm->message.len <= io->len) { - int trigger_ev = nc->listener ? MG_EV_HTTP_REQUEST : MG_EV_HTTP_REPLY; - -/* Whole HTTP message is fully buffered, call event handler */ - -#if MG_ENABLE_JAVASCRIPT - v7_val_t v1, v2, headers, req, args, res; - struct v7 *v7 = nc->mgr->v7; - const char *ev_name = trigger_ev == MG_EV_HTTP_REPLY ? "onsnd" : "onrcv"; - int i, js_callback_handled_request = 0; - - if (v7 != NULL) { - /* Lookup JS callback */ - v1 = v7_get(v7, v7_get_global(v7), "Http", ~0); - v2 = v7_get(v7, v1, ev_name, ~0); - - /* Create callback params. TODO(lsm): own/disown those */ - args = v7_mk_array(v7); - req = v7_mk_object(v7); - headers = v7_mk_object(v7); - - /* Populate request object */ - v7_set(v7, req, "method", ~0, - v7_mk_string(v7, hm->method.p, hm->method.len, 1)); - v7_set(v7, req, "uri", ~0, v7_mk_string(v7, hm->uri.p, hm->uri.len, 1)); - v7_set(v7, req, "body", ~0, - v7_mk_string(v7, hm->body.p, hm->body.len, 1)); - v7_set(v7, req, "headers", ~0, headers); - for (i = 0; hm->header_names[i].len > 0; i++) { - const struct mg_str *name = &hm->header_names[i]; - const struct mg_str *value = &hm->header_values[i]; - v7_set(v7, headers, name->p, name->len, - v7_mk_string(v7, value->p, value->len, 1)); - } - - /* Invoke callback. TODO(lsm): report errors */ - v7_array_push(v7, args, v7_mk_foreign(v7, nc)); - v7_array_push(v7, args, req); - if (v7_apply(v7, v2, V7_UNDEFINED, args, &res) == V7_OK && - v7_is_truthy(v7, res)) { - js_callback_handled_request++; - } - } - - /* If JS callback returns true, stop request processing */ - if (js_callback_handled_request) { - nc->flags |= MG_F_SEND_AND_CLOSE; - } else { - mg_http_call_endpoint_handler(nc, trigger_ev, hm); - } -#else - mg_http_call_endpoint_handler(nc, trigger_ev, hm); -#endif - mbuf_remove(io, hm->message.len); - } - } - (void) pd; -} - -static size_t mg_get_line_len(const char *buf, size_t buf_len) { - size_t len = 0; - while (len < buf_len && buf[len] != '\n') len++; - return len == buf_len ? 0 : len + 1; -} - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART -static void mg_http_multipart_begin(struct mg_connection *nc, - struct http_message *hm, int req_len) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - struct mg_str *ct; - struct mbuf *io = &nc->recv_mbuf; - - char boundary[100]; - int boundary_len; - - if (nc->listener == NULL) { - /* No streaming for replies now */ - goto exit_mp; - } - - ct = mg_get_http_header(hm, "Content-Type"); - if (ct == NULL) { - /* We need more data - or it isn't multipart mesage */ - goto exit_mp; - } - - /* Content-type should start with "multipart" */ - if (ct->len < 9 || strncmp(ct->p, "multipart", 9) != 0) { - goto exit_mp; - } - - boundary_len = - mg_http_parse_header(ct, "boundary", boundary, sizeof(boundary)); - if (boundary_len == 0) { - /* - * Content type is multipart, but there is no boundary, - * probably malformed request - */ - nc->flags = MG_F_CLOSE_IMMEDIATELY; - DBG(("invalid request")); - goto exit_mp; - } - - /* If we reach this place - that is multipart request */ - - if (pd->mp_stream.boundary != NULL) { - /* - * Another streaming request was in progress, - * looks like protocol error - */ - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } else { - pd->mp_stream.state = MPS_BEGIN; - pd->mp_stream.boundary = strdup(boundary); - pd->mp_stream.boundary_len = strlen(boundary); - pd->mp_stream.var_name = pd->mp_stream.file_name = NULL; - - pd->endpoint_handler = mg_http_get_endpoint_handler(nc->listener, &hm->uri); - if (pd->endpoint_handler == NULL) { - pd->endpoint_handler = nc->handler; - } - - mg_call(nc, pd->endpoint_handler, MG_EV_HTTP_MULTIPART_REQUEST, hm); - - mbuf_remove(io, req_len); - } -exit_mp: - ; -} - -#define CONTENT_DISPOSITION "Content-Disposition: " - -static void mg_http_multipart_call_handler(struct mg_connection *c, int ev, - const char *data, size_t data_len) { - struct mg_http_multipart_part mp; - struct mg_http_proto_data *pd = mg_http_get_proto_data(c); - memset(&mp, 0, sizeof(mp)); - - mp.var_name = pd->mp_stream.var_name; - mp.file_name = pd->mp_stream.file_name; - mp.user_data = pd->mp_stream.user_data; - mp.data.p = data; - mp.data.len = data_len; - mg_call(c, pd->endpoint_handler, ev, &mp); - pd->mp_stream.user_data = mp.user_data; -} - -static int mg_http_multipart_got_chunk(struct mg_connection *c) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(c); - struct mbuf *io = &c->recv_mbuf; - - mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_DATA, io->buf, - pd->mp_stream.prev_io_len); - mbuf_remove(io, pd->mp_stream.prev_io_len); - pd->mp_stream.prev_io_len = 0; - pd->mp_stream.state = MPS_WAITING_FOR_CHUNK; - - return 0; -} - -static int mg_http_multipart_finalize(struct mg_connection *c) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(c); - - mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_END, NULL, 0); - free((void *) pd->mp_stream.file_name); - pd->mp_stream.file_name = NULL; - free((void *) pd->mp_stream.var_name); - pd->mp_stream.var_name = NULL; - mg_http_multipart_call_handler(c, MG_EV_HTTP_MULTIPART_REQUEST_END, NULL, 0); - mg_http_free_proto_data_mp_stream(&pd->mp_stream); - pd->mp_stream.state = MPS_FINISHED; - - return 1; -} - -static int mg_http_multipart_wait_for_boundary(struct mg_connection *c) { - const char *boundary; - struct mbuf *io = &c->recv_mbuf; - struct mg_http_proto_data *pd = mg_http_get_proto_data(c); - - if ((int) io->len < pd->mp_stream.boundary_len + 2) { - return 0; - } - - boundary = c_strnstr(io->buf, pd->mp_stream.boundary, io->len); - if (boundary != NULL) { - const char *boundary_end = (boundary + pd->mp_stream.boundary_len); - if (io->len - (boundary_end - io->buf) < 4) { - return 0; - } - if (strncmp(boundary_end, "--\r\n", 4) == 0) { - pd->mp_stream.state = MPS_FINALIZE; - mbuf_remove(io, (boundary_end - io->buf) + 4); - } else { - pd->mp_stream.state = MPS_GOT_BOUNDARY; - } - } else { - return 0; - } - - return 1; -} - -static int mg_http_multipart_process_boundary(struct mg_connection *c) { - int data_size; - const char *boundary, *block_begin; - struct mbuf *io = &c->recv_mbuf; - struct mg_http_proto_data *pd = mg_http_get_proto_data(c); - char file_name[100], var_name[100]; - int line_len; - boundary = c_strnstr(io->buf, pd->mp_stream.boundary, io->len); - block_begin = boundary + pd->mp_stream.boundary_len + 2; - data_size = io->len - (block_begin - io->buf); - - while (data_size > 0 && - (line_len = mg_get_line_len(block_begin, data_size)) != 0) { - if (line_len > (int) sizeof(CONTENT_DISPOSITION) && - mg_ncasecmp(block_begin, CONTENT_DISPOSITION, - sizeof(CONTENT_DISPOSITION) - 1) == 0) { - struct mg_str header; - - header.p = block_begin + sizeof(CONTENT_DISPOSITION) - 1; - header.len = line_len - sizeof(CONTENT_DISPOSITION) - 1; - mg_http_parse_header(&header, "name", var_name, sizeof(var_name) - 2); - mg_http_parse_header(&header, "filename", file_name, - sizeof(file_name) - 2); - block_begin += line_len; - data_size -= line_len; - continue; - } - - if (line_len == 2 && mg_ncasecmp(block_begin, "\r\n", 2) == 0) { - mbuf_remove(io, block_begin - io->buf + 2); - - if (pd->mp_stream.processing_part != 0) { - mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_END, NULL, 0); - } - - free((void *) pd->mp_stream.file_name); - pd->mp_stream.file_name = strdup(file_name); - free((void *) pd->mp_stream.var_name); - pd->mp_stream.var_name = strdup(var_name); - - mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_BEGIN, NULL, 0); - pd->mp_stream.state = MPS_WAITING_FOR_CHUNK; - pd->mp_stream.processing_part++; - return 1; - } - - block_begin += line_len; - } - - pd->mp_stream.state = MPS_WAITING_FOR_BOUNDARY; - - return 0; -} - -static int mg_http_multipart_continue_wait_for_chunk(struct mg_connection *c) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(c); - struct mbuf *io = &c->recv_mbuf; - - const char *boundary; - if ((int) io->len < pd->mp_stream.boundary_len + 6 /* \r\n, --, -- */) { - return 0; - } - - boundary = c_strnstr(io->buf, pd->mp_stream.boundary, io->len); - if (boundary == NULL && pd->mp_stream.prev_io_len == 0) { - pd->mp_stream.prev_io_len = io->len; - return 0; - } else if (boundary == NULL && - (int) io->len > - pd->mp_stream.prev_io_len + pd->mp_stream.boundary_len + 4) { - pd->mp_stream.state = MPS_GOT_CHUNK; - return 1; - } else if (boundary != NULL) { - int data_size = (boundary - io->buf - 4); - mg_http_multipart_call_handler(c, MG_EV_HTTP_PART_DATA, io->buf, data_size); - mbuf_remove(io, (boundary - io->buf)); - pd->mp_stream.prev_io_len = 0; - pd->mp_stream.state = MPS_WAITING_FOR_BOUNDARY; - return 1; - } else { - return 0; - } -} - -static void mg_http_multipart_continue(struct mg_connection *c) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(c); - while (1) { - switch (pd->mp_stream.state) { - case MPS_BEGIN: { - pd->mp_stream.state = MPS_WAITING_FOR_BOUNDARY; - break; - } - case MPS_WAITING_FOR_BOUNDARY: { - if (mg_http_multipart_wait_for_boundary(c) == 0) { - return; - } - break; - } - case MPS_GOT_BOUNDARY: { - if (mg_http_multipart_process_boundary(c) == 0) { - return; - } - break; - } - case MPS_WAITING_FOR_CHUNK: { - if (mg_http_multipart_continue_wait_for_chunk(c) == 0) { - return; - } - break; - } - case MPS_GOT_CHUNK: { - if (mg_http_multipart_got_chunk(c) == 0) { - return; - } - break; - } - case MPS_FINALIZE: { - if (mg_http_multipart_finalize(c) == 0) { - return; - } - break; - } - case MPS_FINISHED: { - mbuf_remove(&c->recv_mbuf, c->recv_mbuf.len); - return; - } - } - } -} - -struct file_upload_state { - char *lfn; - size_t num_recd; - FILE *fp; -}; - -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */ - -void mg_set_protocol_http_websocket(struct mg_connection *nc) { - nc->proto_handler = mg_http_handler; -} - -const char *mg_status_message(int status_code) { - switch (status_code) { - case 206: - return "Partial Content"; - case 301: - return "Moved"; - case 302: - return "Found"; - case 400: - return "Bad Request"; - case 401: - return "Unauthorized"; - case 403: - return "Forbidden"; - case 404: - return "Not Found"; - case 416: - return "Requested Range Not Satisfiable"; - case 418: - return "I'm a teapot"; - case 500: - return "Internal Server Error"; - case 502: - return "Bad Gateway"; - case 503: - return "Service Unavailable"; - -#if MG_ENABLE_EXTRA_ERRORS_DESC - case 100: - return "Continue"; - case 101: - return "Switching Protocols"; - case 102: - return "Processing"; - case 200: - return "OK"; - case 201: - return "Created"; - case 202: - return "Accepted"; - case 203: - return "Non-Authoritative Information"; - case 204: - return "No Content"; - case 205: - return "Reset Content"; - case 207: - return "Multi-Status"; - case 208: - return "Already Reported"; - case 226: - return "IM Used"; - case 300: - return "Multiple Choices"; - case 303: - return "See Other"; - case 304: - return "Not Modified"; - case 305: - return "Use Proxy"; - case 306: - return "Switch Proxy"; - case 307: - return "Temporary Redirect"; - case 308: - return "Permanent Redirect"; - case 402: - return "Payment Required"; - case 405: - return "Method Not Allowed"; - case 406: - return "Not Acceptable"; - case 407: - return "Proxy Authentication Required"; - case 408: - return "Request Timeout"; - case 409: - return "Conflict"; - case 410: - return "Gone"; - case 411: - return "Length Required"; - case 412: - return "Precondition Failed"; - case 413: - return "Payload Too Large"; - case 414: - return "URI Too Long"; - case 415: - return "Unsupported Media Type"; - case 417: - return "Expectation Failed"; - case 422: - return "Unprocessable Entity"; - case 423: - return "Locked"; - case 424: - return "Failed Dependency"; - case 426: - return "Upgrade Required"; - case 428: - return "Precondition Required"; - case 429: - return "Too Many Requests"; - case 431: - return "Request Header Fields Too Large"; - case 451: - return "Unavailable For Legal Reasons"; - case 501: - return "Not Implemented"; - case 504: - return "Gateway Timeout"; - case 505: - return "HTTP Version Not Supported"; - case 506: - return "Variant Also Negotiates"; - case 507: - return "Insufficient Storage"; - case 508: - return "Loop Detected"; - case 510: - return "Not Extended"; - case 511: - return "Network Authentication Required"; -#endif /* MG_ENABLE_EXTRA_ERRORS_DESC */ - - default: - return "OK"; - } -} - -void mg_send_response_line_s(struct mg_connection *nc, int status_code, - const struct mg_str extra_headers) { - mg_printf(nc, "HTTP/1.1 %d %s\r\nServer: %s\r\n", status_code, - mg_status_message(status_code), mg_version_header); - if (extra_headers.len > 0) { - mg_printf(nc, "%.*s\r\n", (int) extra_headers.len, extra_headers.p); - } -} - -void mg_send_response_line(struct mg_connection *nc, int status_code, - const char *extra_headers) { - mg_send_response_line_s(nc, status_code, mg_mk_str(extra_headers)); -} - -void mg_http_send_redirect(struct mg_connection *nc, int status_code, - const struct mg_str location, - const struct mg_str extra_headers) { - char bbody[100], *pbody = bbody; - int bl = mg_asprintf(&pbody, sizeof(bbody), - "

Moved here.\r\n", - (int) location.len, location.p); - char bhead[150], *phead = bhead; - mg_asprintf(&phead, sizeof(bhead), - "Location: %.*s\r\n" - "Content-Type: text/html\r\n" - "Content-Length: %d\r\n" - "Cache-Control: no-cache\r\n" - "%.*s%s", - (int) location.len, location.p, bl, (int) extra_headers.len, - extra_headers.p, (extra_headers.len > 0 ? "\r\n" : "")); - mg_send_response_line(nc, status_code, phead); - if (phead != bhead) MG_FREE(phead); - mg_send(nc, pbody, bl); - if (pbody != bbody) MG_FREE(pbody); -} - -void mg_send_head(struct mg_connection *c, int status_code, - int64_t content_length, const char *extra_headers) { - mg_send_response_line(c, status_code, extra_headers); - if (content_length < 0) { - mg_printf(c, "%s", "Transfer-Encoding: chunked\r\n"); - } else { - mg_printf(c, "Content-Length: %" INT64_FMT "\r\n", content_length); - } - mg_send(c, "\r\n", 2); -} - -void mg_http_send_error(struct mg_connection *nc, int code, - const char *reason) { - if (!reason) reason = mg_status_message(code); - LOG(LL_DEBUG, ("%p %d %s", nc, code, reason)); - mg_send_head(nc, code, strlen(reason), - "Content-Type: text/plain\r\nConnection: close"); - mg_send(nc, reason, strlen(reason)); - nc->flags |= MG_F_SEND_AND_CLOSE; -} - -#if MG_ENABLE_FILESYSTEM -static void mg_http_construct_etag(char *buf, size_t buf_len, - const cs_stat_t *st) { - snprintf(buf, buf_len, "\"%lx.%" INT64_FMT "\"", (unsigned long) st->st_mtime, - (int64_t) st->st_size); -} - -#ifndef WINCE -static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t) { - strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", gmtime(t)); -} -#else -/* Look wince_lib.c for WindowsCE implementation */ -static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t); -#endif - -static int mg_http_parse_range_header(const struct mg_str *header, int64_t *a, - int64_t *b) { - /* - * There is no snscanf. Headers are not guaranteed to be NUL-terminated, - * so we have this. Ugh. - */ - int result; - char *p = (char *) MG_MALLOC(header->len + 1); - if (p == NULL) return 0; - memcpy(p, header->p, header->len); - p[header->len] = '\0'; - result = sscanf(p, "bytes=%" INT64_FMT "-%" INT64_FMT, a, b); - MG_FREE(p); - return result; -} - -void mg_http_serve_file(struct mg_connection *nc, struct http_message *hm, - const char *path, const struct mg_str mime_type, - const struct mg_str extra_headers) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - cs_stat_t st; - LOG(LL_DEBUG, ("%p [%s] %.*s", nc, path, (int) mime_type.len, mime_type.p)); - if (mg_stat(path, &st) != 0 || (pd->file.fp = mg_fopen(path, "rb")) == NULL) { - int code, err = mg_get_errno(); - switch (err) { - case EACCES: - code = 403; - break; - case ENOENT: - code = 404; - break; - default: - code = 500; - }; - mg_http_send_error(nc, code, "Open failed"); - } else { - char etag[50], current_time[50], last_modified[50], range[70]; - time_t t = (time_t) mg_time(); - int64_t r1 = 0, r2 = 0, cl = st.st_size; - struct mg_str *range_hdr = mg_get_http_header(hm, "Range"); - int n, status_code = 200; - - /* Handle Range header */ - range[0] = '\0'; - if (range_hdr != NULL && - (n = mg_http_parse_range_header(range_hdr, &r1, &r2)) > 0 && r1 >= 0 && - r2 >= 0) { - /* If range is specified like "400-", set second limit to content len */ - if (n == 1) { - r2 = cl - 1; - } - if (r1 > r2 || r2 >= cl) { - status_code = 416; - cl = 0; - snprintf(range, sizeof(range), - "Content-Range: bytes */%" INT64_FMT "\r\n", - (int64_t) st.st_size); - } else { - status_code = 206; - cl = r2 - r1 + 1; - snprintf(range, sizeof(range), "Content-Range: bytes %" INT64_FMT - "-%" INT64_FMT "/%" INT64_FMT "\r\n", - r1, r1 + cl - 1, (int64_t) st.st_size); -#if _FILE_OFFSET_BITS == 64 || _POSIX_C_SOURCE >= 200112L || \ - _XOPEN_SOURCE >= 600 - fseeko(pd->file.fp, r1, SEEK_SET); -#else - fseek(pd->file.fp, (long) r1, SEEK_SET); -#endif - } - } - -#if !MG_DISABLE_HTTP_KEEP_ALIVE - { - struct mg_str *conn_hdr = mg_get_http_header(hm, "Connection"); - if (conn_hdr != NULL) { - pd->file.keepalive = (mg_vcasecmp(conn_hdr, "keep-alive") == 0); - } else { - pd->file.keepalive = (mg_vcmp(&hm->proto, "HTTP/1.1") == 0); - } - } -#endif - - mg_http_construct_etag(etag, sizeof(etag), &st); - mg_gmt_time_string(current_time, sizeof(current_time), &t); - mg_gmt_time_string(last_modified, sizeof(last_modified), &st.st_mtime); - /* - * Content length casted to size_t because: - * 1) that's the maximum buffer size anyway - * 2) ESP8266 RTOS SDK newlib vprintf cannot contain a 64bit arg at non-last - * position - * TODO(mkm): fix ESP8266 RTOS SDK - */ - mg_send_response_line_s(nc, status_code, extra_headers); - mg_printf(nc, - "Date: %s\r\n" - "Last-Modified: %s\r\n" - "Accept-Ranges: bytes\r\n" - "Content-Type: %.*s\r\n" - "Connection: %s\r\n" - "Content-Length: %" SIZE_T_FMT - "\r\n" - "%sEtag: %s\r\n\r\n", - current_time, last_modified, (int) mime_type.len, mime_type.p, - (pd->file.keepalive ? "keep-alive" : "close"), (size_t) cl, range, - etag); - - pd->file.cl = cl; - pd->file.type = DATA_FILE; - mg_http_transfer_file_data(nc); - } -} - -static void mg_http_serve_file2(struct mg_connection *nc, const char *path, - struct http_message *hm, - struct mg_serve_http_opts *opts) { -#if MG_ENABLE_HTTP_SSI - if (mg_match_prefix(opts->ssi_pattern, strlen(opts->ssi_pattern), path) > 0) { - mg_handle_ssi_request(nc, hm, path, opts); - return; - } -#endif - mg_http_serve_file(nc, hm, path, mg_get_mime_type(path, "text/plain", opts), - mg_mk_str(opts->extra_headers)); -} - -#endif - -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 (src[i] == '%') { - if (i < src_len - 2 && isxdigit(*(const unsigned char *) (src + i + 1)) && - isxdigit(*(const unsigned char *) (src + i + 2))) { - a = tolower(*(const unsigned char *) (src + i + 1)); - b = tolower(*(const unsigned char *) (src + i + 2)); - dst[j] = (char) ((HEXTOI(a) << 4) | HEXTOI(b)); - i += 2; - } else { - return -1; - } - } 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_http_var(const struct mg_str *buf, const char *name, char *dst, - size_t dst_len) { - const char *p, *e, *s; - size_t name_len; - int len; - - if (dst == NULL || dst_len == 0) { - len = -2; - } else if (buf->p == NULL || name == NULL || buf->len == 0) { - len = -1; - dst[0] = '\0'; - } else { - name_len = strlen(name); - e = buf->p + buf->len; - len = -1; - dst[0] = '\0'; - - for (p = buf->p; p + name_len < e; p++) { - if ((p == buf->p || p[-1] == '&') && p[name_len] == '=' && - !mg_ncasecmp(name, p, name_len)) { - p += name_len + 1; - s = (const char *) memchr(p, '&', (size_t)(e - p)); - if (s == NULL) { - s = e; - } - len = mg_url_decode(p, (size_t)(s - p), dst, dst_len, 1); - if (len == -1) { - len = -2; - } - break; - } - } - } - - return len; -} - -void mg_send_http_chunk(struct mg_connection *nc, const char *buf, size_t len) { - char chunk_size[50]; - int n; - - n = snprintf(chunk_size, sizeof(chunk_size), "%lX\r\n", (unsigned long) len); - mg_send(nc, chunk_size, n); - mg_send(nc, buf, len); - mg_send(nc, "\r\n", 2); -} - -void mg_printf_http_chunk(struct mg_connection *nc, const char *fmt, ...) { - char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem; - int len; - va_list ap; - - va_start(ap, fmt); - len = mg_avprintf(&buf, sizeof(mem), fmt, ap); - va_end(ap); - - if (len >= 0) { - mg_send_http_chunk(nc, buf, len); - } - - /* LCOV_EXCL_START */ - if (buf != mem && buf != NULL) { - MG_FREE(buf); - } - /* LCOV_EXCL_STOP */ -} - -void mg_printf_html_escape(struct mg_connection *nc, const char *fmt, ...) { - char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem; - int i, j, len; - va_list ap; - - va_start(ap, fmt); - len = mg_avprintf(&buf, sizeof(mem), fmt, ap); - va_end(ap); - - if (len >= 0) { - for (i = j = 0; i < len; i++) { - if (buf[i] == '<' || buf[i] == '>') { - mg_send(nc, buf + j, i - j); - mg_send(nc, buf[i] == '<' ? "<" : ">", 4); - j = i + 1; - } - } - mg_send(nc, buf + j, i - j); - } - - /* LCOV_EXCL_START */ - if (buf != mem && buf != NULL) { - MG_FREE(buf); - } - /* LCOV_EXCL_STOP */ -} - -int mg_http_parse_header(struct mg_str *hdr, const char *var_name, char *buf, - size_t buf_size) { - int ch = ' ', ch1 = ',', len = 0, n = strlen(var_name); - const char *p, *end = hdr ? hdr->p + hdr->len : NULL, *s = NULL; - - if (buf != NULL && buf_size > 0) buf[0] = '\0'; - if (hdr == NULL) return 0; - - /* Find where variable starts */ - for (s = hdr->p; s != NULL && s + n < end; s++) { - if ((s == hdr->p || s[-1] == ch || s[-1] == ch1) && s[n] == '=' && - !strncmp(s, var_name, n)) - break; - } - - if (s != NULL && &s[n + 1] < end) { - s += n + 1; - if (*s == '"' || *s == '\'') { - ch = ch1 = *s++; - } - p = s; - while (p < end && p[0] != ch && p[0] != ch1 && len < (int) buf_size) { - if (ch != ' ' && p[0] == '\\' && p[1] == ch) p++; - buf[len++] = *p++; - } - if (len >= (int) buf_size || (ch != ' ' && *p != ch)) { - len = 0; - } else { - if (len > 0 && s[len - 1] == ',') len--; - if (len > 0 && s[len - 1] == ';') len--; - buf[len] = '\0'; - } - } - - return len; -} - -int mg_get_http_basic_auth(struct http_message *hm, char *user, size_t user_len, - char *pass, size_t pass_len) { - struct mg_str *hdr = mg_get_http_header(hm, "Authorization"); - if (hdr == NULL) return -1; - return mg_parse_http_basic_auth(hdr, user, user_len, pass, pass_len); -} - -int mg_parse_http_basic_auth(struct mg_str *hdr, char *user, size_t user_len, - char *pass, size_t pass_len) { - char *buf = NULL; - char fmt[64]; - int res = 0; - - if (mg_strncmp(*hdr, mg_mk_str("Basic "), 6) != 0) return -1; - - buf = (char *) MG_MALLOC(hdr->len); - cs_base64_decode((unsigned char *) hdr->p + 6, hdr->len, buf, NULL); - - /* e.g. "%123[^:]:%321[^\n]" */ - snprintf(fmt, sizeof(fmt), "%%%" SIZE_T_FMT "[^:]:%%%" SIZE_T_FMT "[^\n]", - user_len - 1, pass_len - 1); - if (sscanf(buf, fmt, user, pass) == 0) { - res = -1; - } - - MG_FREE(buf); - return res; -} - -#if MG_ENABLE_FILESYSTEM -static int mg_is_file_hidden(const char *path, - const struct mg_serve_http_opts *opts, - int exclude_specials) { - const char *p1 = opts->per_directory_auth_file; - const char *p2 = opts->hidden_file_pattern; - - /* Strip directory path from the file name */ - const char *pdir = strrchr(path, DIRSEP); - if (pdir != NULL) { - path = pdir + 1; - } - - return (exclude_specials && (!strcmp(path, ".") || !strcmp(path, ".."))) || - (p1 != NULL && - mg_match_prefix(p1, strlen(p1), path) == (int) strlen(p1)) || - (p2 != NULL && mg_match_prefix(p2, strlen(p2), path) > 0); -} - -#if !MG_DISABLE_HTTP_DIGEST_AUTH -static void mg_mkmd5resp(const char *method, size_t method_len, const char *uri, - size_t uri_len, const char *ha1, size_t ha1_len, - const char *nonce, size_t nonce_len, const char *nc, - size_t nc_len, const char *cnonce, size_t cnonce_len, - const char *qop, size_t qop_len, char *resp) { - static const char colon[] = ":"; - static const size_t one = 1; - char ha2[33]; - - cs_md5(ha2, method, method_len, colon, one, uri, uri_len, NULL); - cs_md5(resp, ha1, ha1_len, colon, one, nonce, nonce_len, colon, one, nc, - nc_len, colon, one, cnonce, cnonce_len, colon, one, qop, qop_len, - colon, one, ha2, sizeof(ha2) - 1, NULL); -} - -int mg_http_create_digest_auth_header(char *buf, size_t buf_len, - const char *method, const char *uri, - const char *auth_domain, const char *user, - const char *passwd) { - static const char colon[] = ":", qop[] = "auth"; - static const size_t one = 1; - char ha1[33], resp[33], cnonce[40]; - - snprintf(cnonce, sizeof(cnonce), "%x", (unsigned int) mg_time()); - cs_md5(ha1, user, (size_t) strlen(user), colon, one, auth_domain, - (size_t) strlen(auth_domain), colon, one, passwd, - (size_t) strlen(passwd), NULL); - mg_mkmd5resp(method, strlen(method), uri, strlen(uri), ha1, sizeof(ha1) - 1, - cnonce, strlen(cnonce), "1", one, cnonce, strlen(cnonce), qop, - sizeof(qop) - 1, resp); - return snprintf(buf, buf_len, - "Authorization: Digest username=\"%s\"," - "realm=\"%s\",uri=\"%s\",qop=%s,nc=1,cnonce=%s," - "nonce=%s,response=%s\r\n", - user, auth_domain, uri, qop, cnonce, cnonce, resp); -} - -/* - * Check for authentication timeout. - * Clients send time stamp encoded in nonce. Make sure it is not too old, - * to prevent replay attacks. - * Assumption: nonce is a hexadecimal number of seconds since 1970. - */ -static int mg_check_nonce(const char *nonce) { - unsigned long now = (unsigned long) mg_time(); - unsigned long val = (unsigned long) strtoul(nonce, NULL, 16); - return now < val || now - val < 3600; -} - -int mg_http_check_digest_auth(struct http_message *hm, const char *auth_domain, - FILE *fp) { - struct mg_str *hdr; - char buf[128], f_user[sizeof(buf)], f_ha1[sizeof(buf)], f_domain[sizeof(buf)]; - char user[50], cnonce[33], response[40], uri[200], qop[20], nc[20], nonce[30]; - char expected_response[33]; - - /* Parse "Authorization:" header, fail fast on parse error */ - if (hm == NULL || fp == NULL || - (hdr = mg_get_http_header(hm, "Authorization")) == NULL || - mg_http_parse_header(hdr, "username", user, sizeof(user)) == 0 || - mg_http_parse_header(hdr, "cnonce", cnonce, sizeof(cnonce)) == 0 || - mg_http_parse_header(hdr, "response", response, sizeof(response)) == 0 || - mg_http_parse_header(hdr, "uri", uri, sizeof(uri)) == 0 || - mg_http_parse_header(hdr, "qop", qop, sizeof(qop)) == 0 || - mg_http_parse_header(hdr, "nc", nc, sizeof(nc)) == 0 || - mg_http_parse_header(hdr, "nonce", nonce, sizeof(nonce)) == 0 || - mg_check_nonce(nonce) == 0) { - return 0; - } - - /* - * Read passwords file line by line. If should have htdigest format, - * i.e. each line should be a colon-separated sequence: - * USER_NAME:DOMAIN_NAME:HA1_HASH_OF_USER_DOMAIN_AND_PASSWORD - */ - while (fgets(buf, sizeof(buf), fp) != NULL) { - if (sscanf(buf, "%[^:]:%[^:]:%s", f_user, f_domain, f_ha1) == 3 && - strcmp(user, f_user) == 0 && - /* NOTE(lsm): due to a bug in MSIE, we do not compare URIs */ - strcmp(auth_domain, f_domain) == 0) { - /* User and domain matched, check the password */ - mg_mkmd5resp( - hm->method.p, hm->method.len, hm->uri.p, - hm->uri.len + (hm->query_string.len ? hm->query_string.len + 1 : 0), - f_ha1, strlen(f_ha1), nonce, strlen(nonce), nc, strlen(nc), cnonce, - strlen(cnonce), qop, strlen(qop), expected_response); - return mg_casecmp(response, expected_response) == 0; - } - } - - /* None of the entries in the passwords file matched - return failure */ - return 0; -} - -static int mg_is_authorized(struct http_message *hm, const char *path, - int is_directory, const char *domain, - const char *passwords_file, - int is_global_pass_file) { - char buf[MG_MAX_PATH]; - const char *p; - FILE *fp; - int authorized = 1; - - if (domain != NULL && passwords_file != NULL) { - if (is_global_pass_file) { - fp = mg_fopen(passwords_file, "r"); - } else if (is_directory) { - snprintf(buf, sizeof(buf), "%s%c%s", path, DIRSEP, passwords_file); - fp = mg_fopen(buf, "r"); - } else { - p = strrchr(path, DIRSEP); - if (p == NULL) p = path; - snprintf(buf, sizeof(buf), "%.*s%c%s", (int) (p - path), path, DIRSEP, - passwords_file); - fp = mg_fopen(buf, "r"); - } - - if (fp != NULL) { - authorized = mg_http_check_digest_auth(hm, domain, fp); - fclose(fp); - } - } - - LOG(LL_DEBUG, ("%s '%s' %d %d", path, passwords_file ? passwords_file : "", - is_global_pass_file, authorized)); - return authorized; -} -#else -static int mg_is_authorized(struct http_message *hm, const char *path, - int is_directory, const char *domain, - const char *passwords_file, - int is_global_pass_file) { - (void) hm; - (void) path; - (void) is_directory; - (void) domain; - (void) passwords_file; - (void) is_global_pass_file; - return 1; -} -#endif - -#if MG_ENABLE_DIRECTORY_LISTING -static size_t mg_url_encode(const char *src, size_t s_len, char *dst, - size_t dst_len) { - static const char *dont_escape = "._-$,;~()/"; - static const char *hex = "0123456789abcdef"; - size_t i = 0, j = 0; - - for (i = j = 0; dst_len > 0 && i < s_len && j + 2 < dst_len - 1; i++, j++) { - if (isalnum(*(const unsigned char *) (src + i)) || - strchr(dont_escape, *(const unsigned char *) (src + i)) != NULL) { - dst[j] = src[i]; - } else if (j + 3 < dst_len) { - dst[j] = '%'; - dst[j + 1] = hex[(*(const unsigned char *) (src + i)) >> 4]; - dst[j + 2] = hex[(*(const unsigned char *) (src + i)) & 0xf]; - j += 2; - } - } - - dst[j] = '\0'; - return j; -} - -static void mg_escape(const char *src, char *dst, size_t dst_len) { - size_t n = 0; - while (*src != '\0' && n + 5 < dst_len) { - unsigned char ch = *(unsigned char *) src++; - if (ch == '<') { - n += snprintf(dst + n, dst_len - n, "%s", "<"); - } else { - dst[n++] = ch; - } - } - dst[n] = '\0'; -} - -static void mg_print_dir_entry(struct mg_connection *nc, const char *file_name, - cs_stat_t *stp) { - char size[64], mod[64], href[MAX_PATH_SIZE * 3], path[MAX_PATH_SIZE]; - int64_t fsize = stp->st_size; - int is_dir = S_ISDIR(stp->st_mode); - const char *slash = is_dir ? "/" : ""; - - if (is_dir) { - snprintf(size, sizeof(size), "%s", "[DIRECTORY]"); - } else { - /* - * We use (double) cast below because MSVC 6 compiler cannot - * convert unsigned __int64 to double. - */ - if (fsize < 1024) { - snprintf(size, sizeof(size), "%d", (int) fsize); - } else if (fsize < 0x100000) { - snprintf(size, sizeof(size), "%.1fk", (double) fsize / 1024.0); - } else if (fsize < 0x40000000) { - snprintf(size, sizeof(size), "%.1fM", (double) fsize / 1048576); - } else { - snprintf(size, sizeof(size), "%.1fG", (double) fsize / 1073741824); - } - } - strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime(&stp->st_mtime)); - mg_escape(file_name, path, sizeof(path)); - mg_url_encode(file_name, strlen(file_name), href, sizeof(href)); - mg_printf_http_chunk(nc, - "%s%s" - "%s%s\n", - href, slash, path, slash, mod, is_dir ? -1 : fsize, - size); -} - -static void mg_scan_directory(struct mg_connection *nc, const char *dir, - const struct mg_serve_http_opts *opts, - void (*func)(struct mg_connection *, const char *, - cs_stat_t *)) { - char path[MAX_PATH_SIZE]; - cs_stat_t st; - struct dirent *dp; - DIR *dirp; - - LOG(LL_DEBUG, ("%p [%s]", nc, dir)); - if ((dirp = (opendir(dir))) != NULL) { - while ((dp = readdir(dirp)) != NULL) { - /* Do not show current dir and hidden files */ - if (mg_is_file_hidden((const char *) dp->d_name, opts, 1)) { - continue; - } - snprintf(path, sizeof(path), "%s/%s", dir, dp->d_name); - if (mg_stat(path, &st) == 0) { - func(nc, (const char *) dp->d_name, &st); - } - } - closedir(dirp); - } else { - LOG(LL_DEBUG, ("%p opendir(%s) -> %d", nc, dir, mg_get_errno())); - } -} - -static void mg_send_directory_listing(struct mg_connection *nc, const char *dir, - struct http_message *hm, - struct mg_serve_http_opts *opts) { - static const char *sort_js_code = - ""; - - mg_send_response_line(nc, 200, opts->extra_headers); - mg_printf(nc, "%s: %s\r\n%s: %s\r\n\r\n", "Transfer-Encoding", "chunked", - "Content-Type", "text/html; charset=utf-8"); - - mg_printf_http_chunk( - nc, - "Index of %.*s%s%s" - "\n" - "

Index of %.*s

\n" - "" - "\n" - "\n" - "", - (int) hm->uri.len, hm->uri.p, sort_js_code, sort_js_code2, - (int) hm->uri.len, hm->uri.p); - mg_scan_directory(nc, dir, opts, mg_print_dir_entry); - mg_printf_http_chunk(nc, - "\n" - "
Name" - "Modified" - "Size
\n" - "
%s
\n" - "", - mg_version_header); - mg_send_http_chunk(nc, "", 0); - /* TODO(rojer): Remove when cesanta/dev/issues/197 is fixed. */ - nc->flags |= MG_F_SEND_AND_CLOSE; -} -#endif /* MG_ENABLE_DIRECTORY_LISTING */ - -/* - * Given a directory path, find one of the files specified in the - * comma-separated list of index files `list`. - * First found index file wins. If an index file is found, then gets - * appended to the `path`, stat-ed, and result of `stat()` passed to `stp`. - * If index file is not found, then `path` and `stp` remain unchanged. - */ -MG_INTERNAL void mg_find_index_file(const char *path, const char *list, - char **index_file, cs_stat_t *stp) { - struct mg_str vec; - size_t path_len = strlen(path); - int found = 0; - *index_file = NULL; - - /* 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 = mg_next_comma_list_entry(list, &vec, NULL)) != NULL) { - cs_stat_t st; - size_t len = path_len + 1 + vec.len + 1; - *index_file = (char *) MG_REALLOC(*index_file, len); - if (*index_file == NULL) break; - snprintf(*index_file, len, "%s%c%.*s", path, DIRSEP, (int) vec.len, vec.p); - - /* Does it exist? Is it a file? */ - if (mg_stat(*index_file, &st) == 0 && S_ISREG(st.st_mode)) { - /* Yes it does, break the loop */ - *stp = st; - found = 1; - break; - } - } - if (!found) { - MG_FREE(*index_file); - *index_file = NULL; - } - LOG(LL_DEBUG, ("[%s] [%s]", path, (*index_file ? *index_file : ""))); -} - -#if MG_ENABLE_HTTP_URL_REWRITES -static int mg_http_send_port_based_redirect( - struct mg_connection *c, struct http_message *hm, - const struct mg_serve_http_opts *opts) { - const char *rewrites = opts->url_rewrites; - struct mg_str a, b; - char local_port[20] = {'%'}; - - mg_conn_addr_to_str(c, local_port + 1, sizeof(local_port) - 1, - MG_SOCK_STRINGIFY_PORT); - - while ((rewrites = mg_next_comma_list_entry(rewrites, &a, &b)) != NULL) { - if (mg_vcmp(&a, local_port) == 0) { - mg_send_response_line(c, 301, NULL); - mg_printf(c, "Content-Length: 0\r\nLocation: %.*s%.*s\r\n\r\n", - (int) b.len, b.p, (int) (hm->proto.p - hm->uri.p - 1), - hm->uri.p); - return 1; - } - } - - return 0; -} - -static void mg_reverse_proxy_handler(struct mg_connection *nc, int ev, - void *ev_data) { - struct http_message *hm = (struct http_message *) ev_data; - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - - if (pd == NULL || pd->reverse_proxy_data.linked_conn == NULL) { - DBG(("%p: upstream closed", nc)); - return; - } - - switch (ev) { - case MG_EV_CONNECT: - if (*(int *) ev_data != 0) { - mg_http_send_error(pd->reverse_proxy_data.linked_conn, 502, NULL); - } - break; - /* TODO(mkm): handle streaming */ - case MG_EV_HTTP_REPLY: - mg_send(pd->reverse_proxy_data.linked_conn, hm->message.p, - hm->message.len); - pd->reverse_proxy_data.linked_conn->flags |= MG_F_SEND_AND_CLOSE; - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - break; - case MG_EV_CLOSE: - pd->reverse_proxy_data.linked_conn->flags |= MG_F_SEND_AND_CLOSE; - break; - } -} - -void mg_http_reverse_proxy(struct mg_connection *nc, - const struct http_message *hm, struct mg_str mount, - struct mg_str upstream) { - struct mg_connection *be; - char burl[256], *purl = burl; - char *addr = NULL; - const char *path = NULL; - int i; - const char *error; - struct mg_connect_opts opts; - memset(&opts, 0, sizeof(opts)); - opts.error_string = &error; - - mg_asprintf(&purl, sizeof(burl), "%.*s%.*s", (int) upstream.len, upstream.p, - (int) (hm->uri.len - mount.len), hm->uri.p + mount.len); - - be = mg_connect_http_base(nc->mgr, mg_reverse_proxy_handler, opts, "http://", - "https://", purl, &path, NULL /* user */, - NULL /* pass */, &addr); - LOG(LL_DEBUG, ("Proxying %.*s to %s (rule: %.*s)", (int) hm->uri.len, - hm->uri.p, purl, (int) mount.len, mount.p)); - - if (be == NULL) { - LOG(LL_ERROR, ("Error connecting to %s: %s", purl, error)); - mg_http_send_error(nc, 502, NULL); - goto cleanup; - } - - /* link connections to each other, they must live and die together */ - mg_http_get_proto_data(be)->reverse_proxy_data.linked_conn = nc; - mg_http_get_proto_data(nc)->reverse_proxy_data.linked_conn = be; - - /* send request upstream */ - mg_printf(be, "%.*s %s HTTP/1.1\r\n", (int) hm->method.len, hm->method.p, - path); - - mg_printf(be, "Host: %s\r\n", addr); - for (i = 0; i < MG_MAX_HTTP_HEADERS && hm->header_names[i].len > 0; i++) { - struct mg_str hn = hm->header_names[i]; - struct mg_str hv = hm->header_values[i]; - - /* we rewrite the host header */ - if (mg_vcasecmp(&hn, "Host") == 0) continue; - /* - * Don't pass chunked transfer encoding to the client because hm->body is - * already dechunked when we arrive here. - */ - if (mg_vcasecmp(&hn, "Transfer-encoding") == 0 && - mg_vcasecmp(&hv, "chunked") == 0) { - mg_printf(be, "Content-Length: %" SIZE_T_FMT "\r\n", hm->body.len); - continue; - } - /* We don't support proxying Expect: 100-continue. */ - if (mg_vcasecmp(&hn, "Expect") == 0 && - mg_vcasecmp(&hv, "100-continue") == 0) { - continue; - } - - mg_printf(be, "%.*s: %.*s\r\n", (int) hn.len, hn.p, (int) hv.len, hv.p); - } - - mg_send(be, "\r\n", 2); - mg_send(be, hm->body.p, hm->body.len); - -cleanup: - if (purl != burl) MG_FREE(purl); -} - -static int mg_http_handle_forwarding(struct mg_connection *nc, - struct http_message *hm, - const struct mg_serve_http_opts *opts) { - const char *rewrites = opts->url_rewrites; - struct mg_str a, b; - struct mg_str p1 = MG_MK_STR("http://"), p2 = MG_MK_STR("https://"); - - while ((rewrites = mg_next_comma_list_entry(rewrites, &a, &b)) != NULL) { - if (mg_strncmp(a, hm->uri, a.len) == 0) { - if (mg_strncmp(b, p1, p1.len) == 0 || mg_strncmp(b, p2, p2.len) == 0) { - mg_http_reverse_proxy(nc, hm, a, b); - return 1; - } - } - } - - return 0; -} -#endif - -MG_INTERNAL int mg_uri_to_local_path(struct http_message *hm, - const struct mg_serve_http_opts *opts, - char **local_path, - struct mg_str *remainder) { - int ok = 1; - const char *cp = hm->uri.p, *cp_end = hm->uri.p + hm->uri.len; - struct mg_str root = {NULL, 0}; - const char *file_uri_start = cp; - *local_path = NULL; - remainder->p = NULL; - remainder->len = 0; - - { /* 1. Determine which root to use. */ - -#if MG_ENABLE_HTTP_URL_REWRITES - const char *rewrites = opts->url_rewrites; -#else - const char *rewrites = ""; -#endif - struct mg_str *hh = mg_get_http_header(hm, "Host"); - struct mg_str a, b; - /* Check rewrites first. */ - while ((rewrites = mg_next_comma_list_entry(rewrites, &a, &b)) != NULL) { - if (a.len > 1 && a.p[0] == '@') { - /* Host rewrite. */ - if (hh != NULL && hh->len == a.len - 1 && - mg_ncasecmp(a.p + 1, hh->p, a.len - 1) == 0) { - root = b; - break; - } - } else { - /* Regular rewrite, URI=directory */ - int match_len = mg_match_prefix_n(a, hm->uri); - if (match_len > 0) { - file_uri_start = hm->uri.p + match_len; - if (*file_uri_start == '/' || file_uri_start == cp_end) { - /* Match ended at component boundary, ok. */ - } else if (*(file_uri_start - 1) == '/') { - /* Pattern ends with '/', backtrack. */ - file_uri_start--; - } else { - /* No match: must fall on the component boundary. */ - continue; - } - root = b; - break; - } - } - } - /* If no rewrite rules matched, use DAV or regular document root. */ - if (root.p == NULL) { -#if MG_ENABLE_HTTP_WEBDAV - if (opts->dav_document_root != NULL && mg_is_dav_request(&hm->method)) { - root.p = opts->dav_document_root; - root.len = strlen(opts->dav_document_root); - } else -#endif - { - root.p = opts->document_root; - root.len = strlen(opts->document_root); - } - } - assert(root.p != NULL && root.len > 0); - } - - { /* 2. Find where in the canonical URI path the local path ends. */ - const char *u = file_uri_start + 1; - char *lp = (char *) MG_MALLOC(root.len + hm->uri.len + 1); - char *lp_end = lp + root.len + hm->uri.len + 1; - char *p = lp, *ps; - int exists = 1; - if (lp == NULL) { - ok = 0; - goto out; - } - memcpy(p, root.p, root.len); - p += root.len; - if (*(p - 1) == DIRSEP) p--; - *p = '\0'; - ps = p; - - /* Chop off URI path components one by one and build local path. */ - while (u <= cp_end) { - const char *next = u; - struct mg_str component; - if (exists) { - cs_stat_t st; - exists = (mg_stat(lp, &st) == 0); - if (exists && S_ISREG(st.st_mode)) { - /* We found the terminal, the rest of the URI (if any) is path_info. - */ - if (*(u - 1) == '/') u--; - break; - } - } - if (u >= cp_end) break; - parse_uri_component((const char **) &next, cp_end, '/', &component); - if (component.len > 0) { - int len; - memmove(p + 1, component.p, component.len); - len = mg_url_decode(p + 1, component.len, p + 1, lp_end - p - 1, 0); - if (len <= 0) { - ok = 0; - break; - } - component.p = p + 1; - component.len = len; - if (mg_vcmp(&component, ".") == 0) { - /* Yum. */ - } else if (mg_vcmp(&component, "..") == 0) { - while (p > ps && *p != DIRSEP) p--; - *p = '\0'; - } else { - size_t i; -#ifdef _WIN32 - /* On Windows, make sure it's valid Unicode (no funny stuff). */ - wchar_t buf[MG_MAX_PATH * 2]; - if (to_wchar(component.p, buf, MG_MAX_PATH) == 0) { - DBG(("[%.*s] smells funny", (int) component.len, component.p)); - ok = 0; - break; - } -#endif - *p++ = DIRSEP; - /* No NULs and DIRSEPs in the component (percent-encoded). */ - for (i = 0; i < component.len; i++, p++) { - if (*p == '\0' || *p == DIRSEP -#ifdef _WIN32 - /* On Windows, "/" is also accepted, so check for that too. */ - || - *p == '/' -#endif - ) { - ok = 0; - break; - } - } - } - } - u = next; - } - if (ok) { - *local_path = lp; - if (u > cp_end) u = cp_end; - remainder->p = u; - remainder->len = cp_end - u; - } else { - MG_FREE(lp); - } - } - -out: - LOG(LL_DEBUG, - ("'%.*s' -> '%s' + '%.*s'", (int) hm->uri.len, hm->uri.p, - *local_path ? *local_path : "", (int) remainder->len, remainder->p)); - return ok; -} - -static int mg_get_month_index(const char *s) { - static const char *month_names[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", - "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; - size_t i; - - for (i = 0; i < ARRAY_SIZE(month_names); i++) - if (!strcmp(s, month_names[i])) return (int) i; - - return -1; -} - -static int mg_num_leap_years(int year) { - return year / 4 - year / 100 + year / 400; -} - -/* Parse UTC date-time string, and return the corresponding time_t value. */ -MG_INTERNAL time_t mg_parse_date_string(const char *datetime) { - static const unsigned short days_before_month[] = { - 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; - char month_str[32]; - int second, minute, hour, day, month, year, leap_days, days; - time_t result = (time_t) 0; - - 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)) && - year > 1970 && (month = mg_get_month_index(month_str)) != -1) { - leap_days = mg_num_leap_years(year) - mg_num_leap_years(1970); - year -= 1970; - days = year * 365 + days_before_month[month] + (day - 1) + leap_days; - result = days * 24 * 3600 + hour * 3600 + minute * 60 + second; - } - - return result; -} - -MG_INTERNAL int mg_is_not_modified(struct http_message *hm, cs_stat_t *st) { - struct mg_str *hdr; - if ((hdr = mg_get_http_header(hm, "If-None-Match")) != NULL) { - char etag[64]; - mg_http_construct_etag(etag, sizeof(etag), st); - return mg_vcasecmp(hdr, etag) == 0; - } else if ((hdr = mg_get_http_header(hm, "If-Modified-Since")) != NULL) { - return st->st_mtime <= mg_parse_date_string(hdr->p); - } else { - return 0; - } -} - -static void mg_http_send_digest_auth_request(struct mg_connection *c, - const char *domain) { - mg_printf(c, - "HTTP/1.1 401 Unauthorized\r\n" - "WWW-Authenticate: Digest qop=\"auth\", " - "realm=\"%s\", nonce=\"%lu\"\r\n" - "Content-Length: 0\r\n\r\n", - domain, (unsigned long) mg_time()); -} - -static void mg_http_send_options(struct mg_connection *nc) { - mg_printf(nc, "%s", - "HTTP/1.1 200 OK\r\nAllow: GET, POST, HEAD, CONNECT, OPTIONS" -#if MG_ENABLE_HTTP_WEBDAV - ", MKCOL, PUT, DELETE, PROPFIND, MOVE\r\nDAV: 1,2" -#endif - "\r\n\r\n"); - nc->flags |= MG_F_SEND_AND_CLOSE; -} - -static int mg_is_creation_request(const struct http_message *hm) { - return mg_vcmp(&hm->method, "MKCOL") == 0 || mg_vcmp(&hm->method, "PUT") == 0; -} - -MG_INTERNAL void mg_send_http_file(struct mg_connection *nc, char *path, - const struct mg_str *path_info, - struct http_message *hm, - struct mg_serve_http_opts *opts) { - int exists, is_directory, is_cgi; -#if MG_ENABLE_HTTP_WEBDAV - int is_dav = mg_is_dav_request(&hm->method); -#else - int is_dav = 0; -#endif - char *index_file = NULL; - cs_stat_t st; - - exists = (mg_stat(path, &st) == 0); - is_directory = exists && S_ISDIR(st.st_mode); - - if (is_directory) - mg_find_index_file(path, opts->index_files, &index_file, &st); - - is_cgi = - (mg_match_prefix(opts->cgi_file_pattern, strlen(opts->cgi_file_pattern), - index_file ? index_file : path) > 0); - - LOG(LL_DEBUG, - ("%p %.*s [%s] exists=%d is_dir=%d is_dav=%d is_cgi=%d index=%s", nc, - (int) hm->method.len, hm->method.p, path, exists, is_directory, is_dav, - is_cgi, index_file ? index_file : "")); - - if (is_directory && hm->uri.p[hm->uri.len - 1] != '/' && !is_dav) { - mg_printf(nc, - "HTTP/1.1 301 Moved\r\nLocation: %.*s/\r\n" - "Content-Length: 0\r\n\r\n", - (int) hm->uri.len, hm->uri.p); - MG_FREE(index_file); - return; - } - - /* If we have path_info, the only way to handle it is CGI. */ - if (path_info->len > 0 && !is_cgi) { - mg_http_send_error(nc, 501, NULL); - MG_FREE(index_file); - return; - } - - if (is_dav && opts->dav_document_root == NULL) { - mg_http_send_error(nc, 501, NULL); - } else if (!mg_is_authorized(hm, path, is_directory, opts->auth_domain, - opts->global_auth_file, 1) || - !mg_is_authorized(hm, path, is_directory, opts->auth_domain, - opts->per_directory_auth_file, 0)) { - mg_http_send_digest_auth_request(nc, opts->auth_domain); - } else if (is_cgi) { -#if MG_ENABLE_HTTP_CGI - mg_handle_cgi(nc, index_file ? index_file : path, path_info, hm, opts); -#else - mg_http_send_error(nc, 501, NULL); -#endif /* MG_ENABLE_HTTP_CGI */ - } else if ((!exists || - mg_is_file_hidden(path, opts, 0 /* specials are ok */)) && - !mg_is_creation_request(hm)) { - mg_http_send_error(nc, 404, NULL); -#if MG_ENABLE_HTTP_WEBDAV - } else if (!mg_vcmp(&hm->method, "PROPFIND")) { - mg_handle_propfind(nc, path, &st, hm, opts); -#if !MG_DISABLE_DAV_AUTH - } else if (is_dav && - (opts->dav_auth_file == NULL || - (strcmp(opts->dav_auth_file, "-") != 0 && - !mg_is_authorized(hm, path, is_directory, opts->auth_domain, - opts->dav_auth_file, 1)))) { - mg_http_send_digest_auth_request(nc, opts->auth_domain); -#endif - } else if (!mg_vcmp(&hm->method, "MKCOL")) { - mg_handle_mkcol(nc, path, hm); - } else if (!mg_vcmp(&hm->method, "DELETE")) { - mg_handle_delete(nc, opts, path); - } else if (!mg_vcmp(&hm->method, "PUT")) { - mg_handle_put(nc, path, hm); - } else if (!mg_vcmp(&hm->method, "MOVE")) { - mg_handle_move(nc, opts, path, hm); -#if MG_ENABLE_FAKE_DAVLOCK - } else if (!mg_vcmp(&hm->method, "LOCK")) { - mg_handle_lock(nc, path); -#endif -#endif /* MG_ENABLE_HTTP_WEBDAV */ - } else if (!mg_vcmp(&hm->method, "OPTIONS")) { - mg_http_send_options(nc); - } else if (is_directory && index_file == NULL) { -#if MG_ENABLE_DIRECTORY_LISTING - if (strcmp(opts->enable_directory_listing, "yes") == 0) { - mg_send_directory_listing(nc, path, hm, opts); - } else { - mg_http_send_error(nc, 403, NULL); - } -#else - mg_http_send_error(nc, 501, NULL); -#endif - } else if (mg_is_not_modified(hm, &st)) { - mg_http_send_error(nc, 304, "Not Modified"); - } else { - mg_http_serve_file2(nc, index_file ? index_file : path, hm, opts); - } - MG_FREE(index_file); -} - -void mg_serve_http(struct mg_connection *nc, struct http_message *hm, - struct mg_serve_http_opts opts) { - char *path = NULL; - struct mg_str *hdr, path_info; - uint32_t remote_ip = ntohl(*(uint32_t *) &nc->sa.sin.sin_addr); - - if (mg_check_ip_acl(opts.ip_acl, remote_ip) != 1) { - /* Not allowed to connect */ - mg_http_send_error(nc, 403, NULL); - nc->flags |= MG_F_SEND_AND_CLOSE; - return; - } - -#if MG_ENABLE_HTTP_URL_REWRITES - if (mg_http_handle_forwarding(nc, hm, &opts)) { - return; - } - - if (mg_http_send_port_based_redirect(nc, hm, &opts)) { - return; - } -#endif - - if (opts.document_root == NULL) { - opts.document_root = "."; - } - if (opts.per_directory_auth_file == NULL) { - opts.per_directory_auth_file = ".htpasswd"; - } - if (opts.enable_directory_listing == NULL) { - opts.enable_directory_listing = "yes"; - } - if (opts.cgi_file_pattern == NULL) { - opts.cgi_file_pattern = "**.cgi$|**.php$"; - } - if (opts.ssi_pattern == NULL) { - opts.ssi_pattern = "**.shtml$|**.shtm$"; - } - if (opts.index_files == NULL) { - opts.index_files = "index.html,index.htm,index.shtml,index.cgi,index.php"; - } - /* Normalize path - resolve "." and ".." (in-place). */ - if (!mg_normalize_uri_path(&hm->uri, &hm->uri)) { - mg_http_send_error(nc, 400, NULL); - return; - } - if (mg_uri_to_local_path(hm, &opts, &path, &path_info) == 0) { - mg_http_send_error(nc, 404, NULL); - return; - } - mg_send_http_file(nc, path, &path_info, hm, &opts); - - MG_FREE(path); - path = NULL; - - /* Close connection for non-keep-alive requests */ - if (mg_vcmp(&hm->proto, "HTTP/1.1") != 0 || - ((hdr = mg_get_http_header(hm, "Connection")) != NULL && - mg_vcmp(hdr, "keep-alive") != 0)) { -#if 0 - nc->flags |= MG_F_SEND_AND_CLOSE; -#endif - } -} - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART -void mg_file_upload_handler(struct mg_connection *nc, int ev, void *ev_data, - mg_fu_fname_fn local_name_fn) { - switch (ev) { - case MG_EV_HTTP_PART_BEGIN: { - struct mg_http_multipart_part *mp = - (struct mg_http_multipart_part *) ev_data; - struct file_upload_state *fus = - (struct file_upload_state *) calloc(1, sizeof(*fus)); - struct mg_str lfn = local_name_fn(nc, mg_mk_str(mp->file_name)); - mp->user_data = NULL; - if (lfn.p == NULL || lfn.len == 0) { - LOG(LL_ERROR, ("%p Not allowed to upload %s", nc, mp->file_name)); - mg_printf(nc, - "HTTP/1.1 403 Not Allowed\r\n" - "Content-Type: text/plain\r\n" - "Connection: close\r\n\r\n" - "Not allowed to upload %s\r\n", - mp->file_name); - nc->flags |= MG_F_SEND_AND_CLOSE; - return; - } - fus->lfn = (char *) malloc(lfn.len + 1); - memcpy(fus->lfn, lfn.p, lfn.len); - fus->lfn[lfn.len] = '\0'; - if (lfn.p != mp->file_name) free((char *) lfn.p); - LOG(LL_DEBUG, - ("%p Receiving file %s -> %s", nc, mp->file_name, fus->lfn)); - fus->fp = mg_fopen(fus->lfn, "w"); - if (fus->fp == NULL) { - mg_printf(nc, - "HTTP/1.1 500 Internal Server Error\r\n" - "Content-Type: text/plain\r\n" - "Connection: close\r\n\r\n"); - LOG(LL_ERROR, ("Failed to open %s: %d\n", fus->lfn, mg_get_errno())); - mg_printf(nc, "Failed to open %s: %d\n", fus->lfn, mg_get_errno()); - /* Do not close the connection just yet, discard remainder of the data. - * This is because at the time of writing some browsers (Chrome) fail to - * render response before all the data is sent. */ - } - mp->user_data = (void *) fus; - break; - } - case MG_EV_HTTP_PART_DATA: { - struct mg_http_multipart_part *mp = - (struct mg_http_multipart_part *) ev_data; - struct file_upload_state *fus = - (struct file_upload_state *) mp->user_data; - if (fus == NULL || fus->fp == NULL) break; - if (fwrite(mp->data.p, 1, mp->data.len, fus->fp) != mp->data.len) { - LOG(LL_ERROR, ("Failed to write to %s: %d, wrote %d", fus->lfn, - mg_get_errno(), (int) fus->num_recd)); - if (mg_get_errno() == ENOSPC -#ifdef SPIFFS_ERR_FULL - || mg_get_errno() == SPIFFS_ERR_FULL -#endif - ) { - mg_printf(nc, - "HTTP/1.1 413 Payload Too Large\r\n" - "Content-Type: text/plain\r\n" - "Connection: close\r\n\r\n"); - mg_printf(nc, "Failed to write to %s: no space left; wrote %d\r\n", - fus->lfn, (int) fus->num_recd); - } else { - mg_printf(nc, - "HTTP/1.1 500 Internal Server Error\r\n" - "Content-Type: text/plain\r\n" - "Connection: close\r\n\r\n"); - mg_printf(nc, "Failed to write to %s: %d, wrote %d", mp->file_name, - mg_get_errno(), (int) fus->num_recd); - } - fclose(fus->fp); - remove(fus->lfn); - fus->fp = NULL; - /* Do not close the connection just yet, discard remainder of the data. - * This is because at the time of writing some browsers (Chrome) fail to - * render response before all the data is sent. */ - return; - } - fus->num_recd += mp->data.len; - LOG(LL_DEBUG, ("%p rec'd %d bytes, %d total", nc, (int) mp->data.len, - (int) fus->num_recd)); - break; - } - case MG_EV_HTTP_PART_END: { - struct mg_http_multipart_part *mp = - (struct mg_http_multipart_part *) ev_data; - struct file_upload_state *fus = - (struct file_upload_state *) mp->user_data; - if (fus == NULL) break; - if (mp->status >= 0 && fus->fp != NULL) { - LOG(LL_DEBUG, ("%p Uploaded %s (%s), %d bytes", nc, mp->file_name, - fus->lfn, (int) fus->num_recd)); - mg_printf(nc, - "HTTP/1.1 200 OK\r\n" - "Content-Type: text/plain\r\n" - "Connection: close\r\n\r\n" - "Ok, %s - %d bytes.\r\n", - mp->file_name, (int) fus->num_recd); - } else { - LOG(LL_ERROR, ("Failed to store %s (%s)", mp->file_name, fus->lfn)); - /* - * mp->status < 0 means connection was terminated, so no reason to send - * HTTP reply - */ - } - if (fus->fp != NULL) fclose(fus->fp); - free(fus->lfn); - free(fus); - mp->user_data = NULL; - nc->flags |= MG_F_SEND_AND_CLOSE; - break; - } - } -} - -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */ -#endif /* MG_ENABLE_FILESYSTEM */ - -/* returns 0 on success, -1 on error */ -MG_INTERNAL int mg_http_common_url_parse(const char *url, const char *schema, - const char *schema_tls, int *use_ssl, - char **user, char **pass, char **addr, - int *port_i, const char **path) { - int addr_len = 0; - int auth_sep_pos = -1; - int user_sep_pos = -1; - int port_pos = -1; - (void) user; - (void) pass; - - if (strncmp(url, schema, strlen(schema)) == 0) { - url += strlen(schema); - } else if (strncmp(url, schema_tls, strlen(schema_tls)) == 0) { - url += strlen(schema_tls); - *use_ssl = 1; -#if !MG_ENABLE_SSL - return -1; /* SSL is not enabled, cannot do HTTPS URLs */ -#endif - } - - while (*url != '\0') { - *addr = (char *) MG_REALLOC(*addr, addr_len + 6 /* space for port too. */); - if (*addr == NULL) { - DBG(("OOM")); - return -1; - } - if (*url == '/') { - break; - } - if (*url == '@') { - auth_sep_pos = addr_len; - user_sep_pos = port_pos; - port_pos = -1; - } - if (*url == ':') port_pos = addr_len; - (*addr)[addr_len++] = *url; - (*addr)[addr_len] = '\0'; - url++; - } - - if (addr_len == 0) goto cleanup; - if (port_pos < 0) { - *port_i = addr_len; - addr_len += sprintf(*addr + addr_len, ":%d", *use_ssl ? 443 : 80); - } else { - *port_i = -1; - } - - if (*path == NULL) *path = url; - - if (**path == '\0') *path = "/"; - - if (user != NULL && pass != NULL) { - if (auth_sep_pos == -1) { - *user = NULL; - *pass = NULL; - } else { - /* user is from 0 to user_sep_pos */ - *user = (char *) MG_MALLOC(user_sep_pos + 1); - memcpy(*user, *addr, user_sep_pos); - (*user)[user_sep_pos] = '\0'; - /* pass is from user_sep_pos + 1 to auth_sep_pos */ - *pass = (char *) MG_MALLOC(auth_sep_pos - user_sep_pos - 1 + 1); - memcpy(*pass, *addr + user_sep_pos + 1, auth_sep_pos - user_sep_pos - 1); - (*pass)[auth_sep_pos - user_sep_pos - 1] = '\0'; - - /* move address proper to the front */ - memmove(*addr, *addr + auth_sep_pos + 1, addr_len - auth_sep_pos); - } - } - - DBG(("%s %s", *addr, *path)); - - return 0; - -cleanup: - MG_FREE(*addr); - return -1; -} - -struct mg_connection *mg_connect_http_base( - struct mg_mgr *mgr, mg_event_handler_t ev_handler, - struct mg_connect_opts opts, const char *schema, const char *schema_ssl, - const char *url, const char **path, char **user, char **pass, char **addr) { - struct mg_connection *nc = NULL; - int port_i = -1; - int use_ssl = 0; - - if (mg_http_common_url_parse(url, schema, schema_ssl, &use_ssl, user, pass, - addr, &port_i, path) < 0) { - MG_SET_PTRPTR(opts.error_string, "cannot parse url"); - return NULL; - } - - LOG(LL_DEBUG, ("%s use_ssl? %d", url, use_ssl)); - if (use_ssl) { -#if MG_ENABLE_SSL - /* - * Schema requires SSL, but no SSL parameters were provided in opts. - * In order to maintain backward compatibility, use a faux-SSL with no - * verification. - */ - if (opts.ssl_ca_cert == NULL) { - opts.ssl_ca_cert = "*"; - } -#else - MG_SET_PTRPTR(opts.error_string, "ssl is disabled"); - if (user != NULL) MG_FREE(*user); - if (pass != NULL) MG_FREE(*pass); - MG_FREE(*addr); - return NULL; -#endif - } - - if ((nc = mg_connect_opt(mgr, *addr, ev_handler, opts)) != NULL) { - mg_set_protocol_http_websocket(nc); - /* If the port was addred by us, restore the original host. */ - if (port_i >= 0) (*addr)[port_i] = '\0'; - } - - return nc; -} - -struct mg_connection *mg_connect_http_opt(struct mg_mgr *mgr, - mg_event_handler_t ev_handler, - struct mg_connect_opts opts, - const char *url, - const char *extra_headers, - const char *post_data) { - char *user = NULL, *pass = NULL, *addr = NULL; - const char *path = NULL; - struct mbuf auth; - struct mg_connection *nc = - mg_connect_http_base(mgr, ev_handler, opts, "http://", "https://", url, - &path, &user, &pass, &addr); - - if (nc == NULL) { - return NULL; - } - - mbuf_init(&auth, 0); - if (user != NULL) { - mg_basic_auth_header(user, pass, &auth); - } - - mg_printf(nc, "%s %s HTTP/1.1\r\nHost: %s\r\nContent-Length: %" SIZE_T_FMT - "\r\n%.*s%s\r\n%s", - post_data == NULL ? "GET" : "POST", path, addr, - post_data == NULL ? 0 : strlen(post_data), (int) auth.len, - (auth.buf == NULL ? "" : auth.buf), - extra_headers == NULL ? "" : extra_headers, - post_data == NULL ? "" : post_data); - - mbuf_free(&auth); - MG_FREE(user); - MG_FREE(pass); - MG_FREE(addr); - return nc; -} - -struct mg_connection *mg_connect_http(struct mg_mgr *mgr, - mg_event_handler_t ev_handler, - const char *url, - const char *extra_headers, - const char *post_data) { - struct mg_connect_opts opts; - memset(&opts, 0, sizeof(opts)); - return mg_connect_http_opt(mgr, ev_handler, opts, url, extra_headers, - post_data); -} - -size_t mg_parse_multipart(const char *buf, size_t buf_len, char *var_name, - size_t var_name_len, char *file_name, - size_t file_name_len, const char **data, - size_t *data_len) { - static const char cd[] = "Content-Disposition: "; - size_t hl, bl, n, ll, pos, cdl = sizeof(cd) - 1; - - if (buf == NULL || buf_len <= 0) return 0; - if ((hl = mg_http_get_request_len(buf, buf_len)) <= 0) return 0; - if (buf[0] != '-' || buf[1] != '-' || buf[2] == '\n') return 0; - - /* Get boundary length */ - bl = mg_get_line_len(buf, buf_len); - - /* Loop through headers, fetch variable name and file name */ - var_name[0] = file_name[0] = '\0'; - for (n = bl; (ll = mg_get_line_len(buf + n, hl - n)) > 0; n += ll) { - if (mg_ncasecmp(cd, buf + n, cdl) == 0) { - struct mg_str header; - header.p = buf + n + cdl; - header.len = ll - (cdl + 2); - mg_http_parse_header(&header, "name", var_name, var_name_len); - mg_http_parse_header(&header, "filename", file_name, file_name_len); - } - } - - /* Scan through the body, search for terminating boundary */ - for (pos = hl; pos + (bl - 2) < buf_len; pos++) { - if (buf[pos] == '-' && !strncmp(buf, &buf[pos], bl - 2)) { - if (data_len != NULL) *data_len = (pos - 2) - hl; - if (data != NULL) *data = buf + hl; - return pos; - } - } - - return 0; -} - -void mg_register_http_endpoint(struct mg_connection *nc, const char *uri_path, - mg_event_handler_t handler) { - struct mg_http_proto_data *pd = NULL; - struct mg_http_endpoint *new_ep = NULL; - - if (nc == NULL) return; - new_ep = (struct mg_http_endpoint *) calloc(1, sizeof(*new_ep)); - if (new_ep == NULL) return; - - pd = mg_http_get_proto_data(nc); - new_ep->name = strdup(uri_path); - new_ep->name_len = strlen(new_ep->name); - new_ep->handler = handler; - new_ep->next = pd->endpoints; - pd->endpoints = new_ep; -} - -#endif /* MG_ENABLE_HTTP */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http_cgi.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_CGI - -#ifndef MG_MAX_CGI_ENVIR_VARS -#define MG_MAX_CGI_ENVIR_VARS 64 -#endif - -#ifndef MG_ENV_EXPORT_TO_CGI -#define MG_ENV_EXPORT_TO_CGI "MONGOOSE_CGI" -#endif - -/* - * 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 mg_cgi_env_block { - struct mg_connection *nc; - char buf[MG_CGI_ENVIRONMENT_SIZE]; /* Environment buffer */ - const char *vars[MG_MAX_CGI_ENVIR_VARS]; /* char *envp[] */ - int len; /* Space taken */ - int nvars; /* Number of variables in envp[] */ -}; - -#ifdef _WIN32 -struct mg_threadparam { - sock_t s; - HANDLE hPipe; -}; - -static int mg_wait_until_ready(sock_t sock, int for_read) { - fd_set set; - FD_ZERO(&set); - FD_SET(sock, &set); - return select(sock + 1, for_read ? &set : 0, for_read ? 0 : &set, 0, 0) == 1; -} - -static void *mg_push_to_stdin(void *arg) { - struct mg_threadparam *tp = (struct mg_threadparam *) arg; - int n, sent, stop = 0; - DWORD k; - char buf[BUFSIZ]; - - while (!stop && mg_wait_until_ready(tp->s, 1) && - (n = recv(tp->s, buf, sizeof(buf), 0)) > 0) { - if (n == -1 && GetLastError() == WSAEWOULDBLOCK) continue; - for (sent = 0; !stop && sent < n; sent += k) { - if (!WriteFile(tp->hPipe, buf + sent, n - sent, &k, 0)) stop = 1; - } - } - DBG(("%s", "FORWARED EVERYTHING TO CGI")); - CloseHandle(tp->hPipe); - MG_FREE(tp); - return NULL; -} - -static void *mg_pull_from_stdout(void *arg) { - struct mg_threadparam *tp = (struct mg_threadparam *) arg; - int k = 0, stop = 0; - DWORD n, sent; - char buf[BUFSIZ]; - - while (!stop && ReadFile(tp->hPipe, buf, sizeof(buf), &n, NULL)) { - for (sent = 0; !stop && sent < n; sent += k) { - if (mg_wait_until_ready(tp->s, 0) && - (k = send(tp->s, buf + sent, n - sent, 0)) <= 0) - stop = 1; - } - } - DBG(("%s", "EOF FROM CGI")); - CloseHandle(tp->hPipe); - shutdown(tp->s, 2); // Without this, IO thread may get truncated data - closesocket(tp->s); - MG_FREE(tp); - return NULL; -} - -static void mg_spawn_stdio_thread(sock_t sock, HANDLE hPipe, - void *(*func)(void *)) { - struct mg_threadparam *tp = (struct mg_threadparam *) MG_MALLOC(sizeof(*tp)); - if (tp != NULL) { - tp->s = sock; - tp->hPipe = hPipe; - mg_start_thread(func, tp); - } -} - -static void mg_abs_path(const char *utf8_path, char *abs_path, size_t len) { - wchar_t buf[MAX_PATH_SIZE], buf2[MAX_PATH_SIZE]; - to_wchar(utf8_path, buf, ARRAY_SIZE(buf)); - GetFullPathNameW(buf, ARRAY_SIZE(buf2), buf2, NULL); - WideCharToMultiByte(CP_UTF8, 0, buf2, wcslen(buf2) + 1, abs_path, len, 0, 0); -} - -static int mg_start_process(const char *interp, const char *cmd, - const char *env, const char *envp[], - const char *dir, sock_t sock) { - STARTUPINFOW si; - PROCESS_INFORMATION pi; - HANDLE a[2], b[2], me = GetCurrentProcess(); - wchar_t wcmd[MAX_PATH_SIZE], full_dir[MAX_PATH_SIZE]; - char buf[MAX_PATH_SIZE], buf2[MAX_PATH_SIZE], buf5[MAX_PATH_SIZE], - buf4[MAX_PATH_SIZE], cmdline[MAX_PATH_SIZE]; - DWORD flags = DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS; - FILE *fp; - - memset(&si, 0, sizeof(si)); - memset(&pi, 0, sizeof(pi)); - - si.cb = sizeof(si); - si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; - si.wShowWindow = SW_HIDE; - si.hStdError = GetStdHandle(STD_ERROR_HANDLE); - - CreatePipe(&a[0], &a[1], NULL, 0); - CreatePipe(&b[0], &b[1], NULL, 0); - DuplicateHandle(me, a[0], me, &si.hStdInput, 0, TRUE, flags); - DuplicateHandle(me, b[1], me, &si.hStdOutput, 0, TRUE, flags); - - if (interp == NULL && (fp = mg_fopen(cmd, "r")) != NULL) { - buf[0] = buf[1] = '\0'; - fgets(buf, sizeof(buf), fp); - buf[sizeof(buf) - 1] = '\0'; - if (buf[0] == '#' && buf[1] == '!') { - interp = buf + 2; - /* Trim leading spaces: https://github.com/cesanta/mongoose/issues/489 */ - while (*interp != '\0' && isspace(*(unsigned char *) interp)) { - interp++; - } - } - fclose(fp); - } - - snprintf(buf, sizeof(buf), "%s/%s", dir, cmd); - mg_abs_path(buf, buf2, ARRAY_SIZE(buf2)); - - mg_abs_path(dir, buf5, ARRAY_SIZE(buf5)); - to_wchar(dir, full_dir, ARRAY_SIZE(full_dir)); - - if (interp != NULL) { - mg_abs_path(interp, buf4, ARRAY_SIZE(buf4)); - snprintf(cmdline, sizeof(cmdline), "%s \"%s\"", buf4, buf2); - } else { - snprintf(cmdline, sizeof(cmdline), "\"%s\"", buf2); - } - to_wchar(cmdline, wcmd, ARRAY_SIZE(wcmd)); - - if (CreateProcessW(NULL, wcmd, NULL, NULL, TRUE, CREATE_NEW_PROCESS_GROUP, - (void *) env, full_dir, &si, &pi) != 0) { - mg_spawn_stdio_thread(sock, a[1], mg_push_to_stdin); - mg_spawn_stdio_thread(sock, b[0], mg_pull_from_stdout); - - CloseHandle(si.hStdOutput); - CloseHandle(si.hStdInput); - - CloseHandle(pi.hThread); - CloseHandle(pi.hProcess); - } else { - CloseHandle(a[1]); - CloseHandle(b[0]); - closesocket(sock); - } - DBG(("CGI command: [%ls] -> %p", wcmd, pi.hProcess)); - - /* Not closing a[0] and b[1] because we've used DUPLICATE_CLOSE_SOURCE */ - (void) envp; - return (pi.hProcess != NULL); -} -#else -static int mg_start_process(const char *interp, const char *cmd, - const char *env, const char *envp[], - const char *dir, sock_t sock) { - char buf[500]; - pid_t pid = fork(); - (void) env; - - if (pid == 0) { - /* - * In Linux `chdir` declared with `warn_unused_result` attribute - * To shutup compiler we have yo use result in some way - */ - int tmp = chdir(dir); - (void) tmp; - (void) dup2(sock, 0); - (void) dup2(sock, 1); - closesocket(sock); - - /* - * 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. - */ - signal(SIGCHLD, SIG_DFL); - - if (interp == NULL) { - execle(cmd, cmd, (char *) 0, envp); /* (char *) 0 to squash warning */ - } else { - execle(interp, interp, cmd, (char *) 0, envp); - } - snprintf(buf, sizeof(buf), - "Status: 500\r\n\r\n" - "500 Server Error: %s%s%s: %s", - interp == NULL ? "" : interp, interp == NULL ? "" : " ", cmd, - strerror(errno)); - send(1, buf, strlen(buf), 0); - exit(EXIT_FAILURE); /* exec call failed */ - } - - return (pid != 0); -} -#endif /* _WIN32 */ - -/* - * Append VARIABLE=VALUE\0 string to the buffer, and add a respective - * pointer into the vars array. - */ -static char *mg_addenv(struct mg_cgi_env_block *block, const char *fmt, ...) { - int n, space; - char *added = block->buf + block->len; - va_list ap; - - /* Calculate how much space is left in the buffer */ - space = sizeof(block->buf) - (block->len + 2); - if (space > 0) { - /* Copy VARIABLE=VALUE\0 string into the free space */ - va_start(ap, fmt); - n = vsnprintf(added, (size_t) space, fmt, ap); - va_end(ap); - - /* Make sure we do not overflow buffer and the envp array */ - if (n > 0 && n + 1 < space && - block->nvars < (int) ARRAY_SIZE(block->vars) - 2) { - /* Append a pointer to the added string into the envp array */ - block->vars[block->nvars++] = added; - /* Bump up used length counter. Include \0 terminator */ - block->len += n + 1; - } - } - - return added; -} - -static void mg_addenv2(struct mg_cgi_env_block *blk, const char *name) { - const char *s; - if ((s = getenv(name)) != NULL) mg_addenv(blk, "%s=%s", name, s); -} - -static void mg_prepare_cgi_environment(struct mg_connection *nc, - const char *prog, - const struct mg_str *path_info, - const struct http_message *hm, - const struct mg_serve_http_opts *opts, - struct mg_cgi_env_block *blk) { - const char *s; - struct mg_str *h; - char *p; - size_t i; - char buf[100]; - - blk->len = blk->nvars = 0; - blk->nc = nc; - - if ((s = getenv("SERVER_NAME")) != NULL) { - mg_addenv(blk, "SERVER_NAME=%s", s); - } else { - mg_sock_to_str(nc->sock, buf, sizeof(buf), 3); - mg_addenv(blk, "SERVER_NAME=%s", buf); - } - mg_addenv(blk, "SERVER_ROOT=%s", opts->document_root); - mg_addenv(blk, "DOCUMENT_ROOT=%s", opts->document_root); - mg_addenv(blk, "SERVER_SOFTWARE=%s/%s", "Mongoose", MG_VERSION); - - /* Prepare the environment block */ - mg_addenv(blk, "%s", "GATEWAY_INTERFACE=CGI/1.1"); - mg_addenv(blk, "%s", "SERVER_PROTOCOL=HTTP/1.1"); - mg_addenv(blk, "%s", "REDIRECT_STATUS=200"); /* For PHP */ - - mg_addenv(blk, "REQUEST_METHOD=%.*s", (int) hm->method.len, hm->method.p); - - mg_addenv(blk, "REQUEST_URI=%.*s%s%.*s", (int) hm->uri.len, hm->uri.p, - hm->query_string.len == 0 ? "" : "?", (int) hm->query_string.len, - hm->query_string.p); - - mg_conn_addr_to_str(nc, buf, sizeof(buf), - MG_SOCK_STRINGIFY_REMOTE | MG_SOCK_STRINGIFY_IP); - mg_addenv(blk, "REMOTE_ADDR=%s", buf); - mg_conn_addr_to_str(nc, buf, sizeof(buf), MG_SOCK_STRINGIFY_PORT); - mg_addenv(blk, "SERVER_PORT=%s", buf); - - s = hm->uri.p + hm->uri.len - path_info->len - 1; - if (*s == '/') { - const char *base_name = strrchr(prog, DIRSEP); - mg_addenv(blk, "SCRIPT_NAME=%.*s/%s", (int) (s - hm->uri.p), hm->uri.p, - (base_name != NULL ? base_name + 1 : prog)); - } else { - mg_addenv(blk, "SCRIPT_NAME=%.*s", (int) (s - hm->uri.p + 1), hm->uri.p); - } - mg_addenv(blk, "SCRIPT_FILENAME=%s", prog); - - if (path_info != NULL && path_info->len > 0) { - mg_addenv(blk, "PATH_INFO=%.*s", (int) path_info->len, path_info->p); - /* Not really translated... */ - mg_addenv(blk, "PATH_TRANSLATED=%.*s", (int) path_info->len, path_info->p); - } - -#if MG_ENABLE_SSL - mg_addenv(blk, "HTTPS=%s", (nc->flags & MG_F_SSL ? "on" : "off")); -#else - mg_addenv(blk, "HTTPS=off"); -#endif - - if ((h = mg_get_http_header((struct http_message *) hm, "Content-Type")) != - NULL) { - mg_addenv(blk, "CONTENT_TYPE=%.*s", (int) h->len, h->p); - } - - if (hm->query_string.len > 0) { - mg_addenv(blk, "QUERY_STRING=%.*s", (int) hm->query_string.len, - hm->query_string.p); - } - - if ((h = mg_get_http_header((struct http_message *) hm, "Content-Length")) != - NULL) { - mg_addenv(blk, "CONTENT_LENGTH=%.*s", (int) h->len, h->p); - } - - mg_addenv2(blk, "PATH"); - mg_addenv2(blk, "TMP"); - mg_addenv2(blk, "TEMP"); - mg_addenv2(blk, "TMPDIR"); - mg_addenv2(blk, "PERLLIB"); - mg_addenv2(blk, MG_ENV_EXPORT_TO_CGI); - -#ifdef _WIN32 - mg_addenv2(blk, "COMSPEC"); - mg_addenv2(blk, "SYSTEMROOT"); - mg_addenv2(blk, "SystemDrive"); - mg_addenv2(blk, "ProgramFiles"); - mg_addenv2(blk, "ProgramFiles(x86)"); - mg_addenv2(blk, "CommonProgramFiles(x86)"); -#else - mg_addenv2(blk, "LD_LIBRARY_PATH"); -#endif /* _WIN32 */ - - /* Add all headers as HTTP_* variables */ - for (i = 0; hm->header_names[i].len > 0; i++) { - p = mg_addenv(blk, "HTTP_%.*s=%.*s", (int) hm->header_names[i].len, - hm->header_names[i].p, (int) hm->header_values[i].len, - hm->header_values[i].p); - - /* Convert variable name into uppercase, and change - to _ */ - for (; *p != '=' && *p != '\0'; p++) { - if (*p == '-') *p = '_'; - *p = (char) toupper(*(unsigned char *) p); - } - } - - blk->vars[blk->nvars++] = NULL; - blk->buf[blk->len++] = '\0'; -} - -static void mg_cgi_ev_handler(struct mg_connection *cgi_nc, int ev, - void *ev_data) { - struct mg_connection *nc = (struct mg_connection *) cgi_nc->user_data; - (void) ev_data; - - if (nc == NULL) return; - - switch (ev) { - case MG_EV_RECV: - /* - * CGI script does not output reply line, like "HTTP/1.1 CODE XXXXX\n" - * It outputs headers, then body. Headers might include "Status" - * header, which changes CODE, and it might include "Location" header - * which changes CODE to 302. - * - * Therefore we do not send the output from the CGI script to the user - * until all CGI headers are received. - * - * Here we parse the output from the CGI script, and if all headers has - * been received, send appropriate reply line, and forward all - * received headers to the client. - */ - if (nc->flags & MG_F_USER_1) { - struct mbuf *io = &cgi_nc->recv_mbuf; - int len = mg_http_get_request_len(io->buf, io->len); - - if (len == 0) break; - if (len < 0 || io->len > MG_MAX_HTTP_REQUEST_SIZE) { - cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY; - mg_http_send_error(nc, 500, "Bad headers"); - } else { - struct http_message hm; - struct mg_str *h; - mg_http_parse_headers(io->buf, io->buf + io->len, io->len, &hm); - if (mg_get_http_header(&hm, "Location") != NULL) { - mg_printf(nc, "%s", "HTTP/1.1 302 Moved\r\n"); - } else if ((h = mg_get_http_header(&hm, "Status")) != NULL) { - mg_printf(nc, "HTTP/1.1 %.*s\r\n", (int) h->len, h->p); - } else { - mg_printf(nc, "%s", "HTTP/1.1 200 OK\r\n"); - } - } - nc->flags &= ~MG_F_USER_1; - } - if (!(nc->flags & MG_F_USER_1)) { - mg_forward(cgi_nc, nc); - } - break; - case MG_EV_CLOSE: - mg_http_free_proto_data_cgi(&mg_http_get_proto_data(cgi_nc)->cgi); - nc->flags |= MG_F_SEND_AND_CLOSE; - break; - } -} - -MG_INTERNAL void mg_handle_cgi(struct mg_connection *nc, const char *prog, - const struct mg_str *path_info, - const struct http_message *hm, - const struct mg_serve_http_opts *opts) { - struct mg_cgi_env_block blk; - char dir[MAX_PATH_SIZE]; - const char *p; - sock_t fds[2]; - - DBG(("%p [%s]", nc, prog)); - mg_prepare_cgi_environment(nc, prog, path_info, hm, opts, &blk); - /* - * 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'. - */ - if ((p = strrchr(prog, DIRSEP)) == NULL) { - snprintf(dir, sizeof(dir), "%s", "."); - } else { - snprintf(dir, sizeof(dir), "%.*s", (int) (p - prog), prog); - prog = p + 1; - } - - /* - * Try to create socketpair in a loop until success. mg_socketpair() - * can be interrupted by a signal and fail. - * TODO(lsm): use sigaction to restart interrupted syscall - */ - do { - mg_socketpair(fds, SOCK_STREAM); - } while (fds[0] == INVALID_SOCKET); - - if (mg_start_process(opts->cgi_interpreter, prog, blk.buf, blk.vars, dir, - fds[1]) != 0) { - size_t n = nc->recv_mbuf.len - (hm->message.len - hm->body.len); - struct mg_connection *cgi_nc = - mg_add_sock(nc->mgr, fds[0], mg_cgi_ev_handler); - struct mg_http_proto_data *cgi_pd = mg_http_get_proto_data(cgi_nc); - cgi_pd->cgi.cgi_nc = cgi_nc; - cgi_pd->cgi.cgi_nc->user_data = nc; - nc->flags |= MG_F_USER_1; - /* Push POST data to the CGI */ - if (n > 0 && n < nc->recv_mbuf.len) { - mg_send(cgi_pd->cgi.cgi_nc, hm->body.p, n); - } - mbuf_remove(&nc->recv_mbuf, nc->recv_mbuf.len); - } else { - closesocket(fds[0]); - mg_http_send_error(nc, 500, "CGI failure"); - } - -#ifndef _WIN32 - closesocket(fds[1]); /* On Windows, CGI stdio thread closes that socket */ -#endif -} - -MG_INTERNAL void mg_http_free_proto_data_cgi(struct mg_http_proto_data_cgi *d) { - if (d != NULL) { - if (d->cgi_nc != NULL) d->cgi_nc->flags |= MG_F_CLOSE_IMMEDIATELY; - memset(d, 0, sizeof(struct mg_http_proto_data_cgi)); - } -} - -#endif /* MG_ENABLE_HTTP && MG_ENABLE_HTTP_CGI */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http_ssi.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_SSI && MG_ENABLE_FILESYSTEM - -static void mg_send_ssi_file(struct mg_connection *nc, struct http_message *hm, - const char *path, FILE *fp, int include_level, - const struct mg_serve_http_opts *opts); - -static void mg_send_file_data(struct mg_connection *nc, FILE *fp) { - char buf[BUFSIZ]; - size_t n; - while ((n = fread(buf, 1, sizeof(buf), fp)) > 0) { - mg_send(nc, buf, n); - } -} - -static void mg_do_ssi_include(struct mg_connection *nc, struct http_message *hm, - const char *ssi, char *tag, int include_level, - const struct mg_serve_http_opts *opts) { - char file_name[BUFSIZ], path[MAX_PATH_SIZE], *p; - FILE *fp; - - /* - * 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=\"%[^\"]\"", file_name) == 1) { - /* File name is relative to the webserver root */ - snprintf(path, sizeof(path), "%s/%s", opts->document_root, file_name); - } else if (sscanf(tag, " abspath=\"%[^\"]\"", file_name) == 1) { - /* - * File name is relative to the webserver working directory - * or it is absolute system path - */ - snprintf(path, sizeof(path), "%s", file_name); - } else if (sscanf(tag, " file=\"%[^\"]\"", file_name) == 1 || - sscanf(tag, " \"%[^\"]\"", file_name) == 1) { - /* File name is relative to the currect document */ - snprintf(path, sizeof(path), "%s", ssi); - if ((p = strrchr(path, DIRSEP)) != NULL) { - p[1] = '\0'; - } - snprintf(path + strlen(path), sizeof(path) - strlen(path), "%s", file_name); - } else { - mg_printf(nc, "Bad SSI #include: [%s]", tag); - return; - } - - if ((fp = mg_fopen(path, "rb")) == NULL) { - mg_printf(nc, "SSI include error: mg_fopen(%s): %s", path, - strerror(mg_get_errno())); - } else { - mg_set_close_on_exec((sock_t) fileno(fp)); - if (mg_match_prefix(opts->ssi_pattern, strlen(opts->ssi_pattern), path) > - 0) { - mg_send_ssi_file(nc, hm, path, fp, include_level + 1, opts); - } else { - mg_send_file_data(nc, fp); - } - fclose(fp); - } -} - -#if MG_ENABLE_HTTP_SSI_EXEC -static void do_ssi_exec(struct mg_connection *nc, char *tag) { - char cmd[BUFSIZ]; - FILE *fp; - - if (sscanf(tag, " \"%[^\"]\"", cmd) != 1) { - mg_printf(nc, "Bad SSI #exec: [%s]", tag); - } else if ((fp = popen(cmd, "r")) == NULL) { - mg_printf(nc, "Cannot SSI #exec: [%s]: %s", cmd, strerror(mg_get_errno())); - } else { - mg_send_file_data(nc, fp); - pclose(fp); - } -} -#endif /* MG_ENABLE_HTTP_SSI_EXEC */ - -/* - * SSI directive has the following format: - * - */ -static void mg_send_ssi_file(struct mg_connection *nc, struct http_message *hm, - const char *path, FILE *fp, int include_level, - const struct mg_serve_http_opts *opts) { - static const struct mg_str btag = MG_MK_STR(" */ - buf[i--] = '\0'; - while (i > 0 && buf[i] == ' ') { - buf[i--] = '\0'; - } - - /* Handle known SSI directives */ - if (strncmp(p, d_include.p, d_include.len) == 0) { - mg_do_ssi_include(nc, hm, path, p + d_include.len + 1, include_level, - opts); - } else if (strncmp(p, d_call.p, d_call.len) == 0) { - struct mg_ssi_call_ctx cctx; - memset(&cctx, 0, sizeof(cctx)); - cctx.req = hm; - cctx.file = mg_mk_str(path); - cctx.arg = mg_mk_str(p + d_call.len + 1); - mg_call(nc, NULL, MG_EV_SSI_CALL, - (void *) cctx.arg.p); /* NUL added above */ - mg_call(nc, NULL, MG_EV_SSI_CALL_CTX, &cctx); -#if MG_ENABLE_HTTP_SSI_EXEC - } else if (strncmp(p, d_exec.p, d_exec.len) == 0) { - do_ssi_exec(nc, p + d_exec.len + 1); -#endif - } else { - /* Silently ignore unknown SSI directive. */ - } - len = 0; - } else if (ch == '<') { - in_ssi_tag = 1; - if (len > 0) { - mg_send(nc, buf, (size_t) len); - } - len = 0; - buf[len++] = ch & 0xff; - } else if (in_ssi_tag) { - if (len == (int) btag.len && strncmp(buf, btag.p, btag.len) != 0) { - /* Not an SSI tag */ - in_ssi_tag = 0; - } else if (len == (int) sizeof(buf) - 2) { - mg_printf(nc, "%s: SSI tag is too large", path); - len = 0; - } - buf[len++] = ch & 0xff; - } else { - buf[len++] = ch & 0xff; - if (len == (int) sizeof(buf)) { - mg_send(nc, buf, (size_t) len); - len = 0; - } - } - } - - /* Send the rest of buffered data */ - if (len > 0) { - mg_send(nc, buf, (size_t) len); - } -} - -MG_INTERNAL void mg_handle_ssi_request(struct mg_connection *nc, - struct http_message *hm, - const char *path, - const struct mg_serve_http_opts *opts) { - FILE *fp; - struct mg_str mime_type; - DBG(("%p %s", nc, path)); - - if ((fp = mg_fopen(path, "rb")) == NULL) { - mg_http_send_error(nc, 404, NULL); - } else { - mg_set_close_on_exec((sock_t) fileno(fp)); - - mime_type = mg_get_mime_type(path, "text/plain", opts); - mg_send_response_line(nc, 200, opts->extra_headers); - mg_printf(nc, - "Content-Type: %.*s\r\n" - "Connection: close\r\n\r\n", - (int) mime_type.len, mime_type.p); - mg_send_ssi_file(nc, hm, path, fp, 0, opts); - fclose(fp); - nc->flags |= MG_F_SEND_AND_CLOSE; - } -} - -#endif /* MG_ENABLE_HTTP_SSI && MG_ENABLE_HTTP && MG_ENABLE_FILESYSTEM */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http_webdav.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBDAV - -MG_INTERNAL int mg_is_dav_request(const struct mg_str *s) { - static const char *methods[] = { - "PUT", - "DELETE", - "MKCOL", - "PROPFIND", - "MOVE" -#if MG_ENABLE_FAKE_DAVLOCK - , - "LOCK", - "UNLOCK" -#endif - }; - size_t i; - - for (i = 0; i < ARRAY_SIZE(methods); i++) { - if (mg_vcmp(s, methods[i]) == 0) { - return 1; - } - } - - return 0; -} - -static int mg_mkdir(const char *path, uint32_t mode) { -#ifndef _WIN32 - return mkdir(path, mode); -#else - (void) mode; - return _mkdir(path); -#endif -} - -static void mg_print_props(struct mg_connection *nc, const char *name, - cs_stat_t *stp) { - char mtime[64], buf[MAX_PATH_SIZE * 3]; - time_t t = stp->st_mtime; /* store in local variable for NDK compile */ - mg_gmt_time_string(mtime, sizeof(mtime), &t); - mg_url_encode(name, strlen(name), buf, sizeof(buf)); - mg_printf(nc, - "" - "%s" - "" - "" - "%s" - "%" INT64_FMT - "" - "%s" - "" - "HTTP/1.1 200 OK" - "" - "\n", - buf, S_ISDIR(stp->st_mode) ? "" : "", - (int64_t) stp->st_size, mtime); -} - -MG_INTERNAL void mg_handle_propfind(struct mg_connection *nc, const char *path, - cs_stat_t *stp, struct http_message *hm, - struct mg_serve_http_opts *opts) { - static const char header[] = - "HTTP/1.1 207 Multi-Status\r\n" - "Connection: close\r\n" - "Content-Type: text/xml; charset=utf-8\r\n\r\n" - "" - "\n"; - static const char footer[] = "\n"; - const struct mg_str *depth = mg_get_http_header(hm, "Depth"); - - /* Print properties for the requested resource itself */ - if (S_ISDIR(stp->st_mode) && - strcmp(opts->enable_directory_listing, "yes") != 0) { - mg_printf(nc, "%s", "HTTP/1.1 403 Directory Listing Denied\r\n\r\n"); - } else { - char uri[MAX_PATH_SIZE]; - mg_send(nc, header, sizeof(header) - 1); - snprintf(uri, sizeof(uri), "%.*s", (int) hm->uri.len, hm->uri.p); - mg_print_props(nc, uri, stp); - if (S_ISDIR(stp->st_mode) && (depth == NULL || mg_vcmp(depth, "0") != 0)) { - mg_scan_directory(nc, path, opts, mg_print_props); - } - mg_send(nc, footer, sizeof(footer) - 1); - nc->flags |= MG_F_SEND_AND_CLOSE; - } -} - -#if MG_ENABLE_FAKE_DAVLOCK -/* - * Windows explorer (probably there are another WebDav clients like it) - * requires LOCK support in webdav. W/out this, it still works, but fails - * to save file: shows error message and offers "Save As". - * "Save as" works, but this message is very annoying. - * This is fake lock, which doesn't lock something, just returns LOCK token, - * UNLOCK always answers "OK". - * With this fake LOCK Windows Explorer looks happy and saves file. - * NOTE: that is not DAV LOCK imlementation, it is just a way to shut up - * Windows native DAV client. This is why FAKE LOCK is not enabed by default - */ -MG_INTERNAL void mg_handle_lock(struct mg_connection *nc, const char *path) { - static const char *reply = - "HTTP/1.1 207 Multi-Status\r\n" - "Connection: close\r\n" - "Content-Type: text/xml; charset=utf-8\r\n\r\n" - "" - "\n" - "\n" - "\n" - "\n" - "\n" - "opaquelocktoken:%s%u" - "" - "" - "\n" - "" - "\n"; - mg_printf(nc, reply, path, (unsigned int) mg_time()); - nc->flags |= MG_F_SEND_AND_CLOSE; -} -#endif - -MG_INTERNAL void mg_handle_mkcol(struct mg_connection *nc, const char *path, - struct http_message *hm) { - int status_code = 500; - if (hm->body.len != (size_t) ~0 && hm->body.len > 0) { - status_code = 415; - } else if (!mg_mkdir(path, 0755)) { - status_code = 201; - } else if (errno == EEXIST) { - status_code = 405; - } else if (errno == EACCES) { - status_code = 403; - } else if (errno == ENOENT) { - status_code = 409; - } else { - status_code = 500; - } - mg_http_send_error(nc, status_code, NULL); -} - -static int mg_remove_directory(const struct mg_serve_http_opts *opts, - const char *dir) { - char path[MAX_PATH_SIZE]; - struct dirent *dp; - cs_stat_t st; - DIR *dirp; - - if ((dirp = opendir(dir)) == NULL) return 0; - - while ((dp = readdir(dirp)) != NULL) { - if (mg_is_file_hidden((const char *) dp->d_name, opts, 1)) { - continue; - } - snprintf(path, sizeof(path), "%s%c%s", dir, '/', dp->d_name); - mg_stat(path, &st); - if (S_ISDIR(st.st_mode)) { - mg_remove_directory(opts, path); - } else { - remove(path); - } - } - closedir(dirp); - rmdir(dir); - - return 1; -} - -MG_INTERNAL void mg_handle_move(struct mg_connection *c, - const struct mg_serve_http_opts *opts, - const char *path, struct http_message *hm) { - const struct mg_str *dest = mg_get_http_header(hm, "Destination"); - if (dest == NULL) { - mg_http_send_error(c, 411, NULL); - } else { - const char *p = (char *) memchr(dest->p, '/', dest->len); - if (p != NULL && p[1] == '/' && - (p = (char *) memchr(p + 2, '/', dest->p + dest->len - p)) != NULL) { - char buf[MAX_PATH_SIZE]; - snprintf(buf, sizeof(buf), "%s%.*s", opts->dav_document_root, - (int) (dest->p + dest->len - p), p); - if (rename(path, buf) == 0) { - mg_http_send_error(c, 200, NULL); - } else { - mg_http_send_error(c, 418, NULL); - } - } else { - mg_http_send_error(c, 500, NULL); - } - } -} - -MG_INTERNAL void mg_handle_delete(struct mg_connection *nc, - const struct mg_serve_http_opts *opts, - const char *path) { - cs_stat_t st; - if (mg_stat(path, &st) != 0) { - mg_http_send_error(nc, 404, NULL); - } else if (S_ISDIR(st.st_mode)) { - mg_remove_directory(opts, path); - mg_http_send_error(nc, 204, NULL); - } else if (remove(path) == 0) { - mg_http_send_error(nc, 204, NULL); - } else { - mg_http_send_error(nc, 423, NULL); - } -} - -/* Return -1 on error, 1 on success. */ -static int mg_create_itermediate_directories(const char *path) { - const char *s; - - /* Create intermediate directories if they do not exist */ - for (s = path + 1; *s != '\0'; s++) { - if (*s == '/') { - char buf[MAX_PATH_SIZE]; - cs_stat_t st; - snprintf(buf, sizeof(buf), "%.*s", (int) (s - path), path); - buf[sizeof(buf) - 1] = '\0'; - if (mg_stat(buf, &st) != 0 && mg_mkdir(buf, 0755) != 0) { - return -1; - } - } - } - - return 1; -} - -MG_INTERNAL void mg_handle_put(struct mg_connection *nc, const char *path, - struct http_message *hm) { - struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); - cs_stat_t st; - const struct mg_str *cl_hdr = mg_get_http_header(hm, "Content-Length"); - int rc, status_code = mg_stat(path, &st) == 0 ? 200 : 201; - - mg_http_free_proto_data_file(&pd->file); - if ((rc = mg_create_itermediate_directories(path)) == 0) { - mg_printf(nc, "HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n", status_code); - } else if (rc == -1) { - mg_http_send_error(nc, 500, NULL); - } else if (cl_hdr == NULL) { - mg_http_send_error(nc, 411, NULL); - } else if ((pd->file.fp = mg_fopen(path, "w+b")) == NULL) { - mg_http_send_error(nc, 500, NULL); - } else { - const struct mg_str *range_hdr = mg_get_http_header(hm, "Content-Range"); - int64_t r1 = 0, r2 = 0; - pd->file.type = DATA_PUT; - mg_set_close_on_exec((sock_t) fileno(pd->file.fp)); - pd->file.cl = to64(cl_hdr->p); - if (range_hdr != NULL && - mg_http_parse_range_header(range_hdr, &r1, &r2) > 0) { - status_code = 206; - fseeko(pd->file.fp, r1, SEEK_SET); - pd->file.cl = r2 > r1 ? r2 - r1 + 1 : pd->file.cl - r1; - } - mg_printf(nc, "HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n", status_code); - /* Remove HTTP request from the mbuf, leave only payload */ - mbuf_remove(&nc->recv_mbuf, hm->message.len - hm->body.len); - mg_http_transfer_file_data(nc); - } -} - -#endif /* MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBDAV */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http_websocket.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBSOCKET - -#ifndef MG_WEBSOCKET_PING_INTERVAL_SECONDS -#define MG_WEBSOCKET_PING_INTERVAL_SECONDS 5 -#endif - -#define MG_WS_NO_HOST_HEADER_MAGIC ((char *) 0x1) - -static int mg_is_ws_fragment(unsigned char flags) { - return (flags & 0x80) == 0 || (flags & 0x0f) == 0; -} - -static int mg_is_ws_first_fragment(unsigned char flags) { - return (flags & 0x80) == 0 && (flags & 0x0f) != 0; -} - -static void mg_handle_incoming_websocket_frame(struct mg_connection *nc, - struct websocket_message *wsm) { - if (wsm->flags & 0x8) { - mg_call(nc, nc->handler, MG_EV_WEBSOCKET_CONTROL_FRAME, wsm); - } else { - mg_call(nc, nc->handler, MG_EV_WEBSOCKET_FRAME, wsm); - } -} - -static int mg_deliver_websocket_data(struct mg_connection *nc) { - /* Using unsigned char *, cause of integer arithmetic below */ - uint64_t i, data_len = 0, frame_len = 0, buf_len = nc->recv_mbuf.len, len, - mask_len = 0, header_len = 0; - unsigned char *p = (unsigned char *) nc->recv_mbuf.buf, *buf = p, - *e = p + buf_len; - unsigned *sizep = (unsigned *) &p[1]; /* Size ptr for defragmented frames */ - int ok, reass = buf_len > 0 && mg_is_ws_fragment(p[0]) && - !(nc->flags & MG_F_WEBSOCKET_NO_DEFRAG); - - /* If that's a continuation frame that must be reassembled, handle it */ - if (reass && !mg_is_ws_first_fragment(p[0]) && - buf_len >= 1 + sizeof(*sizep) && buf_len >= 1 + sizeof(*sizep) + *sizep) { - buf += 1 + sizeof(*sizep) + *sizep; - buf_len -= 1 + sizeof(*sizep) + *sizep; - } - - if (buf_len >= 2) { - len = buf[1] & 127; - mask_len = buf[1] & 128 ? 4 : 0; - if (len < 126 && buf_len >= mask_len) { - data_len = len; - header_len = 2 + mask_len; - } else if (len == 126 && buf_len >= 4 + mask_len) { - header_len = 4 + mask_len; - data_len = ntohs(*(uint16_t *) &buf[2]); - } else if (buf_len >= 10 + mask_len) { - header_len = 10 + mask_len; - data_len = (((uint64_t) ntohl(*(uint32_t *) &buf[2])) << 32) + - ntohl(*(uint32_t *) &buf[6]); - } - } - - frame_len = header_len + data_len; - ok = frame_len > 0 && frame_len <= buf_len; - - if (ok) { - struct websocket_message wsm; - - wsm.size = (size_t) data_len; - wsm.data = buf + header_len; - wsm.flags = buf[0]; - - /* Apply mask if necessary */ - if (mask_len > 0) { - for (i = 0; i < data_len; i++) { - buf[i + header_len] ^= (buf + header_len - mask_len)[i % 4]; - } - } - - if (reass) { - /* On first fragmented frame, nullify size */ - if (mg_is_ws_first_fragment(wsm.flags)) { - mbuf_resize(&nc->recv_mbuf, nc->recv_mbuf.size + sizeof(*sizep)); - p[0] &= ~0x0f; /* Next frames will be treated as continuation */ - buf = p + 1 + sizeof(*sizep); - *sizep = 0; /* TODO(lsm): fix. this can stomp over frame data */ - } - - /* Append this frame to the reassembled buffer */ - memmove(buf, wsm.data, e - wsm.data); - (*sizep) += wsm.size; - nc->recv_mbuf.len -= wsm.data - buf; - - /* On last fragmented frame - call user handler and remove data */ - if (wsm.flags & 0x80) { - wsm.data = p + 1 + sizeof(*sizep); - wsm.size = *sizep; - mg_handle_incoming_websocket_frame(nc, &wsm); - mbuf_remove(&nc->recv_mbuf, 1 + sizeof(*sizep) + *sizep); - } - } else { - /* TODO(lsm): properly handle OOB control frames during defragmentation */ - mg_handle_incoming_websocket_frame(nc, &wsm); - mbuf_remove(&nc->recv_mbuf, (size_t) frame_len); /* Cleanup frame */ - } - - /* If client closes, close too */ - if ((buf[0] & 0x0f) == WEBSOCKET_OP_CLOSE) { - nc->flags |= MG_F_SEND_AND_CLOSE; - } - } - - return ok; -} - -struct ws_mask_ctx { - size_t pos; /* zero means unmasked */ - uint32_t mask; -}; - -static uint32_t mg_ws_random_mask(void) { - uint32_t mask; -/* - * The spec requires WS client to generate hard to - * guess mask keys. From RFC6455, Section 5.3: - * - * The unpredictability of the masking key is essential to prevent - * authors of malicious applications from selecting the bytes that appear on - * the wire. - * - * Hence this feature is essential when the actual end user of this API - * is untrusted code that wouldn't have access to a lower level net API - * anyway (e.g. web browsers). Hence this feature is low prio for most - * mongoose use cases and thus can be disabled, e.g. when porting to a platform - * that lacks rand(). - */ -#if MG_DISABLE_WS_RANDOM_MASK - mask = 0xefbeadde; /* generated with a random number generator, I swear */ -#else - if (sizeof(long) >= 4) { - mask = (uint32_t) rand(); - } else if (sizeof(long) == 2) { - mask = (uint32_t) rand() << 16 | (uint32_t) rand(); - } -#endif - return mask; -} - -static void mg_send_ws_header(struct mg_connection *nc, int op, size_t len, - struct ws_mask_ctx *ctx) { - int header_len; - unsigned char header[10]; - - header[0] = (op & WEBSOCKET_DONT_FIN ? 0x0 : 0x80) + (op & 0x0f); - if (len < 126) { - header[1] = (unsigned char) len; - header_len = 2; - } else if (len < 65535) { - uint16_t tmp = htons((uint16_t) len); - header[1] = 126; - memcpy(&header[2], &tmp, sizeof(tmp)); - header_len = 4; - } else { - uint32_t tmp; - header[1] = 127; - tmp = htonl((uint32_t)((uint64_t) len >> 32)); - memcpy(&header[2], &tmp, sizeof(tmp)); - tmp = htonl((uint32_t)(len & 0xffffffff)); - memcpy(&header[6], &tmp, sizeof(tmp)); - header_len = 10; - } - - /* client connections enable masking */ - if (nc->listener == NULL) { - header[1] |= 1 << 7; /* set masking flag */ - mg_send(nc, header, header_len); - ctx->mask = mg_ws_random_mask(); - mg_send(nc, &ctx->mask, sizeof(ctx->mask)); - ctx->pos = nc->send_mbuf.len; - } else { - mg_send(nc, header, header_len); - ctx->pos = 0; - } -} - -static void mg_ws_mask_frame(struct mbuf *mbuf, struct ws_mask_ctx *ctx) { - size_t i; - if (ctx->pos == 0) return; - for (i = 0; i < (mbuf->len - ctx->pos); i++) { - mbuf->buf[ctx->pos + i] ^= ((char *) &ctx->mask)[i % 4]; - } -} - -void mg_send_websocket_frame(struct mg_connection *nc, int op, const void *data, - size_t len) { - struct ws_mask_ctx ctx; - DBG(("%p %d %d", nc, op, (int) len)); - mg_send_ws_header(nc, op, len, &ctx); - mg_send(nc, data, len); - - mg_ws_mask_frame(&nc->send_mbuf, &ctx); - - if (op == WEBSOCKET_OP_CLOSE) { - nc->flags |= MG_F_SEND_AND_CLOSE; - } -} - -void mg_send_websocket_framev(struct mg_connection *nc, int op, - const struct mg_str *strv, int strvcnt) { - struct ws_mask_ctx ctx; - int i; - int len = 0; - for (i = 0; i < strvcnt; i++) { - len += strv[i].len; - } - - mg_send_ws_header(nc, op, len, &ctx); - - for (i = 0; i < strvcnt; i++) { - mg_send(nc, strv[i].p, strv[i].len); - } - - mg_ws_mask_frame(&nc->send_mbuf, &ctx); - - if (op == WEBSOCKET_OP_CLOSE) { - nc->flags |= MG_F_SEND_AND_CLOSE; - } -} - -void mg_printf_websocket_frame(struct mg_connection *nc, int op, - const char *fmt, ...) { - char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem; - va_list ap; - int len; - - va_start(ap, fmt); - if ((len = mg_avprintf(&buf, sizeof(mem), fmt, ap)) > 0) { - mg_send_websocket_frame(nc, op, buf, len); - } - va_end(ap); - - if (buf != mem && buf != NULL) { - MG_FREE(buf); - } -} - -MG_INTERNAL void mg_ws_handler(struct mg_connection *nc, int ev, - void *ev_data) { - mg_call(nc, nc->handler, ev, ev_data); - - switch (ev) { - case MG_EV_RECV: - do { - } while (mg_deliver_websocket_data(nc)); - break; - case MG_EV_POLL: - /* Ping idle websocket connections */ - { - time_t now = *(time_t *) ev_data; - if (nc->flags & MG_F_IS_WEBSOCKET && - now > nc->last_io_time + MG_WEBSOCKET_PING_INTERVAL_SECONDS) { - mg_send_websocket_frame(nc, WEBSOCKET_OP_PING, "", 0); - } - } - break; - default: - break; - } -} - -#ifndef MG_EXT_SHA1 -static void mg_hash_sha1_v(size_t num_msgs, const uint8_t *msgs[], - const size_t *msg_lens, uint8_t *digest) { - size_t i; - cs_sha1_ctx sha_ctx; - cs_sha1_init(&sha_ctx); - for (i = 0; i < num_msgs; i++) { - cs_sha1_update(&sha_ctx, msgs[i], msg_lens[i]); - } - cs_sha1_final(digest, &sha_ctx); -} -#else -extern void mg_hash_sha1_v(size_t num_msgs, const uint8_t *msgs[], - const size_t *msg_lens, uint8_t *digest); -#endif - -MG_INTERNAL void mg_ws_handshake(struct mg_connection *nc, - const struct mg_str *key) { - static const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; - const uint8_t *msgs[2] = {(const uint8_t *) key->p, (const uint8_t *) magic}; - const size_t msg_lens[2] = {key->len, 36}; - unsigned char sha[20]; - char b64_sha[30]; - - mg_hash_sha1_v(2, msgs, msg_lens, sha); - mg_base64_encode(sha, sizeof(sha), b64_sha); - mg_printf(nc, "%s%s%s", - "HTTP/1.1 101 Switching Protocols\r\n" - "Upgrade: websocket\r\n" - "Connection: Upgrade\r\n" - "Sec-WebSocket-Accept: ", - b64_sha, "\r\n\r\n"); - DBG(("%p %.*s %s", nc, (int) key->len, key->p, b64_sha)); -} - -void mg_send_websocket_handshake2(struct mg_connection *nc, const char *path, - const char *host, const char *protocol, - const char *extra_headers) { - mg_send_websocket_handshake3(nc, path, host, protocol, extra_headers, NULL, - NULL); -} - -void mg_send_websocket_handshake3(struct mg_connection *nc, const char *path, - const char *host, const char *protocol, - const char *extra_headers, const char *user, - const char *pass) { - struct mbuf auth; - char key[25]; - uint32_t nonce[4]; - nonce[0] = mg_ws_random_mask(); - nonce[1] = mg_ws_random_mask(); - nonce[2] = mg_ws_random_mask(); - nonce[3] = mg_ws_random_mask(); - mg_base64_encode((unsigned char *) &nonce, sizeof(nonce), key); - - mbuf_init(&auth, 0); - if (user != NULL) { - mg_basic_auth_header(user, pass, &auth); - } - - /* - * NOTE: the (auth.buf == NULL ? "" : auth.buf) is because cc3200 libc is - * broken: it doesn't like zero length to be passed to %.*s - * i.e. sprintf("f%.*so", (int)0, NULL), yields `f\0o`. - * because it handles NULL specially (and incorrectly). - */ - mg_printf(nc, - "GET %s HTTP/1.1\r\n" - "Upgrade: websocket\r\n" - "Connection: Upgrade\r\n" - "%.*s" - "Sec-WebSocket-Version: 13\r\n" - "Sec-WebSocket-Key: %s\r\n", - path, (int) auth.len, (auth.buf == NULL ? "" : auth.buf), key); - - /* TODO(mkm): take default hostname from http proto data if host == NULL */ - if (host != MG_WS_NO_HOST_HEADER_MAGIC) { - mg_printf(nc, "Host: %s\r\n", host); - } - if (protocol != NULL) { - mg_printf(nc, "Sec-WebSocket-Protocol: %s\r\n", protocol); - } - if (extra_headers != NULL) { - mg_printf(nc, "%s", extra_headers); - } - mg_printf(nc, "\r\n"); - - mbuf_free(&auth); -} - -void mg_send_websocket_handshake(struct mg_connection *nc, const char *path, - const char *extra_headers) { - mg_send_websocket_handshake2(nc, path, MG_WS_NO_HOST_HEADER_MAGIC, NULL, - extra_headers); -} - -struct mg_connection *mg_connect_ws_opt(struct mg_mgr *mgr, - mg_event_handler_t ev_handler, - struct mg_connect_opts opts, - const char *url, const char *protocol, - const char *extra_headers) { - char *user = NULL, *pass = NULL, *addr = NULL; - const char *path = NULL; - struct mg_connection *nc = - mg_connect_http_base(mgr, ev_handler, opts, "ws://", "wss://", url, &path, - &user, &pass, &addr); - - if (nc != NULL) { - mg_send_websocket_handshake3(nc, path, addr, protocol, extra_headers, user, - pass); - } - - MG_FREE(addr); - MG_FREE(user); - MG_FREE(pass); - return nc; -} - -struct mg_connection *mg_connect_ws(struct mg_mgr *mgr, - mg_event_handler_t ev_handler, - const char *url, const char *protocol, - const char *extra_headers) { - struct mg_connect_opts opts; - memset(&opts, 0, sizeof(opts)); - return mg_connect_ws_opt(mgr, ev_handler, opts, url, protocol, extra_headers); -} -#endif /* MG_ENABLE_HTTP && MG_ENABLE_HTTP_WEBSOCKET */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/util.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "common/base64.h" */ -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ - -/* For platforms with limited libc */ -#ifndef MAX -#define MAX(a, b) ((a) > (b) ? (a) : (b)) -#endif - -const char *mg_skip(const char *s, const char *end, const char *delims, - struct mg_str *v) { - v->p = s; - while (s < end && strchr(delims, *(unsigned char *) s) == NULL) s++; - v->len = s - v->p; - while (s < end && strchr(delims, *(unsigned char *) s) != NULL) s++; - return s; -} - -static int lowercase(const char *s) { - return tolower(*(const unsigned char *) s); -} - -#if MG_ENABLE_FILESYSTEM -int mg_stat(const char *path, cs_stat_t *st) { -#ifdef _WIN32 - wchar_t wpath[MAX_PATH_SIZE]; - to_wchar(path, wpath, ARRAY_SIZE(wpath)); - DBG(("[%ls] -> %d", wpath, _wstati64(wpath, st))); - return _wstati64(wpath, st); -#else - return stat(path, st); -#endif -} - -FILE *mg_fopen(const char *path, const char *mode) { -#ifdef _WIN32 - wchar_t wpath[MAX_PATH_SIZE], wmode[10]; - to_wchar(path, wpath, ARRAY_SIZE(wpath)); - to_wchar(mode, wmode, ARRAY_SIZE(wmode)); - return _wfopen(wpath, wmode); -#else - return fopen(path, mode); -#endif -} - -int mg_open(const char *path, int flag, int mode) { /* LCOV_EXCL_LINE */ -#if defined(_WIN32) && !defined(WINCE) - wchar_t wpath[MAX_PATH_SIZE]; - to_wchar(path, wpath, ARRAY_SIZE(wpath)); - return _wopen(wpath, flag, mode); -#else - return open(path, flag, mode); /* LCOV_EXCL_LINE */ -#endif -} -#endif - -void mg_base64_encode(const unsigned char *src, int src_len, char *dst) { - cs_base64_encode(src, src_len, dst); -} - -int mg_base64_decode(const unsigned char *s, int len, char *dst) { - return cs_base64_decode(s, len, dst, NULL); -} - -#if MG_ENABLE_THREADS -void *mg_start_thread(void *(*f)(void *), void *p) { -#ifdef WINCE - return (void *) CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) f, p, 0, NULL); -#elif defined(_WIN32) - return (void *) _beginthread((void(__cdecl *) (void *) ) f, 0, p); -#else - pthread_t thread_id = (pthread_t) 0; - pthread_attr_t attr; - - (void) pthread_attr_init(&attr); - (void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); - -#if defined(MG_STACK_SIZE) && MG_STACK_SIZE > 1 - (void) pthread_attr_setstacksize(&attr, MG_STACK_SIZE); -#endif - - pthread_create(&thread_id, &attr, f, p); - pthread_attr_destroy(&attr); - - return (void *) thread_id; -#endif -} -#endif /* MG_ENABLE_THREADS */ - -/* Set close-on-exec bit for a given socket. */ -void mg_set_close_on_exec(sock_t sock) { -#if defined(_WIN32) && !defined(WINCE) - (void) SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0); -#elif defined(__unix__) - fcntl(sock, F_SETFD, FD_CLOEXEC); -#else - (void) sock; -#endif -} - -void mg_sock_addr_to_str(const union socket_address *sa, char *buf, size_t len, - int flags) { - int is_v6; - if (buf == NULL || len <= 0) return; - buf[0] = '\0'; -#if MG_ENABLE_IPV6 - is_v6 = sa->sa.sa_family == AF_INET6; -#else - is_v6 = 0; -#endif - if (flags & MG_SOCK_STRINGIFY_IP) { -#if MG_ENABLE_IPV6 - const void *addr = NULL; - char *start = buf; - socklen_t capacity = len; - if (!is_v6) { - addr = &sa->sin.sin_addr; - } else { - addr = (void *) &sa->sin6.sin6_addr; - if (flags & MG_SOCK_STRINGIFY_PORT) { - *buf = '['; - start++; - capacity--; - } - } - if (inet_ntop(sa->sa.sa_family, addr, start, capacity) == NULL) { - *buf = '\0'; - } -#elif defined(_WIN32) || MG_LWIP || (MG_NET_IF == MG_NET_IF_PIC32) - /* Only Windoze Vista (and newer) have inet_ntop() */ - strncpy(buf, inet_ntoa(sa->sin.sin_addr), len); -#else - inet_ntop(AF_INET, (void *) &sa->sin.sin_addr, buf, len); -#endif - } - if (flags & MG_SOCK_STRINGIFY_PORT) { - int port = ntohs(sa->sin.sin_port); - if (flags & MG_SOCK_STRINGIFY_IP) { - snprintf(buf + strlen(buf), len - (strlen(buf) + 1), "%s:%d", - (is_v6 ? "]" : ""), port); - } else { - snprintf(buf, len, "%d", port); - } - } -} - -void mg_conn_addr_to_str(struct mg_connection *nc, char *buf, size_t len, - int flags) { - union socket_address sa; - memset(&sa, 0, sizeof(sa)); - mg_if_get_conn_addr(nc, flags & MG_SOCK_STRINGIFY_REMOTE, &sa); - mg_sock_addr_to_str(&sa, buf, len, flags); -} - -#if MG_ENABLE_HEXDUMP -int mg_hexdump(const void *buf, int len, char *dst, int dst_len) { - const unsigned char *p = (const unsigned char *) buf; - char ascii[17] = ""; - int i, idx, n = 0; - - for (i = 0; i < len; i++) { - idx = i % 16; - if (idx == 0) { - if (i > 0) n += snprintf(dst + n, MAX(dst_len - n, 0), " %s\n", ascii); - n += snprintf(dst + n, MAX(dst_len - n, 0), "%04x ", i); - } - if (dst_len - n < 0) { - return n; - } - n += snprintf(dst + n, MAX(dst_len - n, 0), " %02x", p[i]); - ascii[idx] = p[i] < 0x20 || p[i] > 0x7e ? '.' : p[i]; - ascii[idx + 1] = '\0'; - } - - while (i++ % 16) n += snprintf(dst + n, MAX(dst_len - n, 0), "%s", " "); - n += snprintf(dst + n, MAX(dst_len - n, 0), " %s\n\n", ascii); - - return n; -} - -void mg_hexdump_connection(struct mg_connection *nc, const char *path, - const void *buf, int num_bytes, int ev) { - FILE *fp = NULL; - char *hexbuf, src[60], dst[60]; - int buf_size = num_bytes * 5 + 100; - - if (strcmp(path, "-") == 0) { - fp = stdout; - } else if (strcmp(path, "--") == 0) { - fp = stderr; -#if MG_ENABLE_FILESYSTEM - } else { - fp = mg_fopen(path, "a"); -#endif - } - if (fp == NULL) return; - - mg_conn_addr_to_str(nc, src, sizeof(src), - MG_SOCK_STRINGIFY_IP | MG_SOCK_STRINGIFY_PORT); - mg_conn_addr_to_str(nc, dst, sizeof(dst), MG_SOCK_STRINGIFY_IP | - MG_SOCK_STRINGIFY_PORT | - MG_SOCK_STRINGIFY_REMOTE); - fprintf( - fp, "%lu %p %s %s %s %d\n", (unsigned long) mg_time(), (void *) nc, src, - ev == MG_EV_RECV ? "<-" : ev == MG_EV_SEND - ? "->" - : ev == MG_EV_ACCEPT - ? "" : "XX", - dst, num_bytes); - if (num_bytes > 0 && (hexbuf = (char *) MG_MALLOC(buf_size)) != NULL) { - mg_hexdump(buf, num_bytes, hexbuf, buf_size); - fprintf(fp, "%s", hexbuf); - MG_FREE(hexbuf); - } - if (fp != stdin && fp != stdout) fclose(fp); -} -#endif - -int mg_is_big_endian(void) { - static const int n = 1; - /* TODO(mkm) use compiletime check with 4-byte char literal */ - return ((char *) &n)[0] == 0; -} - -const char *mg_next_comma_list_entry(const char *list, struct mg_str *val, - struct mg_str *eq_val) { - if (list == NULL || *list == '\0') { - /* End of the list */ - list = NULL; - } else { - val->p = list; - if ((list = strchr(val->p, ',')) != NULL) { - /* Comma found. Store length and shift the list ptr */ - val->len = list - val->p; - list++; - } else { - /* This value is the last one */ - list = val->p + strlen(val->p); - val->len = list - val->p; - } - - 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->p = (const char *) memchr(val->p, '=', val->len); - if (eq_val->p != NULL) { - eq_val->p++; /* Skip over '=' character */ - eq_val->len = val->p + val->len - eq_val->p; - val->len = (eq_val->p - val->p) - 1; - } - } - } - - return list; -} - -int mg_match_prefix_n(const struct mg_str pattern, const struct mg_str str) { - const char *or_str; - size_t len, i = 0, j = 0; - int res; - - if ((or_str = (const char *) memchr(pattern.p, '|', pattern.len)) != NULL) { - struct mg_str pstr = {pattern.p, (size_t)(or_str - pattern.p)}; - res = mg_match_prefix_n(pstr, str); - if (res > 0) return res; - pstr.p = or_str + 1; - pstr.len = (pattern.p + pattern.len) - (or_str + 1); - return mg_match_prefix_n(pstr, str); - } - - for (; i < pattern.len; i++, j++) { - if (pattern.p[i] == '?' && j != str.len) { - continue; - } else if (pattern.p[i] == '$') { - return j == str.len ? (int) j : -1; - } else if (pattern.p[i] == '*') { - i++; - if (pattern.p[i] == '*') { - i++; - len = str.len - j; - } else { - len = 0; - while (j + len != str.len && str.p[j + len] != '/') { - len++; - } - } - if (i == pattern.len) { - return j + len; - } - do { - const struct mg_str pstr = {pattern.p + i, pattern.len - i}; - const struct mg_str sstr = {str.p + j + len, str.len - j - len}; - res = mg_match_prefix_n(pstr, sstr); - } while (res == -1 && len-- > 0); - return res == -1 ? -1 : (int) (j + res + len); - } else if (lowercase(&pattern.p[i]) != lowercase(&str.p[j])) { - return -1; - } - } - return j; -} - -int mg_match_prefix(const char *pattern, int pattern_len, const char *str) { - const struct mg_str pstr = {pattern, (size_t) pattern_len}; - return mg_match_prefix_n(pstr, mg_mk_str(str)); -} - -DO_NOT_WARN_UNUSED MG_INTERNAL int mg_get_errno(void) { -#ifndef WINCE - return errno; -#else - /* TODO(alashkin): translate error codes? */ - return GetLastError(); -#endif -} - -void mg_mbuf_append_base64_putc(char ch, void *user_data) { - struct mbuf *mbuf = (struct mbuf *) user_data; - mbuf_append(mbuf, &ch, sizeof(ch)); -} - -void mg_mbuf_append_base64(struct mbuf *mbuf, const void *data, size_t len) { - struct cs_base64_ctx ctx; - cs_base64_init(&ctx, mg_mbuf_append_base64_putc, mbuf); - cs_base64_update(&ctx, (const char *) data, len); - cs_base64_finish(&ctx); -} - -void mg_basic_auth_header(const char *user, const char *pass, - struct mbuf *buf) { - const char *header_prefix = "Authorization: Basic "; - const char *header_suffix = "\r\n"; - - struct cs_base64_ctx ctx; - cs_base64_init(&ctx, mg_mbuf_append_base64_putc, buf); - - mbuf_append(buf, header_prefix, strlen(header_prefix)); - - cs_base64_update(&ctx, user, strlen(user)); - if (pass != NULL) { - cs_base64_update(&ctx, ":", 1); - cs_base64_update(&ctx, pass, strlen(pass)); - } - cs_base64_finish(&ctx); - mbuf_append(buf, header_suffix, strlen(header_suffix)); -} -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/mqtt.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_MQTT - -#include - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/mqtt.h" */ - -static uint16_t getu16(const char *p) { - const uint8_t *up = (const uint8_t *) p; - return (up[0] << 8) + up[1]; -} - -static const char *scanto(const char *p, struct mg_str *s) { - s->len = getu16(p); - s->p = p + 2; - return s->p + s->len; -} - -MG_INTERNAL int parse_mqtt(struct mbuf *io, struct mg_mqtt_message *mm) { - uint8_t header; - size_t len = 0; - int cmd; - const char *p = &io->buf[1], *end; - - if (io->len < 2) return -1; - header = io->buf[0]; - cmd = header >> 4; - - /* decode mqtt variable length */ - do { - len += (*p & 127) << 7 * (p - &io->buf[1]); - } while ((*p++ & 128) != 0 && ((size_t)(p - io->buf) <= io->len)); - - end = p + len; - if (end > io->buf + io->len + 1) { - return -1; - } - - mm->cmd = cmd; - mm->qos = MG_MQTT_GET_QOS(header); - - switch (cmd) { - case MG_MQTT_CMD_CONNECT: { - p = scanto(p, &mm->protocol_name); - mm->protocol_version = *(uint8_t *) p++; - mm->connect_flags = *(uint8_t *) p++; - mm->keep_alive_timer = getu16(p); - p += 2; - if (p < end) p = scanto(p, &mm->client_id); - if (p < end && (mm->connect_flags & MG_MQTT_HAS_WILL)) - p = scanto(p, &mm->will_topic); - if (p < end && (mm->connect_flags & MG_MQTT_HAS_WILL)) - p = scanto(p, &mm->will_message); - if (p < end && (mm->connect_flags & MG_MQTT_HAS_USER_NAME)) - p = scanto(p, &mm->user_name); - if (p < end && (mm->connect_flags & MG_MQTT_HAS_PASSWORD)) - p = scanto(p, &mm->password); - - LOG(LL_DEBUG, - ("%d %2x %d proto [%.*s] client_id [%.*s] will_topic [%.*s] " - "will_msg [%.*s] user_name [%.*s] password [%.*s]", - len, (int) mm->connect_flags, (int) mm->keep_alive_timer, - (int) mm->protocol_name.len, mm->protocol_name.p, - (int) mm->client_id.len, mm->client_id.p, (int) mm->will_topic.len, - mm->will_topic.p, (int) mm->will_message.len, mm->will_message.p, - (int) mm->user_name.len, mm->user_name.p, (int) mm->password.len, - mm->password.p)); - break; - } - case MG_MQTT_CMD_CONNACK: - mm->connack_ret_code = p[1]; - break; - case MG_MQTT_CMD_PUBACK: - case MG_MQTT_CMD_PUBREC: - case MG_MQTT_CMD_PUBREL: - case MG_MQTT_CMD_PUBCOMP: - case MG_MQTT_CMD_SUBACK: - mm->message_id = getu16(p); - break; - case MG_MQTT_CMD_PUBLISH: { - if (MG_MQTT_GET_QOS(header) > 0) { - mm->message_id = getu16(p); - p += 2; - } - p = scanto(p, &mm->topic); - - mm->payload.p = p; - mm->payload.len = end - p; - break; - } - case MG_MQTT_CMD_SUBSCRIBE: - mm->message_id = getu16(p); - p += 2; - /* - * topic expressions are left in the payload and can be parsed with - * `mg_mqtt_next_subscribe_topic` - */ - mm->payload.p = p; - mm->payload.len = end - p; - break; - default: - /* Unhandled command */ - break; - } - - return end - io->buf; -} - -static void mqtt_handler(struct mg_connection *nc, int ev, void *ev_data) { - int len; - struct mbuf *io = &nc->recv_mbuf; - struct mg_mqtt_message mm; - memset(&mm, 0, sizeof(mm)); - - nc->handler(nc, ev, ev_data); - - switch (ev) { - case MG_EV_RECV: - len = parse_mqtt(io, &mm); - if (len == -1) break; /* not fully buffered */ - nc->handler(nc, MG_MQTT_EVENT_BASE + mm.cmd, &mm); - mbuf_remove(io, len); - break; - } -} - -static void mg_mqtt_proto_data_destructor(void *proto_data) { - MG_FREE(proto_data); -} - -void mg_set_protocol_mqtt(struct mg_connection *nc) { - nc->proto_handler = mqtt_handler; - nc->proto_data = MG_CALLOC(1, sizeof(struct mg_mqtt_proto_data)); - nc->proto_data_destructor = mg_mqtt_proto_data_destructor; -} - -void mg_send_mqtt_handshake(struct mg_connection *nc, const char *client_id) { - static struct mg_send_mqtt_handshake_opts opts; - mg_send_mqtt_handshake_opt(nc, client_id, opts); -} - -void mg_send_mqtt_handshake_opt(struct mg_connection *nc, const char *client_id, - struct mg_send_mqtt_handshake_opts opts) { - uint8_t header = MG_MQTT_CMD_CONNECT << 4; - uint8_t rem_len; - uint16_t keep_alive; - uint16_t len; - struct mg_mqtt_proto_data *pd = (struct mg_mqtt_proto_data *) nc->proto_data; - - /* - * 9: version_header(len, magic_string, version_number), 1: flags, 2: - * keep-alive timer, - * 2: client_identifier_len, n: client_id - */ - rem_len = 9 + 1 + 2 + 2 + (uint8_t) strlen(client_id); - - if (opts.user_name != NULL) { - opts.flags |= MG_MQTT_HAS_USER_NAME; - rem_len += (uint8_t) strlen(opts.user_name) + 2; - } - if (opts.password != NULL) { - opts.flags |= MG_MQTT_HAS_PASSWORD; - rem_len += (uint8_t) strlen(opts.password) + 2; - } - if (opts.will_topic != NULL && opts.will_message != NULL) { - opts.flags |= MG_MQTT_HAS_WILL; - rem_len += (uint8_t) strlen(opts.will_topic) + 2; - rem_len += (uint8_t) strlen(opts.will_message) + 2; - } - - mg_send(nc, &header, 1); - mg_send(nc, &rem_len, 1); - mg_send(nc, "\00\06MQIsdp\03", 9); - mg_send(nc, &opts.flags, 1); - - if (opts.keep_alive == 0) { - opts.keep_alive = 60; - } - - keep_alive = htons(opts.keep_alive); - mg_send(nc, &keep_alive, 2); - - len = htons((uint16_t) strlen(client_id)); - mg_send(nc, &len, 2); - mg_send(nc, client_id, strlen(client_id)); - - if (opts.flags & MG_MQTT_HAS_WILL) { - len = htons((uint16_t) strlen(opts.will_topic)); - mg_send(nc, &len, 2); - mg_send(nc, opts.will_topic, strlen(opts.will_topic)); - - len = htons((uint16_t) strlen(opts.will_message)); - mg_send(nc, &len, 2); - mg_send(nc, opts.will_message, strlen(opts.will_message)); - } - - if (opts.flags & MG_MQTT_HAS_USER_NAME) { - len = htons((uint16_t) strlen(opts.user_name)); - mg_send(nc, &len, 2); - mg_send(nc, opts.user_name, strlen(opts.user_name)); - } - if (opts.flags & MG_MQTT_HAS_PASSWORD) { - len = htons((uint16_t) strlen(opts.password)); - mg_send(nc, &len, 2); - mg_send(nc, opts.password, strlen(opts.password)); - } - - if (pd != NULL) { - pd->keep_alive = opts.keep_alive; - } -} - -static void mg_mqtt_prepend_header(struct mg_connection *nc, uint8_t cmd, - uint8_t flags, size_t len) { - size_t off = nc->send_mbuf.len - len; - uint8_t header = cmd << 4 | (uint8_t) flags; - - uint8_t buf[1 + sizeof(size_t)]; - uint8_t *vlen = &buf[1]; - - assert(nc->send_mbuf.len >= len); - - buf[0] = header; - - /* mqtt variable length encoding */ - do { - *vlen = len % 0x80; - len /= 0x80; - if (len > 0) *vlen |= 0x80; - vlen++; - } while (len > 0); - - mbuf_insert(&nc->send_mbuf, off, buf, vlen - buf); -} - -void mg_mqtt_publish(struct mg_connection *nc, const char *topic, - uint16_t message_id, int flags, const void *data, - size_t len) { - size_t old_len = nc->send_mbuf.len; - - uint16_t topic_len = htons((uint16_t) strlen(topic)); - uint16_t message_id_net = htons(message_id); - - mg_send(nc, &topic_len, 2); - mg_send(nc, topic, strlen(topic)); - if (MG_MQTT_GET_QOS(flags) > 0) { - mg_send(nc, &message_id_net, 2); - } - mg_send(nc, data, len); - - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_PUBLISH, flags, - nc->send_mbuf.len - old_len); -} - -void mg_mqtt_subscribe(struct mg_connection *nc, - const struct mg_mqtt_topic_expression *topics, - size_t topics_len, uint16_t message_id) { - size_t old_len = nc->send_mbuf.len; - - uint16_t message_id_n = htons(message_id); - size_t i; - - mg_send(nc, (char *) &message_id_n, 2); - for (i = 0; i < topics_len; i++) { - uint16_t topic_len_n = htons((uint16_t) strlen(topics[i].topic)); - mg_send(nc, &topic_len_n, 2); - mg_send(nc, topics[i].topic, strlen(topics[i].topic)); - mg_send(nc, &topics[i].qos, 1); - } - - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_SUBSCRIBE, MG_MQTT_QOS(1), - nc->send_mbuf.len - old_len); -} - -int mg_mqtt_next_subscribe_topic(struct mg_mqtt_message *msg, - struct mg_str *topic, uint8_t *qos, int pos) { - unsigned char *buf = (unsigned char *) msg->payload.p + pos; - - if ((size_t) pos >= msg->payload.len) { - return -1; - } - - topic->len = buf[0] << 8 | buf[1]; - topic->p = (char *) buf + 2; - *qos = buf[2 + topic->len]; - return pos + 2 + topic->len + 1; -} - -void mg_mqtt_unsubscribe(struct mg_connection *nc, char **topics, - size_t topics_len, uint16_t message_id) { - size_t old_len = nc->send_mbuf.len; - - uint16_t message_id_n = htons(message_id); - size_t i; - - mg_send(nc, (char *) &message_id_n, 2); - for (i = 0; i < topics_len; i++) { - uint16_t topic_len_n = htons((uint16_t) strlen(topics[i])); - mg_send(nc, &topic_len_n, 2); - mg_send(nc, topics[i], strlen(topics[i])); - } - - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_UNSUBSCRIBE, MG_MQTT_QOS(1), - nc->send_mbuf.len - old_len); -} - -void mg_mqtt_connack(struct mg_connection *nc, uint8_t return_code) { - uint8_t unused = 0; - mg_send(nc, &unused, 1); - mg_send(nc, &return_code, 1); - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_CONNACK, 0, 2); -} - -/* - * Sends a command which contains only a `message_id` and a QoS level of 1. - * - * Helper function. - */ -static void mg_send_mqtt_short_command(struct mg_connection *nc, uint8_t cmd, - uint16_t message_id) { - uint16_t message_id_net = htons(message_id); - mg_send(nc, &message_id_net, 2); - mg_mqtt_prepend_header(nc, cmd, MG_MQTT_QOS(1), 2); -} - -void mg_mqtt_puback(struct mg_connection *nc, uint16_t message_id) { - mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBACK, message_id); -} - -void mg_mqtt_pubrec(struct mg_connection *nc, uint16_t message_id) { - mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBREC, message_id); -} - -void mg_mqtt_pubrel(struct mg_connection *nc, uint16_t message_id) { - mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBREL, message_id); -} - -void mg_mqtt_pubcomp(struct mg_connection *nc, uint16_t message_id) { - mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBCOMP, message_id); -} - -void mg_mqtt_suback(struct mg_connection *nc, uint8_t *qoss, size_t qoss_len, - uint16_t message_id) { - size_t i; - uint16_t message_id_net = htons(message_id); - mg_send(nc, &message_id_net, 2); - for (i = 0; i < qoss_len; i++) { - mg_send(nc, &qoss[i], 1); - } - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_SUBACK, MG_MQTT_QOS(1), 2 + qoss_len); -} - -void mg_mqtt_unsuback(struct mg_connection *nc, uint16_t message_id) { - mg_send_mqtt_short_command(nc, MG_MQTT_CMD_UNSUBACK, message_id); -} - -void mg_mqtt_ping(struct mg_connection *nc) { - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_PINGREQ, 0, 0); -} - -void mg_mqtt_pong(struct mg_connection *nc) { - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_PINGRESP, 0, 0); -} - -void mg_mqtt_disconnect(struct mg_connection *nc) { - mg_mqtt_prepend_header(nc, MG_MQTT_CMD_DISCONNECT, 0, 0); -} - -#endif /* MG_ENABLE_MQTT */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/mqtt_server.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/mqtt-server.h" */ - -#if MG_ENABLE_MQTT_BROKER - -static void mg_mqtt_session_init(struct mg_mqtt_broker *brk, - struct mg_mqtt_session *s, - struct mg_connection *nc) { - s->brk = brk; - s->subscriptions = NULL; - s->num_subscriptions = 0; - s->nc = nc; -} - -static void mg_mqtt_add_session(struct mg_mqtt_session *s) { - LIST_INSERT_HEAD(&s->brk->sessions, s, link); -} - -static void mg_mqtt_remove_session(struct mg_mqtt_session *s) { - LIST_REMOVE(s, link); -} - -static void mg_mqtt_destroy_session(struct mg_mqtt_session *s) { - size_t i; - for (i = 0; i < s->num_subscriptions; i++) { - MG_FREE((void *) s->subscriptions[i].topic); - } - MG_FREE(s->subscriptions); - MG_FREE(s); -} - -static void mg_mqtt_close_session(struct mg_mqtt_session *s) { - mg_mqtt_remove_session(s); - mg_mqtt_destroy_session(s); -} - -void mg_mqtt_broker_init(struct mg_mqtt_broker *brk, void *user_data) { - LIST_INIT(&brk->sessions); - brk->user_data = user_data; -} - -static void mg_mqtt_broker_handle_connect(struct mg_mqtt_broker *brk, - struct mg_connection *nc) { - struct mg_mqtt_session *s = (struct mg_mqtt_session *) calloc(1, sizeof *s); - if (s == NULL) { - /* LCOV_EXCL_START */ - mg_mqtt_connack(nc, MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE); - return; - /* LCOV_EXCL_STOP */ - } - - /* TODO(mkm): check header (magic and version) */ - - mg_mqtt_session_init(brk, s, nc); - s->user_data = nc->user_data; - nc->user_data = s; - mg_mqtt_add_session(s); - - mg_mqtt_connack(nc, MG_EV_MQTT_CONNACK_ACCEPTED); -} - -static void mg_mqtt_broker_handle_subscribe(struct mg_connection *nc, - struct mg_mqtt_message *msg) { - struct mg_mqtt_session *ss = (struct mg_mqtt_session *) nc->user_data; - uint8_t qoss[512]; - size_t qoss_len = 0; - struct mg_str topic; - uint8_t qos; - int pos; - struct mg_mqtt_topic_expression *te; - - for (pos = 0; - (pos = mg_mqtt_next_subscribe_topic(msg, &topic, &qos, pos)) != -1;) { - qoss[qoss_len++] = qos; - } - - ss->subscriptions = (struct mg_mqtt_topic_expression *) realloc( - ss->subscriptions, sizeof(*ss->subscriptions) * qoss_len); - for (pos = 0; - (pos = mg_mqtt_next_subscribe_topic(msg, &topic, &qos, pos)) != -1; - ss->num_subscriptions++) { - te = &ss->subscriptions[ss->num_subscriptions]; - te->topic = (char *) malloc(topic.len + 1); - te->qos = qos; - strncpy((char *) te->topic, topic.p, topic.len + 1); - } - - mg_mqtt_suback(nc, qoss, qoss_len, msg->message_id); -} - -/* - * Matches a topic against a topic expression - * - * See http://goo.gl/iWk21X - * - * Returns 1 if it matches; 0 otherwise. - */ -static int mg_mqtt_match_topic_expression(const char *exp, - const struct mg_str *topic) { - /* TODO(mkm): implement real matching */ - size_t len = strlen(exp); - if (strchr(exp, '#')) { - len -= 2; - if (topic->len < len) { - len = topic->len; - } - } - return strncmp(topic->p, exp, len) == 0; -} - -static void mg_mqtt_broker_handle_publish(struct mg_mqtt_broker *brk, - struct mg_mqtt_message *msg) { - struct mg_mqtt_session *s; - size_t i; - - for (s = mg_mqtt_next(brk, NULL); s != NULL; s = mg_mqtt_next(brk, s)) { - for (i = 0; i < s->num_subscriptions; i++) { - if (mg_mqtt_match_topic_expression(s->subscriptions[i].topic, - &msg->topic)) { - char buf[100], *p = buf; - mg_asprintf(&p, sizeof(buf), "%.*s", (int) msg->topic.len, - msg->topic.p); - if (p == NULL) { - return; - } - mg_mqtt_publish(s->nc, p, 0, 0, msg->payload.p, msg->payload.len); - if (p != buf) { - MG_FREE(p); - } - break; - } - } - } -} - -void mg_mqtt_broker(struct mg_connection *nc, int ev, void *data) { - struct mg_mqtt_message *msg = (struct mg_mqtt_message *) data; - struct mg_mqtt_broker *brk; - - if (nc->listener) { - brk = (struct mg_mqtt_broker *) nc->listener->user_data; - } else { - brk = (struct mg_mqtt_broker *) nc->user_data; - } - - switch (ev) { - case MG_EV_ACCEPT: - mg_set_protocol_mqtt(nc); - nc->user_data = NULL; /* Clear up the inherited pointer to broker */ - break; - case MG_EV_MQTT_CONNECT: - mg_mqtt_broker_handle_connect(brk, nc); - break; - case MG_EV_MQTT_SUBSCRIBE: - mg_mqtt_broker_handle_subscribe(nc, msg); - break; - case MG_EV_MQTT_PUBLISH: - mg_mqtt_broker_handle_publish(brk, msg); - break; - case MG_EV_CLOSE: - if (nc->listener && nc->user_data != NULL) { - mg_mqtt_close_session((struct mg_mqtt_session *) nc->user_data); - } - break; - } -} - -struct mg_mqtt_session *mg_mqtt_next(struct mg_mqtt_broker *brk, - struct mg_mqtt_session *s) { - return s == NULL ? LIST_FIRST(&brk->sessions) : LIST_NEXT(s, link); -} - -#endif /* MG_ENABLE_MQTT_BROKER */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/dns.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_DNS - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/dns.h" */ - -static int mg_dns_tid = 0xa0; - -struct mg_dns_header { - uint16_t transaction_id; - uint16_t flags; - uint16_t num_questions; - uint16_t num_answers; - uint16_t num_authority_prs; - uint16_t num_other_prs; -}; - -struct mg_dns_resource_record *mg_dns_next_record( - struct mg_dns_message *msg, int query, - struct mg_dns_resource_record *prev) { - struct mg_dns_resource_record *rr; - - for (rr = (prev == NULL ? msg->answers : prev + 1); - rr - msg->answers < msg->num_answers; rr++) { - if (rr->rtype == query) { - return rr; - } - } - return NULL; -} - -int mg_dns_parse_record_data(struct mg_dns_message *msg, - struct mg_dns_resource_record *rr, void *data, - size_t data_len) { - switch (rr->rtype) { - case MG_DNS_A_RECORD: - if (data_len < sizeof(struct in_addr)) { - return -1; - } - if (rr->rdata.p + data_len > msg->pkt.p + msg->pkt.len) { - return -1; - } - memcpy(data, rr->rdata.p, data_len); - return 0; -#if MG_ENABLE_IPV6 - case MG_DNS_AAAA_RECORD: - if (data_len < sizeof(struct in6_addr)) { - return -1; /* LCOV_EXCL_LINE */ - } - memcpy(data, rr->rdata.p, data_len); - return 0; -#endif - case MG_DNS_CNAME_RECORD: - mg_dns_uncompress_name(msg, &rr->rdata, (char *) data, data_len); - return 0; - } - - return -1; -} - -int mg_dns_insert_header(struct mbuf *io, size_t pos, - struct mg_dns_message *msg) { - struct mg_dns_header header; - - memset(&header, 0, sizeof(header)); - header.transaction_id = msg->transaction_id; - header.flags = htons(msg->flags); - header.num_questions = htons(msg->num_questions); - header.num_answers = htons(msg->num_answers); - - return mbuf_insert(io, pos, &header, sizeof(header)); -} - -int mg_dns_copy_questions(struct mbuf *io, struct mg_dns_message *msg) { - unsigned char *begin, *end; - struct mg_dns_resource_record *last_q; - if (msg->num_questions <= 0) return 0; - begin = (unsigned char *) msg->pkt.p + sizeof(struct mg_dns_header); - last_q = &msg->questions[msg->num_questions - 1]; - end = (unsigned char *) last_q->name.p + last_q->name.len + 4; - return mbuf_append(io, begin, end - begin); -} - -int mg_dns_encode_name(struct mbuf *io, const char *name, size_t len) { - const char *s; - unsigned char n; - size_t pos = io->len; - - do { - if ((s = strchr(name, '.')) == NULL) { - s = name + len; - } - - if (s - name > 127) { - return -1; /* TODO(mkm) cover */ - } - n = s - name; /* chunk length */ - mbuf_append(io, &n, 1); /* send length */ - mbuf_append(io, name, n); - - if (*s == '.') { - n++; - } - - name += n; - len -= n; - } while (*s != '\0'); - mbuf_append(io, "\0", 1); /* Mark end of host name */ - - return io->len - pos; -} - -int mg_dns_encode_record(struct mbuf *io, struct mg_dns_resource_record *rr, - const char *name, size_t nlen, const void *rdata, - size_t rlen) { - size_t pos = io->len; - uint16_t u16; - uint32_t u32; - - if (rr->kind == MG_DNS_INVALID_RECORD) { - return -1; /* LCOV_EXCL_LINE */ - } - - if (mg_dns_encode_name(io, name, nlen) == -1) { - return -1; - } - - u16 = htons(rr->rtype); - mbuf_append(io, &u16, 2); - u16 = htons(rr->rclass); - mbuf_append(io, &u16, 2); - - if (rr->kind == MG_DNS_ANSWER) { - u32 = htonl(rr->ttl); - mbuf_append(io, &u32, 4); - - if (rr->rtype == MG_DNS_CNAME_RECORD) { - int clen; - /* fill size after encoding */ - size_t off = io->len; - mbuf_append(io, &u16, 2); - if ((clen = mg_dns_encode_name(io, (const char *) rdata, rlen)) == -1) { - return -1; - } - u16 = clen; - io->buf[off] = u16 >> 8; - io->buf[off + 1] = u16 & 0xff; - } else { - u16 = htons((uint16_t) rlen); - mbuf_append(io, &u16, 2); - mbuf_append(io, rdata, rlen); - } - } - - return io->len - pos; -} - -void mg_send_dns_query(struct mg_connection *nc, const char *name, - int query_type) { - struct mg_dns_message *msg = - (struct mg_dns_message *) MG_CALLOC(1, sizeof(*msg)); - struct mbuf pkt; - struct mg_dns_resource_record *rr = &msg->questions[0]; - - DBG(("%s %d", name, query_type)); - - mbuf_init(&pkt, 64 /* Start small, it'll grow as needed. */); - - msg->transaction_id = ++mg_dns_tid; - msg->flags = 0x100; - msg->num_questions = 1; - - mg_dns_insert_header(&pkt, 0, msg); - - rr->rtype = query_type; - rr->rclass = 1; /* Class: inet */ - rr->kind = MG_DNS_QUESTION; - - if (mg_dns_encode_record(&pkt, rr, name, strlen(name), NULL, 0) == -1) { - /* TODO(mkm): return an error code */ - goto cleanup; /* LCOV_EXCL_LINE */ - } - - /* TCP DNS requires messages to be prefixed with len */ - if (!(nc->flags & MG_F_UDP)) { - uint16_t len = htons((uint16_t) pkt.len); - mbuf_insert(&pkt, 0, &len, 2); - } - - mg_send(nc, pkt.buf, pkt.len); - mbuf_free(&pkt); - -cleanup: - MG_FREE(msg); -} - -static unsigned char *mg_parse_dns_resource_record( - unsigned char *data, unsigned char *end, struct mg_dns_resource_record *rr, - int reply) { - unsigned char *name = data; - int chunk_len, data_len; - - while (data < end && (chunk_len = *data)) { - if (((unsigned char *) data)[0] & 0xc0) { - data += 1; - break; - } - data += chunk_len + 1; - } - - if (data > end - 5) { - return NULL; - } - - rr->name.p = (char *) name; - rr->name.len = data - name + 1; - data++; - - rr->rtype = data[0] << 8 | data[1]; - data += 2; - - rr->rclass = data[0] << 8 | data[1]; - data += 2; - - rr->kind = reply ? MG_DNS_ANSWER : MG_DNS_QUESTION; - if (reply) { - if (data >= end - 6) { - return NULL; - } - - rr->ttl = (uint32_t) data[0] << 24 | (uint32_t) data[1] << 16 | - data[2] << 8 | data[3]; - data += 4; - - data_len = *data << 8 | *(data + 1); - data += 2; - - rr->rdata.p = (char *) data; - rr->rdata.len = data_len; - data += data_len; - } - return data; -} - -int mg_parse_dns(const char *buf, int len, struct mg_dns_message *msg) { - struct mg_dns_header *header = (struct mg_dns_header *) buf; - unsigned char *data = (unsigned char *) buf + sizeof(*header); - unsigned char *end = (unsigned char *) buf + len; - int i; - - memset(msg, 0, sizeof(*msg)); - msg->pkt.p = buf; - msg->pkt.len = len; - - if (len < (int) sizeof(*header)) return -1; - - msg->transaction_id = header->transaction_id; - msg->flags = ntohs(header->flags); - msg->num_questions = ntohs(header->num_questions); - if (msg->num_questions > (int) ARRAY_SIZE(msg->questions)) { - msg->num_questions = (int) ARRAY_SIZE(msg->questions); - } - msg->num_answers = ntohs(header->num_answers); - if (msg->num_answers > (int) ARRAY_SIZE(msg->answers)) { - msg->num_answers = (int) ARRAY_SIZE(msg->answers); - } - - for (i = 0; i < msg->num_questions; i++) { - data = mg_parse_dns_resource_record(data, end, &msg->questions[i], 0); - if (data == NULL) return -1; - } - - for (i = 0; i < msg->num_answers; i++) { - data = mg_parse_dns_resource_record(data, end, &msg->answers[i], 1); - if (data == NULL) return -1; - } - - return 0; -} - -size_t mg_dns_uncompress_name(struct mg_dns_message *msg, struct mg_str *name, - char *dst, int dst_len) { - int chunk_len; - char *old_dst = dst; - const unsigned char *data = (unsigned char *) name->p; - const unsigned char *end = (unsigned char *) msg->pkt.p + msg->pkt.len; - - if (data >= end) { - return 0; - } - - while ((chunk_len = *data++)) { - int leeway = dst_len - (dst - old_dst); - if (data >= end) { - return 0; - } - - if (chunk_len & 0xc0) { - uint16_t off = (data[-1] & (~0xc0)) << 8 | data[0]; - if (off >= msg->pkt.len) { - return 0; - } - data = (unsigned char *) msg->pkt.p + off; - continue; - } - if (chunk_len > leeway) { - chunk_len = leeway; - } - - if (data + chunk_len >= end) { - return 0; - } - - memcpy(dst, data, chunk_len); - data += chunk_len; - dst += chunk_len; - leeway -= chunk_len; - if (leeway == 0) { - return dst - old_dst; - } - *dst++ = '.'; - } - - if (dst != old_dst) { - *--dst = 0; - } - return dst - old_dst; -} - -static void dns_handler(struct mg_connection *nc, int ev, void *ev_data) { - struct mbuf *io = &nc->recv_mbuf; - struct mg_dns_message msg; - - /* Pass low-level events to the user handler */ - nc->handler(nc, ev, ev_data); - - switch (ev) { - case MG_EV_RECV: - if (!(nc->flags & MG_F_UDP)) { - mbuf_remove(&nc->recv_mbuf, 2); - } - if (mg_parse_dns(nc->recv_mbuf.buf, nc->recv_mbuf.len, &msg) == -1) { - /* reply + recursion allowed + format error */ - memset(&msg, 0, sizeof(msg)); - msg.flags = 0x8081; - mg_dns_insert_header(io, 0, &msg); - if (!(nc->flags & MG_F_UDP)) { - uint16_t len = htons((uint16_t) io->len); - mbuf_insert(io, 0, &len, 2); - } - mg_send(nc, io->buf, io->len); - } else { - /* Call user handler with parsed message */ - nc->handler(nc, MG_DNS_MESSAGE, &msg); - } - mbuf_remove(io, io->len); - break; - } -} - -void mg_set_protocol_dns(struct mg_connection *nc) { - nc->proto_handler = dns_handler; -} - -#endif /* MG_ENABLE_DNS */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/dns_server.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_DNS_SERVER - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/dns-server.h" */ - -struct mg_dns_reply mg_dns_create_reply(struct mbuf *io, - struct mg_dns_message *msg) { - struct mg_dns_reply rep; - rep.msg = msg; - rep.io = io; - rep.start = io->len; - - /* reply + recursion allowed */ - msg->flags |= 0x8080; - mg_dns_copy_questions(io, msg); - - msg->num_answers = 0; - return rep; -} - -void mg_dns_send_reply(struct mg_connection *nc, struct mg_dns_reply *r) { - size_t sent = r->io->len - r->start; - mg_dns_insert_header(r->io, r->start, r->msg); - if (!(nc->flags & MG_F_UDP)) { - uint16_t len = htons((uint16_t) sent); - mbuf_insert(r->io, r->start, &len, 2); - } - - if (&nc->send_mbuf != r->io) { - mg_send(nc, r->io->buf + r->start, r->io->len - r->start); - r->io->len = r->start; - } -} - -int mg_dns_reply_record(struct mg_dns_reply *reply, - struct mg_dns_resource_record *question, - const char *name, int rtype, int ttl, const void *rdata, - size_t rdata_len) { - struct mg_dns_message *msg = (struct mg_dns_message *) reply->msg; - char rname[512]; - struct mg_dns_resource_record *ans = &msg->answers[msg->num_answers]; - if (msg->num_answers >= MG_MAX_DNS_ANSWERS) { - return -1; /* LCOV_EXCL_LINE */ - } - - if (name == NULL) { - name = rname; - rname[511] = 0; - mg_dns_uncompress_name(msg, &question->name, rname, sizeof(rname) - 1); - } - - *ans = *question; - ans->kind = MG_DNS_ANSWER; - ans->rtype = rtype; - ans->ttl = ttl; - - if (mg_dns_encode_record(reply->io, ans, name, strlen(name), rdata, - rdata_len) == -1) { - return -1; /* LCOV_EXCL_LINE */ - }; - - msg->num_answers++; - return 0; -} - -#endif /* MG_ENABLE_DNS_SERVER */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/resolv.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_ASYNC_RESOLVER - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/resolv.h" */ - -#ifndef MG_DEFAULT_NAMESERVER -#define MG_DEFAULT_NAMESERVER "8.8.8.8" -#endif - -static const char *mg_default_dns_server = "udp://" MG_DEFAULT_NAMESERVER ":53"; - -MG_INTERNAL char mg_dns_server[256]; - -struct mg_resolve_async_request { - char name[1024]; - int query; - mg_resolve_callback_t callback; - void *data; - time_t timeout; - int max_retries; - enum mg_resolve_err err; - - /* state */ - time_t last_time; - int retries; -}; - -/* - * Find what nameserver to use. - * - * Return 0 if OK, -1 if error - */ -static int mg_get_ip_address_of_nameserver(char *name, size_t name_len) { - int ret = -1; - -#ifdef _WIN32 - int i; - LONG err; - HKEY hKey, hSub; - wchar_t subkey[512], value[128], - *key = L"SYSTEM\\ControlSet001\\Services\\Tcpip\\Parameters\\Interfaces"; - - if ((err = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ, &hKey)) != - ERROR_SUCCESS) { - fprintf(stderr, "cannot open reg key %S: %ld\n", key, err); - ret = -1; - } else { - for (ret = -1, i = 0; 1; i++) { - DWORD subkey_size = sizeof(subkey), type, len = sizeof(value); - if (RegEnumKeyExW(hKey, i, subkey, &subkey_size, NULL, NULL, NULL, - NULL) != ERROR_SUCCESS) { - break; - } - if (RegOpenKeyExW(hKey, subkey, 0, KEY_READ, &hSub) == ERROR_SUCCESS && - (RegQueryValueExW(hSub, L"NameServer", 0, &type, (void *) value, - &len) == ERROR_SUCCESS || - RegQueryValueExW(hSub, L"DhcpNameServer", 0, &type, (void *) value, - &len) == ERROR_SUCCESS)) { - /* - * See https://github.com/cesanta/mongoose/issues/176 - * The value taken from the registry can be empty, a single - * IP address, or multiple IP addresses separated by comma. - * If it's empty, check the next interface. - * If it's multiple IP addresses, take the first one. - */ - wchar_t *comma = wcschr(value, ','); - if (value[0] == '\0') { - continue; - } - if (comma != NULL) { - *comma = '\0'; - } - snprintf(name, name_len, "udp://%S:53", value); - ret = 0; - RegCloseKey(hSub); - break; - } - } - RegCloseKey(hKey); - } -#elif MG_ENABLE_FILESYSTEM - FILE *fp; - char line[512]; - - if ((fp = mg_fopen("/etc/resolv.conf", "r")) == NULL) { - ret = -1; - } else { - /* Try to figure out what nameserver to use */ - for (ret = -1; fgets(line, sizeof(line), fp) != NULL;) { - unsigned int a, b, c, d; - if (sscanf(line, "nameserver %u.%u.%u.%u", &a, &b, &c, &d) == 4) { - snprintf(name, name_len, "udp://%u.%u.%u.%u:53", a, b, c, d); - ret = 0; - break; - } - } - (void) fclose(fp); - } -#else - snprintf(name, name_len, "%s", mg_default_dns_server); -#endif /* _WIN32 */ - - return ret; -} - -int mg_resolve_from_hosts_file(const char *name, union socket_address *usa) { -#if MG_ENABLE_FILESYSTEM - /* TODO(mkm) cache /etc/hosts */ - FILE *fp; - char line[1024]; - char *p; - char alias[256]; - unsigned int a, b, c, d; - int len = 0; - - if ((fp = mg_fopen("/etc/hosts", "r")) == NULL) { - return -1; - } - - for (; fgets(line, sizeof(line), fp) != NULL;) { - if (line[0] == '#') continue; - - if (sscanf(line, "%u.%u.%u.%u%n", &a, &b, &c, &d, &len) == 0) { - /* TODO(mkm): handle ipv6 */ - continue; - } - for (p = line + len; sscanf(p, "%s%n", alias, &len) == 1; p += len) { - if (strcmp(alias, name) == 0) { - usa->sin.sin_addr.s_addr = htonl(a << 24 | b << 16 | c << 8 | d); - fclose(fp); - return 0; - } - } - } - - fclose(fp); -#else - (void) name; - (void) usa; -#endif - - return -1; -} - -static void mg_resolve_async_eh(struct mg_connection *nc, int ev, void *data) { - time_t now = (time_t) mg_time(); - struct mg_resolve_async_request *req; - struct mg_dns_message *msg; - int first = 0; - - DBG(("ev=%d user_data=%p", ev, nc->user_data)); - - req = (struct mg_resolve_async_request *) nc->user_data; - - if (req == NULL) { - return; - } - - switch (ev) { - case MG_EV_CONNECT: - /* don't depend on timer not being at epoch for sending out first req */ - first = 1; - /* fallthrough */ - case MG_EV_POLL: - if (req->retries > req->max_retries) { - req->err = MG_RESOLVE_EXCEEDED_RETRY_COUNT; - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - break; - } - if (first || now - req->last_time >= req->timeout) { - mg_send_dns_query(nc, req->name, req->query); - req->last_time = now; - req->retries++; - } - break; - case MG_EV_RECV: - msg = (struct mg_dns_message *) MG_MALLOC(sizeof(*msg)); - if (mg_parse_dns(nc->recv_mbuf.buf, *(int *) data, msg) == 0 && - msg->num_answers > 0) { - req->callback(msg, req->data, MG_RESOLVE_OK); - nc->user_data = NULL; - MG_FREE(req); - } else { - req->err = MG_RESOLVE_NO_ANSWERS; - } - MG_FREE(msg); - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - break; - case MG_EV_SEND: - /* - * If a send error occurs, prevent closing of the connection by the core. - * We will retry after timeout. - */ - nc->flags &= ~MG_F_CLOSE_IMMEDIATELY; - mbuf_remove(&nc->send_mbuf, nc->send_mbuf.len); - break; - case MG_EV_TIMER: - req->err = MG_RESOLVE_TIMEOUT; - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - break; - case MG_EV_CLOSE: - /* If we got here with request still not done, fire an error callback. */ - if (req != NULL) { - req->callback(NULL, req->data, req->err); - nc->user_data = NULL; - MG_FREE(req); - } - break; - } -} - -int mg_resolve_async(struct mg_mgr *mgr, const char *name, int query, - mg_resolve_callback_t cb, void *data) { - struct mg_resolve_async_opts opts; - memset(&opts, 0, sizeof(opts)); - return mg_resolve_async_opt(mgr, name, query, cb, data, opts); -} - -int mg_resolve_async_opt(struct mg_mgr *mgr, const char *name, int query, - mg_resolve_callback_t cb, void *data, - struct mg_resolve_async_opts opts) { - struct mg_resolve_async_request *req; - struct mg_connection *dns_nc; - const char *nameserver = opts.nameserver_url; - - DBG(("%s %d %p", name, query, opts.dns_conn)); - - /* resolve with DNS */ - req = (struct mg_resolve_async_request *) MG_CALLOC(1, sizeof(*req)); - if (req == NULL) { - return -1; - } - - strncpy(req->name, name, sizeof(req->name)); - req->query = query; - req->callback = cb; - req->data = data; - /* TODO(mkm): parse defaults out of resolve.conf */ - req->max_retries = opts.max_retries ? opts.max_retries : 2; - req->timeout = opts.timeout ? opts.timeout : 5; - - /* Lazily initialize dns server */ - if (nameserver == NULL && mg_dns_server[0] == '\0' && - mg_get_ip_address_of_nameserver(mg_dns_server, sizeof(mg_dns_server)) == - -1) { - strncpy(mg_dns_server, mg_default_dns_server, sizeof(mg_dns_server)); - } - - if (nameserver == NULL) { - nameserver = mg_dns_server; - } - - dns_nc = mg_connect(mgr, nameserver, mg_resolve_async_eh); - if (dns_nc == NULL) { - free(req); - return -1; - } - dns_nc->user_data = req; - if (opts.dns_conn != NULL) { - *opts.dns_conn = dns_nc; - } - - return 0; -} - -#endif /* MG_ENABLE_ASYNC_RESOLVER */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/coap.c" -#endif -/* - * Copyright (c) 2015 Cesanta Software Limited - * All rights reserved - * This software is dual-licensed: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. For the terms of this - * license, see . - * - * You are free to use this software under the terms of the GNU General - * Public License, but WITHOUT ANY WARRANTY; without even the implied - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * Alternatively, you can license this software under a commercial - * license, as set out in . - */ - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/coap.h" */ - -#if MG_ENABLE_COAP - -void mg_coap_free_options(struct mg_coap_message *cm) { - while (cm->options != NULL) { - struct mg_coap_option *next = cm->options->next; - MG_FREE(cm->options); - cm->options = next; - } -} - -struct mg_coap_option *mg_coap_add_option(struct mg_coap_message *cm, - uint32_t number, char *value, - size_t len) { - struct mg_coap_option *new_option = - (struct mg_coap_option *) MG_CALLOC(1, sizeof(*new_option)); - - new_option->number = number; - new_option->value.p = value; - new_option->value.len = len; - - if (cm->options == NULL) { - cm->options = cm->optiomg_tail = new_option; - } else { - /* - * A very simple attention to help clients to compose options: - * CoAP wants to see options ASC ordered. - * Could be change by using sort in coap_compose - */ - if (cm->optiomg_tail->number <= new_option->number) { - /* if option is already ordered just add it */ - cm->optiomg_tail = cm->optiomg_tail->next = new_option; - } else { - /* looking for appropriate position */ - struct mg_coap_option *current_opt = cm->options; - struct mg_coap_option *prev_opt = 0; - - while (current_opt != NULL) { - if (current_opt->number > new_option->number) { - break; - } - prev_opt = current_opt; - current_opt = current_opt->next; - } - - if (prev_opt != NULL) { - prev_opt->next = new_option; - new_option->next = current_opt; - } else { - /* insert new_option to the beginning */ - new_option->next = cm->options; - cm->options = new_option; - } - } - } - - return new_option; -} - -/* - * Fills CoAP header in mg_coap_message. - * - * Helper function. - */ -static char *coap_parse_header(char *ptr, struct mbuf *io, - struct mg_coap_message *cm) { - if (io->len < sizeof(uint32_t)) { - cm->flags |= MG_COAP_NOT_ENOUGH_DATA; - return NULL; - } - - /* - * Version (Ver): 2-bit unsigned integer. Indicates the CoAP version - * number. Implementations of this specification MUST set this field - * to 1 (01 binary). Other values are reserved for future versions. - * Messages with unknown version numbers MUST be silently ignored. - */ - if (((uint8_t) *ptr >> 6) != 1) { - cm->flags |= MG_COAP_IGNORE; - return NULL; - } - - /* - * Type (T): 2-bit unsigned integer. Indicates if this message is of - * type Confirmable (0), Non-confirmable (1), Acknowledgement (2), or - * Reset (3). - */ - cm->msg_type = ((uint8_t) *ptr & 0x30) >> 4; - cm->flags |= MG_COAP_MSG_TYPE_FIELD; - - /* - * Token Length (TKL): 4-bit unsigned integer. Indicates the length of - * the variable-length Token field (0-8 bytes). Lengths 9-15 are - * reserved, MUST NOT be sent, and MUST be processed as a message - * format error. - */ - cm->token.len = *ptr & 0x0F; - if (cm->token.len > 8) { - cm->flags |= MG_COAP_FORMAT_ERROR; - return NULL; - } - - ptr++; - - /* - * Code: 8-bit unsigned integer, split into a 3-bit class (most - * significant bits) and a 5-bit detail (least significant bits) - */ - cm->code_class = (uint8_t) *ptr >> 5; - cm->code_detail = *ptr & 0x1F; - cm->flags |= (MG_COAP_CODE_CLASS_FIELD | MG_COAP_CODE_DETAIL_FIELD); - - ptr++; - - /* Message ID: 16-bit unsigned integer in network byte order. */ - cm->msg_id = (uint8_t) *ptr << 8 | (uint8_t) * (ptr + 1); - cm->flags |= MG_COAP_MSG_ID_FIELD; - - ptr += 2; - - return ptr; -} - -/* - * Fills token information in mg_coap_message. - * - * Helper function. - */ -static char *coap_get_token(char *ptr, struct mbuf *io, - struct mg_coap_message *cm) { - if (cm->token.len != 0) { - if (ptr + cm->token.len > io->buf + io->len) { - cm->flags |= MG_COAP_NOT_ENOUGH_DATA; - return NULL; - } else { - cm->token.p = ptr; - ptr += cm->token.len; - cm->flags |= MG_COAP_TOKEN_FIELD; - } - } - - return ptr; -} - -/* - * Returns Option Delta or Length. - * - * Helper function. - */ -static int coap_get_ext_opt(char *ptr, struct mbuf *io, uint16_t *opt_info) { - int ret = 0; - - if (*opt_info == 13) { - /* - * 13: An 8-bit unsigned integer follows the initial byte and - * indicates the Option Delta/Length minus 13. - */ - if (ptr < io->buf + io->len) { - *opt_info = (uint8_t) *ptr + 13; - ret = sizeof(uint8_t); - } else { - ret = -1; /* LCOV_EXCL_LINE */ - } - } else if (*opt_info == 14) { - /* - * 14: A 16-bit unsigned integer in network byte order follows the - * initial byte and indicates the Option Delta/Length minus 269. - */ - if (ptr + sizeof(uint8_t) < io->buf + io->len) { - *opt_info = ((uint8_t) *ptr << 8 | (uint8_t) * (ptr + 1)) + 269; - ret = sizeof(uint16_t); - } else { - ret = -1; /* LCOV_EXCL_LINE */ - } - } - - return ret; -} - -/* - * Fills options in mg_coap_message. - * - * Helper function. - * - * General options format: - * +---------------+---------------+ - * | Option Delta | Option Length | 1 byte - * +---------------+---------------+ - * \ Option Delta (extended) \ 0-2 bytes - * +-------------------------------+ - * / Option Length (extended) \ 0-2 bytes - * +-------------------------------+ - * \ Option Value \ 0 or more bytes - * +-------------------------------+ - */ -static char *coap_get_options(char *ptr, struct mbuf *io, - struct mg_coap_message *cm) { - uint16_t prev_opt = 0; - - if (ptr == io->buf + io->len) { - /* end of packet, ok */ - return NULL; - } - - /* 0xFF is payload marker */ - while (ptr < io->buf + io->len && (uint8_t) *ptr != 0xFF) { - uint16_t option_delta, option_lenght; - int optinfo_len; - - /* Option Delta: 4-bit unsigned integer */ - option_delta = ((uint8_t) *ptr & 0xF0) >> 4; - /* Option Length: 4-bit unsigned integer */ - option_lenght = *ptr & 0x0F; - - if (option_delta == 15 || option_lenght == 15) { - /* - * 15: Reserved for future use. If the field is set to this value, - * it MUST be processed as a message format error - */ - cm->flags |= MG_COAP_FORMAT_ERROR; - break; - } - - ptr++; - - /* check for extended option delta */ - optinfo_len = coap_get_ext_opt(ptr, io, &option_delta); - if (optinfo_len == -1) { - cm->flags |= MG_COAP_NOT_ENOUGH_DATA; /* LCOV_EXCL_LINE */ - break; /* LCOV_EXCL_LINE */ - } - - ptr += optinfo_len; - - /* check or extended option lenght */ - optinfo_len = coap_get_ext_opt(ptr, io, &option_lenght); - if (optinfo_len == -1) { - cm->flags |= MG_COAP_NOT_ENOUGH_DATA; /* LCOV_EXCL_LINE */ - break; /* LCOV_EXCL_LINE */ - } - - ptr += optinfo_len; - - /* - * Instead of specifying the Option Number directly, the instances MUST - * appear in order of their Option Numbers and a delta encoding is used - * between them. - */ - option_delta += prev_opt; - - mg_coap_add_option(cm, option_delta, ptr, option_lenght); - - prev_opt = option_delta; - - if (ptr + option_lenght > io->buf + io->len) { - cm->flags |= MG_COAP_NOT_ENOUGH_DATA; /* LCOV_EXCL_LINE */ - break; /* LCOV_EXCL_LINE */ - } - - ptr += option_lenght; - } - - if ((cm->flags & MG_COAP_ERROR) != 0) { - mg_coap_free_options(cm); - return NULL; - } - - cm->flags |= MG_COAP_OPTIOMG_FIELD; - - if (ptr == io->buf + io->len) { - /* end of packet, ok */ - return NULL; - } - - ptr++; - - return ptr; -} - -uint32_t mg_coap_parse(struct mbuf *io, struct mg_coap_message *cm) { - char *ptr; - - memset(cm, 0, sizeof(*cm)); - - if ((ptr = coap_parse_header(io->buf, io, cm)) == NULL) { - return cm->flags; - } - - if ((ptr = coap_get_token(ptr, io, cm)) == NULL) { - return cm->flags; - } - - if ((ptr = coap_get_options(ptr, io, cm)) == NULL) { - return cm->flags; - } - - /* the rest is payload */ - cm->payload.len = io->len - (ptr - io->buf); - if (cm->payload.len != 0) { - cm->payload.p = ptr; - cm->flags |= MG_COAP_PAYLOAD_FIELD; - } - - return cm->flags; -} - -/* - * Calculates extended size of given Opt Number/Length in coap message. - * - * Helper function. - */ -static size_t coap_get_ext_opt_size(uint32_t value) { - int ret = 0; - - if (value >= 13 && value <= 0xFF + 13) { - ret = sizeof(uint8_t); - } else if (value > 0xFF + 13 && value <= 0xFFFF + 269) { - ret = sizeof(uint16_t); - } - - return ret; -} - -/* - * Splits given Opt Number/Length into base and ext values. - * - * Helper function. - */ -static int coap_split_opt(uint32_t value, uint8_t *base, uint16_t *ext) { - int ret = 0; - - if (value < 13) { - *base = value; - } else if (value >= 13 && value <= 0xFF + 13) { - *base = 13; - *ext = value - 13; - ret = sizeof(uint8_t); - } else if (value > 0xFF + 13 && value <= 0xFFFF + 269) { - *base = 14; - *ext = value - 269; - ret = sizeof(uint16_t); - } - - return ret; -} - -/* - * Puts uint16_t (in network order) into given char stream. - * - * Helper function. - */ -static char *coap_add_uint16(char *ptr, uint16_t val) { - *ptr = val >> 8; - ptr++; - *ptr = val & 0x00FF; - ptr++; - return ptr; -} - -/* - * Puts extended value of Opt Number/Length into given char stream. - * - * Helper function. - */ -static char *coap_add_opt_info(char *ptr, uint16_t val, size_t len) { - if (len == sizeof(uint8_t)) { - *ptr = (char) val; - ptr++; - } else if (len == sizeof(uint16_t)) { - ptr = coap_add_uint16(ptr, val); - } - - return ptr; -} - -/* - * Verifies given mg_coap_message and calculates message size for it. - * - * Helper function. - */ -static uint32_t coap_calculate_packet_size(struct mg_coap_message *cm, - size_t *len) { - struct mg_coap_option *opt; - uint32_t prev_opt_number; - - *len = 4; /* header */ - if (cm->msg_type > MG_COAP_MSG_MAX) { - return MG_COAP_ERROR | MG_COAP_MSG_TYPE_FIELD; - } - if (cm->token.len > 8) { - return MG_COAP_ERROR | MG_COAP_TOKEN_FIELD; - } - if (cm->code_class > 7) { - return MG_COAP_ERROR | MG_COAP_CODE_CLASS_FIELD; - } - if (cm->code_detail > 31) { - return MG_COAP_ERROR | MG_COAP_CODE_DETAIL_FIELD; - } - - *len += cm->token.len; - if (cm->payload.len != 0) { - *len += cm->payload.len + 1; /* ... + 1; add payload marker */ - } - - opt = cm->options; - prev_opt_number = 0; - while (opt != NULL) { - *len += 1; /* basic delta/length */ - *len += coap_get_ext_opt_size(opt->number - prev_opt_number); - *len += coap_get_ext_opt_size((uint32_t) opt->value.len); - /* - * Current implementation performs check if - * option_number > previous option_number and produces an error - * TODO(alashkin): write design doc with limitations - * May be resorting is more suitable solution. - */ - if ((opt->next != NULL && opt->number > opt->next->number) || - opt->value.len > 0xFFFF + 269 || - opt->number - prev_opt_number > 0xFFFF + 269) { - return MG_COAP_ERROR | MG_COAP_OPTIOMG_FIELD; - } - *len += opt->value.len; - prev_opt_number = opt->number; - opt = opt->next; - } - - return 0; -} - -uint32_t mg_coap_compose(struct mg_coap_message *cm, struct mbuf *io) { - struct mg_coap_option *opt; - uint32_t res, prev_opt_number; - size_t prev_io_len, packet_size; - char *ptr; - - res = coap_calculate_packet_size(cm, &packet_size); - if (res != 0) { - return res; - } - - /* saving previous lenght to handle non-empty mbuf */ - prev_io_len = io->len; - mbuf_append(io, NULL, packet_size); - ptr = io->buf + prev_io_len; - - /* - * since cm is verified, it is possible to use bits shift operator - * without additional zeroing of unused bits - */ - - /* ver: 2 bits, msg_type: 2 bits, toklen: 4 bits */ - *ptr = (1 << 6) | (cm->msg_type << 4) | (uint8_t)(cm->token.len); - ptr++; - - /* code class: 3 bits, code detail: 5 bits */ - *ptr = (cm->code_class << 5) | (cm->code_detail); - ptr++; - - ptr = coap_add_uint16(ptr, cm->msg_id); - - if (cm->token.len != 0) { - memcpy(ptr, cm->token.p, cm->token.len); - ptr += cm->token.len; - } - - opt = cm->options; - prev_opt_number = 0; - while (opt != NULL) { - uint8_t delta_base = 0, length_base = 0; - uint16_t delta_ext = 0, length_ext = 0; - - size_t opt_delta_len = - coap_split_opt(opt->number - prev_opt_number, &delta_base, &delta_ext); - size_t opt_lenght_len = - coap_split_opt((uint32_t) opt->value.len, &length_base, &length_ext); - - *ptr = (delta_base << 4) | length_base; - ptr++; - - ptr = coap_add_opt_info(ptr, delta_ext, opt_delta_len); - ptr = coap_add_opt_info(ptr, length_ext, opt_lenght_len); - - if (opt->value.len != 0) { - memcpy(ptr, opt->value.p, opt->value.len); - ptr += opt->value.len; - } - - prev_opt_number = opt->number; - opt = opt->next; - } - - if (cm->payload.len != 0) { - *ptr = (char) -1; - ptr++; - memcpy(ptr, cm->payload.p, cm->payload.len); - } - - return 0; -} - -uint32_t mg_coap_send_message(struct mg_connection *nc, - struct mg_coap_message *cm) { - struct mbuf packet_out; - uint32_t compose_res; - - mbuf_init(&packet_out, 0); - compose_res = mg_coap_compose(cm, &packet_out); - if (compose_res != 0) { - return compose_res; /* LCOV_EXCL_LINE */ - } - - mg_send(nc, packet_out.buf, (int) packet_out.len); - mbuf_free(&packet_out); - - return 0; -} - -uint32_t mg_coap_send_ack(struct mg_connection *nc, uint16_t msg_id) { - struct mg_coap_message cm; - memset(&cm, 0, sizeof(cm)); - cm.msg_type = MG_COAP_MSG_ACK; - cm.msg_id = msg_id; - - return mg_coap_send_message(nc, &cm); -} - -static void coap_handler(struct mg_connection *nc, int ev, void *ev_data) { - struct mbuf *io = &nc->recv_mbuf; - struct mg_coap_message cm; - uint32_t parse_res; - - memset(&cm, 0, sizeof(cm)); - - nc->handler(nc, ev, ev_data); - - switch (ev) { - case MG_EV_RECV: - parse_res = mg_coap_parse(io, &cm); - if ((parse_res & MG_COAP_IGNORE) == 0) { - if ((cm.flags & MG_COAP_NOT_ENOUGH_DATA) != 0) { - /* - * Since we support UDP only - * MG_COAP_NOT_ENOUGH_DATA == MG_COAP_FORMAT_ERROR - */ - cm.flags |= MG_COAP_FORMAT_ERROR; /* LCOV_EXCL_LINE */ - } /* LCOV_EXCL_LINE */ - nc->handler(nc, MG_COAP_EVENT_BASE + cm.msg_type, &cm); - } - - mg_coap_free_options(&cm); - mbuf_remove(io, io->len); - break; - } -} -/* - * Attach built-in CoAP event handler to the given connection. - * - * The user-defined event handler will receive following extra events: - * - * - MG_EV_COAP_CON - * - MG_EV_COAP_NOC - * - MG_EV_COAP_ACK - * - MG_EV_COAP_RST - */ -int mg_set_protocol_coap(struct mg_connection *nc) { - /* supports UDP only */ - if ((nc->flags & MG_F_UDP) == 0) { - return -1; - } - - nc->proto_handler = coap_handler; - - return 0; -} - -#endif /* MG_ENABLE_COAP */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/tun.c" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_TUN - -/* Amalgamated: #include "common/cs_dbg.h" */ -/* Amalgamated: #include "mongoose/src/http.h" */ -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/net.h" */ -/* Amalgamated: #include "mongoose/src/net_if_tun.h" */ -/* Amalgamated: #include "mongoose/src/tun.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ - -static void mg_tun_reconnect(struct mg_tun_client *client, int timeout); - -static void mg_tun_init_client(struct mg_tun_client *client, struct mg_mgr *mgr, - struct mg_iface *iface, const char *dispatcher, - struct mg_tun_ssl_opts ssl) { - client->mgr = mgr; - client->iface = iface; - client->disp_url = dispatcher; - client->last_stream_id = 0; - client->ssl = ssl; - - client->disp = NULL; /* will be set by mg_tun_reconnect */ - client->listener = NULL; /* will be set by mg_do_bind */ - client->reconnect = NULL; /* will be set by mg_tun_reconnect */ -} - -void mg_tun_log_frame(struct mg_tun_frame *frame) { - LOG(LL_DEBUG, ("Got TUN frame: type=0x%x, flags=0x%x stream_id=0x%lx, " - "len=%zu", - frame->type, frame->flags, frame->stream_id, frame->body.len)); -#if MG_ENABLE_HEXDUMP - { - char hex[512]; - mg_hexdump(frame->body.p, frame->body.len, hex, sizeof(hex) - 1); - hex[sizeof(hex) - 1] = '\0'; - LOG(LL_DEBUG, ("body:\n%s", hex)); - } -#else - LOG(LL_DEBUG, ("body: '%.*s'", (int) frame->body.len, frame->body.p)); -#endif -} - -static void mg_tun_close_all(struct mg_tun_client *client) { - struct mg_connection *nc; - for (nc = client->mgr->active_connections; nc != NULL; nc = nc->next) { - if (nc->iface == client->iface && !(nc->flags & MG_F_LISTENING)) { - LOG(LL_DEBUG, ("Closing tunneled connection %p", nc)); - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - /* mg_close_conn(nc); */ - } - } -} - -static void mg_tun_client_handler(struct mg_connection *nc, int ev, - void *ev_data) { - struct mg_tun_client *client = (struct mg_tun_client *) nc->user_data; - - switch (ev) { - case MG_EV_CONNECT: { - int err = *(int *) ev_data; - - if (err) { - LOG(LL_ERROR, ("Cannot connect to the tunnel dispatcher: %d", err)); - } else { - LOG(LL_INFO, ("Connected to the tunnel dispatcher")); - } - break; - } - case MG_EV_HTTP_REPLY: { - struct http_message *hm = (struct http_message *) ev_data; - - if (hm->resp_code != 200) { - LOG(LL_ERROR, - ("Tunnel dispatcher reply non-OK status code %d", hm->resp_code)); - } - break; - } - case MG_EV_WEBSOCKET_HANDSHAKE_DONE: { - LOG(LL_INFO, ("Tunnel dispatcher handshake done")); - break; - } - case MG_EV_WEBSOCKET_FRAME: { - struct websocket_message *wm = (struct websocket_message *) ev_data; - struct mg_connection *tc; - struct mg_tun_frame frame; - - if (mg_tun_parse_frame(wm->data, wm->size, &frame) == -1) { - LOG(LL_ERROR, ("Got invalid tun frame dropping", wm->size)); - break; - } - - mg_tun_log_frame(&frame); - - tc = mg_tun_if_find_conn(client, frame.stream_id); - if (tc == NULL) { - if (frame.body.len > 0) { - LOG(LL_DEBUG, ("Got frame after receiving end has been closed")); - } - break; - } - if (frame.body.len > 0) { - mg_if_recv_tcp_cb(tc, (void *) frame.body.p, frame.body.len, - 0 /* own */); - } - if (frame.flags & MG_TUN_F_END_STREAM) { - LOG(LL_DEBUG, ("Closing tunneled connection because got end of stream " - "from other end")); - tc->flags |= MG_F_CLOSE_IMMEDIATELY; - mg_close_conn(tc); - } - break; - } - case MG_EV_CLOSE: { - LOG(LL_DEBUG, ("Closing all tunneled connections")); - /* - * The client might have been already freed when the listening socket is - * closed. - */ - if (client != NULL) { - mg_tun_close_all(client); - client->disp = NULL; - LOG(LL_INFO, ("Dispatcher connection is no more, reconnecting")); - /* TODO(mkm): implement exp back off */ - mg_tun_reconnect(client, MG_TUN_RECONNECT_INTERVAL); - } - break; - } - default: - break; - } -} - -static void mg_tun_do_reconnect(struct mg_tun_client *client) { - struct mg_connection *dc; - struct mg_connect_opts opts; - memset(&opts, 0, sizeof(opts)); -#if MG_ENABLE_SSL - opts.ssl_cert = client->ssl.ssl_cert; - opts.ssl_key = client->ssl.ssl_key; - opts.ssl_ca_cert = client->ssl.ssl_ca_cert; -#endif - /* HTTP/Websocket listener */ - if ((dc = mg_connect_ws_opt(client->mgr, mg_tun_client_handler, opts, - client->disp_url, MG_TUN_PROTO_NAME, NULL)) == - NULL) { - LOG(LL_ERROR, - ("Cannot connect to WS server on addr [%s]\n", client->disp_url)); - return; - } - - client->disp = dc; - dc->user_data = client; -} - -void mg_tun_reconnect_ev_handler(struct mg_connection *nc, int ev, - void *ev_data) { - struct mg_tun_client *client = (struct mg_tun_client *) nc->user_data; - (void) ev_data; - - switch (ev) { - case MG_EV_TIMER: - if (!(client->listener->flags & MG_F_TUN_DO_NOT_RECONNECT)) { - mg_tun_do_reconnect(client); - } else { - /* Reconnecting is suppressed, we'll check again at the next poll */ - mg_tun_reconnect(client, 0); - } - break; - } -} - -static void mg_tun_reconnect(struct mg_tun_client *client, int timeout) { - if (client->reconnect == NULL) { - client->reconnect = - mg_add_sock(client->mgr, INVALID_SOCKET, mg_tun_reconnect_ev_handler); - client->reconnect->user_data = client; - } - client->reconnect->ev_timer_time = mg_time() + timeout; -} - -static struct mg_tun_client *mg_tun_create_client(struct mg_mgr *mgr, - const char *dispatcher, - struct mg_tun_ssl_opts ssl) { - struct mg_tun_client *client = NULL; - struct mg_iface *iface = mg_find_iface(mgr, &mg_tun_iface_vtable, NULL); - if (iface == NULL) { - LOG(LL_ERROR, ("The tun feature requires the manager to have a tun " - "interface enabled")); - return NULL; - } - - client = (struct mg_tun_client *) MG_MALLOC(sizeof(*client)); - mg_tun_init_client(client, mgr, iface, dispatcher, ssl); - iface->data = client; - - /* - * We need to give application a chance to set MG_F_TUN_DO_NOT_RECONNECT on a - * listening connection right after mg_tun_bind_opt() returned it, so we - * should use mg_tun_reconnect() here, instead of mg_tun_do_reconnect() - */ - mg_tun_reconnect(client, 0); - return client; -} - -void mg_tun_destroy_client(struct mg_tun_client *client) { - /* - * NOTE: - * `client` is NULL in case of OOM - * `client->disp` is NULL if connection failed - * `client->iface is NULL is `mg_find_iface` failed - */ - - if (client != NULL && client->disp != NULL) { - /* the dispatcher connection handler will in turn close all tunnels */ - client->disp->flags |= MG_F_CLOSE_IMMEDIATELY; - /* this is used as a signal to other tun handlers that the party is over */ - client->disp->user_data = NULL; - } - - if (client != NULL && client->reconnect != NULL) { - client->reconnect->flags |= MG_F_CLOSE_IMMEDIATELY; - } - - if (client != NULL && client->iface != NULL) { - client->iface->data = NULL; - } - - MG_FREE(client); -} - -static struct mg_connection *mg_tun_do_bind(struct mg_tun_client *client, - mg_event_handler_t handler, - struct mg_bind_opts opts) { - struct mg_connection *lc; - opts.iface = client->iface; - lc = mg_bind_opt(client->mgr, ":1234" /* dummy port */, handler, opts); - client->listener = lc; - return lc; -} - -struct mg_connection *mg_tun_bind_opt(struct mg_mgr *mgr, - const char *dispatcher, - mg_event_handler_t handler, - struct mg_bind_opts opts) { -#if MG_ENABLE_SSL - struct mg_tun_ssl_opts ssl = {opts.ssl_cert, opts.ssl_key, opts.ssl_ca_cert}; -#else - struct mg_tun_ssl_opts ssl = {0}; -#endif - struct mg_tun_client *client = mg_tun_create_client(mgr, dispatcher, ssl); - if (client == NULL) { - return NULL; - } -#if MG_ENABLE_SSL - /* these options don't make sense in the local mouth of the tunnel */ - opts.ssl_cert = NULL; - opts.ssl_key = NULL; - opts.ssl_ca_cert = NULL; -#endif - return mg_tun_do_bind(client, handler, opts); -} - -int mg_tun_parse_frame(void *data, size_t len, struct mg_tun_frame *frame) { - const size_t header_size = sizeof(uint32_t) + sizeof(uint8_t) * 2; - if (len < header_size) { - return -1; - } - - frame->type = *(uint8_t *) (data); - frame->flags = *(uint8_t *) ((char *) data + 1); - memcpy(&frame->stream_id, (char *) data + 2, sizeof(uint32_t)); - frame->stream_id = ntohl(frame->stream_id); - frame->body.p = (char *) data + header_size; - frame->body.len = len - header_size; - return 0; -} - -void mg_tun_send_frame(struct mg_connection *ws, uint32_t stream_id, - uint8_t type, uint8_t flags, struct mg_str msg) { - stream_id = htonl(stream_id); - { - struct mg_str parts[] = { - {(char *) &type, sizeof(type)}, - {(char *) &flags, sizeof(flags)}, - {(char *) &stream_id, sizeof(stream_id)}, - {msg.p, msg.len} /* vc6 doesn't like just `msg` here */}; - mg_send_websocket_framev(ws, WEBSOCKET_OP_BINARY, parts, - sizeof(parts) / sizeof(parts[0])); - } -} - -#endif /* MG_ENABLE_TUN */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/sntp.c" -#endif -/* - * Copyright (c) 2016 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/sntp.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ - -#if MG_ENABLE_SNTP - -#define SNTP_TIME_OFFSET 2208988800 - -#ifndef SNTP_TIMEOUT -#define SNTP_TIMEOUT 10 -#endif - -#ifndef SNTP_ATTEMPTS -#define SNTP_ATTEMPTS 3 -#endif - -static uint64_t mg_get_sec(uint64_t val) { - return (val & 0xFFFFFFFF00000000) >> 32; -} - -static uint64_t mg_get_usec(uint64_t val) { - uint64_t tmp = (val & 0x00000000FFFFFFFF); - tmp *= 1000000; - tmp >>= 32; - return tmp; -} - -static void mg_ntp_to_tv(uint64_t val, struct timeval *tv) { - uint64_t tmp; - tmp = mg_get_sec(val); - tmp -= SNTP_TIME_OFFSET; - tv->tv_sec = tmp; - tv->tv_usec = mg_get_usec(val); -} - -static void mg_get_ntp_ts(const char *ntp, uint64_t *val) { - uint32_t tmp; - memcpy(&tmp, ntp, sizeof(tmp)); - tmp = ntohl(tmp); - *val = (uint64_t) tmp << 32; - memcpy(&tmp, ntp + 4, sizeof(tmp)); - tmp = ntohl(tmp); - *val |= tmp; -} - -void mg_sntp_send_request(struct mg_connection *c) { - char buf[48] = {0}; - /* - * header - 8 bit: - * LI (2 bit) - 3 (not in sync), VN (3 bit) - 4 (version), - * mode (3 bit) - 3 (client) - */ - buf[0] = (3 << 6) | (4 << 3) | 3; - -/* - * Next fields should be empty in client request - * stratum, 8 bit - * poll interval, 8 bit - * rrecision, 8 bit - * root delay, 32 bit - * root dispersion, 32 bit - * ref id, 32 bit - * ref timestamp, 64 bit - * originate Timestamp, 64 bit - * receive Timestamp, 64 bit -*/ - -/* - * convert time to sntp format (sntp starts from 00:00:00 01.01.1900) - * according to rfc868 it is 2208988800L sec - * this information is used to correct roundtrip delay - * but if local clock is absolutely broken (and doesn't work even - * as simple timer), it is better to disable it -*/ -#ifndef MG_SNMP_NO_DELAY_CORRECTION - uint32_t sec; - sec = htonl(mg_time() + SNTP_TIME_OFFSET); - memcpy(&buf[40], &sec, sizeof(sec)); -#endif - - mg_send(c, buf, sizeof(buf)); -} - -#ifndef MG_SNMP_NO_DELAY_CORRECTION -static uint64_t mg_calculate_delay(uint64_t t1, uint64_t t2, uint64_t t3) { - /* roundloop delay = (T4 - T1) - (T3 - T2) */ - uint64_t d1 = ((mg_time() + SNTP_TIME_OFFSET) * 1000000) - - (mg_get_sec(t1) * 1000000 + mg_get_usec(t1)); - uint64_t d2 = (mg_get_sec(t3) * 1000000 + mg_get_usec(t3)) - - (mg_get_sec(t2) * 1000000 + mg_get_usec(t2)); - - return (d1 > d2) ? d1 - d2 : 0; -} -#endif - -MG_INTERNAL int mg_sntp_parse_reply(const char *buf, int len, - struct mg_sntp_message *msg) { - uint8_t hdr; - uint64_t orig_ts_T1, recv_ts_T2, trsm_ts_T3, delay = 0; - int mode; - struct timeval tv; - - (void) orig_ts_T1; - (void) recv_ts_T2; - if (len < 48) { - return -1; - } - - hdr = buf[0]; - - if ((hdr & 0x38) >> 3 != 4) { - /* Wrong version */ - return -1; - } - - mode = hdr & 0x7; - if (mode != 4 && mode != 5) { - /* Not a server reply */ - return -1; - } - - memset(msg, 0, sizeof(*msg)); - - msg->kiss_of_death = (buf[1] == 0); /* Server asks to not send requests */ - - mg_get_ntp_ts(&buf[40], &trsm_ts_T3); - -#ifndef MG_SNMP_NO_DELAY_CORRECTION - mg_get_ntp_ts(&buf[24], &orig_ts_T1); - mg_get_ntp_ts(&buf[32], &recv_ts_T2); - delay = mg_calculate_delay(orig_ts_T1, recv_ts_T2, trsm_ts_T3); -#endif - - mg_ntp_to_tv(trsm_ts_T3, &tv); - - msg->time = (double) tv.tv_sec + (((double) tv.tv_usec + delay) / 1000000.0); - - return 0; -} - -static void mg_sntp_handler(struct mg_connection *c, int ev, void *ev_data) { - struct mbuf *io = &c->recv_mbuf; - struct mg_sntp_message msg; - - c->handler(c, ev, ev_data); - - switch (ev) { - case MG_EV_RECV: { - if (mg_sntp_parse_reply(io->buf, io->len, &msg) < 0) { - DBG(("Invalid SNTP packet received (%d)", (int) io->len)); - c->handler(c, MG_SNTP_MALFORMED_REPLY, NULL); - } else { - c->handler(c, MG_SNTP_REPLY, (void *) &msg); - } - - mbuf_remove(io, io->len); - break; - } - } -} - -int mg_set_protocol_sntp(struct mg_connection *c) { - if ((c->flags & MG_F_UDP) == 0) { - return -1; - } - - c->proto_handler = mg_sntp_handler; - - return 0; -} - -struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr, - mg_event_handler_t event_handler, - const char *sntp_server_name) { - struct mg_connection *c = NULL; - char url[100], *p_url = url; - const char *proto = "", *port = "", *tmp; - - /* If port is not specified, use default (123) */ - tmp = strchr(sntp_server_name, ':'); - if (tmp != NULL && *(tmp + 1) == '/') { - tmp = strchr(tmp + 1, ':'); - } - - if (tmp == NULL) { - port = ":123"; - } - - /* Add udp:// if needed */ - if (strncmp(sntp_server_name, "udp://", 6) != 0) { - proto = "udp://"; - } - - mg_asprintf(&p_url, sizeof(url), "%s%s%s", proto, sntp_server_name, port); - - c = mg_connect(mgr, p_url, event_handler); - - if (c == NULL) { - goto cleanup; - } - - mg_set_protocol_sntp(c); - -cleanup: - if (p_url != url) { - MG_FREE(p_url); - } - - return c; -} - -struct sntp_data { - mg_event_handler_t hander; - int count; -}; - -static void mg_sntp_util_ev_handler(struct mg_connection *c, int ev, - void *ev_data) { - struct sntp_data *sd = (struct sntp_data *) c->user_data; - - switch (ev) { - case MG_EV_CONNECT: - if (*(int *) ev_data != 0) { - mg_call(c, sd->hander, MG_SNTP_FAILED, NULL); - break; - } - /* fallthrough */ - case MG_EV_TIMER: - if (sd->count <= SNTP_ATTEMPTS) { - mg_sntp_send_request(c); - mg_set_timer(c, mg_time() + 10); - sd->count++; - } else { - mg_call(c, sd->hander, MG_SNTP_FAILED, NULL); - c->flags |= MG_F_CLOSE_IMMEDIATELY; - } - break; - case MG_SNTP_MALFORMED_REPLY: - mg_call(c, sd->hander, MG_SNTP_FAILED, NULL); - c->flags |= MG_F_CLOSE_IMMEDIATELY; - break; - case MG_SNTP_REPLY: - mg_call(c, sd->hander, MG_SNTP_REPLY, ev_data); - c->flags |= MG_F_CLOSE_IMMEDIATELY; - break; - case MG_EV_CLOSE: - MG_FREE(c->user_data); - c->user_data = NULL; - break; - } -} - -struct mg_connection *mg_sntp_get_time(struct mg_mgr *mgr, - mg_event_handler_t event_handler, - const char *sntp_server_name) { - struct mg_connection *c; - struct sntp_data *sd = (struct sntp_data *) MG_CALLOC(1, sizeof(*sd)); - if (sd == NULL) { - return NULL; - } - - c = mg_sntp_connect(mgr, mg_sntp_util_ev_handler, sntp_server_name); - if (c == NULL) { - MG_FREE(sd); - return NULL; - } - - sd->hander = event_handler; - c->user_data = sd; - - return c; -} - -#endif /* MG_ENABLE_SNTP */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/cc3200/cc3200_libc.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if CS_PLATFORM == CS_P_CC3200 - -#include -#include - -#ifndef __TI_COMPILER_VERSION__ -#include -#include -#include -#include -#endif - -#include -#include -#include -#include -#include -#include -#include - -#define CONSOLE_UART UARTA0_BASE - -#ifdef __TI_COMPILER_VERSION__ -int asprintf(char **strp, const char *fmt, ...) { - va_list ap; - int len; - - *strp = malloc(BUFSIZ); - if (*strp == NULL) return -1; - - va_start(ap, fmt); - len = vsnprintf(*strp, BUFSIZ, fmt, ap); - va_end(ap); - - if (len > 0) { - *strp = realloc(*strp, len + 1); - if (*strp == NULL) return -1; - } - - if (len >= BUFSIZ) { - va_start(ap, fmt); - len = vsnprintf(*strp, len + 1, fmt, ap); - va_end(ap); - } - - return len; -} - -#if MG_TI_NO_HOST_INTERFACE -time_t HOSTtime() { - struct timeval tp; - gettimeofday(&tp, NULL); - return tp.tv_sec; -} -#endif - -#endif /* __TI_COMPILER_VERSION__ */ - -#ifndef __TI_COMPILER_VERSION__ -int _gettimeofday_r(struct _reent *r, struct timeval *tp, void *tzp) { -#else -int gettimeofday(struct timeval *tp, void *tzp) { -#endif - unsigned long long r1 = 0, r2; - /* Achieve two consecutive reads of the same value. */ - do { - r2 = r1; - r1 = PRCMSlowClkCtrFastGet(); - } while (r1 != r2); - /* This is a 32768 Hz counter. */ - tp->tv_sec = (r1 >> 15); - /* 1/32768-th of a second is 30.517578125 microseconds, approx. 31, - * but we round down so it doesn't overflow at 32767 */ - tp->tv_usec = (r1 & 0x7FFF) * 30; - return 0; -} - -void fprint_str(FILE *fp, const char *str) { - while (*str != '\0') { - if (*str == '\n') MAP_UARTCharPut(CONSOLE_UART, '\r'); - MAP_UARTCharPut(CONSOLE_UART, *str++); - } -} - -void _exit(int status) { - fprint_str(stderr, "_exit\n"); - /* cause an unaligned access exception, that will drop you into gdb */ - *(int *) 1 = status; - while (1) - ; /* avoid gcc warning because stdlib abort() has noreturn attribute */ -} - -void _not_implemented(const char *what) { - fprint_str(stderr, what); - fprint_str(stderr, " is not implemented\n"); - _exit(42); -} - -int _kill(int pid, int sig) { - (void) pid; - (void) sig; - _not_implemented("_kill"); - return -1; -} - -int _getpid() { - fprint_str(stderr, "_getpid is not implemented\n"); - return 42; -} - -int _isatty(int fd) { - /* 0, 1 and 2 are TTYs. */ - return fd < 2; -} - -#endif /* CS_PLATFORM == CS_P_CC3200 */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/msp432/msp432_libc.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if CS_PLATFORM == CS_P_MSP432 - -#include -#include - -int gettimeofday(struct timeval *tp, void *tzp) { - uint32_t ticks = Clock_getTicks(); - tp->tv_sec = ticks / 1000; - tp->tv_usec = (ticks % 1000) * 1000; - return 0; -} - -#endif /* CS_PLATFORM == CS_P_MSP432 */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/nrf5/nrf5_libc.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if (CS_PLATFORM == CS_P_NRF51 || CS_PLATFORM == CS_P_NRF52) && \ - defined(__ARMCC_VERSION) -int gettimeofday(struct timeval *tp, void *tzp) { - /* TODO */ - tp->tv_sec = 0; - tp->tv_usec = 0; - return 0; -} -#endif -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_fs_slfs.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_ -#define CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_ - -#if defined(MG_FS_SLFS) - -#include -#ifndef __TI_COMPILER_VERSION__ -#include -#include -#endif - -#define MAX_OPEN_SLFS_FILES 8 - -/* Indirect libc interface - same functions, different names. */ -int fs_slfs_open(const char *pathname, int flags, mode_t mode); -int fs_slfs_close(int fd); -ssize_t fs_slfs_read(int fd, void *buf, size_t count); -ssize_t fs_slfs_write(int fd, const void *buf, size_t count); -int fs_slfs_stat(const char *pathname, struct stat *s); -int fs_slfs_fstat(int fd, struct stat *s); -off_t fs_slfs_lseek(int fd, off_t offset, int whence); -int fs_slfs_unlink(const char *filename); -int fs_slfs_rename(const char *from, const char *to); - -void fs_slfs_set_new_file_size(const char *name, size_t size); - -#endif /* defined(MG_FS_SLFS) */ - -#endif /* CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_fs_slfs.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -/* Standard libc interface to TI SimpleLink FS. */ - -#if defined(MG_FS_SLFS) || defined(CC3200_FS_SLFS) - -/* Amalgamated: #include "common/platforms/simplelink/sl_fs_slfs.h" */ - -#include - -#if CS_PLATFORM == CS_P_CC3200 -#include -#endif -#include -#include - -/* Amalgamated: #include "common/cs_dbg.h" */ - -/* From sl_fs.c */ -extern int set_errno(int e); -static const char *drop_dir(const char *fname, bool *is_slfs); - -/* - * With SLFS, you have to pre-declare max file size. Yes. Really. - * 64K should be enough for everyone. Right? - */ -#ifndef FS_SLFS_MAX_FILE_SIZE -#define FS_SLFS_MAX_FILE_SIZE (64 * 1024) -#endif - -struct sl_file_size_hint { - char *name; - size_t size; -}; - -struct sl_fd_info { - _i32 fh; - _off_t pos; - size_t size; -}; - -static struct sl_fd_info s_sl_fds[MAX_OPEN_SLFS_FILES]; -static struct sl_file_size_hint s_sl_file_size_hints[MAX_OPEN_SLFS_FILES]; - -static int sl_fs_to_errno(_i32 r) { - DBG(("SL error: %d", (int) r)); - switch (r) { - case SL_FS_OK: - return 0; - case SL_FS_FILE_NAME_EXIST: - return EEXIST; - case SL_FS_WRONG_FILE_NAME: - return EINVAL; - case SL_FS_ERR_NO_AVAILABLE_NV_INDEX: - case SL_FS_ERR_NO_AVAILABLE_BLOCKS: - return ENOSPC; - case SL_FS_ERR_FAILED_TO_ALLOCATE_MEM: - return ENOMEM; - case SL_FS_ERR_FILE_NOT_EXISTS: - return ENOENT; - case SL_FS_ERR_NOT_SUPPORTED: - return ENOTSUP; - } - return ENXIO; -} - -int fs_slfs_open(const char *pathname, int flags, mode_t mode) { - int fd; - for (fd = 0; fd < MAX_OPEN_SLFS_FILES; fd++) { - if (s_sl_fds[fd].fh <= 0) break; - } - if (fd >= MAX_OPEN_SLFS_FILES) return set_errno(ENOMEM); - struct sl_fd_info *fi = &s_sl_fds[fd]; - - /* - * Apply path manipulations again, in case we got here directly - * (via TI libc's "add_device"). - */ - pathname = drop_dir(pathname, NULL); - - _u32 am = 0; - fi->size = (size_t) -1; - int rw = (flags & 3); - if (rw == O_RDONLY) { - SlFsFileInfo_t sl_fi; - _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi); - if (r == SL_FS_OK) { - fi->size = sl_fi.FileLen; - } - am = FS_MODE_OPEN_READ; - } else { - if (!(flags & O_TRUNC) || (flags & O_APPEND)) { - // FailFS files cannot be opened for append and will be truncated - // when opened for write. - return set_errno(ENOTSUP); - } - if (flags & O_CREAT) { - size_t i, size = FS_SLFS_MAX_FILE_SIZE; - for (i = 0; i < MAX_OPEN_SLFS_FILES; i++) { - if (s_sl_file_size_hints[i].name != NULL && - strcmp(s_sl_file_size_hints[i].name, pathname) == 0) { - size = s_sl_file_size_hints[i].size; - free(s_sl_file_size_hints[i].name); - s_sl_file_size_hints[i].name = NULL; - break; - } - } - DBG(("creating %s with max size %d", pathname, (int) size)); - am = FS_MODE_OPEN_CREATE(size, 0); - } else { - am = FS_MODE_OPEN_WRITE; - } - } - _i32 r = sl_FsOpen((_u8 *) pathname, am, NULL, &fi->fh); - DBG(("sl_FsOpen(%s, 0x%x) = %d, %d", pathname, (int) am, (int) r, - (int) fi->fh)); - if (r == SL_FS_OK) { - fi->pos = 0; - r = fd; - } else { - fi->fh = -1; - r = set_errno(sl_fs_to_errno(r)); - } - return r; -} - -int fs_slfs_close(int fd) { - struct sl_fd_info *fi = &s_sl_fds[fd]; - if (fi->fh <= 0) return set_errno(EBADF); - _i32 r = sl_FsClose(fi->fh, NULL, NULL, 0); - DBG(("sl_FsClose(%d) = %d", (int) fi->fh, (int) r)); - s_sl_fds[fd].fh = -1; - return set_errno(sl_fs_to_errno(r)); -} - -ssize_t fs_slfs_read(int fd, void *buf, size_t count) { - struct sl_fd_info *fi = &s_sl_fds[fd]; - if (fi->fh <= 0) return set_errno(EBADF); - /* Simulate EOF. sl_FsRead @ file_size return SL_FS_ERR_OFFSET_OUT_OF_RANGE. - */ - if (fi->pos == fi->size) return 0; - _i32 r = sl_FsRead(fi->fh, fi->pos, buf, count); - DBG(("sl_FsRead(%d, %d, %d) = %d", (int) fi->fh, (int) fi->pos, (int) count, - (int) r)); - if (r >= 0) { - fi->pos += r; - return r; - } - return set_errno(sl_fs_to_errno(r)); -} - -ssize_t fs_slfs_write(int fd, const void *buf, size_t count) { - struct sl_fd_info *fi = &s_sl_fds[fd]; - if (fi->fh <= 0) return set_errno(EBADF); - _i32 r = sl_FsWrite(fi->fh, fi->pos, (_u8 *) buf, count); - DBG(("sl_FsWrite(%d, %d, %d) = %d", (int) fi->fh, (int) fi->pos, (int) count, - (int) r)); - if (r >= 0) { - fi->pos += r; - return r; - } - return set_errno(sl_fs_to_errno(r)); -} - -int fs_slfs_stat(const char *pathname, struct stat *s) { - SlFsFileInfo_t sl_fi; - /* - * Apply path manipulations again, in case we got here directly - * (via TI libc's "add_device"). - */ - pathname = drop_dir(pathname, NULL); - _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi); - if (r == SL_FS_OK) { - s->st_mode = S_IFREG | 0666; - s->st_nlink = 1; - s->st_size = sl_fi.FileLen; - return 0; - } - return set_errno(sl_fs_to_errno(r)); -} - -int fs_slfs_fstat(int fd, struct stat *s) { - struct sl_fd_info *fi = &s_sl_fds[fd]; - if (fi->fh <= 0) return set_errno(EBADF); - s->st_mode = 0666; - s->st_mode = S_IFREG | 0666; - s->st_nlink = 1; - s->st_size = fi->size; - return 0; -} - -off_t fs_slfs_lseek(int fd, off_t offset, int whence) { - if (s_sl_fds[fd].fh <= 0) return set_errno(EBADF); - switch (whence) { - case SEEK_SET: - s_sl_fds[fd].pos = offset; - break; - case SEEK_CUR: - s_sl_fds[fd].pos += offset; - break; - case SEEK_END: - return set_errno(ENOTSUP); - } - return 0; -} - -int fs_slfs_unlink(const char *pathname) { - /* - * Apply path manipulations again, in case we got here directly - * (via TI libc's "add_device"). - */ - pathname = drop_dir(pathname, NULL); - return set_errno(sl_fs_to_errno(sl_FsDel((const _u8 *) pathname, 0))); -} - -int fs_slfs_rename(const char *from, const char *to) { - return set_errno(ENOTSUP); -} - -void fs_slfs_set_new_file_size(const char *name, size_t size) { - int i; - for (i = 0; i < MAX_OPEN_SLFS_FILES; i++) { - if (s_sl_file_size_hints[i].name == NULL) { - DBG(("File size hint: %s %d", name, (int) size)); - s_sl_file_size_hints[i].name = strdup(name); - s_sl_file_size_hints[i].size = size; - break; - } - } -} - -#endif /* defined(MG_FS_SLFS) || defined(CC3200_FS_SLFS) */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_fs.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_NET_IF == MG_NET_IF_SIMPLELINK && \ - (defined(MG_FS_SLFS) || defined(MG_FS_SPIFFS)) - -#include -#include -#include -#include -#include -#ifdef __TI_COMPILER_VERSION__ -#include -#endif - -/* Amalgamated: #include "common/cs_dbg.h" */ -/* Amalgamated: #include "common/platform.h" */ - -#ifdef CC3200_FS_SPIFFS -/* Amalgamated: #include "cc3200_fs_spiffs.h" */ -#endif - -#ifdef MG_FS_SLFS -/* Amalgamated: #include "sl_fs_slfs.h" */ -#endif - -#define NUM_SYS_FDS 3 -#define SPIFFS_FD_BASE 10 -#define SLFS_FD_BASE 100 - -#ifndef MG_UART_CHAR_PUT -#if CS_PLATFORM == CS_P_CC3200 -#include -#include -#include -#include -#include -#define MG_UART_CHAR_PUT(fd, c) MAP_UARTCharPut(UARTA0_BASE, c); -#else -#define MG_UART_CHAR_PUT(fd, c) -#endif /* CS_PLATFORM == CS_P_CC3200 */ -#endif /* !MG_UART_CHAR_PUT */ - -int set_errno(int e) { - errno = e; - return (e == 0 ? 0 : -1); -} - -static const char *drop_dir(const char *fname, bool *is_slfs) { - if (is_slfs != NULL) { - *is_slfs = (strncmp(fname, "SL:", 3) == 0); - if (*is_slfs) fname += 3; - } - /* Drop "./", if any */ - if (fname[0] == '.' && fname[1] == '/') { - fname += 2; - } - /* - * Drop / if it is the only one in the path. - * This allows use of /pretend/directories but serves /file.txt as normal. - */ - if (fname[0] == '/' && strchr(fname + 1, '/') == NULL) { - fname++; - } - return fname; -} - -enum fd_type { - FD_INVALID, - FD_SYS, -#ifdef CC3200_FS_SPIFFS - FD_SPIFFS, -#endif -#ifdef MG_FS_SLFS - FD_SLFS -#endif -}; -static int fd_type(int fd) { - if (fd >= 0 && fd < NUM_SYS_FDS) return FD_SYS; -#ifdef CC3200_FS_SPIFFS - if (fd >= SPIFFS_FD_BASE && fd < SPIFFS_FD_BASE + MAX_OPEN_SPIFFS_FILES) { - return FD_SPIFFS; - } -#endif -#ifdef MG_FS_SLFS - if (fd >= SLFS_FD_BASE && fd < SLFS_FD_BASE + MAX_OPEN_SLFS_FILES) { - return FD_SLFS; - } -#endif - return FD_INVALID; -} - -#if MG_TI_NO_HOST_INTERFACE -int open(const char *pathname, unsigned flags, int mode) { -#else -int _open(const char *pathname, int flags, mode_t mode) { -#endif - int fd = -1; - bool is_sl; - const char *fname = drop_dir(pathname, &is_sl); - if (is_sl) { -#ifdef MG_FS_SLFS - fd = fs_slfs_open(fname, flags, mode); - if (fd >= 0) fd += SLFS_FD_BASE; -#endif - } else { -#ifdef CC3200_FS_SPIFFS - fd = fs_spiffs_open(fname, flags, mode); - if (fd >= 0) fd += SPIFFS_FD_BASE; -#endif - } - LOG(LL_DEBUG, - ("open(%s, 0x%x) = %d, fname = %s", pathname, flags, fd, fname)); - return fd; -} - -int _stat(const char *pathname, struct stat *st) { - int res = -1; - bool is_sl; - const char *fname = drop_dir(pathname, &is_sl); - memset(st, 0, sizeof(*st)); - /* Simulate statting the root directory. */ - if (fname[0] == '\0' || strcmp(fname, ".") == 0) { - st->st_ino = 0; - st->st_mode = S_IFDIR | 0777; - st->st_nlink = 1; - st->st_size = 0; - return 0; - } - if (is_sl) { -#ifdef MG_FS_SLFS - res = fs_slfs_stat(fname, st); -#endif - } else { -#ifdef CC3200_FS_SPIFFS - res = fs_spiffs_stat(fname, st); -#endif - } - LOG(LL_DEBUG, ("stat(%s) = %d; fname = %s", pathname, res, fname)); - return res; -} - -#if MG_TI_NO_HOST_INTERFACE -int close(int fd) { -#else -int _close(int fd) { -#endif - int r = -1; - switch (fd_type(fd)) { - case FD_INVALID: - r = set_errno(EBADF); - break; - case FD_SYS: - r = set_errno(EACCES); - break; -#ifdef CC3200_FS_SPIFFS - case FD_SPIFFS: - r = fs_spiffs_close(fd - SPIFFS_FD_BASE); - break; -#endif -#ifdef MG_FS_SLFS - case FD_SLFS: - r = fs_slfs_close(fd - SLFS_FD_BASE); - break; -#endif - } - DBG(("close(%d) = %d", fd, r)); - return r; -} - -#if MG_TI_NO_HOST_INTERFACE -off_t lseek(int fd, off_t offset, int whence) { -#else -off_t _lseek(int fd, off_t offset, int whence) { -#endif - int r = -1; - switch (fd_type(fd)) { - case FD_INVALID: - r = set_errno(EBADF); - break; - case FD_SYS: - r = set_errno(ESPIPE); - break; -#ifdef CC3200_FS_SPIFFS - case FD_SPIFFS: - r = fs_spiffs_lseek(fd - SPIFFS_FD_BASE, offset, whence); - break; -#endif -#ifdef MG_FS_SLFS - case FD_SLFS: - r = fs_slfs_lseek(fd - SLFS_FD_BASE, offset, whence); - break; -#endif - } - DBG(("lseek(%d, %d, %d) = %d", fd, (int) offset, whence, r)); - return r; -} - -int _fstat(int fd, struct stat *s) { - int r = -1; - memset(s, 0, sizeof(*s)); - switch (fd_type(fd)) { - case FD_INVALID: - r = set_errno(EBADF); - break; - case FD_SYS: { - /* Create barely passable stats for STD{IN,OUT,ERR}. */ - memset(s, 0, sizeof(*s)); - s->st_ino = fd; - s->st_mode = S_IFCHR | 0666; - r = 0; - break; - } -#ifdef CC3200_FS_SPIFFS - case FD_SPIFFS: - r = fs_spiffs_fstat(fd - SPIFFS_FD_BASE, s); - break; -#endif -#ifdef MG_FS_SLFS - case FD_SLFS: - r = fs_slfs_fstat(fd - SLFS_FD_BASE, s); - break; -#endif - } - DBG(("fstat(%d) = %d", fd, r)); - return r; -} - -#if MG_TI_NO_HOST_INTERFACE -int read(int fd, char *buf, unsigned count) { -#else -ssize_t _read(int fd, void *buf, size_t count) { -#endif - int r = -1; - switch (fd_type(fd)) { - case FD_INVALID: - r = set_errno(EBADF); - break; - case FD_SYS: { - if (fd != 0) { - r = set_errno(EACCES); - break; - } - /* Should we allow reading from stdin = uart? */ - r = set_errno(ENOTSUP); - break; - } -#ifdef CC3200_FS_SPIFFS - case FD_SPIFFS: - r = fs_spiffs_read(fd - SPIFFS_FD_BASE, buf, count); - break; -#endif -#ifdef MG_FS_SLFS - case FD_SLFS: - r = fs_slfs_read(fd - SLFS_FD_BASE, buf, count); - break; -#endif - } - DBG(("read(%d, %u) = %d", fd, count, r)); - return r; -} - -#if MG_TI_NO_HOST_INTERFACE -int write(int fd, const char *buf, unsigned count) { -#else -ssize_t _write(int fd, const void *buf, size_t count) { -#endif - int r = -1; - size_t i = 0; - switch (fd_type(fd)) { - case FD_INVALID: - r = set_errno(EBADF); - break; - case FD_SYS: { - if (fd == 0) { - r = set_errno(EACCES); - break; - } - for (i = 0; i < count; i++) { - const char c = ((const char *) buf)[i]; - if (c == '\n') MG_UART_CHAR_PUT(fd, '\r'); - MG_UART_CHAR_PUT(fd, c); - } - r = count; - break; - } -#ifdef CC3200_FS_SPIFFS - case FD_SPIFFS: - r = fs_spiffs_write(fd - SPIFFS_FD_BASE, buf, count); - break; -#endif -#ifdef MG_FS_SLFS - case FD_SLFS: - r = fs_slfs_write(fd - SLFS_FD_BASE, buf, count); - break; -#endif - } - return r; -} - -/* - * On Newlib we override rename directly too, because the default - * implementation using _link and _unlink doesn't work for us. - */ -#if MG_TI_NO_HOST_INTERFACE || defined(_NEWLIB_VERSION) -int rename(const char *frompath, const char *topath) { - int r = -1; - bool is_sl_from, is_sl_to; - const char *from = drop_dir(frompath, &is_sl_from); - const char *to = drop_dir(topath, &is_sl_to); - if (is_sl_from || is_sl_to) { - set_errno(ENOTSUP); - } else { -#ifdef CC3200_FS_SPIFFS - r = fs_spiffs_rename(from, to); -#endif - } - DBG(("rename(%s, %s) = %d", from, to, r)); - return r; -} -#endif /* MG_TI_NO_HOST_INTERFACE || defined(_NEWLIB_VERSION) */ - -#if MG_TI_NO_HOST_INTERFACE -int unlink(const char *pathname) { -#else -int _unlink(const char *pathname) { -#endif - int r = -1; - bool is_sl; - const char *fname = drop_dir(pathname, &is_sl); - if (is_sl) { -#ifdef MG_FS_SLFS - r = fs_slfs_unlink(fname); -#endif - } else { -#ifdef CC3200_FS_SPIFFS - r = fs_spiffs_unlink(fname); -#endif - } - DBG(("unlink(%s) = %d, fname = %s", pathname, r, fname)); - return r; -} - -#ifdef CC3200_FS_SPIFFS /* FailFS does not support listing files. */ -DIR *opendir(const char *dir_name) { - DIR *r = NULL; - bool is_sl; - drop_dir(dir_name, &is_sl); - if (is_sl) { - r = NULL; - set_errno(ENOTSUP); - } else { - r = fs_spiffs_opendir(dir_name); - } - DBG(("opendir(%s) = %p", dir_name, r)); - return r; -} - -struct dirent *readdir(DIR *dir) { - struct dirent *res = fs_spiffs_readdir(dir); - DBG(("readdir(%p) = %p", dir, res)); - return res; -} - -int closedir(DIR *dir) { - int res = fs_spiffs_closedir(dir); - DBG(("closedir(%p) = %d", dir, res)); - return res; -} - -int rmdir(const char *path) { - return fs_spiffs_rmdir(path); -} - -int mkdir(const char *path, mode_t mode) { - (void) path; - (void) mode; - /* for spiffs supports only root dir, which comes from mongoose as '.' */ - return (strlen(path) == 1 && *path == '.') ? 0 : ENOTDIR; -} -#endif - -int sl_fs_init(void) { - int ret = 1; -#ifdef __TI_COMPILER_VERSION__ -#ifdef MG_FS_SLFS -#pragma diag_push -#pragma diag_suppress 169 /* Nothing we can do about the prototype mismatch. \ - */ - ret = (add_device("SL", _MSA, fs_slfs_open, fs_slfs_close, fs_slfs_read, - fs_slfs_write, fs_slfs_lseek, fs_slfs_unlink, - fs_slfs_rename) == 0); -#pragma diag_pop -#endif -#endif - return ret; -} - -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK && (defined(MG_FS_SLFS) || \ - defined(MG_FS_SPIFFS)) */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_socket.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_NET_IF == MG_NET_IF_SIMPLELINK - -#include -#include - -/* Amalgamated: #include "common/platform.h" */ - -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) { - int res; - struct in_addr *in = (struct in_addr *) src; - if (af != AF_INET) { - errno = EAFNOSUPPORT; - return NULL; - } - res = snprintf(dst, size, "%lu.%lu.%lu.%lu", SL_IPV4_BYTE(in->s_addr, 0), - SL_IPV4_BYTE(in->s_addr, 1), SL_IPV4_BYTE(in->s_addr, 2), - SL_IPV4_BYTE(in->s_addr, 3)); - return res > 0 ? dst : NULL; -} - -char *inet_ntoa(struct in_addr n) { - static char a[16]; - return (char *) inet_ntop(AF_INET, &n, a, sizeof(a)); -} - -int inet_pton(int af, const char *src, void *dst) { - uint32_t a0, a1, a2, a3; - uint8_t *db = (uint8_t *) dst; - if (af != AF_INET) { - errno = EAFNOSUPPORT; - return 0; - } - if (sscanf(src, "%lu.%lu.%lu.%lu", &a0, &a1, &a2, &a3) != 4) { - return 0; - } - *db = a3; - *(db + 1) = a2; - *(db + 2) = a1; - *(db + 3) = a0; - return 1; -} - -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_mg_task.c" -#endif -#if MG_NET_IF == MG_NET_IF_SIMPLELINK && !defined(MG_SIMPLELINK_NO_OSI) - -/* Amalgamated: #include "mg_task.h" */ - -#include - -enum mg_q_msg_type { - MG_Q_MSG_CB, -}; -struct mg_q_msg { - enum mg_q_msg_type type; - void (*cb)(struct mg_mgr *mgr, void *arg); - void *arg; -}; -static OsiMsgQ_t s_mg_q; -static void mg_task(void *arg); - -bool mg_start_task(int priority, int stack_size, mg_init_cb mg_init) { - if (osi_MsgQCreate(&s_mg_q, "MG", sizeof(struct mg_q_msg), 16) != OSI_OK) { - return false; - } - if (osi_TaskCreate(mg_task, (const signed char *) "MG", stack_size, - (void *) mg_init, priority, NULL) != OSI_OK) { - return false; - } - return true; -} - -static void mg_task(void *arg) { - struct mg_mgr mgr; - mg_init_cb mg_init = (mg_init_cb) arg; - mg_mgr_init(&mgr, NULL); - mg_init(&mgr); - while (1) { - struct mg_q_msg msg; - mg_mgr_poll(&mgr, 1); - if (osi_MsgQRead(&s_mg_q, &msg, 1) != OSI_OK) continue; - switch (msg.type) { - case MG_Q_MSG_CB: { - msg.cb(&mgr, msg.arg); - } - } - } -} - -void mg_run_in_task(void (*cb)(struct mg_mgr *mgr, void *arg), void *cb_arg) { - struct mg_q_msg msg = {MG_Q_MSG_CB, cb, cb_arg}; - osi_MsgQWrite(&s_mg_q, &msg, OSI_NO_WAIT); -} - -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK && !defined(MG_SIMPLELINK_NO_OSI) \ - */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_net_if.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_ -#define CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_ - -/* Amalgamated: #include "mongoose/src/net_if.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#ifndef MG_ENABLE_NET_IF_SIMPLELINK -#define MG_ENABLE_NET_IF_SIMPLELINK MG_NET_IF == MG_NET_IF_SIMPLELINK -#endif - -extern struct mg_iface_vtable mg_simplelink_iface_vtable; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_net_if.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -/* Amalgamated: #include "common/platforms/simplelink/sl_net_if.h" */ - -#if MG_ENABLE_NET_IF_SIMPLELINK - -/* Amalgamated: #include "mongoose/src/internal.h" */ -/* Amalgamated: #include "mongoose/src/util.h" */ - -#define MG_TCP_RECV_BUFFER_SIZE 1024 -#define MG_UDP_RECV_BUFFER_SIZE 1500 - -static sock_t mg_open_listening_socket(union socket_address *sa, int type, - int proto); - -int sl_set_ssl_opts(struct mg_connection *nc); - -void mg_set_non_blocking_mode(sock_t sock) { - SlSockNonblocking_t opt; - opt.NonblockingEnabled = 1; - sl_SetSockOpt(sock, SL_SOL_SOCKET, SL_SO_NONBLOCKING, &opt, sizeof(opt)); -} - -static int mg_is_error(int n) { - return (n < 0 && n != SL_EALREADY && n != SL_EAGAIN); -} - -void mg_sl_if_connect_tcp(struct mg_connection *nc, - const union socket_address *sa) { - int proto = 0; - if (nc->flags & MG_F_SSL) proto = SL_SEC_SOCKET; - sock_t sock = sl_Socket(AF_INET, SOCK_STREAM, proto); - if (sock < 0) { - nc->err = sock; - goto out; - } - mg_sock_set(nc, sock); -#if MG_ENABLE_SSL - nc->err = sl_set_ssl_opts(nc); - if (nc->err != 0) goto out; -#endif - nc->err = sl_Connect(sock, &sa->sa, sizeof(sa->sin)); -out: - DBG(("%p to %s:%d sock %d %d err %d", nc, inet_ntoa(sa->sin.sin_addr), - ntohs(sa->sin.sin_port), nc->sock, proto, nc->err)); -} - -void mg_sl_if_connect_udp(struct mg_connection *nc) { - sock_t sock = sl_Socket(AF_INET, SOCK_DGRAM, 0); - if (sock < 0) { - nc->err = sock; - return; - } - mg_sock_set(nc, sock); - nc->err = 0; -} - -int mg_sl_if_listen_tcp(struct mg_connection *nc, union socket_address *sa) { - int proto = 0; - if (nc->flags & MG_F_SSL) proto = SL_SEC_SOCKET; - sock_t sock = mg_open_listening_socket(sa, SOCK_STREAM, proto); - if (sock < 0) return sock; - mg_sock_set(nc, sock); -#if MG_ENABLE_SSL - return sl_set_ssl_opts(nc); -#else - return 0; -#endif -} - -int mg_sl_if_listen_udp(struct mg_connection *nc, union socket_address *sa) { - sock_t sock = mg_open_listening_socket(sa, SOCK_DGRAM, 0); - if (sock == INVALID_SOCKET) return (errno ? errno : 1); - mg_sock_set(nc, sock); - return 0; -} - -void mg_sl_if_tcp_send(struct mg_connection *nc, const void *buf, size_t len) { - mbuf_append(&nc->send_mbuf, buf, len); -} - -void mg_sl_if_udp_send(struct mg_connection *nc, const void *buf, size_t len) { - mbuf_append(&nc->send_mbuf, buf, len); -} - -void mg_sl_if_recved(struct mg_connection *nc, size_t len) { - (void) nc; - (void) len; -} - -int mg_sl_if_create_conn(struct mg_connection *nc) { - (void) nc; - return 1; -} - -void mg_sl_if_destroy_conn(struct mg_connection *nc) { - if (nc->sock == INVALID_SOCKET) return; - /* For UDP, only close outgoing sockets or listeners. */ - if (!(nc->flags & MG_F_UDP) || nc->listener == NULL) { - sl_Close(nc->sock); - } - nc->sock = INVALID_SOCKET; -} - -static int mg_accept_conn(struct mg_connection *lc) { - struct mg_connection *nc; - union socket_address sa; - socklen_t sa_len = sizeof(sa); - sock_t sock = sl_Accept(lc->sock, &sa.sa, &sa_len); - if (sock < 0) { - DBG(("%p: failed to accept: %d", lc, sock)); - return 0; - } - nc = mg_if_accept_new_conn(lc); - if (nc == NULL) { - sl_Close(sock); - return 0; - } - DBG(("%p conn from %s:%d", nc, inet_ntoa(sa.sin.sin_addr), - ntohs(sa.sin.sin_port))); - mg_sock_set(nc, sock); - if (nc->flags & MG_F_SSL) nc->flags |= MG_F_SSL_HANDSHAKE_DONE; - mg_if_accept_tcp_cb(nc, &sa, sa_len); - return 1; -} - -/* 'sa' must be an initialized address to bind to */ -static sock_t mg_open_listening_socket(union socket_address *sa, int type, - int proto) { - int r; - socklen_t sa_len = - (sa->sa.sa_family == AF_INET) ? sizeof(sa->sin) : sizeof(sa->sin6); - sock_t sock = sl_Socket(sa->sa.sa_family, type, proto); - if (sock < 0) return sock; - if ((r = sl_Bind(sock, &sa->sa, sa_len)) < 0) { - sl_Close(sock); - return r; - } - if (type != SOCK_DGRAM && (r = sl_Listen(sock, SOMAXCONN)) < 0) { - sl_Close(sock); - return r; - } - mg_set_non_blocking_mode(sock); - return sock; -} - -static void mg_write_to_socket(struct mg_connection *nc) { - struct mbuf *io = &nc->send_mbuf; - int n = 0; - - if (nc->flags & MG_F_UDP) { - n = sl_SendTo(nc->sock, io->buf, io->len, 0, &nc->sa.sa, - sizeof(nc->sa.sin)); - DBG(("%p %d %d %d %s:%hu", nc, nc->sock, n, errno, - inet_ntoa(nc->sa.sin.sin_addr), ntohs(nc->sa.sin.sin_port))); - } else { - n = (int) sl_Send(nc->sock, io->buf, io->len, 0); - DBG(("%p %d bytes -> %d", nc, n, nc->sock)); - } - - if (n > 0) { - mbuf_remove(io, n); - mg_if_sent_cb(nc, n); - } else if (n < 0 && mg_is_error(n)) { - /* Something went wrong, drop the connection. */ - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } -} - -MG_INTERNAL size_t recv_avail_size(struct mg_connection *conn, size_t max) { - size_t avail; - if (conn->recv_mbuf_limit < conn->recv_mbuf.len) return 0; - avail = conn->recv_mbuf_limit - conn->recv_mbuf.len; - return avail > max ? max : avail; -} - -static void mg_handle_tcp_read(struct mg_connection *conn) { - int n = 0; - char *buf = (char *) MG_MALLOC(MG_TCP_RECV_BUFFER_SIZE); - - if (buf == NULL) { - DBG(("OOM")); - return; - } - - n = (int) sl_Recv(conn->sock, buf, - recv_avail_size(conn, MG_TCP_RECV_BUFFER_SIZE), 0); - DBG(("%p %d bytes <- %d", conn, n, conn->sock)); - if (n > 0) { - mg_if_recv_tcp_cb(conn, buf, n, 1 /* own */); - } else { - MG_FREE(buf); - } - if (n == 0) { - /* Orderly shutdown of the socket, try flushing output. */ - conn->flags |= MG_F_SEND_AND_CLOSE; - } else if (mg_is_error(n)) { - conn->flags |= MG_F_CLOSE_IMMEDIATELY; - } -} - -static void mg_handle_udp_read(struct mg_connection *nc) { - char *buf = (char *) MG_MALLOC(MG_UDP_RECV_BUFFER_SIZE); - if (buf == NULL) return; - union socket_address sa; - socklen_t sa_len = sizeof(sa); - int n = sl_RecvFrom(nc->sock, buf, MG_UDP_RECV_BUFFER_SIZE, 0, - (SlSockAddr_t *) &sa, &sa_len); - DBG(("%p %d bytes from %s:%d", nc, n, inet_ntoa(nc->sa.sin.sin_addr), - ntohs(nc->sa.sin.sin_port))); - if (n > 0) { - mg_if_recv_udp_cb(nc, buf, n, &sa, sa_len); - } else { - MG_FREE(buf); - } -} - -#define _MG_F_FD_CAN_READ 1 -#define _MG_F_FD_CAN_WRITE 1 << 1 -#define _MG_F_FD_ERROR 1 << 2 - -void mg_mgr_handle_conn(struct mg_connection *nc, int fd_flags, double now) { - DBG(("%p fd=%d fd_flags=%d nc_flags=%lu rmbl=%d smbl=%d", nc, nc->sock, - fd_flags, nc->flags, (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len)); - - if (nc->flags & MG_F_CONNECTING) { - if (nc->flags & MG_F_UDP || nc->err != SL_EALREADY) { - mg_if_connect_cb(nc, nc->err); - } else { - /* In SimpleLink, to get status of non-blocking connect() we need to wait - * until socket is writable and repeat the call to sl_Connect again, - * which will now return the real status. */ - if (fd_flags & _MG_F_FD_CAN_WRITE) { - nc->err = sl_Connect(nc->sock, &nc->sa.sa, sizeof(nc->sa.sin)); - DBG(("%p conn res=%d", nc, nc->err)); - if (nc->err == SL_ESECSNOVERIFY || - /* TODO(rojer): Provide API to set the date for verification. */ - nc->err == SL_ESECDATEERROR) { - nc->err = 0; - } - if (nc->flags & MG_F_SSL && nc->err == 0) { - nc->flags |= MG_F_SSL_HANDSHAKE_DONE; - } - mg_if_connect_cb(nc, nc->err); - } - } - /* Ignore read/write in further processing, we've handled it. */ - fd_flags &= ~(_MG_F_FD_CAN_READ | _MG_F_FD_CAN_WRITE); - } - - if (fd_flags & _MG_F_FD_CAN_READ) { - if (nc->flags & MG_F_UDP) { - mg_handle_udp_read(nc); - } else { - if (nc->flags & MG_F_LISTENING) { - mg_accept_conn(nc); - } else { - mg_handle_tcp_read(nc); - } - } - } - - if (!(nc->flags & MG_F_CLOSE_IMMEDIATELY)) { - if ((fd_flags & _MG_F_FD_CAN_WRITE) && nc->send_mbuf.len > 0) { - mg_write_to_socket(nc); - } - - if (!(fd_flags & (_MG_F_FD_CAN_READ | _MG_F_FD_CAN_WRITE))) { - mg_if_poll(nc, now); - } - mg_if_timer(nc, now); - } - - DBG(("%p after fd=%d nc_flags=%lu rmbl=%d smbl=%d", nc, nc->sock, nc->flags, - (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len)); -} - -/* Associate a socket to a connection. */ -void mg_sl_if_sock_set(struct mg_connection *nc, sock_t sock) { - mg_set_non_blocking_mode(sock); - nc->sock = sock; - DBG(("%p %d", nc, sock)); -} - -void mg_sl_if_init(struct mg_iface *iface) { - (void) iface; - DBG(("%p using sl_Select()", iface->mgr)); -} - -void mg_sl_if_free(struct mg_iface *iface) { - (void) iface; -} - -void mg_sl_if_add_conn(struct mg_connection *nc) { - (void) nc; -} - -void mg_sl_if_remove_conn(struct mg_connection *nc) { - (void) nc; -} - -time_t mg_sl_if_poll(struct mg_iface *iface, int timeout_ms) { - struct mg_mgr *mgr = iface->mgr; - double now = mg_time(); - double min_timer; - struct mg_connection *nc, *tmp; - struct SlTimeval_t tv; - SlFdSet_t read_set, write_set, err_set; - sock_t max_fd = INVALID_SOCKET; - int num_fds, num_ev = 0, num_timers = 0; - - SL_FD_ZERO(&read_set); - SL_FD_ZERO(&write_set); - SL_FD_ZERO(&err_set); - - /* - * Note: it is ok to have connections with sock == INVALID_SOCKET in the list, - * e.g. timer-only "connections". - */ - min_timer = 0; - for (nc = mgr->active_connections, num_fds = 0; nc != NULL; nc = tmp) { - tmp = nc->next; - - if (nc->sock != INVALID_SOCKET) { - num_fds++; - - if (!(nc->flags & MG_F_WANT_WRITE) && - nc->recv_mbuf.len < nc->recv_mbuf_limit && - (!(nc->flags & MG_F_UDP) || nc->listener == NULL)) { - SL_FD_SET(nc->sock, &read_set); - if (max_fd == INVALID_SOCKET || nc->sock > max_fd) max_fd = nc->sock; - } - - if (((nc->flags & MG_F_CONNECTING) && !(nc->flags & MG_F_WANT_READ)) || - (nc->send_mbuf.len > 0 && !(nc->flags & MG_F_CONNECTING))) { - SL_FD_SET(nc->sock, &write_set); - SL_FD_SET(nc->sock, &err_set); - if (max_fd == INVALID_SOCKET || nc->sock > max_fd) max_fd = nc->sock; - } - } - - if (nc->ev_timer_time > 0) { - if (num_timers == 0 || nc->ev_timer_time < min_timer) { - min_timer = nc->ev_timer_time; - } - num_timers++; - } - } - - /* - * If there is a timer to be fired earlier than the requested timeout, - * adjust the timeout. - */ - if (num_timers > 0) { - double timer_timeout_ms = (min_timer - mg_time()) * 1000 + 1 /* rounding */; - if (timer_timeout_ms < timeout_ms) { - timeout_ms = timer_timeout_ms; - } - } - if (timeout_ms < 0) timeout_ms = 0; - - tv.tv_sec = timeout_ms / 1000; - tv.tv_usec = (timeout_ms % 1000) * 1000; - - if (num_fds > 0) { - num_ev = sl_Select((int) max_fd + 1, &read_set, &write_set, &err_set, &tv); - } - - now = mg_time(); - DBG(("sl_Select @ %ld num_ev=%d of %d, timeout=%d", (long) now, num_ev, - num_fds, timeout_ms)); - - for (nc = mgr->active_connections; nc != NULL; nc = tmp) { - int fd_flags = 0; - if (nc->sock != INVALID_SOCKET) { - if (num_ev > 0) { - fd_flags = - (SL_FD_ISSET(nc->sock, &read_set) && - (!(nc->flags & MG_F_UDP) || nc->listener == NULL) - ? _MG_F_FD_CAN_READ - : 0) | - (SL_FD_ISSET(nc->sock, &write_set) ? _MG_F_FD_CAN_WRITE : 0) | - (SL_FD_ISSET(nc->sock, &err_set) ? _MG_F_FD_ERROR : 0); - } - /* SimpleLink does not report UDP sockets as writeable. */ - if (nc->flags & MG_F_UDP && nc->send_mbuf.len > 0) { - fd_flags |= _MG_F_FD_CAN_WRITE; - } - } - tmp = nc->next; - mg_mgr_handle_conn(nc, fd_flags, now); - } - - for (nc = mgr->active_connections; nc != NULL; nc = tmp) { - tmp = nc->next; - if ((nc->flags & MG_F_CLOSE_IMMEDIATELY) || - (nc->send_mbuf.len == 0 && (nc->flags & MG_F_SEND_AND_CLOSE))) { - mg_close_conn(nc); - } - } - - return now; -} - -void mg_sl_if_get_conn_addr(struct mg_connection *nc, int remote, - union socket_address *sa) { - /* SimpleLink does not provide a way to get socket's peer address after - * accept or connect. Address hould have been preserved in the connection, - * so we do our best here by using it. */ - if (remote) memcpy(sa, &nc->sa, sizeof(*sa)); -} - -void sl_restart_cb(struct mg_mgr *mgr) { - /* - * SimpleLink has been restarted, meaning all sockets have been invalidated. - * We try our best - we'll restart the listeners, but for outgoing - * connections we have no option but to terminate. - */ - struct mg_connection *nc; - for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) { - if (nc->sock == INVALID_SOCKET) continue; /* Could be a timer */ - if (nc->flags & MG_F_LISTENING) { - DBG(("restarting %p %s:%d", nc, inet_ntoa(nc->sa.sin.sin_addr), - ntohs(nc->sa.sin.sin_port))); - int res = (nc->flags & MG_F_UDP ? mg_sl_if_listen_udp(nc, &nc->sa) - : mg_sl_if_listen_tcp(nc, &nc->sa)); - if (res == 0) continue; - /* Well, we tried and failed. Fall through to closing. */ - } - nc->sock = INVALID_SOCKET; - DBG(("terminating %p %s:%d", nc, inet_ntoa(nc->sa.sin.sin_addr), - ntohs(nc->sa.sin.sin_port))); - /* TODO(rojer): Outgoing UDP? */ - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - } -} - -/* clang-format off */ -#define MG_SL_IFACE_VTABLE \ - { \ - mg_sl_if_init, \ - mg_sl_if_free, \ - mg_sl_if_add_conn, \ - mg_sl_if_remove_conn, \ - mg_sl_if_poll, \ - mg_sl_if_listen_tcp, \ - mg_sl_if_listen_udp, \ - mg_sl_if_connect_tcp, \ - mg_sl_if_connect_udp, \ - mg_sl_if_tcp_send, \ - mg_sl_if_udp_send, \ - mg_sl_if_recved, \ - mg_sl_if_create_conn, \ - mg_sl_if_destroy_conn, \ - mg_sl_if_sock_set, \ - mg_sl_if_get_conn_addr, \ - } -/* clang-format on */ - -struct mg_iface_vtable mg_simplelink_iface_vtable = MG_SL_IFACE_VTABLE; -#if MG_NET_IF == MG_NET_IF_SIMPLELINK -struct mg_iface_vtable mg_default_iface_vtable = MG_SL_IFACE_VTABLE; -#endif - -#endif /* MG_ENABLE_NET_IF_SIMPLELINK */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/sl_ssl_if.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK - -struct mg_ssl_if_ctx { - char *ssl_cert; - char *ssl_key; - char *ssl_ca_cert; - char *ssl_server_name; -}; - -void mg_ssl_if_init() { -} - -enum mg_ssl_if_result mg_ssl_if_conn_init( - struct mg_connection *nc, const struct mg_ssl_if_conn_params *params, - const char **err_msg) { - struct mg_ssl_if_ctx *ctx = - (struct mg_ssl_if_ctx *) MG_CALLOC(1, sizeof(*ctx)); - if (ctx == NULL) { - MG_SET_PTRPTR(err_msg, "Out of memory"); - return MG_SSL_ERROR; - } - nc->ssl_if_data = ctx; - - if (params->cert != NULL || params->key != NULL) { - if (params->cert != NULL && params->key != NULL) { - ctx->ssl_cert = strdup(params->cert); - ctx->ssl_key = strdup(params->key); - } else { - MG_SET_PTRPTR(err_msg, "Both cert and key are required."); - return MG_SSL_ERROR; - } - } - if (params->ca_cert != NULL && strcmp(params->ca_cert, "*") != 0) { - ctx->ssl_ca_cert = strdup(params->ca_cert); - } - /* TODO(rojer): cipher_suites. */ - if (params->server_name != NULL) { - ctx->ssl_server_name = strdup(params->server_name); - } - return MG_SSL_OK; -} - -void mg_ssl_if_conn_free(struct mg_connection *nc) { - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - if (ctx == NULL) return; - nc->ssl_if_data = NULL; - MG_FREE(ctx->ssl_cert); - MG_FREE(ctx->ssl_key); - MG_FREE(ctx->ssl_ca_cert); - MG_FREE(ctx->ssl_server_name); - memset(ctx, 0, sizeof(*ctx)); - MG_FREE(ctx); -} - -bool pem_to_der(const char *pem_file, const char *der_file) { - bool ret = false; - FILE *pf = NULL, *df = NULL; - bool writing = false; - pf = fopen(pem_file, "r"); - if (pf == NULL) goto clean; - remove(der_file); - fs_slfs_set_new_file_size(der_file + 3, 2048); - df = fopen(der_file, "w"); - if (df == NULL) goto clean; - while (1) { - char pem_buf[70]; - char der_buf[48]; - if (!fgets(pem_buf, sizeof(pem_buf), pf)) break; - if (writing) { - if (strstr(pem_buf, "-----END ") != NULL) { - ret = true; - break; - } - int l = 0; - while (!isspace((unsigned int) pem_buf[l])) l++; - int der_len = 0; - cs_base64_decode((const unsigned char *) pem_buf, sizeof(pem_buf), - der_buf, &der_len); - if (der_len <= 0) break; - if (fwrite(der_buf, 1, der_len, df) != der_len) break; - } else if (strstr(pem_buf, "-----BEGIN ") != NULL) { - writing = true; - } - } - -clean: - if (pf != NULL) fclose(pf); - if (df != NULL) { - fclose(df); - if (!ret) remove(der_file); - } - return ret; -} - -#if MG_ENABLE_FILESYSTEM && defined(MG_FS_SLFS) -/* If the file's extension is .pem, convert it to DER format and put on SLFS. */ -static char *sl_pem2der(const char *pem_file) { - const char *pem_ext = strstr(pem_file, ".pem"); - if (pem_ext == NULL || *(pem_ext + 4) != '\0') { - return strdup(pem_file); - } - char *der_file = NULL; - /* DER file must be located on SLFS, add prefix. */ - int l = mg_asprintf(&der_file, 0, "SL:%.*s.der", (int) (pem_ext - pem_file), - pem_file); - if (der_file == NULL) return NULL; - bool result = false; - cs_stat_t st; - if (mg_stat(der_file, &st) != 0) { - result = pem_to_der(pem_file, der_file); - LOG(LL_DEBUG, ("%s -> %s = %d", pem_file, der_file, result)); - } else { - /* File exists, assume it's already been converted. */ - result = true; - } - if (result) { - /* Strip the SL: prefix we added since NWP does not expect it. */ - memmove(der_file, der_file + 3, l - 2 /* including \0 */); - } else { - free(der_file); - der_file = NULL; - } - return der_file; -} -#else -static char *sl_pem2der(const char *pem_file) { - return strdup(pem_file); -} -#endif - -int sl_set_ssl_opts(struct mg_connection *nc) { - int err; - struct mg_ssl_if_ctx *ctx = (struct mg_ssl_if_ctx *) nc->ssl_if_data; - DBG(("%p ssl ctx: %p", nc, ctx)); - - if (ctx != NULL) { - DBG(("%p %s,%s,%s,%s", nc, (ctx->ssl_cert ? ctx->ssl_cert : "-"), - (ctx->ssl_key ? ctx->ssl_cert : "-"), - (ctx->ssl_ca_cert ? ctx->ssl_ca_cert : "-"), - (ctx->ssl_server_name ? ctx->ssl_server_name : "-"))); - if (ctx->ssl_cert != NULL && ctx->ssl_key != NULL) { - char *ssl_cert = sl_pem2der(ctx->ssl_cert); - char *ssl_key = sl_pem2der(ctx->ssl_key); - if (ssl_cert != NULL && ssl_key != NULL) { - err = sl_SetSockOpt(nc->sock, SL_SOL_SOCKET, - SL_SO_SECURE_FILES_CERTIFICATE_FILE_NAME, ssl_cert, - strlen(ssl_cert)); - LOG(LL_INFO, ("CERTIFICATE_FILE_NAME %s -> %d", ssl_cert, err)); - err = sl_SetSockOpt(nc->sock, SL_SOL_SOCKET, - SL_SO_SECURE_FILES_PRIVATE_KEY_FILE_NAME, ssl_key, - strlen(ssl_key)); - LOG(LL_INFO, ("PRIVATE_KEY_FILE_NAME %s -> %d", ssl_key, err)); - } else { - err = -1; - } - free(ssl_cert); - free(ssl_key); - if (err != 0) return err; - } - if (ctx->ssl_ca_cert != NULL) { - if (ctx->ssl_ca_cert[0] != '\0') { - char *ssl_ca_cert = sl_pem2der(ctx->ssl_ca_cert); - if (ssl_ca_cert != NULL) { - err = sl_SetSockOpt(nc->sock, SL_SOL_SOCKET, - SL_SO_SECURE_FILES_CA_FILE_NAME, ssl_ca_cert, - strlen(ssl_ca_cert)); - LOG(LL_INFO, ("CA_FILE_NAME %s -> %d", ssl_ca_cert, err)); - } else { - err = -1; - } - free(ssl_ca_cert); - if (err != 0) return err; - } - } - if (ctx->ssl_server_name != NULL) { - err = sl_SetSockOpt(nc->sock, SL_SOL_SOCKET, - SO_SECURE_DOMAIN_NAME_VERIFICATION, - ctx->ssl_server_name, strlen(ctx->ssl_server_name)); - DBG(("DOMAIN_NAME_VERIFICATION %s -> %d", ctx->ssl_server_name, err)); - /* Domain name verificationw as added in a NWP service pack, older - * versions return SL_ENOPROTOOPT. There isn't much we can do about it, - * so we ignore the error. */ - if (err != 0 && err != SL_ENOPROTOOPT) return err; - } - } - return 0; -} - -#endif /* MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/lwip/mg_lwip_net_if.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_ -#define CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_ - -#ifndef MG_ENABLE_NET_IF_LWIP_LOW_LEVEL -#define MG_ENABLE_NET_IF_LWIP_LOW_LEVEL MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL -#endif - -#if MG_ENABLE_NET_IF_LWIP_LOW_LEVEL - -#include - -extern struct mg_iface_vtable mg_lwip_iface_vtable; - -struct mg_lwip_conn_state { - struct mg_connection *nc; - union { - struct tcp_pcb *tcp; - struct udp_pcb *udp; - } pcb; - err_t err; - size_t num_sent; /* Number of acknowledged bytes to be reported to the core */ - struct pbuf *rx_chain; /* Chain of incoming data segments. */ - size_t rx_offset; /* Offset within the first pbuf (if partially consumed) */ - /* Last SSL write size, for retries. */ - int last_ssl_write_size; -}; - -enum mg_sig_type { - MG_SIG_CONNECT_RESULT = 1, - MG_SIG_RECV = 2, - MG_SIG_SENT_CB = 3, - MG_SIG_CLOSE_CONN = 4, - MG_SIG_TOMBSTONE = 5, -}; - -void mg_lwip_post_signal(enum mg_sig_type sig, struct mg_connection *nc); - -/* To be implemented by the platform. */ -void mg_lwip_mgr_schedule_poll(struct mg_mgr *mgr); - -#endif /* MG_ENABLE_NET_IF_LWIP_LOW_LEVEL */ - -#endif /* CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/lwip/mg_lwip_net_if.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_NET_IF_LWIP_LOW_LEVEL - -#include -#include -#if CS_PLATFORM != CS_P_STM32 -#include -#endif -#include - -/* Amalgamated: #include "common/cs_dbg.h" */ - -/* - * Depending on whether Mongoose is compiled with ipv6 support, use right - * lwip functions - */ -#if MG_ENABLE_IPV6 -#define TCP_NEW tcp_new_ip6 -#define TCP_BIND tcp_bind_ip6 -#define UDP_BIND udp_bind_ip6 -#define IPADDR_NTOA(x) ip6addr_ntoa((const ip6_addr_t *)(x)) -#define SET_ADDR(dst, src) \ - memcpy((dst)->sin6.sin6_addr.s6_addr, (src)->ip6.addr, \ - sizeof((dst)->sin6.sin6_addr.s6_addr)) -#else -#define TCP_NEW tcp_new -#define TCP_BIND tcp_bind -#define UDP_BIND udp_bind -#define IPADDR_NTOA ipaddr_ntoa -#define SET_ADDR(dst, src) (dst)->sin.sin_addr.s_addr = GET_IPV4(src) -#endif - -/* - * If lwip is compiled with ipv6 support, then API changes even for ipv4 - */ -#if !defined(LWIP_IPV6) || !LWIP_IPV6 -#define GET_IPV4(ipX_addr) ((ipX_addr)->addr) -#else -#define GET_IPV4(ipX_addr) ((ipX_addr)->ip4.addr) -#endif - -void mg_lwip_ssl_do_hs(struct mg_connection *nc); -void mg_lwip_ssl_send(struct mg_connection *nc); -void mg_lwip_ssl_recv(struct mg_connection *nc); - -void mg_lwip_if_init(struct mg_iface *iface); -void mg_lwip_if_free(struct mg_iface *iface); -void mg_lwip_if_add_conn(struct mg_connection *nc); -void mg_lwip_if_remove_conn(struct mg_connection *nc); -time_t mg_lwip_if_poll(struct mg_iface *iface, int timeout_ms); - -#if LWIP_TCP_KEEPALIVE -void mg_lwip_set_keepalive_params(struct mg_connection *nc, int idle, - int interval, int count) { - if (nc->sock == INVALID_SOCKET || nc->flags & MG_F_UDP) { - return; - } - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - struct tcp_pcb *tpcb = cs->pcb.tcp; - if (idle > 0 && interval > 0 && count > 0) { - tpcb->keep_idle = idle * 1000; - tpcb->keep_intvl = interval * 1000; - tpcb->keep_cnt = count; - tpcb->so_options |= SOF_KEEPALIVE; - } else { - tpcb->so_options &= ~SOF_KEEPALIVE; - } -} -#elif !defined(MG_NO_LWIP_TCP_KEEPALIVE) -#warning LWIP TCP keepalive is disabled. Please consider enabling it. -#endif /* LWIP_TCP_KEEPALIVE */ - -static err_t mg_lwip_tcp_conn_cb(void *arg, struct tcp_pcb *tpcb, err_t err) { - struct mg_connection *nc = (struct mg_connection *) arg; - DBG(("%p connect to %s:%u = %d", nc, IPADDR_NTOA(&tpcb->remote_ip), - tpcb->remote_port, err)); - if (nc == NULL) { - tcp_abort(tpcb); - return ERR_ARG; - } - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - cs->err = err; -#if LWIP_TCP_KEEPALIVE - if (err == 0) mg_lwip_set_keepalive_params(nc, 60, 10, 6); -#endif - mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc); - return ERR_OK; -} - -static void mg_lwip_tcp_error_cb(void *arg, err_t err) { - struct mg_connection *nc = (struct mg_connection *) arg; - DBG(("%p conn error %d", nc, err)); - if (nc == NULL) return; - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - cs->pcb.tcp = NULL; /* Has already been deallocated */ - if (nc->flags & MG_F_CONNECTING) { - cs->err = err; - mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc); - } else { - mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc); - } -} - -static err_t mg_lwip_tcp_recv_cb(void *arg, struct tcp_pcb *tpcb, - struct pbuf *p, err_t err) { - struct mg_connection *nc = (struct mg_connection *) arg; - DBG(("%p %p %u %d", nc, tpcb, (p != NULL ? p->tot_len : 0), err)); - if (p == NULL) { - if (nc != NULL) { - mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc); - } else { - /* Tombstoned connection, do nothing. */ - } - return ERR_OK; - } else if (nc == NULL) { - tcp_abort(tpcb); - return ERR_ARG; - } - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - /* - * If we get a chain of more than one segment at once, we need to bump - * refcount on the subsequent bufs to make them independent. - */ - if (p->next != NULL) { - struct pbuf *q = p->next; - for (; q != NULL; q = q->next) pbuf_ref(q); - } - if (cs->rx_chain == NULL) { - cs->rx_chain = p; - cs->rx_offset = 0; - } else { - if (pbuf_clen(cs->rx_chain) >= 4) { - /* ESP SDK has a limited pool of 5 pbufs. We must not hog them all or RX - * will be completely blocked. We already have at least 4 in the chain, - * this one is, so we have to make a copy and release this one. */ - struct pbuf *np = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM); - if (np != NULL) { - pbuf_copy(np, p); - pbuf_free(p); - p = np; - } - } - pbuf_chain(cs->rx_chain, p); - } - mg_lwip_post_signal(MG_SIG_RECV, nc); - return ERR_OK; -} - -static void mg_lwip_handle_recv(struct mg_connection *nc) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - -#if MG_ENABLE_SSL - if (nc->flags & MG_F_SSL) { - if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) { - mg_lwip_ssl_recv(nc); - } else { - mg_lwip_ssl_do_hs(nc); - } - return; - } -#endif - - while (cs->rx_chain != NULL) { - struct pbuf *seg = cs->rx_chain; - size_t len = (seg->len - cs->rx_offset); - char *data = (char *) malloc(len); - if (data == NULL) { - DBG(("OOM")); - return; - } - pbuf_copy_partial(seg, data, len, cs->rx_offset); - mg_if_recv_tcp_cb(nc, data, len, 1 /* own */); - cs->rx_offset += len; - if (cs->rx_offset == cs->rx_chain->len) { - cs->rx_chain = pbuf_dechain(cs->rx_chain); - pbuf_free(seg); - cs->rx_offset = 0; - } - } - - if (nc->send_mbuf.len > 0) { - mg_lwip_mgr_schedule_poll(nc->mgr); - } -} - -static err_t mg_lwip_tcp_sent_cb(void *arg, struct tcp_pcb *tpcb, - u16_t num_sent) { - struct mg_connection *nc = (struct mg_connection *) arg; - DBG(("%p %p %u", nc, tpcb, num_sent)); - if (nc == NULL) { - tcp_abort(tpcb); - return ERR_ABRT; - } - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - cs->num_sent += num_sent; - - mg_lwip_post_signal(MG_SIG_SENT_CB, nc); - return ERR_OK; -} - -void mg_lwip_if_connect_tcp(struct mg_connection *nc, - const union socket_address *sa) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - struct tcp_pcb *tpcb = TCP_NEW(); - cs->pcb.tcp = tpcb; - ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr; - u16_t port = ntohs(sa->sin.sin_port); - tcp_arg(tpcb, nc); - tcp_err(tpcb, mg_lwip_tcp_error_cb); - tcp_sent(tpcb, mg_lwip_tcp_sent_cb); - tcp_recv(tpcb, mg_lwip_tcp_recv_cb); - cs->err = TCP_BIND(tpcb, IP_ADDR_ANY, 0 /* any port */); - DBG(("%p tcp_bind = %d", nc, cs->err)); - if (cs->err != ERR_OK) { - mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc); - return; - } - cs->err = tcp_connect(tpcb, ip, port, mg_lwip_tcp_conn_cb); - DBG(("%p tcp_connect %p = %d", nc, tpcb, cs->err)); - if (cs->err != ERR_OK) { - mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc); - return; - } -} - -/* - * Lwip included in the SDKs for nRF5x chips has different type for the - * callback of `udp_recv()` - */ -#if CS_PLATFORM == CS_P_NRF51 || CS_PLATFORM == CS_P_NRF52 || \ - CS_PLATFORM == CS_P_STM32 -static void mg_lwip_udp_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *addr, u16_t port) -#else -static void mg_lwip_udp_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p, - ip_addr_t *addr, u16_t port) -#endif -{ - struct mg_connection *nc = (struct mg_connection *) arg; - size_t len = p->len; - char *data = (char *) malloc(len); - union socket_address sa; - (void) pcb; - DBG(("%p %s:%u %u", nc, IPADDR_NTOA(addr), port, p->len)); - if (data == NULL) { - DBG(("OOM")); - pbuf_free(p); - return; - } - sa.sin.sin_addr.s_addr = addr->addr; - sa.sin.sin_port = htons(port); - pbuf_copy_partial(p, data, len, 0); - pbuf_free(p); - mg_if_recv_udp_cb(nc, data, len, &sa, sizeof(sa.sin)); -} - -void mg_lwip_if_connect_udp(struct mg_connection *nc) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - struct udp_pcb *upcb = udp_new(); - cs->err = UDP_BIND(upcb, IP_ADDR_ANY, 0 /* any port */); - DBG(("%p udp_bind %p = %d", nc, upcb, cs->err)); - if (cs->err == ERR_OK) { - udp_recv(upcb, mg_lwip_udp_recv_cb, nc); - cs->pcb.udp = upcb; - } else { - udp_remove(upcb); - } - mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc); -} - -void mg_lwip_accept_conn(struct mg_connection *nc, struct tcp_pcb *tpcb) { - union socket_address sa; - SET_ADDR(&sa, &tpcb->remote_ip); - sa.sin.sin_port = htons(tpcb->remote_port); - mg_if_accept_tcp_cb(nc, &sa, sizeof(sa.sin)); -} - -static err_t mg_lwip_accept_cb(void *arg, struct tcp_pcb *newtpcb, err_t err) { - struct mg_connection *lc = (struct mg_connection *) arg; - (void) err; - DBG(("%p conn %p from %s:%u", lc, newtpcb, IPADDR_NTOA(&newtpcb->remote_ip), - newtpcb->remote_port)); - struct mg_connection *nc = mg_if_accept_new_conn(lc); - if (nc == NULL) { - tcp_abort(newtpcb); - return ERR_ABRT; - } - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - cs->pcb.tcp = newtpcb; - tcp_arg(newtpcb, nc); - tcp_err(newtpcb, mg_lwip_tcp_error_cb); - tcp_sent(newtpcb, mg_lwip_tcp_sent_cb); - tcp_recv(newtpcb, mg_lwip_tcp_recv_cb); -#if LWIP_TCP_KEEPALIVE - mg_lwip_set_keepalive_params(nc, 60, 10, 6); -#endif -#if MG_ENABLE_SSL - if (lc->flags & MG_F_SSL) { - if (mg_ssl_if_conn_accept(nc, lc) != MG_SSL_OK) { - LOG(LL_ERROR, ("SSL error")); - tcp_close(newtpcb); - } - } else -#endif - { - mg_lwip_accept_conn(nc, newtpcb); - } - return ERR_OK; -} - -int mg_lwip_if_listen_tcp(struct mg_connection *nc, union socket_address *sa) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - struct tcp_pcb *tpcb = TCP_NEW(); - ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr; - u16_t port = ntohs(sa->sin.sin_port); - cs->err = TCP_BIND(tpcb, ip, port); - DBG(("%p tcp_bind(%s:%u) = %d", nc, IPADDR_NTOA(ip), port, cs->err)); - if (cs->err != ERR_OK) { - tcp_close(tpcb); - return -1; - } - tcp_arg(tpcb, nc); - tpcb = tcp_listen(tpcb); - cs->pcb.tcp = tpcb; - tcp_accept(tpcb, mg_lwip_accept_cb); - return 0; -} - -int mg_lwip_if_listen_udp(struct mg_connection *nc, union socket_address *sa) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - struct udp_pcb *upcb = udp_new(); - ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr; - u16_t port = ntohs(sa->sin.sin_port); - cs->err = UDP_BIND(upcb, ip, port); - DBG(("%p udb_bind(%s:%u) = %d", nc, IPADDR_NTOA(ip), port, cs->err)); - if (cs->err != ERR_OK) { - udp_remove(upcb); - return -1; - } - udp_recv(upcb, mg_lwip_udp_recv_cb, nc); - cs->pcb.udp = upcb; - return 0; -} - -int mg_lwip_tcp_write(struct mg_connection *nc, const void *data, - uint16_t len) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - struct tcp_pcb *tpcb = cs->pcb.tcp; - len = MIN(tpcb->mss, MIN(len, tpcb->snd_buf)); - if (len == 0) { - DBG(("%p no buf avail %u %u %u %p %p", tpcb, tpcb->acked, tpcb->snd_buf, - tpcb->snd_queuelen, tpcb->unsent, tpcb->unacked)); - tcp_output(tpcb); - return 0; - } -/* - * On ESP8266 we only allow one TCP segment in flight at any given time. - * This may increase latency and reduce efficiency of tcp windowing, - * but memory is scarce and precious on that platform so we do this to - * reduce footprint. - */ -#if CS_PLATFORM == CS_P_ESP8266 - if (tpcb->unacked != NULL) { - return 0; - } - if (tpcb->unsent != NULL) { - len = MIN(len, (TCP_MSS - tpcb->unsent->len)); - } -#endif - err_t err = tcp_write(tpcb, data, len, TCP_WRITE_FLAG_COPY); - DBG(("%p tcp_write %u = %d", tpcb, len, err)); - if (err != ERR_OK) { - /* - * We ignore ERR_MEM because memory will be freed up when the data is sent - * and we'll retry. - */ - return (err == ERR_MEM ? 0 : -1); - } - return len; -} - -static void mg_lwip_send_more(struct mg_connection *nc) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - if (nc->sock == INVALID_SOCKET || cs->pcb.tcp == NULL) { - DBG(("%p invalid socket", nc)); - return; - } - int num_written = mg_lwip_tcp_write(nc, nc->send_mbuf.buf, nc->send_mbuf.len); - DBG(("%p mg_lwip_tcp_write %u = %d", nc, nc->send_mbuf.len, num_written)); - if (num_written == 0) return; - if (num_written < 0) { - mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc); - } - mbuf_remove(&nc->send_mbuf, num_written); - mbuf_trim(&nc->send_mbuf); -} - -void mg_lwip_if_tcp_send(struct mg_connection *nc, const void *buf, - size_t len) { - mbuf_append(&nc->send_mbuf, buf, len); - mg_lwip_mgr_schedule_poll(nc->mgr); -} - -void mg_lwip_if_udp_send(struct mg_connection *nc, const void *buf, - size_t len) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - if (nc->sock == INVALID_SOCKET || cs->pcb.udp == NULL) { - /* - * In case of UDP, this usually means, what - * async DNS resolve is still in progress and connection - * is not ready yet - */ - DBG(("%p socket is not connected", nc)); - return; - } - struct udp_pcb *upcb = cs->pcb.udp; - struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); - ip_addr_t *ip = (ip_addr_t *) &nc->sa.sin.sin_addr.s_addr; - u16_t port = ntohs(nc->sa.sin.sin_port); - memcpy(p->payload, buf, len); - cs->err = udp_sendto(upcb, p, (ip_addr_t *) ip, port); - DBG(("%p udp_sendto = %d", nc, cs->err)); - pbuf_free(p); - if (cs->err != ERR_OK) { - mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc); - } else { - cs->num_sent += len; - mg_lwip_post_signal(MG_SIG_SENT_CB, nc); - } -} - -void mg_lwip_if_recved(struct mg_connection *nc, size_t len) { - if (nc->flags & MG_F_UDP) return; - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - if (nc->sock == INVALID_SOCKET || cs->pcb.tcp == NULL) { - DBG(("%p invalid socket", nc)); - return; - } - DBG(("%p %p %u", nc, cs->pcb.tcp, len)); -/* Currently SSL acknowledges data immediately. - * TODO(rojer): Find a way to propagate mg_lwip_if_recved. */ -#if MG_ENABLE_SSL - if (!(nc->flags & MG_F_SSL)) { - tcp_recved(cs->pcb.tcp, len); - } -#else - tcp_recved(cs->pcb.tcp, len); -#endif - mbuf_trim(&nc->recv_mbuf); -} - -int mg_lwip_if_create_conn(struct mg_connection *nc) { - struct mg_lwip_conn_state *cs = - (struct mg_lwip_conn_state *) calloc(1, sizeof(*cs)); - if (cs == NULL) return 0; - cs->nc = nc; - nc->sock = (intptr_t) cs; - return 1; -} - -void mg_lwip_if_destroy_conn(struct mg_connection *nc) { - if (nc->sock == INVALID_SOCKET) return; - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - if (!(nc->flags & MG_F_UDP)) { - struct tcp_pcb *tpcb = cs->pcb.tcp; - if (tpcb != NULL) { - tcp_arg(tpcb, NULL); - DBG(("%p tcp_close %p", nc, tpcb)); - tcp_arg(tpcb, NULL); - tcp_close(tpcb); - } - while (cs->rx_chain != NULL) { - struct pbuf *seg = cs->rx_chain; - cs->rx_chain = pbuf_dechain(cs->rx_chain); - pbuf_free(seg); - } - memset(cs, 0, sizeof(*cs)); - free(cs); - } else if (nc->listener == NULL) { - /* Only close outgoing UDP pcb or listeners. */ - struct udp_pcb *upcb = cs->pcb.udp; - if (upcb != NULL) { - DBG(("%p udp_remove %p", nc, upcb)); - udp_remove(upcb); - } - memset(cs, 0, sizeof(*cs)); - free(cs); - } - nc->sock = INVALID_SOCKET; -} - -void mg_lwip_if_get_conn_addr(struct mg_connection *nc, int remote, - union socket_address *sa) { - memset(sa, 0, sizeof(*sa)); - if (nc->sock == INVALID_SOCKET) return; - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - if (nc->flags & MG_F_UDP) { - struct udp_pcb *upcb = cs->pcb.udp; - if (remote) { - memcpy(sa, &nc->sa, sizeof(*sa)); - } else { - sa->sin.sin_port = htons(upcb->local_port); - SET_ADDR(sa, &upcb->local_ip); - } - } else { - struct tcp_pcb *tpcb = cs->pcb.tcp; - if (remote) { - sa->sin.sin_port = htons(tpcb->remote_port); - SET_ADDR(sa, &tpcb->remote_ip); - } else { - sa->sin.sin_port = htons(tpcb->local_port); - SET_ADDR(sa, &tpcb->local_ip); - } - } -} - -void mg_lwip_if_sock_set(struct mg_connection *nc, sock_t sock) { - nc->sock = sock; -} - -/* clang-format off */ -#define MG_LWIP_IFACE_VTABLE \ - { \ - mg_lwip_if_init, \ - mg_lwip_if_free, \ - mg_lwip_if_add_conn, \ - mg_lwip_if_remove_conn, \ - mg_lwip_if_poll, \ - mg_lwip_if_listen_tcp, \ - mg_lwip_if_listen_udp, \ - mg_lwip_if_connect_tcp, \ - mg_lwip_if_connect_udp, \ - mg_lwip_if_tcp_send, \ - mg_lwip_if_udp_send, \ - mg_lwip_if_recved, \ - mg_lwip_if_create_conn, \ - mg_lwip_if_destroy_conn, \ - mg_lwip_if_sock_set, \ - mg_lwip_if_get_conn_addr, \ - } -/* clang-format on */ - -struct mg_iface_vtable mg_lwip_iface_vtable = MG_LWIP_IFACE_VTABLE; -#if MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL -struct mg_iface_vtable mg_default_iface_vtable = MG_LWIP_IFACE_VTABLE; -#endif - -#endif /* MG_ENABLE_NET_IF_LWIP_LOW_LEVEL */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/lwip/mg_lwip_ev_mgr.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL - -#ifndef MG_SIG_QUEUE_LEN -#define MG_SIG_QUEUE_LEN 16 -#endif - -struct mg_ev_mgr_lwip_signal { - int sig; - struct mg_connection *nc; -}; - -struct mg_ev_mgr_lwip_data { - struct mg_ev_mgr_lwip_signal sig_queue[MG_SIG_QUEUE_LEN]; - int sig_queue_len; - int start_index; -}; - -void mg_lwip_post_signal(enum mg_sig_type sig, struct mg_connection *nc) { - struct mg_ev_mgr_lwip_data *md = - (struct mg_ev_mgr_lwip_data *) nc->iface->data; - if (md->sig_queue_len >= MG_SIG_QUEUE_LEN) return; - int end_index = (md->start_index + md->sig_queue_len) % MG_SIG_QUEUE_LEN; - md->sig_queue[end_index].sig = sig; - md->sig_queue[end_index].nc = nc; - md->sig_queue_len++; -} - -void mg_ev_mgr_lwip_process_signals(struct mg_mgr *mgr) { - struct mg_ev_mgr_lwip_data *md = - (struct mg_ev_mgr_lwip_data *) mgr->ifaces[MG_MAIN_IFACE]->data; - while (md->sig_queue_len > 0) { - struct mg_connection *nc = md->sig_queue[md->start_index].nc; - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - switch (md->sig_queue[md->start_index].sig) { - case MG_SIG_CONNECT_RESULT: { -#if MG_ENABLE_SSL - if (cs->err == 0 && (nc->flags & MG_F_SSL) && - !(nc->flags & MG_F_SSL_HANDSHAKE_DONE)) { - mg_lwip_ssl_do_hs(nc); - } else -#endif - { - mg_if_connect_cb(nc, cs->err); - } - break; - } - case MG_SIG_CLOSE_CONN: { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - mg_close_conn(nc); - break; - } - case MG_SIG_RECV: { - mg_lwip_handle_recv(nc); - break; - } - case MG_SIG_SENT_CB: { - if (cs->num_sent > 0) mg_if_sent_cb(nc, cs->num_sent); - cs->num_sent = 0; - - if (nc->send_mbuf.len == 0 && (nc->flags & MG_F_SEND_AND_CLOSE) && - !(nc->flags & MG_F_WANT_WRITE)) { - mg_close_conn(nc); - } - - break; - } - case MG_SIG_TOMBSTONE: { - break; - } - } - md->start_index = (md->start_index + 1) % MG_SIG_QUEUE_LEN; - md->sig_queue_len--; - } -} - -void mg_lwip_if_init(struct mg_iface *iface) { - LOG(LL_INFO, ("%p Mongoose init")); - iface->data = MG_CALLOC(1, sizeof(struct mg_ev_mgr_lwip_data)); -} - -void mg_lwip_if_free(struct mg_iface *iface) { - MG_FREE(iface->data); - iface->data = NULL; -} - -void mg_lwip_if_add_conn(struct mg_connection *nc) { - (void) nc; -} - -void mg_lwip_if_remove_conn(struct mg_connection *nc) { - struct mg_ev_mgr_lwip_data *md = - (struct mg_ev_mgr_lwip_data *) nc->iface->data; - /* Walk the queue and null-out further signals for this conn. */ - for (int i = 0; i < MG_SIG_QUEUE_LEN; i++) { - if (md->sig_queue[i].nc == nc) { - md->sig_queue[i].sig = MG_SIG_TOMBSTONE; - } - } -} - -time_t mg_lwip_if_poll(struct mg_iface *iface, int timeout_ms) { - struct mg_mgr *mgr = iface->mgr; - int n = 0; - double now = mg_time(); - struct mg_connection *nc, *tmp; - double min_timer = 0; - int num_timers = 0; -#if 0 - DBG(("begin poll @%u", (unsigned int) (now * 1000))); -#endif - mg_ev_mgr_lwip_process_signals(mgr); - for (nc = mgr->active_connections; nc != NULL; nc = tmp) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - tmp = nc->next; - n++; - if (nc->flags & MG_F_CLOSE_IMMEDIATELY) { - mg_close_conn(nc); - continue; - } - mg_if_poll(nc, now); - mg_if_timer(nc, now); -#if MG_ENABLE_SSL - if ((nc->flags & MG_F_SSL) && cs != NULL && cs->pcb.tcp != NULL && - cs->pcb.tcp->state == ESTABLISHED) { - if (((nc->flags & MG_F_WANT_WRITE) || - ((nc->send_mbuf.len > 0) && - (nc->flags & MG_F_SSL_HANDSHAKE_DONE))) && - cs->pcb.tcp->snd_buf > 0) { - /* Can write more. */ - if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) { - if (!(nc->flags & MG_F_CONNECTING)) mg_lwip_ssl_send(nc); - } else { - mg_lwip_ssl_do_hs(nc); - } - } - if (cs->rx_chain != NULL || (nc->flags & MG_F_WANT_READ)) { - if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) { - if (!(nc->flags & MG_F_CONNECTING)) mg_lwip_ssl_recv(nc); - } else { - mg_lwip_ssl_do_hs(nc); - } - } - } else -#endif /* MG_ENABLE_SSL */ - { - if (!(nc->flags & (MG_F_CONNECTING | MG_F_UDP))) { - if (nc->send_mbuf.len > 0) mg_lwip_send_more(nc); - } - } - if (nc->sock != INVALID_SOCKET && - !(nc->flags & (MG_F_UDP | MG_F_LISTENING)) && cs->pcb.tcp != NULL && - cs->pcb.tcp->unsent != NULL) { - tcp_output(cs->pcb.tcp); - } - if (nc->ev_timer_time > 0) { - if (num_timers == 0 || nc->ev_timer_time < min_timer) { - min_timer = nc->ev_timer_time; - } - num_timers++; - } - } -#if 0 - DBG(("end poll @%u, %d conns, %d timers (min %u), next in %d ms", - (unsigned int) (now * 1000), n, num_timers, - (unsigned int) (min_timer * 1000), timeout_ms)); -#endif - (void) timeout_ms; - return now; -} - -uint32_t mg_lwip_get_poll_delay_ms(struct mg_mgr *mgr) { - struct mg_connection *nc; - double now = mg_time(); - double min_timer = 0; - int num_timers = 0; - mg_ev_mgr_lwip_process_signals(mgr); - for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) { - if (nc->ev_timer_time > 0) { - if (num_timers == 0 || nc->ev_timer_time < min_timer) { - min_timer = nc->ev_timer_time; - } - num_timers++; - } - } - uint32_t timeout_ms = ~0; - if (num_timers > 0) { - double timer_timeout_ms = (min_timer - now) * 1000 + 1 /* rounding */; - if (timer_timeout_ms < timeout_ms) { - timeout_ms = timer_timeout_ms; - } - } - return timeout_ms; -} - -#endif /* MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/lwip/mg_lwip_ssl_if.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_SSL && MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL - -/* Amalgamated: #include "common/cs_dbg.h" */ - -#include -#include - -#ifndef MG_LWIP_SSL_IO_SIZE -#define MG_LWIP_SSL_IO_SIZE 1024 -#endif - -/* - * Stop processing incoming SSL traffic when recv_mbuf.size is this big. - * It'a a uick solution for SSL recv pushback. - */ -#ifndef MG_LWIP_SSL_RECV_MBUF_LIMIT -#define MG_LWIP_SSL_RECV_MBUF_LIMIT 3072 -#endif - -#ifndef MIN -#define MIN(a, b) ((a) < (b) ? (a) : (b)) -#endif - -void mg_lwip_ssl_do_hs(struct mg_connection *nc) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - int server_side = (nc->listener != NULL); - enum mg_ssl_if_result res; - if (nc->flags & MG_F_CLOSE_IMMEDIATELY) return; - res = mg_ssl_if_handshake(nc); - DBG(("%p %d %d %d", nc, nc->flags, server_side, res)); - if (res != MG_SSL_OK) { - if (res == MG_SSL_WANT_WRITE) { - nc->flags |= MG_F_WANT_WRITE; - cs->err = 0; - } else if (res == MG_SSL_WANT_READ) { - /* - * Nothing to do in particular, we are callback-driven. - * What we definitely do not need anymore is SSL reading (nothing left). - */ - nc->flags &= ~MG_F_WANT_READ; - cs->err = 0; - } else { - cs->err = res; - if (server_side) { - mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc); - } else { - mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc); - } - } - } else { - cs->err = 0; - nc->flags &= ~MG_F_WANT_WRITE; - /* - * Handshake is done. Schedule a read immediately to consume app data - * which may already be waiting. - */ - nc->flags |= (MG_F_SSL_HANDSHAKE_DONE | MG_F_WANT_READ); - if (server_side) { - mg_lwip_accept_conn(nc, cs->pcb.tcp); - } else { - mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc); - } - } -} - -void mg_lwip_ssl_send(struct mg_connection *nc) { - if (nc->sock == INVALID_SOCKET) { - DBG(("%p invalid socket", nc)); - return; - } - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - /* It's ok if the buffer is empty. Return value of 0 may also be valid. */ - int len = cs->last_ssl_write_size; - if (len == 0) { - len = MIN(MG_LWIP_SSL_IO_SIZE, nc->send_mbuf.len); - } - int ret = mg_ssl_if_write(nc, nc->send_mbuf.buf, len); - DBG(("%p SSL_write %u = %d, %d", nc, len, ret)); - if (ret > 0) { - mbuf_remove(&nc->send_mbuf, ret); - mbuf_trim(&nc->send_mbuf); - cs->last_ssl_write_size = 0; - } else if (ret < 0) { - /* This is tricky. We must remember the exact data we were sending to retry - * exactly the same send next time. */ - cs->last_ssl_write_size = len; - } - if (ret == len) { - nc->flags &= ~MG_F_WANT_WRITE; - } else if (ret == MG_SSL_WANT_WRITE) { - nc->flags |= MG_F_WANT_WRITE; - } else { - mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc); - } -} - -void mg_lwip_ssl_recv(struct mg_connection *nc) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - /* Don't deliver data before connect callback */ - if (nc->flags & MG_F_CONNECTING) return; - while (nc->recv_mbuf.len < MG_LWIP_SSL_RECV_MBUF_LIMIT) { - char *buf = (char *) malloc(MG_LWIP_SSL_IO_SIZE); - if (buf == NULL) return; - int ret = mg_ssl_if_read(nc, buf, MG_LWIP_SSL_IO_SIZE); - DBG(("%p %p SSL_read %u = %d", nc, cs->rx_chain, MG_LWIP_SSL_IO_SIZE, ret)); - if (ret <= 0) { - free(buf); - if (ret == MG_SSL_WANT_WRITE) { - nc->flags |= MG_F_WANT_WRITE; - return; - } else if (ret == MG_SSL_WANT_READ) { - /* - * Nothing to do in particular, we are callback-driven. - * What we definitely do not need anymore is SSL reading (nothing left). - */ - nc->flags &= ~MG_F_WANT_READ; - cs->err = 0; - return; - } else { - mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc); - return; - } - } else { - mg_if_recv_tcp_cb(nc, buf, ret, 1 /* own */); - } - } -} - -#ifdef KR_VERSION - -ssize_t kr_send(int fd, const void *buf, size_t len) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) fd; - int ret = mg_lwip_tcp_write(cs->nc, buf, len); - DBG(("%p mg_lwip_tcp_write %u = %d", cs->nc, len, ret)); - if (ret == 0) ret = KR_IO_WOULDBLOCK; - return ret; -} - -ssize_t kr_recv(int fd, void *buf, size_t len) { - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) fd; - struct pbuf *seg = cs->rx_chain; - if (seg == NULL) { - DBG(("%u - nothing to read", len)); - return KR_IO_WOULDBLOCK; - } - size_t seg_len = (seg->len - cs->rx_offset); - DBG(("%u %u %u %u", len, cs->rx_chain->len, seg_len, cs->rx_chain->tot_len)); - len = MIN(len, seg_len); - pbuf_copy_partial(seg, buf, len, cs->rx_offset); - cs->rx_offset += len; - tcp_recved(cs->pcb.tcp, len); - if (cs->rx_offset == cs->rx_chain->len) { - cs->rx_chain = pbuf_dechain(cs->rx_chain); - pbuf_free(seg); - cs->rx_offset = 0; - } - return len; -} - -#elif MG_SSL_IF == MG_SSL_IF_MBEDTLS - -int ssl_socket_send(void *ctx, const unsigned char *buf, size_t len) { - struct mg_connection *nc = (struct mg_connection *) ctx; - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - int ret = mg_lwip_tcp_write(cs->nc, buf, len); - LOG(LL_DEBUG, ("%p %d -> %d", nc, len, ret)); - if (ret == 0) ret = MBEDTLS_ERR_SSL_WANT_WRITE; - return ret; -} - -int ssl_socket_recv(void *ctx, unsigned char *buf, size_t len) { - struct mg_connection *nc = (struct mg_connection *) ctx; - struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock; - struct pbuf *seg = cs->rx_chain; - if (seg == NULL) { - DBG(("%u - nothing to read", len)); - return MBEDTLS_ERR_SSL_WANT_READ; - } - size_t seg_len = (seg->len - cs->rx_offset); - DBG(("%u %u %u %u", len, cs->rx_chain->len, seg_len, cs->rx_chain->tot_len)); - len = MIN(len, seg_len); - pbuf_copy_partial(seg, buf, len, cs->rx_offset); - cs->rx_offset += len; - /* TCP PCB may be NULL if connection has already been closed - * but we still have data to deliver to SSL. */ - if (cs->pcb.tcp != NULL) tcp_recved(cs->pcb.tcp, len); - if (cs->rx_offset == cs->rx_chain->len) { - cs->rx_chain = pbuf_dechain(cs->rx_chain); - pbuf_free(seg); - cs->rx_offset = 0; - } - LOG(LL_DEBUG, ("%p <- %d", nc, (int) len)); - return len; -} - -#endif - -#endif /* MG_ENABLE_SSL && MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/wince/wince_libc.c" -#endif -/* - * Copyright (c) 2016 Cesanta Software Limited - * All rights reserved - */ - -#ifdef WINCE - -const char *strerror(int err) { - /* - * TODO(alashkin): there is no strerror on WinCE; - * look for similar wce_xxxx function - */ - static char buf[10]; - snprintf(buf, sizeof(buf), "%d", err); - return buf; -} - -int open(const char *filename, int oflag, int pmode) { - /* - * TODO(alashkin): mg_open function is not used in mongoose - * but exists in documentation as utility function - * Shall we delete it at all or implement for WinCE as well? - */ - DebugBreak(); - return 0; /* for compiler */ -} - -int _wstati64(const wchar_t *path, cs_stat_t *st) { - DWORD fa = GetFileAttributesW(path); - if (fa == INVALID_FILE_ATTRIBUTES) { - return -1; - } - memset(st, 0, sizeof(*st)); - if ((fa & FILE_ATTRIBUTE_DIRECTORY) == 0) { - HANDLE h; - FILETIME ftime; - st->st_mode |= _S_IFREG; - h = CreateFileW(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, - FILE_ATTRIBUTE_NORMAL, NULL); - if (h == INVALID_HANDLE_VALUE) { - return -1; - } - st->st_size = GetFileSize(h, NULL); - GetFileTime(h, NULL, NULL, &ftime); - st->st_mtime = (uint32_t)((((uint64_t) ftime.dwLowDateTime + - ((uint64_t) ftime.dwHighDateTime << 32)) / - 10000000.0) - - 11644473600); - CloseHandle(h); - } else { - st->st_mode |= _S_IFDIR; - } - return 0; -} - -/* Windows CE doesn't have neither gmtime nor strftime */ -static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t) { - FILETIME ft; - SYSTEMTIME systime; - if (t != NULL) { - uint64_t filetime = (*t + 11644473600) * 10000000; - ft.dwLowDateTime = filetime & 0xFFFFFFFF; - ft.dwHighDateTime = (filetime & 0xFFFFFFFF00000000) >> 32; - FileTimeToSystemTime(&ft, &systime); - } else { - GetSystemTime(&systime); - } - /* There is no PRIu16 in WinCE SDK */ - snprintf(buf, buf_len, "%d.%d.%d %d:%d:%d GMT", (int) systime.wYear, - (int) systime.wMonth, (int) systime.wDay, (int) systime.wHour, - (int) systime.wMinute, (int) systime.wSecond); -} - -#endif -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/pic32/pic32_net_if.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PIC32_NET_IF_H_ -#define CS_COMMON_PLATFORMS_PIC32_NET_IF_H_ - -/* Amalgamated: #include "mongoose/src/net_if.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#ifndef MG_ENABLE_NET_IF_PIC32 -#define MG_ENABLE_NET_IF_PIC32 MG_NET_IF == MG_NET_IF_PIC32 -#endif - -extern struct mg_iface_vtable mg_pic32_iface_vtable; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_PLATFORMS_PIC32_NET_IF_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/pic32/pic32_net_if.c" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#if MG_ENABLE_NET_IF_PIC32 - -int mg_pic32_if_create_conn(struct mg_connection *nc) { - (void) nc; - return 1; -} - -void mg_pic32_if_recved(struct mg_connection *nc, size_t len) { - (void) nc; - (void) len; -} - -void mg_pic32_if_add_conn(struct mg_connection *nc) { - (void) nc; -} - -void mg_pic32_if_init(struct mg_iface *iface) { - (void) iface; - (void) mg_get_errno(); /* Shutup compiler */ -} - -void mg_pic32_if_free(struct mg_iface *iface) { - (void) iface; -} - -void mg_pic32_if_remove_conn(struct mg_connection *nc) { - (void) nc; -} - -void mg_pic32_if_destroy_conn(struct mg_connection *nc) { - if (nc->sock == INVALID_SOCKET) return; - /* For UDP, only close outgoing sockets or listeners. */ - if (!(nc->flags & MG_F_UDP)) { - /* Close TCP */ - TCPIP_TCP_Close((TCP_SOCKET) nc->sock); - } else if (nc->listener == NULL) { - /* Only close outgoing UDP or listeners. */ - TCPIP_UDP_Close((UDP_SOCKET) nc->sock); - } - - nc->sock = INVALID_SOCKET; -} - -int mg_pic32_if_listen_udp(struct mg_connection *nc, union socket_address *sa) { - nc->sock = TCPIP_UDP_ServerOpen( - sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4 - : IP_ADDRESS_TYPE_IPV6, - ntohs(sa->sin.sin_port), - sa->sin.sin_addr.s_addr == 0 ? 0 : (IP_MULTI_ADDRESS *) &sa->sin); - if (nc->sock == INVALID_SOCKET) { - return -1; - } - return 0; -} - -void mg_pic32_if_udp_send(struct mg_connection *nc, const void *buf, - size_t len) { - mbuf_append(&nc->send_mbuf, buf, len); -} - -void mg_pic32_if_tcp_send(struct mg_connection *nc, const void *buf, - size_t len) { - mbuf_append(&nc->send_mbuf, buf, len); -} - -int mg_pic32_if_listen_tcp(struct mg_connection *nc, union socket_address *sa) { - nc->sock = TCPIP_TCP_ServerOpen( - sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4 - : IP_ADDRESS_TYPE_IPV6, - ntohs(sa->sin.sin_port), - sa->sin.sin_addr.s_addr == 0 ? 0 : (IP_MULTI_ADDRESS *) &sa->sin); - memcpy(&nc->sa, sa, sizeof(*sa)); - if (nc->sock == INVALID_SOCKET) { - return -1; - } - return 0; -} - -static int mg_accept_conn(struct mg_connection *lc) { - struct mg_connection *nc; - TCP_SOCKET_INFO si; - union socket_address sa; - - nc = mg_if_accept_new_conn(lc); - - if (nc == NULL) { - return 0; - } - - nc->sock = lc->sock; - nc->flags &= ~MG_F_LISTENING; - - if (!TCPIP_TCP_SocketInfoGet((TCP_SOCKET) nc->sock, &si)) { - return 0; - } - - if (si.addressType == IP_ADDRESS_TYPE_IPV4) { - sa.sin.sin_family = AF_INET; - sa.sin.sin_port = htons(si.remotePort); - sa.sin.sin_addr.s_addr = si.remoteIPaddress.v4Add.Val; - } else { - /* TODO(alashkin): do something with _potential_ IPv6 */ - memset(&sa, 0, sizeof(sa)); - } - - mg_if_accept_tcp_cb(nc, (union socket_address *) &sa, sizeof(sa)); - - return mg_pic32_if_listen_tcp(lc, &lc->sa) >= 0; -} - -char *inet_ntoa(struct in_addr in) { - static char addr[17]; - snprintf(addr, sizeof(addr), "%d.%d.%d.%d", (int) in.S_un.S_un_b.s_b1, - (int) in.S_un.S_un_b.s_b2, (int) in.S_un.S_un_b.s_b3, - (int) in.S_un.S_un_b.s_b4); - return addr; -} - -static void mg_handle_send(struct mg_connection *nc) { - uint16_t bytes_written = 0; - if (nc->flags & MG_F_UDP) { - if (!TCPIP_UDP_RemoteBind( - (UDP_SOCKET) nc->sock, - nc->sa.sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4 - : IP_ADDRESS_TYPE_IPV6, - ntohs(nc->sa.sin.sin_port), (IP_MULTI_ADDRESS *) &nc->sa.sin)) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - return; - } - bytes_written = TCPIP_UDP_TxPutIsReady((UDP_SOCKET) nc->sock, 0); - if (bytes_written >= nc->send_mbuf.len) { - if (TCPIP_UDP_ArrayPut((UDP_SOCKET) nc->sock, - (uint8_t *) nc->send_mbuf.buf, - nc->send_mbuf.len) != nc->send_mbuf.len) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - bytes_written = 0; - } - } - } else { - bytes_written = TCPIP_TCP_FifoTxFreeGet((TCP_SOCKET) nc->sock); - if (bytes_written != 0) { - if (bytes_written > nc->send_mbuf.len) { - bytes_written = nc->send_mbuf.len; - } - if (TCPIP_TCP_ArrayPut((TCP_SOCKET) nc->sock, - (uint8_t *) nc->send_mbuf.buf, - bytes_written) != bytes_written) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - bytes_written = 0; - } - } - } - - if (bytes_written != 0) { - mbuf_remove(&nc->send_mbuf, bytes_written); - mg_if_sent_cb(nc, bytes_written); - } -} - -static void mg_handle_recv(struct mg_connection *nc) { - uint16_t bytes_read = 0; - uint8_t *buf = NULL; - if (nc->flags & MG_F_UDP) { - bytes_read = TCPIP_UDP_GetIsReady((UDP_SOCKET) nc->sock); - if (bytes_read != 0 && - (nc->recv_mbuf_limit == -1 || - nc->recv_mbuf.len + bytes_read < nc->recv_mbuf_limit)) { - buf = (uint8_t *) MG_MALLOC(bytes_read); - if (TCPIP_UDP_ArrayGet((UDP_SOCKET) nc->sock, buf, bytes_read) != - bytes_read) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - bytes_read = 0; - MG_FREE(buf); - } - } - } else { - bytes_read = TCPIP_TCP_GetIsReady((TCP_SOCKET) nc->sock); - if (bytes_read != 0) { - if (nc->recv_mbuf_limit != -1 && - nc->recv_mbuf_limit - nc->recv_mbuf.len > bytes_read) { - bytes_read = nc->recv_mbuf_limit - nc->recv_mbuf.len; - } - buf = (uint8_t *) MG_MALLOC(bytes_read); - if (TCPIP_TCP_ArrayGet((TCP_SOCKET) nc->sock, buf, bytes_read) != - bytes_read) { - nc->flags |= MG_F_CLOSE_IMMEDIATELY; - MG_FREE(buf); - bytes_read = 0; - } - } - } - - if (bytes_read != 0) { - mg_if_recv_tcp_cb(nc, buf, bytes_read, 1 /* own */); - } -} - -time_t mg_pic32_if_poll(struct mg_iface *iface, int timeout_ms) { - struct mg_mgr *mgr = iface->mgr; - double now = mg_time(); - struct mg_connection *nc, *tmp; - - for (nc = mgr->active_connections; nc != NULL; nc = tmp) { - tmp = nc->next; - - if (nc->flags & MG_F_CONNECTING) { - /* processing connections */ - if (nc->flags & MG_F_UDP || - TCPIP_TCP_IsConnected((TCP_SOCKET) nc->sock)) { - mg_if_connect_cb(nc, 0); - } - } else if (nc->flags & MG_F_LISTENING) { - if (TCPIP_TCP_IsConnected((TCP_SOCKET) nc->sock)) { - /* accept new connections */ - mg_accept_conn(nc); - } - } else { - if (nc->send_mbuf.len != 0) { - mg_handle_send(nc); - } - - if (nc->recv_mbuf_limit == -1 || - nc->recv_mbuf.len < nc->recv_mbuf_limit) { - mg_handle_recv(nc); - } - } - } - - for (nc = mgr->active_connections; nc != NULL; nc = tmp) { - tmp = nc->next; - if ((nc->flags & MG_F_CLOSE_IMMEDIATELY) || - (nc->send_mbuf.len == 0 && (nc->flags & MG_F_SEND_AND_CLOSE))) { - mg_close_conn(nc); - } - } - - return now; -} - -void mg_pic32_if_sock_set(struct mg_connection *nc, sock_t sock) { - nc->sock = sock; -} - -void mg_pic32_if_get_conn_addr(struct mg_connection *nc, int remote, - union socket_address *sa) { - /* TODO(alaskin): not implemented yet */ -} - -void mg_pic32_if_connect_tcp(struct mg_connection *nc, - const union socket_address *sa) { - nc->sock = TCPIP_TCP_ClientOpen( - sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4 - : IP_ADDRESS_TYPE_IPV6, - ntohs(sa->sin.sin_port), (IP_MULTI_ADDRESS *) &sa->sin); - nc->err = (nc->sock == INVALID_SOCKET) ? -1 : 0; -} - -void mg_pic32_if_connect_udp(struct mg_connection *nc) { - nc->sock = TCPIP_UDP_ClientOpen(IP_ADDRESS_TYPE_ANY, 0, NULL); - nc->err = (nc->sock == INVALID_SOCKET) ? -1 : 0; -} - -/* clang-format off */ -#define MG_PIC32_IFACE_VTABLE \ - { \ - mg_pic32_if_init, \ - mg_pic32_if_free, \ - mg_pic32_if_add_conn, \ - mg_pic32_if_remove_conn, \ - mg_pic32_if_poll, \ - mg_pic32_if_listen_tcp, \ - mg_pic32_if_listen_udp, \ - mg_pic32_if_connect_tcp, \ - mg_pic32_if_connect_udp, \ - mg_pic32_if_tcp_send, \ - mg_pic32_if_udp_send, \ - mg_pic32_if_recved, \ - mg_pic32_if_create_conn, \ - mg_pic32_if_destroy_conn, \ - mg_pic32_if_sock_set, \ - mg_pic32_if_get_conn_addr, \ - } -/* clang-format on */ - -struct mg_iface_vtable mg_pic32_iface_vtable = MG_PIC32_IFACE_VTABLE; -#if MG_NET_IF == MG_NET_IF_PIC32 -struct mg_iface_vtable mg_default_iface_vtable = MG_PIC32_IFACE_VTABLE; -#endif - -#endif /* MG_ENABLE_NET_IF_PIC32 */ diff --git a/components/oap-wifi/mongoose.h b/components/oap-wifi/mongoose.h deleted file mode 100644 index 9c05d29..0000000 --- a/components/oap-wifi/mongoose.h +++ /dev/null @@ -1,5814 +0,0 @@ -//#define MG_ENABLE_DEBUG 1 - -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/common.h" -#endif -/* - * Copyright (c) 2004-2013 Sergey Lyubka - * Copyright (c) 2013-2015 Cesanta Software Limited - * All rights reserved - * - * This software is dual-licensed: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. For the terms of this - * license, see . - * - * You are free to use this software under the terms of the GNU General - * Public License, but WITHOUT ANY WARRANTY; without even the implied - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * Alternatively, you can license this software under a commercial - * license, as set out in . - */ - -#ifndef CS_MONGOOSE_SRC_COMMON_H_ -#define CS_MONGOOSE_SRC_COMMON_H_ - -#define MG_VERSION "6.7" - -/* Local tweaks, applied before any of Mongoose's own headers. */ -#ifdef MG_LOCALS -#include -#endif - -#endif /* CS_MONGOOSE_SRC_COMMON_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platform.h" -#endif -#ifndef CS_COMMON_PLATFORM_H_ -#define CS_COMMON_PLATFORM_H_ - -/* - * For the "custom" platform, includes and dependencies can be - * provided through mg_locals.h. - */ -#define CS_P_CUSTOM 0 -#define CS_P_UNIX 1 -#define CS_P_WINDOWS 2 -#define CS_P_ESP32 15 -#define CS_P_ESP8266 3 -#define CS_P_CC3200 4 -#define CS_P_MSP432 5 -#define CS_P_CC3100 6 -#define CS_P_TM4C129 14 -#define CS_P_MBED 7 -#define CS_P_WINCE 8 -#define CS_P_NXP_LPC 13 -#define CS_P_NXP_KINETIS 9 -#define CS_P_NRF51 12 -#define CS_P_NRF52 10 -#define CS_P_PIC32 11 -#define CS_P_STM32 16 -/* Next id: 17 */ - -/* If not specified explicitly, we guess platform by defines. */ -#ifndef CS_PLATFORM - -#if defined(TARGET_IS_MSP432P4XX) || defined(__MSP432P401R__) -#define CS_PLATFORM CS_P_MSP432 -#elif defined(cc3200) -#define CS_PLATFORM CS_P_CC3200 -#elif defined(__unix__) || defined(__APPLE__) -#define CS_PLATFORM CS_P_UNIX -#elif defined(WINCE) -#define CS_PLATFORM CS_P_WINCE -#elif defined(_WIN32) -#define CS_PLATFORM CS_P_WINDOWS -#elif defined(__MBED__) -#define CS_PLATFORM CS_P_MBED -#elif defined(__USE_LPCOPEN) -#define CS_PLATFORM CS_P_NXP_LPC -#elif defined(FRDM_K64F) || defined(FREEDOM) -#define CS_PLATFORM CS_P_NXP_KINETIS -#elif defined(PIC32) -#define CS_PLATFORM CS_P_PIC32 -#elif defined(ESP_PLATFORM) -#define CS_PLATFORM CS_P_ESP32 -#elif defined(ICACHE_FLASH) -#define CS_PLATFORM CS_P_ESP8266 -#elif defined(TARGET_IS_TM4C129_RA0) || defined(TARGET_IS_TM4C129_RA1) || \ - defined(TARGET_IS_TM4C129_RA2) -#define CS_PLATFORM CS_P_TM4C129 -#elif defined(STM32) -#define CS_PLATFORM CS_P_STM32 -#endif - -#ifndef CS_PLATFORM -#error "CS_PLATFORM is not specified and we couldn't guess it." -#endif - -#endif /* !defined(CS_PLATFORM) */ - -#define MG_NET_IF_SOCKET 1 -#define MG_NET_IF_SIMPLELINK 2 -#define MG_NET_IF_LWIP_LOW_LEVEL 3 -#define MG_NET_IF_PIC32 4 - -#define MG_SSL_IF_OPENSSL 1 -#define MG_SSL_IF_MBEDTLS 2 -#define MG_SSL_IF_SIMPLELINK 3 - -/* Amalgamated: #include "common/platforms/platform_unix.h" */ -/* Amalgamated: #include "common/platforms/platform_windows.h" */ -/* Amalgamated: #include "common/platforms/platform_esp32.h" */ -/* Amalgamated: #include "common/platforms/platform_esp8266.h" */ -/* Amalgamated: #include "common/platforms/platform_cc3200.h" */ -/* Amalgamated: #include "common/platforms/platform_cc3100.h" */ -/* Amalgamated: #include "common/platforms/platform_mbed.h" */ -/* Amalgamated: #include "common/platforms/platform_nrf51.h" */ -/* Amalgamated: #include "common/platforms/platform_nrf52.h" */ -/* Amalgamated: #include "common/platforms/platform_wince.h" */ -/* Amalgamated: #include "common/platforms/platform_nxp_lpc.h" */ -/* Amalgamated: #include "common/platforms/platform_nxp_kinetis.h" */ -/* Amalgamated: #include "common/platforms/platform_pic32.h" */ -/* Amalgamated: #include "common/platforms/platform_stm32.h" */ - -/* Common stuff */ - -#if !defined(WEAK) -#if (defined(__GNUC__) || defined(__TI_COMPILER_VERSION__)) && !defined(_WIN32) -#define WEAK __attribute__((weak)) -#else -#define WEAK -#endif -#endif - -#ifdef __GNUC__ -#define NORETURN __attribute__((noreturn)) -#define NOINLINE __attribute__((noinline)) -#define WARN_UNUSED_RESULT __attribute__((warn_unused_result)) -#define NOINSTR __attribute__((no_instrument_function)) -#define DO_NOT_WARN_UNUSED __attribute__((unused)) -#else -#define NORETURN -#define NOINLINE -#define WARN_UNUSED_RESULT -#define NOINSTR -#define DO_NOT_WARN_UNUSED -#endif /* __GNUC__ */ - -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0])) -#endif - -#endif /* CS_COMMON_PLATFORM_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_windows.h" -#endif -#ifndef CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_ -#if CS_PLATFORM == CS_P_WINDOWS - -/* - * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) - * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013) - * MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012) - * MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010) - * MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008) - * MSVC++ 8.0 _MSC_VER == 1400 (Visual Studio 2005) - * MSVC++ 7.1 _MSC_VER == 1310 (Visual Studio 2003) - * MSVC++ 7.0 _MSC_VER == 1300 - * MSVC++ 6.0 _MSC_VER == 1200 - * MSVC++ 5.0 _MSC_VER == 1100 - */ -#ifdef _MSC_VER -#pragma warning(disable : 4127) /* FD_SET() emits warning, disable it */ -#pragma warning(disable : 4204) /* missing c99 support */ -#endif - -#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS -#define _WINSOCK_DEPRECATED_NO_WARNINGS 1 -#endif - -#ifndef _CRT_SECURE_NO_WARNINGS -#define _CRT_SECURE_NO_WARNINGS -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef _MSC_VER -#pragma comment(lib, "ws2_32.lib") /* Linking with winsock library */ -#endif - -#include -#include -#include -#include - -#if defined(_MSC_VER) && _MSC_VER >= 1800 -#define strdup _strdup -#endif - -#ifndef EINPROGRESS -#define EINPROGRESS WSAEINPROGRESS -#endif -#ifndef EWOULDBLOCK -#define EWOULDBLOCK WSAEWOULDBLOCK -#endif -#ifndef __func__ -#define STRX(x) #x -#define STR(x) STRX(x) -#define __func__ __FILE__ ":" STR(__LINE__) -#endif -#define snprintf _snprintf -#define fileno _fileno -#define vsnprintf _vsnprintf -#define sleep(x) Sleep((x) *1000) -#define to64(x) _atoi64(x) -#if !defined(__MINGW32__) && !defined(__MINGW64__) -#define popen(x, y) _popen((x), (y)) -#define pclose(x) _pclose(x) -#endif -#define rmdir _rmdir -#if defined(_MSC_VER) && _MSC_VER >= 1400 -#define fseeko(x, y, z) _fseeki64((x), (y), (z)) -#else -#define fseeko(x, y, z) fseek((x), (y), (z)) -#endif -#if defined(_MSC_VER) && _MSC_VER <= 1200 -typedef unsigned long uintptr_t; -typedef long intptr_t; -#endif -typedef int socklen_t; -#if _MSC_VER >= 1700 -#include -#else -typedef signed char int8_t; -typedef unsigned char uint8_t; -typedef int int32_t; -typedef unsigned int uint32_t; -typedef short int16_t; -typedef unsigned short uint16_t; -typedef __int64 int64_t; -typedef unsigned __int64 uint64_t; -#endif -typedef SOCKET sock_t; -typedef uint32_t in_addr_t; -#ifndef UINT16_MAX -#define UINT16_MAX 65535 -#endif -#ifndef UINT32_MAX -#define UINT32_MAX 4294967295 -#endif -#ifndef pid_t -#define pid_t HANDLE -#endif -#define INT64_FMT "I64d" -#define INT64_X_FMT "I64x" -#define SIZE_T_FMT "Iu" -typedef struct _stati64 cs_stat_t; -#ifndef S_ISDIR -#define S_ISDIR(x) (((x) &_S_IFMT) == _S_IFDIR) -#endif -#ifndef S_ISREG -#define S_ISREG(x) (((x) &_S_IFMT) == _S_IFREG) -#endif -#define DIRSEP '\\' -#define CS_DEFINE_DIRENT - -#ifndef va_copy -#ifdef __va_copy -#define va_copy __va_copy -#else -#define va_copy(x, y) (x) = (y) -#endif -#endif - -#ifndef MG_MAX_HTTP_REQUEST_SIZE -#define MG_MAX_HTTP_REQUEST_SIZE 8192 -#endif - -#ifndef MG_MAX_HTTP_SEND_MBUF -#define MG_MAX_HTTP_SEND_MBUF 4096 -#endif - -#ifndef MG_MAX_HTTP_HEADERS -#define MG_MAX_HTTP_HEADERS 40 -#endif - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#ifndef MG_ENABLE_BROADCAST -#define MG_ENABLE_BROADCAST 1 -#endif - -#ifndef MG_ENABLE_DIRECTORY_LISTING -#define MG_ENABLE_DIRECTORY_LISTING 1 -#endif - -#ifndef MG_ENABLE_FILESYSTEM -#define MG_ENABLE_FILESYSTEM 1 -#endif - -#ifndef MG_ENABLE_HTTP_CGI -#define MG_ENABLE_HTTP_CGI MG_ENABLE_FILESYSTEM -#endif - -#ifndef MG_NET_IF -#define MG_NET_IF MG_NET_IF_SOCKET -#endif - -#endif /* CS_PLATFORM == CS_P_WINDOWS */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_unix.h" -#endif -#ifndef CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_ -#if CS_PLATFORM == CS_P_UNIX - -#ifndef _XOPEN_SOURCE -#define _XOPEN_SOURCE 600 -#endif - -/* wants this for C++ */ -#ifndef __STDC_FORMAT_MACROS -#define __STDC_FORMAT_MACROS -#endif - -/* C++ wants that for INT64_MAX */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS -#endif - -/* Enable fseeko() and ftello() functions */ -#ifndef _LARGEFILE_SOURCE -#define _LARGEFILE_SOURCE -#endif - -/* Enable 64-bit file offsets */ -#ifndef _FILE_OFFSET_BITS -#define _FILE_OFFSET_BITS 64 -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef __APPLE__ -#include -#ifndef BYTE_ORDER -#define LITTLE_ENDIAN __DARWIN_LITTLE_ENDIAN -#define BIG_ENDIAN __DARWIN_BIG_ENDIAN -#define PDP_ENDIAN __DARWIN_PDP_ENDIAN -#define BYTE_ORDER __DARWIN_BYTE_ORDER -#endif -#endif - -/* - * osx correctly avoids defining strtoll when compiling in strict ansi mode. - * c++ 11 standard defines strtoll as well. - * We require strtoll, and if your embedded pre-c99 compiler lacks one, please - * implement a shim. - */ -#if !(defined(__cplusplus) && __cplusplus >= 201103L) && \ - !(defined(__DARWIN_C_LEVEL) && __DARWIN_C_LEVEL >= 200809L) -long long strtoll(const char *, char **, int); -#endif - -typedef int sock_t; -#define INVALID_SOCKET (-1) -#define SIZE_T_FMT "zu" -typedef struct stat cs_stat_t; -#define DIRSEP '/' -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 - -#ifndef __cdecl -#define __cdecl -#endif - -#ifndef va_copy -#ifdef __va_copy -#define va_copy __va_copy -#else -#define va_copy(x, y) (x) = (y) -#endif -#endif - -#define closesocket(x) close(x) - -#ifndef MG_MAX_HTTP_REQUEST_SIZE -#define MG_MAX_HTTP_REQUEST_SIZE 8192 -#endif - -#ifndef MG_MAX_HTTP_SEND_MBUF -#define MG_MAX_HTTP_SEND_MBUF 4096 -#endif - -#ifndef MG_MAX_HTTP_HEADERS -#define MG_MAX_HTTP_HEADERS 40 -#endif - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#ifndef MG_ENABLE_BROADCAST -#define MG_ENABLE_BROADCAST 1 -#endif - -#ifndef MG_ENABLE_DIRECTORY_LISTING -#define MG_ENABLE_DIRECTORY_LISTING 1 -#endif - -#ifndef MG_ENABLE_FILESYSTEM -#define MG_ENABLE_FILESYSTEM 1 -#endif - -#ifndef MG_ENABLE_HTTP_CGI -#define MG_ENABLE_HTTP_CGI MG_ENABLE_FILESYSTEM -#endif - -#ifndef MG_NET_IF -#define MG_NET_IF MG_NET_IF_SOCKET -#endif - -#endif /* CS_PLATFORM == CS_P_UNIX */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_esp32.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_ -#if CS_PLATFORM == CS_P_ESP32 - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define DIRSEP '/' -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 -#define __cdecl -#define _FILE_OFFSET_BITS 32 - -#define MG_LWIP 1 - -#ifndef MG_NET_IF -#define MG_NET_IF MG_NET_IF_SOCKET -#endif - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#endif /* CS_PLATFORM == CS_P_ESP32 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_esp8266.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_ -#if CS_PLATFORM == CS_P_ESP8266 - -#include -#include -#include -#include -#include -#include -#include -#include - -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define DIRSEP '/' -#define CS_DEFINE_DIRENT - -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 -#define __cdecl -#define _FILE_OFFSET_BITS 32 - -#ifndef RTOS_SDK -#define fileno(x) -1 -#endif - -#define MG_LWIP 1 - -/* struct timeval is defined in sys/time.h. */ -#define LWIP_TIMEVAL_PRIVATE 0 - -#ifndef MG_NET_IF -#include -#if LWIP_SOCKET /* RTOS SDK has LWIP sockets */ -# define MG_NET_IF MG_NET_IF_SOCKET -#else -# define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL -#endif -#endif - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#endif /* CS_PLATFORM == CS_P_ESP8266 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_cc3100.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_ -#if CS_PLATFORM == CS_P_CC3100 - -#include -#include -#include -#include -#include -#include -#include - -#define MG_NET_IF MG_NET_IF_SIMPLELINK -#define MG_SSL_IF MG_SSL_IF_SIMPLELINK - -/* - * CC3100 SDK and STM32 SDK include headers w/out path, just like - * #include "simplelink.h". As result, we have to add all required directories - * into Makefile IPATH and do the same thing (include w/out path) - */ - -#include -#include -#undef timeval - -typedef int sock_t; -#define INVALID_SOCKET (-1) - -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 -#define SIZE_T_FMT "u" - -#define SOMAXCONN 8 - -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); -char *inet_ntoa(struct in_addr in); -int inet_pton(int af, const char *src, void *dst); - -#endif /* CS_PLATFORM == CS_P_CC3100 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_cc3200.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_ -#if CS_PLATFORM == CS_P_CC3200 - -#include -#include -#include -#include -#include -#include -#include - -#ifndef __TI_COMPILER_VERSION__ -#include -#include -#endif - -#define MG_NET_IF MG_NET_IF_SIMPLELINK -#define MG_SSL_IF MG_SSL_IF_SIMPLELINK - -/* Only SPIFFS supports directories, SLFS does not. */ -#if defined(CC3200_FS_SPIFFS) && !defined(MG_ENABLE_DIRECTORY_LISTING) -#define MG_ENABLE_DIRECTORY_LISTING 1 -#endif - -/* Amalgamated: #include "common/platforms/simplelink/cs_simplelink.h" */ - -typedef int sock_t; -#define INVALID_SOCKET (-1) -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define DIRSEP '/' -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 -#define __cdecl - -#define fileno(x) -1 - -/* Some functions we implement for Mongoose. */ - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __TI_COMPILER_VERSION__ -struct SlTimeval_t; -#define timeval SlTimeval_t -int gettimeofday(struct timeval *t, void *tz); - -int asprintf(char **strp, const char *fmt, ...); - -#endif - -/* TI's libc does not have stat & friends, add them. */ -#ifdef __TI_COMPILER_VERSION__ - -#include - -typedef unsigned int mode_t; -typedef size_t _off_t; -typedef long ssize_t; - -struct stat { - int st_ino; - mode_t st_mode; - int st_nlink; - time_t st_mtime; - off_t st_size; -}; - -int _stat(const char *pathname, struct stat *st); -#define stat(a, b) _stat(a, b) - -#define __S_IFMT 0170000 - -#define __S_IFDIR 0040000 -#define __S_IFCHR 0020000 -#define __S_IFREG 0100000 - -#define __S_ISTYPE(mode, mask) (((mode) &__S_IFMT) == (mask)) - -#define S_IFDIR __S_IFDIR -#define S_IFCHR __S_IFCHR -#define S_IFREG __S_IFREG -#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR) -#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG) - -/* As of 5.2.7, TI compiler does not support va_copy() yet. */ -#define va_copy(apc, ap) ((apc) = (ap)) - -#endif /* __TI_COMPILER_VERSION__ */ - -#ifdef CC3200_FS_SLFS -#define MG_FS_SLFS -#endif - -#if (defined(CC3200_FS_SPIFFS) || defined(CC3200_FS_SLFS)) && \ - !defined(MG_ENABLE_FILESYSTEM) -#define MG_ENABLE_FILESYSTEM 1 -#define CS_DEFINE_DIRENT -#endif - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* CS_PLATFORM == CS_P_CC3200 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_msp432.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_ -#if CS_PLATFORM == CS_P_MSP432 - -#include -#include -#include -#include -#include -#include -#include - -#ifndef __TI_COMPILER_VERSION__ -#include -#include -#endif - -#define MG_NET_IF MG_NET_IF_SIMPLELINK -#define MG_SSL_IF MG_SSL_IF_SIMPLELINK - -/* Amalgamated: #include "common/platforms/simplelink/cs_simplelink.h" */ - -typedef int sock_t; -#define INVALID_SOCKET (-1) -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define DIRSEP '/' -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 -#define __cdecl - -#define fileno(x) -1 - -/* Some functions we implement for Mongoose. */ - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __TI_COMPILER_VERSION__ -struct SlTimeval_t; -#define timeval SlTimeval_t -int gettimeofday(struct timeval *t, void *tz); -#endif - -/* TI's libc does not have stat & friends, add them. */ -#ifdef __TI_COMPILER_VERSION__ - -#include - -typedef unsigned int mode_t; -typedef size_t _off_t; -typedef long ssize_t; - -struct stat { - int st_ino; - mode_t st_mode; - int st_nlink; - time_t st_mtime; - off_t st_size; -}; - -int _stat(const char *pathname, struct stat *st); -#define stat(a, b) _stat(a, b) - -#define __S_IFMT 0170000 - -#define __S_IFDIR 0040000 -#define __S_IFCHR 0020000 -#define __S_IFREG 0100000 - -#define __S_ISTYPE(mode, mask) (((mode) &__S_IFMT) == (mask)) - -#define S_IFDIR __S_IFDIR -#define S_IFCHR __S_IFCHR -#define S_IFREG __S_IFREG -#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR) -#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG) - -/* As of 5.2.7, TI compiler does not support va_copy() yet. */ -#define va_copy(apc, ap) ((apc) = (ap)) - -#endif /* __TI_COMPILER_VERSION__ */ - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#if (defined(CC3200_FS_SPIFFS) || defined(CC3200_FS_SLFS)) && !defined(MG_ENABLE_FILESYSTEM) -#define MG_ENABLE_FILESYSTEM 1 -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* CS_PLATFORM == CS_P_MSP432 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_tm4c129.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_ -#if CS_PLATFORM == CS_P_TM4C129 - -#include -#include -#include -#include -#include -#include -#include - -#ifndef __TI_COMPILER_VERSION__ -#include -#include -#endif - -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define DIRSEP '/' -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 -#define __cdecl - -#ifndef MG_NET_IF -# include -# if LWIP_SOCKET -# define MG_NET_IF MG_NET_IF_SOCKET -# else -# define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL -# endif -# define MG_LWIP 1 -#elif MG_NET_IF == MG_NET_IF_SIMPLELINK -# include "common/platforms/simplelink/cs_simplelink.h" -#endif - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#ifdef __TI_COMPILER_VERSION__ -/* As of 5.2.8, TI compiler does not support va_copy() yet. */ -#define va_copy(apc, ap) ((apc) = (ap)) -#endif /* __TI_COMPILER_VERSION__ */ - -#ifdef __cplusplus -} -#endif - -#endif /* CS_PLATFORM == CS_P_TM4C129 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_mbed.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_MBED_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_MBED_H_ -#if CS_PLATFORM == CS_P_MBED - -/* - * mbed.h contains C++ code (e.g. templates), thus, it should be processed - * only if included directly to startup file (ex: main.cpp) - */ -#ifdef __cplusplus -/* Amalgamated: #include "mbed.h" */ -#endif /* __cplusplus */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -typedef struct stat cs_stat_t; -#define DIRSEP '/' - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -/* - * mbed can be compiled with the ARM compiler which - * just doesn't come with a gettimeofday shim - * because it's a BSD API and ARM targets embedded - * non-unix platforms. - */ -#if defined(__ARMCC_VERSION) || defined(__ICCARM__) -#define _TIMEVAL_DEFINED -#define gettimeofday _gettimeofday - -/* copied from GCC on ARM; for some reason useconds are signed */ -typedef long suseconds_t; /* microseconds (signed) */ -struct timeval { - time_t tv_sec; /* seconds */ - suseconds_t tv_usec; /* and microseconds */ -}; - -#endif - -#if MG_NET_IF == MG_NET_IF_SIMPLELINK - -#define MG_SIMPLELINK_NO_OSI 1 - -#include - -typedef int sock_t; -#define INVALID_SOCKET (-1) - -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define INT64_X_FMT PRIx64 -#define SIZE_T_FMT "u" - -#define SOMAXCONN 8 - -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); -char *inet_ntoa(struct in_addr in); -int inet_pton(int af, const char *src, void *dst); -int inet_aton(const char *cp, struct in_addr *inp); -in_addr_t inet_addr(const char *cp); - -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK */ - -#endif /* CS_PLATFORM == CS_P_MBED */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_MBED_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_nrf51.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_ -#if CS_PLATFORM == CS_P_NRF51 - -#include -#include -#include -#include -#include -#include - -#define to64(x) strtoll(x, NULL, 10) - -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL -#define MG_LWIP 1 -#define MG_ENABLE_IPV6 1 - -/* - * For ARM C Compiler, make lwip to export `struct timeval`; for other - * compilers, suppress it. - */ -#if !defined(__ARMCC_VERSION) -# define LWIP_TIMEVAL_PRIVATE 0 -#else -struct timeval; -int gettimeofday(struct timeval *tp, void *tzp); -#endif - -#define INT64_FMT PRId64 -#define SIZE_T_FMT "u" - -/* - * ARM C Compiler doesn't have strdup, so we provide it - */ -#define CS_ENABLE_STRDUP defined(__ARMCC_VERSION) - -#endif /* CS_PLATFORM == CS_P_NRF51 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_nrf52.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_ -#if CS_PLATFORM == CS_P_NRF52 - -#include -#include -#include -#include -#include -#include -#include - -#define to64(x) strtoll(x, NULL, 10) - -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL -#define MG_LWIP 1 -#define MG_ENABLE_IPV6 1 - -#if !defined(ENOSPC) -# define ENOSPC 28 /* No space left on device */ -#endif - -/* - * For ARM C Compiler, make lwip to export `struct timeval`; for other - * compilers, suppress it. - */ -#if !defined(__ARMCC_VERSION) -# define LWIP_TIMEVAL_PRIVATE 0 -#endif - -#define INT64_FMT PRId64 -#define SIZE_T_FMT "u" - -/* - * ARM C Compiler doesn't have strdup, so we provide it - */ -#define CS_ENABLE_STRDUP defined(__ARMCC_VERSION) - -#endif /* CS_PLATFORM == CS_P_NRF52 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/simplelink/cs_simplelink.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_ -#define CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_ - -/* If simplelink.h is already included, all bets are off. */ -#if defined(MG_NET_IF) && MG_NET_IF == MG_NET_IF_SIMPLELINK && \ - !defined(__SIMPLELINK_H__) - -#include - -#ifndef __TI_COMPILER_VERSION__ -#undef __CONCAT -#undef FD_CLR -#undef FD_ISSET -#undef FD_SET -#undef FD_SETSIZE -#undef FD_ZERO -#undef fd_set -#endif - -/* We want to disable SL_INC_STD_BSD_API_NAMING, so we include user.h ourselves - * and undef it. */ -#define PROVISIONING_API_H_ -#include -#undef PROVISIONING_API_H_ -#undef SL_INC_STD_BSD_API_NAMING - -#include -#include - -/* Now define only the subset of the BSD API that we use. - * Notably, close(), read() and write() are not defined. */ -#define AF_INET SL_AF_INET - -#define socklen_t SlSocklen_t -#define sockaddr SlSockAddr_t -#define sockaddr_in SlSockAddrIn_t -#define in_addr SlInAddr_t - -#define SOCK_STREAM SL_SOCK_STREAM -#define SOCK_DGRAM SL_SOCK_DGRAM - -#define htonl sl_Htonl -#define ntohl sl_Ntohl -#define htons sl_Htons -#define ntohs sl_Ntohs - -#ifndef EACCES -#define EACCES SL_EACCES -#endif -#ifndef EAFNOSUPPORT -#define EAFNOSUPPORT SL_EAFNOSUPPORT -#endif -#ifndef EAGAIN -#define EAGAIN SL_EAGAIN -#endif -#ifndef EBADF -#define EBADF SL_EBADF -#endif -#ifndef EINVAL -#define EINVAL SL_EINVAL -#endif -#ifndef ENOMEM -#define ENOMEM SL_ENOMEM -#endif -#ifndef EWOULDBLOCK -#define EWOULDBLOCK SL_EWOULDBLOCK -#endif - -#define SOMAXCONN 8 - -#ifdef __cplusplus -extern "C" { -#endif - -const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); -char *inet_ntoa(struct in_addr in); -int inet_pton(int af, const char *src, void *dst); - -struct mg_mgr; -struct mg_connection; - -typedef void (*mg_init_cb)(struct mg_mgr *mgr); -bool mg_start_task(int priority, int stack_size, mg_init_cb mg_init); - -void mg_run_in_task(void (*cb)(struct mg_mgr *mgr, void *arg), void *cb_arg); - -int sl_fs_init(void); - -void sl_restart_cb(struct mg_mgr *mgr); - -int sl_set_ssl_opts(struct mg_connection *nc); - -#ifdef __cplusplus -} -#endif - -#endif /* MG_NET_IF == MG_NET_IF_SIMPLELINK && !defined(__SIMPLELINK_H__) */ - -#endif /* CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_wince.h" -#endif -#ifndef CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_ - -#if CS_PLATFORM == CS_P_WINCE - -/* - * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) - * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013) - * MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012) - * MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010) - * MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008) - * MSVC++ 8.0 _MSC_VER == 1400 (Visual Studio 2005) - * MSVC++ 7.1 _MSC_VER == 1310 (Visual Studio 2003) - * MSVC++ 7.0 _MSC_VER == 1300 - * MSVC++ 6.0 _MSC_VER == 1200 - * MSVC++ 5.0 _MSC_VER == 1100 - */ -#pragma warning(disable : 4127) /* FD_SET() emits warning, disable it */ -#pragma warning(disable : 4204) /* missing c99 support */ - -#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS -#define _WINSOCK_DEPRECATED_NO_WARNINGS 1 -#endif - -#ifndef _CRT_SECURE_NO_WARNINGS -#define _CRT_SECURE_NO_WARNINGS -#endif - -#include -#include -#include -#include -#include -#include - -#pragma comment(lib, "ws2.lib") /* Linking with WinCE winsock library */ - -#include -#include -#include - -#define strdup _strdup - -#ifndef EINPROGRESS -#define EINPROGRESS WSAEINPROGRESS -#endif - -#ifndef EWOULDBLOCK -#define EWOULDBLOCK WSAEWOULDBLOCK -#endif - -#ifndef __func__ -#define STRX(x) #x -#define STR(x) STRX(x) -#define __func__ __FILE__ ":" STR(__LINE__) -#endif - -#define snprintf _snprintf -#define fileno _fileno -#define vsnprintf _vsnprintf -#define sleep(x) Sleep((x) *1000) -#define to64(x) _atoi64(x) -#define rmdir _rmdir - -#if defined(_MSC_VER) && _MSC_VER >= 1400 -#define fseeko(x, y, z) _fseeki64((x), (y), (z)) -#else -#define fseeko(x, y, z) fseek((x), (y), (z)) -#endif - -typedef int socklen_t; - -#if _MSC_VER >= 1700 -#include -#else -typedef signed char int8_t; -typedef unsigned char uint8_t; -typedef int int32_t; -typedef unsigned int uint32_t; -typedef short int16_t; -typedef unsigned short uint16_t; -typedef __int64 int64_t; -typedef unsigned __int64 uint64_t; -#endif - -typedef SOCKET sock_t; -typedef uint32_t in_addr_t; - -#ifndef UINT16_MAX -#define UINT16_MAX 65535 -#endif - -#ifndef UINT32_MAX -#define UINT32_MAX 4294967295 -#endif - -#ifndef pid_t -#define pid_t HANDLE -#endif - -#define INT64_FMT "I64d" -#define INT64_X_FMT "I64x" -/* TODO(alashkin): check if this is correct */ -#define SIZE_T_FMT "u" - -#define DIRSEP '\\' -#define CS_DEFINE_DIRENT - -#ifndef va_copy -#ifdef __va_copy -#define va_copy __va_copy -#else -#define va_copy(x, y) (x) = (y) -#endif -#endif - -#ifndef MG_MAX_HTTP_REQUEST_SIZE -#define MG_MAX_HTTP_REQUEST_SIZE 8192 -#endif - -#ifndef MG_MAX_HTTP_SEND_MBUF -#define MG_MAX_HTTP_SEND_MBUF 4096 -#endif - -#ifndef MG_MAX_HTTP_HEADERS -#define MG_MAX_HTTP_HEADERS 40 -#endif - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#define abort() DebugBreak(); - -#ifndef BUFSIZ -#define BUFSIZ 4096 -#endif -/* - * Explicitly disabling MG_ENABLE_THREADS for WinCE - * because they are enabled for _WIN32 by default - */ -#ifndef MG_ENABLE_THREADS -#define MG_ENABLE_THREADS 0 -#endif - -#ifndef MG_ENABLE_FILESYSTEM -#define MG_ENABLE_FILESYSTEM 1 -#endif - -#ifndef MG_NET_IF -#define MG_NET_IF MG_NET_IF_SOCKET -#endif - -typedef struct _stati64 { - uint32_t st_mtime; - uint32_t st_size; - uint32_t st_mode; -} cs_stat_t; - -/* - * WinCE 6.0 has a lot of useful definitions in ATL (not windows.h) headers - * use #ifdefs to avoid conflicts - */ - -#ifndef ENOENT -#define ENOENT ERROR_PATH_NOT_FOUND -#endif - -#ifndef EACCES -#define EACCES ERROR_ACCESS_DENIED -#endif - -#ifndef ENOMEM -#define ENOMEM ERROR_NOT_ENOUGH_MEMORY -#endif - -#ifndef _UINTPTR_T_DEFINED -typedef unsigned int* uintptr_t; -#endif - -#define _S_IFREG 2 -#define _S_IFDIR 4 - -#ifndef S_ISDIR -#define S_ISDIR(x) (((x) & _S_IFDIR) != 0) -#endif - -#ifndef S_ISREG -#define S_ISREG(x) (((x) & _S_IFREG) != 0) -#endif - -int open(const char *filename, int oflag, int pmode); -int _wstati64(const wchar_t *path, cs_stat_t *st); -const char *strerror(); - -#endif /* CS_PLATFORM == CS_P_WINCE */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_nxp_lpc.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_ - -#if CS_PLATFORM == CS_P_NXP_LPC - -#include -#include -#include - -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define INT64_FMT "lld" -#define INT64_X_FMT "llx" -#define __cdecl - -#define MG_LWIP 1 - -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL - -/* - * LPCXpress comes with 3 C library implementations: Newlib, NewlibNano and Redlib. - * See https://community.nxp.com/message/630860 for more details. - * - * Redlib is the default and lacks certain things, so we provide them. - */ -#ifdef __REDLIB_INTERFACE_VERSION__ - -/* Let LWIP define timeval for us. */ -#define LWIP_TIMEVAL_PRIVATE 1 - -#define va_copy(d, s) __builtin_va_copy(d, s) - -#define CS_ENABLE_TO64 1 -#define to64(x) cs_to64(x) - -#define CS_ENABLE_STRDUP 1 - -#else - -#include -#define LWIP_TIMEVAL_PRIVATE 0 -#define to64(x) strtoll(x, NULL, 10) - -#endif - -#endif /* CS_PLATFORM == CS_P_NXP_LPC */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_nxp_kinetis.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_ - -#if CS_PLATFORM == CS_P_NXP_KINETIS - -#include -#include -#include -#include - -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT "lld" -#define INT64_X_FMT "llx" -#define __cdecl - -#define MG_LWIP 1 - -#define MG_NET_IF MG_NET_IF_LWIP_LOW_LEVEL - -/* struct timeval is defined in sys/time.h. */ -#define LWIP_TIMEVAL_PRIVATE 0 - -#endif /* CS_PLATFORM == CS_P_NXP_KINETIS */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_pic32.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_ - -#if CS_PLATFORM == CS_P_PIC32 - -#define MG_NET_IF MG_NET_IF_PIC32 - -#include -#include -#include -#include - -#include -#include - -#include - -typedef TCP_SOCKET sock_t; -#define to64(x) strtoll(x, NULL, 10) - -#define SIZE_T_FMT "lu" -#define INT64_FMT "lld" - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -char* inet_ntoa(struct in_addr in); - -#endif /* CS_PLATFORM == CS_P_PIC32 */ - -#endif /* CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/platform_stm32.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_PLATFORM_STM32_H_ -#define CS_COMMON_PLATFORMS_PLATFORM_STM32_H_ -#if CS_PLATFORM == CS_P_STM32 - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define to64(x) strtoll(x, NULL, 10) -#define INT64_FMT PRId64 -#define SIZE_T_FMT "u" -typedef struct stat cs_stat_t; -#define DIRSEP '/' - -#ifndef CS_ENABLE_STDIO -#define CS_ENABLE_STDIO 1 -#endif - -#ifndef MG_ENABLE_FILESYSTEM -#define MG_ENABLE_FILESYSTEM 1 -#endif - -#define CS_DEFINE_DIRENT - -#endif /* CS_PLATFORM == CS_P_STM32 */ -#endif /* CS_COMMON_PLATFORMS_PLATFORM_STM32_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/platforms/lwip/mg_lwip.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_ -#define CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_ - -#ifndef MG_LWIP -#define MG_LWIP 0 -#endif - -#if MG_LWIP - -/* - * When compiling for nRF5x chips with arm-none-eabi-gcc, it has BYTE_ORDER - * already defined, so in order to avoid warnings in lwip, we have to undefine - * it. - * - * TODO: Check if in the future versions of nRF5 SDK that changes. - * Current version of nRF51 SDK: 0.8.0 - * nRF5 SDK: 0.9.0 - */ -#if CS_PLATFORM == CS_P_NRF51 || CS_PLATFORM == CS_P_NRF52 -#undef BYTE_ORDER -#endif - -#include -#include -#include -#include -#include -#include - -#ifndef LWIP_PROVIDE_ERRNO -#include -#endif - -#if LWIP_SOCKET -#include -#else -/* We really need the definitions from sockets.h. */ -#undef LWIP_SOCKET -#define LWIP_SOCKET 1 -#include -#undef LWIP_SOCKET -#define LWIP_SOCKET 0 -#endif - -#define INVALID_SOCKET (-1) -#define SOMAXCONN 10 -typedef int sock_t; - -#if MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL -struct mg_mgr; -struct mg_connection; -uint32_t mg_lwip_get_poll_delay_ms(struct mg_mgr *mgr); -void mg_lwip_set_keepalive_params(struct mg_connection *nc, int idle, - int interval, int count); -#endif - -#endif /* MG_LWIP */ - -#endif /* CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/cs_time.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_CS_TIME_H_ -#define CS_COMMON_CS_TIME_H_ - -/* Amalgamated: #include "common/platform.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* Sub-second granularity time(). */ -double cs_time(void); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_CS_TIME_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/mg_str.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_MG_STR_H_ -#define CS_COMMON_MG_STR_H_ - -#include - -/* Amalgamated: #include "common/platform.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* Describes chunk of memory */ -struct mg_str { - const char *p; /* Memory chunk pointer */ - size_t len; /* Memory chunk length */ -}; - -/* - * Helper functions for creating mg_str struct from plain C string. - * `NULL` is allowed and becomes `{NULL, 0}`. - */ -struct mg_str mg_mk_str(const char *s); -struct mg_str mg_mk_str_n(const char *s, size_t len); - -/* Macro for initializing mg_str. */ -#define MG_MK_STR(str_literal) \ - { str_literal, sizeof(str_literal) - 1 } - -/* - * Cross-platform version of `strcmp()` where where first string is - * specified by `struct mg_str`. - */ -int mg_vcmp(const struct mg_str *str2, const char *str1); - -/* - * Cross-platform version of `strncasecmp()` where first string is - * specified by `struct mg_str`. - */ -int mg_vcasecmp(const struct mg_str *str2, const char *str1); - -struct mg_str mg_strdup(const struct mg_str s); -int mg_strcmp(const struct mg_str str1, const struct mg_str str2); -int mg_strncmp(const struct mg_str str1, const struct mg_str str2, size_t n); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_MG_STR_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/mbuf.h" -#endif -/* - * Copyright (c) 2015 Cesanta Software Limited - * All rights reserved - */ - -/* - * === Memory Buffers - * - * Mbufs are mutable/growing memory buffers, like C++ strings. - * Mbuf can append data to the end of a buffer or insert data into arbitrary - * position in the middle of a buffer. The buffer grows automatically when - * needed. - */ - -#ifndef CS_COMMON_MBUF_H_ -#define CS_COMMON_MBUF_H_ - -#include -/* Amalgamated: #include "common/platform.h" */ - -#if defined(__cplusplus) -extern "C" { -#endif - -#ifndef MBUF_SIZE_MULTIPLIER -#define MBUF_SIZE_MULTIPLIER 1.5 -#endif - -/* Memory buffer descriptor */ -struct mbuf { - char *buf; /* Buffer pointer */ - size_t len; /* Data length. Data is located between offset 0 and len. */ - size_t size; /* Buffer size allocated by realloc(1). Must be >= len */ -}; - -/* - * Initialises an Mbuf. - * `initial_capacity` specifies the initial capacity of the mbuf. - */ -void mbuf_init(struct mbuf *, size_t initial_capacity); - -/* Frees the space allocated for the mbuffer and resets the mbuf structure. */ -void mbuf_free(struct mbuf *); - -/* - * Appends data to the Mbuf. - * - * Returns the number of bytes appended or 0 if out of memory. - */ -size_t mbuf_append(struct mbuf *, const void *data, size_t data_size); - -/* - * Inserts data at a specified offset in the Mbuf. - * - * Existing data will be shifted forwards and the buffer will - * be grown if necessary. - * Returns the number of bytes inserted. - */ -size_t mbuf_insert(struct mbuf *, size_t, const void *, size_t); - -/* Removes `data_size` bytes from the beginning of the buffer. */ -void mbuf_remove(struct mbuf *, size_t data_size); - -/* - * Resizes an Mbuf. - * - * If `new_size` is smaller than buffer's `len`, the - * resize is not performed. - */ -void mbuf_resize(struct mbuf *, size_t new_size); - -/* Shrinks an Mbuf by resizing its `size` to `len`. */ -void mbuf_trim(struct mbuf *); - -#if defined(__cplusplus) -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_MBUF_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/sha1.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_SHA1_H_ -#define CS_COMMON_SHA1_H_ - -#ifndef DISABLE_SHA1 -#define DISABLE_SHA1 0 -#endif - -#if !DISABLE_SHA1 - -/* Amalgamated: #include "common/platform.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -typedef struct { - uint32_t state[5]; - uint32_t count[2]; - unsigned char buffer[64]; -} cs_sha1_ctx; - -void cs_sha1_init(cs_sha1_ctx *); -void cs_sha1_update(cs_sha1_ctx *, const unsigned char *data, uint32_t len); -void cs_sha1_final(unsigned char digest[20], cs_sha1_ctx *); -void cs_hmac_sha1(const unsigned char *key, size_t key_len, - const unsigned char *text, size_t text_len, - unsigned char out[20]); -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* DISABLE_SHA1 */ - -#endif /* CS_COMMON_SHA1_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/md5.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_MD5_H_ -#define CS_COMMON_MD5_H_ - -/* Amalgamated: #include "common/platform.h" */ - -#ifndef DISABLE_MD5 -#define DISABLE_MD5 0 -#endif - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -typedef struct MD5Context { - uint32_t buf[4]; - uint32_t bits[2]; - unsigned char in[64]; -} MD5_CTX; - -void MD5_Init(MD5_CTX *c); -void MD5_Update(MD5_CTX *c, const unsigned char *data, size_t len); -void MD5_Final(unsigned char *md, MD5_CTX *c); - -/* - * Return stringified MD5 hash for NULL terminated list of pointer/length pairs. - * A length should be specified as size_t variable. - * Example: - * - * char buf[33]; - * cs_md5(buf, "foo", (size_t) 3, "bar", (size_t) 3, NULL); - */ -char *cs_md5(char buf[33], ...); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_COMMON_MD5_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/base64.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_BASE64_H_ -#define CS_COMMON_BASE64_H_ - -#ifndef DISABLE_BASE64 -#define DISABLE_BASE64 0 -#endif - -#if !DISABLE_BASE64 - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void (*cs_base64_putc_t)(char, void *); - -struct cs_base64_ctx { - /* cannot call it putc because it's a macro on some environments */ - cs_base64_putc_t b64_putc; - unsigned char chunk[3]; - int chunk_size; - void *user_data; -}; - -void cs_base64_init(struct cs_base64_ctx *ctx, cs_base64_putc_t putc, - void *user_data); -void cs_base64_update(struct cs_base64_ctx *ctx, const char *str, size_t len); -void cs_base64_finish(struct cs_base64_ctx *ctx); - -void cs_base64_encode(const unsigned char *src, int src_len, char *dst); -void cs_fprint_base64(FILE *f, const unsigned char *src, int src_len); -int cs_base64_decode(const unsigned char *s, int len, char *dst, int *dec_len); - -#ifdef __cplusplus -} -#endif - -#endif /* DISABLE_BASE64 */ - -#endif /* CS_COMMON_BASE64_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/str_util.h" -#endif -/* - * Copyright (c) 2015 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_COMMON_STR_UTIL_H_ -#define CS_COMMON_STR_UTIL_H_ - -#include -#include - -/* Amalgamated: #include "common/platform.h" */ - -#ifndef CS_ENABLE_STRDUP -#define CS_ENABLE_STRDUP 0 -#endif - -#ifndef CS_ENABLE_TO64 -#define CS_ENABLE_TO64 0 -#endif - -/* - * Expands to a string representation of its argument: e.g. - * `CS_STRINGIFY_LIT(5) expands to "5"` - */ -#define CS_STRINGIFY_LIT(x) #x - -/* - * Expands to a string representation of its argument, which is allowed - * to be a macro: e.g. - * - * #define FOO 123 - * CS_STRINGIFY_MACRO(FOO) - * - * expands to 123. - */ -#define CS_STRINGIFY_MACRO(x) CS_STRINGIFY_LIT(x) - -#ifdef __cplusplus -extern "C" { -#endif - -size_t c_strnlen(const char *s, size_t maxlen); -int c_snprintf(char *buf, size_t buf_size, const char *format, ...); -int c_vsnprintf(char *buf, size_t buf_size, const char *format, va_list ap); -/* - * Find the first occurrence of find in s, where the search is limited to the - * first slen characters of s. - */ -const char *c_strnstr(const char *s, const char *find, size_t slen); - -/* - * Stringify binary data. Output buffer size must be 2 * size_of_input + 1 - * because each byte of input takes 2 bytes in string representation - * plus 1 byte for the terminating \0 character. - */ -void cs_to_hex(char *to, const unsigned char *p, size_t len); - -/* - * Convert stringified binary data back to binary. - * Does the reverse of `cs_to_hex()`. - */ -void cs_from_hex(char *to, const char *p, size_t len); - -#if CS_ENABLE_STRDUP -char *strdup(const char *src); -#endif - -#if CS_ENABLE_TO64 -#include -/* - * Simple string -> int64 conversion routine. - */ -int64_t cs_to64(const char *s); -#endif - -/* - * Cross-platform version of `strncasecmp()`. - */ -int mg_ncasecmp(const char *s1, const char *s2, size_t len); - -/* - * Cross-platform version of `strcasecmp()`. - */ -int mg_casecmp(const char *s1, const char *s2); - -/* - * Prints message to the buffer. If the buffer is large enough to hold the - * message, it returns buffer. If buffer is to small, it allocates a large - * enough buffer on heap and returns allocated buffer. - * This is a supposed use case: - * - * char buf[5], *p = buf; - * mg_avprintf(&p, sizeof(buf), "%s", "hi there"); - * use_p_somehow(p); - * if (p != buf) { - * free(p); - * } - * - * The purpose of this is to avoid malloc-ing if generated strings are small. - */ -int mg_asprintf(char **buf, size_t size, const char *fmt, ...); - -/* Same as mg_asprintf, but takes varargs list. */ -int mg_avprintf(char **buf, size_t size, const char *fmt, va_list ap); - -#ifdef __cplusplus -} -#endif - -#endif /* CS_COMMON_STR_UTIL_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "common/queue.h" -#endif -/* clang-format off */ -/*- - * Copyright (c) 1991, 1993 - * The Regents of the University of California. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * @(#)queue.h 8.5 (Berkeley) 8/20/94 - * $FreeBSD$ - */ - -#ifndef _SYS_QUEUE_H_ -#define _SYS_QUEUE_H_ - -/* - * This file defines four types of data structures: singly-linked lists, - * singly-linked tail queues, lists and tail queues. - * - * A singly-linked list is headed by a single forward pointer. The elements - * are singly linked for minimum space and pointer manipulation overhead at - * the expense of O(n) removal for arbitrary elements. New elements can be - * added to the list after an existing element or at the head of the list. - * Elements being removed from the head of the list should use the explicit - * macro for this purpose for optimum efficiency. A singly-linked list may - * only be traversed in the forward direction. Singly-linked lists are ideal - * for applications with large datasets and few or no removals or for - * implementing a LIFO queue. - * - * A singly-linked tail queue is headed by a pair of pointers, one to the - * head of the list and the other to the tail of the list. The elements are - * singly linked for minimum space and pointer manipulation overhead at the - * expense of O(n) removal for arbitrary elements. New elements can be added - * to the list after an existing element, at the head of the list, or at the - * end of the list. Elements being removed from the head of the tail queue - * should use the explicit macro for this purpose for optimum efficiency. - * A singly-linked tail queue may only be traversed in the forward direction. - * Singly-linked tail queues are ideal for applications with large datasets - * and few or no removals or for implementing a FIFO queue. - * - * A list is headed by a single forward pointer (or an array of forward - * pointers for a hash table header). The elements are doubly linked - * so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before - * or after an existing element or at the head of the list. A list - * may be traversed in either direction. - * - * A tail queue is headed by a pair of pointers, one to the head of the - * list and the other to the tail of the list. The elements are doubly - * linked so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before or - * after an existing element, at the head of the list, or at the end of - * the list. A tail queue may be traversed in either direction. - * - * For details on the use of these macros, see the queue(3) manual page. - * - * - * SLIST LIST STAILQ TAILQ - * _HEAD + + + + - * _CLASS_HEAD + + + + - * _HEAD_INITIALIZER + + + + - * _ENTRY + + + + - * _CLASS_ENTRY + + + + - * _INIT + + + + - * _EMPTY + + + + - * _FIRST + + + + - * _NEXT + + + + - * _PREV - + - + - * _LAST - - + + - * _FOREACH + + + + - * _FOREACH_FROM + + + + - * _FOREACH_SAFE + + + + - * _FOREACH_FROM_SAFE + + + + - * _FOREACH_REVERSE - - - + - * _FOREACH_REVERSE_FROM - - - + - * _FOREACH_REVERSE_SAFE - - - + - * _FOREACH_REVERSE_FROM_SAFE - - - + - * _INSERT_HEAD + + + + - * _INSERT_BEFORE - + - + - * _INSERT_AFTER + + + + - * _INSERT_TAIL - - + + - * _CONCAT - - + + - * _REMOVE_AFTER + - + - - * _REMOVE_HEAD + - + - - * _REMOVE + + + + - * _SWAP + + + + - * - */ -#ifdef QUEUE_MACRO_DEBUG -/* Store the last 2 places the queue element or head was altered */ -struct qm_trace { - unsigned long lastline; - unsigned long prevline; - const char *lastfile; - const char *prevfile; -}; - -#define TRACEBUF struct qm_trace trace; -#define TRACEBUF_INITIALIZER { __LINE__, 0, __FILE__, NULL } , -#define TRASHIT(x) do {(x) = (void *)-1;} while (0) -#define QMD_SAVELINK(name, link) void **name = (void *)&(link) - -#define QMD_TRACE_HEAD(head) do { \ - (head)->trace.prevline = (head)->trace.lastline; \ - (head)->trace.prevfile = (head)->trace.lastfile; \ - (head)->trace.lastline = __LINE__; \ - (head)->trace.lastfile = __FILE__; \ -} while (0) - -#define QMD_TRACE_ELEM(elem) do { \ - (elem)->trace.prevline = (elem)->trace.lastline; \ - (elem)->trace.prevfile = (elem)->trace.lastfile; \ - (elem)->trace.lastline = __LINE__; \ - (elem)->trace.lastfile = __FILE__; \ -} while (0) - -#else -#define QMD_TRACE_ELEM(elem) -#define QMD_TRACE_HEAD(head) -#define QMD_SAVELINK(name, link) -#define TRACEBUF -#define TRACEBUF_INITIALIZER -#define TRASHIT(x) -#endif /* QUEUE_MACRO_DEBUG */ - -#ifdef __cplusplus -/* - * In C++ there can be structure lists and class lists: - */ -#define QUEUE_TYPEOF(type) type -#else -#define QUEUE_TYPEOF(type) struct type -#endif - -/* - * Singly-linked List declarations. - */ -#define SLIST_HEAD(name, type) \ -struct name { \ - struct type *slh_first; /* first element */ \ -} - -#define SLIST_CLASS_HEAD(name, type) \ -struct name { \ - class type *slh_first; /* first element */ \ -} - -#define SLIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define SLIST_ENTRY(type) \ -struct { \ - struct type *sle_next; /* next element */ \ -} - -#define SLIST_CLASS_ENTRY(type) \ -struct { \ - class type *sle_next; /* next element */ \ -} - -/* - * Singly-linked List functions. - */ -#define SLIST_EMPTY(head) ((head)->slh_first == NULL) - -#define SLIST_FIRST(head) ((head)->slh_first) - -#define SLIST_FOREACH(var, head, field) \ - for ((var) = SLIST_FIRST((head)); \ - (var); \ - (var) = SLIST_NEXT((var), field)) - -#define SLIST_FOREACH_FROM(var, head, field) \ - for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ - (var); \ - (var) = SLIST_NEXT((var), field)) - -#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = SLIST_FIRST((head)); \ - (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ - for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ - (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ - for ((varp) = &SLIST_FIRST((head)); \ - ((var) = *(varp)) != NULL; \ - (varp) = &SLIST_NEXT((var), field)) - -#define SLIST_INIT(head) do { \ - SLIST_FIRST((head)) = NULL; \ -} while (0) - -#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ - SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ - SLIST_NEXT((slistelm), field) = (elm); \ -} while (0) - -#define SLIST_INSERT_HEAD(head, elm, field) do { \ - SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ - SLIST_FIRST((head)) = (elm); \ -} while (0) - -#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) - -#define SLIST_REMOVE(head, elm, type, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.sle_next); \ - if (SLIST_FIRST((head)) == (elm)) { \ - SLIST_REMOVE_HEAD((head), field); \ - } \ - else { \ - QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head); \ - while (SLIST_NEXT(curelm, field) != (elm)) \ - curelm = SLIST_NEXT(curelm, field); \ - SLIST_REMOVE_AFTER(curelm, field); \ - } \ - TRASHIT(*oldnext); \ -} while (0) - -#define SLIST_REMOVE_AFTER(elm, field) do { \ - SLIST_NEXT(elm, field) = \ - SLIST_NEXT(SLIST_NEXT(elm, field), field); \ -} while (0) - -#define SLIST_REMOVE_HEAD(head, field) do { \ - SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ -} while (0) - -#define SLIST_SWAP(head1, head2, type) do { \ - QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1); \ - SLIST_FIRST(head1) = SLIST_FIRST(head2); \ - SLIST_FIRST(head2) = swap_first; \ -} while (0) - -/* - * Singly-linked Tail queue declarations. - */ -#define STAILQ_HEAD(name, type) \ -struct name { \ - struct type *stqh_first;/* first element */ \ - struct type **stqh_last;/* addr of last next element */ \ -} - -#define STAILQ_CLASS_HEAD(name, type) \ -struct name { \ - class type *stqh_first; /* first element */ \ - class type **stqh_last; /* addr of last next element */ \ -} - -#define STAILQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).stqh_first } - -#define STAILQ_ENTRY(type) \ -struct { \ - struct type *stqe_next; /* next element */ \ -} - -#define STAILQ_CLASS_ENTRY(type) \ -struct { \ - class type *stqe_next; /* next element */ \ -} - -/* - * Singly-linked Tail queue functions. - */ -#define STAILQ_CONCAT(head1, head2) do { \ - if (!STAILQ_EMPTY((head2))) { \ - *(head1)->stqh_last = (head2)->stqh_first; \ - (head1)->stqh_last = (head2)->stqh_last; \ - STAILQ_INIT((head2)); \ - } \ -} while (0) - -#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) - -#define STAILQ_FIRST(head) ((head)->stqh_first) - -#define STAILQ_FOREACH(var, head, field) \ - for((var) = STAILQ_FIRST((head)); \ - (var); \ - (var) = STAILQ_NEXT((var), field)) - -#define STAILQ_FOREACH_FROM(var, head, field) \ - for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ - (var); \ - (var) = STAILQ_NEXT((var), field)) - -#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = STAILQ_FIRST((head)); \ - (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ - for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ - (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define STAILQ_INIT(head) do { \ - STAILQ_FIRST((head)) = NULL; \ - (head)->stqh_last = &STAILQ_FIRST((head)); \ -} while (0) - -#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ - if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ - STAILQ_NEXT((tqelm), field) = (elm); \ -} while (0) - -#define STAILQ_INSERT_HEAD(head, elm, field) do { \ - if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ - STAILQ_FIRST((head)) = (elm); \ -} while (0) - -#define STAILQ_INSERT_TAIL(head, elm, field) do { \ - STAILQ_NEXT((elm), field) = NULL; \ - *(head)->stqh_last = (elm); \ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ -} while (0) - -#define STAILQ_LAST(head, type, field) \ - (STAILQ_EMPTY((head)) ? NULL : \ - __containerof((head)->stqh_last, \ - QUEUE_TYPEOF(type), field.stqe_next)) - -#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) - -#define STAILQ_REMOVE(head, elm, type, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \ - if (STAILQ_FIRST((head)) == (elm)) { \ - STAILQ_REMOVE_HEAD((head), field); \ - } \ - else { \ - QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \ - while (STAILQ_NEXT(curelm, field) != (elm)) \ - curelm = STAILQ_NEXT(curelm, field); \ - STAILQ_REMOVE_AFTER(head, curelm, field); \ - } \ - TRASHIT(*oldnext); \ -} while (0) - -#define STAILQ_REMOVE_AFTER(head, elm, field) do { \ - if ((STAILQ_NEXT(elm, field) = \ - STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ -} while (0) - -#define STAILQ_REMOVE_HEAD(head, field) do { \ - if ((STAILQ_FIRST((head)) = \ - STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ - (head)->stqh_last = &STAILQ_FIRST((head)); \ -} while (0) - -#define STAILQ_SWAP(head1, head2, type) do { \ - QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1); \ - QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last; \ - STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \ - (head1)->stqh_last = (head2)->stqh_last; \ - STAILQ_FIRST(head2) = swap_first; \ - (head2)->stqh_last = swap_last; \ - if (STAILQ_EMPTY(head1)) \ - (head1)->stqh_last = &STAILQ_FIRST(head1); \ - if (STAILQ_EMPTY(head2)) \ - (head2)->stqh_last = &STAILQ_FIRST(head2); \ -} while (0) - - -/* - * List declarations. - */ -#define LIST_HEAD(name, type) \ -struct name { \ - struct type *lh_first; /* first element */ \ -} - -#define LIST_CLASS_HEAD(name, type) \ -struct name { \ - class type *lh_first; /* first element */ \ -} - -#define LIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define LIST_ENTRY(type) \ -struct { \ - struct type *le_next; /* next element */ \ - struct type **le_prev; /* address of previous next element */ \ -} - -#define LIST_CLASS_ENTRY(type) \ -struct { \ - class type *le_next; /* next element */ \ - class type **le_prev; /* address of previous next element */ \ -} - -/* - * List functions. - */ - -#if (defined(_KERNEL) && defined(INVARIANTS)) -#define QMD_LIST_CHECK_HEAD(head, field) do { \ - if (LIST_FIRST((head)) != NULL && \ - LIST_FIRST((head))->field.le_prev != \ - &LIST_FIRST((head))) \ - panic("Bad list head %p first->prev != head", (head)); \ -} while (0) - -#define QMD_LIST_CHECK_NEXT(elm, field) do { \ - if (LIST_NEXT((elm), field) != NULL && \ - LIST_NEXT((elm), field)->field.le_prev != \ - &((elm)->field.le_next)) \ - panic("Bad link elm %p next->prev != elm", (elm)); \ -} while (0) - -#define QMD_LIST_CHECK_PREV(elm, field) do { \ - if (*(elm)->field.le_prev != (elm)) \ - panic("Bad link elm %p prev->next != elm", (elm)); \ -} while (0) -#else -#define QMD_LIST_CHECK_HEAD(head, field) -#define QMD_LIST_CHECK_NEXT(elm, field) -#define QMD_LIST_CHECK_PREV(elm, field) -#endif /* (_KERNEL && INVARIANTS) */ - -#define LIST_EMPTY(head) ((head)->lh_first == NULL) - -#define LIST_FIRST(head) ((head)->lh_first) - -#define LIST_FOREACH(var, head, field) \ - for ((var) = LIST_FIRST((head)); \ - (var); \ - (var) = LIST_NEXT((var), field)) - -#define LIST_FOREACH_FROM(var, head, field) \ - for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ - (var); \ - (var) = LIST_NEXT((var), field)) - -#define LIST_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = LIST_FIRST((head)); \ - (var) && ((tvar) = LIST_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ - for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ - (var) && ((tvar) = LIST_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define LIST_INIT(head) do { \ - LIST_FIRST((head)) = NULL; \ -} while (0) - -#define LIST_INSERT_AFTER(listelm, elm, field) do { \ - QMD_LIST_CHECK_NEXT(listelm, field); \ - if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\ - LIST_NEXT((listelm), field)->field.le_prev = \ - &LIST_NEXT((elm), field); \ - LIST_NEXT((listelm), field) = (elm); \ - (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ -} while (0) - -#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ - QMD_LIST_CHECK_PREV(listelm, field); \ - (elm)->field.le_prev = (listelm)->field.le_prev; \ - LIST_NEXT((elm), field) = (listelm); \ - *(listelm)->field.le_prev = (elm); \ - (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ -} while (0) - -#define LIST_INSERT_HEAD(head, elm, field) do { \ - QMD_LIST_CHECK_HEAD((head), field); \ - if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ - LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\ - LIST_FIRST((head)) = (elm); \ - (elm)->field.le_prev = &LIST_FIRST((head)); \ -} while (0) - -#define LIST_NEXT(elm, field) ((elm)->field.le_next) - -#define LIST_PREV(elm, head, type, field) \ - ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \ - __containerof((elm)->field.le_prev, \ - QUEUE_TYPEOF(type), field.le_next)) - -#define LIST_REMOVE(elm, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.le_next); \ - QMD_SAVELINK(oldprev, (elm)->field.le_prev); \ - QMD_LIST_CHECK_NEXT(elm, field); \ - QMD_LIST_CHECK_PREV(elm, field); \ - if (LIST_NEXT((elm), field) != NULL) \ - LIST_NEXT((elm), field)->field.le_prev = \ - (elm)->field.le_prev; \ - *(elm)->field.le_prev = LIST_NEXT((elm), field); \ - TRASHIT(*oldnext); \ - TRASHIT(*oldprev); \ -} while (0) - -#define LIST_SWAP(head1, head2, type, field) do { \ - QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1); \ - LIST_FIRST((head1)) = LIST_FIRST((head2)); \ - LIST_FIRST((head2)) = swap_tmp; \ - if ((swap_tmp = LIST_FIRST((head1))) != NULL) \ - swap_tmp->field.le_prev = &LIST_FIRST((head1)); \ - if ((swap_tmp = LIST_FIRST((head2))) != NULL) \ - swap_tmp->field.le_prev = &LIST_FIRST((head2)); \ -} while (0) - -/* - * Tail queue declarations. - */ -#define TAILQ_HEAD(name, type) \ -struct name { \ - struct type *tqh_first; /* first element */ \ - struct type **tqh_last; /* addr of last next element */ \ - TRACEBUF \ -} - -#define TAILQ_CLASS_HEAD(name, type) \ -struct name { \ - class type *tqh_first; /* first element */ \ - class type **tqh_last; /* addr of last next element */ \ - TRACEBUF \ -} - -#define TAILQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER } - -#define TAILQ_ENTRY(type) \ -struct { \ - struct type *tqe_next; /* next element */ \ - struct type **tqe_prev; /* address of previous next element */ \ - TRACEBUF \ -} - -#define TAILQ_CLASS_ENTRY(type) \ -struct { \ - class type *tqe_next; /* next element */ \ - class type **tqe_prev; /* address of previous next element */ \ - TRACEBUF \ -} - -/* - * Tail queue functions. - */ -#if (defined(_KERNEL) && defined(INVARIANTS)) -#define QMD_TAILQ_CHECK_HEAD(head, field) do { \ - if (!TAILQ_EMPTY(head) && \ - TAILQ_FIRST((head))->field.tqe_prev != \ - &TAILQ_FIRST((head))) \ - panic("Bad tailq head %p first->prev != head", (head)); \ -} while (0) - -#define QMD_TAILQ_CHECK_TAIL(head, field) do { \ - if (*(head)->tqh_last != NULL) \ - panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \ -} while (0) - -#define QMD_TAILQ_CHECK_NEXT(elm, field) do { \ - if (TAILQ_NEXT((elm), field) != NULL && \ - TAILQ_NEXT((elm), field)->field.tqe_prev != \ - &((elm)->field.tqe_next)) \ - panic("Bad link elm %p next->prev != elm", (elm)); \ -} while (0) - -#define QMD_TAILQ_CHECK_PREV(elm, field) do { \ - if (*(elm)->field.tqe_prev != (elm)) \ - panic("Bad link elm %p prev->next != elm", (elm)); \ -} while (0) -#else -#define QMD_TAILQ_CHECK_HEAD(head, field) -#define QMD_TAILQ_CHECK_TAIL(head, headname) -#define QMD_TAILQ_CHECK_NEXT(elm, field) -#define QMD_TAILQ_CHECK_PREV(elm, field) -#endif /* (_KERNEL && INVARIANTS) */ - -#define TAILQ_CONCAT(head1, head2, field) do { \ - if (!TAILQ_EMPTY(head2)) { \ - *(head1)->tqh_last = (head2)->tqh_first; \ - (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ - (head1)->tqh_last = (head2)->tqh_last; \ - TAILQ_INIT((head2)); \ - QMD_TRACE_HEAD(head1); \ - QMD_TRACE_HEAD(head2); \ - } \ -} while (0) - -#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) - -#define TAILQ_FIRST(head) ((head)->tqh_first) - -#define TAILQ_FOREACH(var, head, field) \ - for ((var) = TAILQ_FIRST((head)); \ - (var); \ - (var) = TAILQ_NEXT((var), field)) - -#define TAILQ_FOREACH_FROM(var, head, field) \ - for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ - (var); \ - (var) = TAILQ_NEXT((var), field)) - -#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = TAILQ_FIRST((head)); \ - (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ - for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ - (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ - for ((var) = TAILQ_LAST((head), headname); \ - (var); \ - (var) = TAILQ_PREV((var), headname, field)) - -#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \ - for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ - (var); \ - (var) = TAILQ_PREV((var), headname, field)) - -#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ - for ((var) = TAILQ_LAST((head), headname); \ - (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ - (var) = (tvar)) - -#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \ - for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ - (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ - (var) = (tvar)) - -#define TAILQ_INIT(head) do { \ - TAILQ_FIRST((head)) = NULL; \ - (head)->tqh_last = &TAILQ_FIRST((head)); \ - QMD_TRACE_HEAD(head); \ -} while (0) - -#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ - QMD_TAILQ_CHECK_NEXT(listelm, field); \ - if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ - TAILQ_NEXT((elm), field)->field.tqe_prev = \ - &TAILQ_NEXT((elm), field); \ - else { \ - (head)->tqh_last = &TAILQ_NEXT((elm), field); \ - QMD_TRACE_HEAD(head); \ - } \ - TAILQ_NEXT((listelm), field) = (elm); \ - (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ - QMD_TRACE_ELEM(&(elm)->field); \ - QMD_TRACE_ELEM(&(listelm)->field); \ -} while (0) - -#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ - QMD_TAILQ_CHECK_PREV(listelm, field); \ - (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ - TAILQ_NEXT((elm), field) = (listelm); \ - *(listelm)->field.tqe_prev = (elm); \ - (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ - QMD_TRACE_ELEM(&(elm)->field); \ - QMD_TRACE_ELEM(&(listelm)->field); \ -} while (0) - -#define TAILQ_INSERT_HEAD(head, elm, field) do { \ - QMD_TAILQ_CHECK_HEAD(head, field); \ - if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ - TAILQ_FIRST((head))->field.tqe_prev = \ - &TAILQ_NEXT((elm), field); \ - else \ - (head)->tqh_last = &TAILQ_NEXT((elm), field); \ - TAILQ_FIRST((head)) = (elm); \ - (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ - QMD_TRACE_HEAD(head); \ - QMD_TRACE_ELEM(&(elm)->field); \ -} while (0) - -#define TAILQ_INSERT_TAIL(head, elm, field) do { \ - QMD_TAILQ_CHECK_TAIL(head, field); \ - TAILQ_NEXT((elm), field) = NULL; \ - (elm)->field.tqe_prev = (head)->tqh_last; \ - *(head)->tqh_last = (elm); \ - (head)->tqh_last = &TAILQ_NEXT((elm), field); \ - QMD_TRACE_HEAD(head); \ - QMD_TRACE_ELEM(&(elm)->field); \ -} while (0) - -#define TAILQ_LAST(head, headname) \ - (*(((struct headname *)((head)->tqh_last))->tqh_last)) - -#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) - -#define TAILQ_PREV(elm, headname, field) \ - (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) - -#define TAILQ_REMOVE(head, elm, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \ - QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \ - QMD_TAILQ_CHECK_NEXT(elm, field); \ - QMD_TAILQ_CHECK_PREV(elm, field); \ - if ((TAILQ_NEXT((elm), field)) != NULL) \ - TAILQ_NEXT((elm), field)->field.tqe_prev = \ - (elm)->field.tqe_prev; \ - else { \ - (head)->tqh_last = (elm)->field.tqe_prev; \ - QMD_TRACE_HEAD(head); \ - } \ - *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ - TRASHIT(*oldnext); \ - TRASHIT(*oldprev); \ - QMD_TRACE_ELEM(&(elm)->field); \ -} while (0) - -#define TAILQ_SWAP(head1, head2, type, field) do { \ - QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first; \ - QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last; \ - (head1)->tqh_first = (head2)->tqh_first; \ - (head1)->tqh_last = (head2)->tqh_last; \ - (head2)->tqh_first = swap_first; \ - (head2)->tqh_last = swap_last; \ - if ((swap_first = (head1)->tqh_first) != NULL) \ - swap_first->field.tqe_prev = &(head1)->tqh_first; \ - else \ - (head1)->tqh_last = &(head1)->tqh_first; \ - if ((swap_first = (head2)->tqh_first) != NULL) \ - swap_first->field.tqe_prev = &(head2)->tqh_first; \ - else \ - (head2)->tqh_last = &(head2)->tqh_first; \ -} while (0) - -#endif /* !_SYS_QUEUE_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/features.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_FEATURES_H_ -#define CS_MONGOOSE_SRC_FEATURES_H_ - -#ifndef MG_DISABLE_HTTP_DIGEST_AUTH -#define MG_DISABLE_HTTP_DIGEST_AUTH 0 -#endif - -#ifndef MG_DISABLE_HTTP_KEEP_ALIVE -#define MG_DISABLE_HTTP_KEEP_ALIVE 0 -#endif - -#ifndef MG_DISABLE_PFS -#define MG_DISABLE_PFS 0 -#endif - -#ifndef MG_DISABLE_WS_RANDOM_MASK -#define MG_DISABLE_WS_RANDOM_MASK 0 -#endif - -#ifndef MG_ENABLE_ASYNC_RESOLVER -#define MG_ENABLE_ASYNC_RESOLVER 1 -#endif - -#ifndef MG_ENABLE_BROADCAST -#define MG_ENABLE_BROADCAST 0 -#endif - -#ifndef MG_ENABLE_COAP -#define MG_ENABLE_COAP 0 -#endif - -#ifndef MG_ENABLE_DEBUG -#define MG_ENABLE_DEBUG 0 -#endif - -#ifndef MG_ENABLE_DIRECTORY_LISTING -#define MG_ENABLE_DIRECTORY_LISTING 0 -#endif - -#ifndef MG_ENABLE_DNS -#define MG_ENABLE_DNS 1 -#endif - -#ifndef MG_ENABLE_DNS_SERVER -#define MG_ENABLE_DNS_SERVER 0 -#endif - -#ifndef MG_ENABLE_FAKE_DAVLOCK -#define MG_ENABLE_FAKE_DAVLOCK 0 -#endif - -#ifndef MG_ENABLE_FILESYSTEM -#define MG_ENABLE_FILESYSTEM 0 -#endif - -#ifndef MG_ENABLE_GETADDRINFO -#define MG_ENABLE_GETADDRINFO 0 -#endif - -#ifndef MG_ENABLE_HEXDUMP -#define MG_ENABLE_HEXDUMP CS_ENABLE_STDIO -#endif - -#ifndef MG_ENABLE_HTTP -#define MG_ENABLE_HTTP 1 -#endif - -#ifndef MG_ENABLE_HTTP_CGI -#define MG_ENABLE_HTTP_CGI 0 -#endif - -#ifndef MG_ENABLE_HTTP_SSI -#define MG_ENABLE_HTTP_SSI MG_ENABLE_FILESYSTEM -#endif - -#ifndef MG_ENABLE_HTTP_SSI_EXEC -#define MG_ENABLE_HTTP_SSI_EXEC 0 -#endif - -#ifndef MG_ENABLE_HTTP_STREAMING_MULTIPART -#define MG_ENABLE_HTTP_STREAMING_MULTIPART 0 -#endif - -#ifndef MG_ENABLE_HTTP_WEBDAV -#define MG_ENABLE_HTTP_WEBDAV 0 -#endif - -#ifndef MG_ENABLE_HTTP_WEBSOCKET -#define MG_ENABLE_HTTP_WEBSOCKET MG_ENABLE_HTTP -#endif - -#ifndef MG_ENABLE_IPV6 -#define MG_ENABLE_IPV6 0 -#endif - -#ifndef MG_ENABLE_JAVASCRIPT -#define MG_ENABLE_JAVASCRIPT 0 -#endif - -#ifndef MG_ENABLE_MQTT -#define MG_ENABLE_MQTT 1 -#endif - -#ifndef MG_ENABLE_MQTT_BROKER -#define MG_ENABLE_MQTT_BROKER 0 -#endif - -#ifndef MG_ENABLE_SSL -#define MG_ENABLE_SSL 0 -#endif - -#ifndef MG_ENABLE_SYNC_RESOLVER -#define MG_ENABLE_SYNC_RESOLVER 0 -#endif - -#ifndef MG_ENABLE_STDIO -#define MG_ENABLE_STDIO CS_ENABLE_STDIO -#endif - -#ifndef MG_NET_IF -#define MG_NET_IF MG_NET_IF_SOCKET -#endif - -#ifndef MG_SSL_IF -#define MG_SSL_IF MG_SSL_IF_OPENSSL -#endif - -#ifndef MG_ENABLE_THREADS /* ifdef-ok */ -#ifdef _WIN32 -#define MG_ENABLE_THREADS 1 -#else -#define MG_ENABLE_THREADS 0 -#endif -#endif - -#if MG_ENABLE_DEBUG && !defined(CS_ENABLE_DEBUG) -#define CS_ENABLE_DEBUG 1 -#endif - -/* MQTT broker requires MQTT */ -#if MG_ENABLE_MQTT_BROKER && !MG_ENABLE_MQTT -#undef MG_ENABLE_MQTT -#define MG_ENABLE_MQTT 1 -#endif - -#ifndef MG_ENABLE_HTTP_URL_REWRITES -#define MG_ENABLE_HTTP_URL_REWRITES \ - (CS_PLATFORM == CS_P_WINDOWS || CS_PLATFORM == CS_P_UNIX) -#endif - -#ifndef MG_ENABLE_TUN -#define MG_ENABLE_TUN MG_ENABLE_HTTP_WEBSOCKET -#endif - -#ifndef MG_ENABLE_SNTP -#define MG_ENABLE_SNTP 0 -#endif - -#ifndef MG_ENABLE_EXTRA_ERRORS_DESC -#define MG_ENABLE_EXTRA_ERRORS_DESC 0 -#endif - -#endif /* CS_MONGOOSE_SRC_FEATURES_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net_if.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_NET_IF_H_ -#define CS_MONGOOSE_SRC_NET_IF_H_ - -/* Amalgamated: #include "common/platform.h" */ - -/* - * Internal async networking core interface. - * Consists of calls made by the core, which should not block, - * and callbacks back into the core ("..._cb"). - * Callbacks may (will) cause methods to be invoked from within, - * but methods are not allowed to invoke callbacks inline. - * - * Implementation must ensure that only one callback is invoked at any time. - */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#define MG_MAIN_IFACE 0 - -struct mg_mgr; -struct mg_connection; -union socket_address; - -struct mg_iface_vtable; - -struct mg_iface { - struct mg_mgr *mgr; - void *data; /* Implementation-specific data */ - struct mg_iface_vtable *vtable; -}; - -struct mg_iface_vtable { - void (*init)(struct mg_iface *iface); - void (*free)(struct mg_iface *iface); - void (*add_conn)(struct mg_connection *nc); - void (*remove_conn)(struct mg_connection *nc); - time_t (*poll)(struct mg_iface *iface, int timeout_ms); - - /* Set up a listening TCP socket on a given address. rv = 0 -> ok. */ - int (*listen_tcp)(struct mg_connection *nc, union socket_address *sa); - /* Request that a "listening" UDP socket be created. */ - int (*listen_udp)(struct mg_connection *nc, union socket_address *sa); - - /* Request that a TCP connection is made to the specified address. */ - void (*connect_tcp)(struct mg_connection *nc, const union socket_address *sa); - /* Open a UDP socket. Doesn't actually connect anything. */ - void (*connect_udp)(struct mg_connection *nc); - - /* Send functions for TCP and UDP. Sent data is copied before return. */ - void (*tcp_send)(struct mg_connection *nc, const void *buf, size_t len); - void (*udp_send)(struct mg_connection *nc, const void *buf, size_t len); - - void (*recved)(struct mg_connection *nc, size_t len); - - /* Perform interface-related connection initialization. Return 1 on ok. */ - int (*create_conn)(struct mg_connection *nc); - /* Perform interface-related cleanup on connection before destruction. */ - void (*destroy_conn)(struct mg_connection *nc); - - /* Associate a socket to a connection. */ - void (*sock_set)(struct mg_connection *nc, sock_t sock); - - /* Put connection's address into *sa, local (remote = 0) or remote. */ - void (*get_conn_addr)(struct mg_connection *nc, int remote, - union socket_address *sa); -}; - -extern struct mg_iface_vtable *mg_ifaces[]; -extern int mg_num_ifaces; - -/* Creates a new interface instance. */ -struct mg_iface *mg_if_create_iface(struct mg_iface_vtable *vtable, - struct mg_mgr *mgr); - -/* - * Find an interface with a given implementation. The search is started from - * interface `from`, exclusive. Returns NULL if none is found. - */ -struct mg_iface *mg_find_iface(struct mg_mgr *mgr, - struct mg_iface_vtable *vtable, - struct mg_iface *from); -/* - * Deliver a new TCP connection. Returns NULL in case on error (unable to - * create connection, in which case interface state should be discarded. - * This is phase 1 of the two-phase process - MG_EV_ACCEPT will be delivered - * when mg_if_accept_tcp_cb is invoked. - */ -struct mg_connection *mg_if_accept_new_conn(struct mg_connection *lc); -void mg_if_accept_tcp_cb(struct mg_connection *nc, union socket_address *sa, - size_t sa_len); - -/* Callback invoked by connect methods. err = 0 -> ok, != 0 -> error. */ -void mg_if_connect_cb(struct mg_connection *nc, int err); -/* Callback that reports that data has been put on the wire. */ -void mg_if_sent_cb(struct mg_connection *nc, int num_sent); -/* - * Receive callback. - * if `own` is true, buf must be heap-allocated and ownership is transferred - * to the core. - * Core will acknowledge consumption by calling iface::recved. - */ -void mg_if_recv_tcp_cb(struct mg_connection *nc, void *buf, int len, int own); -/* - * Receive callback. - * buf must be heap-allocated and ownership is transferred to the core. - * Core will acknowledge consumption by calling iface::recved. - */ -void mg_if_recv_udp_cb(struct mg_connection *nc, void *buf, int len, - union socket_address *sa, size_t sa_len); - -/* void mg_if_close_conn(struct mg_connection *nc); */ - -/* Deliver a POLL event to the connection. */ -void mg_if_poll(struct mg_connection *nc, time_t now); - -/* Deliver a TIMER event to the connection. */ -void mg_if_timer(struct mg_connection *c, double now); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_MONGOOSE_SRC_NET_IF_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/ssl_if.h" -#endif -/* - * Copyright (c) 2014-2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_SSL_IF_H_ -#define CS_MONGOOSE_SRC_SSL_IF_H_ - -#if MG_ENABLE_SSL - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -struct mg_ssl_if_ctx; -struct mg_connection; - -void mg_ssl_if_init(); - -enum mg_ssl_if_result { - MG_SSL_OK = 0, - MG_SSL_WANT_READ = -1, - MG_SSL_WANT_WRITE = -2, - MG_SSL_ERROR = -3, -}; - -struct mg_ssl_if_conn_params { - const char *cert; - const char *key; - const char *ca_cert; - const char *server_name; - const char *cipher_suites; -}; - -enum mg_ssl_if_result mg_ssl_if_conn_init( - struct mg_connection *nc, const struct mg_ssl_if_conn_params *params, - const char **err_msg); -enum mg_ssl_if_result mg_ssl_if_conn_accept(struct mg_connection *nc, - struct mg_connection *lc); -void mg_ssl_if_conn_free(struct mg_connection *nc); - -enum mg_ssl_if_result mg_ssl_if_handshake(struct mg_connection *nc); -int mg_ssl_if_read(struct mg_connection *nc, void *buf, size_t buf_size); -int mg_ssl_if_write(struct mg_connection *nc, const void *data, size_t len); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_SSL */ - -#endif /* CS_MONGOOSE_SRC_SSL_IF_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/net.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - * This software is dual-licensed: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. For the terms of this - * license, see . - * - * You are free to use this software under the terms of the GNU General - * Public License, but WITHOUT ANY WARRANTY; without even the implied - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * Alternatively, you can license this software under a commercial - * license, as set out in . - */ - -/* - * === Core API: TCP/UDP/SSL - * - * NOTE: Mongoose manager is single threaded. It does not protect - * its data structures by mutexes, therefore all functions that are dealing - * with a particular event manager should be called from the same thread, - * with exception of the `mg_broadcast()` function. It is fine to have different - * event managers handled by different threads. - */ - -#ifndef CS_MONGOOSE_SRC_NET_H_ -#define CS_MONGOOSE_SRC_NET_H_ - -#if MG_ENABLE_JAVASCRIPT -#define EXCLUDE_COMMON -#include -#endif - -/* Amalgamated: #include "mongoose/src/common.h" */ -/* Amalgamated: #include "mongoose/src/net_if.h" */ -/* Amalgamated: #include "common/mbuf.h" */ - -#ifndef MG_VPRINTF_BUFFER_SIZE -#define MG_VPRINTF_BUFFER_SIZE 100 -#endif - -#ifdef MG_USE_READ_WRITE -#define MG_RECV_FUNC(s, b, l, f) read(s, b, l) -#define MG_SEND_FUNC(s, b, l, f) write(s, b, l) -#else -#define MG_RECV_FUNC(s, b, l, f) recv(s, b, l, f) -#define MG_SEND_FUNC(s, b, l, f) send(s, b, l, f) -#endif - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -union socket_address { - struct sockaddr sa; - struct sockaddr_in sin; -#if MG_ENABLE_IPV6 - struct sockaddr_in6 sin6; -#else - struct sockaddr sin6; -#endif -}; - -struct mg_connection; - -/* - * Callback function (event handler) prototype. Must be defined by the user. - * Mongoose calls the event handler, passing the events defined below. - */ -typedef void (*mg_event_handler_t)(struct mg_connection *nc, int ev, - void *ev_data); - -/* Events. Meaning of event parameter (evp) is given in the comment. */ -#define MG_EV_POLL 0 /* Sent to each connection on each mg_mgr_poll() call */ -#define MG_EV_ACCEPT 1 /* New connection accepted. union socket_address * */ -#define MG_EV_CONNECT 2 /* connect() succeeded or failed. int * */ -#define MG_EV_RECV 3 /* Data has benn received. int *num_bytes */ -#define MG_EV_SEND 4 /* Data has been written to a socket. int *num_bytes */ -#define MG_EV_CLOSE 5 /* Connection is closed. NULL */ -#define MG_EV_TIMER 6 /* now >= conn->ev_timer_time. double * */ - -/* - * Mongoose event manager. - */ -struct mg_mgr { - struct mg_connection *active_connections; -#if MG_ENABLE_HEXDUMP - const char *hexdump_file; /* Debug hexdump file path */ -#endif -#if MG_ENABLE_BROADCAST - sock_t ctl[2]; /* Socketpair for mg_broadcast() */ -#endif - void *user_data; /* User data */ - int num_ifaces; - struct mg_iface **ifaces; /* network interfaces */ -#if MG_ENABLE_JAVASCRIPT - struct v7 *v7; -#endif -}; - -/* - * Mongoose connection. - */ -struct mg_connection { - struct mg_connection *next, *prev; /* mg_mgr::active_connections linkage */ - struct mg_connection *listener; /* Set only for accept()-ed connections */ - struct mg_mgr *mgr; /* Pointer to containing manager */ - - sock_t sock; /* Socket to the remote peer */ - int err; - union socket_address sa; /* Remote peer address */ - size_t recv_mbuf_limit; /* Max size of recv buffer */ - struct mbuf recv_mbuf; /* Received data */ - struct mbuf send_mbuf; /* Data scheduled for sending */ - time_t last_io_time; /* Timestamp of the last socket IO */ - double ev_timer_time; /* Timestamp of the future MG_EV_TIMER */ -#if MG_ENABLE_SSL - void *ssl_if_data; /* SSL library data. */ -#endif - mg_event_handler_t proto_handler; /* Protocol-specific event handler */ - void *proto_data; /* Protocol-specific data */ - void (*proto_data_destructor)(void *proto_data); - mg_event_handler_t handler; /* Event handler function */ - void *user_data; /* User-specific data */ - union { - void *v; - /* - * the C standard is fussy about fitting function pointers into - * void pointers, since some archs might have fat pointers for functions. - */ - mg_event_handler_t f; - } priv_1; - void *priv_2; - void *mgr_data; /* Implementation-specific event manager's data. */ - struct mg_iface *iface; - unsigned long flags; -/* Flags set by Mongoose */ -#define MG_F_LISTENING (1 << 0) /* This connection is listening */ -#define MG_F_UDP (1 << 1) /* This connection is UDP */ -#define MG_F_RESOLVING (1 << 2) /* Waiting for async resolver */ -#define MG_F_CONNECTING (1 << 3) /* connect() call in progress */ -#define MG_F_SSL (1 << 4) /* SSL is enabled on the connection */ -#define MG_F_SSL_HANDSHAKE_DONE (1 << 5) /* SSL hanshake has completed */ -#define MG_F_WANT_READ (1 << 6) /* SSL specific */ -#define MG_F_WANT_WRITE (1 << 7) /* SSL specific */ -#define MG_F_IS_WEBSOCKET (1 << 8) /* Websocket specific */ - -/* Flags that are settable by user */ -#define MG_F_SEND_AND_CLOSE (1 << 10) /* Push remaining data and close */ -#define MG_F_CLOSE_IMMEDIATELY (1 << 11) /* Disconnect */ -#define MG_F_WEBSOCKET_NO_DEFRAG (1 << 12) /* Websocket specific */ -#define MG_F_DELETE_CHUNK (1 << 13) /* HTTP specific */ -#define MG_F_ENABLE_BROADCAST (1 << 14) /* Allow broadcast address usage */ -#define MG_F_TUN_DO_NOT_RECONNECT (1 << 15) /* Don't reconnect tunnel */ - -#define MG_F_USER_1 (1 << 20) /* Flags left for application */ -#define MG_F_USER_2 (1 << 21) -#define MG_F_USER_3 (1 << 22) -#define MG_F_USER_4 (1 << 23) -#define MG_F_USER_5 (1 << 24) -#define MG_F_USER_6 (1 << 25) -}; - -/* - * Initialise Mongoose manager. Side effect: ignores SIGPIPE signal. - * `mgr->user_data` field will be initialised with a `user_data` parameter. - * That is an arbitrary pointer, where the user code can associate some data - * with the particular Mongoose manager. For example, a C++ wrapper class - * could be written in which case `user_data` can hold a pointer to the - * class instance. - */ -void mg_mgr_init(struct mg_mgr *mgr, void *user_data); - -/* - * Optional parameters to `mg_mgr_init_opt()`. - * - * If `main_iface` is not NULL, it will be used as the main interface in the - * default interface set. The pointer will be free'd by `mg_mgr_free`. - * Otherwise, the main interface will be autodetected based on the current - * platform. - * - * If `num_ifaces` is 0 and `ifaces` is NULL, the default interface set will be - * used. - * This is an advanced option, as it requires you to construct a full interface - * set, including special networking interfaces required by some optional - * features such as TCP tunneling. Memory backing `ifaces` and each of the - * `num_ifaces` pointers it contains will be reclaimed by `mg_mgr_free`. - */ -struct mg_mgr_init_opts { - struct mg_iface_vtable *main_iface; - int num_ifaces; - struct mg_iface_vtable **ifaces; -}; - -/* - * Like `mg_mgr_init` but with more options. - * - * Notably, this allows you to create a manger and choose - * dynamically which networking interface implementation to use. - */ -void mg_mgr_init_opt(struct mg_mgr *mgr, void *user_data, - struct mg_mgr_init_opts opts); - -/* - * De-initialises Mongoose manager. - * - * Closes and deallocates all active connections. - */ -void mg_mgr_free(struct mg_mgr *); - -/* - * This function performs the actual IO and must be called in a loop - * (an event loop). It returns the current timestamp. - * `milli` is the maximum number of milliseconds to sleep. - * `mg_mgr_poll()` checks all connections for IO readiness. If at least one - * of the connections is IO-ready, `mg_mgr_poll()` triggers the respective - * event handlers and returns. - */ -time_t mg_mgr_poll(struct mg_mgr *, int milli); - -#if MG_ENABLE_BROADCAST -/* - * Passes a message of a given length to all connections. - * - * Must be called from a thread that does NOT call `mg_mgr_poll()`. - * Note that `mg_broadcast()` is the only function - * that can be, and must be, called from a different (non-IO) thread. - * - * `func` callback function will be called by the IO thread for each - * connection. When called, the event will be `MG_EV_POLL`, and a message will - * be passed as the `ev_data` pointer. Maximum message size is capped - * by `MG_CTL_MSG_MESSAGE_SIZE` which is set to 8192 bytes. - */ -void mg_broadcast(struct mg_mgr *, mg_event_handler_t func, void *, size_t); -#endif - -/* - * Iterates over all active connections. - * - * Returns the next connection from the list - * of active connections or `NULL` if there are no more connections. Below - * is the iteration idiom: - * - * ```c - * for (c = mg_next(srv, NULL); c != NULL; c = mg_next(srv, c)) { - * // Do something with connection `c` - * } - * ``` - */ -struct mg_connection *mg_next(struct mg_mgr *, struct mg_connection *); - -/* - * Optional parameters to `mg_add_sock_opt()`. - * - * `flags` is an initial `struct mg_connection::flags` bitmask to set, - * see `MG_F_*` flags definitions. - */ -struct mg_add_sock_opts { - void *user_data; /* Initial value for connection's user_data */ - unsigned int flags; /* Initial connection flags */ - const char **error_string; /* Placeholder for the error string */ - struct mg_iface *iface; /* Interface instance */ -}; - -/* - * Creates a connection, associates it with the given socket and event handler - * and adds it to the manager. - * - * For more options see the `mg_add_sock_opt` variant. - */ -struct mg_connection *mg_add_sock(struct mg_mgr *, sock_t, mg_event_handler_t); - -/* - * Creates a connection, associates it with the given socket and event handler - * and adds to the manager. - * - * See the `mg_add_sock_opts` structure for a description of the options. - */ -struct mg_connection *mg_add_sock_opt(struct mg_mgr *, sock_t, - mg_event_handler_t, - struct mg_add_sock_opts); - -/* - * Optional parameters to `mg_bind_opt()`. - * - * `flags` is an initial `struct mg_connection::flags` bitmask to set, - * see `MG_F_*` flags definitions. - */ -struct mg_bind_opts { - void *user_data; /* Initial value for connection's user_data */ - unsigned int flags; /* Extra connection flags */ - const char **error_string; /* Placeholder for the error string */ - struct mg_iface *iface; /* Interface instance */ -#if MG_ENABLE_SSL - /* - * SSL settings. - * - * Server certificate to present to clients or client certificate to - * present to tunnel dispatcher (for tunneled connections). - */ - const char *ssl_cert; - /* Private key corresponding to the certificate. If ssl_cert is set but - * ssl_key is not, ssl_cert is used. */ - const char *ssl_key; - /* CA bundle used to verify client certificates or tunnel dispatchers. */ - const char *ssl_ca_cert; - /* Colon-delimited list of acceptable cipher suites. - * Names depend on the library used, for example: - * - * ECDH-ECDSA-AES128-GCM-SHA256:DHE-RSA-AES128-SHA256 (OpenSSL) - * TLS-ECDH-ECDSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256 - * (mbedTLS) - * - * For OpenSSL the list can be obtained by running "openssl ciphers". - * For mbedTLS, names can be found in library/ssl_ciphersuites.c - * If NULL, a reasonable default is used. - */ - const char *ssl_cipher_suites; -#endif -}; - -/* - * Creates a listening connection. - * - * See `mg_bind_opt` for full documentation. - */ -struct mg_connection *mg_bind(struct mg_mgr *, const char *, - mg_event_handler_t); -/* - * Creates a listening connection. - * - * The `address` parameter specifies which address to bind to. It's format is - * the same as for the `mg_connect()` call, where `HOST` part is optional. - * `address` can be just a port number, e.g. `:8000`. To bind to a specific - * interface, an IP address can be specified, e.g. `1.2.3.4:8000`. By default, - * a TCP connection is created. To create UDP connection, prepend `udp://` - * prefix, e.g. `udp://:8000`. To summarize, `address` paramer has following - * format: `[PROTO://][IP_ADDRESS]:PORT`, where `PROTO` could be `tcp` or - * `udp`. - * - * See the `mg_bind_opts` structure for a description of the optional - * parameters. - * - * Returns a new listening connection or `NULL` on error. - * NOTE: The connection remains owned by the manager, do not free(). - */ -struct mg_connection *mg_bind_opt(struct mg_mgr *mgr, const char *address, - mg_event_handler_t handler, - struct mg_bind_opts opts); - -/* Optional parameters to `mg_connect_opt()` */ -struct mg_connect_opts { - void *user_data; /* Initial value for connection's user_data */ - unsigned int flags; /* Extra connection flags */ - const char **error_string; /* Placeholder for the error string */ - struct mg_iface *iface; /* Interface instance */ -#if MG_ENABLE_SSL - /* - * SSL settings. - * Client certificate to present to the server. - */ - const char *ssl_cert; - /* - * Private key corresponding to the certificate. - * If ssl_cert is set but ssl_key is not, ssl_cert is used. - */ - const char *ssl_key; - /* - * Verify server certificate using this CA bundle. If set to "*", then SSL - * is enabled but no cert verification is performed. - */ - const char *ssl_ca_cert; - /* Colon-delimited list of acceptable cipher suites. - * Names depend on the library used, for example: - * - * ECDH-ECDSA-AES128-GCM-SHA256:DHE-RSA-AES128-SHA256 (OpenSSL) - * TLS-ECDH-ECDSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256 - * (mbedTLS) - * - * For OpenSSL the list can be obtained by running "openssl ciphers". - * For mbedTLS, names can be found in library/ssl_ciphersuites.c - * If NULL, a reasonable default is used. - */ - const char *ssl_cipher_suites; - /* - * Server name verification. If ssl_ca_cert is set and the certificate has - * passed verification, its subject will be verified against this string. - * By default (if ssl_server_name is NULL) hostname part of the address will - * be used. Wildcard matching is supported. A special value of "*" disables - * name verification. - */ - const char *ssl_server_name; -#endif -}; - -/* - * Connects to a remote host. - * - * See `mg_connect_opt()` for full documentation. - */ -struct mg_connection *mg_connect(struct mg_mgr *mgr, const char *address, - mg_event_handler_t handler); - -/* - * Connects to a remote host. - * - * The `address` format is `[PROTO://]HOST:PORT`. `PROTO` could be `tcp` or - * `udp`. `HOST` could be an IP address, - * IPv6 address (if Mongoose is compiled with `-DMG_ENABLE_IPV6`) or a host - * name. If `HOST` is a name, Mongoose will resolve it asynchronously. Examples - * of valid addresses: `google.com:80`, `udp://1.2.3.4:53`, `10.0.0.1:443`, - * `[::1]:80` - * - * See the `mg_connect_opts` structure for a description of the optional - * parameters. - * - * Returns a new outbound connection or `NULL` on error. - * - * NOTE: The connection remains owned by the manager, do not free(). - * - * NOTE: To enable IPv6 addresses `-DMG_ENABLE_IPV6` should be specified - * in the compilation flags. - * - * NOTE: The new connection will receive `MG_EV_CONNECT` as its first event - * which will report the connect success status. - * If the asynchronous resolution fails or the `connect()` syscall fails for - * whatever reason (e.g. with `ECONNREFUSED` or `ENETUNREACH`), then - * `MG_EV_CONNECT` event will report failure. Code example below: - * - * ```c - * static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) { - * int connect_status; - * - * switch (ev) { - * case MG_EV_CONNECT: - * connect_status = * (int *) ev_data; - * if (connect_status == 0) { - * // Success - * } else { - * // Error - * printf("connect() error: %s\n", strerror(connect_status)); - * } - * break; - * ... - * } - * } - * - * ... - * mg_connect(mgr, "my_site.com:80", ev_handler); - * ``` - */ -struct mg_connection *mg_connect_opt(struct mg_mgr *mgr, const char *address, - mg_event_handler_t handler, - struct mg_connect_opts opts); - -#if MG_ENABLE_SSL && MG_NET_IF != MG_NET_IF_SIMPLELINK -/* - * Note: This function is deprecated. Please, use SSL options in - * mg_connect_opt. - * - * Enables SSL for a given connection. - * `cert` is a server certificate file name for a listening connection - * or a client certificate file name for an outgoing connection. - * The certificate files must be in PEM format. The server certificate file - * must contain a certificate, concatenated with a private key, optionally - * concatenated with DH parameters. - * `ca_cert` is a CA certificate or NULL if peer verification is not - * required. - * Return: NULL on success or error message on error. - */ -const char *mg_set_ssl(struct mg_connection *nc, const char *cert, - const char *ca_cert); -#endif - -/* - * Sends data to the connection. - * - * Note that sending functions do not actually push data to the socket. - * They just append data to the output buffer. MG_EV_SEND will be delivered when - * the data has actually been pushed out. - */ -void mg_send(struct mg_connection *, const void *buf, int len); - -/* Enables format string warnings for mg_printf */ -#if defined(__GNUC__) -__attribute__((format(printf, 2, 3))) -#endif -/* don't separate from mg_printf declaration */ - -/* - * Sends `printf`-style formatted data to the connection. - * - * See `mg_send` for more details on send semantics. - */ -int mg_printf(struct mg_connection *, const char *fmt, ...); - -/* Same as `mg_printf()`, but takes `va_list ap` as an argument. */ -int mg_vprintf(struct mg_connection *, const char *fmt, va_list ap); - -/* - * Creates a socket pair. - * `sock_type` can be either `SOCK_STREAM` or `SOCK_DGRAM`. - * Returns 0 on failure and 1 on success. - */ -int mg_socketpair(sock_t[2], int sock_type); - -#if MG_ENABLE_SYNC_RESOLVER -/* - * Convert domain name into IP address. - * - * This is a utility function. If compilation flags have - * `-DMG_ENABLE_GETADDRINFO`, then `getaddrinfo()` call is used for name - * resolution. Otherwise, `gethostbyname()` is used. - * - * CAUTION: this function can block. - * Return 1 on success, 0 on failure. - */ -int mg_resolve(const char *domain_name, char *ip_addr_buf, size_t buf_len); -#endif - -/* - * Verify given IP address against the ACL. - * - * `remote_ip` - an IPv4 address to check, in host byte order - * `acl` - a comma separated list of IP subnets: `x.x.x.x/x` or `x.x.x.x`. - * Each subnet is - * prepended by either a - or a + sign. A plus sign means allow, where a - * minus sign means deny. If a subnet mask is omitted, such as `-1.2.3.4`, - * it means that only that single IP address is denied. - * Subnet masks may vary from 0 to 32, inclusive. The default setting - * is to allow all access. On each request the full list is traversed, - * and the last match wins. Example: - * - * `-0.0.0.0/0,+192.168/16` - deny all acccesses, only allow 192.168/16 subnet - * - * To learn more about subnet masks, see this - * link:https://en.wikipedia.org/wiki/Subnetwork[Wikipedia page on Subnetwork]. - * - * Returns -1 if ACL is malformed, 0 if address is disallowed, 1 if allowed. - */ -int mg_check_ip_acl(const char *acl, uint32_t remote_ip); - -#if MG_ENABLE_JAVASCRIPT -/* - * Enables server-side JavaScript scripting. - * Requires a `-DMG_ENABLE_JAVASCRIPT` compilation flag and V7 engine sources. - * V7 instance must not be destroyed during manager's lifetime. - * Returns a V7 error. - */ -enum v7_err mg_enable_javascript(struct mg_mgr *m, struct v7 *v7, - const char *init_js_file_name); -#endif - -/* - * Schedules an MG_EV_TIMER event to be delivered at `timestamp` time. - * `timestamp` is UNIX time (the number of seconds since Epoch). It is - * `double` instead of `time_t` to allow for sub-second precision. - * Returns the old timer value. - * - * Example: set the connect timeout to 1.5 seconds: - * - * ``` - * c = mg_connect(&mgr, "cesanta.com", ev_handler); - * mg_set_timer(c, mg_time() + 1.5); - * ... - * - * void ev_handler(struct mg_connection *c, int ev, void *ev_data) { - * switch (ev) { - * case MG_EV_CONNECT: - * mg_set_timer(c, 0); // Clear connect timer - * break; - * case MG_EV_TIMER: - * log("Connect timeout"); - * c->flags |= MG_F_CLOSE_IMMEDIATELY; - * break; - * ``` - */ -double mg_set_timer(struct mg_connection *c, double timestamp); - -/* - * A sub-second precision version of time(). - */ -double mg_time(void); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_MONGOOSE_SRC_NET_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/uri.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* - * === URI - */ - -#ifndef CS_MONGOOSE_SRC_URI_H_ -#define CS_MONGOOSE_SRC_URI_H_ - -/* Amalgamated: #include "mongoose/src/net.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* - * Parses an URI and fills string chunks with locations of the respective - * uri components within the input uri string. NULL pointers will be - * ignored. - * - * General syntax: - * - * [scheme://[user_info@]]host[:port][/path][?query][#fragment] - * - * Example: - * - * foo.com:80 - * tcp://foo.com:1234 - * http://foo.com:80/bar?baz=1 - * https://user:pw@foo.com:443/blah - * - * `path` will include the leading slash. `query` won't include the leading `?`. - * `host` can contain embedded colons if surrounded by square brackets in order - * to support IPv6 literal addresses. - * - * - * Returns 0 on success, -1 on error. - */ -int mg_parse_uri(struct mg_str uri, struct mg_str *scheme, - struct mg_str *user_info, struct mg_str *host, - unsigned int *port, struct mg_str *path, struct mg_str *query, - struct mg_str *fragment); - -int mg_normalize_uri_path(const struct mg_str *in, struct mg_str *out); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ -#endif /* CS_MONGOOSE_SRC_URI_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/util.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* - * === Utility API - */ - -#ifndef CS_MONGOOSE_SRC_UTIL_H_ -#define CS_MONGOOSE_SRC_UTIL_H_ - -#include - -/* Amalgamated: #include "mongoose/src/common.h" */ -/* Amalgamated: #include "mongoose/src/net_if.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#ifndef MAX_PATH_SIZE -#define MAX_PATH_SIZE 500 -#endif - -/* - * Fetches substring from input string `s`, `end` into `v`. - * Skips initial delimiter characters. Records first non-delimiter character - * at the beginning of substring `v`. Then scans the rest of the string - * until a delimiter character or end-of-string is found. - * `delimiters` is a 0-terminated string containing delimiter characters. - * Either one of `delimiters` or `end_string` terminates the search. - * Returns an `s` pointer, advanced forward where parsing has stopped. - */ -const char *mg_skip(const char *s, const char *end_string, - const char *delimiters, struct mg_str *v); - -/* - * Decodes base64-encoded string `s`, `len` into the destination `dst`. - * The destination has to have enough space to hold the decoded buffer. - * Decoding stops either when all strings have been decoded or invalid an - * character appeared. - * Destination is '\0'-terminated. - * Returns the number of decoded characters. On success, that should be equal - * to `len`. On error (invalid character) the return value is smaller then - * `len`. - */ -int mg_base64_decode(const unsigned char *s, int len, char *dst); - -/* - * Base64-encode chunk of memory `src`, `src_len` into the destination `dst`. - * Destination has to have enough space to hold encoded buffer. - * Destination is '\0'-terminated. - */ -void mg_base64_encode(const unsigned char *src, int src_len, char *dst); - -#if MG_ENABLE_FILESYSTEM -/* - * Performs a 64-bit `stat()` call against a given file. - * - * `path` should be UTF8 encoded. - * - * Return value is the same as for `stat()` syscall. - */ -int mg_stat(const char *path, cs_stat_t *st); - -/* - * Opens the given file and returns a file stream. - * - * `path` and `mode` should be UTF8 encoded. - * - * Return value is the same as for the `fopen()` call. - */ -FILE *mg_fopen(const char *path, const char *mode); - -/* - * Opens the given file and returns a file stream. - * - * `path` should be UTF8 encoded. - * - * Return value is the same as for the `open()` syscall. - */ -int mg_open(const char *path, int flag, int mode); -#endif /* MG_ENABLE_FILESYSTEM */ - -#if MG_ENABLE_THREADS -/* - * Starts a new detached thread. - * Arguments and semantics are the same as pthead's `pthread_create()`. - * `thread_func` is a thread function, `thread_func_param` is a parameter - * that is passed to the thread function. - */ -void *mg_start_thread(void *(*thread_func)(void *), void *thread_func_param); -#endif - -void mg_set_close_on_exec(sock_t); - -#define MG_SOCK_STRINGIFY_IP 1 -#define MG_SOCK_STRINGIFY_PORT 2 -#define MG_SOCK_STRINGIFY_REMOTE 4 -/* - * Converts a connection's local or remote address into string. - * - * The `flags` parameter is a bit mask that controls the behaviour, - * see `MG_SOCK_STRINGIFY_*` definitions. - * - * - MG_SOCK_STRINGIFY_IP - print IP address - * - MG_SOCK_STRINGIFY_PORT - print port number - * - MG_SOCK_STRINGIFY_REMOTE - print remote peer's IP/port, not local address - * - * If both port number and IP address are printed, they are separated by `:`. - * If compiled with `-DMG_ENABLE_IPV6`, IPv6 addresses are supported. - */ -void mg_conn_addr_to_str(struct mg_connection *nc, char *buf, size_t len, - int flags); -#if MG_NET_IF == MG_NET_IF_SOCKET -/* Legacy interface. */ -void mg_sock_to_str(sock_t sock, char *buf, size_t len, int flags); -#endif - -/* - * Convert the socket's address into string. - * - * `flags` is MG_SOCK_STRINGIFY_IP and/or MG_SOCK_STRINGIFY_PORT. - */ -void mg_sock_addr_to_str(const union socket_address *sa, char *buf, size_t len, - int flags); - -#if MG_ENABLE_HEXDUMP -/* - * Generates a human-readable hexdump of memory chunk. - * - * Takes a memory buffer `buf` of length `len` and creates a hex dump of that - * buffer in `dst`. The generated output is a-la hexdump(1). - * Returns the length of generated string, excluding terminating `\0`. If - * returned length is bigger than `dst_len`, the overflow bytes are discarded. - */ -int mg_hexdump(const void *buf, int len, char *dst, int dst_len); - -/* - * Generates human-readable hexdump of the data sent or received by the - * connection. `path` is a file name where hexdump should be written. - * `num_bytes` is a number of bytes sent/received. `ev` is one of the `MG_*` - * events sent to an event handler. This function is supposed to be called from - * the event handler. - */ -void mg_hexdump_connection(struct mg_connection *nc, const char *path, - const void *buf, int num_bytes, int ev); -#endif - -/* - * Returns true if target platform is big endian. - */ -int mg_is_big_endian(void); - -/* - * 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. - * The value is stored in a val vector. If the value has a form "x=y", then - * eq_val vector is initialised to point to the "y" part, and val vector length - * is adjusted to point only to "x". - * If the list is just a comma separated list of entries, like "aa,bb,cc" then - * `eq_val` will contain zero-length string. - * - * The purpose of this function is to parse comma separated string without - * any copying/memory allocation. - */ -const char *mg_next_comma_list_entry(const char *list, struct mg_str *val, - struct mg_str *eq_val); - -/* - * Matches 0-terminated string (mg_match_prefix) or string with given length - * mg_match_prefix_n against a glob pattern. - * - * Match is case-insensitive. Returns number of bytes matched, or -1 if no - * match. - */ -int mg_match_prefix(const char *pattern, int pattern_len, const char *str); -int mg_match_prefix_n(const struct mg_str pattern, const struct mg_str str); - -/* - * Use with cs_base64_init/update/finish in order to write out base64 in chunks. - */ -void mg_mbuf_append_base64_putc(char ch, void *user_data); - -/* - * Encode `len` bytes starting at `data` as base64 and append them to an mbuf. - */ -void mg_mbuf_append_base64(struct mbuf *mbuf, const void *data, size_t len); - -/* - * Generate a Basic Auth header and appends it to buf. - * If pass is NULL, then user is expected to contain the credentials pair - * already encoded as `user:pass`. - */ -void mg_basic_auth_header(const char *user, const char *pass, struct mbuf *buf); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ -#endif /* CS_MONGOOSE_SRC_UTIL_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* - * === Common API reference - */ - -#ifndef CS_MONGOOSE_SRC_HTTP_H_ -#define CS_MONGOOSE_SRC_HTTP_H_ - -#if MG_ENABLE_HTTP - -/* Amalgamated: #include "mongoose/src/net.h" */ -/* Amalgamated: #include "common/mg_str.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#ifndef MG_MAX_HTTP_HEADERS -#define MG_MAX_HTTP_HEADERS 20 -#endif - -#ifndef MG_MAX_HTTP_REQUEST_SIZE -#define MG_MAX_HTTP_REQUEST_SIZE 1024 -#endif - -#ifndef MG_MAX_PATH -#ifdef PATH_MAX -#define MG_MAX_PATH PATH_MAX -#else -#define MG_MAX_PATH 256 -#endif -#endif - -#ifndef MG_MAX_HTTP_SEND_MBUF -#define MG_MAX_HTTP_SEND_MBUF 1024 -#endif - -#ifndef MG_CGI_ENVIRONMENT_SIZE -#define MG_CGI_ENVIRONMENT_SIZE 8192 -#endif - -/* HTTP message */ -struct http_message { - struct mg_str message; /* Whole message: request line + headers + body */ - - /* HTTP Request line (or HTTP response line) */ - struct mg_str method; /* "GET" */ - struct mg_str uri; /* "/my_file.html" */ - struct mg_str proto; /* "HTTP/1.1" -- for both request and response */ - - /* For responses, code and response status message are set */ - int resp_code; - struct mg_str resp_status_msg; - - /* - * Query-string part of the URI. For example, for HTTP request - * GET /foo/bar?param1=val1¶m2=val2 - * | uri | query_string | - * - * Note that question mark character doesn't belong neither to the uri, - * nor to the query_string - */ - struct mg_str query_string; - - /* Headers */ - struct mg_str header_names[MG_MAX_HTTP_HEADERS]; - struct mg_str header_values[MG_MAX_HTTP_HEADERS]; - - /* Message body */ - struct mg_str body; /* Zero-length for requests with no body */ -}; - -#if MG_ENABLE_HTTP_WEBSOCKET -/* WebSocket message */ -struct websocket_message { - unsigned char *data; - size_t size; - unsigned char flags; -}; -#endif - -/* HTTP multipart part */ -struct mg_http_multipart_part { - const char *file_name; - const char *var_name; - struct mg_str data; - int status; /* <0 on error */ - void *user_data; -}; - -/* SSI call context */ -struct mg_ssi_call_ctx { - struct http_message *req; /* The request being processed. */ - struct mg_str file; /* Filesystem path of the file being processed. */ - struct mg_str arg; /* The argument passed to the tag: . */ -}; - -/* HTTP and websocket events. void *ev_data is described in a comment. */ -#define MG_EV_HTTP_REQUEST 100 /* struct http_message * */ -#define MG_EV_HTTP_REPLY 101 /* struct http_message * */ -#define MG_EV_HTTP_CHUNK 102 /* struct http_message * */ -#define MG_EV_SSI_CALL 105 /* char * */ -#define MG_EV_SSI_CALL_CTX 106 /* struct mg_ssi_call_ctx * */ - -#if MG_ENABLE_HTTP_WEBSOCKET -#define MG_EV_WEBSOCKET_HANDSHAKE_REQUEST 111 /* struct http_message * */ -#define MG_EV_WEBSOCKET_HANDSHAKE_DONE 112 /* NULL */ -#define MG_EV_WEBSOCKET_FRAME 113 /* struct websocket_message * */ -#define MG_EV_WEBSOCKET_CONTROL_FRAME 114 /* struct websocket_message * */ -#endif - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART -#define MG_EV_HTTP_MULTIPART_REQUEST 121 /* struct http_message */ -#define MG_EV_HTTP_PART_BEGIN 122 /* struct mg_http_multipart_part */ -#define MG_EV_HTTP_PART_DATA 123 /* struct mg_http_multipart_part */ -#define MG_EV_HTTP_PART_END 124 /* struct mg_http_multipart_part */ -/* struct mg_http_multipart_part */ -#define MG_EV_HTTP_MULTIPART_REQUEST_END 125 -#endif - -/* - * Attaches a built-in HTTP event handler to the given connection. - * The user-defined event handler will receive following extra events: - * - * - MG_EV_HTTP_REQUEST: HTTP request has arrived. Parsed HTTP request - * is passed as - * `struct http_message` through the handler's `void *ev_data` pointer. - * - MG_EV_HTTP_REPLY: The HTTP reply has arrived. The parsed HTTP reply is - * passed as `struct http_message` through the handler's `void *ev_data` - * pointer. - * - MG_EV_HTTP_CHUNK: The HTTP chunked-encoding chunk has arrived. - * The parsed HTTP reply is passed as `struct http_message` through the - * handler's `void *ev_data` pointer. `http_message::body` would contain - * incomplete, reassembled HTTP body. - * It will grow with every new chunk that arrives, and it can - * potentially consume a lot of memory. An event handler may process - * the body as chunks are coming, and signal Mongoose to delete processed - * body by setting `MG_F_DELETE_CHUNK` in `mg_connection::flags`. When - * the last zero chunk is received, - * Mongoose sends `MG_EV_HTTP_REPLY` event with - * full reassembled body (if handler did not signal to delete chunks) or - * with empty body (if handler did signal to delete chunks). - * - MG_EV_WEBSOCKET_HANDSHAKE_REQUEST: server has received the WebSocket - * handshake request. `ev_data` contains parsed HTTP request. - * - MG_EV_WEBSOCKET_HANDSHAKE_DONE: server has completed the WebSocket - * handshake. `ev_data` is `NULL`. - * - MG_EV_WEBSOCKET_FRAME: new WebSocket frame has arrived. `ev_data` is - * `struct websocket_message *` - * - * When compiled with MG_ENABLE_HTTP_STREAMING_MULTIPART, Mongoose parses - * multipart requests and splits them into separate events: - * - MG_EV_HTTP_MULTIPART_REQUEST: Start of the request. - * This event is sent before body is parsed. After this, the user - * should expect a sequence of PART_BEGIN/DATA/END requests. - * This is also the last time when headers and other request fields are - * accessible. - * - MG_EV_HTTP_PART_BEGIN: Start of a part of a multipart message. - * Argument: mg_http_multipart_part with var_name and file_name set - * (if present). No data is passed in this message. - * - MG_EV_HTTP_PART_DATA: new portion of data from the multipart message. - * Argument: mg_http_multipart_part. var_name and file_name are preserved, - * data is available in mg_http_multipart_part.data. - * - MG_EV_HTTP_PART_END: End of the current part. var_name, file_name are - * the same, no data in the message. If status is 0, then the part is - * properly terminated with a boundary, status < 0 means that connection - * was terminated. - * - MG_EV_HTTP_MULTIPART_REQUEST_END: End of the multipart request. - * Argument: mg_http_multipart_part, var_name and file_name are NULL, - * status = 0 means request was properly closed, < 0 means connection - * was terminated (note: in this case both PART_END and REQUEST_END are - * delivered). - */ -void mg_set_protocol_http_websocket(struct mg_connection *nc); - -#if MG_ENABLE_HTTP_WEBSOCKET -/* - * Send websocket handshake to the server. - * - * `nc` must be a valid connection, connected to a server. `uri` is an URI - * to fetch, extra_headers` is extra HTTP headers to send or `NULL`. - * - * This function is intended to be used by websocket client. - * - * Note that the Host header is mandatory in HTTP/1.1 and must be - * included in `extra_headers`. `mg_send_websocket_handshake2` offers - * a better API for that. - * - * Deprecated in favour of `mg_send_websocket_handshake2` - */ -void mg_send_websocket_handshake(struct mg_connection *nc, const char *uri, - const char *extra_headers); - -/* - * Send websocket handshake to the server. - * - * `nc` must be a valid connection, connected to a server. `uri` is an URI - * to fetch, `host` goes into the `Host` header, `protocol` goes into the - * `Sec-WebSocket-Proto` header (NULL to omit), extra_headers` is extra HTTP - * headers to send or `NULL`. - * - * This function is intended to be used by websocket client. - */ -void mg_send_websocket_handshake2(struct mg_connection *nc, const char *path, - const char *host, const char *protocol, - const char *extra_headers); - -/* Like mg_send_websocket_handshake2 but also passes basic auth header */ -void mg_send_websocket_handshake3(struct mg_connection *nc, const char *path, - const char *host, const char *protocol, - const char *extra_headers, const char *user, - const char *pass); -/* - * Helper function that creates an outbound WebSocket connection. - * - * `url` is a URL to connect to. It must be properly URL-encoded, e.g. have - * no spaces, etc. By default, `mg_connect_ws()` sends Connection and - * Host headers. `extra_headers` is an extra HTTP header to send, e.g. - * `"User-Agent: my-app\r\n"`. - * If `protocol` is not NULL, then a `Sec-WebSocket-Protocol` header is sent. - * - * Examples: - * - * ```c - * nc1 = mg_connect_ws(mgr, ev_handler_1, "ws://echo.websocket.org", NULL, - * NULL); - * nc2 = mg_connect_ws(mgr, ev_handler_1, "wss://echo.websocket.org", NULL, - * NULL); - * nc3 = mg_connect_ws(mgr, ev_handler_1, "ws://api.cesanta.com", - * "clubby.cesanta.com", NULL); - * ``` - */ -struct mg_connection *mg_connect_ws(struct mg_mgr *mgr, - mg_event_handler_t event_handler, - const char *url, const char *protocol, - const char *extra_headers); - -/* - * Helper function that creates an outbound WebSocket connection - * - * Mostly identical to `mg_connect_ws`, but allows to provide extra parameters - * (for example, SSL parameters) - */ -struct mg_connection *mg_connect_ws_opt(struct mg_mgr *mgr, - mg_event_handler_t ev_handler, - struct mg_connect_opts opts, - const char *url, const char *protocol, - const char *extra_headers); - -/* - * Send WebSocket frame to the remote end. - * - * `op_and_flags` specifies the frame's type. It's one of: - * - * - WEBSOCKET_OP_CONTINUE - * - WEBSOCKET_OP_TEXT - * - WEBSOCKET_OP_BINARY - * - WEBSOCKET_OP_CLOSE - * - WEBSOCKET_OP_PING - * - WEBSOCKET_OP_PONG - * - * Orred with one of the flags: - * - * - WEBSOCKET_DONT_FIN: Don't set the FIN flag on the frame to be sent. - * - * `data` and `data_len` contain frame data. - */ -void mg_send_websocket_frame(struct mg_connection *nc, int op_and_flags, - const void *data, size_t data_len); - -/* - * Sends multiple websocket frames. - * - * Like `mg_send_websocket_frame()`, but composes a frame from multiple buffers. - */ -void mg_send_websocket_framev(struct mg_connection *nc, int op_and_flags, - const struct mg_str *strings, int num_strings); - -/* - * Sends WebSocket frame to the remote end. - * - * Like `mg_send_websocket_frame()`, but allows to create formatted messages - * with `printf()`-like semantics. - */ -void mg_printf_websocket_frame(struct mg_connection *nc, int op_and_flags, - const char *fmt, ...); - -/* Websocket opcodes, from http://tools.ietf.org/html/rfc6455 */ -#define WEBSOCKET_OP_CONTINUE 0 -#define WEBSOCKET_OP_TEXT 1 -#define WEBSOCKET_OP_BINARY 2 -#define WEBSOCKET_OP_CLOSE 8 -#define WEBSOCKET_OP_PING 9 -#define WEBSOCKET_OP_PONG 10 - -/* - * If set causes the FIN flag to not be set on outbound - * frames. This enables sending multiple fragments of a single - * logical message. - * - * The WebSocket protocol mandates that if the FIN flag of a data - * frame is not set, the next frame must be a WEBSOCKET_OP_CONTINUE. - * The last frame must have the FIN bit set. - * - * Note that mongoose will automatically defragment incoming messages, - * so this flag is used only on outbound messages. - */ -#define WEBSOCKET_DONT_FIN 0x100 - -#endif /* MG_ENABLE_HTTP_WEBSOCKET */ - -/* - * Decodes a URL-encoded string. - * - * Source string is specified by (`src`, `src_len`), and destination is - * (`dst`, `dst_len`). If `is_form_url_encoded` is non-zero, then - * `+` character is decoded as a blank space character. This function - * guarantees to NUL-terminate the destination. If destination is too small, - * then the source string is partially decoded and `-1` is returned. Otherwise, - * a length of the decoded string is returned, not counting final NUL. - */ -int mg_url_decode(const char *src, int src_len, char *dst, int dst_len, - int is_form_url_encoded); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_HTTP */ - -#endif /* CS_MONGOOSE_SRC_HTTP_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http_server.h" -#endif -/* - * === Server API reference - */ - -#ifndef CS_MONGOOSE_SRC_HTTP_SERVER_H_ -#define CS_MONGOOSE_SRC_HTTP_SERVER_H_ - -#if MG_ENABLE_HTTP - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* - * Parses a HTTP message. - * - * `is_req` should be set to 1 if parsing a request, 0 if reply. - * - * Returns the number of bytes parsed. If HTTP message is - * incomplete `0` is returned. On parse error, a negative number is returned. - */ -int mg_parse_http(const char *s, int n, struct http_message *hm, int is_req); - -/* - * Searches and returns the header `name` in parsed HTTP message `hm`. - * If header is not found, NULL is returned. Example: - * - * struct mg_str *host_hdr = mg_get_http_header(hm, "Host"); - */ -struct mg_str *mg_get_http_header(struct http_message *hm, const char *name); - -/* - * Parses the HTTP header `hdr`. Finds variable `var_name` and stores its value - * in the buffer `buf`, `buf_size`. Returns 0 if variable not found, non-zero - * otherwise. - * - * This function is supposed to parse cookies, authentication headers, etc. - * Example (error handling omitted): - * - * char user[20]; - * struct mg_str *hdr = mg_get_http_header(hm, "Authorization"); - * mg_http_parse_header(hdr, "username", user, sizeof(user)); - * - * Returns the length of the variable's value. If buffer is not large enough, - * or variable not found, 0 is returned. - */ -int mg_http_parse_header(struct mg_str *hdr, const char *var_name, char *buf, - size_t buf_size); - -/* - * Gets and parses the Authorization: Basic header - * Returns -1 if no Authorization header is found, or if - * mg_parse_http_basic_auth - * fails parsing the resulting header. - */ -int mg_get_http_basic_auth(struct http_message *hm, char *user, size_t user_len, - char *pass, size_t pass_len); - -/* - * Parses the Authorization: Basic header - * Returns -1 iif the authorization type is not "Basic" or any other error such - * as incorrectly encoded base64 user password pair. - */ -int mg_parse_http_basic_auth(struct mg_str *hdr, char *user, size_t user_len, - char *pass, size_t pass_len); - -/* - * Parses the buffer `buf`, `buf_len` that contains multipart form data chunks. - * Stores the chunk name in a `var_name`, `var_name_len` buffer. - * If a chunk is an uploaded file, then `file_name`, `file_name_len` is - * filled with an uploaded file name. `chunk`, `chunk_len` - * points to the chunk data. - * - * Return: number of bytes to skip to the next chunk or 0 if there are - * no more chunks. - * - * Usage example: - * - * ```c - * static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) { - * switch(ev) { - * case MG_EV_HTTP_REQUEST: { - * struct http_message *hm = (struct http_message *) ev_data; - * char var_name[100], file_name[100]; - * const char *chunk; - * size_t chunk_len, n1, n2; - * - * n1 = n2 = 0; - * while ((n2 = mg_parse_multipart(hm->body.p + n1, - * hm->body.len - n1, - * var_name, sizeof(var_name), - * file_name, sizeof(file_name), - * &chunk, &chunk_len)) > 0) { - * printf("var: %s, file_name: %s, size: %d, chunk: [%.*s]\n", - * var_name, file_name, (int) chunk_len, - * (int) chunk_len, chunk); - * n1 += n2; - * } - * } - * break; - * ``` - */ -size_t mg_parse_multipart(const char *buf, size_t buf_len, char *var_name, - size_t var_name_len, char *file_name, - size_t file_name_len, const char **chunk, - size_t *chunk_len); - -/* - * Fetches a HTTP form variable. - * - * Fetches a variable `name` from a `buf` into a buffer specified by `dst`, - * `dst_len`. The destination is always zero-terminated. Returns the length of - * a fetched variable. If not found, 0 is returned. `buf` must be valid - * url-encoded buffer. If destination is too small, `-1` is returned. - */ -int mg_get_http_var(const struct mg_str *buf, const char *name, char *dst, - size_t dst_len); - -#if MG_ENABLE_FILESYSTEM -/* - * This structure defines how `mg_serve_http()` works. - * Best practice is to set only required settings, and leave the rest as NULL. - */ -struct mg_serve_http_opts { - /* Path to web root directory */ - const char *document_root; - - /* List of index files. Default is "" */ - const char *index_files; - - /* - * Leave as NULL to disable authentication. - * To enable directory protection with authentication, set this to ".htpasswd" - * Then, creating ".htpasswd" file in any directory automatically protects - * it with digest authentication. - * Use `mongoose` web server binary, or `htdigest` Apache utility to - * create/manipulate passwords file. - * Make sure `auth_domain` is set to a valid domain name. - */ - const char *per_directory_auth_file; - - /* Authorization domain (domain name of this web server) */ - const char *auth_domain; - - /* - * Leave as NULL to disable authentication. - * Normally, only selected directories in the document root are protected. - * If absolutely every access to the web server needs to be authenticated, - * regardless of the URI, set this option to the path to the passwords file. - * Format of that file is the same as ".htpasswd" file. Make sure that file - * is located outside document root to prevent people fetching it. - */ - const char *global_auth_file; - - /* Set to "no" to disable directory listing. Enabled by default. */ - const char *enable_directory_listing; - - /* - * SSI files pattern. If not set, "**.shtml$|**.shtm$" is used. - * - * All files that match ssi_pattern are treated as SSI. - * - * Server Side Includes (SSI) is a simple interpreted server-side scripting - * language which is most commonly used to include the contents of a file - * into a web page. It can be useful when it is desirable to include a common - * piece of code throughout a website, for example, headers and footers. - * - * In order for a webpage to recognize an SSI-enabled HTML file, the - * filename should end with a special extension, by default the extension - * should be either .shtml or .shtm - * - * Unknown SSI directives are silently ignored by Mongoose. Currently, - * the following SSI directives are supported: - * <!--#include FILE_TO_INCLUDE --> - * <!--#exec "COMMAND_TO_EXECUTE" --> - * <!--#call COMMAND --> - * - * Note that <!--#include ...> directive supports three path - *specifications: - * - * <!--#include virtual="path" --> Path is relative to web server root - * <!--#include abspath="path" --> Path is absolute or relative to the - * web server working dir - * <!--#include file="path" -->, Path is relative to current document - * <!--#include "path" --> - * - * The include directive may be used to include the contents of a file or - * the result of running a CGI script. - * - * The exec directive is used to execute - * a command on a server, and show command's output. Example: - * - * <!--#exec "ls -l" --> - * - * The call directive is a way to invoke a C handler from the HTML page. - * On each occurence of <!--#call COMMAND OPTIONAL_PARAMS> directive, - * Mongoose calls a registered event handler with MG_EV_SSI_CALL event, - * and event parameter will point to the COMMAND OPTIONAL_PARAMS string. - * An event handler can output any text, for example by calling - * `mg_printf()`. This is a flexible way of generating a web page on - * server side by calling a C event handler. Example: - * - * <!--#call foo --> ... <!--#call bar --> - * - * In the event handler: - * case MG_EV_SSI_CALL: { - * const char *param = (const char *) ev_data; - * if (strcmp(param, "foo") == 0) { - * mg_printf(c, "hello from foo"); - * } else if (strcmp(param, "bar") == 0) { - * mg_printf(c, "hello from bar"); - * } - * break; - * } - */ - const char *ssi_pattern; - - /* IP ACL. By default, NULL, meaning all IPs are allowed to connect */ - const char *ip_acl; - -#if MG_ENABLE_HTTP_URL_REWRITES - /* URL rewrites. - * - * Comma-separated list of `uri_pattern=url_file_or_directory_path` rewrites. - * When HTTP request is received, Mongoose constructs a file name from the - * requested URI by combining `document_root` and the URI. However, if the - * rewrite option is used and `uri_pattern` matches requested URI, then - * `document_root` is ignored. Instead, `url_file_or_directory_path` is used, - * which should be a full path name or a path relative to the web server's - * current working directory. It can also be an URI (http:// or https://) - * in which case mongoose will behave as a reverse proxy for that destination. - * - * Note that `uri_pattern`, as all Mongoose patterns, is a prefix pattern. - * - * If uri_pattern starts with `@` symbol, then Mongoose compares it with the - * HOST header of the request. If they are equal, Mongoose sets document root - * to `file_or_directory_path`, implementing virtual hosts support. - * Example: `@foo.com=/document/root/for/foo.com` - * - * If `uri_pattern` starts with `%` symbol, then Mongoose compares it with - * the listening port. If they match, then Mongoose issues a 301 redirect. - * For example, to redirect all HTTP requests to the - * HTTPS port, do `%80=https://my.site.com`. Note that the request URI is - * automatically appended to the redirect location. - */ - const char *url_rewrites; -#endif - - /* DAV document root. If NULL, DAV requests are going to fail. */ - const char *dav_document_root; - - /* - * DAV passwords file. If NULL, DAV requests are going to fail. - * If passwords file is set to "-", then DAV auth is disabled. - */ - const char *dav_auth_file; - - /* Glob pattern for the files to hide. */ - const char *hidden_file_pattern; - - /* Set to non-NULL to enable CGI, e.g. **.cgi$|**.php$" */ - const char *cgi_file_pattern; - - /* If not NULL, ignore CGI script hashbang and use this interpreter */ - const char *cgi_interpreter; - - /* - * Comma-separated list of Content-Type overrides for path suffixes, e.g. - * ".txt=text/plain; charset=utf-8,.c=text/plain" - */ - const char *custom_mime_types; - - /* - * Extra HTTP headers to add to each server response. - * Example: to enable CORS, set this to "Access-Control-Allow-Origin: *". - */ - const char *extra_headers; -}; - -/* - * Serves given HTTP request according to the `options`. - * - * Example code snippet: - * - * ```c - * static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) { - * struct http_message *hm = (struct http_message *) ev_data; - * struct mg_serve_http_opts opts = { .document_root = "/var/www" }; // C99 - * - * switch (ev) { - * case MG_EV_HTTP_REQUEST: - * mg_serve_http(nc, hm, opts); - * break; - * default: - * break; - * } - * } - * ``` - */ -void mg_serve_http(struct mg_connection *nc, struct http_message *hm, - struct mg_serve_http_opts opts); - -/* - * Serves a specific file with a given MIME type and optional extra headers. - * - * Example code snippet: - * - * ```c - * static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) { - * switch (ev) { - * case MG_EV_HTTP_REQUEST: { - * struct http_message *hm = (struct http_message *) ev_data; - * mg_http_serve_file(nc, hm, "file.txt", - * mg_mk_str("text/plain"), mg_mk_str("")); - * break; - * } - * ... - * } - * } - * ``` - */ -void mg_http_serve_file(struct mg_connection *nc, struct http_message *hm, - const char *path, const struct mg_str mime_type, - const struct mg_str extra_headers); - -#if MG_ENABLE_HTTP_STREAMING_MULTIPART - -/* Callback prototype for `mg_file_upload_handler()`. */ -typedef struct mg_str (*mg_fu_fname_fn)(struct mg_connection *nc, - struct mg_str fname); - -/* - * File upload handler. - * This handler can be used to implement file uploads with minimum code. - * This handler will process MG_EV_HTTP_PART_* events and store file data into - * a local file. - * `local_name_fn` will be invoked with whatever name was provided by the client - * and will expect the name of the local file to open. A return value of NULL - * will abort file upload (client will get a "403 Forbidden" response). If - * non-null, the returned string must be heap-allocated and will be freed by - * the caller. - * Exception: it is ok to return the same string verbatim. - * - * Example: - * - * ```c - * struct mg_str upload_fname(struct mg_connection *nc, struct mg_str fname) { - * // Just return the same filename. Do not actually do this except in test! - * // fname is user-controlled and needs to be sanitized. - * return fname; - * } - * void ev_handler(struct mg_connection *nc, int ev, void *ev_data) { - * switch (ev) { - * ... - * case MG_EV_HTTP_PART_BEGIN: - * case MG_EV_HTTP_PART_DATA: - * case MG_EV_HTTP_PART_END: - * mg_file_upload_handler(nc, ev, ev_data, upload_fname); - * break; - * } - * } - * ``` - */ -void mg_file_upload_handler(struct mg_connection *nc, int ev, void *ev_data, - mg_fu_fname_fn local_name_fn); -#endif /* MG_ENABLE_HTTP_STREAMING_MULTIPART */ -#endif /* MG_ENABLE_FILESYSTEM */ - -/* - * Registers a callback for a specified http endpoint - * Note: if callback is registered it is called instead of the - * callback provided in mg_bind - * - * Example code snippet: - * - * ```c - * static void handle_hello1(struct mg_connection *nc, int ev, void *ev_data) { - * (void) ev; (void) ev_data; - * mg_printf(nc, "HTTP/1.0 200 OK\r\n\r\n[I am Hello1]"); - * nc->flags |= MG_F_SEND_AND_CLOSE; - * } - * - * static void handle_hello1(struct mg_connection *nc, int ev, void *ev_data) { - * (void) ev; (void) ev_data; - * mg_printf(nc, "HTTP/1.0 200 OK\r\n\r\n[I am Hello2]"); - * nc->flags |= MG_F_SEND_AND_CLOSE; - * } - * - * void init() { - * nc = mg_bind(&mgr, local_addr, cb1); - * mg_register_http_endpoint(nc, "/hello1", handle_hello1); - * mg_register_http_endpoint(nc, "/hello1/hello2", handle_hello2); - * } - * ``` - */ -void mg_register_http_endpoint(struct mg_connection *nc, const char *uri_path, - mg_event_handler_t handler); - -/* - * Authenticates a HTTP request against an opened password file. - * Returns 1 if authenticated, 0 otherwise. - */ -int mg_http_check_digest_auth(struct http_message *hm, const char *auth_domain, - FILE *fp); - -/* - * Sends buffer `buf` of size `len` to the client using chunked HTTP encoding. - * This function sends the buffer size as hex number + newline first, then - * the buffer itself, then the newline. For example, - * `mg_send_http_chunk(nc, "foo", 3)` whill append the `3\r\nfoo\r\n` string - * to the `nc->send_mbuf` output IO buffer. - * - * NOTE: The HTTP header "Transfer-Encoding: chunked" should be sent prior to - * using this function. - * - * NOTE: do not forget to send an empty chunk at the end of the response, - * to tell the client that everything was sent. Example: - * - * ``` - * mg_printf_http_chunk(nc, "%s", "my response!"); - * mg_send_http_chunk(nc, "", 0); // Tell the client we're finished - * ``` - */ -void mg_send_http_chunk(struct mg_connection *nc, const char *buf, size_t len); - -/* - * Sends a printf-formatted HTTP chunk. - * Functionality is similar to `mg_send_http_chunk()`. - */ -void mg_printf_http_chunk(struct mg_connection *nc, const char *fmt, ...); - -/* - * Sends the response status line. - * If `extra_headers` is not NULL, then `extra_headers` are also sent - * after the reponse line. `extra_headers` must NOT end end with new line. - * Example: - * - * mg_send_response_line(nc, 200, "Access-Control-Allow-Origin: *"); - * - * Will result in: - * - * HTTP/1.1 200 OK\r\n - * Access-Control-Allow-Origin: *\r\n - */ -void mg_send_response_line(struct mg_connection *nc, int status_code, - const char *extra_headers); - -/* - * Sends an error response. If reason is NULL, the message will be inferred - * from the error code (if supported). - */ -void mg_http_send_error(struct mg_connection *nc, int code, const char *reason); - -/* - * Sends a redirect response. - * `status_code` should be either 301 or 302 and `location` point to the - * new location. - * If `extra_headers` is not empty, then `extra_headers` are also sent - * after the reponse line. `extra_headers` must NOT end end with new line. - * - * Example: - * - * mg_http_send_redirect(nc, 302, mg_mk_str("/login"), mg_mk_str(NULL)); - */ -void mg_http_send_redirect(struct mg_connection *nc, int status_code, - const struct mg_str location, - const struct mg_str extra_headers); - -/* - * Sends the response line and headers. - * This function sends the response line with the `status_code`, and - * automatically - * sends one header: either "Content-Length" or "Transfer-Encoding". - * If `content_length` is negative, then "Transfer-Encoding: chunked" header - * is sent, otherwise, "Content-Length" header is sent. - * - * NOTE: If `Transfer-Encoding` is `chunked`, then message body must be sent - * using `mg_send_http_chunk()` or `mg_printf_http_chunk()` functions. - * Otherwise, `mg_send()` or `mg_printf()` must be used. - * Extra headers could be set through `extra_headers`. Note `extra_headers` - * must NOT be terminated by a new line. - */ -void mg_send_head(struct mg_connection *n, int status_code, - int64_t content_length, const char *extra_headers); - -/* - * Sends a printf-formatted HTTP chunk, escaping HTML tags. - */ -void mg_printf_html_escape(struct mg_connection *nc, const char *fmt, ...); - -#if MG_ENABLE_HTTP_URL_REWRITES -/* - * Proxies a given request to a given upstream http server. The path prefix - * in `mount` will be stripped of the path requested to the upstream server, - * e.g. if mount is /api and upstream is http://localhost:8001/foo - * then an incoming request to /api/bar will cause a request to - * http://localhost:8001/foo/bar - * - * EXPERIMENTAL API. Please use http_serve_http + url_rewrites if a static - * mapping is good enough. - */ -void mg_http_reverse_proxy(struct mg_connection *nc, - const struct http_message *hm, struct mg_str mount, - struct mg_str upstream); -#endif - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_HTTP */ - -#endif /* CS_MONGOOSE_SRC_HTTP_SERVER_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/http_client.h" -#endif -/* - * === Client API reference - */ - -#ifndef CS_MONGOOSE_SRC_HTTP_CLIENT_H_ -#define CS_MONGOOSE_SRC_HTTP_CLIENT_H_ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* - * Helper function that creates an outbound HTTP connection. - * - * `url` is the URL to fetch. It must be properly URL-encoded, e.g. have - * no spaces, etc. By default, `mg_connect_http()` sends the Connection and - * Host headers. `extra_headers` is an extra HTTP header to send, e.g. - * `"User-Agent: my-app\r\n"`. - * If `post_data` is NULL, then a GET request is created. Otherwise, a POST - * request is created with the specified POST data. Note that if the data being - * posted is a form submission, the `Content-Type` header should be set - * accordingly (see example below). - * - * Examples: - * - * ```c - * nc1 = mg_connect_http(mgr, ev_handler_1, "http://www.google.com", NULL, - * NULL); - * nc2 = mg_connect_http(mgr, ev_handler_1, "https://github.com", NULL, NULL); - * nc3 = mg_connect_http( - * mgr, ev_handler_1, "my_server:8000/form_submit/", - * "Content-Type: application/x-www-form-urlencoded\r\n", - * "var_1=value_1&var_2=value_2"); - * ``` - */ -struct mg_connection *mg_connect_http(struct mg_mgr *mgr, - mg_event_handler_t event_handler, - const char *url, - const char *extra_headers, - const char *post_data); - -/* - * Helper function that creates an outbound HTTP connection. - * - * Mostly identical to mg_connect_http, but allows you to provide extra - *parameters - * (for example, SSL parameters) - */ -struct mg_connection *mg_connect_http_opt(struct mg_mgr *mgr, - mg_event_handler_t ev_handler, - struct mg_connect_opts opts, - const char *url, - const char *extra_headers, - const char *post_data); - -/* Creates digest authentication header for a client request. */ -int mg_http_create_digest_auth_header(char *buf, size_t buf_len, - const char *method, const char *uri, - const char *auth_domain, const char *user, - const char *passwd); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ -#endif /* CS_MONGOOSE_SRC_HTTP_CLIENT_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/mqtt.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - * This software is dual-licensed: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. For the terms of this - * license, see . - * - * You are free to use this software under the terms of the GNU General - * Public License, but WITHOUT ANY WARRANTY; without even the implied - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * Alternatively, you can license this software under a commercial - * license, as set out in . - */ - -/* - * === MQTT API reference - */ - -#ifndef CS_MONGOOSE_SRC_MQTT_H_ -#define CS_MONGOOSE_SRC_MQTT_H_ - -/* Amalgamated: #include "mongoose/src/net.h" */ - -struct mg_mqtt_message { - int cmd; - int qos; - struct mg_str topic; - struct mg_str payload; - - uint8_t connack_ret_code; /* connack */ - uint16_t message_id; /* puback */ - - /* connect */ - uint8_t protocol_version; - uint8_t connect_flags; - uint16_t keep_alive_timer; - struct mg_str protocol_name; - struct mg_str client_id; - struct mg_str will_topic; - struct mg_str will_message; - struct mg_str user_name; - struct mg_str password; -}; - -struct mg_mqtt_topic_expression { - const char *topic; - uint8_t qos; -}; - -struct mg_send_mqtt_handshake_opts { - unsigned char flags; /* connection flags */ - uint16_t keep_alive; - const char *will_topic; - const char *will_message; - const char *user_name; - const char *password; -}; - -/* mg_mqtt_proto_data should be in header to allow external access to it */ -struct mg_mqtt_proto_data { - uint16_t keep_alive; -}; - -/* Message types */ -#define MG_MQTT_CMD_CONNECT 1 -#define MG_MQTT_CMD_CONNACK 2 -#define MG_MQTT_CMD_PUBLISH 3 -#define MG_MQTT_CMD_PUBACK 4 -#define MG_MQTT_CMD_PUBREC 5 -#define MG_MQTT_CMD_PUBREL 6 -#define MG_MQTT_CMD_PUBCOMP 7 -#define MG_MQTT_CMD_SUBSCRIBE 8 -#define MG_MQTT_CMD_SUBACK 9 -#define MG_MQTT_CMD_UNSUBSCRIBE 10 -#define MG_MQTT_CMD_UNSUBACK 11 -#define MG_MQTT_CMD_PINGREQ 12 -#define MG_MQTT_CMD_PINGRESP 13 -#define MG_MQTT_CMD_DISCONNECT 14 - -/* MQTT event types */ -#define MG_MQTT_EVENT_BASE 200 -#define MG_EV_MQTT_CONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNECT) -#define MG_EV_MQTT_CONNACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNACK) -#define MG_EV_MQTT_PUBLISH (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBLISH) -#define MG_EV_MQTT_PUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBACK) -#define MG_EV_MQTT_PUBREC (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREC) -#define MG_EV_MQTT_PUBREL (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREL) -#define MG_EV_MQTT_PUBCOMP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBCOMP) -#define MG_EV_MQTT_SUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBSCRIBE) -#define MG_EV_MQTT_SUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBACK) -#define MG_EV_MQTT_UNSUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBSCRIBE) -#define MG_EV_MQTT_UNSUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBACK) -#define MG_EV_MQTT_PINGREQ (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGREQ) -#define MG_EV_MQTT_PINGRESP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGRESP) -#define MG_EV_MQTT_DISCONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_DISCONNECT) - -/* Message flags */ -#define MG_MQTT_RETAIN 0x1 -#define MG_MQTT_DUP 0x4 -#define MG_MQTT_QOS(qos) ((qos) << 1) -#define MG_MQTT_GET_QOS(flags) (((flags) &0x6) >> 1) -#define MG_MQTT_SET_QOS(flags, qos) (flags) = ((flags) & ~0x6) | ((qos) << 1) - -/* Connection flags */ -#define MG_MQTT_CLEAN_SESSION 0x02 -#define MG_MQTT_HAS_WILL 0x04 -#define MG_MQTT_WILL_RETAIN 0x20 -#define MG_MQTT_HAS_PASSWORD 0x40 -#define MG_MQTT_HAS_USER_NAME 0x80 -#define MG_MQTT_GET_WILL_QOS(flags) (((flags) &0x18) >> 3) -#define MG_MQTT_SET_WILL_QOS(flags, qos) \ - (flags) = ((flags) & ~0x18) | ((qos) << 3) - -/* CONNACK return codes */ -#define MG_EV_MQTT_CONNACK_ACCEPTED 0 -#define MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION 1 -#define MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED 2 -#define MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE 3 -#define MG_EV_MQTT_CONNACK_BAD_AUTH 4 -#define MG_EV_MQTT_CONNACK_NOT_AUTHORIZED 5 - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* - * Attaches a built-in MQTT event handler to the given connection. - * - * The user-defined event handler will receive following extra events: - * - * - MG_EV_MQTT_CONNACK - * - MG_EV_MQTT_PUBLISH - * - MG_EV_MQTT_PUBACK - * - MG_EV_MQTT_PUBREC - * - MG_EV_MQTT_PUBREL - * - MG_EV_MQTT_PUBCOMP - * - MG_EV_MQTT_SUBACK - */ -void mg_set_protocol_mqtt(struct mg_connection *nc); - -/* Sends an MQTT handshake. */ -void mg_send_mqtt_handshake(struct mg_connection *nc, const char *client_id); - -/* Sends an MQTT handshake with optional parameters. */ -void mg_send_mqtt_handshake_opt(struct mg_connection *nc, const char *client_id, - struct mg_send_mqtt_handshake_opts); - -/* Publishes a message to a given topic. */ -void mg_mqtt_publish(struct mg_connection *nc, const char *topic, - uint16_t message_id, int flags, const void *data, - size_t len); - -/* Subscribes to a bunch of topics. */ -void mg_mqtt_subscribe(struct mg_connection *nc, - const struct mg_mqtt_topic_expression *topics, - size_t topics_len, uint16_t message_id); - -/* Unsubscribes from a bunch of topics. */ -void mg_mqtt_unsubscribe(struct mg_connection *nc, char **topics, - size_t topics_len, uint16_t message_id); - -/* Sends a DISCONNECT command. */ -void mg_mqtt_disconnect(struct mg_connection *nc); - -/* Sends a CONNACK command with a given `return_code`. */ -void mg_mqtt_connack(struct mg_connection *nc, uint8_t return_code); - -/* Sends a PUBACK command with a given `message_id`. */ -void mg_mqtt_puback(struct mg_connection *nc, uint16_t message_id); - -/* Sends a PUBREC command with a given `message_id`. */ -void mg_mqtt_pubrec(struct mg_connection *nc, uint16_t message_id); - -/* Sends a PUBREL command with a given `message_id`. */ -void mg_mqtt_pubrel(struct mg_connection *nc, uint16_t message_id); - -/* Sends a PUBCOMP command with a given `message_id`. */ -void mg_mqtt_pubcomp(struct mg_connection *nc, uint16_t message_id); - -/* - * Sends a SUBACK command with a given `message_id` - * and a sequence of granted QoSs. - */ -void mg_mqtt_suback(struct mg_connection *nc, uint8_t *qoss, size_t qoss_len, - uint16_t message_id); - -/* Sends a UNSUBACK command with a given `message_id`. */ -void mg_mqtt_unsuback(struct mg_connection *nc, uint16_t message_id); - -/* Sends a PINGREQ command. */ -void mg_mqtt_ping(struct mg_connection *nc); - -/* Sends a PINGRESP command. */ -void mg_mqtt_pong(struct mg_connection *nc); - -/* - * Extracts the next topic expression from a SUBSCRIBE command payload. - * - * The topic expression name will point to a string in the payload buffer. - * Returns the pos of the next topic expression or -1 when the list - * of topics is exhausted. - */ -int mg_mqtt_next_subscribe_topic(struct mg_mqtt_message *msg, - struct mg_str *topic, uint8_t *qos, int pos); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* CS_MONGOOSE_SRC_MQTT_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/mqtt_server.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - * This software is dual-licensed: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. For the terms of this - * license, see . - * - * You are free to use this software under the terms of the GNU General - * Public License, but WITHOUT ANY WARRANTY; without even the implied - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * Alternatively, you can license this software under a commercial - * license, as set out in . - */ - -/* - * === MQTT Server API reference - */ - -#ifndef CS_MONGOOSE_SRC_MQTT_BROKER_H_ -#define CS_MONGOOSE_SRC_MQTT_BROKER_H_ - -#if MG_ENABLE_MQTT_BROKER - -/* Amalgamated: #include "common/queue.h" */ -/* Amalgamated: #include "mongoose/src/mqtt.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#define MG_MQTT_MAX_SESSION_SUBSCRIPTIONS 512; - -struct mg_mqtt_broker; - -/* MQTT session (Broker side). */ -struct mg_mqtt_session { - struct mg_mqtt_broker *brk; /* Broker */ - LIST_ENTRY(mg_mqtt_session) link; /* mg_mqtt_broker::sessions linkage */ - struct mg_connection *nc; /* Connection with the client */ - size_t num_subscriptions; /* Size of `subscriptions` array */ - void *user_data; /* User data */ - struct mg_mqtt_topic_expression *subscriptions; -}; - -/* MQTT broker. */ -struct mg_mqtt_broker { - LIST_HEAD(_mg_sesshead, mg_mqtt_session) sessions; /* Session list */ - void *user_data; /* User data */ -}; - -/* Initialises a MQTT broker. */ -void mg_mqtt_broker_init(struct mg_mqtt_broker *brk, void *user_data); - -/* - * Processes a MQTT broker message. - * - * The listening connection expects a pointer to an initialised - * `mg_mqtt_broker` structure in the `user_data` field. - * - * Basic usage: - * - * ```c - * mg_mqtt_broker_init(&brk, NULL); - * - * if ((nc = mg_bind(&mgr, address, mg_mqtt_broker)) == NULL) { - * // fail; - * } - * nc->user_data = &brk; - * ``` - * - * New incoming connections will receive a `mg_mqtt_session` structure - * in the connection `user_data`. The original `user_data` will be stored - * in the `user_data` field of the session structure. This allows the user - * handler to store user data before `mg_mqtt_broker` creates the session. - * - * Since only the MG_EV_ACCEPT message is processed by the listening socket, - * for most events the `user_data` will thus point to a `mg_mqtt_session`. - */ -void mg_mqtt_broker(struct mg_connection *brk, int ev, void *data); - -/* - * Iterates over all MQTT session connections. Example: - * - * ```c - * struct mg_mqtt_session *s; - * for (s = mg_mqtt_next(brk, NULL); s != NULL; s = mg_mqtt_next(brk, s)) { - * // Do something - * } - * ``` - */ -struct mg_mqtt_session *mg_mqtt_next(struct mg_mqtt_broker *brk, - struct mg_mqtt_session *s); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_MQTT_BROKER */ -#endif /* CS_MONGOOSE_SRC_MQTT_BROKER_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/dns.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* - * === DNS API reference - */ - -#ifndef CS_MONGOOSE_SRC_DNS_H_ -#define CS_MONGOOSE_SRC_DNS_H_ - -/* Amalgamated: #include "mongoose/src/net.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#define MG_DNS_A_RECORD 0x01 /* Lookup IP address */ -#define MG_DNS_CNAME_RECORD 0x05 /* Lookup CNAME */ -#define MG_DNS_PTR_RECORD 0x0c /* Lookup PTR */ -#define MG_DNS_TXT_RECORD 0x10 /* Lookup TXT */ -#define MG_DNS_AAAA_RECORD 0x1c /* Lookup IPv6 address */ -#define MG_DNS_SRV_RECORD 0x21 /* Lookup SRV */ -#define MG_DNS_MX_RECORD 0x0f /* Lookup mail server for domain */ - -#define MG_MAX_DNS_QUESTIONS 32 -#define MG_MAX_DNS_ANSWERS 32 - -#define MG_DNS_MESSAGE 100 /* High-level DNS message event */ - -enum mg_dns_resource_record_kind { - MG_DNS_INVALID_RECORD = 0, - MG_DNS_QUESTION, - MG_DNS_ANSWER -}; - -/* DNS resource record. */ -struct mg_dns_resource_record { - struct mg_str name; /* buffer with compressed name */ - int rtype; - int rclass; - int ttl; - enum mg_dns_resource_record_kind kind; - struct mg_str rdata; /* protocol data (can be a compressed name) */ -}; - -/* DNS message (request and response). */ -struct mg_dns_message { - struct mg_str pkt; /* packet body */ - uint16_t flags; - uint16_t transaction_id; - int num_questions; - int num_answers; - struct mg_dns_resource_record questions[MG_MAX_DNS_QUESTIONS]; - struct mg_dns_resource_record answers[MG_MAX_DNS_ANSWERS]; -}; - -struct mg_dns_resource_record *mg_dns_next_record( - struct mg_dns_message *msg, int query, struct mg_dns_resource_record *prev); - -/* - * Parses the record data from a DNS resource record. - * - * - A: struct in_addr *ina - * - AAAA: struct in6_addr *ina - * - CNAME: char buffer - * - * Returns -1 on error. - * - * TODO(mkm): MX - */ -int mg_dns_parse_record_data(struct mg_dns_message *msg, - struct mg_dns_resource_record *rr, void *data, - size_t data_len); - -/* - * Sends a DNS query to the remote end. - */ -void mg_send_dns_query(struct mg_connection *nc, const char *name, - int query_type); - -/* - * Inserts a DNS header to an IO buffer. - * - * Returns the number of bytes inserted. - */ -int mg_dns_insert_header(struct mbuf *io, size_t pos, - struct mg_dns_message *msg); - -/* - * Appends already encoded questions from an existing message. - * - * This is useful when generating a DNS reply message which includes - * all question records. - * - * Returns the number of appended bytes. - */ -int mg_dns_copy_questions(struct mbuf *io, struct mg_dns_message *msg); - -/* - * Encodes and appends a DNS resource record to an IO buffer. - * - * The record metadata is taken from the `rr` parameter, while the name and data - * are taken from the parameters, encoded in the appropriate format depending on - * record type and stored in the IO buffer. The encoded values might contain - * offsets within the IO buffer. It's thus important that the IO buffer doesn't - * get trimmed while a sequence of records are encoded while preparing a DNS - * reply. - * - * This function doesn't update the `name` and `rdata` pointers in the `rr` - * struct because they might be invalidated as soon as the IO buffer grows - * again. - * - * Returns the number of bytes appened or -1 in case of error. - */ -int mg_dns_encode_record(struct mbuf *io, struct mg_dns_resource_record *rr, - const char *name, size_t nlen, const void *rdata, - size_t rlen); - -/* - * Encodes a DNS name. - */ -int mg_dns_encode_name(struct mbuf *io, const char *name, size_t len); - -/* Low-level: parses a DNS response. */ -int mg_parse_dns(const char *buf, int len, struct mg_dns_message *msg); - -/* - * Uncompresses a DNS compressed name. - * - * The containing DNS message is required because of the compressed encoding - * and reference suffixes present elsewhere in the packet. - * - * If the name is less than `dst_len` characters long, the remainder - * of `dst` is terminated with `\0` characters. Otherwise, `dst` is not - * terminated. - * - * If `dst_len` is 0 `dst` can be NULL. - * Returns the uncompressed name length. - */ -size_t mg_dns_uncompress_name(struct mg_dns_message *msg, struct mg_str *name, - char *dst, int dst_len); - -/* - * Attaches a built-in DNS event handler to the given listening connection. - * - * The DNS event handler parses the incoming UDP packets, treating them as DNS - * requests. If an incoming packet gets successfully parsed by the DNS event - * handler, a user event handler will receive an `MG_DNS_REQUEST` event, with - * `ev_data` pointing to the parsed `struct mg_dns_message`. - * - * See - * [captive_dns_server](https://github.com/cesanta/mongoose/tree/master/examples/captive_dns_server) - * example on how to handle DNS request and send DNS reply. - */ -void mg_set_protocol_dns(struct mg_connection *nc); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ -#endif /* CS_MONGOOSE_SRC_DNS_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/dns_server.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* - * === DNS server API reference - * - * Disabled by default; enable with `-DMG_ENABLE_DNS_SERVER`. - */ - -#ifndef CS_MONGOOSE_SRC_DNS_SERVER_H_ -#define CS_MONGOOSE_SRC_DNS_SERVER_H_ - -#if MG_ENABLE_DNS_SERVER - -/* Amalgamated: #include "mongoose/src/dns.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#define MG_DNS_SERVER_DEFAULT_TTL 3600 - -struct mg_dns_reply { - struct mg_dns_message *msg; - struct mbuf *io; - size_t start; -}; - -/* - * Creates a DNS reply. - * - * The reply will be based on an existing query message `msg`. - * The query body will be appended to the output buffer. - * "reply + recursion allowed" will be added to the message flags and the - * message's num_answers will be set to 0. - * - * Answer records can be appended with `mg_dns_send_reply` or by lower - * level function defined in the DNS API. - * - * In order to send a reply use `mg_dns_send_reply`. - * It's possible to use a connection's send buffer as reply buffer, - * and it will work for both UDP and TCP connections. - * - * Example: - * - * ```c - * reply = mg_dns_create_reply(&nc->send_mbuf, msg); - * for (i = 0; i < msg->num_questions; i++) { - * rr = &msg->questions[i]; - * if (rr->rtype == MG_DNS_A_RECORD) { - * mg_dns_reply_record(&reply, rr, 3600, &dummy_ip_addr, 4); - * } - * } - * mg_dns_send_reply(nc, &reply); - * ``` - */ -struct mg_dns_reply mg_dns_create_reply(struct mbuf *io, - struct mg_dns_message *msg); - -/* - * Appends a DNS reply record to the IO buffer and to the DNS message. - * - * The message's num_answers field will be incremented. It's the caller's duty - * to ensure num_answers is properly initialised. - * - * Returns -1 on error. - */ -int mg_dns_reply_record(struct mg_dns_reply *reply, - struct mg_dns_resource_record *question, - const char *name, int rtype, int ttl, const void *rdata, - size_t rdata_len); - -/* - * Sends a DNS reply through a connection. - * - * The DNS data is stored in an IO buffer pointed by reply structure in `r`. - * This function mutates the content of that buffer in order to ensure that - * the DNS header reflects the size and flags of the message, that might have - * been updated either with `mg_dns_reply_record` or by direct manipulation of - * `r->message`. - * - * Once sent, the IO buffer will be trimmed unless the reply IO buffer - * is the connection's send buffer and the connection is not in UDP mode. - */ -void mg_dns_send_reply(struct mg_connection *nc, struct mg_dns_reply *r); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_DNS_SERVER */ -#endif /* CS_MONGOOSE_SRC_DNS_SERVER_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/resolv.h" -#endif -/* - * Copyright (c) 2014 Cesanta Software Limited - * All rights reserved - */ - -/* - * === API reference - */ - -#ifndef CS_MONGOOSE_SRC_RESOLV_H_ -#define CS_MONGOOSE_SRC_RESOLV_H_ - -/* Amalgamated: #include "mongoose/src/dns.h" */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -enum mg_resolve_err { - MG_RESOLVE_OK = 0, - MG_RESOLVE_NO_ANSWERS = 1, - MG_RESOLVE_EXCEEDED_RETRY_COUNT = 2, - MG_RESOLVE_TIMEOUT = 3 -}; - -typedef void (*mg_resolve_callback_t)(struct mg_dns_message *dns_message, - void *user_data, enum mg_resolve_err); - -/* Options for `mg_resolve_async_opt`. */ -struct mg_resolve_async_opts { - const char *nameserver_url; - int max_retries; /* defaults to 2 if zero */ - int timeout; /* in seconds; defaults to 5 if zero */ - int accept_literal; /* pseudo-resolve literal ipv4 and ipv6 addrs */ - int only_literal; /* only resolves literal addrs; sync cb invocation */ - struct mg_connection **dns_conn; /* return DNS connection */ -}; - -/* See `mg_resolve_async_opt()` */ -int mg_resolve_async(struct mg_mgr *mgr, const char *name, int query, - mg_resolve_callback_t cb, void *data); - -/* - * Resolved a DNS name asynchronously. - * - * Upon successful resolution, the user callback will be invoked - * with the full DNS response message and a pointer to the user's - * context `data`. - * - * In case of timeout while performing the resolution the callback - * will receive a NULL `msg`. - * - * The DNS answers can be extracted with `mg_next_record` and - * `mg_dns_parse_record_data`: - * - * [source,c] - * ---- - * struct in_addr ina; - * struct mg_dns_resource_record *rr = mg_next_record(msg, MG_DNS_A_RECORD, - * NULL); - * mg_dns_parse_record_data(msg, rr, &ina, sizeof(ina)); - * ---- - */ -int mg_resolve_async_opt(struct mg_mgr *mgr, const char *name, int query, - mg_resolve_callback_t cb, void *data, - struct mg_resolve_async_opts opts); - -/* - * Resolve a name from `/etc/hosts`. - * - * Returns 0 on success, -1 on failure. - */ -int mg_resolve_from_hosts_file(const char *host, union socket_address *usa); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ -#endif /* CS_MONGOOSE_SRC_RESOLV_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/coap.h" -#endif -/* - * Copyright (c) 2015 Cesanta Software Limited - * All rights reserved - * This software is dual-licensed: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. For the terms of this - * license, see . - * - * You are free to use this software under the terms of the GNU General - * Public License, but WITHOUT ANY WARRANTY; without even the implied - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * Alternatively, you can license this software under a commercial - * license, as set out in . - */ - -/* - * === CoAP API reference - * - * CoAP message format: - * - * ``` - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- - * |Ver| T | TKL | Code | Message ID | Token (if any, TKL bytes) ... - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- - * | Options (if any) ... |1 1 1 1 1 1 1 1| Payload (if any) ... - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- - * ``` - */ - -#ifndef CS_MONGOOSE_SRC_COAP_H_ -#define CS_MONGOOSE_SRC_COAP_H_ - -#if MG_ENABLE_COAP - -#define MG_COAP_MSG_TYPE_FIELD 0x2 -#define MG_COAP_CODE_CLASS_FIELD 0x4 -#define MG_COAP_CODE_DETAIL_FIELD 0x8 -#define MG_COAP_MSG_ID_FIELD 0x10 -#define MG_COAP_TOKEN_FIELD 0x20 -#define MG_COAP_OPTIOMG_FIELD 0x40 -#define MG_COAP_PAYLOAD_FIELD 0x80 - -#define MG_COAP_ERROR 0x10000 -#define MG_COAP_FORMAT_ERROR (MG_COAP_ERROR | 0x20000) -#define MG_COAP_IGNORE (MG_COAP_ERROR | 0x40000) -#define MG_COAP_NOT_ENOUGH_DATA (MG_COAP_ERROR | 0x80000) -#define MG_COAP_NETWORK_ERROR (MG_COAP_ERROR | 0x100000) - -#define MG_COAP_MSG_CON 0 -#define MG_COAP_MSG_NOC 1 -#define MG_COAP_MSG_ACK 2 -#define MG_COAP_MSG_RST 3 -#define MG_COAP_MSG_MAX 3 - -#define MG_COAP_CODECLASS_REQUEST 0 -#define MG_COAP_CODECLASS_RESP_OK 2 -#define MG_COAP_CODECLASS_CLIENT_ERR 4 -#define MG_COAP_CODECLASS_SRV_ERR 5 - -#define MG_COAP_EVENT_BASE 300 -#define MG_EV_COAP_CON (MG_COAP_EVENT_BASE + MG_COAP_MSG_CON) -#define MG_EV_COAP_NOC (MG_COAP_EVENT_BASE + MG_COAP_MSG_NOC) -#define MG_EV_COAP_ACK (MG_COAP_EVENT_BASE + MG_COAP_MSG_ACK) -#define MG_EV_COAP_RST (MG_COAP_EVENT_BASE + MG_COAP_MSG_RST) - -/* - * CoAP options. - * Use mg_coap_add_option and mg_coap_free_options - * for creation and destruction. - */ -struct mg_coap_option { - struct mg_coap_option *next; - uint32_t number; - struct mg_str value; -}; - -/* CoAP message. See RFC 7252 for details. */ -struct mg_coap_message { - uint32_t flags; - uint8_t msg_type; - uint8_t code_class; - uint8_t code_detail; - uint16_t msg_id; - struct mg_str token; - struct mg_coap_option *options; - struct mg_str payload; - struct mg_coap_option *optiomg_tail; -}; - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* Sets CoAP protocol handler - triggers CoAP specific events. */ -int mg_set_protocol_coap(struct mg_connection *nc); - -/* - * Adds a new option to mg_coap_message structure. - * Returns pointer to the newly created option. - * Note: options must be freed by using mg_coap_free_options - */ -struct mg_coap_option *mg_coap_add_option(struct mg_coap_message *cm, - uint32_t number, char *value, - size_t len); - -/* - * Frees the memory allocated for options. - * If the cm paramater doesn't contain any option it does nothing. - */ -void mg_coap_free_options(struct mg_coap_message *cm); - -/* - * Composes a CoAP message from `mg_coap_message` - * and sends it into `nc` connection. - * Returns 0 on success. On error, it is a bitmask: - * - * - `#define MG_COAP_ERROR 0x10000` - * - `#define MG_COAP_FORMAT_ERROR (MG_COAP_ERROR | 0x20000)` - * - `#define MG_COAP_IGNORE (MG_COAP_ERROR | 0x40000)` - * - `#define MG_COAP_NOT_ENOUGH_DATA (MG_COAP_ERROR | 0x80000)` - * - `#define MG_COAP_NETWORK_ERROR (MG_COAP_ERROR | 0x100000)` - */ -uint32_t mg_coap_send_message(struct mg_connection *nc, - struct mg_coap_message *cm); - -/* - * Composes CoAP acknowledgement from `mg_coap_message` - * and sends it into `nc` connection. - * Return value: see `mg_coap_send_message()` - */ -uint32_t mg_coap_send_ack(struct mg_connection *nc, uint16_t msg_id); - -/* - * Parses CoAP message and fills mg_coap_message and returns cm->flags. - * This is a helper function. - * - * NOTE: usually CoAP works over UDP, so lack of data means format error. - * But, in theory, it is possible to use CoAP over TCP (according to RFC) - * - * The caller has to check results and treat COAP_NOT_ENOUGH_DATA according to - * underlying protocol: - * - * - in case of UDP COAP_NOT_ENOUGH_DATA means COAP_FORMAT_ERROR, - * - in case of TCP client can try to receive more data - * - * Return value: see `mg_coap_send_message()` - */ -uint32_t mg_coap_parse(struct mbuf *io, struct mg_coap_message *cm); - -/* - * Composes CoAP message from mg_coap_message structure. - * This is a helper function. - * Return value: see `mg_coap_send_message()` - */ -uint32_t mg_coap_compose(struct mg_coap_message *cm, struct mbuf *io); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* MG_ENABLE_COAP */ - -#endif /* CS_MONGOOSE_SRC_COAP_H_ */ -#ifdef MG_MODULE_LINES -#line 1 "mongoose/src/sntp.h" -#endif -/* - * Copyright (c) 2016 Cesanta Software Limited - * All rights reserved - */ - -#ifndef CS_MONGOOSE_SRC_SNTP_H_ -#define CS_MONGOOSE_SRC_SNTP_H_ - -#if MG_ENABLE_SNTP - -#define MG_SNTP_EVENT_BASE 500 - -/* - * Received reply from time server. Event handler parameter contains - * pointer to mg_sntp_message structure - */ -#define MG_SNTP_REPLY (MG_SNTP_EVENT_BASE + 1) - -/* Received malformed SNTP packet */ -#define MG_SNTP_MALFORMED_REPLY (MG_SNTP_EVENT_BASE + 2) - -/* Failed to get time from server (timeout etc) */ -#define MG_SNTP_FAILED (MG_SNTP_EVENT_BASE + 3) - -struct mg_sntp_message { - /* if server sends this flags, user should not send requests to it */ - int kiss_of_death; - /* usual mg_time */ - double time; -}; - -/* Establishes connection to given sntp server */ -struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr, - mg_event_handler_t event_handler, - const char *sntp_server_name); - -/* Sends time request to given connection */ -void mg_sntp_send_request(struct mg_connection *c); - -/* - * Helper function - * Establishes connection to time server, tries to send request - * repeats sending SNTP_ATTEMPTS times every SNTP_TIMEOUT sec - * (if needed) - * See sntp_client example - */ -struct mg_connection *mg_sntp_get_time(struct mg_mgr *mgr, - mg_event_handler_t event_handler, - const char *sntp_server_name); - -#endif - -#endif /* CS_MONGOOSE_SRC_SNTP_H_ */ diff --git a/components/oap-wifi/server.c b/components/oap-wifi/server.c deleted file mode 100644 index f47e998..0000000 --- a/components/oap-wifi/server.c +++ /dev/null @@ -1,167 +0,0 @@ -/* - * server.c - * - * Created on: Oct 4, 2017 - * Author: kris - * - * This file is part of OpenAirProject-ESP32. - * - * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * OpenAirProject-ESP32 is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with OpenAirProject-ESP32. If not, see . - */ - -#include "server.h" -#include -#include -#include -#include -#include "esp_err.h" -#include "oap_common.h" - -#define tag "serv" - -typedef enum { - NOT_RUN = 0, - IDLE, - RUNNING, - RESTARTING -} server_mode_t; - -extern int mg_invalid_socket; - -static server_mode_t mode = NOT_RUN; - -/* -char *mongoose_eventToString(int ev) { - static char temp[100]; - switch (ev) { - case MG_EV_CONNECT: - return "MG_EV_CONNECT"; - case MG_EV_ACCEPT: - return "MG_EV_ACCEPT"; - case MG_EV_CLOSE: - return "MG_EV_CLOSE"; - case MG_EV_SEND: - return "MG_EV_SEND"; - case MG_EV_RECV: - return "MG_EV_RECV"; - case MG_EV_HTTP_REQUEST: - return "MG_EV_HTTP_REQUEST"; - case MG_EV_MQTT_CONNACK: - return "MG_EV_MQTT_CONNACK"; - case MG_EV_MQTT_CONNACK_ACCEPTED: - return "MG_EV_MQTT_CONNACK"; - case MG_EV_MQTT_CONNECT: - return "MG_EV_MQTT_CONNECT"; - case MG_EV_MQTT_DISCONNECT: - return "MG_EV_MQTT_DISCONNECT"; - case MG_EV_MQTT_PINGREQ: - return "MG_EV_MQTT_PINGREQ"; - case MG_EV_MQTT_PINGRESP: - return "MG_EV_MQTT_PINGRESP"; - case MG_EV_MQTT_PUBACK: - return "MG_EV_MQTT_PUBACK"; - case MG_EV_MQTT_PUBCOMP: - return "MG_EV_MQTT_PUBCOMP"; - case MG_EV_MQTT_PUBLISH: - return "MG_EV_MQTT_PUBLISH"; - case MG_EV_MQTT_PUBREC: - return "MG_EV_MQTT_PUBREC"; - case MG_EV_MQTT_PUBREL: - return "MG_EV_MQTT_PUBREL"; - case MG_EV_MQTT_SUBACK: - return "MG_EV_MQTT_SUBACK"; - case MG_EV_MQTT_SUBSCRIBE: - return "MG_EV_MQTT_SUBSCRIBE"; - case MG_EV_MQTT_UNSUBACK: - return "MG_EV_MQTT_UNSUBACK"; - case MG_EV_MQTT_UNSUBSCRIBE: - return "MG_EV_MQTT_UNSUBSCRIBE"; - case MG_EV_WEBSOCKET_HANDSHAKE_REQUEST: - return "MG_EV_WEBSOCKET_HANDSHAKE_REQUEST"; - case MG_EV_WEBSOCKET_HANDSHAKE_DONE: - return "MG_EV_WEBSOCKET_HANDSHAKE_DONE"; - case MG_EV_WEBSOCKET_FRAME: - return "MG_EV_WEBSOCKET_FRAME"; - } - sprintf(temp, "Unknown event: %d", ev); - return temp; -}*/ - - -static esp_err_t main_loop(void *mongoose_event_handler) { - struct mg_mgr mgr; - struct mg_connection *connection; - - ESP_LOGD(tag, ">> main_loop"); - mg_mgr_init(&mgr, NULL); - - connection = mg_bind(&mgr, ":80", mongoose_event_handler); - - if (connection == NULL) { - //when this happens usually it won't recover until it gets a new IP - //maybe we should reboot? - ESP_LOGW(tag, "No connection from the mg_bind()."); - mg_mgr_free(&mgr); - return ESP_FAIL; - } - //use http - mg_set_protocol_http_websocket(connection); - - mg_invalid_socket=0; //hack for corrupted mongoose sockets (AP mode + http request triggers it) - while (mode == RUNNING && !mg_invalid_socket) { - mg_mgr_poll(&mgr, 1000); - } - - mg_mgr_free(&mgr); - ESP_LOGD(tag, "<< main_loop"); - return ESP_OK; -} - -static void server_task(void *mongoose_event_handler) { - ESP_LOGD(tag, "start"); - while (1) { - switch (mode) { - case RUNNING: - if (main_loop(mongoose_event_handler) != ESP_OK) { - vTaskDelay(1000 / portTICK_PERIOD_MS); - } - break; - case IDLE: - vTaskDelay(1000 / portTICK_PERIOD_MS); - break; - default: //{RESTARTING,NOT_RUN} => RUNNING - mode = RUNNING; - } - } - vTaskDelete(NULL); -} - -void server_restart() { - ESP_LOGD(tag, "restart"); - mode = RESTARTING; -} - -void server_stop() { - ESP_LOGD(tag, "idle"); - mode = IDLE; -} - -void server_start(void *event_handler) { - if (mode == NOT_RUN) { - mode = RUNNING; - xTaskCreatePinnedToCore(&server_task, "mongoose_task", 10000, event_handler, DEFAULT_TASK_PRIORITY+1, NULL, 0); - } else { - server_restart(); - } -} diff --git a/components/oap-wifi/server.h b/components/oap-wifi/server.h deleted file mode 100644 index 3e3a053..0000000 --- a/components/oap-wifi/server.h +++ /dev/null @@ -1,34 +0,0 @@ -/* - * server.h - * - * Created on: Oct 4, 2017 - * Author: kris - * - * This file is part of OpenAirProject-ESP32. - * - * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * OpenAirProject-ESP32 is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with OpenAirProject-ESP32. If not, see . - */ - -#ifndef COMPONENTS_BOOTWIFI_SERVER_H_ -#define COMPONENTS_BOOTWIFI_SERVER_H_ - -#include "mongoose.h" - -void server_restart(); -void server_stop(); -void server_start(void *event_handler); - - - -#endif /* COMPONENTS_BOOTWIFI_SERVER_H_ */ diff --git a/components/oap-wifi/server_cpanel.c b/components/oap-wifi/server_cpanel.c deleted file mode 100644 index a7b9832..0000000 --- a/components/oap-wifi/server_cpanel.c +++ /dev/null @@ -1,35 +0,0 @@ -/* - * server_cpanel.c - * - * Created on: Oct 5, 2017 - * Author: kris - * - * This file is part of OpenAirProject-ESP32. - * - * OpenAirProject-ESP32 is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * OpenAirProject-ESP32 is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with OpenAirProject-ESP32. If not, see . - */ - -#include "server_cpanel.h" -#include "server.h" -#include "cpanel.h" - -void cpanel_wifi_handler(bool connected, bool ap_mode) { - if (connected) { - server_start(cpanel_event_handler); - } else { - server_restart(); - } -} - - diff --git a/components/oap-wifi/web.c b/components/oap-wifi/web.c new file mode 100644 index 0000000..04cfd37 --- /dev/null +++ b/components/oap-wifi/web.c @@ -0,0 +1,371 @@ +#include +#include +#include +#include + +#include "oap_common.h" +#undef HTTP_GET +#undef HTTP_POST +#include "cJSON.h" +#include "oap_storage.h" +#include "pm_meter.h" +#include "mhz19.h" +#include "hw_gpio.h" + +#include "web.h" + +static const char *TAG="web"; +extern const uint8_t index_html_start[] asm("_binary_index_html_start"); +extern const uint8_t index_html_end[] asm("_binary_index_html_end"); + +static esp_err_t index_handler(httpd_req_t *req) +{ + size_t resp_size = index_html_end-index_html_start; + httpd_resp_set_type(req, HTTPD_TYPE_TEXT); + httpd_resp_send(req, (const char *)index_html_start, resp_size); + return ESP_OK; +} + +httpd_uri_t index_desc = { + .uri = "/", + .method = HTTP_GET, + .handler = index_handler +}; + +static esp_err_t reboot_handler(httpd_req_t *req) +{ + httpd_resp_set_type(req, HTTPD_TYPE_TEXT); + httpd_resp_send(req, "", 0); + oap_reboot("requested by user"); + return ESP_OK; +} + +httpd_uri_t reboot_desc = { + .uri = "/reboot", + .method = HTTP_POST, + .handler = reboot_handler +}; + +static esp_err_t handler_get_config(httpd_req_t *req) +{ + httpd_resp_set_type(req, HTTPD_TYPE_JSON); + httpd_resp_set_hdr(req, "X-Version", oap_version_str()); + + cJSON* config = storage_get_config_to_update(); + char* json = cJSON_Print(config); + httpd_resp_send(req, json, strlen(json)); + free(json); + return ESP_OK; +} + +httpd_uri_t get_config_desc = { + .uri = "/config", + .method = HTTP_GET, + .handler = handler_get_config +}; + +static esp_err_t handler_post_config(httpd_req_t *req) +{ + /* Read request bod */ + char content[1000]; + + /* Truncate if content length larger than the buffer */ + size_t recv_size = MIN(req->content_len, sizeof(content)); + + int ret = httpd_req_recv(req, content, recv_size); + if (ret < 0) { + /* In case of recv error, returning ESP_FAIL will + * ensure that the underlying socket is closed */ + return ESP_FAIL; + } + cJSON* config = cJSON_Parse(content); + if (config) { + storage_update_config(config); + handler_get_config(req); + } else { + httpd_resp_set_status(req, HTTPD_500); + } + cJSON_Delete(config); + + /* Send a simple response */ + const char *resp = "URI POST Response"; + httpd_resp_send(req, resp, strlen(resp)); + + return ESP_OK; +} + +httpd_uri_t post_config_desc = { + .uri = "/config", + .method = HTTP_POST, + .handler = handler_post_config +}; + +static esp_err_t handler_get_status(httpd_req_t *req) +{ + httpd_resp_set_type(req, HTTPD_TYPE_JSON); + cJSON *root, *status, *data; + + root = cJSON_CreateObject(); + status = cJSON_CreateObject(); + data = cJSON_CreateObject(); + + cJSON_AddItemToObject(root, "status", status); + cJSON_AddItemToObject(root, "data", data); + + cJSON_AddItemToObject(status, "version", cJSON_CreateString(oap_version_str())); + + time_t now = time(NULL); + struct tm timeinfo = {0}; + + localtime_r(&now, &timeinfo); + time_t boot_time = now-(xTaskGetTickCount()/configTICK_RATE_HZ); + long sysTime = oap_epoch_sec(); + if(timeinfo.tm_year > (2016 - 1900)) { +#if 0 + setenv("TZ", "CET-1CEST,M3.5.0,M10.5.0/3", 1); + tzset(); +#endif + char strftime_buf[64]; + strftime(strftime_buf, sizeof(strftime_buf), "%c", &timeinfo); + cJSON_AddItemToObject(status, "utctime", cJSON_CreateString(strftime_buf)); + } + cJSON_AddItemToObject(status, "time", cJSON_CreateNumber(now)); + cJSON_AddItemToObject(status, "uptime", cJSON_CreateNumber(now - boot_time)); + cJSON_AddItemToObject(status, "heap", cJSON_CreateNumber(esp_get_free_heap_size())); + #ifdef CONFIG_OAP_BMX280_ENABLED + if(last_env_data[0].timestamp) { + cJSON *envobj0 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env0", envobj0); + cJSON_AddItemToObject(envobj0, "temp", cJSON_CreateNumber(last_env_data[0].env_data.bmx280.temp)); + cJSON_AddItemToObject(envobj0, "pressure", cJSON_CreateNumber(last_env_data[0].env_data.bmx280.sealevel)); + cJSON_AddItemToObject(envobj0, "humidity", cJSON_CreateNumber(last_env_data[0].env_data.bmx280.humidity)); + cJSON_AddItemToObject(envobj0, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[0].timestamp)); + } + #endif + #ifdef CONFIG_OAP_BMX280_ENABLED_AUX + if(last_env_data[1].timestamp) { + cJSON *envobj1 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env1", envobj1); + cJSON_AddItemToObject(envobj1, "temp", cJSON_CreateNumber(last_env_data[1].env_data.bmx280.temp)); + cJSON_AddItemToObject(envobj1, "pressure", cJSON_CreateNumber(last_env_data[1].env_data.bmx280.sealevel)); + cJSON_AddItemToObject(envobj1, "humidity", cJSON_CreateNumber(last_env_data[1].env_data.bmx280.humidity)); + cJSON_AddItemToObject(envobj1, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[1].timestamp)); + } + #endif + #ifdef CONFIG_OAP_MH_ENABLED + if(last_env_data[2].timestamp) { + cJSON *envobj2 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env2", envobj2); + cJSON_AddItemToObject(envobj2, "co2", cJSON_CreateNumber(last_env_data[2].env_data.mhz19.co2)); + cJSON_AddItemToObject(envobj2, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[2].timestamp)); + } + #endif + #ifdef CONFIG_OAP_HCSR04_0_ENABLED + if(last_env_data[3].timestamp) { + cJSON *envobj3 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env3", envobj3); + cJSON_AddItemToObject(envobj3, "distance", cJSON_CreateNumber(last_env_data[3].env_data.hcsr04.distance)); + cJSON_AddItemToObject(envobj3, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[3].timestamp)); + } + #endif + #ifdef CONFIG_OAP_HCSR04_1_ENABLED + if(last_env_data[4].timestamp) { + cJSON *envobj4 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env4", envobj4); + cJSON_AddItemToObject(envobj4, "distance", cJSON_CreateNumber(last_env_data[4].env_data.hcsr04.distance)); + cJSON_AddItemToObject(envobj4, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[4].timestamp)); + } + #endif + #ifdef CONFIG_OAP_GPIO_0_ENABLED + if(last_env_data[5].timestamp) { + cJSON *envobj5 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env5", envobj5); + cJSON_AddItemToObject(envobj5, "GPIlastLow", cJSON_CreateNumber(last_env_data[5].env_data.gpio.GPIlastLow)); + cJSON_AddItemToObject(envobj5, "GPIlastHigh", cJSON_CreateNumber(last_env_data[5].env_data.gpio.GPIlastHigh)); + cJSON_AddItemToObject(envobj5, "GPICounter", cJSON_CreateNumber(last_env_data[5].env_data.gpio.GPICounter)); + cJSON_AddItemToObject(envobj5, "GPICountDelta", cJSON_CreateNumber(last_env_data[5].env_data.gpio.GPICountDelta)); + cJSON_AddItemToObject(envobj5, "GPOlastOut", cJSON_CreateNumber(last_env_data[5].env_data.gpio.GPOlastOut)); + cJSON_AddItemToObject(envobj5, "GPOlastVal", cJSON_CreateNumber(last_env_data[5].env_data.gpio.GPOlastVal)); + cJSON_AddItemToObject(envobj5, "GPOtriggerLength", cJSON_CreateNumber(last_env_data[5].env_data.gpio.GPOtriggerLength)); + cJSON_AddItemToObject(envobj5, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[5].timestamp)); + } + #endif + #ifdef CONFIG_OAP_GPIO_1_ENABLED + if(last_env_data[6].timestamp) { + cJSON *envobj6 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env6", envobj6); + cJSON_AddItemToObject(envobj6, "GPIlastLow", cJSON_CreateNumber(last_env_data[6].env_data.gpio.GPIlastLow)); + cJSON_AddItemToObject(envobj6, "GPICounter", cJSON_CreateNumber(last_env_data[6].env_data.gpio.GPICounter)); + cJSON_AddItemToObject(envobj6, "GPICountDelta", cJSON_CreateNumber(last_env_data[6].env_data.gpio.GPICountDelta)); + cJSON_AddItemToObject(envobj6, "GPIlastHigh", cJSON_CreateNumber(last_env_data[6].env_data.gpio.GPIlastHigh)); + cJSON_AddItemToObject(envobj6, "GPOlastOut", cJSON_CreateNumber(last_env_data[6].env_data.gpio.GPOlastOut)); + cJSON_AddItemToObject(envobj6, "GPOlastVal", cJSON_CreateNumber(last_env_data[6].env_data.gpio.GPOlastVal)); + cJSON_AddItemToObject(envobj6, "GPOtriggerLength", cJSON_CreateNumber(last_env_data[6].env_data.gpio.GPOtriggerLength)); + cJSON_AddItemToObject(envobj6, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[6].timestamp)); + } + #endif + #ifdef CONFIG_OAP_GPIO_2_ENABLED + if(last_env_data[7].timestamp) { + cJSON *envobj7 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env7", envobj7); + cJSON_AddItemToObject(envobj7, "GPIlastLow", cJSON_CreateNumber(last_env_data[7].env_data.gpio.GPIlastLow)); + cJSON_AddItemToObject(envobj7, "GPIlastHigh", cJSON_CreateNumber(last_env_data[7].env_data.gpio.GPIlastHigh)); + cJSON_AddItemToObject(envobj7, "GPICounter", cJSON_CreateNumber(last_env_data[7].env_data.gpio.GPICounter)); + cJSON_AddItemToObject(envobj7, "GPICountDelta", cJSON_CreateNumber(last_env_data[7].env_data.gpio.GPICountDelta)); + cJSON_AddItemToObject(envobj7, "GPOlastOut", cJSON_CreateNumber(last_env_data[7].env_data.gpio.GPOlastOut)); + cJSON_AddItemToObject(envobj7, "GPOlastVal", cJSON_CreateNumber(last_env_data[7].env_data.gpio.GPOlastVal)); + cJSON_AddItemToObject(envobj7, "GPOtriggerLength", cJSON_CreateNumber(last_env_data[7].env_data.gpio.GPOtriggerLength)); + cJSON_AddItemToObject(envobj7, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[7].timestamp)); + } + #endif + #ifdef CONFIG_OAP_GPIO_3_ENABLED + if(last_env_data[8].timestamp) { + cJSON *envobj8 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "env8", envobj8); + cJSON_AddItemToObject(envobj8, "GPIlastLow", cJSON_CreateNumber(last_env_data[8].env_data.gpio.GPIlastLow)); + cJSON_AddItemToObject(envobj8, "GPIlastHigh", cJSON_CreateNumber(last_env_data[8].env_data.gpio.GPIlastHigh)); + cJSON_AddItemToObject(envobj8, "GPICounter", cJSON_CreateNumber(last_env_data[8].env_data.gpio.GPICounter)); + cJSON_AddItemToObject(envobj8, "GPICountDelta", cJSON_CreateNumber(last_env_data[8].env_data.gpio.GPICountDelta)); + cJSON_AddItemToObject(envobj8, "GPOlastOut", cJSON_CreateNumber(last_env_data[8].env_data.gpio.GPOlastOut)); + cJSON_AddItemToObject(envobj8, "GPOlastVal", cJSON_CreateNumber(last_env_data[8].env_data.gpio.GPOlastVal)); + cJSON_AddItemToObject(envobj8, "GPOtriggerLength", cJSON_CreateNumber(last_env_data[8].env_data.gpio.GPOtriggerLength)); + cJSON_AddItemToObject(envobj8, "timestamp", cJSON_CreateNumber(sysTime - last_env_data[8].timestamp)); + } + #endif + #ifdef CONFIG_OAP_PM_UART_ENABLE + if(pm_data_array.timestamp) { + cJSON *pmobj0 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "pm0", pmobj0); + cJSON_AddItemToObject(pmobj0, "pm1_0", cJSON_CreateNumber(pm_data_array.pm_data[0].pm1_0)); + cJSON_AddItemToObject(pmobj0, "pm2_5", cJSON_CreateNumber(pm_data_array.pm_data[0].pm2_5)); + cJSON_AddItemToObject(pmobj0, "pm10", cJSON_CreateNumber(pm_data_array.pm_data[0].pm10)); + cJSON_AddItemToObject(pmobj0, "timestamp", cJSON_CreateNumber(sysTime - pm_data_array.timestamp)); + #ifdef CONFIG_OAP_PM_UART_AUX_ENABLE + cJSON *pmobj1 = cJSON_CreateObject(); + cJSON_AddItemToObject(data, "pm1", pmobj1); + cJSON_AddItemToObject(pmobj1, "pm1_0", cJSON_CreateNumber(pm_data_array.pm_data[1].pm1_0)); + cJSON_AddItemToObject(pmobj1, "pm2_5", cJSON_CreateNumber(pm_data_array.pm_data[1].pm2_5)); + cJSON_AddItemToObject(pmobj1, "pm10", cJSON_CreateNumber(pm_data_array.pm_data[1].pm10)); + #endif + } + #endif + char* json = cJSON_Print(root); + httpd_resp_send(req, json, strlen(json)); + + free(json); + cJSON_Delete(root); + return ESP_OK; +} + +httpd_uri_t get_status_desc = { + .uri = "/status", + .method = HTTP_GET, + .handler = handler_get_status +}; + +static esp_err_t trigger_handler(httpd_req_t *req) +{ + char* buf; + size_t buf_len; + char *str = "ok\n"; + httpd_resp_set_type(req, HTTPD_TYPE_TEXT); + buf_len = httpd_req_get_url_query_len(req) + 1; + if (buf_len > 1) { + buf = malloc(buf_len); + if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) { + ESP_LOGI(TAG, "Found URL query => %s", buf); + char param[32]; + int delay = 0; + int value = 0; + int gpio = -1; + /* Get value of expected key from query string */ + if (httpd_query_key_value(buf, "delay", param, sizeof(param)) == ESP_OK) { + ESP_LOGI(TAG, "Found URL query parameter => delay=%s", param); + delay=atoi(param); + } + if (httpd_query_key_value(buf, "value", param, sizeof(param)) == ESP_OK) { + ESP_LOGI(TAG, "Found URL query parameter => value=%s", param); + value=atoi(param); + } + if (httpd_query_key_value(buf, "gpio", param, sizeof(param)) == ESP_OK) { + ESP_LOGI(TAG, "Found URL query parameter => gpio=%s", param); + gpio=atoi(param); + } + if (httpd_query_key_value(buf, "func", param, sizeof(param)) == ESP_OK) { + ESP_LOGI(TAG, "Found URL query parameter => func=%s", param); + if(!strcasecmp(param, "calibrate")) { + mhz19_calibrate(&mhz19_cfg[0]); + } + } else if(gpio >= 0) { + hw_gpio_queue_trigger(gpio, value, delay); + } + } + free(buf); + } + httpd_resp_send(req, str, strlen(str)); + return ESP_OK; +} + +httpd_uri_t trigger_desc = { + .uri = "/trigger", + .method = HTTP_GET, + .handler = trigger_handler +}; + +httpd_handle_t start_webserver(void) +{ + httpd_handle_t server = NULL; + httpd_config_t config = HTTPD_DEFAULT_CONFIG(); + config.stack_size = 6*1024; + config.lru_purge_enable = true; + config.backlog_conn = 25; + config.max_open_sockets = 12; + config.max_uri_handlers = 6; + + // Start the httpd server + ESP_LOGI(TAG, "Starting server on port: '%d'", config.server_port); + if (httpd_start(&server, &config) == ESP_OK) { + // Set URI handlers + ESP_LOGI(TAG, "Registering URI handlers"); + httpd_register_uri_handler(server, &index_desc); + httpd_register_uri_handler(server, &reboot_desc); + httpd_register_uri_handler(server, &get_config_desc); + httpd_register_uri_handler(server, &post_config_desc); + httpd_register_uri_handler(server, &get_status_desc); + httpd_register_uri_handler(server, &trigger_desc); + esp_log_level_set("httpd_parse", ESP_LOG_WARN); + esp_log_level_set("httpd_txrx", ESP_LOG_WARN); + esp_log_level_set("httpd_uri", ESP_LOG_WARN); + esp_log_level_set("httpd_sess", ESP_LOG_WARN); + esp_log_level_set("httpd", ESP_LOG_WARN); + return server; + } + + ESP_LOGI(TAG, "Error starting server!"); + return NULL; +} + +void stop_webserver(httpd_handle_t server) +{ + // Stop the httpd server + httpd_stop(server); +} + + +static httpd_handle_t server = NULL; + +void web_wifi_handler(bool connected, bool ap_mode) +{ + if (connected) { + if (server == NULL) { + server = start_webserver(); + } + } else { + + if (server) { + stop_webserver(server); + server = NULL; + } + } +} + diff --git a/doc/MH-Z19 CO2 Ver1.0.pdf b/doc/MH-Z19 CO2 Ver1.0.pdf new file mode 100644 index 0000000..58b486c Binary files /dev/null and b/doc/MH-Z19 CO2 Ver1.0.pdf differ diff --git a/main/Kconfig.projbuild b/main/Kconfig.projbuild index d108032..1ca3bab 100644 --- a/main/Kconfig.projbuild +++ b/main/Kconfig.projbuild @@ -1,10 +1,16 @@ menu "OpenAirProject" config OAP_CONTROL_PANEL - int "enable control panel" - default 1 + bool "enable control panel" + default y help Enable web-based control panel where you can configure various parameters of the sensor, including wifi and data publishing settings -endmenu \ No newline at end of file +config OAP_RGB_LED + bool "enable air quality RGB-LED" + default y + help + Enable air quality RGB-LED. If set to disable the only the blue channel is being used. +endmenu + diff --git a/main/main.c b/main/main.c index 5001e4c..eb8b5fd 100644 --- a/main/main.c +++ b/main/main.c @@ -31,9 +31,11 @@ #include "esp_system.h" #include "nvs_flash.h" #include "esp_log.h" +#include "driver/gpio.h" #include #include "thing_speak.h" +#include "http_get_publisher.h" #include "meas_intervals.h" #include "meas_continuous.h" @@ -42,13 +44,18 @@ #include "ctrl_btn.h" #include "bmx280.h" #include "pmsx003.h" +#include "mhz19.h" #include "oap_common.h" #include "oap_storage.h" #include "oap_debug.h" #include "awsiot.h" #include "ota.h" #include "oap_data.h" -#include "server_cpanel.h" +#include "ssd1366.h" +#include "hcsr04.h" +#include "hw_gpio.h" +#include "udp_server.h" +#include "web.h" #define ESP_INTR_FLAG_DEFAULT 0 @@ -78,13 +85,13 @@ static void ledc_update() { static void ledc_set_mode(led_mode_t mode) { ledc_state.mode = mode; } - +#ifdef CONFIG_OAP_RGB_LED static void ledc_set_color(float r, float g, float b) { ledc_state.color.v[0] = r; ledc_state.color.v[1] = g; ledc_state.color.v[2] = b; } - +#endif static void ledc_init() { ledc_queue = xQueueCreate(10, sizeof(led_cmd_t)); led_init(oap_sensor_config.led, ledc_queue); @@ -105,12 +112,14 @@ static void ledc_init() { static QueueHandle_t pm_meter_result_queue; static pmsx003_config_t pms_pair_config[2]; +pm_data_pair_t pm_data_array; extern pm_meter_t pm_meter_intervals; extern pm_meter_t pm_meter_continuous; #define PM_RESULT_SEND_TIMEOUT 100 static void pm_meter_result_handler(pm_data_pair_t* pm_data_pair) { + memcpy(&pm_data_array, pm_data_pair, sizeof(pm_data_pair_t)); if (!xQueueSend(pm_meter_result_queue, pm_data_pair, PM_RESULT_SEND_TIMEOUT)) { ESP_LOGW(TAG,"pm_meter_result_queue overflow"); } @@ -133,24 +142,6 @@ static void pm_meter_output_handler(pm_meter_event_t event, void* data) { } } -//TODO share -static void set_gpio(uint8_t gpio, uint8_t enabled) { - if (gpio > 0) { - ESP_LOGD(TAG, "set pin %d => %d", gpio, enabled); - gpio_set_level(gpio, enabled); - } -} - -//TODO share -static void configure_gpio(uint8_t gpio) { - if (gpio > 0) { - ESP_LOGD(TAG, "configure pin %d as output", gpio); - gpio_pad_select_gpio(gpio); - ESP_ERROR_CHECK(gpio_set_direction(gpio, GPIO_MODE_OUTPUT)); - ESP_ERROR_CHECK(gpio_set_pull_mode(gpio, GPIO_PULLDOWN_ONLY)); - } -} - static void pmsx003_enable_0(uint8_t enable) { if (oap_sensor_config.heater) { set_gpio(pm_meter_aux.heater_pin, enable); @@ -229,26 +220,38 @@ static esp_err_t pm_meter_init() { return ESP_OK; } +//--------- ENV ----------- +static hcsr04_config_t hcsr04_cfg[HW_HCSR04_DEVICES_MAX]; +hw_gpio_config_t hw_gpio_cfg[HW_GPIO_DEVICES_MAX]; +static bmx280_config_t bmx280_config[HW_BMX280_DEVICES_MAX]; +mhz19_config_t mhz19_cfg[HW_MHZ19_DEVICES_MAX]; +env_data_record_t last_env_data[HW_HCSR04_DEVICES_MAX+HW_GPIO_DEVICES_MAX+HW_BMX280_DEVICES_MAX+HW_MHZ19_DEVICES_MAX]; -//--------- ENV ----------- - -typedef struct { - env_data_t env_data; - long timestamp; -} env_data_record_t; - -static env_data_record_t last_env_data[2]; -static bmx280_config_t bmx280_config[2]; +static SemaphoreHandle_t envSemaphore = NULL; static void env_sensor_callback(env_data_t* env_data) { - if (env_data->sensor_idx <= 1) { - ESP_LOGI(TAG,"env (%d): temp : %.2f C, pressure: %.2f hPa, humidity: %.2f %%", env_data->sensor_idx, env_data->temp, env_data->pressure, env_data->humidity); - env_data_record_t* r = last_env_data + env_data->sensor_idx; - r->timestamp = oap_epoch_sec(); - memcpy(&last_env_data->env_data, env_data, sizeof(env_data_t)); + if (env_data->sensor_idx < (sizeof(last_env_data)/sizeof(env_data_record_t))) { + if( xSemaphoreTakeRecursive( envSemaphore, ( TickType_t ) 1000 ) == pdTRUE ) { + switch(env_data->sensor_type) { + case sensor_bmx280: + ESP_LOGI(TAG, "env (%d): temp : %.2f C, pressure: %.2f hPa, humidity: %.2f %%", env_data->sensor_idx, env_data->bmx280.temp, env_data->bmx280.pressure, env_data->bmx280.humidity);break; + case sensor_mhz19: + ESP_LOGI(TAG, "env (%d): temp : %.2f C, CO2: %d ppm", env_data->sensor_idx, env_data->mhz19.temp, env_data->mhz19.co2);break; + case sensor_hcsr04: + ESP_LOGI(TAG, "env (%d): dist: %dcm", env_data->sensor_idx, env_data->hcsr04.distance);break; + case sensor_gpio: + ESP_LOGI(TAG, "env (%d): GPIlastLow: %llu, GPIlastHigh: %llu, GPICounter: %llu, GPOlastOut: %llu, GPOlastVal: %d ", env_data->sensor_idx, env_data->gpio.GPIlastLow, env_data->gpio.GPIlastHigh, env_data->gpio.GPICounter, env_data->gpio.GPOlastOut, env_data->gpio.GPOlastVal);break; + } + env_data_record_t* r = last_env_data + env_data->sensor_idx; + r->timestamp = oap_epoch_sec(); + memcpy(r, env_data, sizeof(env_data_t)); + xSemaphoreGiveRecursive(envSemaphore); + } else { + ESP_LOGW(TAG,"*** env waiting too long for mutex ***"); + } } else { ESP_LOGE(TAG, "env (%d) - invalid sensor", env_data->sensor_idx); } @@ -257,28 +260,96 @@ static void env_sensor_callback(env_data_t* env_data) { static void env_sensors_init() { memset(&last_env_data, 0, sizeof(env_data_record_t)*2); memset(bmx280_config, 0, sizeof(bmx280_config_t)*2); - - if (bmx280_set_hardware_config(&bmx280_config[0], 0) == ESP_OK) { + envSemaphore = xSemaphoreCreateRecursiveMutex(); +#ifdef CONFIG_OAP_BMX280_ENABLED + if (oap_sensor_config.bmx280_enabled && bmx280_set_hardware_config(&bmx280_config[0], 0) == ESP_OK) { bmx280_config[0].interval = 5000; bmx280_config[0].callback = &env_sensor_callback; + bmx280_config[0].altitude = oap_sensor_config.altitude; + bmx280_config[0].tempOffset = oap_sensor_config.tempOffset; + bmx280_config[0].humidityOffset = oap_sensor_config.humidityOffset; if (bmx280_init(&bmx280_config[0]) != ESP_OK) { ESP_LOGE(TAG, "couldn't initialise bmx280 sensor %d", 0); } } - - if (bmx280_set_hardware_config(&bmx280_config[1], 1) == ESP_OK) { +#endif +#ifdef CONFIG_OAP_BMX280_ENABLED_AUX + if (oap_sensor_config.bmx280_enabled && bmx280_set_hardware_config(&bmx280_config[1], 1) == ESP_OK) { bmx280_config[1].interval = 5000; bmx280_config[1].callback = &env_sensor_callback; + bmx280_config[1].altitude = oap_sensor_config.altitude; + bmx280_config[1].tempOffset = oap_sensor_config.tempOffset; + bmx280_config[1].humidityOffset = oap_sensor_config.humidityOffset; if (bmx280_init(&bmx280_config[1]) != ESP_OK) { ESP_LOGE(TAG, "couldn't initialise bmx280 sensor %d", 1); } } +#endif +#ifdef CONFIG_OAP_MH_ENABLED + if (mhz19_set_hardware_config(&mhz19_cfg[0], 2) == ESP_OK) { + mhz19_cfg[0].interval = 5000; + mhz19_cfg[0].callback = &env_sensor_callback; + mhz19_init(&mhz19_cfg[0]); + mhz19_enable(&mhz19_cfg[0], oap_sensor_config.mhz19_enabled); + } +#endif +#ifdef CONFIG_OAP_HCSR04_0_ENABLED + if(hcsr04_set_hardware_config(&hcsr04_cfg[0], 3) == ESP_OK) { + hcsr04_cfg[0].interval = 1000; + hcsr04_cfg[0].callback = &env_sensor_callback; + hcsr04_init(&hcsr04_cfg[0]); + hcsr04_enable(&hcsr04_cfg[0], oap_sensor_config.hcsr04_enabled); + } +#endif +#ifdef CONFIG_OAP_HCSR04_1_ENABLED + if(hcsr04_set_hardware_config(&hcsr04_cfg[1], 4) == ESP_OK) { + hcsr04_cfg[1].interval = 100; + hcsr04_cfg[1].callback = &env_sensor_callback; + hcsr04_init(&hcsr04_cfg[1]); + hcsr04_enable(&hcsr04_cfg[1], oap_sensor_config.hcsr04_enabled); + } +#endif +#ifdef CONFIG_OAP_GPIO_0_ENABLED + if(hw_gpio_set_hardware_config(&hw_gpio_cfg[0], 5) == ESP_OK) { + hw_gpio_cfg[0].interval = 100; + hw_gpio_cfg[0].callback = &env_sensor_callback; + hw_gpio_init(&hw_gpio_cfg[0]); + hw_gpio_enable(&hw_gpio_cfg[0], oap_sensor_config.gpio_enabled); + } +#endif +#ifdef CONFIG_OAP_GPIO_1_ENABLED + if(hw_gpio_set_hardware_config(&hw_gpio_cfg[1], 6) == ESP_OK) { + hw_gpio_cfg[1].interval = 100; + hw_gpio_cfg[1].callback = &env_sensor_callback; + hw_gpio_init(&hw_gpio_cfg[1]); + hw_gpio_enable(&hw_gpio_cfg[1], oap_sensor_config.gpio_enabled); + } +#endif +#ifdef CONFIG_OAP_GPIO_2_ENABLED + if(hw_gpio_set_hardware_config(&hw_gpio_cfg[2], 7) == ESP_OK) { + hw_gpio_cfg[2].interval = 100; + hw_gpio_cfg[2].callback = &env_sensor_callback; + hw_gpio_init(&hw_gpio_cfg[2]); + hw_gpio_enable(&hw_gpio_cfg[2], oap_sensor_config.gpio_enabled); + } +#endif +#ifdef CONFIG_OAP_GPIO_3_ENABLED + if(hw_gpio_set_hardware_config(&hw_gpio_cfg[3], 8) == ESP_OK) { + hw_gpio_cfg[3].interval = 100; + hw_gpio_cfg[3].callback = &env_sensor_callback; + hw_gpio_init(&hw_gpio_cfg[3]); + hw_gpio_enable(&hw_gpio_cfg[3], oap_sensor_config.gpio_enabled); + } +#endif +#ifdef CONFIG_OAP_GPIO_UDP_ENABLED + if(oap_sensor_config.gpio_udp_enabled) { + xTaskCreate((TaskFunction_t)udp_server, "GPIO udp server", 1024*3, NULL, DEFAULT_TASK_PRIORITY, NULL); + } +#endif } - - //--------- MAIN ----------- list_t* publishers; @@ -292,26 +363,46 @@ static void publish_all(oap_measurement_t* meas) { } static void publish_loop() { + long last_published = 0; + while (1) { long localTime = oap_epoch_sec_valid(); long sysTime = oap_epoch_sec(); pm_data_pair_t pm_data_pair; + memset(&pm_data_pair, 0, sizeof(pm_data_pair)); log_heap_size("publish_loop"); - if (xQueueReceive(pm_meter_result_queue, &pm_data_pair, 10000)) { + if ( +#if defined CONFIG_OAP_PM_UART_ENABLE || defined CONFIG_OAP_PM_UART_AUX_ENABLE + xQueueReceive(pm_meter_result_queue, &pm_data_pair, 10000) || +#endif + (sysTime - last_published) > oap_sensor_config.meas_interval) { +#if !defined CONFIG_OAP_PM_UART_ENABLE && !defined CONFIG_OAP_PM_UART_AUX_ENABL + delay(100000); +#endif log_task_stack(TAG); + last_published = sysTime; +#ifdef CONFIG_OAP_RGB_LED float aqi = fminf(pm_data_pair.pm_data[0].pm2_5 / 100.0, 1.0); //ESP_LOGI(TAG, "AQI=%f",aqi); ledc_set_color(aqi,(1-aqi), 0); +#endif ledc_set_mode(LED_SET); ledc_update(); oap_measurement_t meas = { - .pm = &pm_data_pair.pm_data[0], - .pm_aux = pm_data_pair.count == 2 ? &pm_data_pair.pm_data[1] : NULL, + .pm = sysTime - pm_data_pair.timestamp < (oap_sensor_config.meas_interval*2) ? &pm_data_pair.pm_data[0]:NULL, + .pm_aux = pm_data_pair.timestamp < (oap_sensor_config.meas_interval*2) ? (pm_data_pair.count == 2 ? &pm_data_pair.pm_data[1] : NULL):NULL, .env = sysTime - last_env_data[0].timestamp < 60 ? &last_env_data[0].env_data : NULL, .env_int = sysTime - last_env_data[1].timestamp < 60 ? &last_env_data[1].env_data : NULL, + .co2 = sysTime - last_env_data[2].timestamp < 60 ? &last_env_data[2].env_data : NULL, + .distance1 = sysTime - last_env_data[3].timestamp < 60 ? &last_env_data[3].env_data : NULL, + .distance2 = sysTime - last_env_data[4].timestamp < 60 ? &last_env_data[4].env_data : NULL, + .gpio1 = sysTime - last_env_data[5].timestamp < 60 ? &last_env_data[5].env_data : NULL, + .gpio2 = sysTime - last_env_data[6].timestamp < 60 ? &last_env_data[6].env_data : NULL, + .gpio3 = sysTime - last_env_data[7].timestamp < 60 ? &last_env_data[7].env_data : NULL, + .gpio4 = sysTime - last_env_data[8].timestamp < 60 ? &last_env_data[8].env_data : NULL, .local_time = localTime }; @@ -333,6 +424,16 @@ static oap_sensor_config_t sensor_config_from_json(cJSON* sconfig) { if ((field = cJSON_GetObjectItem(sconfig, "measInterval"))) sensor_config.meas_interval = field->valueint; if ((field = cJSON_GetObjectItem(sconfig, "measStrategy"))) sensor_config.meas_strategy = field->valueint; if ((field = cJSON_GetObjectItem(sconfig, "test"))) sensor_config.test = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "altitude"))) sensor_config.altitude = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "tempOffset"))) sensor_config.tempOffset = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "humidityOffset"))) sensor_config.humidityOffset = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "mhz19_enabled"))) sensor_config.mhz19_enabled = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "hcsr04_enabled"))) sensor_config.hcsr04_enabled = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "ssd1306_enabled"))) sensor_config.ssd1306_enabled = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "gpio_enabled"))) sensor_config.gpio_enabled = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "pms_enabled"))) sensor_config.pms_enabled = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "bmx280_enabled"))) sensor_config.bmx280_enabled = field->valueint; + if ((field = cJSON_GetObjectItem(sconfig, "gpio_udp_enabled"))) sensor_config.gpio_udp_enabled = field->valueint; return sensor_config; } @@ -344,6 +445,9 @@ void publishers_init() { if (thingspeak_publisher.configure(storage_get_config("thingspeak")) == ESP_OK) { list_insert(publishers, &thingspeak_publisher); } + if (http_get_publisher.configure(storage_get_config(NULL)) == ESP_OK) { + list_insert(publishers, &http_get_publisher); + } } @@ -357,11 +461,49 @@ static void btn_handler(btn_action_t action) { case TOO_MANY_CLICKS : reset_to_factory_partition(); break; + case LONG_PRESS : + ESP_LOGW(TAG, "config reset!"); + storage_clean(); + ledc_set_mode(LED_BLINK); + ledc_update(); + delay(1000); + oap_reboot("reboot due to config reset"); + break; default: break; } } +void display_task(void *ptr) { + char logstr[80]; + + ssd1306_init(); + ssd1306_display_clear(); + sprintf(logstr, "\n\nESP32-Sensor\n\nVersion %s", oap_version_str()); + ssd1306_display_text(logstr); + char *toggle=""; + while(1) { + delay(5000); + ssd1306_display_clear(); + sprintf(logstr, "%s%.2fC\n\n%.2fhPa\n\n%.2f%% / %dppm\n\nPM: %d / %d / %d",toggle, + last_env_data[0].env_data.bmx280.temp, + last_env_data[0].env_data.bmx280.sealevel, + last_env_data[0].env_data.bmx280.humidity, + last_env_data[2].env_data.mhz19.co2, + pm_data_array.pm_data[0].pm1_0, + pm_data_array.pm_data[0].pm2_5, + pm_data_array.pm_data[0].pm10 + ); + ssd1306_display_text(logstr); + if(!toggle[0]) { + toggle="\n"; + } else { + toggle=""; + } + } + vTaskDelete(NULL); +} + void app_main() { //silence annoying logs esp_log_level_set("ledc", ESP_LOG_INFO); @@ -371,7 +513,7 @@ void app_main() { //a sec to start flashing delay(1000); ESP_LOGI(TAG,"starting app... firmware %s", oap_version_str()); - + gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT); //130kb is a nice cap to test against alloc fails //reduce_heap_size_to(130000); storage_init(); @@ -380,14 +522,23 @@ void app_main() { //wifi/mongoose requires plenty of mem, start it here btn_configure(&btn_handler); - wifi_configure(is_ap_mode_pressed() ? NULL : storage_get_config("wifi"), CONFIG_OAP_CONTROL_PANEL ? cpanel_wifi_handler : NULL); + wifi_configure(is_ap_mode_pressed() ? NULL : storage_get_config("wifi"), CONFIG_OAP_CONTROL_PANEL ? web_wifi_handler : NULL); wifi_boot(); start_ota_task(storage_get_config("ota")); ledc_init(); +#if defined CONFIG_OAP_PM_UART_ENABLE || defined CONFIG_OAP_PM_UART_AUX_ENABLE pm_meter_result_queue = xQueueCreate(1, sizeof(pm_data_pair_t)); - pm_meter_init(); + if(oap_sensor_config.pms_enabled) { + pm_meter_init(); + } +#endif env_sensors_init(); +#ifdef CONFIG_OAP_SDD1306_ENABLED + if(oap_sensor_config.ssd1306_enabled) { + xTaskCreate((TaskFunction_t)display_task, "display task", 1024*3, NULL, DEFAULT_TASK_PRIORITY, NULL); + } +#endif publishers_init(); publish_loop(); diff --git a/sdkconfig.defaults b/sdkconfig.defaults index 7b6a5b9..a19da40 100644 --- a/sdkconfig.defaults +++ b/sdkconfig.defaults @@ -248,7 +248,7 @@ CONFIG_LOG_COLORS=y # LWIP # # CONFIG_L2_TO_L3_COPY is not set -CONFIG_LWIP_MAX_SOCKETS=4 +CONFIG_LWIP_MAX_SOCKETS=16 CONFIG_LWIP_THREAD_LOCAL_STORAGE_INDEX=0 # CONFIG_LWIP_SO_REUSE is not set CONFIG_LWIP_SO_RCVBUF=y