Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / e9792c4563a332bca6598bc444b6a30ed34ae724 / . / Lib / BaseHTTPServer.py
blob: 10a706e1f8d485d7be56d96a8cad38a11ad08b4d [file] [log] [blame]
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]1"""HTTP server base class.
2
3Note: the class in this module doesn't implement any HTTP request; see
4SimpleHTTPServer for simple implementations of GET, HEAD and POST
5(including CGI scripts).
6
7Contents:
8
9- BaseHTTPRequestHandler: HTTP request handler base class
10- test: test function
11
12XXX 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
67import sys
68import time
69import socket # For gethostbyaddr()
70import string
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]71import mimetools
72import SocketServer
73
74# Default error message
75DEFAULT_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
88class HTTPServer(SocketServer.TCPServer):
89
90 def server_bind(self):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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()
Guido van Rossum145a5f71999-06-09 15:05:47 +0000[diff] [blame]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
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]106 self.server_name = hostname
107 self.server_port = port
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]108
109
110class 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,
Guido van Rossumba895d81999-09-15 15:28:25 +0000[diff] [blame]175 a request SPAM will be handled by a method do_SPAM(). If no
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]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
Guido van Rossumd65b5391999-10-26 13:01:36 +0000[diff] [blame]222 def parse_request(self):
223 """Parse a request (internal).
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]224
Guido van Rossumd65b5391999-10-26 13:01:36 +0000[diff] [blame]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.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]231
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]232 """
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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`)
Guido van Rossumd65b5391999-10-26 13:01:36 +0000[diff] [blame]245 return 0
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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`)
Guido van Rossumd65b5391999-10-26 13:01:36 +0000[diff] [blame]251 return 0
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]252 else:
253 self.send_error(400, "Bad request syntax (%s)" % `requestline`)
Guido van Rossumd65b5391999-10-26 13:01:36 +0000[diff] [blame]254 return 0
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]255 self.command, self.path, self.request_version = command, path, version
256 self.headers = self.MessageClass(self.rfile, 0)
Guido van Rossumd65b5391999-10-26 13:01:36 +0000[diff] [blame]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
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]272 if not hasattr(self, mname):
Guido van Rossumd65b5391999-10-26 13:01:36 +0000[diff] [blame]273 self.send_error(501, "Unsupported method (%s)" % `self.command`)
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]274 return
275 method = getattr(self, mname)
276 method()
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]277
278 def send_error(self, code, message=None):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]279 """Send and log an error reply.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]280
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]281 Arguments are the error code, and a detailed message.
282 The detailed message defaults to the short entry matching the
283 response code.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]284
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]288
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]289 """
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]290
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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})
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]305
306 error_message_format = DEFAULT_ERROR_MESSAGE
307
308 def send_response(self, code, message=None):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]309 """Send the response header and log the response code.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]310
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]311 Also send two standard headers with the server software
312 version and the current date.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]313
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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())
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]326
327 def send_header(self, keyword, value):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]328 """Send a MIME header."""
329 if self.request_version != 'HTTP/0.9':
330 self.wfile.write("%s: %s\r\n" % (keyword, value))
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]331
332 def end_headers(self):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]333 """Send the blank line ending the MIME headers."""
334 if self.request_version != 'HTTP/0.9':
335 self.wfile.write("\r\n")
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]336
337 def log_request(self, code='-', size='-'):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]338 """Log an accepted request.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]339
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]340 This is called by send_reponse().
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]341
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]342 """
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]343
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]344 self.log_message('"%s" %s %s',
345 self.requestline, str(code), str(size))
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]346
347 def log_error(self, *args):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]348 """Log an error.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]349
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]350 This is called when a request cannot be fulfilled. By
351 default it passes the message on to log_message().
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]352
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]353 Arguments are the same as for log_message().
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]354
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]355 XXX This should go to the separate error log.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]356
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]357 """
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]358
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]359 apply(self.log_message, args)
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]360
361 def log_message(self, format, *args):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]362 """Log an arbitrary message.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]363
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]364 This is used by all other logging functions. Override
365 it if you have specific logging wishes.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]366
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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!).
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]372
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]373 The client host and current date/time are prefixed to
374 every message.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]375
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]376 """
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]377
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]378 sys.stderr.write("%s - - [%s] %s\n" %
379 (self.address_string(),
380 self.log_date_time_string(),
381 format%args))
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]382
383 def version_string(self):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]384 """Return the server software version string."""
385 return self.server_version + ' ' + self.sys_version
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]386
387 def date_time_string(self):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]396
397 def log_date_time_string(self):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]404
405 weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
406
407 monthname = [None,
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]408 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
409 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]410
411 def address_string(self):
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]412 """Return the client address formatted for logging.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]413
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]414 This version looks up the full hostname using gethostbyaddr(),
415 and tries to find a name that contains at least one dot.
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]416
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]417 """
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]418
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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]
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]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 = {
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]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 }
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]476
477
478def test(HandlerClass = BaseHTTPRequestHandler,
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]479 ServerClass = HTTPServer):
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]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:]:
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]488 port = string.atoi(sys.argv[1])
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]489 else:
Guido van Rossum45e2fbc1998-03-26 21:13:24 +0000[diff] [blame]490 port = 8000
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]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
499if __name__ == '__main__':
500 test()