{-# LINE 1 "src/Posix/Socket/Types.hsc" #-}
{-# language DataKinds #-}
{-# language DerivingStrategies #-}
{-# language DuplicateRecordFields #-}
{-# language GADTSyntax #-}
{-# language GeneralizedNewtypeDeriving #-}
{-# language KindSignatures #-}
{-# language MagicHash #-}
{-# language UnboxedTuples #-}
{-# language NamedFieldPuns #-}

-- This is needed because hsc2hs does not currently handle ticked
-- promoted data constructors correctly.
{-# OPTIONS_GHC -fno-warn-unticked-promoted-constructors #-}





-- | All of the data constructors provided by this module are unsafe.
--   Only use them if you really know what you are doing.
module Posix.Socket.Types
  ( Domain(..)
  , Type(..)
  , Protocol(..)
  , Level(..)
  , OptionName(..)
  , OptionValue(..)
  , SocketAddress(..)
  , SocketAddressInternet(..)
  , SocketAddressInternet6(..)
  , SocketAddressUnix(..)
  , MessageFlags(..)
  , Message(..)
  , ShutdownType(..)
    -- * Socket Families
  , unix
  , unspecified
  , internet
  , internet6
    -- * Socket Types
  , stream
  , datagram
  , raw
  , sequencedPacket
    -- * Protocols
  , defaultProtocol
  , rawProtocol
  , icmp
  , tcp
  , udp
  , ip
  , ipv6
    -- * Receive Flags
  , peek
  , outOfBand
  , waitAll
    -- * Send Flags
  , noSignal
    -- * Shutdown Types
  , read
  , write
  , readWrite
    -- * Socket Levels
  , levelSocket
    -- * Option Names
  , optionError
  , broadcast
    -- * Message Header
    -- ** Peek
  , peekMessageHeaderName
  , peekMessageHeaderNameLength
  , peekMessageHeaderIOVector
  , peekMessageHeaderIOVectorLength
  , peekMessageHeaderControl
  , peekMessageHeaderControlLength
  , peekMessageHeaderFlags
  , peekControlMessageHeaderLevel
  , peekControlMessageHeaderLength
  , peekControlMessageHeaderType
    -- ** Poke
  , pokeMessageHeaderName
  , pokeMessageHeaderNameLength
  , pokeMessageHeaderIOVector
  , pokeMessageHeaderIOVectorLength
  , pokeMessageHeaderControl
  , pokeMessageHeaderControlLength
  , pokeMessageHeaderFlags
    -- ** Metadata
  , sizeofMessageHeader
    -- * IO Vector
    -- ** Peek
  , peekIOVectorBase
  , peekIOVectorLength
    -- ** Poke
  , pokeIOVectorBase
  , pokeIOVectorLength
    -- ** Metadata
  , sizeofIOVector
  ) where

import Prelude hiding (read)

import Data.Bits (Bits,(.|.))
import Data.Primitive (ByteArray,Prim(..))
import Data.Primitive.Addr (Addr(..))
import Data.Word (Word16,Word32,Word64)
import Foreign.C.Types (CInt(..),CSize)
import Foreign.Storable (peekByteOff,pokeByteOff)
import GHC.Ptr (Ptr(..))
import GHC.Exts (Int(I#),Int#,(*#),(+#))

import qualified Data.Kind
import qualified Data.Primitive as PM

-- | A socket communications domain, sometimes referred to as a family. The spec
--   mandates @AF_UNIX@, @AF_UNSPEC@, and @AF_INET@.
newtype Domain = Domain CInt

-- | A socket type. The spec mandates @SOCK_STREAM@, @SOCK_DGRAM@,
--   and @SOCK_SEQPACKET@. Other types may be available on a per-platform
--   basis.
newtype Type = Type CInt

newtype Protocol = Protocol { getProtocol :: CInt }

newtype Level = Level CInt

-- | Options used in the @option_name@ argument in @getsockopt@
--   or @setsockopt@.  
newtype OptionName = OptionName CInt

-- | Which end of the socket to shutdown.
newtype ShutdownType = ShutdownType CInt

-- | The direction of a message. The data constructor are only used
--   at the type level as phantom arguments.
data Message = Send | Receive

-- | Receive flags are given by @MessageFlags Receive@ and send flags
--   are given by @MessageFlags Send@. This is done because there are
--   several flags that are applicable in either a receiving
--   context or a sending context.
newtype MessageFlags :: Message -> Data.Kind.Type where
  MessageFlags :: CInt -> MessageFlags m
  deriving stock (Eq)
  deriving newtype (Bits)

instance Semigroup (MessageFlags m) where (<>) = (.|.)
instance Monoid (MessageFlags m) where mempty = MessageFlags 0

-- | The @sockaddr@ data. This is an extensible tagged union, so this library
--   has chosen to represent it as byte array. It is up to platform-specific
--   libraries to inhabit this type with values. The byte array backing this
--   may be unpinned or pinned.
newtype SocketAddress = SocketAddress ByteArray
  deriving newtype (Eq,Show)

-- | The @option_value@ data.
newtype OptionValue = OptionValue ByteArray

-- | An address for an Internet socket over IPv4. The
--   <http://pubs.opengroup.org/onlinepubs/000095399/basedefs/netinet/in.h.html POSIX specification>
--   mandates three fields:
--
--   > sa_family_t     sin_family   AF_INET
--   > in_port_t       sin_port     Port number
--   > struct in_addr  sin_addr     IP address
--
--   This type omits the first field since is a constant that
--   is only relevant for serialization purposes. The spec also
--   mandates that @sin_port@ and @sin_addr@ be in network
--   byte order, so keep in mind that these values are not
--   immidiately useable.
data SocketAddressInternet = SocketAddressInternet
  { port :: !Word16
  , address :: !Word32
  } deriving (Eq,Show)

-- | The index and read functions ignore @sin_family@. The write functions
-- will set @sin_family@ to @AF_INET@.
instance Prim SocketAddressInternet where
  sizeOf# _ = unI (16)
{-# LINE 183 "src/Posix/Socket/Types.hsc" #-}
  alignment# _ = PM.alignment# (undefined :: Word)
  indexByteArray# arr i = SocketAddressInternet
    { port = (\hsc_arr hsc_ix -> indexByteArray# hsc_arr (1# +# (hsc_ix *# 8#))) arr i
{-# LINE 186 "src/Posix/Socket/Types.hsc" #-}
    , address = (\hsc_arr hsc_ix -> indexByteArray# hsc_arr (1# +# (hsc_ix *# 4#))) arr i
{-# LINE 187 "src/Posix/Socket/Types.hsc" #-}
    }
  indexOffAddr# arr i = SocketAddressInternet
    { port = (\hsc_arr hsc_ix -> indexOffAddr# hsc_arr (1# +# (hsc_ix *# 8#))) arr i
{-# LINE 190 "src/Posix/Socket/Types.hsc" #-}
    , address = (\hsc_arr hsc_ix -> indexOffAddr# hsc_arr (1# +# (hsc_ix *# 4#))) arr i
{-# LINE 191 "src/Posix/Socket/Types.hsc" #-}
    }
  readByteArray# arr i s0 =
    case (\hsc_arr hsc_ix -> readByteArray# hsc_arr (1# +# (hsc_ix *# 8#))) arr i s0 of
{-# LINE 194 "src/Posix/Socket/Types.hsc" #-}
      (# s1, port #) -> case (\hsc_arr hsc_ix -> readByteArray# hsc_arr (1# +# (hsc_ix *# 4#))) arr i s1 of
{-# LINE 195 "src/Posix/Socket/Types.hsc" #-}
        (# s2, address #) -> (# s2, SocketAddressInternet{port,address} #)
  readOffAddr# arr i s0 =
    case (\hsc_arr hsc_ix -> readOffAddr# hsc_arr (1# +# (hsc_ix *# 8#))) arr i s0 of
{-# LINE 198 "src/Posix/Socket/Types.hsc" #-}
      (# s1, port #) -> case (\hsc_arr hsc_ix -> readOffAddr# hsc_arr (1# +# (hsc_ix *# 4#))) arr i s1 of
{-# LINE 199 "src/Posix/Socket/Types.hsc" #-}
        (# s2, address #) -> (# s2, SocketAddressInternet{port,address} #)
  writeByteArray# arr i SocketAddressInternet{port,address} s0 =
    case (\hsc_arr hsc_ix -> writeByteArray# hsc_arr (0# +# (hsc_ix *# 8#))) arr i (2 :: Word16) s0 of
{-# LINE 202 "src/Posix/Socket/Types.hsc" #-}
      s1 -> case (\hsc_arr hsc_ix -> writeByteArray# hsc_arr (1# +# (hsc_ix *# 8#))) arr i port s1 of
{-# LINE 203 "src/Posix/Socket/Types.hsc" #-}
        s2 -> (\hsc_arr hsc_ix -> writeByteArray# hsc_arr (1# +# (hsc_ix *# 4#))) arr i address s2
{-# LINE 204 "src/Posix/Socket/Types.hsc" #-}
  writeOffAddr# arr i SocketAddressInternet{port,address} s0 =
    case (\hsc_arr hsc_ix -> writeOffAddr# hsc_arr (0# +# (hsc_ix *# 8#))) arr i (2 :: Word16) s0 of
{-# LINE 206 "src/Posix/Socket/Types.hsc" #-}
      s1 -> case (\hsc_arr hsc_ix -> writeOffAddr# hsc_arr (1# +# (hsc_ix *# 8#))) arr i port s1 of
{-# LINE 207 "src/Posix/Socket/Types.hsc" #-}
        s2 -> (\hsc_arr hsc_ix -> writeOffAddr# hsc_arr (1# +# (hsc_ix *# 4#))) arr i address s2
{-# LINE 208 "src/Posix/Socket/Types.hsc" #-}
  setByteArray# = PM.defaultSetByteArray#
  setOffAddr# = PM.defaultSetOffAddr#

-- Revisit this. We really need a standard Word128 type somewhere.
-- Solution: use the wideword package.
data SocketAddressInternet6 = SocketAddressInternet6
  { port :: !Word16
  , flowInfo :: !Word32
  , addressA :: !Word64
  , addressB :: !Word64
  , scopeId :: !Word32
  }

-- | An address for a UNIX domain socket. The
--   <http://pubs.opengroup.org/onlinepubs/009604499/basedefs/sys/un.h.html POSIX specification>
--   mandates two fields:
--
--   > sa_family_t  sun_family  Address family. 
--   > char         sun_path[]  Socket pathname. 
--
--   However, the first field is omitted since it is always @AF_UNIX@.
--   It is adding during serialization. Although @sun_path@ is a
--   null-terminated string, @SocketAddressUnix@ should not have
--   a trailing null byte. The conversion function @encodeSocketAddressUnix@
--   adds the null terminator. The size of path should not equal
--   or exceed the platform-dependent size of @sun_path@.
newtype SocketAddressUnix = SocketAddressUnix
  { path :: ByteArray
  }

-- | The @SOCK_STREAM@ socket type.
stream :: Type
stream = Type 1
{-# LINE 241 "src/Posix/Socket/Types.hsc" #-}

-- | The @SOCK_DGRAM@ socket type.
datagram :: Type
datagram = Type 2
{-# LINE 245 "src/Posix/Socket/Types.hsc" #-}

-- | The @SOCK_RAW@ socket type. POSIX declares raw sockets optional.
--   However, they are included here for convenience. Please open an
--   issue if this prevents this library from compiling on a
--   POSIX-compliant operating system that anyone uses for haskell
--   development. Keep in mind that even though raw sockets may exist
--   on all POSIX-compliant operating systems, they may differ in
--   their behavior.
raw :: Type
raw = Type 3
{-# LINE 255 "src/Posix/Socket/Types.hsc" #-}

-- | The @SOCK_SEQPACKET@ socket type.
sequencedPacket :: Type
sequencedPacket = Type 5
{-# LINE 259 "src/Posix/Socket/Types.hsc" #-}

-- | The @AF_UNIX@ communications domain.
unix :: Domain
unix = Domain 1
{-# LINE 263 "src/Posix/Socket/Types.hsc" #-}

-- | The @AF_UNSPEC@ communications domain.
unspecified :: Domain
unspecified = Domain 0
{-# LINE 267 "src/Posix/Socket/Types.hsc" #-}

-- | The @AF_INET@ communications domain.
internet :: Domain
internet = Domain 2
{-# LINE 271 "src/Posix/Socket/Types.hsc" #-}

-- | The @AF_INET6@ communications domain. POSIX declares raw sockets
--   optional. However, they are included here for convenience. Please
--   open an issue if this prevents this library from compiling on a
--   POSIX-compliant operating system that anyone uses for haskell
--   development.
internet6 :: Domain
internet6 = Domain 10
{-# LINE 279 "src/Posix/Socket/Types.hsc" #-}

-- | The @MSG_OOB@ receive flag or send flag.
outOfBand :: MessageFlags m
outOfBand = MessageFlags 1
{-# LINE 283 "src/Posix/Socket/Types.hsc" #-}

-- | The @MSG_PEEK@ receive flag.
peek :: MessageFlags Receive
peek = MessageFlags 2
{-# LINE 287 "src/Posix/Socket/Types.hsc" #-}

-- | The @MSG_WAITALL@ receive flag.
waitAll :: MessageFlags Receive
waitAll = MessageFlags 256
{-# LINE 291 "src/Posix/Socket/Types.hsc" #-}

-- | The @MSG_NOSIGNAL@ send flag.
noSignal :: MessageFlags Send
noSignal = MessageFlags 16384
{-# LINE 295 "src/Posix/Socket/Types.hsc" #-}

-- | The default protocol for a socket type.
defaultProtocol :: Protocol
defaultProtocol = Protocol 0

-- | The @IPPROTO_RAW@ protocol.
rawProtocol :: Protocol
rawProtocol = Protocol 255
{-# LINE 303 "src/Posix/Socket/Types.hsc" #-}

-- | The @IPPROTO_ICMP@ protocol.
icmp :: Protocol
icmp = Protocol 1
{-# LINE 307 "src/Posix/Socket/Types.hsc" #-}

-- | The @IPPROTO_TCP@ protocol.
tcp :: Protocol
tcp = Protocol 6
{-# LINE 311 "src/Posix/Socket/Types.hsc" #-}

-- | The @IPPROTO_UDP@ protocol.
udp :: Protocol
udp = Protocol 17
{-# LINE 315 "src/Posix/Socket/Types.hsc" #-}

-- | The @IPPROTO_IP@ protocol.
ip :: Protocol
ip = Protocol 0
{-# LINE 319 "src/Posix/Socket/Types.hsc" #-}

-- | The @IPPROTO_IPV6@ protocol.
ipv6 :: Protocol
ipv6 = Protocol 41
{-# LINE 323 "src/Posix/Socket/Types.hsc" #-}

-- | Disable further receive operations (e.g. @SHUT_RD@)
read :: ShutdownType
read = ShutdownType 0
{-# LINE 327 "src/Posix/Socket/Types.hsc" #-}

-- | Disable further send operations (e.g. @SHUT_WR@)
write :: ShutdownType
write = ShutdownType 1
{-# LINE 331 "src/Posix/Socket/Types.hsc" #-}

-- | Disable further send operations (e.g. @SHUT_RDWR@)
readWrite :: ShutdownType
readWrite = ShutdownType 2
{-# LINE 335 "src/Posix/Socket/Types.hsc" #-}

-- | Socket error status (e.g. @SOL_SOCKET@)
levelSocket :: Level
levelSocket = Level 1
{-# LINE 339 "src/Posix/Socket/Types.hsc" #-}

-- | Socket error status (e.g. @SO_ERROR@)
optionError :: OptionName
optionError = OptionName 4
{-# LINE 343 "src/Posix/Socket/Types.hsc" #-}

-- | Transmission of broadcast messages is supported (e.g. @SO_BROADCAST@)
broadcast :: OptionName
broadcast = OptionName 6
{-# LINE 347 "src/Posix/Socket/Types.hsc" #-}

peekControlMessageHeaderLength :: Addr -> IO CInt
peekControlMessageHeaderLength (Addr p) = (\hsc_ptr -> peekByteOff hsc_ptr 0) (Ptr p)
{-# LINE 350 "src/Posix/Socket/Types.hsc" #-}

peekControlMessageHeaderLevel :: Addr -> IO Level
peekControlMessageHeaderLevel (Addr p) = do
  i <- (\hsc_ptr -> peekByteOff hsc_ptr 8) (Ptr p)
{-# LINE 354 "src/Posix/Socket/Types.hsc" #-}
  pure (Level i)

peekControlMessageHeaderType :: Addr -> IO Type
peekControlMessageHeaderType (Addr p) = do
  i <- (\hsc_ptr -> peekByteOff hsc_ptr 12) (Ptr p)
{-# LINE 359 "src/Posix/Socket/Types.hsc" #-}
  pure (Type i)

-- Think about reintroducing this function when it becomes necessary.
-- advanceControlMessageHeaderData :: Addr -> Addr
-- advanceControlMessageHeaderData p =
--   PM.plusAddr p (#{size struct cmsghdr})

peekIOVectorBase :: Addr -> IO Addr
peekIOVectorBase (Addr p) = do
  Ptr x <- (\hsc_ptr -> peekByteOff hsc_ptr 0) (Ptr p)
{-# LINE 369 "src/Posix/Socket/Types.hsc" #-}
  pure (Addr x)

peekIOVectorLength :: Addr -> IO CSize
peekIOVectorLength (Addr p) = (\hsc_ptr -> peekByteOff hsc_ptr 8) (Ptr p)
{-# LINE 373 "src/Posix/Socket/Types.hsc" #-}

-- | The size of a serialized @msghdr@.
sizeofMessageHeader :: CInt
sizeofMessageHeader = (56)
{-# LINE 377 "src/Posix/Socket/Types.hsc" #-}

-- | The size of a serialized @iovec@.
sizeofIOVector :: CInt
sizeofIOVector = (16)
{-# LINE 381 "src/Posix/Socket/Types.hsc" #-}

peekMessageHeaderName :: Addr -> IO Addr
peekMessageHeaderName (Addr p) = do
  Ptr x <- (\hsc_ptr -> peekByteOff hsc_ptr 0) (Ptr p)
{-# LINE 385 "src/Posix/Socket/Types.hsc" #-}
  pure (Addr x)

pokeMessageHeaderName :: Addr -> Addr -> IO ()
pokeMessageHeaderName (Addr p) (Addr x) = (\hsc_ptr -> pokeByteOff hsc_ptr 0) (Ptr p) (Ptr x)
{-# LINE 389 "src/Posix/Socket/Types.hsc" #-}

pokeMessageHeaderNameLength :: Addr -> CInt -> IO ()
pokeMessageHeaderNameLength (Addr p) = (\hsc_ptr -> pokeByteOff hsc_ptr 8) (Ptr p)
{-# LINE 392 "src/Posix/Socket/Types.hsc" #-}

pokeMessageHeaderIOVector :: Addr -> Addr -> IO ()
pokeMessageHeaderIOVector (Addr p) (Addr x) = (\hsc_ptr -> pokeByteOff hsc_ptr 16) (Ptr p) (Ptr x)
{-# LINE 395 "src/Posix/Socket/Types.hsc" #-}

pokeMessageHeaderIOVectorLength :: Addr -> CSize -> IO ()
pokeMessageHeaderIOVectorLength (Addr p) = (\hsc_ptr -> pokeByteOff hsc_ptr 24) (Ptr p)
{-# LINE 398 "src/Posix/Socket/Types.hsc" #-}

pokeMessageHeaderControl :: Addr -> Addr -> IO ()
pokeMessageHeaderControl (Addr p) (Addr x) = (\hsc_ptr -> pokeByteOff hsc_ptr 32) (Ptr p) (Ptr x)
{-# LINE 401 "src/Posix/Socket/Types.hsc" #-}

pokeMessageHeaderControlLength :: Addr -> CSize -> IO ()
pokeMessageHeaderControlLength (Addr p) = (\hsc_ptr -> pokeByteOff hsc_ptr 40) (Ptr p)
{-# LINE 404 "src/Posix/Socket/Types.hsc" #-}

pokeMessageHeaderFlags :: Addr -> MessageFlags Receive -> IO ()
pokeMessageHeaderFlags (Addr p) (MessageFlags i) = (\hsc_ptr -> pokeByteOff hsc_ptr 48) (Ptr p) i
{-# LINE 407 "src/Posix/Socket/Types.hsc" #-}

peekMessageHeaderNameLength :: Addr -> IO CInt
peekMessageHeaderNameLength (Addr p) = (\hsc_ptr -> peekByteOff hsc_ptr 8) (Ptr p)
{-# LINE 410 "src/Posix/Socket/Types.hsc" #-}

peekMessageHeaderIOVector :: Addr -> IO Addr
peekMessageHeaderIOVector (Addr p) = do
  Ptr r <- (\hsc_ptr -> peekByteOff hsc_ptr 16) (Ptr p)
{-# LINE 414 "src/Posix/Socket/Types.hsc" #-}
  pure (Addr r)

peekMessageHeaderIOVectorLength :: Addr -> IO CSize
peekMessageHeaderIOVectorLength (Addr p) = (\hsc_ptr -> peekByteOff hsc_ptr 24) (Ptr p)
{-# LINE 418 "src/Posix/Socket/Types.hsc" #-}

peekMessageHeaderControl :: Addr -> IO Addr
peekMessageHeaderControl (Addr p) = do
  Ptr r <- (\hsc_ptr -> peekByteOff hsc_ptr 32) (Ptr p)
{-# LINE 422 "src/Posix/Socket/Types.hsc" #-}
  pure (Addr r)

pokeIOVectorBase :: Addr -> Addr -> IO ()
pokeIOVectorBase (Addr p) (Addr x) = (\hsc_ptr -> pokeByteOff hsc_ptr 0) (Ptr p) (Ptr x)
{-# LINE 426 "src/Posix/Socket/Types.hsc" #-}

pokeIOVectorLength :: Addr -> CSize -> IO ()
pokeIOVectorLength (Addr p) = (\hsc_ptr -> pokeByteOff hsc_ptr 8) (Ptr p)
{-# LINE 429 "src/Posix/Socket/Types.hsc" #-}

peekMessageHeaderControlLength :: Addr -> IO CSize
peekMessageHeaderControlLength (Addr p) = (\hsc_ptr -> peekByteOff hsc_ptr 40) (Ptr p)
{-# LINE 432 "src/Posix/Socket/Types.hsc" #-}

peekMessageHeaderFlags :: Addr -> IO (MessageFlags Receive)
peekMessageHeaderFlags (Addr p) = do
  i <- (\hsc_ptr -> peekByteOff hsc_ptr 48) (Ptr p)
{-# LINE 436 "src/Posix/Socket/Types.hsc" #-}
  pure (MessageFlags i)

unI :: Int -> Int#
unI (I# i) = i