The Tor Browser / file revision

 # 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