Skip to content

Commit d63a478

Browse files
fhesselfhessel
committed
Some refactoring on the websocket implementation
1 parent 0bc27ef commit d63a478

16 files changed

+584
-442
lines changed

‎src/HTTPConnection.cpp‎

Lines changed: 91 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ HTTPConnection::HTTPConnection(ResourceResolver * resResolver):
1717
_isKeepAlive = false;
1818
_lastTransmissionTS = millis();
1919
_shutdownTS = 0;
20-
_websocket = nullptr;
20+
_wsHandler = nullptr;
2121
}
2222

2323
HTTPConnection::~HTTPConnection() {
@@ -125,6 +125,11 @@ void HTTPConnection::closeConnection() {
125125
delete _httpHeaders;
126126
_httpHeaders = NULL;
127127
}
128+
129+
if (_wsHandler != nullptr) {
130+
HTTPS_DLOG("[ ] Freeing WS Handler");
131+
delete _wsHandler;
132+
}
128133
}
129134

130135
/**
@@ -417,48 +422,29 @@ void HTTPConnection::loop() {
417422
{
418423
HTTPS_DLOG("[ ] Resolving resource...");
419424
ResolvedResource resolvedResource;
420-
_resResolver->resolveNode(_httpMethod, _httpResource, resolvedResource);
425+
426+
// Check which kind of node we need (Websocket or regular)
427+
bool websocketRequested = checkWebsocket();
428+
429+
_resResolver->resolveNode(_httpMethod, _httpResource, resolvedResource, websocketRequested ? WEBSOCKET : HANDLER_CALLBACK);
430+
431+
// Is there any match (may be the defaultNode, if it is configured)
421432
if (resolvedResource.didMatch()) {
422-
// Did the client request connection:keep-alive?
423-
HTTPHeader * connectionHeader = _httpHeaders->get("Connection");
424-
if (connectionHeader != NULL && std::string("keep-alive").compare(connectionHeader->_value)==0) {
425-
HTTPS_DLOGHEX("[ ] Keep-Alive activated. fid=", _socket);
426-
_isKeepAlive = true;
433+
// Check for client's request to keep-alive if we have a handler function.
434+
if (resolvedResource.getMatchingNode()->_nodeType == HANDLER_CALLBACK) {
435+
// Did the client set connection:keep-alive?
436+
HTTPHeader * connectionHeader = _httpHeaders->get("Connection");
437+
if (connectionHeader != NULL && std::string("keep-alive").compare(connectionHeader->_value)==0) {
438+
HTTPS_DLOGHEX("[ ] Keep-Alive activated. fid=", _socket);
439+
_isKeepAlive = true;
440+
} else {
441+
HTTPS_DLOGHEX("[ ] Keep-Alive disabled. fid=", _socket);
442+
_isKeepAlive = false;
443+
}
427444
} else {
428-
HTTPS_DLOGHEX("[ ] Keep-Alive disabled. fid=", _socket);
429445
_isKeepAlive = false;
430446
}
431447

432-
// do we have a websocket connection?
433-
if(checkWebsocket()) {
434-
// Create response
435-
HTTPResponse res = HTTPResponse(this);
436-
// Add default headers to the response
437-
auto allDefaultHeaders = _defaultHeaders->getAll();
438-
for(std::vector<HTTPHeader*>::iterator header = allDefaultHeaders->begin(); header != allDefaultHeaders->end(); ++header) {
439-
res.setHeader((*header)->_name, (*header)->_value);
440-
}
441-
// Set the response status
442-
res.setStatusCode(101);
443-
res.setStatusText("Switching Protocols");
444-
res.setHeader("Upgrade", "websocket");
445-
res.setHeader("Connection", "Upgrade");
446-
res.setHeader("Sec-WebSocket-Accept", websocketKeyResponseHash(_httpHeaders->getValue("Sec-WebSocket-Key")));
447-
res.print("");
448-
449-
// Callback for the actual resource
450-
HTTPSCallbackFunction * resourceCallback = resolvedResource.getMatchingNode()->_callback;
451-
// persistent request for websocket. To be destroyed when connection closes.
452-
HTTPRequest *req = new HTTPRequest(this, _httpHeaders, resolvedResource.getParams(), _httpResource, _httpMethod, "");
453-
// bind function call to the actual resource
454-
std::function<void()> next = std::function<void()>(std::bind(resourceCallback, req, nullptr));
455-
_websocket = new Websocket(this); // make websocket with this connection
456-
next(); // call callback
457-
delete req;
458-
_connectionState = STATE_WEBSOCKET;
459-
break;
460-
}
461-
462448
// Create request context
463449
HTTPRequest req = HTTPRequest(this, _httpHeaders, resolvedResource.getParams(), _httpResource, _httpMethod, resolvedResource.getMatchingNode()->_tag);
464450
HTTPResponse res = HTTPResponse(this);
@@ -469,8 +455,15 @@ void HTTPConnection::loop() {
469455
res.setHeader((*header)->_name, (*header)->_value);
470456
}
471457

472-
// Callback for the actual resource
473-
HTTPSCallbackFunction * resourceCallback = resolvedResource.getMatchingNode()->_callback;
458+
// Find the request handler callback
459+
HTTPSCallbackFunction * resourceCallback;
460+
if (websocketRequested) {
461+
// For the websocket, we use the handshake callback defined below
462+
resourceCallback = &handleWebsocketHandshake;
463+
} else {
464+
// For resource nodes, we use the callback defined by the node itself
465+
resourceCallback = ((ResourceNode*)resolvedResource.getMatchingNode())->_callback;
466+
}
474467

475468
// Get the current middleware chain
476469
auto vecMw = _resResolver->getMiddleware();
@@ -495,37 +488,45 @@ void HTTPConnection::loop() {
495488
req.discardRequestBody();
496489
}
497490

498-
// Handling the request is done
499-
HTTPS_DLOG("[ ] Handler function done, request complete");
500-
501-
// Now we need to check if we can use keep-alive to reuse the SSL connection
502-
// However, if the client did not set content-size or defined connection: close,
503-
// we have no chance to do so.
504-
if (!_isKeepAlive) {
505-
// No KeepAlive -> We are done. Transition to next state.
506-
if (!isClosed()) {
507-
_connectionState = STATE_BODY_FINISHED;
508-
}
491+
// Finally, after the handshake is done, we create the WebsocketHandler and change the internal state.
492+
if(websocketRequested) {
493+
_wsHandler = ((WebsocketNode*)resolvedResource.getMatchingNode())->newHandler();
494+
_wsHandler->initialize(this); // make websocket with this connection
495+
_connectionState = STATE_WEBSOCKET;
509496
} else {
510-
if (res.isResponseBuffered()) {
511-
// If the response could be buffered:
512-
res.setHeader("Connection", "keep-alive");
513-
res.finalize();
514-
if (_clientState != CSTATE_CLOSED) {
515-
// Refresh the timeout for the new request
516-
refreshTimeout();
517-
// Reset headers for the new connection
518-
_httpHeaders->clearAll();
519-
// Go back to initial state
520-
_connectionState = STATE_INITIAL;
497+
// Handling the request is done
498+
HTTPS_DLOG("[ ] Handler function done, request complete");
499+
500+
// Now we need to check if we can use keep-alive to reuse the SSL connection
501+
// However, if the client did not set content-size or defined connection: close,
502+
// we have no chance to do so.
503+
if (!_isKeepAlive) {
504+
// No KeepAlive -> We are done. Transition to next state.
505+
if (!isClosed()) {
506+
_connectionState = STATE_BODY_FINISHED;
507+
}
508+
} else {
509+
if (res.isResponseBuffered()) {
510+
// If the response could be buffered:
511+
res.setHeader("Connection", "keep-alive");
512+
res.finalize();
513+
if (_clientState != CSTATE_CLOSED) {
514+
// Refresh the timeout for the new request
515+
refreshTimeout();
516+
// Reset headers for the new connection
517+
_httpHeaders->clearAll();
518+
// Go back to initial state
519+
_connectionState = STATE_INITIAL;
520+
}
521+
}
522+
// The response could not be buffered or the client has closed:
523+
if (!isClosed() && _connectionState!=STATE_INITIAL) {
524+
_connectionState = STATE_BODY_FINISHED;
521525
}
522-
}
523-
// The response could not be buffered or the client has closed:
524-
if (!isClosed() && _connectionState!=STATE_INITIAL) {
525-
_connectionState = STATE_BODY_FINISHED;
526526
}
527527
}
528528
} else {
529+
// No match (no default route configured, nothing does match)
529530
HTTPS_DLOG("[ERR] Could not find a matching resource. Server error.");
530531
serverError();
531532
}
@@ -542,14 +543,15 @@ void HTTPConnection::loop() {
542543
refreshTimeout(); // don't timeout websocket connection
543544
if(pendingBufferSize() > 0) {
544545
HTTPS_DLOG("[ ] websocket handler");
545-
if(_websocket->read() < 0) {
546-
_websocket->close();
547-
delete _websocket;
548-
_httpHeaders->clearAll();
549-
_connectionState = STATE_CLOSING;
550-
}
546+
_wsHandler->loop();
547+
}
548+
// If the handler has terminated the connection, clean up and close the socket too
549+
if (_wsHandler->closed()) {
550+
HTTPS_DLOG("[ ] WS Connection closed. Freeing WS Handler");
551+
delete _wsHandler;
552+
_wsHandler = nullptr;
553+
_connectionState = STATE_CLOSING;
551554
}
552-
//readBuffer();
553555
break;
554556
default:;
555557
}
@@ -579,7 +581,22 @@ bool HTTPConnection::checkWebsocket() {
579581
return false;
580582
}
581583

582-
std::string HTTPConnection::websocketKeyResponseHash(std::string key) {
584+
/**
585+
* Handler function for the websocket handshake. Will be used by HTTPConnection if a websocket is detected
586+
*/
587+
void handleWebsocketHandshake(HTTPRequest * req, HTTPResponse * res) {
588+
res->setStatusCode(101);
589+
res->setStatusText("Switching Protocols");
590+
res->setHeader("Upgrade", "websocket");
591+
res->setHeader("Connection", "Upgrade");
592+
res->setHeader("Sec-WebSocket-Accept", websocketKeyResponseHash(req->getHeader("Sec-WebSocket-Key")));
593+
res->print("");
594+
}
595+
596+
/**
597+
* Function used to compute the value of the Sec-WebSocket-Accept during Websocket handshake
598+
*/
599+
std::string websocketKeyResponseHash(std::string key) {
583600
std::string newKey = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
584601
uint8_t shaData[HTTPS_SHA1_LENGTH];
585602
esp_sha(SHA1, (uint8_t*)newKey.data(), newKey.length(), shaData);

‎src/HTTPConnection.hpp‎

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,15 +14,20 @@
1414
#include "lwip/sockets.h"
1515

1616
#include "HTTPSServerConstants.hpp"
17+
#include "ConnectionContext.hpp"
18+
1719
#include "HTTPHeaders.hpp"
1820
#include "HTTPHeader.hpp"
21+
1922
#include "ResourceResolver.hpp"
2023
#include "ResolvedResource.hpp"
24+
2125
#include "ResourceNode.hpp"
2226
#include "HTTPRequest.hpp"
2327
#include "HTTPResponse.hpp"
24-
#include "ConnectionContext.hpp"
25-
#include "Websocket.hpp"
28+
29+
#include "WebsocketHandler.hpp"
30+
#include "WebsocketNode.hpp"
2631

2732
namespace httpsserver {
2833

@@ -150,10 +155,14 @@ class HTTPConnection : private ConnectionContext {
150155
bool _isKeepAlive;
151156

152157
//Websocket connection
153-
Websocket * _websocket;
158+
WebsocketHandler * _wsHandler;
154159

155160
};
156161

162+
void handleWebsocketHandshake(HTTPRequest * req, HTTPResponse * res);
163+
164+
std::string websocketKeyResponseHash(std::string key);
165+
157166
} /* namespace httpsserver */
158167

159168
#endif /* SRC_HTTPCONNECTION_HPP_ */

‎src/HTTPNode.cpp‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
#include "HTTPNode.hpp"
2+
3+
namespace httpsserver {
4+
5+
HTTPNode::HTTPNode(const std::string path, const HTTPNodeType nodeType, const std::string tag):
6+
_path(std::move(path)),
7+
_tag(std::move(tag)),
8+
_nodeType(nodeType) {
9+
10+
// Count the parameters
11+
_urlParamCount = 0;
12+
size_t idx = 0;
13+
while((idx = path.find("/*", idx)) != std::string::npos) {
14+
_urlParamCount+=1;
15+
// If we don't do this, the same index will be found again... and again... and again...
16+
idx+=1;
17+
};
18+
19+
// Check if there are parameters
20+
if (_urlParamCount > 0) {
21+
// If there are parameters, store their indices
22+
_urlParamIdx = new size_t[_urlParamCount];
23+
for(int i = 0; i < _urlParamCount; i++) {
24+
_urlParamIdx[i] = path.find("/*", i==0 ? 0 : _urlParamIdx[i-1])+1;
25+
}
26+
} else {
27+
_urlParamIdx = NULL;
28+
}
29+
}
30+
31+
HTTPNode::~HTTPNode() {
32+
if (_urlParamIdx != NULL) {
33+
delete[] _urlParamIdx;
34+
}
35+
}
36+
37+
bool HTTPNode::hasUrlParameter() {
38+
return _urlParamCount > 0;
39+
}
40+
41+
size_t HTTPNode::getParamIdx(uint8_t idx) {
42+
if (idx<_urlParamCount) {
43+
return _urlParamIdx[idx];
44+
} else {
45+
return -1;
46+
}
47+
}
48+
49+
uint8_t HTTPNode::getUrlParamCount() {
50+
return _urlParamCount;
51+
}
52+
}

‎src/HTTPNode.hpp‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
#ifndef SRC_HTTPNODE_HPP_
2+
#define SRC_HTTPNODE_HPP_
3+
4+
#include <Arduino.h>
5+
#include <string>
6+
7+
namespace httpsserver {
8+
9+
enum HTTPNodeType {
10+
/** Node with a handler callback function (class ResourceNode) */
11+
HANDLER_CALLBACK,
12+
/** Node with a websocket handler (class WebsocketNode) */
13+
WEBSOCKET
14+
};
15+
16+
class HTTPNode {
17+
public:
18+
HTTPNode(const std::string path, const HTTPNodeType nodeType, const std::string tag = "");
19+
virtual ~HTTPNode();
20+
21+
/**
22+
* The path under which this node will be available. Should start with a slash. Example:
23+
* "/myResource"
24+
*/
25+
const std::string _path;
26+
27+
/**
28+
* Stores a tag that can be used in middleware and handler functions to identify this
29+
* specific node, tag the node with a required permission, ...
30+
*/
31+
const std::string _tag;
32+
33+
/** Stores the type of the node (as we have not runtime type information by default) */
34+
const HTTPNodeType _nodeType;
35+
36+
bool hasUrlParameter();
37+
uint8_t getUrlParamCount();
38+
size_t getParamIdx(uint8_t);
39+
40+
private:
41+
uint8_t _urlParamCount;
42+
size_t * _urlParamIdx;
43+
};
44+
45+
} // namespace httpserver
46+
47+
#endif

‎src/ResolvedResource.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,11 +18,11 @@ bool ResolvedResource::didMatch() {
1818
return _matchingNode != NULL;
1919
}
2020

21-
ResourceNode * ResolvedResource::getMatchingNode() {
21+
HTTPNode * ResolvedResource::getMatchingNode() {
2222
return _matchingNode;
2323
}
2424

25-
void ResolvedResource::setMatchingNode(ResourceNode * node) {
25+
void ResolvedResource::setMatchingNode(HTTPNode * node) {
2626
_matchingNode = node;
2727
}
2828

‎src/ResolvedResource.hpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -11,14 +11,14 @@ class ResolvedResource {
1111
ResolvedResource();
1212
~ResolvedResource();
1313

14-
void setMatchingNode(ResourceNode * node);
15-
ResourceNode * getMatchingNode();
14+
void setMatchingNode(HTTPNode * node);
15+
HTTPNode * getMatchingNode();
1616
bool didMatch();
1717
ResourceParameters * getParams();
1818
void setParams(ResourceParameters * params);
1919

2020
private:
21-
ResourceNode * _matchingNode;
21+
HTTPNode * _matchingNode;
2222
ResourceParameters * _params;
2323
};
2424

0 commit comments

Comments
 (0)