1 # hgweb/server.py - The standalone hg web server.

     2 #

     3 # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>

     4 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

     5 #

     6 # This software may be used and distributed according to the terms of the

     7 # GNU General Public License version 2 or any later version.

     8 

     9 import os, sys, errno, urllib, BaseHTTPServer, socket, SocketServer, traceback

    10 from mercurial import util, error

    11 from mercurial.i18n import _

    12 

    13 def _splitURI(uri):

    14     """ Return path and query splited from uri

    15 

    16     Just like CGI environment, the path is unquoted, the query is

    17     not.

    18     """

    19     if '?' in uri:

    20         path, query = uri.split('?', 1)

    21     else:

    22         path, query = uri, ''

    23     return urllib.unquote(path), query

    24 

    25 class _error_logger(object):

    26     def __init__(self, handler):

    27         self.handler = handler

    28     def flush(self):

    29         pass

    30     def write(self, str):

    31         self.writelines(str.split('\n'))

    32     def writelines(self, seq):

    33         for msg in seq:

    34             self.handler.log_error("HG error:  %s", msg)

    35 

    36 class _httprequesthandler(BaseHTTPServer.BaseHTTPRequestHandler):

    37 

    38     url_scheme = 'http'

    39 

    40     @staticmethod

    41     def preparehttpserver(httpserver, ssl_cert):

    42         """Prepare .socket of new HTTPServer instance"""

    43         pass

    44 

    45     def __init__(self, *args, **kargs):

    46         self.protocol_version = 'HTTP/1.1'

    47         BaseHTTPServer.BaseHTTPRequestHandler.__init__(self, *args, **kargs)

    48 

    49     def _log_any(self, fp, format, *args):

    50         fp.write("%s - - [%s] %s\n" % (self.client_address[0],

    51                                        self.log_date_time_string(),

    52                                        format % args))

    53         fp.flush()

    54 

    55     def log_error(self, format, *args):

    56         self._log_any(self.server.errorlog, format, *args)

    57 

    58     def log_message(self, format, *args):

    59         self._log_any(self.server.accesslog, format, *args)

    60 

    61     def do_write(self):

    62         try:

    63             self.do_hgweb()

    64         except socket.error, inst:

    65             if inst[0] != errno.EPIPE:

    66                 raise

    67 

    68     def do_POST(self):

    69         try:

    70             self.do_write()

    71         except StandardError:

    72             self._start_response("500 Internal Server Error", [])

    73             self._write("Internal Server Error")

    74             tb = "".join(traceback.format_exception(*sys.exc_info()))

    75             self.log_error("Exception happened during processing "

    76                            "request '%s':\n%s", self.path, tb)

    77 

    78     def do_GET(self):

    79         self.do_POST()

    80 

    81     def do_hgweb(self):

    82         path, query = _splitURI(self.path)

    83 

    84         env = {}

    85         env['GATEWAY_INTERFACE'] = 'CGI/1.1'

    86         env['REQUEST_METHOD'] = self.command

    87         env['SERVER_NAME'] = self.server.server_name

    88         env['SERVER_PORT'] = str(self.server.server_port)

    89         env['REQUEST_URI'] = self.path

    90         env['SCRIPT_NAME'] = self.server.prefix

    91         env['PATH_INFO'] = path[len(self.server.prefix):]

    92         env['REMOTE_HOST'] = self.client_address[0]

    93         env['REMOTE_ADDR'] = self.client_address[0]

    94         if query:

    95             env['QUERY_STRING'] = query

    96 

    97         if self.headers.typeheader is None:

    98             env['CONTENT_TYPE'] = self.headers.type

    99         else:

   100             env['CONTENT_TYPE'] = self.headers.typeheader

   101         length = self.headers.getheader('content-length')

   102         if length:

   103             env['CONTENT_LENGTH'] = length

   104         for header in [h for h in self.headers.keys()

   105                        if h not in ('content-type', 'content-length')]:

   106             hkey = 'HTTP_' + header.replace('-', '_').upper()

   107             hval = self.headers.getheader(header)

   108             hval = hval.replace('\n', '').strip()

   109             if hval:

   110                 env[hkey] = hval

   111         env['SERVER_PROTOCOL'] = self.request_version

   112         env['wsgi.version'] = (1, 0)

   113         env['wsgi.url_scheme'] = self.url_scheme

   114         env['wsgi.input'] = self.rfile

   115         env['wsgi.errors'] = _error_logger(self)

   116         env['wsgi.multithread'] = isinstance(self.server,

   117                                              SocketServer.ThreadingMixIn)

   118         env['wsgi.multiprocess'] = isinstance(self.server,

   119                                               SocketServer.ForkingMixIn)

   120         env['wsgi.run_once'] = 0

   121 

   122         self.close_connection = True

   123         self.saved_status = None

   124         self.saved_headers = []

   125         self.sent_headers = False

   126         self.length = None

   127         for chunk in self.server.application(env, self._start_response):

   128             self._write(chunk)

   129 

   130     def send_headers(self):

   131         if not self.saved_status:

   132             raise AssertionError("Sending headers before "

   133                                  "start_response() called")

   134         saved_status = self.saved_status.split(None, 1)

   135         saved_status[0] = int(saved_status[0])

   136         self.send_response(*saved_status)

   137         should_close = True

   138         for h in self.saved_headers:

   139             self.send_header(*h)

   140             if h[0].lower() == 'content-length':

   141                 should_close = False

   142                 self.length = int(h[1])

   143         # The value of the Connection header is a list of case-insensitive

   144         # tokens separated by commas and optional whitespace.

   145         if 'close' in [token.strip().lower() for token in

   146                        self.headers.get('connection', '').split(',')]:

   147             should_close = True

   148         if should_close:

   149             self.send_header('Connection', 'close')

   150         self.close_connection = should_close

   151         self.end_headers()

   152         self.sent_headers = True

   153 

   154     def _start_response(self, http_status, headers, exc_info=None):

   155         code, msg = http_status.split(None, 1)

   156         code = int(code)

   157         self.saved_status = http_status

   158         bad_headers = ('connection', 'transfer-encoding')

   159         self.saved_headers = [h for h in headers

   160                               if h[0].lower() not in bad_headers]

   161         return self._write

   162 

   163     def _write(self, data):

   164         if not self.saved_status:

   165             raise AssertionError("data written before start_response() called")

   166         elif not self.sent_headers:

   167             self.send_headers()

   168         if self.length is not None:

   169             if len(data) > self.length:

   170                 raise AssertionError("Content-length header sent, but more "

   171                                      "bytes than specified are being written.")

   172             self.length = self.length - len(data)

   173         self.wfile.write(data)

   174         self.wfile.flush()

   175 

   176 class _httprequesthandleropenssl(_httprequesthandler):

   177     """HTTPS handler based on pyOpenSSL"""

   178 

   179     url_scheme = 'https'

   180 

   181     @staticmethod

   182     def preparehttpserver(httpserver, ssl_cert):

   183         try:

   184             import OpenSSL

   185             OpenSSL.SSL.Context

   186         except ImportError:

   187             raise util.Abort(_("SSL support is unavailable"))

   188         ctx = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD)

   189         ctx.use_privatekey_file(ssl_cert)

   190         ctx.use_certificate_file(ssl_cert)

   191         sock = socket.socket(httpserver.address_family, httpserver.socket_type)

   192         httpserver.socket = OpenSSL.SSL.Connection(ctx, sock)

   193         httpserver.server_bind()

   194         httpserver.server_activate()

   195 

   196     def setup(self):

   197         self.connection = self.request

   198         self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)

   199         self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)

   200 

   201     def do_write(self):

   202         import OpenSSL

   203         try:

   204             _httprequesthandler.do_write(self)

   205         except OpenSSL.SSL.SysCallError, inst:

   206             if inst.args[0] != errno.EPIPE:

   207                 raise

   208 

   209     def handle_one_request(self):

   210         import OpenSSL

   211         try:

   212             _httprequesthandler.handle_one_request(self)

   213         except (OpenSSL.SSL.SysCallError, OpenSSL.SSL.ZeroReturnError):

   214             self.close_connection = True

   215             pass

   216 

   217 class _httprequesthandlerssl(_httprequesthandler):

   218     """HTTPS handler based on Pythons ssl module (introduced in 2.6)"""

   219 

   220     url_scheme = 'https'

   221 

   222     @staticmethod

   223     def preparehttpserver(httpserver, ssl_cert):

   224         try:

   225             import ssl

   226             ssl.wrap_socket

   227         except ImportError:

   228             raise util.Abort(_("SSL support is unavailable"))

   229         httpserver.socket = ssl.wrap_socket(httpserver.socket, server_side=True,

   230             certfile=ssl_cert, ssl_version=ssl.PROTOCOL_SSLv23)

   231 

   232     def setup(self):

   233         self.connection = self.request

   234         self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)

   235         self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)

   236 

   237 try:

   238     from threading import activeCount

   239     _mixin = SocketServer.ThreadingMixIn

   240 except ImportError:

   241     if hasattr(os, "fork"):

   242         _mixin = SocketServer.ForkingMixIn

   243     else:

   244         class _mixin:

   245             pass

   246 

   247 def openlog(opt, default):

   248     if opt and opt != '-':

   249         return open(opt, 'a')

   250     return default

   251 

   252 class MercurialHTTPServer(object, _mixin, BaseHTTPServer.HTTPServer):

   253 

   254     # SO_REUSEADDR has broken semantics on windows

   255     if os.name == 'nt':

   256         allow_reuse_address = 0

   257 

   258     def __init__(self, ui, app, addr, handler, **kwargs):

   259         BaseHTTPServer.HTTPServer.__init__(self, addr, handler, **kwargs)

   260         self.daemon_threads = True

   261         self.application = app

   262 

   263         handler.preparehttpserver(self, ui.config('web', 'certificate'))

   264 

   265         prefix = ui.config('web', 'prefix', '')

   266         if prefix:

   267             prefix = '/' + prefix.strip('/')

   268         self.prefix = prefix

   269 

   270         alog = openlog(ui.config('web', 'accesslog', '-'), sys.stdout)

   271         elog = openlog(ui.config('web', 'errorlog', '-'), sys.stderr)

   272         self.accesslog = alog

   273         self.errorlog = elog

   274 

   275         self.addr, self.port = self.socket.getsockname()[0:2]

   276         self.fqaddr = socket.getfqdn(addr[0])

   277 

   278 class IPv6HTTPServer(MercurialHTTPServer):

   279     address_family = getattr(socket, 'AF_INET6', None)

   280     def __init__(self, *args, **kwargs):

   281         if self.address_family is None:

   282             raise error.RepoError(_('IPv6 is not available on this system'))

   283         super(IPv6HTTPServer, self).__init__(*args, **kwargs)

   284 

   285 def create_server(ui, app):

   286 

   287     if ui.config('web', 'certificate'):

   288         if sys.version_info >= (2, 6):

   289             handler = _httprequesthandlerssl

   290         else:

   291             handler = _httprequesthandleropenssl

   292     else:

   293         handler = _httprequesthandler

   294 

   295     if ui.configbool('web', 'ipv6'):

   296         cls = IPv6HTTPServer

   297     else:

   298         cls = MercurialHTTPServer

   299 

   300     # ugly hack due to python issue5853 (for threaded use)

   301     import mimetypes; mimetypes.init()

   302 

   303     address = ui.config('web', 'address', '')

   304     port = util.getport(ui.config('web', 'port', 8000))

   305     try:

   306         return cls(ui, app, (address, port), handler)

   307     except socket.error, inst:

   308         raise util.Abort(_("cannot start server at '%s:%d': %s")

   309                          % (address, port, inst.args[1]))