summaryrefslogtreecommitdiff
path: root/misc/Cookie.py
diff options
context:
space:
mode:
Diffstat (limited to 'misc/Cookie.py')
-rw-r--r--misc/Cookie.py553
1 files changed, 553 insertions, 0 deletions
diff --git a/misc/Cookie.py b/misc/Cookie.py
new file mode 100644
index 000000000..d6e74cb6c
--- /dev/null
+++ b/misc/Cookie.py
@@ -0,0 +1,553 @@
+#!/usr/bin/env python
+
+"""
+# Id: Cookie.py,v 2.4 1998/02/13 16:42:30 timo Exp
+# by Timothy O'Malley <timo@bbn.com> Date: 1998/02/13 16:42:30
+#
+# Cookie.py is an update for the old nscookie.py module.
+# Under the old module, it was not possible to set attributes,
+# such as "secure" or "Max-Age" on key,value granularity. This
+# shortcoming has been addressed in Cookie.py but has come at
+# the cost of a slightly changed interface. Cookie.py also
+# requires Python-1.5, for the re and cPickle modules.
+#
+# The original idea to treat Cookies as a dictionary came from
+# Dave Mitchel (davem@magnet.com) in 1995, when he released the
+# first version of nscookie.py.
+
+Here's a sample session to show how to use this module.
+At the moment, this is the only documentation.
+
+Importing is easy..
+
+ >>> import Cookie
+
+Most of the time you start by creating a cookie. The __init__
+routine can take several arguments, but that isn't covered here.
+
+ >>> C = Cookie.Cookie()
+
+Now, you can add values to the Cookie just as is if it were a
+dictionary.
+
+ >>> C["joe"] = "a cookie"
+ >>> C
+ Set-Cookie: joe="a cookie";
+
+Notice that the printable representation of a Cookie is the
+appropriate format for a Set-Cookie: header. This is the
+default behavior. You can change the header by using the
+the .output() function
+
+ >>> C.output("Cookie:")
+ 'Cookie: joe="a cookie";'
+
+
+The .load() method of a Cookie extracts cookies from a string. In
+a CGI script, you would use this method to extract the cookies
+from the HTTP_COOKIE environment variable.
+
+ >>> C.load("mary=hadalittlelamb;")
+ >>> C
+ Set-Cookie: mary=hadalittlelamb;
+ Set-Cookie: joe="a cookie";
+
+Each element of the Cookie also supports all of the RFC 2109
+Cookie attributes. Here's an example which sets the Path
+attribute.
+
+ >>> C["joe"]["path"] = "/home/joe"
+ >>> C
+ Set-Cookie: mary=hadalittlelamb;
+ Set-Cookie: joe="a cookie"; Path=/home/joe;
+
+Before I forget, the .load() method is pretty smart about
+identifying a cookie. Escaped quotation marks and nested
+semicolons do not confuse it.
+
+ >>> C.load('lobotomy="joe=wolf; lobotomy=\\"nested quote\\"; mark=\\012;";')
+ >>> C
+ Set-Cookie: mary=hadalittlelamb;
+ Set-Cookie: joe="a cookie"; Path=/home/joe;
+ Set-Cookie: lobotomy="joe=wolf; lobotomy=\"nested quote\"; mark=\012;";
+
+
+Each dictionary element has a 'value' attribute, which gives you
+back the value associated with the key.
+
+ >>> C["joe"].value
+ 'a cookie'
+ >>> C["lobotomy"].value
+ 'joe=wolf; lobotomy="nested quote"; mark=\012;'
+
+If you set a cookie to a non-string object, that object is
+automatically pickled (using cPickle or pickle) in the
+Set-Cookie: header.
+
+ >>> C["int"] = 7
+ >>> C
+ Set-Cookie: lobotomy="joe=wolf; lobotomy=\"nested quote\"; mark=\012;";
+ Set-Cookie: joe="a cookie"; Path=/home/joe;
+ Set-Cookie: mary=hadalittlelamb;
+ Set-Cookie: int="I7\012.";
+
+If the .load() method finds a pickled object in the string, then
+it automatically unpickles it. The 'value' attribute gives you back
+the true value, not the encoded representation.
+
+
+ >>> C.load('anotherint="I45\\012.";')
+
+ >>> C["anotherint"].value
+ 45
+ >>> C["int"].value
+ 7
+
+ >>> C
+ Set-Cookie: lobotomy="joe=wolf; lobotomy=\"nested quote\"; mark=\012;";
+ Set-Cookie: joe="a cookie"; Path=/home/joe;
+ Set-Cookie: mary=hadalittlelamb;
+ Set-Cookie: anotherint="I45\012.";
+ Set-Cookie: int="I7\012.";
+
+Finally, the encoding/decoding behavior is controllable by
+two attributes of the Cookie:
+
+ net_setfunc() Takes in an encoded string and returns a value
+ user_setfunc() Takes in a value and returns the encoded string
+
+By default, these functions are defined in the Cookie module, but
+you should feel free to override them.
+
+ >>> C.net_setfunc
+ <function _debabelize at c1558>
+ >>> C.user_setfunc
+ <function _babelize at c1530>
+
+Finis.
+"""
+
+__version__ = "$Revision: 424 $"
+
+#
+# Import our required modules
+#
+import string, sys
+from UserDict import UserDict
+try:
+ from cPickle import dumps, loads
+except ImportError:
+ from pickle import dumps, loads
+try:
+ import re
+except ImportError:
+ raise ImportError, "Cookie.py requires 're' from Python 1.5 or later"
+
+#
+# Define an exception visible to External modules
+#
+class CookieError(Exception):
+ pass
+
+
+# These quoting routines conform to the RFC2109 specification, which in
+# turn references the character definitions from RFC2068. They provide
+# a two-way quoting algorithm. Any non-text character is translated
+# into a 4 character sequence: a forward-slash followed by the
+# three-digit octal equivalent of the character. Any '\' or '"' is
+# quoted with a preceeding '\' slash.
+#
+# These are taken from RFC2068 and RFC2109.
+# _LegalChars is the list of chars which don't require "'s
+# _SpecialChars require the cookie to be double-quoted
+# _Translator hash-table for fast quoting
+#
+_LegalChars = string.letters + string.digits + "!#$%&'*+-.^_`|~"
+_SpecialChars = string.translate(string._idmap, string._idmap, _LegalChars)
+_Translator = {
+ '\000' : '\\000', '\001' : '\\001', '\002' : '\\002', '\003' : '\\003',
+ '\004' : '\\004', '\005' : '\\005', '\006' : '\\006', '\007' : '\\007',
+ '\010' : '\\010', '\011' : '\\011', '\012' : '\\012', '\013' : '\\013',
+ '\014' : '\\014', '\015' : '\\015', '\016' : '\\016', '\017' : '\\017',
+ '\020' : '\\020', '\021' : '\\021', '\022' : '\\022', '\023' : '\\023',
+ '\024' : '\\024', '\025' : '\\025', '\026' : '\\026', '\027' : '\\027',
+ '\030' : '\\030', '\031' : '\\031', '\032' : '\\032', '\033' : '\\033',
+ '\034' : '\\034', '\035' : '\\035', '\036' : '\\036', '\037' : '\\037',
+ ' ' : ' ', '!' : '!', '"' : '\\"', '#' : '#',
+ '$' : '$', '%' : '%', '&' : '&', "'" : "'",
+ '(' : '(', ')' : ')', '*' : '*', '+' : '+',
+ ',' : ',', '-' : '-', '.' : '.', '/' : '/',
+ '0' : '0', '1' : '1', '2' : '2', '3' : '3',
+ '4' : '4', '5' : '5', '6' : '6', '7' : '7',
+ '8' : '8', '9' : '9', ':' : ':', ';' : ';',
+ '<' : '<', ':' : ':', '>' : '>', '?' : '?', '=':'=',
+ '@' : '@', 'A' : 'A', 'B' : 'B', 'C' : 'C',
+ 'D' : 'D', 'E' : 'E', 'F' : 'F', 'G' : 'G',
+ 'H' : 'H', 'I' : 'I', 'J' : 'J', 'K' : 'K',
+ 'L' : 'L', 'M' : 'M', 'N' : 'N', 'O' : 'O',
+ 'P' : 'P', 'Q' : 'Q', 'R' : 'R', 'S' : 'S',
+ 'T' : 'T', 'U' : 'U', 'V' : 'V', 'W' : 'W',
+ 'X' : 'X', 'Y' : 'Y', 'Z' : 'Z', '[' : '[',
+ '\\' : '\\\\', ']' : ']', '^' : '^', '_' : '_',
+ '`' : '`', 'a' : 'a', 'b' : 'b', 'c' : 'c',
+ 'd' : 'd', 'e' : 'e', 'f' : 'f', 'g' : 'g',
+ 'h' : 'h', 'i' : 'i', 'j' : 'j', 'k' : 'k',
+ 'l' : 'l', 'm' : 'm', 'n' : 'n', 'o' : 'o',
+ 'p' : 'p', 'q' : 'q', 'r' : 'r', 's' : 's',
+ 't' : 't', 'u' : 'u', 'v' : 'v', 'w' : 'w',
+ 'x' : 'x', 'y' : 'y', 'z' : 'z', '{' : '{',
+ '|' : '|', '}' : '}', '~' : '~', '\177' : '\\177',
+ '\200' : '\\200', '\201' : '\\201', '\202' : '\\202', '\203' : '\\203',
+ '\204' : '\\204', '\205' : '\\205', '\206' : '\\206', '\207' : '\\207',
+ '\210' : '\\210', '\211' : '\\211', '\212' : '\\212', '\213' : '\\213',
+ '\214' : '\\214', '\215' : '\\215', '\216' : '\\216', '\217' : '\\217',
+ '\220' : '\\220', '\221' : '\\221', '\222' : '\\222', '\223' : '\\223',
+ '\224' : '\\224', '\225' : '\\225', '\226' : '\\226', '\227' : '\\227',
+ '\230' : '\\230', '\231' : '\\231', '\232' : '\\232', '\233' : '\\233',
+ '\234' : '\\234', '\235' : '\\235', '\236' : '\\236', '\237' : '\\237',
+ '\240' : '\\240', '\241' : '\\241', '\242' : '\\242', '\243' : '\\243',
+ '\244' : '\\244', '\245' : '\\245', '\246' : '\\246', '\247' : '\\247',
+ '\250' : '\\250', '\251' : '\\251', '\252' : '\\252', '\253' : '\\253',
+ '\254' : '\\254', '\255' : '\\255', '\256' : '\\256', '\257' : '\\257',
+ '\260' : '\\260', '\261' : '\\261', '\262' : '\\262', '\263' : '\\263',
+ '\264' : '\\264', '\265' : '\\265', '\266' : '\\266', '\267' : '\\267',
+ '\270' : '\\270', '\271' : '\\271', '\272' : '\\272', '\273' : '\\273',
+ '\274' : '\\274', '\275' : '\\275', '\276' : '\\276', '\277' : '\\277',
+ '\300' : '\\300', '\301' : '\\301', '\302' : '\\302', '\303' : '\\303',
+ '\304' : '\\304', '\305' : '\\305', '\306' : '\\306', '\307' : '\\307',
+ '\310' : '\\310', '\311' : '\\311', '\312' : '\\312', '\313' : '\\313',
+ '\314' : '\\314', '\315' : '\\315', '\316' : '\\316', '\317' : '\\317',
+ '\320' : '\\320', '\321' : '\\321', '\322' : '\\322', '\323' : '\\323',
+ '\324' : '\\324', '\325' : '\\325', '\326' : '\\326', '\327' : '\\327',
+ '\330' : '\\330', '\331' : '\\331', '\332' : '\\332', '\333' : '\\333',
+ '\334' : '\\334', '\335' : '\\335', '\336' : '\\336', '\337' : '\\337',
+ '\340' : '\\340', '\341' : '\\341', '\342' : '\\342', '\343' : '\\343',
+ '\344' : '\\344', '\345' : '\\345', '\346' : '\\346', '\347' : '\\347',
+ '\350' : '\\350', '\351' : '\\351', '\352' : '\\352', '\353' : '\\353',
+ '\354' : '\\354', '\355' : '\\355', '\356' : '\\356', '\357' : '\\357',
+ '\360' : '\\360', '\361' : '\\361', '\362' : '\\362', '\363' : '\\363',
+ '\364' : '\\364', '\365' : '\\365', '\366' : '\\366', '\367' : '\\367',
+ '\370' : '\\370', '\371' : '\\371', '\372' : '\\372', '\373' : '\\373',
+ '\374' : '\\374', '\375' : '\\375', '\376' : '\\376', '\377' : '\\377'
+ }
+
+def _translate(c, table=_Translator):
+ return table[c]
+
+def _quote(str, join=string.join):
+ # First check for common (and simple) case.
+ #
+ for C in _SpecialChars:
+ if C in str:
+ break
+ else:
+ return str
+
+ # Ok, down to work.
+ # It's a shame we can't use _Translator.__getitem__
+ # but Python code doesn't have access to that function.
+ #
+ return '"' + join( map(_translate, str), "") + '"'
+# end _quote
+
+
+_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
+_QuotePatt = re.compile(r"[\\].")
+
+def _unquote(str):
+ # If there aren't any doublequotes,
+ # then there can't be any special characters. See RFC 2109.
+ if len(str) < 2:
+ return str
+ if str[0] != '"' or str[-1] != '"':
+ return str
+
+ # We have to assume that we must decode this string.
+ # Down to work.
+
+ # Remove the "s
+ str = str[1:-1]
+
+ # Check for special sequences. Examples:
+ # \012 --> \n
+ # \" --> "
+ #
+ i = 0
+ n = len(str)
+ res = []
+ while 0 <= i < n:
+ Omatch = _OctalPatt.search(str, i)
+ Qmatch = _QuotePatt.search(str, i)
+ if not Omatch and not Qmatch: # Neither matched
+ res.append(str[i:])
+ break
+ # else:
+ j = k = -1
+ if Omatch: j = Omatch.start(0)
+ if Qmatch: k = Qmatch.start(0)
+ if Qmatch and ( not Omatch or k < j ): # QuotePatt matched
+ res.append(str[i:k])
+ res.append(str[k+1])
+ i = k+2
+ else: # OctalPatt matched
+ res.append(str[i:j])
+ res.append( chr( string.atoi(str[j+1:j+4], 8) ) )
+ i = j+4
+ return string.join(res, "")
+# end _unquote
+
+
+# The _babelize() and _debabelize() functions allow arbitrary objects
+# to be used as cookie values. Large cookies may add significant
+# overhead, because the client retransmits them on each visit.
+#
+# Note: HTTP imposes a 2k limit on the size of cookie. I don't check
+# for this limit, so be careful!!!
+#
+
+def _babelize(val, dumps=dumps):
+ if type(val) == type(""):
+ return _quote(val)
+ else:
+ return _quote( dumps(val) )
+
+
+def _debabelize(val, loads=loads):
+ str = _unquote(val)
+ try:
+ return loads(str)
+ except:
+ return str
+
+
+# The _getdate() routine is used to set the expiration time in
+# the cookie's HTTP header. By default, _getdate() returns the
+# current time in the appropriate "expires" format for a
+# Set-Cookie header. The one optional argument is an offset from
+# now, in seconds. For example, an offset of -3600 means "one hour ago".
+# The offset may be a floating point number.
+#
+
+_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+_monthname = [None,
+ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+ 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
+ from time import gmtime, time
+ now = time()
+ year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
+ return "%s, %02d-%3s-%4d %02d:%02d:%02d GMT" % \
+ (weekdayname[wd], day, monthname[month], year, hh, mm, ss)
+
+
+#
+# A class to hold ONE key,value pair.
+# In a cookie, each such pair may have several attributes.
+# so this class is used to keep the attributes associated
+# with the appropriate key,value pair.
+# This class also includes a coded_value attribute, which
+# is used to hold the network representation of the
+# value. This is most useful when Python objects are
+# pickled for network transit.
+#
+
+class Morsel(UserDict):
+ # RFC 2109 lists these attributes as reserved:
+ # path comment domain
+ # max-age secure version
+ #
+ # For historical reasons, these attributes are also reserved:
+ # expires
+ #
+ # This dictionary provides a mapping from the lowercase
+ # variant on the left to the appropriate Set-Cookie
+ # format on the right.
+ __reserved = { "expires" : "expires",
+ "path" : "Path",
+ "comment" : "Comment",
+ "domain" : "Domain",
+ "max-age" : "Max-Age",
+ "secure" : "secure",
+ "version" : "Version",
+ }
+ __reserved_keys = __reserved.keys()
+
+ def __init__(self):
+ # Set defaults
+ self.key = self.value = self.coded_value = None
+ UserDict.__init__(self)
+
+ # Set default attributes
+ for K in self.__reserved_keys:
+ UserDict.__setitem__(self, K, "")
+ # end __init__
+
+ def __setitem__(self, K, V):
+ K = string.lower(K)
+ if not K in self.__reserved_keys:
+ raise CookieError("Invalid Attribute %s" % K)
+ UserDict.__setitem__(self, K, V)
+ # end __setitem__
+
+ def set(self, key, val, coded_val):
+ if string.lower(key) in self.__reserved_keys:
+ raise CookieError("Attempt to set a reserved key: %s" % key)
+ self.key = key
+ self.value = val
+ self.coded_value = coded_val
+ # end set
+
+ def output(self, header = "Set-Cookie:"):
+ return "%s %s" % ( header, self.OutputString() )
+
+ __repr__ = output
+
+ def js_output(self):
+ # Print javascript
+ return """
+ <SCRIPT LANGUAGE="JavaScript">
+ <!-- begin hiding
+ document.cookie = \"%s\"
+ // end hiding -->
+ </script>
+ """ % ( self.OutputString(), )
+ # end js_output()
+
+ def OutputString(self):
+ # Build up our result
+ #
+ result = []
+ RA = result.append
+
+ # First, the key=value pair
+ RA("%s=%s;" % (self.key, self.coded_value))
+
+ # Now add any defined attributes
+ for K,V in self.items():
+ if not V: continue
+ if K == "expires" and type(V) == type(1):
+ RA("%s=%s;" % (self.__reserved[K], _getdate(V)))
+ elif K == "max-age" and type(V) == type(1):
+ RA("%s=%d;" % (self.__reserved[K], V))
+ elif K == "secure":
+ RA("%s;" % self.__reserved[K])
+ else:
+ RA("%s=%s;" % (self.__reserved[K], V))
+
+ # Return the result
+ return string.join(result, " ")
+ # end OutputString
+# end Morsel class
+
+
+
+#
+# Pattern for finding cookie
+#
+# This used to be strict parsing based on the RFC2109 and RFC2068
+# specifications. I have since discovered that MSIE 3.0x doesn't
+# follow the character rules outlined in those specs. As a
+# result, the parsing rules here are less strict.
+#
+
+_LegalCharsPatt = r"[\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{]+"
+_CookiePattern = re.compile(
+ r"(?x)" # This is a Verbose pattern
+ r"(?P<key>" # Start of group 'key'
+ ""+ _LegalCharsPatt +"" # Any word
+ r")" # End of group 'key'
+ r"\s*=\s*" # Equal Sign
+ r"(?P<val>" # Start of group 'val'
+ r'"(?:[^\\"]|\\.)*"' # Any doublequoted string
+ r"|" # or
+ ""+ _LegalCharsPatt +"" # Any word
+ r")" # End of group 'val'
+ r"\s*;?" # Probably ending in a semi-colon
+ )
+
+
+# At long last, here is the cookie class.
+# Using this class is almost just like using a dictionary.
+# See this module's docstring for example usage.
+#
+class Cookie(UserDict):
+ # A container class for a set of Morsels
+ #
+
+ def __init__(self, input=None,
+ net_setfunc=_debabelize, user_setfunc=_babelize):
+ self.net_setfunc = net_setfunc # when set from network
+ self.user_setfunc = user_setfunc # when set by user
+ UserDict.__init__(self)
+ if input: self.load(input)
+ # end __init__
+
+ def __setitem__(self, key, value):
+ """Dictionary style assignment."""
+ M = self.get(key, Morsel())
+ M.set(key, value, apply(self.user_setfunc, (value,)))
+ UserDict.__setitem__(self, key, M)
+ # end __setitem__
+
+ def output(self, header="Set-Cookie:"):
+ """Return a string suitable for HTTP."""
+ result = []
+ for K,V in self.items():
+ result.append( V.output(header) )
+ return string.join(result,"\n")
+ # end output
+
+ __repr__ = output
+
+ def js_output(self):
+ """Return a string suitable for JavaScript."""
+ result = []
+ for K,V in self.items():
+ result.append( V.js_output() )
+ return string.join(result, "")
+ # end js_output
+
+ def load(self, rawdata):
+ """Load cookies from a string (presumably HTTP_COOKIE) or
+ from a dictionary. Loading cookies from a dictionary 'd'
+ is equivalent to calling:
+ map(Cookie.__setitem__, d.keys(), d.values())
+ Unfortunately, this does NOT allow merging of two Cookie
+ dictionaries!
+ """
+ if type(rawdata) == type(""):
+ self.__ParseString(rawdata)
+ else:
+ for K,V in rawdata.items():
+ self[K] = V
+ return
+ # end get()
+
+ def __ParseString(self, str, patt=_CookiePattern):
+ i = 0 # Our starting point
+ n = len(str) # Length of string
+ M = None # Current morsel
+
+ while 0 <= i < n:
+ # Start looking for a cookie
+ match = patt.search(str, i)
+ if not match: break # No more cookies
+ K,V = match.group("key"), match.group("val")
+ i = match.end(0)
+
+ # Parse the key, value in case it's metainfo
+ if K[0] == "$" and M:
+ M[string.lower(K[1:])] = V
+ # We ignore attributes which pertain to the cookie
+ # mechanism as a whole. See RFC 2109.
+ # (Does anyone care?)
+ else:
+ M = Morsel()
+ M.set(K, apply(self.net_setfunc, (V,)), V)
+ UserDict.__setitem__(self, K, M)
+ return
+ # end __ParseString
+
+# end Cookie class
generated by cgit v1.2.3-70-g09d2 (git 2.51.2) at 2025-11-09 10:39:36 +0000