Blame | Last modification | View Log | RSS feed
// SPDX-License-Identifier: LGPL-3.0-or-later// Copyright 2016-2026 Hristo Gochkov, Mathieu Carbou, Emil Muratov, Will Miles#include "ESPAsyncWebServer.h"#include "WebResponseImpl.h"#include "AsyncWebServerLogging.h"#include <algorithm>#include <memory>#include <utility>#ifndef CONFIG_LWIP_TCP_WND_DEFAULT#ifdef TCP_WND // ESP8266#define CONFIG_LWIP_TCP_WND_DEFAULT TCP_WND#else// as it is defined for esp32's LWIP#define CONFIG_LWIP_TCP_WND_DEFAULT 5760#endif#endifusing namespace asyncsrv;/** Abstract Response**/STR_RETURN_TYPE AsyncWebServerResponse::responseCodeToString(int code) {switch (code) {case 100: return STR(T_HTTP_CODE_100);case 101: return STR(T_HTTP_CODE_101);case 200: return STR(T_HTTP_CODE_200);case 201: return STR(T_HTTP_CODE_201);case 202: return STR(T_HTTP_CODE_202);case 203: return STR(T_HTTP_CODE_203);case 204: return STR(T_HTTP_CODE_204);case 205: return STR(T_HTTP_CODE_205);case 206: return STR(T_HTTP_CODE_206);case 300: return STR(T_HTTP_CODE_300);case 301: return STR(T_HTTP_CODE_301);case 302: return STR(T_HTTP_CODE_302);case 303: return STR(T_HTTP_CODE_303);case 304: return STR(T_HTTP_CODE_304);case 305: return STR(T_HTTP_CODE_305);case 307: return STR(T_HTTP_CODE_307);case 400: return STR(T_HTTP_CODE_400);case 401: return STR(T_HTTP_CODE_401);case 402: return STR(T_HTTP_CODE_402);case 403: return STR(T_HTTP_CODE_403);case 404: return STR(T_HTTP_CODE_404);case 405: return STR(T_HTTP_CODE_405);case 406: return STR(T_HTTP_CODE_406);case 407: return STR(T_HTTP_CODE_407);case 408: return STR(T_HTTP_CODE_408);case 409: return STR(T_HTTP_CODE_409);case 410: return STR(T_HTTP_CODE_410);case 411: return STR(T_HTTP_CODE_411);case 412: return STR(T_HTTP_CODE_412);case 413: return STR(T_HTTP_CODE_413);case 414: return STR(T_HTTP_CODE_414);case 415: return STR(T_HTTP_CODE_415);case 416: return STR(T_HTTP_CODE_416);case 417: return STR(T_HTTP_CODE_417);case 429: return STR(T_HTTP_CODE_429);case 500: return STR(T_HTTP_CODE_500);case 501: return STR(T_HTTP_CODE_501);case 502: return STR(T_HTTP_CODE_502);case 503: return STR(T_HTTP_CODE_503);case 504: return STR(T_HTTP_CODE_504);case 505: return STR(T_HTTP_CODE_505);case 507: return STR(T_HTTP_CODE_507);default: return STR(T_HTTP_CODE_ANY);}}AsyncWebServerResponse::AsyncWebServerResponse(): _code(0), _contentType(), _contentLength(0), _sendContentLength(true), _chunked(false), _headLength(0), _sentLength(0), _ackedLength(0), _writtenLength(0),_state(RESPONSE_SETUP) {for (const auto &header : DefaultHeaders::Instance()) {_headers.emplace_back(header);}}void AsyncWebServerResponse::setCode(int code) {if (_state == RESPONSE_SETUP) {_code = code;}}void AsyncWebServerResponse::setContentLength(size_t len) {if (_state == RESPONSE_SETUP && addHeader(T_Content_Length, len, true)) {_contentLength = len;}}void AsyncWebServerResponse::setContentType(const char *type) {if (_state == RESPONSE_SETUP && addHeader(T_Content_Type, type, true)) {_contentType = type;}}bool AsyncWebServerResponse::removeHeader(const char *name) {bool h_erased = false;for (auto i = _headers.begin(); i != _headers.end();) {if (i->name().equalsIgnoreCase(name)) {_headers.erase(i);h_erased = true;} else {++i;}}return h_erased;}bool AsyncWebServerResponse::removeHeader(const char *name, const char *value) {for (auto i = _headers.begin(); i != _headers.end(); ++i) {if (i->name().equalsIgnoreCase(name) && i->value().equalsIgnoreCase(value)) {_headers.erase(i);return true;}}return false;}const AsyncWebHeader *AsyncWebServerResponse::getHeader(const char *name) const {auto iter = std::find_if(std::begin(_headers), std::end(_headers), [&name](const AsyncWebHeader &header) {return header.name().equalsIgnoreCase(name);});return (iter == std::end(_headers)) ? nullptr : &(*iter);}bool AsyncWebServerResponse::headerMustBePresentOnce(const String &name) {for (uint8_t i = 0; i < T_only_once_headers_len; i++) {if (name.equalsIgnoreCase(T_only_once_headers[i])) {return true;}}return false;}bool AsyncWebServerResponse::addHeader(AsyncWebHeader &&header, bool replaceExisting) {if (!header) {return false; // invalid header}for (auto i = _headers.begin(); i != _headers.end(); ++i) {if (i->name().equalsIgnoreCase(header.name())) {// header already setif (replaceExisting) {// remove, break and add the new one_headers.erase(i);break;} else if (headerMustBePresentOnce(i->name())) { // we can have only one header with that name// do not updatereturn false;} else {break; // accept multiple headers with the same name}}}// header was not found found, or existing one was removed_headers.emplace_back(std::move(header));return true;}bool AsyncWebServerResponse::addHeader(const char *name, const char *value, bool replaceExisting) {for (auto i = _headers.begin(); i != _headers.end(); ++i) {if (i->name().equalsIgnoreCase(name)) {// header already setif (replaceExisting) {// remove, break and add the new one_headers.erase(i);break;} else if (headerMustBePresentOnce(i->name())) { // we can have only one header with that name// do not updatereturn false;} else {break; // accept multiple headers with the same name}}}// header was not found found, or existing one was removed_headers.emplace_back(name, value);return true;}void AsyncWebServerResponse::_assembleHead(String &buffer, uint8_t version) {if (version) {addHeader(T_Accept_Ranges, T_none, false);if (_chunked) {addHeader(T_Transfer_Encoding, T_chunked, false);}}if (_sendContentLength) {addHeader(T_Content_Length, String(_contentLength), false);}if (_contentType.length()) {addHeader(T_Content_Type, _contentType.c_str(), false);}// precompute buffer size to avoid reallocations by String classsize_t len = 0;len += 50; // HTTP/1.1 200 <reason>\r\nfor (const auto &header : _headers) {len += header.name().length() + header.value().length() + 4;}// prepare bufferbuffer.reserve(len);// HTTP header#ifdef ESP8266buffer.concat(PSTR("HTTP/1."));#elsebuffer.concat("HTTP/1.");#endifbuffer.concat(version);buffer.concat(' ');buffer.concat(_code);buffer.concat(' ');buffer.concat(responseCodeToString(_code));buffer.concat(T_rn);// Add headersfor (const auto &header : _headers) {buffer.concat(header.name());#ifdef ESP8266buffer.concat(PSTR(": "));#elsebuffer.concat(": ");#endifbuffer.concat(header.value());buffer.concat(T_rn);}buffer.concat(T_rn);_headLength = buffer.length();}bool AsyncWebServerResponse::_started() const {return _state > RESPONSE_SETUP;}bool AsyncWebServerResponse::_finished() const {return _state > RESPONSE_WAIT_ACK;}bool AsyncWebServerResponse::_failed() const {return _state == RESPONSE_FAILED;}bool AsyncWebServerResponse::_sourceValid() const {return false;}void AsyncWebServerResponse::_respond(AsyncWebServerRequest *request) {_state = RESPONSE_END;}/** String/Code Response* */AsyncBasicResponse::AsyncBasicResponse(int code, const char *contentType, const char *content) {_code = code;_content = content;_contentType = contentType;if (_content.length()) {_contentLength = _content.length();if (!_contentType.length()) {_contentType = T_text_plain;}}addHeader(T_Connection, T_close, false);}void AsyncBasicResponse::_respond(AsyncWebServerRequest *request) {_state = RESPONSE_HEADERS;_assembleHead(_assembled_headers, request->version());write_send_buffs(request, 0, 0);}size_t AsyncBasicResponse::write_send_buffs(AsyncWebServerRequest *request, size_t len, uint32_t time) {(void)time;// this is not functionally needed in AsyncBasicResponse itself, but kept for compatibility if some of the derived classes are rely on it somehow_ackedLength += len;size_t payloadlen{0}; // amount of data to be written to tcp sockbuff during this call, used as return value of this method// send http headers firstif (_state == RESPONSE_HEADERS) {// copy headers buffer to sock buffersize_t const pcb_written = request->client()->add(_assembled_headers.c_str() + _writtenHeadersLength, _assembled_headers.length() - _writtenHeadersLength);_writtenLength += pcb_written;_writtenHeadersLength += pcb_written;if (_writtenHeadersLength < _assembled_headers.length()) {// we were not able to fit all headers in current buff, send this part here and return later for the restif (!request->client()->send()) {// something is wrong, what should we do here?request->client()->close();return 0;}return pcb_written;}// otherwise we've added all the (remainder) headers in current buff, go on with content_state = RESPONSE_CONTENT;payloadlen += pcb_written;_assembled_headers = String(); // clear}if (_state == RESPONSE_CONTENT) {size_t const pcb_written = request->client()->write(_content.c_str() + _sentLength, _content.length() - _sentLength);_writtenLength += pcb_written; // total written data (hdrs + body)_sentLength += pcb_written; // body written datapayloadlen += pcb_written; // data writtent in current buffif (_sentLength >= _content.length()) {// we've just sent all the (remainder) data in current buff, complete the response_state = RESPONSE_END;}}// implicit completeif (_state == RESPONSE_WAIT_ACK) {_state = RESPONSE_END;}return payloadlen;}/** Abstract Response**/AsyncAbstractResponse::AsyncAbstractResponse(AwsTemplateProcessor callback) : _callback(callback) {// In case of template processing, we're unable to determine real response sizeif (callback) {_contentLength = 0;_sendContentLength = false;_chunked = true;}}void AsyncAbstractResponse::_respond(AsyncWebServerRequest *request) {addHeader(T_Connection, T_close, false);_assembleHead(_assembled_headers, request->version());_state = RESPONSE_HEADERS;write_send_buffs(request, 0, 0);}size_t AsyncAbstractResponse::write_send_buffs(AsyncWebServerRequest *request, size_t len, uint32_t time) {(void)time;if (!_sourceValid()) {_state = RESPONSE_FAILED;request->client()->close();return 0;}#if ASYNCWEBSERVER_USE_CHUNK_INFLIGHT/*for response payloads with unknown length or length larger than TCP_WND we need to control AsyncTCP's queue and in-flight fragmentation.Either user callback could fill buffer with very small chunks or long running large response could receive a lot of poll() calls here,both could flood asynctcp's queue with large number of events to handle and fragment socket buffer space for large responses.Let's ignore polled acks and acks in case when available window size is less than our used buffer size since we won't be able to fill and send it wholeThat way we could balance on having at least half tcp win in-flight while minimizing send/ack events in asynctcp QThis could decrease sustained bandwidth for one single connection but would drastically improve parallelism and equalize bandwidth sharing*/// return a credit for each chunk of acked data (polls does not give any credits)if (len) {++_in_flight_credit;_in_flight -= std::min(len, _in_flight);}if (_chunked || !_sendContentLength || (_sentLength > CONFIG_LWIP_TCP_WND_DEFAULT)) {if (!_in_flight_credit || (ASYNC_RESPONCE_BUFF_SIZE > request->client()->space())) {// async_ws_log_d("defer user call in_flight:%u, tcpwin:%u", _in_flight, request->client()->space());// take the credit back since we are ignoring this ack and rely on other inflight data acksif (len) {--_in_flight_credit;}return 0;}}#endif// this is not functionally needed in AsyncAbstractResponse itself, but kept for compatibility if some of the derived classes are rely on it somehow_ackedLength += len;size_t payloadlen{0}; // amount of data to be written to tcp sockbuff during this call, used as return value of this method// send http headers firstif (_state == RESPONSE_HEADERS) {// copy headers buffer to sock buffersize_t const pcb_written = request->client()->add(_assembled_headers.c_str() + _writtenHeadersLength, _assembled_headers.length() - _writtenHeadersLength);_writtenLength += pcb_written;_writtenHeadersLength += pcb_written;if (_writtenHeadersLength < _assembled_headers.length()) {// we were not able to fit all headers in current buff, send this part here and return later for the rest#if ASYNCWEBSERVER_USE_CHUNK_INFLIGHT_in_flight += pcb_written;--_in_flight_credit; // take a credit#endifif (!request->client()->send()) {// something is wrong, what should we do here?request->client()->close();return 0;}return pcb_written;}// otherwise we've added all the (remainder) headers in current buff_state = RESPONSE_CONTENT;payloadlen += pcb_written;_assembled_headers = String(); // clear}// send content bodyif (_state == RESPONSE_CONTENT) {do {if (_send_buffer_len && _send_buffer) {// data is pending in buffer from a previous call or previous iterationsize_t const added_len =request->client()->add(reinterpret_cast<char *>(_send_buffer->data() + _send_buffer_offset), _send_buffer_len - _send_buffer_offset);if (added_len != _send_buffer_len - _send_buffer_offset) {// we were not able to add entire buffer's content to tcp buffs, leave it for later// (this should not happen normally unless connection's TCP window suddenly changed from remote or mem pressure)_send_buffer_offset += added_len;break;} else {_send_buffer_len = _send_buffer_offset = 0; // consider buffer empty}payloadlen += added_len;}auto tcp_win = request->client()->space();if (tcp_win == 0 || _state == RESPONSE_END) {break; // no room left or no more data}if ((_chunked || !_sendContentLength) && (tcp_win < CONFIG_LWIP_TCP_MSS / 2)) {// available window size is not enough to send a new chunk sized half of tcp mss, let's wait for better chance and reduce pressure to AsyncTCP's event Qbreak;}if (!_send_buffer) {auto p = new (std::nothrow) std::array<uint8_t, ASYNC_RESPONCE_BUFF_SIZE>;if (p) {_send_buffer.reset(p);_send_buffer_len = _send_buffer_offset = 0;} else {break; // OOM}}if (_chunked) {// HTTP 1.1 allows leading zeros in chunk length. Or spaces may be added.// See https://datatracker.ietf.org/doc/html/rfc9112#section-7.1size_t const readLen =_fillBufferAndProcessTemplates(_send_buffer->data() + 6, std::min(_send_buffer->size(), tcp_win) - 8); // reserve 8 bytes for chunk size dataif (readLen != RESPONSE_TRY_AGAIN) {// Write 4 hex digits directly without null terminatorstatic constexpr char hexChars[] = "0123456789abcdef";_send_buffer->data()[0] = hexChars[(readLen >> 12) & 0xF];_send_buffer->data()[1] = hexChars[(readLen >> 8) & 0xF];_send_buffer->data()[2] = hexChars[(readLen >> 4) & 0xF];_send_buffer->data()[3] = hexChars[readLen & 0xF];_send_buffer->data()[4] = '\r';_send_buffer->data()[5] = '\n';// data (readLen bytes) is already there_send_buffer->at(readLen + 6) = '\r';_send_buffer->at(readLen + 7) = '\n';_send_buffer_len += readLen + 8; // set buffers's size to match added data_sentLength += readLen; // data is not sent yet, but we won't get a chance to count this later properly for chunked dataif (!readLen) {// last chunk?_state = RESPONSE_END;}}} else {// Non-chunked data. We can either have a response:// - with a known content-length (example: Json response), in that case we pass the remaining length if lower than tcp_win// - or with unknown content-length (see LargeResponse example, like ESP32Cam with streaming), in that case we just fill as much as tcp_win allowssize_t maxLen = std::min(_send_buffer->size(), tcp_win);if (_contentLength) {maxLen = _contentLength > _sentLength ? std::min(maxLen, _contentLength - _sentLength) : 0;}size_t const readLen = _fillBufferAndProcessTemplates(_send_buffer->data(), maxLen);if (readLen == 0) {// no more data to send_state = RESPONSE_END;} else if (readLen != RESPONSE_TRY_AGAIN) {_send_buffer_len += readLen; // set buffers's size to match added data_sentLength += readLen; // data is not sent yet, but we need it to understand that it would be last blockif (_sendContentLength && (_sentLength == _contentLength)) {// it was last piece of content_state = RESPONSE_END;}}}} while (_send_buffer_len); // go on till we have something in buffer pending to send// execute sending whatever we have in sock buffs nowrequest->client()->send();_writtenLength += payloadlen;#if ASYNCWEBSERVER_USE_CHUNK_INFLIGHT_in_flight += payloadlen;--_in_flight_credit; // take a credit#endifif (_send_buffer_len == 0) {// buffer empty, we can release mem, otherwise need to keep it till next run (should not happen under normal conditions)_send_buffer.reset();}return payloadlen;} // (_state == RESPONSE_CONTENT)// implicit checkif (_state == RESPONSE_WAIT_ACK) {// we do not need to wait for any acks actually if we won't send any more data,// connection would be closed gracefully with last piece of data (in AsyncWebServerRequest::_onAck)_state = RESPONSE_END;}return 0;}size_t AsyncAbstractResponse::_readDataFromCacheOrContent(uint8_t *data, const size_t len) {// If we have something in cache, copy it to bufferconst size_t readFromCache = std::min(len, _cache.size());if (readFromCache) {memcpy(data, _cache.data(), readFromCache);_cache.erase(_cache.begin(), _cache.begin() + readFromCache);}// If we need to read more...const size_t needFromFile = len - readFromCache;const size_t readFromContent = _fillBuffer(data + readFromCache, needFromFile);return readFromCache + readFromContent;}size_t AsyncAbstractResponse::_fillBufferAndProcessTemplates(uint8_t *data, size_t len) {if (!_callback) {return _fillBuffer(data, len);}const size_t originalLen = len;len = _readDataFromCacheOrContent(data, len);// Now we've read 'len' bytes, either from cache or from file// Search for template placeholdersuint8_t *pTemplateStart = data;while ((pTemplateStart < &data[len]) && (pTemplateStart = (uint8_t *)memchr(pTemplateStart, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart + 1))) {// data[0] ... data[len - 1]uint8_t *pTemplateEnd =(pTemplateStart < &data[len - 1]) ? (uint8_t *)memchr(pTemplateStart + 1, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart) : nullptr;// temporary buffer to hold parameter nameuint8_t buf[TEMPLATE_PARAM_NAME_LENGTH + 1];String paramName;// If closing placeholder is found:if (pTemplateEnd) {// prepare argument to callbackconst size_t paramNameLength = std::min((size_t)sizeof(buf) - 1, (size_t)(pTemplateEnd - pTemplateStart - 1));if (paramNameLength) {memcpy(buf, pTemplateStart + 1, paramNameLength);buf[paramNameLength] = 0;paramName = String(reinterpret_cast<char *>(buf));} else { // double percent sign encountered, this is single percent sign escaped.// remove the 2nd percent signmemmove(pTemplateEnd, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);len += _readDataFromCacheOrContent(&data[len - 1], 1) - 1;++pTemplateStart;}} else if (&data[len - 1] - pTemplateStart + 1< TEMPLATE_PARAM_NAME_LENGTH + 2) { // closing placeholder not found, check if it's in the remaining file datamemcpy(buf, pTemplateStart + 1, &data[len - 1] - pTemplateStart);const size_t readFromCacheOrContent =_readDataFromCacheOrContent(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PARAM_NAME_LENGTH + 2 - (&data[len - 1] - pTemplateStart + 1));if (readFromCacheOrContent) {pTemplateEnd = (uint8_t *)memchr(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PLACEHOLDER, readFromCacheOrContent);if (pTemplateEnd) {// prepare argument to callback*pTemplateEnd = 0;paramName = String(reinterpret_cast<char *>(buf));// Copy remaining read-ahead data into cache_cache.insert(_cache.begin(), pTemplateEnd + 1, buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);pTemplateEnd = &data[len - 1];} else // closing placeholder not found in file data, store found percent symbol as is and advance to the next position{// but first, store read file data in cache_cache.insert(_cache.begin(), buf + (&data[len - 1] - pTemplateStart), buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);++pTemplateStart;}} else { // closing placeholder not found in content data, store found percent symbol as is and advance to the next position++pTemplateStart;}} else { // closing placeholder not found in content data, store found percent symbol as is and advance to the next position++pTemplateStart;}if (paramName.length()) {// call callback and replace with result.// Everything in range [pTemplateStart, pTemplateEnd] can be safely replaced with parameter value.// Data after pTemplateEnd may need to be moved.// The first byte of data after placeholder is located at pTemplateEnd + 1.// It should be located at pTemplateStart + numBytesCopied (to begin right after inserted parameter value).const String paramValue(_callback(paramName));const char *pvstr = paramValue.c_str();const unsigned int pvlen = paramValue.length();const size_t numBytesCopied = std::min(pvlen, static_cast<unsigned int>(&data[originalLen - 1] - pTemplateStart + 1));// make room for param value// 1. move extra data to cache if parameter value is longer than placeholder AND if there is no room to storeif ((pTemplateEnd + 1 < pTemplateStart + numBytesCopied) && (originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1) < len)) {_cache.insert(_cache.begin(), &data[originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1)], &data[len]);// 2. parameter value is longer than placeholder text, push the data after placeholder which not saved into cache further to the endmemmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[originalLen] - pTemplateStart - numBytesCopied);len = originalLen; // fix issue with truncated data, not sure if it has any side effects} else if (pTemplateEnd + 1 != pTemplateStart + numBytesCopied) {// 2. Either parameter value is shorter than placeholder text OR there is enough free space in buffer to fit.// Move the entire data after the placeholdermemmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);}// 3. replace placeholder with actual valuememcpy(pTemplateStart, pvstr, numBytesCopied);// If result is longer than buffer, copy the remainder into cache (this could happen only if placeholder text itself did not fit entirely in buffer)if (numBytesCopied < pvlen) {_cache.insert(_cache.begin(), pvstr + numBytesCopied, pvstr + pvlen);} else if (pTemplateStart + numBytesCopied < pTemplateEnd + 1) { // result is copied fully; if result is shorter than placeholder text...// there is some free room, fill it from cacheconst size_t roomFreed = pTemplateEnd + 1 - pTemplateStart - numBytesCopied;const size_t totalFreeRoom = originalLen - len + roomFreed;len += _readDataFromCacheOrContent(&data[len - roomFreed], totalFreeRoom) - roomFreed;} else { // result is copied fully; it is longer than placeholder textconst size_t roomTaken = pTemplateStart + numBytesCopied - pTemplateEnd - 1;len = std::min(len + roomTaken, originalLen);}}} // while(pTemplateStart)return len;}/** File Response* *//*** @brief Sets the content type based on the file path extension** This method determines the appropriate MIME content type for a file based on its* file extension. It supports both external content type functions (if available)* and an internal mapping of common file extensions to their corresponding MIME types.** @param path The file path string from which to extract the extension* @note The method modifies the internal _contentType member variable*/void AsyncFileResponse::_setContentTypeFromPath(const String &path) {#if HAVE_EXTERN_GET_Content_Type_FUNCTION#ifndef ESP8266extern const char *getContentType(const String &path);#elseextern const __FlashStringHelper *getContentType(const String &path);#endif_contentType = getContentType(path);#elseconst char *cpath = path.c_str();const char *dot = strrchr(cpath, '.');if (!dot) {_contentType = T_application_octet_stream;return;}if (strcmp(dot, T__html) == 0 || strcmp(dot, T__htm) == 0) {_contentType = T_text_html;} else if (strcmp(dot, T__css) == 0) {_contentType = T_text_css;} else if (strcmp(dot, T__js) == 0 || strcmp(dot, T__mjs) == 0) {_contentType = T_text_javascript;} else if (strcmp(dot, T__json) == 0) {_contentType = T_application_json;} else if (strcmp(dot, T__png) == 0) {_contentType = T_image_png;} else if (strcmp(dot, T__ico) == 0) {_contentType = T_image_x_icon;} else if (strcmp(dot, T__svg) == 0) {_contentType = T_image_svg_xml;} else if (strcmp(dot, T__jpg) == 0) {_contentType = T_image_jpeg;} else if (strcmp(dot, T__webp) == 0) {_contentType = T_image_webp;} else if (strcmp(dot, T__avif) == 0) {_contentType = T_image_avif;} else if (strcmp(dot, T__gif) == 0) {_contentType = T_image_gif;} else if (strcmp(dot, T__woff2) == 0) {_contentType = T_font_woff2;} else if (strcmp(dot, T__woff) == 0) {_contentType = T_font_woff;} else if (strcmp(dot, T__ttf) == 0) {_contentType = T_font_ttf;} else if (strcmp(dot, T__xml) == 0) {_contentType = T_text_xml;} else if (strcmp(dot, T__pdf) == 0) {_contentType = T_application_pdf;} else if (strcmp(dot, T__mp4) == 0) {_contentType = T_video_mp4;} else if (strcmp(dot, T__opus) == 0) {_contentType = T_audio_opus;} else if (strcmp(dot, T__webm) == 0) {_contentType = T_video_webm;} else if (strcmp(dot, T__txt) == 0) {_contentType = T_text_plain;} else {_contentType = T_application_octet_stream;}#endif}/*** @brief Constructor for AsyncFileResponse that handles file serving with compression support** This constructor creates an AsyncFileResponse object that can serve files from a filesystem,* with automatic fallback to gzip-compressed versions if the original file is not found.* It also handles ETag generation for caching and supports both inline and download modes.** @param fs Reference to the filesystem object used to open files* @param path Path to the file to be served (without compression extension)* @param contentType MIME type of the file content (empty string for auto-detection)* @param download If true, file will be served as download attachment; if false, as inline content* @param callback Template processor callback for dynamic content processing*/AsyncFileResponse::AsyncFileResponse(FS &fs, const String &path, const char *contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) {// Try to open the uncompressed version first_content = fs.open(path, fs::FileOpenMode::read);if (!_content.available()) {// If not available try to open the compressed version (.gz)String gzPath;uint16_t pathLen = path.length();gzPath.reserve(pathLen + 3);gzPath.concat(path);gzPath.concat(asyncsrv::T__gz);_content = fs.open(gzPath, fs::FileOpenMode::read);char serverETag[11];if (AsyncWebServerRequest::_getEtag(_content, serverETag)) {addHeader(T_Content_Encoding, T_gzip, false);_callback = nullptr; // Unable to process zipped templates_sendContentLength = true;_chunked = false;// Add ETag and cache headersaddHeader(T_ETag, serverETag, true);addHeader(T_Cache_Control, T_no_cache, true);_content.seek(0);} else {// File is corrupted or invalid_code = 404;return;}}_contentLength = _content.size();if (*contentType == '\0') {_setContentTypeFromPath(path);} else {_contentType = contentType;}if (download) {// Extract filename from path and set as download attachmentint filenameStart = path.lastIndexOf('/') + 1;const char *filename = path.c_str() + filenameStart;String buf;buf.reserve(sizeof(T_attachment) - 1 + strlen(filename) + 2);buf = T_attachment;buf += filename;buf += "\"";addHeader(T_Content_Disposition, buf, false);} else {// Serve file inline (display in browser)addHeader(T_Content_Disposition, T_inline, false);}_code = 200;}AsyncFileResponse::AsyncFileResponse(File content, const String &path, const char *contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) {_code = 200;if (String(content.name()).endsWith(T__gz) && !path.endsWith(T__gz)) {addHeader(T_Content_Encoding, T_gzip, false);_callback = nullptr; // Unable to process gzipped templates_sendContentLength = true;_chunked = false;}_content = content;_contentLength = _content.size();if (*contentType == '\0') {_setContentTypeFromPath(path);} else {_contentType = contentType;}if (download) {// Extract filename from path and set as download attachmentint filenameStart = path.lastIndexOf('/') + 1;const char *filename = path.c_str() + filenameStart;String buf;buf.reserve(sizeof(T_attachment) - 1 + strlen(filename) + 2);buf = T_attachment;buf += filename;buf += "\"";addHeader(T_Content_Disposition, buf, false);} else {// Serve file inline (display in browser)addHeader(T_Content_Disposition, T_inline, false);}}size_t AsyncFileResponse::_fillBuffer(uint8_t *data, size_t len) {return _content.read(data, len);}/** Stream Response* */AsyncStreamResponse::AsyncStreamResponse(Stream &stream, const char *contentType, size_t len, AwsTemplateProcessor callback) : AsyncAbstractResponse(callback) {_code = 200;_content = &stream;_contentLength = len;_contentType = contentType;}size_t AsyncStreamResponse::_fillBuffer(uint8_t *data, size_t len) {size_t available = _content->available();size_t outLen = (available > len) ? len : available;size_t i;for (i = 0; i < outLen; i++) {data[i] = _content->read();}return outLen;}/** Callback Response* */AsyncCallbackResponse::AsyncCallbackResponse(const char *contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback): AsyncAbstractResponse(templateCallback) {_code = 200;_content = callback;_contentLength = len;if (!len) {_sendContentLength = false;}_contentType = contentType;_filledLength = 0;}size_t AsyncCallbackResponse::_fillBuffer(uint8_t *data, size_t len) {size_t ret = _content(data, len, _filledLength);if (ret != RESPONSE_TRY_AGAIN) {_filledLength += ret;}return ret;}/** Chunked Response* */AsyncChunkedResponse::AsyncChunkedResponse(const char *contentType, AwsResponseFiller callback, AwsTemplateProcessor processorCallback): AsyncAbstractResponse(processorCallback) {_code = 200;_content = callback;_contentLength = 0;_contentType = contentType;_sendContentLength = false;_chunked = true;_filledLength = 0;}size_t AsyncChunkedResponse::_fillBuffer(uint8_t *data, size_t len) {size_t ret = _content(data, len, _filledLength);if (ret != RESPONSE_TRY_AGAIN) {_filledLength += ret;}return ret;}/** Progmem Response* */AsyncProgmemResponse::AsyncProgmemResponse(int code, const char *contentType, const uint8_t *content, size_t len, AwsTemplateProcessor callback): AsyncAbstractResponse(callback), _content(content), _index(0) {_code = code;_contentType = contentType;_contentLength = len;}size_t AsyncProgmemResponse::_fillBuffer(uint8_t *data, size_t len) {size_t read_size = std::min(len, _contentLength - _index);memcpy_P(data, _content + _index, read_size);_index += read_size;return read_size;}/** Response Stream (You can print/write/printf to it, up to the contentLen bytes)* */AsyncResponseStream::AsyncResponseStream(const char *contentType, size_t bufferSize) {_code = 200;_contentLength = 0;_contentType = contentType;// internal buffer will be null on allocation failure_content = std::unique_ptr<cbuf>(new cbuf(bufferSize));if (bufferSize && _content->size() < bufferSize) {async_ws_log_e("Failed to allocate");}}size_t AsyncResponseStream::_fillBuffer(uint8_t *buf, size_t maxLen) {return _content->read((char *)buf, maxLen);}size_t AsyncResponseStream::write(const uint8_t *data, size_t len) {if (_started()) {return 0;}if (len > _content->room()) {size_t needed = len - _content->room();_content->resizeAdd(needed);// log a warning if allocation failed, but do not return: keep writing the bytes we can// with _content->write: if len is more than the available size in the buffer, only// the available size will be writtenif (len > _content->room()) {async_ws_log_e("Failed to allocate");}}size_t written = _content->write((const char *)data, len);_contentLength += written;return written;}size_t AsyncResponseStream::write(uint8_t data) {return write(&data, 1);}