The Tor Browser: comparison testing/mochitest/pywebsocket/mod

--1:000000000000
+:9507d2afc7cd
+# 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.
+"""PythonHeaderParserHandler for mod_pywebsocket.
+Apache HTTP Server and mod_python must be configured such that this
+function is called to handle WebSocket request.
+"""
+import logging
+from mod_python import apache
+from mod_pywebsocket import common
+from mod_pywebsocket import dispatch
+from mod_pywebsocket import handshake
+from mod_pywebsocket import util
+# PythonOption to specify the handler root directory.
+_PYOPT_HANDLER_ROOT = 'mod_pywebsocket.handler_root'
+# PythonOption to specify the handler scan directory.
+# This must be a directory under the root directory.
+# The default is the root directory.
+_PYOPT_HANDLER_SCAN = 'mod_pywebsocket.handler_scan'
+# PythonOption to allow handlers whose canonical path is
+# not under the root directory. It's disallowed by default.
+# Set this option with value of 'yes' to allow.
+_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT = (
+'mod_pywebsocket.allow_handlers_outside_root_dir')
+# Map from values to their meanings. 'Yes' and 'No' are allowed just for
+# compatibility.
+_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT_DEFINITION = {
+'off': False, 'no': False, 'on': True, 'yes': True}
+# PythonOption to specify to allow draft75 handshake.
+# The default is None (Off)
+_PYOPT_ALLOW_DRAFT75 = 'mod_pywebsocket.allow_draft75'
+# Map from values to their meanings.
+_PYOPT_ALLOW_DRAFT75_DEFINITION = {'off': False, 'on': True}
+class ApacheLogHandler(logging.Handler):
+"""Wrapper logging.Handler to emit log message to apache's error.log."""
+_LEVELS = {
+logging.DEBUG: apache.APLOG_DEBUG,
+logging.INFO: apache.APLOG_INFO,
+logging.WARNING: apache.APLOG_WARNING,
+logging.ERROR: apache.APLOG_ERR,
+logging.CRITICAL: apache.APLOG_CRIT,
+}
+def __init__(self, request=None):
+logging.Handler.__init__(self)
+self._log_error = apache.log_error
+if request is not None:
+self._log_error = request.log_error
+# Time and level will be printed by Apache.
+self._formatter = logging.Formatter('%(name)s: %(message)s')
+def emit(self, record):
+apache_level = apache.APLOG_DEBUG
+if record.levelno in ApacheLogHandler._LEVELS:
+apache_level = ApacheLogHandler._LEVELS[record.levelno]
+msg = self._formatter.format(record)
+# "server" parameter must be passed to have "level" parameter work.
+# If only "level" parameter is passed, nothing shows up on Apache's
+# log. However, at this point, we cannot get the server object of the
+# virtual host which will process WebSocket requests. The only server
+# object we can get here is apache.main_server. But Wherever (server
+# configuration context or virtual host context) we put
+# PythonHeaderParserHandler directive, apache.main_server just points
+# the main server instance (not any of virtual server instance). Then,
+# Apache follows LogLevel directive in the server configuration context
+# to filter logs. So, we need to specify LogLevel in the server
+# configuration context. Even if we specify "LogLevel debug" in the
+# virtual host context which actually handles WebSocket connections,
+# DEBUG level logs never show up unless "LogLevel debug" is specified
+# in the server configuration context.
+#
+# TODO(tyoshino): Provide logging methods on request object. When
+# request is mp_request object (when used together with Apache), the
+# methods call request.log_error indirectly. When request is
+# _StandaloneRequest, the methods call Python's logging facility which
+# we create in standalone.py.
+self._log_error(msg, apache_level, apache.main_server)
+def _configure_logging():
+logger = logging.getLogger()
+# Logs are filtered by Apache based on LogLevel directive in Apache
+# configuration file. We must just pass logs for all levels to
+# ApacheLogHandler.
+logger.setLevel(logging.DEBUG)
+logger.addHandler(ApacheLogHandler())
+_configure_logging()
+_LOGGER = logging.getLogger(__name__)
+def _parse_option(name, value, definition):
+if value is None:
+return False
+meaning = definition.get(value.lower())
+if meaning is None:
+raise Exception('Invalid value for PythonOption %s: %r' %
+(name, value))
+return meaning
+def _create_dispatcher():
+_LOGGER.info('Initializing Dispatcher')
+options = apache.main_server.get_options()
+handler_root = options.get(_PYOPT_HANDLER_ROOT, None)
+if not handler_root:
+raise Exception('PythonOption %s is not defined' % _PYOPT_HANDLER_ROOT,
+apache.APLOG_ERR)
+handler_scan = options.get(_PYOPT_HANDLER_SCAN, handler_root)
+allow_handlers_outside_root = _parse_option(
+_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT,
+options.get(_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT),
+_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT_DEFINITION)
+dispatcher = dispatch.Dispatcher(
+handler_root, handler_scan, allow_handlers_outside_root)
+for warning in dispatcher.source_warnings():
+apache.log_error('mod_pywebsocket: %s' % warning, apache.APLOG_WARNING)
+return dispatcher
+# Initialize
+_dispatcher = _create_dispatcher()
+def headerparserhandler(request):
+"""Handle request.
+Args:
+request: mod_python request.
+This function is named headerparserhandler because it is the default
+name for a PythonHeaderParserHandler.
+"""
+handshake_is_done = False
+try:
+# Fallback to default http handler for request paths for which
+# we don't have request handlers.
+if not _dispatcher.get_handler_suite(request.uri):
+request.log_error('No handler for resource: %r' % request.uri,
+apache.APLOG_INFO)
+request.log_error('Fallback to Apache', apache.APLOG_INFO)
+return apache.DECLINED
+except dispatch.DispatchException, e:
+request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+if not handshake_is_done:
+return e.status
+try:
+allow_draft75 = _parse_option(
+_PYOPT_ALLOW_DRAFT75,
+apache.main_server.get_options().get(_PYOPT_ALLOW_DRAFT75),
+_PYOPT_ALLOW_DRAFT75_DEFINITION)
+try:
+handshake.do_handshake(
+request, _dispatcher, allowDraft75=allow_draft75)
+except handshake.VersionException, e:
+request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+request.err_headers_out.add(common.SEC_WEBSOCKET_VERSION_HEADER,
+e.supported_versions)
+return apache.HTTP_BAD_REQUEST
+except handshake.HandshakeException, e:
+# Handshake for ws/wss failed.
+# Send http response with error status.
+request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+return e.status
+handshake_is_done = True
+request._dispatcher = _dispatcher
+_dispatcher.transfer_data(request)
+except handshake.AbortedByUserException, e:
+request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+except Exception, e:
+# DispatchException can also be thrown if something is wrong in
+# pywebsocket code. It's caught here, then.
+request.log_error('mod_pywebsocket: %s\n%s' %
+(e, util.get_stack_trace()),
+apache.APLOG_ERR)
+# Unknown exceptions before handshake mean Apache must handle its
+# request with another handler.
+if not handshake_is_done:
+return apache.DECLINED
+# Set assbackwards to suppress response header generation by Apache.
+request.assbackwards = 1
+return apache.DONE  # Return DONE such that no other handlers are invoked.
+# vi:sts=4 sw=4 et

The Tor Browser / file comparison

comparison: testing/mochitest/pywebsocket/mod_pywebsocket/headerparserhandler.py

testing/mochitest/pywebsocket/mod_pywebsocket/headerparserhandler.py