mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
244 lines
9.2 KiB
Python
244 lines
9.2 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.
|
|
|
|
|
|
"""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
|