AsyncWebSocket: Use DynamicBuffer for APIs

This makes it clear that the buffers are copied or moved to the library.
Using a shared buffer implies the client might be permitted to hang on
to it - this is not generally permissible as the websocket might write
to the buffer while sending it.

Author: willmmiles

src/AsyncWebSocket.cpp

@@ -778,7 +778,7 @@ void AsyncWebSocketClient::text(const __FlashStringHelper *data){
     free(message);
   }
 }
-void AsyncWebSocketClient::text(AsyncWebSocketSharedBuffer buffer)
+void AsyncWebSocketClient::text(AsyncWebSocketBuffer buffer)
 {
   _queueMessage(new AsyncWebSocketMultiMessage(std::move(buffer)));
 }
@@ -815,7 +815,7 @@ void AsyncWebSocketClient::binary(const __FlashStringHelper *data, size_t len){
   }
 
 }
-void AsyncWebSocketClient::binary(AsyncWebSocketSharedBuffer buffer)
+void AsyncWebSocketClient::binary(AsyncWebSocketBuffer buffer)
 {
   _queueMessage(new AsyncWebSocketMultiMessage(std::move(buffer), WS_BINARY));
 }
@@ -944,22 +944,19 @@ void AsyncWebSocket::text(uint32_t id, const char * message, size_t len){
     c->text(message, len);
 }
 
