fixing error when sending close and an error occurs

smasherprog · smasherprog · commit 7db8c7312a0e · 2017-07-30T15:21:49.000-07:00
diff --git a/include/internal/DataStructures.h b/include/internal/DataStructures.h
@@ -156,7 +156,7 @@ namespace SL {
                 if (SocketStatus_ == SocketStatus::CONNECTED) {//only send a close to an open socket
                     auto self(std::static_pointer_cast<WSocket<SOCKETTYPE, PARENTTYPE>>(shared_from_this()));
                     auto p(Parent);
-                    if (p) closeImpl(p, self, code, msg);
+                    if (p) sendclosemessage(p, self, code, msg);
                 }
             }
 
diff --git a/include/internal/WebSocketProtocol.h b/include/internal/WebSocketProtocol.h
@@ -32,7 +32,7 @@ namespace SL {
             else if (secs.count() > 0) {
                 socket->read_deadline.async_wait([parent, socket](const std::error_code& ec) {
                     if (ec != asio::error::operation_aborted) {
-                        return closeImpl(parent, socket, 1001, "read timer expired on the socket ");
+                        return sendclosemessage(parent, socket, 1001, "read timer expired on the socket ");
                     }
                 });
             }
@@ -54,7 +54,7 @@ namespace SL {
             else if (secs.count() > 0) {
                 socket->write_deadline.async_wait([parent, socket](const std::error_code& ec) {
                     if (ec != asio::error::operation_aborted) {
-                        return closeImpl(parent, socket, 1001, "write timer expired on the socket ");
+                        return sendclosemessage(parent, socket, 1001, "write timer expired on the socket ");
                     }
                 });
             }
@@ -86,7 +86,7 @@ namespace SL {
                     socket->SendMessageQueue.emplace_back(SendQueueItem{ msg, compressmessage });
                     if (socket->SendMessageQueue.size() == 1) {
                         SL::WS_LITE::startwrite(parent, socket);
-                    }  
+                    }
                     //update the socket status to reflect it is closing to prevent other messages from being sent.. this is the last valid message
                     //make sure to do this after a call to startwrite so the write process sends the close message, but no others
                     if (msg.code == OpCode::CLOSE) {
@@ -95,7 +95,7 @@ namespace SL {
                 }
             });
         }
