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):
631 self
.__response
= None
632 self
.__state
= _CS_IDLE
635 self
._set
_hostport
(host
, port
)
636 if strict
is not None:
639 def _set_hostport(self
, host
, port
):
642 j
= host
.rfind(']') # ipv6 addresses have [...]
645 port
= int(host
[i
+1:])
647 raise InvalidURL("nonnumeric port: '%s'" % host
[i
+1:])
650 port
= self
.default_port
651 if host
and host
[0] == '[' and host
[-1] == ']':
656 def set_debuglevel(self
, level
):
657 self
.debuglevel
= level
660 """Connect to the host and port specified in __init__."""
661 msg
= "getaddrinfo returns an empty list"
662 for res
in socket
.getaddrinfo(self
.host
, self
.port
, 0,
664 af
, socktype
, proto
, canonname
, sa
= res
666 self
.sock
= socket
.socket(af
, socktype
, proto
)
667 if self
.debuglevel
> 0:
668 print "connect: (%s, %s)" % (self
.host
, self
.port
)
669 self
.sock
.connect(sa
)
670 except socket
.error
, msg
:
671 if self
.debuglevel
> 0:
672 print 'connect fail:', (self
.host
, self
.port
)
679 raise socket
.error
, msg
682 """Close the connection to the HTTP server."""
684 self
.sock
.close() # close it manually... there may be other refs
687 self
.__response
.close()
688 self
.__response
= None
689 self
.__state
= _CS_IDLE
692 """Send `str' to the server."""
693 if self
.sock
is None:
699 # send the data to the server. if we get a broken pipe, then close
700 # the socket. we want to reconnect when somebody tries to send again.
702 # NOTE: we DO propagate the error, though, because we cannot simply
703 # ignore the error... the caller will know if they can retry.
704 if self
.debuglevel
> 0:
705 print "send:", repr(str)
707 self
.sock
.sendall(str)
708 except socket
.error
, v
:
709 if v
[0] == 32: # Broken pipe
713 def _output(self
, s
):
714 """Add a line of output to the current request buffer.
716 Assumes that the line does *not* end with \\r\\n.
718 self
._buffer
.append(s
)
720 def _send_output(self
):
721 """Send the currently buffered request and clear the buffer.
723 Appends an extra \\r\\n to the buffer.
725 self
._buffer
.extend(("", ""))
726 msg
= "\r\n".join(self
._buffer
)
730 def putrequest(self
, method
, url
, skip_host
=0, skip_accept_encoding
=0):
731 """Send a request to the server.
733 `method' specifies an HTTP request method, e.g. 'GET'.
734 `url' specifies the object being requested, e.g. '/index.html'.
735 `skip_host' if True does not add automatically a 'Host:' header
736 `skip_accept_encoding' if True does not add automatically an
737 'Accept-Encoding:' header
740 # if a prior response has been completed, then forget about it.
741 if self
.__response
and self
.__response
.isclosed():
742 self
.__response
= None
745 # in certain cases, we cannot issue another request on this connection.
747 # 1) we are in the process of sending a request. (_CS_REQ_STARTED)
748 # 2) a response to a previous request has signalled that it is going
749 # to close the connection upon completion.
750 # 3) the headers for the previous response have not been read, thus
751 # we cannot determine whether point (2) is true. (_CS_REQ_SENT)
753 # if there is no prior response, then we can request at will.
755 # if point (2) is true, then we will have passed the socket to the
756 # response (effectively meaning, "there is no prior response"), and
757 # will open a new one when a new request is made.
759 # Note: if a prior response exists, then we *can* start a new request.
760 # We are not allowed to begin fetching the response to this new
761 # request, however, until that prior response is complete.
763 if self
.__state
== _CS_IDLE
:
764 self
.__state
= _CS_REQ_STARTED
766 raise CannotSendRequest()
768 # Save the method we use, we need it later in the response phase
769 self
._method
= method
772 str = '%s %s %s' % (method
, url
, self
._http
_vsn
_str
)
776 if self
._http
_vsn
== 11:
777 # Issue some standard headers for better HTTP/1.1 compliance
780 # this header is issued *only* for HTTP/1.1
781 # connections. more specifically, this means it is
782 # only issued when the client uses the new
783 # HTTPConnection() class. backwards-compat clients
784 # will be using HTTP/1.0 and those clients may be
785 # issuing this header themselves. we should NOT issue
786 # it twice; some web servers (such as Apache) barf
787 # when they see two Host: headers
789 # If we need a non-standard port,include it in the
790 # header. If the request is going through a proxy,
791 # but the host of the actual URL, not the host of the
795 if url
.startswith('http'):
796 nil
, netloc
, nil
, nil
, nil
= urlsplit(url
)
800 netloc_enc
= netloc
.encode("ascii")
801 except UnicodeEncodeError:
802 netloc_enc
= netloc
.encode("idna")
803 self
.putheader('Host', netloc_enc
)
806 host_enc
= self
.host
.encode("ascii")
807 except UnicodeEncodeError:
808 host_enc
= self
.host
.encode("idna")
809 if self
.port
== HTTP_PORT
:
810 self
.putheader('Host', host_enc
)
812 self
.putheader('Host', "%s:%s" % (host_enc
, self
.port
))
814 # note: we are assuming that clients will not attempt to set these
815 # headers since *this* library must deal with the
816 # consequences. this also means that when the supporting
817 # libraries are updated to recognize other forms, then this
818 # code should be changed (removed or updated).
820 # we only want a Content-Encoding of "identity" since we don't
821 # support encodings such as x-gzip or x-deflate.
822 if not skip_accept_encoding
:
823 self
.putheader('Accept-Encoding', 'identity')
825 # we can accept "chunked" Transfer-Encodings, but no others
826 # NOTE: no TE header implies *only* "chunked"
827 #self.putheader('TE', 'chunked')
829 # if TE is supplied in the header, then it must appear in a
831 #self.putheader('Connection', 'TE')
834 # For HTTP/1.0, the server will assume "not chunked"
837 def putheader(self
, header
, value
):
838 """Send a request header line to the server.
840 For example: h.putheader('Accept', 'text/html')
842 if self
.__state
!= _CS_REQ_STARTED
:
843 raise CannotSendHeader()
845 str = '%s: %s' % (header
, value
)
848 def endheaders(self
):
849 """Indicate that the last header line has been sent to the server."""
851 if self
.__state
== _CS_REQ_STARTED
:
852 self
.__state
= _CS_REQ_SENT
854 raise CannotSendHeader()
858 def request(self
, method
, url
, body
=None, headers
={}):
859 """Send a complete request to the server."""
862 self
._send
_request
(method
, url
, body
, headers
)
863 except socket
.error
, v
:
864 # trap 'Broken pipe' if we're allowed to automatically reconnect
865 if v
[0] != 32 or not self
.auto_open
:
868 self
._send
_request
(method
, url
, body
, headers
)
870 def _send_request(self
, method
, url
, body
, headers
):
871 # honour explicitly requested Host: and Accept-Encoding headers
872 header_names
= dict.fromkeys([k
.lower() for k
in headers
])
874 if 'host' in header_names
:
875 skips
['skip_host'] = 1
876 if 'accept-encoding' in header_names
:
877 skips
['skip_accept_encoding'] = 1
879 self
.putrequest(method
, url
, **skips
)
881 if body
and ('content-length' not in header_names
):
882 self
.putheader('Content-Length', str(len(body
)))
883 for hdr
, value
in headers
.iteritems():
884 self
.putheader(hdr
, value
)
890 def getresponse(self
):
891 "Get the response from the server."
893 # if a prior response has been completed, then forget about it.
894 if self
.__response
and self
.__response
.isclosed():
895 self
.__response
= None
898 # if a prior response exists, then it must be completed (otherwise, we
899 # cannot read this response's header to determine the connection-close
902 # note: if a prior response existed, but was connection-close, then the
903 # socket and response were made independent of this HTTPConnection
904 # object since a new request requires that we open a whole new
907 # this means the prior response had one of two states:
908 # 1) will_close: this connection was reset and the prior socket and
909 # response operate independently
910 # 2) persistent: the response was retained and we await its
911 # isclosed() status to become true.
913 if self
.__state
!= _CS_REQ_SENT
or self
.__response
:
914 raise ResponseNotReady()
916 if self
.debuglevel
> 0:
917 response
= self
.response_class(self
.sock
, self
.debuglevel
,
921 response
= self
.response_class(self
.sock
, strict
=self
.strict
,
925 assert response
.will_close
!= _UNKNOWN
926 self
.__state
= _CS_IDLE
928 if response
.will_close
:
929 # Pass the socket to the response
932 # remember this, so we can tell when it is complete
933 self
.__response
= response
937 # The next several classes are used to define FakeSocket, a socket-like
938 # interface to an SSL connection.
940 # The primary complexity comes from faking a makefile() method. The
941 # standard socket makefile() implementation calls dup() on the socket
942 # file descriptor. As a consequence, clients can call close() on the
943 # parent socket and its makefile children in any order. The underlying
944 # socket isn't closed until they are all closed.
946 # The implementation uses reference counting to keep the socket open
947 # until the last client calls close(). SharedSocket keeps track of
948 # the reference counting and SharedSocketClient provides an constructor
949 # and close() method that call incref() and decref() correctly.
953 def __init__(self
, sock
):
962 assert self
._refcnt
>= 0
963 if self
._refcnt
== 0:
969 class SharedSocketClient
:
971 def __init__(self
, shared
):
973 self
._shared
= shared
974 self
._shared
.incref()
975 self
._sock
= shared
.sock
979 self
._shared
.decref()
983 class SSLFile(SharedSocketClient
):
984 """File-like object wrapping an SSL socket."""
988 def __init__(self
, sock
, ssl
, bufsize
=None):
989 SharedSocketClient
.__init
__(self
, sock
)
992 self
._bufsize
= bufsize
or self
.__class
__.BUFSIZE
996 # put in a loop so that we retry on transient errors
999 buf
= self
._ssl
.read(self
._bufsize
)
1000 except socket
.sslerror
, err
:
1001 if (err
[0] == socket
.SSL_ERROR_WANT_READ
1002 or err
[0] == socket
.SSL_ERROR_WANT_WRITE
):
1004 if (err
[0] == socket
.SSL_ERROR_ZERO_RETURN
1005 or err
[0] == socket
.SSL_ERROR_EOF
):
1008 except socket
.error
, err
:
1009 if err
[0] == errno
.EINTR
:
1011 if err
[0] == errno
.EBADF
:
1012 # XXX socket was closed?
1019 def read(self
, size
=None):
1021 avail
= len(self
._buf
)
1022 while size
is None or avail
< size
:
1033 self
._buf
= all
[size
:]
1040 i
= L
[-1].find("\n")
1048 # loop exited because there is no more data
1052 # XXX could do enough bookkeeping not to do a 2nd search
1053 i
= all
.find("\n") + 1
1058 def readlines(self
, sizehint
=0):
1062 line
= self
.readline()
1067 if sizehint
and total
>= sizehint
:
1072 return self
._sock
.fileno()
1078 line
= self
.readline()
1083 class FakeSocket(SharedSocketClient
):
1085 class _closedsocket
:
1086 def __getattr__(self
, name
):
1087 raise error(9, 'Bad file descriptor')
1089 def __init__(self
, sock
, ssl
):
1090 sock
= SharedSocket(sock
)
1091 SharedSocketClient
.__init
__(self
, sock
)
1095 SharedSocketClient
.close(self
)
1096 self
._sock
= self
.__class
__._closedsocket
()
1098 def makefile(self
, mode
, bufsize
=None):
1099 if mode
!= 'r' and mode
!= 'rb':
1100 raise UnimplementedFileMode()
1101 return SSLFile(self
._shared
, self
._ssl
, bufsize
)
1103 def send(self
, stuff
, flags
= 0):
1104 return self
._ssl
.write(stuff
)
1108 def recv(self
, len = 1024, flags
= 0):
1109 return self
._ssl
.read(len)
1111 def __getattr__(self
, attr
):
1112 return getattr(self
._sock
, attr
)
1115 class HTTPSConnection(HTTPConnection
):
1116 "This class allows communication via SSL."
1118 default_port
= HTTPS_PORT
1120 def __init__(self
, host
, port
=None, key_file
=None, cert_file
=None,
1122 HTTPConnection
.__init
__(self
, host
, port
, strict
)
1123 self
.key_file
= key_file
1124 self
.cert_file
= cert_file
1127 "Connect to a host on a given (SSL) port."
1129 sock
= socket
.socket(socket
.AF_INET
, socket
.SOCK_STREAM
)
1130 sock
.connect((self
.host
, self
.port
))
1131 ssl
= socket
.ssl(sock
, self
.key_file
, self
.cert_file
)
1132 self
.sock
= FakeSocket(sock
, ssl
)
1136 "Compatibility class with httplib.py from 1.5."
1139 _http_vsn_str
= 'HTTP/1.0'
1143 _connection_class
= HTTPConnection
1145 def __init__(self
, host
='', port
=None, strict
=None):
1146 "Provide a default host, since the superclass requires one."
1148 # some joker passed 0 explicitly, meaning default port
1152 # Note that we may pass an empty string as the host; this will throw
1153 # an error when we attempt to connect. Presumably, the client code
1154 # will call connect before then, with a proper host.
1155 self
._setup
(self
._connection
_class
(host
, port
, strict
))
1157 def _setup(self
, conn
):
1160 # set up delegation to flesh out interface
1161 self
.send
= conn
.send
1162 self
.putrequest
= conn
.putrequest
1163 self
.endheaders
= conn
.endheaders
1164 self
.set_debuglevel
= conn
.set_debuglevel
1166 conn
._http
_vsn
= self
._http
_vsn
1167 conn
._http
_vsn
_str
= self
._http
_vsn
_str
1171 def connect(self
, host
=None, port
=None):
1172 "Accept arguments to set the host/port, since the superclass doesn't."
1174 if host
is not None:
1175 self
._conn
._set
_hostport
(host
, port
)
1176 self
._conn
.connect()
1179 "Provide a getfile, since the superclass' does not use this concept."
1182 def putheader(self
, header
, *values
):
1183 "The superclass allows only one value argument."
1184 self
._conn
.putheader(header
, '\r\n\t'.join(values
))
1187 """Compat definition since superclass does not define it.
1189 Returns a tuple consisting of:
1190 - server status code (e.g. '200' if all goes well)
1191 - server "reason" corresponding to status code
1192 - any RFC822 headers in the response from the server
1195 response
= self
._conn
.getresponse()
1196 except BadStatusLine
, e
:
1197 ### hmm. if getresponse() ever closes the socket on a bad request,
1198 ### then we are going to have problems with self.sock
1200 ### should we keep this behavior? do people use it?
1201 # keep the socket open (as a file), and return it
1202 self
.file = self
._conn
.sock
.makefile('rb', 0)
1204 # close our socket -- we want to restart after any protocol error
1208 return -1, e
.line
, None
1210 self
.headers
= response
.msg
1211 self
.file = response
.fp
1212 return response
.status
, response
.reason
, response
.msg
1217 # note that self.file == response.fp, which gets closed by the
1218 # superclass. just clear the object ref here.
1219 ### hmm. messy. if status==-1, then self.file is owned by us.
1220 ### well... we aren't explicitly closing, but losing this ref will
1224 if hasattr(socket
, 'ssl'):
1226 """Compatibility with 1.5 httplib interface
1228 Python 1.5.2 did not have an HTTPS class, but it defined an
1229 interface for sending http requests that is also useful for
1233 _connection_class
= HTTPSConnection
1235 def __init__(self
, host
='', port
=None, key_file
=None, cert_file
=None,
1237 # provide a default host, pass the X509 cert info
1239 # urf. compensate for bad input.
1242 self
._setup
(self
._connection
_class
(host
, port
, key_file
,
1245 # we never actually use these for anything, but we keep them
1246 # here for compatibility with post-1.5.2 CVS.
1247 self
.key_file
= key_file
1248 self
.cert_file
= cert_file
1251 class HTTPException(Exception):
1252 # Subclasses that define an __init__ must call Exception.__init__
1253 # or define self.args. Otherwise, str() will fail.
1256 class NotConnected(HTTPException
):
1259 class InvalidURL(HTTPException
):
1262 class UnknownProtocol(HTTPException
):
1263 def __init__(self
, version
):
1264 self
.args
= version
,
1265 self
.version
= version
1267 class UnknownTransferEncoding(HTTPException
):
1270 class UnimplementedFileMode(HTTPException
):
1273 class IncompleteRead(HTTPException
):
1274 def __init__(self
, partial
):
1275 self
.args
= partial
,
1276 self
.partial
= partial
1278 class ImproperConnectionState(HTTPException
):
1281 class CannotSendRequest(ImproperConnectionState
):
1284 class CannotSendHeader(ImproperConnectionState
):
1287 class ResponseNotReady(ImproperConnectionState
):
1290 class BadStatusLine(HTTPException
):
1291 def __init__(self
, line
):
1295 # for backwards compatibility
1296 error
= HTTPException
1298 class LineAndFileWrapper
:
1299 """A limited file-like object for HTTP/0.9 responses."""
1301 # The status-line parsing code calls readline(), which normally
1302 # get the HTTP status line. For a 0.9 response, however, this is
1303 # actually the first line of the body! Clients need to get a
1304 # readable file object that contains that line.
1306 def __init__(self
, line
, file):
1309 self
._line
_consumed
= 0
1310 self
._line
_offset
= 0
1311 self
._line
_left
= len(line
)
1313 def __getattr__(self
, attr
):
1314 return getattr(self
._file
, attr
)
1317 # called when the last byte is read from the line. After the
1318 # call, all read methods are delegated to the underlying file
1320 self
._line
_consumed
= 1
1321 self
.read
= self
._file
.read
1322 self
.readline
= self
._file
.readline
1323 self
.readlines
= self
._file
.readlines
1325 def read(self
, amt
=None):
1326 if self
._line
_consumed
:
1327 return self
._file
.read(amt
)
1328 assert self
._line
_left
1329 if amt
is None or amt
> self
._line
_left
:
1330 s
= self
._line
[self
._line
_offset
:]
1333 return s
+ self
._file
.read()
1335 return s
+ self
._file
.read(amt
- len(s
))
1337 assert amt
<= self
._line
_left
1338 i
= self
._line
_offset
1341 self
._line
_offset
= j
1342 self
._line
_left
-= amt
1343 if self
._line
_left
== 0:
1348 if self
._line
_consumed
:
1349 return self
._file
.readline()
1350 assert self
._line
_left
1351 s
= self
._line
[self
._line
_offset
:]
1355 def readlines(self
, size
=None):
1356 if self
._line
_consumed
:
1357 return self
._file
.readlines(size
)
1358 assert self
._line
_left
1359 L
= [self
._line
[self
._line
_offset
:]]
1362 return L
+ self
._file
.readlines()
1364 return L
+ self
._file
.readlines(size
)
1367 """Test this module.
1369 A hodge podge of tests collected here, because they have too many
1370 external dependencies for the regular test suite.
1375 opts
, args
= getopt
.getopt(sys
.argv
[1:], 'd')
1378 if o
== '-d': dl
= dl
+ 1
1379 host
= 'www.python.org'
1381 if args
[0:]: host
= args
[0]
1382 if args
[1:]: selector
= args
[1]
1384 h
.set_debuglevel(dl
)
1386 h
.putrequest('GET', selector
)
1388 status
, reason
, headers
= h
.getreply()
1389 print 'status =', status
1390 print 'reason =', reason
1391 print "read", len(h
.getfile().read())
1394 for header
in headers
.headers
: print header
.strip()
1397 # minimal test that code to extract host from url works
1400 _http_vsn_str
= 'HTTP/1.1'
1402 h
= HTTP11('www.python.org')
1403 h
.putrequest('GET', 'http://www.python.org/~jeremy/')
1408 if hasattr(socket
, 'ssl'):
1410 for host
, selector
in (('sourceforge.net', '/projects/python'),
1412 print "https://%s%s" % (host
, selector
)
1414 hs
.set_debuglevel(dl
)
1416 hs
.putrequest('GET', selector
)
1418 status
, reason
, headers
= hs
.getreply()
1419 print 'status =', status
1420 print 'reason =', reason
1421 print "read", len(hs
.getfile().read())
1424 for header
in headers
.headers
: print header
.strip()
1427 if __name__
== '__main__':