sys/lib/python/urllib2.py

   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:password@proxy.example.com')
 608     (None, 'joe', 'password', 'proxy.example.com')
 609     >>> _parse_proxy('joe:password@proxy.example.com: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:password@proxy.example.com/')
 619     ('http', 'joe', 'password', 'proxy.example.com')
 620     >>> _parse_proxy('http://joe:password@proxy.example.com:3128')
 621     ('http', 'joe', 'password', 'proxy.example.com:3128')
 622
 623     Everything after the authority is ignored:
 624
 625     >>> _parse_proxy('ftp://joe:password@proxy.example.com/rubbish:3128')
 626     ('ftp', 'joe', 'password', 'proxy.example.com')
 627
 628     Test for no trailing '/' case:
 629
 630     >>> _parse_proxy('http://joe:password@proxy.example.com')
 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.b64encode(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     # XXX this allows for multiple auth-schemes, but will stupidly pick
 770     # the last one with a realm specified.
 771
 772     rx = re.compile('(?:.*,)*[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', re.I)
 773
 774     # XXX could pre-emptively send auth info already accepted (RFC 2617,
 775     # end of section 2, and section 1.2 immediately after "credentials"
 776     # production).
 777
 778     def __init__(self, password_mgr=None):
 779         if password_mgr is None:
 780             password_mgr = HTTPPasswordMgr()
 781         self.passwd = password_mgr
 782         self.add_password = self.passwd.add_password
 783
 784     def http_error_auth_reqed(self, authreq, host, req, headers):
 785         # host may be an authority (without userinfo) or a URL with an
 786         # authority
 787         # XXX could be multiple headers
 788         authreq = headers.get(authreq, None)
 789         if authreq:
 790             mo = AbstractBasicAuthHandler.rx.search(authreq)
 791             if mo:
 792                 scheme, realm = mo.groups()
 793                 if scheme.lower() == 'basic':
 794                     return self.retry_http_basic_auth(host, req, realm)
 795
 796     def retry_http_basic_auth(self, host, req, realm):
 797         user, pw = self.passwd.find_user_password(realm, host)
 798         if pw is not None:
 799             raw = "%s:%s" % (user, pw)
 800             auth = 'Basic %s' % base64.b64encode(raw).strip()
 801             if req.headers.get(self.auth_header, None) == auth:
 802                 return None
 803             req.add_header(self.auth_header, auth)
 804             return self.parent.open(req)
 805         else:
 806             return None
 807
 808
 809 class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
 810
 811     auth_header = 'Authorization'
 812
 813     def http_error_401(self, req, fp, code, msg, headers):
 814         url = req.get_full_url()
 815         return self.http_error_auth_reqed('www-authenticate',
 816                                           url, req, headers)
 817
 818
 819 class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
 820
 821     auth_header = 'Proxy-authorization'
 822
 823     def http_error_407(self, req, fp, code, msg, headers):
 824         # http_error_auth_reqed requires that there is no userinfo component in
 825         # authority.  Assume there isn't one, since urllib2 does not (and
 826         # should not, RFC 3986 s. 3.2.1) support requests for URLs containing
 827         # userinfo.
 828         authority = req.get_host()
 829         return self.http_error_auth_reqed('proxy-authenticate',
 830                                           authority, req, headers)
 831
 832
 833 def randombytes(n):
 834     """Return n random bytes."""
 835     # Use /dev/urandom if it is available.  Fall back to random module
 836     # if not.  It might be worthwhile to extend this function to use
 837     # other platform-specific mechanisms for getting random bytes.
 838     if os.path.exists("/dev/urandom"):
 839         f = open("/dev/urandom")
 840         s = f.read(n)
 841         f.close()
 842         return s
 843     else:
 844         L = [chr(random.randrange(0, 256)) for i in range(n)]
 845         return "".join(L)
 846
 847 class AbstractDigestAuthHandler:
 848     # Digest authentication is specified in RFC 2617.
 849
 850     # XXX The client does not inspect the Authentication-Info header
 851     # in a successful response.
 852
 853     # XXX It should be possible to test this implementation against
 854     # a mock server that just generates a static set of challenges.
 855
 856     # XXX qop="auth-int" supports is shaky
 857
 858     def __init__(self, passwd=None):
 859         if passwd is None:
 860             passwd = HTTPPasswordMgr()
 861         self.passwd = passwd
 862         self.add_password = self.passwd.add_password
 863         self.retried = 0
 864         self.nonce_count = 0
 865
 866     def reset_retry_count(self):
 867         self.retried = 0
 868
 869     def http_error_auth_reqed(self, auth_header, host, req, headers):
 870         authreq = headers.get(auth_header, None)
 871         if self.retried > 5:
 872             # Don't fail endlessly - if we failed once, we'll probably
 873             # fail a second time. Hm. Unless the Password Manager is
 874             # prompting for the information. Crap. This isn't great
 875             # but it's better than the current 'repeat until recursion
 876             # depth exceeded' approach <wink>
 877             raise HTTPError(req.get_full_url(), 401, "digest auth failed",
 878                             headers, None)
 879         else:
 880             self.retried += 1
 881         if authreq:
 882             scheme = authreq.split()[0]
 883             if scheme.lower() == 'digest':
 884                 return self.retry_http_digest_auth(req, authreq)
 885
 886     def retry_http_digest_auth(self, req, auth):
 887         token, challenge = auth.split(' ', 1)
 888         chal = parse_keqv_list(parse_http_list(challenge))
 889         auth = self.get_authorization(req, chal)
 890         if auth:
 891             auth_val = 'Digest %s' % auth
 892             if req.headers.get(self.auth_header, None) == auth_val:
 893                 return None
 894             req.add_unredirected_header(self.auth_header, auth_val)
 895             resp = self.parent.open(req)
 896             return resp
 897
 898     def get_cnonce(self, nonce):
 899         # The cnonce-value is an opaque
 900         # quoted string value provided by the client and used by both client
 901         # and server to avoid chosen plaintext attacks, to provide mutual
 902         # authentication, and to provide some message integrity protection.
 903         # This isn't a fabulous effort, but it's probably Good Enough.
 904         dig = hashlib.sha1("%s:%s:%s:%s" % (self.nonce_count, nonce, time.ctime(),
 905                                             randombytes(8))).hexdigest()
 906         return dig[:16]
 907
 908     def get_authorization(self, req, chal):
 909         try:
 910             realm = chal['realm']
 911             nonce = chal['nonce']
 912             qop = chal.get('qop')
 913             algorithm = chal.get('algorithm', 'MD5')
 914             # mod_digest doesn't send an opaque, even though it isn't
 915             # supposed to be optional
 916             opaque = chal.get('opaque', None)
 917         except KeyError:
 918             return None
 919
 920         H, KD = self.get_algorithm_impls(algorithm)
 921         if H is None:
 922             return None
 923
 924         user, pw = self.passwd.find_user_password(realm, req.get_full_url())
 925         if user is None:
 926             return None
 927
 928         # XXX not implemented yet
 929         if req.has_data():
 930             entdig = self.get_entity_digest(req.get_data(), chal)
 931         else:
 932             entdig = None
 933
 934         A1 = "%s:%s:%s" % (user, realm, pw)
 935         A2 = "%s:%s" % (req.get_method(),
 936                         # XXX selector: what about proxies and full urls
 937                         req.get_selector())
 938         if qop == 'auth':
 939             self.nonce_count += 1
 940             ncvalue = '%08x' % self.nonce_count
 941             cnonce = self.get_cnonce(nonce)
 942             noncebit = "%s:%s:%s:%s:%s" % (nonce, ncvalue, cnonce, qop, H(A2))
 943             respdig = KD(H(A1), noncebit)
 944         elif qop is None:
 945             respdig = KD(H(A1), "%s:%s" % (nonce, H(A2)))
 946         else:
 947             # XXX handle auth-int.
 948             pass
 949
 950         # XXX should the partial digests be encoded too?
 951
 952         base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \
 953                'response="%s"' % (user, realm, nonce, req.get_selector(),
 954                                   respdig)
 955         if opaque:
 956             base += ', opaque="%s"' % opaque
 957         if entdig:
 958             base += ', digest="%s"' % entdig
 959         base += ', algorithm="%s"' % algorithm
 960         if qop:
 961             base += ', qop=auth, nc=%s, cnonce="%s"' % (ncvalue, cnonce)
 962         return base
 963
 964     def get_algorithm_impls(self, algorithm):
 965         # lambdas assume digest modules are imported at the top level
 966         if algorithm == 'MD5':
 967             H = lambda x: hashlib.md5(x).hexdigest()
 968         elif algorithm == 'SHA':
 969             H = lambda x: hashlib.sha1(x).hexdigest()
 970         # XXX MD5-sess
 971         KD = lambda s, d: H("%s:%s" % (s, d))
 972         return H, KD
 973
 974     def get_entity_digest(self, data, chal):
 975         # XXX not implemented yet
 976         return None
 977
 978
 979 class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
 980     """An authentication protocol defined by RFC 2069
 981
 982     Digest authentication improves on basic authentication because it
 983     does not transmit passwords in the clear.
 984     """
 985
 986     auth_header = 'Authorization'
 987     handler_order = 490  # before Basic auth
 988
 989     def http_error_401(self, req, fp, code, msg, headers):
 990         host = urlparse.urlparse(req.get_full_url())[1]
 991         retry = self.http_error_auth_reqed('www-authenticate',
 992                                            host, req, headers)
 993         self.reset_retry_count()
 994         return retry
 995
 996
 997 class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
 998
 999     auth_header = 'Proxy-Authorization'
1000     handler_order = 490  # before Basic auth
1001
1002     def http_error_407(self, req, fp, code, msg, headers):
1003         host = req.get_host()
1004         retry = self.http_error_auth_reqed('proxy-authenticate',
1005                                            host, req, headers)
1006         self.reset_retry_count()
1007         return retry
1008
1009 class AbstractHTTPHandler(BaseHandler):
1010
1011     def __init__(self, debuglevel=0):
1012         self._debuglevel = debuglevel
1013
1014     def set_http_debuglevel(self, level):
1015         self._debuglevel = level
1016
1017     def do_request_(self, request):
1018         host = request.get_host()
1019         if not host:
1020             raise URLError('no host given')
1021
1022         if request.has_data():  # POST
1023             data = request.get_data()
1024             if not request.has_header('Content-type'):
1025                 request.add_unredirected_header(
1026                     'Content-type',
1027                     'application/x-www-form-urlencoded')
1028             if not request.has_header('Content-length'):
1029                 request.add_unredirected_header(
1030                     'Content-length', '%d' % len(data))
1031
1032         scheme, sel = splittype(request.get_selector())
1033         sel_host, sel_path = splithost(sel)
1034         if not request.has_header('Host'):
1035             request.add_unredirected_header('Host', sel_host or host)
1036         for name, value in self.parent.addheaders:
1037             name = name.capitalize()
1038             if not request.has_header(name):
1039                 request.add_unredirected_header(name, value)
1040
1041         return request
1042
1043     def do_open(self, http_class, req):
1044         """Return an addinfourl object for the request, using http_class.
1045
1046         http_class must implement the HTTPConnection API from httplib.
1047         The addinfourl return value is a file-like object.  It also
1048         has methods and attributes including:
1049             - info(): return a mimetools.Message object for the headers
1050             - geturl(): return the original request URL
1051             - code: HTTP status code
1052         """
1053         host = req.get_host()
1054         if not host:
1055             raise URLError('no host given')
1056
1057         h = http_class(host) # will parse host:port
1058         h.set_debuglevel(self._debuglevel)
1059
1060         headers = dict(req.headers)
1061         headers.update(req.unredirected_hdrs)
1062         # We want to make an HTTP/1.1 request, but the addinfourl
1063         # class isn't prepared to deal with a persistent connection.
1064         # It will try to read all remaining data from the socket,
1065         # which will block while the server waits for the next request.
1066         # So make sure the connection gets closed after the (only)
1067         # request.
1068         headers["Connection"] = "close"
1069         headers = dict(
1070             (name.title(), val) for name, val in headers.items())
1071         try:
1072             h.request(req.get_method(), req.get_selector(), req.data, headers)
1073             r = h.getresponse()
1074         except socket.error, err: # XXX what error?
1075             raise URLError(err)
1076
1077         # Pick apart the HTTPResponse object to get the addinfourl
1078         # object initialized properly.
1079
1080         # Wrap the HTTPResponse object in socket's file object adapter
1081         # for Windows.  That adapter calls recv(), so delegate recv()
1082         # to read().  This weird wrapping allows the returned object to
1083         # have readline() and readlines() methods.
1084
1085         # XXX It might be better to extract the read buffering code
1086         # out of socket._fileobject() and into a base class.
1087
1088         r.recv = r.read
1089         fp = socket._fileobject(r, close=True)
1090
1091         resp = addinfourl(fp, r.msg, req.get_full_url())
1092         resp.code = r.status
1093         resp.msg = r.reason
1094         return resp
1095
1096
1097 class HTTPHandler(AbstractHTTPHandler):
1098
1099     def http_open(self, req):
1100         return self.do_open(httplib.HTTPConnection, req)
1101
1102     http_request = AbstractHTTPHandler.do_request_
1103
1104 if hasattr(httplib, 'HTTPS'):
1105     class HTTPSHandler(AbstractHTTPHandler):
1106
1107         def https_open(self, req):
1108             return self.do_open(httplib.HTTPSConnection, req)
1109
1110         https_request = AbstractHTTPHandler.do_request_
1111
1112 class HTTPCookieProcessor(BaseHandler):
1113     def __init__(self, cookiejar=None):
1114         import cookielib
1115         if cookiejar is None:
1116             cookiejar = cookielib.CookieJar()
1117         self.cookiejar = cookiejar
1118
1119     def http_request(self, request):
1120         self.cookiejar.add_cookie_header(request)
1121         return request
1122
1123     def http_response(self, request, response):
1124         self.cookiejar.extract_cookies(response, request)
1125         return response
1126
1127     https_request = http_request
1128     https_response = http_response
1129
1130 class UnknownHandler(BaseHandler):
1131     def unknown_open(self, req):
1132         type = req.get_type()
1133         raise URLError('unknown url type: %s' % type)
1134
1135 def parse_keqv_list(l):
1136     """Parse list of key=value strings where keys are not duplicated."""
1137     parsed = {}
1138     for elt in l:
1139         k, v = elt.split('=', 1)
1140         if v[0] == '"' and v[-1] == '"':
1141             v = v[1:-1]
1142         parsed[k] = v
1143     return parsed
1144
1145 def parse_http_list(s):
1146     """Parse lists as described by RFC 2068 Section 2.
1147
1148     In particular, parse comma-separated lists where the elements of
1149     the list may include quoted-strings.  A quoted-string could
1150     contain a comma.  A non-quoted string could have quotes in the
1151     middle.  Neither commas nor quotes count if they are escaped.
1152     Only double-quotes count, not single-quotes.
1153     """
1154     res = []
1155     part = ''
1156
1157     escape = quote = False
1158     for cur in s:
1159         if escape:
1160             part += cur
1161             escape = False
1162             continue
1163         if quote:
1164             if cur == '\\':
1165                 escape = True
1166                 continue
1167             elif cur == '"':
1168                 quote = False
1169             part += cur
1170             continue
1171
1172         if cur == ',':
1173             res.append(part)
1174             part = ''
1175             continue
1176
1177         if cur == '"':
1178             quote = True
1179
1180         part += cur
1181
1182     # append last part
1183     if part:
1184         res.append(part)
1185
1186     return [part.strip() for part in res]
1187
1188 class FileHandler(BaseHandler):
1189     # Use local file or FTP depending on form of URL
1190     def file_open(self, req):
1191         url = req.get_selector()
1192         if url[:2] == '//' and url[2:3] != '/':
1193             req.type = 'ftp'
1194             return self.parent.open(req)
1195         else:
1196             return self.open_local_file(req)
1197
1198     # names for the localhost
1199     names = None
1200     def get_names(self):
1201         if FileHandler.names is None:
1202             try:
1203                 FileHandler.names = (socket.gethostbyname('localhost'),
1204                                     socket.gethostbyname(socket.gethostname()))
1205             except socket.gaierror:
1206                 FileHandler.names = (socket.gethostbyname('localhost'),)
1207         return FileHandler.names
1208
1209     # not entirely sure what the rules are here
1210     def open_local_file(self, req):
1211         import email.Utils
1212         import mimetypes
1213         host = req.get_host()
1214         file = req.get_selector()
1215         localfile = url2pathname(file)
1216         stats = os.stat(localfile)
1217         size = stats.st_size
1218         modified = email.Utils.formatdate(stats.st_mtime, usegmt=True)
1219         mtype = mimetypes.guess_type(file)[0]
1220         headers = mimetools.Message(StringIO(
1221             'Content-type: %s\nContent-length: %d\nLast-modified: %s\n' %
1222             (mtype or 'text/plain', size, modified)))
1223         if host:
1224             host, port = splitport(host)
1225         if not host or \
1226            (not port and socket.gethostbyname(host) in self.get_names()):
1227             return addinfourl(open(localfile, 'rb'),
1228                               headers, 'file:'+file)
1229         raise URLError('file not on local host')
1230
1231 class FTPHandler(BaseHandler):
1232     def ftp_open(self, req):
1233         import ftplib
1234         import mimetypes
1235         host = req.get_host()
1236         if not host:
1237             raise IOError, ('ftp error', 'no host given')
1238         host, port = splitport(host)
1239         if port is None:
1240             port = ftplib.FTP_PORT
1241         else:
1242             port = int(port)
1243
1244         # username/password handling
1245         user, host = splituser(host)
1246         if user:
1247             user, passwd = splitpasswd(user)
1248         else:
1249             passwd = None
1250         host = unquote(host)
1251         user = unquote(user or '')
1252         passwd = unquote(passwd or '')
1253
1254         try:
1255             host = socket.gethostbyname(host)
1256         except socket.error, msg:
1257             raise URLError(msg)
1258         path, attrs = splitattr(req.get_selector())
1259         dirs = path.split('/')
1260         dirs = map(unquote, dirs)
1261         dirs, file = dirs[:-1], dirs[-1]
1262         if dirs and not dirs[0]:
1263             dirs = dirs[1:]
1264         try:
1265             fw = self.connect_ftp(user, passwd, host, port, dirs)
1266             type = file and 'I' or 'D'
1267             for attr in attrs:
1268                 attr, value = splitvalue(attr)
1269                 if attr.lower() == 'type' and \
1270                    value in ('a', 'A', 'i', 'I', 'd', 'D'):
1271                     type = value.upper()
1272             fp, retrlen = fw.retrfile(file, type)
1273             headers = ""
1274             mtype = mimetypes.guess_type(req.get_full_url())[0]
1275             if mtype:
1276                 headers += "Content-type: %s\n" % mtype
1277             if retrlen is not None and retrlen >= 0:
1278                 headers += "Content-length: %d\n" % retrlen
1279             sf = StringIO(headers)
1280             headers = mimetools.Message(sf)
1281             return addinfourl(fp, headers, req.get_full_url())
1282         except ftplib.all_errors, msg:
1283             raise IOError, ('ftp error', msg), sys.exc_info()[2]
1284
1285     def connect_ftp(self, user, passwd, host, port, dirs):
1286         fw = ftpwrapper(user, passwd, host, port, dirs)
1287 ##        fw.ftp.set_debuglevel(1)
1288         return fw
1289
1290 class CacheFTPHandler(FTPHandler):
1291     # XXX would be nice to have pluggable cache strategies
1292     # XXX this stuff is definitely not thread safe
1293     def __init__(self):
1294         self.cache = {}
1295         self.timeout = {}
1296         self.soonest = 0
1297         self.delay = 60
1298         self.max_conns = 16
1299
1300     def setTimeout(self, t):
1301         self.delay = t
1302
1303     def setMaxConns(self, m):
1304         self.max_conns = m
1305
1306     def connect_ftp(self, user, passwd, host, port, dirs):
1307         key = user, host, port, '/'.join(dirs)
1308         if key in self.cache:
1309             self.timeout[key] = time.time() + self.delay
1310         else:
1311             self.cache[key] = ftpwrapper(user, passwd, host, port, dirs)
1312             self.timeout[key] = time.time() + self.delay
1313         self.check_cache()
1314         return self.cache[key]
1315
1316     def check_cache(self):
1317         # first check for old ones
1318         t = time.time()
1319         if self.soonest <= t:
1320             for k, v in self.timeout.items():
1321                 if v < t:
1322                     self.cache[k].close()
1323                     del self.cache[k]
1324                     del self.timeout[k]
1325         self.soonest = min(self.timeout.values())
1326
1327         # then check the size
1328         if len(self.cache) == self.max_conns:
1329             for k, v in self.timeout.items():
1330                 if v == self.soonest:
1331                     del self.cache[k]
1332                     del self.timeout[k]
1333                     break
1334             self.soonest = min(self.timeout.values())
1335
1336 class GopherHandler(BaseHandler):
1337     def gopher_open(self, req):
1338         # XXX can raise socket.error
1339         import gopherlib  # this raises DeprecationWarning in 2.5
1340         host = req.get_host()
1341         if not host:
1342             raise GopherError('no host given')
1343         host = unquote(host)
1344         selector = req.get_selector()
1345         type, selector = splitgophertype(selector)
1346         selector, query = splitquery(selector)
1347         selector = unquote(selector)
1348         if query:
1349             query = unquote(query)
1350             fp = gopherlib.send_query(selector, query, host)
1351         else:
1352             fp = gopherlib.send_selector(selector, host)
1353         return addinfourl(fp, noheaders(), req.get_full_url())