feedc0de/arduinoWebSockets
1
0
Fork 0
forked from Links2004/arduinoWebSockets
Code Pull Requests Activity

clang-format

Browse Source
This commit is contained in:
Links
2019-06-10 12:57:49 +02:00
parent e8df841b7f
commit 3063ad27ae
7 changed files with 729 additions and 719 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
.clang-format Normal file
View File

@ -0,0 +1,63 @@
---
BasedOnStyle: Google
AccessModifierOffset: '-2'
AlignAfterOpenBracket: DontAlign
AlignConsecutiveAssignments: 'true'
AlignConsecutiveDeclarations: 'false'
AlignEscapedNewlines: Left
AlignTrailingComments: 'true'
AllowAllParametersOfDeclarationOnNextLine: 'false'
AllowShortBlocksOnASingleLine: 'false'
AllowShortCaseLabelsOnASingleLine: 'false'
AllowShortFunctionsOnASingleLine: InlineOnly
AllowShortIfStatementsOnASingleLine: 'true'
AllowShortLoopsOnASingleLine: 'true'
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: 'true'
AlwaysBreakTemplateDeclarations: 'false'
BinPackParameters: 'true'
BreakAfterJavaFieldAnnotations: 'false'
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: 'false'
BreakBeforeTernaryOperators: 'false'
BreakConstructorInitializers: BeforeColon
BreakStringLiterals: 'false'
ColumnLimit: '0'
CompactNamespaces: 'true'
ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
ConstructorInitializerIndentWidth: '4'
ContinuationIndentWidth: '4'
Cpp11BracedListStyle: 'false'
DerivePointerAlignment: 'false'
FixNamespaceComments: 'true'
IndentCaseLabels: 'true'
IndentWidth: '4'
IndentWrappedFunctionNames: 'false'
JavaScriptQuotes: Single
JavaScriptWrapImports: 'false'
KeepEmptyLinesAtTheStartOfBlocks: 'false'
MaxEmptyLinesToKeep: '1'
NamespaceIndentation: All
ObjCBlockIndentWidth: '4'
ObjCSpaceAfterProperty: 'false'
ObjCSpaceBeforeProtocolList: 'false'
PointerAlignment: Middle
SortIncludes: 'false'
SortUsingDeclarations: 'true'
SpaceAfterCStyleCast: 'false'
SpaceAfterTemplateKeyword: 'false'
SpaceBeforeAssignmentOperators: 'true'
SpaceBeforeParens: Never
SpaceInEmptyParentheses: 'false'
SpacesBeforeTrailingComments: '4'
SpacesInAngles: 'false'
SpacesInCStyleCastParentheses: 'false'
SpacesInContainerLiterals: 'false'
SpacesInParentheses: 'false'
SpacesInSquareBrackets: 'false'
TabWidth: '4'
UseTab: Never
...

88
src/WebSockets.cpp
View File

