Test and remove warnings of undefined behaviour

Network/Socket/Buffer.hs

@@ -53,8 +53,6 @@ socket2FD s = do
 -- | Send data to the socket. The socket must be connected to a remote
 -- socket. Returns the number of bytes sent.  Applications are
 -- responsible for ensuring that all data has been sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendBuf :: Socket    -- Bound/Connected Socket
         -> Ptr Word8  -- Pointer to the data to send
         -> Int        -- Length of the buffer
@@ -115,8 +113,6 @@ recvBufFrom s ptr nbytes
 -- The return value is the length of received data. Zero means
 -- EOF. Historical note: Version 2.8.x.y or earlier,
 -- an EOF error was thrown. This was changed in version 3.0.
---
--- Receiving data from closed socket may lead to undefined behaviour.
 recvBuf :: Socket -> Ptr Word8 -> Int -> IO Int
 recvBuf s ptr nbytes
  | nbytes <= 0 = ioError (mkInvalidRecvArgError "Network.Socket.recvBuf")

Network/Socket/ByteString.hs

@@ -68,8 +68,6 @@ import Network.Socket.Types
 -- explicitly, so the socket need not be in a connected state.
 -- Returns the number of bytes sent. Applications are responsible for
 -- ensuring that all data has been sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendTo :: Socket -> ByteString -> SockAddr -> IO Int
 sendTo = G.sendTo
 
@@ -79,17 +77,13 @@ sendTo = G.sendTo
 -- data has been sent or an error occurs.  On error, an exception is
 -- raised, and there is no way to determine how much data, if any, was
 -- successfully sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendAllTo :: Socket -> ByteString -> SockAddr -> IO ()
 sendAllTo = G.sendAllTo
 
 -- | Receive data from the socket.  The socket need not be in a
 -- connected state.  Returns @(bytes, address)@ where @bytes@ is a
 -- 'ByteString' representing the data received and @address@ is a
 -- 'SockAddr' representing the address of the sending socket.
---
--- Receiving data from closed socket may lead to undefined behaviour.
 recvFrom :: Socket -> Int -> IO (ByteString, SockAddr)
 recvFrom = G.recvFrom
 

Network/Socket/ByteString/IO.hsc

@@ -73,8 +73,6 @@ import Network.Socket.ByteString.MsgHdr (MsgHdr(..))
 -- | Send data to the socket.  The socket must be connected to a
 -- remote socket.  Returns the number of bytes sent. Applications are
 -- responsible for ensuring that all data has been sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 send :: Socket     -- ^ Connected socket
      -> ByteString  -- ^ Data to send
      -> IO Int      -- ^ Number of bytes sent
@@ -92,8 +90,6 @@ waitWhen0 _ _ = return ()
 -- until either all data has been sent or an error occurs.  On error,
 -- an exception is raised, and there is no way to determine how much
 -- data, if any, was successfully sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendAll :: Socket     -- ^ Connected socket
         -> ByteString  -- ^ Data to send
         -> IO ()
@@ -107,8 +103,6 @@ sendAll s bs = do
 -- explicitly, so the socket need not be in a connected state.
 -- Returns the number of bytes sent. Applications are responsible for
 -- ensuring that all data has been sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendTo :: SocketAddress sa =>
           Socket     -- ^ Socket
        -> ByteString  -- ^ Data to send
@@ -123,8 +117,6 @@ sendTo s xs sa =
 -- data has been sent or an error occurs.  On error, an exception is
 -- raised, and there is no way to determine how much data, if any, was
 -- successfully sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendAllTo :: SocketAddress sa =>
              Socket     -- ^ Socket
           -> ByteString  -- ^ Data to send
@@ -142,8 +134,6 @@ sendAllTo s xs sa = do
 -- sent or an error occurs.  On error, an exception is raised, and
 -- there is no way to determine how much data, if any, was
 -- successfully sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendMany :: Socket       -- ^ Connected socket
          -> [ByteString]  -- ^ Data to send
          -> IO ()
@@ -170,8 +160,6 @@ sendMany s = sendAll s . B.concat
 -- continues to send data until either all data has been sent or an
 -- error occurs.  On error, an exception is raised, and there is no
 -- way to determine how much data, if any, was successfully sent.
---
--- Sending data to closed socket may lead to undefined behaviour.
 sendManyTo :: Socket       -- ^ Socket
            -> [ByteString]  -- ^ Data to send
            -> SockAddr      -- ^ Recipient address
@@ -211,8 +199,6 @@ sendManyTo s cs = sendAllTo s (B.concat cs)
 --
 -- For TCP sockets, a zero length return value means the peer has
 -- closed its half side of the connection.
---
--- Receiving data from closed socket may lead to undefined behaviour.
 recv :: Socket        -- ^ Connected socket
      -> Int            -- ^ Maximum number of bytes to receive
      -> IO ByteString  -- ^ Data received
@@ -226,8 +212,6 @@ recv s nbytes
 -- 'SockAddr' representing the address of the sending socket.
 --
 -- If the first return value is zero, it means EOF.
---
--- Receiving data from closed socket may lead to undefined behaviour.
 recvFrom :: SocketAddress sa =>
             Socket                     -- ^ Socket
          -> Int                        -- ^ Maximum number of bytes to receive

Network/Socket/ByteString/Lazy.hs