-        template<class PARENTTYPE, class SOCKETTYPE>void closeImpl(const PARENTTYPE& parent, const SOCKETTYPE& socket, unsigned short code, const std::string& msg) {
+        template<class PARENTTYPE, class SOCKETTYPE>void sendclosemessage(const PARENTTYPE& parent, const SOCKETTYPE& socket, unsigned short code, const std::string& msg) {
             SL_WS_LITE_LOG(Logging_Levels::INFO_log_level, "closeImpl " << msg);
             WSMessage ws;
             ws.code = OpCode::CLOSE;
@@ -107,6 +107,9 @@ namespace SL {
             sendImpl(parent, socket, ws, false);
         }
 
+     
+
+
 
         template<class PARENTTYPE, class SOCKETTYPE, class SENDBUFFERTYPE>inline void handleclose(const PARENTTYPE& parent, const SOCKETTYPE& socket, const SENDBUFFERTYPE& msg) {
             SL_WS_LITE_LOG(Logging_Levels::INFO_log_level, "Closed: " << msg.code);
@@ -119,6 +122,16 @@ namespace SL {
             socket->Socket.lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec);
             ec.clear();
             socket->Socket.lowest_layer().close(ec);
+        }   
+        
+        template<class PARENTTYPE, class SOCKETTYPE, class SENDBUFFERTYPE>void closeImpl(const PARENTTYPE& parent, const SOCKETTYPE& socket, unsigned short code, const std::string& msg, const SENDBUFFERTYPE& networkmsg) {
+            if (networkmsg.code == OpCode::CLOSE) {
+                //failed when sending a close message... get out and notify
+                handleclose(parent, socket, networkmsg);
+            }
+            else {
+                sendclosemessage(parent, socket, code, msg);
+            }
         }
         template<class PARENTTYPE, class SOCKETTYPE, class SENDBUFFERTYPE>inline void write_end(const PARENTTYPE& parent, const SOCKETTYPE& socket, const SENDBUFFERTYPE& msg) {
 
@@ -129,7 +142,7 @@ namespace SL {
                 UNUSED(bytes_transferred);
                 if (ec)
                 {
-                    return closeImpl(parent, socket, 1002, "write header failed " + ec.message());
+                    return closeImpl(parent, socket, 1002, "write header failed " + ec.message(), msg);
                 }
                 assert(msg.len == bytes_transferred);
                 if (msg.code == OpCode::CLOSE) {
@@ -161,7 +174,7 @@ namespace SL {
                     handleclose(parent, socket, msg);
                 }
                 else {
-                    return closeImpl(parent, socket, 1002, "write mask failed " + ec.message());
+                    return closeImpl(parent, socket, 1002, "write mask failed " + ec.message(), msg);
                 }
             }
             else {
@@ -212,7 +225,7 @@ namespace SL {
                 writeend(parent, socket, msg);
             }
             else {
-                return closeImpl(parent, socket, 1002, "write header failed   " + ec.message());
+                return closeImpl(parent, socket, 1002, "write header failed   " + ec.message(), msg);
             }
 
         }
@@ -237,26 +250,26 @@ namespace SL {
             if (!getFin(socket->ReceiveHeader)) {
                 if (socket->LastOpCode == OpCode::INVALID) {
                     if (opcode != OpCode::BINARY && opcode != OpCode::TEXT) {
-                        return closeImpl(parent, socket, 1002, "First Non Fin Frame must be binary or text");
+                        return sendclosemessage(parent, socket, 1002, "First Non Fin Frame must be binary or text");
                     }
                     socket->LastOpCode = opcode;
                 }
                 else if (opcode != OpCode::CONTINUATION) {
-                    return closeImpl(parent, socket, 1002, "Continuation Received without a previous frame");
+                    return sendclosemessage(parent, socket, 1002, "Continuation Received without a previous frame");
                 }
                 ReadHeaderNext(parent, socket);
             }
             else {
 
                 if (socket->LastOpCode != OpCode::INVALID && opcode != OpCode::CONTINUATION) {
-                    return closeImpl(parent, socket, 1002, "Continuation Received without a previous frame");
+                    return sendclosemessage(parent, socket, 1002, "Continuation Received without a previous frame");
                 }
                 else if (socket->LastOpCode == OpCode::INVALID && opcode == OpCode::CONTINUATION) {
-                    return closeImpl(parent, socket, 1002, "Continuation Received without a previous frame");
+                    return sendclosemessage(parent, socket, 1002, "Continuation Received without a previous frame");
                 }
                 else if (socket->LastOpCode == OpCode::TEXT || opcode == OpCode::TEXT) {
                     if (!isValidUtf8(socket->ReceiveBuffer, socket->ReceiveBufferSize)) {
-                        return closeImpl(parent, socket, 1007, "Frame not valid utf8");
+                        return sendclosemessage(parent, socket, 1007, "Frame not valid utf8");
                     }
                 }
                 if (parent->onMessage) {
@@ -280,26 +293,26 @@ namespace SL {
                 auto closecode = hton(*reinterpret_cast<unsigned short*>(buffer.get()));
                 if (size > 2) {
                     if (!isValidUtf8(buffer.get() + sizeof(closecode), size - sizeof(closecode))) {
-                        return closeImpl(parent, socket, 1007, "Frame not valid utf8");
+                        return sendclosemessage(parent, socket, 1007, "Frame not valid utf8");
                     }
                 }
 
                 if (((closecode >= 1000 && closecode <= 1011) || (closecode >= 3000 && closecode <= 4999)) && closecode != 1004 && closecode != 1005 && closecode != 1006) {
-                    return closeImpl(parent, socket, 1000, "");
+                    return sendclosemessage(parent, socket, 1000, "");
                 }
                 else
                 {
-                    return closeImpl(parent, socket, 1002, "");
+                    return sendclosemessage(parent, socket, 1002, "");
                 }
             }
             else if (size != 0) {
-                return closeImpl(parent, socket, 1002, "");
+                return sendclosemessage(parent, socket, 1002, "");
             }
-            return closeImpl(parent, socket, 1000, "");
+            return sendclosemessage(parent, socket, 1000, "");
         }
         template <class PARENTTYPE, class SOCKETTYPE>inline void ProcessControlMessage(const PARENTTYPE& parent, const SOCKETTYPE& socket, const std::shared_ptr<unsigned char>& buffer, size_t size) {
             if (!getFin(socket->ReceiveHeader)) {
-                return closeImpl(parent, socket, 1002, "Closing connection. Control Frames must be Fin");
+                return sendclosemessage(parent, socket, 1002, "Closing connection. Control Frames must be Fin");
             }
             auto opcode = getOpCode(socket->ReceiveHeader);
 
@@ -321,19 +334,19 @@ namespace SL {
                 return ProcessClose(parent, socket, buffer, size);
 
             default:
-                return closeImpl(parent, socket, 1002, "Closing connection. nonvalid op code");
+                return sendclosemessage(parent, socket, 1002, "Closing connection. nonvalid op code");
             }
             ReadHeaderNext(parent, socket);
 
         }
         template <class PARENTTYPE, class SOCKETTYPE>inline void ReadBody(const PARENTTYPE& parent, const SOCKETTYPE& socket) {
 
             if (!DidPassMaskRequirement<PARENTTYPE>(socket->ReceiveHeader)) {//Close connection if it did not meet the mask requirement. 
-                return closeImpl(parent, socket, 1002, "Closing connection because mask requirement not met");
+                return sendclosemessage(parent, socket, 1002, "Closing connection because mask requirement not met");
             }
 
             if (getrsv2(socket->ReceiveHeader) || getrsv3(socket->ReceiveHeader) || (getrsv1(socket->ReceiveHeader) && !socket->CompressionEnabled)) {
-                return closeImpl(parent, socket, 1002, "Closing connection. rsv bit set");
+                return sendclosemessage(parent, socket, 1002, "Closing connection. rsv bit set");
             }
 
             auto opcode = getOpCode(socket->ReceiveHeader);
@@ -346,7 +359,7 @@ namespace SL {
             case 127:
                 size = static_cast<size_t>(ntoh(getpayloadLength8(socket->ReceiveHeader)));
                 if (size > std::numeric_limits<std::size_t>::max()) {
-                    return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");
+                    return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");
                 }
                 break;
             default:
@@ -356,23 +369,23 @@ namespace SL {
             size += AdditionalBodyBytesToRead<PARENTTYPE>();
             if (opcode == OpCode::PING || opcode == OpCode::PONG || opcode == OpCode::CLOSE) {
                 if (size - AdditionalBodyBytesToRead<PARENTTYPE>() > CONTROLBUFFERMAXSIZE) {
-                    return closeImpl(parent, socket, 1002, "Payload exceeded for control frames. Size requested " + std::to_string(size));
+                    return sendclosemessage(parent, socket, 1002, "Payload exceeded for control frames. Size requested " + std::to_string(size));
                 }
                 else if (size > 0) {
                     auto buffer = std::shared_ptr<unsigned char>(new unsigned char[size], [](auto p) { delete[] p; });
                     asio::async_read(socket->Socket, asio::buffer(buffer.get(), size), [parent, socket, buffer, size](const std::error_code& ec, size_t bytes_transferred) {
 
                         if (!ec || bytes_transferred != size) {
                             if (size != bytes_transferred) {
-                                return closeImpl(parent, socket, 1002, "Did not receive all bytes ... ");
+                                return sendclosemessage(parent, socket, 1002, "Did not receive all bytes ... ");
                             }
                             UnMaskMessage(parent, size, buffer.get());
 
                             auto tempsize = size - AdditionalBodyBytesToRead<PARENTTYPE>();
                             ProcessControlMessage(parent, socket, buffer, tempsize);
                         }
                         else {
-                            return closeImpl(parent, socket, 1002, "ReadBody Error " + ec.message());
+                            return sendclosemessage(parent, socket, 1002, "ReadBody Error " + ec.message());
                         }
                     });
                 }
@@ -386,37 +399,37 @@ namespace SL {
                 auto addedsize = socket->ReceiveBufferSize + size;
                 if (addedsize > std::numeric_limits<std::size_t>::max()) {
                     SL_WS_LITE_LOG(Logging_Levels::ERROR_log_level, "payload exceeds memory on system!!! ");
-                    return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");
+                    return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");
                 }
                 socket->ReceiveBufferSize = addedsize;
 
                 if (socket->ReceiveBufferSize > parent->MaxPayload) {
-                    return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");
+                    return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");
                 }
                 if (socket->ReceiveBufferSize > std::numeric_limits<std::size_t>::max()) {
                     SL_WS_LITE_LOG(Logging_Levels::ERROR_log_level, "payload exceeds memory on system!!! ");
-                    return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");
+                    return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");
                 }
 
                 if (size > 0) {
                     socket->ReceiveBuffer = static_cast<unsigned char*>(realloc(socket->ReceiveBuffer, socket->ReceiveBufferSize));
                     if (!socket->ReceiveBuffer) {
                         SL_WS_LITE_LOG(Logging_Levels::ERROR_log_level, "MEMORY ALLOCATION ERROR!!! Tried to realloc " << socket->ReceiveBufferSize);
-                        return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");
+                        return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");
                     }
                     asio::async_read(socket->Socket, asio::buffer(socket->ReceiveBuffer + socket->ReceiveBufferSize - size, size), [parent, socket, size](const std::error_code& ec, size_t bytes_transferred) {
 
                         if (!ec || bytes_transferred != size) {
                             if (size != bytes_transferred) {
-                                return closeImpl(parent, socket, 1002, "Did not receive all bytes ... ");
+                                return sendclosemessage(parent, socket, 1002, "Did not receive all bytes ... ");
                             }
                             auto buffer = socket->ReceiveBuffer + socket->ReceiveBufferSize - size;
                             UnMaskMessage(parent, size, buffer);
                             socket->ReceiveBufferSize -= AdditionalBodyBytesToRead<PARENTTYPE>();
                             ProcessMessage(parent, socket);
                         }
                         else {
-                            return closeImpl(parent, socket, 1002, "ReadBody Error " + ec.message());
+                            return sendclosemessage(parent, socket, 1002, "ReadBody Error " + ec.message());
                         }
                     });
                 }
@@ -425,7 +438,7 @@ namespace SL {
                 }
             }
             else {
-                return closeImpl(parent, socket, 1002, "Closing connection. nonvalid op code");
+                return sendclosemessage(parent, socket, 1002, "Closing connection. nonvalid op code");
             }
 
         }
@@ -460,7 +473,7 @@ namespace SL {
                                 ReadBody(parent, socket);
                             }
                             else {
-                                return closeImpl(parent, socket, 1002, "readheader ExtendedPayloadlen " + ec.message());
+                                return sendclosemessage(parent, socket, 1002, "readheader ExtendedPayloadlen " + ec.message());
                             }
                         });
                     }
@@ -470,7 +483,7 @@ namespace SL {
 
                 }
                 else {
-                    return closeImpl(parent, socket, 1002, "WebSocket ReadHeader failed " + ec.message());
+                    return sendclosemessage(parent, socket, 1002, "WebSocket ReadHeader failed " + ec.message());
                 }
             });
         }
diff --git a/src/internal/ClientImpl.cpp b/src/internal/ClientImpl.cpp
@@ -72,10 +72,7 @@ namespace SL {
                                 socket->SocketStatus_ = SocketStatus::CONNECTED;
                                 if (self->onConnection) {
                                     self->onConnection(socket, header);
-                                }/*
-                                if (read_buffer->size() > bytes_transferred) {
-                                    SL_WS_LITE_LOG(Logging_Levels::INFO_log_level, "Read Extra Data " << read_buffer->size() - bytes_transferred);
-                                }*/
+                                }
                                 ReadHeaderStart(self, socket);
                             }
                             else {

Original file line number	Diff line number	Diff line change
`@@ -156,7 +156,7 @@ namespace SL {`
`156`	`156`	`if (SocketStatus_ == SocketStatus::CONNECTED) {//only send a close to an open socket`
`157`	`157`	`auto self(std::static_pointer_cast<WSocket<SOCKETTYPE, PARENTTYPE>>(shared_from_this()));`
`158`	`158`	`auto p(Parent);`
`159`		`- if (p) closeImpl(p, self, code, msg);`
	`159`	`+ if (p) sendclosemessage(p, self, code, msg);`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ namespace SL {`
`32`	`32`	`else if (secs.count() > 0) {`
`33`	`33`	`socket->read_deadline.async_wait([parent, socket](const std::error_code& ec) {`
`34`	`34`	`if (ec != asio::error::operation_aborted) {`
`35`		`- return closeImpl(parent, socket, 1001, "read timer expired on the socket ");`
	`35`	`+ return sendclosemessage(parent, socket, 1001, "read timer expired on the socket ");`
`36`	`36`	`}`
`37`	`37`	`});`
`38`	`38`	`}`
`@@ -54,7 +54,7 @@ namespace SL {`
`54`	`54`	`else if (secs.count() > 0) {`
`55`	`55`	`socket->write_deadline.async_wait([parent, socket](const std::error_code& ec) {`
`56`	`56`	`if (ec != asio::error::operation_aborted) {`
`57`		`- return closeImpl(parent, socket, 1001, "write timer expired on the socket ");`
	`57`	`+ return sendclosemessage(parent, socket, 1001, "write timer expired on the socket ");`
`58`	`58`	`}`
`59`	`59`	`});`
`60`	`60`	`}`
`@@ -86,7 +86,7 @@ namespace SL {`
`86`	`86`	`socket->SendMessageQueue.emplace_back(SendQueueItem{ msg, compressmessage });`
`87`	`87`	`if (socket->SendMessageQueue.size() == 1) {`
`88`	`88`	`SL::WS_LITE::startwrite(parent, socket);`
`89`		`- }`
	`89`	`+ }`
`90`	`90`	`//update the socket status to reflect it is closing to prevent other messages from being sent.. this is the last valid message`
`91`	`91`	`//make sure to do this after a call to startwrite so the write process sends the close message, but no others`
`92`	`92`	`if (msg.code == OpCode::CLOSE) {`
`@@ -95,7 +95,7 @@ namespace SL {`
`95`	`95`	`}`
`96`	`96`	`});`
`97`	`97`	`}`
`98`		`- template<class PARENTTYPE, class SOCKETTYPE>void closeImpl(const PARENTTYPE& parent, const SOCKETTYPE& socket, unsigned short code, const std::string& msg) {`
	`98`	`+ template<class PARENTTYPE, class SOCKETTYPE>void sendclosemessage(const PARENTTYPE& parent, const SOCKETTYPE& socket, unsigned short code, const std::string& msg) {`
`99`	`99`	`SL_WS_LITE_LOG(Logging_Levels::INFO_log_level, "closeImpl " << msg);`
`100`	`100`	`WSMessage ws;`
`101`	`101`	`ws.code = OpCode::CLOSE;`
`@@ -107,6 +107,9 @@ namespace SL {`
`107`	`107`	`sendImpl(parent, socket, ws, false);`
`108`	`108`	`}`
`109`	`109`
	`110`	`+`
	`111`	`+`
	`112`	`+`
`110`	`113`
`111`	`114`	`template<class PARENTTYPE, class SOCKETTYPE, class SENDBUFFERTYPE>inline void handleclose(const PARENTTYPE& parent, const SOCKETTYPE& socket, const SENDBUFFERTYPE& msg) {`
`112`	`115`	`SL_WS_LITE_LOG(Logging_Levels::INFO_log_level, "Closed: " << msg.code);`
`@@ -119,6 +122,16 @@ namespace SL {`
`119`	`122`	`socket->Socket.lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec);`
`120`	`123`	`ec.clear();`
`121`	`124`	`socket->Socket.lowest_layer().close(ec);`
	`125`	`+ }`
	`126`	`+`
	`127`	`+ template<class PARENTTYPE, class SOCKETTYPE, class SENDBUFFERTYPE>void closeImpl(const PARENTTYPE& parent, const SOCKETTYPE& socket, unsigned short code, const std::string& msg, const SENDBUFFERTYPE& networkmsg) {`
	`128`	`+ if (networkmsg.code == OpCode::CLOSE) {`
	`129`	`+ //failed when sending a close message... get out and notify`
	`130`	`+ handleclose(parent, socket, networkmsg);`
	`131`	`+ }`
	`132`	`+ else {`
	`133`	`+ sendclosemessage(parent, socket, code, msg);`
	`134`	`+ }`
`122`	`135`	`}`
`123`	`136`	`template<class PARENTTYPE, class SOCKETTYPE, class SENDBUFFERTYPE>inline void write_end(const PARENTTYPE& parent, const SOCKETTYPE& socket, const SENDBUFFERTYPE& msg) {`
`124`	`137`
`@@ -129,7 +142,7 @@ namespace SL {`
`129`	`142`	`UNUSED(bytes_transferred);`
`130`	`143`	`if (ec)`
`131`	`144`	`{`
`132`		`- return closeImpl(parent, socket, 1002, "write header failed " + ec.message());`
	`145`	`+ return closeImpl(parent, socket, 1002, "write header failed " + ec.message(), msg);`
`133`	`146`	`}`
`134`	`147`	`assert(msg.len == bytes_transferred);`
`135`	`148`	`if (msg.code == OpCode::CLOSE) {`
`@@ -161,7 +174,7 @@ namespace SL {`
`161`	`174`	`handleclose(parent, socket, msg);`
`162`	`175`	`}`
`163`	`176`	`else {`
`164`		`- return closeImpl(parent, socket, 1002, "write mask failed " + ec.message());`
	`177`	`+ return closeImpl(parent, socket, 1002, "write mask failed " + ec.message(), msg);`
`165`	`178`	`}`
`166`	`179`	`}`
`167`	`180`	`else {`
`@@ -212,7 +225,7 @@ namespace SL {`
`212`	`225`	`writeend(parent, socket, msg);`
`213`	`226`	`}`
`214`	`227`	`else {`
`215`		`- return closeImpl(parent, socket, 1002, "write header failed " + ec.message());`
	`228`	`+ return closeImpl(parent, socket, 1002, "write header failed " + ec.message(), msg);`
`216`	`229`	`}`
`217`	`230`
`218`	`231`	`}`
`@@ -237,26 +250,26 @@ namespace SL {`
`237`	`250`	`if (!getFin(socket->ReceiveHeader)) {`
`238`	`251`	`if (socket->LastOpCode == OpCode::INVALID) {`
`239`	`252`	`if (opcode != OpCode::BINARY && opcode != OpCode::TEXT) {`
`240`		`- return closeImpl(parent, socket, 1002, "First Non Fin Frame must be binary or text");`
	`253`	`+ return sendclosemessage(parent, socket, 1002, "First Non Fin Frame must be binary or text");`
`241`	`254`	`}`
`242`	`255`	`socket->LastOpCode = opcode;`
`243`	`256`	`}`
`244`	`257`	`else if (opcode != OpCode::CONTINUATION) {`
`245`		`- return closeImpl(parent, socket, 1002, "Continuation Received without a previous frame");`
	`258`	`+ return sendclosemessage(parent, socket, 1002, "Continuation Received without a previous frame");`
`246`	`259`	`}`
`247`	`260`	`ReadHeaderNext(parent, socket);`
`248`	`261`	`}`
`249`	`262`	`else {`
`250`	`263`
`251`	`264`	`if (socket->LastOpCode != OpCode::INVALID && opcode != OpCode::CONTINUATION) {`
`252`		`- return closeImpl(parent, socket, 1002, "Continuation Received without a previous frame");`
	`265`	`+ return sendclosemessage(parent, socket, 1002, "Continuation Received without a previous frame");`
`253`	`266`	`}`
`254`	`267`	`else if (socket->LastOpCode == OpCode::INVALID && opcode == OpCode::CONTINUATION) {`
`255`		`- return closeImpl(parent, socket, 1002, "Continuation Received without a previous frame");`
	`268`	`+ return sendclosemessage(parent, socket, 1002, "Continuation Received without a previous frame");`
`256`	`269`	`}`
`257`	`270`	`else if (socket->LastOpCode == OpCode::TEXT \|\| opcode == OpCode::TEXT) {`
`258`	`271`	`if (!isValidUtf8(socket->ReceiveBuffer, socket->ReceiveBufferSize)) {`
`259`		`- return closeImpl(parent, socket, 1007, "Frame not valid utf8");`
	`272`	`+ return sendclosemessage(parent, socket, 1007, "Frame not valid utf8");`
`260`	`273`	`}`
`261`	`274`	`}`
`262`	`275`	`if (parent->onMessage) {`
`@@ -280,26 +293,26 @@ namespace SL {`
`280`	`293`	`auto closecode = hton(reinterpret_cast<unsigned short>(buffer.get()));`
`281`	`294`	`if (size > 2) {`
`282`	`295`	`if (!isValidUtf8(buffer.get() + sizeof(closecode), size - sizeof(closecode))) {`
`283`		`- return closeImpl(parent, socket, 1007, "Frame not valid utf8");`
	`296`	`+ return sendclosemessage(parent, socket, 1007, "Frame not valid utf8");`
`284`	`297`	`}`
`285`	`298`	`}`
`286`	`299`
`287`	`300`	`if (((closecode >= 1000 && closecode <= 1011) \|\| (closecode >= 3000 && closecode <= 4999)) && closecode != 1004 && closecode != 1005 && closecode != 1006) {`
`288`		`- return closeImpl(parent, socket, 1000, "");`
	`301`	`+ return sendclosemessage(parent, socket, 1000, "");`
`289`	`302`	`}`
`290`	`303`	`else`
`291`	`304`	`{`
`292`		`- return closeImpl(parent, socket, 1002, "");`
	`305`	`+ return sendclosemessage(parent, socket, 1002, "");`
`293`	`306`	`}`
`294`	`307`	`}`
`295`	`308`	`else if (size != 0) {`
`296`		`- return closeImpl(parent, socket, 1002, "");`
	`309`	`+ return sendclosemessage(parent, socket, 1002, "");`
`297`	`310`	`}`
`298`		`- return closeImpl(parent, socket, 1000, "");`
	`311`	`+ return sendclosemessage(parent, socket, 1000, "");`
`299`	`312`	`}`
`300`	`313`	`template <class PARENTTYPE, class SOCKETTYPE>inline void ProcessControlMessage(const PARENTTYPE& parent, const SOCKETTYPE& socket, const std::shared_ptr<unsigned char>& buffer, size_t size) {`
`301`	`314`	`if (!getFin(socket->ReceiveHeader)) {`
`302`		`- return closeImpl(parent, socket, 1002, "Closing connection. Control Frames must be Fin");`
	`315`	`+ return sendclosemessage(parent, socket, 1002, "Closing connection. Control Frames must be Fin");`
`303`	`316`	`}`
`304`	`317`	`auto opcode = getOpCode(socket->ReceiveHeader);`
`305`	`318`
`@@ -321,19 +334,19 @@ namespace SL {`
`321`	`334`	`return ProcessClose(parent, socket, buffer, size);`
`322`	`335`
`323`	`336`	`default:`
`324`		`- return closeImpl(parent, socket, 1002, "Closing connection. nonvalid op code");`
	`337`	`+ return sendclosemessage(parent, socket, 1002, "Closing connection. nonvalid op code");`
`325`	`338`	`}`
`326`	`339`	`ReadHeaderNext(parent, socket);`
`327`	`340`
`328`	`341`	`}`
`329`	`342`	`template <class PARENTTYPE, class SOCKETTYPE>inline void ReadBody(const PARENTTYPE& parent, const SOCKETTYPE& socket) {`
`330`	`343`
`331`	`344`	`if (!DidPassMaskRequirement<PARENTTYPE>(socket->ReceiveHeader)) {//Close connection if it did not meet the mask requirement.`
`332`		`- return closeImpl(parent, socket, 1002, "Closing connection because mask requirement not met");`
	`345`	`+ return sendclosemessage(parent, socket, 1002, "Closing connection because mask requirement not met");`
`333`	`346`	`}`
`334`	`347`
`335`	`348`	`if (getrsv2(socket->ReceiveHeader) \|\| getrsv3(socket->ReceiveHeader) \|\| (getrsv1(socket->ReceiveHeader) && !socket->CompressionEnabled)) {`
`336`		`- return closeImpl(parent, socket, 1002, "Closing connection. rsv bit set");`
	`349`	`+ return sendclosemessage(parent, socket, 1002, "Closing connection. rsv bit set");`
`337`	`350`	`}`
`338`	`351`
`339`	`352`	`auto opcode = getOpCode(socket->ReceiveHeader);`
`@@ -346,7 +359,7 @@ namespace SL {`
`346`	`359`	`case 127:`
`347`	`360`	`size = static_cast<size_t>(ntoh(getpayloadLength8(socket->ReceiveHeader)));`
`348`	`361`	`if (size > std::numeric_limits<std::size_t>::max()) {`
`349`		`- return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");`
	`362`	`+ return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");`
`350`	`363`	`}`
`351`	`364`	`break;`
`352`	`365`	`default:`
`@@ -356,23 +369,23 @@ namespace SL {`
`356`	`369`	`size += AdditionalBodyBytesToRead<PARENTTYPE>();`
`357`	`370`	`if (opcode == OpCode::PING \|\| opcode == OpCode::PONG \|\| opcode == OpCode::CLOSE) {`
`358`	`371`	`if (size - AdditionalBodyBytesToRead<PARENTTYPE>() > CONTROLBUFFERMAXSIZE) {`
`359`		`- return closeImpl(parent, socket, 1002, "Payload exceeded for control frames. Size requested " + std::to_string(size));`
	`372`	`+ return sendclosemessage(parent, socket, 1002, "Payload exceeded for control frames. Size requested " + std::to_string(size));`
`360`	`373`	`}`
`361`	`374`	`else if (size > 0) {`
`362`	`375`	`auto buffer = std::shared_ptr<unsigned char>(new unsigned char[size], [](auto p) { delete[] p; });`
`363`	`376`	`asio::async_read(socket->Socket, asio::buffer(buffer.get(), size), [parent, socket, buffer, size](const std::error_code& ec, size_t bytes_transferred) {`
`364`	`377`
`365`	`378`	`if (!ec \|\| bytes_transferred != size) {`
`366`	`379`	`if (size != bytes_transferred) {`
`367`		`- return closeImpl(parent, socket, 1002, "Did not receive all bytes ... ");`
	`380`	`+ return sendclosemessage(parent, socket, 1002, "Did not receive all bytes ... ");`
`368`	`381`	`}`
`369`	`382`	`UnMaskMessage(parent, size, buffer.get());`
`370`	`383`
`371`	`384`	`auto tempsize = size - AdditionalBodyBytesToRead<PARENTTYPE>();`
`372`	`385`	`ProcessControlMessage(parent, socket, buffer, tempsize);`
`373`	`386`	`}`
`374`	`387`	`else {`
`375`		`- return closeImpl(parent, socket, 1002, "ReadBody Error " + ec.message());`
	`388`	`+ return sendclosemessage(parent, socket, 1002, "ReadBody Error " + ec.message());`
`376`	`389`	`}`
`377`	`390`	`});`
`378`	`391`	`}`
`@@ -386,37 +399,37 @@ namespace SL {`
`386`	`399`	`auto addedsize = socket->ReceiveBufferSize + size;`
`387`	`400`	`if (addedsize > std::numeric_limits<std::size_t>::max()) {`
`388`	`401`	`SL_WS_LITE_LOG(Logging_Levels::ERROR_log_level, "payload exceeds memory on system!!! ");`
`389`		`- return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");`
	`402`	`+ return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");`
`390`	`403`	`}`
`391`	`404`	`socket->ReceiveBufferSize = addedsize;`
`392`	`405`
`393`	`406`	`if (socket->ReceiveBufferSize > parent->MaxPayload) {`
`394`		`- return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");`
	`407`	`+ return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");`
`395`	`408`	`}`
`396`	`409`	`if (socket->ReceiveBufferSize > std::numeric_limits<std::size_t>::max()) {`
`397`	`410`	`SL_WS_LITE_LOG(Logging_Levels::ERROR_log_level, "payload exceeds memory on system!!! ");`
`398`		`- return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");`
	`411`	`+ return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");`
`399`	`412`	`}`
`400`	`413`
`401`	`414`	`if (size > 0) {`
`402`	`415`	`socket->ReceiveBuffer = static_cast<unsigned char*>(realloc(socket->ReceiveBuffer, socket->ReceiveBufferSize));`
`403`	`416`	`if (!socket->ReceiveBuffer) {`
`404`	`417`	`SL_WS_LITE_LOG(Logging_Levels::ERROR_log_level, "MEMORY ALLOCATION ERROR!!! Tried to realloc " << socket->ReceiveBufferSize);`
`405`		`- return closeImpl(parent, socket, 1009, "Payload exceeded MaxPayload size");`
	`418`	`+ return sendclosemessage(parent, socket, 1009, "Payload exceeded MaxPayload size");`
`406`	`419`	`}`
`407`	`420`	`asio::async_read(socket->Socket, asio::buffer(socket->ReceiveBuffer + socket->ReceiveBufferSize - size, size), [parent, socket, size](const std::error_code& ec, size_t bytes_transferred) {`
`408`	`421`
`409`	`422`	`if (!ec \|\| bytes_transferred != size) {`
`410`	`423`	`if (size != bytes_transferred) {`
`411`		`- return closeImpl(parent, socket, 1002, "Did not receive all bytes ... ");`
	`424`	`+ return sendclosemessage(parent, socket, 1002, "Did not receive all bytes ... ");`
`412`	`425`	`}`
`413`	`426`	`auto buffer = socket->ReceiveBuffer + socket->ReceiveBufferSize - size;`
`414`	`427`	`UnMaskMessage(parent, size, buffer);`
`415`	`428`	`socket->ReceiveBufferSize -= AdditionalBodyBytesToRead<PARENTTYPE>();`
`416`	`429`	`ProcessMessage(parent, socket);`
`417`	`430`	`}`
`418`	`431`	`else {`
`419`		`- return closeImpl(parent, socket, 1002, "ReadBody Error " + ec.message());`
	`432`	`+ return sendclosemessage(parent, socket, 1002, "ReadBody Error " + ec.message());`
`420`	`433`	`}`
`421`	`434`	`});`
`422`	`435`	`}`
`@@ -425,7 +438,7 @@ namespace SL {`
`425`	`438`	`}`
`426`	`439`	`}`
`427`	`440`	`else {`
`428`		`- return closeImpl(parent, socket, 1002, "Closing connection. nonvalid op code");`
	`441`	`+ return sendclosemessage(parent, socket, 1002, "Closing connection. nonvalid op code");`
`429`	`442`	`}`
`430`	`443`
`431`	`444`	`}`
`@@ -460,7 +473,7 @@ namespace SL {`
`460`	`473`	`ReadBody(parent, socket);`
`461`	`474`	`}`
`462`	`475`	`else {`
`463`		`- return closeImpl(parent, socket, 1002, "readheader ExtendedPayloadlen " + ec.message());`
	`476`	`+ return sendclosemessage(parent, socket, 1002, "readheader ExtendedPayloadlen " + ec.message());`
`464`	`477`	`}`
`465`	`478`	`});`
`466`	`479`	`}`
`@@ -470,7 +483,7 @@ namespace SL {`
`470`	`483`
`471`	`484`	`}`
`472`	`485`	`else {`
`473`		`- return closeImpl(parent, socket, 1002, "WebSocket ReadHeader failed " + ec.message());`
	`486`	`+ return sendclosemessage(parent, socket, 1002, "WebSocket ReadHeader failed " + ec.message());`
`474`	`487`	`}`
`475`	`488`	`});`
`476`	`489`	`}`