This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2854

hgweb: use our forked wsgiheaders module instead of stdlib one
ClosedPublic

Authored by durin42 on Mar 13 2018, 11:30 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGda84e26d85ed: hgweb: use our forked wsgiheaders module instead of stdlib one
Summary

Now we use bytes for headers, rather than native strings.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Mar 13 2018, 11:30 PM
indygreg requested changes to this revision.Mar 14 2018, 12:54 AM
indygreg added a subscriber: indygreg.

parsedrequest.headers is supposed to be bytes. One of the goals of this refactor was to make the WSGI code all bytes all the time. So if system strings are making their way to the new request or response objects (i.e. outside request.py), then something is wrong and we should fix that: we shouldn’t need to introduce raw literals outside of the very low level WSGI code.

This revision now requires changes to proceed.Mar 14 2018, 12:54 AM
indygreg added a comment.Mar 14 2018, 10:56 AM
In D2854#45911, @indygreg wrote:

parsedrequest.headers is supposed to be bytes. One of the goals of this refactor was to make the WSGI code all bytes all the time. So if system strings are making their way to the new request or response objects (i.e. outside request.py), then something is wrong and we should fix that: we shouldn’t need to introduce raw literals outside of the very low level WSGI code.

We're using wsgirequest.headers.Headers. Python 3's implementation insists that headers be specified as the native str type: https://github.com/python/cpython/blob/master/Lib/wsgiref/headers.py. Because of course it does. Ugh.

It looks like we'll have to implement a case insensitive + -/_ normalizing keys dict for header storage. Shouldn't be a big deal.

durin42 edited the summary of this revision. (Show Details)Apr 11 2018, 3:50 PM
durin42 retitled this revision from hgweb: str/bytes followups after indygreg's refactoring to hgweb: use our forked wsgiheaders module instead of stdlib one.
durin42 added a child revision: D3246: keepalive: rewrite readinto() to not use read().
durin42 updated this revision to Diff 8009.
indygreg accepted this revision.Apr 12 2018, 11:10 AM
This revision is now accepted and ready to land.Apr 12 2018, 11:10 AM
indygreg requested changes to this revision.Apr 12 2018, 11:30 AM

This one caused an import cycle: Import cycle: mercurial.hgweb.__init__ -> mercurial.hgweb.hgweb_mod -> mercurial.hgweb.request -> mercurial.hgweb.__init__

This revision now requires changes to proceed.Apr 12 2018, 11:30 AM
durin42 updated this revision to Diff 8074.Apr 12 2018, 12:47 PM
indygreg accepted this revision.Apr 12 2018, 12:59 PM
This revision is now accepted and ready to land.Apr 12 2018, 12:59 PM
Closed by commit rHGda84e26d85ed: hgweb: use our forked wsgiheaders module instead of stdlib one (authored by durin42). · Explain WhyApr 12 2018, 1:01 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7020

mercurial/hgweb/common.py

return getattr(self.f, attr) return getattr(self.f, attr)
raise AttributeError raise AttributeError
def _statusmessage(code): def _statusmessage(code):
responses = httpserver.basehttprequesthandler.responses responses = httpserver.basehttprequesthandler.responses
return responses.get(code, ('Error', 'Unknown error'))[0] return responses.get(code, ('Error', 'Unknown error'))[0]
def statusmessage(code, message=None): def statusmessage(code, message=None):
return '%d %s' % (code, message or _statusmessage(code)) return r'%d %s' % (code, message or _statusmessage(code))
def get_stat(spath, fn): def get_stat(spath, fn):
"""stat fn if it exists, spath otherwise""" """stat fn if it exists, spath otherwise"""
cl_path = os.path.join(spath, fn) cl_path = os.path.join(spath, fn)
if os.path.exists(cl_path): if os.path.exists(cl_path):
return os.stat(cl_path) return os.stat(cl_path)
else: else:
return os.stat(spath) return os.stat(spath)
ct = mimetypes.guess_type(pycompat.fsdecode(path))[0] or "text/plain" ct = mimetypes.guess_type(pycompat.fsdecode(path))[0] or "text/plain"
with open(path, 'rb') as fh: with open(path, 'rb') as fh:
data = fh.read() data = fh.read()
res.headers['Content-Type'] = ct res.headers['Content-Type'] = ct
res.setbodybytes(data) res.setbodybytes(data)
return res return res
except TypeError: except TypeError:
raise ErrorResponse(HTTP_SERVER_ERROR, 'illegal filename') raise ErrorResponse(HTTP_SERVER_ERROR, r'illegal filename')
except OSError as err: except OSError as err:
if err.errno == errno.ENOENT: if err.errno == errno.ENOENT:
raise ErrorResponse(HTTP_NOT_FOUND) raise ErrorResponse(HTTP_NOT_FOUND)
else: else:
raise ErrorResponse(HTTP_SERVER_ERROR, raise ErrorResponse(HTTP_SERVER_ERROR,
encoding.strtolocal(err.strerror)) encoding.strtolocal(err.strerror))
def paritygen(stripecount, offset=0): def paritygen(stripecount, offset=0):

