Lib/BaseHTTPServer.py

   1 """HTTP server base class.
   2
   3 Note: the class in this module doesn't implement any HTTP request; see
   4 SimpleHTTPServer for simple implementations of GET, HEAD and POST
   5 (including CGI scripts).  It does, however, optionally implement HTTP/1.1
   6 persistent connections, as of version 0.3.
   7
   8 Contents:
   9
  10 - BaseHTTPRequestHandler: HTTP request handler base class
  11 - test: test function
  12
  13 XXX To do:
  14
  15 - log requests even later (to capture byte count)
  16 - log user-agent header and other interesting goodies
  17 - send error log to separate file
  18 """
  19
  20
  21 # See also:
  22 #
  23 # HTTP Working Group                                        T. Berners-Lee
  24 # INTERNET-DRAFT                                            R. T. Fielding
  25 # <draft-ietf-http-v10-spec-00.txt>                     H. Frystyk Nielsen
  26 # Expires September 8, 1995                                  March 8, 1995
  27 #
  28 # URL: http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-v10-spec-00.txt
  29 #
  30 # and
  31 #
  32 # Network Working Group                                      R. Fielding
  33 # Request for Comments: 2616                                       et al
  34 # Obsoletes: 2068                                              June 1999
  35 # Category: Standards Track
  36 #
  37 # URL: http://www.faqs.org/rfcs/rfc2616.html
  38
  39 # Log files
  40 # ---------
  41 #
  42 # Here's a quote from the NCSA httpd docs about log file format.
  43 #
  44 # | The logfile format is as follows. Each line consists of:
  45 # |
  46 # | host rfc931 authuser [DD/Mon/YYYY:hh:mm:ss] "request" ddd bbbb
  47 # |
  48 # |        host: Either the DNS name or the IP number of the remote client
  49 # |        rfc931: Any information returned by identd for this person,
  50 # |                - otherwise.
  51 # |        authuser: If user sent a userid for authentication, the user name,
  52 # |                  - otherwise.
  53 # |        DD: Day
  54 # |        Mon: Month (calendar name)
  55 # |        YYYY: Year
  56 # |        hh: hour (24-hour format, the machine's timezone)
  57 # |        mm: minutes
  58 # |        ss: seconds
  59 # |        request: The first line of the HTTP request as sent by the client.
  60 # |        ddd: the status code returned by the server, - if not available.
  61 # |        bbbb: the total number of bytes sent,
  62 # |              *not including the HTTP/1.0 header*, - if not available
  63 # |
  64 # | You can determine the name of the file accessed through request.
  65 #
  66 # (Actually, the latter is only true if you know the server configuration
  67 # at the time the request was made!)
  68
  69 __version__ = "0.3"
  70
  71 __all__ = ["HTTPServer", "BaseHTTPRequestHandler"]
  72
  73 import sys
  74 import time
  75 import socket # For gethostbyaddr()
  76 import mimetools
  77 import SocketServer
  78 import cStringIO
  79
  80 # Default error message
  81 DEFAULT_ERROR_MESSAGE = """\
  82 <head>
  83 <title>Error response</title>
  84 </head>
  85 <body>
  86 <h1>Error response</h1>
  87 <p>Error code %(code)d.
  88 <p>Message: %(message)s.
  89 <p>Error code explanation: %(code)s = %(explain)s.
  90 </body>
  91 """
  92
  93
  94 class HTTPServer(SocketServer.TCPServer):
  95
  96     allow_reuse_address = 1    # Seems to make sense in testing environment
  97
  98     def server_bind(self):
  99         """Override server_bind to store the server name."""
 100         SocketServer.TCPServer.server_bind(self)
 101         host, port = self.socket.getsockname()
 102         self.server_name = socket.getfqdn(host)
 103         self.server_port = port
 104
 105
 106 class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
 107
 108     """HTTP request handler base class.
 109
 110     The following explanation of HTTP serves to guide you through the
 111     code as well as to expose any misunderstandings I may have about
 112     HTTP (so you don't need to read the code to figure out I'm wrong
 113     :-).
 114
 115     HTTP (HyperText Transfer Protocol) is an extensible protocol on
 116     top of a reliable stream transport (e.g. TCP/IP).  The protocol
 117     recognizes three parts to a request:
 118
 119     1. One line identifying the request type and path
 120     2. An optional set of RFC-822-style headers
 121     3. An optional data part
 122
 123     The headers and data are separated by a blank line.
 124
 125     The first line of the request has the form
 126
 127     <command> <path> <version>
 128
 129     where <command> is a (case-sensitive) keyword such as GET or POST,
 130     <path> is a string containing path information for the request,
 131     and <version> should be the string "HTTP/1.0" or "HTTP/1.1".
 132     <path> is encoded using the URL encoding scheme (using %xx to signify
 133     the ASCII character with hex code xx).
 134
 135     The protocol is vague about whether lines are separated by LF
 136     characters or by CRLF pairs -- for compatibility with the widest
 137     range of clients, both should be accepted.  Similarly, whitespace
 138     in the request line should be treated sensibly (allowing multiple
 139     spaces between components and allowing trailing whitespace).
 140
 141     Similarly, for output, lines ought to be separated by CRLF pairs
 142     but most clients grok LF characters just fine.
 143
 144     If the first line of the request has the form
 145
 146     <command> <path>
 147
 148     (i.e. <version> is left out) then this is assumed to be an HTTP
 149     0.9 request; this form has no optional headers and data part and
 150     the reply consists of just the data.
 151
 152     The reply form of the HTTP 1.x protocol again has three parts:
 153
 154     1. One line giving the response code
 155     2. An optional set of RFC-822-style headers
 156     3. The data
 157
 158     Again, the headers and data are separated by a blank line.
 159
 160     The response code line has the form
 161
 162     <version> <responsecode> <responsestring>
 163
 164     where <version> is the protocol version ("HTTP/1.0" or "HTTP/1.1"),
 165     <responsecode> is a 3-digit response code indicating success or
 166     failure of the request, and <responsestring> is an optional
 167     human-readable string explaining what the response code means.
 168
 169     This server parses the request and the headers, and then calls a
 170     function specific to the request type (<command>).  Specifically,
 171     a request SPAM will be handled by a method do_SPAM().  If no
 172     such method exists the server sends an error response to the
 173     client.  If it exists, it is called with no arguments:
 174
 175     do_SPAM()
 176
 177     Note that the request name is case sensitive (i.e. SPAM and spam
 178     are different requests).
 179
 180     The various request details are stored in instance variables:
 181
 182     - client_address is the client IP address in the form (host,
 183     port);
 184
 185     - command, path and version are the broken-down request line;
 186
 187     - headers is an instance of mimetools.Message (or a derived
 188     class) containing the header information;
 189
 190     - rfile is a file object open for reading positioned at the
 191     start of the optional input data part;
 192
 193     - wfile is a file object open for writing.
 194
 195     IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!
 196
 197     The first thing to be written must be the response line.  Then
 198     follow 0 or more header lines, then a blank line, and then the
 199     actual data (if any).  The meaning of the header lines depends on
 200     the command executed by the server; in most cases, when data is
 201     returned, there should be at least one header line of the form
 202
 203     Content-type: <type>/<subtype>
 204
 205     where <type> and <subtype> should be registered MIME types,
 206     e.g. "text/html" or "text/plain".
 207
 208     """
 209
 210     # The Python system version, truncated to its first component.
 211     sys_version = "Python/" + sys.version.split()[0]
 212
 213     # The server software version.  You may want to override this.
 214     # The format is multiple whitespace-separated strings,
 215     # where each string is of the form name[/version].
 216     server_version = "BaseHTTP/" + __version__
 217
 218     def parse_request(self):
 219         """Parse a request (internal).
 220
 221         The request should be stored in self.raw_request; the results
 222         are in self.command, self.path, self.request_version and
 223         self.headers.
 224
 225         Return True for success, False for failure; on failure, an
 226         error is sent back.
 227
 228         """
 229         self.request_version = version = "HTTP/0.9" # Default
 230         self.close_connection = 1
 231         requestline = self.raw_requestline
 232         if requestline[-2:] == '\r\n':
 233             requestline = requestline[:-2]
 234         elif requestline[-1:] == '\n':
 235             requestline = requestline[:-1]
 236         self.requestline = requestline
 237         words = requestline.split()
 238         if len(words) == 3:
 239             [command, path, version] = words
 240             if version[:5] != 'HTTP/':
 241                 self.send_error(400, "Bad request version (%s)" % `version`)
 242                 return False
 243             try:
 244                 version_number = float(version.split('/', 1)[1])
 245             except ValueError:
 246                 self.send_error(400, "Bad request version (%s)" % `version`)
 247                 return False
 248             if version_number >= 1.1 and self.protocol_version >= "HTTP/1.1":
 249                 self.close_connection = 0
 250             if version_number >= 2.0:
 251                 self.send_error(505,
 252                                 "Invalid HTTP Version (%f)" % version_number)
 253                 return False
 254         elif len(words) == 2:
 255             [command, path] = words
 256             self.close_connection = 1
 257             if command != 'GET':
 258                 self.send_error(400,
 259                                 "Bad HTTP/0.9 request type (%s)" % `command`)
 260                 return False
 261         elif not words:
 262             return False
 263         else:
 264             self.send_error(400, "Bad request syntax (%s)" % `requestline`)
 265             return False
 266         self.command, self.path, self.request_version = command, path, version
 267
 268         # Deal with pipelining
 269         bytes = ""
 270         while 1:
 271             line = self.rfile.readline()
 272             bytes = bytes + line
 273             if line == '\r\n' or line == '\n' or line == '':
 274                 break
 275
 276         # Examine the headers and look for a Connection directive
 277         hfile = cStringIO.StringIO(bytes)
 278         self.headers = self.MessageClass(hfile)
 279
 280         conntype = self.headers.get('Connection', "")
 281         if conntype.lower() == 'close':
 282             self.close_connection = 1
 283         elif (conntype.lower() == 'keep-alive' and
 284               self.protocol_version >= "HTTP/1.1"):
 285             self.close_connection = 0
 286         return True
 287
 288     def handle_one_request(self):
 289         """Handle a single HTTP request.
 290
 291         You normally don't need to override this method; see the class
 292         __doc__ string for information on how to handle specific HTTP
 293         commands such as GET and POST.
 294
 295         """
 296         self.raw_requestline = self.rfile.readline()
 297         if not self.raw_requestline:
 298             self.close_connection = 1
 299             return
 300         if not self.parse_request(): # An error code has been sent, just exit
 301             return
 302         mname = 'do_' + self.command
 303         if not hasattr(self, mname):
 304             self.send_error(501, "Unsupported method (%s)" % `self.command`)
 305             return
 306         method = getattr(self, mname)
 307         method()
 308
 309     def handle(self):
 310         """Handle multiple requests if necessary."""
 311         self.close_connection = 1
 312
 313         self.handle_one_request()
 314         while not self.close_connection:
 315             self.handle_one_request()
 316
 317     def send_error(self, code, message=None):
 318         """Send and log an error reply.
 319
 320         Arguments are the error code, and a detailed message.
 321         The detailed message defaults to the short entry matching the
 322         response code.
 323
 324         This sends an error response (so it must be called before any
 325         output has been generated), logs the error, and finally sends
 326         a piece of HTML explaining the error to the user.
 327
 328         """
 329
 330         try:
 331             short, long = self.responses[code]
 332         except KeyError:
 333             short, long = '???', '???'
 334         if message is None:
 335             message = short
 336         explain = long
 337         self.log_error("code %d, message %s", code, message)
 338         content = (self.error_message_format %
 339                    {'code': code, 'message': message, 'explain': explain})
 340         self.send_response(code, message)
 341         self.send_header("Content-Type", "text/html")
 342         self.send_header('Connection', 'close')
 343         self.end_headers()
 344         if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
 345             self.wfile.write(content)
 346
 347     error_message_format = DEFAULT_ERROR_MESSAGE
 348
 349     def send_response(self, code, message=None):
 350         """Send the response header and log the response code.
 351
 352         Also send two standard headers with the server software
 353         version and the current date.
 354
 355         """
 356         self.log_request(code)
 357         if message is None:
 358             if code in self.responses:
 359                 message = self.responses[code][0]
 360             else:
 361                 message = ''
 362         if self.request_version != 'HTTP/0.9':
 363             self.wfile.write("%s %d %s\r\n" %
 364                              (self.protocol_version, code, message))
 365             # print (self.protocol_version, code, message)
 366         self.send_header('Server', self.version_string())
 367         self.send_header('Date', self.date_time_string())
 368
 369     def send_header(self, keyword, value):
 370         """Send a MIME header."""
 371         if self.request_version != 'HTTP/0.9':
 372             self.wfile.write("%s: %s\r\n" % (keyword, value))
 373
 374         if keyword.lower() == 'connection':
 375             if value.lower() == 'close':
 376                 self.close_connection = 1
 377             elif value.lower() == 'keep-alive':
 378                 self.close_connection = 0
 379
 380     def end_headers(self):
 381         """Send the blank line ending the MIME headers."""
 382         if self.request_version != 'HTTP/0.9':
 383             self.wfile.write("\r\n")
 384
 385     def log_request(self, code='-', size='-'):
 386         """Log an accepted request.
 387
 388         This is called by send_reponse().
 389
 390         """
 391
 392         self.log_message('"%s" %s %s',
 393                          self.requestline, str(code), str(size))
 394
 395     def log_error(self, *args):
 396         """Log an error.
 397
 398         This is called when a request cannot be fulfilled.  By
 399         default it passes the message on to log_message().
 400
 401         Arguments are the same as for log_message().
 402
 403         XXX This should go to the separate error log.
 404
 405         """
 406
 407         apply(self.log_message, args)
 408
 409     def log_message(self, format, *args):
 410         """Log an arbitrary message.
 411
 412         This is used by all other logging functions.  Override
 413         it if you have specific logging wishes.
 414
 415         The first argument, FORMAT, is a format string for the
 416         message to be logged.  If the format string contains
 417         any % escapes requiring parameters, they should be
 418         specified as subsequent arguments (it's just like
 419         printf!).
 420
 421         The client host and current date/time are prefixed to
 422         every message.
 423
 424         """
 425
 426         sys.stderr.write("%s - - [%s] %s\n" %
 427                          (self.address_string(),
 428                           self.log_date_time_string(),
 429                           format%args))
 430
 431     def version_string(self):
 432         """Return the server software version string."""
 433         return self.server_version + ' ' + self.sys_version
 434
 435     def date_time_string(self):
 436         """Return the current date and time formatted for a message header."""
 437         now = time.time()
 438         year, month, day, hh, mm, ss, wd, y, z = time.gmtime(now)
 439         s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
 440                 self.weekdayname[wd],
 441                 day, self.monthname[month], year,
 442                 hh, mm, ss)
 443         return s
 444
 445     def log_date_time_string(self):
 446         """Return the current time formatted for logging."""
 447         now = time.time()
 448         year, month, day, hh, mm, ss, x, y, z = time.localtime(now)
 449         s = "%02d/%3s/%04d %02d:%02d:%02d" % (
 450                 day, self.monthname[month], year, hh, mm, ss)
 451         return s
 452
 453     weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
 454
 455     monthname = [None,
 456                  'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
 457                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
 458
 459     def address_string(self):
 460         """Return the client address formatted for logging.
 461
 462         This version looks up the full hostname using gethostbyaddr(),
 463         and tries to find a name that contains at least one dot.
 464
 465         """
 466
 467         host, port = self.client_address
 468         return socket.getfqdn(host)
 469
 470     # Essentially static class variables
 471
 472     # The version of the HTTP protocol we support.
 473     # Set this to HTTP/1.1 to enable automatic keepalive
 474     protocol_version = "HTTP/1.0"
 475
 476     # The Message-like class used to parse headers
 477     MessageClass = mimetools.Message
 478
 479     # Table mapping response codes to messages; entries have the
 480     # form {code: (shortmessage, longmessage)}.
 481     # See http://www.w3.org/hypertext/WWW/Protocols/HTTP/HTRESP.html
 482     responses = {
 483         100: ('Continue', 'Request received, please continue'),
 484         101: ('Switching Protocols',
 485               'Switching to new protocol; obey Upgrade header'),
 486
 487         200: ('OK', 'Request fulfilled, document follows'),
 488         201: ('Created', 'Document created, URL follows'),
 489         202: ('Accepted',
 490               'Request accepted, processing continues off-line'),
 491         203: ('Non-Authoritative Information', 'Request fulfilled from cache'),
 492         204: ('No response', 'Request fulfilled, nothing follows'),
 493         205: ('Reset Content', 'Clear input form for further input.'),
 494         206: ('Partial Content', 'Partial content follows.'),
 495
 496         300: ('Multiple Choices',
 497               'Object has several resources -- see URI list'),
 498         301: ('Moved Permanently', 'Object moved permanently -- see URI list'),
 499         302: ('Found', 'Object moved temporarily -- see URI list'),
 500         303: ('See Other', 'Object moved -- see Method and URL list'),
 501         304: ('Not modified',
 502               'Document has not changed since given time'),
 503         305: ('Use Proxy',
 504               'You must use proxy specified in Location to access this '
 505               'resource.'),
 506         307: ('Temporary Redirect',
 507               'Object moved temporarily -- see URI list'),
 508
 509         400: ('Bad request',
 510               'Bad request syntax or unsupported method'),
 511         401: ('Unauthorized',
 512               'No permission -- see authorization schemes'),
 513         402: ('Payment required',
 514               'No payment -- see charging schemes'),
 515         403: ('Forbidden',
 516               'Request forbidden -- authorization will not help'),
 517         404: ('Not Found', 'Nothing matches the given URI'),
 518         405: ('Method Not Allowed',
 519               'Specified method is invalid for this server.'),
 520         406: ('Not Acceptable', 'URI not available in preferred format.'),
 521         407: ('Proxy Authentication Required', 'You must authenticate with '
 522               'this proxy before proceeding.'),
 523         408: ('Request Time-out', 'Request timed out; try again later.'),
 524         409: ('Conflict', 'Request conflict.'),
 525         410: ('Gone',
 526               'URI no longer exists and has been permanently removed.'),
 527         411: ('Length Required', 'Client must specify Content-Length.'),
 528         412: ('Precondition Failed', 'Precondition in headers is false.'),
 529         413: ('Request Entity Too Large', 'Entity is too large.'),
 530         414: ('Request-URI Too Long', 'URI is too long.'),
 531         415: ('Unsupported Media Type', 'Entity body in unsupported format.'),
 532         416: ('Requested Range Not Satisfiable',
 533               'Cannot satisfy request range.'),
 534         417: ('Expectation Failed',
 535               'Expect condition could not be satisfied.'),
 536
 537         500: ('Internal error', 'Server got itself in trouble'),
 538         501: ('Not Implemented',
 539               'Server does not support this operation'),
 540         502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),
 541         503: ('Service temporarily overloaded',
 542               'The server cannot process the request due to a high load'),
 543         504: ('Gateway timeout',
 544               'The gateway server did not receive a timely response'),
 545         505: ('HTTP Version not supported', 'Cannot fulfill request.'),
 546         }
 547
 548
 549 def test(HandlerClass = BaseHTTPRequestHandler,
 550          ServerClass = HTTPServer, protocol="HTTP/1.0"):
 551     """Test the HTTP request handler class.
 552
 553     This runs an HTTP server on port 8000 (or the first command line
 554     argument).
 555
 556     """
 557
 558     if sys.argv[1:]:
 559         port = int(sys.argv[1])
 560     else:
 561         port = 8000
 562     server_address = ('', port)
 563
 564     HandlerClass.protocol_version = protocol
 565     httpd = ServerClass(server_address, HandlerClass)
 566
 567     sa = httpd.socket.getsockname()
 568     print "Serving HTTP on", sa[0], "port", sa[1], "..."
 569     httpd.serve_forever()
 570
 571
 572 if __name__ == '__main__':
 573     test()