438 lines
12 KiB
C++
438 lines
12 KiB
C++
#include "ESPAsyncWebServer.h"
|
|
#include "AsyncWebServerResponseImpl.h"
|
|
#include "cbuf.h"
|
|
|
|
/*
|
|
* Abstract Response
|
|
* */
|
|
const char* AsyncWebServerResponse::_responseCodeToString(int code) {
|
|
switch (code) {
|
|
case 100: return "Continue";
|
|
case 101: return "Switching Protocols";
|
|
case 200: return "OK";
|
|
case 201: return "Created";
|
|
case 202: return "Accepted";
|
|
case 203: return "Non-Authoritative Information";
|
|
case 204: return "No Content";
|
|
case 205: return "Reset Content";
|
|
case 206: return "Partial Content";
|
|
case 300: return "Multiple Choices";
|
|
case 301: return "Moved Permanently";
|
|
case 302: return "Found";
|
|
case 303: return "See Other";
|
|
case 304: return "Not Modified";
|
|
case 305: return "Use Proxy";
|
|
case 307: return "Temporary Redirect";
|
|
case 400: return "Bad Request";
|
|
case 401: return "Unauthorized";
|
|
case 402: return "Payment Required";
|
|
case 403: return "Forbidden";
|
|
case 404: return "Not Found";
|
|
case 405: return "Method Not Allowed";
|
|
case 406: return "Not Acceptable";
|
|
case 407: return "Proxy Authentication Required";
|
|
case 408: return "Request Time-out";
|
|
case 409: return "Conflict";
|
|
case 410: return "Gone";
|
|
case 411: return "Length Required";
|
|
case 412: return "Precondition Failed";
|
|
case 413: return "Request Entity Too Large";
|
|
case 414: return "Request-URI Too Large";
|
|
case 415: return "Unsupported Media Type";
|
|
case 416: return "Requested range not satisfiable";
|
|
case 417: return "Expectation Failed";
|
|
case 500: return "Internal Server Error";
|
|
case 501: return "Not Implemented";
|
|
case 502: return "Bad Gateway";
|
|
case 503: return "Service Unavailable";
|
|
case 504: return "Gateway Time-out";
|
|
case 505: return "HTTP Version not supported";
|
|
default: return "";
|
|
}
|
|
}
|
|
|
|
AsyncWebServerResponse::AsyncWebServerResponse()
|
|
: _code(0)
|
|
, _headers(NULL)
|
|
, _contentType()
|
|
, _contentLength(0)
|
|
, _sendContentLength(true)
|
|
, _chunked(false)
|
|
, _headLength(0)
|
|
, _sentLength(0)
|
|
, _ackedLength(0)
|
|
, _state(RESPONSE_SETUP)
|
|
{
|
|
addHeader("Connection","close");
|
|
addHeader("Access-Control-Allow-Origin","*");
|
|
}
|
|
|
|
AsyncWebServerResponse::~AsyncWebServerResponse(){
|
|
while(_headers != NULL){
|
|
AsyncWebHeader *h = _headers;
|
|
_headers = h->next;
|
|
delete h;
|
|
}
|
|
}
|
|
|
|
void AsyncWebServerResponse::setContentLength(size_t len){
|
|
if(_state == RESPONSE_SETUP)
|
|
_contentLength = len;
|
|
}
|
|
|
|
void AsyncWebServerResponse::setContentType(String type){
|
|
if(_state == RESPONSE_SETUP)
|
|
_contentType = type;
|
|
}
|
|
|
|
void AsyncWebServerResponse::addHeader(String name, String value){
|
|
AsyncWebHeader *header = new AsyncWebHeader(name, value);
|
|
if(_headers == NULL){
|
|
_headers = header;
|
|
} else {
|
|
AsyncWebHeader *h = _headers;
|
|
while(h->next != NULL) h = h->next;
|
|
h->next = header;
|
|
}
|
|
}
|
|
|
|
String AsyncWebServerResponse::_assembleHead(uint8_t version){
|
|
if(version){
|
|
addHeader("Accept-Ranges","none");
|
|
if(_chunked)
|
|
addHeader("Transfer-Encoding","chunked");
|
|
}
|
|
String out = "HTTP/1." + String(version) + " " + String(_code) + " " + _responseCodeToString(_code) + "\r\n";
|
|
if(_sendContentLength)
|
|
out += "Content-Length: " + String(_contentLength) + "\r\n";
|
|
|
|
if(_contentType.length())
|
|
out += "Content-Type: " + _contentType + "\r\n";
|
|
|
|
AsyncWebHeader *h;
|
|
while(_headers != NULL){
|
|
h = _headers;
|
|
_headers = _headers->next;
|
|
out += h->toString();
|
|
delete h;
|
|
}
|
|
out += "\r\n";
|
|
_headLength = out.length();
|
|
return out;
|
|
}
|
|
|
|
bool AsyncWebServerResponse::_finished(){ return _state > RESPONSE_WAIT_ACK; }
|
|
bool AsyncWebServerResponse::_failed(){ return _state == RESPONSE_FAILED; }
|
|
void AsyncWebServerResponse::_respond(AsyncWebServerRequest *request){ _state = RESPONSE_END; request->client()->close(); }
|
|
size_t AsyncWebServerResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){ return 0; }
|
|
|
|
/*
|
|
* String/Code Response
|
|
* */
|
|
AsyncBasicResponse::AsyncBasicResponse(int code, String contentType, String content){
|
|
_code = code;
|
|
_content = content;
|
|
_contentType = contentType;
|
|
if(_content.length()){
|
|
_contentLength = _content.length();
|
|
if(!_contentType.length())
|
|
_contentType = "text/plain";
|
|
}
|
|
}
|
|
|
|
void AsyncBasicResponse::_respond(AsyncWebServerRequest *request){
|
|
_state = RESPONSE_HEADERS;
|
|
String out = _assembleHead(request->version());
|
|
size_t outLen = out.length();
|
|
size_t space = request->client()->space();
|
|
if(!_contentLength && space >= outLen){
|
|
request->client()->write(out.c_str(), outLen);
|
|
_state = RESPONSE_WAIT_ACK;
|
|
} else if(_contentLength && space >= outLen + _contentLength){
|
|
out += _content;
|
|
outLen += _contentLength;
|
|
request->client()->write(out.c_str(), outLen);
|
|
_state = RESPONSE_WAIT_ACK;
|
|
} else if(space && space < out.length()){
|
|
String partial = out.substring(0, space);
|
|
_content = out.substring(space) + _content;
|
|
_contentLength += outLen - space;
|
|
request->client()->write(partial.c_str(), partial.length());
|
|
_state = RESPONSE_CONTENT;
|
|
} else if(space > outLen && space < (outLen + _contentLength)){
|
|
size_t shift = space - outLen;
|
|
outLen += shift;
|
|
_sentLength += shift;
|
|
out += _content.substring(0, shift);
|
|
_content = _content.substring(shift);
|
|
request->client()->write(out.c_str(), outLen);
|
|
_state = RESPONSE_CONTENT;
|
|
} else {
|
|
_content = out + _content;
|
|
_contentLength += outLen;
|
|
_state = RESPONSE_CONTENT;
|
|
}
|
|
}
|
|
|
|
size_t AsyncBasicResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){
|
|
_ackedLength += len;
|
|
if(_state == RESPONSE_CONTENT){
|
|
size_t available = _contentLength - _sentLength;
|
|
size_t space = request->client()->space();
|
|
//we can fit in this packet
|
|
if(space > available){
|
|
request->client()->write(_content.c_str(), available);
|
|
_content = String();
|
|
_state = RESPONSE_WAIT_ACK;
|
|
return available;
|
|
}
|
|
//send some data, the rest on ack
|
|
String out = _content.substring(0, space);
|
|
_content = _content.substring(space);
|
|
_sentLength += space;
|
|
request->client()->write(out.c_str(), space);
|
|
return space;
|
|
} else if(_state == RESPONSE_WAIT_ACK){
|
|
if(_ackedLength >= (_headLength+_contentLength)){
|
|
_state = RESPONSE_END;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Abstract Response
|
|
* */
|
|
|
|
void AsyncAbstractResponse::_respond(AsyncWebServerRequest *request){
|
|
if(!_sourceValid()){
|
|
_state = RESPONSE_FAILED;
|
|
request->send(500);
|
|
return;
|
|
}
|
|
_head = _assembleHead(request->version());
|
|
_state = RESPONSE_HEADERS;
|
|
size_t outLen = _head.length();
|
|
size_t space = request->client()->space();
|
|
if(space >= outLen){
|
|
request->client()->write(_head.c_str(), outLen);
|
|
_head = String();
|
|
_state = RESPONSE_CONTENT;
|
|
} else {
|
|
String out = _head.substring(0, space);
|
|
_head = _head.substring(space);
|
|
request->client()->write(out.c_str(), out.length());
|
|
out = String();
|
|
}
|
|
}
|
|
|
|
size_t AsyncAbstractResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){
|
|
if(!_sourceValid()){
|
|
_state = RESPONSE_FAILED;
|
|
request->client()->close();
|
|
return 0;
|
|
}
|
|
_ackedLength += len;
|
|
size_t space = request->client()->space();
|
|
if(_state == RESPONSE_CONTENT){
|
|
size_t outLen;
|
|
size_t readLen = 0;
|
|
|
|
if(_chunked || !_sendContentLength){
|
|
outLen = space;
|
|
} else {
|
|
size_t remaining = _contentLength - _sentLength;
|
|
outLen = (remaining > space)?space:remaining;
|
|
}
|
|
uint8_t *buf = (uint8_t *)malloc(outLen);
|
|
|
|
if(_chunked){
|
|
readLen = _fillBuffer(buf, outLen - 8);
|
|
char pre[6];
|
|
sprintf(pre, "%x\r\n", readLen);
|
|
size_t preLen = strlen(pre);
|
|
memmove(buf+preLen, buf, preLen);
|
|
for(size_t i=0; i<preLen; i++)
|
|
buf[i] = pre[i];
|
|
outLen = preLen + readLen;
|
|
buf[outLen++] = '\r';
|
|
buf[outLen++] = '\n';
|
|
} else {
|
|
outLen = _fillBuffer(buf, outLen);
|
|
}
|
|
|
|
if(outLen)
|
|
outLen = request->client()->write((const char*)buf, outLen);
|
|
_sentLength += outLen;
|
|
free(buf);
|
|
|
|
if((_chunked && readLen == 0) || (!_sendContentLength && outLen == 0) || _sentLength == _contentLength){
|
|
_state = RESPONSE_WAIT_ACK;
|
|
}
|
|
return outLen;
|
|
|
|
} else if(_state == RESPONSE_HEADERS){
|
|
size_t outLen = _head.length();
|
|
if(space >= outLen){
|
|
request->client()->write(_head.c_str(), outLen);
|
|
_head = String();
|
|
_state = RESPONSE_CONTENT;
|
|
return outLen;
|
|
} else {
|
|
String out = _head.substring(0, space);
|
|
_head = _head.substring(space);
|
|
request->client()->write(out.c_str(), out.length());
|
|
return out.length();
|
|
}
|
|
} else if(_state == RESPONSE_WAIT_ACK){
|
|
if(!_sendContentLength || _ackedLength >= (_headLength+_contentLength)){
|
|
_state = RESPONSE_END;
|
|
if(!_chunked && !_sendContentLength)
|
|
request->client()->close();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
* File Response
|
|
* */
|
|
|
|
AsyncFileResponse::~AsyncFileResponse(){
|
|
if(_content)
|
|
_content.close();
|
|
}
|
|
|
|
void AsyncFileResponse::_setContentType(String path){
|
|
if (path.endsWith(".html")) _contentType = "text/html";
|
|
else if (path.endsWith(".htm")) _contentType = "text/html";
|
|
else if (path.endsWith(".css")) _contentType = "text/css";
|
|
else if (path.endsWith(".txt")) _contentType = "text/plain";
|
|
else if (path.endsWith(".js")) _contentType = "application/javascript";
|
|
else if (path.endsWith(".png")) _contentType = "image/png";
|
|
else if (path.endsWith(".gif")) _contentType = "image/gif";
|
|
else if (path.endsWith(".jpg")) _contentType = "image/jpeg";
|
|
else if (path.endsWith(".ico")) _contentType = "image/x-icon";
|
|
else if (path.endsWith(".svg")) _contentType = "image/svg+xml";
|
|
else if (path.endsWith(".xml")) _contentType = "text/xml";
|
|
else if (path.endsWith(".pdf")) _contentType = "application/pdf";
|
|
else if (path.endsWith(".zip")) _contentType = "application/zip";
|
|
else if(path.endsWith(".gz")) _contentType = "application/x-gzip";
|
|
else _contentType = "application/octet-stream";
|
|
}
|
|
|
|
AsyncFileResponse::AsyncFileResponse(FS &fs, String path, String contentType, bool download){
|
|
_code = 200;
|
|
_path = path;
|
|
if(!download && !fs.exists(_path) && fs.exists(_path+".gz")){
|
|
_path = _path+".gz";
|
|
addHeader("Content-Encoding", "gzip");
|
|
}
|
|
|
|
if(download)
|
|
_contentType = "application/octet-stream";
|
|
else
|
|
_setContentType(path);
|
|
_content = fs.open(_path, "r");
|
|
_contentLength = _content.size();
|
|
}
|
|
|
|
size_t AsyncFileResponse::_fillBuffer(uint8_t *data, size_t len){
|
|
_content.read(data, len);
|
|
return len;
|
|
}
|
|
|
|
/*
|
|
* Stream Response
|
|
* */
|
|
|
|
AsyncStreamResponse::AsyncStreamResponse(Stream &stream, String contentType, size_t len){
|
|
_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(String contentType, size_t len, AwsResponseFiller callback){
|
|
_code = 200;
|
|
_content = callback;
|
|
_contentLength = len;
|
|
if(!len)
|
|
_sendContentLength = false;
|
|
_contentType = contentType;
|
|
}
|
|
|
|
size_t AsyncCallbackResponse::_fillBuffer(uint8_t *data, size_t len){
|
|
return _content(data, len);
|
|
}
|
|
|
|
/*
|
|
* Chunked Response
|
|
* */
|
|
|
|
AsyncChunkedResponse::AsyncChunkedResponse(String contentType, AwsResponseFiller callback){
|
|
_code = 200;
|
|
_content = callback;
|
|
_contentLength = 0;
|
|
_contentType = contentType;
|
|
_sendContentLength = false;
|
|
_chunked = true;
|
|
}
|
|
|
|
size_t AsyncChunkedResponse::_fillBuffer(uint8_t *data, size_t len){
|
|
return _content(data, len);
|
|
}
|
|
|
|
|
|
/*
|
|
* Response Stream (You can print/write/printf to it, up to the contentLen bytes)
|
|
* */
|
|
|
|
AsyncResponseStream::AsyncResponseStream(String contentType, size_t len, size_t bufferSize){
|
|
_code = 200;
|
|
_contentLength = len;
|
|
if(!len)
|
|
_sendContentLength = false;
|
|
_contentType = contentType;
|
|
_content = new cbuf(bufferSize);
|
|
}
|
|
|
|
AsyncResponseStream::~AsyncResponseStream(){
|
|
delete _content;
|
|
}
|
|
|
|
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(_finished() || (_content->room() == 0 && ETS_INTR_WITHINISR()))
|
|
return 0;
|
|
if(len > _content->available())
|
|
len = _content->available();
|
|
while(_content->room() < len) delay(0);
|
|
return _content->write((const char*)data, len);
|
|
}
|
|
|
|
size_t AsyncResponseStream::write(uint8_t data){
|
|
return write(&data, 1);
|
|
}
|
|
|