mercurial/hgweb/hgweb_mod.py

node = args.pop(0).replace('%2F', '/') node = args.pop(0).replace('%2F', '/')
req.qsparams['node'] = node req.qsparams['node'] = node
if args: if args:
if 'file' in req.qsparams: if 'file' in req.qsparams:
del req.qsparams['file'] del req.qsparams['file']
for a in args: for a in args:
req.qsparams.add('file', a) req.qsparams.add('file', a)
ua = req.headers.get('User-Agent', '') ua = pycompat.bytesurl(req.headers.get(r'User-Agent', r''))
if cmd == 'rev' and 'mercurial' in ua: if cmd == 'rev' and 'mercurial' in ua:
req.qsparams['style'] = 'raw' req.qsparams['style'] = 'raw'
if cmd == 'archive': if cmd == 'archive':
fn = req.qsparams['node'] fn = req.qsparams['node']
for type_, spec in rctx.archivespecs.iteritems(): for type_, spec in rctx.archivespecs.iteritems():
ext = spec[2] ext = spec[2]
if fn.endswith(ext): if fn.endswith(ext):
req.qsparams['node'] = fn[:-len(ext)] req.qsparams['node'] = fn[:-len(ext)]
req.qsparams['type'] = type_ req.qsparams['type'] = type_
else: else:
cmd = req.qsparams.get('cmd', '') cmd = req.qsparams.get('cmd', '')
# process the web interface request # process the web interface request
try: try:
rctx.tmpl = rctx.templater(req) rctx.tmpl = rctx.templater(req)
ctype = rctx.tmpl('mimetype', encoding=encoding.encoding) ctype = rctx.tmpl('mimetype', encoding=encoding.encoding)
ctype = templateutil.stringify(ctype) ctype = pycompat.strurl(templateutil.stringify(ctype))
# check read permissions non-static content # check read permissions non-static content
if cmd != 'static': if cmd != 'static':
self.check_perm(rctx, req, None) self.check_perm(rctx, req, None)
if cmd == '': if cmd == '':
req.qsparams['cmd'] = rctx.tmpl.cache['default'] req.qsparams['cmd'] = rctx.tmpl.cache['default']
cmd = req.qsparams['cmd'] cmd = req.qsparams['cmd']
# Don't enable caching if using a CSP nonce because then it wouldn't # Don't enable caching if using a CSP nonce because then it wouldn't
# be a nonce. # be a nonce.
if rctx.configbool('web', 'cache') and not rctx.nonce: if rctx.configbool('web', 'cache') and not rctx.nonce:
tag = 'W/"%d"' % self.mtime tag = r'W/"%d"' % self.mtime
if req.headers.get('If-None-Match') == tag: if req.headers.get(r'If-None-Match') == tag:
res.status = '304 Not Modified' res.status = r'304 Not Modified'
# Response body not allowed on 304. # Response body not allowed on 304.
res.setbodybytes('') res.setbodybytes('')
return res.sendresponse() return res.sendresponse()
res.headers['ETag'] = tag res.headers[r'ETag'] = tag
if cmd not in webcommands.__all__: if cmd not in webcommands.__all__:
msg = 'no such method: %s' % cmd msg = 'no such method: %s' % cmd
raise ErrorResponse(HTTP_BAD_REQUEST, msg) raise ErrorResponse(HTTP_BAD_REQUEST, msg)
else: else:
# Set some globals appropriate for web handlers. Commands can # Set some globals appropriate for web handlers. Commands can
# override easily enough. # override easily enough.
res.status = '200 Script output follows' res.status = r'200 Script output follows'
res.headers['Content-Type'] = ctype res.headers[r'Content-Type'] = ctype
return getattr(webcommands, cmd)(rctx) return getattr(webcommands, cmd)(rctx)
except (error.LookupError, error.RepoLookupError) as err: except (error.LookupError, error.RepoLookupError) as err:
msg = pycompat.bytestr(err) msg = pycompat.bytestr(err)
if (util.safehasattr(err, 'name') and if (util.safehasattr(err, 'name') and
not isinstance(err, error.ManifestLookupError)): not isinstance(err, error.ManifestLookupError)):
msg = 'revision not found: %s' % err.name msg = 'revision not found: %s' % err.name
res.status = '404 Not Found' res.status = r'404 Not Found'
res.headers['Content-Type'] = ctype res.headers[r'Content-Type'] = ctype
return rctx.sendtemplate('error', error=msg) return rctx.sendtemplate('error', error=msg)
except (error.RepoError, error.RevlogError) as e: except (error.RepoError, error.RevlogError) as e:
res.status = '500 Internal Server Error' res.status = r'500 Internal Server Error'
res.headers['Content-Type'] = ctype res.headers[r'Content-Type'] = ctype
return rctx.sendtemplate('error', error=pycompat.bytestr(e)) return rctx.sendtemplate('error', error=pycompat.bytestr(e))
except ErrorResponse as e: except ErrorResponse as e:
res.status = statusmessage(e.code, pycompat.bytestr(e)) res.status = statusmessage(e.code, e)
res.headers['Content-Type'] = ctype res.headers[r'Content-Type'] = ctype
return rctx.sendtemplate('error', error=pycompat.bytestr(e)) return rctx.sendtemplate('error', error=pycompat.bytestr(e))
def check_perm(self, rctx, req, op): def check_perm(self, rctx, req, op):
for permhook in permhooks: for permhook in permhooks:
permhook(rctx, req, op) permhook(rctx, req, op)
def getwebview(repo): def getwebview(repo):
"""The 'web.view' config controls changeset filter to hgweb. Possible """The 'web.view' config controls changeset filter to hgweb. Possible

