blinkenstrip

webserver.c (10624B)

---

 /*
   Wifi connection & web server
 
   The wifi code is nearly identicial to the examples
   examples/wifi/getting_started/station/main/station_example_main.c
   and examples/wifi/getting_started/softAP/main/softap_example_main.c
   which are part of the esp-idf distribution. This example code is in
   the Public Domain (or CC0 licensed, at your option.)
 
   Functions http_server_netconn_serve and http_server are (partly)
   taken from
   https://github.com/cmmakerclub/esp32-webserver/blob/master/main/main.c,
   copyright (C) 2016 Espressif Systems, licensed under the Apache
   License 2.0.
 
   Everything else:
 
   Copyright © 2021 Gerd Beuster <gerd@frombelow.net>
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 */
 
 #include <string.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/event_groups.h"
 #include "esp_system.h"
 #include "esp_wifi.h"
 #include "esp_event.h"
 #include "esp_log.h"
 #include "nvs_flash.h"
 
 #include "lwip/err.h"
 #include "lwip/sys.h"
 
 #include "webserver.h"
 #include "debug.h"
 
 
 /* FreeRTOS event group to signal when we are connected*/
 static EventGroupHandle_t s_wifi_event_group;
 
 /* The event group allows multiple bits for each event, but we only care about two events:
  * - we are connected to the AP with an IP
  * - we failed to connect after the maximum amount of retries */
 #define WIFI_CONNECTED_BIT BIT0
 #define WIFI_FAIL_BIT      BIT1
 
 static const char *TAG = "webserver";
 
 static void event_handler_join_network(void* arg, esp_event_base_t event_base,
 			  int32_t event_id, void* event_data)
 {
   if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
     esp_wifi_connect();
   } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
     esp_wifi_connect();
   } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
     ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
     ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
     xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
   }
 }
 
 static void event_handler_run_ap(void* arg, esp_event_base_t event_base,
                                     int32_t event_id, void* event_data)
 {
     if (event_id == WIFI_EVENT_AP_STACONNECTED) {
         wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;
         ESP_LOGI(TAG, "station "MACSTR" join, AID=%d",
                  MAC2STR(event->mac), event->aid);
     } else if (event_id == WIFI_EVENT_AP_STADISCONNECTED) {
         wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
         ESP_LOGI(TAG, "station "MACSTR" leave, AID=%d",
                  MAC2STR(event->mac), event->aid);
     }
 }
 
 void initialise_wifi(uint8_t wifi_ap, char *wifi_essid,
 		     char *wifi_password)
 {
   s_wifi_event_group = xEventGroupCreate();
   ESP_ERROR_CHECK(esp_netif_init());
   ESP_ERROR_CHECK(esp_event_loop_create_default());
   DEBUG_MSG(DEBUG, ("wifi_ap is %d\n", wifi_ap));
   if(wifi_ap){
     DEBUG_MSG(DEBUG, ("Starting wifi access point.\n"));
     // Run our own WIFI access point.
     esp_netif_create_default_wifi_ap();
     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
     ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID,
 					       &event_handler_run_ap, NULL));
     wifi_config_t wifi_config = {
 				 .ap = {
 					.channel = 0,
 					.max_connection = 4,
 					.authmode = WIFI_AUTH_WPA_WPA2_PSK
 					},
     };
     if (strlen((char *) wifi_password) == 0) {
       wifi_config.ap.authmode = WIFI_AUTH_OPEN;
     }
     else {
       strncpy((char *) wifi_config.ap.password, wifi_password, 64);
     }
     strncpy((char *) wifi_config.ap.ssid, wifi_essid, 32);
     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
     ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));
     ESP_ERROR_CHECK(esp_wifi_start());
     ESP_LOGI(TAG, "wifi_init_softap finished. SSID:%s password:%s",
              wifi_config.ap.ssid, wifi_config.ap.password);
   }
   else{
     // Connect to existing WIFI network.
     esp_netif_create_default_wifi_sta();
     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
     ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID,
 					       &event_handler_join_network,
 					       NULL));
     ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP,
 					       &event_handler_join_network,
 					       NULL));
     wifi_config_t wifi_config = {
 				 .sta = {
 					 /* Setting a password implies
 					  * station will connect to
 					  * all security modes
 					  * including WEP/WPA.
 					  * However these modes are
 					  * deprecated and not
 					  * advisable to be
 					  * used. Incase your Access
 					  * point doesn't support
 					  * WPA2, these mode can be
 					  * enabled by commenting
 					  * below line */
 					 .threshold.authmode = WIFI_AUTH_WPA2_PSK,
 					 .pmf_cfg = {
 						     .capable = true,
 						     .required = false
 						     },
 					 },
     };
     strncpy((char *) wifi_config.sta.ssid, wifi_essid, 32);
     strncpy((char *) wifi_config.sta.password, wifi_password, 64);
     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );
     ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );
     ESP_ERROR_CHECK(esp_wifi_start() );
       
     ESP_LOGI(TAG, "wifi_init_sta finished.");
       
     /* Waiting until either the connection is established
      * (WIFI_CONNECTED_BIT) or connection failed for the maximum
      * number of re-tries (WIFI_FAIL_BIT). The bits are set by
      * event_handler_join_network() (see above) */
     EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
 					   WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
 					   pdFALSE,
 					   pdFALSE,
 					   portMAX_DELAY);
 
     /* xEventGroupWaitBits() returns the bits before the call
      * returned, hence we can test which event actually happened. */
     if (bits & WIFI_CONNECTED_BIT) {
       ESP_LOGI(TAG, "connected to ap SSID:%s password:%s",
 	       wifi_essid, wifi_password);
     } else if (bits & WIFI_FAIL_BIT) {
       ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s",
 	       wifi_essid, wifi_password);
     } else {
       ESP_LOGE(TAG, "UNEXPECTED EVENT");
     }
 
     ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP,
 						 &event_handler_join_network));
     ESP_ERROR_CHECK(esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID,
 						 &event_handler_join_network));
     vEventGroupDelete(s_wifi_event_group);
   }
 }
   
 
 
 /* {{{ Webserver */
 
 // Retrieve value of parameter key starting at begin.
 // Begin and end of the value string are stored in value_begin and value_end.
 // The function returns true if the key was found, false otherwise.
 bool url_key_value(char *begin, const char *key,
                            char **value_begin, char **value_end) {
   if ((begin == NULL) || (begin[0] == '\0') || (begin[0] == ' ')) {
     // End of GET request reached and key not found.
     return (false);
   }
   else {
     if ((strncmp(key, begin, strlen(key)) == 0) &&
 	(*(begin+strlen(key)) == '=')) {
     // Key found! Return value!
       *value_begin = begin+strlen(key)+1;
       *value_end = *value_begin + strcspn(*value_begin, " &");
       return true;
     }
     else {
       // Continue search recursively
       begin = begin + strcspn(begin, " &");
       if((begin[0] != '\0') && (begin[0] != ' ')) {
         begin++;
       }
       return url_key_value(begin, key, value_begin, value_end);
     }
   }
 }
   
 // Get URL without any parameters.
 void base_url(char *url_with_parameters, 
               char **base_url_begin, char **base_url_end,
               char **parameters_start) {
   bool get_request = !strncmp(url_with_parameters, "GET", 3);
   if(get_request){
     *base_url_begin = url_with_parameters + 4;
     *base_url_end = *base_url_begin + strcspn(*base_url_begin, " ?");
     *parameters_start = *base_url_end+1;
   }
   else{
     *base_url_begin = url_with_parameters + 5;
     *base_url_end = *base_url_begin + strcspn(*base_url_begin, " ?");
     *parameters_start = strstr(*base_url_end, "\r\n\r\n")+4;
   }
 }
 
 static void http_server_netconn_serve(struct netconn *conn)
 {
   struct netbuf *inbuf;
   char *buf;
   u16_t buflen;
   err_t err;
 
   /* Read the data from the port, blocking if nothing yet there.
      We assume the request (the part we care about) is in one netbuf */
   err = netconn_recv(conn, &inbuf);
 
   if (err == ERR_OK) {
     netbuf_data(inbuf, (void**)&buf, &buflen);
      // Terminate buffer string.
     *(buf+buflen) ='\0';
     DEBUG_MSG(DEBUG, ("Receveid HTTP request:\n%s\n", buf));
     char *base_url_begin, *base_url_end, *parameters_start;
     base_url(buf, &base_url_begin, &base_url_end, &parameters_start);
     // Dispatch page handler
     uint8_t i = 0;
     while ((i < number_of_page_handlers) &&
            strncmp(page_handlers[i].url, base_url_begin, 
                    base_url_end-base_url_begin)){
       i++;
     };
     if(i == number_of_page_handlers){
       // No handler for this URL. Return error page.
       const char error404[] =
         "HTTP/1.1 404 Not Found\r\n\r\n<html><head><title>Not Found!</title></head><body><h1>Not Found!</body></html>\r\n";
       netconn_write(conn, error404, sizeof(error404)-1, NETCONN_NOCOPY);
     }
     else{
       // Serve page
       (page_handlers[i].handler)(conn, base_url_begin, base_url_end,
                                  parameters_start);
     }
   }
   /* Close the connection (server closes in HTTP) */
   netconn_close(conn);
 
   /* Delete the buffer (netconn_recv gives us ownership,
      so we have to make sure to deallocate the buffer) */
   netbuf_delete(inbuf);
 }
 
 void http_server(void *pvParameters)
 {
   struct netconn *conn, *newconn;
   err_t err;
   conn = netconn_new(NETCONN_TCP);
   netconn_bind(conn, NULL, 80);
   netconn_listen(conn);
   do {
     err = netconn_accept(conn, &newconn);
     if (err == ERR_OK) {
       http_server_netconn_serve(newconn);
       netconn_delete(newconn);
     }
   } while(err == ERR_OK);
   netconn_close(conn);
   netconn_delete(conn);
 }
 
 /* }}} */