updated pywebsocket

1 files changed, 48 insertions, 16 deletions

diff --git a/module/lib/mod_pywebsocket/handshake/hybi.py b/module/lib/mod_pywebsocket/handshake/hybi.py
index 2883acbf8..fc0e2a096 100644
--- a/module/lib/mod_pywebsocket/handshake/hybi.py
+++ b/module/lib/mod_pywebsocket/handshake/hybi.py
@@ -182,34 +182,60 @@ class Handshaker(object):
 
             # Extra handshake handler may modify/remove processors.
             self._dispatcher.do_extra_handshake(self._request)
+            processors = filter(lambda processor: processor is not None,
+                                self._request.ws_extension_processors)
+
+            accepted_extensions = []
+
+            # We need to take care of mux extension here. Extensions that
+            # are placed before mux should be applied to logical channels.
+            mux_index = -1
+            for i, processor in enumerate(processors):
+                if processor.name() == common.MUX_EXTENSION:
+                    mux_index = i
+                    break
+            if mux_index >= 0:
+                mux_processor = processors[mux_index]
+                logical_channel_processors = processors[:mux_index]
+                processors = processors[mux_index+1:]
+
+                for processor in logical_channel_processors:
+                    extension_response = processor.get_extension_response()
+                    if extension_response is None:
+                        # Rejected.
+                        continue
+                    accepted_extensions.append(extension_response)
+                # Pass a shallow copy of accepted_extensions as extensions for
+                # logical channels.
+                mux_response = mux_processor.get_extension_response(
+                    self._request, accepted_extensions[:])
+                if mux_response is not None:
+                    accepted_extensions.append(mux_response)
 
             stream_options = StreamOptions()
 
-            self._request.ws_extensions = None
-            for processor in self._request.ws_extension_processors:
-                if processor is None:
-                    # Some processors may be removed by extra handshake
-                    # handler.
-                    continue
+            # When there is mux extension, here, |processors| contain only
+            # prosessors for extensions placed after mux.
+            for processor in processors:
 
                 extension_response = processor.get_extension_response()
                 if extension_response is None:
                     # Rejected.
                     continue
 
-                if self._request.ws_extensions is None:
-                    self._request.ws_extensions = []
-                self._request.ws_extensions.append(extension_response)
+                accepted_extensions.append(extension_response)
 
                 processor.setup_stream_options(stream_options)
 
-            if self._request.ws_extensions is not None:
+            if len(accepted_extensions) > 0:
+                self._request.ws_extensions = accepted_extensions
                 self._logger.debug(
                     'Extensions accepted: %r',
-                    map(common.ExtensionParameter.name,
-                        self._request.ws_extensions))
+                    map(common.ExtensionParameter.name, accepted_extensions))
+            else:
+                self._request.ws_extensions = None
 
-            self._request.ws_stream = Stream(self._request, stream_options)
+            self._request.ws_stream = self._create_stream(stream_options)
 
             if self._request.ws_requested_protocols is not None:
                 if self._request.ws_protocol is None:
@@ -268,7 +294,7 @@ class Handshaker(object):
         protocol_header = self._request.headers_in.get(
             common.SEC_WEBSOCKET_PROTOCOL_HEADER)
 
-        if not protocol_header:
+        if protocol_header is None:
             self._request.ws_requested_protocols = None
             return
 
@@ -341,7 +367,10 @@ class Handshaker(object):
 
         return key
 
-    def _send_handshake(self, accept):
+    def _create_stream(self, stream_options):
+        return Stream(self._request, stream_options)
+
+    def _create_handshake_response(self, accept):
         response = []
 
         response.append('HTTP/1.1 101 Switching Protocols\r\n')
@@ -363,7 +392,10 @@ class Handshaker(object):
                 common.format_extensions(self._request.ws_extensions)))
         response.append('\r\n')
 
-        raw_response = ''.join(response)
+        return ''.join(response)
+
+    def _send_handshake(self, accept):
+        raw_response = self._create_handshake_response(accept)
         self._request.connection.write(raw_response)
         self._logger.debug('Sent server\'s opening handshake: %r',
                            raw_response)