Python code coverage for Lib/cookielib.py

#	count	content
1	n/a	"""HTTP cookie handling for web clients.
2	n/a
3	n/a	This module has (now fairly distant) origins in Gisle Aas' Perl module
4	n/a	HTTP::Cookies, from the libwww-perl library.
5	n/a
6	n/a	Docstrings, comments and debug strings in this code refer to the
7	n/a	attributes of the HTTP cookie system as cookie-attributes, to distinguish
8	n/a	them clearly from Python attributes.
9	n/a
10	n/a	Class diagram (note that BSDDBCookieJar and the MSIE* classes are not
11	n/a	distributed with the Python standard library, but are available from
12	n/a	http://wwwsearch.sf.net/):
13	n/a
14	n/a	CookieJar____
15	n/a	/ \ \
16	n/a	FileCookieJar \ \
17	n/a	/ \| \ \ \
18	n/a	MozillaCookieJar \| LWPCookieJar \ \
19	n/a	\| \| \
20	n/a	\| ---MSIEBase \| \
21	n/a	\| / \| \| \
22	n/a	\| / MSIEDBCookieJar BSDDBCookieJar
23	n/a	\|/
24	n/a	MSIECookieJar
25	n/a
26	1	"""
27	n/a
28	1	__all__ = ['Cookie', 'CookieJar', 'CookiePolicy', 'DefaultCookiePolicy',
29	1	'FileCookieJar', 'LWPCookieJar', 'lwp_cookie_str', 'LoadError',
30	1	'MozillaCookieJar']
31	n/a
32	1	import re, urlparse, copy, time, urllib
33	1	try:
34	1	import threading as _threading
35	0	except ImportError:
36	0	import dummy_threading as _threading
37	1	import httplib # only for the default HTTP port
38	1	from calendar import timegm
39	n/a
40	1	debug = False # set to True to enable debugging via the logging module
41	1	logger = None
42	n/a
43	1	def _debug(*args):
44	1044	if not debug:
45	1044	return
46	n/a	global logger
47	0	if not logger:
48	0	import logging
49	0	logger = logging.getLogger("cookielib")
50	0	return logger.debug(*args)
51	n/a
52	n/a
53	1	DEFAULT_HTTP_PORT = str(httplib.HTTP_PORT)
54	1	MISSING_FILENAME_TEXT = ("a filename was not supplied (nor was the CookieJar "
55	n/a	"instance initialised with one)")
56	n/a
57	1	def _warn_unhandled_exception():
58	n/a	# There are a few catch-all except: statements in this module, for
59	n/a	# catching input that's bad in unexpected ways. Warn if any
60	n/a	# exceptions are caught there.
61	0	import warnings, traceback, StringIO
62	0	f = StringIO.StringIO()
63	0	traceback.print_exc(None, f)
64	0	msg = f.getvalue()
65	0	warnings.warn("cookielib bug!\n%s" % msg, stacklevel=2)
66	n/a
67	n/a
68	n/a	# Date/time conversion
69	n/a	# -----------------------------------------------------------------------------
70	n/a
71	1	EPOCH_YEAR = 1970
72	1	def _timegm(tt):
73	70	year, month, mday, hour, min, sec = tt[:6]
74	70	if ((year >= EPOCH_YEAR) and (1 <= month <= 12) and (1 <= mday <= 31) and
75	66	(0 <= hour <= 24) and (0 <= min <= 59) and (0 <= sec <= 61)):
76	60	return timegm(tt)
77	n/a	else:
78	10	return None
79	n/a
80	1	DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
81	1	MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
82	1	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
83	1	MONTHS_LOWER = []
84	13	for month in MONTHS: MONTHS_LOWER.append(month.lower())
85	n/a
86	1	def time2isoz(t=None):
87	n/a	"""Return a string representing time in seconds since epoch, t.
88	n/a
89	n/a	If the function is called without an argument, it will use the current
90	n/a	time.
91	n/a
92	n/a	The format of the returned string is like "YYYY-MM-DD hh:mm:ssZ",
93	n/a	representing Universal Time (UTC, aka GMT). An example of this format is:
94	n/a
95	n/a	1994-11-24 08:49:37Z
96	n/a
97	n/a	"""
98	9	if t is None: t = time.time()
99	9	year, mon, mday, hour, min, sec = time.gmtime(t)[:6]
100	9	return "%04d-%02d-%02d %02d:%02d:%02dZ" % (
101	9	year, mon, mday, hour, min, sec)
102	n/a
103	1	def time2netscape(t=None):
104	n/a	"""Return a string representing time in seconds since epoch, t.
105	n/a
106	n/a	If the function is called without an argument, it will use the current
107	n/a	time.
108	n/a
109	n/a	The format of the returned string is like this:
110	n/a
111	n/a	Wed, DD-Mon-YYYY HH:MM:SS GMT
112	n/a
113	n/a	"""
114	2	if t is None: t = time.time()
115	2	year, mon, mday, hour, min, sec, wday = time.gmtime(t)[:7]
116	2	return "%s %02d-%s-%04d %02d:%02d:%02d GMT" % (
117	2	DAYS[wday], mday, MONTHS[mon-1], year, hour, min, sec)
118	n/a
119	n/a
120	1	UTC_ZONES = {"GMT": None, "UTC": None, "UT": None, "Z": None}
121	n/a
122	1	TIMEZONE_RE = re.compile(r"^([-+])?(\d\d?):?(\d\d)?$")
123	1	def offset_from_tz_string(tz):
124	59	offset = None
125	59	if tz in UTC_ZONES:
126	59	offset = 0
127	n/a	else:
128	0	m = TIMEZONE_RE.search(tz)
129	0	if m:
130	0	offset = 3600 * int(m.group(2))
131	0	if m.group(3):
132	0	offset = offset + 60 * int(m.group(3))
133	0	if m.group(1) == '-':
134	0	offset = -offset
135	59	return offset
136	n/a
137	1	def _str2time(day, mon, yr, hr, min, sec, tz):
138	n/a	# translate month name to number
139	n/a	# month numbers start with 1 (January)
140	73	try:
141	73	mon = MONTHS_LOWER.index(mon.lower())+1
142	16	except ValueError:
143	n/a	# maybe it's already a number
144	16	try:
145	16	imon = int(mon)
146	0	except ValueError:
147	0	return None
148	16	if 1 <= imon <= 12:
149	12	mon = imon
150	n/a	else:
151	4	return None
152	n/a
153	n/a	# make sure clock elements are defined
154	69	if hr is None: hr = 0
155	69	if min is None: min = 0
156	69	if sec is None: sec = 0
157	n/a
158	69	yr = int(yr)
159	69	day = int(day)
160	69	hr = int(hr)
161	69	min = int(min)
162	69	sec = int(sec)
163	n/a
164	69	if yr < 1000:
165	n/a	# find "obvious" year
166	11	cur_yr = time.localtime(time.time())[0]
167	11	m = cur_yr % 100
168	11	tmp = yr
169	11	yr = yr + cur_yr - m
170	11	m = m - tmp
171	11	if abs(m) > 50:
172	10	if m > 0: yr = yr + 100
173	10	else: yr = yr - 100
174	n/a
175	n/a	# convert UTC time tuple to seconds since epoch (not timezone-adjusted)
176	69	t = _timegm((yr, mon, day, hr, min, sec, tz))
177	n/a
178	69	if t is not None:
179	n/a	# adjust time using timezone string, to get absolute time since epoch
180	59	if tz is None:
181	21	tz = "UTC"
182	59	tz = tz.upper()
183	59	offset = offset_from_tz_string(tz)
184	59	if offset is None:
185	0	return None
186	59	t = t - offset
187	n/a
188	69	return t
189	n/a
190	1	STRICT_DATE_RE = re.compile(
191	1	r"^[SMTWF][a-z][a-z], (\d\d) ([JFMASOND][a-z][a-z]) "
192	n/a	"(\d\d\d\d) (\d\d):(\d\d):(\d\d) GMT$")
193	1	WEEKDAY_RE = re.compile(
194	1	r"^(?:Sun\|Mon\|Tue\|Wed\|Thu\|Fri\|Sat)[a-z],?\s", re.I)
195	1	LOOSE_HTTP_DATE_RE = re.compile(
196	n/a	r"""^
197	n/a	(\d\d?) # day
198	n/a	(?:\s+\|[-\/])
199	n/a	(\w+) # month
200	n/a	(?:\s+\|[-\/])
201	n/a	(\d+) # year
202	n/a	(?:
203	n/a	(?:\s+\|:) # separator before clock
204	n/a	(\d\d?):(\d\d) # hour:min
205	n/a	(?::(\d\d))? # optional seconds
206	n/a	)? # optional clock
207	n/a	\s*
208	n/a	([-+]?\d{2,4}\|(?![APap][Mm]\b)[A-Za-z]+)? # timezone
209	n/a	\s*
210	n/a	(?:$\w+$)? # ASCII representation of timezone in parens.
211	1	\s*$""", re.X)
212	1	def http2time(text):
213	n/a	"""Returns time in seconds since epoch of time represented by a string.
214	n/a
215	n/a	Return value is an integer.
216	n/a
217	n/a	None is returned if the format of str is unrecognized, the time is outside
218	n/a	the representable range, or the timezone string is not recognized. If the
219	n/a	string contains no timezone, UTC is assumed.
220	n/a
221	n/a	The timezone in the string may be numerical (like "-0800" or "+0100") or a
222	n/a	string timezone (like "UTC", "GMT", "BST" or "EST"). Currently, only the
223	n/a	timezone strings equivalent to UTC (zero offset) are known to the function.
224	n/a
225	n/a	The function loosely parses the following formats:
226	n/a
227	n/a	Wed, 09 Feb 1994 22:23:32 GMT -- HTTP format
228	n/a	Tuesday, 08-Feb-94 14:15:29 GMT -- old rfc850 HTTP format
229	n/a	Tuesday, 08-Feb-1994 14:15:29 GMT -- broken rfc850 HTTP format
230	n/a	09 Feb 1994 22:23:32 GMT -- HTTP format (no weekday)
231	n/a	08-Feb-94 14:15:29 GMT -- rfc850 format (no weekday)
232	n/a	08-Feb-1994 14:15:29 GMT -- broken rfc850 format (no weekday)
233	n/a
234	n/a	The parser ignores leading and trailing whitespace. The time may be
235	n/a	absent.
236	n/a
237	n/a	If the year is given with only 2 digits, the function will select the
238	n/a	century that makes the year closest to the current date.
239	n/a
240	n/a	"""
241	n/a	# fast exit for strictly conforming string
242	82	m = STRICT_DATE_RE.search(text)
243	82	if m:
244	1	g = m.groups()
245	1	mon = MONTHS_LOWER.index(g[1].lower()) + 1
246	1	tt = (int(g[2]), mon, int(g[0]),
247	1	int(g[3]), int(g[4]), float(g[5]))
248	1	return _timegm(tt)
249	n/a
250	n/a	# No, we need some messy parsing...
251	n/a
252	n/a	# clean up
253	81	text = text.lstrip()
254	81	text = WEEKDAY_RE.sub("", text, 1) # Useless weekday
255	n/a
256	n/a	# tz is time zone specifier string
257	81	day, mon, yr, hr, min, sec, tz = [None]*7
258	n/a
259	n/a	# loose regexp parse
260	81	m = LOOSE_HTTP_DATE_RE.search(text)
261	81	if m is not None:
262	71	day, mon, yr, hr, min, sec, tz = m.groups()
263	n/a	else:
264	10	return None # bad format
265	n/a
266	71	return _str2time(day, mon, yr, hr, min, sec, tz)
267	n/a
268	1	ISO_DATE_RE = re.compile(
269	n/a	"""^
270	n/a	(\d{4}) # year
271	n/a	[-\/]?
272	n/a	(\d\d?) # numerical month
273	n/a	[-\/]?
274	n/a	(\d\d?) # day
275	n/a	(?:
276	n/a	(?:\s+\|[-:Tt]) # separator before clock
277	n/a	(\d\d?):?(\d\d) # hour:min
278	n/a	(?::?(\d\d(?:\.\d*)?))? # optional seconds (and fractional)
279	n/a	)? # optional clock
280	n/a	\s*
281	n/a	([-+]?\d\d?:?(:?\d\d)?
282	n/a	\|Z\|z)? # timezone (Z is "zero meridian", i.e. GMT)
283	1	\s*$""", re.X)
284	1	def iso2time(text):
285	n/a	"""
286	n/a	As for http2time, but parses the ISO 8601 formats:
287	n/a
288	n/a	1994-02-03 14:15:29 -0100 -- ISO 8601 format
289	n/a	1994-02-03 14:15:29 -- zone is optional
290	n/a	1994-02-03 -- only date
291	n/a	1994-02-03T14:15:29 -- Use T as separator
292	n/a	19940203T141529Z -- ISO 8601 compact format
293	n/a	19940203 -- only date
294	n/a
295	n/a	"""
296	n/a	# clean up
297	2	text = text.lstrip()
298	n/a
299	n/a	# tz is time zone specifier string
300	2	day, mon, yr, hr, min, sec, tz = [None]*7
301	n/a
302	n/a	# loose regexp parse
303	2	m = ISO_DATE_RE.search(text)
304	2	if m is not None:
305	n/a	# XXX there's an extra bit of the timezone I'm ignoring here: is
306	n/a	# this the right thing to do?
307	2	yr, mon, day, hr, min, sec, tz, _ = m.groups()
308	n/a	else:
309	0	return None # bad format
310	n/a
311	2	return _str2time(day, mon, yr, hr, min, sec, tz)
312	n/a
313	n/a
314	n/a	# Header parsing
315	n/a	# -----------------------------------------------------------------------------
316	n/a
317	1	def unmatched(match):
318	n/a	"""Return unmatched part of re.Match object."""
319	490	start, end = match.span(0)
320	490	return match.string[:start]+match.string[end:]
321	n/a
322	1	HEADER_TOKEN_RE = re.compile(r"^\s*([^=\s;,]+)")
323	1	HEADER_QUOTED_VALUE_RE = re.compile(r"^\s=\s\"([^\"\\](?:\\.[^\"\\])*)\"")
324	1	HEADER_VALUE_RE = re.compile(r"^\s=\s([^\s;,]*)")
325	1	HEADER_ESCAPE_RE = re.compile(r"\\(.)")
326	1	def split_header_words(header_values):
327	n/a	r"""Parse header values into a list of lists containing key,value pairs.
328	n/a
329	n/a	The function knows how to deal with ",", ";" and "=" as well as quoted
330	n/a	values after "=". A list of space separated tokens are parsed as if they
331	n/a	were separated by ";".
332	n/a
333	n/a	If the header_values passed as argument contains multiple values, then they
334	n/a	are treated as if they were a single value separated by comma ",".
335	n/a
336	n/a	This means that this function is useful for parsing header fields that
337	n/a	follow this syntax (BNF as from the HTTP/1.1 specification, but we relax
338	n/a	the requirement for tokens).
339	n/a
340	n/a	headers = #header
341	n/a	header = (token \| parameter) *( [";"] (token \| parameter))
342	n/a
343	n/a	token = 1*<any CHAR except CTLs or separators>
344	n/a	separators = "(" \| ")" \| "<" \| ">" \| "@"
345	n/a	\| "," \| ";" \| ":" \| "\" \| <">
346	n/a	\| "/" \| "[" \| "]" \| "?" \| "="
347	n/a	\| "{" \| "}" \| SP \| HT
348	n/a
349	n/a	quoted-string = ( <"> *(qdtext \| quoted-pair ) <"> )
350	n/a	qdtext = <any TEXT except <">>
351	n/a	quoted-pair = "\" CHAR
352	n/a
353	n/a	parameter = attribute "=" value
354	n/a	attribute = token
355	n/a	value = token \| quoted-string
356	n/a
357	n/a	Each header is represented by a list of key/value pairs. The value for a
358	n/a	simple token (not part of a parameter) is None. Syntactically incorrect
359	n/a	headers will not necessarily be parsed as you would want.
360	n/a
361	n/a	This is easier to describe with some examples:
362	n/a
363	n/a	>>> split_header_words(['foo="bar"; port="80,81"; discard, bar=baz'])
364	n/a	[[('foo', 'bar'), ('port', '80,81'), ('discard', None)], [('bar', 'baz')]]
365	n/a	>>> split_header_words(['text/html; charset="iso-8859-1"'])
366	n/a	[[('text/html', None), ('charset', 'iso-8859-1')]]
367	n/a	>>> split_header_words([r'Basic realm="\"foo\bar\""'])
368	n/a	[[('Basic', None), ('realm', '"foobar"')]]
369	n/a
370	n/a	"""
371	159	assert not isinstance(header_values, basestring)
372	159	result = []
373	249	for text in header_values:
374	90	orig_text = text
375	90	pairs = []
376	532	while text:
377	442	m = HEADER_TOKEN_RE.search(text)
378	442	if m:
379	266	text = unmatched(m)
380	266	name = m.group(1)
381	266	m = HEADER_QUOTED_VALUE_RE.search(text)
382	266	if m: # quoted value
383	83	text = unmatched(m)
384	83	value = m.group(1)
385	83	value = HEADER_ESCAPE_RE.sub(r"\1", value)
386	n/a	else:
387	183	m = HEADER_VALUE_RE.search(text)
388	183	if m: # unquoted value
389	141	text = unmatched(m)
390	141	value = m.group(1)
391	141	value = value.rstrip()
392	n/a	else:
393	n/a	# no value, a lone token
394	42	value = None
395	266	pairs.append((name, value))
396	176	elif text.lstrip().startswith(","):
397	n/a	# concatenated headers, as per RFC 2616 section 4.2
398	10	text = text.lstrip()[1:]
399	10	if pairs: result.append(pairs)
400	10	pairs = []
401	n/a	else:
402	n/a	# skip junk
403	166	non_junk, nr_junk_chars = re.subn("^[=\s;]*", "", text)
404	166	assert nr_junk_chars > 0, (
405	0	"split_header_words bug: '%s', '%s', %s" %
406	0	(orig_text, text, pairs))
407	166	text = non_junk
408	90	if pairs: result.append(pairs)
409	159	return result
410	n/a
411	1	HEADER_JOIN_ESCAPE_RE = re.compile(r"([\"\\])")
412	1	def join_header_words(lists):
413	n/a	"""Do the inverse (almost) of the conversion done by split_header_words.
414	n/a
415	n/a	Takes a list of lists of (key, value) pairs and produces a single header
416	n/a	value. Attribute values are quoted if needed.
417	n/a
418	n/a	>>> join_header_words([[("text/plain", None), ("charset", "iso-8859/1")]])
419	n/a	'text/plain; charset="iso-8859/1"'
420	n/a	>>> join_header_words([[("text/plain", None)], [("charset", "iso-8859/1")]])
421	n/a	'text/plain, charset="iso-8859/1"'
422	n/a
423	n/a	"""
424	23	headers = []
425	49	for pairs in lists:
426	26	attr = []
427	104	for k, v in pairs:
428	78	if v is not None:
429	51	if not re.search(r"^\w+$", v):
430	26	v = HEADER_JOIN_ESCAPE_RE.sub(r"\\\1", v) # escape " and \
431	26	v = '"%s"' % v
432	51	k = "%s=%s" % (k, v)
433	78	attr.append(k)
434	26	if attr: headers.append("; ".join(attr))
435	23	return ", ".join(headers)
436	n/a
437	1	def _strip_quotes(text):
438	29	if text.startswith('"'):
439	4	text = text[1:]
440	29	if text.endswith('"'):
441	4	text = text[:-1]
442	29	return text
443	n/a
444	1	def parse_ns_headers(ns_headers):
445	n/a	"""Ad-hoc parser for Netscape protocol cookie-attributes.
446	n/a
447	n/a	The old Netscape cookie format for Set-Cookie can for instance contain
448	n/a	an unquoted "," in the expires field, so we have to use this ad-hoc
449	n/a	parser instead of split_header_words.
450	n/a
451	n/a	XXX This may not make the best possible effort to parse all the crap
452	n/a	that Netscape Cookie headers contain. Ronald Tschalar's HTTPClient
453	n/a	parser is probably better, so could do worse than following that if
454	n/a	this ever gives any trouble.
455	n/a
456	n/a	Currently, this is also used for parsing RFC 2109 cookies.
457	n/a
458	n/a	"""
459	0	known_attrs = ("expires", "domain", "path", "secure",
460	n/a	# RFC 2109 attrs (may turn up in Netscape cookies, too)
461	80	"version", "port", "max-age")
462	n/a
463	80	result = []
464	168	for ns_header in ns_headers:
465	88	pairs = []
466	88	version_set = False
467	259	for ii, param in enumerate(re.split(r";\s*", ns_header)):
468	171	param = param.rstrip()
469	171	if param == "": continue
470	169	if "=" not in param:
471	9	k, v = param, None
472	n/a	else:
473	160	k, v = re.split(r"\s=\s", param, 1)
474	160	k = k.lstrip()
475	169	if ii != 0:
476	83	lc = k.lower()
477	83	if lc in known_attrs:
478	81	k = lc
479	83	if k == "version":
480	n/a	# This is an RFC 2109 cookie.
481	9	v = _strip_quotes(v)
482	9	version_set = True
483	83	if k == "expires":
484	n/a	# convert expires date to seconds since epoch
485	20	v = http2time(_strip_quotes(v)) # None if invalid
486	169	pairs.append((k, v))
487	n/a
488	88	if pairs:
489	86	if not version_set:
490	77	pairs.append(("version", "0"))
491	86	result.append(pairs)
492	n/a
493	80	return result
494	n/a
495	n/a
496	1	IPV4_RE = re.compile(r"\.\d+$")
497	1	def is_HDN(text):
498	n/a	"""Return True if text is a host domain name."""
499	n/a	# XXX
500	n/a	# This may well be wrong. Which RFC is HDN defined in, if any (for
501	n/a	# the purposes of RFC 2965)?
502	n/a	# For the current implementation, what about IPv6? Remember to look
503	n/a	# at other uses of IPV4_RE also, if change this.
504	78	if IPV4_RE.search(text):
505	4	return False
506	74	if text == "":
507	2	return False
508	72	if text[0] == "." or text[-1] == ".":
509	8	return False
510	64	return True
511	n/a
512	1	def domain_match(A, B):
513	n/a	"""Return True if domain A domain-matches domain B, according to RFC 2965.
514	n/a
515	n/a	A and B may be host domain names or IP addresses.
516	n/a
517	n/a	RFC 2965, section 1:
518	n/a
519	n/a	Host names can be specified either as an IP address or a HDN string.
520	n/a	Sometimes we compare one host name with another. (Such comparisons SHALL
521	n/a	be case-insensitive.) Host A's name domain-matches host B's if
522	n/a
523	n/a	* their host name strings string-compare equal; or
524	n/a
525	n/a	* A is a HDN string and has the form NB, where N is a non-empty
526	n/a	name string, B has the form .B', and B' is a HDN string. (So,
527	n/a	x.y.com domain-matches .Y.com but not Y.com.)
528	n/a
529	n/a	Note that domain-match is not a commutative operation: a.b.c.com
530	n/a	domain-matches .c.com, but not the reverse.
531	n/a
532	n/a	"""
533	n/a	# Note that, if A or B are IP addresses, the only relevant part of the
534	n/a	# definition of the domain-match algorithm is the direct string-compare.
535	76	A = A.lower()
536	76	B = B.lower()
537	76	if A == B:
538	39	return True
539	37	if not is_HDN(A):
540	4	return False
541	33	i = A.rfind(B)
542	33	if i == -1 or i == 0:
543	n/a	# A does not have form NB, or N is the empty string
544	2	return False
545	31	if not B.startswith("."):
546	5	return False
547	26	if not is_HDN(B[1:]):
548	0	return False
549	26	return True
550	n/a
551	1	def liberal_is_HDN(text):
552	n/a	"""Return True if text is a sort-of-like a host domain name.
553	n/a
554	n/a	For accepting/blocking domains.
555	n/a
556	n/a	"""
557	62	if IPV4_RE.search(text):
558	4	return False
559	58	return True
560	n/a
561	1	def user_domain_match(A, B):
562	n/a	"""For blocking/accepting domains.
563	n/a
564	n/a	A and B may be host domain names or IP addresses.
565	n/a
566	n/a	"""
567	33	A = A.lower()
568	33	B = B.lower()
569	33	if not (liberal_is_HDN(A) and liberal_is_HDN(B)):
570	4	if A == B:
571	n/a	# equal IP addresses
572	1	return True
573	3	return False
574	29	initial_dot = B.startswith(".")
575	29	if initial_dot and A.endswith(B):
576	7	return True
577	22	if not initial_dot and A == B:
578	5	return True
579	17	return False
580	n/a
581	1	cut_port_re = re.compile(r":\d+$")
582	1	def request_host(request):
583	n/a	"""Return request-host, as defined by RFC 2965.
584	n/a
585	n/a	Variation from RFC: returned value is lowercased, for convenient
586	n/a	comparison.
587	n/a
588	n/a	"""
589	407	url = request.get_full_url()
590	407	host = urlparse.urlparse(url)[1]
591	407	if host == "":
592	1	host = request.get_header("Host", "")
593	n/a
594	n/a	# remove port, if present
595	407	host = cut_port_re.sub("", host, 1)
596	407	return host.lower()
597	n/a
598	1	def eff_request_host(request):
599	n/a	"""Return a tuple (request-host, effective request-host name).
600	n/a
601	n/a	As defined by RFC 2965, except both are lowercased.
602	n/a
603	n/a	"""
604	403	erhn = req_host = request_host(request)
605	403	if req_host.find(".") == -1 and not IPV4_RE.search(req_host):
606	27	erhn = req_host + ".local"
607	403	return req_host, erhn
608	n/a
609	1	def request_path(request):
610	n/a	"""request-URI, as defined by RFC 2965."""
611	245	url = request.get_full_url()
612	n/a	#scheme, netloc, path, parameters, query, frag = urlparse.urlparse(url)
613	n/a	#req_path = escape_path("".join(urlparse.urlparse(url)[2:]))
614	245	path, parameters, query, frag = urlparse.urlparse(url)[2:]
615	245	if parameters:
616	1	path = "%s;%s" % (path, parameters)
617	245	path = escape_path(path)
618	245	req_path = urlparse.urlunparse(("", "", path, "", query, frag))
619	245	if not req_path.startswith("/"):
620	n/a	# fix bad RFC 2396 absoluteURI
621	21	req_path = "/"+req_path
622	245	return req_path
623	n/a
624	1	def request_port(request):
625	30	host = request.get_host()
626	30	i = host.find(':')
627	30	if i >= 0:
628	7	port = host[i+1:]
629	7	try:
630	7	int(port)
631	0	except ValueError:
632	0	_debug("nonnumeric port: '%s'", port)
633	0	return None
634	n/a	else:
635	23	port = DEFAULT_HTTP_PORT
636	30	return port
637	n/a
638	n/a	# Characters in addition to A-Z, a-z, 0-9, '_', '.', and '-' that don't
639	n/a	# need to be escaped to form a valid HTTP URL (RFCs 2396 and 1738).
640	1	HTTP_PATH_SAFE = "%/;:@&=+$,!~*'()"
641	1	ESCAPED_CHAR_RE = re.compile(r"%([0-9a-fA-F][0-9a-fA-F])")
642	1	def uppercase_escaped_char(match):
643	48	return "%%%s" % match.group(1).upper()
644	1	def escape_path(path):
645	n/a	"""Escape any invalid characters in HTTP URL, and uppercase all escapes."""
646	n/a	# There's no knowing what character encoding was used to create URLs
647	n/a	# containing %-escapes, but since we have to pick one to escape invalid
648	n/a	# path characters, we pick UTF-8, as recommended in the HTML 4.0
649	n/a	# specification:
650	n/a	# http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.2.1
651	n/a	# And here, kind of: draft-fielding-uri-rfc2396bis-03
652	n/a	# (And in draft IRI specification: draft-duerst-iri-05)
653	n/a	# (And here, for new URI schemes: RFC 2718)
654	292	if isinstance(path, unicode):
655	2	path = path.encode("utf-8")
656	292	path = urllib.quote(path, HTTP_PATH_SAFE)
657	292	path = ESCAPED_CHAR_RE.sub(uppercase_escaped_char, path)
658	292	return path
659	n/a
660	1	def reach(h):
661	n/a	"""Return reach of host h, as defined by RFC 2965, section 1.
662	n/a
663	n/a	The reach R of a host name H is defined as follows:
664	n/a
665	n/a	* If
666	n/a
667	n/a	- H is the host domain name of a host; and,
668	n/a
669	n/a	- H has the form A.B; and
670	n/a
671	n/a	- A has no embedded (that is, interior) dots; and
672	n/a
673	n/a	- B has at least one embedded dot, or B is the string "local".
674	n/a	then the reach of H is .B.
675	n/a
676	n/a	* Otherwise, the reach of H is H.
677	n/a
678	n/a	>>> reach("www.acme.com")
679	n/a	'.acme.com'
680	n/a	>>> reach("acme.com")
681	n/a	'acme.com'
682	n/a	>>> reach("acme.local")
683	n/a	'.local'
684	n/a
685	n/a	"""
686	8	i = h.find(".")
687	8	if i >= 0:
688	n/a	#a = h[:i] # this line is only here to show what a is
689	7	b = h[i+1:]
690	7	i = b.find(".")
691	7	if is_HDN(h) and (i >= 0 or b == "local"):
692	2	return "."+b
693	6	return h
694	n/a
695	1	def is_third_party(request):
696	n/a	"""
697	n/a
698	n/a	RFC 2965, section 3.3.6:
699	n/a
700	n/a	An unverifiable transaction is to a third-party host if its request-
701	n/a	host U does not domain-match the reach R of the request-host O in the
702	n/a	origin transaction.
703	n/a
704	n/a	"""
705	0	req_host = request_host(request)
706	0	if not domain_match(req_host, reach(request.get_origin_req_host())):
707	0	return True
708	n/a	else:
709	0	return False
710	n/a
711	n/a
712	2	class Cookie:
713	n/a	"""HTTP Cookie.
714	n/a
715	n/a	This class represents both Netscape and RFC 2965 cookies.
716	n/a
717	n/a	This is deliberately a very simple class. It just holds attributes. It's
718	n/a	possible to construct Cookie instances that don't comply with the cookie
719	n/a	standards. CookieJar.make_cookies is the factory function for Cookie
720	n/a	objects -- it deals with cookie parsing, supplying defaults, and
721	n/a	normalising to the representation used in this class. CookiePolicy is
722	n/a	responsible for checking them to see whether they should be accepted from
723	n/a	and returned to the server.
724	n/a
725	n/a	Note that the port may be present in the headers, but unspecified ("Port"
726	n/a	rather than"Port=80", for example); if this is the case, port is None.
727	n/a
728	1	"""
729	n/a
730	n/a	def __init__(self, version, name, value,
731	n/a	port, port_specified,
732	n/a	domain, domain_specified, domain_initial_dot,
733	n/a	path, path_specified,
734	n/a	secure,
735	n/a	expires,
736	n/a	discard,
737	n/a	comment,
738	n/a	comment_url,
739	n/a	rest,
740	1	rfc2109=False,
741	n/a	):
742	n/a
743	149	if version is not None: version = int(version)
744	149	if expires is not None: expires = int(expires)
745	149	if port is None and port_specified is True:
746	0	raise ValueError("if port is None, port_specified must be false")
747	n/a
748	149	self.version = version
749	149	self.name = name
750	149	self.value = value
751	149	self.port = port
752	149	self.port_specified = port_specified
753	n/a	# normalise case, as per RFC 2965 section 3.3.3
754	149	self.domain = domain.lower()
755	149	self.domain_specified = domain_specified
756	n/a	# Sigh. We need to know whether the domain given in the
757	n/a	# cookie-attribute had an initial dot, in order to follow RFC 2965
758	n/a	# (as clarified in draft errata). Needed for the returned $Domain
759	n/a	# value.
760	149	self.domain_initial_dot = domain_initial_dot
761	149	self.path = path
762	149	self.path_specified = path_specified
763	149	self.secure = secure
764	149	self.expires = expires
765	149	self.discard = discard
766	149	self.comment = comment
767	149	self.comment_url = comment_url
768	149	self.rfc2109 = rfc2109
769	n/a
770	149	self._rest = copy.copy(rest)
771	n/a
772	1	def has_nonstandard_attr(self, name):
773	2	return name in self._rest
774	1	def get_nonstandard_attr(self, name, default=None):
775	0	return self._rest.get(name, default)
776	1	def set_nonstandard_attr(self, name, value):
777	0	self._rest[name] = value
778	n/a
779	1	def is_expired(self, now=None):
780	325	if now is None: now = time.time()
781	325	if (self.expires is not None) and (self.expires <= now):
782	0	return True
783	325	return False
784	n/a
785	1	def __str__(self):
786	0	if self.port is None: p = ""
787	0	else: p = ":"+self.port
788	0	limit = self.domain + p + self.path
789	0	if self.value is not None:
790	0	namevalue = "%s=%s" % (self.name, self.value)
791	n/a	else:
792	0	namevalue = self.name
793	0	return "<Cookie %s for %s>" % (namevalue, limit)
794	n/a
795	1	def __repr__(self):
796	26	args = []
797	26	for name in ("version", "name", "value",
798	0	"port", "port_specified",
799	0	"domain", "domain_specified", "domain_initial_dot",
800	0	"path", "path_specified",
801	416	"secure", "expires", "discard", "comment", "comment_url",
802	n/a	):
803	390	attr = getattr(self, name)
804	390	args.append("%s=%s" % (name, repr(attr)))
805	26	args.append("rest=%s" % repr(self._rest))
806	26	args.append("rfc2109=%s" % repr(self.rfc2109))
807	26	return "Cookie(%s)" % ", ".join(args)
808	n/a
809	n/a
810	2	class CookiePolicy:
811	n/a	"""Defines which cookies get accepted from and returned to server.
812	n/a
813	n/a	May also modify cookies, though this is probably a bad idea.
814	n/a
815	n/a	The subclass DefaultCookiePolicy defines the standard rules for Netscape
816	n/a	and RFC 2965 cookies -- override that if you want a customised policy.
817	n/a
818	1	"""
819	1	def set_ok(self, cookie, request):
820	n/a	"""Return true if (and only if) cookie should be accepted from server.
821	n/a
822	n/a	Currently, pre-expired cookies never get this far -- the CookieJar
823	n/a	class deletes such cookies itself.
824	n/a
825	n/a	"""
826	0	raise NotImplementedError()
827	n/a
828	1	def return_ok(self, cookie, request):
829	n/a	"""Return true if (and only if) cookie should be returned to server."""
830	0	raise NotImplementedError()
831	n/a
832	1	def domain_return_ok(self, domain, request):
833	n/a	"""Return false if cookies should not be returned, given cookie domain.
834	n/a	"""
835	0	return True
836	n/a
837	1	def path_return_ok(self, path, request):
838	n/a	"""Return false if cookies should not be returned, given cookie path.
839	n/a	"""
840	0	return True
841	n/a
842	n/a
843	2	class DefaultCookiePolicy(CookiePolicy):
844	1	"""Implements the standard rules for accepting and returning cookies."""
845	n/a
846	1	DomainStrictNoDots = 1
847	1	DomainStrictNonDomain = 2
848	1	DomainRFC2965Match = 4
849	n/a
850	1	DomainLiberal = 0
851	1	DomainStrict = DomainStrictNoDots\|DomainStrictNonDomain
852	n/a
853	n/a	def __init__(self,
854	1	blocked_domains=None, allowed_domains=None,
855	1	netscape=True, rfc2965=False,
856	1	rfc2109_as_netscape=None,
857	1	hide_cookie2=False,
858	1	strict_domain=False,
859	1	strict_rfc2965_unverifiable=True,
860	1	strict_ns_unverifiable=False,
861	1	strict_ns_domain=DomainLiberal,
862	1	strict_ns_set_initial_dollar=False,
863	1	strict_ns_set_path=False,
864	n/a	):
865	n/a	"""Constructor arguments should be passed as keyword arguments only."""
866	68	self.netscape = netscape
867	68	self.rfc2965 = rfc2965
868	68	self.rfc2109_as_netscape = rfc2109_as_netscape
869	68	self.hide_cookie2 = hide_cookie2
870	68	self.strict_domain = strict_domain
871	68	self.strict_rfc2965_unverifiable = strict_rfc2965_unverifiable
872	68	self.strict_ns_unverifiable = strict_ns_unverifiable
873	68	self.strict_ns_domain = strict_ns_domain
874	68	self.strict_ns_set_initial_dollar = strict_ns_set_initial_dollar
875	68	self.strict_ns_set_path = strict_ns_set_path
876	n/a
877	68	if blocked_domains is not None:
878	2	self._blocked_domains = tuple(blocked_domains)
879	n/a	else:
880	66	self._blocked_domains = ()
881	n/a
882	68	if allowed_domains is not None:
883	1	allowed_domains = tuple(allowed_domains)
884	68	self._allowed_domains = allowed_domains
885	n/a
886	1	def blocked_domains(self):
887	n/a	"""Return the sequence of blocked domains (as a tuple)."""
888	0	return self._blocked_domains
889	1	def set_blocked_domains(self, blocked_domains):
890	n/a	"""Set the sequence of blocked domains."""
891	2	self._blocked_domains = tuple(blocked_domains)
892	n/a
893	1	def is_blocked(self, domain):
894	245	for blocked_domain in self._blocked_domains:
895	10	if user_domain_match(domain, blocked_domain):
896	3	return True
897	235	return False
898	n/a
899	1	def allowed_domains(self):
900	n/a	"""Return None, or the sequence of allowed domains (as a tuple)."""
901	0	return self._allowed_domains
902	1	def set_allowed_domains(self, allowed_domains):
903	n/a	"""Set the sequence of allowed domains, or None."""
904	0	if allowed_domains is not None:
905	0	allowed_domains = tuple(allowed_domains)
906	0	self._allowed_domains = allowed_domains
907	n/a
908	1	def is_not_allowed(self, domain):
909	235	if self._allowed_domains is None:
910	232	return False
911	5	for allowed_domain in self._allowed_domains:
912	3	if user_domain_match(domain, allowed_domain):
913	1	return False
914	2	return True
915	n/a
916	1	def set_ok(self, cookie, request):
917	n/a	"""
918	n/a	If you override .set_ok(), be sure to call this method. If it returns
919	n/a	false, so should your subclass (assuming your subclass wants to be more
920	n/a	strict about which cookies to accept).
921	n/a
922	n/a	"""
923	128	_debug(" - checking cookie %s=%s", cookie.name, cookie.value)
924	n/a
925	128	assert cookie.name is not None
926	n/a
927	851	for n in "version", "verifiability", "name", "path", "domain", "port":
928	741	fn_name = "set_ok_"+n
929	741	fn = getattr(self, fn_name)
930	741	if not fn(cookie, request):
931	18	return False
932	n/a
933	110	return True
934	n/a
935	1	def set_ok_version(self, cookie, request):
936	128	if cookie.version is None:
937	n/a	# Version is always set to 0 by parse_ns_headers if it's a Netscape
938	n/a	# cookie, so this must be an invalid RFC 2965 cookie.
939	0	_debug(" Set-Cookie2 without version attribute (%s=%s)",
940	0	cookie.name, cookie.value)
941	0	return False
942	128	if cookie.version > 0 and not self.rfc2965:
943	2	_debug(" RFC 2965 cookies are switched off")
944	2	return False
945	126	elif cookie.version == 0 and not self.netscape:
946	0	_debug(" Netscape cookies are switched off")
947	0	return False
948	126	return True
949	n/a
950	1	def set_ok_verifiability(self, cookie, request):
951	126	if request.is_unverifiable() and is_third_party(request):
952	0	if cookie.version > 0 and self.strict_rfc2965_unverifiable:
953	0	_debug(" third-party RFC 2965 cookie during "
954	n/a	"unverifiable transaction")
955	0	return False
956	0	elif cookie.version == 0 and self.strict_ns_unverifiable:
957	0	_debug(" third-party Netscape cookie during "
958	n/a	"unverifiable transaction")
959	0	return False
960	126	return True
961	n/a
962	1	def set_ok_name(self, cookie, request):
963	n/a	# Try and stop servers setting V0 cookies designed to hack other
964	n/a	# servers that know both V0 and V1 protocols.
965	126	if (cookie.version == 0 and self.strict_ns_set_initial_dollar and
966	0	cookie.name.startswith("$")):
967	0	_debug(" illegal name (starts with '$'): '%s'", cookie.name)
968	0	return False
969	126	return True
970	n/a
971	1	def set_ok_path(self, cookie, request):
972	126	if cookie.path_specified:
973	33	req_path = request_path(request)
974	33	if ((cookie.version > 0 or
975	21	(cookie.version == 0 and self.strict_ns_set_path)) and
976	12	not req_path.startswith(cookie.path)):
977	2	_debug(" path attribute %s is not a prefix of request "
978	2	"path %s", cookie.path, req_path)
979	2	return False
980	124	return True
981	n/a
982	1	def set_ok_domain(self, cookie, request):
983	124	if self.is_blocked(cookie.domain):
984	2	_debug(" domain %s is in user block-list", cookie.domain)
985	2	return False
986	122	if self.is_not_allowed(cookie.domain):
987	1	_debug(" domain %s is not in user allow-list", cookie.domain)
988	1	return False
989	121	if cookie.domain_specified:
990	35	req_host, erhn = eff_request_host(request)
991	35	domain = cookie.domain
992	35	if self.strict_domain and (domain.count(".") >= 2):
993	n/a	# XXX This should probably be compared with the Konqueror
994	n/a	# (kcookiejar.cpp) and Mozilla implementations, but it's a
995	n/a	# losing battle.
996	5	i = domain.rfind(".")
997	5	j = domain.rfind(".", 0, i)
998	5	if j == 0: # domain like .foo.bar
999	4	tld = domain[i+1:]
1000	4	sld = domain[j+1:i]
1001	4	if sld.lower() in ("co", "ac", "com", "edu", "org", "net",
1002	0	"gov", "mil", "int", "aero", "biz", "cat", "coop",
1003	0	"info", "jobs", "mobi", "museum", "name", "pro",
1004	4	"travel", "eu") and len(tld) == 2:
1005	n/a	# domain like .co.uk
1006	4	_debug(" country-code second level domain %s", domain)
1007	4	return False
1008	31	if domain.startswith("."):
1009	31	undotted_domain = domain[1:]
1010	n/a	else:
1011	0	undotted_domain = domain
1012	31	embedded_dots = (undotted_domain.find(".") >= 0)
1013	31	if not embedded_dots and domain != ".local":
1014	3	_debug(" non-local domain %s contains no embedded dot",
1015	3	domain)
1016	3	return False
1017	28	if cookie.version == 0:
1018	13	if (not erhn.endswith(domain) and
1019	5	(not erhn.startswith(".") and
1020	5	not ("."+erhn).endswith(domain))):
1021	0	_debug(" effective request-host %s (even with added "
1022	n/a	"initial dot) does not end end with %s",
1023	0	erhn, domain)
1024	0	return False
1025	28	if (cookie.version > 0 or
1026	13	(self.strict_ns_domain & self.DomainRFC2965Match)):
1027	15	if not domain_match(erhn, domain):
1028	2	_debug(" effective request-host %s does not domain-match "
1029	2	"%s", erhn, domain)
1030	2	return False
1031	26	if (cookie.version > 0 or
1032	13	(self.strict_ns_domain & self.DomainStrictNoDots)):
1033	13	host_prefix = req_host[:-len(domain)]
1034	13	if (host_prefix.find(".") >= 0 and
1035	1	not IPV4_RE.search(req_host)):
1036	1	_debug(" host prefix %s for domain %s contains a dot",
1037	1	host_prefix, domain)
1038	1	return False
1039	111	return True
1040	n/a
1041	1	def set_ok_port(self, cookie, request):
1042	111	if cookie.port_specified:
1043	7	req_port = request_port(request)
1044	7	if req_port is None:
1045	0	req_port = "80"
1046	n/a	else:
1047	7	req_port = str(req_port)
1048	13	for p in cookie.port.split(","):
1049	12	try:
1050	12	int(p)
1051	0	except ValueError:
1052	0	_debug(" bad port %s (not numeric)", p)
1053	0	return False
1054	12	if p == req_port:
1055	6	break
1056	n/a	else:
1057	1	_debug(" request port (%s) not found in %s",
1058	1	req_port, cookie.port)
1059	1	return False
1060	110	return True
1061	n/a
1062	1	def return_ok(self, cookie, request):
1063	n/a	"""
1064	n/a	If you override .return_ok(), be sure to call this method. If it
1065	n/a	returns false, so should your subclass (assuming your subclass wants to
1066	n/a	be more strict about which cookies to return).
1067	n/a
1068	n/a	"""
1069	n/a	# Path has already been checked by .path_return_ok(), and domain
1070	n/a	# blocking done by .domain_return_ok().
1071	117	_debug(" - checking cookie %s=%s", cookie.name, cookie.value)
1072	n/a
1073	802	for n in "version", "verifiability", "secure", "expires", "port", "domain":
1074	693	fn_name = "return_ok_"+n
1075	693	fn = getattr(self, fn_name)
1076	693	if not fn(cookie, request):
1077	8	return False
1078	109	return True
1079	n/a
1080	1	def return_ok_version(self, cookie, request):
1081	117	if cookie.version > 0 and not self.rfc2965:
1082	0	_debug(" RFC 2965 cookies are switched off")
1083	0	return False
1084	117	elif cookie.version == 0 and not self.netscape:
1085	0	_debug(" Netscape cookies are switched off")
1086	0	return False
1087	117	return True
1088	n/a
1089	1	def return_ok_verifiability(self, cookie, request):
1090	117	if request.is_unverifiable() and is_third_party(request):
1091	0	if cookie.version > 0 and self.strict_rfc2965_unverifiable:
1092	0	_debug(" third-party RFC 2965 cookie during unverifiable "
1093	n/a	"transaction")
1094	0	return False
1095	0	elif cookie.version == 0 and self.strict_ns_unverifiable:
1096	0	_debug(" third-party Netscape cookie during unverifiable "
1097	n/a	"transaction")
1098	0	return False
1099	117	return True
1100	n/a
1101	1	def return_ok_secure(self, cookie, request):
1102	117	if cookie.secure and request.get_type() != "https":
1103	3	_debug(" secure cookie with non-secure request")
1104	3	return False
1105	114	return True
1106	n/a
1107	1	def return_ok_expires(self, cookie, request):
1108	114	if cookie.is_expired(self._now):
1109	0	_debug(" cookie expired")
1110	0	return False
1111	114	return True
1112	n/a
1113	1	def return_ok_port(self, cookie, request):
1114	114	if cookie.port:
1115	17	req_port = request_port(request)
1116	17	if req_port is None:
1117	0	req_port = "80"
1118	21	for p in cookie.port.split(","):
1119	21	if p == req_port:
1120	17	break
1121	n/a	else:
1122	0	_debug(" request port %s does not match cookie port %s",
1123	0	req_port, cookie.port)
1124	0	return False
1125	114	return True
1126	n/a
1127	1	def return_ok_domain(self, cookie, request):
1128	114	req_host, erhn = eff_request_host(request)
1129	114	domain = cookie.domain
1130	n/a
1131	n/a	# strict check of non-domain cookies: Mozilla does this, MSIE5 doesn't
1132	114	if (cookie.version == 0 and
1133	64	(self.strict_ns_domain & self.DomainStrictNonDomain) and
1134	8	not cookie.domain_specified and domain != erhn):
1135	1	_debug(" cookie with unspecified domain does not string-compare "
1136	n/a	"equal to request domain")
1137	1	return False
1138	n/a
1139	113	if cookie.version > 0 and not domain_match(erhn, domain):
1140	4	_debug(" effective request-host name %s does not domain-match "
1141	4	"RFC 2965 cookie domain %s", erhn, domain)
1142	4	return False
1143	109	if cookie.version == 0 and not ("."+erhn).endswith(domain):
1144	0	_debug(" request-host %s does not match Netscape cookie domain "
1145	0	"%s", req_host, domain)
1146	0	return False
1147	109	return True
1148	n/a
1149	1	def domain_return_ok(self, domain, request):
1150	n/a	# Liberal check of. This is here as an optimization to avoid
1151	n/a	# having to load lots of MSIE cookie files unless necessary.
1152	157	req_host, erhn = eff_request_host(request)
1153	157	if not req_host.startswith("."):
1154	157	req_host = "."+req_host
1155	157	if not erhn.startswith("."):
1156	157	erhn = "."+erhn
1157	157	if not (req_host.endswith(domain) or erhn.endswith(domain)):
1158	n/a	#_debug(" request domain %s does not match cookie domain %s",
1159	n/a	# req_host, domain)
1160	43	return False
1161	n/a
1162	114	if self.is_blocked(domain):
1163	1	_debug(" domain %s is in user block-list", domain)
1164	1	return False
1165	113	if self.is_not_allowed(domain):
1166	1	_debug(" domain %s is not in user allow-list", domain)
1167	1	return False
1168	n/a
1169	112	return True
1170	n/a
1171	1	def path_return_ok(self, path, request):
1172	112	_debug("- checking cookie path=%s", path)
1173	112	req_path = request_path(request)
1174	112	if not req_path.startswith(path):
1175	11	_debug(" %s does not path-match %s", req_path, path)
1176	11	return False
1177	101	return True
1178	n/a
1179	n/a
1180	1	def vals_sorted_by_key(adict):
1181	815	keys = adict.keys()
1182	815	keys.sort()
1183	815	return map(adict.get, keys)
1184	n/a
1185	1	def deepvalues(mapping):
1186	n/a	"""Iterates over nested mapping, depth-first, in sorted order by key."""
1187	815	values = vals_sorted_by_key(mapping)
1188	1758	for obj in values:
1189	943	mapping = False
1190	943	try:
1191	943	obj.items
1192	351	except AttributeError:
1193	351	pass
1194	n/a	else:
1195	592	mapping = True
1196	1294	for subobj in deepvalues(obj):
1197	702	yield subobj
1198	943	if not mapping:
1199	351	yield obj
1200	n/a
1201	n/a
1202	n/a	# Used as second parameter to dict.get() method, to distinguish absent
1203	n/a	# dict key from one with a None value.
1204	2	class Absent: pass
1205	n/a
1206	2	class CookieJar:
1207	n/a	"""Collection of HTTP cookies.
1208	n/a
1209	n/a	You may not need to know about this class: try
1210	n/a	urllib2.build_opener(HTTPCookieProcessor).open(url).
1211	n/a
1212	1	"""
1213	n/a
1214	1	non_word_re = re.compile(r"\W")
1215	1	quote_re = re.compile(r"([\"\\])")
1216	1	strict_domain_re = re.compile(r"\.?[^.]*")
1217	1	domain_re = re.compile(r"[^.]*")
1218	1	dots_re = re.compile(r"^\.+")
1219	n/a
1220	1	magic_re = r"^\#LWP-Cookies-(\d+\.\d+)"
1221	n/a
1222	1	def __init__(self, policy=None):
1223	70	if policy is None:
1224	33	policy = DefaultCookiePolicy()
1225	70	self._policy = policy
1226	n/a
1227	70	self._cookies_lock = _threading.RLock()
1228	70	self._cookies = {}
1229	n/a
1230	1	def set_policy(self, policy):
1231	5	self._policy = policy
1232	n/a
1233	1	def _cookies_for_domain(self, domain, request):
1234	141	cookies = []
1235	141	if not self._policy.domain_return_ok(domain, request):
1236	40	return []
1237	101	_debug("Checking %s for cookies to return", domain)
1238	101	cookies_by_path = self._cookies[domain]
1239	213	for path in cookies_by_path.keys():
1240	112	if not self._policy.path_return_ok(path, request):
1241	11	continue
1242	101	cookies_by_name = cookies_by_path[path]
1243	218	for cookie in cookies_by_name.values():
1244	117	if not self._policy.return_ok(cookie, request):
1245	8	_debug(" not returning cookie")
1246	8	continue
1247	109	_debug(" it's a match")
1248	109	cookies.append(cookie)
1249	101	return cookies
1250	n/a
1251	1	def _cookies_for_request(self, request):
1252	n/a	"""Return a list of cookies to be returned to server."""
1253	152	cookies = []
1254	293	for domain in self._cookies.keys():
1255	141	cookies.extend(self._cookies_for_domain(domain, request))
1256	152	return cookies
1257	n/a
1258	1	def _cookie_attrs(self, cookies):
1259	n/a	"""Return a list of cookie-attributes to be returned to server.
1260	n/a
1261	n/a	like ['foo="bar"; $Path="/"', ...]
1262	n/a
1263	n/a	The $Version attribute is also added when appropriate (currently only
1264	n/a	once per request).
1265	n/a
1266	n/a	"""
1267	n/a	# add cookies in order of most specific (ie. longest) path first
1268	261	cookies.sort(key=lambda arg: len(arg.path), reverse=True)
1269	n/a
1270	152	version_set = False
1271	n/a
1272	152	attrs = []
1273	261	for cookie in cookies:
1274	n/a	# set version of Cookie header
1275	n/a	# XXX
1276	n/a	# What should it be if multiple matching Set-Cookie headers have
1277	n/a	# different versions themselves?
1278	n/a	# Answer: there is no answer; was supposed to be settled by
1279	n/a	# RFC 2965 errata, but that may never appear...
1280	109	version = cookie.version
1281	109	if not version_set:
1282	78	version_set = True
1283	78	if version > 0:
1284	37	attrs.append("$Version=%s" % version)
1285	n/a
1286	n/a	# quote cookie value if necessary
1287	n/a	# (not for Netscape protocol, which already has any quotes
1288	n/a	# intact, due to the poorly-specified Netscape Cookie: syntax)
1289	109	if ((cookie.value is not None) and
1290	106	self.non_word_re.search(cookie.value) and version > 0):
1291	1	value = self.quote_re.sub(r"\\\1", cookie.value)
1292	n/a	else:
1293	108	value = cookie.value
1294	n/a
1295	n/a	# add cookie-attributes to be returned in Cookie header
1296	109	if cookie.value is None:
1297	3	attrs.append(cookie.name)
1298	n/a	else:
1299	106	attrs.append("%s=%s" % (cookie.name, value))
1300	109	if version > 0:
1301	46	if cookie.path_specified:
1302	10	attrs.append('$Path="%s"' % cookie.path)
1303	46	if cookie.domain.startswith("."):
1304	10	domain = cookie.domain
1305	10	if (not cookie.domain_initial_dot and
1306	4	domain.startswith(".")):
1307	4	domain = domain[1:]
1308	10	attrs.append('$Domain="%s"' % domain)
1309	46	if cookie.port is not None:
1310	10	p = "$Port"
1311	10	if cookie.port_specified:
1312	5	p = p + ('="%s"' % cookie.port)
1313	10	attrs.append(p)
1314	n/a
1315	152	return attrs
1316	n/a
1317	1	def add_cookie_header(self, request):
1318	n/a	"""Add correct Cookie: header to request (urllib2.Request object).
1319	n/a
1320	n/a	The Cookie2 header is also added unless policy.hide_cookie2 is true.
1321	n/a
1322	n/a	"""
1323	152	_debug("add_cookie_header")
1324	152	self._cookies_lock.acquire()
1325	152	try:
1326	n/a
1327	152	self._policy._now = self._now = int(time.time())
1328	n/a
1329	152	cookies = self._cookies_for_request(request)
1330	n/a
1331	152	attrs = self._cookie_attrs(cookies)
1332	152	if attrs:
1333	78	if not request.has_header("Cookie"):
1334	78	request.add_unredirected_header(
1335	78	"Cookie", "; ".join(attrs))
1336	n/a
1337	n/a	# if necessary, advertise that we know RFC 2965
1338	152	if (self._policy.rfc2965 and not self._policy.hide_cookie2 and
1339	93	not request.has_header("Cookie2")):
1340	139	for cookie in cookies:
1341	56	if cookie.version != 1:
1342	10	request.add_unredirected_header("Cookie2", '$Version="1"')
1343	10	break
1344	n/a
1345	n/a	finally:
1346	152	self._cookies_lock.release()
1347	n/a
1348	152	self.clear_expired_cookies()
1349	n/a
1350	1	def _normalized_cookie_tuples(self, attrs_set):
1351	n/a	"""Return list of tuples containing normalised cookie information.
1352	n/a
1353	n/a	attrs_set is the list of lists of key,value pairs extracted from
1354	n/a	the Set-Cookie or Set-Cookie2 headers.
1355	n/a
1356	n/a	Tuples are name, value, standard, rest, where name and value are the
1357	n/a	cookie name and value, standard is a dictionary containing the standard
1358	n/a	cookie-attributes (discard, secure, version, expires or max-age,
1359	n/a	domain, path and port) and rest is a dictionary containing the rest of
1360	n/a	the cookie-attributes.
1361	n/a
1362	n/a	"""
1363	197	cookie_tuples = []
1364	n/a
1365	197	boolean_attrs = "discard", "secure"
1366	0	value_attrs = ("version",
1367	0	"expires", "max-age",
1368	0	"domain", "path", "port",
1369	197	"comment", "commenturl")
1370	n/a
1371	332	for cookie_attrs in attrs_set:
1372	135	name, value = cookie_attrs[0]
1373	n/a
1374	n/a	# Build dictionary of standard cookie-attributes (standard) and
1375	n/a	# dictionary of other cookie-attributes (rest).
1376	n/a
1377	n/a	# Note: expiry time is normalised to seconds since epoch. V0
1378	n/a	# cookies should have the Expires cookie-attribute, and V1 cookies
1379	n/a	# should have Max-Age, but since V1 includes RFC 2109 cookies (and
1380	n/a	# since V0 cookies may be a mish-mash of Netscape and RFC 2109), we
1381	n/a	# accept either (but prefer Max-Age).
1382	135	max_age_set = False
1383	n/a
1384	135	bad_cookie = False
1385	n/a
1386	135	standard = {}
1387	135	rest = {}
1388	395	for k, v in cookie_attrs[1:]:
1389	261	lc = k.lower()
1390	n/a	# don't lose case distinction for unknown fields
1391	261	if lc in value_attrs or lc in boolean_attrs:
1392	259	k = lc
1393	261	if k in boolean_attrs and v is None:
1394	n/a	# boolean cookie-attribute is present, but has no value
1395	n/a	# (like "discard", rather than "port=80")
1396	10	v = True
1397	261	if k in standard:
1398	n/a	# only first value is significant
1399	1	continue
1400	260	if k == "domain":
1401	36	if v is None:
1402	0	_debug(" missing value for domain attribute")
1403	0	bad_cookie = True
1404	0	break
1405	n/a	# RFC 2965 section 3.3.3
1406	36	v = v.lower()
1407	260	if k == "expires":
1408	16	if max_age_set:
1409	n/a	# Prefer max-age to expires (like Mozilla)
1410	0	continue
1411	16	if v is None:
1412	3	_debug(" missing or invalid value for expires "
1413	n/a	"attribute: treating as session cookie")
1414	3	continue
1415	257	if k == "max-age":
1416	8	max_age_set = True
1417	8	try:
1418	8	v = int(v)
1419	1	except ValueError:
1420	1	_debug(" missing or invalid (non-numeric) value for "
1421	n/a	"max-age attribute")
1422	1	bad_cookie = True
1423	1	break
1424	n/a	# convert RFC 2965 Max-Age to seconds since epoch
1425	n/a	# XXX Strictly you're supposed to follow RFC 2616
1426	n/a	# age-calculation rules. Remember that zero Max-Age is a
1427	n/a	# is a request to discard (old and new) cookie, though.
1428	7	k = "expires"
1429	7	v = self._now + v
1430	256	if (k in value_attrs) or (k in boolean_attrs):
1431	254	if (v is None and
1432	4	k not in ("port", "comment", "commenturl")):
1433	0	_debug(" missing value for %s attribute" % k)
1434	0	bad_cookie = True
1435	0	break
1436	254	standard[k] = v
1437	n/a	else:
1438	2	rest[k] = v
1439	n/a
1440	135	if bad_cookie:
1441	1	continue
1442	n/a
1443	134	cookie_tuples.append((name, value, standard, rest))
1444	n/a
1445	197	return cookie_tuples
1446	n/a
1447	1	def _cookie_from_cookie_tuple(self, tup, request):
1448	n/a	# standard is dict of standard cookie-attributes, rest is dict of the
1449	n/a	# rest of them
1450	134	name, value, standard, rest = tup
1451	n/a
1452	134	domain = standard.get("domain", Absent)
1453	134	path = standard.get("path", Absent)
1454	134	port = standard.get("port", Absent)
1455	134	expires = standard.get("expires", Absent)
1456	n/a
1457	n/a	# set the easy defaults
1458	134	version = standard.get("version", None)
1459	134	if version is not None:
1460	134	try:
1461	134	version = int(version)
1462	1	except ValueError:
1463	1	return None # invalid version, ignore cookie
1464	133	secure = standard.get("secure", False)
1465	n/a	# (discard is also set if expires is Absent)
1466	133	discard = standard.get("discard", False)
1467	133	comment = standard.get("comment", None)
1468	133	comment_url = standard.get("commenturl", None)
1469	n/a
1470	n/a	# set default path
1471	133	if path is not Absent and path != "":
1472	36	path_specified = True
1473	36	path = escape_path(path)
1474	n/a	else:
1475	97	path_specified = False
1476	97	path = request_path(request)
1477	97	i = path.rfind("/")
1478	97	if i != -1:
1479	97	if version == 0:
1480	n/a	# Netscape spec parts company from reality here
1481	47	path = path[:i]
1482	n/a	else:
1483	50	path = path[:i+1]
1484	97	if len(path) == 0: path = "/"
1485	n/a
1486	n/a	# set default domain
1487	133	domain_specified = domain is not Absent
1488	n/a	# but first we have to remember whether it starts with a dot
1489	133	domain_initial_dot = False
1490	133	if domain_specified:
1491	36	domain_initial_dot = bool(domain.startswith("."))
1492	133	if domain is Absent:
1493	97	req_host, erhn = eff_request_host(request)
1494	97	domain = erhn
1495	36	elif not domain.startswith("."):
1496	9	domain = "."+domain
1497	n/a
1498	n/a	# set default port
1499	133	port_specified = False
1500	133	if port is not Absent:
1501	11	if port is None:
1502	n/a	# Port attr present, but has no value: default to request port.
1503	n/a	# Cookie should then only be sent back on that port.
1504	4	port = request_port(request)
1505	n/a	else:
1506	7	port_specified = True
1507	7	port = re.sub(r"\s+", "", port)
1508	n/a	else:
1509	n/a	# No port attr present. Cookie can be sent back on any port.
1510	122	port = None
1511	n/a
1512	n/a	# set default expires and discard
1513	133	if expires is Absent:
1514	114	expires = None
1515	114	discard = True
1516	19	elif expires <= self._now:
1517	n/a	# Expiry date in past is request to delete cookie. This can't be
1518	n/a	# in DefaultCookiePolicy, because can't delete cookies there.
1519	3	try:
1520	3	self.clear(domain, path, name)
1521	1	except KeyError:
1522	1	pass
1523	3	_debug("Expiring cookie, domain='%s', path='%s', name='%s'",
1524	3	domain, path, name)
1525	3	return None
1526	n/a
1527	130	return Cookie(version,
1528	130	name, value,
1529	130	port, port_specified,
1530	130	domain, domain_specified, domain_initial_dot,
1531	130	path, path_specified,
1532	130	secure,
1533	130	expires,
1534	130	discard,
1535	130	comment,
1536	130	comment_url,
1537	130	rest)
1538	n/a
1539	1	def _cookies_from_attrs_set(self, attrs_set, request):
1540	197	cookie_tuples = self._normalized_cookie_tuples(attrs_set)
1541	n/a
1542	197	cookies = []
1543	331	for tup in cookie_tuples:
1544	134	cookie = self._cookie_from_cookie_tuple(tup, request)
1545	134	if cookie: cookies.append(cookie)
1546	197	return cookies
1547	n/a
1548	1	def _process_rfc2109_cookies(self, cookies):
1549	71	rfc2109_as_ns = getattr(self._policy, 'rfc2109_as_netscape', None)
1550	71	if rfc2109_as_ns is None:
1551	67	rfc2109_as_ns = not self._policy.rfc2965
1552	144	for cookie in cookies:
1553	73	if cookie.version == 1:
1554	6	cookie.rfc2109 = True
1555	6	if rfc2109_as_ns:
1556	n/a	# treat 2109 cookies as Netscape cookies rather than
1557	n/a	# as RFC2965 cookies
1558	3	cookie.version = 0
1559	n/a
1560	1	def make_cookies(self, response, request):
1561	n/a	"""Return sequence of Cookie objects extracted from response object."""
1562	n/a	# get cookie-attributes for RFC 2965 and Netscape protocols
1563	163	headers = response.info()
1564	163	rfc2965_hdrs = headers.getheaders("Set-Cookie2")
1565	163	ns_hdrs = headers.getheaders("Set-Cookie")
1566	n/a
1567	163	rfc2965 = self._policy.rfc2965
1568	163	netscape = self._policy.netscape
1569	n/a
1570	163	if ((not rfc2965_hdrs and not ns_hdrs) or
1571	131	(not ns_hdrs and not rfc2965) or
1572	126	(not rfc2965_hdrs and not netscape) or
1573	126	(not netscape and not rfc2965)):
1574	37	return [] # no relevant cookie headers: quick exit
1575	n/a
1576	126	try:
1577	126	cookies = self._cookies_from_attrs_set(
1578	126	split_header_words(rfc2965_hdrs), request)
1579	0	except Exception:
1580	0	_warn_unhandled_exception()
1581	0	cookies = []
1582	n/a
1583	126	if ns_hdrs and netscape:
1584	71	try:
1585	n/a	# RFC 2109 and Netscape cookies
1586	71	ns_cookies = self._cookies_from_attrs_set(
1587	71	parse_ns_headers(ns_hdrs), request)
1588	0	except Exception:
1589	0	_warn_unhandled_exception()
1590	0	ns_cookies = []
1591	71	self._process_rfc2109_cookies(ns_cookies)
1592	n/a
1593	n/a	# Look for Netscape cookies (from Set-Cookie headers) that match
1594	n/a	# corresponding RFC 2965 cookies (from Set-Cookie2 headers).
1595	n/a	# For each match, keep the RFC 2965 cookie and ignore the Netscape
1596	n/a	# cookie (RFC 2965 section 9.1). Actually, RFC 2109 cookies are
1597	n/a	# bundled in with the Netscape cookies for this purpose, which is
1598	n/a	# reasonable behaviour.
1599	71	if rfc2965:
1600	16	lookup = {}
1601	16	for cookie in cookies:
1602	0	lookup[(cookie.domain, cookie.path, cookie.name)] = None
1603	n/a
1604	16	def no_matching_rfc2965(ns_cookie, lookup=lookup):
1605	19	key = ns_cookie.domain, ns_cookie.path, ns_cookie.name
1606	19	return key not in lookup
1607	16	ns_cookies = filter(no_matching_rfc2965, ns_cookies)
1608	n/a
1609	71	if ns_cookies:
1610	65	cookies.extend(ns_cookies)
1611	n/a
1612	126	return cookies
1613	n/a
1614	1	def set_cookie_if_ok(self, cookie, request):
1615	n/a	"""Set a cookie if policy says it's OK to do so."""
1616	0	self._cookies_lock.acquire()
1617	0	try:
1618	0	self._policy._now = self._now = int(time.time())
1619	n/a
1620	0	if self._policy.set_ok(cookie, request):
1621	0	self.set_cookie(cookie)
1622	n/a
1623	n/a
1624	n/a	finally:
1625	0	self._cookies_lock.release()
1626	n/a
1627	1	def set_cookie(self, cookie):
1628	n/a	"""Set a cookie, without checking whether or not it should be set."""
1629	131	c = self._cookies
1630	131	self._cookies_lock.acquire()
1631	131	try:
1632	131	if cookie.domain not in c: c[cookie.domain] = {}
1633	131	c2 = c[cookie.domain]
1634	131	if cookie.path not in c2: c2[cookie.path] = {}
1635	131	c3 = c2[cookie.path]
1636	131	c3[cookie.name] = cookie
1637	n/a	finally:
1638	131	self._cookies_lock.release()
1639	n/a
1640	1	def extract_cookies(self, response, request):
1641	n/a	"""Extract cookies from response, where allowable given the request."""
1642	161	_debug("extract_cookies: %s", response.info())
1643	161	self._cookies_lock.acquire()
1644	161	try:
1645	161	self._policy._now = self._now = int(time.time())
1646	n/a
1647	289	for cookie in self.make_cookies(response, request):
1648	128	if self._policy.set_ok(cookie, request):
1649	110	_debug(" setting cookie: %s", cookie)
1650	110	self.set_cookie(cookie)
1651	n/a	finally:
1652	161	self._cookies_lock.release()
1653	n/a
1654	1	def clear(self, domain=None, path=None, name=None):
1655	n/a	"""Clear some cookies.
1656	n/a
1657	n/a	Invoking this method without arguments will clear all cookies. If
1658	n/a	given a single argument, only cookies belonging to that domain will be
1659	n/a	removed. If given two arguments, cookies belonging to the specified
1660	n/a	path within that domain are removed. If given three arguments, then
1661	n/a	the cookie with the specified name, path and domain is removed.
1662	n/a
1663	n/a	Raises KeyError if no matching cookie exists.
1664	n/a
1665	n/a	"""
1666	8	if name is not None:
1667	6	if (domain is None) or (path is None):
1668	0	raise ValueError(
1669	0	"domain and path must be given to remove a cookie by name")
1670	6	del self._cookies[domain][path][name]
1671	2	elif path is not None:
1672	0	if domain is None:
1673	0	raise ValueError(
1674	0	"domain must be given to remove cookies by path")
1675	0	del self._cookies[domain][path]
1676	2	elif domain is not None:
1677	0	del self._cookies[domain]
1678	n/a	else:
1679	2	self._cookies = {}
1680	n/a
1681	1	def clear_session_cookies(self):
1682	n/a	"""Discard all session cookies.
1683	n/a
1684	n/a	Note that the .save() method won't save session cookies anyway, unless
1685	n/a	you ask otherwise by passing a true ignore_discard argument.
1686	n/a
1687	n/a	"""
1688	2	self._cookies_lock.acquire()
1689	2	try:
1690	8	for cookie in self:
1691	6	if cookie.discard:
1692	3	self.clear(cookie.domain, cookie.path, cookie.name)
1693	n/a	finally:
1694	2	self._cookies_lock.release()
1695	n/a
1696	1	def clear_expired_cookies(self):
1697	n/a	"""Discard all expired cookies.
1698	n/a
1699	n/a	You probably don't need to call this method: expired cookies are never
1700	n/a	sent back to the server (provided you're using DefaultCookiePolicy),
1701	n/a	this method is called by CookieJar itself every so often, and the
1702	n/a	.save() method won't save expired cookies anyway (unless you ask
1703	n/a	otherwise by passing a true ignore_expires argument).
1704	n/a
1705	n/a	"""
1706	152	self._cookies_lock.acquire()
1707	152	try:
1708	152	now = time.time()
1709	329	for cookie in self:
1710	177	if cookie.is_expired(now):
1711	0	self.clear(cookie.domain, cookie.path, cookie.name)
1712	n/a	finally:
1713	152	self._cookies_lock.release()
1714	n/a
1715	1	def __iter__(self):
1716	223	return deepvalues(self._cookies)
1717	n/a
1718	1	def __len__(self):
1719	n/a	"""Return number of contained cookies."""
1720	52	i = 0
1721	147	for cookie in self: i = i + 1
1722	52	return i
1723	n/a
1724	1	def __repr__(self):
1725	6	r = []
1726	32	for cookie in self: r.append(repr(cookie))
1727	6	return "<%s[%s]>" % (self.__class__, ", ".join(r))
1728	n/a
1729	1	def __str__(self):
1730	0	r = []
1731	0	for cookie in self: r.append(str(cookie))
1732	0	return "<%s[%s]>" % (self.__class__, ", ".join(r))
1733	n/a
1734	n/a
1735	n/a	# derives from IOError for backwards-compatibility with Python 2.4.0
1736	2	class LoadError(IOError): pass
1737	n/a
1738	2	class FileCookieJar(CookieJar):
1739	1	"""CookieJar that can be loaded from and saved to a file."""
1740	n/a
1741	1	def __init__(self, filename=None, delayload=False, policy=None):
1742	n/a	"""
1743	n/a	Cookies are NOT loaded from the named file until either the .load() or
1744	n/a	.revert() method is called.
1745	n/a
1746	n/a	"""
1747	13	CookieJar.__init__(self, policy)
1748	13	if filename is not None:
1749	5	try:
1750	5	filename+""
1751	0	except:
1752	0	raise ValueError("filename must be string-like")
1753	13	self.filename = filename
1754	13	self.delayload = bool(delayload)
1755	n/a
1756	1	def save(self, filename=None, ignore_discard=False, ignore_expires=False):
1757	n/a	"""Save cookies to a file."""
1758	0	raise NotImplementedError()
1759	n/a
1760	1	def load(self, filename=None, ignore_discard=False, ignore_expires=False):
1761	n/a	"""Load cookies from a file."""
1762	9	if filename is None:
1763	2	if self.filename is not None: filename = self.filename
1764	0	else: raise ValueError(MISSING_FILENAME_TEXT)
1765	n/a
1766	9	f = open(filename)
1767	7	try:
1768	7	self._really_load(f, filename, ignore_discard, ignore_expires)
1769	n/a	finally:
1770	7	f.close()
1771	n/a
1772	1	def revert(self, filename=None,
1773	1	ignore_discard=False, ignore_expires=False):
1774	n/a	"""Clear all cookies and reload cookies from a saved file.
1775	n/a
1776	n/a	Raises LoadError (or IOError) if reversion is not successful; the
1777	n/a	object's state will not be altered if this happens.
1778	n/a
1779	n/a	"""
1780	1	if filename is None:
1781	1	if self.filename is not None: filename = self.filename
1782	0	else: raise ValueError(MISSING_FILENAME_TEXT)
1783	n/a
1784	1	self._cookies_lock.acquire()
1785	1	try:
1786	n/a
1787	1	old_state = copy.deepcopy(self._cookies)
1788	1	self._cookies = {}
1789	1	try:
1790	1	self.load(filename, ignore_discard, ignore_expires)
1791	0	except (LoadError, IOError):
1792	0	self._cookies = old_state
1793	0	raise
1794	n/a
1795	n/a	finally:
1796	1	self._cookies_lock.release()
1797	n/a
1798	1	from _LWPCookieJar import LWPCookieJar, lwp_cookie_str
1799	1	from _MozillaCookieJar import MozillaCookieJar