--- /dev/null
+#! /usr/local/bin/python\r
+\r
+# NOTE: the above "/usr/local/bin/python" is NOT a mistake. It is\r
+# intentionally NOT "/usr/bin/env python". On many systems\r
+# (e.g. Solaris), /usr/local/bin is not in $PATH as passed to CGI\r
+# scripts, and /usr/local/bin is the default directory where Python is\r
+# installed, so /usr/bin/env would be unable to find python. Granted,\r
+# binary installations by Linux vendors often install Python in\r
+# /usr/bin. So let those vendors patch cgi.py to match their choice\r
+# of installation.\r
+\r
+"""Support module for CGI (Common Gateway Interface) scripts.\r
+\r
+This module defines a number of utilities for use by CGI scripts\r
+written in Python.\r
+"""\r
+\r
+# XXX Perhaps there should be a slimmed version that doesn't contain\r
+# all those backwards compatible and debugging classes and functions?\r
+\r
+# History\r
+# -------\r
+#\r
+# Michael McLay started this module. Steve Majewski changed the\r
+# interface to SvFormContentDict and FormContentDict. The multipart\r
+# parsing was inspired by code submitted by Andreas Paepcke. Guido van\r
+# Rossum rewrote, reformatted and documented the module and is currently\r
+# responsible for its maintenance.\r
+#\r
+\r
+__version__ = "2.6"\r
+\r
+\r
+# Imports\r
+# =======\r
+\r
+from operator import attrgetter\r
+import sys\r
+import os\r
+import urllib\r
+import UserDict\r
+import urlparse\r
+\r
+from warnings import filterwarnings, catch_warnings, warn\r
+with catch_warnings():\r
+ if sys.py3kwarning:\r
+ filterwarnings("ignore", ".*mimetools has been removed",\r
+ DeprecationWarning)\r
+ filterwarnings("ignore", ".*rfc822 has been removed",\r
+ DeprecationWarning)\r
+ import mimetools\r
+ import rfc822\r
+\r
+try:\r
+ from cStringIO import StringIO\r
+except ImportError:\r
+ from StringIO import StringIO\r
+\r
+__all__ = ["MiniFieldStorage", "FieldStorage", "FormContentDict",\r
+ "SvFormContentDict", "InterpFormContentDict", "FormContent",\r
+ "parse", "parse_qs", "parse_qsl", "parse_multipart",\r
+ "parse_header", "print_exception", "print_environ",\r
+ "print_form", "print_directory", "print_arguments",\r
+ "print_environ_usage", "escape"]\r
+\r
+# Logging support\r
+# ===============\r
+\r
+logfile = "" # Filename to log to, if not empty\r
+logfp = None # File object to log to, if not None\r
+\r
+def initlog(*allargs):\r
+ """Write a log message, if there is a log file.\r
+\r
+ Even though this function is called initlog(), you should always\r
+ use log(); log is a variable that is set either to initlog\r
+ (initially), to dolog (once the log file has been opened), or to\r
+ nolog (when logging is disabled).\r
+\r
+ The first argument is a format string; the remaining arguments (if\r
+ any) are arguments to the % operator, so e.g.\r
+ log("%s: %s", "a", "b")\r
+ will write "a: b" to the log file, followed by a newline.\r
+\r
+ If the global logfp is not None, it should be a file object to\r
+ which log data is written.\r
+\r
+ If the global logfp is None, the global logfile may be a string\r
+ giving a filename to open, in append mode. This file should be\r
+ world writable!!! If the file can't be opened, logging is\r
+ silently disabled (since there is no safe place where we could\r
+ send an error message).\r
+\r
+ """\r
+ global logfp, log\r
+ if logfile and not logfp:\r
+ try:\r
+ logfp = open(logfile, "a")\r
+ except IOError:\r
+ pass\r
+ if not logfp:\r
+ log = nolog\r
+ else:\r
+ log = dolog\r
+ log(*allargs)\r
+\r
+def dolog(fmt, *args):\r
+ """Write a log message to the log file. See initlog() for docs."""\r
+ logfp.write(fmt%args + "\n")\r
+\r
+def nolog(*allargs):\r
+ """Dummy function, assigned to log when logging is disabled."""\r
+ pass\r
+\r
+log = initlog # The current logging function\r
+\r
+\r
+# Parsing functions\r
+# =================\r
+\r
+# Maximum input we will accept when REQUEST_METHOD is POST\r
+# 0 ==> unlimited input\r
+maxlen = 0\r
+\r
+def parse(fp=None, environ=os.environ, keep_blank_values=0, strict_parsing=0):\r
+ """Parse a query in the environment or from a file (default stdin)\r
+\r
+ Arguments, all optional:\r
+\r
+ fp : file pointer; default: sys.stdin\r
+\r
+ environ : environment dictionary; default: os.environ\r
+\r
+ keep_blank_values: flag indicating whether blank values in\r
+ percent-encoded forms should be treated as blank strings.\r
+ A true value indicates that blanks should be retained as\r
+ blank strings. The default false value indicates that\r
+ blank values are to be ignored and treated as if they were\r
+ not included.\r
+\r
+ strict_parsing: flag indicating what to do with parsing errors.\r
+ If false (the default), errors are silently ignored.\r
+ If true, errors raise a ValueError exception.\r
+ """\r
+ if fp is None:\r
+ fp = sys.stdin\r
+ if not 'REQUEST_METHOD' in environ:\r
+ environ['REQUEST_METHOD'] = 'GET' # For testing stand-alone\r
+ if environ['REQUEST_METHOD'] == 'POST':\r
+ ctype, pdict = parse_header(environ['CONTENT_TYPE'])\r
+ if ctype == 'multipart/form-data':\r
+ return parse_multipart(fp, pdict)\r
+ elif ctype == 'application/x-www-form-urlencoded':\r
+ clength = int(environ['CONTENT_LENGTH'])\r
+ if maxlen and clength > maxlen:\r
+ raise ValueError, 'Maximum content length exceeded'\r
+ qs = fp.read(clength)\r
+ else:\r
+ qs = '' # Unknown content-type\r
+ if 'QUERY_STRING' in environ:\r
+ if qs: qs = qs + '&'\r
+ qs = qs + environ['QUERY_STRING']\r
+ elif sys.argv[1:]:\r
+ if qs: qs = qs + '&'\r
+ qs = qs + sys.argv[1]\r
+ environ['QUERY_STRING'] = qs # XXX Shouldn't, really\r
+ elif 'QUERY_STRING' in environ:\r
+ qs = environ['QUERY_STRING']\r
+ else:\r
+ if sys.argv[1:]:\r
+ qs = sys.argv[1]\r
+ else:\r
+ qs = ""\r
+ environ['QUERY_STRING'] = qs # XXX Shouldn't, really\r
+ return urlparse.parse_qs(qs, keep_blank_values, strict_parsing)\r
+\r
+\r
+# parse query string function called from urlparse,\r
+# this is done in order to maintain backward compatiblity.\r
+\r
+def parse_qs(qs, keep_blank_values=0, strict_parsing=0):\r
+ """Parse a query given as a string argument."""\r
+ warn("cgi.parse_qs is deprecated, use urlparse.parse_qs instead",\r
+ PendingDeprecationWarning, 2)\r
+ return urlparse.parse_qs(qs, keep_blank_values, strict_parsing)\r
+\r
+\r
+def parse_qsl(qs, keep_blank_values=0, strict_parsing=0):\r
+ """Parse a query given as a string argument."""\r
+ warn("cgi.parse_qsl is deprecated, use urlparse.parse_qsl instead",\r
+ PendingDeprecationWarning, 2)\r
+ return urlparse.parse_qsl(qs, keep_blank_values, strict_parsing)\r
+\r
+def parse_multipart(fp, pdict):\r
+ """Parse multipart input.\r
+\r
+ Arguments:\r
+ fp : input file\r
+ pdict: dictionary containing other parameters of content-type header\r
+\r
+ Returns a dictionary just like parse_qs(): keys are the field names, each\r
+ value is a list of values for that field. This is easy to use but not\r
+ much good if you are expecting megabytes to be uploaded -- in that case,\r
+ use the FieldStorage class instead which is much more flexible. Note\r
+ that content-type is the raw, unparsed contents of the content-type\r
+ header.\r
+\r
+ XXX This does not parse nested multipart parts -- use FieldStorage for\r
+ that.\r
+\r
+ XXX This should really be subsumed by FieldStorage altogether -- no\r
+ point in having two implementations of the same parsing algorithm.\r
+ Also, FieldStorage protects itself better against certain DoS attacks\r
+ by limiting the size of the data read in one chunk. The API here\r
+ does not support that kind of protection. This also affects parse()\r
+ since it can call parse_multipart().\r
+\r
+ """\r
+ boundary = ""\r
+ if 'boundary' in pdict:\r
+ boundary = pdict['boundary']\r
+ if not valid_boundary(boundary):\r
+ raise ValueError, ('Invalid boundary in multipart form: %r'\r
+ % (boundary,))\r
+\r
+ nextpart = "--" + boundary\r
+ lastpart = "--" + boundary + "--"\r
+ partdict = {}\r
+ terminator = ""\r
+\r
+ while terminator != lastpart:\r
+ bytes = -1\r
+ data = None\r
+ if terminator:\r
+ # At start of next part. Read headers first.\r
+ headers = mimetools.Message(fp)\r
+ clength = headers.getheader('content-length')\r
+ if clength:\r
+ try:\r
+ bytes = int(clength)\r
+ except ValueError:\r
+ pass\r
+ if bytes > 0:\r
+ if maxlen and bytes > maxlen:\r
+ raise ValueError, 'Maximum content length exceeded'\r
+ data = fp.read(bytes)\r
+ else:\r
+ data = ""\r
+ # Read lines until end of part.\r
+ lines = []\r
+ while 1:\r
+ line = fp.readline()\r
+ if not line:\r
+ terminator = lastpart # End outer loop\r
+ break\r
+ if line[:2] == "--":\r
+ terminator = line.strip()\r
+ if terminator in (nextpart, lastpart):\r
+ break\r
+ lines.append(line)\r
+ # Done with part.\r
+ if data is None:\r
+ continue\r
+ if bytes < 0:\r
+ if lines:\r
+ # Strip final line terminator\r
+ line = lines[-1]\r
+ if line[-2:] == "\r\n":\r
+ line = line[:-2]\r
+ elif line[-1:] == "\n":\r
+ line = line[:-1]\r
+ lines[-1] = line\r
+ data = "".join(lines)\r
+ line = headers['content-disposition']\r
+ if not line:\r
+ continue\r
+ key, params = parse_header(line)\r
+ if key != 'form-data':\r
+ continue\r
+ if 'name' in params:\r
+ name = params['name']\r
+ else:\r
+ continue\r
+ if name in partdict:\r
+ partdict[name].append(data)\r
+ else:\r
+ partdict[name] = [data]\r
+\r
+ return partdict\r
+\r
+\r
+def _parseparam(s):\r
+ while s[:1] == ';':\r
+ s = s[1:]\r
+ end = s.find(';')\r
+ while end > 0 and s.count('"', 0, end) % 2:\r
+ end = s.find(';', end + 1)\r
+ if end < 0:\r
+ end = len(s)\r
+ f = s[:end]\r
+ yield f.strip()\r
+ s = s[end:]\r
+\r
+def parse_header(line):\r
+ """Parse a Content-type like header.\r
+\r
+ Return the main content-type and a dictionary of options.\r
+\r
+ """\r
+ parts = _parseparam(';' + line)\r
+ key = parts.next()\r
+ pdict = {}\r
+ for p in parts:\r
+ i = p.find('=')\r
+ if i >= 0:\r
+ name = p[:i].strip().lower()\r
+ value = p[i+1:].strip()\r
+ if len(value) >= 2 and value[0] == value[-1] == '"':\r
+ value = value[1:-1]\r
+ value = value.replace('\\\\', '\\').replace('\\"', '"')\r
+ pdict[name] = value\r
+ return key, pdict\r
+\r
+\r
+# Classes for field storage\r
+# =========================\r
+\r
+class MiniFieldStorage:\r
+\r
+ """Like FieldStorage, for use when no file uploads are possible."""\r
+\r
+ # Dummy attributes\r
+ filename = None\r
+ list = None\r
+ type = None\r
+ file = None\r
+ type_options = {}\r
+ disposition = None\r
+ disposition_options = {}\r
+ headers = {}\r
+\r
+ def __init__(self, name, value):\r
+ """Constructor from field name and value."""\r
+ self.name = name\r
+ self.value = value\r
+ # self.file = StringIO(value)\r
+\r
+ def __repr__(self):\r
+ """Return printable representation."""\r
+ return "MiniFieldStorage(%r, %r)" % (self.name, self.value)\r
+\r
+\r
+class FieldStorage:\r
+\r
+ """Store a sequence of fields, reading multipart/form-data.\r
+\r
+ This class provides naming, typing, files stored on disk, and\r
+ more. At the top level, it is accessible like a dictionary, whose\r
+ keys are the field names. (Note: None can occur as a field name.)\r
+ The items are either a Python list (if there's multiple values) or\r
+ another FieldStorage or MiniFieldStorage object. If it's a single\r
+ object, it has the following attributes:\r
+\r
+ name: the field name, if specified; otherwise None\r
+\r
+ filename: the filename, if specified; otherwise None; this is the\r
+ client side filename, *not* the file name on which it is\r
+ stored (that's a temporary file you don't deal with)\r
+\r
+ value: the value as a *string*; for file uploads, this\r
+ transparently reads the file every time you request the value\r
+\r
+ file: the file(-like) object from which you can read the data;\r
+ None if the data is stored a simple string\r
+\r
+ type: the content-type, or None if not specified\r
+\r
+ type_options: dictionary of options specified on the content-type\r
+ line\r
+\r
+ disposition: content-disposition, or None if not specified\r
+\r
+ disposition_options: dictionary of corresponding options\r
+\r
+ headers: a dictionary(-like) object (sometimes rfc822.Message or a\r
+ subclass thereof) containing *all* headers\r
+\r
+ The class is subclassable, mostly for the purpose of overriding\r
+ the make_file() method, which is called internally to come up with\r
+ a file open for reading and writing. This makes it possible to\r
+ override the default choice of storing all files in a temporary\r
+ directory and unlinking them as soon as they have been opened.\r
+\r
+ """\r
+\r
+ def __init__(self, fp=None, headers=None, outerboundary="",\r
+ environ=os.environ, keep_blank_values=0, strict_parsing=0):\r
+ """Constructor. Read multipart/* until last part.\r
+\r
+ Arguments, all optional:\r
+\r
+ fp : file pointer; default: sys.stdin\r
+ (not used when the request method is GET)\r
+\r
+ headers : header dictionary-like object; default:\r
+ taken from environ as per CGI spec\r
+\r
+ outerboundary : terminating multipart boundary\r
+ (for internal use only)\r
+\r
+ environ : environment dictionary; default: os.environ\r
+\r
+ keep_blank_values: flag indicating whether blank values in\r
+ percent-encoded forms should be treated as blank strings.\r
+ A true value indicates that blanks should be retained as\r
+ blank strings. The default false value indicates that\r
+ blank values are to be ignored and treated as if they were\r
+ not included.\r
+\r
+ strict_parsing: flag indicating what to do with parsing errors.\r
+ If false (the default), errors are silently ignored.\r
+ If true, errors raise a ValueError exception.\r
+\r
+ """\r
+ method = 'GET'\r
+ self.keep_blank_values = keep_blank_values\r
+ self.strict_parsing = strict_parsing\r
+ if 'REQUEST_METHOD' in environ:\r
+ method = environ['REQUEST_METHOD'].upper()\r
+ self.qs_on_post = None\r
+ if method == 'GET' or method == 'HEAD':\r
+ if 'QUERY_STRING' in environ:\r
+ qs = environ['QUERY_STRING']\r
+ elif sys.argv[1:]:\r
+ qs = sys.argv[1]\r
+ else:\r
+ qs = ""\r
+ fp = StringIO(qs)\r
+ if headers is None:\r
+ headers = {'content-type':\r
+ "application/x-www-form-urlencoded"}\r
+ if headers is None:\r
+ headers = {}\r
+ if method == 'POST':\r
+ # Set default content-type for POST to what's traditional\r
+ headers['content-type'] = "application/x-www-form-urlencoded"\r
+ if 'CONTENT_TYPE' in environ:\r
+ headers['content-type'] = environ['CONTENT_TYPE']\r
+ if 'QUERY_STRING' in environ:\r
+ self.qs_on_post = environ['QUERY_STRING']\r
+ if 'CONTENT_LENGTH' in environ:\r
+ headers['content-length'] = environ['CONTENT_LENGTH']\r
+ self.fp = fp or sys.stdin\r
+ self.headers = headers\r
+ self.outerboundary = outerboundary\r
+\r
+ # Process content-disposition header\r
+ cdisp, pdict = "", {}\r
+ if 'content-disposition' in self.headers:\r
+ cdisp, pdict = parse_header(self.headers['content-disposition'])\r
+ self.disposition = cdisp\r
+ self.disposition_options = pdict\r
+ self.name = None\r
+ if 'name' in pdict:\r
+ self.name = pdict['name']\r
+ self.filename = None\r
+ if 'filename' in pdict:\r
+ self.filename = pdict['filename']\r
+\r
+ # Process content-type header\r
+ #\r
+ # Honor any existing content-type header. But if there is no\r
+ # content-type header, use some sensible defaults. Assume\r
+ # outerboundary is "" at the outer level, but something non-false\r
+ # inside a multi-part. The default for an inner part is text/plain,\r
+ # but for an outer part it should be urlencoded. This should catch\r
+ # bogus clients which erroneously forget to include a content-type\r
+ # header.\r
+ #\r
+ # See below for what we do if there does exist a content-type header,\r
+ # but it happens to be something we don't understand.\r
+ if 'content-type' in self.headers:\r
+ ctype, pdict = parse_header(self.headers['content-type'])\r
+ elif self.outerboundary or method != 'POST':\r
+ ctype, pdict = "text/plain", {}\r
+ else:\r
+ ctype, pdict = 'application/x-www-form-urlencoded', {}\r
+ self.type = ctype\r
+ self.type_options = pdict\r
+ self.innerboundary = ""\r
+ if 'boundary' in pdict:\r
+ self.innerboundary = pdict['boundary']\r
+ clen = -1\r
+ if 'content-length' in self.headers:\r
+ try:\r
+ clen = int(self.headers['content-length'])\r
+ except ValueError:\r
+ pass\r
+ if maxlen and clen > maxlen:\r
+ raise ValueError, 'Maximum content length exceeded'\r
+ self.length = clen\r
+\r
+ self.list = self.file = None\r
+ self.done = 0\r
+ if ctype == 'application/x-www-form-urlencoded':\r
+ self.read_urlencoded()\r
+ elif ctype[:10] == 'multipart/':\r
+ self.read_multi(environ, keep_blank_values, strict_parsing)\r
+ else:\r
+ self.read_single()\r
+\r
+ def __repr__(self):\r
+ """Return a printable representation."""\r
+ return "FieldStorage(%r, %r, %r)" % (\r
+ self.name, self.filename, self.value)\r
+\r
+ def __iter__(self):\r
+ return iter(self.keys())\r
+\r
+ def __getattr__(self, name):\r
+ if name != 'value':\r
+ raise AttributeError, name\r
+ if self.file:\r
+ self.file.seek(0)\r
+ value = self.file.read()\r
+ self.file.seek(0)\r
+ elif self.list is not None:\r
+ value = self.list\r
+ else:\r
+ value = None\r
+ return value\r
+\r
+ def __getitem__(self, key):\r
+ """Dictionary style indexing."""\r
+ if self.list is None:\r
+ raise TypeError, "not indexable"\r
+ found = []\r
+ for item in self.list:\r
+ if item.name == key: found.append(item)\r
+ if not found:\r
+ raise KeyError, key\r
+ if len(found) == 1:\r
+ return found[0]\r
+ else:\r
+ return found\r
+\r
+ def getvalue(self, key, default=None):\r
+ """Dictionary style get() method, including 'value' lookup."""\r
+ if key in self:\r
+ value = self[key]\r
+ if type(value) is type([]):\r
+ return map(attrgetter('value'), value)\r
+ else:\r
+ return value.value\r
+ else:\r
+ return default\r
+\r
+ def getfirst(self, key, default=None):\r
+ """ Return the first value received."""\r
+ if key in self:\r
+ value = self[key]\r
+ if type(value) is type([]):\r
+ return value[0].value\r
+ else:\r
+ return value.value\r
+ else:\r
+ return default\r
+\r
+ def getlist(self, key):\r
+ """ Return list of received values."""\r
+ if key in self:\r
+ value = self[key]\r
+ if type(value) is type([]):\r
+ return map(attrgetter('value'), value)\r
+ else:\r
+ return [value.value]\r
+ else:\r
+ return []\r
+\r
+ def keys(self):\r
+ """Dictionary style keys() method."""\r
+ if self.list is None:\r
+ raise TypeError, "not indexable"\r
+ return list(set(item.name for item in self.list))\r
+\r
+ def has_key(self, key):\r
+ """Dictionary style has_key() method."""\r
+ if self.list is None:\r
+ raise TypeError, "not indexable"\r
+ return any(item.name == key for item in self.list)\r
+\r
+ def __contains__(self, key):\r
+ """Dictionary style __contains__ method."""\r
+ if self.list is None:\r
+ raise TypeError, "not indexable"\r
+ return any(item.name == key for item in self.list)\r
+\r
+ def __len__(self):\r
+ """Dictionary style len(x) support."""\r
+ return len(self.keys())\r
+\r
+ def __nonzero__(self):\r
+ return bool(self.list)\r
+\r
+ def read_urlencoded(self):\r
+ """Internal: read data in query string format."""\r
+ qs = self.fp.read(self.length)\r
+ if self.qs_on_post:\r
+ qs += '&' + self.qs_on_post\r
+ self.list = list = []\r
+ for key, value in urlparse.parse_qsl(qs, self.keep_blank_values,\r
+ self.strict_parsing):\r
+ list.append(MiniFieldStorage(key, value))\r
+ self.skip_lines()\r
+\r
+ FieldStorageClass = None\r
+\r
+ def read_multi(self, environ, keep_blank_values, strict_parsing):\r
+ """Internal: read a part that is itself multipart."""\r
+ ib = self.innerboundary\r
+ if not valid_boundary(ib):\r
+ raise ValueError, 'Invalid boundary in multipart form: %r' % (ib,)\r
+ self.list = []\r
+ if self.qs_on_post:\r
+ for key, value in urlparse.parse_qsl(self.qs_on_post,\r
+ self.keep_blank_values, self.strict_parsing):\r
+ self.list.append(MiniFieldStorage(key, value))\r
+ FieldStorageClass = None\r
+\r
+ klass = self.FieldStorageClass or self.__class__\r
+ part = klass(self.fp, {}, ib,\r
+ environ, keep_blank_values, strict_parsing)\r
+ # Throw first part away\r
+ while not part.done:\r
+ headers = rfc822.Message(self.fp)\r
+ part = klass(self.fp, headers, ib,\r
+ environ, keep_blank_values, strict_parsing)\r
+ self.list.append(part)\r
+ self.skip_lines()\r
+\r
+ def read_single(self):\r
+ """Internal: read an atomic part."""\r
+ if self.length >= 0:\r
+ self.read_binary()\r
+ self.skip_lines()\r
+ else:\r
+ self.read_lines()\r
+ self.file.seek(0)\r
+\r
+ bufsize = 8*1024 # I/O buffering size for copy to file\r
+\r
+ def read_binary(self):\r
+ """Internal: read binary data."""\r
+ self.file = self.make_file('b')\r
+ todo = self.length\r
+ if todo >= 0:\r
+ while todo > 0:\r
+ data = self.fp.read(min(todo, self.bufsize))\r
+ if not data:\r
+ self.done = -1\r
+ break\r
+ self.file.write(data)\r
+ todo = todo - len(data)\r
+\r
+ def read_lines(self):\r
+ """Internal: read lines until EOF or outerboundary."""\r
+ self.file = self.__file = StringIO()\r
+ if self.outerboundary:\r
+ self.read_lines_to_outerboundary()\r
+ else:\r
+ self.read_lines_to_eof()\r
+\r
+ def __write(self, line):\r
+ if self.__file is not None:\r
+ if self.__file.tell() + len(line) > 1000:\r
+ self.file = self.make_file('')\r
+ self.file.write(self.__file.getvalue())\r
+ self.__file = None\r
+ self.file.write(line)\r
+\r
+ def read_lines_to_eof(self):\r
+ """Internal: read lines until EOF."""\r
+ while 1:\r
+ line = self.fp.readline(1<<16)\r
+ if not line:\r
+ self.done = -1\r
+ break\r
+ self.__write(line)\r
+\r
+ def read_lines_to_outerboundary(self):\r
+ """Internal: read lines until outerboundary."""\r
+ next = "--" + self.outerboundary\r
+ last = next + "--"\r
+ delim = ""\r
+ last_line_lfend = True\r
+ while 1:\r
+ line = self.fp.readline(1<<16)\r
+ if not line:\r
+ self.done = -1\r
+ break\r
+ if line[:2] == "--" and last_line_lfend:\r
+ strippedline = line.strip()\r
+ if strippedline == next:\r
+ break\r
+ if strippedline == last:\r
+ self.done = 1\r
+ break\r
+ odelim = delim\r
+ if line[-2:] == "\r\n":\r
+ delim = "\r\n"\r
+ line = line[:-2]\r
+ last_line_lfend = True\r
+ elif line[-1] == "\n":\r
+ delim = "\n"\r
+ line = line[:-1]\r
+ last_line_lfend = True\r
+ else:\r
+ delim = ""\r
+ last_line_lfend = False\r
+ self.__write(odelim + line)\r
+\r
+ def skip_lines(self):\r
+ """Internal: skip lines until outer boundary if defined."""\r
+ if not self.outerboundary or self.done:\r
+ return\r
+ next = "--" + self.outerboundary\r
+ last = next + "--"\r
+ last_line_lfend = True\r
+ while 1:\r
+ line = self.fp.readline(1<<16)\r
+ if not line:\r
+ self.done = -1\r
+ break\r
+ if line[:2] == "--" and last_line_lfend:\r
+ strippedline = line.strip()\r
+ if strippedline == next:\r
+ break\r
+ if strippedline == last:\r
+ self.done = 1\r
+ break\r
+ last_line_lfend = line.endswith('\n')\r
+\r
+ def make_file(self, binary=None):\r
+ """Overridable: return a readable & writable file.\r
+\r
+ The file will be used as follows:\r
+ - data is written to it\r
+ - seek(0)\r
+ - data is read from it\r
+\r
+ The 'binary' argument is unused -- the file is always opened\r
+ in binary mode.\r
+\r
+ This version opens a temporary file for reading and writing,\r
+ and immediately deletes (unlinks) it. The trick (on Unix!) is\r
+ that the file can still be used, but it can't be opened by\r
+ another process, and it will automatically be deleted when it\r
+ is closed or when the current process terminates.\r
+\r
+ If you want a more permanent file, you derive a class which\r
+ overrides this method. If you want a visible temporary file\r
+ that is nevertheless automatically deleted when the script\r
+ terminates, try defining a __del__ method in a derived class\r
+ which unlinks the temporary files you have created.\r
+\r
+ """\r
+ import tempfile\r
+ return tempfile.TemporaryFile("w+b")\r
+\r
+\r
+\r
+# Backwards Compatibility Classes\r
+# ===============================\r
+\r
+class FormContentDict(UserDict.UserDict):\r
+ """Form content as dictionary with a list of values per field.\r
+\r
+ form = FormContentDict()\r
+\r
+ form[key] -> [value, value, ...]\r
+ key in form -> Boolean\r
+ form.keys() -> [key, key, ...]\r
+ form.values() -> [[val, val, ...], [val, val, ...], ...]\r
+ form.items() -> [(key, [val, val, ...]), (key, [val, val, ...]), ...]\r
+ form.dict == {key: [val, val, ...], ...}\r
+\r
+ """\r
+ def __init__(self, environ=os.environ, keep_blank_values=0, strict_parsing=0):\r
+ self.dict = self.data = parse(environ=environ,\r
+ keep_blank_values=keep_blank_values,\r
+ strict_parsing=strict_parsing)\r
+ self.query_string = environ['QUERY_STRING']\r
+\r
+\r
+class SvFormContentDict(FormContentDict):\r
+ """Form content as dictionary expecting a single value per field.\r
+\r
+ If you only expect a single value for each field, then form[key]\r
+ will return that single value. It will raise an IndexError if\r
+ that expectation is not true. If you expect a field to have\r
+ possible multiple values, than you can use form.getlist(key) to\r
+ get all of the values. values() and items() are a compromise:\r
+ they return single strings where there is a single value, and\r
+ lists of strings otherwise.\r
+\r
+ """\r
+ def __getitem__(self, key):\r
+ if len(self.dict[key]) > 1:\r
+ raise IndexError, 'expecting a single value'\r
+ return self.dict[key][0]\r
+ def getlist(self, key):\r
+ return self.dict[key]\r
+ def values(self):\r
+ result = []\r
+ for value in self.dict.values():\r
+ if len(value) == 1:\r
+ result.append(value[0])\r
+ else: result.append(value)\r
+ return result\r
+ def items(self):\r
+ result = []\r
+ for key, value in self.dict.items():\r
+ if len(value) == 1:\r
+ result.append((key, value[0]))\r
+ else: result.append((key, value))\r
+ return result\r
+\r
+\r
+class InterpFormContentDict(SvFormContentDict):\r
+ """This class is present for backwards compatibility only."""\r
+ def __getitem__(self, key):\r
+ v = SvFormContentDict.__getitem__(self, key)\r
+ if v[0] in '0123456789+-.':\r
+ try: return int(v)\r
+ except ValueError:\r
+ try: return float(v)\r
+ except ValueError: pass\r
+ return v.strip()\r
+ def values(self):\r
+ result = []\r
+ for key in self.keys():\r
+ try:\r
+ result.append(self[key])\r
+ except IndexError:\r
+ result.append(self.dict[key])\r
+ return result\r
+ def items(self):\r
+ result = []\r
+ for key in self.keys():\r
+ try:\r
+ result.append((key, self[key]))\r
+ except IndexError:\r
+ result.append((key, self.dict[key]))\r
+ return result\r
+\r
+\r
+class FormContent(FormContentDict):\r
+ """This class is present for backwards compatibility only."""\r
+ def values(self, key):\r
+ if key in self.dict :return self.dict[key]\r
+ else: return None\r
+ def indexed_value(self, key, location):\r
+ if key in self.dict:\r
+ if len(self.dict[key]) > location:\r
+ return self.dict[key][location]\r
+ else: return None\r
+ else: return None\r
+ def value(self, key):\r
+ if key in self.dict: return self.dict[key][0]\r
+ else: return None\r
+ def length(self, key):\r
+ return len(self.dict[key])\r
+ def stripped(self, key):\r
+ if key in self.dict: return self.dict[key][0].strip()\r
+ else: return None\r
+ def pars(self):\r
+ return self.dict\r
+\r
+\r
+# Test/debug code\r
+# ===============\r
+\r
+def test(environ=os.environ):\r
+ """Robust test CGI script, usable as main program.\r
+\r
+ Write minimal HTTP headers and dump all information provided to\r
+ the script in HTML form.\r
+\r
+ """\r
+ print "Content-type: text/html"\r
+ print\r
+ sys.stderr = sys.stdout\r
+ try:\r
+ form = FieldStorage() # Replace with other classes to test those\r
+ print_directory()\r
+ print_arguments()\r
+ print_form(form)\r
+ print_environ(environ)\r
+ print_environ_usage()\r
+ def f():\r
+ exec "testing print_exception() -- <I>italics?</I>"\r
+ def g(f=f):\r
+ f()\r
+ print "<H3>What follows is a test, not an actual exception:</H3>"\r
+ g()\r
+ except:\r
+ print_exception()\r
+\r
+ print "<H1>Second try with a small maxlen...</H1>"\r
+\r
+ global maxlen\r
+ maxlen = 50\r
+ try:\r
+ form = FieldStorage() # Replace with other classes to test those\r
+ print_directory()\r
+ print_arguments()\r
+ print_form(form)\r
+ print_environ(environ)\r
+ except:\r
+ print_exception()\r
+\r
+def print_exception(type=None, value=None, tb=None, limit=None):\r
+ if type is None:\r
+ type, value, tb = sys.exc_info()\r
+ import traceback\r
+ print\r
+ print "<H3>Traceback (most recent call last):</H3>"\r
+ list = traceback.format_tb(tb, limit) + \\r
+ traceback.format_exception_only(type, value)\r
+ print "<PRE>%s<B>%s</B></PRE>" % (\r
+ escape("".join(list[:-1])),\r
+ escape(list[-1]),\r
+ )\r
+ del tb\r
+\r
+def print_environ(environ=os.environ):\r
+ """Dump the shell environment as HTML."""\r
+ keys = environ.keys()\r
+ keys.sort()\r
+ print\r
+ print "<H3>Shell Environment:</H3>"\r
+ print "<DL>"\r
+ for key in keys:\r
+ print "<DT>", escape(key), "<DD>", escape(environ[key])\r
+ print "</DL>"\r
+ print\r
+\r
+def print_form(form):\r
+ """Dump the contents of a form as HTML."""\r
+ keys = form.keys()\r
+ keys.sort()\r
+ print\r
+ print "<H3>Form Contents:</H3>"\r
+ if not keys:\r
+ print "<P>No form fields."\r
+ print "<DL>"\r
+ for key in keys:\r
+ print "<DT>" + escape(key) + ":",\r
+ value = form[key]\r
+ print "<i>" + escape(repr(type(value))) + "</i>"\r
+ print "<DD>" + escape(repr(value))\r
+ print "</DL>"\r
+ print\r
+\r
+def print_directory():\r
+ """Dump the current directory as HTML."""\r
+ print\r
+ print "<H3>Current Working Directory:</H3>"\r
+ try:\r
+ pwd = os.getcwd()\r
+ except os.error, msg:\r
+ print "os.error:", escape(str(msg))\r
+ else:\r
+ print escape(pwd)\r
+ print\r
+\r
+def print_arguments():\r
+ print\r
+ print "<H3>Command Line Arguments:</H3>"\r
+ print\r
+ print sys.argv\r
+ print\r
+\r
+def print_environ_usage():\r
+ """Dump a list of environment variables used by CGI as HTML."""\r
+ print """\r
+<H3>These environment variables could have been set:</H3>\r
+<UL>\r
+<LI>AUTH_TYPE\r
+<LI>CONTENT_LENGTH\r
+<LI>CONTENT_TYPE\r
+<LI>DATE_GMT\r
+<LI>DATE_LOCAL\r
+<LI>DOCUMENT_NAME\r
+<LI>DOCUMENT_ROOT\r
+<LI>DOCUMENT_URI\r
+<LI>GATEWAY_INTERFACE\r
+<LI>LAST_MODIFIED\r
+<LI>PATH\r
+<LI>PATH_INFO\r
+<LI>PATH_TRANSLATED\r
+<LI>QUERY_STRING\r
+<LI>REMOTE_ADDR\r
+<LI>REMOTE_HOST\r
+<LI>REMOTE_IDENT\r
+<LI>REMOTE_USER\r
+<LI>REQUEST_METHOD\r
+<LI>SCRIPT_NAME\r
+<LI>SERVER_NAME\r
+<LI>SERVER_PORT\r
+<LI>SERVER_PROTOCOL\r
+<LI>SERVER_ROOT\r
+<LI>SERVER_SOFTWARE\r
+</UL>\r
+In addition, HTTP headers sent by the server may be passed in the\r
+environment as well. Here are some common variable names:\r
+<UL>\r
+<LI>HTTP_ACCEPT\r
+<LI>HTTP_CONNECTION\r
+<LI>HTTP_HOST\r
+<LI>HTTP_PRAGMA\r
+<LI>HTTP_REFERER\r
+<LI>HTTP_USER_AGENT\r
+</UL>\r
+"""\r
+\r
+\r
+# Utilities\r
+# =========\r
+\r
+def escape(s, quote=None):\r
+ '''Replace special characters "&", "<" and ">" to HTML-safe sequences.\r
+ If the optional flag quote is true, the quotation mark character (")\r
+ is also translated.'''\r
+ s = s.replace("&", "&") # Must be done first!\r
+ s = s.replace("<", "<")\r
+ s = s.replace(">", ">")\r
+ if quote:\r
+ s = s.replace('"', """)\r
+ return s\r
+\r
+def valid_boundary(s, _vb_pattern="^[ -~]{0,200}[!-~]$"):\r
+ import re\r
+ return re.match(_vb_pattern, s)\r
+\r
+# Invoke mainline\r
+# ===============\r
+\r
+# Call test() when this file is run as a script (not imported as a module)\r
+if __name__ == '__main__':\r
+ test()\r
projects / mirror_edk2.git / blobdiff