Python code coverage for Lib/Cookie.py

#	count	content
1	n/a	#!/usr/bin/env python
2	n/a	#
3	n/a
4	n/a	####
5	n/a	# Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>
6	n/a	#
7	n/a	# All Rights Reserved
8	n/a	#
9	n/a	# Permission to use, copy, modify, and distribute this software
10	n/a	# and its documentation for any purpose and without fee is hereby
11	n/a	# granted, provided that the above copyright notice appear in all
12	n/a	# copies and that both that copyright notice and this permission
13	n/a	# notice appear in supporting documentation, and that the name of
14	n/a	# Timothy O'Malley not be used in advertising or publicity
15	n/a	# pertaining to distribution of the software without specific, written
16	n/a	# prior permission.
17	n/a	#
18	n/a	# Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
19	n/a	# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
20	n/a	# AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
21	n/a	# ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
22	n/a	# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
23	n/a	# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
24	n/a	# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
25	n/a	# PERFORMANCE OF THIS SOFTWARE.
26	n/a	#
27	n/a	####
28	n/a	#
29	n/a	# Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp
30	n/a	# by Timothy O'Malley <timo@alum.mit.edu>
31	n/a	#
32	n/a	# Cookie.py is a Python module for the handling of HTTP
33	n/a	# cookies as a Python dictionary. See RFC 2109 for more
34	n/a	# information on cookies.
35	n/a	#
36	n/a	# The original idea to treat Cookies as a dictionary came from
37	n/a	# Dave Mitchell (davem@magnet.com) in 1995, when he released the
38	n/a	# first version of nscookie.py.
39	n/a	#
40	n/a	####
41	n/a
42	n/a	r"""
43	n/a	Here's a sample session to show how to use this module.
44	n/a	At the moment, this is the only documentation.
45	n/a
46	n/a	The Basics
47	n/a	----------
48	n/a
49	n/a	Importing is easy..
50	n/a
51	n/a	>>> import Cookie
52	n/a
53	n/a	Most of the time you start by creating a cookie. Cookies come in
54	n/a	three flavors, each with slightly different encoding semantics, but
55	n/a	more on that later.
56	n/a
57	n/a	>>> C = Cookie.SimpleCookie()
58	n/a	>>> C = Cookie.SerialCookie()
59	n/a	>>> C = Cookie.SmartCookie()
60	n/a
61	n/a	[Note: Long-time users of Cookie.py will remember using
62	n/a	Cookie.Cookie() to create an Cookie object. Although deprecated, it
63	n/a	is still supported by the code. See the Backward Compatibility notes
64	n/a	for more information.]
65	n/a
66	n/a	Once you've created your Cookie, you can add values just as if it were
67	n/a	a dictionary.
68	n/a
69	n/a	>>> C = Cookie.SmartCookie()
70	n/a	>>> C["fig"] = "newton"
71	n/a	>>> C["sugar"] = "wafer"
72	n/a	>>> C.output()
73	n/a	'Set-Cookie: fig=newton\r\nSet-Cookie: sugar=wafer'
74	n/a
75	n/a	Notice that the printable representation of a Cookie is the
76	n/a	appropriate format for a Set-Cookie: header. This is the
77	n/a	default behavior. You can change the header and printed
78	n/a	attributes by using the .output() function
79	n/a
80	n/a	>>> C = Cookie.SmartCookie()
81	n/a	>>> C["rocky"] = "road"
82	n/a	>>> C["rocky"]["path"] = "/cookie"
83	n/a	>>> print C.output(header="Cookie:")
84	n/a	Cookie: rocky=road; Path=/cookie
85	n/a	>>> print C.output(attrs=[], header="Cookie:")
86	n/a	Cookie: rocky=road
87	n/a
88	n/a	The load() method of a Cookie extracts cookies from a string. In a
89	n/a	CGI script, you would use this method to extract the cookies from the
90	n/a	HTTP_COOKIE environment variable.
91	n/a
92	n/a	>>> C = Cookie.SmartCookie()
93	n/a	>>> C.load("chips=ahoy; vienna=finger")
94	n/a	>>> C.output()
95	n/a	'Set-Cookie: chips=ahoy\r\nSet-Cookie: vienna=finger'
96	n/a
97	n/a	The load() method is darn-tootin smart about identifying cookies
98	n/a	within a string. Escaped quotation marks, nested semicolons, and other
99	n/a	such trickeries do not confuse it.
100	n/a
101	n/a	>>> C = Cookie.SmartCookie()
102	n/a	>>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
103	n/a	>>> print C
104	n/a	Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;"
105	n/a
106	n/a	Each element of the Cookie also supports all of the RFC 2109
107	n/a	Cookie attributes. Here's an example which sets the Path
108	n/a	attribute.
109	n/a
110	n/a	>>> C = Cookie.SmartCookie()
111	n/a	>>> C["oreo"] = "doublestuff"
112	n/a	>>> C["oreo"]["path"] = "/"
113	n/a	>>> print C
114	n/a	Set-Cookie: oreo=doublestuff; Path=/
115	n/a
116	n/a	Each dictionary element has a 'value' attribute, which gives you
117	n/a	back the value associated with the key.
118	n/a
119	n/a	>>> C = Cookie.SmartCookie()
120	n/a	>>> C["twix"] = "none for you"
121	n/a	>>> C["twix"].value
122	n/a	'none for you'
123	n/a
124	n/a
125	n/a	A Bit More Advanced
126	n/a	-------------------
127	n/a
128	n/a	As mentioned before, there are three different flavors of Cookie
129	n/a	objects, each with different encoding/decoding semantics. This
130	n/a	section briefly discusses the differences.
131	n/a
132	n/a	SimpleCookie
133	n/a
134	n/a	The SimpleCookie expects that all values should be standard strings.
135	n/a	Just to be sure, SimpleCookie invokes the str() builtin to convert
136	n/a	the value to a string, when the values are set dictionary-style.
137	n/a
138	n/a	>>> C = Cookie.SimpleCookie()
139	n/a	>>> C["number"] = 7
140	n/a	>>> C["string"] = "seven"
141	n/a	>>> C["number"].value
142	n/a	'7'
143	n/a	>>> C["string"].value
144	n/a	'seven'
145	n/a	>>> C.output()
146	n/a	'Set-Cookie: number=7\r\nSet-Cookie: string=seven'
147	n/a
148	n/a
149	n/a	SerialCookie
150	n/a
151	n/a	The SerialCookie expects that all values should be serialized using
152	n/a	cPickle (or pickle, if cPickle isn't available). As a result of
153	n/a	serializing, SerialCookie can save almost any Python object to a
154	n/a	value, and recover the exact same object when the cookie has been
155	n/a	returned. (SerialCookie can yield some strange-looking cookie
156	n/a	values, however.)
157	n/a
158	n/a	>>> C = Cookie.SerialCookie()
159	n/a	>>> C["number"] = 7
160	n/a	>>> C["string"] = "seven"
161	n/a	>>> C["number"].value
162	n/a	7
163	n/a	>>> C["string"].value
164	n/a	'seven'
165	n/a	>>> C.output()
166	n/a	'Set-Cookie: number="I7\\012."\r\nSet-Cookie: string="S\'seven\'\\012p1\\012."'
167	n/a
168	n/a	Be warned, however, if SerialCookie cannot de-serialize a value (because
169	n/a	it isn't a valid pickle'd object), IT WILL RAISE AN EXCEPTION.
170	n/a
171	n/a
172	n/a	SmartCookie
173	n/a
174	n/a	The SmartCookie combines aspects of each of the other two flavors.
175	n/a	When setting a value in a dictionary-fashion, the SmartCookie will
176	n/a	serialize (ala cPickle) the value if and only if it isn't a
177	n/a	Python string. String objects are not serialized. Similarly,
178	n/a	when the load() method parses out values, it attempts to de-serialize
179	n/a	the value. If it fails, then it fallsback to treating the value
180	n/a	as a string.
181	n/a
182	n/a	>>> C = Cookie.SmartCookie()
183	n/a	>>> C["number"] = 7
184	n/a	>>> C["string"] = "seven"
185	n/a	>>> C["number"].value
186	n/a	7
187	n/a	>>> C["string"].value
188	n/a	'seven'
189	n/a	>>> C.output()
190	n/a	'Set-Cookie: number="I7\\012."\r\nSet-Cookie: string=seven'
191	n/a
192	n/a
193	n/a	Backwards Compatibility
194	n/a	-----------------------
195	n/a
196	n/a	In order to keep compatibilty with earlier versions of Cookie.py,
197	n/a	it is still possible to use Cookie.Cookie() to create a Cookie. In
198	n/a	fact, this simply returns a SmartCookie.
199	n/a
200	n/a	>>> C = Cookie.Cookie()
201	n/a	>>> print C.__class__.__name__
202	n/a	SmartCookie
203	n/a
204	n/a
205	n/a	Finis.
206	1	""" #"
207	n/a	# ^
208	n/a	# \|----helps out font-lock
209	n/a
210	n/a	#
211	n/a	# Import our required modules
212	n/a	#
213	1	import string
214	n/a
215	1	try:
216	1	from cPickle import dumps, loads
217	0	except ImportError:
218	0	from pickle import dumps, loads
219	n/a
220	1	import re, warnings
221	n/a
222	1	__all__ = ["CookieError","BaseCookie","SimpleCookie","SerialCookie",
223	1	"SmartCookie","Cookie"]
224	n/a
225	1	_nulljoin = ''.join
226	1	_semispacejoin = '; '.join
227	1	_spacejoin = ' '.join
228	n/a
229	n/a	#
230	n/a	# Define an exception visible to External modules
231	n/a	#
232	2	class CookieError(Exception):
233	1	pass
234	n/a
235	n/a
236	n/a	# These quoting routines conform to the RFC2109 specification, which in
237	n/a	# turn references the character definitions from RFC2068. They provide
238	n/a	# a two-way quoting algorithm. Any non-text character is translated
239	n/a	# into a 4 character sequence: a forward-slash followed by the
240	n/a	# three-digit octal equivalent of the character. Any '\' or '"' is
241	n/a	# quoted with a preceeding '\' slash.
242	n/a	#
243	n/a	# These are taken from RFC2068 and RFC2109.
244	n/a	# _LegalChars is the list of chars which don't require "'s
245	n/a	# _Translator hash-table for fast quoting
246	n/a	#
247	1	_LegalChars = string.ascii_letters + string.digits + "!#$%&'*+-.^_`\|~"
248	1	_Translator = {
249	1	'\000' : '\\000', '\001' : '\\001', '\002' : '\\002',
250	1	'\003' : '\\003', '\004' : '\\004', '\005' : '\\005',
251	1	'\006' : '\\006', '\007' : '\\007', '\010' : '\\010',
252	1	'\011' : '\\011', '\012' : '\\012', '\013' : '\\013',
253	1	'\014' : '\\014', '\015' : '\\015', '\016' : '\\016',
254	1	'\017' : '\\017', '\020' : '\\020', '\021' : '\\021',
255	1	'\022' : '\\022', '\023' : '\\023', '\024' : '\\024',
256	1	'\025' : '\\025', '\026' : '\\026', '\027' : '\\027',
257	1	'\030' : '\\030', '\031' : '\\031', '\032' : '\\032',
258	1	'\033' : '\\033', '\034' : '\\034', '\035' : '\\035',
259	1	'\036' : '\\036', '\037' : '\\037',
260	n/a
261	1	'"' : '\\"', '\\' : '\\\\',
262	n/a
263	1	'\177' : '\\177', '\200' : '\\200', '\201' : '\\201',
264	1	'\202' : '\\202', '\203' : '\\203', '\204' : '\\204',
265	1	'\205' : '\\205', '\206' : '\\206', '\207' : '\\207',
266	1	'\210' : '\\210', '\211' : '\\211', '\212' : '\\212',
267	1	'\213' : '\\213', '\214' : '\\214', '\215' : '\\215',
268	1	'\216' : '\\216', '\217' : '\\217', '\220' : '\\220',
269	1	'\221' : '\\221', '\222' : '\\222', '\223' : '\\223',
270	1	'\224' : '\\224', '\225' : '\\225', '\226' : '\\226',
271	1	'\227' : '\\227', '\230' : '\\230', '\231' : '\\231',
272	1	'\232' : '\\232', '\233' : '\\233', '\234' : '\\234',
273	1	'\235' : '\\235', '\236' : '\\236', '\237' : '\\237',
274	1	'\240' : '\\240', '\241' : '\\241', '\242' : '\\242',
275	1	'\243' : '\\243', '\244' : '\\244', '\245' : '\\245',
276	1	'\246' : '\\246', '\247' : '\\247', '\250' : '\\250',
277	1	'\251' : '\\251', '\252' : '\\252', '\253' : '\\253',
278	1	'\254' : '\\254', '\255' : '\\255', '\256' : '\\256',
279	1	'\257' : '\\257', '\260' : '\\260', '\261' : '\\261',
280	1	'\262' : '\\262', '\263' : '\\263', '\264' : '\\264',
281	1	'\265' : '\\265', '\266' : '\\266', '\267' : '\\267',
282	1	'\270' : '\\270', '\271' : '\\271', '\272' : '\\272',
283	1	'\273' : '\\273', '\274' : '\\274', '\275' : '\\275',
284	1	'\276' : '\\276', '\277' : '\\277', '\300' : '\\300',
285	1	'\301' : '\\301', '\302' : '\\302', '\303' : '\\303',
286	1	'\304' : '\\304', '\305' : '\\305', '\306' : '\\306',
287	1	'\307' : '\\307', '\310' : '\\310', '\311' : '\\311',
288	1	'\312' : '\\312', '\313' : '\\313', '\314' : '\\314',
289	1	'\315' : '\\315', '\316' : '\\316', '\317' : '\\317',
290	1	'\320' : '\\320', '\321' : '\\321', '\322' : '\\322',
291	1	'\323' : '\\323', '\324' : '\\324', '\325' : '\\325',
292	1	'\326' : '\\326', '\327' : '\\327', '\330' : '\\330',
293	1	'\331' : '\\331', '\332' : '\\332', '\333' : '\\333',
294	1	'\334' : '\\334', '\335' : '\\335', '\336' : '\\336',
295	1	'\337' : '\\337', '\340' : '\\340', '\341' : '\\341',
296	1	'\342' : '\\342', '\343' : '\\343', '\344' : '\\344',
297	1	'\345' : '\\345', '\346' : '\\346', '\347' : '\\347',
298	1	'\350' : '\\350', '\351' : '\\351', '\352' : '\\352',
299	1	'\353' : '\\353', '\354' : '\\354', '\355' : '\\355',
300	1	'\356' : '\\356', '\357' : '\\357', '\360' : '\\360',
301	1	'\361' : '\\361', '\362' : '\\362', '\363' : '\\363',
302	1	'\364' : '\\364', '\365' : '\\365', '\366' : '\\366',
303	1	'\367' : '\\367', '\370' : '\\370', '\371' : '\\371',
304	1	'\372' : '\\372', '\373' : '\\373', '\374' : '\\374',
305	1	'\375' : '\\375', '\376' : '\\376', '\377' : '\\377'
306	n/a	}
307	n/a
308	258	_idmap = ''.join(chr(x) for x in xrange(256))
309	n/a
310	1	def _quote(str, LegalChars=_LegalChars,
311	1	idmap=_idmap, translate=string.translate):
312	n/a	#
313	n/a	# If the string does not need to be double-quoted,
314	n/a	# then just return the string. Otherwise, surround
315	n/a	# the string in doublequotes and precede quote (with a \)
316	n/a	# special characters.
317	n/a	#
318	11	if "" == translate(str, idmap, LegalChars):
319	7	return str
320	n/a	else:
321	4	return '"' + _nulljoin( map(_Translator.get, str, str) ) + '"'
322	n/a	# end _quote
323	n/a
324	n/a
325	1	_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
326	1	_QuotePatt = re.compile(r"[\\].")
327	n/a
328	1	def _unquote(str):
329	n/a	# If there aren't any doublequotes,
330	n/a	# then there can't be any special characters. See RFC 2109.
331	13	if len(str) < 2:
332	1	return str
333	12	if str[0] != '"' or str[-1] != '"':
334	6	return str
335	n/a
336	n/a	# We have to assume that we must decode this string.
337	n/a	# Down to work.
338	n/a
339	n/a	# Remove the "s
340	6	str = str[1:-1]
341	n/a
342	n/a	# Check for special sequences. Examples:
343	n/a	# \012 --> \n
344	n/a	# \" --> "
345	n/a	#
346	6	i = 0
347	6	n = len(str)
348	6	res = []
349	12	while 0 <= i < n:
350	12	Omatch = _OctalPatt.search(str, i)
351	12	Qmatch = _QuotePatt.search(str, i)
352	12	if not Omatch and not Qmatch: # Neither matched
353	6	res.append(str[i:])
354	6	break
355	n/a	# else:
356	6	j = k = -1
357	6	if Omatch: j = Omatch.start(0)
358	6	if Qmatch: k = Qmatch.start(0)
359	6	if Qmatch and ( not Omatch or k < j ): # QuotePatt matched
360	4	res.append(str[i:k])
361	4	res.append(str[k+1])
362	4	i = k+2
363	n/a	else: # OctalPatt matched
364	2	res.append(str[i:j])
365	2	res.append( chr( int(str[j+1:j+4], 8) ) )
366	2	i = j+4
367	6	return _nulljoin(res)
368	n/a	# end _unquote
369	n/a
370	n/a	# The _getdate() routine is used to set the expiration time in
371	n/a	# the cookie's HTTP header. By default, _getdate() returns the
372	n/a	# current time in the appropriate "expires" format for a
373	n/a	# Set-Cookie header. The one optional argument is an offset from
374	n/a	# now, in seconds. For example, an offset of -3600 means "one hour ago".
375	n/a	# The offset may be a floating point number.
376	n/a	#
377	n/a
378	1	_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
379	n/a
380	1	_monthname = [None,
381	1	'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
382	1	'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
383	n/a
384	1	def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
385	0	from time import gmtime, time
386	0	now = time()
387	0	year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
388	0	return "%s, %02d-%3s-%4d %02d:%02d:%02d GMT" % \
389	0	(weekdayname[wd], day, monthname[month], year, hh, mm, ss)
390	n/a
391	n/a
392	n/a	#
393	n/a	# A class to hold ONE key,value pair.
394	n/a	# In a cookie, each such pair may have several attributes.
395	n/a	# so this class is used to keep the attributes associated
396	n/a	# with the appropriate key,value pair.
397	n/a	# This class also includes a coded_value attribute, which
398	n/a	# is used to hold the network representation of the
399	n/a	# value. This is most useful when Python objects are
400	n/a	# pickled for network transit.
401	n/a	#
402	n/a
403	2	class Morsel(dict):
404	n/a	# RFC 2109 lists these attributes as reserved:
405	n/a	# path comment domain
406	n/a	# max-age secure version
407	n/a	#
408	n/a	# For historical reasons, these attributes are also reserved:
409	n/a	# expires
410	n/a	#
411	n/a	# This is an extension from Microsoft:
412	n/a	# httponly
413	n/a	#
414	n/a	# This dictionary provides a mapping from the lowercase
415	n/a	# variant on the left to the appropriate traditional
416	n/a	# formatting on the right.
417	1	_reserved = { "expires" : "expires",
418	1	"path" : "Path",
419	1	"comment" : "Comment",
420	1	"domain" : "Domain",
421	1	"max-age" : "Max-Age",
422	1	"secure" : "secure",
423	1	"httponly" : "httponly",
424	1	"version" : "Version",
425	n/a	}
426	n/a
427	1	def __init__(self):
428	n/a	# Set defaults
429	20	self.key = self.value = self.coded_value = None
430	n/a
431	n/a	# Set default attributes
432	180	for K in self._reserved:
433	160	dict.__setitem__(self, K, "")
434	n/a	# end __init__
435	n/a
436	1	def __setitem__(self, K, V):
437	6	K = K.lower()
438	6	if not K in self._reserved:
439	0	raise CookieError("Invalid Attribute %s" % K)
440	6	dict.__setitem__(self, K, V)
441	n/a	# end __setitem__
442	n/a
443	1	def isReservedKey(self, K):
444	0	return K.lower() in self._reserved
445	n/a	# end isReservedKey
446	n/a
447	n/a	def set(self, key, val, coded_val,
448	1	LegalChars=_LegalChars,
449	1	idmap=_idmap, translate=string.translate):
450	n/a	# First we verify that the key isn't a reserved word
451	n/a	# Second we make sure it only contains legal characters
452	20	if key.lower() in self._reserved:
453	0	raise CookieError("Attempt to set a reserved key: %s" % key)
454	20	if "" != translate(key, idmap, LegalChars):
455	0	raise CookieError("Illegal key value: %s" % key)
456	n/a
457	n/a	# It's a good key, so save it.
458	20	self.key = key
459	20	self.value = val
460	20	self.coded_value = coded_val
461	n/a	# end set
462	n/a
463	1	def output(self, attrs=None, header = "Set-Cookie:"):
464	19	return "%s %s" % ( header, self.OutputString(attrs) )
465	n/a
466	1	__str__ = output
467	n/a
468	1	def __repr__(self):
469	0	return '<%s: %s=%s>' % (self.__class__.__name__,
470	0	self.key, repr(self.value) )
471	n/a
472	1	def js_output(self, attrs=None):
473	n/a	# Print javascript
474	n/a	return """
475	n/a	<script type="text/javascript">
476	n/a	<!-- begin hiding
477	n/a	document.cookie = \"%s\";
478	n/a	// end hiding -->
479	n/a	</script>
480	2	""" % ( self.OutputString(attrs).replace('"',r'\"'), )
481	n/a	# end js_output()
482	n/a
483	1	def OutputString(self, attrs=None):
484	n/a	# Build up our result
485	n/a	#
486	21	result = []
487	21	RA = result.append
488	n/a
489	n/a	# First, the key=value pair
490	21	RA("%s=%s" % (self.key, self.coded_value))
491	n/a
492	n/a	# Now add any defined attributes
493	21	if attrs is None:
494	18	attrs = self._reserved
495	21	items = self.items()
496	21	items.sort()
497	189	for K,V in items:
498	168	if V == "": continue
499	9	if K not in attrs: continue
500	6	if K == "expires" and type(V) == type(1):
501	0	RA("%s=%s" % (self._reserved[K], _getdate(V)))
502	6	elif K == "max-age" and type(V) == type(1):
503	0	RA("%s=%d" % (self._reserved[K], V))
504	6	elif K == "secure":
505	0	RA(str(self._reserved[K]))
506	6	elif K == "httponly":
507	0	RA(str(self._reserved[K]))
508	n/a	else:
509	6	RA("%s=%s" % (self._reserved[K], V))
510	n/a
511	n/a	# Return the result
512	21	return _semispacejoin(result)
513	n/a	# end OutputString
514	n/a	# end Morsel class
515	n/a
516	n/a
517	n/a
518	n/a	#
519	n/a	# Pattern for finding cookie
520	n/a	#
521	n/a	# This used to be strict parsing based on the RFC2109 and RFC2068
522	n/a	# specifications. I have since discovered that MSIE 3.0x doesn't
523	n/a	# follow the character rules outlined in those specs. As a
524	n/a	# result, the parsing rules here are less strict.
525	n/a	#
526	n/a
527	1	_LegalCharsPatt = r"[\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\\|\)\(\?\}\{\=]"
528	1	_CookiePattern = re.compile(
529	n/a	r"(?x)" # This is a Verbose pattern
530	n/a	r"(?P<key>" # Start of group 'key'
531	n/a	""+ _LegalCharsPatt +"+?" # Any word of at least one letter, nongreedy
532	n/a	r")" # End of group 'key'
533	n/a	r"\s=\s" # Equal Sign
534	n/a	r"(?P<val>" # Start of group 'val'
535	n/a	r'"(?:[^\\"]\|\\.)*"' # Any doublequoted string
536	n/a	r"\|" # or
537	1	""+ _LegalCharsPatt +"*" # Any word or empty string
538	n/a	r")" # End of group 'val'
539	n/a	r"\s*;?" # Probably ending in a semi-colon
540	n/a	)
541	n/a
542	n/a
543	n/a	# At long last, here is the cookie class.
544	n/a	# Using this class is almost just like using a dictionary.
545	n/a	# See this module's docstring for example usage.
546	n/a	#
547	2	class BaseCookie(dict):
548	n/a	# A container class for a set of Morsels
549	n/a	#
550	n/a
551	1	def value_decode(self, val):
552	n/a	"""real_value, coded_value = value_decode(STRING)
553	n/a	Called prior to setting a cookie's value from the network
554	n/a	representation. The VALUE is the value read from HTTP
555	n/a	header.
556	n/a	Override this function to modify the behavior of cookies.
557	n/a	"""
558	0	return val, val
559	n/a	# end value_encode
560	n/a
561	1	def value_encode(self, val):
562	n/a	"""real_value, coded_value = value_encode(VALUE)
563	n/a	Called prior to setting a cookie's value from the dictionary
564	n/a	representation. The VALUE is the value being assigned.
565	n/a	Override this function to modify the behavior of cookies.
566	n/a	"""
567	0	strval = str(val)
568	0	return strval, strval
569	n/a	# end value_encode
570	n/a
571	1	def __init__(self, input=None):
572	18	if input: self.load(input)
573	n/a	# end __init__
574	n/a
575	1	def __set(self, key, real_value, coded_value):
576	n/a	"""Private method for setting a cookie's value"""
577	20	M = self.get(key, Morsel())
578	20	M.set(key, real_value, coded_value)
579	20	dict.__setitem__(self, key, M)
580	n/a	# end __set
581	n/a
582	1	def __setitem__(self, key, value):
583	n/a	"""Dictionary style assignment."""
584	11	rval, cval = self.value_encode(value)
585	11	self.__set(key, rval, cval)
586	n/a	# end __setitem__
587	n/a
588	1	def output(self, attrs=None, header="Set-Cookie:", sep="\015\012"):
589	n/a	"""Return a string suitable for HTTP."""
590	13	result = []
591	13	items = self.items()
592	13	items.sort()
593	32	for K,V in items:
594	19	result.append( V.output(attrs, header) )
595	13	return sep.join(result)
596	n/a	# end output
597	n/a
598	1	__str__ = output
599	n/a
600	1	def __repr__(self):
601	3	L = []
602	3	items = self.items()
603	3	items.sort()
604	7	for K,V in items:
605	4	L.append( '%s=%s' % (K,repr(V.value) ) )
606	3	return '<%s: %s>' % (self.__class__.__name__, _spacejoin(L))
607	n/a
608	1	def js_output(self, attrs=None):
609	n/a	"""Return a string suitable for JavaScript."""
610	2	result = []
611	2	items = self.items()
612	2	items.sort()
613	4	for K,V in items:
614	2	result.append( V.js_output(attrs) )
615	2	return _nulljoin(result)
616	n/a	# end js_output
617	n/a
618	1	def load(self, rawdata):
619	n/a	"""Load cookies from a string (presumably HTTP_COOKIE) or
620	n/a	from a dictionary. Loading cookies from a dictionary 'd'
621	n/a	is equivalent to calling:
622	n/a	map(Cookie.__setitem__, d.keys(), d.values())
623	n/a	"""
624	7	if type(rawdata) == type(""):
625	7	self.__ParseString(rawdata)
626	n/a	else:
627	n/a	# self.update() wouldn't call our custom __setitem__
628	0	for k, v in rawdata.items():
629	0	self[k] = v
630	7	return
631	n/a	# end load()
632	n/a
633	1	def __ParseString(self, str, patt=_CookiePattern):
634	7	i = 0 # Our starting point
635	7	n = len(str) # Length of string
636	7	M = None # current morsel
637	n/a
638	20	while 0 <= i < n:
639	n/a	# Start looking for a cookie
640	13	match = patt.search(str, i)
641	13	if not match: break # No more cookies
642	n/a
643	13	K,V = match.group("key"), match.group("val")
644	13	i = match.end(0)
645	n/a
646	n/a	# Parse the key, value in case it's metainfo
647	13	if K[0] == "$":
648	n/a	# We ignore attributes which pertain to the cookie
649	n/a	# mechanism as a whole. See RFC 2109.
650	n/a	# (Does anyone care?)
651	0	if M:
652	0	M[ K[1:] ] = V
653	13	elif K.lower() in Morsel._reserved:
654	4	if M:
655	4	M[ K ] = _unquote(V)
656	n/a	else:
657	9	rval, cval = self.value_decode(V)
658	9	self.__set(K, rval, cval)
659	9	M = self[K]
660	n/a	# end __ParseString
661	n/a	# end BaseCookie class
662	n/a
663	2	class SimpleCookie(BaseCookie):
664	n/a	"""SimpleCookie
665	n/a	SimpleCookie supports strings as cookie values. When setting
666	n/a	the value using the dictionary assignment notation, SimpleCookie
667	n/a	calls the builtin str() to convert the value to a string. Values
668	n/a	received from HTTP are kept as strings.
669	1	"""
670	1	def value_decode(self, val):
671	6	return _unquote( val ), val
672	1	def value_encode(self, val):
673	2	strval = str(val)
674	2	return strval, _quote( strval )
675	n/a	# end SimpleCookie
676	n/a
677	2	class SerialCookie(BaseCookie):
678	n/a	"""SerialCookie
679	n/a	SerialCookie supports arbitrary objects as cookie values. All
680	n/a	values are serialized (using cPickle) before being sent to the
681	n/a	client. All incoming values are assumed to be valid Pickle
682	n/a	representations. IF AN INCOMING VALUE IS NOT IN A VALID PICKLE
683	n/a	FORMAT, THEN AN EXCEPTION WILL BE RAISED.
684	n/a
685	n/a	Note: Large cookie values add overhead because they must be
686	n/a	retransmitted on every HTTP transaction.
687	n/a
688	n/a	Note: HTTP has a 2k limit on the size of a cookie. This class
689	n/a	does not check for this limit, so be careful!!!
690	1	"""
691	1	def __init__(self, input=None):
692	2	warnings.warn("SerialCookie class is insecure; do not use it",
693	2	DeprecationWarning)
694	2	BaseCookie.__init__(self, input)
695	n/a	# end __init__
696	1	def value_decode(self, val):
697	n/a	# This could raise an exception!
698	0	return loads( _unquote(val) ), val
699	1	def value_encode(self, val):
700	2	return val, _quote( dumps(val) )
701	n/a	# end SerialCookie
702	n/a
703	2	class SmartCookie(BaseCookie):
704	n/a	"""SmartCookie
705	n/a	SmartCookie supports arbitrary objects as cookie values. If the
706	n/a	object is a string, then it is quoted. If the object is not a
707	n/a	string, however, then SmartCookie will use cPickle to serialize
708	n/a	the object into a string representation.
709	n/a
710	n/a	Note: Large cookie values add overhead because they must be
711	n/a	retransmitted on every HTTP transaction.
712	n/a
713	n/a	Note: HTTP has a 2k limit on the size of a cookie. This class
714	n/a	does not check for this limit, so be careful!!!
715	1	"""
716	1	def __init__(self, input=None):
717	9	warnings.warn("Cookie/SmartCookie class is insecure; do not use it",
718	9	DeprecationWarning)
719	9	BaseCookie.__init__(self, input)
720	n/a	# end __init__
721	1	def value_decode(self, val):
722	3	strval = _unquote(val)
723	3	try:
724	3	return loads(strval), val
725	3	except:
726	3	return strval, val
727	1	def value_encode(self, val):
728	7	if type(val) == type(""):
729	6	return val, _quote(val)
730	n/a	else:
731	1	return val, _quote( dumps(val) )
732	n/a	# end SmartCookie
733	n/a
734	n/a
735	n/a	###########################################################
736	n/a	# Backwards Compatibility: Don't break any existing code!
737	n/a
738	n/a	# We provide Cookie() as an alias for SmartCookie()
739	1	Cookie = SmartCookie
740	n/a
741	n/a	#
742	n/a	###########################################################
743	n/a
744	1	def _test():
745	0	import doctest, Cookie
746	0	return doctest.testmod(Cookie)
747	n/a
748	1	if __name__ == "__main__":
749	0	_test()
750	n/a
751	n/a
752	n/a	#Local Variables:
753	n/a	#tab-width: 4
754	n/a	#end: