1 """Tests for TCP connection handling, including proper and timely close."""
2
3 import socket
4 import sys
5 import time
6 timeout = 1
7
8
9 import cherrypy
10 from cherrypy._cpcompat import HTTPConnection, HTTPSConnection, NotConnected, BadStatusLine
11 from cherrypy._cpcompat import ntob, urlopen, unicodestr
12 from cherrypy.test import webtest
13 from cherrypy import _cperror
14
15
16 pov = 'pPeErRsSiIsStTeEnNcCeE oOfF vViIsSiIoOnN'
17
22
23 class Root:
24
25 def index(self):
26 return pov
27 index.exposed = True
28 page1 = index
29 page2 = index
30 page3 = index
31
32 def hello(self):
33 return "Hello, world!"
34 hello.exposed = True
35
36 def timeout(self, t):
37 return str(cherrypy.server.httpserver.timeout)
38 timeout.exposed = True
39
40 def stream(self, set_cl=False):
41 if set_cl:
42 cherrypy.response.headers['Content-Length'] = 10
43
44 def content():
45 for x in range(10):
46 yield str(x)
47
48 return content()
49 stream.exposed = True
50 stream._cp_config = {'response.stream': True}
51
52 def error(self, code=500):
53 raise cherrypy.HTTPError(code)
54 error.exposed = True
55
56 def upload(self):
57 if not cherrypy.request.method == 'POST':
58 raise AssertionError("'POST' != request.method %r" %
59 cherrypy.request.method)
60 return "thanks for '%s'" % cherrypy.request.body.read()
61 upload.exposed = True
62
63 def custom(self, response_code):
64 cherrypy.response.status = response_code
65 return "Code = %s" % response_code
66 custom.exposed = True
67
68 def err_before_read(self):
69 return "ok"
70 err_before_read.exposed = True
71 err_before_read._cp_config = {'hooks.on_start_resource': raise500}
72
73 def one_megabyte_of_a(self):
74 return ["a" * 1024] * 1024
75 one_megabyte_of_a.exposed = True
76
77 def custom_cl(self, body, cl):
78 cherrypy.response.headers['Content-Length'] = cl
79 if not isinstance(body, list):
80 body = [body]
81 newbody = []
82 for chunk in body:
83 if isinstance(chunk, unicodestr):
84 chunk = chunk.encode('ISO-8859-1')
85 newbody.append(chunk)
86 return newbody
87 custom_cl.exposed = True
88
89
90 custom_cl._cp_config = {'tools.encode.on': False}
91
92 cherrypy.tree.mount(Root())
93 cherrypy.config.update({
94 'server.max_request_body_size': 1001,
95 'server.socket_timeout': timeout,
96 })
97
98
99 from cherrypy.test import helper
100
102 setup_server = staticmethod(setup_server)
103
132
135
138
140 if cherrypy.server.protocol_version == "HTTP/1.1":
141 self.PROTOCOL = "HTTP/1.1"
142
143 self.persistent = True
144
145
146 self.getPage("/")
147 self.assertStatus('200 OK')
148 self.assertBody(pov)
149 self.assertNoHeader("Connection")
150
151
152 if set_cl:
153
154
155 self.getPage("/stream?set_cl=Yes")
156 self.assertHeader("Content-Length")
157 self.assertNoHeader("Connection", "close")
158 self.assertNoHeader("Transfer-Encoding")
159
160 self.assertStatus('200 OK')
161 self.assertBody('0123456789')
162 else:
163
164
165
166 self.getPage("/stream")
167 self.assertNoHeader("Content-Length")
168 self.assertStatus('200 OK')
169 self.assertBody('0123456789')
170
171 chunked_response = False
172 for k, v in self.headers:
173 if k.lower() == "transfer-encoding":
174 if str(v) == "chunked":
175 chunked_response = True
176
177 if chunked_response:
178 self.assertNoHeader("Connection", "close")
179 else:
180 self.assertHeader("Connection", "close")
181
182
183 self.assertRaises(NotConnected, self.getPage, "/")
184
185
186 self.getPage("/stream", method='HEAD')
187 self.assertStatus('200 OK')
188 self.assertBody('')
189 self.assertNoHeader("Transfer-Encoding")
190 else:
191 self.PROTOCOL = "HTTP/1.0"
192
193 self.persistent = True
194
195
196 self.getPage("/", headers=[("Connection", "Keep-Alive")])
197 self.assertStatus('200 OK')
198 self.assertBody(pov)
199 self.assertHeader("Connection", "Keep-Alive")
200
201
202 if set_cl:
203
204
205 self.getPage("/stream?set_cl=Yes",
206 headers=[("Connection", "Keep-Alive")])
207 self.assertHeader("Content-Length")
208 self.assertHeader("Connection", "Keep-Alive")
209 self.assertNoHeader("Transfer-Encoding")
210 self.assertStatus('200 OK')
211 self.assertBody('0123456789')
212 else:
213
214
215 self.getPage("/stream", headers=[("Connection", "Keep-Alive")])
216 self.assertStatus('200 OK')
217 self.assertBody('0123456789')
218
219 self.assertNoHeader("Content-Length")
220 self.assertNoHeader("Connection", "Keep-Alive")
221 self.assertNoHeader("Transfer-Encoding")
222
223
224 self.assertRaises(NotConnected, self.getPage, "/")
225
252
253
254
255
257 setup_server = staticmethod(setup_server)
258
298
300
301
302 if cherrypy.server.protocol_version != "HTTP/1.1":
303 return self.skip()
304
305 self.PROTOCOL = "HTTP/1.1"
306
307
308 self.persistent = True
309 conn = self.HTTP_CONN
310 conn.putrequest("GET", "/timeout?t=%s" % timeout, skip_host=True)
311 conn.putheader("Host", self.HOST)
312 conn.endheaders()
313 response = conn.response_class(conn.sock, method="GET")
314 response.begin()
315 self.assertEqual(response.status, 200)
316 self.body = response.read()
317 self.assertBody(str(timeout))
318
319
320 conn._output(ntob('GET /hello HTTP/1.1'))
321 conn._output(ntob("Host: %s" % self.HOST, 'ascii'))
322 conn._send_output()
323 response = conn.response_class(conn.sock, method="GET")
324 response.begin()
325 self.assertEqual(response.status, 200)
326 self.body = response.read()
327 self.assertBody("Hello, world!")
328
329
330 time.sleep(timeout * 2)
331
332
333 conn._output(ntob('GET /hello HTTP/1.1'))
334 conn._output(ntob("Host: %s" % self.HOST, 'ascii'))
335 conn._send_output()
336 response = conn.response_class(conn.sock, method="GET")
337 try:
338 response.begin()
339 except:
340 if not isinstance(sys.exc_info()[1],
341 (socket.error, BadStatusLine)):
342 self.fail("Writing to timed out socket didn't fail"
343 " as it should have: %s" % sys.exc_info()[1])
344 else:
345 if response.status != 408:
346 self.fail("Writing to timed out socket didn't fail"
347 " as it should have: %s" %
348 response.read())
349
350 conn.close()
351
352
353 self.persistent = True
354 conn = self.HTTP_CONN
355 conn.putrequest("GET", "/", skip_host=True)
356 conn.putheader("Host", self.HOST)
357 conn.endheaders()
358 response = conn.response_class(conn.sock, method="GET")
359 response.begin()
360 self.assertEqual(response.status, 200)
361 self.body = response.read()
362 self.assertBody(pov)
363
364
365
366
367 conn.send(ntob('GET /hello HTTP/1.1'))
368
369 time.sleep(timeout * 2)
370 response = conn.response_class(conn.sock, method="GET")
371 try:
372 response.begin()
373 except:
374 if not isinstance(sys.exc_info()[1],
375 (socket.error, BadStatusLine)):
376 self.fail("Writing to timed out socket didn't fail"
377 " as it should have: %s" % sys.exc_info()[1])
378 else:
379 self.fail("Writing to timed out socket didn't fail"
380 " as it should have: %s" %
381 response.read())
382
383 conn.close()
384
385
386 self.persistent = True
387 conn = self.HTTP_CONN
388 conn.putrequest("GET", "/", skip_host=True)
389 conn.putheader("Host", self.HOST)
390 conn.endheaders()
391 response = conn.response_class(conn.sock, method="GET")
392 response.begin()
393 self.assertEqual(response.status, 200)
394 self.body = response.read()
395 self.assertBody(pov)
396 conn.close()
397
399 if cherrypy.server.protocol_version != "HTTP/1.1":
400 return self.skip()
401
402 self.PROTOCOL = "HTTP/1.1"
403
404
405 self.persistent = True
406 conn = self.HTTP_CONN
407
408
409 conn.putrequest("GET", "/hello", skip_host=True)
410 conn.putheader("Host", self.HOST)
411 conn.endheaders()
412
413 for trial in range(5):
414
415 conn._output(ntob('GET /hello HTTP/1.1'))
416 conn._output(ntob("Host: %s" % self.HOST, 'ascii'))
417 conn._send_output()
418
419
420 response = conn.response_class(conn.sock, method="GET")
421 response.begin()
422 body = response.read(13)
423 self.assertEqual(response.status, 200)
424 self.assertEqual(body, ntob("Hello, world!"))
425
426
427 response = conn.response_class(conn.sock, method="GET")
428 response.begin()
429 body = response.read()
430 self.assertEqual(response.status, 200)
431 self.assertEqual(body, ntob("Hello, world!"))
432
433 conn.close()
434
436 if cherrypy.server.protocol_version != "HTTP/1.1":
437 return self.skip()
438
439 self.PROTOCOL = "HTTP/1.1"
440
441 self.persistent = True
442 conn = self.HTTP_CONN
443
444
445
446
447 conn.putrequest("POST", "/upload", skip_host=True)
448 conn.putheader("Host", self.HOST)
449 conn.putheader("Content-Type", "text/plain")
450 conn.putheader("Content-Length", "4")
451 conn.endheaders()
452 conn.send(ntob("d'oh"))
453 response = conn.response_class(conn.sock, method="POST")
454 version, status, reason = response._read_status()
455 self.assertNotEqual(status, 100)
456 conn.close()
457
458
459 conn.connect()
460 conn.putrequest("POST", "/upload", skip_host=True)
461 conn.putheader("Host", self.HOST)
462 conn.putheader("Content-Type", "text/plain")
463 conn.putheader("Content-Length", "17")
464 conn.putheader("Expect", "100-continue")
465 conn.endheaders()
466 response = conn.response_class(conn.sock, method="POST")
467
468
469 version, status, reason = response._read_status()
470 self.assertEqual(status, 100)
471 while True:
472 line = response.fp.readline().strip()
473 if line:
474 self.fail("100 Continue should not output any headers. Got %r" % line)
475 else:
476 break
477
478
479 body = ntob("I am a small file")
480 conn.send(body)
481
482
483 response.begin()
484 self.status, self.headers, self.body = webtest.shb(response)
485 self.assertStatus(200)
486 self.assertBody("thanks for '%s'" % body)
487 conn.close()
488
489
491 setup_server = staticmethod(setup_server)
492
494 if cherrypy.server.protocol_version != "HTTP/1.1":
495 return self.skip()
496
497 self.PROTOCOL = "HTTP/1.1"
498
499 if self.scheme == "https":
500 self.HTTP_CONN = HTTPSConnection
501 else:
502 self.HTTP_CONN = HTTPConnection
503
504
505 old_max = cherrypy.server.max_request_body_size
506 for new_max in (0, old_max):
507 cherrypy.server.max_request_body_size = new_max
508
509 self.persistent = True
510 conn = self.HTTP_CONN
511
512
513 conn.putrequest("POST", "/err_before_read", skip_host=True)
514 conn.putheader("Host", self.HOST)
515 conn.putheader("Content-Type", "text/plain")
516 conn.putheader("Content-Length", "1000")
517 conn.putheader("Expect", "100-continue")
518 conn.endheaders()
519 response = conn.response_class(conn.sock, method="POST")
520
521
522 version, status, reason = response._read_status()
523 self.assertEqual(status, 100)
524 while True:
525 skip = response.fp.readline().strip()
526 if not skip:
527 break
528
529
530 conn.send(ntob("x" * 1000))
531
532
533 response.begin()
534 self.status, self.headers, self.body = webtest.shb(response)
535 self.assertStatus(500)
536
537
538 conn._output(ntob('POST /upload HTTP/1.1'))
539 conn._output(ntob("Host: %s" % self.HOST, 'ascii'))
540 conn._output(ntob("Content-Type: text/plain"))
541 conn._output(ntob("Content-Length: 17"))
542 conn._output(ntob("Expect: 100-continue"))
543 conn._send_output()
544 response = conn.response_class(conn.sock, method="POST")
545
546
547 version, status, reason = response._read_status()
548 self.assertEqual(status, 100)
549 while True:
550 skip = response.fp.readline().strip()
551 if not skip:
552 break
553
554
555 body = ntob("I am a small file")
556 conn.send(body)
557
558
559 response.begin()
560 self.status, self.headers, self.body = webtest.shb(response)
561 self.assertStatus(200)
562 self.assertBody("thanks for '%s'" % body)
563 conn.close()
564
566 if cherrypy.server.protocol_version != "HTTP/1.1":
567 return self.skip()
568
569 self.PROTOCOL = "HTTP/1.1"
570
571
572 self.persistent = True
573
574
575 self.getPage("/")
576 self.assertStatus('200 OK')
577 self.assertBody(pov)
578 self.assertNoHeader("Connection")
579
580
581 self.getPage("/custom/204")
582 self.assertStatus(204)
583 self.assertNoHeader("Content-Length")
584 self.assertBody("")
585 self.assertNoHeader("Connection")
586
587
588 self.getPage("/custom/304")
589 self.assertStatus(304)
590 self.assertNoHeader("Content-Length")
591 self.assertBody("")
592 self.assertNoHeader("Connection")
593
595 if cherrypy.server.protocol_version != "HTTP/1.1":
596 return self.skip()
597
598 if (hasattr(self, 'harness') and
599 "modpython" in self.harness.__class__.__name__.lower()):
600
601 return self.skip()
602
603 self.PROTOCOL = "HTTP/1.1"
604
605
606 self.persistent = True
607 conn = self.HTTP_CONN
608
609
610 body = ntob("8;key=value\r\nxx\r\nxxxx\r\n5\r\nyyyyy\r\n0\r\n"
611 "Content-Type: application/json\r\n"
612 "\r\n")
613 conn.putrequest("POST", "/upload", skip_host=True)
614 conn.putheader("Host", self.HOST)
615 conn.putheader("Transfer-Encoding", "chunked")
616 conn.putheader("Trailer", "Content-Type")
617
618
619
620 conn.putheader("Content-Length", "3")
621 conn.endheaders()
622 conn.send(body)
623 response = conn.getresponse()
624 self.status, self.headers, self.body = webtest.shb(response)
625 self.assertStatus('200 OK')
626 self.assertBody("thanks for '%s'" % ntob('xx\r\nxxxxyyyyy'))
627
628
629
630 body = ntob("3e3\r\n" + ("x" * 995) + "\r\n0\r\n\r\n")
631 conn.putrequest("POST", "/upload", skip_host=True)
632 conn.putheader("Host", self.HOST)
633 conn.putheader("Transfer-Encoding", "chunked")
634 conn.putheader("Content-Type", "text/plain")
635
636
637 conn.endheaders()
638 conn.send(body)
639 response = conn.getresponse()
640 self.status, self.headers, self.body = webtest.shb(response)
641 self.assertStatus(413)
642 conn.close()
643
645
646
647 self.persistent = True
648 conn = self.HTTP_CONN
649 conn.putrequest("POST", "/upload", skip_host=True)
650 conn.putheader("Host", self.HOST)
651 conn.putheader("Content-Type", "text/plain")
652 conn.putheader("Content-Length", "9999")
653 conn.endheaders()
654 response = conn.getresponse()
655 self.status, self.headers, self.body = webtest.shb(response)
656 self.assertStatus(413)
657 self.assertBody("The entity sent with the request exceeds "
658 "the maximum allowed bytes.")
659 conn.close()
660
662
663
664 self.persistent = True
665 conn = self.HTTP_CONN
666 conn.putrequest("GET", "/custom_cl?body=I+have+too+many+bytes&cl=5",
667 skip_host=True)
668 conn.putheader("Host", self.HOST)
669 conn.endheaders()
670 response = conn.getresponse()
671 self.status, self.headers, self.body = webtest.shb(response)
672 self.assertStatus(500)
673 self.assertBody(
674 "The requested resource returned more bytes than the "
675 "declared Content-Length.")
676 conn.close()
677
679
680
681 self.persistent = True
682 conn = self.HTTP_CONN
683 conn.putrequest("GET", "/custom_cl?body=I+too&body=+have+too+many&cl=5",
684 skip_host=True)
685 conn.putheader("Host", self.HOST)
686 conn.endheaders()
687 response = conn.getresponse()
688 self.status, self.headers, self.body = webtest.shb(response)
689 self.assertStatus(200)
690 self.assertBody("I too")
691 conn.close()
692
694 remote_data_conn = urlopen('%s://%s:%s/one_megabyte_of_a/' %
695 (self.scheme, self.HOST, self.PORT,))
696 buf = remote_data_conn.read(512)
697 time.sleep(timeout * 0.6)
698 remaining = (1024 * 1024) - 512
699 while remaining:
700 data = remote_data_conn.read(remaining)
701 if not data:
702 break
703 else:
704 buf += data
705 remaining -= len(data)
706
707 self.assertEqual(len(buf), 1024 * 1024)
708 self.assertEqual(buf, ntob("a" * 1024 * 1024))
709 self.assertEqual(remaining, 0)
710 remote_data_conn.close()
711
712
734