Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / 1e8c8a20f2b5ff51415ed8dfbf4df574595a95fb / . / Lib / BaseHTTPServer.py
blob: 281ddf6049935924ec0198a8075390a4efdd1b0c [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
71import rfc822
72import mimetools
73import SocketServer
74
75# Default error message
76DEFAULT_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
89class 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
107class 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()
Guido van Rossumf69da221996-02-12 23:58:38 +0000[diff] [blame]229 self.request_version = version = "HTTP/0.9" # Default
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]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 != self.protocol_version:
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
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]248 else:
Guido van Rossumf69da221996-02-12 23:58:38 +0000[diff] [blame]249 self.send_error(400, "Bad request syntax (%s)" % `requestline`)
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]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):
Guido van Rossumf69da221996-02-12 23:58:38 +0000[diff] [blame]255 self.send_error(501, "Unsupported method (%s)" % `mname`)
Guido van Rossume7e578f1995-08-04 04:00:20 +0000[diff] [blame]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][1]
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
460def 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
481if __name__ == '__main__':
482 test()