| """Simple HTTP Server. |
| |
| This module builds on BaseHTTPServer by implementing the standard GET |
| and HEAD requests in a fairly straightforward manner. |
| |
| """ |
| |
| |
| __version__ = "0.6" |
| |
| __all__ = ["SimpleHTTPRequestHandler"] |
| |
| import os |
| import posixpath |
| import BaseHTTPServer |
| import urllib |
| import urlparse |
| import cgi |
| import shutil |
| import mimetypes |
| from io import StringIO |
| |
| |
| class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): |
| |
| """Simple HTTP request handler with GET and HEAD commands. |
| |
| This serves files from the current directory and any of its |
| subdirectories. The MIME type for files is determined by |
| calling the .guess_type() method. |
| |
| The GET and HEAD requests are identical except that the HEAD |
| request omits the actual contents of the file. |
| |
| """ |
| |
| server_version = "SimpleHTTP/" + __version__ |
| |
| def do_GET(self): |
| """Serve a GET request.""" |
| f = self.send_head() |
| if f: |
| self.copyfile(f, self.wfile) |
| 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. |
| |
| This sends the response code and MIME headers. |
| |
| Return value is either a file object (which has to be copied |
| to the outputfile by the caller unless the command was HEAD, |
| and must be closed by the caller under all circumstances), or |
| None, in which case the caller has nothing further to do. |
| |
| """ |
| 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) |
| if ctype.startswith('text/'): |
| mode = 'r' |
| else: |
| mode = 'rb' |
| try: |
| f = open(path, mode) |
| except IOError: |
| self.send_error(404, "File not found") |
| return None |
| 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 |
| |
| def list_directory(self, path): |
| """Helper to produce a directory listing (absent index.html). |
| |
| Return value is either a file object, or None (indicating an |
| error). In either case, the headers are sent, making the |
| interface the same as for send_head(). |
| |
| """ |
| try: |
| list = os.listdir(path) |
| except os.error: |
| self.send_error(404, "No permission to list directory") |
| return None |
| list.sort(key=lambda a: a.lower()) |
| f = StringIO() |
| displaypath = cgi.escape(urllib.unquote(self.path)) |
| f.write("<title>Directory listing for %s</title>\n" % displaypath) |
| f.write("<h2>Directory listing for %s</h2>\n" % displaypath) |
| f.write("<hr>\n<ul>\n") |
| 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 / |
| f.write('<li><a href="%s">%s</a>\n' |
| % (urllib.quote(linkname), cgi.escape(displayname))) |
| f.write("</ul>\n<hr>\n") |
| length = f.tell() |
| f.seek(0) |
| self.send_response(200) |
| self.send_header("Content-type", "text/html") |
| self.send_header("Content-Length", str(length)) |
| self.end_headers() |
| return f |
| |
| def translate_path(self, path): |
| """Translate a /-separated PATH to the local filename syntax. |
| |
| Components that mean special things to the local file system |
| (e.g. drive or directory names) are ignored. (XXX They should |
| probably be diagnosed.) |
| |
| """ |
| # abandon query parameters |
| path = urlparse.urlparse(path)[2] |
| path = posixpath.normpath(urllib.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) |
| return path |
| |
| def copyfile(self, source, outputfile): |
| """Copy all data between two file objects. |
| |
| The SOURCE argument is a file object open for reading |
| (or anything with a read() method) and the DESTINATION |
| argument is a file object open for writing (or |
| anything with a write() method). |
| |
| The only reason for overriding this would be to change |
| the block size or perhaps to replace newlines by CRLF |
| -- note however that this the default server uses this |
| to copy binary data as well. |
| |
| """ |
| shutil.copyfileobj(source, outputfile) |
| |
| def guess_type(self, path): |
| """Guess the type of a file. |
| |
| Argument is a PATH (a filename). |
| |
| Return value is a string of the form type/subtype, |
| usable for a MIME Content-type header. |
| |
| The default implementation looks the file's extension |
| up in the table self.extensions_map, using application/octet-stream |
| as a default; however it would be permissible (if |
| slow) to look inside the data to make a better guess. |
| |
| """ |
| |
| 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', |
| }) |
| |
| |
| def test(HandlerClass = SimpleHTTPRequestHandler, |
| ServerClass = BaseHTTPServer.HTTPServer): |
| BaseHTTPServer.test(HandlerClass, ServerClass) |
| |
| |
| if __name__ == '__main__': |
| test() |