Fix frame spillover when not read quickly enough

When Frame.parser is given more data than expected, the next frame's header +
contents can end up as part of the payload, causing a UTF-8 validation error, or
ends up being thrown away. This can happen in the SSL case if we read slowly and
allow the socket's buffer to fill up a little.

This commit fixes that by amending WebSocket.once() to only provide bytes <=
reading_buffer_size to the stream parser and keeping the rest in a buffer,
giving the Frame a chance to stop receiving data at a frame boundary.

Fixes: #218

Author: hyperair

ws4py/websocket.py

@@ -387,25 +387,28 @@ def once(self):
             logger.debug("WebSocket is already terminated")
             return False
         try:
-            b = self.sock.recv(self.reading_buffer_size)
-            if self._is_secure:
-                b += self._get_from_pending()
-            if not b:
-                return False
-            self.buf += b
+            if not self.buf:
+                b = self.sock.recv(self.reading_buffer_size)
+                if self._is_secure:
+                    b += self._get_from_pending()
+                if not b:
+                    return False
+                self.buf += b
         except (socket.error, OSError, pyOpenSSLError) as e:
             if hasattr(e, "errno") and e.errno == errno.EINTR:
                 pass
             else:
                 self.unhandled_error(e)
                 return False
         else:
-            # process as much as we can
-            # the process will stop either if there is no buffer left
-            # or if the stream is closed
-            if not self.process(self.buf):
+            # handle spillover to prevent overfilling a frame
+            buf = self.buf[:self.reading_buffer_size]
+            remaining = self.buf[self.reading_buffer_size:]
+
+            if not self.process(buf):
                 return False
-            self.buf = b""
+
+            self.buf = remaining
 
         return True