Remove EOF errors from receive functions

It is generally accepted that EOF errors in `Network` were a mistake.
Using exceptions for control flow is an anti-pattern in the Haskell
community. While we are in the process of introducing epoch breaking
changes it makes sense to attempt to remove these historic accidents.

There should really be no perceived change for users of
`Network.ByteString(.Lazy).recv`, however `recvFrom` does change
behavior. There are two key differences in `recvFrom`:

1. It is now returning a `(0, address)` on an EOF.
2. It will peek the socket's address and `getPeerName` on an EOF. This
    has some implications for performance, and such may be controversial.

The second point poses a question. Does the return type of
`SocketAddress sa => IO (Int, sa)` make sense for `recvBufFrom`?

Author: eborden

Network/Socket/Buffer.hs

@@ -11,7 +11,7 @@ module Network.Socket.Buffer (
 
 import qualified Control.Exception as E
 import Foreign.Marshal.Alloc (alloca)
-import GHC.IO.Exception (IOErrorType(EOF, InvalidArgument))
+import GHC.IO.Exception (IOErrorType(InvalidArgument))
 import System.IO.Error (mkIOError, ioeSetErrorString)
 
 #if defined(mingw32_HOST_OS)
@@ -97,13 +97,9 @@ recvBufFrom s ptr nbytes
             flags = 0
         len <- throwSocketErrorWaitRead s "Network.Socket.recvBufFrom" $
                  c_recvfrom fd ptr cnbytes flags ptr_sa ptr_len
-        let len' = fromIntegral len
-        if len' == 0
-            then ioError (mkEOFError "Network.Socket.recvFrom")
-            else do
-                sockaddr <- peekSocketAddress ptr_sa
-                    `E.catch` \(E.SomeException _) -> getPeerName s
-                return (len', sockaddr)
+        sockaddr <- peekSocketAddress ptr_sa
+            `E.catch` \(E.SomeException _) -> getPeerName s
+        return (fromIntegral len, sockaddr)
 
 -- | Receive data from the socket.  The socket must be in a connected
 -- state. This function may return fewer bytes than specified.  If the
@@ -133,19 +129,13 @@ recvBuf s ptr nbytes
     len <- throwSocketErrorWaitRead s "Network.Socket.recvBuf" $
              c_recv fd (castPtr ptr) (fromIntegral nbytes) 0{-flags-}
 #endif
-    let len' = fromIntegral len
-    if len' == 0
-      then ioError (mkEOFError "Network.Socket.recvBuf")
-      else return len'
+    return $ fromIntegral len
 
 mkInvalidRecvArgError :: String -> IOError
 mkInvalidRecvArgError loc = ioeSetErrorString (mkIOError
                                     InvalidArgument
                                     loc Nothing Nothing) "non-positive length"
 
-mkEOFError :: String -> IOError
-mkEOFError loc = ioeSetErrorString (mkIOError EOF loc Nothing Nothing) "end of file"
-
 #if !defined(mingw32_HOST_OS)
 foreign import ccall unsafe "send"
   c_send :: CInt -> Ptr a -> CSize -> CInt -> IO CInt

Network/Socket/ByteString/IO.hsc

@@ -43,14 +43,12 @@ module Network.Socket.ByteString.IO
     ) where
 
 import Control.Concurrent (threadWaitWrite, rtsSupportsBoundThreads)
-import Control.Exception as E (catch, throwIO)
 import Data.ByteString (ByteString)
 import qualified Data.ByteString as B
 import Data.ByteString.Internal (createAndTrim)
 import Data.ByteString.Unsafe (unsafeUseAsCStringLen)
 import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (castPtr)
-import System.IO.Error (isEOFError)
 
 import Network.Socket.Buffer
 import Network.Socket.ByteString.Internal
@@ -220,10 +218,7 @@ recv :: Socket        -- ^ Connected socket
      -> IO ByteString  -- ^ Data received
 recv s nbytes
     | nbytes < 0 = ioError (mkInvalidRecvArgError "Network.Socket.ByteString.recv")
-    | otherwise  = createAndTrim nbytes $ \ptr ->
-        E.catch
-          (recvBuf s ptr nbytes)
-          (\e -> if isEOFError e then return 0 else throwIO e)
+    | otherwise  = createAndTrim nbytes $ \ptr -> recvBuf s ptr nbytes
 
 -- | Receive data from the socket.  The socket need not be in a
 -- connected state.  Returns @(bytes, address)@ where @bytes@ is a