From 2c6aee9096c7502ad2ec1c522f4b0e9be0a6569d Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@haypocalc.com>
Date: Sat, 24 Jul 2010 02:46:16 +0000
Subject: [PATCH] Forward port r70643 (#5542) + part of r83120 (just remove the
 comment)

Remove special logic that closes HTTPConnection socket on EPIPE.

If the socket is closed, the client has no chance to read the response
from the server.  EPIPE means that it isn't possible to write more
data from the socket, but not that it is impossible to read.
---
 Lib/httplib.py           | 42 ++++++++++++----------------------------
 Lib/test/test_httplib.py | 31 +++++++++++++++++++++++++++++
 Misc/NEWS                |  2 ++
 3 files changed, 45 insertions(+), 30 deletions(-)

diff --git a/Lib/httplib.py b/Lib/httplib.py
index d66a9fcd05b..b1452f439c3 100644
--- a/Lib/httplib.py
+++ b/Lib/httplib.py
@@ -67,6 +67,7 @@ Req-sent-unread-response       _CS_REQ_SENT       <response_class>
 """
 
 from array import array
+import os
 import socket
 from sys import py3kwarning
 from urlparse import urlsplit
@@ -756,27 +757,17 @@ class HTTPConnection:
             else:
                 raise NotConnected()
 
-        # send the data to the server. if we get a broken pipe, then close
-        # the socket. we want to reconnect when somebody tries to send again.
-        #
-        # NOTE: we DO propagate the error, though, because we cannot simply
-        #       ignore the error... the caller will know if they can retry.
         if self.debuglevel > 0:
             print "send:", repr(str)
-        try:
-            blocksize=8192
-            if hasattr(str,'read') and not isinstance(str, array):
-                if self.debuglevel > 0: print "sendIng a read()able"
-                data=str.read(blocksize)
-                while data:
-                    self.sock.sendall(data)
-                    data=str.read(blocksize)
-            else:
-                self.sock.sendall(str)
-        except socket.error, v:
-            if v.args[0] == 32:      # Broken pipe
-                self.close()
-            raise
+        blocksize = 8192
+        if hasattr(str,'read') and not isinstance(str, array):
+            if self.debuglevel > 0: print "sendIng a read()able"
+            data = str.read(blocksize)
+            while data:
+                self.sock.sendall(data)
+                data = str.read(blocksize)
+        else:
+            self.sock.sendall(str)
 
     def _output(self, s):
         """Add a line of output to the current request buffer.
@@ -941,15 +932,7 @@ class HTTPConnection:
 
     def request(self, method, url, body=None, headers={}):
         """Send a complete request to the server."""
-
-        try:
-            self._send_request(method, url, body, headers)
-        except socket.error, v:
-            # trap 'Broken pipe' if we're allowed to automatically reconnect
-            if v.args[0] != 32 or not self.auto_open:
-                raise
-            # try one more time
-            self._send_request(method, url, body, headers)
+        self._send_request(method, url, body, headers)
 
     def _set_content_length(self, body):
         # Set the content-length based on the body.
@@ -959,7 +942,6 @@ class HTTPConnection:
         except TypeError, te:
             # If this is a file-like object, try to
             # fstat its file descriptor
-            import os
             try:
                 thelen = str(os.fstat(body.fileno()).st_size)
             except (AttributeError, OSError):
@@ -970,7 +952,7 @@ class HTTPConnection:
             self.putheader('Content-Length', thelen)
 
     def _send_request(self, method, url, body, headers):
-        # honour explicitly requested Host: and Accept-Encoding headers
+        # Honor explicitly requested Host: and Accept-Encoding: headers.
         header_names = dict.fromkeys([k.lower() for k in headers])
         skips = {}
         if 'host' in header_names:
diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py
index 2d0b8e750bd..1fb810e816a 100644
--- a/Lib/test/test_httplib.py
+++ b/Lib/test/test_httplib.py
@@ -2,6 +2,7 @@ import array
 import httplib
 import StringIO
 import socket
+import errno
 
 import unittest
 TestCase = unittest.TestCase
@@ -24,6 +25,21 @@ class FakeSocket:
             raise httplib.UnimplementedFileMode()
         return self.fileclass(self.text)
 
+class EPipeSocket(FakeSocket):
+
+    def __init__(self, text, pipe_trigger):
+        # When sendall() is called with pipe_trigger, raise EPIPE.
+        FakeSocket.__init__(self, text)
+        self.pipe_trigger = pipe_trigger
+
+    def sendall(self, data):
+        if self.pipe_trigger in data:
+            raise socket.error(errno.EPIPE, "gotcha")
+        self.data += data
+
+    def close(self):
+        pass
+
 class NoEOFStringIO(StringIO.StringIO):
     """Like StringIO, but raises AssertionError on EOF.
 
@@ -254,6 +270,21 @@ class BasicTest(TestCase):
         finally:
             resp.close()
 
+    def test_epipe(self):
+        sock = EPipeSocket(
+            "HTTP/1.0 401 Authorization Required\r\n"
+            "Content-type: text/html\r\n"
+            "WWW-Authenticate: Basic realm=\"example\"\r\n",
+            b"Content-Length")
+        conn = httplib.HTTPConnection("example.com")
+        conn.sock = sock
+        self.assertRaises(socket.error,
+                          lambda: conn.request("PUT", "/url", "body"))
+        resp = conn.getresponse()
+        self.assertEqual(401, resp.status)
+        self.assertEqual("Basic realm=\"example\"",
+                         resp.getheader("www-authenticate"))
+
 
 class OfflineTest(TestCase):
     def test_responses(self):
diff --git a/Misc/NEWS b/Misc/NEWS
index e1f2c20a866..22aa5b88df2 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -18,6 +18,8 @@ Core and Builtins
 Library
 -------
 
+- Issue #5542: Remove special logic that closes HTTPConnection socket on EPIPE.
+
 - Issue #4629: getopt raises an error if an argument ends with = whereas getopt
   doesn't except a value (eg. --help= is rejected if getopt uses ['help='] long
   options).