mercurial/hgweb/hgwebdir_mod.py

csp, nonce = cspvalues(self.ui) csp, nonce = cspvalues(self.ui)
if csp: if csp:
res.headers['Content-Security-Policy'] = csp res.headers['Content-Security-Policy'] = csp
virtual = req.dispatchpath.strip('/') virtual = req.dispatchpath.strip('/')
tmpl = self.templater(req, nonce) tmpl = self.templater(req, nonce)
ctype = tmpl('mimetype', encoding=encoding.encoding) ctype = tmpl('mimetype', encoding=encoding.encoding)
ctype = templateutil.stringify(ctype) ctype = pycompat.strurl(templateutil.stringify(ctype))
# Global defaults. These can be overridden by any handler. # Global defaults. These can be overridden by any handler.
res.status = '200 Script output follows' res.status = r'200 Script output follows'
res.headers['Content-Type'] = ctype res.headers[r'Content-Type'] = ctype
# a static file # a static file
if virtual.startswith('static/') or 'static' in req.qsparams: if virtual.startswith('static/') or 'static' in req.qsparams:
if virtual.startswith('static/'): if virtual.startswith('static/'):
fname = virtual[7:] fname = virtual[7:]
else: else:
fname = req.qsparams['static'] fname = req.qsparams['static']
static = self.ui.config("web", "static", None, static = self.ui.config("web", "static", None,
yield '' yield ''
for virtualrepo in _virtualdirs(): for virtualrepo in _virtualdirs():
real = repos.get(virtualrepo) real = repos.get(virtualrepo)
if real: if real:
# Re-parse the WSGI environment to take into account our # Re-parse the WSGI environment to take into account our
# repository path component. # repository path component.
strenv = {pycompat.strurl(k): pycompat.strurl(v) for k, v in
req.rawenv.iteritems()}
req = requestmod.parserequestfromenv( req = requestmod.parserequestfromenv(
req.rawenv, reponame=virtualrepo, strenv, reponame=virtualrepo,
altbaseurl=self.ui.config('web', 'baseurl')) altbaseurl=self.ui.config('web', 'baseurl'))
try: try:
# ensure caller gets private copy of ui # ensure caller gets private copy of ui
repo = hg.repository(self.ui.copy(), real) repo = hg.repository(self.ui.copy(), real)
return hgweb_mod.hgweb(repo).run_wsgi(req, res) return hgweb_mod.hgweb(repo).run_wsgi(req, res)
except IOError as inst: except IOError as inst:
msg = encoding.strtolocal(inst.strerror) msg = encoding.strtolocal(inst.strerror)
raise ErrorResponse(HTTP_SERVER_ERROR, msg) raise ErrorResponse(HTTP_SERVER_ERROR, msg)
except error.RepoError as inst: except error.RepoError as inst:
raise ErrorResponse(HTTP_SERVER_ERROR, bytes(inst)) raise ErrorResponse(HTTP_SERVER_ERROR, bytes(inst))
# browse subdirectories # browse subdirectories
subdir = virtual + '/' subdir = virtual + '/'
if [r for r in repos if r.startswith(subdir)]: if [r for r in repos if r.startswith(subdir)]:
return self.makeindex(req, res, tmpl, subdir) return self.makeindex(req, res, tmpl, subdir)
# prefixes not found # prefixes not found
res.status = '404 Not Found' res.status = r'404 Not Found'
res.setbodygen(tmpl('notfound', repo=virtual)) res.setbodygen(tmpl('notfound', repo=virtual))
return res.sendresponse() return res.sendresponse()
except ErrorResponse as e: except ErrorResponse as e:
res.status = statusmessage(e.code, pycompat.bytestr(e)) res.status = statusmessage(e.code, e)
res.setbodygen(tmpl('error', error=e.message or '')) res.setbodygen(tmpl('error', error=e.message or ''))
return res.sendresponse() return res.sendresponse()
finally: finally:
tmpl = None tmpl = None
def makeindex(self, req, res, tmpl, subdir=""): def makeindex(self, req, res, tmpl, subdir=""):
self.refresh() self.refresh()
sortable = ["name", "description", "contact", "lastchange"] sortable = ["name", "description", "contact", "lastchange"]

mercurial/hgweb/request.py

# HTTP_* keys contain HTTP request headers. The Headers structure should # HTTP_* keys contain HTTP request headers. The Headers structure should
# perform case normalization for us. We just rewrite underscore to dash # perform case normalization for us. We just rewrite underscore to dash
# so keys match what likely went over the wire. # so keys match what likely went over the wire.
headers = [] headers = []
for k, v in env.iteritems(): for k, v in env.iteritems():
if k.startswith('HTTP_'): if k.startswith('HTTP_'):
headers.append((k[len('HTTP_'):].replace('_', '-'), v)) headers.append((k[len('HTTP_'):].replace('_', '-'), v))
headers = wsgiheaders.Headers(headers)
headers = wsgiheaders.Headers([(pycompat.strurl(k), pycompat.strurl(v))
for k, v in headers])
# This is kind of a lie because the HTTP header wasn't explicitly # This is kind of a lie because the HTTP header wasn't explicitly
# sent. But for all intents and purposes it should be OK to lie about # sent. But for all intents and purposes it should be OK to lie about
# this, since a consumer will either either value to determine how many # this, since a consumer will either either value to determine how many
# bytes are available to read. # bytes are available to read.
if 'CONTENT_LENGTH' in env and 'HTTP_CONTENT_LENGTH' not in env: if 'CONTENT_LENGTH' in env and 'HTTP_CONTENT_LENGTH' not in env:
headers['Content-Length'] = env['CONTENT_LENGTH'] headers[r'Content-Length'] = pycompat.strurl(env['CONTENT_LENGTH'])
bodyfh = env['wsgi.input'] bodyfh = env['wsgi.input']
if 'Content-Length' in headers: if r'Content-Length' in headers:
bodyfh = util.cappedreader(bodyfh, int(headers['Content-Length'])) bodyfh = util.cappedreader(bodyfh, int(headers[r'Content-Length']))
return parsedrequest(method=env['REQUEST_METHOD'], return parsedrequest(method=env['REQUEST_METHOD'],
url=fullurl, baseurl=baseurl, url=fullurl, baseurl=baseurl,
advertisedurl=advertisedfullurl, advertisedurl=advertisedfullurl,
advertisedbaseurl=advertisedbaseurl, advertisedbaseurl=advertisedbaseurl,
urlscheme=env['wsgi.url_scheme'], urlscheme=env['wsgi.url_scheme'],
remoteuser=env.get('REMOTE_USER'), remoteuser=env.get('REMOTE_USER'),
remotehost=env.get('REMOTE_HOST'), remotehost=env.get('REMOTE_HOST'),
def setbodybytes(self, b): def setbodybytes(self, b):
"""Define the response body as static bytes. """Define the response body as static bytes.
The empty string signals that there is no response body. The empty string signals that there is no response body.
""" """
self._verifybody() self._verifybody()
self._bodybytes = b self._bodybytes = b
self.headers['Content-Length'] = '%d' % len(b) self.headers[r'Content-Length'] = r'%d' % len(b)
def setbodygen(self, gen): def setbodygen(self, gen):
"""Define the response body as a generator of bytes.""" """Define the response body as a generator of bytes."""
self._verifybody() self._verifybody()
self._bodygen = gen self._bodygen = gen
def setbodywillwrite(self): def setbodywillwrite(self):
"""Signal an intent to use write() to emit the response body. """Signal an intent to use write() to emit the response body.
# RFC 7232 Section 4.1 states that a 304 MUST generate one of # RFC 7232 Section 4.1 states that a 304 MUST generate one of
# {Cache-Control, Content-Location, Date, ETag, Expires, Vary} # {Cache-Control, Content-Location, Date, ETag, Expires, Vary}
# and SHOULD NOT generate other headers unless they could be used # and SHOULD NOT generate other headers unless they could be used
# to guide cache updates. Furthermore, RFC 7230 Section 3.3.2 # to guide cache updates. Furthermore, RFC 7230 Section 3.3.2
# states that no response body can be issued. Content-Length can # states that no response body can be issued. Content-Length can
# be sent. But if it is present, it should be the size of the response # be sent. But if it is present, it should be the size of the response
# that wasn't transferred. # that wasn't transferred.
if self.status.startswith('304 '): if self.status.startswith(r'304 '):
# setbodybytes('') will set C-L to 0. This doesn't conform with the # setbodybytes('') will set C-L to 0. This doesn't conform with the
# spec. So remove it. # spec. So remove it.
if self.headers.get('Content-Length') == '0': if self.headers.get(r'Content-Length') == r'0':
del self.headers['Content-Length'] del self.headers[r'Content-Length']
# Strictly speaking, this is too strict. But until it causes # Strictly speaking, this is too strict. But until it causes
# problems, let's be strict. # problems, let's be strict.
badheaders = {k for k in self.headers.keys() badheaders = {k for k in self.headers.keys()
if k.lower() not in ('date', 'etag', 'expires', if k.lower() not in (r'date', r'etag', r'expires',
'cache-control', r'cache-control',
'content-location', r'content-location',
'vary')} r'vary')}
if badheaders: if badheaders:
raise error.ProgrammingError( raise error.ProgrammingError(
'illegal header on 304 response: %s' % 'illegal header on 304 response: %s' %
', '.join(sorted(badheaders))) ', '.join(sorted(badheaders)))
if self._bodygen is not None or self._bodywillwrite: if self._bodygen is not None or self._bodywillwrite:
raise error.ProgrammingError("must use setbodybytes('') with " raise error.ProgrammingError("must use setbodybytes('') with "
"304 responses") "304 responses")
# Various HTTP clients (notably httplib) won't read the HTTP response # Various HTTP clients (notably httplib) won't read the HTTP response
# until the HTTP request has been sent in full. If servers (us) send a # until the HTTP request has been sent in full. If servers (us) send a
# response before the HTTP request has been fully sent, the connection # response before the HTTP request has been fully sent, the connection
# may deadlock because neither end is reading. # may deadlock because neither end is reading.
# #
# We work around this by "draining" the request data before # We work around this by "draining" the request data before
# sending any response in some conditions. # sending any response in some conditions.
drain = False drain = False
close = False close = False
# If the client sent Expect: 100-continue, we assume it is smart enough # If the client sent Expect: 100-continue, we assume it is smart enough
# to deal with the server sending a response before reading the request. # to deal with the server sending a response before reading the request.
# (httplib doesn't do this.) # (httplib doesn't do this.)
if self._req.headers.get('Expect', '').lower() == '100-continue': if self._req.headers.get(r'Expect', r'').lower() == r'100-continue':
pass pass
# Only tend to request methods that have bodies. Strictly speaking, # Only tend to request methods that have bodies. Strictly speaking,
# we should sniff for a body. But this is fine for our existing # we should sniff for a body. But this is fine for our existing
# WSGI applications. # WSGI applications.
elif self._req.method not in ('POST', 'PUT'): elif self._req.method not in ('POST', 'PUT'):
pass pass
else: else:
# If we don't know how much data to read, there's no guarantee # If we don't know how much data to read, there's no guarantee

mercurial/hgweb/server.py

except socket.error as inst: except socket.error as inst:
if inst[0] != errno.EPIPE: if inst[0] != errno.EPIPE:
raise raise
def do_POST(self): def do_POST(self):
try: try:
self.do_write() self.do_write()
except Exception: except Exception:
self._start_response("500 Internal Server Error", []) self._start_response(r"500 Internal Server Error", [])
self._write("Internal Server Error") self._write("Internal Server Error")
self._done() self._done()
tb = r"".join(traceback.format_exception(*sys.exc_info())) tb = r"".join(traceback.format_exception(*sys.exc_info()))
# We need a native-string newline to poke in the log # We need a native-string newline to poke in the log
# message, because we won't get a newline when using an # message, because we won't get a newline when using an
# r-string. This is the easy way out. # r-string. This is the easy way out.
newline = chr(10) newline = chr(10)
self.log_error(r"Exception happened during processing " self.log_error(r"Exception happened during processing "
env[r'REMOTE_ADDR'] = self.client_address[0] env[r'REMOTE_ADDR'] = self.client_address[0]
env[r'QUERY_STRING'] = query or r'' env[r'QUERY_STRING'] = query or r''
if pycompat.ispy3: if pycompat.ispy3:
if self.headers.get_content_type() is None: if self.headers.get_content_type() is None:
env[r'CONTENT_TYPE'] = self.headers.get_default_type() env[r'CONTENT_TYPE'] = self.headers.get_default_type()
else: else:
env[r'CONTENT_TYPE'] = self.headers.get_content_type() env[r'CONTENT_TYPE'] = self.headers.get_content_type()
length = self.headers.get('content-length') length = self.headers.get(r'content-length')
else: else:
if self.headers.typeheader is None: if self.headers.typeheader is None:
env[r'CONTENT_TYPE'] = self.headers.type env[r'CONTENT_TYPE'] = self.headers.type
else: else:
env[r'CONTENT_TYPE'] = self.headers.typeheader env[r'CONTENT_TYPE'] = self.headers.typeheader
length = self.headers.getheader('content-length') length = self.headers.getheader(r'content-length')
if length: if length:
env[r'CONTENT_LENGTH'] = length env[r'CONTENT_LENGTH'] = length
for header in [h for h in self.headers.keys() for header in [h for h in self.headers.keys()
if h not in ('content-type', 'content-length')]: if h not in (r'content-type', r'content-length')]:
hkey = r'HTTP_' + header.replace(r'-', r'_').upper() hkey = r'HTTP_' + header.replace(r'-', r'_').upper()
hval = self.headers.get(header) hval = self.headers.get(header)
hval = hval.replace(r'\n', r'').strip() hval = hval.replace(r'\n', r'').strip()
if hval: if hval:
env[hkey] = hval env[hkey] = hval
env[r'SERVER_PROTOCOL'] = self.request_version env[r'SERVER_PROTOCOL'] = self.request_version
env[r'wsgi.version'] = (1, 0) env[r'wsgi.version'] = (1, 0)
env[r'wsgi.url_scheme'] = pycompat.sysstr(self.url_scheme) env[r'wsgi.url_scheme'] = pycompat.sysstr(self.url_scheme)
if env.get(r'HTTP_EXPECT', '').lower() == '100-continue': if env.get(r'HTTP_EXPECT', '').lower() == r'100-continue':
self.rfile = common.continuereader(self.rfile, self.wfile.write) self.rfile = common.continuereader(self.rfile, self.wfile.write)
env[r'wsgi.input'] = self.rfile env[r'wsgi.input'] = self.rfile
env[r'wsgi.errors'] = _error_logger(self) env[r'wsgi.errors'] = _error_logger(self)
env[r'wsgi.multithread'] = isinstance(self.server, env[r'wsgi.multithread'] = isinstance(self.server,
socketserver.ThreadingMixIn) socketserver.ThreadingMixIn)
env[r'wsgi.multiprocess'] = isinstance(self.server, env[r'wsgi.multiprocess'] = isinstance(self.server,
socketserver.ForkingMixIn) socketserver.ForkingMixIn)

mercurial/wireprotoserver.py

stringio = util.stringio stringio = util.stringio
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
HTTP_OK = 200 HTTP_OK = 200
HGTYPE = 'application/mercurial-0.1' HGTYPE = r'application/mercurial-0.1'
HGTYPE2 = 'application/mercurial-0.2' HGTYPE2 = r'application/mercurial-0.2'
HGERRTYPE = 'application/hg-error' HGERRTYPE = r'application/hg-error'
SSHV1 = wireprototypes.SSHV1 SSHV1 = wireprototypes.SSHV1
SSHV2 = wireprototypes.SSHV2 SSHV2 = wireprototypes.SSHV2
def decodevaluefromheaders(req, headerprefix): def decodevaluefromheaders(req, headerprefix):
"""Decode a long value from multiple HTTP request headers. """Decode a long value from multiple HTTP request headers.
Returns the value as a bytes, not a str. Returns the value as a bytes, not a str.
""" """
chunks = [] chunks = []
i = 1 i = 1
while True: while True:
v = req.headers.get(b'%s-%d' % (headerprefix, i)) v = req.headers.get(r'%s-%d' % (headerprefix, i))
if v is None: if v is None:
break break
chunks.append(pycompat.bytesurl(v)) chunks.append(pycompat.bytesurl(v))
i += 1 i += 1
return ''.join(chunks) return ''.join(chunks)
class httpv1protocolhandler(wireprototypes.baseprotocolhandler): class httpv1protocolhandler(wireprototypes.baseprotocolhandler):
star[key] = knownargs[key][0] star[key] = knownargs[key][0]
data['*'] = star data['*'] = star
else: else:
data[k] = knownargs[k][0] data[k] = knownargs[k][0]
return [data[k] for k in keys] return [data[k] for k in keys]
def _args(self): def _args(self):
args = self._req.qsparams.asdictoflists() args = self._req.qsparams.asdictoflists()
postlen = int(self._req.headers.get(b'X-HgArgs-Post', 0)) postlen = int(self._req.headers.get(r'X-HgArgs-Post', 0))
if postlen: if postlen:
args.update(urlreq.parseqs( args.update(urlreq.parseqs(
self._req.bodyfh.read(postlen), keep_blank_values=True)) self._req.bodyfh.read(postlen), keep_blank_values=True))
return args return args
argvalue = decodevaluefromheaders(self._req, b'X-HgArg') argvalue = decodevaluefromheaders(self._req, r'X-HgArg')
args.update(urlreq.parseqs(argvalue, keep_blank_values=True)) args.update(urlreq.parseqs(argvalue, keep_blank_values=True))
return args return args
def forwardpayload(self, fp): def forwardpayload(self, fp):
# Existing clients *always* send Content-Length. # Existing clients *always* send Content-Length.
length = int(self._req.headers[b'Content-Length']) length = int(self._req.headers[r'Content-Length'])
# If httppostargs is used, we need to read Content-Length # If httppostargs is used, we need to read Content-Length
# minus the amount that was consumed by args. # minus the amount that was consumed by args.
length -= int(self._req.headers.get(b'X-HgArgs-Post', 0)) length -= int(self._req.headers.get(r'X-HgArgs-Post', 0))
for s in util.filechunkiter(self._req.bodyfh, limit=length): for s in util.filechunkiter(self._req.bodyfh, limit=length):
fp.write(s) fp.write(s)
@contextlib.contextmanager @contextlib.contextmanager
def mayberedirectstdio(self): def mayberedirectstdio(self):
oldout = self._ui.fout oldout = self._ui.fout
olderr = self._ui.ferr olderr = self._ui.ferr
return False return False
# The "cmd" query string argument is only valid on the root path of the # The "cmd" query string argument is only valid on the root path of the
# repo. e.g. ``/?cmd=foo``, ``/repo?cmd=foo``. URL paths within the repo # repo. e.g. ``/?cmd=foo``, ``/repo?cmd=foo``. URL paths within the repo
# like ``/blah?cmd=foo`` are not allowed. So don't recognize the request # like ``/blah?cmd=foo`` are not allowed. So don't recognize the request
# in this case. We send an HTTP 404 for backwards compatibility reasons. # in this case. We send an HTTP 404 for backwards compatibility reasons.
if req.dispatchpath: if req.dispatchpath:
res.status = hgwebcommon.statusmessage(404) res.status = hgwebcommon.statusmessage(404)
res.headers['Content-Type'] = HGTYPE res.headers[r'Content-Type'] = HGTYPE
# TODO This is not a good response to issue for this request. This # TODO This is not a good response to issue for this request. This
# is mostly for BC for now. # is mostly for BC for now.
res.setbodybytes('0\n%s\n' % b'Not Found') res.setbodybytes('0\n%s\n' % b'Not Found')
return True return True
proto = httpv1protocolhandler(req, repo.ui, proto = httpv1protocolhandler(req, repo.ui,
lambda perm: checkperm(rctx, req, perm)) lambda perm: checkperm(rctx, req, perm))
# The permissions checker should be the only thing that can raise an # The permissions checker should be the only thing that can raise an
# ErrorResponse. It is kind of a layer violation to catch an hgweb # ErrorResponse. It is kind of a layer violation to catch an hgweb
# exception here. So consider refactoring into a exception type that # exception here. So consider refactoring into a exception type that
# is associated with the wire protocol. # is associated with the wire protocol.
try: try:
_callhttp(repo, req, res, proto, cmd) _callhttp(repo, req, res, proto, cmd)
except hgwebcommon.ErrorResponse as e: except hgwebcommon.ErrorResponse as e:
for k, v in e.headers: for k, v in e.headers:
res.headers[k] = v res.headers[k] = v
res.status = hgwebcommon.statusmessage(e.code, pycompat.bytestr(e)) res.status = hgwebcommon.statusmessage(e.code, e)
# TODO This response body assumes the failed command was # TODO This response body assumes the failed command was
# "unbundle." That assumption is not always valid. # "unbundle." That assumption is not always valid.
res.setbodybytes('0\n%s\n' % pycompat.bytestr(e)) res.setbodybytes('0\n%s\n' % pycompat.bytestr(e))
return True return True
def _httpresponsetype(ui, req, prefer_uncompressed): def _httpresponsetype(ui, req, prefer_uncompressed):
"""Determine the appropriate response type and compression settings. """Determine the appropriate response type and compression settings.
yield struct.pack('B', len(name)) yield struct.pack('B', len(name))
yield name yield name
for chunk in gen: for chunk in gen:
yield chunk yield chunk
def setresponse(code, contenttype, bodybytes=None, bodygen=None): def setresponse(code, contenttype, bodybytes=None, bodygen=None):
if code == HTTP_OK: if code == HTTP_OK:
res.status = '200 Script output follows' res.status = r'200 Script output follows'
else: else:
res.status = hgwebcommon.statusmessage(code) res.status = hgwebcommon.statusmessage(code)
res.headers['Content-Type'] = contenttype res.headers[r'Content-Type'] = pycompat.strurl(contenttype)
if bodybytes is not None: if bodybytes is not None:
res.setbodybytes(bodybytes) res.setbodybytes(bodybytes)
if bodygen is not None: if bodygen is not None:
res.setbodygen(bodygen) res.setbodygen(bodygen)
if not wireproto.commands.commandavailable(cmd, proto): if not wireproto.commands.commandavailable(cmd, proto):
setresponse(HTTP_OK, HGERRTYPE, setresponse(HTTP_OK, HGERRTYPE,