| # 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} |
| |
| # (Obsolete option. Ignored.) |
| # PythonOption to specify to allow handshake defined in Hixie 75 version |
| # protocol. 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: Warning in source loading: %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( |
| 'mod_pywebsocket: No handler for resource: %r' % request.uri, |
| apache.APLOG_INFO) |
| request.log_error( |
| 'mod_pywebsocket: Fallback to Apache', apache.APLOG_INFO) |
| return apache.DECLINED |
| except dispatch.DispatchException, e: |
| request.log_error( |
| 'mod_pywebsocket: Dispatch failed for error: %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: Handshake failed for version error: %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: Handshake failed for error: %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: Aborted: %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: Exception occurred: %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 |
