mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
266 lines
9.1 KiB
Python
266 lines
9.1 KiB
Python
# Copyright 2011, Google Inc.
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above
|
|
# copyright notice, this list of conditions and the following disclaimer
|
|
# in the documentation and/or other materials provided with the
|
|
# distribution.
|
|
# * Neither the name of Google Inc. nor the names of its
|
|
# contributors may be used to endorse or promote products derived from
|
|
# this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
from mod_pywebsocket import common
|
|
from mod_pywebsocket import util
|
|
|
|
|
|
_available_processors = {}
|
|
|
|
|
|
class ExtensionProcessorInterface(object):
|
|
|
|
def get_extension_response(self):
|
|
return None
|
|
|
|
def setup_stream_options(self, stream_options):
|
|
pass
|
|
|
|
|
|
class DeflateStreamExtensionProcessor(ExtensionProcessorInterface):
|
|
"""WebSocket DEFLATE stream extension processor."""
|
|
|
|
def __init__(self, request):
|
|
self._logger = util.get_class_logger(self)
|
|
|
|
self._request = request
|
|
|
|
def get_extension_response(self):
|
|
if len(self._request.get_parameter_names()) != 0:
|
|
return None
|
|
|
|
self._logger.debug(
|
|
'Enable %s extension', common.DEFLATE_STREAM_EXTENSION)
|
|
|
|
return common.ExtensionParameter(common.DEFLATE_STREAM_EXTENSION)
|
|
|
|
def setup_stream_options(self, stream_options):
|
|
stream_options.deflate_stream = True
|
|
|
|
|
|
_available_processors[common.DEFLATE_STREAM_EXTENSION] = (
|
|
DeflateStreamExtensionProcessor)
|
|
|
|
|
|
class DeflateFrameExtensionProcessor(ExtensionProcessorInterface):
|
|
"""WebSocket Per-frame DEFLATE extension processor."""
|
|
|
|
_WINDOW_BITS_PARAM = 'max_window_bits'
|
|
_NO_CONTEXT_TAKEOVER_PARAM = 'no_context_takeover'
|
|
|
|
def __init__(self, request):
|
|
self._logger = util.get_class_logger(self)
|
|
|
|
self._request = request
|
|
|
|
self._response_window_bits = None
|
|
self._response_no_context_takeover = False
|
|
|
|
# Counters for statistics.
|
|
|
|
# Total number of outgoing bytes supplied to this filter.
|
|
self._total_outgoing_payload_bytes = 0
|
|
# Total number of bytes sent to the network after applying this filter.
|
|
self._total_filtered_outgoing_payload_bytes = 0
|
|
|
|
# Total number of bytes received from the network.
|
|
self._total_incoming_payload_bytes = 0
|
|
# Total number of incoming bytes obtained after applying this filter.
|
|
self._total_filtered_incoming_payload_bytes = 0
|
|
|
|
def get_extension_response(self):
|
|
# Any unknown parameter will be just ignored.
|
|
|
|
window_bits = self._request.get_parameter_value(
|
|
self._WINDOW_BITS_PARAM)
|
|
no_context_takeover = self._request.has_parameter(
|
|
self._NO_CONTEXT_TAKEOVER_PARAM)
|
|
if (no_context_takeover and
|
|
self._request.get_parameter_value(
|
|
self._NO_CONTEXT_TAKEOVER_PARAM) is not None):
|
|
return None
|
|
|
|
if window_bits is not None:
|
|
try:
|
|
window_bits = int(window_bits)
|
|
except ValueError, e:
|
|
return None
|
|
if window_bits < 8 or window_bits > 15:
|
|
return None
|
|
|
|
self._deflater = util._RFC1979Deflater(
|
|
window_bits, no_context_takeover)
|
|
|
|
self._inflater = util._RFC1979Inflater()
|
|
|
|
self._compress_outgoing = True
|
|
|
|
response = common.ExtensionParameter(self._request.name())
|
|
|
|
if self._response_window_bits is not None:
|
|
response.add_parameter(
|
|
self._WINDOW_BITS_PARAM, str(self._response_window_bits))
|
|
if self._response_no_context_takeover:
|
|
response.add_parameter(
|
|
self._NO_CONTEXT_TAKEOVER_PARAM, None)
|
|
|
|
self._logger.debug(
|
|
'Enable %s extension ('
|
|
'request: window_bits=%s; no_context_takeover=%r, '
|
|
'response: window_wbits=%s; no_context_takeover=%r)' %
|
|
(self._request.name(),
|
|
window_bits,
|
|
no_context_takeover,
|
|
self._response_window_bits,
|
|
self._response_no_context_takeover))
|
|
|
|
return response
|
|
|
|
def setup_stream_options(self, stream_options):
|
|
|
|
class _OutgoingFilter(object):
|
|
|
|
def __init__(self, parent):
|
|
self._parent = parent
|
|
|
|
def filter(self, frame):
|
|
self._parent._outgoing_filter(frame)
|
|
|
|
class _IncomingFilter(object):
|
|
|
|
def __init__(self, parent):
|
|
self._parent = parent
|
|
|
|
def filter(self, frame):
|
|
self._parent._incoming_filter(frame)
|
|
|
|
stream_options.outgoing_frame_filters.append(
|
|
_OutgoingFilter(self))
|
|
stream_options.incoming_frame_filters.insert(
|
|
0, _IncomingFilter(self))
|
|
|
|
def set_response_window_bits(self, value):
|
|
self._response_window_bits = value
|
|
|
|
def set_response_no_context_takeover(self, value):
|
|
self._response_no_context_takeover = value
|
|
|
|
def enable_outgoing_compression(self):
|
|
self._compress_outgoing = True
|
|
|
|
def disable_outgoing_compression(self):
|
|
self._compress_outgoing = False
|
|
|
|
def _outgoing_filter(self, frame):
|
|
"""Transform outgoing frames. This method is called only by
|
|
an _OutgoingFilter instance.
|
|
"""
|
|
|
|
original_payload_size = len(frame.payload)
|
|
self._total_outgoing_payload_bytes += original_payload_size
|
|
|
|
if (not self._compress_outgoing or
|
|
common.is_control_opcode(frame.opcode)):
|
|
self._total_filtered_outgoing_payload_bytes += (
|
|
original_payload_size)
|
|
return
|
|
|
|
frame.payload = self._deflater.filter(frame.payload)
|
|
frame.rsv1 = 1
|
|
|
|
filtered_payload_size = len(frame.payload)
|
|
self._total_filtered_outgoing_payload_bytes += filtered_payload_size
|
|
|
|
# Print inf when ratio is not available.
|
|
ratio = float('inf')
|
|
average_ratio = float('inf')
|
|
if original_payload_size != 0:
|
|
ratio = float(filtered_payload_size) / original_payload_size
|
|
if self._total_outgoing_payload_bytes != 0:
|
|
average_ratio = (
|
|
float(self._total_filtered_outgoing_payload_bytes) /
|
|
self._total_outgoing_payload_bytes)
|
|
self._logger.debug(
|
|
'Outgoing compress ratio: %f (average: %f)' %
|
|
(ratio, average_ratio))
|
|
|
|
def _incoming_filter(self, frame):
|
|
"""Transform incoming frames. This method is called only by
|
|
an _IncomingFilter instance.
|
|
"""
|
|
|
|
received_payload_size = len(frame.payload)
|
|
self._total_incoming_payload_bytes += received_payload_size
|
|
|
|
if frame.rsv1 != 1 or common.is_control_opcode(frame.opcode):
|
|
self._total_filtered_incoming_payload_bytes += (
|
|
received_payload_size)
|
|
return
|
|
|
|
frame.payload = self._inflater.filter(frame.payload)
|
|
frame.rsv1 = 0
|
|
|
|
filtered_payload_size = len(frame.payload)
|
|
self._total_filtered_incoming_payload_bytes += filtered_payload_size
|
|
|
|
# Print inf when ratio is not available.
|
|
ratio = float('inf')
|
|
average_ratio = float('inf')
|
|
if received_payload_size != 0:
|
|
ratio = float(received_payload_size) / filtered_payload_size
|
|
if self._total_filtered_incoming_payload_bytes != 0:
|
|
average_ratio = (
|
|
float(self._total_incoming_payload_bytes) /
|
|
self._total_filtered_incoming_payload_bytes)
|
|
self._logger.debug(
|
|
'Incoming compress ratio: %f (average: %f)' %
|
|
(ratio, average_ratio))
|
|
|
|
|
|
_available_processors[common.DEFLATE_FRAME_EXTENSION] = (
|
|
DeflateFrameExtensionProcessor)
|
|
|
|
|
|
# Adding vendor-prefixed deflate-frame extension.
|
|
# TODO(bashi): Remove this after WebKit stops using vender prefix.
|
|
_available_processors[common.X_WEBKIT_DEFLATE_FRAME_EXTENSION] = (
|
|
DeflateFrameExtensionProcessor)
|
|
|
|
|
|
def get_extension_processor(extension_request):
|
|
global _available_processors
|
|
processor_class = _available_processors.get(extension_request.name())
|
|
if processor_class is None:
|
|
return None
|
|
return processor_class(extension_request)
|
|
|
|
|
|
# vi:sts=4 sw=4 et
|