{-# LANGUAGE ForeignFunctionInterface, OverloadedStrings #-}
{-# LANGUAGE CPP #-}
module Network.Socket.BufferPool.Recv (
receive
, makeRecvN
) where
import qualified Data.ByteString as BS
import Data.ByteString.Internal (ByteString(..), unsafeCreate)
import Data.IORef
import Foreign.C.Error (eAGAIN, getErrno, throwErrno)
import Foreign.C.Types
import Foreign.Ptr (Ptr, castPtr)
import GHC.Conc (threadWaitRead)
import Network.Socket (Socket, withFdSocket)
import System.Posix.Types (Fd(..))
#ifdef mingw32_HOST_OS
import GHC.IO.FD (FD(..), readRawBufferPtr)
import Network.Socket.BufferPool.Windows
#endif
import Network.Socket.BufferPool.Types
import Network.Socket.BufferPool.Buffer
receive :: Socket -> BufferPool -> Recv
receive :: Socket -> BufferPool -> Recv
receive Socket
sock BufferPool
pool = BufferPool -> (Buffer -> Int -> IO Int) -> Recv
withBufferPool BufferPool
pool forall a b. (a -> b) -> a -> b
$ \Buffer
ptr Int
size -> do
#if MIN_VERSION_network(3,1,0)
forall r. Socket -> (CInt -> IO r) -> IO r
withFdSocket Socket
sock forall a b. (a -> b) -> a -> b
$ \CInt
fd -> do
#elif MIN_VERSION_network(3,0,0)
fd <- fdSocket sock
#else
let fd = fdSocket sock
#endif
let size' :: CSize
size' = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
size
forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> Buffer -> CSize -> IO CInt
tryReceive CInt
fd Buffer
ptr CSize
size'
tryReceive :: CInt -> Buffer -> CSize -> IO CInt
tryReceive :: CInt -> Buffer -> CSize -> IO CInt
tryReceive CInt
sock Buffer
ptr CSize
size = IO CInt
go
where
go :: IO CInt
go = do
#ifdef mingw32_HOST_OS
bytes <- windowsThreadBlockHack $ fromIntegral <$> readRawBufferPtr "tryReceive" (FD sock 1) (castPtr ptr) 0 size
#else
CInt
bytes <- CInt -> Ptr CChar -> CSize -> CInt -> IO CInt
c_recv CInt
sock (forall a b. Ptr a -> Ptr b
castPtr Buffer
ptr) CSize
size CInt
0
#endif
if CInt
bytes forall a. Eq a => a -> a -> Bool
== -CInt
1 then do
Errno
errno <- IO Errno
getErrno
if Errno
errno forall a. Eq a => a -> a -> Bool
== Errno
eAGAIN then do
Fd -> IO ()
threadWaitRead (CInt -> Fd
Fd CInt
sock)
IO CInt
go
else
forall a. String -> IO a
throwErrno String
"tryReceive"
else
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
bytes
makeRecvN :: ByteString -> Recv -> IO RecvN
makeRecvN :: ByteString -> Recv -> IO RecvN
makeRecvN ByteString
bs0 Recv
recv = do
IORef ByteString
ref <- forall a. a -> IO (IORef a)
newIORef ByteString
bs0
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ IORef ByteString -> Recv -> RecvN
recvN IORef ByteString
ref Recv
recv
recvN :: IORef ByteString -> Recv -> RecvN
recvN :: IORef ByteString -> Recv -> RecvN
recvN IORef ByteString
ref Recv
recv Int
size = do
ByteString
cached <- forall a. IORef a -> IO a
readIORef IORef ByteString
ref
(ByteString
bs, ByteString
leftover) <- ByteString -> Int -> Recv -> IO (ByteString, ByteString)
tryRecvN ByteString
cached Int
size Recv
recv
forall a. IORef a -> a -> IO ()
writeIORef IORef ByteString
ref ByteString
leftover
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
bs
tryRecvN :: ByteString -> Int -> IO ByteString -> IO (ByteString, ByteString)
tryRecvN :: ByteString -> Int -> Recv -> IO (ByteString, ByteString)
tryRecvN ByteString
init0 Int
siz0 Recv
recv
| Int
siz0 forall a. Ord a => a -> a -> Bool
<= Int
len0 = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> ByteString -> (ByteString, ByteString)
BS.splitAt Int
siz0 ByteString
init0
| Bool
otherwise = ([ByteString] -> [ByteString])
-> Int -> IO (ByteString, ByteString)
go (ByteString
init0forall a. a -> [a] -> [a]
:) (Int
siz0 forall a. Num a => a -> a -> a
- Int
len0)
where
len0 :: Int
len0 = ByteString -> Int
BS.length ByteString
init0
go :: ([ByteString] -> [ByteString])
-> Int -> IO (ByteString, ByteString)
go [ByteString] -> [ByteString]
build Int
left = do
ByteString
bs <- Recv
recv
let len :: Int
len = ByteString -> Int
BS.length ByteString
bs
if Int
len forall a. Eq a => a -> a -> Bool
== Int
0 then
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString
"", ByteString
"")
else if Int
len forall a. Ord a => a -> a -> Bool
>= Int
left then do
let (ByteString
consume, ByteString
leftover) = Int -> ByteString -> (ByteString, ByteString)
BS.splitAt Int
left ByteString
bs
ret :: ByteString
ret = Int -> [ByteString] -> ByteString
concatN Int
siz0 forall a b. (a -> b) -> a -> b
$ [ByteString] -> [ByteString]
build [ByteString
consume]
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString
ret, ByteString
leftover)
else do
let build' :: [ByteString] -> [ByteString]
build' = [ByteString] -> [ByteString]
build forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString
bs forall a. a -> [a] -> [a]
:)
left' :: Int
left' = Int
left forall a. Num a => a -> a -> a
- Int
len
([ByteString] -> [ByteString])
-> Int -> IO (ByteString, ByteString)
go [ByteString] -> [ByteString]
build' Int
left'
concatN :: Int -> [ByteString] -> ByteString
concatN :: Int -> [ByteString] -> ByteString
concatN Int
total [ByteString]
bss0 = Int -> (Buffer -> IO ()) -> ByteString
unsafeCreate Int
total forall a b. (a -> b) -> a -> b
$ \Buffer
ptr -> [ByteString] -> Buffer -> IO ()
goCopy [ByteString]
bss0 Buffer
ptr
where
goCopy :: [ByteString] -> Buffer -> IO ()
goCopy [] Buffer
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()
goCopy (ByteString
bs:[ByteString]
bss) Buffer
ptr = do
Buffer
ptr' <- Buffer -> ByteString -> IO Buffer
copy Buffer
ptr ByteString
bs
[ByteString] -> Buffer -> IO ()
goCopy [ByteString]
bss Buffer
ptr'
#ifndef mingw32_HOST_OS
foreign import ccall unsafe "recv"
c_recv :: CInt -> Ptr CChar -> CSize -> CInt -> IO CInt
#endif