This module provides access to the BSD socket interface. This module is generally more efficient than the String based network functions in Network.Socket. For detailed documentation, consult your favorite POSIX socket reference. All functions communicate failures by converting the error number to System.IO.IOError.

This module is made to be imported with Network.Socket like so:

 import Network.Socket hiding (send, sendTo, recv, recvFrom)
 import Network.Socket.ByteString

Vectored I/O, also known as scatter/gather I/O, allows multiple data segments to be sent using a single system call, without first concatenating the segments. For example, given a list of ByteStrings, xs,

 sendMany sock xs

is equivalent to

 sendAll sock (concat xs)

but potentially more efficient.

Vectored I/O are often useful when implementing network protocols that, for example, group data into segments consisting of one or more fixed-length headers followed by a variable-length body.

Here are two minimal example programs using the TCP/IP protocol: a server that echoes all data that it receives back (servicing only one client) and a client using it.

 -- Echo server program
 module Main where

 import Control.Monad (unless)
 import Network.Socket hiding (recv)
 import qualified Data.ByteString as S
 import Network.Socket.ByteString (recv, sendAll)

 main :: IO ()
 main = withSocketsDo $
     do addrinfos <- getAddrInfo
                     (Just (defaultHints {addrFlags = [AI_PASSIVE]}))
                     Nothing (Just "3000")
        let serveraddr = head addrinfos
        sock <- socket (addrFamily serveraddr) Stream defaultProtocol
        bindSocket sock (addrAddress serveraddr)
        listen sock 1
        (conn, _) <- accept sock
        talk conn
        sClose conn
        sClose sock

     where
       talk :: Socket -> IO ()
       talk conn =
           do msg <- recv conn 1024
              unless (S.null msg) $ sendAll conn msg >> talk conn

 -- Echo client program
 module Main where

 import Network.Socket hiding (recv)
 import Network.Socket.ByteString (recv, sendAll)
 import qualified Data.ByteString.Char8 as C

 main :: IO ()
 main = withSocketsDo $
     do addrinfos <- getAddrInfo Nothing (Just "") (Just "3000")
        let serveraddr = head addrinfos
        sock <- socket (addrFamily serveraddr) Stream defaultProtocol
        connect sock (addrAddress serveraddr)
        sendAll sock $ C.pack "Hello, world!"
        msg <- recv sock 1024
        sClose sock
        putStr "Received "
        C.putStrLn msg