casa-mp-base

From 106948d996d74bf5ff7e3511f35eefea0a90561f Mon Sep 17 00:00:00 2001

From: rpigott <rpigott@berkeley.edu>

Date: Sun, 27 Jan 2019 00:59:26 -0800

Subject: [PATCH 1/4] update to wsproto 0.13

​

---

 mitmproxy/proxy/protocol/websocket.py | 87 +++++++++++++--------------

 setup.py                              |  2 +-

 2 files changed, 44 insertions(+), 45 deletions(-)

​

diff --git mitmproxy/proxy/protocol/websocket.py mitmproxy/proxy/protocol/websocket.py

index 0d1964a60..591bae7e0 100644

--- mitmproxy/proxy/protocol/websocket.py

+++ mitmproxy/proxy/protocol/websocket.py

@@ -4,8 +4,9 @@

 import wsproto

-from wsproto import events

-from wsproto.connection import ConnectionType, WSConnection

+from wsproto import events, WSConnection

+from wsproto.connection import ConnectionType

+from wsproto.events import AcceptConnection, CloseConnection, Message, Ping, Request

 from wsproto.extensions import PerMessageDeflate

 from mitmproxy import exceptions

@@ -56,47 +57,44 @@ def __init__(self, ctx, handshake_flow):

         if 'Sec-WebSocket-Extensions' in handshake_flow.response.headers:

             if PerMessageDeflate.name in handshake_flow.response.headers['Sec-WebSocket-Extensions']:

                 extensions = [PerMessageDeflate()]

-        self.connections[self.client_conn] = WSConnection(ConnectionType.SERVER,

-                                                          extensions=extensions)

-        self.connections[self.server_conn] = WSConnection(ConnectionType.CLIENT,

-                                                          host=handshake_flow.request.host,

-                                                          resource=handshake_flow.request.path,

-                                                          extensions=extensions)

+        self.connections[self.client_conn] = WSConnection(ConnectionType.SERVER)

+        self.connections[self.server_conn] = WSConnection(ConnectionType.CLIENT)

+

         if extensions:

-            for conn in self.connections.values():

-                conn.extensions[0].finalize(conn, handshake_flow.response.headers['Sec-WebSocket-Extensions'])

+            extensions[0].finalize(handshake_flow.response.headers['Sec-WebSocket-Extensions'])

-        data = self.connections[self.server_conn].bytes_to_send()

-        self.connections[self.client_conn].receive_bytes(data)

+        request = Request(extensions = extensions, host = handshake_flow.request.host, target = handshake_flow.request.path)

+        data = self.connections[self.server_conn].send(request)

+        self.connections[self.client_conn].receive_data(data)

         event = next(self.connections[self.client_conn].events())

-        assert isinstance(event, events.ConnectionRequested)

+        assert isinstance(event, events.Request)

-        self.connections[self.client_conn].accept(event)

-        self.connections[self.server_conn].receive_bytes(self.connections[self.client_conn].bytes_to_send())

-        assert isinstance(next(self.connections[self.server_conn].events()), events.ConnectionEstablished)

+        data = self.connections[self.client_conn].send(AcceptConnection(extensions=extensions))

+        self.connections[self.server_conn].receive_data(data)

+        assert isinstance(next(self.connections[self.server_conn].events()), events.AcceptConnection)

     def _handle_event(self, event, source_conn, other_conn, is_server):

-        if isinstance(event, events.DataReceived):

-            return self._handle_data_received(event, source_conn, other_conn, is_server)

-        elif isinstance(event, events.PingReceived):

-            return self._handle_ping_received(event, source_conn, other_conn, is_server)

-        elif isinstance(event, events.PongReceived):

-            return self._handle_pong_received(event, source_conn, other_conn, is_server)

-        elif isinstance(event, events.ConnectionClosed):

-            return self._handle_connection_closed(event, source_conn, other_conn, is_server)

+        if isinstance(event, events.Message):

+            return self._handle_message(event, source_conn, other_conn, is_server)

+        elif isinstance(event, events.Ping):

+            return self._handle_ping(event, source_conn, other_conn, is_server)

+        elif isinstance(event, events.Pong):

+            return self._handle_pong(event, source_conn, other_conn, is_server)

+        elif isinstance(event, events.CloseConnection):

+            return self._handle_close_connection(event, source_conn, other_conn, is_server)

         # fail-safe for unhandled events

         return True  # pragma: no cover

-    def _handle_data_received(self, event, source_conn, other_conn, is_server):

+    def _handle_message(self, event, source_conn, other_conn, is_server):

         fb = self.server_frame_buffer if is_server else self.client_frame_buffer

         fb.append(event.data)

         if event.message_finished:

             original_chunk_sizes = [len(f) for f in fb]

-            if isinstance(event, events.TextReceived):