@@ -33,6 +33,7 @@ import           Data.ByteString.Lazy.Internal (ByteString(..), defaultChunkSize
 import           Network.Socket                (ShutdownCmd (..), shutdown)
 import           Prelude                       hiding (getContents)
 import           System.IO.Unsafe              (unsafeInterleaveIO)
+import           Control.Exception             (onException)
 
 #if defined(mingw32_HOST_OS)
 import Network.Socket.ByteString.Lazy.Windows  (send, sendAll)
@@ -64,7 +65,9 @@ getContents s = loop
     loop = unsafeInterleaveIO $ do
         sbs <- N.recv s defaultChunkSize
         if S.null sbs
-            then shutdown s ShutdownReceive >> return Empty
+            then do
+              shutdown s ShutdownReceive `onException` return ()
+              return Empty
             else Chunk sbs <$> loop
 
 -- | Receive data from the socket.  The socket must be in a connected
@@ -74,8 +77,6 @@ getContents s = loop
 -- until a message arrives.
 --
 -- If there is no more data to be received, returns an empty 'ByteString'.
---
--- Receiving data from closed socket may lead to undefined behaviour.
 recv
     :: Socket -- ^ Connected socket
     -> Int64 -- ^ Maximum number of bytes to receive

Network/Socket/Types.hsc

@@ -136,9 +136,6 @@ invalidateSocket (Socket ref _) errorAction normalAction = do
 -- | Close the socket. This function does not throw exceptions even if
 --   the underlying system call returns errors.
 --
---   Sending data to or receiving data from closed socket
---   may lead to undefined behaviour.
---
 --   If multiple threads use the same socket and one uses 'fdSocket' and
 --   the other use 'close', unexpected behavior may happen.
 --   For more information, please refer to the documentation of 'fdSocket'.
@@ -156,9 +153,6 @@ close s = invalidateSocket s (\_ -> return ()) $ \oldfd -> do
 
 -- | Close the socket. This function throws exceptions if
 --   the underlying system call returns errors.
---
---   Sending data to or receiving data from closed socket
---   may lead to undefined behaviour.
 close' :: Socket -> IO ()
 close' s = invalidateSocket s (\_ -> return ()) $ \oldfd -> do
     -- closeFdWith avoids the deadlock of IO manager.

network.cabal

@@ -115,8 +115,11 @@ test-suite spec
   default-language: Haskell2010
   hs-source-dirs: tests
   main-is: Spec.hs
-  other-modules: RegressionSpec
-                 SimpleSpec
+  other-modules:
+    Network.Test.Common
+    Network.SocketSpec
+    Network.Socket.ByteStringSpec
+    Network.Socket.ByteString.LazySpec
   type: exitcode-stdio-1.0
   ghc-options: -Wall -threaded
   -- NB: make sure to versions of hspec and hspec-discover

tests/Network/Socket/ByteString/LazySpec.hs

@@ -0,0 +1,85 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Network.Socket.ByteString.LazySpec (main, spec) where
+
+import Prelude hiding (getContents)
+
+import qualified Data.ByteString.Lazy as L
+import Network.Socket
+import Network.Socket.ByteString.Lazy
+import Network.Test.Common
+import Control.Monad
+
+import Test.Hspec
+
+main :: IO ()
+main = hspec spec
+
+spec :: Spec
+spec = do
+    describe "send" $ do
+        it "works well" $ do
+            let server sock = recv sock 1024 `shouldReturn` lazyTestMsg
+                client sock = send sock lazyTestMsg
+            tcpTest client server
+
+        it "throws when closed" $ do
+            let server _ = return ()
+                client sock = do
+                    close sock
+                    send sock lazyTestMsg `shouldThrow` anyException
+            tcpTest client server
+
+    describe "sendAll" $ do
+        it "works well" $ do
+            let server sock = recv sock 1024 `shouldReturn` lazyTestMsg
+                client sock = sendAll sock lazyTestMsg
+            tcpTest client server
+
+        it "throws when closed" $ do
+            let server _ = return ()
+                client sock = do
+                    close sock
+                    sendAll sock lazyTestMsg `shouldThrow` anyException
+            tcpTest client server
+
+    describe "getContents" $ do
+        it "works well" $ do
+            let server sock = getContents sock `shouldReturn` lazyTestMsg
+                client sock = do
+                    void $ send sock lazyTestMsg
+                    shutdown sock ShutdownSend
+            tcpTest client server
+
+        it "returns empty string at EOF" $ do
+            let client s = getContents s `shouldReturn` L.empty
+                server s = shutdown s ShutdownSend
+            tcpTest client server
+
+    describe "recv" $ do
+        it "works well" $ do
+            let server sock = recv sock 1024 `shouldReturn` lazyTestMsg
+                client sock = send sock lazyTestMsg
+            tcpTest client server
+
+        it "throws when closed" $ do
+            let server sock = do
+                    close sock
+                    recv sock 1024 `shouldThrow` anyException
+                client sock = send sock lazyTestMsg
+            tcpTest client server
+
+        it "can treat overflow" $ do
+            let server sock = do
+                    seg1 <- recv sock (L.length lazyTestMsg - 3)
+                    seg2 <- recv sock 1024
+                    let msg = L.append seg1 seg2
+                    msg `shouldBe` lazyTestMsg
+                client sock = send sock lazyTestMsg
+            tcpTest client server
+
+        it "returns empty string at EOF" $ do
+            let client s = recv s 4096 `shouldReturn` L.empty
+                server s = shutdown s ShutdownSend
+            tcpTest client server