blob: 188f4f60faec6d6d90e7a1b5f4be53ee536023e2 [file] [log] [blame]
Greg Stein5e0fa402000-06-26 08:28:01 +00001"""HTTP/1.1 client library
Guido van Rossum41999c11997-12-09 00:12:23 +00002
Greg Stein5e0fa402000-06-26 08:28:01 +00003<intro stuff goes here>
4<other stuff, too>
Guido van Rossum41999c11997-12-09 00:12:23 +00005
Thomas Wouters0e3f5912006-08-11 14:57:12 +00006HTTPConnection goes through a number of "states", which define when a client
Greg Stein5e0fa402000-06-26 08:28:01 +00007may legally make another request or fetch the response for a particular
8request. This diagram details these state transitions:
Guido van Rossum41999c11997-12-09 00:12:23 +00009
Greg Stein5e0fa402000-06-26 08:28:01 +000010 (null)
11 |
12 | HTTPConnection()
13 v
14 Idle
15 |
16 | putrequest()
17 v
18 Request-started
19 |
20 | ( putheader() )* endheaders()
21 v
22 Request-sent
23 |
24 | response = getresponse()
25 v
26 Unread-response [Response-headers-read]
27 |\____________________
Tim Peters5ceadc82001-01-13 19:16:21 +000028 | |
29 | response.read() | putrequest()
30 v v
31 Idle Req-started-unread-response
32 ______/|
33 / |
34 response.read() | | ( putheader() )* endheaders()
35 v v
36 Request-started Req-sent-unread-response
37 |
38 | response.read()
39 v
40 Request-sent
Greg Stein5e0fa402000-06-26 08:28:01 +000041
42This 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
47
48Note: 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.
58
59Logical State __state __response
60------------- ------- ----------
61Idle _CS_IDLE None
62Request-started _CS_REQ_STARTED None
63Request-sent _CS_REQ_SENT None
64Unread-response _CS_IDLE <response_class>
65Req-started-unread-response _CS_REQ_STARTED <response_class>
66Req-sent-unread-response _CS_REQ_SENT <response_class>
Guido van Rossum41999c11997-12-09 00:12:23 +000067"""
Guido van Rossum23acc951994-02-21 16:36:04 +000068
Barry Warsaw820c1202008-06-12 04:06:45 +000069import email.parser
70import email.message
Jeremy Hylton636950f2009-03-28 04:34:21 +000071import io
72import os
73import socket
Senthil Kumaran7bc0d872010-12-19 10:49:52 +000074import collections
Jeremy Hylton1afc1692008-06-18 20:49:58 +000075from urllib.parse import urlsplit
Thomas Wouters89d996e2007-09-08 17:39:28 +000076import warnings
Guido van Rossum23acc951994-02-21 16:36:04 +000077
Thomas Wouters47b49bf2007-08-30 22:15:33 +000078__all__ = ["HTTPResponse", "HTTPConnection",
Skip Montanaro951a8842001-06-01 16:25:38 +000079 "HTTPException", "NotConnected", "UnknownProtocol",
Jeremy Hylton7c75c992002-06-28 23:38:14 +000080 "UnknownTransferEncoding", "UnimplementedFileMode",
81 "IncompleteRead", "InvalidURL", "ImproperConnectionState",
82 "CannotSendRequest", "CannotSendHeader", "ResponseNotReady",
Georg Brandl6aab16e2006-02-17 19:17:25 +000083 "BadStatusLine", "error", "responses"]
Skip Montanaro2dd42762001-01-23 15:35:05 +000084
Guido van Rossum23acc951994-02-21 16:36:04 +000085HTTP_PORT = 80
Guido van Rossum09c8b6c1999-12-07 21:37:17 +000086HTTPS_PORT = 443
87
Greg Stein5e0fa402000-06-26 08:28:01 +000088_UNKNOWN = 'UNKNOWN'
89
90# connection states
91_CS_IDLE = 'Idle'
92_CS_REQ_STARTED = 'Request-started'
93_CS_REQ_SENT = 'Request-sent'
94
Martin v. Löwis39a31782004-09-18 09:03:49 +000095# status codes
96# informational
97CONTINUE = 100
98SWITCHING_PROTOCOLS = 101
99PROCESSING = 102
100
101# successful
102OK = 200
103CREATED = 201
104ACCEPTED = 202
105NON_AUTHORITATIVE_INFORMATION = 203
106NO_CONTENT = 204
107RESET_CONTENT = 205
108PARTIAL_CONTENT = 206
109MULTI_STATUS = 207
110IM_USED = 226
111
112# redirection
113MULTIPLE_CHOICES = 300
114MOVED_PERMANENTLY = 301
115FOUND = 302
116SEE_OTHER = 303
117NOT_MODIFIED = 304
118USE_PROXY = 305
119TEMPORARY_REDIRECT = 307
120
121# client error
122BAD_REQUEST = 400
123UNAUTHORIZED = 401
124PAYMENT_REQUIRED = 402
125FORBIDDEN = 403
126NOT_FOUND = 404
127METHOD_NOT_ALLOWED = 405
128NOT_ACCEPTABLE = 406
129PROXY_AUTHENTICATION_REQUIRED = 407
130REQUEST_TIMEOUT = 408
131CONFLICT = 409
132GONE = 410
133LENGTH_REQUIRED = 411
134PRECONDITION_FAILED = 412
135REQUEST_ENTITY_TOO_LARGE = 413
136REQUEST_URI_TOO_LONG = 414
137UNSUPPORTED_MEDIA_TYPE = 415
138REQUESTED_RANGE_NOT_SATISFIABLE = 416
139EXPECTATION_FAILED = 417
140UNPROCESSABLE_ENTITY = 422
141LOCKED = 423
142FAILED_DEPENDENCY = 424
143UPGRADE_REQUIRED = 426
Hynek Schlawack51b2ed52012-05-16 09:51:07 +0200144PRECONDITION_REQUIRED = 428
145TOO_MANY_REQUESTS = 429
146REQUEST_HEADER_FIELDS_TOO_LARGE = 431
Martin v. Löwis39a31782004-09-18 09:03:49 +0000147
148# server error
149INTERNAL_SERVER_ERROR = 500
150NOT_IMPLEMENTED = 501
151BAD_GATEWAY = 502
152SERVICE_UNAVAILABLE = 503
153GATEWAY_TIMEOUT = 504
154HTTP_VERSION_NOT_SUPPORTED = 505
155INSUFFICIENT_STORAGE = 507
156NOT_EXTENDED = 510
Hynek Schlawack51b2ed52012-05-16 09:51:07 +0200157NETWORK_AUTHENTICATION_REQUIRED = 511
Martin v. Löwis39a31782004-09-18 09:03:49 +0000158
Georg Brandl6aab16e2006-02-17 19:17:25 +0000159# Mapping status codes to official W3C names
160responses = {
161 100: 'Continue',
162 101: 'Switching Protocols',
163
164 200: 'OK',
165 201: 'Created',
166 202: 'Accepted',
167 203: 'Non-Authoritative Information',
168 204: 'No Content',
169 205: 'Reset Content',
170 206: 'Partial Content',
171
172 300: 'Multiple Choices',
173 301: 'Moved Permanently',
174 302: 'Found',
175 303: 'See Other',
176 304: 'Not Modified',
177 305: 'Use Proxy',
178 306: '(Unused)',
179 307: 'Temporary Redirect',
180
181 400: 'Bad Request',
182 401: 'Unauthorized',
183 402: 'Payment Required',
184 403: 'Forbidden',
185 404: 'Not Found',
186 405: 'Method Not Allowed',
187 406: 'Not Acceptable',
188 407: 'Proxy Authentication Required',
189 408: 'Request Timeout',
190 409: 'Conflict',
191 410: 'Gone',
192 411: 'Length Required',
193 412: 'Precondition Failed',
194 413: 'Request Entity Too Large',
195 414: 'Request-URI Too Long',
196 415: 'Unsupported Media Type',
197 416: 'Requested Range Not Satisfiable',
198 417: 'Expectation Failed',
Hynek Schlawack51b2ed52012-05-16 09:51:07 +0200199 428: 'Precondition Required',
200 429: 'Too Many Requests',
201 431: 'Request Header Fields Too Large',
Georg Brandl6aab16e2006-02-17 19:17:25 +0000202
203 500: 'Internal Server Error',
204 501: 'Not Implemented',
205 502: 'Bad Gateway',
206 503: 'Service Unavailable',
207 504: 'Gateway Timeout',
208 505: 'HTTP Version Not Supported',
Hynek Schlawack51b2ed52012-05-16 09:51:07 +0200209 511: 'Network Authentication Required',
Georg Brandl6aab16e2006-02-17 19:17:25 +0000210}
211
Georg Brandl80ba8e82005-09-29 20:16:07 +0000212# maximal amount of data to read at one time in _safe_read
213MAXAMOUNT = 1048576
214
Senthil Kumaran5466bf12010-12-18 16:55:23 +0000215# maximal line length when calling readline().
216_MAXLINE = 65536
217
Barry Warsaw820c1202008-06-12 04:06:45 +0000218class HTTPMessage(email.message.Message):
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000219 # XXX The only usage of this method is in
220 # http.server.CGIHTTPRequestHandler. Maybe move the code there so
221 # that it doesn't need to be part of the public API. The API has
222 # never been defined so this could cause backwards compatibility
223 # issues.
224
Barry Warsaw820c1202008-06-12 04:06:45 +0000225 def getallmatchingheaders(self, name):
226 """Find all header lines matching a given header name.
Jeremy Hylton6d0a4c72002-07-07 16:51:37 +0000227
Barry Warsaw820c1202008-06-12 04:06:45 +0000228 Look through the list of headers and find all lines matching a given
229 header name (and their continuation lines). A list of the lines is
230 returned, without interpretation. If the header does not occur, an
231 empty list is returned. If the header occurs multiple times, all
232 occurrences are returned. Case is not important in the header name.
Jeremy Hylton6d0a4c72002-07-07 16:51:37 +0000233
Jeremy Hylton6d0a4c72002-07-07 16:51:37 +0000234 """
Barry Warsaw820c1202008-06-12 04:06:45 +0000235 name = name.lower() + ':'
236 n = len(name)
237 lst = []
238 hit = 0
239 for line in self.keys():
240 if line[:n].lower() == name:
241 hit = 1
242 elif not line[:1].isspace():
243 hit = 0
244 if hit:
245 lst.append(line)
246 return lst
Jeremy Hylton6d0a4c72002-07-07 16:51:37 +0000247
Jeremy Hylton98eb6c22009-03-27 18:31:36 +0000248def parse_headers(fp, _class=HTTPMessage):
Barry Warsaw820c1202008-06-12 04:06:45 +0000249 """Parses only RFC2822 headers from a file pointer.
250
251 email Parser wants to see strings rather than bytes.
252 But a TextIOWrapper around self.rfile would buffer too many bytes
253 from the stream, bytes which we later need to read as bytes.
254 So we read the correct bytes here, as bytes, for email Parser
255 to parse.
256
257 """
Barry Warsaw820c1202008-06-12 04:06:45 +0000258 headers = []
259 while True:
Senthil Kumaran5466bf12010-12-18 16:55:23 +0000260 line = fp.readline(_MAXLINE + 1)
261 if len(line) > _MAXLINE:
262 raise LineTooLong("header line")
Barry Warsaw820c1202008-06-12 04:06:45 +0000263 headers.append(line)
264 if line in (b'\r\n', b'\n', b''):
265 break
266 hstring = b''.join(headers).decode('iso-8859-1')
Jeremy Hylton98eb6c22009-03-27 18:31:36 +0000267 return email.parser.Parser(_class=_class).parsestr(hstring)
Greg Stein5e0fa402000-06-26 08:28:01 +0000268
Jeremy Hyltond46aa372002-07-06 18:48:07 +0000269
Antoine Pitrou988dbd72010-12-17 17:35:56 +0000270class HTTPResponse(io.RawIOBase):
Jeremy Hyltond46aa372002-07-06 18:48:07 +0000271
272 # See RFC 2616 sec 19.6 and RFC 1945 sec 6 for details.
273
Jeremy Hylton811fc142007-08-03 13:30:02 +0000274 # The bytes from the socket object are iso-8859-1 strings.
275 # See RFC 2616 sec 2.2 which notes an exception for MIME-encoded
276 # text following RFC 2047. The basic status line parsing only
277 # accepts iso-8859-1.
278
Senthil Kumaran052ddb02013-03-18 14:11:41 -0700279 def __init__(self, sock, debuglevel=0, method=None, url=None):
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000280 # If the response includes a content-length header, we need to
281 # make sure that the client doesn't read more than the
Jeremy Hylton39b198d2007-08-04 19:22:00 +0000282 # specified number of bytes. If it does, it will block until
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000283 # the server times out and closes the connection. This will
284 # happen if a self.fp.read() is done (without a size) whether
285 # self.fp is buffered or not. So, no self.fp.read() by
286 # clients unless they know what they are doing.
Benjamin Petersonf72d9fb2009-02-08 00:29:20 +0000287 self.fp = sock.makefile("rb")
Jeremy Hylton30f86742000-09-18 22:50:38 +0000288 self.debuglevel = debuglevel
Jeremy Hyltonc1b2cb92003-05-05 16:13:58 +0000289 self._method = method
Greg Stein5e0fa402000-06-26 08:28:01 +0000290
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000291 # The HTTPResponse object is returned via urllib. The clients
292 # of http and urllib expect different attributes for the
293 # headers. headers is used here and supports urllib. msg is
294 # provided as a backwards compatibility layer for http
295 # clients.
296
297 self.headers = self.msg = None
Greg Stein5e0fa402000-06-26 08:28:01 +0000298
Greg Steindd6eefb2000-07-18 09:09:48 +0000299 # from the Status-Line of the response
Tim Peters07e99cb2001-01-14 23:47:14 +0000300 self.version = _UNKNOWN # HTTP-Version
301 self.status = _UNKNOWN # Status-Code
302 self.reason = _UNKNOWN # Reason-Phrase
Greg Stein5e0fa402000-06-26 08:28:01 +0000303
Tim Peters07e99cb2001-01-14 23:47:14 +0000304 self.chunked = _UNKNOWN # is "chunked" being used?
305 self.chunk_left = _UNKNOWN # bytes left to read in current chunk
306 self.length = _UNKNOWN # number of bytes left in response
307 self.will_close = _UNKNOWN # conn will close at end of response
Greg Stein5e0fa402000-06-26 08:28:01 +0000308
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000309 def _read_status(self):
Senthil Kumaran5466bf12010-12-18 16:55:23 +0000310 line = str(self.fp.readline(_MAXLINE + 1), "iso-8859-1")
311 if len(line) > _MAXLINE:
312 raise LineTooLong("status line")
Jeremy Hylton30f86742000-09-18 22:50:38 +0000313 if self.debuglevel > 0:
Guido van Rossumbe19ed72007-02-09 05:37:30 +0000314 print("reply:", repr(line))
Jeremy Hyltonb6769522003-06-29 17:55:05 +0000315 if not line:
316 # Presumably, the server closed the connection before
317 # sending a valid response.
318 raise BadStatusLine(line)
Greg Steindd6eefb2000-07-18 09:09:48 +0000319 try:
Antoine Pitrou988dbd72010-12-17 17:35:56 +0000320 version, status, reason = line.split(None, 2)
Greg Steindd6eefb2000-07-18 09:09:48 +0000321 except ValueError:
322 try:
Antoine Pitrou988dbd72010-12-17 17:35:56 +0000323 version, status = line.split(None, 1)
Greg Steindd6eefb2000-07-18 09:09:48 +0000324 reason = ""
325 except ValueError:
Antoine Pitrou988dbd72010-12-17 17:35:56 +0000326 # empty version will cause next test to fail.
Jeremy Hyltond46aa372002-07-06 18:48:07 +0000327 version = ""
Jeremy Hyltone5d0e842007-08-03 13:45:24 +0000328 if not version.startswith("HTTP/"):
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200329 self._close_conn()
Antoine Pitrou988dbd72010-12-17 17:35:56 +0000330 raise BadStatusLine(line)
Greg Stein5e0fa402000-06-26 08:28:01 +0000331
Jeremy Hylton23d40472001-04-13 14:57:08 +0000332 # The status code is a three-digit number
333 try:
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000334 status = int(status)
Jeremy Hylton23d40472001-04-13 14:57:08 +0000335 if status < 100 or status > 999:
336 raise BadStatusLine(line)
337 except ValueError:
338 raise BadStatusLine(line)
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000339 return version, status, reason
Greg Stein5e0fa402000-06-26 08:28:01 +0000340
Jeremy Hylton39c03802002-07-12 14:04:09 +0000341 def begin(self):
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000342 if self.headers is not None:
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000343 # we've already started reading the response
344 return
345
346 # read until we get a non-100 response
Raymond Hettingerb2e0b922003-02-26 22:45:18 +0000347 while True:
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000348 version, status, reason = self._read_status()
Martin v. Löwis39a31782004-09-18 09:03:49 +0000349 if status != CONTINUE:
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000350 break
351 # skip the header from the 100 response
Raymond Hettingerb2e0b922003-02-26 22:45:18 +0000352 while True:
Senthil Kumaran5466bf12010-12-18 16:55:23 +0000353 skip = self.fp.readline(_MAXLINE + 1)
354 if len(skip) > _MAXLINE:
355 raise LineTooLong("header line")
356 skip = skip.strip()
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000357 if not skip:
358 break
359 if self.debuglevel > 0:
Guido van Rossumbe19ed72007-02-09 05:37:30 +0000360 print("header:", skip)
Tim Petersc411dba2002-07-16 21:35:23 +0000361
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000362 self.code = self.status = status
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +0000363 self.reason = reason.strip()
Antoine Pitrou988dbd72010-12-17 17:35:56 +0000364 if version in ("HTTP/1.0", "HTTP/0.9"):
365 # Some servers might still return "0.9", treat it as 1.0 anyway
Greg Steindd6eefb2000-07-18 09:09:48 +0000366 self.version = 10
Jeremy Hyltone5d0e842007-08-03 13:45:24 +0000367 elif version.startswith("HTTP/1."):
Tim Peters07e99cb2001-01-14 23:47:14 +0000368 self.version = 11 # use HTTP/1.1 code for HTTP/1.x where x>=1
Greg Steindd6eefb2000-07-18 09:09:48 +0000369 else:
370 raise UnknownProtocol(version)
Greg Stein5e0fa402000-06-26 08:28:01 +0000371
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000372 self.headers = self.msg = parse_headers(self.fp)
Barry Warsaw820c1202008-06-12 04:06:45 +0000373
Jeremy Hylton30f86742000-09-18 22:50:38 +0000374 if self.debuglevel > 0:
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000375 for hdr in self.headers:
Jeremy Hyltone5d0e842007-08-03 13:45:24 +0000376 print("header:", hdr, end=" ")
Greg Stein5e0fa402000-06-26 08:28:01 +0000377
Greg Steindd6eefb2000-07-18 09:09:48 +0000378 # are we using the chunked-style of transfer encoding?
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000379 tr_enc = self.headers.get("transfer-encoding")
Jeremy Hyltond229b3a2002-09-03 19:24:24 +0000380 if tr_enc and tr_enc.lower() == "chunked":
Jeremy Hylton236156f2008-12-15 03:00:50 +0000381 self.chunked = True
Greg Steindd6eefb2000-07-18 09:09:48 +0000382 self.chunk_left = None
383 else:
Jeremy Hylton236156f2008-12-15 03:00:50 +0000384 self.chunked = False
Greg Stein5e0fa402000-06-26 08:28:01 +0000385
Greg Steindd6eefb2000-07-18 09:09:48 +0000386 # will the connection close at the end of the response?
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000387 self.will_close = self._check_close()
Greg Stein5e0fa402000-06-26 08:28:01 +0000388
Greg Steindd6eefb2000-07-18 09:09:48 +0000389 # do we have a Content-Length?
390 # NOTE: RFC 2616, S4.4, #3 says we ignore this if tr_enc is "chunked"
Jeremy Hylton0ee5eeb2007-08-04 03:25:17 +0000391 self.length = None
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000392 length = self.headers.get("content-length")
Barry Warsaw820c1202008-06-12 04:06:45 +0000393
394 # are we using the chunked-style of transfer encoding?
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000395 tr_enc = self.headers.get("transfer-encoding")
Greg Steindd6eefb2000-07-18 09:09:48 +0000396 if length and not self.chunked:
Jeremy Hylton30a81812000-09-14 20:34:27 +0000397 try:
398 self.length = int(length)
399 except ValueError:
Christian Heimesa612dc02008-02-24 13:08:18 +0000400 self.length = None
401 else:
402 if self.length < 0: # ignore nonsensical negative lengths
403 self.length = None
404 else:
405 self.length = None
Greg Stein5e0fa402000-06-26 08:28:01 +0000406
Greg Steindd6eefb2000-07-18 09:09:48 +0000407 # does the body have a fixed length? (of zero)
Martin v. Löwis39a31782004-09-18 09:03:49 +0000408 if (status == NO_CONTENT or status == NOT_MODIFIED or
Jeremy Hyltonc1b2cb92003-05-05 16:13:58 +0000409 100 <= status < 200 or # 1xx codes
Jeremy Hyltone5d0e842007-08-03 13:45:24 +0000410 self._method == "HEAD"):
Greg Steindd6eefb2000-07-18 09:09:48 +0000411 self.length = 0
Greg Stein5e0fa402000-06-26 08:28:01 +0000412
Greg Steindd6eefb2000-07-18 09:09:48 +0000413 # if the connection remains open, and we aren't using chunked, and
414 # a content-length was not provided, then assume that the connection
415 # WILL close.
Jeremy Hylton0ee5eeb2007-08-04 03:25:17 +0000416 if (not self.will_close and
417 not self.chunked and
418 self.length is None):
Jeremy Hylton236156f2008-12-15 03:00:50 +0000419 self.will_close = True
Greg Stein5e0fa402000-06-26 08:28:01 +0000420
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000421 def _check_close(self):
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000422 conn = self.headers.get("connection")
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000423 if self.version == 11:
424 # An HTTP/1.1 proxy is assumed to stay open unless
425 # explicitly closed.
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000426 conn = self.headers.get("connection")
Raymond Hettingerbac788a2004-05-04 09:21:43 +0000427 if conn and "close" in conn.lower():
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000428 return True
429 return False
430
Jeremy Hylton2c178252004-08-07 16:28:14 +0000431 # Some HTTP/1.0 implementations have support for persistent
432 # connections, using rules different than HTTP/1.1.
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000433
Christian Heimes895627f2007-12-08 17:28:33 +0000434 # For older HTTP, Keep-Alive indicates persistent connection.
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000435 if self.headers.get("keep-alive"):
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000436 return False
Tim Peters77c06fb2002-11-24 02:35:35 +0000437
Jeremy Hylton2c178252004-08-07 16:28:14 +0000438 # At least Akamai returns a "Connection: Keep-Alive" header,
439 # which was supposed to be sent by the client.
440 if conn and "keep-alive" in conn.lower():
441 return False
442
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000443 # Proxy-Connection is a netscape hack.
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000444 pconn = self.headers.get("proxy-connection")
Raymond Hettingerbac788a2004-05-04 09:21:43 +0000445 if pconn and "keep-alive" in pconn.lower():
Jeremy Hylton22b3a492002-11-13 17:27:43 +0000446 return False
447
448 # otherwise, assume it will close
449 return True
450
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200451 def _close_conn(self):
452 fp = self.fp
453 self.fp = None
454 fp.close()
455
Greg Steindd6eefb2000-07-18 09:09:48 +0000456 def close(self):
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200457 super().close() # set "closed" flag
Greg Steindd6eefb2000-07-18 09:09:48 +0000458 if self.fp:
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200459 self._close_conn()
Greg Stein5e0fa402000-06-26 08:28:01 +0000460
Jeremy Hyltondf5f6b52007-08-08 17:36:33 +0000461 # These implementations are for the benefit of io.BufferedReader.
462
463 # XXX This class should probably be revised to act more like
464 # the "raw stream" that BufferedReader expects.
465
Jeremy Hyltondf5f6b52007-08-08 17:36:33 +0000466 def flush(self):
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200467 super().flush()
468 if self.fp:
469 self.fp.flush()
Jeremy Hyltondf5f6b52007-08-08 17:36:33 +0000470
Jeremy Hyltona7cff022009-04-01 02:35:56 +0000471 def readable(self):
472 return True
473
Jeremy Hyltondf5f6b52007-08-08 17:36:33 +0000474 # End of "raw stream" methods
475
Greg Steindd6eefb2000-07-18 09:09:48 +0000476 def isclosed(self):
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200477 """True if the connection is closed."""
Greg Steindd6eefb2000-07-18 09:09:48 +0000478 # NOTE: it is possible that we will not ever call self.close(). This
479 # case occurs when will_close is TRUE, length is None, and we
480 # read up to the last byte, but NOT past it.
481 #
482 # IMPLIES: if will_close is FALSE, then self.close() will ALWAYS be
483 # called, meaning self.isclosed() is meaningful.
484 return self.fp is None
485
486 def read(self, amt=None):
487 if self.fp is None:
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000488 return b""
Greg Steindd6eefb2000-07-18 09:09:48 +0000489
Senthil Kumaran71fb6c82010-04-28 17:39:48 +0000490 if self._method == "HEAD":
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200491 self._close_conn()
Senthil Kumaran71fb6c82010-04-28 17:39:48 +0000492 return b""
493
Antoine Pitrou38d96432011-12-06 22:33:57 +0100494 if amt is not None:
495 # Amount is given, so call base class version
496 # (which is implemented in terms of self.readinto)
497 return super(HTTPResponse, self).read(amt)
498 else:
499 # Amount is not given (unbounded read) so we must check self.length
500 # and self.chunked
Tim Peters230a60c2002-11-09 05:08:07 +0000501
Antoine Pitrou38d96432011-12-06 22:33:57 +0100502 if self.chunked:
503 return self._readall_chunked()
504
Jeremy Hyltondef9d2a2004-11-07 16:13:49 +0000505 if self.length is None:
Greg Steindd6eefb2000-07-18 09:09:48 +0000506 s = self.fp.read()
507 else:
Antoine Pitroubeec61a2013-02-02 22:49:34 +0100508 try:
509 s = self._safe_read(self.length)
510 except IncompleteRead:
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200511 self._close_conn()
Antoine Pitroubeec61a2013-02-02 22:49:34 +0100512 raise
Jeremy Hyltondef9d2a2004-11-07 16:13:49 +0000513 self.length = 0
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200514 self._close_conn() # we read everything
Greg Steindd6eefb2000-07-18 09:09:48 +0000515 return s
516
Antoine Pitrou38d96432011-12-06 22:33:57 +0100517 def readinto(self, b):
518 if self.fp is None:
519 return 0
520
521 if self._method == "HEAD":
Serhiy Storchakab6c86fd2013-02-06 10:35:40 +0200522 self._close_conn()
Antoine Pitrou38d96432011-12-06 22:33:57 +0100523 return 0
524
525 if self.chunked:
526 return self._readinto_chunked(b)
527
Greg Steindd6eefb2000-07-18 09:09:48 +0000528 if self.length is not None:
Antoine Pitrou38d96432011-12-06 22:33:57 +0100529 if len(b) > self.length:
Greg Steindd6eefb2000-07-18 09:09:48 +0000530 # clip the read to the "end of response"
Antoine Pitrou38d96432011-12-06 22:33:57 +0100531 b = memoryview(b)[0:self.length]
Greg Steindd6eefb2000-07-18 09:09:48 +0000532
533 # we do not use _safe_read() here because this may be a .will_close
534 # connection, and the user is reading more bytes than will be provided
535 # (for example, reading in 1k chunks)
Antoine Pitrou38d96432011-12-06 22:33:57 +0100536 n = self.fp.readinto(b)
Antoine Pitrou6a35e182013-02-02 23:04:56 +0100537 if not n:
Antoine Pitroubeec61a2013-02-02 22:49:34 +0100538 # Ideally, we would raise IncompleteRead if the content-length
539 # wasn't satisfied, but it might break compatibility.
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200540 self._close_conn()
Antoine Pitrou6a35e182013-02-02 23:04:56 +0100541 elif self.length is not None:
Antoine Pitrou38d96432011-12-06 22:33:57 +0100542 self.length -= n
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000543 if not self.length:
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200544 self._close_conn()
Antoine Pitrou38d96432011-12-06 22:33:57 +0100545 return n
Greg Steindd6eefb2000-07-18 09:09:48 +0000546
Antoine Pitrou38d96432011-12-06 22:33:57 +0100547 def _read_next_chunk_size(self):
548 # Read the next chunk size from the file
549 line = self.fp.readline(_MAXLINE + 1)
550 if len(line) > _MAXLINE:
551 raise LineTooLong("chunk size")
552 i = line.find(b";")
553 if i >= 0:
554 line = line[:i] # strip chunk-extensions
555 try:
556 return int(line, 16)
557 except ValueError:
558 # close the connection as protocol synchronisation is
559 # probably lost
Serhiy Storchakab6c86fd2013-02-06 10:35:40 +0200560 self._close_conn()
Antoine Pitrou38d96432011-12-06 22:33:57 +0100561 raise
Jeremy Hyltond4c472c2002-09-03 20:49:06 +0000562
Antoine Pitrou38d96432011-12-06 22:33:57 +0100563 def _read_and_discard_trailer(self):
Jeremy Hyltond4c472c2002-09-03 20:49:06 +0000564 # read and discard trailer up to the CRLF terminator
565 ### note: we shouldn't have any trailers!
Raymond Hettingerb2e0b922003-02-26 22:45:18 +0000566 while True:
Senthil Kumaran5466bf12010-12-18 16:55:23 +0000567 line = self.fp.readline(_MAXLINE + 1)
568 if len(line) > _MAXLINE:
569 raise LineTooLong("trailer line")
Christian Heimes0bd4e112008-02-12 22:59:25 +0000570 if not line:
571 # a vanishingly small number of sites EOF without
572 # sending the trailer
573 break
Senthil Kumaran7e70a5c2012-04-29 10:39:49 +0800574 if line in (b'\r\n', b'\n', b''):
Jeremy Hyltond4c472c2002-09-03 20:49:06 +0000575 break
576
Antoine Pitrou38d96432011-12-06 22:33:57 +0100577 def _readall_chunked(self):
578 assert self.chunked != _UNKNOWN
579 chunk_left = self.chunk_left
580 value = []
581 while True:
582 if chunk_left is None:
583 try:
584 chunk_left = self._read_next_chunk_size()
585 if chunk_left == 0:
586 break
587 except ValueError:
588 raise IncompleteRead(b''.join(value))
589 value.append(self._safe_read(chunk_left))
590
591 # we read the whole chunk, get another
592 self._safe_read(2) # toss the CRLF at the end of the chunk
593 chunk_left = None
594
595 self._read_and_discard_trailer()
596
Jeremy Hyltond4c472c2002-09-03 20:49:06 +0000597 # we read everything; close the "file"
Serhiy Storchakab5b9c8c2013-02-06 10:31:57 +0200598 self._close_conn()
Jeremy Hyltond4c472c2002-09-03 20:49:06 +0000599
Chris Withers9c33cbf2009-09-04 17:04:16 +0000600 return b''.join(value)
Tim Peters230a60c2002-11-09 05:08:07 +0000601
Antoine Pitrou38d96432011-12-06 22:33:57 +0100602 def _readinto_chunked(self, b):
603 assert self.chunked != _UNKNOWN
604 chunk_left = self.chunk_left
605
606 total_bytes = 0
607 mvb = memoryview(b)
608 while True:
609 if chunk_left is None:
610 try:
611 chunk_left = self._read_next_chunk_size()
612 if chunk_left == 0:
613 break
614 except ValueError:
615 raise IncompleteRead(bytes(b[0:total_bytes]))
Antoine Pitrou4ce6aa42011-12-06 22:34:36 +0100616
Antoine Pitrou38d96432011-12-06 22:33:57 +0100617 if len(mvb) < chunk_left:
618 n = self._safe_readinto(mvb)
619 self.chunk_left = chunk_left - n
Antoine Pitrouf7e78182012-01-04 18:57:22 +0100620 return total_bytes + n
Antoine Pitrou38d96432011-12-06 22:33:57 +0100621 elif len(mvb) == chunk_left:
622 n = self._safe_readinto(mvb)
623 self._safe_read(2) # toss the CRLF at the end of the chunk
624 self.chunk_left = None
Antoine Pitrouf7e78182012-01-04 18:57:22 +0100625 return total_bytes + n
Antoine Pitrou38d96432011-12-06 22:33:57 +0100626 else:
627 temp_mvb = mvb[0:chunk_left]
628 n = self._safe_readinto(temp_mvb)
629 mvb = mvb[n:]
630 total_bytes += n
631
632 # we read the whole chunk, get another
633 self._safe_read(2) # toss the CRLF at the end of the chunk
634 chunk_left = None
635
636 self._read_and_discard_trailer()
637
638 # we read everything; close the "file"
Serhiy Storchakab6c86fd2013-02-06 10:35:40 +0200639 self._close_conn()
Antoine Pitrou38d96432011-12-06 22:33:57 +0100640
641 return total_bytes
642
Greg Steindd6eefb2000-07-18 09:09:48 +0000643 def _safe_read(self, amt):
644 """Read the number of bytes requested, compensating for partial reads.
645
646 Normally, we have a blocking socket, but a read() can be interrupted
647 by a signal (resulting in a partial read).
648
649 Note that we cannot distinguish between EOF and an interrupt when zero
650 bytes have been read. IncompleteRead() will be raised in this
651 situation.
652
653 This function should be used when <amt> bytes "should" be present for
654 reading. If the bytes are truly not available (due to EOF), then the
655 IncompleteRead exception can be used to detect the problem.
656 """
Georg Brandl80ba8e82005-09-29 20:16:07 +0000657 s = []
Greg Steindd6eefb2000-07-18 09:09:48 +0000658 while amt > 0:
Georg Brandl80ba8e82005-09-29 20:16:07 +0000659 chunk = self.fp.read(min(amt, MAXAMOUNT))
Greg Steindd6eefb2000-07-18 09:09:48 +0000660 if not chunk:
Benjamin Peterson6accb982009-03-02 22:50:25 +0000661 raise IncompleteRead(b''.join(s), amt)
Georg Brandl80ba8e82005-09-29 20:16:07 +0000662 s.append(chunk)
Raymond Hettingerb2e0b922003-02-26 22:45:18 +0000663 amt -= len(chunk)
Guido van Rossuma00f1232007-09-12 19:43:09 +0000664 return b"".join(s)
Greg Steindd6eefb2000-07-18 09:09:48 +0000665
Antoine Pitrou38d96432011-12-06 22:33:57 +0100666 def _safe_readinto(self, b):
667 """Same as _safe_read, but for reading into a buffer."""
668 total_bytes = 0
669 mvb = memoryview(b)
670 while total_bytes < len(b):
671 if MAXAMOUNT < len(mvb):
672 temp_mvb = mvb[0:MAXAMOUNT]
673 n = self.fp.readinto(temp_mvb)
674 else:
675 n = self.fp.readinto(mvb)
676 if not n:
677 raise IncompleteRead(bytes(mvb[0:total_bytes]), len(b))
678 mvb = mvb[n:]
679 total_bytes += n
680 return total_bytes
681
Antoine Pitroub353c122009-02-11 00:39:14 +0000682 def fileno(self):
683 return self.fp.fileno()
684
Greg Steindd6eefb2000-07-18 09:09:48 +0000685 def getheader(self, name, default=None):
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000686 if self.headers is None:
Greg Steindd6eefb2000-07-18 09:09:48 +0000687 raise ResponseNotReady()
Senthil Kumaran9f8dc442010-08-02 11:04:58 +0000688 headers = self.headers.get_all(name) or default
689 if isinstance(headers, str) or not hasattr(headers, '__iter__'):
690 return headers
691 else:
692 return ', '.join(headers)
Greg Stein5e0fa402000-06-26 08:28:01 +0000693
Martin v. Löwisdeacce22004-08-18 12:46:26 +0000694 def getheaders(self):
695 """Return list of (header, value) tuples."""
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000696 if self.headers is None:
Martin v. Löwisdeacce22004-08-18 12:46:26 +0000697 raise ResponseNotReady()
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000698 return list(self.headers.items())
Martin v. Löwisdeacce22004-08-18 12:46:26 +0000699
Antoine Pitroub353c122009-02-11 00:39:14 +0000700 # We override IOBase.__iter__ so that it doesn't check for closed-ness
701
702 def __iter__(self):
703 return self
704
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000705 # For compatibility with old-style urllib responses.
706
707 def info(self):
708 return self.headers
709
710 def geturl(self):
711 return self.url
712
713 def getcode(self):
714 return self.status
Greg Stein5e0fa402000-06-26 08:28:01 +0000715
716class HTTPConnection:
717
Greg Steindd6eefb2000-07-18 09:09:48 +0000718 _http_vsn = 11
719 _http_vsn_str = 'HTTP/1.1'
Greg Stein5e0fa402000-06-26 08:28:01 +0000720
Greg Steindd6eefb2000-07-18 09:09:48 +0000721 response_class = HTTPResponse
722 default_port = HTTP_PORT
723 auto_open = 1
Jeremy Hylton30f86742000-09-18 22:50:38 +0000724 debuglevel = 0
Antoine Pitrou90e47742013-01-02 22:10:47 +0100725 # TCP Maximum Segment Size (MSS) is determined by the TCP stack on
726 # a per-connection basis. There is no simple and efficient
727 # platform independent mechanism for determining the MSS, so
728 # instead a reasonable estimate is chosen. The getsockopt()
729 # interface using the TCP_MAXSEG parameter may be a suitable
730 # approach on some operating systems. A value of 16KiB is chosen
731 # as a reasonable estimate of the maximum MSS.
732 mss = 16384
Greg Stein5e0fa402000-06-26 08:28:01 +0000733
Senthil Kumaran052ddb02013-03-18 14:11:41 -0700734 def __init__(self, host, port=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
735 source_address=None):
Guido van Rossumd8faa362007-04-27 19:54:29 +0000736 self.timeout = timeout
Gregory P. Smithb4066372010-01-03 03:28:29 +0000737 self.source_address = source_address
Greg Steindd6eefb2000-07-18 09:09:48 +0000738 self.sock = None
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000739 self._buffer = []
Greg Steindd6eefb2000-07-18 09:09:48 +0000740 self.__response = None
741 self.__state = _CS_IDLE
Jeremy Hyltonc1b2cb92003-05-05 16:13:58 +0000742 self._method = None
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000743 self._tunnel_host = None
744 self._tunnel_port = None
Georg Brandlc7c199f2011-01-22 22:06:24 +0000745 self._tunnel_headers = {}
Tim Petersc411dba2002-07-16 21:35:23 +0000746
Greg Steindd6eefb2000-07-18 09:09:48 +0000747 self._set_hostport(host, port)
Greg Stein5e0fa402000-06-26 08:28:01 +0000748
Senthil Kumaran47fff872009-12-20 07:10:31 +0000749 def set_tunnel(self, host, port=None, headers=None):
750 """ Sets up the host and the port for the HTTP CONNECT Tunnelling.
751
752 The headers argument should be a mapping of extra HTTP headers
753 to send with the CONNECT request.
754 """
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000755 self._tunnel_host = host
756 self._tunnel_port = port
Senthil Kumaran47fff872009-12-20 07:10:31 +0000757 if headers:
758 self._tunnel_headers = headers
759 else:
760 self._tunnel_headers.clear()
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000761
Greg Steindd6eefb2000-07-18 09:09:48 +0000762 def _set_hostport(self, host, port):
763 if port is None:
Skip Montanaro10e6e0e2004-09-14 16:32:02 +0000764 i = host.rfind(':')
Skip Montanarocae14d22004-09-14 17:55:21 +0000765 j = host.rfind(']') # ipv6 addresses have [...]
766 if i > j:
Skip Montanaro9d389972002-03-24 16:53:50 +0000767 try:
768 port = int(host[i+1:])
769 except ValueError:
Łukasz Langaa5a9a9c2011-10-18 21:17:39 +0200770 if host[i+1:] == "": # http://foo.com:/ == http://foo.com/
771 port = self.default_port
772 else:
773 raise InvalidURL("nonnumeric port: '%s'" % host[i+1:])
Greg Steindd6eefb2000-07-18 09:09:48 +0000774 host = host[:i]
775 else:
776 port = self.default_port
Raymond Hettinger4d037912004-10-14 15:23:38 +0000777 if host and host[0] == '[' and host[-1] == ']':
Brett Cannon0a1af4a2004-09-15 23:26:23 +0000778 host = host[1:-1]
Greg Steindd6eefb2000-07-18 09:09:48 +0000779 self.host = host
780 self.port = port
Greg Stein5e0fa402000-06-26 08:28:01 +0000781
Jeremy Hylton30f86742000-09-18 22:50:38 +0000782 def set_debuglevel(self, level):
783 self.debuglevel = level
784
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000785 def _tunnel(self):
786 self._set_hostport(self._tunnel_host, self._tunnel_port)
Georg Brandlc7c199f2011-01-22 22:06:24 +0000787 connect_str = "CONNECT %s:%d HTTP/1.0\r\n" % (self.host, self.port)
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000788 connect_bytes = connect_str.encode("ascii")
789 self.send(connect_bytes)
Georg Brandlc7c199f2011-01-22 22:06:24 +0000790 for header, value in self._tunnel_headers.items():
Senthil Kumaran47fff872009-12-20 07:10:31 +0000791 header_str = "%s: %s\r\n" % (header, value)
Marc-André Lemburg8f36af72011-02-25 15:42:01 +0000792 header_bytes = header_str.encode("latin-1")
Senthil Kumaran47fff872009-12-20 07:10:31 +0000793 self.send(header_bytes)
Georg Brandlc7c199f2011-01-22 22:06:24 +0000794 self.send(b'\r\n')
Senthil Kumaran47fff872009-12-20 07:10:31 +0000795
Georg Brandlc7c199f2011-01-22 22:06:24 +0000796 response = self.response_class(self.sock, method=self._method)
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000797 (version, code, message) = response._read_status()
Senthil Kumaran47fff872009-12-20 07:10:31 +0000798
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000799 if code != 200:
800 self.close()
Andrew Svetlov0832af62012-12-18 23:10:48 +0200801 raise OSError("Tunnel connection failed: %d %s" % (code,
802 message.strip()))
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000803 while True:
Senthil Kumaran5466bf12010-12-18 16:55:23 +0000804 line = response.fp.readline(_MAXLINE + 1)
805 if len(line) > _MAXLINE:
806 raise LineTooLong("header line")
Senthil Kumaranb12771a2012-04-23 23:50:07 +0800807 if not line:
808 # for sites which EOF without sending a trailer
809 break
Senthil Kumaran7e70a5c2012-04-29 10:39:49 +0800810 if line in (b'\r\n', b'\n', b''):
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000811 break
812
Greg Steindd6eefb2000-07-18 09:09:48 +0000813 def connect(self):
814 """Connect to the host and port specified in __init__."""
Guido van Rossumd8faa362007-04-27 19:54:29 +0000815 self.sock = socket.create_connection((self.host,self.port),
Gregory P. Smithb4066372010-01-03 03:28:29 +0000816 self.timeout, self.source_address)
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +0000817 if self._tunnel_host:
818 self._tunnel()
Greg Stein5e0fa402000-06-26 08:28:01 +0000819
Greg Steindd6eefb2000-07-18 09:09:48 +0000820 def close(self):
821 """Close the connection to the HTTP server."""
822 if self.sock:
Tim Peters07e99cb2001-01-14 23:47:14 +0000823 self.sock.close() # close it manually... there may be other refs
Greg Steindd6eefb2000-07-18 09:09:48 +0000824 self.sock = None
825 if self.__response:
826 self.__response.close()
827 self.__response = None
828 self.__state = _CS_IDLE
Greg Stein5e0fa402000-06-26 08:28:01 +0000829
Senthil Kumaran5a2da3b2010-10-02 10:33:13 +0000830 def send(self, data):
Senthil Kumaran7bc0d872010-12-19 10:49:52 +0000831 """Send `data' to the server.
832 ``data`` can be a string object, a bytes object, an array object, a
833 file-like object that supports a .read() method, or an iterable object.
834 """
835
Greg Steindd6eefb2000-07-18 09:09:48 +0000836 if self.sock is None:
837 if self.auto_open:
838 self.connect()
839 else:
840 raise NotConnected()
Greg Stein5e0fa402000-06-26 08:28:01 +0000841
Jeremy Hylton30f86742000-09-18 22:50:38 +0000842 if self.debuglevel > 0:
Senthil Kumaran5a2da3b2010-10-02 10:33:13 +0000843 print("send:", repr(data))
Jeremy Hylton636950f2009-03-28 04:34:21 +0000844 blocksize = 8192
Senthil Kumaran5a2da3b2010-10-02 10:33:13 +0000845 if hasattr(data, "read") :
Jeremy Hylton636950f2009-03-28 04:34:21 +0000846 if self.debuglevel > 0:
847 print("sendIng a read()able")
848 encode = False
Antoine Pitrouead1d622009-09-29 18:44:53 +0000849 try:
Senthil Kumaran5a2da3b2010-10-02 10:33:13 +0000850 mode = data.mode
Antoine Pitrouead1d622009-09-29 18:44:53 +0000851 except AttributeError:
852 # io.BytesIO and other file-like objects don't have a `mode`
853 # attribute.
854 pass
855 else:
856 if "b" not in mode:
857 encode = True
858 if self.debuglevel > 0:
859 print("encoding file using iso-8859-1")
Jeremy Hylton636950f2009-03-28 04:34:21 +0000860 while 1:
Senthil Kumaran5a2da3b2010-10-02 10:33:13 +0000861 datablock = data.read(blocksize)
862 if not datablock:
Jeremy Hylton636950f2009-03-28 04:34:21 +0000863 break
864 if encode:
Senthil Kumaran5a2da3b2010-10-02 10:33:13 +0000865 datablock = datablock.encode("iso-8859-1")
866 self.sock.sendall(datablock)
Andrew Svetlov7b2c8bb2013-04-12 22:49:19 +0300867 return
Senthil Kumaran7bc0d872010-12-19 10:49:52 +0000868 try:
Senthil Kumaran5a2da3b2010-10-02 10:33:13 +0000869 self.sock.sendall(data)
Senthil Kumaran7bc0d872010-12-19 10:49:52 +0000870 except TypeError:
871 if isinstance(data, collections.Iterable):
872 for d in data:
873 self.sock.sendall(d)
874 else:
Georg Brandl25e2cd12011-08-03 08:27:00 +0200875 raise TypeError("data should be a bytes-like object "
876 "or an iterable, got %r" % type(data))
Greg Stein5e0fa402000-06-26 08:28:01 +0000877
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000878 def _output(self, s):
879 """Add a line of output to the current request buffer.
Tim Peters469cdad2002-08-08 20:19:19 +0000880
Jeremy Hyltone3252ec2002-07-16 21:41:43 +0000881 Assumes that the line does *not* end with \\r\\n.
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000882 """
883 self._buffer.append(s)
884
Benjamin Peterson1742e402008-11-30 22:15:29 +0000885 def _send_output(self, message_body=None):
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000886 """Send the currently buffered request and clear the buffer.
887
Jeremy Hyltone3252ec2002-07-16 21:41:43 +0000888 Appends an extra \\r\\n to the buffer.
Benjamin Peterson822b21c2009-01-18 00:04:57 +0000889 A message_body may be specified, to be appended to the request.
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000890 """
Martin v. Löwisdd5a8602007-06-30 09:22:09 +0000891 self._buffer.extend((b"", b""))
892 msg = b"\r\n".join(self._buffer)
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000893 del self._buffer[:]
Benjamin Peterson1742e402008-11-30 22:15:29 +0000894 # If msg and message_body are sent in a single send() call,
895 # it will avoid performance problems caused by the interaction
Antoine Pitrou90e47742013-01-02 22:10:47 +0100896 # between delayed ack and the Nagle algorithm. However,
897 # there is no performance gain if the message is larger
898 # than MSS (and there is a memory penalty for the message
899 # copy).
900 if isinstance(message_body, bytes) and len(message_body) < self.mss:
Benjamin Peterson1742e402008-11-30 22:15:29 +0000901 msg += message_body
Benjamin Peterson822b21c2009-01-18 00:04:57 +0000902 message_body = None
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000903 self.send(msg)
Benjamin Peterson822b21c2009-01-18 00:04:57 +0000904 if message_body is not None:
Jeremy Hylton236654b2009-03-27 20:24:34 +0000905 # message_body was not a string (i.e. it is a file), and
906 # we must run the risk of Nagle.
Benjamin Peterson822b21c2009-01-18 00:04:57 +0000907 self.send(message_body)
Jeremy Hylton8531b1b2002-07-16 21:21:11 +0000908
Martin v. Löwisaf7dc8d2003-11-19 19:51:55 +0000909 def putrequest(self, method, url, skip_host=0, skip_accept_encoding=0):
Greg Steindd6eefb2000-07-18 09:09:48 +0000910 """Send a request to the server.
Greg Stein5e0fa402000-06-26 08:28:01 +0000911
Greg Steindd6eefb2000-07-18 09:09:48 +0000912 `method' specifies an HTTP request method, e.g. 'GET'.
913 `url' specifies the object being requested, e.g. '/index.html'.
Martin v. Löwisaf7dc8d2003-11-19 19:51:55 +0000914 `skip_host' if True does not add automatically a 'Host:' header
915 `skip_accept_encoding' if True does not add automatically an
916 'Accept-Encoding:' header
Greg Steindd6eefb2000-07-18 09:09:48 +0000917 """
Greg Stein5e0fa402000-06-26 08:28:01 +0000918
Greg Stein616a58d2003-06-24 06:35:19 +0000919 # if a prior response has been completed, then forget about it.
Greg Steindd6eefb2000-07-18 09:09:48 +0000920 if self.__response and self.__response.isclosed():
921 self.__response = None
Greg Stein5e0fa402000-06-26 08:28:01 +0000922
Tim Peters58eb11c2004-01-18 20:29:55 +0000923
Greg Steindd6eefb2000-07-18 09:09:48 +0000924 # in certain cases, we cannot issue another request on this connection.
925 # this occurs when:
926 # 1) we are in the process of sending a request. (_CS_REQ_STARTED)
927 # 2) a response to a previous request has signalled that it is going
928 # to close the connection upon completion.
929 # 3) the headers for the previous response have not been read, thus
930 # we cannot determine whether point (2) is true. (_CS_REQ_SENT)
931 #
932 # if there is no prior response, then we can request at will.
933 #
934 # if point (2) is true, then we will have passed the socket to the
935 # response (effectively meaning, "there is no prior response"), and
936 # will open a new one when a new request is made.
937 #
938 # Note: if a prior response exists, then we *can* start a new request.
939 # We are not allowed to begin fetching the response to this new
940 # request, however, until that prior response is complete.
941 #
942 if self.__state == _CS_IDLE:
943 self.__state = _CS_REQ_STARTED
944 else:
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +0000945 raise CannotSendRequest(self.__state)
Greg Stein5e0fa402000-06-26 08:28:01 +0000946
Jeremy Hyltonc1b2cb92003-05-05 16:13:58 +0000947 # Save the method we use, we need it later in the response phase
948 self._method = method
Greg Steindd6eefb2000-07-18 09:09:48 +0000949 if not url:
950 url = '/'
Martin v. Löwisdd5a8602007-06-30 09:22:09 +0000951 request = '%s %s %s' % (method, url, self._http_vsn_str)
Greg Stein5e0fa402000-06-26 08:28:01 +0000952
Martin v. Löwisdd5a8602007-06-30 09:22:09 +0000953 # Non-ASCII characters should have been eliminated earlier
954 self._output(request.encode('ascii'))
Greg Stein5e0fa402000-06-26 08:28:01 +0000955
Greg Steindd6eefb2000-07-18 09:09:48 +0000956 if self._http_vsn == 11:
957 # Issue some standard headers for better HTTP/1.1 compliance
Greg Stein5e0fa402000-06-26 08:28:01 +0000958
Jeremy Hylton3921ff62002-03-09 06:07:23 +0000959 if not skip_host:
960 # this header is issued *only* for HTTP/1.1
961 # connections. more specifically, this means it is
962 # only issued when the client uses the new
963 # HTTPConnection() class. backwards-compat clients
964 # will be using HTTP/1.0 and those clients may be
965 # issuing this header themselves. we should NOT issue
966 # it twice; some web servers (such as Apache) barf
967 # when they see two Host: headers
Guido van Rossumf6922aa2001-01-14 21:03:01 +0000968
Jeremy Hylton3921ff62002-03-09 06:07:23 +0000969 # If we need a non-standard port,include it in the
970 # header. If the request is going through a proxy,
971 # but the host of the actual URL, not the host of the
972 # proxy.
Jeremy Hylton8acf1e02002-03-08 19:35:51 +0000973
Jeremy Hylton3921ff62002-03-09 06:07:23 +0000974 netloc = ''
975 if url.startswith('http'):
976 nil, netloc, nil, nil, nil = urlsplit(url)
977
978 if netloc:
Thomas Wouters477c8d52006-05-27 19:21:47 +0000979 try:
980 netloc_enc = netloc.encode("ascii")
981 except UnicodeEncodeError:
982 netloc_enc = netloc.encode("idna")
983 self.putheader('Host', netloc_enc)
Jeremy Hylton3921ff62002-03-09 06:07:23 +0000984 else:
Thomas Wouters477c8d52006-05-27 19:21:47 +0000985 try:
986 host_enc = self.host.encode("ascii")
987 except UnicodeEncodeError:
988 host_enc = self.host.encode("idna")
Senthil Kumaran74ebd9e2010-11-13 12:27:49 +0000989
990 # As per RFC 273, IPv6 address should be wrapped with []
991 # when used as Host header
992
993 if self.host.find(':') >= 0:
994 host_enc = b'[' + host_enc + b']'
995
Georg Brandl86b2fb92008-07-16 03:43:04 +0000996 if self.port == self.default_port:
Thomas Wouters477c8d52006-05-27 19:21:47 +0000997 self.putheader('Host', host_enc)
998 else:
Guido van Rossum98297ee2007-11-06 21:34:58 +0000999 host_enc = host_enc.decode("ascii")
Thomas Wouters477c8d52006-05-27 19:21:47 +00001000 self.putheader('Host', "%s:%s" % (host_enc, self.port))
Greg Stein5e0fa402000-06-26 08:28:01 +00001001
Greg Steindd6eefb2000-07-18 09:09:48 +00001002 # note: we are assuming that clients will not attempt to set these
1003 # headers since *this* library must deal with the
1004 # consequences. this also means that when the supporting
1005 # libraries are updated to recognize other forms, then this
1006 # code should be changed (removed or updated).
Greg Stein5e0fa402000-06-26 08:28:01 +00001007
Greg Steindd6eefb2000-07-18 09:09:48 +00001008 # we only want a Content-Encoding of "identity" since we don't
1009 # support encodings such as x-gzip or x-deflate.
Martin v. Löwisaf7dc8d2003-11-19 19:51:55 +00001010 if not skip_accept_encoding:
1011 self.putheader('Accept-Encoding', 'identity')
Greg Stein5e0fa402000-06-26 08:28:01 +00001012
Greg Steindd6eefb2000-07-18 09:09:48 +00001013 # we can accept "chunked" Transfer-Encodings, but no others
1014 # NOTE: no TE header implies *only* "chunked"
1015 #self.putheader('TE', 'chunked')
Greg Stein5e0fa402000-06-26 08:28:01 +00001016
Greg Steindd6eefb2000-07-18 09:09:48 +00001017 # if TE is supplied in the header, then it must appear in a
1018 # Connection header.
1019 #self.putheader('Connection', 'TE')
Greg Stein5e0fa402000-06-26 08:28:01 +00001020
Greg Steindd6eefb2000-07-18 09:09:48 +00001021 else:
1022 # For HTTP/1.0, the server will assume "not chunked"
1023 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001024
Benjamin Petersonf608c612008-11-16 18:33:53 +00001025 def putheader(self, header, *values):
Greg Steindd6eefb2000-07-18 09:09:48 +00001026 """Send a request header line to the server.
Greg Stein5e0fa402000-06-26 08:28:01 +00001027
Greg Steindd6eefb2000-07-18 09:09:48 +00001028 For example: h.putheader('Accept', 'text/html')
1029 """
1030 if self.__state != _CS_REQ_STARTED:
1031 raise CannotSendHeader()
Greg Stein5e0fa402000-06-26 08:28:01 +00001032
Guido van Rossum98297ee2007-11-06 21:34:58 +00001033 if hasattr(header, 'encode'):
1034 header = header.encode('ascii')
Benjamin Petersonf608c612008-11-16 18:33:53 +00001035 values = list(values)
1036 for i, one_value in enumerate(values):
1037 if hasattr(one_value, 'encode'):
Marc-André Lemburg8f36af72011-02-25 15:42:01 +00001038 values[i] = one_value.encode('latin-1')
Senthil Kumaran58d5dbf2010-10-03 18:22:42 +00001039 elif isinstance(one_value, int):
1040 values[i] = str(one_value).encode('ascii')
Benjamin Petersonf608c612008-11-16 18:33:53 +00001041 value = b'\r\n\t'.join(values)
Guido van Rossum98297ee2007-11-06 21:34:58 +00001042 header = header + b': ' + value
1043 self._output(header)
Greg Stein5e0fa402000-06-26 08:28:01 +00001044
Benjamin Peterson1742e402008-11-30 22:15:29 +00001045 def endheaders(self, message_body=None):
1046 """Indicate that the last header line has been sent to the server.
Greg Stein5e0fa402000-06-26 08:28:01 +00001047
Senthil Kumaranad87fa62011-10-05 23:26:49 +08001048 This method sends the request to the server. The optional message_body
1049 argument can be used to pass a message body associated with the
1050 request. The message body will be sent in the same packet as the
1051 message headers if it is a string, otherwise it is sent as a separate
1052 packet.
Benjamin Peterson1742e402008-11-30 22:15:29 +00001053 """
Greg Steindd6eefb2000-07-18 09:09:48 +00001054 if self.__state == _CS_REQ_STARTED:
1055 self.__state = _CS_REQ_SENT
1056 else:
1057 raise CannotSendHeader()
Benjamin Peterson1742e402008-11-30 22:15:29 +00001058 self._send_output(message_body)
Greg Stein5e0fa402000-06-26 08:28:01 +00001059
Greg Steindd6eefb2000-07-18 09:09:48 +00001060 def request(self, method, url, body=None, headers={}):
1061 """Send a complete request to the server."""
Jeremy Hylton636950f2009-03-28 04:34:21 +00001062 self._send_request(method, url, body, headers)
Greg Stein5e0fa402000-06-26 08:28:01 +00001063
Benjamin Peterson1742e402008-11-30 22:15:29 +00001064 def _set_content_length(self, body):
1065 # Set the content-length based on the body.
1066 thelen = None
1067 try:
1068 thelen = str(len(body))
1069 except TypeError as te:
1070 # If this is a file-like object, try to
1071 # fstat its file descriptor
Benjamin Peterson1742e402008-11-30 22:15:29 +00001072 try:
1073 thelen = str(os.fstat(body.fileno()).st_size)
1074 except (AttributeError, OSError):
1075 # Don't send a length if this failed
1076 if self.debuglevel > 0: print("Cannot stat!!")
1077
1078 if thelen is not None:
1079 self.putheader('Content-Length', thelen)
1080
Greg Steindd6eefb2000-07-18 09:09:48 +00001081 def _send_request(self, method, url, body, headers):
Jeremy Hylton636950f2009-03-28 04:34:21 +00001082 # Honor explicitly requested Host: and Accept-Encoding: headers.
Jeremy Hylton2c178252004-08-07 16:28:14 +00001083 header_names = dict.fromkeys([k.lower() for k in headers])
1084 skips = {}
1085 if 'host' in header_names:
1086 skips['skip_host'] = 1
1087 if 'accept-encoding' in header_names:
1088 skips['skip_accept_encoding'] = 1
Greg Stein5e0fa402000-06-26 08:28:01 +00001089
Jeremy Hylton2c178252004-08-07 16:28:14 +00001090 self.putrequest(method, url, **skips)
1091
Senthil Kumaran5fa4a892012-05-19 16:58:09 +08001092 if body is not None and ('content-length' not in header_names):
Benjamin Peterson1742e402008-11-30 22:15:29 +00001093 self._set_content_length(body)
Guido van Rossumcc2b0162007-02-11 06:12:03 +00001094 for hdr, value in headers.items():
Greg Steindd6eefb2000-07-18 09:09:48 +00001095 self.putheader(hdr, value)
Jeremy Hyltonef9f48e2009-03-26 22:04:05 +00001096 if isinstance(body, str):
Jeremy Hylton236654b2009-03-27 20:24:34 +00001097 # RFC 2616 Section 3.7.1 says that text default has a
1098 # default charset of iso-8859-1.
1099 body = body.encode('iso-8859-1')
Jeremy Hyltonef9f48e2009-03-26 22:04:05 +00001100 self.endheaders(body)
Greg Stein5e0fa402000-06-26 08:28:01 +00001101
Greg Steindd6eefb2000-07-18 09:09:48 +00001102 def getresponse(self):
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +00001103 """Get the response from the server.
1104
1105 If the HTTPConnection is in the correct state, returns an
1106 instance of HTTPResponse or of whatever object is returned by
1107 class the response_class variable.
1108
1109 If a request has not been sent or if a previous response has
1110 not be handled, ResponseNotReady is raised. If the HTTP
1111 response indicates that the connection should be closed, then
1112 it will be closed before the response is returned. When the
1113 connection is closed, the underlying socket is closed.
1114 """
Greg Stein5e0fa402000-06-26 08:28:01 +00001115
Greg Stein616a58d2003-06-24 06:35:19 +00001116 # if a prior response has been completed, then forget about it.
Greg Steindd6eefb2000-07-18 09:09:48 +00001117 if self.__response and self.__response.isclosed():
1118 self.__response = None
Greg Stein5e0fa402000-06-26 08:28:01 +00001119
Greg Steindd6eefb2000-07-18 09:09:48 +00001120 # if a prior response exists, then it must be completed (otherwise, we
1121 # cannot read this response's header to determine the connection-close
1122 # behavior)
1123 #
1124 # note: if a prior response existed, but was connection-close, then the
1125 # socket and response were made independent of this HTTPConnection
1126 # object since a new request requires that we open a whole new
1127 # connection
1128 #
1129 # this means the prior response had one of two states:
1130 # 1) will_close: this connection was reset and the prior socket and
1131 # response operate independently
1132 # 2) persistent: the response was retained and we await its
1133 # isclosed() status to become true.
1134 #
1135 if self.__state != _CS_REQ_SENT or self.__response:
Jeremy Hylton6c5e28c2009-03-31 14:35:53 +00001136 raise ResponseNotReady(self.__state)
Greg Stein5e0fa402000-06-26 08:28:01 +00001137
Jeremy Hylton30f86742000-09-18 22:50:38 +00001138 if self.debuglevel > 0:
Jeremy Hyltond46aa372002-07-06 18:48:07 +00001139 response = self.response_class(self.sock, self.debuglevel,
Jeremy Hyltonc1b2cb92003-05-05 16:13:58 +00001140 method=self._method)
Jeremy Hylton30f86742000-09-18 22:50:38 +00001141 else:
Antoine Pitrou988dbd72010-12-17 17:35:56 +00001142 response = self.response_class(self.sock, method=self._method)
Greg Stein5e0fa402000-06-26 08:28:01 +00001143
Jeremy Hylton39c03802002-07-12 14:04:09 +00001144 response.begin()
Jeremy Hyltonbe4fcf12002-06-28 22:38:01 +00001145 assert response.will_close != _UNKNOWN
Greg Steindd6eefb2000-07-18 09:09:48 +00001146 self.__state = _CS_IDLE
Greg Stein5e0fa402000-06-26 08:28:01 +00001147
Greg Steindd6eefb2000-07-18 09:09:48 +00001148 if response.will_close:
Guido van Rossumd8faa362007-04-27 19:54:29 +00001149 # this effectively passes the connection to the response
1150 self.close()
Greg Steindd6eefb2000-07-18 09:09:48 +00001151 else:
1152 # remember this, so we can tell when it is complete
1153 self.__response = response
Greg Stein5e0fa402000-06-26 08:28:01 +00001154
Greg Steindd6eefb2000-07-18 09:09:48 +00001155 return response
Greg Stein5e0fa402000-06-26 08:28:01 +00001156
Thomas Wouters47b49bf2007-08-30 22:15:33 +00001157try:
1158 import ssl
Brett Cannon0a140662013-06-13 20:57:26 -04001159except ModuleNotFoundError:
Thomas Wouters47b49bf2007-08-30 22:15:33 +00001160 pass
1161else:
1162 class HTTPSConnection(HTTPConnection):
1163 "This class allows communication via SSL."
Jeremy Hylton29d27ac2002-07-09 21:22:36 +00001164
Thomas Wouters47b49bf2007-08-30 22:15:33 +00001165 default_port = HTTPS_PORT
Jeremy Hylton29d27ac2002-07-09 21:22:36 +00001166
Antoine Pitrou803e6d62010-10-13 10:36:15 +00001167 # XXX Should key_file and cert_file be deprecated in favour of context?
1168
Thomas Wouters47b49bf2007-08-30 22:15:33 +00001169 def __init__(self, host, port=None, key_file=None, cert_file=None,
Senthil Kumaran052ddb02013-03-18 14:11:41 -07001170 timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
1171 source_address=None, *, context=None,
1172 check_hostname=None):
1173 super(HTTPSConnection, self).__init__(host, port, timeout,
Gregory P. Smithb4066372010-01-03 03:28:29 +00001174 source_address)
Thomas Wouters47b49bf2007-08-30 22:15:33 +00001175 self.key_file = key_file
1176 self.cert_file = cert_file
Antoine Pitrou803e6d62010-10-13 10:36:15 +00001177 if context is None:
1178 # Some reasonable defaults
1179 context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
1180 context.options |= ssl.OP_NO_SSLv2
1181 will_verify = context.verify_mode != ssl.CERT_NONE
1182 if check_hostname is None:
1183 check_hostname = will_verify
1184 elif check_hostname and not will_verify:
1185 raise ValueError("check_hostname needs a SSL context with "
1186 "either CERT_OPTIONAL or CERT_REQUIRED")
1187 if key_file or cert_file:
Antoine Pitrou80603992010-10-13 10:45:16 +00001188 context.load_cert_chain(cert_file, key_file)
Antoine Pitrou803e6d62010-10-13 10:36:15 +00001189 self._context = context
1190 self._check_hostname = check_hostname
Jeremy Hylton29d27ac2002-07-09 21:22:36 +00001191
Thomas Wouters47b49bf2007-08-30 22:15:33 +00001192 def connect(self):
1193 "Connect to a host on a given (SSL) port."
Jeremy Hylton29d27ac2002-07-09 21:22:36 +00001194
Jeremy Hylton636950f2009-03-28 04:34:21 +00001195 sock = socket.create_connection((self.host, self.port),
Gregory P. Smithb4066372010-01-03 03:28:29 +00001196 self.timeout, self.source_address)
Senthil Kumaran97f0c6b2009-07-25 04:24:38 +00001197
1198 if self._tunnel_host:
1199 self.sock = sock
1200 self._tunnel()
1201
Antoine Pitroud5323212010-10-22 18:19:07 +00001202 server_hostname = self.host if ssl.HAS_SNI else None
1203 self.sock = self._context.wrap_socket(sock,
1204 server_hostname=server_hostname)
Antoine Pitrou803e6d62010-10-13 10:36:15 +00001205 try:
1206 if self._check_hostname:
1207 ssl.match_hostname(self.sock.getpeercert(), self.host)
1208 except Exception:
1209 self.sock.shutdown(socket.SHUT_RDWR)
1210 self.sock.close()
1211 raise
Jeremy Hylton29d27ac2002-07-09 21:22:36 +00001212
Thomas Wouters47b49bf2007-08-30 22:15:33 +00001213 __all__.append("HTTPSConnection")
Greg Stein5e0fa402000-06-26 08:28:01 +00001214
Greg Stein5e0fa402000-06-26 08:28:01 +00001215class HTTPException(Exception):
Jeremy Hylton12f4f352002-07-06 18:55:01 +00001216 # Subclasses that define an __init__ must call Exception.__init__
1217 # or define self.args. Otherwise, str() will fail.
Greg Steindd6eefb2000-07-18 09:09:48 +00001218 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001219
1220class NotConnected(HTTPException):
Greg Steindd6eefb2000-07-18 09:09:48 +00001221 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001222
Skip Montanaro9d389972002-03-24 16:53:50 +00001223class InvalidURL(HTTPException):
1224 pass
1225
Greg Stein5e0fa402000-06-26 08:28:01 +00001226class UnknownProtocol(HTTPException):
Greg Steindd6eefb2000-07-18 09:09:48 +00001227 def __init__(self, version):
Jeremy Hylton12f4f352002-07-06 18:55:01 +00001228 self.args = version,
Greg Steindd6eefb2000-07-18 09:09:48 +00001229 self.version = version
Greg Stein5e0fa402000-06-26 08:28:01 +00001230
1231class UnknownTransferEncoding(HTTPException):
Greg Steindd6eefb2000-07-18 09:09:48 +00001232 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001233
Greg Stein5e0fa402000-06-26 08:28:01 +00001234class UnimplementedFileMode(HTTPException):
Greg Steindd6eefb2000-07-18 09:09:48 +00001235 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001236
1237class IncompleteRead(HTTPException):
Benjamin Peterson6accb982009-03-02 22:50:25 +00001238 def __init__(self, partial, expected=None):
Jeremy Hylton12f4f352002-07-06 18:55:01 +00001239 self.args = partial,
Greg Steindd6eefb2000-07-18 09:09:48 +00001240 self.partial = partial
Benjamin Peterson6accb982009-03-02 22:50:25 +00001241 self.expected = expected
1242 def __repr__(self):
1243 if self.expected is not None:
1244 e = ', %i more expected' % self.expected
1245 else:
1246 e = ''
1247 return 'IncompleteRead(%i bytes read%s)' % (len(self.partial), e)
1248 def __str__(self):
1249 return repr(self)
Greg Stein5e0fa402000-06-26 08:28:01 +00001250
1251class ImproperConnectionState(HTTPException):
Greg Steindd6eefb2000-07-18 09:09:48 +00001252 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001253
1254class CannotSendRequest(ImproperConnectionState):
Greg Steindd6eefb2000-07-18 09:09:48 +00001255 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001256
1257class CannotSendHeader(ImproperConnectionState):
Greg Steindd6eefb2000-07-18 09:09:48 +00001258 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001259
1260class ResponseNotReady(ImproperConnectionState):
Greg Steindd6eefb2000-07-18 09:09:48 +00001261 pass
Greg Stein5e0fa402000-06-26 08:28:01 +00001262
1263class BadStatusLine(HTTPException):
Greg Steindd6eefb2000-07-18 09:09:48 +00001264 def __init__(self, line):
Benjamin Peterson11dbfd42010-03-21 22:50:04 +00001265 if not line:
1266 line = repr(line)
Jeremy Hylton12f4f352002-07-06 18:55:01 +00001267 self.args = line,
Greg Steindd6eefb2000-07-18 09:09:48 +00001268 self.line = line
Greg Stein5e0fa402000-06-26 08:28:01 +00001269
Senthil Kumaran5466bf12010-12-18 16:55:23 +00001270class LineTooLong(HTTPException):
1271 def __init__(self, line_type):
1272 HTTPException.__init__(self, "got more than %d bytes when reading %s"
1273 % (_MAXLINE, line_type))
1274
Greg Stein5e0fa402000-06-26 08:28:01 +00001275# for backwards compatibility
1276error = HTTPException