1 #! /usr/local/bin/python
3 # NOTE: the above "/usr/local/bin/python" is NOT a mistake. It is
4 # intentionally NOT "/usr/bin/env python". On many systems
5 # (e.g. Solaris), /usr/local/bin is not in $PATH as passed to CGI
6 # scripts, and /usr/local/bin is the default directory where Python is
7 # installed, so /usr/bin/env would be unable to find python. Granted,
8 # binary installations by Linux vendors often install Python in
9 # /usr/bin. So let those vendors patch cgi.py to match their choice
12 """Support module for CGI (Common Gateway Interface) scripts.
14 This module defines a number of utilities for use by CGI scripts
18 # XXX Perhaps there should be a slimmed version that doesn't contain
19 # all those backwards compatible and debugging classes and functions?
24 # Michael McLay started this module. Steve Majewski changed the
25 # interface to SvFormContentDict and FormContentDict. The multipart
26 # parsing was inspired by code submitted by Andreas Paepcke. Guido van
27 # Rossum rewrote, reformatted and documented the module and is currently
28 # responsible for its maintenance.
37 from operator
import attrgetter
45 from cStringIO
import StringIO
47 from StringIO
import StringIO
49 __all__
= ["MiniFieldStorage", "FieldStorage", "FormContentDict",
50 "SvFormContentDict", "InterpFormContentDict", "FormContent",
51 "parse", "parse_qs", "parse_qsl", "parse_multipart",
52 "parse_header", "print_exception", "print_environ",
53 "print_form", "print_directory", "print_arguments",
54 "print_environ_usage", "escape"]
59 logfile
= "" # Filename to log to, if not empty
60 logfp
= None # File object to log to, if not None
62 def initlog(*allargs
):
63 """Write a log message, if there is a log file.
65 Even though this function is called initlog(), you should always
66 use log(); log is a variable that is set either to initlog
67 (initially), to dolog (once the log file has been opened), or to
68 nolog (when logging is disabled).
70 The first argument is a format string; the remaining arguments (if
71 any) are arguments to the % operator, so e.g.
72 log("%s: %s", "a", "b")
73 will write "a: b" to the log file, followed by a newline.
75 If the global logfp is not None, it should be a file object to
76 which log data is written.
78 If the global logfp is None, the global logfile may be a string
79 giving a filename to open, in append mode. This file should be
80 world writable!!! If the file can't be opened, logging is
81 silently disabled (since there is no safe place where we could
82 send an error message).
86 if logfile
and not logfp
:
88 logfp
= open(logfile
, "a")
97 def dolog(fmt
, *args
):
98 """Write a log message to the log file. See initlog() for docs."""
99 logfp
.write(fmt
%args
+ "\n")
102 """Dummy function, assigned to log when logging is disabled."""
105 log
= initlog
# The current logging function
111 # Maximum input we will accept when REQUEST_METHOD is POST
112 # 0 ==> unlimited input
115 def parse(fp
=None, environ
=os
.environ
, keep_blank_values
=0, strict_parsing
=0):
116 """Parse a query in the environment or from a file (default stdin)
118 Arguments, all optional:
120 fp : file pointer; default: sys.stdin
122 environ : environment dictionary; default: os.environ
124 keep_blank_values: flag indicating whether blank values in
125 URL encoded forms should be treated as blank strings.
126 A true value indicates that blanks should be retained as
127 blank strings. The default false value indicates that
128 blank values are to be ignored and treated as if they were
131 strict_parsing: flag indicating what to do with parsing errors.
132 If false (the default), errors are silently ignored.
133 If true, errors raise a ValueError exception.
137 if not 'REQUEST_METHOD' in environ
:
138 environ
['REQUEST_METHOD'] = 'GET' # For testing stand-alone
139 if environ
['REQUEST_METHOD'] == 'POST':
140 ctype
, pdict
= parse_header(environ
['CONTENT_TYPE'])
141 if ctype
== 'multipart/form-data':
142 return parse_multipart(fp
, pdict
)
143 elif ctype
== 'application/x-www-form-urlencoded':
144 clength
= int(environ
['CONTENT_LENGTH'])
145 if maxlen
and clength
> maxlen
:
146 raise ValueError, 'Maximum content length exceeded'
147 qs
= fp
.read(clength
)
149 qs
= '' # Unknown content-type
150 if 'QUERY_STRING' in environ
:
152 qs
= qs
+ environ
['QUERY_STRING']
155 qs
= qs
+ sys
.argv
[1]
156 environ
['QUERY_STRING'] = qs
# XXX Shouldn't, really
157 elif 'QUERY_STRING' in environ
:
158 qs
= environ
['QUERY_STRING']
164 environ
['QUERY_STRING'] = qs
# XXX Shouldn't, really
165 return parse_qs(qs
, keep_blank_values
, strict_parsing
)
168 def parse_qs(qs
, keep_blank_values
=0, strict_parsing
=0):
169 """Parse a query given as a string argument.
173 qs: URL-encoded query string to be parsed
175 keep_blank_values: flag indicating whether blank values in
176 URL encoded queries should be treated as blank strings.
177 A true value indicates that blanks should be retained as
178 blank strings. The default false value indicates that
179 blank values are to be ignored and treated as if they were
182 strict_parsing: flag indicating what to do with parsing errors.
183 If false (the default), errors are silently ignored.
184 If true, errors raise a ValueError exception.
187 for name
, value
in parse_qsl(qs
, keep_blank_values
, strict_parsing
):
189 dict[name
].append(value
)
194 def parse_qsl(qs
, keep_blank_values
=0, strict_parsing
=0):
195 """Parse a query given as a string argument.
199 qs: URL-encoded query string to be parsed
201 keep_blank_values: flag indicating whether blank values in
202 URL encoded queries should be treated as blank strings. A
203 true value indicates that blanks should be retained as blank
204 strings. The default false value indicates that blank values
205 are to be ignored and treated as if they were not included.
207 strict_parsing: flag indicating what to do with parsing errors. If
208 false (the default), errors are silently ignored. If true,
209 errors raise a ValueError exception.
211 Returns a list, as G-d intended.
213 pairs
= [s2
for s1
in qs
.split('&') for s2
in s1
.split(';')]
215 for name_value
in pairs
:
216 if not name_value
and not strict_parsing
:
218 nv
= name_value
.split('=', 1)
221 raise ValueError, "bad query field: %r" % (name_value
,)
222 # Handle case of a control-name with no equal sign
223 if keep_blank_values
:
227 if len(nv
[1]) or keep_blank_values
:
228 name
= urllib
.unquote(nv
[0].replace('+', ' '))
229 value
= urllib
.unquote(nv
[1].replace('+', ' '))
230 r
.append((name
, value
))
235 def parse_multipart(fp
, pdict
):
236 """Parse multipart input.
240 pdict: dictionary containing other parameters of content-type header
242 Returns a dictionary just like parse_qs(): keys are the field names, each
243 value is a list of values for that field. This is easy to use but not
244 much good if you are expecting megabytes to be uploaded -- in that case,
245 use the FieldStorage class instead which is much more flexible. Note
246 that content-type is the raw, unparsed contents of the content-type
249 XXX This does not parse nested multipart parts -- use FieldStorage for
252 XXX This should really be subsumed by FieldStorage altogether -- no
253 point in having two implementations of the same parsing algorithm.
254 Also, FieldStorage protects itself better against certain DoS attacks
255 by limiting the size of the data read in one chunk. The API here
256 does not support that kind of protection. This also affects parse()
257 since it can call parse_multipart().
261 if 'boundary' in pdict
:
262 boundary
= pdict
['boundary']
263 if not valid_boundary(boundary
):
264 raise ValueError, ('Invalid boundary in multipart form: %r'
267 nextpart
= "--" + boundary
268 lastpart
= "--" + boundary
+ "--"
272 while terminator
!= lastpart
:
276 # At start of next part. Read headers first.
277 headers
= mimetools
.Message(fp
)
278 clength
= headers
.getheader('content-length')
285 if maxlen
and bytes
> maxlen
:
286 raise ValueError, 'Maximum content length exceeded'
287 data
= fp
.read(bytes
)
290 # Read lines until end of part.
295 terminator
= lastpart
# End outer loop
298 terminator
= line
.strip()
299 if terminator
in (nextpart
, lastpart
):
307 # Strip final line terminator
309 if line
[-2:] == "\r\n":
311 elif line
[-1:] == "\n":
314 data
= "".join(lines
)
315 line
= headers
['content-disposition']
318 key
, params
= parse_header(line
)
319 if key
!= 'form-data':
322 name
= params
['name']
326 partdict
[name
].append(data
)
328 partdict
[name
] = [data
]
333 def parse_header(line
):
334 """Parse a Content-type like header.
336 Return the main content-type and a dictionary of options.
339 plist
= [x
.strip() for x
in line
.split(';')]
340 key
= plist
.pop(0).lower()
345 name
= p
[:i
].strip().lower()
346 value
= p
[i
+1:].strip()
347 if len(value
) >= 2 and value
[0] == value
[-1] == '"':
349 value
= value
.replace('\\\\', '\\').replace('\\"', '"')
354 # Classes for field storage
355 # =========================
357 class MiniFieldStorage
:
359 """Like FieldStorage, for use when no file uploads are possible."""
368 disposition_options
= {}
371 def __init__(self
, name
, value
):
372 """Constructor from field name and value."""
375 # self.file = StringIO(value)
378 """Return printable representation."""
379 return "MiniFieldStorage(%r, %r)" % (self
.name
, self
.value
)
384 """Store a sequence of fields, reading multipart/form-data.
386 This class provides naming, typing, files stored on disk, and
387 more. At the top level, it is accessible like a dictionary, whose
388 keys are the field names. (Note: None can occur as a field name.)
389 The items are either a Python list (if there's multiple values) or
390 another FieldStorage or MiniFieldStorage object. If it's a single
391 object, it has the following attributes:
393 name: the field name, if specified; otherwise None
395 filename: the filename, if specified; otherwise None; this is the
396 client side filename, *not* the file name on which it is
397 stored (that's a temporary file you don't deal with)
399 value: the value as a *string*; for file uploads, this
400 transparently reads the file every time you request the value
402 file: the file(-like) object from which you can read the data;
403 None if the data is stored a simple string
405 type: the content-type, or None if not specified
407 type_options: dictionary of options specified on the content-type
410 disposition: content-disposition, or None if not specified
412 disposition_options: dictionary of corresponding options
414 headers: a dictionary(-like) object (sometimes rfc822.Message or a
415 subclass thereof) containing *all* headers
417 The class is subclassable, mostly for the purpose of overriding
418 the make_file() method, which is called internally to come up with
419 a file open for reading and writing. This makes it possible to
420 override the default choice of storing all files in a temporary
421 directory and unlinking them as soon as they have been opened.
425 def __init__(self
, fp
=None, headers
=None, outerboundary
="",
426 environ
=os
.environ
, keep_blank_values
=0, strict_parsing
=0):
427 """Constructor. Read multipart/* until last part.
429 Arguments, all optional:
431 fp : file pointer; default: sys.stdin
432 (not used when the request method is GET)
434 headers : header dictionary-like object; default:
435 taken from environ as per CGI spec
437 outerboundary : terminating multipart boundary
438 (for internal use only)
440 environ : environment dictionary; default: os.environ
442 keep_blank_values: flag indicating whether blank values in
443 URL encoded forms should be treated as blank strings.
444 A true value indicates that blanks should be retained as
445 blank strings. The default false value indicates that
446 blank values are to be ignored and treated as if they were
449 strict_parsing: flag indicating what to do with parsing errors.
450 If false (the default), errors are silently ignored.
451 If true, errors raise a ValueError exception.
455 self
.keep_blank_values
= keep_blank_values
456 self
.strict_parsing
= strict_parsing
457 if 'REQUEST_METHOD' in environ
:
458 method
= environ
['REQUEST_METHOD'].upper()
459 self
.qs_on_post
= None
460 if method
== 'GET' or method
== 'HEAD':
461 if 'QUERY_STRING' in environ
:
462 qs
= environ
['QUERY_STRING']
469 headers
= {'content-type':
470 "application/x-www-form-urlencoded"}
474 # Set default content-type for POST to what's traditional
475 headers
['content-type'] = "application/x-www-form-urlencoded"
476 if 'CONTENT_TYPE' in environ
:
477 headers
['content-type'] = environ
['CONTENT_TYPE']
478 if 'QUERY_STRING' in environ
:
479 self
.qs_on_post
= environ
['QUERY_STRING']
480 if 'CONTENT_LENGTH' in environ
:
481 headers
['content-length'] = environ
['CONTENT_LENGTH']
482 self
.fp
= fp
or sys
.stdin
483 self
.headers
= headers
484 self
.outerboundary
= outerboundary
486 # Process content-disposition header
487 cdisp
, pdict
= "", {}
488 if 'content-disposition' in self
.headers
:
489 cdisp
, pdict
= parse_header(self
.headers
['content-disposition'])
490 self
.disposition
= cdisp
491 self
.disposition_options
= pdict
494 self
.name
= pdict
['name']
496 if 'filename' in pdict
:
497 self
.filename
= pdict
['filename']
499 # Process content-type header
501 # Honor any existing content-type header. But if there is no
502 # content-type header, use some sensible defaults. Assume
503 # outerboundary is "" at the outer level, but something non-false
504 # inside a multi-part. The default for an inner part is text/plain,
505 # but for an outer part it should be urlencoded. This should catch
506 # bogus clients which erroneously forget to include a content-type
509 # See below for what we do if there does exist a content-type header,
510 # but it happens to be something we don't understand.
511 if 'content-type' in self
.headers
:
512 ctype
, pdict
= parse_header(self
.headers
['content-type'])
513 elif self
.outerboundary
or method
!= 'POST':
514 ctype
, pdict
= "text/plain", {}
516 ctype
, pdict
= 'application/x-www-form-urlencoded', {}
518 self
.type_options
= pdict
519 self
.innerboundary
= ""
520 if 'boundary' in pdict
:
521 self
.innerboundary
= pdict
['boundary']
523 if 'content-length' in self
.headers
:
525 clen
= int(self
.headers
['content-length'])
528 if maxlen
and clen
> maxlen
:
529 raise ValueError, 'Maximum content length exceeded'
532 self
.list = self
.file = None
534 if ctype
== 'application/x-www-form-urlencoded':
535 self
.read_urlencoded()
536 elif ctype
[:10] == 'multipart/':
537 self
.read_multi(environ
, keep_blank_values
, strict_parsing
)
542 """Return a printable representation."""
543 return "FieldStorage(%r, %r, %r)" % (
544 self
.name
, self
.filename
, self
.value
)
547 return iter(self
.keys())
549 def __getattr__(self
, name
):
551 raise AttributeError, name
554 value
= self
.file.read()
556 elif self
.list is not None:
562 def __getitem__(self
, key
):
563 """Dictionary style indexing."""
564 if self
.list is None:
565 raise TypeError, "not indexable"
567 for item
in self
.list:
568 if item
.name
== key
: found
.append(item
)
576 def getvalue(self
, key
, default
=None):
577 """Dictionary style get() method, including 'value' lookup."""
580 if type(value
) is type([]):
581 return map(attrgetter('value'), value
)
587 def getfirst(self
, key
, default
=None):
588 """ Return the first value received."""
591 if type(value
) is type([]):
592 return value
[0].value
598 def getlist(self
, key
):
599 """ Return list of received values."""
602 if type(value
) is type([]):
603 return map(attrgetter('value'), value
)
610 """Dictionary style keys() method."""
611 if self
.list is None:
612 raise TypeError, "not indexable"
613 return list(set(item
.name
for item
in self
.list))
615 def has_key(self
, key
):
616 """Dictionary style has_key() method."""
617 if self
.list is None:
618 raise TypeError, "not indexable"
619 return any(item
.name
== key
for item
in self
.list)
621 def __contains__(self
, key
):
622 """Dictionary style __contains__ method."""
623 if self
.list is None:
624 raise TypeError, "not indexable"
625 return any(item
.name
== key
for item
in self
.list)
628 """Dictionary style len(x) support."""
629 return len(self
.keys())
631 def __nonzero__(self
):
632 return bool(self
.list)
634 def read_urlencoded(self
):
635 """Internal: read data in query string format."""
636 qs
= self
.fp
.read(self
.length
)
638 qs
+= '&' + self
.qs_on_post
639 self
.list = list = []
640 for key
, value
in parse_qsl(qs
, self
.keep_blank_values
,
641 self
.strict_parsing
):
642 list.append(MiniFieldStorage(key
, value
))
645 FieldStorageClass
= None
647 def read_multi(self
, environ
, keep_blank_values
, strict_parsing
):
648 """Internal: read a part that is itself multipart."""
649 ib
= self
.innerboundary
650 if not valid_boundary(ib
):
651 raise ValueError, 'Invalid boundary in multipart form: %r' % (ib
,)
654 for key
, value
in parse_qsl(self
.qs_on_post
, self
.keep_blank_values
,
655 self
.strict_parsing
):
656 self
.list.append(MiniFieldStorage(key
, value
))
657 FieldStorageClass
= None
659 klass
= self
.FieldStorageClass
or self
.__class
__
660 part
= klass(self
.fp
, {}, ib
,
661 environ
, keep_blank_values
, strict_parsing
)
662 # Throw first part away
664 headers
= rfc822
.Message(self
.fp
)
665 part
= klass(self
.fp
, headers
, ib
,
666 environ
, keep_blank_values
, strict_parsing
)
667 self
.list.append(part
)
670 def read_single(self
):
671 """Internal: read an atomic part."""
679 bufsize
= 8*1024 # I/O buffering size for copy to file
681 def read_binary(self
):
682 """Internal: read binary data."""
683 self
.file = self
.make_file('b')
687 data
= self
.fp
.read(min(todo
, self
.bufsize
))
691 self
.file.write(data
)
692 todo
= todo
- len(data
)
694 def read_lines(self
):
695 """Internal: read lines until EOF or outerboundary."""
696 self
.file = self
.__file
= StringIO()
697 if self
.outerboundary
:
698 self
.read_lines_to_outerboundary()
700 self
.read_lines_to_eof()
702 def __write(self
, line
):
703 if self
.__file
is not None:
704 if self
.__file
.tell() + len(line
) > 1000:
705 self
.file = self
.make_file('')
706 self
.file.write(self
.__file
.getvalue())
708 self
.file.write(line
)
710 def read_lines_to_eof(self
):
711 """Internal: read lines until EOF."""
713 line
= self
.fp
.readline(1<<16)
719 def read_lines_to_outerboundary(self
):
720 """Internal: read lines until outerboundary."""
721 next
= "--" + self
.outerboundary
724 last_line_lfend
= True
726 line
= self
.fp
.readline(1<<16)
730 if line
[:2] == "--" and last_line_lfend
:
731 strippedline
= line
.strip()
732 if strippedline
== next
:
734 if strippedline
== last
:
738 if line
[-2:] == "\r\n":
741 last_line_lfend
= True
742 elif line
[-1] == "\n":
745 last_line_lfend
= True
748 last_line_lfend
= False
749 self
.__write
(odelim
+ line
)
751 def skip_lines(self
):
752 """Internal: skip lines until outer boundary if defined."""
753 if not self
.outerboundary
or self
.done
:
755 next
= "--" + self
.outerboundary
757 last_line_lfend
= True
759 line
= self
.fp
.readline(1<<16)
763 if line
[:2] == "--" and last_line_lfend
:
764 strippedline
= line
.strip()
765 if strippedline
== next
:
767 if strippedline
== last
:
770 last_line_lfend
= line
.endswith('\n')
772 def make_file(self
, binary
=None):
773 """Overridable: return a readable & writable file.
775 The file will be used as follows:
776 - data is written to it
778 - data is read from it
780 The 'binary' argument is unused -- the file is always opened
783 This version opens a temporary file for reading and writing,
784 and immediately deletes (unlinks) it. The trick (on Unix!) is
785 that the file can still be used, but it can't be opened by
786 another process, and it will automatically be deleted when it
787 is closed or when the current process terminates.
789 If you want a more permanent file, you derive a class which
790 overrides this method. If you want a visible temporary file
791 that is nevertheless automatically deleted when the script
792 terminates, try defining a __del__ method in a derived class
793 which unlinks the temporary files you have created.
797 return tempfile
.TemporaryFile("w+b")
801 # Backwards Compatibility Classes
802 # ===============================
804 class FormContentDict(UserDict
.UserDict
):
805 """Form content as dictionary with a list of values per field.
807 form = FormContentDict()
809 form[key] -> [value, value, ...]
810 key in form -> Boolean
811 form.keys() -> [key, key, ...]
812 form.values() -> [[val, val, ...], [val, val, ...], ...]
813 form.items() -> [(key, [val, val, ...]), (key, [val, val, ...]), ...]
814 form.dict == {key: [val, val, ...], ...}
817 def __init__(self
, environ
=os
.environ
, keep_blank_values
=0, strict_parsing
=0):
818 self
.dict = self
.data
= parse(environ
=environ
,
819 keep_blank_values
=keep_blank_values
,
820 strict_parsing
=strict_parsing
)
821 self
.query_string
= environ
['QUERY_STRING']
824 class SvFormContentDict(FormContentDict
):
825 """Form content as dictionary expecting a single value per field.
827 If you only expect a single value for each field, then form[key]
828 will return that single value. It will raise an IndexError if
829 that expectation is not true. If you expect a field to have
830 possible multiple values, than you can use form.getlist(key) to
831 get all of the values. values() and items() are a compromise:
832 they return single strings where there is a single value, and
833 lists of strings otherwise.
836 def __getitem__(self
, key
):
837 if len(self
.dict[key
]) > 1:
838 raise IndexError, 'expecting a single value'
839 return self
.dict[key
][0]
840 def getlist(self
, key
):
841 return self
.dict[key
]
844 for value
in self
.dict.values():
846 result
.append(value
[0])
847 else: result
.append(value
)
851 for key
, value
in self
.dict.items():
853 result
.append((key
, value
[0]))
854 else: result
.append((key
, value
))
858 class InterpFormContentDict(SvFormContentDict
):
859 """This class is present for backwards compatibility only."""
860 def __getitem__(self
, key
):
861 v
= SvFormContentDict
.__getitem
__(self
, key
)
862 if v
[0] in '0123456789+-.':
866 except ValueError: pass
870 for key
in self
.keys():
872 result
.append(self
[key
])
874 result
.append(self
.dict[key
])
878 for key
in self
.keys():
880 result
.append((key
, self
[key
]))
882 result
.append((key
, self
.dict[key
]))
886 class FormContent(FormContentDict
):
887 """This class is present for backwards compatibility only."""
888 def values(self
, key
):
889 if key
in self
.dict :return self
.dict[key
]
891 def indexed_value(self
, key
, location
):
893 if len(self
.dict[key
]) > location
:
894 return self
.dict[key
][location
]
897 def value(self
, key
):
898 if key
in self
.dict: return self
.dict[key
][0]
900 def length(self
, key
):
901 return len(self
.dict[key
])
902 def stripped(self
, key
):
903 if key
in self
.dict: return self
.dict[key
][0].strip()
912 def test(environ
=os
.environ
):
913 """Robust test CGI script, usable as main program.
915 Write minimal HTTP headers and dump all information provided to
916 the script in HTML form.
919 print "Content-type: text/html"
921 sys
.stderr
= sys
.stdout
923 form
= FieldStorage() # Replace with other classes to test those
927 print_environ(environ
)
928 print_environ_usage()
930 exec "testing print_exception() -- <I>italics?</I>"
933 print "<H3>What follows is a test, not an actual exception:</H3>"
938 print "<H1>Second try with a small maxlen...</H1>"
943 form
= FieldStorage() # Replace with other classes to test those
947 print_environ(environ
)
951 def print_exception(type=None, value
=None, tb
=None, limit
=None):
953 type, value
, tb
= sys
.exc_info()
956 print "<H3>Traceback (most recent call last):</H3>"
957 list = traceback
.format_tb(tb
, limit
) + \
958 traceback
.format_exception_only(type, value
)
959 print "<PRE>%s<B>%s</B></PRE>" % (
960 escape("".join(list[:-1])),
965 def print_environ(environ
=os
.environ
):
966 """Dump the shell environment as HTML."""
967 keys
= environ
.keys()
970 print "<H3>Shell Environment:</H3>"
973 print "<DT>", escape(key
), "<DD>", escape(environ
[key
])
977 def print_form(form
):
978 """Dump the contents of a form as HTML."""
982 print "<H3>Form Contents:</H3>"
984 print "<P>No form fields."
987 print "<DT>" + escape(key
) + ":",
989 print "<i>" + escape(repr(type(value
))) + "</i>"
990 print "<DD>" + escape(repr(value
))
994 def print_directory():
995 """Dump the current directory as HTML."""
997 print "<H3>Current Working Directory:</H3>"
1000 except os
.error
, msg
:
1001 print "os.error:", escape(str(msg
))
1006 def print_arguments():
1008 print "<H3>Command Line Arguments:</H3>"
1013 def print_environ_usage():
1014 """Dump a list of environment variables used by CGI as HTML."""
1016 <H3>These environment variables could have been set:</H3>
1026 <LI>GATEWAY_INTERFACE
1044 In addition, HTTP headers sent by the server may be passed in the
1045 environment as well. Here are some common variable names:
1060 def escape(s
, quote
=None):
1061 '''Replace special characters "&", "<" and ">" to HTML-safe sequences.
1062 If the optional flag quote is true, the quotation mark character (")
1063 is also translated.'''
1064 s
= s
.replace("&", "&") # Must be done first!
1065 s
= s
.replace("<", "<")
1066 s
= s
.replace(">", ">")
1068 s
= s
.replace('"', """)
1071 def valid_boundary(s
, _vb_pattern
="^[ -~]{0,200}[!-~]$"):
1073 return re
.match(_vb_pattern
, s
)
1078 # Call test() when this file is run as a script (not imported as a module)
1079 if __name__
== '__main__':