Debian Codegraph @

Lib/wsgiref/handlers.py

raw
1 """Base classes for server/gateway implementations"""
2
3 from .util import FileWrapper, guess_scheme, is_hop_by_hop
4 from .headers import Headers, _name_disallowed_re
5
6 import sys, os, time
7
8 __all__ = [
9 'BaseHandler', 'SimpleHandler', 'BaseCGIHandler', 'CGIHandler',
10 'IISCGIHandler', 'read_environ'
11 ]
12
13 # Weekday and month names for HTTP date/time formatting; always English!
14 _weekdayname = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
15 _monthname = [None, # Dummy so we can use 1-based month numbers
16 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
17 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
18
19 def format_date_time(timestamp):
20 year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp)
21 return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
22 _weekdayname[wd], day, _monthname[month], year, hh, mm, ss
23 )
24
25 _is_request = {
26 'SCRIPT_NAME', 'PATH_INFO', 'QUERY_STRING', 'REQUEST_METHOD', 'AUTH_TYPE',
27 'CONTENT_TYPE', 'CONTENT_LENGTH', 'HTTPS', 'REMOTE_USER', 'REMOTE_IDENT',
28 }.__contains__
29
30 def _needs_transcode(k):
31 return _is_request(k) or k.startswith('HTTP_') or k.startswith('SSL_') \
32 or (k.startswith('REDIRECT_') and _needs_transcode(k[9:]))
33
34 def read_environ():
35 """Read environment, fixing HTTP variables"""
36 enc = sys.getfilesystemencoding()
37 esc = 'surrogateescape'
38 try:
39 ''.encode('utf-8', esc)
40 except LookupError:
41 esc = 'replace'
42 environ = {}
43
44 # Take the basic environment from native-unicode os.environ. Attempt to
45 # fix up the variables that come from the HTTP request to compensate for
46 # the bytes->unicode decoding step that will already have taken place.
47 for k, v in os.environ.items():
48 if _needs_transcode(k):
49
50 # On win32, the os.environ is natively Unicode. Different servers
51 # decode the request bytes using different encodings.
52 if sys.platform == 'win32':
53 software = os.environ.get('SERVER_SOFTWARE', '').lower()
54
55 # On IIS, the HTTP request will be decoded as UTF-8 as long
56 # as the input is a valid UTF-8 sequence. Otherwise it is
57 # decoded using the system code page (mbcs), with no way to
58 # detect this has happened. Because UTF-8 is the more likely
59 # encoding, and mbcs is inherently unreliable (an mbcs string
60 # that happens to be valid UTF-8 will not be decoded as mbcs)
61 # always recreate the original bytes as UTF-8.
62 if software.startswith('microsoft-iis/'):
63 v = v.encode('utf-8').decode('iso-8859-1')
64
65 # Apache mod_cgi writes bytes-as-unicode (as if ISO-8859-1) direct
66 # to the Unicode environ. No modification needed.
67 elif software.startswith('apache/'):
68 pass
69
70 # Python 3's http.server.CGIHTTPRequestHandler decodes
71 # using the urllib.unquote default of UTF-8, amongst other
72 # issues.
73 elif (
74 software.startswith('simplehttp/')
75 and 'python/3' in software
76 ):
77 v = v.encode('utf-8').decode('iso-8859-1')
78
79 # For other servers, guess that they have written bytes to
80 # the environ using stdio byte-oriented interfaces, ending up
81 # with the system code page.
82 else:
83 v = v.encode(enc, 'replace').decode('iso-8859-1')
84
85 # Recover bytes from unicode environ, using surrogate escapes
86 # where available (Python 3.1+).
87 else:
88 v = v.encode(enc, esc).decode('iso-8859-1')
89
90 environ[k] = v
91 return environ
92
93
94 class BaseHandler:
95 """Manage the invocation of a WSGI application"""
96
97 # Configuration parameters; can override per-subclass or per-instance
98 wsgi_version = (1,0)
99 wsgi_multithread = True
100 wsgi_multiprocess = True
101 wsgi_run_once = False
102
103 origin_server = True # We are transmitting direct to client
104 http_version = "1.0" # Version that should be used for response
105 server_software = None # String name of server software, if any
106
107 # os_environ is used to supply configuration from the OS environment:
108 # by default it's a copy of 'os.environ' as of import time, but you can
109 # override this in e.g. your __init__ method.
110 os_environ= read_environ()
111
112 # Collaborator classes
113 wsgi_file_wrapper = FileWrapper # set to None to disable
114 headers_class = Headers # must be a Headers-like class
115
116 # Error handling (also per-subclass or per-instance)
117 traceback_limit = None # Print entire traceback to self.get_stderr()
118 error_status = "500 Internal Server Error"
119 error_headers = [('Content-Type','text/plain')]
120 error_body = b"A server error occurred. Please contact the administrator."
121
122 # State variables (don't mess with these)
123 status = result = None
124 headers_sent = False
125 headers = None
126 bytes_sent = 0
127
128 def run(self, application):
129 """Invoke the application"""
130 # Note to self: don't move the close()! Asynchronous servers shouldn't
131 # call close() from finish_response(), so if you close() anywhere but
132 # the double-error branch here, you'll break asynchronous servers by
133 # prematurely closing. Async servers must return from 'run()' without
134 # closing if there might still be output to iterate over.
135 try:
136 self.setup_environ()
137 self.result = application(self.environ, self.start_response)
138 self.finish_response()
139 except (ConnectionAbortedError, BrokenPipeError, ConnectionResetError):
140 # We expect the client to close the connection abruptly from time
141 # to time.
142 return
143 except:
144 try:
145 self.handle_error()
146 except:
147 # If we get an error handling an error, just give up already!
148 self.close()
149 raise # ...and let the actual server figure it out.
150
151
152 def setup_environ(self):
153 """Set up the environment for one request"""
154
155 env = self.environ = self.os_environ.copy()
156 self.add_cgi_vars()
157
158 env['wsgi.input'] = self.get_stdin()
159 env['wsgi.errors'] = self.get_stderr()
160 env['wsgi.version'] = self.wsgi_version
161 env['wsgi.run_once'] = self.wsgi_run_once
162 env['wsgi.url_scheme'] = self.get_scheme()
163 env['wsgi.multithread'] = self.wsgi_multithread
164 env['wsgi.multiprocess'] = self.wsgi_multiprocess
165
166 if self.wsgi_file_wrapper is not None:
167 env['wsgi.file_wrapper'] = self.wsgi_file_wrapper
168
169 if self.origin_server and self.server_software:
170 env.setdefault('SERVER_SOFTWARE',self.server_software)
171
172
173 def finish_response(self):
174 """Send any iterable data, then close self and the iterable
175
176 Subclasses intended for use in asynchronous servers will
177 want to redefine this method, such that it sets up callbacks
178 in the event loop to iterate over the data, and to call
179 'self.close()' once the response is finished.
180 """
181 try:
182 if not self.result_is_file() or not self.sendfile():
183 for data in self.result:
184 self.write(data)
185 self.finish_content()
186 except:
187 # Call close() on the iterable returned by the WSGI application
188 # in case of an exception.
189 if hasattr(self.result, 'close'):
190 self.result.close()
191 raise
192 else:
193 # We only call close() when no exception is raised, because it
194 # will set status, result, headers, and environ fields to None.
195 # See bpo-29183 for more details.
196 self.close()
197
198
199 def get_scheme(self):
200 """Return the URL scheme being used"""
201 return guess_scheme(self.environ)
202
203
204 def set_content_length(self):
205 """Compute Content-Length or switch to chunked encoding if possible"""
206 try:
207 blocks = len(self.result)
208 except (TypeError,AttributeError,NotImplementedError):
209 pass
210 else:
211 if blocks==1:
212 self.headers['Content-Length'] = str(self.bytes_sent)
213 return
214 # XXX Try for chunked encoding if origin server and client is 1.1
215
216
217 def cleanup_headers(self):
218 """Make any necessary header changes or defaults
219
220 Subclasses can extend this to add other defaults.
221 """
222 if 'Content-Length' not in self.headers:
223 self.set_content_length()
224
225 def start_response(self, status, headers,exc_info=None):
226 """'start_response()' callable as specified by PEP 3333"""
227
228 if exc_info:
229 try:
230 if self.headers_sent:
231 raise
232 finally:
233 exc_info = None # avoid dangling circular ref
234 elif self.headers is not None:
235 raise AssertionError("Headers already set!")
236
237 self.status = status
238 self.headers = self.headers_class(headers)
239 status = self._convert_string_type(status, "Status")
240 self._validate_status(status)
241
242 if __debug__:
243 for name, val in headers:
244 name = self._convert_string_type(name, "Header name")
245 val = self._convert_string_type(val, "Header value")
246 assert not is_hop_by_hop(name),\
247 f"Hop-by-hop header, '{name}: {val}', not allowed"
248
249 return self.write
250
251 def _validate_status(self, status):
252 if _name_disallowed_re.search(status):
253 raise ValueError("Control characters are not allowed in status")
254 if len(status) < 4:
255 raise AssertionError("Status must be at least 4 characters")
256 if not status[:3].isdigit():
257 raise AssertionError("Status message must begin w/3-digit code")
258 if status[3] != " ":
259 raise AssertionError("Status message must have a space after code")
260
261 def _convert_string_type(self, value, title):
262 """Convert/check value type."""
263 if type(value) is str:
264 return value
265 raise AssertionError(
266 "{0} must be of type str (got {1})".format(title, repr(value))
267 )
268
269 def send_preamble(self):
270 """Transmit version/status/date/server, via self._write()"""
271 if self.origin_server:
272 if self.client_is_modern():
273 self._write(('HTTP/%s %s\r\n' % (self.http_version,self.status)).encode('iso-8859-1'))
274 if 'Date' not in self.headers:
275 self._write(
276 ('Date: %s\r\n' % format_date_time(time.time())).encode('iso-8859-1')
277 )
278 if self.server_software and 'Server' not in self.headers:
279 self._write(('Server: %s\r\n' % self.server_software).encode('iso-8859-1'))
280 else:
281 self._write(('Status: %s\r\n' % self.status).encode('iso-8859-1'))
282
283 def write(self, data):
284 """'write()' callable as specified by PEP 3333"""
285
286 assert type(data) is bytes, \
287 "write() argument must be a bytes instance"
288
289 if not self.status:
290 raise AssertionError("write() before start_response()")
291
292 elif not self.headers_sent:
293 # Before the first output, send the stored headers
294 self.bytes_sent = len(data) # make sure we know content-length
295 self.send_headers()
296 else:
297 self.bytes_sent += len(data)
298
299 # XXX check Content-Length and truncate if too many bytes written?
300 self._write(data)
301 self._flush()
302
303
304 def sendfile(self):
305 """Platform-specific file transmission
306
307 Override this method in subclasses to support platform-specific
308 file transmission. It is only called if the application's
309 return iterable ('self.result') is an instance of
310 'self.wsgi_file_wrapper'.
311
312 This method should return a true value if it was able to actually
313 transmit the wrapped file-like object using a platform-specific
314 approach. It should return a false value if normal iteration
315 should be used instead. An exception can be raised to indicate
316 that transmission was attempted, but failed.
317
318 NOTE: this method should call 'self.send_headers()' if
319 'self.headers_sent' is false and it is going to attempt direct
320 transmission of the file.
321 """
322 return False # No platform-specific transmission by default
323
324
325 def finish_content(self):
326 """Ensure headers and content have both been sent"""
327 if not self.headers_sent:
328 # Only zero Content-Length if not set by the application (so
329 # that HEAD requests can be satisfied properly, see #3839)
330 self.headers.setdefault('Content-Length', "0")
331 self.send_headers()
332 else:
333 pass # XXX check if content-length was too short?
334
335 def close(self):
336 """Close the iterable (if needed) and reset all instance vars
337
338 Subclasses may want to also drop the client connection.
339 """
340 try:
341 if hasattr(self.result,'close'):
342 self.result.close()
343 finally:
344 self.result = self.headers = self.status = self.environ = None
345 self.bytes_sent = 0; self.headers_sent = False
346
347
348 def send_headers(self):
349 """Transmit headers to the client, via self._write()"""
350 self.cleanup_headers()
351 self.headers_sent = True
352 if not self.origin_server or self.client_is_modern():
353 self.send_preamble()
354 self._write(bytes(self.headers))
355
356
357 def result_is_file(self):
358 """True if 'self.result' is an instance of 'self.wsgi_file_wrapper'"""
359 wrapper = self.wsgi_file_wrapper
360 return wrapper is not None and isinstance(self.result,wrapper)
361
362
363 def client_is_modern(self):
364 """True if client can accept status and headers"""
365 return self.environ['SERVER_PROTOCOL'].upper() != 'HTTP/0.9'
366
367
368 def log_exception(self,exc_info):
369 """Log the 'exc_info' tuple in the server log
370
371 Subclasses may override to retarget the output or change its format.
372 """
373 try:
374 from traceback import print_exception
375 stderr = self.get_stderr()
376 print_exception(
377 exc_info[0], exc_info[1], exc_info[2],
378 self.traceback_limit, stderr
379 )
380 stderr.flush()
381 finally:
382 exc_info = None
383
384 def handle_error(self):
385 """Log current error, and send error output to client if possible"""
386 self.log_exception(sys.exc_info())
387 if not self.headers_sent:
388 self.result = self.error_output(self.environ, self.start_response)
389 self.finish_response()
390 # XXX else: attempt advanced recovery techniques for HTML or text?
391
392 def error_output(self, environ, start_response):
393 """WSGI mini-app to create error output
394
395 By default, this just uses the 'error_status', 'error_headers',
396 and 'error_body' attributes to generate an output page. It can
397 be overridden in a subclass to dynamically generate diagnostics,
398 choose an appropriate message for the user's preferred language, etc.
399
400 Note, however, that it's not recommended from a security perspective to
401 spit out diagnostics to any old user; ideally, you should have to do
402 something special to enable diagnostic output, which is why we don't
403 include any here!
404 """
405 start_response(self.error_status,self.error_headers[:],sys.exc_info())
406 return [self.error_body]
407
408
409 # Pure abstract methods; *must* be overridden in subclasses
410
411 def _write(self,data):
412 """Override in subclass to buffer data for send to client
413
414 It's okay if this method actually transmits the data; BaseHandler
415 just separates write and flush operations for greater efficiency
416 when the underlying system actually has such a distinction.
417 """
418 raise NotImplementedError
419
420 def _flush(self):
421 """Override in subclass to force sending of recent '_write()' calls
422
423 It's okay if this method is a no-op (i.e., if '_write()' actually
424 sends the data.
425 """
426 raise NotImplementedError
427
428 def get_stdin(self):
429 """Override in subclass to return suitable 'wsgi.input'"""
430 raise NotImplementedError
431
432 def get_stderr(self):
433 """Override in subclass to return suitable 'wsgi.errors'"""
434 raise NotImplementedError
435
436 def add_cgi_vars(self):
437 """Override in subclass to insert CGI variables in 'self.environ'"""
438 raise NotImplementedError
439
440
441 class SimpleHandler(BaseHandler):
442 """Handler that's just initialized with streams, environment, etc.
443
444 This handler subclass is intended for synchronous HTTP/1.0 origin servers,
445 and handles sending the entire response output, given the correct inputs.
446
447 Usage::
448
449 handler = SimpleHandler(
450 inp,out,err,env, multithread=False, multiprocess=True
451 )
452 handler.run(app)"""
453
454 def __init__(self,stdin,stdout,stderr,environ,
455 multithread=True, multiprocess=False
456 ):
457 self.stdin = stdin
458 self.stdout = stdout
459 self.stderr = stderr
460 self.base_env = environ
461 self.wsgi_multithread = multithread
462 self.wsgi_multiprocess = multiprocess
463
464 def get_stdin(self):
465 return self.stdin
466
467 def get_stderr(self):
468 return self.stderr
469
470 def add_cgi_vars(self):
471 self.environ.update(self.base_env)
472
473 def _write(self,data):
474 result = self.stdout.write(data)
475 if result is None or result == len(data):
476 return
477 from warnings import warn
478 warn("SimpleHandler.stdout.write() should not do partial writes",
479 DeprecationWarning)
480 while data := data[result:]:
481 result = self.stdout.write(data)
482
483 def _flush(self):
484 self.stdout.flush()
485 self._flush = self.stdout.flush
486
487
488 class BaseCGIHandler(SimpleHandler):
489
490 """CGI-like systems using input/output/error streams and environ mapping
491
492 Usage::
493
494 handler = BaseCGIHandler(inp,out,err,env)
495 handler.run(app)
496
497 This handler class is useful for gateway protocols like ReadyExec and
498 FastCGI, that have usable input/output/error streams and an environment
499 mapping. It's also the base class for CGIHandler, which just uses
500 sys.stdin, os.environ, and so on.
501
502 The constructor also takes keyword arguments 'multithread' and
503 'multiprocess' (defaulting to 'True' and 'False' respectively) to control
504 the configuration sent to the application. It sets 'origin_server' to
505 False (to enable CGI-like output), and assumes that 'wsgi.run_once' is
506 False.
507 """
508
509 origin_server = False
510
511
512 class CGIHandler(BaseCGIHandler):
513
514 """CGI-based invocation via sys.stdin/stdout/stderr and os.environ
515
516 Usage::
517
518 CGIHandler().run(app)
519
520 The difference between this class and BaseCGIHandler is that it always
521 uses 'wsgi.run_once' of 'True', 'wsgi.multithread' of 'False', and
522 'wsgi.multiprocess' of 'True'. It does not take any initialization
523 parameters, but always uses 'sys.stdin', 'os.environ', and friends.
524
525 If you need to override any of these parameters, use BaseCGIHandler
526 instead.
527 """
528
529 wsgi_run_once = True
530 # Do not allow os.environ to leak between requests in Google App Engine
531 # and other multi-run CGI use cases. This is not easily testable.
532 # See http://bugs.python.org/issue7250
533 os_environ = {}
534
535 def __init__(self):
536 BaseCGIHandler.__init__(
537 self, sys.stdin.buffer, sys.stdout.buffer, sys.stderr,
538 read_environ(), multithread=False, multiprocess=True
539 )
540
541
542 class IISCGIHandler(BaseCGIHandler):
543 """CGI-based invocation with workaround for IIS path bug
544
545 This handler should be used in preference to CGIHandler when deploying on
546 Microsoft IIS without having set the config allowPathInfo option (IIS>=7)
547 or metabase allowPathInfoForScriptMappings (IIS<7).
548 """
549 wsgi_run_once = True
550 os_environ = {}
551
552 # By default, IIS gives a PATH_INFO that duplicates the SCRIPT_NAME at
553 # the front, causing problems for WSGI applications that wish to implement
554 # routing. This handler strips any such duplicated path.
555
556 # IIS can be configured to pass the correct PATH_INFO, but this causes
557 # another bug where PATH_TRANSLATED is wrong. Luckily this variable is
558 # rarely used and is not guaranteed by WSGI. On IIS<7, though, the
559 # setting can only be made on a vhost level, affecting all other script
560 # mappings, many of which break when exposed to the PATH_TRANSLATED bug.
561 # For this reason IIS<7 is almost never deployed with the fix. (Even IIS7
562 # rarely uses it because there is still no UI for it.)
563
564 # There is no way for CGI code to tell whether the option was set, so a
565 # separate handler class is provided.
566 def __init__(self):
567 environ= read_environ()
568 path = environ.get('PATH_INFO', '')
569 script = environ.get('SCRIPT_NAME', '')
570 if (path+'/').startswith(script+'/'):
571 environ['PATH_INFO'] = path[len(script):]
572 BaseCGIHandler.__init__(
573 self, sys.stdin.buffer, sys.stdout.buffer, sys.stderr,
574 environ, multithread=False, multiprocess=True
575 )