allow_reuse_address = 1 # Seems to make sense in testing environment

def server_bind(self):

"""Override server_bind to store the server name."""

socketserver.TCPServer.server_bind(self)

host, port = self.socket.getsockname()[:2]

self.server_name = socket.getfqdn(host)

"""HTTP request handler base class.

# The Python system version, truncated to its first component.

sys_version = "Python/" + sys.version.split()[0]

# The server software version. You may want to override this.

# The format is multiple whitespace-separated strings,

# where each string is of the form name[/version].

server_version = "BaseHTTP/" + __version__

error_message_format = DEFAULT_ERROR_MESSAGE

error_content_type = DEFAULT_ERROR_CONTENT_TYPE

# The default request version. This only affects responses up until

# the point where the request line is parsed, so it mainly decides what

# the client gets back when sending a malformed request line.

# Most web servers default to HTTP 0.9, i.e. don't send a status line.

default_request_version = "HTTP/0.9"

def parse_request(self):

"""Parse a request (internal).

self.command = None # set in case of error on the first line

self.request_version = version = self.default_request_version

self.close_connection = 1

requestline = str(self.raw_requestline, 'iso-8859-1')

requestline = requestline.rstrip('\r\n')

self.requestline = requestline

words = requestline.split()

if len(words) == 3:

command, path, version = words

if version[:5] != 'HTTP/':

self.send_error(400, "Bad request version (%r)" % version)

return False

try:

base_version_number = version.split('/', 1)[1]

version_number = base_version_number.split(".")

# RFC 2145 section 3.1 says there can be only one "." and

# - major and minor numbers MUST be treated as

# separate integers;

# - HTTP/2.4 is a lower version than HTTP/2.13, which in

# turn is lower than HTTP/12.3;

# - Leading zeros MUST be ignored by recipients.

if len(version_number) != 2:

raise ValueError

version_number = int(version_number[0]), int(version_number[1])

except (ValueError, IndexError):

self.send_error(400, "Bad request version (%r)" % version)

return False

if version_number >= (1, 1) and self.protocol_version >= "HTTP/1.1":

self.close_connection = 0

if version_number >= (2, 0):

self.send_error(505,

"Invalid HTTP Version (%s)" % base_version_number)

return False

elif len(words) == 2:

command, path = words

self.close_connection = 1

if command != 'GET':

self.send_error(400,

"Bad HTTP/0.9 request type (%r)" % command)

return False

elif not words:

return False

else:

self.send_error(400, "Bad request syntax (%r)" % requestline)

return False

self.command, self.path, self.request_version = command, path, version

# Examine the headers and look for a Connection directive.

try:

self.headers = http.client.parse_headers(self.rfile,

_class=self.MessageClass)

except http.client.LineTooLong:

self.send_error(400, "Line too long")

return False

conntype = self.headers.get('Connection', "")

if conntype.lower() == 'close':

self.close_connection = 1

elif (conntype.lower() == 'keep-alive' and

self.protocol_version >= "HTTP/1.1"):

self.close_connection = 0

# Examine the headers and look for an Expect directive

expect = self.headers.get('Expect', "")

if (expect.lower() == "100-continue" and

self.protocol_version >= "HTTP/1.1" and

self.request_version >= "HTTP/1.1"):

if not self.handle_expect_100():

return False

return True

def handle_expect_100(self):

"""Decide what to do with an "Expect: 100-continue" header.

self.send_response_only(100)

self.end_headers()

return True

def handle_one_request(self):

"""Handle a single HTTP request.

try:

self.raw_requestline = self.rfile.readline(65537)

if len(self.raw_requestline) > 65536:

self.requestline = ''

self.request_version = ''

self.command = ''

self.send_error(414)

return

if not self.raw_requestline:

self.close_connection = 1

return

if not self.parse_request():

# An error code has been sent, just exit

return

mname = 'do_' + self.command

if not hasattr(self, mname):

self.send_error(501, "Unsupported method (%r)" % self.command)

return

method = getattr(self, mname)

method()

self.wfile.flush() #actually send the response if not already done.

except socket.timeout as e:

#a read or a write timed out. Discard this connection

self.log_error("Request timed out: %r", e)

self.close_connection = 1

return

def handle(self):

"""Handle multiple requests if necessary."""

self.close_connection = 1

self.handle_one_request()

while not self.close_connection:

self.handle_one_request()

def send_error(self, code, message=None, explain=None):

