feedc0de/ESPAsyncWebServer
1
0
Fork 0
forked from me-no-dev/ESPAsyncWebServer
Code Pull Requests Activity

_controlQueue is now a std::queue

Browse Source
This commit is contained in:
0xFEEDC0DE64
2020-12-19 23:26:51 +01:00
parent 8bb1c704cd
commit f5e439c8f8
2 changed files with 26 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/AsyncWebSocket.cpp
View File

@ -475,8 +475,7 @@ AsyncWebSocketMultiMessage::~AsyncWebSocketMultiMessage() {
const size_t AWSC_PING_PAYLOAD_LEN = 22; const size_t AWSC_PING_PAYLOAD_LEN = 22;
AsyncWebSocketClient::AsyncWebSocketClient(AsyncWebServerRequest *request, AsyncWebSocket *server) AsyncWebSocketClient::AsyncWebSocketClient(AsyncWebServerRequest *request, AsyncWebSocket *server)
: _controlQueue(LinkedList<AsyncWebSocketControl *>([](AsyncWebSocketControl *c){ delete c; })) : _messageQueue(LinkedList<AsyncWebSocketMessage *>([](AsyncWebSocketMessage *m){ delete m; }))
, _messageQueue(LinkedList<AsyncWebSocketMessage *>([](AsyncWebSocketMessage *m){ delete m; }))
, _tempObject(NULL) , _tempObject(NULL)
{ {
_client = request->client(); _client = request->client();
@ -500,23 +499,23 @@ AsyncWebSocketClient::AsyncWebSocketClient(AsyncWebServerRequest *request, Async
AsyncWebSocketClient::~AsyncWebSocketClient(){ AsyncWebSocketClient::~AsyncWebSocketClient(){
_messageQueue.free(); _messageQueue.free();
_controlQueue.free(); _controlQueue = {};
_server->_handleEvent(this, WS_EVT_DISCONNECT, NULL, NULL, 0); _server->_handleEvent(this, WS_EVT_DISCONNECT, NULL, NULL, 0);
} }
void AsyncWebSocketClient::_onAck(size_t len, uint32_t time){ void AsyncWebSocketClient::_onAck(size_t len, uint32_t time){
_lastMessageTime = millis(); _lastMessageTime = millis();
if(!_controlQueue.isEmpty()){ if (!_controlQueue.empty()){
auto head = _controlQueue.front(); auto &head = _controlQueue.front();
if(head->finished()){ if (head.finished()){
len -= head->len(); len -= head.len();
if(_status == WS_DISCONNECTING && head->opcode() == WS_DISCONNECT){ if (_status == WS_DISCONNECTING && head.opcode() == WS_DISCONNECT){
_controlQueue.remove(head); _controlQueue.pop();
_status = WS_DISCONNECTED; _status = WS_DISCONNECTED;
_client->close(true); _client->close(true);
return; return;
} }
_controlQueue.remove(head); _controlQueue.pop();
} }
} }
if(len && !_messageQueue.isEmpty()){ if(len && !_messageQueue.isEmpty()){
@ -527,9 +526,9 @@ void AsyncWebSocketClient::_onAck(size_t len, uint32_t time){
} }
void AsyncWebSocketClient::_onPoll(){ void AsyncWebSocketClient::_onPoll(){
if(_client->canSend() && (!_controlQueue.isEmpty() || !_messageQueue.isEmpty())){ if(_client->canSend() && (!_controlQueue.empty() || !_messageQueue.isEmpty())){
_runQueue(); _runQueue();
} else if(_keepAlivePeriod > 0 && _controlQueue.isEmpty() && _messageQueue.isEmpty() && (millis() - _lastMessageTime) >= _keepAlivePeriod){ } else if(_keepAlivePeriod > 0 && _controlQueue.empty() && _messageQueue.isEmpty() && (millis() - _lastMessageTime) >= _keepAlivePeriod){
ping((uint8_t *)AWSC_PING_PAYLOAD, AWSC_PING_PAYLOAD_LEN); ping((uint8_t *)AWSC_PING_PAYLOAD, AWSC_PING_PAYLOAD_LEN);
} }
} }
@ -539,8 +538,8 @@ void AsyncWebSocketClient::_runQueue(){
_messageQueue.remove(_messageQueue.front()); _messageQueue.remove(_messageQueue.front());
} }
if(!_controlQueue.isEmpty() && (_messageQueue.isEmpty() || _messageQueue.front()->betweenFrames()) && webSocketSendFrameWindow(_client) > (size_t)(_controlQueue.front()->len() - 1)){ if(!_controlQueue.empty() && (_messageQueue.isEmpty() || _messageQueue.front()->betweenFrames()) && webSocketSendFrameWindow(_client) > (size_t)(_controlQueue.front().len() - 1)){
_controlQueue.front()->send(_client); _controlQueue.front().send(_client);
} else if(!_messageQueue.isEmpty() && _messageQueue.front()->betweenFrames() && webSocketSendFrameWindow(_client)){ } else if(!_messageQueue.isEmpty() && _messageQueue.front()->betweenFrames() && webSocketSendFrameWindow(_client)){
_messageQueue.front()->send(_client); _messageQueue.front()->send(_client);
} }
@ -567,11 +566,9 @@ void AsyncWebSocketClient::_queueMessage(AsyncWebSocketMessage *dataMessage){
_runQueue(); _runQueue();
} }
void AsyncWebSocketClient::_queueControl(AsyncWebSocketControl *controlMessage){ void AsyncWebSocketClient::_queueControl(uint8_t opcode, uint8_t *data, size_t len, bool mask){
if(controlMessage == NULL) _controlQueue.emplace(opcode, data, len, mask);
return; if (_client->canSend())
_controlQueue.add(controlMessage);
if(_client->canSend())
_runQueue(); _runQueue();
} }
@ -592,17 +589,17 @@ void AsyncWebSocketClient::close(uint16_t code, const char * message){
if(message != NULL){ if(message != NULL){
memcpy(buf+2, message, packetLen -2); memcpy(buf+2, message, packetLen -2);
} }
_queueControl(new AsyncWebSocketControl(WS_DISCONNECT,(uint8_t*)buf,packetLen)); _queueControl(WS_DISCONNECT, (uint8_t*)buf, packetLen);
free(buf); free(buf);
return; return;
} }
} }
_queueControl(new AsyncWebSocketControl(WS_DISCONNECT)); _queueControl(WS_DISCONNECT);
} }
void AsyncWebSocketClient::ping(uint8_t *data, size_t len){ void AsyncWebSocketClient::ping(uint8_t *data, size_t len){
if(_status == WS_CONNECTED) if(_status == WS_CONNECTED)
_queueControl(new AsyncWebSocketControl(WS_PING, data, len)); _queueControl(WS_PING, data, len);
} }
void AsyncWebSocketClient::_onError(int8_t){} void AsyncWebSocketClient::_onError(int8_t){}
@ -683,10 +680,10 @@ void AsyncWebSocketClient::_onData(void *pbuf, size_t plen){
} else { } else {
_status = WS_DISCONNECTING; _status = WS_DISCONNECTING;
_client->ackLater(); _client->ackLater();
_queueControl(new AsyncWebSocketControl(WS_DISCONNECT, data, datalen)); _queueControl(WS_DISCONNECT, data, datalen);
} }
} else if(_pinfo.opcode == WS_PING){ } else if(_pinfo.opcode == WS_PING){
_queueControl(new AsyncWebSocketControl(WS_PONG, data, datalen)); _queueControl(WS_PONG, data, datalen);
} else if(_pinfo.opcode == WS_PONG){ } else if(_pinfo.opcode == WS_PONG){
if(datalen != AWSC_PING_PAYLOAD_LEN || memcmp(AWSC_PING_PAYLOAD, data, AWSC_PING_PAYLOAD_LEN) != 0) if(datalen != AWSC_PING_PAYLOAD_LEN || memcmp(AWSC_PING_PAYLOAD, data, AWSC_PING_PAYLOAD_LEN) != 0)
_server->_handleEvent(this, WS_EVT_PONG, NULL, data, datalen); _server->_handleEvent(this, WS_EVT_PONG, NULL, data, datalen);
@ -1243,10 +1240,6 @@ void AsyncWebSocket::_cleanBuffers()
} }
} }
const AsyncWebSocket::AsyncWebSocketClientLinkedList &AsyncWebSocket::getClients() const {
return _clients;
}
/* /*
* Response to Web Socket request - sends the authorization and detaches the TCP Client from the web server * Response to Web Socket request - sends the authorization and detaches the TCP Client from the web server
* Authentication code from https://github.com/Links2004/arduinoWebSockets/blob/master/src/WebSockets.cpp#L480 * Authentication code from https://github.com/Links2004/arduinoWebSockets/blob/master/src/WebSockets.cpp#L480

11
src/AsyncWebSocket.h
View File

@ -34,6 +34,7 @@
#include "AsyncWebSynchronization.h" #include "AsyncWebSynchronization.h"
#include <list> #include <list>
#include <queue>
#ifdef ESP8266 #ifdef ESP8266
#include <Hash.h> #include <Hash.h>
@ -163,7 +164,7 @@ class AsyncWebSocketClient {
uint32_t _clientId; uint32_t _clientId;
AwsClientStatus _status; AwsClientStatus _status;
LinkedList<AsyncWebSocketControl *> _controlQueue; std::queue<AsyncWebSocketControl> _controlQueue;
LinkedList<AsyncWebSocketMessage *> _messageQueue; LinkedList<AsyncWebSocketMessage *> _messageQueue;
uint8_t _pstate; uint8_t _pstate;
@ -173,7 +174,7 @@ class AsyncWebSocketClient {
uint32_t _keepAlivePeriod; uint32_t _keepAlivePeriod;
void _queueMessage(AsyncWebSocketMessage *dataMessage); void _queueMessage(AsyncWebSocketMessage *dataMessage);
void _queueControl(AsyncWebSocketControl *controlMessage); void _queueControl(uint8_t opcode, uint8_t *data=NULL, size_t len=0, bool mask=false);
void _runQueue(); void _runQueue();
public: public:
@ -245,11 +246,9 @@ typedef std::function<void(AsyncWebSocket * server, AsyncWebSocketClient * clien
//WebServer Handler implementation that plays the role of a socket server //WebServer Handler implementation that plays the role of a socket server
class AsyncWebSocket: public AsyncWebHandler { class AsyncWebSocket: public AsyncWebHandler {
public:
typedef std::list<AsyncWebSocketClient> AsyncWebSocketClientLinkedList;
private: private:
String _url; String _url;
AsyncWebSocketClientLinkedList _clients; std::list<AsyncWebSocketClient> _clients;
uint32_t _cNextId; uint32_t _cNextId;
AwsEventHandler _eventHandler; AwsEventHandler _eventHandler;
bool _enabled; bool _enabled;
@ -336,7 +335,7 @@ class AsyncWebSocket: public AsyncWebHandler {
std::list<AsyncWebSocketMessageBuffer> _buffers; std::list<AsyncWebSocketMessageBuffer> _buffers;
void _cleanBuffers(); void _cleanBuffers();
const AsyncWebSocketClientLinkedList &getClients() const; const auto &getClients() const { return _clients; }
}; };
//WebServer response to authenticate the socket and detach the tcp client from the web server request //WebServer response to authenticate the socket and detach the tcp client from the web server request