Debian Codegraph @

Lib/http/server.py

raw
1 """HTTP server classes.
2
3 Note: BaseHTTPRequestHandler doesn't implement any HTTP request; see
4 SimpleHTTPRequestHandler for simple implementations of GET, HEAD and POST,
5 and (deprecated) CGIHTTPRequestHandler for CGI scripts.
6
7 It does, however, optionally implement HTTP/1.1 persistent connections.
8
9 Notes on CGIHTTPRequestHandler
10 ------------------------------
11
12 This class is deprecated. It implements GET and POST requests to cgi-bin scripts.
13
14 If the os.fork() function is not present (Windows), subprocess.Popen() is used,
15 with slightly altered but never documented semantics. Use from a threaded
16 process is likely to trigger a warning at os.fork() time.
17
18 In all cases, the implementation is intentionally naive -- all
19 requests are executed synchronously.
20
21 SECURITY WARNING: DON'T USE THIS CODE UNLESS YOU ARE INSIDE A FIREWALL
22 -- it may execute arbitrary Python code or external programs.
23
24 Note that status code 200 is sent prior to execution of a CGI script, so
25 scripts cannot send other status codes such as 302 (redirect).
26
27 XXX 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__ = [
86 "HTTPServer", "ThreadingHTTPServer", "BaseHTTPRequestHandler",
87 "SimpleHTTPRequestHandler", "CGIHTTPRequestHandler",
88 ]
89
90 import copy
91 import datetime
92 import email.utils
93 import html
94 import http.client
95 import io
96 import itertools
97 import mimetypes
98 import os
99 import posixpath
100 import select
101 import shutil
102 import socket # For gethostbyaddr()
103 import socketserver
104 import sys
105 import time
106 import urllib.parse
107
108 from http import HTTPStatus
109
110
111 # Default error message template
112 DEFAULT_ERROR_MESSAGE = """\
113 <!DOCTYPE HTML>
114 <html lang="en">
115 <head>
116 <meta charset="utf-8">
117 <title>Error response</title>
118 </head>
119 <body>
120 <h1>Error response</h1>
121 <p>Error code: %(code)d</p>
122 <p>Message: %(message)s.</p>
123 <p>Error code explanation: %(code)s - %(explain)s.</p>
124 </body>
125 </html>
126 """
127
128 DEFAULT_ERROR_CONTENT_TYPE = "text/html;charset=utf-8"
129
130 # Data larger than this will be read in chunks, to prevent extreme
131 # overallocation.
132 _MIN_READ_BUF_SIZE = 1 << 20
133
134 class HTTPServer(socketserver.TCPServer):
135
136 allow_reuse_address = 1 # Seems to make sense in testing environment
137
138 def server_bind(self):
139 """Override server_bind to store the server name."""
140 socketserver.TCPServer.server_bind(self)
141 host, port = self.server_address[:2]
142 self.server_name = socket.getfqdn(host)
143 self.server_port = port
144
145
146 class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
147 daemon_threads = True
148
149
150 class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
151
152 """HTTP request handler base class.
153
154 The following explanation of HTTP serves to guide you through the
155 code as well as to expose any misunderstandings I may have about
156 HTTP (so you don't need to read the code to figure out I'm wrong
157 :-).
158
159 HTTP (HyperText Transfer Protocol) is an extensible protocol on
160 top of a reliable stream transport (e.g. TCP/IP). The protocol
161 recognizes three parts to a request:
162
163 1. One line identifying the request type and path
164 2. An optional set of RFC-822-style headers
165 3. An optional data part
166
167 The headers and data are separated by a blank line.
168
169 The first line of the request has the form
170
171 <command> <path> <version>
172
173 where <command> is a (case-sensitive) keyword such as GET or POST,
174 <path> is a string containing path information for the request,
175 and <version> should be the string "HTTP/1.0" or "HTTP/1.1".
176 <path> is encoded using the URL encoding scheme (using %xx to signify
177 the ASCII character with hex code xx).
178
179 The specification specifies that lines are separated by CRLF but
180 for compatibility with the widest range of clients recommends
181 servers also handle LF. Similarly, whitespace in the request line
182 is treated sensibly (allowing multiple spaces between components
183 and allowing trailing whitespace).
184
185 Similarly, for output, lines ought to be separated by CRLF pairs
186 but most clients grok LF characters just fine.
187
188 If the first line of the request has the form
189
190 <command> <path>
191
192 (i.e. <version> is left out) then this is assumed to be an HTTP
193 0.9 request; this form has no optional headers and data part and
194 the reply consists of just the data.
195
196 The reply form of the HTTP 1.x protocol again has three parts:
197
198 1. One line giving the response code
199 2. An optional set of RFC-822-style headers
200 3. The data
201
202 Again, the headers and data are separated by a blank line.
203
204 The response code line has the form
205
206 <version> <responsecode> <responsestring>
207
208 where <version> is the protocol version ("HTTP/1.0" or "HTTP/1.1"),
209 <responsecode> is a 3-digit response code indicating success or
210 failure of the request, and <responsestring> is an optional
211 human-readable string explaining what the response code means.
212
213 This server parses the request and the headers, and then calls a
214 function specific to the request type (<command>). Specifically,
215 a request SPAM will be handled by a method do_SPAM(). If no
216 such method exists the server sends an error response to the
217 client. If it exists, it is called with no arguments:
218
219 do_SPAM()
220
221 Note that the request name is case sensitive (i.e. SPAM and spam
222 are different requests).
223
224 The various request details are stored in instance variables:
225
226 - client_address is the client IP address in the form (host,
227 port);
228
229 - command, path and version are the broken-down request line;
230
231 - headers is an instance of email.message.Message (or a derived
232 class) containing the header information;
233
234 - rfile is a file object open for reading positioned at the
235 start of the optional input data part;
236
237 - wfile is a file object open for writing.
238
239 IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!
240
241 The first thing to be written must be the response line. Then
242 follow 0 or more header lines, then a blank line, and then the
243 actual data (if any). The meaning of the header lines depends on
244 the command executed by the server; in most cases, when data is
245 returned, there should be at least one header line of the form
246
247 Content-type: <type>/<subtype>
248
249 where <type> and <subtype> should be registered MIME types,
250 e.g. "text/html" or "text/plain".
251
252 """
253
254 # The Python system version, truncated to its first component.
255 sys_version = "Python/" + sys.version.split()[0]
256
257 # The server software version. You may want to override this.
258 # The format is multiple whitespace-separated strings,
259 # where each string is of the form name[/version].
260 server_version = "BaseHTTP/" + __version__
261
262 error_message_format = DEFAULT_ERROR_MESSAGE
263 error_content_type = DEFAULT_ERROR_CONTENT_TYPE
264
265 # The default request version. This only affects responses up until
266 # the point where the request line is parsed, so it mainly decides what
267 # the client gets back when sending a malformed request line.
268 # Most web servers default to HTTP 0.9, i.e. don't send a status line.
269 default_request_version = "HTTP/0.9"
270
271 def parse_request(self):
272 """Parse a request (internal).
273
274 The request should be stored in self.raw_requestline; the results
275 are in self.command, self.path, self.request_version and
276 self.headers.
277
278 Return True for success, False for failure; on failure, any relevant
279 error response has already been sent back.
280
281 """
282 is_http_0_9 = False
283 self.command = None # set in case of error on the first line
284 self.request_version = version = self.default_request_version
285 self.close_connection = True
286 requestline = str(self.raw_requestline, 'iso-8859-1')
287 requestline = requestline.rstrip('\r\n')
288 self.requestline = requestline
289 words = requestline.split()
290 if len(words) == 0:
291 return False
292
293 if len(words) >= 3: # Enough to determine protocol version
294 version = words[-1]
295 try:
296 if not version.startswith('HTTP/'):
297 raise ValueError
298 base_version_number = version.split('/', 1)[1]
299 version_number = base_version_number.split(".")
300 # RFC 2145 section 3.1 says there can be only one "." and
301 # - major and minor numbers MUST be treated as
302 # separate integers;
303 # - HTTP/2.4 is a lower version than HTTP/2.13, which in
304 # turn is lower than HTTP/12.3;
305 # - Leading zeros MUST be ignored by recipients.
306 if len(version_number) != 2:
307 raise ValueError
308 if any(not component.isdigit() for component in version_number):
309 raise ValueError("non digit in http version")
310 if any(len(component) > 10 for component in version_number):
311 raise ValueError("unreasonable length http version")
312 version_number = int(version_number[0]), int(version_number[1])
313 except (ValueError, IndexError):
314 # Send the error response with a status line and headers.
315 self.request_version = ''
316 self.send_error(
317 HTTPStatus.BAD_REQUEST,
318 "Bad request version (%r)" % version)
319 return False
320 self.request_version = version
321 if version_number >= (1, 1) and self.protocol_version >= "HTTP/1.1":
322 self.close_connection = False
323 if version_number >= (2, 0):
324 self.send_error(
325 HTTPStatus.HTTP_VERSION_NOT_SUPPORTED,
326 "Invalid HTTP version (%s)" % base_version_number)
327 return False
328
329 if not 2 <= len(words) <= 3:
330 self.request_version = ''
331 self.send_error(
332 HTTPStatus.BAD_REQUEST,
333 "Bad request syntax (%r)" % requestline)
334 return False
335 command, path = words[:2]
336 if len(words) == 2:
337 self.close_connection = True
338 if command != 'GET':
339 self.request_version = ''
340 self.send_error(
341 HTTPStatus.BAD_REQUEST,
342 "Bad HTTP/0.9 request type (%r)" % command)
343 return False
344 is_http_0_9 = True
345 self.command, self.path = command, path
346
347 # gh-87389: The purpose of replacing '//' with '/' is to protect
348 # against open redirect attacks possibly triggered if the path starts
349 # with '//' because http clients treat //path as an absolute URI
350 # without scheme (similar to http://path) rather than a path.
351 if self.path.startswith('//'):
352 self.path = '/' + self.path.lstrip('/') # Reduce to a single /
353
354 # For HTTP/0.9, headers are not expected at all.
355 if is_http_0_9:
356 self.headers = {}
357 return True
358
359 # Examine the headers and look for a Connection directive.
360 try:
361 self.headers = http.client.parse_headers(self.rfile,
362 _class=self.MessageClass)
363 except http.client.LineTooLong as err:
364 self.send_error(
365 HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
366 "Line too long",
367 str(err))
368 return False
369 except http.client.HTTPException as err:
370 self.send_error(
371 HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
372 "Too many headers",
373 str(err)
374 )
375 return False
376
377 conntype = self.headers.get('Connection', "")
378 if conntype.lower() == 'close':
379 self.close_connection = True
380 elif (conntype.lower() == 'keep-alive' and
381 self.protocol_version >= "HTTP/1.1"):
382 self.close_connection = False
383 # Examine the headers and look for an Expect directive
384 expect = self.headers.get('Expect', "")
385 if (expect.lower() == "100-continue" and
386 self.protocol_version >= "HTTP/1.1" and
387 self.request_version >= "HTTP/1.1"):
388 if not self.handle_expect_100():
389 return False
390 return True
391
392 def handle_expect_100(self):
393 """Decide what to do with an "Expect: 100-continue" header.
394
395 If the client is expecting a 100 Continue response, we must
396 respond with either a 100 Continue or a final response before
397 waiting for the request body. The default is to always respond
398 with a 100 Continue. You can behave differently (for example,
399 reject unauthorized requests) by overriding this method.
400
401 This method should either return True (possibly after sending
402 a 100 Continue response) or send an error response and return
403 False.
404
405 """
406 self.send_response_only(HTTPStatus.CONTINUE)
407 self.end_headers()
408 return True
409
410 def handle_one_request(self):
411 """Handle a single HTTP request.
412
413 You normally don't need to override this method; see the class
414 __doc__ string for information on how to handle specific HTTP
415 commands such as GET and POST.
416
417 """
418 try:
419 self.raw_requestline = self.rfile.readline(65537)
420 if len(self.raw_requestline) > 65536:
421 self.requestline = ''
422 self.request_version = ''
423 self.command = ''
424 self.send_error(HTTPStatus.REQUEST_URI_TOO_LONG)
425 return
426 if not self.raw_requestline:
427 self.close_connection = True
428 return
429 if not self.parse_request():
430 # An error code has been sent, just exit
431 return
432 mname = 'do_' + self.command
433 if not hasattr(self, mname):
434 self.send_error(
435 HTTPStatus.NOT_IMPLEMENTED,
436 "Unsupported method (%r)" % self.command)
437 return
438 method = getattr(self, mname)
439 method()
440 self.wfile.flush() #actually send the response if not already done.
441 except TimeoutError as e:
442 #a read or a write timed out. Discard this connection
443 self.log_error("Request timed out: %r", e)
444 self.close_connection = True
445 return
446
447 def handle(self):
448 """Handle multiple requests if necessary."""
449 self.close_connection = True
450
451 self.handle_one_request()
452 while not self.close_connection:
453 self.handle_one_request()
454
455 def send_error(self, code, message=None, explain=None):
456 """Send and log an error reply.
457
458 Arguments are
459 * code: an HTTP error code
460 3 digits
461 * message: a simple optional 1 line reason phrase.
462 *( HTAB / SP / VCHAR / %x80-FF )
463 defaults to short entry matching the response code
464 * explain: a detailed message defaults to the long entry
465 matching the response code.
466
467 This sends an error response (so it must be called before any
468 output has been generated), logs the error, and finally sends
469 a piece of HTML explaining the error to the user.
470
471 """
472
473 try:
474 shortmsg, longmsg = self.responses[code]
475 except KeyError:
476 shortmsg, longmsg = '???', '???'
477 if message is None:
478 message = shortmsg
479 if explain is None:
480 explain = longmsg
481 self.log_error("code %d, message %s", code, message)
482 self.send_response(code, message)
483 self.send_header('Connection', 'close')
484
485 # Message body is omitted for cases described in:
486 # - RFC7230: 3.3. 1xx, 204(No Content), 304(Not Modified)
487 # - RFC7231: 6.3.6. 205(Reset Content)
488 body = None
489 if (code >= 200 and
490 code not in (HTTPStatus.NO_CONTENT,
491 HTTPStatus.RESET_CONTENT,
492 HTTPStatus.NOT_MODIFIED)):
493 # HTML encode to prevent Cross Site Scripting attacks
494 # (see bug #1100201)
495 content = (self.error_message_format % {
496 'code': code,
497 'message': html.escape(message, quote=False),
498 'explain': html.escape(explain, quote=False)
499 })
500 body = content.encode('UTF-8', 'replace')
501 self.send_header("Content-Type", self.error_content_type)
502 self.send_header('Content-Length', str(len(body)))
503 self.end_headers()
504
505 if self.command != 'HEAD' and body:
506 self.wfile.write(body)
507
508 def send_response(self, code, message=None):
509 """Add the response header to the headers buffer and log the
510 response code.
511
512 Also send two standard headers with the server software
513 version and the current date.
514
515 """
516 self.log_request(code)
517 self.send_response_only(code, message)
518 self.send_header('Server', self.version_string())
519 self.send_header('Date', self.date_time_string())
520
521 def send_response_only(self, code, message=None):
522 """Send the response header only."""
523 if self.request_version != 'HTTP/0.9':
524 if message is None:
525 if code in self.responses:
526 message = self.responses[code][0]
527 else:
528 message = ''
529 if not hasattr(self, '_headers_buffer'):
530 self._headers_buffer = []
531 self._headers_buffer.append(("%s %d %s\r\n" %
532 (self.protocol_version, code, message)).encode(
533 'latin-1', 'strict'))
534
535 def send_header(self, keyword, value):
536 """Send a MIME header to the headers buffer."""
537 if self.request_version != 'HTTP/0.9':
538 if not hasattr(self, '_headers_buffer'):
539 self._headers_buffer = []
540 self._headers_buffer.append(
541 ("%s: %s\r\n" % (keyword, value)).encode('latin-1', 'strict'))
542
543 if keyword.lower() == 'connection':
544 if value.lower() == 'close':
545 self.close_connection = True
546 elif value.lower() == 'keep-alive':
547 self.close_connection = False
548
549 def end_headers(self):
550 """Send the blank line ending the MIME headers."""
551 if self.request_version != 'HTTP/0.9':
552 self._headers_buffer.append(b"\r\n")
553 self.flush_headers()
554
555 def flush_headers(self):
556 if hasattr(self, '_headers_buffer'):
557 self.wfile.write(b"".join(self._headers_buffer))
558 self._headers_buffer = []
559
560 def log_request(self, code='-', size='-'):
561 """Log an accepted request.
562
563 This is called by send_response().
564
565 """
566 if isinstance(code, HTTPStatus):
567 code = code.value
568 self.log_message('"%s" %s %s',
569 self.requestline, str(code), str(size))
570
571 def log_error(self, format, *args):
572 """Log an error.
573
574 This is called when a request cannot be fulfilled. By
575 default it passes the message on to log_message().
576
577 Arguments are the same as for log_message().
578
579 XXX This should go to the separate error log.
580
581 """
582
583 self.log_message(format, *args)
584
585 # https://en.wikipedia.org/wiki/List_of_Unicode_characters#Control_codes
586 _control_char_table = str.maketrans(
587 {c: fr'\x{c:02x}' for c in itertools.chain(range(0x20), range(0x7f,0xa0))})
588 _control_char_table[ord('\\')] = r'\\'
589
590 def log_message(self, format, *args):
591 """Log an arbitrary message.
592
593 This is used by all other logging functions. Override
594 it if you have specific logging wishes.
595
596 The first argument, FORMAT, is a format string for the
597 message to be logged. If the format string contains
598 any % escapes requiring parameters, they should be
599 specified as subsequent arguments (it's just like
600 printf!).
601
602 The client ip and current date/time are prefixed to
603 every message.
604
605 Unicode control characters are replaced with escaped hex
606 before writing the output to stderr.
607
608 """
609
610 message = format % args
611 sys.stderr.write("%s - - [%s] %s\n" %
612 (self.address_string(),
613 self.log_date_time_string(),
614 message.translate(self._control_char_table)))
615
616 def version_string(self):
617 """Return the server software version string."""
618 return self.server_version + ' ' + self.sys_version
619
620 def date_time_string(self, timestamp=None):
621 """Return the current date and time formatted for a message header."""
622 if timestamp is None:
623 timestamp = time.time()
624 return email.utils.formatdate(timestamp, usegmt=True)
625
626 def log_date_time_string(self):
627 """Return the current time formatted for logging."""
628 now = time.time()
629 year, month, day, hh, mm, ss, x, y, z = time.localtime(now)
630 s = "%02d/%3s/%04d %02d:%02d:%02d" % (
631 day, self.monthname[month], year, hh, mm, ss)
632 return s
633
634 weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
635
636 monthname = [None,
637 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
638 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
639
640 def address_string(self):
641 """Return the client address."""
642
643 return self.client_address[0]
644
645 # Essentially static class variables
646
647 # The version of the HTTP protocol we support.
648 # Set this to HTTP/1.1 to enable automatic keepalive
649 protocol_version = "HTTP/1.0"
650
651 # MessageClass used to parse headers
652 MessageClass = http.client.HTTPMessage
653
654 # hack to maintain backwards compatibility
655 responses = {
656 v: (v.phrase, v.description)
657 for v in HTTPStatus.__members__.values()
658 }
659
660
661 class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
662
663 """Simple HTTP request handler with GET and HEAD commands.
664
665 This serves files from the current directory and any of its
666 subdirectories. The MIME type for files is determined by
667 calling the .guess_type() method.
668
669 The GET and HEAD requests are identical except that the HEAD
670 request omits the actual contents of the file.
671
672 """
673
674 server_version = "SimpleHTTP/" + __version__
675 index_pages = ("index.html", "index.htm")
676 extensions_map = _encodings_map_default = {
677 '.gz': 'application/gzip',
678 '.Z': 'application/octet-stream',
679 '.bz2': 'application/x-bzip2',
680 '.xz': 'application/x-xz',
681 }
682
683 def __init__(self, *args, directory=None, **kwargs):
684 if directory is None:
685 directory = os.getcwd()
686 self.directory = os.fspath(directory)
687 super().__init__(*args, **kwargs)
688
689 def do_GET(self):
690 """Serve a GET request."""
691 f = self.send_head()
692 if f:
693 try:
694 self.copyfile(f, self.wfile)
695 finally:
696 f.close()
697
698 def do_HEAD(self):
699 """Serve a HEAD request."""
700 f = self.send_head()
701 if f:
702 f.close()
703
704 def send_head(self):
705 """Common code for GET and HEAD commands.
706
707 This sends the response code and MIME headers.
708
709 Return value is either a file object (which has to be copied
710 to the outputfile by the caller unless the command was HEAD,
711 and must be closed by the caller under all circumstances), or
712 None, in which case the caller has nothing further to do.
713
714 """
715 path = self.translate_path(self.path)
716 f = None
717 if os.path.isdir(path):
718 parts = urllib.parse.urlsplit(self.path)
719 if not parts.path.endswith(('/', '%2f', '%2F')):
720 # redirect browser - doing basically what apache does
721 self.send_response(HTTPStatus.MOVED_PERMANENTLY)
722 new_parts = (parts[0], parts[1], parts[2] + '/',
723 parts[3], parts[4])
724 new_url = urllib.parse.urlunsplit(new_parts)
725 self.send_header("Location", new_url)
726 self.send_header("Content-Length", "0")
727 self.end_headers()
728 return None
729 for index in self.index_pages:
730 index = os.path.join(path, index)
731 if os.path.isfile(index):
732 path = index
733 break
734 else:
735 return self.list_directory(path)
736 ctype = self.guess_type(path)
737 # check for trailing "/" which should return 404. See Issue17324
738 # The test for this was added in test_httpserver.py
739 # However, some OS platforms accept a trailingSlash as a filename
740 # See discussion on python-dev and Issue34711 regarding
741 # parsing and rejection of filenames with a trailing slash
742 if path.endswith("/"):
743 self.send_error(HTTPStatus.NOT_FOUND, "File not found")
744 return None
745 try:
746 f = open(path, 'rb')
747 except OSError:
748 self.send_error(HTTPStatus.NOT_FOUND, "File not found")
749 return None
750
751 try:
752 fs = os.fstat(f.fileno())
753 # Use browser cache if possible
754 if ("If-Modified-Since" in self.headers
755 and "If-None-Match" not in self.headers):
756 # compare If-Modified-Since and time of last file modification
757 try:
758 ims = email.utils.parsedate_to_datetime(
759 self.headers["If-Modified-Since"])
760 except (TypeError, IndexError, OverflowError, ValueError):
761 # ignore ill-formed values
762 pass
763 else:
764 if ims.tzinfo is None:
765 # obsolete format with no timezone, cf.
766 # https://tools.ietf.org/html/rfc7231#section-7.1.1.1
767 ims = ims.replace(tzinfo=datetime.timezone.utc)
768 if ims.tzinfo is datetime.timezone.utc:
769 # compare to UTC datetime of last modification
770 last_modif = datetime.datetime.fromtimestamp(
771 fs.st_mtime, datetime.timezone.utc)
772 # remove microseconds, like in If-Modified-Since
773 last_modif = last_modif.replace(microsecond=0)
774
775 if last_modif <= ims:
776 self.send_response(HTTPStatus.NOT_MODIFIED)
777 self.end_headers()
778 f.close()
779 return None
780
781 self.send_response(HTTPStatus.OK)
782 self.send_header("Content-type", ctype)
783 self.send_header("Content-Length", str(fs[6]))
784 self.send_header("Last-Modified",
785 self.date_time_string(fs.st_mtime))
786 self.end_headers()
787 return f
788 except:
789 f.close()
790 raise
791
792 def list_directory(self, path):
793 """Helper to produce a directory listing (absent index.html).
794
795 Return value is either a file object, or None (indicating an
796 error). In either case, the headers are sent, making the
797 interface the same as for send_head().
798
799 """
800 try:
801 list = os.listdir(path)
802 except OSError:
803 self.send_error(
804 HTTPStatus.NOT_FOUND,
805 "No permission to list directory")
806 return None
807 list.sort(key=lambda a: a.lower())
808 r = []
809 displaypath = self.path
810 displaypath = displaypath.split('#', 1)[0]
811 displaypath = displaypath.split('?', 1)[0]
812 try:
813 displaypath = urllib.parse.unquote(displaypath,
814 errors='surrogatepass')
815 except UnicodeDecodeError:
816 displaypath = urllib.parse.unquote(displaypath)
817 displaypath = html.escape(displaypath, quote=False)
818 enc = sys.getfilesystemencoding()
819 title = f'Directory listing for {displaypath}'
820 r.append('<!DOCTYPE HTML>')
821 r.append('<html lang="en">')
822 r.append('<head>')
823 r.append(f'<meta charset="{enc}">')
824 r.append(f'<title>{title}</title>\n</head>')
825 r.append(f'<body>\n<h1>{title}</h1>')
826 r.append('<hr>\n<ul>')
827 for name in list:
828 fullname = os.path.join(path, name)
829 displayname = linkname = name
830 # Append / for directories or @ for symbolic links
831 if os.path.isdir(fullname):
832 displayname = name + "/"
833 linkname = name + "/"
834 if os.path.islink(fullname):
835 displayname = name + "@"
836 # Note: a link to a directory displays with @ and links with /
837 r.append('<li><a href="%s">%s</a></li>'
838 % (urllib.parse.quote(linkname,
839 errors='surrogatepass'),
840 html.escape(displayname, quote=False)))
841 r.append('</ul>\n<hr>\n</body>\n</html>\n')
842 encoded = '\n'.join(r).encode(enc, 'surrogateescape')
843 f = io.BytesIO()
844 f.write(encoded)
845 f.seek(0)
846 self.send_response(HTTPStatus.OK)
847 self.send_header("Content-type", "text/html; charset=%s" % enc)
848 self.send_header("Content-Length", str(len(encoded)))
849 self.end_headers()
850 return f
851
852 def translate_path(self, path):
853 """Translate a /-separated PATH to the local filename syntax.
854
855 Components that mean special things to the local file system
856 (e.g. drive or directory names) are ignored. (XXX They should
857 probably be diagnosed.)
858
859 """
860 # abandon query parameters
861 path = path.split('#', 1)[0]
862 path = path.split('?', 1)[0]
863 # Don't forget explicit trailing slash when normalizing. Issue17324
864 try:
865 path = urllib.parse.unquote(path, errors='surrogatepass')
866 except UnicodeDecodeError:
867 path = urllib.parse.unquote(path)
868 trailing_slash = path.endswith('/')
869 path = posixpath.normpath(path)
870 words = path.split('/')
871 words = filter(None, words)
872 path = self.directory
873 for word in words:
874 if os.path.dirname(word) or word in (os.curdir, os.pardir):
875 # Ignore components that are not a simple file/directory name
876 continue
877 path = os.path.join(path, word)
878 if trailing_slash:
879 path += '/'
880 return path
881
882 def copyfile(self, source, outputfile):
883 """Copy all data between two file objects.
884
885 The SOURCE argument is a file object open for reading
886 (or anything with a read() method) and the DESTINATION
887 argument is a file object open for writing (or
888 anything with a write() method).
889
890 The only reason for overriding this would be to change
891 the block size or perhaps to replace newlines by CRLF
892 -- note however that this the default server uses this
893 to copy binary data as well.
894
895 """
896 shutil.copyfileobj(source, outputfile)
897
898 def guess_type(self, path):
899 """Guess the type of a file.
900
901 Argument is a PATH (a filename).
902
903 Return value is a string of the form type/subtype,
904 usable for a MIME Content-type header.
905
906 The default implementation looks the file's extension
907 up in the table self.extensions_map, using application/octet-stream
908 as a default; however it would be permissible (if
909 slow) to look inside the data to make a better guess.
910
911 """
912 base, ext = posixpath.splitext(path)
913 if ext in self.extensions_map:
914 return self.extensions_map[ext]
915 ext = ext.lower()
916 if ext in self.extensions_map:
917 return self.extensions_map[ext]
918 guess, _ = mimetypes.guess_file_type(path)
919 if guess:
920 return guess
921 return 'application/octet-stream'
922
923
924 # Utilities for CGIHTTPRequestHandler
925
926 def _url_collapse_path(path):
927 """
928 Given a URL path, remove extra '/'s and '.' path elements and collapse
929 any '..' references and returns a collapsed path.
930
931 Implements something akin to RFC-2396 5.2 step 6 to parse relative paths.
932 The utility of this function is limited to is_cgi method and helps
933 preventing some security attacks.
934
935 Returns: The reconstituted URL, which will always start with a '/'.
936
937 Raises: IndexError if too many '..' occur within the path.
938
939 """
940 # Query component should not be involved.
941 path, _, query = path.partition('?')
942 path = urllib.parse.unquote(path)
943
944 # Similar to os.path.split(os.path.normpath(path)) but specific to URL
945 # path semantics rather than local operating system semantics.
946 path_parts = path.split('/')
947 head_parts = []
948 for part in path_parts[:-1]:
949 if part == '..':
950 head_parts.pop() # IndexError if more '..' than prior parts
951 elif part and part != '.':
952 head_parts.append( part )
953 if path_parts:
954 tail_part = path_parts.pop()
955 if tail_part:
956 if tail_part == '..':
957 head_parts.pop()
958 tail_part = ''
959 elif tail_part == '.':
960 tail_part = ''
961 else:
962 tail_part = ''
963
964 if query:
965 tail_part = '?'.join((tail_part, query))
966
967 splitpath = ('/' + '/'.join(head_parts), tail_part)
968 collapsed_path = "/".join(splitpath)
969
970 return collapsed_path
971
972
973
974 nobody = None
975
976 def nobody_uid():
977 """Internal routine to get nobody's uid"""
978 global nobody
979 if nobody:
980 return nobody
981 try:
982 import pwd
983 except ImportError:
984 return -1
985 try:
986 nobody = pwd.getpwnam('nobody')[2]
987 except KeyError:
988 nobody = 1 + max(x[2] for x in pwd.getpwall())
989 return nobody
990
991
992 def executable(path):
993 """Test for executable file."""
994 return os.access(path, os.X_OK)
995
996
997 class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
998
999 """Complete HTTP server with GET, HEAD and POST commands.
1000
1001 GET and HEAD also support running CGI scripts.
1002
1003 The POST command is *only* implemented for CGI scripts.
1004
1005 """
1006
1007 def __init__(self, *args, **kwargs):
1008 import warnings
1009 warnings._deprecated("http.server.CGIHTTPRequestHandler",
1010 remove=(3, 15))
1011 super().__init__(*args, **kwargs)
1012
1013 # Determine platform specifics
1014 have_fork = hasattr(os, 'fork')
1015
1016 # Make rfile unbuffered -- we need to read one line and then pass
1017 # the rest to a subprocess, so we can't use buffered input.
1018 rbufsize = 0
1019
1020 def do_POST(self):
1021 """Serve a POST request.
1022
1023 This is only implemented for CGI scripts.
1024
1025 """
1026
1027 if self.is_cgi():
1028 self.run_cgi()
1029 else:
1030 self.send_error(
1031 HTTPStatus.NOT_IMPLEMENTED,
1032 "Can only POST to CGI scripts")
1033
1034 def send_head(self):
1035 """Version of send_head that support CGI scripts"""
1036 if self.is_cgi():
1037 return self.run_cgi()
1038 else:
1039 return SimpleHTTPRequestHandler.send_head(self)
1040
1041 def is_cgi(self):
1042 """Test whether self.path corresponds to a CGI script.
1043
1044 Returns True and updates the cgi_info attribute to the tuple
1045 (dir, rest) if self.path requires running a CGI script.
1046 Returns False otherwise.
1047
1048 If any exception is raised, the caller should assume that
1049 self.path was rejected as invalid and act accordingly.
1050
1051 The default implementation tests whether the normalized url
1052 path begins with one of the strings in self.cgi_directories
1053 (and the next character is a '/' or the end of the string).
1054
1055 """
1056 collapsed_path = _url_collapse_path(self.path)
1057 dir_sep = collapsed_path.find('/', 1)
1058 while dir_sep > 0 and not collapsed_path[:dir_sep] in self.cgi_directories:
1059 dir_sep = collapsed_path.find('/', dir_sep+1)
1060 if dir_sep > 0:
1061 head, tail = collapsed_path[:dir_sep], collapsed_path[dir_sep+1:]
1062 self.cgi_info = head, tail
1063 return True
1064 return False
1065
1066
1067 cgi_directories = ['/cgi-bin', '/htbin']
1068
1069 def is_executable(self, path):
1070 """Test whether argument path is an executable file."""
1071 return executable(path)
1072
1073 def is_python(self, path):
1074 """Test whether argument path is a Python script."""
1075 head, tail = os.path.splitext(path)
1076 return tail.lower() in (".py", ".pyw")
1077
1078 def run_cgi(self):
1079 """Execute a CGI script."""
1080 dir, rest = self.cgi_info
1081 path = dir + '/' + rest
1082 i = path.find('/', len(dir)+1)
1083 while i >= 0:
1084 nextdir = path[:i]
1085 nextrest = path[i+1:]
1086
1087 scriptdir = self.translate_path(nextdir)
1088 if os.path.isdir(scriptdir):
1089 dir, rest = nextdir, nextrest
1090 i = path.find('/', len(dir)+1)
1091 else:
1092 break
1093
1094 # find an explicit query string, if present.
1095 rest, _, query = rest.partition('?')
1096
1097 # dissect the part after the directory name into a script name &
1098 # a possible additional path, to be stored in PATH_INFO.
1099 i = rest.find('/')
1100 if i >= 0:
1101 script, rest = rest[:i], rest[i:]
1102 else:
1103 script, rest = rest, ''
1104
1105 scriptname = dir + '/' + script
1106 scriptfile = self.translate_path(scriptname)
1107 if not os.path.exists(scriptfile):
1108 self.send_error(
1109 HTTPStatus.NOT_FOUND,
1110 "No such CGI script (%r)" % scriptname)
1111 return
1112 if not os.path.isfile(scriptfile):
1113 self.send_error(
1114 HTTPStatus.FORBIDDEN,
1115 "CGI script is not a plain file (%r)" % scriptname)
1116 return
1117 ispy = self.is_python(scriptname)
1118 if self.have_fork or not ispy:
1119 if not self.is_executable(scriptfile):
1120 self.send_error(
1121 HTTPStatus.FORBIDDEN,
1122 "CGI script is not executable (%r)" % scriptname)
1123 return
1124
1125 # Reference: https://www6.uniovi.es/~antonio/ncsa_httpd/cgi/env.html
1126 # XXX Much of the following could be prepared ahead of time!
1127 env = copy.deepcopy(os.environ)
1128 env['SERVER_SOFTWARE'] = self.version_string()
1129 env['SERVER_NAME'] = self.server.server_name
1130 env['GATEWAY_INTERFACE'] = 'CGI/1.1'
1131 env['SERVER_PROTOCOL'] = self.protocol_version
1132 env['SERVER_PORT'] = str(self.server.server_port)
1133 env['REQUEST_METHOD'] = self.command
1134 uqrest = urllib.parse.unquote(rest)
1135 env['PATH_INFO'] = uqrest
1136 env['PATH_TRANSLATED'] = self.translate_path(uqrest)
1137 env['SCRIPT_NAME'] = scriptname
1138 env['QUERY_STRING'] = query
1139 env['REMOTE_ADDR'] = self.client_address[0]
1140 authorization = self.headers.get("authorization")
1141 if authorization:
1142 authorization = authorization.split()
1143 if len(authorization) == 2:
1144 import base64, binascii
1145 env['AUTH_TYPE'] = authorization[0]
1146 if authorization[0].lower() == "basic":
1147 try:
1148 authorization = authorization[1].encode('ascii')
1149 authorization = base64.decodebytes(authorization).\
1150 decode('ascii')
1151 except (binascii.Error, UnicodeError):
1152 pass
1153 else:
1154 authorization = authorization.split(':')
1155 if len(authorization) == 2:
1156 env['REMOTE_USER'] = authorization[0]
1157 # XXX REMOTE_IDENT
1158 if self.headers.get('content-type') is None:
1159 env['CONTENT_TYPE'] = self.headers.get_content_type()
1160 else:
1161 env['CONTENT_TYPE'] = self.headers['content-type']
1162 length = self.headers.get('content-length')
1163 if length:
1164 env['CONTENT_LENGTH'] = length
1165 referer = self.headers.get('referer')
1166 if referer:
1167 env['HTTP_REFERER'] = referer
1168 accept = self.headers.get_all('accept', ())
1169 env['HTTP_ACCEPT'] = ','.join(accept)
1170 ua = self.headers.get('user-agent')
1171 if ua:
1172 env['HTTP_USER_AGENT'] = ua
1173 co = filter(None, self.headers.get_all('cookie', []))
1174 cookie_str = ', '.join(co)
1175 if cookie_str:
1176 env['HTTP_COOKIE'] = cookie_str
1177 # XXX Other HTTP_* headers
1178 # Since we're setting the env in the parent, provide empty
1179 # values to override previously set values
1180 for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',
1181 'HTTP_USER_AGENT', 'HTTP_COOKIE', 'HTTP_REFERER'):
1182 env.setdefault(k, "")
1183
1184 self.send_response(HTTPStatus.OK, "Script output follows")
1185 self.flush_headers()
1186
1187 decoded_query = query.replace('+', ' ')
1188
1189 if self.have_fork:
1190 # Unix -- fork as we should
1191 args = [script]
1192 if '=' not in decoded_query:
1193 args.append(decoded_query)
1194 nobody = nobody_uid()
1195 self.wfile.flush() # Always flush before forking
1196 pid = os.fork()
1197 if pid != 0:
1198 # Parent
1199 pid, sts = os.waitpid(pid, 0)
1200 # throw away additional data [see bug #427345]
1201 while select.select([self.rfile], [], [], 0)[0]:
1202 if not self.rfile.read(1):
1203 break
1204 exitcode = os.waitstatus_to_exitcode(sts)
1205 if exitcode:
1206 self.log_error(f"CGI script exit code {exitcode}")
1207 return
1208 # Child
1209 try:
1210 try:
1211 os.setuid(nobody)
1212 except OSError:
1213 pass
1214 os.dup2(self.rfile.fileno(), 0)
1215 os.dup2(self.wfile.fileno(), 1)
1216 os.execve(scriptfile, args, env)
1217 except:
1218 self.server.handle_error(self.request, self.client_address)
1219 os._exit(127)
1220
1221 else:
1222 # Non-Unix -- use subprocess
1223 import subprocess
1224 cmdline = [scriptfile]
1225 if self.is_python(scriptfile):
1226 interp = sys.executable
1227 if interp.lower().endswith("w.exe"):
1228 # On Windows, use python.exe, not pythonw.exe
1229 interp = interp[:-5] + interp[-4:]
1230 cmdline = [interp, '-u'] + cmdline
1231 if '=' not in query:
1232 cmdline.append(query)
1233 self.log_message("command: %s", subprocess.list2cmdline(cmdline))
1234 try:
1235 nbytes = int(length)
1236 except (TypeError, ValueError):
1237 nbytes = 0
1238 p = subprocess.Popen(cmdline,
1239 stdin=subprocess.PIPE,
1240 stdout=subprocess.PIPE,
1241 stderr=subprocess.PIPE,
1242 env = env
1243 )
1244 if self.command.lower() == "post" and nbytes > 0:
1245 cursize = 0
1246 data = self.rfile.read(min(nbytes, _MIN_READ_BUF_SIZE))
1247 while len(data) < nbytes and len(data) != cursize:
1248 cursize = len(data)
1249 # This is a geometric increase in read size (never more
1250 # than doubling out the current length of data per loop
1251 # iteration).
1252 delta = min(cursize, nbytes - cursize)
1253 try:
1254 data += self.rfile.read(delta)
1255 except TimeoutError:
1256 break
1257 else:
1258 data = None
1259 # throw away additional data [see bug #427345]
1260 while select.select([self.rfile._sock], [], [], 0)[0]:
1261 if not self.rfile._sock.recv(1):
1262 break
1263 stdout, stderr = p.communicate(data)
1264 self.wfile.write(stdout)
1265 if stderr:
1266 self.log_error('%s', stderr)
1267 p.stderr.close()
1268 p.stdout.close()
1269 status = p.returncode
1270 if status:
1271 self.log_error("CGI script exit status %#x", status)
1272 else:
1273 self.log_message("CGI script exited OK")
1274
1275
1276 def _get_best_family(*address):
1277 infos = socket.getaddrinfo(
1278 *address,
1279 type=socket.SOCK_STREAM,
1280 flags=socket.AI_PASSIVE,
1281 )
1282 family, type, proto, canonname, sockaddr = next(iter(infos))
1283 return family, sockaddr
1284
1285
1286 def test(HandlerClass=BaseHTTPRequestHandler,
1287 ServerClass=ThreadingHTTPServer,
1288 protocol="HTTP/1.0", port=8000, bind=None):
1289 """Test the HTTP request handler class.
1290
1291 This runs an HTTP server on port 8000 (or the port argument).
1292
1293 """
1294 ServerClass.address_family, addr = _get_best_family(bind, port)
1295 HandlerClass.protocol_version = protocol
1296 with ServerClass(addr, HandlerClass) as httpd:
1297 host, port = httpd.socket.getsockname()[:2]
1298 url_host = f'[{host}]' if ':' in host else host
1299 print(
1300 f"Serving HTTP on {host} port {port} "
1301 f"(http://{url_host}:{port}/) ..."
1302 )
1303 try:
1304 httpd.serve_forever()
1305 except KeyboardInterrupt:
1306 print("\nKeyboard interrupt received, exiting.")
1307 sys.exit(0)
1308
1309 if __name__ == '__main__':
1310 import argparse
1311 import contextlib
1312
1313 parser = argparse.ArgumentParser()
1314 parser.add_argument('--cgi', action='store_true',
1315 help='run as CGI server')
1316 parser.add_argument('-b', '--bind', metavar='ADDRESS',
1317 help='bind to this address '
1318 '(default: all interfaces)')
1319 parser.add_argument('-d', '--directory', default=os.getcwd(),
1320 help='serve this directory '
1321 '(default: current directory)')
1322 parser.add_argument('-p', '--protocol', metavar='VERSION',
1323 default='HTTP/1.0',
1324 help='conform to this HTTP version '
1325 '(default: %(default)s)')
1326 parser.add_argument('port', default=8000, type=int, nargs='?',
1327 help='bind to this port '
1328 '(default: %(default)s)')
1329 args = parser.parse_args()
1330 if args.cgi:
1331 handler_class = CGIHTTPRequestHandler
1332 else:
1333 handler_class = SimpleHTTPRequestHandler
1334
1335 # ensure dual-stack is not disabled; ref #38907
1336 class DualStackServer(ThreadingHTTPServer):
1337
1338 def server_bind(self):
1339 # suppress exception when protocol is IPv4
1340 with contextlib.suppress(Exception):
1341 self.socket.setsockopt(
1342 socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
1343 return super().server_bind()
1344
1345 def finish_request(self, request, client_address):
1346 self.RequestHandlerClass(request, client_address, self,
1347 directory=args.directory)
1348
1349 test(
1350 HandlerClass=handler_class,
1351 ServerClass=DualStackServer,
1352 port=args.port,
1353 bind=args.bind,
1354 protocol=args.protocol,
1355 )