This file is indexed.

/usr/share/pyshared/paste/webkit/wkcommon.py is in python-pastewebkit 1.0-7.

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 [('&', '&'),
                       ('<', '&lt;'),
                       ('>', '&gt;'),
                       ('"', '&quot;')]:
        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()