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