Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

urllib2.py@ 3226

Visit:

Last change on this file since 3226 was 3225, checked in by bird, 19 years ago
Python 2.5
File size: 46.2 KB

Line
1	"""An extensible library for opening URLs using a variety of protocols
2
3	The simplest way to use this module is to call the urlopen function,
4	which accepts a string containing a URL or a Request object (described
5	below). It opens the URL and returns the results as file-like
6	object; the returned object has some extra methods described below.
7
8	The OpenerDirector manages a collection of Handler objects that do
9	all the actual work. Each Handler implements a particular protocol or
10	option. The OpenerDirector is a composite object that invokes the
11	Handlers needed to open the requested URL. For example, the
12	HTTPHandler performs HTTP GET and POST requests and deals with
13	non-error returns. The HTTPRedirectHandler automatically deals with
14	HTTP 301, 302, 303 and 307 redirect errors, and the HTTPDigestAuthHandler
15	deals with digest authentication.
16
17	urlopen(url, data=None) -- basic usage is the same as original
18	urllib. pass the url and optionally data to post to an HTTP URL, and
19	get a file-like object back. One difference is that you can also pass
20	a Request instance instead of URL. Raises a URLError (subclass of
21	IOError); for HTTP errors, raises an HTTPError, which can also be
22	treated as a valid response.
23
24	build_opener -- function that creates a new OpenerDirector instance.
25	will install the default handlers. accepts one or more Handlers as
26	arguments, either instances or Handler classes that it will
27	instantiate. if one of the argument is a subclass of the default
28	handler, the argument will be installed instead of the default.
29
30	install_opener -- installs a new opener as the default opener.
31
32	objects of interest:
33	OpenerDirector --
34
35	Request -- an object that encapsulates the state of a request. the
36	state can be a simple as the URL. it can also include extra HTTP
37	headers, e.g. a User-Agent.
38
39	BaseHandler --
40
41	exceptions:
42	URLError-- a subclass of IOError, individual protocols have their own
43	specific subclass
44
45	HTTPError-- also a valid HTTP response, so you can treat an HTTP error
46	as an exceptional event or valid response
47
48	internals:
49	BaseHandler and parent
50	_call_chain conventions
51
52	Example usage:
53
54	import urllib2
55
56	# set up authentication info
57	authinfo = urllib2.HTTPBasicAuthHandler()
58	authinfo.add_password('realm', 'host', 'username', 'password')
59
60	proxy_support = urllib2.ProxyHandler({"http" : "http://ahad-haam:3128"})
61
62	# build a new opener that adds authentication and caching FTP handlers
63	opener = urllib2.build_opener(proxy_support, authinfo, urllib2.CacheFTPHandler)
64
65	# install it
66	urllib2.install_opener(opener)
67
68	f = urllib2.urlopen('http://www.python.org/')
69
70
71	"""
72
73	# XXX issues:
74	# If an authentication error handler that tries to perform
75	# authentication for some reason but fails, how should the error be
76	# signalled? The client needs to know the HTTP error code. But if
77	# the handler knows that the problem was, e.g., that it didn't know
78	# that hash algo that requested in the challenge, it would be good to
79	# pass that information along to the client, too.
80	# ftp errors aren't handled cleanly
81	# check digest against correct (i.e. non-apache) implementation
82
83	# Possible extensions:
84	# complex proxies XXX not sure what exactly was meant by this
85	# abstract factory for opener
86
87	import base64
88	import hashlib
89	import httplib
90	import mimetools
91	import os
92	import posixpath
93	import random
94	import re
95	import socket
96	import sys
97	import time
98	import urlparse
99	import bisect
100
101	try:
102	from cStringIO import StringIO
103	except ImportError:
104	from StringIO import StringIO
105
106	from urllib import (unwrap, unquote, splittype, splithost, quote,
107	addinfourl, splitport, splitgophertype, splitquery,
108	splitattr, ftpwrapper, noheaders, splituser, splitpasswd, splitvalue)
109
110	# support for FileHandler, proxies via environment variables
111	from urllib import localhost, url2pathname, getproxies
112
113	# used in User-Agent header sent
114	__version__ = sys.version[:3]
115
116	_opener = None
117	def urlopen(url, data=None):
118	global _opener
119	if _opener is None:
120	_opener = build_opener()
121	return _opener.open(url, data)
122
123	def install_opener(opener):
124	global _opener
125	_opener = opener
126
127	# do these error classes make sense?
128	# make sure all of the IOError stuff is overridden. we just want to be
129	# subtypes.
130
131	class URLError(IOError):
132	# URLError is a sub-type of IOError, but it doesn't share any of
133	# the implementation. need to override __init__ and __str__.
134	# It sets self.args for compatibility with other EnvironmentError
135	# subclasses, but args doesn't have the typical format with errno in
136	# slot 0 and strerror in slot 1. This may be better than nothing.
137	def __init__(self, reason):
138	self.args = reason,
139	self.reason = reason
140
141	def __str__(self):
142	return '<urlopen error %s>' % self.reason
143
144	class HTTPError(URLError, addinfourl):
145	"""Raised when HTTP error occurs, but also acts like non-error return"""
146	__super_init = addinfourl.__init__
147
148	def __init__(self, url, code, msg, hdrs, fp):
149	self.code = code
150	self.msg = msg
151	self.hdrs = hdrs
152	self.fp = fp
153	self.filename = url
154	# The addinfourl classes depend on fp being a valid file
155	# object. In some cases, the HTTPError may not have a valid
156	# file object. If this happens, the simplest workaround is to
157	# not initialize the base classes.
158	if fp is not None:
159	self.__super_init(fp, hdrs, url)
160
161	def __str__(self):
162	return 'HTTP Error %s: %s' % (self.code, self.msg)
163
164	class GopherError(URLError):
165	pass
166
167	# copied from cookielib.py
168	_cut_port_re = re.compile(r":\d+$")
169	def request_host(request):
170	"""Return request-host, as defined by RFC 2965.
171
172	Variation from RFC: returned value is lowercased, for convenient
173	comparison.
174
175	"""
176	url = request.get_full_url()
177	host = urlparse.urlparse(url)[1]
178	if host == "":
179	host = request.get_header("Host", "")
180
181	# remove port, if present
182	host = _cut_port_re.sub("", host, 1)
183	return host.lower()
184
185	class Request:
186
187	def __init__(self, url, data=None, headers={},
188	origin_req_host=None, unverifiable=False):
189	# unwrap('<URL:type://host/path>') --> 'type://host/path'
190	self.__original = unwrap(url)
191	self.type = None
192	# self.__r_type is what's left after doing the splittype
193	self.host = None
194	self.port = None
195	self.data = data
196	self.headers = {}
197	for key, value in headers.items():
198	self.add_header(key, value)
199	self.unredirected_hdrs = {}
200	if origin_req_host is None:
201	origin_req_host = request_host(self)
202	self.origin_req_host = origin_req_host
203	self.unverifiable = unverifiable
204
205	def __getattr__(self, attr):
206	# XXX this is a fallback mechanism to guard against these
207	# methods getting called in a non-standard order. this may be
208	# too complicated and/or unnecessary.
209	# XXX should the __r_XXX attributes be public?
210	if attr[:12] == '_Request__r_':
211	name = attr[12:]
212	if hasattr(Request, 'get_' + name):
213	getattr(self, 'get_' + name)()
214	return getattr(self, attr)
215	raise AttributeError, attr
216
217	def get_method(self):
218	if self.has_data():
219	return "POST"
220	else:
221	return "GET"
222
223	# XXX these helper methods are lame
224
225	def add_data(self, data):
226	self.data = data
227
228	def has_data(self):
229	return self.data is not None
230
231	def get_data(self):
232	return self.data
233
234	def get_full_url(self):
235	return self.__original
236
237	def get_type(self):
238	if self.type is None:
239	self.type, self.__r_type = splittype(self.__original)
240	if self.type is None:
241	raise ValueError, "unknown url type: %s" % self.__original
242	return self.type
243
244	def get_host(self):
245	if self.host is None:
246	self.host, self.__r_host = splithost(self.__r_type)
247	if self.host:
248	self.host = unquote(self.host)
249	return self.host
250
251	def get_selector(self):
252	return self.__r_host
253
254	def set_proxy(self, host, type):
255	self.host, self.type = host, type
256	self.__r_host = self.__original
257
258	def get_origin_req_host(self):
259	return self.origin_req_host
260
261	def is_unverifiable(self):
262	return self.unverifiable
263
264	def add_header(self, key, val):
265	# useful for something like authentication
266	self.headers[key.capitalize()] = val
267
268	def add_unredirected_header(self, key, val):
269	# will not be added to a redirected request
270	self.unredirected_hdrs[key.capitalize()] = val
271
272	def has_header(self, header_name):
273	return (header_name in self.headers or
274	header_name in self.unredirected_hdrs)
275
276	def get_header(self, header_name, default=None):
277	return self.headers.get(
278	header_name,
279	self.unredirected_hdrs.get(header_name, default))
280
281	def header_items(self):
282	hdrs = self.unredirected_hdrs.copy()
283	hdrs.update(self.headers)
284	return hdrs.items()
285
286	class OpenerDirector:
287	def __init__(self):
288	client_version = "Python-urllib/%s" % __version__
289	self.addheaders = [('User-agent', client_version)]
290	# manage the individual handlers
291	self.handlers = []
292	self.handle_open = {}
293	self.handle_error = {}
294	self.process_response = {}
295	self.process_request = {}
296
297	def add_handler(self, handler):
298	added = False
299	for meth in dir(handler):
300	if meth in ["redirect_request", "do_open", "proxy_open"]:
301	# oops, coincidental match
302	continue
303
304	i = meth.find("_")
305	protocol = meth[:i]
306	condition = meth[i+1:]
307
308	if condition.startswith("error"):
309	j = condition.find("_") + i + 1
310	kind = meth[j+1:]
311	try:
312	kind = int(kind)
313	except ValueError:
314	pass
315	lookup = self.handle_error.get(protocol, {})
316	self.handle_error[protocol] = lookup
317	elif condition == "open":
318	kind = protocol
319	lookup = self.handle_open
320	elif condition == "response":
321	kind = protocol
322	lookup = self.process_response
323	elif condition == "request":
324	kind = protocol
325	lookup = self.process_request
326	else:
327	continue
328
329	handlers = lookup.setdefault(kind, [])
330	if handlers:
331	bisect.insort(handlers, handler)
332	else:
333	handlers.append(handler)
334	added = True
335
336	if added:
337	# XXX why does self.handlers need to be sorted?
338	bisect.insort(self.handlers, handler)
339	handler.add_parent(self)
340
341	def close(self):
342	# Only exists for backwards compatibility.
343	pass
344
345	def _call_chain(self, chain, kind, meth_name, *args):
346	# Handlers raise an exception if no one else should try to handle
347	# the request, or return None if they can't but another handler
348	# could. Otherwise, they return the response.
349	handlers = chain.get(kind, ())
350	for handler in handlers:
351	func = getattr(handler, meth_name)
352
353	result = func(*args)
354	if result is not None:
355	return result
356
357	def open(self, fullurl, data=None):
358	# accept a URL or a Request object
359	if isinstance(fullurl, basestring):
360	req = Request(fullurl, data)
361	else:
362	req = fullurl
363	if data is not None:
364	req.add_data(data)
365
366	protocol = req.get_type()
367
368	# pre-process request
369	meth_name = protocol+"_request"
370	for processor in self.process_request.get(protocol, []):
371	meth = getattr(processor, meth_name)
372	req = meth(req)
373
374	response = self._open(req, data)
375
376	# post-process response
377	meth_name = protocol+"_response"
378	for processor in self.process_response.get(protocol, []):
379	meth = getattr(processor, meth_name)
380	response = meth(req, response)
381
382	return response
383
384	def _open(self, req, data=None):
385	result = self._call_chain(self.handle_open, 'default',
386	'default_open', req)
387	if result:
388	return result
389
390	protocol = req.get_type()
391	result = self._call_chain(self.handle_open, protocol, protocol +
392	'_open', req)
393	if result:
394	return result
395
396	return self._call_chain(self.handle_open, 'unknown',
397	'unknown_open', req)
398
399	def error(self, proto, *args):
400	if proto in ('http', 'https'):
401	# XXX http[s] protocols are special-cased
402	dict = self.handle_error['http'] # https is not different than http
403	proto = args[2] # YUCK!
404	meth_name = 'http_error_%s' % proto
405	http_err = 1
406	orig_args = args
407	else:
408	dict = self.handle_error
409	meth_name = proto + '_error'
410	http_err = 0
411	args = (dict, proto, meth_name) + args
412	result = self._call_chain(*args)
413	if result:
414	return result
415
416	if http_err:
417	args = (dict, 'default', 'http_error_default') + orig_args
418	return self._call_chain(*args)
419
420	# XXX probably also want an abstract factory that knows when it makes
421	# sense to skip a superclass in favor of a subclass and when it might
422	# make sense to include both
423
424	def build_opener(*handlers):
425	"""Create an opener object from a list of handlers.
426
427	The opener will use several default handlers, including support
428	for HTTP and FTP.
429
430	If any of the handlers passed as arguments are subclasses of the
431	default handlers, the default handlers will not be used.
432	"""
433	import types
434	def isclass(obj):
435	return isinstance(obj, types.ClassType) or hasattr(obj, "__bases__")
436
437	opener = OpenerDirector()
438	default_classes = [ProxyHandler, UnknownHandler, HTTPHandler,
439	HTTPDefaultErrorHandler, HTTPRedirectHandler,
440	FTPHandler, FileHandler, HTTPErrorProcessor]
441	if hasattr(httplib, 'HTTPS'):
442	default_classes.append(HTTPSHandler)
443	skip = []
444	for klass in default_classes:
445	for check in handlers:
446	if isclass(check):
447	if issubclass(check, klass):
448	skip.append(klass)
449	elif isinstance(check, klass):
450	skip.append(klass)
451	for klass in skip:
452	default_classes.remove(klass)
453
454	for klass in default_classes:
455	opener.add_handler(klass())
456
457	for h in handlers:
458	if isclass(h):
459	h = h()
460	opener.add_handler(h)
461	return opener
462
463	class BaseHandler:
464	handler_order = 500
465
466	def add_parent(self, parent):
467	self.parent = parent
468
469	def close(self):
470	# Only exists for backwards compatibility
471	pass
472
473	def __lt__(self, other):
474	if not hasattr(other, "handler_order"):
475	# Try to preserve the old behavior of having custom classes
476	# inserted after default ones (works only for custom user
477	# classes which are not aware of handler_order).
478	return True
479	return self.handler_order < other.handler_order
480
481
482	class HTTPErrorProcessor(BaseHandler):
483	"""Process HTTP error responses."""
484	handler_order = 1000 # after all other processing
485
486	def http_response(self, request, response):
487	code, msg, hdrs = response.code, response.msg, response.info()
488
489	if code not in (200, 206):
490	response = self.parent.error(
491	'http', request, response, code, msg, hdrs)
492
493	return response
494
495	https_response = http_response
496
497	class HTTPDefaultErrorHandler(BaseHandler):
498	def http_error_default(self, req, fp, code, msg, hdrs):
499	raise HTTPError(req.get_full_url(), code, msg, hdrs, fp)
500
501	class HTTPRedirectHandler(BaseHandler):
502	# maximum number of redirections to any single URL
503	# this is needed because of the state that cookies introduce
504	max_repeats = 4
505	# maximum total number of redirections (regardless of URL) before
506	# assuming we're in a loop
507	max_redirections = 10
508
509	def redirect_request(self, req, fp, code, msg, headers, newurl):
510	"""Return a Request or None in response to a redirect.
511
512	This is called by the http_error_30x methods when a
513	redirection response is received. If a redirection should
514	take place, return a new Request to allow http_error_30x to
515	perform the redirect. Otherwise, raise HTTPError if no-one
516	else should try to handle this url. Return None if you can't
517	but another Handler might.
518	"""
519	m = req.get_method()
520	if (code in (301, 302, 303, 307) and m in ("GET", "HEAD")
521	or code in (301, 302, 303) and m == "POST"):
522	# Strictly (according to RFC 2616), 301 or 302 in response
523	# to a POST MUST NOT cause a redirection without confirmation
524	# from the user (of urllib2, in this case). In practice,
525	# essentially all clients do redirect in this case, so we
526	# do the same.
527	# be conciliant with URIs containing a space
528	newurl = newurl.replace(' ', '%20')
529	return Request(newurl,
530	headers=req.headers,
531	origin_req_host=req.get_origin_req_host(),
532	unverifiable=True)
533	else:
534	raise HTTPError(req.get_full_url(), code, msg, headers, fp)
535
536	# Implementation note: To avoid the server sending us into an
537	# infinite loop, the request object needs to track what URLs we
538	# have already seen. Do this by adding a handler-specific
539	# attribute to the Request object.
540	def http_error_302(self, req, fp, code, msg, headers):
541	# Some servers (incorrectly) return multiple Location headers
542	# (so probably same goes for URI). Use first header.
543	if 'location' in headers:
544	newurl = headers.getheaders('location')[0]
545	elif 'uri' in headers:
546	newurl = headers.getheaders('uri')[0]
547	else:
548	return
549	newurl = urlparse.urljoin(req.get_full_url(), newurl)
550
551	# XXX Probably want to forget about the state of the current
552	# request, although that might interact poorly with other
553	# handlers that also use handler-specific request attributes
554	new = self.redirect_request(req, fp, code, msg, headers, newurl)
555	if new is None:
556	return
557
558	# loop detection
559	# .redirect_dict has a key url if url was previously visited.
560	if hasattr(req, 'redirect_dict'):
561	visited = new.redirect_dict = req.redirect_dict
562	if (visited.get(newurl, 0) >= self.max_repeats or
563	len(visited) >= self.max_redirections):
564	raise HTTPError(req.get_full_url(), code,
565	self.inf_msg + msg, headers, fp)
566	else:
567	visited = new.redirect_dict = req.redirect_dict = {}
568	visited[newurl] = visited.get(newurl, 0) + 1
569
570	# Don't close the fp until we are sure that we won't use it
571	# with HTTPError.
572	fp.read()
573	fp.close()
574
575	return self.parent.open(new)
576
577	http_error_301 = http_error_303 = http_error_307 = http_error_302
578
579	inf_msg = "The HTTP server returned a redirect error that would " \
580	"lead to an infinite loop.\n" \
581	"The last 30x error message was:\n"
582
583
584	def _parse_proxy(proxy):
585	"""Return (scheme, user, password, host/port) given a URL or an authority.
586
587	If a URL is supplied, it must have an authority (host:port) component.
588	According to RFC 3986, having an authority component means the URL must
589	have two slashes after the scheme:
590
591	>>> _parse_proxy('file:/ftp.example.com/')
592	Traceback (most recent call last):
593	ValueError: proxy URL with no authority: 'file:/ftp.example.com/'
594
595	The first three items of the returned tuple may be None.
596
597	Examples of authority parsing:
598
599	>>> _parse_proxy('proxy.example.com')
600	(None, None, None, 'proxy.example.com')
601	>>> _parse_proxy('proxy.example.com:3128')
602	(None, None, None, 'proxy.example.com:3128')
603
604	The authority component may optionally include userinfo (assumed to be
605	username:password):
606
607	>>> _parse_proxy('joe:[email protected]')
608	(None, 'joe', 'password', 'proxy.example.com')
609	>>> _parse_proxy('joe:[email protected]:3128')
610	(None, 'joe', 'password', 'proxy.example.com:3128')
611
612	Same examples, but with URLs instead:
613
614	>>> _parse_proxy('http://proxy.example.com/')
615	('http', None, None, 'proxy.example.com')
616	>>> _parse_proxy('http://proxy.example.com:3128/')
617	('http', None, None, 'proxy.example.com:3128')
618	>>> _parse_proxy('http://joe:[email protected]/')
619	('http', 'joe', 'password', 'proxy.example.com')
620	>>> _parse_proxy('http://joe:[email protected]:3128')
621	('http', 'joe', 'password', 'proxy.example.com:3128')
622
623	Everything after the authority is ignored:
624
625	>>> _parse_proxy('ftp://joe:[email protected]/rubbish:3128')
626	('ftp', 'joe', 'password', 'proxy.example.com')
627
628	Test for no trailing '/' case:
629
630	>>> _parse_proxy('http://joe:[email protected]')
631	('http', 'joe', 'password', 'proxy.example.com')
632
633	"""
634	scheme, r_scheme = splittype(proxy)
635	if not r_scheme.startswith("/"):
636	# authority
637	scheme = None
638	authority = proxy
639	else:
640	# URL
641	if not r_scheme.startswith("//"):
642	raise ValueError("proxy URL with no authority: %r" % proxy)
643	# We have an authority, so for RFC 3986-compliant URLs (by ss 3.
644	# and 3.3.), path is empty or starts with '/'
645	end = r_scheme.find("/", 2)
646	if end == -1:
647	end = None
648	authority = r_scheme[2:end]
649	userinfo, hostport = splituser(authority)
650	if userinfo is not None:
651	user, password = splitpasswd(userinfo)
652	else:
653	user = password = None
654	return scheme, user, password, hostport
655
656	class ProxyHandler(BaseHandler):
657	# Proxies must be in front
658	handler_order = 100
659
660	def __init__(self, proxies=None):
661	if proxies is None:
662	proxies = getproxies()
663	assert hasattr(proxies, 'has_key'), "proxies must be a mapping"
664	self.proxies = proxies
665	for type, url in proxies.items():
666	setattr(self, '%s_open' % type,
667	lambda r, proxy=url, type=type, meth=self.proxy_open: \
668	meth(r, proxy, type))
669
670	def proxy_open(self, req, proxy, type):
671	orig_type = req.get_type()
672	proxy_type, user, password, hostport = _parse_proxy(proxy)
673	if proxy_type is None:
674	proxy_type = orig_type
675	if user and password:
676	user_pass = '%s:%s' % (unquote(user), unquote(password))
677	creds = base64.encodestring(user_pass).strip()
678	req.add_header('Proxy-authorization', 'Basic ' + creds)
679	hostport = unquote(hostport)
680	req.set_proxy(hostport, proxy_type)
681	if orig_type == proxy_type:
682	# let other handlers take care of it
683	return None
684	else:
685	# need to start over, because the other handlers don't
686	# grok the proxy's URL type
687	# e.g. if we have a constructor arg proxies like so:
688	# {'http': 'ftp://proxy.example.com'}, we may end up turning
689	# a request for http://acme.example.com/a into one for
690	# ftp://proxy.example.com/a
691	return self.parent.open(req)
692
693	class HTTPPasswordMgr:
694
695	def __init__(self):
696	self.passwd = {}
697
698	def add_password(self, realm, uri, user, passwd):
699	# uri could be a single URI or a sequence
700	if isinstance(uri, basestring):
701	uri = [uri]
702	if not realm in self.passwd:
703	self.passwd[realm] = {}
704	for default_port in True, False:
705	reduced_uri = tuple(
706	[self.reduce_uri(u, default_port) for u in uri])
707	self.passwd[realm][reduced_uri] = (user, passwd)
708
709	def find_user_password(self, realm, authuri):
710	domains = self.passwd.get(realm, {})
711	for default_port in True, False:
712	reduced_authuri = self.reduce_uri(authuri, default_port)
713	for uris, authinfo in domains.iteritems():
714	for uri in uris:
715	if self.is_suburi(uri, reduced_authuri):
716	return authinfo
717	return None, None
718
719	def reduce_uri(self, uri, default_port=True):
720	"""Accept authority or URI and extract only the authority and path."""
721	# note HTTP URLs do not have a userinfo component
722	parts = urlparse.urlsplit(uri)
723	if parts[1]:
724	# URI
725	scheme = parts[0]
726	authority = parts[1]
727	path = parts[2] or '/'
728	else:
729	# host or host:port
730	scheme = None
731	authority = uri
732	path = '/'
733	host, port = splitport(authority)
734	if default_port and port is None and scheme is not None:
735	dport = {"http": 80,
736	"https": 443,
737	}.get(scheme)
738	if dport is not None:
739	authority = "%s:%d" % (host, dport)
740	return authority, path
741
742	def is_suburi(self, base, test):
743	"""Check if test is below base in a URI tree
744
745	Both args must be URIs in reduced form.
746	"""
747	if base == test:
748	return True
749	if base[0] != test[0]:
750	return False
751	common = posixpath.commonprefix((base[1], test[1]))
752	if len(common) == len(base[1]):
753	return True
754	return False
755
756
757	class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr):
758
759	def find_user_password(self, realm, authuri):
760	user, password = HTTPPasswordMgr.find_user_password(self, realm,
761	authuri)
762	if user is not None:
763	return user, password
764	return HTTPPasswordMgr.find_user_password(self, None, authuri)
765
766
767	class AbstractBasicAuthHandler:
768
769	rx = re.compile('[ \t]([^ \t]+)[ \t]+realm="([^"])"', re.I)
770
771	# XXX there can actually be multiple auth-schemes in a
772	# www-authenticate header. should probably be a lot more careful
773	# in parsing them to extract multiple alternatives