284 # general transaction handler to support different ways to handle

   285 # HTTPS proxying before and after Python 2.6.3.

   286 def _generic_start_transaction(handler, h, req):

   287     if hasattr(req, '_tunnel_host') and req._tunnel_host:

   288         tunnel_host = req._tunnel_host

   289         if tunnel_host[:7] not in ['http://', 'https:/']:

   290             tunnel_host = 'https://' + tunnel_host

   291         new_tunnel = True

   292     else:

   293         tunnel_host = req.get_selector()

   294         new_tunnel = False

   295 

   296     if new_tunnel or tunnel_host == req.get_full_url(): # has proxy

   297         urlparts = urlparse.urlparse(tunnel_host)

   298         if new_tunnel or urlparts[0] == 'https': # only use CONNECT for HTTPS

   299             if ':' in urlparts[1]:

   300                 realhost, realport = urlparts[1].split(':')

   301                 realport = int(realport)

   302             else:

   303                 realhost = urlparts[1]

   304                 realport = 443

   305 

   306             h.realhost = realhost

   307             h.realport = realport

   308             h.headers = req.headers.copy()

   309             h.headers.update(handler.parent.addheaders)

   310             return

   311 

   312     h.realhost = None

   313     h.realport = None

   314     h.headers = None

   315 

   316 def _generic_proxytunnel(self):

   317     proxyheaders = dict(

   318             [(x, self.headers[x]) for x in self.headers

   319              if x.lower().startswith('proxy-')])

   320     self._set_hostport(self.host, self.port)

   321     self.send('CONNECT %s:%d HTTP/1.0\r\n' % (self.realhost, self.realport))

   322     for header in proxyheaders.iteritems():

   323         self.send('%s: %s\r\n' % header)

   324     self.send('\r\n')

   325 

   326     # majority of the following code is duplicated from

   327     # httplib.HTTPConnection as there are no adequate places to

   328     # override functions to provide the needed functionality

   329     res = self.response_class(self.sock,

   330                               strict=self.strict,

   331                               method=self._method)

   332 

   333     while True:

   334         version, status, reason = res._read_status()

   335         if status != httplib.CONTINUE:

   336             break

   337         while True:

   338             skip = res.fp.readline().strip()

   339             if not skip:

   340                 break

   341     res.status = status

   342     res.reason = reason.strip()

   343 

   344     if res.status == 200:

   345         while True:

   346             line = res.fp.readline()

   347             if line == '\r\n':

   348                 break

   349         return True

   350 

   351     if version == 'HTTP/1.0':

   352         res.version = 10

   353     elif version.startswith('HTTP/1.'):

   354         res.version = 11

   355     elif version == 'HTTP/0.9':

   356         res.version = 9

   357     else:

   358         raise httplib.UnknownProtocol(version)

   359 

   360     if res.version == 9:

   361         res.length = None

   362         res.chunked = 0

   363         res.will_close = 1

   364         res.msg = httplib.HTTPMessage(cStringIO.StringIO())

   365         return False

   366 

   367     res.msg = httplib.HTTPMessage(res.fp)

   368     res.msg.fp = None

   369 

   370     # are we using the chunked-style of transfer encoding?

   371     trenc = res.msg.getheader('transfer-encoding')

   372     if trenc and trenc.lower() == "chunked":

   373         res.chunked = 1

   374         res.chunk_left = None

   375     else:

   376         res.chunked = 0

   377 

   378     # will the connection close at the end of the response?

   379     res.will_close = res._check_close()

   380 

   381     # do we have a Content-Length?

   382     # NOTE: RFC 2616, S4.4, #3 says we ignore this if tr_enc is "chunked"

   383     length = res.msg.getheader('content-length')

   384     if length and not res.chunked:

   385         try:

   386             res.length = int(length)

   387         except ValueError:

   388             res.length = None

   389         else:

   390             if res.length < 0:  # ignore nonsensical negative lengths

   391                 res.length = None

   392     else:

   393         res.length = None

   394 

   395     # does the body have a fixed length? (of zero)

   396     if (status == httplib.NO_CONTENT or status == httplib.NOT_MODIFIED or

   397         100 <= status < 200 or # 1xx codes

   398         res._method == 'HEAD'):

   399         res.length = 0

   400 

   401     # if the connection remains open, and we aren't using chunked, and

   402     # a content-length was not provided, then assume that the connection

   403     # WILL close.

   404     if (not res.will_close and

   405        not res.chunked and

   406        res.length is None):

   407         res.will_close = 1

   408 

   409     self.proxyres = res

   410 

   411     return False

   412 

   433 

   434         def connect(self):

   435             if self.realhost: # use CONNECT proxy

   436                 self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

   437                 self.sock.connect((self.host, self.port))

   438                 if _generic_proxytunnel(self):

   439                     self.sock = _ssl_wrap_socket(self.sock, self.cert_file, self.key_file)

   440             else:

   441                 BetterHTTPS.connect(self)

   449 

   450         def _start_transaction(self, h, req):

   451             _generic_start_transaction(self, h, req)

   452             return keepalive.KeepAliveHandler._start_transaction(self, h, req)