"""Send and log an error reply.

try:

shortmsg, longmsg = self.responses[code]

except KeyError:

shortmsg, longmsg = '???', '???'

if message is None:

message = shortmsg

if explain is None:

explain = longmsg

self.log_error("code %d, message %s", code, message)

# using _quote_html to prevent Cross Site Scripting attacks (see bug #1100201)

content = (self.error_message_format %

{'code': code, 'message': _quote_html(message), 'explain': _quote_html(explain)})

body = content.encode('UTF-8', 'replace')

self.send_response(code, message)

self.send_header("Content-Type", self.error_content_type)

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

self.send_header('Content-Length', int(len(body)))

self.end_headers()

if self.command != 'HEAD' and code >= 200 and code not in (204, 304):

self.wfile.write(body)

def send_response(self, code, message=None):

"""Add the response header to the headers buffer and log the

self.log_request(code)

self.send_response_only(code, message)

self.send_header('Server', self.version_string())

self.send_header('Date', self.date_time_string())

def send_response_only(self, code, message=None):

"""Send the response header only."""

if message is None:

if code in self.responses:

message = self.responses[code][0]

else:

message = ''

if self.request_version != 'HTTP/0.9':

if not hasattr(self, '_headers_buffer'):

self._headers_buffer = []

self._headers_buffer.append(("%s %d %s\r\n" %

(self.protocol_version, code, message)).encode(

'latin-1', 'strict'))

def send_header(self, keyword, value):

"""Send a MIME header to the headers buffer."""

if self.request_version != 'HTTP/0.9':

if not hasattr(self, '_headers_buffer'):

self._headers_buffer = []

self._headers_buffer.append(

("%s: %s\r\n" % (keyword, value)).encode('latin-1', 'strict'))

if keyword.lower() == 'connection':

if value.lower() == 'close':

self.close_connection = 1

elif value.lower() == 'keep-alive':

self.close_connection = 0

def end_headers(self):

"""Send the blank line ending the MIME headers."""

if self.request_version != 'HTTP/0.9':

self._headers_buffer.append(b"\r\n")

self.flush_headers()

def flush_headers(self):

if hasattr(self, '_headers_buffer'):

self.wfile.write(b"".join(self._headers_buffer))

self._headers_buffer = []

def log_request(self, code='-', size='-'):

"""Log an accepted request.

self.log_message('"%s" %s %s',

self.requestline, str(code), str(size))

def log_error(self, format, *args):

"""Log an error.

self.log_message(format, *args)

def log_message(self, format, *args):

