/usr/lib/python2.7/dist-packages/paste/webkit/wkcommon.py is in python-pastewebkit 1.0-8.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 | import cgi
import urllib
import warnings
import inspect
import Cookie as CookieEngine
__all__ = ['NoDefault', 'htmlEncode', 'htmlDecode',
'urlEncode', 'urlDecode',
]
try:
from MiscUtils import NoDefault
except ImportError:
class NoDefault:
pass
def htmlEncode(s):
return cgi.escape(s, 1)
def htmlDecode(s):
for char, code in [('&', '&'),
('<', '<'),
('>', '>'),
('"', '"')]:
s = s.replace(code, char)
return s
urlDecode = urllib.unquote
urlEncode = urllib.quote
def requestURI(dict):
"""
Returns the request URI for a given CGI-style dictionary. Uses
REQUEST_URI if available, otherwise constructs and returns it from
SCRIPT_NAME, PATH_INFO and QUERY_STRING.
"""
uri = dict.get('REQUEST_URI', None)
if uri is None:
uri = dict.get('SCRIPT_NAME', '') + dict.get('PATH_INFO', '')
query = dict.get('QUERY_STRING', '')
if query:
uri = uri + '?' + query
return uri
def deprecated(msg=None):
# @@: Right now this takes up a surprising amount of CPU time
# (blech! inspect is slow)
return
if not msg:
frame = inspect.stack()[1]
methodName = frame[3]
msg = 'The use of %s is deprecated' % methodName
warnings.warn(msg, DeprecationWarning, stacklevel=3)
class Cookie:
"""
Cookie is used to create cookies that have additional
attributes beyond their value.
Note that web browsers don't typically send any information
with the cookie other than it's value. Therefore
`HTTPRequest.cookie` simply returns a value such as an
integer or a string.
When the server sends cookies back to the browser, it can send
a cookie that simply has a value, or the cookie can be
accompanied by various attributes (domain, path, max-age, ...)
as described in `RFC 2109`_. Therefore, in HTTPResponse,
`setCookie` can take either an instance of the Cookie class,
as defined in this module, or a value.
Note that Cookies values get pickled (see the `pickle` module),
so you can set and get cookies that are integers, lists,
dictionaries, etc.
.. _`RFC 2109`: ftp://ftp.isi.edu/in-notes/rfc2109.txt
"""
## Future
##
## * This class should provide error checking in the setFoo()
## methods. Or maybe our internal Cookie implementation
## already does that?
## * This implementation is probably not as efficient as it
## should be, [a] it works and [b] the interface is stable.
## We can optimize later.
def __init__(self, name, value):
"""
Create a cookie -- properties other than `name` and
`value` are set with methods.
"""
self._cookies = CookieEngine.SimpleCookie()
self._name = name
self._value = value
self._cookies[name] = value
self._cookie = self._cookies[name]
"""
**Accessors**
"""
def comment(self):
return self._cookie['comment']
def domain(self):
return self._cookie['domain']
def maxAge(self):
return self._cookie['max-age']
def expires(self):
return self._cookie['expires']
def name(self):
return self._name
def path(self):
return self._cookie['path']
def isSecure(self):
return self._cookie['secure']
def value(self):
return self._value
def version(self):
return self._cookie['version']
"""
**Setters**
"""
def setComment(self, comment):
self._cookie['comment'] = comment
def setDomain(self, domain):
self._cookie['domain'] = domain
def setExpires(self, expires):
self._cookie['expires'] = expires
def setMaxAge(self, maxAge):
self._cookie['max-age'] = maxAge
def setPath(self, path):
self._cookie['path'] = path
def setSecure(self, bool):
self._cookie['secure'] = bool
def setValue(self, value):
self._value = value
self._cookies[self._name] = value
def setVersion(self, version):
self._cookie['version'] = version
"""
**Misc**
"""
def delete(self):
"""
When sent, this should delete the cookie from the user's
browser, by making it empty, expiring it in the past,
and setting its max-age to 0. One of these will delete
the cookie for any browser (which one actually works
depends on the browser).
"""
self._value = ''
self._cookie['expires'] = "Mon, 01-Jan-1900 00:00:00 GMT"
self._cookie['max-age'] = 0
self._cookie['path'] = '/'
def headerValue(self):
"""
Returns a string with the value that should be
used in the HTTP headers. """
items = self._cookies.items()
assert(len(items)==1)
return items[0][1].OutputString()
|