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