"""Log an arbitrary message.

sys.stderr.write("%s - - [%s] %s\n" %

(self.address_string(),

self.log_date_time_string(),

format%args))

def version_string(self):

"""Return the server software version string."""

return self.server_version + ' ' + self.sys_version

def date_time_string(self, timestamp=None):

"""Return the current date and time formatted for a message header."""

if timestamp is None:

timestamp = time.time()

year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp)

s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (

self.weekdayname[wd],

day, self.monthname[month], year,

hh, mm, ss)

return s

def log_date_time_string(self):

"""Return the current time formatted for logging."""

now = time.time()

year, month, day, hh, mm, ss, x, y, z = time.localtime(now)

s = "%02d/%3s/%04d %02d:%02d:%02d" % (

day, self.monthname[month], year, hh, mm, ss)

return s

weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

monthname = [None,

'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',

'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

def address_string(self):

"""Return the client address."""

return self.client_address[0]

# Essentially static class variables

# The version of the HTTP protocol we support.

# Set this to HTTP/1.1 to enable automatic keepalive

protocol_version = "HTTP/1.0"

# MessageClass used to parse headers

MessageClass = http.client.HTTPMessage

# Table mapping response codes to messages; entries have the

# form {code: (shortmessage, longmessage)}.

# See RFC 2616 and 6585.

responses = {

100: ('Continue', 'Request received, please continue'),

101: ('Switching Protocols',

'Switching to new protocol; obey Upgrade header'),

200: ('OK', 'Request fulfilled, document follows'),

201: ('Created', 'Document created, URL follows'),

202: ('Accepted',

'Request accepted, processing continues off-line'),

203: ('Non-Authoritative Information', 'Request fulfilled from cache'),

204: ('No Content', 'Request fulfilled, nothing follows'),

205: ('Reset Content', 'Clear input form for further input.'),

206: ('Partial Content', 'Partial content follows.'),

300: ('Multiple Choices',

'Object has several resources -- see URI list'),

301: ('Moved Permanently', 'Object moved permanently -- see URI list'),

302: ('Found', 'Object moved temporarily -- see URI list'),

303: ('See Other', 'Object moved -- see Method and URL list'),

304: ('Not Modified',

'Document has not changed since given time'),

305: ('Use Proxy',

'You must use proxy specified in Location to access this '

'resource.'),

307: ('Temporary Redirect',

'Object moved temporarily -- see URI list'),

400: ('Bad Request',

'Bad request syntax or unsupported method'),

401: ('Unauthorized',

'No permission -- see authorization schemes'),

402: ('Payment Required',

'No payment -- see charging schemes'),

403: ('Forbidden',

'Request forbidden -- authorization will not help'),

404: ('Not Found', 'Nothing matches the given URI'),

405: ('Method Not Allowed',

'Specified method is invalid for this resource.'),

406: ('Not Acceptable', 'URI not available in preferred format.'),

407: ('Proxy Authentication Required', 'You must authenticate with '

'this proxy before proceeding.'),

408: ('Request Timeout', 'Request timed out; try again later.'),

409: ('Conflict', 'Request conflict.'),

410: ('Gone',

'URI no longer exists and has been permanently removed.'),

411: ('Length Required', 'Client must specify Content-Length.'),

412: ('Precondition Failed', 'Precondition in headers is false.'),

413: ('Request Entity Too Large', 'Entity is too large.'),

414: ('Request-URI Too Long', 'URI is too long.'),

415: ('Unsupported Media Type', 'Entity body in unsupported format.'),

416: ('Requested Range Not Satisfiable',

'Cannot satisfy request range.'),

417: ('Expectation Failed',

'Expect condition could not be satisfied.'),

428: ('Precondition Required',

'The origin server requires the request to be conditional.'),

429: ('Too Many Requests', 'The user has sent too many requests '

'in a given amount of time ("rate limiting").'),

431: ('Request Header Fields Too Large', 'The server is unwilling to '

'process the request because its header fields are too large.'),

500: ('Internal Server Error', 'Server got itself in trouble'),

501: ('Not Implemented',

'Server does not support this operation'),

502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),

503: ('Service Unavailable',

'The server cannot process the request due to a high load'),

504: ('Gateway Timeout',

'The gateway server did not receive a timely response'),

505: ('HTTP Version Not Supported', 'Cannot fulfill request.'),

511: ('Network Authentication Required',

'The client needs to authenticate to gain network access.'),

"""Simple HTTP request handler with GET and HEAD commands.

server_version = "SimpleHTTP/" + __version__

def do_GET(self):

"""Serve a GET request."""

f = self.send_head()

if f:

try:

self.copyfile(f, self.wfile)

finally:

f.close()

def do_HEAD(self):

"""Serve a HEAD request."""

f = self.send_head()

if f:

f.close()

def send_head(self):

"""Common code for GET and HEAD commands.

path = self.translate_path(self.path)

f = None

if os.path.isdir(path):

if not self.path.endswith('/'):

# redirect browser - doing basically what apache does

self.send_response(301)

self.send_header("Location", self.path + "/")

self.end_headers()

return None

for index in "index.html", "index.htm":

index = os.path.join(path, index)

if os.path.exists(index):

path = index

break

else:

return self.list_directory(path)

ctype = self.guess_type(path)

try:

f = open(path, 'rb')

except OSError:

self.send_error(404, "File not found")

return None

try:

self.send_response(200)

self.send_header("Content-type", ctype)

fs = os.fstat(f.fileno())

self.send_header("Content-Length", str(fs[6]))

self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))

self.end_headers()

return f

except:

f.close()

raise

def list_directory(self, path):

"""Helper to produce a directory listing (absent index.html).

try:

list = os.listdir(path)

except OSError:

self.send_error(404, "No permission to list directory")

return None

list.sort(key=lambda a: a.lower())

r = []

displaypath = html.escape(urllib.parse.unquote(self.path))

enc = sys.getfilesystemencoding()

title = 'Directory listing for %s' % displaypath

r.append('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" '

'"http://www.w3.org/TR/html4/strict.dtd">')

r.append('<html>\n<head>')

r.append('<meta http-equiv="Content-Type" '

'content="text/html; charset=%s">' % enc)

r.append('<title>%s</title>\n</head>' % title)

r.append('<body>\n<h1>%s</h1>' % title)