@ -48,7 +48,6 @@ extern "C" {
#endif #endif
/** /**
* *
* @param client WSclient_t * ptr to the client struct * @param client WSclient_t * ptr to the client struct
@ -60,7 +59,7 @@ void WebSockets::clientDisconnect(WSclient_t * client, uint16_t code, char * rea
DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] clientDisconnect code: %u\n", client->num, code); DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] clientDisconnect code: %u\n", client->num, code);
if(client->status == WSC_CONNECTED && code) { if(client->status == WSC_CONNECTED && code) {
if(reason) { if(reason) {
sendFrame(client, WSop_close, (uint8_t *) reason, reasonLen); sendFrame(client, WSop_close, (uint8_t *)reason, reasonLen);
} else { } else {
uint8_t buffer[2]; uint8_t buffer[2];
buffer[0] = ((code >> 8) & 0xFF); buffer[0] = ((code >> 8) & 0xFF);
@ -82,7 +81,6 @@ void WebSockets::clientDisconnect(WSclient_t * client, uint16_t code, char * rea
* @return true if ok * @return true if ok
*/ */
bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin, bool headerToPayload) { bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin, bool headerToPayload) {
if(client->tcp && !client->tcp->connected()) { if(client->tcp && !client->tcp->connected()) {
DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not Connected!?\n", client->num); DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not Connected!?\n", client->num);
return false; return false;
@ -127,7 +125,7 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
// try to send data in one TCP package (only if some free Heap is there) // try to send data in one TCP package (only if some free Heap is there)
if(!headerToPayload && ((length > 0) && (length < 1400)) && (GET_FREE_HEAP > 6000)) { if(!headerToPayload && ((length > 0) && (length < 1400)) && (GET_FREE_HEAP > 6000)) {
DEBUG_WEBSOCKETS("[WS][%d][sendFrame] pack to one TCP package...\n", client->num); DEBUG_WEBSOCKETS("[WS][%d][sendFrame] pack to one TCP package...\n", client->num);
uint8_t * dataPtr = (uint8_t *) malloc(length + WEBSOCKETS_MAX_HEADER_SIZE); uint8_t * dataPtr = (uint8_t *)malloc(length + WEBSOCKETS_MAX_HEADER_SIZE);
if(dataPtr) { if(dataPtr) {
memcpy((dataPtr + WEBSOCKETS_MAX_HEADER_SIZE), payload, length); memcpy((dataPtr + WEBSOCKETS_MAX_HEADER_SIZE), payload, length);
headerToPayload = true; headerToPayload = true;
@ -271,7 +269,7 @@ void WebSockets::headerDone(WSclient_t * client) {
client->status = WSC_CONNECTED; client->status = WSC_CONNECTED;
client->cWsRXsize = 0; client->cWsRXsize = 0;
DEBUG_WEBSOCKETS("[WS][%d][headerDone] Header Handling Done.\n", client->num); DEBUG_WEBSOCKETS("[WS][%d][headerDone] Header Handling Done.\n", client->num);
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->cHttpLine = ""; client->cHttpLine = "";
handleWebsocket(client); handleWebsocket(client);
#endif #endif
@ -318,12 +316,12 @@ bool WebSockets::handleWebsocketWaitFor(WSclient_t * client, size_t size) {
// timeout or error // timeout or error
server->clientDisconnect(client, 1002); server->clientDisconnect(client, 1002);
} }
}, this, size, std::placeholders::_1, std::placeholders::_2)); },
this, size, std::placeholders::_1, std::placeholders::_2));
return false; return false;
} }
void WebSockets::handleWebsocketCb(WSclient_t * client) { void WebSockets::handleWebsocketCb(WSclient_t * client) {
if(!client->tcp || !client->tcp->connected()) { if(!client->tcp || !client->tcp->connected()) {
return; return;
} }
@ -344,11 +342,11 @@ void WebSockets::handleWebsocketCb(WSclient_t * client) {
header->rsv1 = ((*buffer >> 6) & 0x01); header->rsv1 = ((*buffer >> 6) & 0x01);
header->rsv2 = ((*buffer >> 5) & 0x01); header->rsv2 = ((*buffer >> 5) & 0x01);
header->rsv3 = ((*buffer >> 4) & 0x01); header->rsv3 = ((*buffer >> 4) & 0x01);
header->opCode = (WSopcode_t) (*buffer & 0x0F); header->opCode = (WSopcode_t)(*buffer & 0x0F);
buffer++; buffer++;
header->mask = ((*buffer >> 7) & 0x01); header->mask = ((*buffer >> 7) & 0x01);
header->payloadLen = (WSopcode_t) (*buffer & 0x7F); header->payloadLen = (WSopcode_t)(*buffer & 0x7F);
buffer++; buffer++;
if(header->payloadLen == 126) { if(header->payloadLen == 126) {
@ -395,7 +393,7 @@ void WebSockets::handleWebsocketCb(WSclient_t * client) {
if(header->payloadLen > 0) { if(header->payloadLen > 0) {
// if text data we need one more // if text data we need one more
payload = (uint8_t *) malloc(header->payloadLen + 1); payload = (uint8_t *)malloc(header->payloadLen + 1);
if(!payload) { if(!payload) {
DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, header->payloadLen); DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, header->payloadLen);
@ -409,7 +407,6 @@ void WebSockets::handleWebsocketCb(WSclient_t * client) {
} }
void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload) { void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload) {
WSMessageHeader_t * header = &client->cWsHeaderDecode; WSMessageHeader_t * header = &client->cWsHeaderDecode;
if(ok) { if(ok) {
if(header->payloadLen > 0) { if(header->payloadLen > 0) {
@ -433,22 +430,22 @@ void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t
break; break;
case WSop_ping: case WSop_ping:
// send pong back // send pong back
DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] ping received (%s)\n", client->num, payload ? (const char*)payload : ""); DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] ping received (%s)\n", client->num, payload ? (const char *)payload : "");
sendFrame(client, WSop_pong, payload, header->payloadLen); sendFrame(client, WSop_pong, payload, header->payloadLen);
messageReceived(client, header->opCode, payload, header->payloadLen, header->fin); messageReceived(client, header->opCode, payload, header->payloadLen, header->fin);
break; break;
case WSop_pong: case WSop_pong:
DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get pong (%s)\n", client->num, payload ? (const char*)payload : ""); DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get pong (%s)\n", client->num, payload ? (const char *)payload : "");
client->pongReceived = true; client->pongReceived = true;
messageReceived(client, header->opCode, payload, header->payloadLen, header->fin); messageReceived(client, header->opCode, payload, header->payloadLen, header->fin);
break; break;
case WSop_close: { case WSop_close: {
#ifndef NODEBUG_WEBSOCKETS #ifndef NODEBUG_WEBSOCKETS
uint16_t reasonCode = 1000; uint16_t reasonCode = 1000;
if(header->payloadLen >= 2) { if(header->payloadLen >= 2) {
reasonCode = payload[0] << 8 | payload[1]; reasonCode = payload[0] << 8 | payload[1];
} }
#endif #endif
DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get ask for close. Code: %d", client->num, reasonCode); DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get ask for close. Code: %d", client->num, reasonCode);
if(header->payloadLen > 2) { if(header->payloadLen > 2) {
DEBUG_WEBSOCKETS(" (%s)\n", (payload + 2)); DEBUG_WEBSOCKETS(" (%s)\n", (payload + 2));
@ -456,8 +453,7 @@ void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t
DEBUG_WEBSOCKETS("\n"); DEBUG_WEBSOCKETS("\n");
} }
clientDisconnect(client, 1000); clientDisconnect(client, 1000);
} } break;
break;
default: default:
clientDisconnect(client, 1002); clientDisconnect(client, 1002);
break; break;
@ -469,7 +465,7 @@ void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t
// reset input // reset input
client->cWsRXsize = 0; client->cWsRXsize = 0;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
//register callback for next message //register callback for next message
handleWebsocketWaitFor(client, 2); handleWebsocketWaitFor(client, 2);
#endif #endif
@ -492,12 +488,12 @@ String WebSockets::acceptKey(String & clientKey) {
sha1(clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", &sha1HashBin[0]); sha1(clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", &sha1HashBin[0]);
#elif defined(ESP32) #elif defined(ESP32)
String data = clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; String data = clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
esp_sha(SHA1, (unsigned char*)data.c_str(), data.length(), &sha1HashBin[0]); esp_sha(SHA1, (unsigned char *)data.c_str(), data.length(), &sha1HashBin[0]);
#else #else
clientKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; clientKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
SHA1_CTX ctx; SHA1_CTX ctx;
SHA1Init(&ctx); SHA1Init(&ctx);
SHA1Update(&ctx, (const unsigned char*)clientKey.c_str(), clientKey.length()); SHA1Update(&ctx, (const unsigned char *)clientKey.c_str(), clientKey.length());
SHA1Final(&sha1HashBin[0], &ctx); SHA1Final(&sha1HashBin[0], &ctx);
#endif #endif
@ -515,11 +511,11 @@ String WebSockets::acceptKey(String & clientKey) {
*/ */
String WebSockets::base64_encode(uint8_t * data, size_t length) { String WebSockets::base64_encode(uint8_t * data, size_t length) {
size_t size = ((length * 1.6f) + 1); size_t size = ((length * 1.6f) + 1);
char * buffer = (char *) malloc(size); char * buffer = (char *)malloc(size);
if(buffer) { if(buffer) {
base64_encodestate _state; base64_encodestate _state;
base64_init_encodestate(&_state); base64_init_encodestate(&_state);
int len = base64_encode_block((const char *) &data[0], length, &buffer[0], &_state); int len = base64_encode_block((const char *)&data[0], length, &buffer[0], &_state);
len = base64_encode_blockend((buffer + len), &_state); len = base64_encode_blockend((buffer + len), &_state);
String base64 = String(buffer); String base64 = String(buffer);
@ -537,7 +533,7 @@ String WebSockets::base64_encode(uint8_t * data, size_t length) {
* @return true if ok * @return true if ok
*/ */
bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWaitCb cb) { bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWaitCb cb) {
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
if(!client->tcp || !client->tcp->connected()) { if(!client->tcp || !client->tcp->connected()) {
return false; return false;
} }
@ -546,7 +542,8 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
if(cb) { if(cb) {
cb(client, ok); cb(client, ok);
} }
}, client, std::placeholders::_1, cb)); },
client, std::placeholders::_1, cb));
#else #else
unsigned long t = millis(); unsigned long t = millis();
@ -578,13 +575,13 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
} }
if(!client->tcp->available()) { if(!client->tcp->available()) {
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
delay(0); delay(0);
#endif #endif
continue; continue;
} }
len = client->tcp->read((uint8_t*) out, n); len = client->tcp->read((uint8_t *)out, n);
if(len) { if(len) {
t = millis(); t = millis();
out += len; out += len;
@ -593,7 +590,7 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
} else { } else {
//DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n); //DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
delay(0); delay(0);
#endif #endif
} }
@ -611,9 +608,11 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
* @param n size_t byte count * @param n size_t byte count
* @return bytes send * @return bytes send
*/ */
size_t WebSockets::write(WSclient_t * client, uint8_t *out, size_t n) { size_t WebSockets::write(WSclient_t * client, uint8_t * out, size_t n) {
if(out == NULL) return 0; if(out == NULL)
if(client == NULL) return 0; return 0;
if(client == NULL)
return 0;
unsigned long t = millis(); unsigned long t = millis();
size_t len = 0; size_t len = 0;
size_t total = 0; size_t total = 0;
@ -634,7 +633,7 @@ size_t WebSockets::write(WSclient_t * client, uint8_t *out, size_t n) {
break; break;
} }
len = client->tcp->write((const uint8_t*)out, n); len = client->tcp->write((const uint8_t *)out, n);
if(len) { if(len) {
t = millis(); t = millis();
out += len; out += len;
@ -644,17 +643,19 @@ size_t WebSockets::write(WSclient_t * client, uint8_t *out, size_t n) {
} else { } else {
//DEBUG_WEBSOCKETS("write %d failed left %d!\n", len, n); //DEBUG_WEBSOCKETS("write %d failed left %d!\n", len, n);
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
delay(0); delay(0);
#endif #endif
} }
return total; return total;
} }
size_t WebSockets::write(WSclient_t * client, const char *out) { size_t WebSockets::write(WSclient_t * client, const char * out) {
if(client == NULL) return 0; if(client == NULL)
if(out == NULL) return 0; return 0;
return write(client, (uint8_t*)out, strlen(out)); if(out == NULL)
return 0;
return write(client, (uint8_t *)out, strlen(out));
} }
/** /**
@ -664,8 +665,9 @@ size_t WebSockets::write(WSclient_t * client, const char *out) {
* @param pongTimeout uint32_t millis after which pong should timout if not received * @param pongTimeout uint32_t millis after which pong should timout if not received
* @param disconnectTimeoutCount uint8_t how many timeouts before disconnect, 0=> do not disconnect * @param disconnectTimeoutCount uint8_t how many timeouts before disconnect, 0=> do not disconnect
*/ */
void WebSockets::enableHeartbeat(WSclient_t * client, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount){ void WebSockets::enableHeartbeat(WSclient_t * client, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
if(client == NULL) return; if(client == NULL)
return;
client->pingInterval = pingInterval; client->pingInterval = pingInterval;
client->pongTimeout = pongTimeout; client->pongTimeout = pongTimeout;
client->disconnectTimeoutCount = disconnectTimeoutCount; client->disconnectTimeoutCount = disconnectTimeoutCount;
@ -676,20 +678,20 @@ void WebSockets::enableHeartbeat(WSclient_t * client, uint32_t pingInterval, uin
* handle ping/pong heartbeat timeout process * handle ping/pong heartbeat timeout process
* @param client WSclient_t * * @param client WSclient_t *
*/ */
void WebSockets::handleHBTimeout(WSclient_t * client){ void WebSockets::handleHBTimeout(WSclient_t * client) {
if (client->pingInterval) { // if heartbeat is enabled if(client->pingInterval) { // if heartbeat is enabled
uint32_t pi = millis() - client->lastPing; uint32_t pi = millis() - client->lastPing;
if (client->pongReceived) { if(client->pongReceived) {
client->pongTimeoutCount = 0; client->pongTimeoutCount = 0;
} else { } else {
if (pi > client->pongTimeout){ // pong not received in time if(pi > client->pongTimeout) { // pong not received in time
client->pongTimeoutCount++; client->pongTimeoutCount++;
client->lastPing = millis() - client->pingInterval - 500; // force ping on the next run client->lastPing = millis() - client->pingInterval - 500; // force ping on the next run
DEBUG_WEBSOCKETS("[HBtimeout] pong TIMEOUT! lp=%d millis=%d pi=%d count=%d\n", client->lastPing, millis(), pi, client->pongTimeoutCount); DEBUG_WEBSOCKETS("[HBtimeout] pong TIMEOUT! lp=%d millis=%d pi=%d count=%d\n", client->lastPing, millis(), pi, client->pongTimeoutCount);
if (client->disconnectTimeoutCount && client->pongTimeoutCount >= client->disconnectTimeoutCount){ if(client->disconnectTimeoutCount && client->pongTimeoutCount >= client->disconnectTimeoutCount) {
DEBUG_WEBSOCKETS("[HBtimeout] count=%d, DISCONNECTING\n", client->pongTimeoutCount); DEBUG_WEBSOCKETS("[HBtimeout] count=%d, DISCONNECTING\n", client->pongTimeoutCount);
clientDisconnect(client); clientDisconnect(client);
} }

36
src/WebSockets.h
View File

@ -40,16 +40,14 @@
#include <functional> #include <functional>
#endif #endif
#ifndef NODEBUG_WEBSOCKETS #ifndef NODEBUG_WEBSOCKETS
#ifdef DEBUG_ESP_PORT #ifdef DEBUG_ESP_PORT
#define DEBUG_WEBSOCKETS(...) DEBUG_ESP_PORT.printf( __VA_ARGS__ ) #define DEBUG_WEBSOCKETS(...) DEBUG_ESP_PORT.printf(__VA_ARGS__)
#else #else
//#define DEBUG_WEBSOCKETS(...) os_printf( __VA_ARGS__ ) //#define DEBUG_WEBSOCKETS(...) os_printf( __VA_ARGS__ )
#endif #endif
#endif #endif
#ifndef DEBUG_WEBSOCKETS #ifndef DEBUG_WEBSOCKETS
#define DEBUG_WEBSOCKETS(...) #define DEBUG_WEBSOCKETS(...)
#define NODEBUG_WEBSOCKETS #define NODEBUG_WEBSOCKETS
@ -57,7 +55,7 @@
#if defined(ESP8266) || defined(ESP32) #if defined(ESP8266) || defined(ESP32)
#define WEBSOCKETS_MAX_DATA_SIZE (15*1024) #define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
#define WEBSOCKETS_USE_BIG_MEM #define WEBSOCKETS_USE_BIG_MEM
#define GET_FREE_HEAP ESP.getFreeHeap() #define GET_FREE_HEAP ESP.getFreeHeap()
// moves all Header strings to Flash (~300 Byte) // moves all Header strings to Flash (~300 Byte)
@ -65,7 +63,7 @@
#elif defined(STM32_DEVICE) #elif defined(STM32_DEVICE)
#define WEBSOCKETS_MAX_DATA_SIZE (15*1024) #define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
#define WEBSOCKETS_USE_BIG_MEM #define WEBSOCKETS_USE_BIG_MEM
#define GET_FREE_HEAP System.freeMemory() #define GET_FREE_HEAP System.freeMemory()
@ -78,7 +76,6 @@
#endif #endif
#define WEBSOCKETS_TCP_TIMEOUT (2000) #define WEBSOCKETS_TCP_TIMEOUT (2000)
#define NETWORK_ESP8266_ASYNC (0) #define NETWORK_ESP8266_ASYNC (0)
@ -108,13 +105,12 @@
#endif #endif
// Includes and defined based on Network Type // Includes and defined based on Network Type
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
// Note: // Note:
// No SSL/WSS support for client in Async mode // No SSL/WSS support for client in Async mode
// TLS lib need a sync interface! // TLS lib need a sync interface!
#if defined(ESP8266) #if defined(ESP8266)
#include <ESP8266WiFi.h> #include <ESP8266WiFi.h>
#elif defined(ESP32) #elif defined(ESP32)
@ -131,7 +127,7 @@
#define WEBSOCKETS_NETWORK_CLASS AsyncTCPbuffer #define WEBSOCKETS_NETWORK_CLASS AsyncTCPbuffer
#define WEBSOCKETS_NETWORK_SERVER_CLASS AsyncServer #define WEBSOCKETS_NETWORK_SERVER_CLASS AsyncServer
#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
#if !defined(ESP8266) && !defined(ESP31B) #if !defined(ESP8266) && !defined(ESP31B)
#error "network type ESP8266 only possible on the ESP mcu!" #error "network type ESP8266 only possible on the ESP mcu!"
@ -146,7 +142,7 @@
#define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure #define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure
#define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer #define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_W5100) #elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_W5100)
#ifdef STM32_DEVICE #ifdef STM32_DEVICE
#define WEBSOCKETS_NETWORK_CLASS TCPClient #define WEBSOCKETS_NETWORK_CLASS TCPClient
@ -158,13 +154,13 @@
#define WEBSOCKETS_NETWORK_SERVER_CLASS EthernetServer #define WEBSOCKETS_NETWORK_SERVER_CLASS EthernetServer
#endif #endif
#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ENC28J60) #elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ENC28J60)
#include <UIPEthernet.h> #include <UIPEthernet.h>
#define WEBSOCKETS_NETWORK_CLASS UIPClient #define WEBSOCKETS_NETWORK_CLASS UIPClient
#define WEBSOCKETS_NETWORK_SERVER_CLASS UIPServer #define WEBSOCKETS_NETWORK_SERVER_CLASS UIPServer
#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
#include <WiFi.h> #include <WiFi.h>
#include <WiFiClientSecure.h> #include <WiFiClientSecure.h>
@ -172,7 +168,7 @@
#define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure #define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure
#define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer #define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32_ETH) #elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32_ETH)
#include <ETH.h> #include <ETH.h>
#define WEBSOCKETS_NETWORK_CLASS WiFiClient #define WEBSOCKETS_NETWORK_CLASS WiFiClient
@ -182,7 +178,6 @@
#error "no network type selected!" #error "no network type selected!"
#endif #endif
#ifdef WEBSOCKETS_NETWORK_SSL_CLASS #ifdef WEBSOCKETS_NETWORK_SSL_CLASS
#define HAS_SSL #define HAS_SSL
#endif #endif
@ -226,7 +221,6 @@ typedef enum {
} WSopcode_t; } WSopcode_t;
typedef struct { typedef struct {
bool fin; bool fin;
bool rsv1; bool rsv1;
bool rsv2; bool rsv2;
@ -287,14 +281,12 @@ typedef struct {
uint8_t disconnectTimeoutCount; // after how many subsequent pong timeouts discconnect will happen, 0 means "do not disconnect" uint8_t disconnectTimeoutCount; // after how many subsequent pong timeouts discconnect will happen, 0 means "do not disconnect"
uint8_t pongTimeoutCount; // current pong timeout count uint8_t pongTimeoutCount; // current pong timeout count
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
String cHttpLine; ///< HTTP header lines String cHttpLine; ///< HTTP header lines
#endif #endif
} WSclient_t; } WSclient_t;
class WebSockets { class WebSockets {
protected: protected:
#ifdef __AVR__ #ifdef __AVR__
@ -322,14 +314,12 @@ class WebSockets {
String acceptKey(String & clientKey); String acceptKey(String & clientKey);
String base64_encode(uint8_t * data, size_t length); String base64_encode(uint8_t * data, size_t length);
bool readCb(WSclient_t * client, uint8_t *out, size_t n, WSreadWaitCb cb); bool readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWaitCb cb);
virtual size_t write(WSclient_t * client, uint8_t *out, size_t n); virtual size_t write(WSclient_t * client, uint8_t * out, size_t n);
size_t write(WSclient_t * client, const char *out); size_t write(WSclient_t * client, const char * out);
void enableHeartbeat(WSclient_t * client, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount); void enableHeartbeat(WSclient_t * client, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount);
void handleHBTimeout(WSclient_t * client); void handleHBTimeout(WSclient_t * client);
}; };
#ifndef UNUSED #ifndef UNUSED

118
src/WebSocketsClient.cpp
View File

@ -39,7 +39,7 @@ WebSocketsClient::~WebSocketsClient() {
/** /**
* calles to init the Websockets server * calles to init the Websockets server
*/ */
void WebSocketsClient::begin(const char *host, uint16_t port, const char * url, const char * protocol) { void WebSocketsClient::begin(const char * host, uint16_t port, const char * url, const char * protocol) {
_host = host; _host = host;
_port = port; _port = port;
#if defined(HAS_SSL) #if defined(HAS_SSL)
@ -77,7 +77,7 @@ void WebSocketsClient::begin(const char *host, uint16_t port, const char * url,
// todo find better seed // todo find better seed
randomSeed(millis()); randomSeed(millis());
#endif #endif
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
asyncConnect(); asyncConnect();
#endif #endif
@ -94,7 +94,7 @@ void WebSocketsClient::begin(IPAddress host, uint16_t port, const char * url, co
} }
#if defined(HAS_SSL) #if defined(HAS_SSL)
void WebSocketsClient::beginSSL(const char *host, uint16_t port, const char * url, const char * fingerprint, const char * protocol) { void WebSocketsClient::beginSSL(const char * host, uint16_t port, const char * url, const char * fingerprint, const char * protocol) {
begin(host, port, url, protocol); begin(host, port, url, protocol);
_client.isSSL = true; _client.isSSL = true;
_fingerprint = fingerprint; _fingerprint = fingerprint;
@ -105,7 +105,7 @@ void WebSocketsClient::beginSSL(String host, uint16_t port, String url, String f
beginSSL(host.c_str(), port, url.c_str(), fingerprint.c_str(), protocol.c_str()); beginSSL(host.c_str(), port, url.c_str(), fingerprint.c_str(), protocol.c_str());
} }
void WebSocketsClient::beginSslWithCA(const char *host, uint16_t port, const char * url, const char * CA_cert, const char * protocol) { void WebSocketsClient::beginSslWithCA(const char * host, uint16_t port, const char * url, const char * CA_cert, const char * protocol) {
begin(host, port, url, protocol); begin(host, port, url, protocol);
_client.isSSL = true; _client.isSSL = true;
_fingerprint = ""; _fingerprint = "";
@ -113,7 +113,7 @@ void WebSocketsClient::beginSslWithCA(const char *host, uint16_t port, const cha
} }
#endif #endif
void WebSocketsClient::beginSocketIO(const char *host, uint16_t port, const char * url, const char * protocol) { void WebSocketsClient::beginSocketIO(const char * host, uint16_t port, const char * url, const char * protocol) {
begin(host, port, url, protocol); begin(host, port, url, protocol);
_client.isSocketIO = true; _client.isSocketIO = true;
} }
@ -123,7 +123,7 @@ void WebSocketsClient::beginSocketIO(String host, uint16_t port, String url, Str
} }
#if defined(HAS_SSL) #if defined(HAS_SSL)
void WebSocketsClient::beginSocketIOSSL(const char *host, uint16_t port, const char * url, const char * protocol) { void WebSocketsClient::beginSocketIOSSL(const char * host, uint16_t port, const char * url, const char * protocol) {
begin(host, port, url, protocol); begin(host, port, url, protocol);
_client.isSocketIO = true; _client.isSocketIO = true;
_client.isSSL = true; _client.isSSL = true;
@ -134,7 +134,7 @@ void WebSocketsClient::beginSocketIOSSL(String host, uint16_t port, String url,
beginSocketIOSSL(host.c_str(), port, url.c_str(), protocol.c_str()); beginSocketIOSSL(host.c_str(), port, url.c_str(), protocol.c_str());
} }
void WebSocketsClient::beginSocketIOSSLWithCA(const char *host, uint16_t port, const char * url, const char * CA_cert, const char * protocol) { void WebSocketsClient::beginSocketIOSSLWithCA(const char * host, uint16_t port, const char * url, const char * CA_cert, const char * protocol) {
begin(host, port, url, protocol); begin(host, port, url, protocol);
_client.isSocketIO = true; _client.isSocketIO = true;
_client.isSSL = true; _client.isSSL = true;
@ -143,7 +143,7 @@ void WebSocketsClient::beginSocketIOSSLWithCA(const char *host, uint16_t port, c
} }
#endif #endif
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
/** /**
* called in arduino loop * called in arduino loop
*/ */
@ -197,16 +197,14 @@ void WebSocketsClient::loop(void) {
} else { } else {
connectFailedCb(); connectFailedCb();
_lastConnectionFail = millis(); _lastConnectionFail = millis();
} }
} else { } else {
handleClientData(); handleClientData();
if (_client.status == WSC_CONNECTED){ if(_client.status == WSC_CONNECTED) {
handleHBPing(); handleHBPing();
handleHBTimeout(&_client); handleHBTimeout(&_client);
} }
} }
} }
#endif #endif
@ -229,7 +227,7 @@ void WebSocketsClient::onEvent(WebSocketClientEvent cbEvent) {
*/ */
bool WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPayload) { bool WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPayload) {
if(length == 0) { if(length == 0) {
length = strlen((const char *) payload); length = strlen((const char *)payload);
} }
if(clientIsConnected(&_client)) { if(clientIsConnected(&_client)) {
return sendFrame(&_client, WSop_text, payload, length, true, headerToPayload); return sendFrame(&_client, WSop_text, payload, length, true, headerToPayload);
@ -238,19 +236,19 @@ bool WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPa
} }
bool WebSocketsClient::sendTXT(const uint8_t * payload, size_t length) { bool WebSocketsClient::sendTXT(const uint8_t * payload, size_t length) {
return sendTXT((uint8_t *) payload, length); return sendTXT((uint8_t *)payload, length);
} }
bool WebSocketsClient::sendTXT(char * payload, size_t length, bool headerToPayload) { bool WebSocketsClient::sendTXT(char * payload, size_t length, bool headerToPayload) {
return sendTXT((uint8_t *) payload, length, headerToPayload); return sendTXT((uint8_t *)payload, length, headerToPayload);
} }
bool WebSocketsClient::sendTXT(const char * payload, size_t length) { bool WebSocketsClient::sendTXT(const char * payload, size_t length) {
return sendTXT((uint8_t *) payload, length); return sendTXT((uint8_t *)payload, length);
} }
bool WebSocketsClient::sendTXT(String & payload) { bool WebSocketsClient::sendTXT(String & payload) {
return sendTXT((uint8_t *) payload.c_str(), payload.length()); return sendTXT((uint8_t *)payload.c_str(), payload.length());
} }
/** /**
@ -269,7 +267,7 @@ bool WebSocketsClient::sendBIN(uint8_t * payload, size_t length, bool headerToPa
} }
bool WebSocketsClient::sendBIN(const uint8_t * payload, size_t length) { bool WebSocketsClient::sendBIN(const uint8_t * payload, size_t length) {
return sendBIN((uint8_t *) payload, length); return sendBIN((uint8_t *)payload, length);
} }
/** /**
@ -281,7 +279,7 @@ bool WebSocketsClient::sendBIN(const uint8_t * payload, size_t length) {
bool WebSocketsClient::sendPing(uint8_t * payload, size_t length) { bool WebSocketsClient::sendPing(uint8_t * payload, size_t length) {
if(clientIsConnected(&_client)) { if(clientIsConnected(&_client)) {
bool sent = sendFrame(&_client, WSop_ping, payload, length); bool sent = sendFrame(&_client, WSop_ping, payload, length);
if (sent) if(sent)
_client.lastPing = millis(); _client.lastPing = millis();
return sent; return sent;
} }
@ -289,7 +287,7 @@ bool WebSocketsClient::sendPing(uint8_t * payload, size_t length) {
} }
bool WebSocketsClient::sendPing(String & payload) { bool WebSocketsClient::sendPing(String & payload) {
return sendPing((uint8_t *) payload.c_str(), payload.length()); return sendPing((uint8_t *)payload.c_str(), payload.length());
} }
/** /**
@ -312,7 +310,7 @@ void WebSocketsClient::setAuthorization(const char * user, const char * password
String auth = user; String auth = user;
auth += ":"; auth += ":";
auth += password; auth += password;
_client.base64Authorization = base64_encode((uint8_t *) auth.c_str(), auth.length()); _client.base64Authorization = base64_encode((uint8_t *)auth.c_str(), auth.length());
} }
} }
@ -383,7 +381,6 @@ void WebSocketsClient::messageReceived(WSclient_t * client, WSopcode_t opcode, u
} }
runCbEvent(type, payload, length); runCbEvent(type, payload, length);
} }
/** /**
@ -391,10 +388,9 @@ void WebSocketsClient::messageReceived(WSclient_t * client, WSopcode_t opcode, u
* @param client WSclient_t * ptr to the client struct * @param client WSclient_t * ptr to the client struct
*/ */
void WebSocketsClient::clientDisconnect(WSclient_t * client) { void WebSocketsClient::clientDisconnect(WSclient_t * client) {
bool event = false; bool event = false;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
if(client->isSSL && client->ssl) { if(client->isSSL && client->ssl) {
if(client->ssl->connected()) { if(client->ssl->connected()) {
client->ssl->flush(); client->ssl->flush();
@ -409,13 +405,13 @@ void WebSocketsClient::clientDisconnect(WSclient_t * client) {
if(client->tcp) { if(client->tcp) {
if(client->tcp->connected()) { if(client->tcp->connected()) {
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
client->tcp->flush(); client->tcp->flush();
#endif #endif
client->tcp->stop(); client->tcp->stop();
} }
event = true; event = true;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->status = WSC_NOT_CONNECTED; client->status = WSC_NOT_CONNECTED;
#else #else
delete client->tcp; delete client->tcp;
@ -445,7 +441,6 @@ void WebSocketsClient::clientDisconnect(WSclient_t * client) {
* @return true = conneted * @return true = conneted
*/ */
bool WebSocketsClient::clientIsConnected(WSclient_t * client) { bool WebSocketsClient::clientIsConnected(WSclient_t * client) {
if(!client->tcp) { if(!client->tcp) {
return false; return false;
} }
@ -470,7 +465,7 @@ bool WebSocketsClient::clientIsConnected(WSclient_t * client) {
return false; return false;
} }
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
/** /**
* Handel incomming data from Client * Handel incomming data from Client
*/ */
@ -481,8 +476,7 @@ void WebSocketsClient::handleClientData(void) {
case WSC_HEADER: { case WSC_HEADER: {
String headerLine = _client.tcp->readStringUntil('\n'); String headerLine = _client.tcp->readStringUntil('\n');
handleHeader(&_client, &headerLine); handleHeader(&_client, &headerLine);
} } break;
break;
case WSC_CONNECTED: case WSC_CONNECTED:
WebSockets::handleWebsocket(&_client); WebSockets::handleWebsocket(&_client);
break; break;
@ -491,7 +485,7 @@ void WebSocketsClient::handleClientData(void) {
break; break;
} }
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
delay(0); delay(0);
#endif #endif
} }
@ -502,7 +496,6 @@ void WebSocketsClient::handleClientData(void) {
* @param client WSclient_t * ptr to the client struct * @param client WSclient_t * ptr to the client struct
*/ */
void WebSocketsClient::sendHeader(WSclient_t * client) { void WebSocketsClient::sendHeader(WSclient_t * client) {
static const char * NEW_LINE = "\r\n"; static const char * NEW_LINE = "\r\n";
DEBUG_WEBSOCKETS("[WS-Client][sendHeader] sending header...\n"); DEBUG_WEBSOCKETS("[WS-Client][sendHeader] sending header...\n");
@ -534,12 +527,14 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
} }
handshake = WEBSOCKETS_STRING("GET "); handshake = WEBSOCKETS_STRING("GET ");
handshake += url + WEBSOCKETS_STRING(" HTTP/1.1\r\n" handshake += url + WEBSOCKETS_STRING(
" HTTP/1.1\r\n"
"Host: "); "Host: ");
handshake += _host + ":" + _port + NEW_LINE; handshake += _host + ":" + _port + NEW_LINE;
if(ws_header) { if(ws_header) {
handshake += WEBSOCKETS_STRING("Connection: Upgrade\r\n" handshake += WEBSOCKETS_STRING(
"Connection: Upgrade\r\n"
"Upgrade: websocket\r\n" "Upgrade: websocket\r\n"
"Sec-WebSocket-Version: 13\r\n" "Sec-WebSocket-Version: 13\r\n"
"Sec-WebSocket-Key: "); "Sec-WebSocket-Key: ");
@ -577,15 +572,14 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
handshake += NEW_LINE; handshake += NEW_LINE;
DEBUG_WEBSOCKETS("[WS-Client][sendHeader] handshake %s", (uint8_t* )handshake.c_str()); DEBUG_WEBSOCKETS("[WS-Client][sendHeader] handshake %s", (uint8_t *)handshake.c_str());
write(client, (uint8_t*) handshake.c_str(), handshake.length()); write(client, (uint8_t *)handshake.c_str(), handshake.length());
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine))); client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine)));
#endif #endif
DEBUG_WEBSOCKETS("[WS-Client][sendHeader] sending header... Done (%luus).\n", (micros() - start)); DEBUG_WEBSOCKETS("[WS-Client][sendHeader] sending header... Done (%luus).\n", (micros() - start));
} }
/** /**
@ -593,7 +587,6 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
* @param client WSclient_t * ptr to the client struct * @param client WSclient_t * ptr to the client struct
*/ */
void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) { void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
headerLine->trim(); // remove \r headerLine->trim(); // remove \r
if(headerLine->length() > 0) { if(headerLine->length() > 0) {
@ -640,10 +633,9 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
} }
(*headerLine) = ""; (*headerLine) = "";
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine))); client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine)));
#endif #endif
} else { } else {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header read fin.\n"); DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header read fin.\n");
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Client settings:\n"); DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Client settings:\n");
@ -684,7 +676,6 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
} }
if(ok) { if(ok) {
if(client->cAccept.length() == 0) { if(client->cAccept.length() == 0) {
ok = false; ok = false;
} else { } else {
@ -698,12 +689,10 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
} }
if(ok) { if(ok) {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Websocket connection init done.\n"); DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Websocket connection init done.\n");
headerDone(client); headerDone(client);
runCbEvent(WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length()); runCbEvent(WStype_CONNECTED, (uint8_t *)client->cUrl.c_str(), client->cUrl.length());
} else if(clientIsConnected(client) && client->isSocketIO && client->cSessionId.length() > 0) { } else if(clientIsConnected(client) && client->isSocketIO && client->cSessionId.length() > 0) {
sendHeader(client); sendHeader(client);
} else { } else {
@ -718,10 +707,9 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
} }
void WebSocketsClient::connectedCb() { void WebSocketsClient::connectedCb() {
DEBUG_WEBSOCKETS("[WS-Client] connected to %s:%u.\n", _host.c_str(), _port); DEBUG_WEBSOCKETS("[WS-Client] connected to %s:%u.\n", _host.c_str(), _port);
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
_client.tcp->onDisconnect(std::bind([](WebSocketsClient * c, AsyncTCPbuffer * obj, WSclient_t * client) -> bool { _client.tcp->onDisconnect(std::bind([](WebSocketsClient * c, AsyncTCPbuffer * obj, WSclient_t * client) -> bool {
DEBUG_WEBSOCKETS("[WS-Server][%d] Disconnect client\n", client->num); DEBUG_WEBSOCKETS("[WS-Server][%d] Disconnect client\n", client->num);
client->status = WSC_NOT_CONNECTED; client->status = WSC_NOT_CONNECTED;
@ -731,17 +719,18 @@ void WebSocketsClient::connectedCb() {
c->asyncConnect(); c->asyncConnect();
return true; return true;
}, this, std::placeholders::_1, &_client)); },
this, std::placeholders::_1, &_client));
#endif #endif
_client.status = WSC_HEADER; _client.status = WSC_HEADER;
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
// set Timeout for readBytesUntil and readStringUntil // set Timeout for readBytesUntil and readStringUntil
_client.tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT); _client.tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT);
#endif #endif
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32 #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
_client.tcp->setNoDelay(true); _client.tcp->setNoDelay(true);
#endif #endif
@ -761,17 +750,15 @@ void WebSocketsClient::connectedCb() {
// send Header to Server // send Header to Server
sendHeader(&_client); sendHeader(&_client);
} }
void WebSocketsClient::connectFailedCb() { void WebSocketsClient::connectFailedCb() {
DEBUG_WEBSOCKETS("[WS-Client] connection to %s:%u Failed\n", _host.c_str(), _port); DEBUG_WEBSOCKETS("[WS-Client] connection to %s:%u Failed\n", _host.c_str(), _port);
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
void WebSocketsClient::asyncConnect() { void WebSocketsClient::asyncConnect() {
DEBUG_WEBSOCKETS("[WS-Client] asyncConnect...\n"); DEBUG_WEBSOCKETS("[WS-Client] asyncConnect...\n");
AsyncClient * tcpclient = new AsyncClient(); AsyncClient * tcpclient = new AsyncClient();
@ -781,12 +768,12 @@ void WebSocketsClient::asyncConnect() {
return; return;
} }
tcpclient->onDisconnect([](void *obj, AsyncClient* c) { tcpclient->onDisconnect([](void * obj, AsyncClient * c) {
c->free(); c->free();
delete c; delete c;
}); });
tcpclient->onConnect(std::bind([](WebSocketsClient * ws , AsyncClient * tcp) { tcpclient->onConnect(std::bind([](WebSocketsClient * ws, AsyncClient * tcp) {
ws->_client.tcp = new AsyncTCPbuffer(tcp); ws->_client.tcp = new AsyncTCPbuffer(tcp);
if(!ws->_client.tcp) { if(!ws->_client.tcp) {
DEBUG_WEBSOCKETS("[WS-Client] creating Network class failed!\n"); DEBUG_WEBSOCKETS("[WS-Client] creating Network class failed!\n");
@ -794,20 +781,21 @@ void WebSocketsClient::asyncConnect() {
return; return;
} }
ws->connectedCb(); ws->connectedCb();
}, this, std::placeholders::_2)); },
this, std::placeholders::_2));
tcpclient->onError(std::bind([](WebSocketsClient * ws , AsyncClient * tcp) { tcpclient->onError(std::bind([](WebSocketsClient * ws, AsyncClient * tcp) {
ws->connectFailedCb(); ws->connectFailedCb();
// reconnect // reconnect
ws->asyncConnect(); ws->asyncConnect();
}, this, std::placeholders::_2)); },
this, std::placeholders::_2));
if(!tcpclient->connect(_host.c_str(), _port)) { if(!tcpclient->connect(_host.c_str(), _port)) {
connectFailedCb(); connectFailedCb();
delete tcpclient; delete tcpclient;
} }
} }
#endif #endif
@ -815,17 +803,17 @@ void WebSocketsClient::asyncConnect() {
/** /**
* send heartbeat ping to server in set intervals * send heartbeat ping to server in set intervals
*/ */
void WebSocketsClient::handleHBPing(){ void WebSocketsClient::handleHBPing() {
if (_client.pingInterval == 0) return; if(_client.pingInterval == 0)
return;
uint32_t pi = millis() - _client.lastPing; uint32_t pi = millis() - _client.lastPing;
if (pi > _client.pingInterval){ if(pi > _client.pingInterval) {
DEBUG_WEBSOCKETS("[WS-Client] sending HB ping\n"); DEBUG_WEBSOCKETS("[WS-Client] sending HB ping\n");
if (sendPing()) { if(sendPing()) {
_client.lastPing = millis(); _client.lastPing = millis();
_client.pongReceived = false; _client.pongReceived = false;
} }
} }
} }
/** /**
@ -834,13 +822,13 @@ void WebSocketsClient::handleHBPing(){
* @param pongTimeout uint32_t millis after which pong should timout if not received * @param pongTimeout uint32_t millis after which pong should timout if not received
* @param disconnectTimeoutCount uint8_t how many timeouts before disconnect, 0=> do not disconnect * @param disconnectTimeoutCount uint8_t how many timeouts before disconnect, 0=> do not disconnect
*/ */
void WebSocketsClient::enableHeartbeat(uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount){ void WebSocketsClient::enableHeartbeat(uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
WebSockets::enableHeartbeat(&_client, pingInterval, pongTimeout, disconnectTimeoutCount); WebSockets::enableHeartbeat(&_client, pingInterval, pongTimeout, disconnectTimeoutCount);
} }
/** /**
* disable ping/pong heartbeat process * disable ping/pong heartbeat process
*/ */
void WebSocketsClient::disableHeartbeat(){ void WebSocketsClient::disableHeartbeat() {
_client.pingInterval = 0; _client.pingInterval = 0;
} }

28
src/WebSocketsClient.h
View File

@ -27,42 +27,41 @@
#include "WebSockets.h" #include "WebSockets.h"
class WebSocketsClient: private WebSockets { class WebSocketsClient : private WebSockets {
public: public:
#ifdef __AVR__ #ifdef __AVR__
typedef void (*WebSocketClientEvent)(WStype_t type, uint8_t * payload, size_t length); typedef void (*WebSocketClientEvent)(WStype_t type, uint8_t * payload, size_t length);
#else #else
typedef std::function<void (WStype_t type, uint8_t * payload, size_t length)> WebSocketClientEvent; typedef std::function<void(WStype_t type, uint8_t * payload, size_t length)> WebSocketClientEvent;
#endif #endif
WebSocketsClient(void); WebSocketsClient(void);
virtual ~WebSocketsClient(void); virtual ~WebSocketsClient(void);
void begin(const char *host, uint16_t port, const char * url = "/", const char * protocol = "arduino"); void begin(const char * host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
void begin(String host, uint16_t port, String url = "/", String protocol = "arduino"); void begin(String host, uint16_t port, String url = "/", String protocol = "arduino");
void begin(IPAddress host, uint16_t port, const char * url = "/", const char * protocol = "arduino"); void begin(IPAddress host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
#if defined(HAS_SSL) #if defined(HAS_SSL)
void beginSSL(const char *host, uint16_t port, const char * url = "/", const char * = "", const char * protocol = "arduino"); void beginSSL(const char * host, uint16_t port, const char * url = "/", const char * = "", const char * protocol = "arduino");
void beginSSL(String host, uint16_t port, String url = "/", String fingerprint = "", String protocol = "arduino"); void beginSSL(String host, uint16_t port, String url = "/", String fingerprint = "", String protocol = "arduino");
void beginSslWithCA(const char *host, uint16_t port, const char * url = "/", const char * CA_cert = NULL, const char * protocol = "arduino"); void beginSslWithCA(const char * host, uint16_t port, const char * url = "/", const char * CA_cert = NULL, const char * protocol = "arduino");
#endif #endif
void beginSocketIO(const char *host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino"); void beginSocketIO(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino");
void beginSocketIO(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino"); void beginSocketIO(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino");
#if defined(HAS_SSL) #if defined(HAS_SSL)
void beginSocketIOSSL(const char *host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino"); void beginSocketIOSSL(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino");
void beginSocketIOSSL(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino"); void beginSocketIOSSL(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino");
void beginSocketIOSSLWithCA(const char *host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * CA_cert = NULL, const char * protocol = "arduino"); void beginSocketIOSSLWithCA(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * CA_cert = NULL, const char * protocol = "arduino");
#endif #endif
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
void loop(void); void loop(void);
#else #else
// Async interface not need a loop call // Async interface not need a loop call
void loop(void) __attribute__ ((deprecated)) {} void loop(void) __attribute__((deprecated)) {}
#endif #endif
void onEvent(WebSocketClientEvent cbEvent); void onEvent(WebSocketClientEvent cbEvent);
@ -97,7 +96,7 @@ class WebSocketsClient: private WebSockets {
#if defined(HAS_SSL) #if defined(HAS_SSL)
String _fingerprint; String _fingerprint;
const char *_CA_cert; const char * _CA_cert;
#endif #endif
WSclient_t _client; WSclient_t _client;
@ -111,7 +110,7 @@ class WebSocketsClient: private WebSockets {
void clientDisconnect(WSclient_t * client); void clientDisconnect(WSclient_t * client);
bool clientIsConnected(WSclient_t * client); bool clientIsConnected(WSclient_t * client);
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
void handleClientData(void); void handleClientData(void);
#endif #endif
@ -123,7 +122,7 @@ class WebSocketsClient: private WebSockets {
void handleHBPing(); // send ping in specified intervals void handleHBPing(); // send ping in specified intervals
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
void asyncConnect(); void asyncConnect();
#endif #endif
@ -138,7 +137,6 @@ class WebSocketsClient: private WebSockets {
_cbEvent(type, payload, length); _cbEvent(type, payload, length);
} }
} }
}; };
#endif /* WEBSOCKETSCLIENT_H_ */ #endif /* WEBSOCKETSCLIENT_H_ */

151
src/WebSocketsServer.cpp
View File

@ -33,10 +33,11 @@ WebSocketsServer::WebSocketsServer(uint16_t port, String origin, String protocol
_server = new WEBSOCKETS_NETWORK_SERVER_CLASS(port); _server = new WEBSOCKETS_NETWORK_SERVER_CLASS(port);
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
_server->onClient([](void *s, AsyncClient* c){ _server->onClient([](void * s, AsyncClient * c) {
((WebSocketsServer*)s)->newClient(new AsyncTCPbuffer(c)); ((WebSocketsServer *)s)->newClient(new AsyncTCPbuffer(c));
}, this); },
this);
#endif #endif
_cbEvent = NULL; _cbEvent = NULL;
@ -48,12 +49,11 @@ WebSocketsServer::WebSocketsServer(uint16_t port, String origin, String protocol
memset(&_clients[0], 0x00, (sizeof(WSclient_t) * WEBSOCKETS_SERVER_CLIENT_MAX)); memset(&_clients[0], 0x00, (sizeof(WSclient_t) * WEBSOCKETS_SERVER_CLIENT_MAX));
} }
WebSocketsServer::~WebSocketsServer() { WebSocketsServer::~WebSocketsServer() {
// disconnect all clients // disconnect all clients
close(); close();
if (_mandatoryHttpHeaders) if(_mandatoryHttpHeaders)
delete[] _mandatoryHttpHeaders; delete[] _mandatoryHttpHeaders;
_mandatoryHttpHeaderCount = 0; _mandatoryHttpHeaderCount = 0;
@ -72,7 +72,7 @@ void WebSocketsServer::begin(void) {
client->num = i; client->num = i;
client->status = WSC_NOT_CONNECTED; client->status = WSC_NOT_CONNECTED;
client->tcp = NULL; client->tcp = NULL;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
client->isSSL = false; client->isSSL = false;
client->ssl = NULL; client->ssl = NULL;
#endif #endif
@ -88,7 +88,7 @@ void WebSocketsServer::begin(void) {
client->cWsRXsize = 0; client->cWsRXsize = 0;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->cHttpLine = ""; client->cHttpLine = "";
#endif #endif
} }
@ -96,7 +96,7 @@ void WebSocketsServer::begin(void) {
#ifdef ESP8266 #ifdef ESP8266
randomSeed(RANDOM_REG32); randomSeed(RANDOM_REG32);
#elif defined(ESP32) #elif defined(ESP32)
#define DR_REG_RNG_BASE 0x3ff75144 #define DR_REG_RNG_BASE 0x3ff75144
randomSeed(READ_PERI_REG(DR_REG_RNG_BASE)); randomSeed(READ_PERI_REG(DR_REG_RNG_BASE));
#else #else
// TODO find better seed // TODO find better seed
@ -113,17 +113,16 @@ void WebSocketsServer::close(void) {
_runnning = false; _runnning = false;
disconnect(); disconnect();
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
_server->close(); _server->close();
#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
_server->end(); _server->end();
#else #else
// TODO how to close server? // TODO how to close server?
#endif #endif
} }
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
/** /**
* called in arduino loop * called in arduino loop
*/ */
@ -151,18 +150,17 @@ void WebSocketsServer::onEvent(WebSocketServerEvent cbEvent) {
*/ */
void WebSocketsServer::onValidateHttpHeader( void WebSocketsServer::onValidateHttpHeader(
WebSocketServerHttpHeaderValFunc validationFunc, WebSocketServerHttpHeaderValFunc validationFunc,
const char* mandatoryHttpHeaders[], const char * mandatoryHttpHeaders[],
size_t mandatoryHttpHeaderCount) size_t mandatoryHttpHeaderCount) {
{
_httpHeaderValidationFunc = validationFunc; _httpHeaderValidationFunc = validationFunc;
if (_mandatoryHttpHeaders) if(_mandatoryHttpHeaders)
delete[] _mandatoryHttpHeaders; delete[] _mandatoryHttpHeaders;
_mandatoryHttpHeaderCount = mandatoryHttpHeaderCount; _mandatoryHttpHeaderCount = mandatoryHttpHeaderCount;
_mandatoryHttpHeaders = new String[_mandatoryHttpHeaderCount]; _mandatoryHttpHeaders = new String[_mandatoryHttpHeaderCount];
for (size_t i = 0; i < _mandatoryHttpHeaderCount; i++) { for(size_t i = 0; i < _mandatoryHttpHeaderCount; i++) {
_mandatoryHttpHeaders[i] = mandatoryHttpHeaders[i]; _mandatoryHttpHeaders[i] = mandatoryHttpHeaders[i];
} }
} }
@ -180,7 +178,7 @@ bool WebSocketsServer::sendTXT(uint8_t num, uint8_t * payload, size_t length, bo
return false; return false;
} }
if(length == 0) { if(length == 0) {
length = strlen((const char *) payload); length = strlen((const char *)payload);
} }
WSclient_t * client = &_clients[num]; WSclient_t * client = &_clients[num];
if(clientIsConnected(client)) { if(clientIsConnected(client)) {
@ -190,19 +188,19 @@ bool WebSocketsServer::sendTXT(uint8_t num, uint8_t * payload, size_t length, bo
} }
bool WebSocketsServer::sendTXT(uint8_t num, const uint8_t * payload, size_t length) { bool WebSocketsServer::sendTXT(uint8_t num, const uint8_t * payload, size_t length) {
return sendTXT(num, (uint8_t *) payload, length); return sendTXT(num, (uint8_t *)payload, length);
} }
bool WebSocketsServer::sendTXT(uint8_t num, char * payload, size_t length, bool headerToPayload) { bool WebSocketsServer::sendTXT(uint8_t num, char * payload, size_t length, bool headerToPayload) {
return sendTXT(num, (uint8_t *) payload, length, headerToPayload); return sendTXT(num, (uint8_t *)payload, length, headerToPayload);
} }
bool WebSocketsServer::sendTXT(uint8_t num, const char * payload, size_t length) { bool WebSocketsServer::sendTXT(uint8_t num, const char * payload, size_t length) {
return sendTXT(num, (uint8_t *) payload, length); return sendTXT(num, (uint8_t *)payload, length);
} }
bool WebSocketsServer::sendTXT(uint8_t num, String & payload) { bool WebSocketsServer::sendTXT(uint8_t num, String & payload) {
return sendTXT(num, (uint8_t *) payload.c_str(), payload.length()); return sendTXT(num, (uint8_t *)payload.c_str(), payload.length());
} }
/** /**
@ -216,7 +214,7 @@ bool WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool heade
WSclient_t * client; WSclient_t * client;
bool ret = true; bool ret = true;
if(length == 0) { if(length == 0) {
length = strlen((const char *) payload); length = strlen((const char *)payload);
} }
for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) { for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
@ -226,7 +224,7 @@ bool WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool heade
ret = false; ret = false;
} }
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
delay(0); delay(0);
#endif #endif
} }
@ -234,19 +232,19 @@ bool WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool heade
} }
bool WebSocketsServer::broadcastTXT(const uint8_t * payload, size_t length) { bool WebSocketsServer::broadcastTXT(const uint8_t * payload, size_t length) {
return broadcastTXT((uint8_t *) payload, length); return broadcastTXT((uint8_t *)payload, length);
} }
bool WebSocketsServer::broadcastTXT(char * payload, size_t length, bool headerToPayload) { bool WebSocketsServer::broadcastTXT(char * payload, size_t length, bool headerToPayload) {
return broadcastTXT((uint8_t *) payload, length, headerToPayload); return broadcastTXT((uint8_t *)payload, length, headerToPayload);
} }
bool WebSocketsServer::broadcastTXT(const char * payload, size_t length) { bool WebSocketsServer::broadcastTXT(const char * payload, size_t length) {
return broadcastTXT((uint8_t *) payload, length); return broadcastTXT((uint8_t *)payload, length);
} }
bool WebSocketsServer::broadcastTXT(String & payload) { bool WebSocketsServer::broadcastTXT(String & payload) {
return broadcastTXT((uint8_t *) payload.c_str(), payload.length()); return broadcastTXT((uint8_t *)payload.c_str(), payload.length());
} }
/** /**
@ -269,7 +267,7 @@ bool WebSocketsServer::sendBIN(uint8_t num, uint8_t * payload, size_t length, bo
} }
bool WebSocketsServer::sendBIN(uint8_t num, const uint8_t * payload, size_t length) { bool WebSocketsServer::sendBIN(uint8_t num, const uint8_t * payload, size_t length) {
return sendBIN(num, (uint8_t *) payload, length); return sendBIN(num, (uint8_t *)payload, length);
} }
/** /**
@ -289,7 +287,7 @@ bool WebSocketsServer::broadcastBIN(uint8_t * payload, size_t length, bool heade
ret = false; ret = false;
} }
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
delay(0); delay(0);
#endif #endif
} }
@ -297,10 +295,9 @@ bool WebSocketsServer::broadcastBIN(uint8_t * payload, size_t length, bool heade
} }
bool WebSocketsServer::broadcastBIN(const uint8_t * payload, size_t length) { bool WebSocketsServer::broadcastBIN(const uint8_t * payload, size_t length) {
return broadcastBIN((uint8_t *) payload, length); return broadcastBIN((uint8_t *)payload, length);
} }
/** /**
* sends a WS ping to Client * sends a WS ping to Client
* @param num uint8_t client id * @param num uint8_t client id
@ -320,7 +317,7 @@ bool WebSocketsServer::sendPing(uint8_t num, uint8_t * payload, size_t length) {
} }
bool WebSocketsServer::sendPing(uint8_t num, String & payload) { bool WebSocketsServer::sendPing(uint8_t num, String & payload) {
return sendPing(num, (uint8_t *) payload.c_str(), payload.length()); return sendPing(num, (uint8_t *)payload.c_str(), payload.length());
} }
/** /**
@ -339,7 +336,7 @@ bool WebSocketsServer::broadcastPing(uint8_t * payload, size_t length) {
ret = false; ret = false;
} }
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
delay(0); delay(0);
#endif #endif
} }
@ -347,10 +344,9 @@ bool WebSocketsServer::broadcastPing(uint8_t * payload, size_t length) {
} }
bool WebSocketsServer::broadcastPing(String & payload) { bool WebSocketsServer::broadcastPing(String & payload) {
return broadcastPing((uint8_t *) payload.c_str(), payload.length()); return broadcastPing((uint8_t *)payload.c_str(), payload.length());
} }
/** /**
* disconnect all clients * disconnect all clients
*/ */
@ -378,7 +374,6 @@ void WebSocketsServer::disconnect(uint8_t num) {
} }
} }
/* /*
* set the Authorization for the http request * set the Authorization for the http request
* @param user const char * * @param user const char *
@ -421,7 +416,7 @@ int WebSocketsServer::connectedClients(bool ping) {
return count; return count;
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
/** /**
* get an IP for a client * get an IP for a client
* @param num uint8_t client id * @param num uint8_t client id
@ -455,27 +450,25 @@ bool WebSocketsServer::newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient) {
// state is not connected or tcp connection is lost // state is not connected or tcp connection is lost
if(!clientIsConnected(client)) { if(!clientIsConnected(client)) {
client->tcp = TCPclient; client->tcp = TCPclient;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
client->isSSL = false; client->isSSL = false;
client->tcp->setNoDelay(true); client->tcp->setNoDelay(true);
#endif #endif
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
// set Timeout for readBytesUntil and readStringUntil // set Timeout for readBytesUntil and readStringUntil
client->tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT); client->tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT);
#endif #endif
client->status = WSC_HEADER; client->status = WSC_HEADER;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
IPAddress ip = client->tcp->remoteIP(); IPAddress ip = client->tcp->remoteIP();
DEBUG_WEBSOCKETS("[WS-Server][%d] new client from %d.%d.%d.%d\n", client->num, ip[0], ip[1], ip[2], ip[3]); DEBUG_WEBSOCKETS("[WS-Server][%d] new client from %d.%d.%d.%d\n", client->num, ip[0], ip[1], ip[2], ip[3]);
#else #else
DEBUG_WEBSOCKETS("[WS-Server][%d] new client\n", client->num); DEBUG_WEBSOCKETS("[WS-Server][%d] new client\n", client->num);
#endif #endif
#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->tcp->onDisconnect(std::bind([](WebSocketsServer * server, AsyncTCPbuffer * obj, WSclient_t * client) -> bool { client->tcp->onDisconnect(std::bind([](WebSocketsServer * server, AsyncTCPbuffer * obj, WSclient_t * client) -> bool {
DEBUG_WEBSOCKETS("[WS-Server][%d] Disconnect client\n", client->num); DEBUG_WEBSOCKETS("[WS-Server][%d] Disconnect client\n", client->num);
@ -485,8 +478,8 @@ bool WebSocketsServer::newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient) {
*sl = NULL; *sl = NULL;
} }
return true; return true;
}, this, std::placeholders::_1, client)); },
this, std::placeholders::_1, client));
client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsServer::handleHeader, this, client, &(client->cHttpLine))); client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsServer::handleHeader, this, client, &(client->cHttpLine)));
#endif #endif
@ -530,7 +523,6 @@ void WebSocketsServer::messageReceived(WSclient_t * client, WSopcode_t opcode, u
} }
runCbEvent(client->num, type, payload, length); runCbEvent(client->num, type, payload, length);
} }
/** /**
@ -538,9 +530,7 @@ void WebSocketsServer::messageReceived(WSclient_t * client, WSopcode_t opcode, u
* @param client WSclient_t * ptr to the client struct * @param client WSclient_t * ptr to the client struct
*/ */
void WebSocketsServer::clientDisconnect(WSclient_t * client) { void WebSocketsServer::clientDisconnect(WSclient_t * client) {
#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
if(client->isSSL && client->ssl) { if(client->isSSL && client->ssl) {
if(client->ssl->connected()) { if(client->ssl->connected()) {
client->ssl->flush(); client->ssl->flush();
@ -554,12 +544,12 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
if(client->tcp) { if(client->tcp) {
if(client->tcp->connected()) { if(client->tcp->connected()) {
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
client->tcp->flush(); client->tcp->flush();
#endif #endif
client->tcp->stop(); client->tcp->stop();
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->status = WSC_NOT_CONNECTED; client->status = WSC_NOT_CONNECTED;
#else #else
delete client->tcp; delete client->tcp;
@ -576,7 +566,7 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
client->cWsRXsize = 0; client->cWsRXsize = 0;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->cHttpLine = ""; client->cHttpLine = "";
#endif #endif
@ -585,7 +575,6 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
DEBUG_WEBSOCKETS("[WS-Server][%d] client disconnected.\n", client->num); DEBUG_WEBSOCKETS("[WS-Server][%d] client disconnected.\n", client->num);
runCbEvent(client->num, WStype_DISCONNECTED, NULL, 0); runCbEvent(client->num, WStype_DISCONNECTED, NULL, 0);
} }
/** /**
@ -594,7 +583,6 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
* @return true = connected * @return true = connected
*/ */
bool WebSocketsServer::clientIsConnected(WSclient_t * client) { bool WebSocketsServer::clientIsConnected(WSclient_t * client) {
if(!client->tcp) { if(!client->tcp) {
return false; return false;
} }
@ -620,18 +608,17 @@ bool WebSocketsServer::clientIsConnected(WSclient_t * client) {
return false; return false;
} }
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
/** /**
* Handle incoming Connection Request * Handle incoming Connection Request
*/ */
void WebSocketsServer::handleNewClients(void) { void WebSocketsServer::handleNewClients(void) {
#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
while(_server->hasClient()) { while(_server->hasClient()) {
#endif #endif
bool ok = false; bool ok = false;
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
// store new connection // store new connection
WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available()); WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
#else #else
@ -647,7 +634,7 @@ void WebSocketsServer::handleNewClients(void) {
if(!ok) { if(!ok) {
// no free space to handle client // no free space to handle client
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
IPAddress ip = tcpClient->remoteIP(); IPAddress ip = tcpClient->remoteIP();
DEBUG_WEBSOCKETS("[WS-Server] no free space new client from %d.%d.%d.%d\n", ip[0], ip[1], ip[2], ip[3]); DEBUG_WEBSOCKETS("[WS-Server] no free space new client from %d.%d.%d.%d\n", ip[0], ip[1], ip[2], ip[3]);
#else #else
@ -656,19 +643,16 @@ void WebSocketsServer::handleNewClients(void) {
tcpClient->stop(); tcpClient->stop();
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
delay(0); delay(0);
} }
#endif #endif
} }
/** /**
* Handel incomming data from Client * Handel incomming data from Client
*/ */
void WebSocketsServer::handleClientData(void) { void WebSocketsServer::handleClientData(void) {
WSclient_t * client; WSclient_t * client;
for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) { for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
client = &_clients[i]; client = &_clients[i];
@ -677,12 +661,10 @@ void WebSocketsServer::handleClientData(void) {
if(len > 0) { if(len > 0) {
//DEBUG_WEBSOCKETS("[WS-Server][%d][handleClientData] len: %d\n", client->num, len); //DEBUG_WEBSOCKETS("[WS-Server][%d][handleClientData] len: %d\n", client->num, len);
switch(client->status) { switch(client->status) {
case WSC_HEADER: case WSC_HEADER: {
{
String headerLine = client->tcp->readStringUntil('\n'); String headerLine = client->tcp->readStringUntil('\n');
handleHeader(client, &headerLine); handleHeader(client, &headerLine);
} } break;
break;
case WSC_CONNECTED: case WSC_CONNECTED:
WebSockets::handleWebsocket(client); WebSockets::handleWebsocket(client);
break; break;
@ -692,7 +674,7 @@ void WebSocketsServer::handleClientData(void) {
} }
} }
} }
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
delay(0); delay(0);
#endif #endif
} }
@ -704,21 +686,19 @@ void WebSocketsServer::handleClientData(void) {
* @param headerName String ///< the name of the header being checked * @param headerName String ///< the name of the header being checked
*/ */
bool WebSocketsServer::hasMandatoryHeader(String headerName) { bool WebSocketsServer::hasMandatoryHeader(String headerName) {
for (size_t i = 0; i < _mandatoryHttpHeaderCount; i++) { for(size_t i = 0; i < _mandatoryHttpHeaderCount; i++) {
if (_mandatoryHttpHeaders[i].equalsIgnoreCase(headerName)) if(_mandatoryHttpHeaders[i].equalsIgnoreCase(headerName))
return true; return true;
} }
return false; return false;
} }
/** /**
* handles http header reading for WebSocket upgrade * handles http header reading for WebSocket upgrade
* @param client WSclient_t * ///< pointer to the client struct * @param client WSclient_t * ///< pointer to the client struct
* @param headerLine String ///< the header being read / processed * @param headerLine String ///< the header being read / processed
*/ */
void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) { void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
static const char * NEW_LINE = "\r\n"; static const char * NEW_LINE = "\r\n";
headerLine->trim(); // remove \r headerLine->trim(); // remove \r
@ -728,7 +708,6 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
// websocket requests always start with GET see rfc6455 // websocket requests always start with GET see rfc6455
if(headerLine->startsWith("GET ")) { if(headerLine->startsWith("GET ")) {
// cut URL out // cut URL out
client->cUrl = headerLine->substring(4, headerLine->indexOf(' ', 4)); client->cUrl = headerLine->substring(4, headerLine->indexOf(' ', 4));
@ -777,11 +756,10 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
} }
(*headerLine) = ""; (*headerLine) = "";
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsServer::handleHeader, this, client, &(client->cHttpLine))); client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsServer::handleHeader, this, client, &(client->cHttpLine)));
#endif #endif
} else { } else {
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Header read fin.\n", client->num); DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Header read fin.\n", client->num);
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cURL: %s\n", client->num, client->cUrl.c_str()); DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cURL: %s\n", client->num, client->cUrl.c_str());
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cIsUpgrade: %d\n", client->num, client->cIsUpgrade); DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cIsUpgrade: %d\n", client->num, client->cIsUpgrade);
@ -809,7 +787,7 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
if(!client->cHttpHeadersValid) { if(!client->cHttpHeadersValid) {
ok = false; ok = false;
} }
if (client->cMandatoryHeadersCount != _mandatoryHttpHeaderCount) { if(client->cMandatoryHeadersCount != _mandatoryHttpHeaderCount) {
ok = false; ok = false;
} }
} }
@ -825,7 +803,6 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
} }
if(ok) { if(ok) {
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Websocket connection incoming.\n", client->num); DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Websocket connection incoming.\n", client->num);
// generate Sec-WebSocket-Accept key // generate Sec-WebSocket-Accept key
@ -835,7 +812,8 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
client->status = WSC_CONNECTED; client->status = WSC_CONNECTED;
String handshake = WEBSOCKETS_STRING("HTTP/1.1 101 Switching Protocols\r\n" String handshake = WEBSOCKETS_STRING(
"HTTP/1.1 101 Switching Protocols\r\n"
"Server: arduino-WebSocketsServer\r\n" "Server: arduino-WebSocketsServer\r\n"
"Upgrade: websocket\r\n" "Upgrade: websocket\r\n"
"Connection: Upgrade\r\n" "Connection: Upgrade\r\n"
@ -845,33 +823,30 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
if(_origin.length() > 0) { if(_origin.length() > 0) {
handshake += WEBSOCKETS_STRING("Access-Control-Allow-Origin: "); handshake += WEBSOCKETS_STRING("Access-Control-Allow-Origin: ");
handshake +=_origin + NEW_LINE; handshake += _origin + NEW_LINE;
} }
if(client->cProtocol.length() > 0) { if(client->cProtocol.length() > 0) {
handshake += WEBSOCKETS_STRING("Sec-WebSocket-Protocol: "); handshake += WEBSOCKETS_STRING("Sec-WebSocket-Protocol: ");
handshake +=_protocol + NEW_LINE; handshake += _protocol + NEW_LINE;
} }
// header end // header end
handshake += NEW_LINE; handshake += NEW_LINE;
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] handshake %s", client->num, (uint8_t*)handshake.c_str()); DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] handshake %s", client->num, (uint8_t *)handshake.c_str());
write(client, (uint8_t*)handshake.c_str(), handshake.length()); write(client, (uint8_t *)handshake.c_str(), handshake.length());
headerDone(client); headerDone(client);
// send ping // send ping
WebSockets::sendFrame(client, WSop_ping); WebSockets::sendFrame(client, WSop_ping);
runCbEvent(client->num, WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length()); runCbEvent(client->num, WStype_CONNECTED, (uint8_t *)client->cUrl.c_str(), client->cUrl.length());
} else { } else {
handleNonWebsocketConnection(client); handleNonWebsocketConnection(client);
} }
} }
} }

38
src/WebSocketsServer.h
View File

@ -31,18 +31,14 @@
#define WEBSOCKETS_SERVER_CLIENT_MAX (5) #define WEBSOCKETS_SERVER_CLIENT_MAX (5)
#endif #endif
class WebSocketsServer : protected WebSockets {
public:
class WebSocketsServer: protected WebSockets {
public:
#ifdef __AVR__ #ifdef __AVR__
typedef void (*WebSocketServerEvent)(uint8_t num, WStype_t type, uint8_t * payload, size_t length); typedef void (*WebSocketServerEvent)(uint8_t num, WStype_t type, uint8_t * payload, size_t length);
typedef bool (*WebSocketServerHttpHeaderValFunc)(String headerName, String headerValue); typedef bool (*WebSocketServerHttpHeaderValFunc)(String headerName, String headerValue);
#else #else
typedef std::function<void (uint8_t num, WStype_t type, uint8_t * payload, size_t length)> WebSocketServerEvent; typedef std::function<void(uint8_t num, WStype_t type, uint8_t * payload, size_t length)> WebSocketServerEvent;
typedef std::function<bool (String headerName, String headerValue)> WebSocketServerHttpHeaderValFunc; typedef std::function<bool(String headerName, String headerValue)> WebSocketServerHttpHeaderValFunc;
#endif #endif
WebSocketsServer(uint16_t port, String origin = "", String protocol = "arduino"); WebSocketsServer(uint16_t port, String origin = "", String protocol = "arduino");
@ -51,20 +47,19 @@ public:
void begin(void); void begin(void);
void close(void); void close(void);
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
void loop(void); void loop(void);
#else #else
// Async interface not need a loop call // Async interface not need a loop call
void loop(void) __attribute__ ((deprecated)) {} void loop(void) __attribute__((deprecated)) {}
#endif #endif
void onEvent(WebSocketServerEvent cbEvent); void onEvent(WebSocketServerEvent cbEvent);
void onValidateHttpHeader( void onValidateHttpHeader(
WebSocketServerHttpHeaderValFunc validationFunc, WebSocketServerHttpHeaderValFunc validationFunc,
const char* mandatoryHttpHeaders[], const char * mandatoryHttpHeaders[],
size_t mandatoryHttpHeaderCount); size_t mandatoryHttpHeaderCount);
bool sendTXT(uint8_t num, uint8_t * payload, size_t length = 0, bool headerToPayload = false); bool sendTXT(uint8_t num, uint8_t * payload, size_t length = 0, bool headerToPayload = false);
bool sendTXT(uint8_t num, const uint8_t * payload, size_t length = 0); bool sendTXT(uint8_t num, const uint8_t * payload, size_t length = 0);
bool sendTXT(uint8_t num, char * payload, size_t length = 0, bool headerToPayload = false); bool sendTXT(uint8_t num, char * payload, size_t length = 0, bool headerToPayload = false);
@ -97,11 +92,11 @@ public:
int connectedClients(bool ping = false); int connectedClients(bool ping = false);
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) #if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
IPAddress remoteIP(uint8_t num); IPAddress remoteIP(uint8_t num);
#endif #endif
protected: protected:
uint16_t _port; uint16_t _port;
String _origin; String _origin;
String _protocol; String _protocol;
@ -125,7 +120,7 @@ protected:
void clientDisconnect(WSclient_t * client); void clientDisconnect(WSclient_t * client);
bool clientIsConnected(WSclient_t * client); bool clientIsConnected(WSclient_t * client);
#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC) #if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
void handleNewClients(void); void handleNewClients(void);
void handleClientData(void); void handleClientData(void);
#endif #endif
@ -139,7 +134,8 @@ protected:
*/ */
virtual void handleNonWebsocketConnection(WSclient_t * client) { virtual void handleNonWebsocketConnection(WSclient_t * client) {
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] no Websocket connection close.\n", client->num); DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] no Websocket connection close.\n", client->num);
client->tcp->write("HTTP/1.1 400 Bad Request\r\n" client->tcp->write(
"HTTP/1.1 400 Bad Request\r\n"
"Server: arduino-WebSocket-Server\r\n" "Server: arduino-WebSocket-Server\r\n"
"Content-Type: text/plain\r\n" "Content-Type: text/plain\r\n"
"Content-Length: 32\r\n" "Content-Length: 32\r\n"
@ -155,8 +151,9 @@ protected:
* Note: can be override * Note: can be override
* @param client WSclient_t * ptr to the client struct * @param client WSclient_t * ptr to the client struct
*/ */
virtual void handleAuthorizationFailed(WSclient_t *client) { virtual void handleAuthorizationFailed(WSclient_t * client) {
client->tcp->write("HTTP/1.1 401 Unauthorized\r\n" client->tcp->write(
"HTTP/1.1 401 Unauthorized\r\n"
"Server: arduino-WebSocket-Server\r\n" "Server: arduino-WebSocket-Server\r\n"
"Content-Type: text/plain\r\n" "Content-Type: text/plain\r\n"
"Content-Length: 45\r\n" "Content-Length: 45\r\n"
@ -198,15 +195,12 @@ protected:
return true; return true;
} }
private: private:
/* /*
* returns an indicator whether the given named header exists in the configured _mandatoryHttpHeaders collection * returns an indicator whether the given named header exists in the configured _mandatoryHttpHeaders collection
* @param headerName String ///< the name of the header being checked * @param headerName String ///< the name of the header being checked
*/ */
bool hasMandatoryHeader(String headerName); bool hasMandatoryHeader(String headerName);
}; };
#endif /* WEBSOCKETSSERVER_H_ */ #endif /* WEBSOCKETSSERVER_H_ */