Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / 90c8d06d687eed87fa61bf6bcc3a40beeaef39cd / . / Lib / http / server.py
blob: 1873b13105e1bc86d484c52558e85e568357e386 [file] [log] [blame]
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1"""HTTP server classes.
2
3Note: BaseHTTPRequestHandler doesn't implement any HTTP request; see
4SimpleHTTPRequestHandler for simple implementations of GET, HEAD and POST,
5and CGIHTTPRequestHandler for CGI scripts.
6
7It does, however, optionally implement HTTP/1.1 persistent connections,
8as of version 0.3.
9
10Notes on CGIHTTPRequestHandler
11------------------------------
12
13This class implements GET and POST requests to cgi-bin scripts.
14
15If the os.fork() function is not present (e.g. on Windows),
Amaury Forgeot d'Arccb0d2d72008-06-18 22:19:22 +0000[diff] [blame]16subprocess.Popen() is used as a fallback, with slightly altered semantics.
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]17
18In all cases, the implementation is intentionally naive -- all
19requests are executed synchronously.
20
21SECURITY WARNING: DON'T USE THIS CODE UNLESS YOU ARE INSIDE A FIREWALL
22-- it may execute arbitrary Python code or external programs.
23
24Note that status code 200 is sent prior to execution of a CGI script, so
25scripts cannot send other status codes such as 302 (redirect).
26
27XXX To do:
28
29- log requests even later (to capture byte count)
30- log user-agent header and other interesting goodies
31- send error log to separate file
32"""
33
34
35# See also:
36#
37# HTTP Working Group T. Berners-Lee
38# INTERNET-DRAFT R. T. Fielding
39# <draft-ietf-http-v10-spec-00.txt> H. Frystyk Nielsen
40# Expires September 8, 1995 March 8, 1995
41#
42# URL: http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-v10-spec-00.txt
43#
44# and
45#
46# Network Working Group R. Fielding
47# Request for Comments: 2616 et al
48# Obsoletes: 2068 June 1999
49# Category: Standards Track
50#
51# URL: http://www.faqs.org/rfcs/rfc2616.html
52
53# Log files
54# ---------
55#
56# Here's a quote from the NCSA httpd docs about log file format.
57#
58# | The logfile format is as follows. Each line consists of:
59# |
60# | host rfc931 authuser [DD/Mon/YYYY:hh:mm:ss] "request" ddd bbbb
61# |
62# | host: Either the DNS name or the IP number of the remote client
63# | rfc931: Any information returned by identd for this person,
64# | - otherwise.
65# | authuser: If user sent a userid for authentication, the user name,
66# | - otherwise.
67# | DD: Day
68# | Mon: Month (calendar name)
69# | YYYY: Year
70# | hh: hour (24-hour format, the machine's timezone)
71# | mm: minutes
72# | ss: seconds
73# | request: The first line of the HTTP request as sent by the client.
74# | ddd: the status code returned by the server, - if not available.
75# | bbbb: the total number of bytes sent,
76# | *not including the HTTP/1.0 header*, - if not available
77# |
78# | You can determine the name of the file accessed through request.
79#
80# (Actually, the latter is only true if you know the server configuration
81# at the time the request was made!)
82
83__version__ = "0.6"
84
85__all__ = ["HTTPServer", "BaseHTTPRequestHandler"]
86
Georg Brandl1f7fffb2010-10-15 15:57:45 +0000[diff] [blame]87import html
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]88import email.message
89import email.parser
Jeremy Hylton914ab452009-03-27 17:16:06 +0000[diff] [blame]90import http.client
91import io
92import mimetypes
93import os
94import posixpath
95import select
96import shutil
97import socket # For gethostbyaddr()
98import socketserver
99import sys
100import time
101import urllib.parse
Senthil Kumaran42713722010-10-03 17:55:45 +0000[diff] [blame]102import copy
Senthil Kumaran1251faf2012-06-03 16:15:54 +0800[diff] [blame]103import argparse
104
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]105
106# Default error message template
107DEFAULT_ERROR_MESSAGE = """\
Senthil Kumaran1b407fe2011-03-20 10:44:30 +0800[diff] [blame]108<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
109 "http://www.w3.org/TR/html4/strict.dtd">
Ezio Melottica897e92011-11-02 19:33:29 +0200[diff] [blame]110<html>
Senthil Kumaranb253c9f2011-03-17 16:43:22 +0800[diff] [blame]111 <head>
Senthil Kumaran1b407fe2011-03-20 10:44:30 +0800[diff] [blame]112 <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
Senthil Kumaranb253c9f2011-03-17 16:43:22 +0800[diff] [blame]113 <title>Error response</title>
114 </head>
115 <body>
116 <h1>Error response</h1>
117 <p>Error code: %(code)d</p>
118 <p>Message: %(message)s.</p>
119 <p>Error code explanation: %(code)s - %(explain)s.</p>
120 </body>
121</html>
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]122"""
123
124DEFAULT_ERROR_CONTENT_TYPE = "text/html;charset=utf-8"
125
126def _quote_html(html):
127 return html.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
128
129class HTTPServer(socketserver.TCPServer):
130
131 allow_reuse_address = 1 # Seems to make sense in testing environment
132
133 def server_bind(self):
134 """Override server_bind to store the server name."""
135 socketserver.TCPServer.server_bind(self)
136 host, port = self.socket.getsockname()[:2]
137 self.server_name = socket.getfqdn(host)
138 self.server_port = port
139
140
141class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
142
143 """HTTP request handler base class.
144
145 The following explanation of HTTP serves to guide you through the
146 code as well as to expose any misunderstandings I may have about
147 HTTP (so you don't need to read the code to figure out I'm wrong
148 :-).
149
150 HTTP (HyperText Transfer Protocol) is an extensible protocol on
151 top of a reliable stream transport (e.g. TCP/IP). The protocol
152 recognizes three parts to a request:
153
154 1. One line identifying the request type and path
155 2. An optional set of RFC-822-style headers
156 3. An optional data part
157
158 The headers and data are separated by a blank line.
159
160 The first line of the request has the form
161
162 <command> <path> <version>
163
164 where <command> is a (case-sensitive) keyword such as GET or POST,
165 <path> is a string containing path information for the request,
166 and <version> should be the string "HTTP/1.0" or "HTTP/1.1".
167 <path> is encoded using the URL encoding scheme (using %xx to signify
168 the ASCII character with hex code xx).
169
170 The specification specifies that lines are separated by CRLF but
171 for compatibility with the widest range of clients recommends
172 servers also handle LF. Similarly, whitespace in the request line
173 is treated sensibly (allowing multiple spaces between components
174 and allowing trailing whitespace).
175
176 Similarly, for output, lines ought to be separated by CRLF pairs
177 but most clients grok LF characters just fine.
178
179 If the first line of the request has the form
180
181 <command> <path>
182
183 (i.e. <version> is left out) then this is assumed to be an HTTP
184 0.9 request; this form has no optional headers and data part and
185 the reply consists of just the data.
186
187 The reply form of the HTTP 1.x protocol again has three parts:
188
189 1. One line giving the response code
190 2. An optional set of RFC-822-style headers
191 3. The data
192
193 Again, the headers and data are separated by a blank line.
194
195 The response code line has the form
196
197 <version> <responsecode> <responsestring>
198
199 where <version> is the protocol version ("HTTP/1.0" or "HTTP/1.1"),
200 <responsecode> is a 3-digit response code indicating success or
201 failure of the request, and <responsestring> is an optional
202 human-readable string explaining what the response code means.
203
204 This server parses the request and the headers, and then calls a
205 function specific to the request type (<command>). Specifically,
206 a request SPAM will be handled by a method do_SPAM(). If no
207 such method exists the server sends an error response to the
208 client. If it exists, it is called with no arguments:
209
210 do_SPAM()
211
212 Note that the request name is case sensitive (i.e. SPAM and spam
213 are different requests).
214
215 The various request details are stored in instance variables:
216
217 - client_address is the client IP address in the form (host,
218 port);
219
220 - command, path and version are the broken-down request line;
221
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]222 - headers is an instance of email.message.Message (or a derived
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]223 class) containing the header information;
224
225 - rfile is a file object open for reading positioned at the
226 start of the optional input data part;
227
228 - wfile is a file object open for writing.
229
230 IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!
231
232 The first thing to be written must be the response line. Then
233 follow 0 or more header lines, then a blank line, and then the
234 actual data (if any). The meaning of the header lines depends on
235 the command executed by the server; in most cases, when data is
236 returned, there should be at least one header line of the form
237
238 Content-type: <type>/<subtype>
239
240 where <type> and <subtype> should be registered MIME types,
241 e.g. "text/html" or "text/plain".
242
243 """
244
245 # The Python system version, truncated to its first component.
246 sys_version = "Python/" + sys.version.split()[0]
247
248 # The server software version. You may want to override this.
249 # The format is multiple whitespace-separated strings,
250 # where each string is of the form name[/version].
251 server_version = "BaseHTTP/" + __version__
252
253 error_message_format = DEFAULT_ERROR_MESSAGE
254 error_content_type = DEFAULT_ERROR_CONTENT_TYPE
255
256 # The default request version. This only affects responses up until
257 # the point where the request line is parsed, so it mainly decides what
258 # the client gets back when sending a malformed request line.
259 # Most web servers default to HTTP 0.9, i.e. don't send a status line.
260 default_request_version = "HTTP/0.9"
261
262 def parse_request(self):
263 """Parse a request (internal).
264
265 The request should be stored in self.raw_requestline; the results
266 are in self.command, self.path, self.request_version and
267 self.headers.
268
269 Return True for success, False for failure; on failure, an
270 error is sent back.
271
272 """
273 self.command = None # set in case of error on the first line
274 self.request_version = version = self.default_request_version
275 self.close_connection = 1
276 requestline = str(self.raw_requestline, 'iso-8859-1')
Senthil Kumaran30755492011-12-23 17:03:41 +0800[diff] [blame]277 requestline = requestline.rstrip('\r\n')
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]278 self.requestline = requestline
279 words = requestline.split()
280 if len(words) == 3:
Senthil Kumaran30755492011-12-23 17:03:41 +0800[diff] [blame]281 command, path, version = words
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]282 if version[:5] != 'HTTP/':
283 self.send_error(400, "Bad request version (%r)" % version)
284 return False
285 try:
286 base_version_number = version.split('/', 1)[1]
287 version_number = base_version_number.split(".")
288 # RFC 2145 section 3.1 says there can be only one "." and
289 # - major and minor numbers MUST be treated as
290 # separate integers;
291 # - HTTP/2.4 is a lower version than HTTP/2.13, which in
292 # turn is lower than HTTP/12.3;
293 # - Leading zeros MUST be ignored by recipients.
294 if len(version_number) != 2:
295 raise ValueError
296 version_number = int(version_number[0]), int(version_number[1])
297 except (ValueError, IndexError):
298 self.send_error(400, "Bad request version (%r)" % version)
299 return False
300 if version_number >= (1, 1) and self.protocol_version >= "HTTP/1.1":
301 self.close_connection = 0
302 if version_number >= (2, 0):
303 self.send_error(505,
304 "Invalid HTTP Version (%s)" % base_version_number)
305 return False
306 elif len(words) == 2:
Senthil Kumaran30755492011-12-23 17:03:41 +0800[diff] [blame]307 command, path = words
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]308 self.close_connection = 1
309 if command != 'GET':
310 self.send_error(400,
311 "Bad HTTP/0.9 request type (%r)" % command)
312 return False
313 elif not words:
314 return False
315 else:
316 self.send_error(400, "Bad request syntax (%r)" % requestline)
317 return False
318 self.command, self.path, self.request_version = command, path, version
319
320 # Examine the headers and look for a Connection directive.
Senthil Kumaran5466bf12010-12-18 16:55:23 +0000[diff] [blame]321 try:
322 self.headers = http.client.parse_headers(self.rfile,
323 _class=self.MessageClass)
324 except http.client.LineTooLong:
325 self.send_error(400, "Line too long")
326 return False
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]327
328 conntype = self.headers.get('Connection', "")
329 if conntype.lower() == 'close':
330 self.close_connection = 1
331 elif (conntype.lower() == 'keep-alive' and
332 self.protocol_version >= "HTTP/1.1"):
333 self.close_connection = 0
Senthil Kumaran0f476d42010-09-30 06:09:18 +0000[diff] [blame]334 # Examine the headers and look for an Expect directive
335 expect = self.headers.get('Expect', "")
336 if (expect.lower() == "100-continue" and
337 self.protocol_version >= "HTTP/1.1" and
338 self.request_version >= "HTTP/1.1"):
339 if not self.handle_expect_100():
340 return False
341 return True
342
343 def handle_expect_100(self):
344 """Decide what to do with an "Expect: 100-continue" header.
345
346 If the client is expecting a 100 Continue response, we must
347 respond with either a 100 Continue or a final response before
348 waiting for the request body. The default is to always respond
349 with a 100 Continue. You can behave differently (for example,
350 reject unauthorized requests) by overriding this method.
351
352 This method should either return True (possibly after sending
353 a 100 Continue response) or send an error response and return
354 False.
355
356 """
357 self.send_response_only(100)
Senthil Kumaranc7ae19b2011-05-09 23:25:02 +0800[diff] [blame]358 self.flush_headers()
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]359 return True
360
361 def handle_one_request(self):
362 """Handle a single HTTP request.
363
364 You normally don't need to override this method; see the class
365 __doc__ string for information on how to handle specific HTTP
366 commands such as GET and POST.
367
368 """
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +0000[diff] [blame]369 try:
Antoine Pitrouc4924372010-12-16 16:48:36 +0000[diff] [blame]370 self.raw_requestline = self.rfile.readline(65537)
371 if len(self.raw_requestline) > 65536:
372 self.requestline = ''
373 self.request_version = ''
374 self.command = ''
375 self.send_error(414)
376 return
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +0000[diff] [blame]377 if not self.raw_requestline:
378 self.close_connection = 1
379 return
380 if not self.parse_request():
381 # An error code has been sent, just exit
382 return
383 mname = 'do_' + self.command
384 if not hasattr(self, mname):
385 self.send_error(501, "Unsupported method (%r)" % self.command)
386 return
387 method = getattr(self, mname)
388 method()
389 self.wfile.flush() #actually send the response if not already done.
390 except socket.timeout as e:
391 #a read or a write timed out. Discard this connection
392 self.log_error("Request timed out: %r", e)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]393 self.close_connection = 1
394 return
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]395
396 def handle(self):
397 """Handle multiple requests if necessary."""
398 self.close_connection = 1
399
400 self.handle_one_request()
401 while not self.close_connection:
402 self.handle_one_request()
403
404 def send_error(self, code, message=None):
405 """Send and log an error reply.
406
407 Arguments are the error code, and a detailed message.
408 The detailed message defaults to the short entry matching the
409 response code.
410
411 This sends an error response (so it must be called before any
412 output has been generated), logs the error, and finally sends
413 a piece of HTML explaining the error to the user.
414
415 """
416
417 try:
418 shortmsg, longmsg = self.responses[code]
419 except KeyError:
420 shortmsg, longmsg = '???', '???'
421 if message is None:
422 message = shortmsg
423 explain = longmsg
424 self.log_error("code %d, message %s", code, message)
425 # using _quote_html to prevent Cross Site Scripting attacks (see bug #1100201)
426 content = (self.error_message_format %
427 {'code': code, 'message': _quote_html(message), 'explain': explain})
Senthil Kumaran52d27202012-10-10 23:16:21 -0700[diff] [blame]428 body = content.encode('UTF-8', 'replace')
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]429 self.send_response(code, message)
430 self.send_header("Content-Type", self.error_content_type)
431 self.send_header('Connection', 'close')
Senthil Kumaran52d27202012-10-10 23:16:21 -0700[diff] [blame]432 self.send_header('Content-Length', int(len(body)))
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]433 self.end_headers()
434 if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
Senthil Kumaran52d27202012-10-10 23:16:21 -0700[diff] [blame]435 self.wfile.write(body)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]436
437 def send_response(self, code, message=None):
Senthil Kumaranc7ae19b2011-05-09 23:25:02 +0800[diff] [blame]438 """Add the response header to the headers buffer and log the
439 response code.
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]440
441 Also send two standard headers with the server software
442 version and the current date.
443
444 """
445 self.log_request(code)
Senthil Kumaran0f476d42010-09-30 06:09:18 +0000[diff] [blame]446 self.send_response_only(code, message)
447 self.send_header('Server', self.version_string())
448 self.send_header('Date', self.date_time_string())
449
450 def send_response_only(self, code, message=None):
451 """Send the response header only."""
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]452 if message is None:
453 if code in self.responses:
454 message = self.responses[code][0]
455 else:
456 message = ''
457 if self.request_version != 'HTTP/0.9':
Senthil Kumaranc7ae19b2011-05-09 23:25:02 +0800[diff] [blame]458 if not hasattr(self, '_headers_buffer'):
459 self._headers_buffer = []
460 self._headers_buffer.append(("%s %d %s\r\n" %
461 (self.protocol_version, code, message)).encode(
462 'latin-1', 'strict'))
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]463
464 def send_header(self, keyword, value):
Senthil Kumaranc7ae19b2011-05-09 23:25:02 +0800[diff] [blame]465 """Send a MIME header to the headers buffer."""
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]466 if self.request_version != 'HTTP/0.9':
Senthil Kumarane4dad4f2010-11-21 14:36:14 +0000[diff] [blame]467 if not hasattr(self, '_headers_buffer'):
468 self._headers_buffer = []
469 self._headers_buffer.append(
Marc-André Lemburg8f36af72011-02-25 15:42:01 +0000[diff] [blame]470 ("%s: %s\r\n" % (keyword, value)).encode('latin-1', 'strict'))
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]471
472 if keyword.lower() == 'connection':
473 if value.lower() == 'close':
474 self.close_connection = 1
475 elif value.lower() == 'keep-alive':
476 self.close_connection = 0
477
478 def end_headers(self):
479 """Send the blank line ending the MIME headers."""
480 if self.request_version != 'HTTP/0.9':
Senthil Kumarane4dad4f2010-11-21 14:36:14 +0000[diff] [blame]481 self._headers_buffer.append(b"\r\n")
Senthil Kumaranc7ae19b2011-05-09 23:25:02 +0800[diff] [blame]482 self.flush_headers()
483
484 def flush_headers(self):
485 if hasattr(self, '_headers_buffer'):
Senthil Kumarane4dad4f2010-11-21 14:36:14 +0000[diff] [blame]486 self.wfile.write(b"".join(self._headers_buffer))
487 self._headers_buffer = []
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]488
489 def log_request(self, code='-', size='-'):
490 """Log an accepted request.
491
492 This is called by send_response().
493
494 """
495
496 self.log_message('"%s" %s %s',
497 self.requestline, str(code), str(size))
498
499 def log_error(self, format, *args):
500 """Log an error.
501
502 This is called when a request cannot be fulfilled. By
503 default it passes the message on to log_message().
504
505 Arguments are the same as for log_message().
506
507 XXX This should go to the separate error log.
508
509 """
510
511 self.log_message(format, *args)
512
513 def log_message(self, format, *args):
514 """Log an arbitrary message.
515
516 This is used by all other logging functions. Override
517 it if you have specific logging wishes.
518
519 The first argument, FORMAT, is a format string for the
520 message to be logged. If the format string contains
521 any % escapes requiring parameters, they should be
522 specified as subsequent arguments (it's just like
523 printf!).
524
Senthil Kumarandb727b42012-04-29 13:41:03 +0800[diff] [blame]525 The client ip and current date/time are prefixed to
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]526 every message.
527
528 """
529
530 sys.stderr.write("%s - - [%s] %s\n" %
531 (self.address_string(),
532 self.log_date_time_string(),
533 format%args))
534
535 def version_string(self):
536 """Return the server software version string."""
537 return self.server_version + ' ' + self.sys_version
538
539 def date_time_string(self, timestamp=None):
540 """Return the current date and time formatted for a message header."""
541 if timestamp is None:
542 timestamp = time.time()
543 year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp)
544 s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
545 self.weekdayname[wd],
546 day, self.monthname[month], year,
547 hh, mm, ss)
548 return s
549
550 def log_date_time_string(self):
551 """Return the current time formatted for logging."""
552 now = time.time()
553 year, month, day, hh, mm, ss, x, y, z = time.localtime(now)
554 s = "%02d/%3s/%04d %02d:%02d:%02d" % (
555 day, self.monthname[month], year, hh, mm, ss)
556 return s
557
558 weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
559
560 monthname = [None,
561 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
562 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
563
564 def address_string(self):
Senthil Kumaran1aacba42012-04-29 12:51:54 +0800[diff] [blame]565 """Return the client address."""
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]566
Senthil Kumaran1aacba42012-04-29 12:51:54 +0800[diff] [blame]567 return self.client_address[0]
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]568
569 # Essentially static class variables
570
571 # The version of the HTTP protocol we support.
572 # Set this to HTTP/1.1 to enable automatic keepalive
573 protocol_version = "HTTP/1.0"
574
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]575 # MessageClass used to parse headers
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]576 MessageClass = http.client.HTTPMessage
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]577
578 # Table mapping response codes to messages; entries have the
579 # form {code: (shortmessage, longmessage)}.
Hynek Schlawack51b2ed52012-05-16 09:51:07 +0200[diff] [blame]580 # See RFC 2616 and 6585.
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]581 responses = {
582 100: ('Continue', 'Request received, please continue'),
583 101: ('Switching Protocols',
584 'Switching to new protocol; obey Upgrade header'),
585
586 200: ('OK', 'Request fulfilled, document follows'),
587 201: ('Created', 'Document created, URL follows'),
588 202: ('Accepted',
589 'Request accepted, processing continues off-line'),
590 203: ('Non-Authoritative Information', 'Request fulfilled from cache'),
591 204: ('No Content', 'Request fulfilled, nothing follows'),
592 205: ('Reset Content', 'Clear input form for further input.'),
593 206: ('Partial Content', 'Partial content follows.'),
594
595 300: ('Multiple Choices',
596 'Object has several resources -- see URI list'),
597 301: ('Moved Permanently', 'Object moved permanently -- see URI list'),
598 302: ('Found', 'Object moved temporarily -- see URI list'),
599 303: ('See Other', 'Object moved -- see Method and URL list'),
600 304: ('Not Modified',
601 'Document has not changed since given time'),
602 305: ('Use Proxy',
603 'You must use proxy specified in Location to access this '
604 'resource.'),
605 307: ('Temporary Redirect',
606 'Object moved temporarily -- see URI list'),
607
608 400: ('Bad Request',
609 'Bad request syntax or unsupported method'),
610 401: ('Unauthorized',
611 'No permission -- see authorization schemes'),
612 402: ('Payment Required',
613 'No payment -- see charging schemes'),
614 403: ('Forbidden',
615 'Request forbidden -- authorization will not help'),
616 404: ('Not Found', 'Nothing matches the given URI'),
617 405: ('Method Not Allowed',
Senthil Kumaran7aa26212010-02-22 11:00:50 +0000[diff] [blame]618 'Specified method is invalid for this resource.'),
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]619 406: ('Not Acceptable', 'URI not available in preferred format.'),
620 407: ('Proxy Authentication Required', 'You must authenticate with '
621 'this proxy before proceeding.'),
622 408: ('Request Timeout', 'Request timed out; try again later.'),
623 409: ('Conflict', 'Request conflict.'),
624 410: ('Gone',
625 'URI no longer exists and has been permanently removed.'),
626 411: ('Length Required', 'Client must specify Content-Length.'),
627 412: ('Precondition Failed', 'Precondition in headers is false.'),
628 413: ('Request Entity Too Large', 'Entity is too large.'),
629 414: ('Request-URI Too Long', 'URI is too long.'),
630 415: ('Unsupported Media Type', 'Entity body in unsupported format.'),
631 416: ('Requested Range Not Satisfiable',
632 'Cannot satisfy request range.'),
633 417: ('Expectation Failed',
634 'Expect condition could not be satisfied.'),
Hynek Schlawack51b2ed52012-05-16 09:51:07 +0200[diff] [blame]635 428: ('Precondition Required',
636 'The origin server requires the request to be conditional.'),
637 429: ('Too Many Requests', 'The user has sent too many requests '
638 'in a given amount of time ("rate limiting").'),
639 431: ('Request Header Fields Too Large', 'The server is unwilling to '
640 'process the request because its header fields are too large.'),
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]641
642 500: ('Internal Server Error', 'Server got itself in trouble'),
643 501: ('Not Implemented',
644 'Server does not support this operation'),
645 502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),
646 503: ('Service Unavailable',
647 'The server cannot process the request due to a high load'),
648 504: ('Gateway Timeout',
649 'The gateway server did not receive a timely response'),
650 505: ('HTTP Version Not Supported', 'Cannot fulfill request.'),
Hynek Schlawack51b2ed52012-05-16 09:51:07 +0200[diff] [blame]651 511: ('Network Authentication Required',
652 'The client needs to authenticate to gain network access.'),
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]653 }
654
655
656class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
657
658 """Simple HTTP request handler with GET and HEAD commands.
659
660 This serves files from the current directory and any of its
661 subdirectories. The MIME type for files is determined by
662 calling the .guess_type() method.
663
664 The GET and HEAD requests are identical except that the HEAD
665 request omits the actual contents of the file.
666
667 """
668
669 server_version = "SimpleHTTP/" + __version__
670
671 def do_GET(self):
672 """Serve a GET request."""
673 f = self.send_head()
674 if f:
675 self.copyfile(f, self.wfile)
676 f.close()
677
678 def do_HEAD(self):
679 """Serve a HEAD request."""
680 f = self.send_head()
681 if f:
682 f.close()
683
684 def send_head(self):
685 """Common code for GET and HEAD commands.
686
687 This sends the response code and MIME headers.
688
689 Return value is either a file object (which has to be copied
690 to the outputfile by the caller unless the command was HEAD,
691 and must be closed by the caller under all circumstances), or
692 None, in which case the caller has nothing further to do.
693
694 """
695 path = self.translate_path(self.path)
696 f = None
697 if os.path.isdir(path):
698 if not self.path.endswith('/'):
699 # redirect browser - doing basically what apache does
700 self.send_response(301)
701 self.send_header("Location", self.path + "/")
702 self.end_headers()
703 return None
704 for index in "index.html", "index.htm":
705 index = os.path.join(path, index)
706 if os.path.exists(index):
707 path = index
708 break
709 else:
710 return self.list_directory(path)
711 ctype = self.guess_type(path)
712 try:
713 f = open(path, 'rb')
Andrew Svetlovf7a17b42012-12-25 16:47:37 +0200[diff] [blame]714 except OSError:
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]715 self.send_error(404, "File not found")
716 return None
717 self.send_response(200)
718 self.send_header("Content-type", ctype)
719 fs = os.fstat(f.fileno())
720 self.send_header("Content-Length", str(fs[6]))
721 self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
722 self.end_headers()
723 return f
724
725 def list_directory(self, path):
726 """Helper to produce a directory listing (absent index.html).
727
728 Return value is either a file object, or None (indicating an
729 error). In either case, the headers are sent, making the
730 interface the same as for send_head().
731
732 """
733 try:
734 list = os.listdir(path)
Andrew Svetlovad28c7f2012-12-18 22:02:39 +0200[diff] [blame]735 except OSError:
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]736 self.send_error(404, "No permission to list directory")
737 return None
738 list.sort(key=lambda a: a.lower())
739 r = []
Georg Brandl1f7fffb2010-10-15 15:57:45 +0000[diff] [blame]740 displaypath = html.escape(urllib.parse.unquote(self.path))
Ezio Melottica897e92011-11-02 19:33:29 +0200[diff] [blame]741 enc = sys.getfilesystemencoding()
742 title = 'Directory listing for %s' % displaypath
743 r.append('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" '
744 '"http://www.w3.org/TR/html4/strict.dtd">')
745 r.append('<html>\n<head>')
746 r.append('<meta http-equiv="Content-Type" '
747 'content="text/html; charset=%s">' % enc)
748 r.append('<title>%s</title>\n</head>' % title)
749 r.append('<body>\n<h1>%s</h1>' % title)
750 r.append('<hr>\n<ul>')
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]751 for name in list:
752 fullname = os.path.join(path, name)
753 displayname = linkname = name
754 # Append / for directories or @ for symbolic links
755 if os.path.isdir(fullname):
756 displayname = name + "/"
757 linkname = name + "/"
758 if os.path.islink(fullname):
759 displayname = name + "@"
760 # Note: a link to a directory displays with @ and links with /
Ezio Melottica897e92011-11-02 19:33:29 +0200[diff] [blame]761 r.append('<li><a href="%s">%s</a></li>'
Georg Brandl1f7fffb2010-10-15 15:57:45 +0000[diff] [blame]762 % (urllib.parse.quote(linkname), html.escape(displayname)))
Ezio Melottica897e92011-11-02 19:33:29 +0200[diff] [blame]763 r.append('</ul>\n<hr>\n</body>\n</html>\n')
764 encoded = '\n'.join(r).encode(enc)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]765 f = io.BytesIO()
766 f.write(encoded)
767 f.seek(0)
768 self.send_response(200)
769 self.send_header("Content-type", "text/html; charset=%s" % enc)
770 self.send_header("Content-Length", str(len(encoded)))
771 self.end_headers()
772 return f
773
774 def translate_path(self, path):
775 """Translate a /-separated PATH to the local filename syntax.
776
777 Components that mean special things to the local file system
778 (e.g. drive or directory names) are ignored. (XXX They should
779 probably be diagnosed.)
780
781 """
782 # abandon query parameters
783 path = path.split('?',1)[0]
784 path = path.split('#',1)[0]
Jeremy Hylton1afc1692008-06-18 20:49:58 +0000[diff] [blame]785 path = posixpath.normpath(urllib.parse.unquote(path))
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]786 words = path.split('/')
787 words = filter(None, words)
788 path = os.getcwd()
789 for word in words:
790 drive, word = os.path.splitdrive(word)
791 head, word = os.path.split(word)
792 if word in (os.curdir, os.pardir): continue
793 path = os.path.join(path, word)
794 return path
795
796 def copyfile(self, source, outputfile):
797 """Copy all data between two file objects.
798
799 The SOURCE argument is a file object open for reading
800 (or anything with a read() method) and the DESTINATION
801 argument is a file object open for writing (or
802 anything with a write() method).
803
804 The only reason for overriding this would be to change
805 the block size or perhaps to replace newlines by CRLF
806 -- note however that this the default server uses this
807 to copy binary data as well.
808
809 """
810 shutil.copyfileobj(source, outputfile)
811
812 def guess_type(self, path):
813 """Guess the type of a file.
814
815 Argument is a PATH (a filename).
816
817 Return value is a string of the form type/subtype,
818 usable for a MIME Content-type header.
819
820 The default implementation looks the file's extension
821 up in the table self.extensions_map, using application/octet-stream
822 as a default; however it would be permissible (if
823 slow) to look inside the data to make a better guess.
824
825 """
826
827 base, ext = posixpath.splitext(path)
828 if ext in self.extensions_map:
829 return self.extensions_map[ext]
830 ext = ext.lower()
831 if ext in self.extensions_map:
832 return self.extensions_map[ext]
833 else:
834 return self.extensions_map['']
835
836 if not mimetypes.inited:
837 mimetypes.init() # try to read system mime.types
838 extensions_map = mimetypes.types_map.copy()
839 extensions_map.update({
840 '': 'application/octet-stream', # Default
841 '.py': 'text/plain',
842 '.c': 'text/plain',
843 '.h': 'text/plain',
844 })
845
846
847# Utilities for CGIHTTPRequestHandler
848
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]849def _url_collapse_path(path):
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]850 """
851 Given a URL path, remove extra '/'s and '.' path elements and collapse
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]852 any '..' references and returns a colllapsed path.
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]853
854 Implements something akin to RFC-2396 5.2 step 6 to parse relative paths.
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]855 The utility of this function is limited to is_cgi method and helps
856 preventing some security attacks.
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]857
858 Returns: A tuple of (head, tail) where tail is everything after the final /
859 and head is everything before it. Head will always start with a '/' and,
860 if it contains anything else, never have a trailing '/'.
861
862 Raises: IndexError if too many '..' occur within the path.
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]863
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]864 """
865 # Similar to os.path.split(os.path.normpath(path)) but specific to URL
866 # path semantics rather than local operating system semantics.
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]867 path_parts = path.split('/')
868 head_parts = []
869 for part in path_parts[:-1]:
870 if part == '..':
871 head_parts.pop() # IndexError if more '..' than prior parts
872 elif part and part != '.':
873 head_parts.append( part )
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]874 if path_parts:
Senthil Kumarandbb369d2012-04-11 03:15:28 +0800[diff] [blame]875 tail_part = path_parts.pop()
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]876 if tail_part:
877 if tail_part == '..':
878 head_parts.pop()
879 tail_part = ''
880 elif tail_part == '.':
881 tail_part = ''
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]882 else:
883 tail_part = ''
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]884
885 splitpath = ('/' + '/'.join(head_parts), tail_part)
886 collapsed_path = "/".join(splitpath)
887
888 return collapsed_path
889
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]890
891
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]892nobody = None
893
894def nobody_uid():
895 """Internal routine to get nobody's uid"""
896 global nobody
897 if nobody:
898 return nobody
899 try:
900 import pwd
901 except ImportError:
902 return -1
903 try:
904 nobody = pwd.getpwnam('nobody')[2]
905 except KeyError:
Georg Brandlcbd2ab12010-12-04 10:39:14 +0000[diff] [blame]906 nobody = 1 + max(x[2] for x in pwd.getpwall())
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]907 return nobody
908
909
910def executable(path):
911 """Test for executable file."""
Victor Stinnerfb25ba92011-06-20 17:45:54 +0200[diff] [blame]912 return os.access(path, os.X_OK)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]913
914
915class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
916
917 """Complete HTTP server with GET, HEAD and POST commands.
918
919 GET and HEAD also support running CGI scripts.
920
921 The POST command is *only* implemented for CGI scripts.
922
923 """
924
925 # Determine platform specifics
926 have_fork = hasattr(os, 'fork')
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]927
928 # Make rfile unbuffered -- we need to read one line and then pass
929 # the rest to a subprocess, so we can't use buffered input.
930 rbufsize = 0
931
932 def do_POST(self):
933 """Serve a POST request.
934
935 This is only implemented for CGI scripts.
936
937 """
938
939 if self.is_cgi():
940 self.run_cgi()
941 else:
942 self.send_error(501, "Can only POST to CGI scripts")
943
944 def send_head(self):
945 """Version of send_head that support CGI scripts"""
946 if self.is_cgi():
947 return self.run_cgi()
948 else:
949 return SimpleHTTPRequestHandler.send_head(self)
950
951 def is_cgi(self):
952 """Test whether self.path corresponds to a CGI script.
953
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]954 Returns True and updates the cgi_info attribute to the tuple
955 (dir, rest) if self.path requires running a CGI script.
956 Returns False otherwise.
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]957
Benjamin Petersona7deeee2009-05-08 20:54:42 +0000[diff] [blame]958 If any exception is raised, the caller should assume that
959 self.path was rejected as invalid and act accordingly.
960
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]961 The default implementation tests whether the normalized url
962 path begins with one of the strings in self.cgi_directories
963 (and the next character is a '/' or the end of the string).
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]964
965 """
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]966 collapsed_path = _url_collapse_path(self.path)
967 dir_sep = collapsed_path.find('/', 1)
968 head, tail = collapsed_path[:dir_sep], collapsed_path[dir_sep+1:]
Senthil Kumarandbb369d2012-04-11 03:15:28 +0800[diff] [blame]969 if head in self.cgi_directories:
970 self.cgi_info = head, tail
Benjamin Petersonad71f0f2009-04-11 20:12:10 +0000[diff] [blame]971 return True
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]972 return False
973
Senthil Kumarand70846b2012-04-12 02:34:32 +0800[diff] [blame]974
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]975 cgi_directories = ['/cgi-bin', '/htbin']
976
977 def is_executable(self, path):
978 """Test whether argument path is an executable file."""
979 return executable(path)
980
981 def is_python(self, path):
982 """Test whether argument path is a Python script."""
983 head, tail = os.path.splitext(path)
984 return tail.lower() in (".py", ".pyw")
985
986 def run_cgi(self):
987 """Execute a CGI script."""
988 path = self.path
989 dir, rest = self.cgi_info
990
991 i = path.find('/', len(dir) + 1)
992 while i >= 0:
993 nextdir = path[:i]
994 nextrest = path[i+1:]
995
996 scriptdir = self.translate_path(nextdir)
997 if os.path.isdir(scriptdir):
998 dir, rest = nextdir, nextrest
999 i = path.find('/', len(dir) + 1)
1000 else:
1001 break
1002
1003 # find an explicit query string, if present.
1004 i = rest.rfind('?')
1005 if i >= 0:
1006 rest, query = rest[:i], rest[i+1:]
1007 else:
1008 query = ''
1009
1010 # dissect the part after the directory name into a script name &
1011 # a possible additional path, to be stored in PATH_INFO.
1012 i = rest.find('/')
1013 if i >= 0:
1014 script, rest = rest[:i], rest[i:]
1015 else:
1016 script, rest = rest, ''
1017
1018 scriptname = dir + '/' + script
1019 scriptfile = self.translate_path(scriptname)
1020 if not os.path.exists(scriptfile):
1021 self.send_error(404, "No such CGI script (%r)" % scriptname)
1022 return
1023 if not os.path.isfile(scriptfile):
1024 self.send_error(403, "CGI script is not a plain file (%r)" %
1025 scriptname)
1026 return
1027 ispy = self.is_python(scriptname)
Victor Stinnerfb25ba92011-06-20 17:45:54 +0200[diff] [blame]1028 if self.have_fork or not ispy:
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1029 if not self.is_executable(scriptfile):
1030 self.send_error(403, "CGI script is not executable (%r)" %
1031 scriptname)
1032 return
1033
1034 # Reference: http://hoohoo.ncsa.uiuc.edu/cgi/env.html
1035 # XXX Much of the following could be prepared ahead of time!
Senthil Kumaran42713722010-10-03 17:55:45 +0000[diff] [blame]1036 env = copy.deepcopy(os.environ)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1037 env['SERVER_SOFTWARE'] = self.version_string()
1038 env['SERVER_NAME'] = self.server.server_name
1039 env['GATEWAY_INTERFACE'] = 'CGI/1.1'
1040 env['SERVER_PROTOCOL'] = self.protocol_version
1041 env['SERVER_PORT'] = str(self.server.server_port)
1042 env['REQUEST_METHOD'] = self.command
Jeremy Hylton1afc1692008-06-18 20:49:58 +0000[diff] [blame]1043 uqrest = urllib.parse.unquote(rest)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1044 env['PATH_INFO'] = uqrest
1045 env['PATH_TRANSLATED'] = self.translate_path(uqrest)
1046 env['SCRIPT_NAME'] = scriptname
1047 if query:
1048 env['QUERY_STRING'] = query
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1049 env['REMOTE_ADDR'] = self.client_address[0]
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]1050 authorization = self.headers.get("authorization")
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1051 if authorization:
1052 authorization = authorization.split()
1053 if len(authorization) == 2:
1054 import base64, binascii
1055 env['AUTH_TYPE'] = authorization[0]
1056 if authorization[0].lower() == "basic":
1057 try:
1058 authorization = authorization[1].encode('ascii')
Georg Brandl706824f2009-06-04 09:42:55 +0000[diff] [blame]1059 authorization = base64.decodebytes(authorization).\
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1060 decode('ascii')
1061 except (binascii.Error, UnicodeError):
1062 pass
1063 else:
1064 authorization = authorization.split(':')
1065 if len(authorization) == 2:
1066 env['REMOTE_USER'] = authorization[0]
1067 # XXX REMOTE_IDENT
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]1068 if self.headers.get('content-type') is None:
1069 env['CONTENT_TYPE'] = self.headers.get_content_type()
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1070 else:
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]1071 env['CONTENT_TYPE'] = self.headers['content-type']
1072 length = self.headers.get('content-length')
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1073 if length:
1074 env['CONTENT_LENGTH'] = length
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]1075 referer = self.headers.get('referer')
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1076 if referer:
1077 env['HTTP_REFERER'] = referer
1078 accept = []
1079 for line in self.headers.getallmatchingheaders('accept'):
1080 if line[:1] in "\t\n\r ":
1081 accept.append(line.strip())
1082 else:
1083 accept = accept + line[7:].split(',')
1084 env['HTTP_ACCEPT'] = ','.join(accept)
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]1085 ua = self.headers.get('user-agent')
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1086 if ua:
1087 env['HTTP_USER_AGENT'] = ua
Barry Warsaw820c1202008-06-12 04:06:45 +0000[diff] [blame]1088 co = filter(None, self.headers.get_all('cookie', []))
Georg Brandl62e2ca22010-07-31 21:54:24 +0000[diff] [blame]1089 cookie_str = ', '.join(co)
1090 if cookie_str:
1091 env['HTTP_COOKIE'] = cookie_str
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1092 # XXX Other HTTP_* headers
1093 # Since we're setting the env in the parent, provide empty
1094 # values to override previously set values
1095 for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',
1096 'HTTP_USER_AGENT', 'HTTP_COOKIE', 'HTTP_REFERER'):
1097 env.setdefault(k, "")
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1098
1099 self.send_response(200, "Script output follows")
Senthil Kumaranc7ae19b2011-05-09 23:25:02 +0800[diff] [blame]1100 self.flush_headers()
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1101
1102 decoded_query = query.replace('+', ' ')
1103
1104 if self.have_fork:
1105 # Unix -- fork as we should
1106 args = [script]
1107 if '=' not in decoded_query:
1108 args.append(decoded_query)
1109 nobody = nobody_uid()
1110 self.wfile.flush() # Always flush before forking
1111 pid = os.fork()
1112 if pid != 0:
1113 # Parent
1114 pid, sts = os.waitpid(pid, 0)
1115 # throw away additional data [see bug #427345]
1116 while select.select([self.rfile], [], [], 0)[0]:
1117 if not self.rfile.read(1):
1118 break
1119 if sts:
1120 self.log_error("CGI script exit status %#x", sts)
1121 return
1122 # Child
1123 try:
1124 try:
1125 os.setuid(nobody)
Andrew Svetlovad28c7f2012-12-18 22:02:39 +0200[diff] [blame]1126 except OSError:
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1127 pass
1128 os.dup2(self.rfile.fileno(), 0)
1129 os.dup2(self.wfile.fileno(), 1)
Senthil Kumaran42713722010-10-03 17:55:45 +0000[diff] [blame]1130 os.execve(scriptfile, args, env)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1131 except:
1132 self.server.handle_error(self.request, self.client_address)
1133 os._exit(127)
1134
Amaury Forgeot d'Arccb0d2d72008-06-18 22:19:22 +0000[diff] [blame]1135 else:
1136 # Non-Unix -- use subprocess
1137 import subprocess
Senthil Kumarane29cd162009-11-11 04:17:53 +0000[diff] [blame]1138 cmdline = [scriptfile]
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1139 if self.is_python(scriptfile):
1140 interp = sys.executable
1141 if interp.lower().endswith("w.exe"):
1142 # On Windows, use python.exe, not pythonw.exe
1143 interp = interp[:-5] + interp[-4:]
Senthil Kumarane29cd162009-11-11 04:17:53 +0000[diff] [blame]1144 cmdline = [interp, '-u'] + cmdline
1145 if '=' not in query:
1146 cmdline.append(query)
1147 self.log_message("command: %s", subprocess.list2cmdline(cmdline))
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1148 try:
1149 nbytes = int(length)
1150 except (TypeError, ValueError):
1151 nbytes = 0
Amaury Forgeot d'Arccb0d2d72008-06-18 22:19:22 +0000[diff] [blame]1152 p = subprocess.Popen(cmdline,
1153 stdin=subprocess.PIPE,
1154 stdout=subprocess.PIPE,
Senthil Kumaran42713722010-10-03 17:55:45 +0000[diff] [blame]1155 stderr=subprocess.PIPE,
1156 env = env
Amaury Forgeot d'Arccb0d2d72008-06-18 22:19:22 +0000[diff] [blame]1157 )
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1158 if self.command.lower() == "post" and nbytes > 0:
1159 data = self.rfile.read(nbytes)
Amaury Forgeot d'Arccb0d2d72008-06-18 22:19:22 +0000[diff] [blame]1160 else:
1161 data = None
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1162 # throw away additional data [see bug #427345]
1163 while select.select([self.rfile._sock], [], [], 0)[0]:
1164 if not self.rfile._sock.recv(1):
1165 break
Amaury Forgeot d'Arccb0d2d72008-06-18 22:19:22 +0000[diff] [blame]1166 stdout, stderr = p.communicate(data)
1167 self.wfile.write(stdout)
1168 if stderr:
1169 self.log_error('%s', stderr)
Brian Curtincbad4df2010-11-05 15:04:48 +0000[diff] [blame]1170 p.stderr.close()
1171 p.stdout.close()
Amaury Forgeot d'Arccb0d2d72008-06-18 22:19:22 +0000[diff] [blame]1172 status = p.returncode
1173 if status:
1174 self.log_error("CGI script exit status %#x", status)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1175 else:
1176 self.log_message("CGI script exited OK")
1177
1178
1179def test(HandlerClass = BaseHTTPRequestHandler,
Senthil Kumaran1251faf2012-06-03 16:15:54 +0800[diff] [blame]1180 ServerClass = HTTPServer, protocol="HTTP/1.0", port=8000):
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1181 """Test the HTTP request handler class.
1182
1183 This runs an HTTP server on port 8000 (or the first command line
1184 argument).
1185
1186 """
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1187 server_address = ('', port)
1188
1189 HandlerClass.protocol_version = protocol
1190 httpd = ServerClass(server_address, HandlerClass)
1191
1192 sa = httpd.socket.getsockname()
1193 print("Serving HTTP on", sa[0], "port", sa[1], "...")
Alexandre Vassalottib5292a22009-04-03 07:16:55 +0000[diff] [blame]1194 try:
1195 httpd.serve_forever()
1196 except KeyboardInterrupt:
1197 print("\nKeyboard interrupt received, exiting.")
1198 httpd.server_close()
1199 sys.exit(0)
Georg Brandl24420152008-05-26 16:32:26 +0000[diff] [blame]1200
1201if __name__ == '__main__':
Senthil Kumaran1251faf2012-06-03 16:15:54 +0800[diff] [blame]1202 parser = argparse.ArgumentParser()
1203 parser.add_argument('--cgi', action='store_true',
1204 help='Run as CGI Server')
1205 parser.add_argument('port', action='store',
1206 default=8000, type=int,
1207 nargs='?',
1208 help='Specify alternate port [default: 8000]')
1209 args = parser.parse_args()
1210 if args.cgi:
1211 test(HandlerClass=CGIHTTPRequestHandler, port=args.port)
1212 else:
1213 test(HandlerClass=SimpleHTTPRequestHandler, port=args.port)