r.append('<hr>\n<ul>')

for name in list:

fullname = os.path.join(path, name)

displayname = linkname = name

# Append / for directories or @ for symbolic links

if os.path.isdir(fullname):

displayname = name + "/"

linkname = name + "/"

if os.path.islink(fullname):

displayname = name + "@"

# Note: a link to a directory displays with @ and links with /

r.append('<li><a href="%s">%s</a></li>'

% (urllib.parse.quote(linkname), html.escape(displayname)))

r.append('</ul>\n<hr>\n</body>\n</html>\n')

encoded = '\n'.join(r).encode(enc)

f = io.BytesIO()

f.write(encoded)

f.seek(0)

self.send_response(200)

self.send_header("Content-type", "text/html; charset=%s" % enc)

self.send_header("Content-Length", str(len(encoded)))

self.end_headers()

return f

def translate_path(self, path):

"""Translate a /-separated PATH to the local filename syntax.

# abandon query parameters

path = path.split('?',1)[0]

path = path.split('#',1)[0]

# Don't forget explicit trailing slash when normalizing. Issue17324

trailing_slash = path.rstrip().endswith('/')

path = posixpath.normpath(urllib.parse.unquote(path))

words = path.split('/')

words = filter(None, words)

path = os.getcwd()

for word in words:

drive, word = os.path.splitdrive(word)

head, word = os.path.split(word)

if word in (os.curdir, os.pardir): continue

path = os.path.join(path, word)

if trailing_slash:

path += '/'

return path

def copyfile(self, source, outputfile):

"""Copy all data between two file objects.

shutil.copyfileobj(source, outputfile)

def guess_type(self, path):

"""Guess the type of a file.

base, ext = posixpath.splitext(path)

if ext in self.extensions_map:

return self.extensions_map[ext]

ext = ext.lower()

if ext in self.extensions_map:

return self.extensions_map[ext]

else:

return self.extensions_map['']

if not mimetypes.inited:

mimetypes.init() # try to read system mime.types

extensions_map = mimetypes.types_map.copy()

extensions_map.update({

'': 'application/octet-stream', # Default

'.py': 'text/plain',

'.c': 'text/plain',

'.h': 'text/plain',

"""

# Similar to os.path.split(os.path.normpath(path)) but specific to URL

# path semantics rather than local operating system semantics.

path_parts = path.split('/')

head_parts = []

for part in path_parts[:-1]:

if part == '..':

head_parts.pop() # IndexError if more '..' than prior parts

elif part and part != '.':

head_parts.append( part )

if path_parts:

tail_part = path_parts.pop()

if tail_part:

if tail_part == '..':

head_parts.pop()

tail_part = ''

elif tail_part == '.':

tail_part = ''

else:

tail_part = ''

splitpath = ('/' + '/'.join(head_parts), tail_part)

collapsed_path = "/".join(splitpath)

"""Internal routine to get nobody's uid"""

global nobody

if nobody:

return nobody

try:

import pwd

except ImportError:

return -1

try:

nobody = pwd.getpwnam('nobody')[2]

except KeyError:

nobody = 1 + max(x[2] for x in pwd.getpwall())

"""Complete HTTP server with GET, HEAD and POST commands.

# Determine platform specifics

have_fork = hasattr(os, 'fork')

# Make rfile unbuffered -- we need to read one line and then pass

# the rest to a subprocess, so we can't use buffered input.

rbufsize = 0

def do_POST(self):

"""Serve a POST request.

if self.is_cgi():

self.run_cgi()

else:

self.send_error(501, "Can only POST to CGI scripts")

def send_head(self):

"""Version of send_head that support CGI scripts"""

if self.is_cgi():

return self.run_cgi()

else:

return SimpleHTTPRequestHandler.send_head(self)

def is_cgi(self):

"""Test whether self.path corresponds to a CGI script.

collapsed_path = _url_collapse_path(self.path)

dir_sep = collapsed_path.find('/', 1)

head, tail = collapsed_path[:dir_sep], collapsed_path[dir_sep+1:]

if head in self.cgi_directories:

self.cgi_info = head, tail

return True

return False

cgi_directories = ['/cgi-bin', '/htbin']

def is_executable(self, path):

"""Test whether argument path is an executable file."""

return executable(path)

def is_python(self, path):

"""Test whether argument path is a Python script."""

head, tail = os.path.splitext(path)

return tail.lower() in (".py", ".pyw")