1 """HTTP/1.1 client library
3 <intro stuff goes here>
6 HTTPConnection goes through a number of "states", which define when a client
7 may legally make another request or fetch the response for a particular
8 request. This diagram details these state transitions:
20 | ( putheader() )* endheaders()
24 | response = getresponse()
26 Unread-response [Response-headers-read]
27 |\____________________
29 | response.read() | putrequest()
31 Idle Req-started-unread-response
34 response.read() | | ( putheader() )* endheaders()
36 Request-started Req-sent-unread-response
42 This diagram presents the following rules:
43 -- a second request may not be started until {response-headers-read}
44 -- a response [object] cannot be retrieved until {request-sent}
45 -- there is no differentiation between an unread response body and a
46 partially read response body
48 Note: this enforcement is applied by the HTTPConnection class. The
49 HTTPResponse class does not enforce this state machine, which
50 implies sophisticated clients may accelerate the request/response
51 pipeline. Caution should be taken, though: accelerating the states
52 beyond the above pattern may imply knowledge of the server's
53 connection-close behavior for certain requests. For example, it
54 is impossible to tell whether the server will close the connection
55 UNTIL the response headers have been read; this means that further
56 requests cannot be placed into the pipeline until it is known that
57 the server will NOT be closing the connection.
59 Logical State __state __response
60 ------------- ------- ----------
62 Request-started _CS_REQ_STARTED None
63 Request-sent _CS_REQ_SENT None
64 Unread-response _CS_IDLE <response_class>
65 Req-started-unread-response _CS_REQ_STARTED <response_class>
66 Req-sent-unread-response _CS_REQ_SENT <response_class>
72 from urlparse
import urlsplit
75 from cStringIO
import StringIO
77 from StringIO
import StringIO
79 __all__
= ["HTTP", "HTTPResponse", "HTTPConnection", "HTTPSConnection",
80 "HTTPException", "NotConnected", "UnknownProtocol",
81 "UnknownTransferEncoding", "UnimplementedFileMode",
82 "IncompleteRead", "InvalidURL", "ImproperConnectionState",
83 "CannotSendRequest", "CannotSendHeader", "ResponseNotReady",
84 "BadStatusLine", "error", "responses"]
93 _CS_REQ_STARTED
= 'Request-started'
94 _CS_REQ_SENT
= 'Request-sent'
99 SWITCHING_PROTOCOLS
= 101
106 NON_AUTHORITATIVE_INFORMATION
= 203
109 PARTIAL_CONTENT
= 206
114 MULTIPLE_CHOICES
= 300
115 MOVED_PERMANENTLY
= 301
120 TEMPORARY_REDIRECT
= 307
125 PAYMENT_REQUIRED
= 402
128 METHOD_NOT_ALLOWED
= 405
130 PROXY_AUTHENTICATION_REQUIRED
= 407
131 REQUEST_TIMEOUT
= 408
134 LENGTH_REQUIRED
= 411
135 PRECONDITION_FAILED
= 412
136 REQUEST_ENTITY_TOO_LARGE
= 413
137 REQUEST_URI_TOO_LONG
= 414
138 UNSUPPORTED_MEDIA_TYPE
= 415
139 REQUESTED_RANGE_NOT_SATISFIABLE
= 416
140 EXPECTATION_FAILED
= 417
141 UNPROCESSABLE_ENTITY
= 422
143 FAILED_DEPENDENCY
= 424
144 UPGRADE_REQUIRED
= 426
147 INTERNAL_SERVER_ERROR
= 500
148 NOT_IMPLEMENTED
= 501
150 SERVICE_UNAVAILABLE
= 503
151 GATEWAY_TIMEOUT
= 504
152 HTTP_VERSION_NOT_SUPPORTED
= 505
153 INSUFFICIENT_STORAGE
= 507
156 # Mapping status codes to official W3C names
159 101: 'Switching Protocols',
164 203: 'Non-Authoritative Information',
166 205: 'Reset Content',
167 206: 'Partial Content',
169 300: 'Multiple Choices',
170 301: 'Moved Permanently',
176 307: 'Temporary Redirect',
180 402: 'Payment Required',
183 405: 'Method Not Allowed',
184 406: 'Not Acceptable',
185 407: 'Proxy Authentication Required',
186 408: 'Request Timeout',
189 411: 'Length Required',
190 412: 'Precondition Failed',
191 413: 'Request Entity Too Large',
192 414: 'Request-URI Too Long',
193 415: 'Unsupported Media Type',
194 416: 'Requested Range Not Satisfiable',
195 417: 'Expectation Failed',
197 500: 'Internal Server Error',
198 501: 'Not Implemented',
200 503: 'Service Unavailable',
201 504: 'Gateway Timeout',
202 505: 'HTTP Version Not Supported',
205 # maximal amount of data to read at one time in _safe_read
208 class HTTPMessage(mimetools
.Message
):
210 def addheader(self
, key
, value
):
211 """Add header for field key handling repeats."""
212 prev
= self
.dict.get(key
)
214 self
.dict[key
] = value
216 combined
= ", ".join((prev
, value
))
217 self
.dict[key
] = combined
219 def addcontinue(self
, key
, more
):
220 """Add more field data from a continuation line."""
221 prev
= self
.dict[key
]
222 self
.dict[key
] = prev
+ "\n " + more
224 def readheaders(self
):
225 """Read header lines.
227 Read header lines up to the entirely blank line that terminates them.
228 The (normally blank) line that ends the headers is skipped, but not
229 included in the returned list. If a non-header line ends the headers,
230 (which is an error), an attempt is made to backspace over it; it is
231 never included in the returned list.
233 The variable self.status is set to the empty string if all went well,
234 otherwise it is an error message. The variable self.headers is a
235 completely uninterpreted list of lines contained in the header (so
236 printing them will reproduce the header exactly as it appears in the
239 If multiple header fields with the same name occur, they are combined
240 according to the rules in RFC 2616 sec 4.2:
242 Appending each subsequent field-value to the first, each separated
243 by a comma. The order in which header fields with the same field-name
244 are received is significant to the interpretation of the combined
247 # XXX The implementation overrides the readheaders() method of
248 # rfc822.Message. The base class design isn't amenable to
249 # customized behavior here so the method here is a copy of the
250 # base class code with a few small changes.
254 self
.headers
= hlist
= []
258 startofline
= unread
= tell
= None
259 if hasattr(self
.fp
, 'unread'):
260 unread
= self
.fp
.unread
268 startofline
= tell
= None
270 line
= self
.fp
.readline()
272 self
.status
= 'EOF in headers'
274 # Skip unix From name time lines
275 if firstline
and line
.startswith('From '):
276 self
.unixfrom
= self
.unixfrom
+ line
279 if headerseen
and line
[0] in ' \t':
280 # XXX Not sure if continuation lines are handled properly
281 # for http and/or for repeating headers
282 # It's a continuation line.
284 self
.addcontinue(headerseen
, line
.strip())
286 elif self
.iscomment(line
):
287 # It's a comment. Ignore it.
289 elif self
.islast(line
):
290 # Note! No pushback here! The delimiter line gets eaten.
292 headerseen
= self
.isheader(line
)
294 # It's a legal header line, save it.
296 self
.addheader(headerseen
, line
[len(headerseen
)+1:].strip())
299 # It's not a header line; throw it back and stop here.
301 self
.status
= 'No headers'
303 self
.status
= 'Non-header line where header expected'
304 # Try to undo the read.
308 self
.fp
.seek(startofline
)
310 self
.status
= self
.status
+ '; bad seek'
315 # strict: If true, raise BadStatusLine if the status line can't be
316 # parsed as a valid HTTP/1.0 or 1.1 status line. By default it is
317 # false because it prevents clients from talking to HTTP/0.9
318 # servers. Note that a response with a sufficiently corrupted
319 # status line will look like an HTTP/0.9 response.
321 # See RFC 2616 sec 19.6 and RFC 1945 sec 6 for details.
323 def __init__(self
, sock
, debuglevel
=0, strict
=0, method
=None):
324 self
.fp
= sock
.makefile('rb', 0)
325 self
.debuglevel
= debuglevel
327 self
._method
= method
331 # from the Status-Line of the response
332 self
.version
= _UNKNOWN
# HTTP-Version
333 self
.status
= _UNKNOWN
# Status-Code
334 self
.reason
= _UNKNOWN
# Reason-Phrase
336 self
.chunked
= _UNKNOWN
# is "chunked" being used?
337 self
.chunk_left
= _UNKNOWN
# bytes left to read in current chunk
338 self
.length
= _UNKNOWN
# number of bytes left in response
339 self
.will_close
= _UNKNOWN
# conn will close at end of response
341 def _read_status(self
):
342 # Initialize with Simple-Response defaults
343 line
= self
.fp
.readline()
344 if self
.debuglevel
> 0:
345 print "reply:", repr(line
)
347 # Presumably, the server closed the connection before
348 # sending a valid response.
349 raise BadStatusLine(line
)
351 [version
, status
, reason
] = line
.split(None, 2)
354 [version
, status
] = line
.split(None, 1)
357 # empty version will cause next test to fail and status
358 # will be treated as 0.9 response.
360 if not version
.startswith('HTTP/'):
363 raise BadStatusLine(line
)
365 # assume it's a Simple-Response from an 0.9 server
366 self
.fp
= LineAndFileWrapper(line
, self
.fp
)
367 return "HTTP/0.9", 200, ""
369 # The status code is a three-digit number
372 if status
< 100 or status
> 999:
373 raise BadStatusLine(line
)
375 raise BadStatusLine(line
)
376 return version
, status
, reason
379 if self
.msg
is not None:
380 # we've already started reading the response
383 # read until we get a non-100 response
385 version
, status
, reason
= self
._read
_status
()
386 if status
!= CONTINUE
:
388 # skip the header from the 100 response
390 skip
= self
.fp
.readline().strip()
393 if self
.debuglevel
> 0:
394 print "header:", skip
397 self
.reason
= reason
.strip()
398 if version
== 'HTTP/1.0':
400 elif version
.startswith('HTTP/1.'):
401 self
.version
= 11 # use HTTP/1.1 code for HTTP/1.x where x>=1
402 elif version
== 'HTTP/0.9':
405 raise UnknownProtocol(version
)
407 if self
.version
== 9:
411 self
.msg
= HTTPMessage(StringIO())
414 self
.msg
= HTTPMessage(self
.fp
, 0)
415 if self
.debuglevel
> 0:
416 for hdr
in self
.msg
.headers
:
417 print "header:", hdr
,
419 # don't let the msg keep an fp
422 # are we using the chunked-style of transfer encoding?
423 tr_enc
= self
.msg
.getheader('transfer-encoding')
424 if tr_enc
and tr_enc
.lower() == "chunked":
426 self
.chunk_left
= None
430 # will the connection close at the end of the response?
431 self
.will_close
= self
._check
_close
()
433 # do we have a Content-Length?
434 # NOTE: RFC 2616, S4.4, #3 says we ignore this if tr_enc is "chunked"
435 length
= self
.msg
.getheader('content-length')
436 if length
and not self
.chunked
:
438 self
.length
= int(length
)
444 # does the body have a fixed length? (of zero)
445 if (status
== NO_CONTENT
or status
== NOT_MODIFIED
or
446 100 <= status
< 200 or # 1xx codes
447 self
._method
== 'HEAD'):
450 # if the connection remains open, and we aren't using chunked, and
451 # a content-length was not provided, then assume that the connection
453 if not self
.will_close
and \
454 not self
.chunked
and \
458 def _check_close(self
):
459 conn
= self
.msg
.getheader('connection')
460 if self
.version
== 11:
461 # An HTTP/1.1 proxy is assumed to stay open unless
463 conn
= self
.msg
.getheader('connection')
464 if conn
and "close" in conn
.lower():
468 # Some HTTP/1.0 implementations have support for persistent
469 # connections, using rules different than HTTP/1.1.
471 # For older HTTP, Keep-Alive indiciates persistent connection.
472 if self
.msg
.getheader('keep-alive'):
475 # At least Akamai returns a "Connection: Keep-Alive" header,
476 # which was supposed to be sent by the client.
477 if conn
and "keep-alive" in conn
.lower():
480 # Proxy-Connection is a netscape hack.
481 pconn
= self
.msg
.getheader('proxy-connection')
482 if pconn
and "keep-alive" in pconn
.lower():
485 # otherwise, assume it will close
494 # NOTE: it is possible that we will not ever call self.close(). This
495 # case occurs when will_close is TRUE, length is None, and we
496 # read up to the last byte, but NOT past it.
498 # IMPLIES: if will_close is FALSE, then self.close() will ALWAYS be
499 # called, meaning self.isclosed() is meaningful.
500 return self
.fp
is None
502 # XXX It would be nice to have readline and __iter__ for this, too.
504 def read(self
, amt
=None):
509 return self
._read
_chunked
(amt
)
513 if self
.length
is None:
516 s
= self
._safe
_read
(self
.length
)
518 self
.close() # we read everything
521 if self
.length
is not None:
522 if amt
> self
.length
:
523 # clip the read to the "end of response"
526 # we do not use _safe_read() here because this may be a .will_close
527 # connection, and the user is reading more bytes than will be provided
528 # (for example, reading in 1k chunks)
529 s
= self
.fp
.read(amt
)
530 if self
.length
is not None:
531 self
.length
-= len(s
)
535 def _read_chunked(self
, amt
):
536 assert self
.chunked
!= _UNKNOWN
537 chunk_left
= self
.chunk_left
540 # XXX This accumulates chunks by repeated string concatenation,
541 # which is not efficient as the number or size of chunks gets big.
543 if chunk_left
is None:
544 line
= self
.fp
.readline()
547 line
= line
[:i
] # strip chunk-extensions
548 chunk_left
= int(line
, 16)
552 value
+= self
._safe
_read
(chunk_left
)
553 elif amt
< chunk_left
:
554 value
+= self
._safe
_read
(amt
)
555 self
.chunk_left
= chunk_left
- amt
557 elif amt
== chunk_left
:
558 value
+= self
._safe
_read
(amt
)
559 self
._safe
_read
(2) # toss the CRLF at the end of the chunk
560 self
.chunk_left
= None
563 value
+= self
._safe
_read
(chunk_left
)
566 # we read the whole chunk, get another
567 self
._safe
_read
(2) # toss the CRLF at the end of the chunk
570 # read and discard trailer up to the CRLF terminator
571 ### note: we shouldn't have any trailers!
573 line
= self
.fp
.readline()
577 # we read everything; close the "file"
582 def _safe_read(self
, amt
):
583 """Read the number of bytes requested, compensating for partial reads.
585 Normally, we have a blocking socket, but a read() can be interrupted
586 by a signal (resulting in a partial read).
588 Note that we cannot distinguish between EOF and an interrupt when zero
589 bytes have been read. IncompleteRead() will be raised in this
592 This function should be used when <amt> bytes "should" be present for
593 reading. If the bytes are truly not available (due to EOF), then the
594 IncompleteRead exception can be used to detect the problem.
598 chunk
= self
.fp
.read(min(amt
, MAXAMOUNT
))
600 raise IncompleteRead(s
)
605 def getheader(self
, name
, default
=None):
607 raise ResponseNotReady()
608 return self
.msg
.getheader(name
, default
)
610 def getheaders(self
):
611 """Return list of (header, value) tuples."""
613 raise ResponseNotReady()
614 return self
.msg
.items()
617 class HTTPConnection
:
620 _http_vsn_str
= 'HTTP/1.1'
622 response_class
= HTTPResponse
623 default_port
= HTTP_PORT
628 def __init__(self
, host
, port
=None, strict
=None, timeout
=None):
629 self
.timeout
= timeout
632 self
.__response
= None
633 self
.__state
= _CS_IDLE
636 self
._set
_hostport
(host
, port
)
637 if strict
is not None:
640 def _set_hostport(self
, host
, port
):
643 j
= host
.rfind(']') # ipv6 addresses have [...]
646 port
= int(host
[i
+1:])
648 raise InvalidURL("nonnumeric port: '%s'" % host
[i
+1:])
651 port
= self
.default_port
652 if host
and host
[0] == '[' and host
[-1] == ']':
657 def set_debuglevel(self
, level
):
658 self
.debuglevel
= level
661 """Connect to the host and port specified in __init__."""
662 self
.sock
= socket
.create_connection((self
.host
,self
.port
),
666 """Close the connection to the HTTP server."""
668 self
.sock
.close() # close it manually... there may be other refs
671 self
.__response
.close()
672 self
.__response
= None
673 self
.__state
= _CS_IDLE
676 """Send `str' to the server."""
677 if self
.sock
is None:
683 # send the data to the server. if we get a broken pipe, then close
684 # the socket. we want to reconnect when somebody tries to send again.
686 # NOTE: we DO propagate the error, though, because we cannot simply
687 # ignore the error... the caller will know if they can retry.
688 if self
.debuglevel
> 0:
689 print "send:", repr(str)
692 if hasattr(str,'read') :
693 if self
.debuglevel
> 0: print "sendIng a read()able"
694 data
=str.read(blocksize
)
696 self
.sock
.sendall(data
)
697 data
=str.read(blocksize
)
699 self
.sock
.sendall(str)
700 except socket
.error
, v
:
701 if v
[0] == 32: # Broken pipe
705 def _output(self
, s
):
706 """Add a line of output to the current request buffer.
708 Assumes that the line does *not* end with \\r\\n.
710 self
._buffer
.append(s
)
712 def _send_output(self
):
713 """Send the currently buffered request and clear the buffer.
715 Appends an extra \\r\\n to the buffer.
717 self
._buffer
.extend(("", ""))
718 msg
= "\r\n".join(self
._buffer
)
722 def putrequest(self
, method
, url
, skip_host
=0, skip_accept_encoding
=0):
723 """Send a request to the server.
725 `method' specifies an HTTP request method, e.g. 'GET'.
726 `url' specifies the object being requested, e.g. '/index.html'.
727 `skip_host' if True does not add automatically a 'Host:' header
728 `skip_accept_encoding' if True does not add automatically an
729 'Accept-Encoding:' header
732 # if a prior response has been completed, then forget about it.
733 if self
.__response
and self
.__response
.isclosed():
734 self
.__response
= None
737 # in certain cases, we cannot issue another request on this connection.
739 # 1) we are in the process of sending a request. (_CS_REQ_STARTED)
740 # 2) a response to a previous request has signalled that it is going
741 # to close the connection upon completion.
742 # 3) the headers for the previous response have not been read, thus
743 # we cannot determine whether point (2) is true. (_CS_REQ_SENT)
745 # if there is no prior response, then we can request at will.
747 # if point (2) is true, then we will have passed the socket to the
748 # response (effectively meaning, "there is no prior response"), and
749 # will open a new one when a new request is made.
751 # Note: if a prior response exists, then we *can* start a new request.
752 # We are not allowed to begin fetching the response to this new
753 # request, however, until that prior response is complete.
755 if self
.__state
== _CS_IDLE
:
756 self
.__state
= _CS_REQ_STARTED
758 raise CannotSendRequest()
760 # Save the method we use, we need it later in the response phase
761 self
._method
= method
764 str = '%s %s %s' % (method
, url
, self
._http
_vsn
_str
)
768 if self
._http
_vsn
== 11:
769 # Issue some standard headers for better HTTP/1.1 compliance
772 # this header is issued *only* for HTTP/1.1
773 # connections. more specifically, this means it is
774 # only issued when the client uses the new
775 # HTTPConnection() class. backwards-compat clients
776 # will be using HTTP/1.0 and those clients may be
777 # issuing this header themselves. we should NOT issue
778 # it twice; some web servers (such as Apache) barf
779 # when they see two Host: headers
781 # If we need a non-standard port,include it in the
782 # header. If the request is going through a proxy,
783 # but the host of the actual URL, not the host of the
787 if url
.startswith('http'):
788 nil
, netloc
, nil
, nil
, nil
= urlsplit(url
)
792 netloc_enc
= netloc
.encode("ascii")
793 except UnicodeEncodeError:
794 netloc_enc
= netloc
.encode("idna")
795 self
.putheader('Host', netloc_enc
)
798 host_enc
= self
.host
.encode("ascii")
799 except UnicodeEncodeError:
800 host_enc
= self
.host
.encode("idna")
801 if self
.port
== HTTP_PORT
:
802 self
.putheader('Host', host_enc
)
804 self
.putheader('Host', "%s:%s" % (host_enc
, self
.port
))
806 # note: we are assuming that clients will not attempt to set these
807 # headers since *this* library must deal with the
808 # consequences. this also means that when the supporting
809 # libraries are updated to recognize other forms, then this
810 # code should be changed (removed or updated).
812 # we only want a Content-Encoding of "identity" since we don't
813 # support encodings such as x-gzip or x-deflate.
814 if not skip_accept_encoding
:
815 self
.putheader('Accept-Encoding', 'identity')
817 # we can accept "chunked" Transfer-Encodings, but no others
818 # NOTE: no TE header implies *only* "chunked"
819 #self.putheader('TE', 'chunked')
821 # if TE is supplied in the header, then it must appear in a
823 #self.putheader('Connection', 'TE')
826 # For HTTP/1.0, the server will assume "not chunked"
829 def putheader(self
, header
, value
):
830 """Send a request header line to the server.
832 For example: h.putheader('Accept', 'text/html')
834 if self
.__state
!= _CS_REQ_STARTED
:
835 raise CannotSendHeader()
837 str = '%s: %s' % (header
, value
)
840 def endheaders(self
):
841 """Indicate that the last header line has been sent to the server."""
843 if self
.__state
== _CS_REQ_STARTED
:
844 self
.__state
= _CS_REQ_SENT
846 raise CannotSendHeader()
850 def request(self
, method
, url
, body
=None, headers
={}):
851 """Send a complete request to the server."""
854 self
._send
_request
(method
, url
, body
, headers
)
855 except socket
.error
, v
:
856 # trap 'Broken pipe' if we're allowed to automatically reconnect
857 if v
[0] != 32 or not self
.auto_open
:
860 self
._send
_request
(method
, url
, body
, headers
)
862 def _send_request(self
, method
, url
, body
, headers
):
863 # honour explicitly requested Host: and Accept-Encoding headers
864 header_names
= dict.fromkeys([k
.lower() for k
in headers
])
866 if 'host' in header_names
:
867 skips
['skip_host'] = 1
868 if 'accept-encoding' in header_names
:
869 skips
['skip_accept_encoding'] = 1
871 self
.putrequest(method
, url
, **skips
)
873 if body
and ('content-length' not in header_names
):
876 thelen
=str(len(body
))
877 except TypeError, te
:
878 # If this is a file-like object, try to
879 # fstat its file descriptor
882 thelen
= str(os
.fstat(body
.fileno()).st_size
)
883 except (AttributeError, OSError):
884 # Don't send a length if this failed
885 if self
.debuglevel
> 0: print "Cannot stat!!"
887 if thelen
is not None:
888 self
.putheader('Content-Length',thelen
)
889 for hdr
, value
in headers
.iteritems():
890 self
.putheader(hdr
, value
)
896 def getresponse(self
):
897 "Get the response from the server."
899 # if a prior response has been completed, then forget about it.
900 if self
.__response
and self
.__response
.isclosed():
901 self
.__response
= None
904 # if a prior response exists, then it must be completed (otherwise, we
905 # cannot read this response's header to determine the connection-close
908 # note: if a prior response existed, but was connection-close, then the
909 # socket and response were made independent of this HTTPConnection
910 # object since a new request requires that we open a whole new
913 # this means the prior response had one of two states:
914 # 1) will_close: this connection was reset and the prior socket and
915 # response operate independently
916 # 2) persistent: the response was retained and we await its
917 # isclosed() status to become true.
919 if self
.__state
!= _CS_REQ_SENT
or self
.__response
:
920 raise ResponseNotReady()
922 if self
.debuglevel
> 0:
923 response
= self
.response_class(self
.sock
, self
.debuglevel
,
927 response
= self
.response_class(self
.sock
, strict
=self
.strict
,
931 assert response
.will_close
!= _UNKNOWN
932 self
.__state
= _CS_IDLE
934 if response
.will_close
:
935 # this effectively passes the connection to the response
938 # remember this, so we can tell when it is complete
939 self
.__response
= response
943 # The next several classes are used to define FakeSocket, a socket-like
944 # interface to an SSL connection.
946 # The primary complexity comes from faking a makefile() method. The
947 # standard socket makefile() implementation calls dup() on the socket
948 # file descriptor. As a consequence, clients can call close() on the
949 # parent socket and its makefile children in any order. The underlying
950 # socket isn't closed until they are all closed.
952 # The implementation uses reference counting to keep the socket open
953 # until the last client calls close(). SharedSocket keeps track of
954 # the reference counting and SharedSocketClient provides an constructor
955 # and close() method that call incref() and decref() correctly.
959 def __init__(self
, sock
):
968 assert self
._refcnt
>= 0
969 if self
._refcnt
== 0:
975 class SharedSocketClient
:
977 def __init__(self
, shared
):
979 self
._shared
= shared
980 self
._shared
.incref()
981 self
._sock
= shared
.sock
985 self
._shared
.decref()
989 class SSLFile(SharedSocketClient
):
990 """File-like object wrapping an SSL socket."""
994 def __init__(self
, sock
, ssl
, bufsize
=None):
995 SharedSocketClient
.__init
__(self
, sock
)
998 self
._bufsize
= bufsize
or self
.__class
__.BUFSIZE
1002 # put in a loop so that we retry on transient errors
1005 buf
= self
._ssl
.read(self
._bufsize
)
1006 except socket
.sslerror
, err
:
1007 if (err
[0] == socket
.SSL_ERROR_WANT_READ
1008 or err
[0] == socket
.SSL_ERROR_WANT_WRITE
):
1010 if (err
[0] == socket
.SSL_ERROR_ZERO_RETURN
1011 or err
[0] == socket
.SSL_ERROR_EOF
):
1014 except socket
.error
, err
:
1015 if err
[0] == errno
.EINTR
:
1017 if err
[0] == errno
.EBADF
:
1018 # XXX socket was closed?
1025 def read(self
, size
=None):
1027 avail
= len(self
._buf
)
1028 while size
is None or avail
< size
:
1039 self
._buf
= all
[size
:]
1046 i
= L
[-1].find("\n")
1054 # loop exited because there is no more data
1058 # XXX could do enough bookkeeping not to do a 2nd search
1059 i
= all
.find("\n") + 1
1064 def readlines(self
, sizehint
=0):
1068 line
= self
.readline()
1073 if sizehint
and total
>= sizehint
:
1078 return self
._sock
.fileno()
1084 line
= self
.readline()
1089 class FakeSocket(SharedSocketClient
):
1091 class _closedsocket
:
1092 def __getattr__(self
, name
):
1093 raise error(9, 'Bad file descriptor')
1095 def __init__(self
, sock
, ssl
):
1096 sock
= SharedSocket(sock
)
1097 SharedSocketClient
.__init
__(self
, sock
)
1101 SharedSocketClient
.close(self
)
1102 self
._sock
= self
.__class
__._closedsocket
()
1104 def makefile(self
, mode
, bufsize
=None):
1105 if mode
!= 'r' and mode
!= 'rb':
1106 raise UnimplementedFileMode()
1107 return SSLFile(self
._shared
, self
._ssl
, bufsize
)
1109 def send(self
, stuff
, flags
= 0):
1110 return self
._ssl
.write(stuff
)
1114 def recv(self
, len = 1024, flags
= 0):
1115 return self
._ssl
.read(len)
1117 def __getattr__(self
, attr
):
1118 return getattr(self
._sock
, attr
)
1121 class HTTPSConnection(HTTPConnection
):
1122 "This class allows communication via SSL."
1124 default_port
= HTTPS_PORT
1126 def __init__(self
, host
, port
=None, key_file
=None, cert_file
=None,
1128 HTTPConnection
.__init
__(self
, host
, port
, strict
)
1129 self
.key_file
= key_file
1130 self
.cert_file
= cert_file
1133 "Connect to a host on a given (SSL) port."
1135 sock
= socket
.socket(socket
.AF_INET
, socket
.SOCK_STREAM
)
1136 sock
.connect((self
.host
, self
.port
))
1137 ssl
= socket
.ssl(sock
, self
.key_file
, self
.cert_file
)
1138 self
.sock
= FakeSocket(sock
, ssl
)
1142 "Compatibility class with httplib.py from 1.5."
1145 _http_vsn_str
= 'HTTP/1.0'
1149 _connection_class
= HTTPConnection
1151 def __init__(self
, host
='', port
=None, strict
=None):
1152 "Provide a default host, since the superclass requires one."
1154 # some joker passed 0 explicitly, meaning default port
1158 # Note that we may pass an empty string as the host; this will throw
1159 # an error when we attempt to connect. Presumably, the client code
1160 # will call connect before then, with a proper host.
1161 self
._setup
(self
._connection
_class
(host
, port
, strict
))
1163 def _setup(self
, conn
):
1166 # set up delegation to flesh out interface
1167 self
.send
= conn
.send
1168 self
.putrequest
= conn
.putrequest
1169 self
.endheaders
= conn
.endheaders
1170 self
.set_debuglevel
= conn
.set_debuglevel
1172 conn
._http
_vsn
= self
._http
_vsn
1173 conn
._http
_vsn
_str
= self
._http
_vsn
_str
1177 def connect(self
, host
=None, port
=None):
1178 "Accept arguments to set the host/port, since the superclass doesn't."
1180 if host
is not None:
1181 self
._conn
._set
_hostport
(host
, port
)
1182 self
._conn
.connect()
1185 "Provide a getfile, since the superclass' does not use this concept."
1188 def putheader(self
, header
, *values
):
1189 "The superclass allows only one value argument."
1190 self
._conn
.putheader(header
, '\r\n\t'.join(values
))
1193 """Compat definition since superclass does not define it.
1195 Returns a tuple consisting of:
1196 - server status code (e.g. '200' if all goes well)
1197 - server "reason" corresponding to status code
1198 - any RFC822 headers in the response from the server
1201 response
= self
._conn
.getresponse()
1202 except BadStatusLine
, e
:
1203 ### hmm. if getresponse() ever closes the socket on a bad request,
1204 ### then we are going to have problems with self.sock
1206 ### should we keep this behavior? do people use it?
1207 # keep the socket open (as a file), and return it
1208 self
.file = self
._conn
.sock
.makefile('rb', 0)
1210 # close our socket -- we want to restart after any protocol error
1214 return -1, e
.line
, None
1216 self
.headers
= response
.msg
1217 self
.file = response
.fp
1218 return response
.status
, response
.reason
, response
.msg
1223 # note that self.file == response.fp, which gets closed by the
1224 # superclass. just clear the object ref here.
1225 ### hmm. messy. if status==-1, then self.file is owned by us.
1226 ### well... we aren't explicitly closing, but losing this ref will
1230 if hasattr(socket
, 'ssl'):
1232 """Compatibility with 1.5 httplib interface
1234 Python 1.5.2 did not have an HTTPS class, but it defined an
1235 interface for sending http requests that is also useful for
1239 _connection_class
= HTTPSConnection
1241 def __init__(self
, host
='', port
=None, key_file
=None, cert_file
=None,
1243 # provide a default host, pass the X509 cert info
1245 # urf. compensate for bad input.
1248 self
._setup
(self
._connection
_class
(host
, port
, key_file
,
1251 # we never actually use these for anything, but we keep them
1252 # here for compatibility with post-1.5.2 CVS.
1253 self
.key_file
= key_file
1254 self
.cert_file
= cert_file
1257 class HTTPException(Exception):
1258 # Subclasses that define an __init__ must call Exception.__init__
1259 # or define self.args. Otherwise, str() will fail.
1262 class NotConnected(HTTPException
):
1265 class InvalidURL(HTTPException
):
1268 class UnknownProtocol(HTTPException
):
1269 def __init__(self
, version
):
1270 self
.args
= version
,
1271 self
.version
= version
1273 class UnknownTransferEncoding(HTTPException
):
1276 class UnimplementedFileMode(HTTPException
):
1279 class IncompleteRead(HTTPException
):
1280 def __init__(self
, partial
):
1281 self
.args
= partial
,
1282 self
.partial
= partial
1284 class ImproperConnectionState(HTTPException
):
1287 class CannotSendRequest(ImproperConnectionState
):
1290 class CannotSendHeader(ImproperConnectionState
):
1293 class ResponseNotReady(ImproperConnectionState
):
1296 class BadStatusLine(HTTPException
):
1297 def __init__(self
, line
):
1301 # for backwards compatibility
1302 error
= HTTPException
1304 class LineAndFileWrapper
:
1305 """A limited file-like object for HTTP/0.9 responses."""
1307 # The status-line parsing code calls readline(), which normally
1308 # get the HTTP status line. For a 0.9 response, however, this is
1309 # actually the first line of the body! Clients need to get a
1310 # readable file object that contains that line.
1312 def __init__(self
, line
, file):
1315 self
._line
_consumed
= 0
1316 self
._line
_offset
= 0
1317 self
._line
_left
= len(line
)
1319 def __getattr__(self
, attr
):
1320 return getattr(self
._file
, attr
)
1323 # called when the last byte is read from the line. After the
1324 # call, all read methods are delegated to the underlying file
1326 self
._line
_consumed
= 1
1327 self
.read
= self
._file
.read
1328 self
.readline
= self
._file
.readline
1329 self
.readlines
= self
._file
.readlines
1331 def read(self
, amt
=None):
1332 if self
._line
_consumed
:
1333 return self
._file
.read(amt
)
1334 assert self
._line
_left
1335 if amt
is None or amt
> self
._line
_left
:
1336 s
= self
._line
[self
._line
_offset
:]
1339 return s
+ self
._file
.read()
1341 return s
+ self
._file
.read(amt
- len(s
))
1343 assert amt
<= self
._line
_left
1344 i
= self
._line
_offset
1347 self
._line
_offset
= j
1348 self
._line
_left
-= amt
1349 if self
._line
_left
== 0:
1354 if self
._line
_consumed
:
1355 return self
._file
.readline()
1356 assert self
._line
_left
1357 s
= self
._line
[self
._line
_offset
:]
1361 def readlines(self
, size
=None):
1362 if self
._line
_consumed
:
1363 return self
._file
.readlines(size
)
1364 assert self
._line
_left
1365 L
= [self
._line
[self
._line
_offset
:]]
1368 return L
+ self
._file
.readlines()
1370 return L
+ self
._file
.readlines(size
)
1373 """Test this module.
1375 A hodge podge of tests collected here, because they have too many
1376 external dependencies for the regular test suite.
1381 opts
, args
= getopt
.getopt(sys
.argv
[1:], 'd')
1384 if o
== '-d': dl
= dl
+ 1
1385 host
= 'www.python.org'
1387 if args
[0:]: host
= args
[0]
1388 if args
[1:]: selector
= args
[1]
1390 h
.set_debuglevel(dl
)
1392 h
.putrequest('GET', selector
)
1394 status
, reason
, headers
= h
.getreply()
1395 print 'status =', status
1396 print 'reason =', reason
1397 print "read", len(h
.getfile().read())
1400 for header
in headers
.headers
: print header
.strip()
1403 # minimal test that code to extract host from url works
1406 _http_vsn_str
= 'HTTP/1.1'
1408 h
= HTTP11('www.python.org')
1409 h
.putrequest('GET', 'http://www.python.org/~jeremy/')
1414 if hasattr(socket
, 'ssl'):
1416 for host
, selector
in (('sourceforge.net', '/projects/python'),
1418 print "https://%s%s" % (host
, selector
)
1420 hs
.set_debuglevel(dl
)
1422 hs
.putrequest('GET', selector
)
1424 status
, reason
, headers
= hs
.getreply()
1425 print 'status =', status
1426 print 'reason =', reason
1427 print "read", len(hs
.getfile().read())
1430 for header
in headers
.headers
: print header
.strip()
1433 if __name__
== '__main__':