-void AsyncWebSocket::textAll(const AsyncWebSocketSharedBuffer& buffer){
+void AsyncWebSocket::textAll(AsyncWebSocketBuffer buffer){
   if (!buffer) return;
-  for(const auto& c: _clients){
-    if(c->status() == WS_CONNECTED){
-        c->text(buffer);
-    }
-  }
+  messageAll(AsyncWebSocketMultiMessage(std::move(buffer)));
 }
 
 void AsyncWebSocket::textAll(const char * message, size_t len){
-  textAll(AsyncWebSocketSharedBuffer(message, len)); 
+  if ((!message) || (len ==0)) return;
+  messageAll(AsyncWebSocketMultiMessage(SharedBuffer{message, len}));
 }
 
 void AsyncWebSocket::textAll(const AsyncWebSocketMessageBuffer* buffer){
   if (!buffer) return;
-  textAll(buffer->_buf);
+  textAll(std::move(buffer->_buf));
   delete buffer;
 }
 
@@ -970,20 +967,17 @@ void AsyncWebSocket::binary(uint32_t id, const char * message, size_t len){
 }
 
 void AsyncWebSocket::binaryAll(const char * message, size_t len){
-  binaryAll(SharedBuffer(message, len)); 
+  binaryAll(DynamicBuffer(message, len));
 }
 
-void AsyncWebSocket::binaryAll(const AsyncWebSocketSharedBuffer &buffer)
+void AsyncWebSocket::binaryAll(AsyncWebSocketBuffer buffer)
 {
-    for(const auto& c: _clients){
-    if(c->status() == WS_CONNECTED)
-      c->binary(buffer);
-  }
+  messageAll(AsyncWebSocketMultiMessage(std::move(buffer), WS_BINARY));
 }
 
 void AsyncWebSocket::binaryAll(const AsyncWebSocketMessageBuffer* buffer){
   if (!buffer) return;
-  binaryAll(buffer->_buf);
+  binaryAll(std::move(buffer->_buf));
   delete buffer;
 }
 
@@ -1023,7 +1017,7 @@ size_t AsyncWebSocket::printfAll(const char *format, ...) {
   va_end(arg);
   delete[] temp;
 
-  AsyncWebSocketSharedBuffer buffer(len); 
+  AsyncWebSocketBuffer buffer(len); 
   if (!buffer) {
     return 0;
   }
@@ -1061,7 +1055,7 @@ size_t AsyncWebSocket::printfAll_P(PGM_P formatP, ...) {
   va_end(arg);
   delete[] temp;
 
-  AsyncWebSocketSharedBuffer buffer(len); 
+  AsyncWebSocketBuffer buffer(len); 
   if (!buffer) {
     return 0;
   }
@@ -1198,7 +1192,7 @@ void AsyncWebSocket::handleRequest(AsyncWebServerRequest *request){
 // Deprecated API
 AsyncWebSocketMessageBuffer* AsyncWebSocket::makeBuffer(size_t size)
 {
-  AsyncWebSocketSharedBuffer buffer(size);  
+  AsyncWebSocketBuffer buffer(size);  
   if (buffer.size() == 0) {
     return nullptr;
   }
@@ -1207,7 +1201,7 @@ AsyncWebSocketMessageBuffer* AsyncWebSocket::makeBuffer(size_t size)
 
 AsyncWebSocketMessageBuffer* AsyncWebSocket::makeBuffer(const uint8_t * data, size_t size)
 {
-  AsyncWebSocketSharedBuffer buffer((const char*) data, size); 
+  AsyncWebSocketBuffer buffer((const char*) data, size); 
   if (buffer.size() == 0) {
     return nullptr;
   }

src/AsyncWebSocket.h

@@ -89,20 +89,22 @@ typedef enum { WS_CONTINUATION, WS_TEXT, WS_BINARY, WS_DISCONNECT = 0x08, WS_PIN
 typedef enum { WS_MSG_SENDING, WS_MSG_SENT, WS_MSG_ERROR } AwsMessageStatus;
 typedef enum { WS_EVT_CONNECT, WS_EVT_DISCONNECT, WS_EVT_PONG, WS_EVT_ERROR, WS_EVT_DATA } AwsEventType;
 
+typedef DynamicBuffer AsyncWebSocketBuffer;
 typedef SharedBuffer AsyncWebSocketSharedBuffer;
 
-// API compatibility class - use AsyncWebSocketSharedBuffer directly
+// API compatibility class.
+// Use AsyncWebSocketBuffer directly instead of this where possible.
 class AsyncWebSocketMessageBuffer {
   private:
-    AsyncWebSocketSharedBuffer _buf;
+    DynamicBuffer _buf;
 
   public:
     AsyncWebSocketMessageBuffer() {};
     AsyncWebSocketMessageBuffer(size_t size) : _buf(size) {};
     AsyncWebSocketMessageBuffer(uint8_t * data, size_t size)  : _buf(reinterpret_cast<char*>(data), size) {};
-    AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer &r) { if (r._buf) _buf = SharedBuffer(r._buf.copy()); }
+    AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer &r) { if (r._buf) _buf = r._buf; }
     AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer &&) = default;
-    AsyncWebSocketMessageBuffer(AsyncWebSocketSharedBuffer b) : _buf(std::move(b)) {};
+    AsyncWebSocketMessageBuffer(DynamicBuffer b) : _buf(std::move(b)) {};
     ~AsyncWebSocketMessageBuffer() {};
 
     void operator ++(int i) {};
@@ -160,6 +162,7 @@ class AsyncWebSocketMultiMessage: public AsyncWebSocketMessage {
     AsyncWebSocketSharedBuffer _WSbuffer; 
 public:
     AsyncWebSocketMultiMessage(AsyncWebSocketSharedBuffer buffer, uint8_t opcode=WS_TEXT, bool mask=false); 
+    AsyncWebSocketMultiMessage(AsyncWebSocketBuffer buffer, uint8_t opcode=WS_TEXT, bool mask=false) : AsyncWebSocketMultiMessage(AsyncWebSocketSharedBuffer(std::move(buffer)), opcode, mask){}; 
     virtual ~AsyncWebSocketMultiMessage() override;
     virtual bool betweenFrames() const override { return _acked == _ack; }
     virtual void ack(size_t len, uint32_t time) override ;
@@ -233,7 +236,7 @@ class AsyncWebSocketClient {
     void text(char * message);
     void text(const String &message);
     void text(const __FlashStringHelper *data);
-    void text(AsyncWebSocketSharedBuffer buffer); 
+    void text(AsyncWebSocketBuffer buffer); 
     void text(AsyncWebSocketMessageBuffer* buffer) __attribute__((deprecated));  // frees buffer 
 
     void binary(const char * message, size_t len);
@@ -242,7 +245,7 @@ class AsyncWebSocketClient {
     void binary(char * message);
     void binary(const String &message);
     void binary(const __FlashStringHelper *data, size_t len);
-    void binary(AsyncWebSocketSharedBuffer buffer); 
+    void binary(AsyncWebSocketBuffer buffer); 
     void binary(AsyncWebSocketMessageBuffer* buffer) __attribute__((deprecated));  // frees buffer 
 
     bool canSend() { return _messageQueue.length() < WS_MAX_QUEUED_MESSAGES; }
@@ -295,14 +298,15 @@ class AsyncWebSocket: public AsyncWebHandler {
     void text(uint32_t id, char * message);
     void text(uint32_t id, const String &message);
     void text(uint32_t id, const __FlashStringHelper *message);
+    void text(uint32_t id, AsyncWebSocketBuffer buffer); 
 
     void textAll(const char * message, size_t len);
     void textAll(const char * message);
     void textAll(uint8_t * message, size_t len);
     void textAll(char * message);
     void textAll(const String &message);
     void textAll(const __FlashStringHelper *message); //  need to convert
-    void textAll(const AsyncWebSocketSharedBuffer& buffer); 
+    void textAll(AsyncWebSocketBuffer buffer); // must be moved, or will be copied
     void textAll(const AsyncWebSocketMessageBuffer* buffer) __attribute__((deprecated));  // frees buffer
 
     void binary(uint32_t id, const char * message, size_t len);
@@ -318,7 +322,7 @@ class AsyncWebSocket: public AsyncWebHandler {
     void binaryAll(char * message);
     void binaryAll(const String &message);
     void binaryAll(const __FlashStringHelper *message, size_t len);
-    void binaryAll(const AsyncWebSocketSharedBuffer& buffer); 
+    void binaryAll(AsyncWebSocketBuffer buffer); 
     void binaryAll(const AsyncWebSocketMessageBuffer* buffer) __attribute__((deprecated));  // frees buffer
 
     void message(uint32_t id, AsyncWebSocketMessage *message);