eaw/SharpKey
1
0
Fork 0
Code Issues Packages Projects Releases 1 Wiki Activity
Files
75a7bb2518f50031059204035c7e9b926bf67ada
SharpKey/main/WiFi.cpp

2940 lines
121 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Name: WiFi.cpp
// Created: Jan 2022
// Version: v1.0
// Author(s): Philip Smart
// Description: The WiFi AP/Client Interface.
// This source file contains the application logic to provide WiFi connectivity in
// order to allow remote query and configuration of the sharpkey interface.
//
// The module provides Access Point (AP) functionality to allow initial connection
// in order to configure local WiFi credentials.
//
// The module provides Client functionality, using the configured credentials,
// to connect to a local Wifi net and present a browser session for querying and
// mapping configuration of the sharpkey interface.
// Credits:
// Copyright: (c) 2022 Philip Smart <philip.smart@net2net.org>
//
// History: Jan 2022 - Initial write.
// Mar 2022 - Split out from main.cpp.
// v1.01 May 2022 - Initial release version.
// v1.02 Jun 2022 - Seperated out the WiFi Enable switch and made the WiFi module active
// via a reboot process. This is necessary now that Bluetooth is inbuilt
// as the ESP32 shares an antenna and both operating together electrically
// is difficult but also the IDF stack conflicts as well.
//
// Notes: See Makefile to enable/disable conditional components
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// This source file 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.
//
// This source file 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 this program. If not, see <http://www.gnu.org/licenses/>.
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// This is an optional compile time module, only compile if configured.
#include "sdkconfig.h"
#if defined(CONFIG_IF_WIFI_ENABLED)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <regex>
#include <filesystem>
#include <vector>
#include <algorithm>
#include <memory>
#include <unistd.h>
#include <map>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_ota_ops.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#include "Arduino.h"
#include "driver/gpio.h"
#include "soc/timer_group_struct.h"
#include "soc/timer_group_reg.h"
#include <sys/param.h>
#include "esp_tls_crypto.h"
#include <esp_http_server.h>
#include "esp_littlefs.h"
#include "WiFi.h"
// External reference to the SharpKey global configuration stored in NVS.
struct SharpKeyConfig {
struct {
uint8_t bootMode;
uint32_t hostMode;
} params;
};
extern struct SharpKeyConfig sharpKeyConfig;
#define SHARPKEY_NAME "SharpKey"
// FreeRTOS event group to signal when we are connected
static EventGroupHandle_t s_wifi_event_group;
// Template to convert a given type into a std::string.
//
template<typename Type> std::string to_str(const Type & t, int precision, int base)
{
// Locals.
//
std::ostringstream os;
if(precision != 0)
{
os << std::fixed << std::setw(precision) << std::setprecision(precision) << std::setfill('0') << t;
} else
{
if(base == 16)
{
os << "0x" << std::hex << t;
} else
{
os << t;
}
}
return os.str();
}
// Method to convert the idf internal partition type to a readable string for output to the browser.
//
std::string WiFi::esp32PartitionType(esp_partition_type_t type)
{
// Locals.
//
std::string result = "Unknown";
switch(static_cast<int>(type))
{
case ESP_PARTITION_TYPE_APP:
result = "App";
break;
case ESP_PARTITION_TYPE_DATA:
result = "Data";
break;
default:
result = "n/a";
break;
}
// Return the string version of the enum.
return(result);
}
// Method to convert the idf internal partition subtype to a readable string for output to the browser.
//
std::string WiFi::esp32PartitionSubType(esp_partition_subtype_t subtype)
{
// Locals.
//
std::string result = "Unknown";
switch(static_cast<int>(subtype))
{
case ESP_PARTITION_SUBTYPE_APP_FACTORY:
result = "Factory";
break;
case ESP_PARTITION_SUBTYPE_DATA_PHY:
result = "phy";
break;
case ESP_PARTITION_SUBTYPE_DATA_NVS:
result = "nvs";
break;
case ESP_PARTITION_SUBTYPE_DATA_COREDUMP:
result = "core";
break;
case ESP_PARTITION_SUBTYPE_DATA_NVS_KEYS:
result = "nvs_keys";
break;
case ESP_PARTITION_SUBTYPE_DATA_EFUSE_EM:
result = "efuse";
break;
case ESP_PARTITION_SUBTYPE_DATA_ESPHTTPD:
result = "httpd";
break;
case ESP_PARTITION_SUBTYPE_DATA_FAT:
result = "fat";
break;
case ESP_PARTITION_SUBTYPE_DATA_SPIFFS:
result = "spiffs";
break;
case ESP_PARTITION_SUBTYPE_APP_OTA_0:
case ESP_PARTITION_SUBTYPE_APP_OTA_1:
case ESP_PARTITION_SUBTYPE_APP_OTA_2:
case ESP_PARTITION_SUBTYPE_APP_OTA_3:
case ESP_PARTITION_SUBTYPE_APP_OTA_4:
case ESP_PARTITION_SUBTYPE_APP_OTA_5:
case ESP_PARTITION_SUBTYPE_APP_OTA_6:
case ESP_PARTITION_SUBTYPE_APP_OTA_7:
case ESP_PARTITION_SUBTYPE_APP_OTA_8:
case ESP_PARTITION_SUBTYPE_APP_OTA_9:
case ESP_PARTITION_SUBTYPE_APP_OTA_10:
case ESP_PARTITION_SUBTYPE_APP_OTA_11:
case ESP_PARTITION_SUBTYPE_APP_OTA_12:
case ESP_PARTITION_SUBTYPE_APP_OTA_13:
case ESP_PARTITION_SUBTYPE_APP_OTA_14:
case ESP_PARTITION_SUBTYPE_APP_OTA_15:
case ESP_PARTITION_SUBTYPE_APP_OTA_MAX:
result = "ota_" + to_str(subtype - ESP_PARTITION_SUBTYPE_APP_OTA_MIN, 0, 10);
break;
default:
result = to_str(subtype, 0, 10);
break;
}
// Return the string version of the enum.
return(result);
}
// Method to return the version number of a given module.
float WiFi::getVersionNumber(std::string name)
{
// Locals.
//
int idx = 0;
// Loop through the version list looking for FilePack.
while(idx < wifiCtrl.run.versionList->elements && wifiCtrl.run.versionList->item[idx]->object.compare(name) != 0)
{
idx++;
}
// Return the version number if found.
return(idx == wifiCtrl.run.versionList->elements ? 0.00 : wifiCtrl.run.versionList->item[idx]->version);
}
// Method to request KeyMap table headers from the underlying interface and send as a Javascript array.
//
esp_err_t WiFi::sendKeyMapHeaders(httpd_req_t *req)
{
// Locals.
//
esp_err_t result = ESP_OK;
std::string jsArray;
std::vector<std::string> headerList;
// Call the underlying interface to fill the vector with a list of header names.
keyIf->getKeyMapHeaders(headerList);
// Build up a javascript array and send to the browser direct.
//
jsArray = "[";
for(std::size_t idx = 0; idx < headerList.size(); idx++)
{
jsArray.append("\"").append(headerList[idx]).append("\"");
if(idx == headerList.size()-1)
{
jsArray.append(",\"<i class=\\\"fa fa-check\\\"></i>\"]");
} else
{
jsArray.append(",");
}
}
// Send array and return result.
result=httpd_resp_send_chunk(req, jsArray.c_str(), jsArray.size());
// Send result, ESP_OK = all successful, anything else a transmission or data error occurred.
return(result);
}
// Method to request KeyMap table data types from the underlying interface and send as a Javascript array.
esp_err_t WiFi::sendKeyMapTypes(httpd_req_t *req)
{
// Locals.
//
int startPos;
esp_err_t result = ESP_OK;
std::string jsArray;
std::vector<std::string> typeList;
// Call the underlying interface to fill a vector with the type of each keymap column.
keyIf->getKeyMapTypes(typeList);
// Build up a javascript array containing the column types mapping if needed to an EditTable value.
//
jsArray = "[";
for(std::size_t idx = 0; idx < typeList.size(); idx++)
{
// Strip out the custom tag, (custom_ttp_ where tt = type, ie. rd = Radio, cb = Checkbox, p = polarity, p = positive, = negative) not needed, use as an internal marker to identify custom fields.
if((startPos = typeList[idx].find("custom_")) >= 0)
{
jsArray.append("\"").append(typeList[idx].substr(startPos+11, std::string::npos)).append("\"");
} else
{
jsArray.append("\"").append(typeList[idx]).append("\"");
}
if(idx == typeList.size()-1)
{
jsArray.append(",\"checkbox\"]");
} else
{
jsArray.append(",");
}
}
// Send array and return result.
result=httpd_resp_send_chunk(req, jsArray.c_str(), jsArray.size());
// Send result, ESP_OK = all successful, anything else a transmission or data error occurred.
return(result);
}
// Method to expand the custom type fields in the interface to custom fields in the EditTable configuration code.
// This code is injected into the javascript setup and will invoke a custom popover or select UI.
esp_err_t WiFi::sendKeyMapCustomTypeFields(httpd_req_t *req)
{
// Locals.
//
int startPos;
esp_err_t result = ESP_OK;
std::string typeStr = "";
std::vector<std::string> typeList;
// Call the underlying interface to fill a vector with the type of each keymap column.
keyIf->getKeyMapTypes(typeList);
for(std::size_t idx = 0; idx < typeList.size(); idx++)
{
// Custom field?
if((startPos = typeList[idx].find("custom")) >= 0)
{
// Find any duplicate by searching the vector just processed.
bool duplicate = false;
for(std::size_t idx2 = 0; idx2 < idx; idx2++) { if(typeList[idx].compare(typeList[idx2]) == 0) { duplicate = true; break; } }
if(duplicate) continue;
// Negative or positive value?
bool negate = (typeList[idx].substr(startPos+9, 1)[0] == 'p' ? false : true);
// Build the custom type definition which is injected into the javascript setup of EditTable.
typeStr += " '" + typeList[idx].substr(startPos+11, std::string::npos) + "' : { \n" +
" html: '<input type=\"text\" class=\"" + typeList[idx].substr(startPos+11, std::string::npos) + "\" data-placement=\"left\"/>', \n";
// As some of the interface parameters are negative active, if the 'custom' label is followed by a minus '-' this means the value sent or received needs to be negated.
// This is because the UI works in positive values. If the 'custom' label is followed by an underscore '_' then no data change is made.
typeStr.append(" getValue: function (input) { \n");
typeStr.append(" var $thisVal = $(input).val(); \n");
if(negate)
typeStr.append(" return hexConvert($thisVal, true);\n");
else
typeStr.append(" return hexConvert($thisVal, false);\n");
typeStr.append(" }, \n");
typeStr.append(" setValue: function (input, inVal) { \n");
if(negate)
typeStr.append(" var $thisVal = $(input).attr(\"value\", hexConvert(inVal, true));\n");
else
typeStr.append(" var $thisVal = $(input).attr(\"value\", hexConvert(inVal, false));\n");
typeStr.append(" return $thisVal; \n");
typeStr.append(" } \n");
typeStr.append(" },\n");
}
}
// Send array and return result.
result=httpd_resp_send_chunk(req, typeStr.c_str(), typeStr.size());
// Send result, ESP_OK = all successful, anything else a transmission or data error occurred.
return(result);
}
// Method to request KeyMap table entries, row at a time, from the underlying interface and send as a Javascript array.
// This method could involve large amounts of data which may overflow the heap so data is requested and sent row by row.
esp_err_t WiFi::sendKeyMapData(httpd_req_t *req)
{
// Locals.
//
esp_err_t result = ESP_OK;
bool startMode = true;
bool firstRow = true;
int row = 0;
std::string jsArray = "";
std::vector<uint32_t> data;
// Initiate a loop, calling the underlying interface to return data row by row until the end of the keymap data.
while(result == ESP_OK && keyIf->getKeyMapData(data, &row, startMode) == false)
{
// At start, we initialise the data retrieval and also setup the Javascript array designator.
if(startMode == true)
{
startMode = false;
jsArray = "[";
}
if(firstRow == false)
{
jsArray = ",";
} else
{
firstRow = false;
}
jsArray.append("[");
for(std::size_t idx = 0; idx < data.size(); idx++)
{
jsArray.append("\"").append(to_str(data[idx], 0, 16)).append("\"");
if(idx == data.size()-1)
{
jsArray.append(",false]");
} else
{
jsArray.append(",");
}
}
data.clear();
// Send array and return result.
result=httpd_resp_send_chunk(req, jsArray.c_str(), jsArray.size());
}
// At the end we need to close the javascript array designator. No way to do this in the loop as the data get method doesnt provide next state information.
if(result == ESP_OK)
{
jsArray = "]";
// Send array and return result.
result=httpd_resp_send_chunk(req, jsArray.c_str(), jsArray.size());
}
// Send result, ESP_OK = all successful, anything else a transmission or data error occurred.
return(result);
}
// Method for building up the popover modals which are used to enable a user to select values by tick rather than work out a hex value.
//
esp_err_t WiFi::sendKeyMapPopovers(httpd_req_t *req)
{
// Locals.
//
int startPos;
esp_err_t result = ESP_OK;
std::string jsArray;
std::string jsClass;
std::vector<std::string> headerList;
std::vector<std::string> typeList;
std::vector<std::pair<std::string, int>> selectList;
// Get list of column headers, these are used as the popover title.
keyIf->getKeyMapHeaders(headerList);
// Get list of types, these are needed to setup a popup for each custom field.
keyIf->getKeyMapTypes(typeList);
// Loop through the types, process any custom field into a popover modal.
for(std::size_t idx = 0; result == ESP_OK && idx < typeList.size(); idx++)
{
// Custom field? Skip if not custom type.
if((startPos = typeList[idx].find("custom_")) >= 0)
{
// Find any duplicate by searching the vector just processed.
bool duplicate = false;
for(std::size_t idx2 = 0; idx2 < idx; idx2++) { if(typeList[idx].compare(typeList[idx2]) == 0) { duplicate = true; break; } }
if(duplicate) continue;
jsClass = typeList[idx].substr(startPos+11, std::string::npos);
jsArray = "<div class=\"popover-markup\" id=\"popover-" + jsClass + "\">\n" +
" <div class=\"head hide\">" + headerList[idx] + "</div>\n" +
" <div class=\"content hide\">\n" +
" <form role=\"form\">\n" +
" <div class=\"row\">\n" +
" <div class=\"col-xs-6 col-md-8\">\n";
// Get the select list of values for the current custom type.
keyIf->getKeyMapSelectList(selectList, typeList[idx]);
// Add in all the check boxes.
if(typeList[idx].find("custom_cb") != std::string::npos)
{
for(auto iter = std::begin(selectList); iter != std::end(selectList); iter++)
{
jsArray.append(" <div class=\"checkbox\">\n")
.append(" <label>\n")
.append(" <input id=\"").append(jsClass).append("_").append(iter->first).append("\" type=\"checkbox\" data-value=\"").append(to_str(iter->second, 0, 10)).append("\"/> ").append(iter->first).append("\n")
.append(" </label>\n")
.append(" </div>\n");
}
}
else if(typeList[idx].find("custom_rd") != std::string::npos)
{
for(auto iter = std::begin(selectList); iter != std::end(selectList); iter++)
{
jsArray.append(" <div class=\"radio\">\n")
.append(" <label>\n")
.append(" <input id=\"").append(jsClass).append("_").append(iter->first).append("\" type=\"radio\" name=\"").append(jsClass).append("\" data-value=\"").append(to_str(iter->second, 0, 10)).append("\"/> ").append(iter->first).append("\n")
.append(" </label>\n")
.append(" </div>\n");
}
}
// Finish off by closing up the opened DIV blocks.
jsArray.append(" </div>\n")
.append(" </div>\n")
.append(" </form>\n")
.append(" </div>\n")
.append("</div>\n");
// Send array and return result.
result=httpd_resp_send_chunk(req, jsArray.c_str(), jsArray.size());
// Free up memory for next iteration.
selectList.clear();
}
}
// Send result, ESP_OK = all successful, anything else a transmission or data error occurred.
return(result);
}
// Method to render the radio select for Mouse Host Scaling.
//
esp_err_t WiFi::sendMouseRadioChoice(httpd_req_t *req, const char *option)
{
// Locals.
//
int startPos;
esp_err_t result = ESP_OK;
std::string typeStr = "";
std::string typeHead = "";
std::string typeBody = "";
std::vector<std::string> typeList;
std::vector<std::pair<std::string, int>> selectList;
KeyInterface *activeMouseIf = (mouseIf == NULL ? keyIf : mouseIf);
// Call the underlying interface to fill a vector with the type of config parameters.
activeMouseIf->getMouseConfigTypes(typeList);
for(std::size_t idx = 0; idx < typeList.size(); idx++)
{
// Custom field?
if((startPos = typeList[idx].find(option)) >= 0)
{
// Find any duplicate by searching the vector just processed.
bool duplicate = false;
for(std::size_t idx2 = 0; idx2 < idx; idx2++) { if(typeList[idx].compare(typeList[idx2]) == 0) { duplicate = true; break; } }
if(duplicate) continue;
// Get the select list of values for the current config type.
activeMouseIf->getMouseSelectList(selectList, typeList[idx]);
typeStr.append("<div class=\"form-check form-check-inline\">\n");
for(auto iter = std::begin(selectList); iter != std::end(selectList); iter++)
{
// Skip current value item.
if(iter == std::begin(selectList)) continue;
typeStr.append(" <input class=\"form-check-input radio-mouse\" id=\"").append(typeList[idx]).append("_").append(iter->first).append("\" type=\"radio\" name=\"").append(typeList[idx]).append("\" value=\"").append(to_str(iter->second, 0, 10)).append("\"").append(selectList[0].second == iter->second ? "checked" : "").append("/>")
.append(" <label class=\"form-check-label radio-mouse\" for=\"").append(typeList[idx]).append("_").append(iter->first).append("\">").append(iter->first).append("</label>\n");
}
typeStr.append("</div><br>");
}
}
// Send array and return result.
result=httpd_resp_send_chunk(req, typeStr.c_str(), typeStr.size());
// Send result, ESP_OK = all successful, anything else a transmission or data error occurred.
return(result);
}
// Method to expand variable macros into variable values within a string buffer. The buffer will contain HTML/CSS text prior to despatch to a browser.
//
esp_err_t WiFi::expandVarsAndSend(httpd_req_t *req, std::string str)
{
// Fast path: template variables are always prefixed "%SK_".
// A line with no "%SK_" cannot contain any template variable, so skip the
// expensive pairs build (which includes flash partition enumeration via
// esp_partition_find / esp_ota_get_partition_description) and send directly.
if(str.find("%SK_") == std::string::npos)
{
str += "\n";
return httpd_resp_send_chunk(req, str.c_str(), str.length());
}
// Locals.
//
bool largeMacroDetected = false;
int startPos;
t_kvPair keyValue;
esp_err_t result = ESP_OK;
std::vector<t_kvPair> pairs;
// Build up the list of pairs, place holder to value, this is used to expand the given string with latest runtime values.
// Certain macros return a lot of data so they cannot be added into the mapping vector due to RAM constraints, these are handled in-situ.
//
keyValue.name = "%SK_WIFIMODEAP%"; keyValue.value = (wifiCtrl.run.wifiMode == WIFI_CONFIG_AP ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_WIFIMODECLIENT%"; keyValue.value = (wifiCtrl.run.wifiMode == WIFI_CONFIG_CLIENT ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_CLIENTSSID%"; keyValue.value = wifiConfig.clientParams.ssid; pairs.push_back(keyValue);
keyValue.name = "%SK_CLIENTPWD%"; keyValue.value = wifiConfig.clientParams.pwd; pairs.push_back(keyValue);
keyValue.name = "%SK_CLIENTDHCPON%"; keyValue.value = (wifiConfig.clientParams.useDHCP == true ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_CLIENTDHCPOFF%"; keyValue.value = (wifiConfig.clientParams.useDHCP == false ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_CLIENTIP%"; keyValue.value = wifiConfig.clientParams.ip; pairs.push_back(keyValue);
keyValue.name = "%SK_CLIENTNM%"; keyValue.value = wifiConfig.clientParams.netmask; pairs.push_back(keyValue);
keyValue.name = "%SK_CLIENTGW%"; keyValue.value = wifiConfig.clientParams.gateway; pairs.push_back(keyValue);
keyValue.name = "%SK_APSSID%"; keyValue.value = wifiConfig.apParams.ssid; pairs.push_back(keyValue);
keyValue.name = "%SK_APPWD%"; keyValue.value = wifiConfig.apParams.pwd; pairs.push_back(keyValue);
keyValue.name = "%SK_APIP%"; keyValue.value = wifiConfig.apParams.ip; pairs.push_back(keyValue);
keyValue.name = "%SK_APNM%"; keyValue.value = wifiConfig.apParams.netmask; pairs.push_back(keyValue);
keyValue.name = "%SK_APGW%"; keyValue.value = wifiConfig.apParams.gateway; pairs.push_back(keyValue);
keyValue.name = "%SK_CURRENTSSID%"; keyValue.value = (wifiCtrl.run.wifiMode == WIFI_CONFIG_AP ? wifiCtrl.ap.ssid : wifiCtrl.client.ssid); pairs.push_back(keyValue);
keyValue.name = "%SK_CURRENTPWD%"; keyValue.value = (wifiCtrl.run.wifiMode == WIFI_CONFIG_AP ? wifiCtrl.ap.pwd : wifiCtrl.client.pwd); pairs.push_back(keyValue);
keyValue.name = "%SK_CURRENTIP%"; keyValue.value = (wifiCtrl.run.wifiMode == WIFI_CONFIG_AP ? wifiCtrl.ap.ip : wifiCtrl.client.ip); pairs.push_back(keyValue);
keyValue.name = "%SK_CURRENTNM%"; keyValue.value = (wifiCtrl.run.wifiMode == WIFI_CONFIG_AP ? wifiCtrl.ap.netmask : wifiCtrl.client.netmask); pairs.push_back(keyValue);
keyValue.name = "%SK_CURRENTGW%"; keyValue.value = (wifiCtrl.run.wifiMode == WIFI_CONFIG_AP ? wifiCtrl.ap.gateway : wifiCtrl.client.gateway); pairs.push_back(keyValue);
keyValue.name = "%SK_CURRENTIF%"; keyValue.value = keyIf->ifName().append(" "); pairs.push_back(keyValue);
keyValue.name = "%SK_SECONDIF%"; keyValue.value = (mouseIf != NULL ? mouseIf->ifName().append(" ") : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_AUTO%"; keyValue.value = (sharpKeyConfig.params.hostMode == 0 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_MZ2500%"; keyValue.value = (sharpKeyConfig.params.hostMode == 2500 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_MZ2800%"; keyValue.value = (sharpKeyConfig.params.hostMode == 2800 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_X1%"; keyValue.value = (sharpKeyConfig.params.hostMode == 1 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_X68000%"; keyValue.value = (sharpKeyConfig.params.hostMode == 68000 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_MZ5600%"; keyValue.value = (sharpKeyConfig.params.hostMode == 5600 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_PC9801%"; keyValue.value = (sharpKeyConfig.params.hostMode == 9801 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_HOSTMODE_MOUSE%"; keyValue.value = (sharpKeyConfig.params.hostMode == 2 ? "checked" : ""); pairs.push_back(keyValue);
keyValue.name = "%SK_REBOOTBUTTON%"; keyValue.value = (wifiCtrl.run.rebootButton == true ? "block" : "none"); pairs.push_back(keyValue);
keyValue.name = "%SK_ERRMSG%"; keyValue.value = wifiCtrl.run.errorMsg; pairs.push_back(keyValue);
keyValue.name = "%SK_PRODNAME%"; keyValue.value = (wifiCtrl.run.versionList->elements > 1 ? wifiCtrl.run.versionList->item[0]->object : "Unknown"); pairs.push_back(keyValue);
keyValue.name = "%SK_PRODVERSION%"; keyValue.value = (wifiCtrl.run.versionList->elements > 1 ? to_str(wifiCtrl.run.versionList->item[0]->version, 2, 10) : "Unknown"); pairs.push_back(keyValue);
keyValue.name = "%SK_MODULES%"; if(wifiCtrl.run.versionList->elements > 1)
{
std::ostringstream list;
list << "<table class=\"table table-borderless table-sm\"><tbody><tr>";
for(int idx=0, cols=0; idx < wifiCtrl.run.versionList->elements; idx++)
{
// Ignore SharpKey/FilePack, they are part of our version list but not relevant as a module.
if(wifiCtrl.run.versionList->item[idx]->object.compare("SharpKey") == 0 || wifiCtrl.run.versionList->item[idx]->object.compare("FilePack") == 0)
continue;
if((cols++ % 6) == 0)
{
list << "</tr>";
if(idx < wifiCtrl.run.versionList->elements) { list << "<tr>"; }
}
list << "<td><span style=\"color: blue;\">" << wifiCtrl.run.versionList->item[idx]->object << "</span> <i>(v" << to_str(wifiCtrl.run.versionList->item[idx]->version, 2, 10) << ")&nbsp;&nbsp;&nbsp;</i></td> ";
}
list << "</tr></tbody?></table>";
keyValue.value = list.str();
} else { keyValue.value = "Unknown"; }; pairs.push_back(keyValue);
keyValue.name = "%SK_FILEPACK%"; {
std::ostringstream list;
list << "<table class=\"table table-borderless table-sm\"><tbody><tr>";
list << "<td><span style=\"color: blue;\">FilePack</span> <i>(v" << to_str(getVersionNumber("FilePack"), 2, 10) << ")</i></td> ";
list << "</tr></tbody?></table>";
keyValue.value = list.str();
} pairs.push_back(keyValue);
keyValue.name = "%SK_PARTITIONS%"; {
std::ostringstream list;
const esp_partition_t *runPart = esp_ota_get_running_partition();
esp_partition_iterator_t it;
it = esp_partition_find(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
esp_err_t err;
esp_app_desc_t appDesc;
for (; it != NULL; it = esp_partition_next(it)) {
const esp_partition_t *part = esp_partition_get(it);
err = esp_ota_get_partition_description(part, &appDesc);
list << "<tr>"
<< "<td>" << part->label << "</td>"
<< "<td>" << esp32PartitionType(part->type) << "</td>"
<< "<td>" << esp32PartitionSubType(part->subtype) << "</td>"
<< "<td>" << to_str(part->address, 0, 16) << "</td>"
<< "<td>" << to_str(part->size, 0, 16) << "</td>"
<< "<td>" << (err == ESP_OK ? appDesc.version : part->subtype == ESP_PARTITION_SUBTYPE_DATA_SPIFFS ? to_str(getVersionNumber("FilePack"), 2, 10) : "") << "</td>"
<< "<td>" << (err == ESP_OK ? appDesc.date : "") << " "
<< (err == ESP_OK ? appDesc.time : "") << "</td>"
<< "<td>" << (runPart->address == part->address ? "Yes" : "") << "</td>"
<< "</tr>";
}
esp_partition_iterator_release(it);
keyValue.value = list.str();
} pairs.push_back(keyValue);
keyValue.name = "%SK_KEYMAPHEADER%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_KEYMAPTYPES%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_KEYMAPJSFIELDS%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_KEYMAPDATA%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_KEYMAPPOPOVER%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_MOUSEHOSTSCALING%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_MOUSEPS2SCALING%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_MOUSEPS2RESOLUTION%"; keyValue.value = ""; pairs.push_back(keyValue);
keyValue.name = "%SK_MOUSEPS2SAMPLERATE%"; keyValue.value = ""; pairs.push_back(keyValue);
// Go through list of place holders to expand and replace.
//
for(auto pair : pairs)
{
// If the varname exists, replace with value.
if((startPos = str.find(pair.name)) >= 0)
{
// Dont expand large data macros yet, they can potentially generate too much data for the limited ESP32 RAM.
if(pair.name.compare("%SK_KEYMAPHEADER%") != 0 && pair.name.compare("%SK_KEYMAPTYPES%") != 0 && pair.name.compare("%SK_KEYMAPDATA%") != 0 &&
pair.name.compare("%SK_KEYMAPJSFIELDS%") != 0 && pair.name.compare("%SK_KEYMAPPOPOVER%") != 0 && pair.name.compare("%SK_MOUSEHOSTSCALING%") != 0 &&
pair.name.compare("%SK_MOUSEPS2SCALING%") != 0 && pair.name.compare("%SK_MOUSEPS2RESOLUTION%") != 0 && pair.name.compare("%SK_MOUSEPS2SAMPLERATE%") != 0
)
{
str.replace(startPos, pair.name.length(), pair.value);
} else
{
largeMacroDetected = true;
}
}
}
// Complete line ready for transmission.
str.append("\n");
// Normal macros have been expanded, if no large macros were detected, send the expanded string and return.
//
if(largeMacroDetected == false)
{
// Send as a chunk to the browser.
if(str.size() > 0)
{
result=httpd_resp_send_chunk(req, str.c_str(), str.size());
}
} else
{
// Repeat the key:value search, locating the large macro, only 1 is allowed per line.
for(auto pair : pairs)
{
// If the macro name exists, process, it will be the large macro, only 1 allowed per line.
if((startPos = str.find(pair.name)) >= 0)
{
// Ease of reading.
int endMacroPos = startPos+pair.name.size();
int sizeMacro = pair.name.size();
int sizeEndStr = str.size() - startPos - sizeMacro;
if(sizeEndStr < 0) sizeEndStr = 0;
// Send the first part of the string upto but excluding the macro.
if(startPos > 0)
result=httpd_resp_send_chunk(req, str.substr(0, startPos).c_str(), startPos);
if(result == ESP_OK)
{
// Keymap Table header. The underlying interface converts its keyboard mapping table into a javascript format list of column headers.
if(pair.name.compare("%SK_KEYMAPHEADER%") == 0)
{
result = sendKeyMapHeaders(req);
}
// Keymap Table types. The underlying interface converts its keyboard mapping table into a javascript format list of column types.
if(pair.name.compare("%SK_KEYMAPTYPES%") == 0)
{
result = sendKeyMapTypes(req);
}
// Keymap field definition for custom fields.
if(pair.name.compare("%SK_KEYMAPJSFIELDS%") == 0)
{
result = sendKeyMapCustomTypeFields(req);
}
// Keymap Table data. This is the big one where the underlying interface converts its keyboard mapping table into a javascript format list of column types.
if(pair.name.compare("%SK_KEYMAPDATA%") == 0)
{
result = sendKeyMapData(req);
}
// Popover boxes, aid data input in a more user friendly manner.
if(pair.name.compare("%SK_KEYMAPPOPOVER%") == 0)
{
result = sendKeyMapPopovers(req);
}
// Mouse host scaling - Radio selection of the scaling required for adaption of the PS/2 mouse data to host.
if(pair.name.compare("%SK_MOUSEHOSTSCALING%") == 0)
{
result = sendMouseRadioChoice(req, "host_scaling");
}
if(pair.name.compare("%SK_MOUSEPS2SCALING%") == 0)
{
result = sendMouseRadioChoice(req, "mouse_scaling");
}
if(pair.name.compare("%SK_MOUSEPS2RESOLUTION%") == 0)
{
result = sendMouseRadioChoice(req, "mouse_resolution");
}
if(pair.name.compare("%SK_MOUSEPS2SAMPLERATE%") == 0)
{
result = sendMouseRadioChoice(req, "mouse_sampling");
}
// If the input string had any data after the macro then send it to complete transmission.
if(result == ESP_OK && sizeEndStr > 0)
{
result=httpd_resp_send_chunk(req, str.substr(endMacroPos, std::string::npos).c_str(), sizeEndStr);
}
}
break;
}
}
}
// Debug, track heap size.
ESP_LOGD(WIFITAG, "After expansion Free Heap (%d)", xPortGetFreeHeapSize());
// Return result of expansion/transmission.
return(result);
}
// A method to open and read a file line by line, expanding any macros therein and sending the result to the open socket connection.
//
esp_err_t WiFi::expandAndSendFile(httpd_req_t *req, const char *basePath, std::string fileName)
{
// Locals.
//
std::string line;
std::ifstream inFile;
esp_err_t result = ESP_OK;
// Build the FQFN for reading.
std::string fqfn = basePath; fqfn += "/"; fqfn += fileName;
// Ensure the content type is set correctly.
setContentTypeFromFileType(req, fileName);
// Read the entire file in one filesystem operation — dramatically faster than
// getline() per line (each getline triggers a separate fread, ~2-3ms per call;
// a 300-line file would cost 600-900ms in filesystem I/O alone).
inFile.open(fqfn.c_str());
if(!inFile.is_open())
{
httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File does not exist");
return(ESP_FAIL);
}
std::string contents((std::istreambuf_iterator<char>(inFile)), std::istreambuf_iterator<char>());
inFile.close();
if(contents.find("%SK_") == std::string::npos)
{
// No template variables — send entire file as a single HTTP chunk.
result = httpd_resp_send_chunk(req, contents.c_str(), contents.length());
if(result == ESP_OK)
result = httpd_resp_send_chunk(req, NULL, 0);
}
else
{
// Template variables present — process line by line from the in-memory
// string (no filesystem I/O per line).
std::istringstream stream(contents);
while(result == ESP_OK && std::getline(stream, line))
{
if((result = expandVarsAndSend(req, line)) != ESP_OK)
{
httpd_resp_sendstr_chunk(req, NULL);
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to send file");
break;
}
}
if(result == ESP_OK)
{
result = httpd_resp_send_chunk(req, NULL, 0);
}
}
return(result);
}
bool WiFi::isFileExt(std::string fileName, std::string extension)
{
// Locals.
//
bool result = false;
// Match the extension.
if(strcasecmp(fileName.substr(fileName.find_last_of(".")).c_str(), extension.substr(extension.find_last_of(".")).c_str()) == 0)
{
// If this is a multi part extension, match the whole extension too.
//
result = true;
if(extension.find_first_of(".") != extension.find_last_of(".") && strcasecmp(fileName.substr(fileName.find_first_of(".")).c_str(), extension.c_str()) != 0)
{
result = false;
}
}
// Extension match?
return(result);
}
// Method to set the HTTP response content type according to file extension.
//
esp_err_t WiFi::setContentTypeFromFileType(httpd_req_t *req, std::string fileName)
{
if (isFileExt(fileName, ".pdf"))
{
return httpd_resp_set_type(req, "application/pdf");
}
else if (isFileExt(fileName, ".html"))
{
return httpd_resp_set_type(req, "text/html");
}
else if (isFileExt(fileName, ".css"))
{
return httpd_resp_set_type(req, "text/css");
}
else if (isFileExt(fileName, ".js"))
{
return httpd_resp_set_type(req, "application/javascript");
}
else if (isFileExt(fileName, ".ico"))
{
return httpd_resp_set_type(req, "image/x-icon");
}
else if (isFileExt(fileName, ".jpeg") || isFileExt(fileName, ".jpg"))
{
return httpd_resp_set_type(req, "image/jpeg");
}
else if (isFileExt(fileName, ".bin"))
{
return httpd_resp_set_type(req, "application/octet-stream");
}
else if (isFileExt(fileName, ".bmp"))
{
return httpd_resp_set_type(req, "image/bmp");
}
else if (isFileExt(fileName, ".gif"))
{
return httpd_resp_set_type(req, "image/gif");
}
else if (isFileExt(fileName, ".jar"))
{
return httpd_resp_set_type(req, "application/java-archive");
}
else if (isFileExt(fileName, ".js"))
{
return httpd_resp_set_type(req, "text/javascript");
}
else if (isFileExt(fileName, ".json"))
{
return httpd_resp_set_type(req, "application/json");
}
else if (isFileExt(fileName, ".png"))
{
return httpd_resp_set_type(req, "image/png");
}
else if (isFileExt(fileName, ".php"))
{
return httpd_resp_set_type(req, "application/x-httod-php");
}
else if (isFileExt(fileName, ".rtf"))
{
return httpd_resp_set_type(req, "application/rtf");
}
else if (isFileExt(fileName, ".tif") || isFileExt(fileName, ".tiff"))
{
return httpd_resp_set_type(req, "image/tiff");
}
else if (isFileExt(fileName, ".txt"))
{
return httpd_resp_set_type(req, "text/plain");
}
else if (isFileExt(fileName, ".xml"))
{
return httpd_resp_set_type(req, "application/xml");
}
else if (isFileExt(fileName, ".ico")) {
return httpd_resp_set_type(req, "image/x-icon");
}
// Default to plain text.
return httpd_resp_set_type(req, "text/plain");
}
// Locates the path within URI anc copies it into a string.
//
esp_err_t WiFi::getPathFromURI(std::string& destPath, std::string& destFile, const char *basePath, const char *uri)
{
// Locals.
//
size_t pathlen = strlen(uri);
const char *question = strchr(uri, '?');
const char *hash = strchr(uri, '#');
// Question in the URI - skip.
if(question)
{
pathlen = MIN(pathlen, question - uri);
}
// Hash in the URI - skip.
if(hash)
{
pathlen = MIN(pathlen, hash - uri);
}
// Construct full path (base + path)
destPath = basePath;
destPath.append(uri, pathlen);
// Extract filename.
destFile = "";
destFile.append(uri, 1, pathlen-1);
// Result, fail if no path extracted.
return(destFile.size() == 0 ? ESP_FAIL : ESP_OK);
}
// Overloaded method to get the remaining URI from the triggering base path.
//
esp_err_t WiFi::getPathFromURI(std::string& destPath, const char *basePath, const char *uri)
{
// Locals.
//
esp_err_t result = ESP_OK;
size_t pathlen = strlen(uri);
const char *question = strchr(uri, '?');
const char *hash = strchr(uri, '#');
// Question in the URI - skip.
if(question)
{
pathlen = MIN(pathlen, question - uri);
}
// Hash in the URI - skip.
if(hash)
{
pathlen = MIN(pathlen, hash - uri);
}
// Extract the path without starting base path and without trailing variables.
destPath = "";
destPath.append(uri, pathlen);
result = (destPath.find(basePath) != std::string::npos ? ESP_OK : ESP_FAIL);
if(result == ESP_OK)
{
destPath.erase(0, strlen(basePath));
}
// Result, fail if no base path was found.
return(result);
}
// Handler to read and send static files. HTML/CSS are expanded with embedded vars.
//
esp_err_t WiFi::defaultFileHandler(httpd_req_t *req)
{
// Locals.
//
FILE *fd = NULL;
struct stat file_stat;
char *buf;
int bufLen;
esp_err_t result = ESP_OK;
std::string gzipFile = "";
std::string disposition = "";
// Per-request local variables — the shared wifiCtrl.session struct must NOT be
// used here because multiple requests are handled concurrently by esp_http_server.
// Using the shared session caused a race condition where parallel requests
// overwrote each other's filePath/fileName/gzip fields, leaving some responses
// stuck forever in "pending" state.
std::string localFilePath;
std::string localFileName;
bool localGzip = false;
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Close connection after each file response. The server is single-threaded —
// while sending a large file (e.g. 98KB font), all other requests are blocked.
// With keep-alive, the browser queues subsequent requests on existing connections
// that may be stalled behind a large transfer, leaving them "pending" forever.
// With Connection:close, the browser opens fresh connections for each resource.
httpd_resp_set_hdr(req, "Connection", "close");
// Get encoding methods.
bufLen = httpd_req_get_hdr_value_len(req, "Accept-Encoding") + 1;
if(bufLen > 1)
{
buf = new char[bufLen];
if(httpd_req_get_hdr_value_str(req, "Accept-Encoding", buf, bufLen) == ESP_OK)
{
localGzip = (strstr(buf, "gzip") != NULL ? true : false);
}
delete buf;
}
// Look for a filename in the URI and construct the file path returning both.
if(pThis->getPathFromURI(localFilePath, localFileName, pThis->wifiCtrl.run.basePath, req->uri) == ESP_FAIL)
{
if(strlen(req->uri) == 1 && req->uri[0] == '/')
{
localFileName = "/";
} else
{
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filename invalid");
return(ESP_FAIL);
}
}
// See if the provided name matches a static handler, such as root.
if(localFileName.compare("/") == 0 || localFileName.compare("index.html") == 0 || localFileName.compare("index.htm") == 0)
{
return pThis->expandAndSendFile(req, pThis->wifiCtrl.run.basePath, "index.html");
}
// Is this a macro to specify keymap file?
if(localFileName.compare("keymap") == 0)
{
localFileName = std::regex_replace(localFileName, std::regex("keymap"), pThis->keyIf->getKeyMapFileName());
localFilePath = std::regex_replace(localFilePath, std::regex("keymap"), pThis->keyIf->getKeyMapFileName());
disposition = "attachment; filename=" + pThis->keyIf->getKeyMapFileName();
if(httpd_resp_set_hdr(req, "Content-Disposition", disposition.c_str()) != ESP_OK)
{
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Set content disposition filename failed");
return(ESP_FAIL);
}
}
// Get details of the file, throw error 404 - File Not Found on error.
if(stat(localFilePath.c_str(), &file_stat) == -1)
{
if(localGzip)
gzipFile = localFilePath + ".gz";
if(localGzip == true && stat(gzipFile.c_str(), &file_stat) == -1)
{
httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File does not exist");
return(ESP_FAIL);
}
if(httpd_resp_set_hdr(req, "Content-Encoding", "gzip") != ESP_OK)
{
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Set content encoding to gzip failed");
return(ESP_FAIL);
}
}
// If the file is HTML, JS or CSS then process externally as we need to substitute embedded variables.
// Guard around gzipFile.size: gzipped html/js/css cannot be parsed, served 'as is'.
if((pThis->isFileExt(localFileName, ".html") || (pThis->isFileExt(localFileName, ".js") && !pThis->isFileExt(localFileName, ".min.js")) || (pThis->isFileExt(localFileName, ".css") && !pThis->isFileExt(localFileName, ".min.css"))) && gzipFile.size() == 0)
{
result = pThis->expandAndSendFile(req, pThis->wifiCtrl.run.basePath, localFileName);
} else
{
fd = fopen(gzipFile.size() > 0 ? gzipFile.c_str() : localFilePath.c_str(), "r");
if(!fd)
{
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read existing file");
return(ESP_FAIL);
}
ESP_LOGI(WIFITAG, "Sending %sfile : %s (%ld bytes)...", gzipFile.size() > 0 ? "gzip " : " ", localFileName.c_str(), file_stat.st_size);
pThis->setContentTypeFromFileType(req, localFileName);
// Use smart pointer to prevent leaks on error paths.
std::unique_ptr<char[]> chunk(new (std::nothrow) char[MAX_CHUNK_SIZE]);
if(chunk == nullptr)
{
ESP_LOGE(WIFITAG, "Memory exhausted in defaultFileHandler — closing socket");
fclose(fd);
int sockFd = httpd_req_to_sockfd(req);
if(sockFd != -1) close(sockFd);
return(ESP_FAIL);
}
size_t chunksize;
do {
chunksize = fread(chunk.get(), 1, MAX_CHUNK_SIZE, fd);
if(chunksize > 0)
{
if(httpd_resp_send_chunk(req, chunk.get(), chunksize) != ESP_OK)
{
result = ESP_FAIL;
httpd_resp_send_chunk(req, NULL, 0);
int sockFd = httpd_req_to_sockfd(req);
if(sockFd != -1) close(sockFd);
}
}
} while(chunksize != 0 && result == ESP_OK);
fclose(fd);
ESP_LOGI(WIFITAG, "File sending complete");
}
// Respond with an empty chunk to signal HTTP response completion.
if(result == ESP_OK)
httpd_resp_send_chunk(req, NULL, 0);
return result;
}
// Handler to send data sets. The handler is triggered on the /data URI and subpaths define the data to be sent.
//
esp_err_t WiFi::defaultDataGETHandler(httpd_req_t *req)
{
// Locals.
//
char *buf;
int bufLen;
esp_err_t result = ESP_OK;
std::string uriStr;
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Get required Header values for processing.
bufLen = httpd_req_get_hdr_value_len(req, "Host") + 1;
if(bufLen > 1)
{
buf = new char[bufLen];
// Copy null terminated value string into buffer
if(httpd_req_get_hdr_value_str(req, "Host", buf, bufLen) == ESP_OK)
{
// Assign to control structure for later use.
pThis->wifiCtrl.session.host = buf;
}
// Free up memory to complete.
delete buf;
}
// Get and store the URL query string.
bufLen = httpd_req_get_url_query_len(req) + 1;
if (bufLen > 1)
{
buf = new char[bufLen];
if (httpd_req_get_url_query_str(req, buf, bufLen) == ESP_OK)
{
pThis->wifiCtrl.session.queryStr = buf;
ESP_LOGI(WIFITAG, "Found URL query => %s", pThis->wifiCtrl.session.queryStr.c_str());
}
// Free up memory to complete.
delete buf;
}
// Get the subpath from the URI.
if(pThis->getPathFromURI(uriStr, "/data/", req->uri) == ESP_FAIL)
{
// Respond with 500 Internal Server Error.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to extract URI");
return(ESP_FAIL);
}
// Match URI and execute required data retrieval and return.
if(uriStr.compare("keymap/table/headers") == 0)
{
result = pThis->sendKeyMapHeaders(req);
} else
if(uriStr.compare("keymap/table/types") == 0)
{
result = pThis->sendKeyMapTypes(req);
} else
if(uriStr.compare("keymap/table/data") == 0)
{
result = pThis->sendKeyMapData(req);
} else
{
result = ESP_FAIL;
}
// Check the result, if the data send failed we need to tidy up and send an error code.
if(result != ESP_OK)
{
// Abort sending file.
httpd_resp_sendstr_chunk(req, NULL);
// Respond with 500 Internal Server Error.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to send data.");
} else
{
// Successful, end the response with a NULL string.
result = httpd_resp_send_chunk(req, NULL, 0);
}
// Return result, successful data send == ESP_OK.
return(result);
}
// A method, activated on a client side POST using AJAX file upload, to accept incoming data and write it into the next free OTA partition. If successful
// set the active partition to the newly loaded one.
//
IRAM_ATTR esp_err_t WiFi::otaFirmwareUpdatePOSTHandler(httpd_req_t *req)
{
// Locals.
//
esp_err_t ret = ESP_OK;
std::string resp = "";
bool checkImageHeader = true;
esp_ota_handle_t updateHandle = 0 ;
esp_app_desc_t newAppInfo;
esp_app_desc_t runningAppInfo;
esp_app_desc_t invalidAppInfo;
const esp_partition_t *lastInvalidApp;
const esp_partition_t *runningApp;
const esp_partition_t *updatePartition;
// Retrieve pointer to object in order to access data.
//WiFi* pThis = (WiFi*)req->user_ctx;
// Get current configuration and next available partition in round-robin style.
lastInvalidApp = esp_ota_get_last_invalid_partition();
runningApp = esp_ota_get_running_partition();
updatePartition = esp_ota_get_next_update_partition(NULL);
if(runningApp == NULL || updatePartition == NULL)
{
// Respond with 500 Internal Server Error as we couldnt get primary information on running partition or next available partition for update.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to resolve current/next NVS OTA partition information.");
return(ESP_FAIL);
}
// Allocate heap space for our receive buffer.
//
char *chunk = new char[MAX_CHUNK_SIZE];
size_t chunkSize;
// Use the Content length as the size of the file to be uploaded.
int remaining = req->content_len;
// Loop while data is still expected.
while(remaining > 0)
{
ESP_LOGI(WIFITAG, "Remaining size : %d", remaining);
// The file is received in chunks according to the free memory available for a buffer. It has to be at least the size of the firmware application header
// so that it can be read and evaluated in one chunk.
if((chunkSize = httpd_req_recv(req, chunk, MIN(remaining, MAX_CHUNK_SIZE))) <= 0)
{
// Retry if timeout occurred.
if (chunkSize == HTTPD_SOCK_ERR_TIMEOUT)
continue;
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error when a file error occurs.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
return(ESP_FAIL);
}
// If this is the first read, check the header information and make sure we are not uploading a bad file or one the same as the current image.
//
if(checkImageHeader == true)
{
// The size should be at least that of the application header structures.
//
if (chunkSize > sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t))
{
// Check current version being downloaded.
memcpy(&newAppInfo, &chunk[sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t)], sizeof(esp_app_desc_t));
if(newAppInfo.magic_word != ESP_APP_DESC_MAGIC_WORD)
{
// Release memory, error!!
delete chunk;
/* Respond with 500 Internal Server Error */
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "File image is not a valid firmware file.");
return(ESP_FAIL);
}
// Get information on the running application image.
if(esp_ota_get_partition_description(runningApp, &runningAppInfo) == ESP_OK)
{
ESP_LOGI(WIFITAG, "Running firmware version: %s, new: %s", runningAppInfo.version, newAppInfo.version);
}
// Compare and make sure we are not trying to upload the same image as the running image.
if(strcmp(newAppInfo.version, runningAppInfo.version) == 0)
{
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error - Same firmware version as running image being uploaded.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Firmware version is same as current version.");
return(ESP_FAIL);
}
// This part is crucial. If a previous image upload failed to boot, it is marked as bad and the previous working image is rebooted.
// Checks need to be made to ensure we are not trying to upload the same bad image as we may not be so lucky next time detecting it as bad!
//
if (esp_ota_get_partition_description(lastInvalidApp, &invalidAppInfo) == ESP_OK)
{
ESP_LOGI(WIFITAG, "Last invalid firmware version: %s", invalidAppInfo.version);
}
// Check current version with last invalid partition version. On first factory load there wont be a last partition.
if(lastInvalidApp != NULL)
{
if (memcmp(invalidAppInfo.version, newAppInfo.version, sizeof(newAppInfo.version)) == 0)
{
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error - New image is a previous bad image, cannot upload.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Firmware version is known as bad, it previously failed to boot.");
return(ESP_FAIL);
}
}
// Dont repeat the check!
checkImageHeader = false;
// Start the update procedure, data is written as it arrives from the client in chunks.
ret = esp_ota_begin(updatePartition, OTA_WITH_SEQUENTIAL_WRITES, &updateHandle);
if(ret != ESP_OK)
{
esp_ota_abort(updateHandle);
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error - Failed to initialise NVS for writing.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to initialise NVS OTA partition for writing.");
return(ESP_FAIL);
}
} else
{
esp_ota_abort(updateHandle);
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error - Failed to receive sufficient bytes from file to identify header.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive sufficient bytes from file to identify image.");
return(ESP_FAIL);
}
}
// Write out this chunk of data.
ret = esp_ota_write( updateHandle, (const void *)chunk, chunkSize);
if(ret != ESP_OK)
{
esp_ota_abort(updateHandle);
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error - Failed to write packet to NVS OTA partition.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write data to NVS partition.");
return(ESP_FAIL);
}
// Keep track of remaining size to download.
remaining -= chunkSize;
}
// Release memory, all done!
delete chunk;
// Complete the NVS write transaction.
ret = esp_ota_end(updateHandle);
if(ret != ESP_OK)
{
if(ret == ESP_ERR_OTA_VALIDATE_FAILED)
{
// Respond with 500 Internal Server Error - Image validation failed.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Image validation failed, image is corrupt.");
return(ESP_FAIL);
} else
{
// Respond with 500 Internal Server Error - Image completion failed.
std::string errMsg = "Image completion failed:"; errMsg += esp_err_to_name(ret);
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, errMsg.c_str());
return(ESP_FAIL);
}
}
// The image has been successfully downloaded, it is not duplicate or a known dud and validation has passed so set it up as the next boot partition.
ret = esp_ota_set_boot_partition(updatePartition);
if(ret != ESP_OK)
{
std::string errMsg = "Set boot parition to new image failed:"; errMsg += esp_err_to_name(ret);
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, errMsg.c_str());
return(ESP_FAIL);
}
// Done, send positive status.
vTaskDelay(500);
httpd_resp_set_status(req, "200 OK");
httpd_resp_sendstr(req, "");
return(ret);
}
// Method to update the LittleFS filesystem OTA. The image file is pushed via an AJAX xhttp POST, received in chunks and written direct
// to the parition. There is no rollback, any failure will see the filesystem corrupted. On a bigger ESP32 Flash chip, rollback may be
// possible but not with the 4MB standard IC.
IRAM_ATTR esp_err_t WiFi::otaFilepackUpdatePOSTHandler(httpd_req_t *req)
{
// Locals.
//
esp_err_t ret = ESP_OK;
std::string resp = "";
bool checkImageHeader = true;
uint32_t partStartAddr;
uint32_t partOffsetAddr = 0;
uint32_t partSize = 0;
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Find the filesystem partition.
esp_partition_iterator_t it;
it = esp_partition_find(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_SPIFFS, NULL);
if(it == NULL)
{
// Respond with 500 Internal Server Error - Couldnt find the filesystem partition.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Couldnt find a filesysten partition, is this ESP32 configured?");
return(ESP_FAIL);
}
// Get the partition information from the iterator.
const esp_partition_t *part = esp_partition_get(it);
// Setup the addresses of the partition.
partStartAddr = part->address;
partSize = part->size;
// Check to ensure the file to upload is not larger than the partition.
//
if(req->content_len > partSize)
{
// Respond with 500 Internal Server Error - File is too large.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Upload file size too large.");
return(ESP_FAIL);
}
// Erase the partition.
ret = esp_partition_erase_range(part, partOffsetAddr, partSize);
if(ret != ESP_OK)
{
// Respond with 500 Internal Server Error - Partition erase failure.
std::string errMsg = "Failed to erase partition:"; errMsg += esp_err_to_name(ret); errMsg += ", you may need to connect external programmer.";
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, errMsg.c_str());
return(ESP_FAIL);
}
// Allocate heap space for our receive buffer.
//
char *chunk = new char[MAX_CHUNK_SIZE];
size_t chunkSize;
// Use the Content length as the size of the file to be uploaded.
int remaining = req->content_len;
// Loop while data is still expected.
while(remaining > 0)
{
ESP_LOGI(WIFITAG, "Remaining size : %d", remaining);
// The file is received in chunks according to the free memory available for a buffer. It has to be at least the size of the firmware application header
// so that it can be read and evaluated in one chunk.
if((chunkSize = httpd_req_recv(req, chunk, MIN(remaining, MAX_CHUNK_SIZE))) <= 0)
{
// Retry if timeout occurred.
if (chunkSize == HTTPD_SOCK_ERR_TIMEOUT)
continue;
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error when a file error occurs.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
return(ESP_FAIL);
}
// If this is the first read, check the header information and make sure we are not uploading a bad file or one the same as the current image.
//
if(checkImageHeader == true)
{
// Simple check, look for the base path name in the image. Also the max size was checked earlier, smaller sizes are fine as the littlefs
// filestructure is valid but larger files will overwrite NVS data.
if(strncmp(pThis->wifiCtrl.run.fsPath+1, &chunk[8], strlen(pThis->wifiCtrl.run.fsPath)-1) != 0)
{
// Release memory, error!!
delete chunk;
/* Respond with 500 Internal Server Error */
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filepack image is not a valid file.");
return(ESP_FAIL);
}
// Dont repeat the check!
checkImageHeader = false;
}
// Write out the chunk we received, any errors we abort - probably means the user needs to use an external programmer to correct to error.
ret = esp_partition_write_raw(part, partOffsetAddr, (const void *)chunk, chunkSize);
if(ret != ESP_OK)
{
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error - Write failure.
std::string errMsg = "Write failure: "; errMsg += esp_err_to_name(ret); errMsg += " @ "; errMsg += to_str(partStartAddr+partOffsetAddr, 0, 16);
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, errMsg.c_str());
return(ESP_FAIL);
}
// Update counters.
partOffsetAddr += chunkSize;
remaining -= chunkSize;
}
// Release memory, all done!
delete chunk;
// Done, send positive status.
vTaskDelay(500);
httpd_resp_set_status(req, "200 OK");
httpd_resp_sendstr(req, "");
// Send result.
return(ESP_OK);
}
// Method to upload a file and store it onto the filesystem tagged according to the current running I/F.
// This method could be merged with the Firmware/Filepack methods but at the moment kept seperate to allow for any
// unseen requirements.
// The data should be passed to the I/F object so that it can verify
//
esp_err_t WiFi::keymapUploadPOSTHandler(httpd_req_t *req)
{
// Locals.
//
std::string resp = "";
std::fstream keyFileOut;
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Attempt to open the keymap file for writing.
//
if(pThis->keyIf->createKeyMapFile(keyFileOut) == false)
{
// Respond with 500 Internal Server Error - File creation error.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to create temporary keymap file");
return(ESP_FAIL);
}
// Allocate heap space for our receive buffer.
//
char *chunk = new char[MAX_CHUNK_SIZE];
size_t chunkSize;
// Use the Content length as the size of the file to be uploaded.
int remaining = req->content_len;
// Loop while data is still expected.
while(remaining > 0)
{
ESP_LOGI(WIFITAG, "Remaining size : %d", remaining);
// The file is received in chunks according to the free memory available for a buffer.
if((chunkSize = httpd_req_recv(req, chunk, MIN(remaining, MAX_CHUNK_SIZE))) <= 0)
{
// Retry if timeout occurred.
if (chunkSize == HTTPD_SOCK_ERR_TIMEOUT)
continue;
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error when a reception error occurs.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
return(ESP_FAIL);
}
// Store the data chunk into the keymap file.
if(pThis->keyIf->storeDataToKeyMapFile(keyFileOut, chunk, chunkSize) == false)
{
// Cleanup the mess!
pThis->keyIf->closeAndCommitKeyMapFile(keyFileOut, true);
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error when a file error occurs.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write data into file");
return(ESP_FAIL);
}
// Update counters.
remaining -= chunkSize;
}
// Release memory, all done!
delete chunk;
// Close and commit the file.
if(pThis->keyIf->closeAndCommitKeyMapFile(keyFileOut, false) == false)
{
// Respond with 500 Internal Server Error if the commit fails.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write data into file");
return(ESP_FAIL);
}
// Done, send positive status.
vTaskDelay(500);
httpd_resp_set_status(req, "200 OK");
httpd_resp_sendstr(req, "");
// Send result.
return(ESP_OK);
}
// Method to store the keymap table data. The POST data is captured in chunks and sent to the underlying interface method
// for parsing and extraction.
esp_err_t WiFi::keymapTablePOSTHandler(httpd_req_t *req)
{
// Locals.
//
int startPos;
int endPos;
int commaPos;
std::string resp = "";
std::string jsonData = "";
std::string jsonArray = "";
std::fstream keyFileOut;
std::vector<uint32_t> dataArray;
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Attempt to open the keymap file for writing.
//
if(pThis->keyIf->createKeyMapFile(keyFileOut) == false)
{
// Respond with 500 Internal Server Error - File creation error.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to create temporary keymap file");
return(ESP_FAIL);
}
// Allocate heap space for our receive buffer.
//
char *chunk = new char[MAX_CHUNK_SIZE];
size_t chunkSize;
// Use the Content length as the size of the JSON array to be uploaded.
int remaining = req->content_len;
// Loop while data is still expected.
while(remaining > 0)
{
ESP_LOGI(WIFITAG, "Remaining size : %d", remaining);
// The file is received in chunks according to the free memory available for a buffer.
if((chunkSize = httpd_req_recv(req, chunk, MIN(remaining, MAX_CHUNK_SIZE))) <= 0)
{
// Retry if timeout occurred.
if (chunkSize == HTTPD_SOCK_ERR_TIMEOUT)
continue;
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error when a reception error occurs.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
return(ESP_FAIL);
}
// Build up the JSON Data array and process piecemeal to keep overall memory usage low.
jsonData.append(chunk, chunkSize);
do {
startPos = jsonData.find("[[");
if(startPos != std::string::npos) { startPos++; } else { startPos = jsonData.find("["); }
endPos = jsonData.find("]");
if(startPos != std::string::npos && endPos != std::string::npos)
{
// Extract the array and parse into bytes.
jsonArray = jsonData.substr(startPos, endPos+1);
do {
commaPos = jsonArray.find("\"");
if(commaPos != std::string::npos)
{
jsonArray.erase(0, commaPos+1);
commaPos = jsonArray.find("\"");
if(commaPos != std::string::npos)
{
std::istringstream iss(jsonArray.substr(0, commaPos));
uint32_t word;
iss >> std::hex >> word;
dataArray.push_back(word);
}
commaPos = jsonArray.find(",");
if(commaPos != std::string::npos)
{
jsonArray.erase(0, commaPos+1);
}
}
} while(jsonArray.size() > 0 && commaPos != std::string::npos);
// Remove the array and the comma (or ending ]) seperator.
jsonData.erase(0, endPos + 2);
}
} while(startPos != std::string::npos && endPos != std::string::npos);
// Store the data chunk into the keymap file.
if(pThis->keyIf->storeDataToKeyMapFile(keyFileOut, dataArray) == false)
{
// Cleanup the mess!
pThis->keyIf->closeAndCommitKeyMapFile(keyFileOut, true);
// Release memory, error!!
delete chunk;
// Respond with 500 Internal Server Error when a file error occurs.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write data into file");
return(ESP_FAIL);
}
// Free up vector for next loop.
dataArray.clear();
// Update counters.
remaining -= chunkSize;
}
// Release memory, all done!
delete chunk;
// Close and commit the file.
if(pThis->keyIf->closeAndCommitKeyMapFile(keyFileOut, false) == false)
{
// Respond with 500 Internal Server Error if the commit fails.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write data into file");
return(ESP_FAIL);
}
// Done, send positive status.
vTaskDelay(500);
httpd_resp_set_status(req, "200 OK");
httpd_resp_sendstr(req, "");
// Send result.
return(ESP_OK);
}
// Method to extract the Key/Value pairs from a received POST request.
//
esp_err_t WiFi::getPOSTData(httpd_req_t *req, std::vector<t_kvPair> *pairs)
{
// Locals.
//
char buf[100];
int ret;
int rcvBytes = req->content_len;
std::string post;
t_kvPair keyValue;
// Loop retrieving the POST in chunks and assemble into a string.
while(rcvBytes > 0)
{
// Read data for the request.
if((ret = httpd_req_recv(req, buf, MIN(rcvBytes, sizeof(buf)-1))) <= 0)
{
if(ret == HTTPD_SOCK_ERR_TIMEOUT)
{
/* Retry receiving if timeout occurred */
continue;
}
return(ESP_FAIL);
}
buf[ret] = '\0';
// Add to our string for tokenising.
post = post + buf;
// Update bytes still to arrive.
rcvBytes -= ret;
}
// Split the POST into key pairs.
std::vector<std::string> keys = this->split(post, "&");
for(auto key : keys)
{
size_t pos = key.find('=');
keyValue.name = key.substr(0, pos);
keyValue.value = key.substr(pos + 1);
pairs->push_back(keyValue);
}
// Successful extraction of the Key/Value pairs from the POST.
return(ESP_OK);
}
// Method to process POST data specifically for the WiFi configuration. The key:value pairs are parsed, data extracted
// and validated. Any errors are sent back to the UI/Browser.
esp_err_t WiFi::wifiDataPOSTHandler(httpd_req_t *req, std::vector<t_kvPair> pairs, std::string& resp)
{
// Locals.
//
bool dataError = false;
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Loop through all the URI key pairs, updating configuration values as necessary.
for(auto pair : pairs)
{
//printf("%s->%s\n", pair.name.c_str(), pair.value.c_str());
if(pair.name.compare("wifiMode") == 0)
{
if(pair.value.compare("ap") == 0)
{
pThis->wifiConfig.params.wifiMode = WIFI_CONFIG_AP;
dataError = false;
} else
{
pThis->wifiConfig.params.wifiMode = WIFI_CONFIG_CLIENT;
dataError = false;
}
}
if(pair.name.compare("clientSSID") == 0)
{
strncpy(pThis->wifiConfig.clientParams.ssid, pair.value.c_str(), MAX_WIFI_SSID_LEN);
}
if(pair.name.compare("apSSID") == 0)
{
strncpy(pThis->wifiConfig.apParams.ssid, pair.value.c_str(), MAX_WIFI_SSID_LEN);
}
if(pair.name.compare("clientPWD") == 0)
{
strncpy(pThis->wifiConfig.clientParams.pwd, pair.value.c_str(), MAX_WIFI_PWD_LEN);
}
if(pair.name.compare("apPWD") == 0)
{
strncpy(pThis->wifiConfig.apParams.pwd, pair.value.c_str(), MAX_WIFI_PWD_LEN);
}
if(pair.name.compare("dhcpMode") == 0)
{
if(pair.value.compare("on") == 0)
{
pThis->wifiConfig.clientParams.useDHCP = true;
} else
{
pThis->wifiConfig.clientParams.useDHCP = false;
}
}
if(pair.name.compare("clientIP") == 0)
{
strncpy(pThis->wifiConfig.clientParams.ip, pair.value.c_str(), MAX_WIFI_IP_LEN);
}
if(pair.name.compare("apIP") == 0)
{
strncpy(pThis->wifiConfig.apParams.ip, pair.value.c_str(), MAX_WIFI_IP_LEN);
}
if(pair.name.compare("clientNETMASK") == 0)
{
strncpy(pThis->wifiConfig.clientParams.netmask, pair.value.c_str(), MAX_WIFI_NETMASK_LEN);
}
if(pair.name.compare("apNETMASK") == 0)
{
strncpy(pThis->wifiConfig.apParams.netmask, pair.value.c_str(), MAX_WIFI_NETMASK_LEN);
}
if(pair.name.compare("clientGATEWAY") == 0)
{
// Gateway isnt mandatory in client mode.
if(pair.value.size() > 0 && pThis->wifiConfig.params.wifiMode == WIFI_CONFIG_CLIENT)
{
strncpy(pThis->wifiConfig.clientParams.gateway, pair.value.c_str(), MAX_WIFI_GATEWAY_LEN);
}
}
if(pair.name.compare("apGATEWAY") == 0)
{
// Access point mode, if no gateway is given, assign the IP address as the gateway.
strncpy(pThis->wifiConfig.apParams.gateway, pThis->wifiConfig.apParams.ip, MAX_WIFI_GATEWAY_LEN+1);
}
}
// Validate the data if no error was raised for individual fields.
if(dataError == false)
{
if(pThis->wifiConfig.params.wifiMode == WIFI_CONFIG_AP)
{
if(strlen(pThis->wifiConfig.apParams.ssid) == 0)
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "SSID not given!";
dataError = true;
}
if(strlen(pThis->wifiConfig.apParams.pwd) == 0)
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Password not given!";
dataError = true;
}
if(!pThis->validateIP(pThis->wifiConfig.apParams.ip))
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Illegal AP IP address(" + pThis->wifiConfig.apParams.ip + ")";
dataError = true;
}
if(!pThis->validateIP(pThis->wifiConfig.apParams.netmask))
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Illegal AP Netmask address(" + pThis->wifiConfig.apParams.netmask + ")";
dataError = true;
}
// Gateway isnt mandatory, but if filled in, validate it.
if(strlen(pThis->wifiConfig.apParams.gateway) == 0 || !pThis->validateIP(pThis->wifiConfig.apParams.gateway))
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Illegal AP Gateway address(" + pThis->wifiConfig.clientParams.gateway + ")";
dataError = true;
}
}
// Only verify client parameters when active.
else if(pThis->wifiConfig.params.wifiMode == WIFI_CONFIG_CLIENT)
{
if(pThis->wifiConfig.clientParams.useDHCP == false)
{
if(strlen(pThis->wifiConfig.clientParams.ssid) == 0)
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "SSID not given!";
dataError = true;
}
if(strlen(pThis->wifiConfig.clientParams.pwd) == 0)
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Password not given!";
dataError = true;
}
if(!pThis->validateIP(pThis->wifiConfig.clientParams.ip))
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Illegal IP address(" + pThis->wifiConfig.clientParams.ip + ")";
dataError = true;
}
if(!pThis->validateIP(pThis->wifiConfig.clientParams.netmask))
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Illegal Netmask address(" + pThis->wifiConfig.clientParams.netmask + ")";
dataError = true;
}
// Gateway isnt mandatory, but if filled in, validate it.
if(strlen(pThis->wifiConfig.clientParams.gateway) > 0 && !pThis->validateIP(pThis->wifiConfig.clientParams.gateway))
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Illegal Gateway address(" + pThis->wifiConfig.clientParams.gateway + ")";
dataError = true;
}
}
} else
{
resp = resp + (resp.size() > 0 ? "," : "");
resp = resp + "Unknown WiFi Mode (" + to_str(pThis->wifiConfig.params.wifiMode, 0, 10) + "), internal coding error, please contact support.";
dataError = true;
}
}
// No errors, save wifi configuration.
if(dataError == false)
{
// Mark data as valid.
pThis->wifiConfig.clientParams.valid = true;
if(pThis->nvs->persistData(pThis->wifiCtrl.run.thisClass.c_str(), &pThis->wifiConfig, sizeof(t_wifiConfig)) == false)
{
ESP_LOGI(WIFITAG, "Persisting SharpKey(%s) configuration data failed, updates will not persist in future power cycles.", pThis->wifiCtrl.run.thisClass.c_str());
pThis->led->setLEDMode(LED::LED_MODE_BLINK_ONESHOT, LED::LED_DUTY_CYCLE_10, 200, 1000L, 0L);
} else
// Few other updates so make a commit here to ensure data is flushed and written.
if(pThis->nvs->commitData() == false)
{
ESP_LOGI(WIFITAG, "NVS Commit writes operation failed, some previous writes may not persist in future power cycles.");
pThis->led->setLEDMode(LED::LED_MODE_BLINK_ONESHOT, LED::LED_DUTY_CYCLE_10, 200, 500L, 0L);
}
}
return(dataError == false ? ESP_OK : ESP_FAIL);
}
// Method to process POST data specifically for the Mouse interface. The key:value pairs are sent to the Mouse
// interface for parsing and storing, any errors are sent back to the UI/Browser.
esp_err_t WiFi::mouseDataPOSTHandler(httpd_req_t *req, std::vector<t_kvPair> pairs, std::string& resp)
{
// Locals.
//
bool dataError = false;
KeyInterface *activeMouseIf = (mouseIf == NULL ? keyIf : mouseIf);
// Run through pairs and send to the mouse interface to interpret.
resp = "";
for(auto pair : pairs)
{
// Call the Mouse configuration handler tp validate and set the parameter.
dataError = activeMouseIf->setMouseConfigValue(pair.name, pair.value);
if(dataError)
{
resp.append("Variable:" + pair.name + " has an invalid value:" + pair.value);
dataError = false;
}
}
// Update success status.
if(resp.size() > 0) dataError = true;
// Persist the values if no errors occurred.
if(dataError == false)
{
dataError = activeMouseIf->persistConfig() ? false : true;
if(dataError)
{
resp.append("Save config to NVS RAM failed, retry, if 2nd attempt fails, power cycle the interface.");
}
}
return(dataError == false ? ESP_OK : ESP_FAIL);
}
// /data/hostconfig POST handler. Process host machine selection and store in NVS.
//
esp_err_t WiFi::hostConfigDataPOSTHandler(httpd_req_t *req, std::vector<t_kvPair> pairs, std::string& resp)
{
// Locals.
//
bool dataError = false;
uint32_t newHostMode = 0;
resp = "";
for(auto pair : pairs)
{
if(pair.name.compare("hostmode") == 0)
{
newHostMode = (uint32_t)atoi(pair.value.c_str());
// Validate the value.
if(newHostMode != 0 && newHostMode != 2500 && newHostMode != 2800 && newHostMode != 1 &&
newHostMode != 68000 && newHostMode != 5600 && newHostMode != 9801 && newHostMode != 2)
{
resp.append("Invalid host mode value: " + pair.value);
dataError = true;
}
}
}
if(!dataError)
{
sharpKeyConfig.params.hostMode = newHostMode;
if(nvs->persistData(SHARPKEY_NAME, &sharpKeyConfig, sizeof(struct SharpKeyConfig)) == false ||
nvs->commitData() == false)
{
resp.append("Save config to NVS RAM failed, retry, if 2nd attempt fails, power cycle the interface.");
dataError = true;
}
}
return(dataError == false ? ESP_OK : ESP_FAIL);
}
// /data POST handler. Process the request and call service as required.
//
esp_err_t WiFi::defaultDataPOSTHandler(httpd_req_t *req)
{
// Locals.
//
std::vector<t_kvPair> pairs;
esp_err_t ret = ESP_OK;
std::string resp = "";
std::string uriStr;
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Get the subpath from the URI.
if(pThis->getPathFromURI(uriStr, "/data/", req->uri) == ESP_FAIL)
{
// Respond with 500 Internal Server Error.
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to extract URI");
return(ESP_FAIL);
}
// Process the POST into key/value pairs.
ret = pThis->getPOSTData(req, &pairs);
if(ret == ESP_OK)
{
if(uriStr.compare("wifi") == 0)
{
if((ret = pThis->wifiDataPOSTHandler(req, pairs, resp)) == ESP_OK)
{
// Success so add reboot button.
pThis->wifiCtrl.run.rebootButton = true;
resp = "Data values accepted. Press 'Reboot' to initiate network connection with the new configuration.";
}
}
if(uriStr.compare("mouse") == 0)
{
if((ret = pThis->mouseDataPOSTHandler(req, pairs, resp)) == ESP_OK)
{
// Success so indicate all ok.
pThis->wifiCtrl.run.rebootButton = true;
resp = "Data values accepted. Press 'Reboot' to restart interface with new values.";
}
}
if(uriStr.compare("hostconfig") == 0)
{
if((ret = pThis->hostConfigDataPOSTHandler(req, pairs, resp)) == ESP_OK)
{
pThis->wifiCtrl.run.rebootButton = true;
resp = "Host configuration saved. Press 'Reboot' to restart interface with new host selection.";
}
}
} else
{
resp = "<p>No values in POST, check browser!</p>";
}
// Add in an error message if one has been generated.
pThis->wifiCtrl.run.errorMsg = "<font size=\"2\" face=\"verdana\" color=\"";
pThis->wifiCtrl.run.errorMsg += (ret == ESP_OK ? "green" : "red");
pThis->wifiCtrl.run.errorMsg += "\">" + resp + "</font>";
// Send message directly, it will appear as an error or success message.
httpd_resp_send_chunk(req, pThis->wifiCtrl.run.errorMsg.c_str(), pThis->wifiCtrl.run.errorMsg.size()+1);
// End response
httpd_resp_send_chunk(req, NULL, 0);
return(ret);
}
// /reboot POST handler.
// Simple handler, send a message indicating reboot taking place with a reload URL statement.
//
esp_err_t WiFi::defaultRebootHandler(httpd_req_t *req)
{
// Locals.
//
esp_err_t ret = ESP_OK;
std::string resp = "";
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)req->user_ctx;
// Build a response message.
if(pThis->wifiConfig.clientParams.useDHCP == false)
{
resp = "<head> <meta http-equiv=\"refresh\" content=\"10; URL=http://";
resp += pThis->wifiConfig.clientParams.ip;
resp += "/\" /> </head><body><font size=\"5\" face=\"verdana\" color=\"red\"/>Rebooting... </font><font size=\"5\" face=\"verdana\" color=\"black\"/>Please wait.</font></body>";
} else
{
resp = "<head> </head><body><font size=\"5\" face=\"verdana\" color=\"red\"/>Rebooting... </font><br><font size=\"4\" face=\"verdana\" color=\"black\"/><p>Please look in your router admin panel for the assigned IP address and enter http://&lt;router assigned ip address&gt; into browser to continue.</p></font></body>";
}
// Send the response and wait a while, then request reboot.
httpd_resp_send(req, resp.c_str(), resp.size()+1);
vTaskDelay(100);
pThis->wifiCtrl.run.reboot = true;
// Get out, a reboot will occur very soon.
return(ret);
}
// Method to start the basic HTTP webserver.
//
bool WiFi::startWebserver(void)
{
// Locals.
//
bool result = false;
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
// Tweak default settings.
// Pages request multiple files simultaneously (CSS, JS, fonts, images).
// The default 7 sockets causes LRU purge to kill active transfers, leaving
// resources stuck in "pending" state forever. 20 sockets accommodates
// parallel requests with spare slots. Aggressive recv_wait_timeout recycles
// idle keep-alive connections; send_wait_timeout prevents stale connections
// from blocking fresh ones.
config.stack_size = 16384;
config.uri_match_fn = httpd_uri_match_wildcard;
config.lru_purge_enable = true;
config.max_uri_handlers = 14;
config.max_open_sockets = 7;
config.recv_wait_timeout = 1;
config.send_wait_timeout = 15;
// Setup the required paths and descriptors then register them with the server.
const httpd_uri_t dataPOST = {
.uri = "/data",
.method = HTTP_POST,
.handler = defaultDataPOSTHandler,
.user_ctx = this
};
const httpd_uri_t dataSubPOST = {
.uri = "/data/*",
.method = HTTP_POST,
.handler = defaultDataPOSTHandler,
.user_ctx = this
};
const httpd_uri_t dataGET = {
.uri = "/data",
.method = HTTP_GET,
.handler = defaultDataGETHandler,
.user_ctx = this
};
const httpd_uri_t dataSubGET = {
.uri = "/data/*",
.method = HTTP_GET,
.handler = defaultDataGETHandler,
.user_ctx = this
};
const httpd_uri_t keymapTablePOST = {
.uri = "/keymap/table",
.method = HTTP_POST,
.handler = keymapTablePOSTHandler,
.user_ctx = this
};
const httpd_uri_t keymap = {
.uri = "/keymap",
.method = HTTP_POST,
.handler = keymapUploadPOSTHandler,
.user_ctx = this
};
const httpd_uri_t otafw = {
.uri = "/ota/firmware",
.method = HTTP_POST,
.handler = otaFirmwareUpdatePOSTHandler,
.user_ctx = this
};
const httpd_uri_t otafp = {
.uri = "/ota/filepack",
.method = HTTP_POST,
.handler = otaFilepackUpdatePOSTHandler,
.user_ctx = this
};
const httpd_uri_t rebootPOST = {
.uri = "/reboot",
.method = HTTP_POST,
.handler = defaultRebootHandler,
.user_ctx = this
};
const httpd_uri_t rebootGET = {
.uri = "/reboot",
.method = HTTP_GET,
.handler = defaultRebootHandler,
.user_ctx = this
};
const httpd_uri_t root = {
.uri = "/",
.method = HTTP_GET,
.handler = defaultFileHandler,
.user_ctx = this
};
// Catch all, assume files if no handler setup.
const httpd_uri_t files = {
.uri = "/*",
.method = HTTP_GET,
.handler = defaultFileHandler,
.user_ctx = this
};
// Store the file system basepath on t
strlcpy(this->wifiCtrl.run.basePath, this->wifiCtrl.run.fsPath, sizeof(this->wifiCtrl.run.basePath));
// Start the web server.
ESP_LOGI(WIFITAG, "Starting server on port: '%d'", config.server_port);
if (httpd_start(&wifiCtrl.run.server, &config) == ESP_OK)
{
// Set URI handlers
ESP_LOGI(WIFITAG, "Registering URI handlers");
// Root directory handler. Equivalent to index.html/index.htm. The method, based on the current mode (AP/Client) decides on which
// file to serve.
httpd_register_uri_handler(wifiCtrl.run.server, &root);
// POST handlers.
httpd_register_uri_handler(wifiCtrl.run.server, &dataSubPOST);
httpd_register_uri_handler(wifiCtrl.run.server, &dataPOST);
httpd_register_uri_handler(wifiCtrl.run.server, &dataSubGET);
httpd_register_uri_handler(wifiCtrl.run.server, &dataGET);
httpd_register_uri_handler(wifiCtrl.run.server, &keymapTablePOST);
httpd_register_uri_handler(wifiCtrl.run.server, &keymap);
httpd_register_uri_handler(wifiCtrl.run.server, &otafw);
httpd_register_uri_handler(wifiCtrl.run.server, &otafp);
httpd_register_uri_handler(wifiCtrl.run.server, &rebootPOST);
httpd_register_uri_handler(wifiCtrl.run.server, &rebootGET);
// If no URL matches then default to serving files.
httpd_register_uri_handler(wifiCtrl.run.server, &files);
result = true;
}
// Return result of startup.
return(result);
}
// Method to stop the basic HTTP webserver.
//
void WiFi::stopWebserver(void)
{
// Stop the web server and set the handle to NULL to indicate state.
httpd_stop(wifiCtrl.run.server);
wifiCtrl.run.server = NULL;
return;
}
// Event handler for Client mode Wifi event callback.
//
IRAM_ATTR void WiFi::wifiClientHandler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
// Locals.
//
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)arg;
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)
{
if(pThis->wifiCtrl.client.clientRetryCnt < CONFIG_IF_WIFI_MAX_RETRIES)
{
esp_wifi_connect();
pThis->wifiCtrl.client.clientRetryCnt++;
ESP_LOGI(WIFITAG, "retry to connect to the AP");
} else
{
xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
}
ESP_LOGI(WIFITAG,"connect to the AP fail");
}
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;
// Copy details into control structure for ease of use in rendering pages.
strncpy(pThis->wifiCtrl.ap.ssid, pThis->wifiConfig.clientParams.ssid, MAX_WIFI_SSID_LEN+1);
strncpy(pThis->wifiCtrl.ap.pwd, pThis->wifiConfig.clientParams.pwd, MAX_WIFI_PWD_LEN+1);
sprintf(pThis->wifiCtrl.client.ip, IPSTR, IP2STR(&event->ip_info.ip));
sprintf(pThis->wifiCtrl.client.netmask, IPSTR, IP2STR(&event->ip_info.netmask));
sprintf(pThis->wifiCtrl.client.gateway, IPSTR, IP2STR(&event->ip_info.gw));
pThis->wifiCtrl.client.connected = true;
pThis->wifiCtrl.client.clientRetryCnt = 0;
ESP_LOGI(WIFITAG, "got ip:" IPSTR " Netmask:" IPSTR " Gateway:" IPSTR, IP2STR(&event->ip_info.ip), IP2STR(&event->ip_info.netmask), IP2STR(&event->ip_info.gw));
xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
// Start the webserver if it hasnt been configured.
if(pThis->wifiCtrl.run.server == NULL)
{
pThis->startWebserver();
}
}
return;
}
// Event handler for Access Point mode Wifi event callback.
//
IRAM_ATTR void WiFi::wifiAPHandler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
// Locals.
//
// Retrieve pointer to object in order to access data.
WiFi* pThis = (WiFi*)arg;
if (event_id == WIFI_EVENT_AP_STACONNECTED)
{
wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;
ESP_LOGI(WIFITAG, "station " MACSTR " join, AID=%d", MAC2STR(event->mac), event->aid);
// Start the webserver if it hasnt been configured.
if(pThis->wifiCtrl.run.server == NULL)
{
pThis->startWebserver();
}
}
else if (event_id == WIFI_EVENT_AP_STADISCONNECTED)
{
wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
ESP_LOGI(WIFITAG, "station " MACSTR " leave, AID=%d", MAC2STR(event->mac), event->aid);
}
return;
}
// Method to initialise the interface as a client to a known network, the SSID
// and password have already been setup.
//
bool WiFi::setupWifiClient(void)
{
// Locals.
//
wifi_init_config_t wifiInitConfig = WIFI_INIT_CONFIG_DEFAULT();
esp_netif_t *netConfig;
esp_netif_ip_info_t ipInfo;
esp_event_handler_instance_t instID;
esp_event_handler_instance_t instIP;
EventBits_t bits;
wifi_config_t wifiConfig = { .sta = {
/* ssid */ {},
/* password */ {},
/* scan_method */ {},
/* bssid_set */ {},
/* bssid */ {},
/* channel */ {},
/* listen_interval */ {},
/* sort_method */ {},
/* threshold */ {
/* rssi */ {},
/* authmode */ WIFI_AUTH_WPA2_PSK
},
/* pmf_cfg */ {
/* capable */ true,
/* required */ false
},
/* rm_enabled */ {},
/* btm_enabled */ {},
/* mbo_enabled */ {}, // For IDF 4.4 and higher
/* reserved */ {}
}
};
// Add in configured SSID/Password parameters.
strncpy((char *)wifiConfig.sta.ssid, this->wifiConfig.clientParams.ssid, MAX_WIFI_SSID_LEN+1);
strncpy((char *)wifiConfig.sta.password, this->wifiConfig.clientParams.pwd, MAX_WIFI_PWD_LEN+1);
//nvs_handle_t net80211_handle;
//nvs_open("nvs.net80211", NVS_READWRITE, &net80211_handle);
//nvs_erase_all(net80211_handle);
//nvs_commit(net80211_handle);
//nvs_close(net80211_handle);
// Initialise control structure.
//
wifiCtrl.client.connected = false;
wifiCtrl.client.ip[0] = '\0';
wifiCtrl.client.netmask[0] = '\0';
wifiCtrl.client.gateway[0] = '\0';
// Create an event handler group to manage callbacks.
s_wifi_event_group = xEventGroupCreate();
// Setup the network interface.
if(esp_netif_init())
{
ESP_LOGI(WIFITAG, "Couldnt initialise netif, disabling WiFi.");
return(false);
}
// Setup the event loop.
if(esp_event_loop_create_default())
{
ESP_LOGI(WIFITAG, "Couldnt initialise event loop, disabling WiFi.");
return(false);
}
// Setup the wifi client (station).
netConfig = esp_netif_create_default_wifi_sta();
// If fixed IP is configured, set it up.
if(!this->wifiConfig.clientParams.useDHCP)
{
int a, b, c, d;
esp_netif_dhcpc_stop(netConfig);
if(!splitIP(this->wifiConfig.clientParams.ip, &a, &b, &c, &d))
{
ESP_LOGI(WIFITAG, "Client IP invalid:%s", this->wifiConfig.clientParams.ip);
return false;
}
IP4_ADDR(&ipInfo.ip, a, b, c, d);
if(!splitIP(this->wifiConfig.clientParams.netmask, &a, &b, &c, &d))
{
ESP_LOGI(WIFITAG, "Client NETMASK invalid:%s", this->wifiConfig.clientParams.netmask);
return false;
}
IP4_ADDR(&ipInfo.netmask, a, b, c, d);
if(!splitIP(this->wifiConfig.clientParams.gateway, &a, &b, &c, &d))
{
ESP_LOGI(WIFITAG, "Client GATEWAY invalid:%s", this->wifiConfig.clientParams.gateway);
return false;
}
IP4_ADDR(&ipInfo.gw, a, b, c, d);
esp_netif_set_ip_info(netConfig, &ipInfo);
}
// Set TX power to max.
esp_wifi_set_max_tx_power(127);
// Setup the config for wifi.
wifiInitConfig = WIFI_INIT_CONFIG_DEFAULT();
if(esp_wifi_init(&wifiInitConfig))
{
ESP_LOGI(WIFITAG, "Couldnt initialise wifi with default parameters, disabling WiFi.");
return(false);
}
// Register event handlers.
if(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifiClientHandler, this, &instID))
{
ESP_LOGI(WIFITAG, "Couldnt register event handler for ID, disabling WiFi.");
return(false);
}
if(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifiClientHandler, this, &instIP))
{
ESP_LOGI(WIFITAG, "Couldnt register event handler for IP, disabling WiFi.");
return(false);
}
if(esp_wifi_set_mode(WIFI_MODE_STA))
{
ESP_LOGI(WIFITAG, "Couldnt set Wifi mode to Client, disabling WiFi.");
return(false);
}
if(esp_wifi_set_config(WIFI_IF_STA, &wifiConfig))
{
ESP_LOGI(WIFITAG, "Couldnt configure client mode, disabling WiFi.");
return(false);
}
if(esp_wifi_start())
{
ESP_LOGI(WIFITAG, "Couldnt start Client session, disabling WiFi.");
return(false);
}
// 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 wifiClientHandler() (see above)
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(WIFITAG, "Connected: SSID:%s password:%s", this->wifiConfig.clientParams.ssid, this->wifiConfig.clientParams.pwd);
}
else if (bits & WIFI_FAIL_BIT)
{
ESP_LOGI(WIFITAG, "Connection Fail: SSID:%s, password:%s.", this->wifiConfig.clientParams.ssid, this->wifiConfig.clientParams.pwd);
return(false);
}
else
{
ESP_LOGE(WIFITAG, "Unknown evemt, bits:%d", bits);
return(false);
}
// No errors.
return(true);
}
// Method to initialise the interface as a Soft Access point with a given SSID
// and password.
// The Access Point mode is basically to bootstrap a Client connection where the
// client connecting provides the credentials in order to connect as a client to
// another AP to join a local network.
//
bool WiFi::setupWifiAP(void)
{
// Locals.
//
esp_err_t retcode;
wifi_init_config_t wifiInitConfig;
esp_netif_t *wifiAP;
esp_netif_ip_info_t ipInfo;
wifi_config_t wifiConfig = { .ap = {
/* ssid */ CONFIG_IF_WIFI_SSID,
/* password */ CONFIG_IF_WIFI_DEFAULT_SSID_PWD,
/* ssid_len */ strlen(CONFIG_IF_WIFI_SSID),
/* channel */ CONFIG_IF_WIFI_AP_CHANNEL,
/* authmode */ WIFI_AUTH_WPA_WPA2_PSK,
/* hidden */ CONFIG_IF_WIFI_SSID_HIDDEN,
/* max_connection */ CONFIG_IF_WIFI_MAX_CONNECTIONS,
/* beacon_interval */ 100,
/* pairwise_cipher */ WIFI_CIPHER_TYPE_TKIP,
/* ftm_responder */ 0,
// /* pmf_cfg */ {
// /* capable */ true,
// /* required */ false
// }
}
};
// Intialise the network interface.
if(esp_netif_init())
{
ESP_LOGI(WIFITAG, "Couldnt initialise network interface, disabling WiFi.");
return(false);
}
if((retcode = esp_event_loop_create_default()))
{
ESP_LOGI(WIFITAG, "Couldnt create default loop(%d), disabling WiFi.", retcode);
return(false);
}
// Create the default Access Point.
//
wifiAP = esp_netif_create_default_wifi_ap();
// Setup the base parameters of the Access Point which may differ from ESP32 defaults.
int a, b, c, d;
if(!splitIP(this->wifiConfig.apParams.ip, &a, &b, &c, &d))
{
ESP_LOGI(WIFITAG, "AP IP invalid:%s", this->wifiConfig.apParams.ip);
return false;
}
IP4_ADDR(&ipInfo.ip, a, b, c, d);
if(!splitIP(this->wifiConfig.apParams.netmask, &a, &b, &c, &d))
{
ESP_LOGI(WIFITAG, "AP NETMASK invalid:%s", this->wifiConfig.apParams.netmask);
return false;
}
IP4_ADDR(&ipInfo.netmask, a, b, c, d);
if(!splitIP(this->wifiConfig.apParams.gateway, &a, &b, &c, &d))
{
ESP_LOGI(WIFITAG, "AP GATEWAY invalid:%s", this->wifiConfig.apParams.gateway);
return false;
}
IP4_ADDR(&ipInfo.gw, a, b, c, d);
// Update the SSID/Password from NVS.
strncpy((char *)wifiConfig.ap.ssid, this->wifiConfig.apParams.ssid, MAX_WIFI_SSID_LEN+1);
strncpy((char *)wifiConfig.ap.password, this->wifiConfig.apParams.pwd, MAX_WIFI_PWD_LEN+1);
wifiConfig.ap.ssid_len = (uint8_t)strlen(this->wifiConfig.apParams.ssid);
// Copy the configured params into the runtime params, just in case they change prior to next boot.
// (this) used for clarity as wifi config local have similar names to global persistence names.
strncpy(this->wifiCtrl.ap.ssid, this->wifiConfig.apParams.ssid, MAX_WIFI_SSID_LEN+1);
strncpy(this->wifiCtrl.ap.pwd, this->wifiConfig.apParams.pwd, MAX_WIFI_PWD_LEN+1);
strncpy(this->wifiCtrl.ap.ip, this->wifiConfig.apParams.ip, MAX_WIFI_IP_LEN+1);
strncpy(this->wifiCtrl.ap.netmask, this->wifiConfig.apParams.netmask, MAX_WIFI_NETMASK_LEN+1);
strncpy(this->wifiCtrl.ap.gateway, this->wifiConfig.apParams.gateway, MAX_WIFI_GATEWAY_LEN+1);
// Reconfigure the DHCP Server.
esp_netif_dhcps_stop(wifiAP);
esp_netif_set_ip_info(wifiAP, &ipInfo);
esp_netif_dhcps_start(wifiAP);
// Set TX power to max.
esp_wifi_set_max_tx_power(127);
// Initialise AP with default parameters.
wifiInitConfig = WIFI_INIT_CONFIG_DEFAULT();
if(esp_wifi_init(&wifiInitConfig))
{
ESP_LOGI(WIFITAG, "Couldnt setup AP with default parameters, disabling WiFi.");
return(false);
}
// Setup callback handlers for wifi events.
if(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifiAPHandler, this, NULL))
{
ESP_LOGI(WIFITAG, "Couldnt setup event handlers, disabling WiFi.");
return(false);
}
// If there is no password for the access point set authentication to open.
if (strlen(CONFIG_IF_WIFI_DEFAULT_SSID_PWD) == 0)
{
wifiConfig.ap.authmode = WIFI_AUTH_OPEN;
}
// Setup as an Access Point.
if(esp_wifi_set_mode(WIFI_MODE_AP))
{
ESP_LOGI(WIFITAG, "Couldnt set mode to Access Point, disabling WiFi.");
return(false);
}
// Configure the Access Point
if(esp_wifi_set_config(WIFI_IF_AP, &wifiConfig))
{
ESP_LOGI(WIFITAG, "Couldnt configure Access Point, disabling WiFi.");
return(false);
}
// Start the Access Point.
if(esp_wifi_start())
{
ESP_LOGI(WIFITAG, "Couldnt start Access Point session, disabling WiFi.");
return(false);
}
// No errors.
return(true);
}
// Method to disable the wifi turning the transceiver off.
//
bool WiFi::stopWifi(void)
{
if(esp_wifi_stop())
{
ESP_LOGI(WIFITAG, "Couldnt stop the WiFi, reboot needed.");
return(false);
}
if(esp_wifi_deinit())
{
ESP_LOGI(WIFITAG, "Couldnt deactivate WiFi, reboot needed.");
return(false);
}
// No errors.
return(true);
}
// WiFi interface runtime logic. This method provides a browser interface to the SharpKey for status query and configuration.
//
void WiFi::run(void)
{
// Locals.
#define WIFIIFTAG "wifiRun"
// If Access Point mode has been forced, set the config parameter to AP so that Access Point mode is entered regardless of NVS setting.
if(wifiCtrl.run.wifiMode == WIFI_CONFIG_AP)
{
wifiConfig.params.wifiMode = WIFI_CONFIG_AP;
// Reset the configured addresses, SSID and password of the Access Point to factory default. This ensures known connection data.
strncpy(wifiConfig.apParams.ssid, CONFIG_IF_WIFI_SSID, MAX_WIFI_SSID_LEN);
strncpy(wifiConfig.apParams.pwd, CONFIG_IF_WIFI_DEFAULT_SSID_PWD, MAX_WIFI_PWD_LEN);
strncpy(wifiConfig.apParams.ip, WIFI_AP_DEFAULT_IP, MAX_WIFI_IP_LEN);
strncpy(wifiConfig.apParams.netmask, WIFI_AP_DEFAULT_NETMASK, MAX_WIFI_NETMASK_LEN);
strncpy(wifiConfig.apParams.gateway, WIFI_AP_DEFAULT_GW, MAX_WIFI_GATEWAY_LEN);
}
// Enable Access Point mode if configured.
if(wifiConfig.params.wifiMode == WIFI_CONFIG_AP)
{
if(!setupWifiAP())
{
wifiCtrl.run.reboot = true;
} else
{
wifiCtrl.run.wifiMode = wifiConfig.params.wifiMode;
// Flash LED to indicate access point mode is active.
//
led->setLEDMode(LED::LED_MODE_BLINK_ONESHOT, LED::LED_DUTY_CYCLE_10, 5, 10000L, 500L);
}
} else
{
// Setup as a client for general browser connectivity.
if(!setupWifiClient())
{
wifiCtrl.run.reboot = true;
} else
{
wifiCtrl.run.wifiMode = wifiConfig.params.wifiMode;
// Flash LED to indicate client mode is active.
//
led->setLEDMode(LED::LED_MODE_BLINK_ONESHOT, LED::LED_DUTY_CYCLE_50, 5, 10000L, 500L);
}
}
// Enter a loop, only exitting if a reboot is required.
do {
// Let other tasks run. NB. This value affects the debounce counter, update as necessary.
vTaskDelay(500);
} while(wifiCtrl.run.reboot == false);
return;
}
// Constructor. No overloading methods.
WiFi::WiFi(KeyInterface *hdlKeyIf, KeyInterface *hdlMouseIf, bool defaultMode, NVS *nvs, LED *led, const char *fsPath, t_versionList *versionList)
{
// Initialise variables.
//
wifiCtrl.client.clientRetryCnt = 0;
wifiCtrl.run.server = NULL;
wifiCtrl.run.errorMsg = "";
wifiCtrl.run.rebootButton = false;
wifiCtrl.run.reboot = false;
wifiCtrl.run.wifiMode = (defaultMode == true ? WIFI_CONFIG_AP : WIFI_ON);
// The Non Volatile Storage object is bound to this object for storage and retrieval of configuration data.
this->nvs = nvs;
// The LED activity indicator object.
this->led = led;
// Setup the default path on the underlying filesystem.
this->wifiCtrl.run.fsPath = fsPath;
// Store the version list, used in html variable expansion for version number reporting.
this->wifiCtrl.run.versionList = versionList;
// Store the classname, used for NVS keys.
this->wifiCtrl.run.thisClass = keyIf->getClassName(__PRETTY_FUNCTION__);
// Retrieve configuration, if it doesnt exist, set defaults.
//
if(nvs->retrieveData(this->wifiCtrl.run.thisClass.c_str(), &this->wifiConfig, sizeof(t_wifiConfig)) == false)
{
ESP_LOGI(WIFITAG, "Wifi configuration set to default, no valid config in NVS found.");
// Empty set for the client parameters until configured.
wifiConfig.clientParams.valid = false;
wifiConfig.clientParams.ssid[0] = '\0';
wifiConfig.clientParams.pwd[0] = '\0';
wifiConfig.clientParams.ip[0] = '\0';
wifiConfig.clientParams.netmask[0] = '\0';
wifiConfig.clientParams.gateway[0] = '\0';
strncpy(wifiConfig.apParams.ssid, CONFIG_IF_WIFI_SSID, MAX_WIFI_SSID_LEN);
strncpy(wifiConfig.apParams.pwd, CONFIG_IF_WIFI_DEFAULT_SSID_PWD, MAX_WIFI_PWD_LEN);
strncpy(wifiConfig.apParams.ip, WIFI_AP_DEFAULT_IP, MAX_WIFI_IP_LEN);
strncpy(wifiConfig.apParams.netmask, WIFI_AP_DEFAULT_NETMASK, MAX_WIFI_NETMASK_LEN);
strncpy(wifiConfig.apParams.gateway, WIFI_AP_DEFAULT_GW, MAX_WIFI_GATEWAY_LEN);
wifiConfig.params.wifiMode = WIFI_CONFIG_AP;
// Persist the data for next time.
if(nvs->persistData(wifiCtrl.run.thisClass.c_str(), &this->wifiConfig, sizeof(t_wifiConfig)) == false)
{
ESP_LOGI(WIFITAG, "Persisting Default Wifi configuration data failed, check NVS setup.");
}
// Commit data, ensuring values are written to NVS and the mutex is released.
else if(nvs->commitData() == false)
{
ESP_LOGI(WIFITAG, "NVS Commit writes operation failed, some previous writes may not persist in future power cycles.");
}
}
// The interface objects are bound to this object so that configuration and rendering of web pages can take place. As the KeyInterface class knows about its
// data set and configuration requirements it is the only object which can render web pages for it.
//
keyIf = NULL;
mouseIf = NULL;
if(hdlKeyIf != NULL && hdlMouseIf == NULL)
{
this->keyIf = hdlKeyIf;
}
else if(hdlKeyIf == NULL && hdlMouseIf != NULL)
{
this->keyIf = mouseIf;
}
else if(hdlKeyIf != NULL && hdlMouseIf != NULL)
{
this->keyIf = hdlKeyIf;
this->mouseIf = hdlMouseIf;
}
}
// Constructor, used for version reporting so no hardware is initialised.
WiFi::WiFi(void)
{
return;
}
// Destructor - only ever called when the class is used for version reporting.
WiFi::~WiFi(void)
{
return;
}
// End of compile time enabled build of the WiFi module.
#endif
Reference in New Issue View Git Blame Copy Permalink