#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Soup.Objects.Socket
(
Socket(..) ,
IsSocket ,
toSocket ,
noSocket ,
#if ENABLE_OVERLOADING
SocketConnectAsyncMethodInfo ,
#endif
socketConnectAsync ,
#if ENABLE_OVERLOADING
SocketConnectSyncMethodInfo ,
#endif
socketConnectSync ,
#if ENABLE_OVERLOADING
SocketDisconnectMethodInfo ,
#endif
socketDisconnect ,
#if ENABLE_OVERLOADING
SocketGetFdMethodInfo ,
#endif
socketGetFd ,
#if ENABLE_OVERLOADING
SocketGetLocalAddressMethodInfo ,
#endif
socketGetLocalAddress ,
#if ENABLE_OVERLOADING
SocketGetRemoteAddressMethodInfo ,
#endif
socketGetRemoteAddress ,
#if ENABLE_OVERLOADING
SocketIsConnectedMethodInfo ,
#endif
socketIsConnected ,
#if ENABLE_OVERLOADING
SocketIsSslMethodInfo ,
#endif
socketIsSsl ,
#if ENABLE_OVERLOADING
SocketListenMethodInfo ,
#endif
socketListen ,
#if ENABLE_OVERLOADING
SocketReadMethodInfo ,
#endif
socketRead ,
#if ENABLE_OVERLOADING
SocketReadUntilMethodInfo ,
#endif
socketReadUntil ,
#if ENABLE_OVERLOADING
SocketStartProxySslMethodInfo ,
#endif
socketStartProxySsl ,
#if ENABLE_OVERLOADING
SocketStartSslMethodInfo ,
#endif
socketStartSsl ,
#if ENABLE_OVERLOADING
SocketWriteMethodInfo ,
#endif
socketWrite ,
#if ENABLE_OVERLOADING
SocketAsyncContextPropertyInfo ,
#endif
constructSocketAsyncContext ,
getSocketAsyncContext ,
#if ENABLE_OVERLOADING
socketAsyncContext ,
#endif
#if ENABLE_OVERLOADING
SocketFdPropertyInfo ,
#endif
constructSocketFd ,
getSocketFd ,
#if ENABLE_OVERLOADING
socketFd ,
#endif
#if ENABLE_OVERLOADING
SocketGsocketPropertyInfo ,
#endif
constructSocketGsocket ,
#if ENABLE_OVERLOADING
socketGsocket ,
#endif
#if ENABLE_OVERLOADING
SocketIostreamPropertyInfo ,
#endif
constructSocketIostream ,
#if ENABLE_OVERLOADING
socketIostream ,
#endif
#if ENABLE_OVERLOADING
SocketIpv6OnlyPropertyInfo ,
#endif
constructSocketIpv6Only ,
getSocketIpv6Only ,
setSocketIpv6Only ,
#if ENABLE_OVERLOADING
socketIpv6Only ,
#endif
#if ENABLE_OVERLOADING
SocketIsServerPropertyInfo ,
#endif
getSocketIsServer ,
#if ENABLE_OVERLOADING
socketIsServer ,
#endif
#if ENABLE_OVERLOADING
SocketLocalAddressPropertyInfo ,
#endif
constructSocketLocalAddress ,
getSocketLocalAddress ,
#if ENABLE_OVERLOADING
socketLocalAddress ,
#endif
#if ENABLE_OVERLOADING
SocketNonBlockingPropertyInfo ,
#endif
constructSocketNonBlocking ,
getSocketNonBlocking ,
setSocketNonBlocking ,
#if ENABLE_OVERLOADING
socketNonBlocking ,
#endif
#if ENABLE_OVERLOADING
SocketRemoteAddressPropertyInfo ,
#endif
constructSocketRemoteAddress ,
getSocketRemoteAddress ,
#if ENABLE_OVERLOADING
socketRemoteAddress ,
#endif
#if ENABLE_OVERLOADING
SocketSslCredsPropertyInfo ,
#endif
constructSocketSslCreds ,
getSocketSslCreds ,
setSocketSslCreds ,
#if ENABLE_OVERLOADING
socketSslCreds ,
#endif
#if ENABLE_OVERLOADING
SocketSslFallbackPropertyInfo ,
#endif
constructSocketSslFallback ,
getSocketSslFallback ,
#if ENABLE_OVERLOADING
socketSslFallback ,
#endif
#if ENABLE_OVERLOADING
SocketSslStrictPropertyInfo ,
#endif
constructSocketSslStrict ,
getSocketSslStrict ,
#if ENABLE_OVERLOADING
socketSslStrict ,
#endif
#if ENABLE_OVERLOADING
SocketTimeoutPropertyInfo ,
#endif
constructSocketTimeout ,
getSocketTimeout ,
setSocketTimeout ,
#if ENABLE_OVERLOADING
socketTimeout ,
#endif
#if ENABLE_OVERLOADING
SocketTlsCertificatePropertyInfo ,
#endif
getSocketTlsCertificate ,
#if ENABLE_OVERLOADING
socketTlsCertificate ,
#endif
#if ENABLE_OVERLOADING
SocketTlsErrorsPropertyInfo ,
#endif
getSocketTlsErrors ,
#if ENABLE_OVERLOADING
socketTlsErrors ,
#endif
#if ENABLE_OVERLOADING
SocketTrustedCertificatePropertyInfo ,
#endif
getSocketTrustedCertificate ,
#if ENABLE_OVERLOADING
socketTrustedCertificate ,
#endif
#if ENABLE_OVERLOADING
SocketUseThreadContextPropertyInfo ,
#endif
constructSocketUseThreadContext ,
getSocketUseThreadContext ,
#if ENABLE_OVERLOADING
socketUseThreadContext ,
#endif
C_SocketDisconnectedCallback ,
SocketDisconnectedCallback ,
#if ENABLE_OVERLOADING
SocketDisconnectedSignalInfo ,
#endif
afterSocketDisconnected ,
genClosure_SocketDisconnected ,
mk_SocketDisconnectedCallback ,
noSocketDisconnectedCallback ,
onSocketDisconnected ,
wrap_SocketDisconnectedCallback ,
C_SocketEventCallback ,
SocketEventCallback ,
#if ENABLE_OVERLOADING
SocketEventSignalInfo ,
#endif
afterSocketEvent ,
genClosure_SocketEvent ,
mk_SocketEventCallback ,
noSocketEventCallback ,
onSocketEvent ,
wrap_SocketEventCallback ,
C_SocketNewConnectionCallback ,
SocketNewConnectionCallback ,
#if ENABLE_OVERLOADING
SocketNewConnectionSignalInfo ,
#endif
afterSocketNewConnection ,
genClosure_SocketNewConnection ,
mk_SocketNewConnectionCallback ,
noSocketNewConnectionCallback ,
onSocketNewConnection ,
wrap_SocketNewConnectionCallback ,
C_SocketReadableCallback ,
SocketReadableCallback ,
#if ENABLE_OVERLOADING
SocketReadableSignalInfo ,
#endif
afterSocketReadable ,
genClosure_SocketReadable ,
mk_SocketReadableCallback ,
noSocketReadableCallback ,
onSocketReadable ,
wrap_SocketReadableCallback ,
C_SocketWritableCallback ,
SocketWritableCallback ,
#if ENABLE_OVERLOADING
SocketWritableSignalInfo ,
#endif
afterSocketWritable ,
genClosure_SocketWritable ,
mk_SocketWritableCallback ,
noSocketWritableCallback ,
onSocketWritable ,
wrap_SocketWritableCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Enums as Gio.Enums
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.IOStream as Gio.IOStream
import qualified GI.Gio.Objects.Socket as Gio.Socket
import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import qualified GI.Soup.Callbacks as Soup.Callbacks
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Objects.Address as Soup.Address
newtype Socket = Socket (ManagedPtr Socket)
foreign import ccall "soup_socket_get_type"
c_soup_socket_get_type :: IO GType
instance GObject Socket where
gobjectType = c_soup_socket_get_type
class (GObject o, O.IsDescendantOf Socket o) => IsSocket o
instance (GObject o, O.IsDescendantOf Socket o) => IsSocket o
instance O.HasParentTypes Socket
type instance O.ParentTypes Socket = '[GObject.Object.Object, Gio.Initable.Initable]
toSocket :: (MonadIO m, IsSocket o) => o -> m Socket
toSocket = liftIO . unsafeCastTo Socket
noSocket :: Maybe Socket
noSocket = Nothing
#if ENABLE_OVERLOADING
type family ResolveSocketMethod (t :: Symbol) (o :: *) :: * where
ResolveSocketMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveSocketMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveSocketMethod "connectAsync" o = SocketConnectAsyncMethodInfo
ResolveSocketMethod "connectSync" o = SocketConnectSyncMethodInfo
ResolveSocketMethod "disconnect" o = SocketDisconnectMethodInfo
ResolveSocketMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveSocketMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveSocketMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveSocketMethod "init" o = Gio.Initable.InitableInitMethodInfo
ResolveSocketMethod "isConnected" o = SocketIsConnectedMethodInfo
ResolveSocketMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveSocketMethod "isSsl" o = SocketIsSslMethodInfo
ResolveSocketMethod "listen" o = SocketListenMethodInfo
ResolveSocketMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveSocketMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveSocketMethod "read" o = SocketReadMethodInfo
ResolveSocketMethod "readUntil" o = SocketReadUntilMethodInfo
ResolveSocketMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveSocketMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveSocketMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveSocketMethod "startProxySsl" o = SocketStartProxySslMethodInfo
ResolveSocketMethod "startSsl" o = SocketStartSslMethodInfo
ResolveSocketMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveSocketMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveSocketMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveSocketMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveSocketMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveSocketMethod "write" o = SocketWriteMethodInfo
ResolveSocketMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveSocketMethod "getFd" o = SocketGetFdMethodInfo
ResolveSocketMethod "getLocalAddress" o = SocketGetLocalAddressMethodInfo
ResolveSocketMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveSocketMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveSocketMethod "getRemoteAddress" o = SocketGetRemoteAddressMethodInfo
ResolveSocketMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveSocketMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveSocketMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSocketMethod t Socket, O.MethodInfo info Socket p) => OL.IsLabel t (Socket -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
type SocketDisconnectedCallback =
IO ()
noSocketDisconnectedCallback :: Maybe SocketDisconnectedCallback
noSocketDisconnectedCallback = Nothing
type C_SocketDisconnectedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SocketDisconnectedCallback :: C_SocketDisconnectedCallback -> IO (FunPtr C_SocketDisconnectedCallback)
genClosure_SocketDisconnected :: MonadIO m => SocketDisconnectedCallback -> m (GClosure C_SocketDisconnectedCallback)
genClosure_SocketDisconnected cb = liftIO $ do
let cb' = wrap_SocketDisconnectedCallback cb
mk_SocketDisconnectedCallback cb' >>= B.GClosure.newGClosure
wrap_SocketDisconnectedCallback ::
SocketDisconnectedCallback ->
C_SocketDisconnectedCallback
wrap_SocketDisconnectedCallback _cb _ _ = do
_cb
onSocketDisconnected :: (IsSocket a, MonadIO m) => a -> SocketDisconnectedCallback -> m SignalHandlerId
onSocketDisconnected obj cb = liftIO $ do
let cb' = wrap_SocketDisconnectedCallback cb
cb'' <- mk_SocketDisconnectedCallback cb'
connectSignalFunPtr obj "disconnected" cb'' SignalConnectBefore
afterSocketDisconnected :: (IsSocket a, MonadIO m) => a -> SocketDisconnectedCallback -> m SignalHandlerId
afterSocketDisconnected obj cb = liftIO $ do
let cb' = wrap_SocketDisconnectedCallback cb
cb'' <- mk_SocketDisconnectedCallback cb'
connectSignalFunPtr obj "disconnected" cb'' SignalConnectAfter
type SocketEventCallback =
Gio.Enums.SocketClientEvent
-> Gio.IOStream.IOStream
-> IO ()
noSocketEventCallback :: Maybe SocketEventCallback
noSocketEventCallback = Nothing
type C_SocketEventCallback =
Ptr () ->
CUInt ->
Ptr Gio.IOStream.IOStream ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SocketEventCallback :: C_SocketEventCallback -> IO (FunPtr C_SocketEventCallback)
genClosure_SocketEvent :: MonadIO m => SocketEventCallback -> m (GClosure C_SocketEventCallback)
genClosure_SocketEvent cb = liftIO $ do
let cb' = wrap_SocketEventCallback cb
mk_SocketEventCallback cb' >>= B.GClosure.newGClosure
wrap_SocketEventCallback ::
SocketEventCallback ->
C_SocketEventCallback
wrap_SocketEventCallback _cb _ event connection _ = do
let event' = (toEnum . fromIntegral) event
connection' <- (newObject Gio.IOStream.IOStream) connection
_cb event' connection'
onSocketEvent :: (IsSocket a, MonadIO m) => a -> SocketEventCallback -> m SignalHandlerId
onSocketEvent obj cb = liftIO $ do
let cb' = wrap_SocketEventCallback cb
cb'' <- mk_SocketEventCallback cb'
connectSignalFunPtr obj "event" cb'' SignalConnectBefore
afterSocketEvent :: (IsSocket a, MonadIO m) => a -> SocketEventCallback -> m SignalHandlerId
afterSocketEvent obj cb = liftIO $ do
let cb' = wrap_SocketEventCallback cb
cb'' <- mk_SocketEventCallback cb'
connectSignalFunPtr obj "event" cb'' SignalConnectAfter
type SocketNewConnectionCallback =
Socket
-> IO ()
noSocketNewConnectionCallback :: Maybe SocketNewConnectionCallback
noSocketNewConnectionCallback = Nothing
type C_SocketNewConnectionCallback =
Ptr () ->
Ptr Socket ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SocketNewConnectionCallback :: C_SocketNewConnectionCallback -> IO (FunPtr C_SocketNewConnectionCallback)
genClosure_SocketNewConnection :: MonadIO m => SocketNewConnectionCallback -> m (GClosure C_SocketNewConnectionCallback)
genClosure_SocketNewConnection cb = liftIO $ do
let cb' = wrap_SocketNewConnectionCallback cb
mk_SocketNewConnectionCallback cb' >>= B.GClosure.newGClosure
wrap_SocketNewConnectionCallback ::
SocketNewConnectionCallback ->
C_SocketNewConnectionCallback
wrap_SocketNewConnectionCallback _cb _ new _ = do
new' <- (newObject Socket) new
_cb new'
onSocketNewConnection :: (IsSocket a, MonadIO m) => a -> SocketNewConnectionCallback -> m SignalHandlerId
onSocketNewConnection obj cb = liftIO $ do
let cb' = wrap_SocketNewConnectionCallback cb
cb'' <- mk_SocketNewConnectionCallback cb'
connectSignalFunPtr obj "new-connection" cb'' SignalConnectBefore
afterSocketNewConnection :: (IsSocket a, MonadIO m) => a -> SocketNewConnectionCallback -> m SignalHandlerId
afterSocketNewConnection obj cb = liftIO $ do
let cb' = wrap_SocketNewConnectionCallback cb
cb'' <- mk_SocketNewConnectionCallback cb'
connectSignalFunPtr obj "new-connection" cb'' SignalConnectAfter
type SocketReadableCallback =
IO ()
noSocketReadableCallback :: Maybe SocketReadableCallback
noSocketReadableCallback = Nothing
type C_SocketReadableCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SocketReadableCallback :: C_SocketReadableCallback -> IO (FunPtr C_SocketReadableCallback)
genClosure_SocketReadable :: MonadIO m => SocketReadableCallback -> m (GClosure C_SocketReadableCallback)
genClosure_SocketReadable cb = liftIO $ do
let cb' = wrap_SocketReadableCallback cb
mk_SocketReadableCallback cb' >>= B.GClosure.newGClosure
wrap_SocketReadableCallback ::
SocketReadableCallback ->
C_SocketReadableCallback
wrap_SocketReadableCallback _cb _ _ = do
_cb
onSocketReadable :: (IsSocket a, MonadIO m) => a -> SocketReadableCallback -> m SignalHandlerId
onSocketReadable obj cb = liftIO $ do
let cb' = wrap_SocketReadableCallback cb
cb'' <- mk_SocketReadableCallback cb'
connectSignalFunPtr obj "readable" cb'' SignalConnectBefore
afterSocketReadable :: (IsSocket a, MonadIO m) => a -> SocketReadableCallback -> m SignalHandlerId
afterSocketReadable obj cb = liftIO $ do
let cb' = wrap_SocketReadableCallback cb
cb'' <- mk_SocketReadableCallback cb'
connectSignalFunPtr obj "readable" cb'' SignalConnectAfter
type SocketWritableCallback =
IO ()
noSocketWritableCallback :: Maybe SocketWritableCallback
noSocketWritableCallback = Nothing
type C_SocketWritableCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SocketWritableCallback :: C_SocketWritableCallback -> IO (FunPtr C_SocketWritableCallback)
genClosure_SocketWritable :: MonadIO m => SocketWritableCallback -> m (GClosure C_SocketWritableCallback)
genClosure_SocketWritable cb = liftIO $ do
let cb' = wrap_SocketWritableCallback cb
mk_SocketWritableCallback cb' >>= B.GClosure.newGClosure
wrap_SocketWritableCallback ::
SocketWritableCallback ->
C_SocketWritableCallback
wrap_SocketWritableCallback _cb _ _ = do
_cb
onSocketWritable :: (IsSocket a, MonadIO m) => a -> SocketWritableCallback -> m SignalHandlerId
onSocketWritable obj cb = liftIO $ do
let cb' = wrap_SocketWritableCallback cb
cb'' <- mk_SocketWritableCallback cb'
connectSignalFunPtr obj "writable" cb'' SignalConnectBefore
afterSocketWritable :: (IsSocket a, MonadIO m) => a -> SocketWritableCallback -> m SignalHandlerId
afterSocketWritable obj cb = liftIO $ do
let cb' = wrap_SocketWritableCallback cb
cb'' <- mk_SocketWritableCallback cb'
connectSignalFunPtr obj "writable" cb'' SignalConnectAfter
getSocketAsyncContext :: (MonadIO m, IsSocket o) => o -> m (Ptr ())
getSocketAsyncContext obj = liftIO $ B.Properties.getObjectPropertyPtr obj "async-context"
constructSocketAsyncContext :: (IsSocket o) => Ptr () -> IO (GValueConstruct o)
constructSocketAsyncContext val = B.Properties.constructObjectPropertyPtr "async-context" val
#if ENABLE_OVERLOADING
data SocketAsyncContextPropertyInfo
instance AttrInfo SocketAsyncContextPropertyInfo where
type AttrAllowedOps SocketAsyncContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketAsyncContextPropertyInfo = (~) (Ptr ())
type AttrBaseTypeConstraint SocketAsyncContextPropertyInfo = IsSocket
type AttrGetType SocketAsyncContextPropertyInfo = (Ptr ())
type AttrLabel SocketAsyncContextPropertyInfo = "async-context"
type AttrOrigin SocketAsyncContextPropertyInfo = Socket
attrGet _ = getSocketAsyncContext
attrSet _ = undefined
attrConstruct _ = constructSocketAsyncContext
attrClear _ = undefined
#endif
getSocketFd :: (MonadIO m, IsSocket o) => o -> m Int32
getSocketFd obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "fd"
constructSocketFd :: (IsSocket o) => Int32 -> IO (GValueConstruct o)
constructSocketFd val = B.Properties.constructObjectPropertyInt32 "fd" val
#if ENABLE_OVERLOADING
data SocketFdPropertyInfo
instance AttrInfo SocketFdPropertyInfo where
type AttrAllowedOps SocketFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketFdPropertyInfo = (~) Int32
type AttrBaseTypeConstraint SocketFdPropertyInfo = IsSocket
type AttrGetType SocketFdPropertyInfo = Int32
type AttrLabel SocketFdPropertyInfo = "fd"
type AttrOrigin SocketFdPropertyInfo = Socket
attrGet _ = getSocketFd
attrSet _ = undefined
attrConstruct _ = constructSocketFd
attrClear _ = undefined
#endif
constructSocketGsocket :: (IsSocket o, Gio.Socket.IsSocket a) => a -> IO (GValueConstruct o)
constructSocketGsocket val = B.Properties.constructObjectPropertyObject "gsocket" (Just val)
#if ENABLE_OVERLOADING
data SocketGsocketPropertyInfo
instance AttrInfo SocketGsocketPropertyInfo where
type AttrAllowedOps SocketGsocketPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
type AttrSetTypeConstraint SocketGsocketPropertyInfo = Gio.Socket.IsSocket
type AttrBaseTypeConstraint SocketGsocketPropertyInfo = IsSocket
type AttrGetType SocketGsocketPropertyInfo = ()
type AttrLabel SocketGsocketPropertyInfo = "gsocket"
type AttrOrigin SocketGsocketPropertyInfo = Socket
attrGet _ = undefined
attrSet _ = undefined
attrConstruct _ = constructSocketGsocket
attrClear _ = undefined
#endif
constructSocketIostream :: (IsSocket o, Gio.IOStream.IsIOStream a) => a -> IO (GValueConstruct o)
constructSocketIostream val = B.Properties.constructObjectPropertyObject "iostream" (Just val)
#if ENABLE_OVERLOADING
data SocketIostreamPropertyInfo
instance AttrInfo SocketIostreamPropertyInfo where
type AttrAllowedOps SocketIostreamPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
type AttrSetTypeConstraint SocketIostreamPropertyInfo = Gio.IOStream.IsIOStream
type AttrBaseTypeConstraint SocketIostreamPropertyInfo = IsSocket
type AttrGetType SocketIostreamPropertyInfo = ()
type AttrLabel SocketIostreamPropertyInfo = "iostream"
type AttrOrigin SocketIostreamPropertyInfo = Socket
attrGet _ = undefined
attrSet _ = undefined
attrConstruct _ = constructSocketIostream
attrClear _ = undefined
#endif
getSocketIpv6Only :: (MonadIO m, IsSocket o) => o -> m Bool
getSocketIpv6Only obj = liftIO $ B.Properties.getObjectPropertyBool obj "ipv6-only"
setSocketIpv6Only :: (MonadIO m, IsSocket o) => o -> Bool -> m ()
setSocketIpv6Only obj val = liftIO $ B.Properties.setObjectPropertyBool obj "ipv6-only" val
constructSocketIpv6Only :: (IsSocket o) => Bool -> IO (GValueConstruct o)
constructSocketIpv6Only val = B.Properties.constructObjectPropertyBool "ipv6-only" val
#if ENABLE_OVERLOADING
data SocketIpv6OnlyPropertyInfo
instance AttrInfo SocketIpv6OnlyPropertyInfo where
type AttrAllowedOps SocketIpv6OnlyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketIpv6OnlyPropertyInfo = (~) Bool
type AttrBaseTypeConstraint SocketIpv6OnlyPropertyInfo = IsSocket
type AttrGetType SocketIpv6OnlyPropertyInfo = Bool
type AttrLabel SocketIpv6OnlyPropertyInfo = "ipv6-only"
type AttrOrigin SocketIpv6OnlyPropertyInfo = Socket
attrGet _ = getSocketIpv6Only
attrSet _ = setSocketIpv6Only
attrConstruct _ = constructSocketIpv6Only
attrClear _ = undefined
#endif
getSocketIsServer :: (MonadIO m, IsSocket o) => o -> m Bool
getSocketIsServer obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-server"
#if ENABLE_OVERLOADING
data SocketIsServerPropertyInfo
instance AttrInfo SocketIsServerPropertyInfo where
type AttrAllowedOps SocketIsServerPropertyInfo = '[ 'AttrGet]
type AttrSetTypeConstraint SocketIsServerPropertyInfo = (~) ()
type AttrBaseTypeConstraint SocketIsServerPropertyInfo = IsSocket
type AttrGetType SocketIsServerPropertyInfo = Bool
type AttrLabel SocketIsServerPropertyInfo = "is-server"
type AttrOrigin SocketIsServerPropertyInfo = Socket
attrGet _ = getSocketIsServer
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getSocketLocalAddress :: (MonadIO m, IsSocket o) => o -> m Soup.Address.Address
getSocketLocalAddress obj = liftIO $ checkUnexpectedNothing "getSocketLocalAddress" $ B.Properties.getObjectPropertyObject obj "local-address" Soup.Address.Address
constructSocketLocalAddress :: (IsSocket o, Soup.Address.IsAddress a) => a -> IO (GValueConstruct o)
constructSocketLocalAddress val = B.Properties.constructObjectPropertyObject "local-address" (Just val)
#if ENABLE_OVERLOADING
data SocketLocalAddressPropertyInfo
instance AttrInfo SocketLocalAddressPropertyInfo where
type AttrAllowedOps SocketLocalAddressPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint SocketLocalAddressPropertyInfo = Soup.Address.IsAddress
type AttrBaseTypeConstraint SocketLocalAddressPropertyInfo = IsSocket
type AttrGetType SocketLocalAddressPropertyInfo = Soup.Address.Address
type AttrLabel SocketLocalAddressPropertyInfo = "local-address"
type AttrOrigin SocketLocalAddressPropertyInfo = Socket
attrGet _ = getSocketLocalAddress
attrSet _ = undefined
attrConstruct _ = constructSocketLocalAddress
attrClear _ = undefined
#endif
getSocketNonBlocking :: (MonadIO m, IsSocket o) => o -> m Bool
getSocketNonBlocking obj = liftIO $ B.Properties.getObjectPropertyBool obj "non-blocking"
setSocketNonBlocking :: (MonadIO m, IsSocket o) => o -> Bool -> m ()
setSocketNonBlocking obj val = liftIO $ B.Properties.setObjectPropertyBool obj "non-blocking" val
constructSocketNonBlocking :: (IsSocket o) => Bool -> IO (GValueConstruct o)
constructSocketNonBlocking val = B.Properties.constructObjectPropertyBool "non-blocking" val
#if ENABLE_OVERLOADING
data SocketNonBlockingPropertyInfo
instance AttrInfo SocketNonBlockingPropertyInfo where
type AttrAllowedOps SocketNonBlockingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketNonBlockingPropertyInfo = (~) Bool
type AttrBaseTypeConstraint SocketNonBlockingPropertyInfo = IsSocket
type AttrGetType SocketNonBlockingPropertyInfo = Bool
type AttrLabel SocketNonBlockingPropertyInfo = "non-blocking"
type AttrOrigin SocketNonBlockingPropertyInfo = Socket
attrGet _ = getSocketNonBlocking
attrSet _ = setSocketNonBlocking
attrConstruct _ = constructSocketNonBlocking
attrClear _ = undefined
#endif
getSocketRemoteAddress :: (MonadIO m, IsSocket o) => o -> m Soup.Address.Address
getSocketRemoteAddress obj = liftIO $ checkUnexpectedNothing "getSocketRemoteAddress" $ B.Properties.getObjectPropertyObject obj "remote-address" Soup.Address.Address
constructSocketRemoteAddress :: (IsSocket o, Soup.Address.IsAddress a) => a -> IO (GValueConstruct o)
constructSocketRemoteAddress val = B.Properties.constructObjectPropertyObject "remote-address" (Just val)
#if ENABLE_OVERLOADING
data SocketRemoteAddressPropertyInfo
instance AttrInfo SocketRemoteAddressPropertyInfo where
type AttrAllowedOps SocketRemoteAddressPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint SocketRemoteAddressPropertyInfo = Soup.Address.IsAddress
type AttrBaseTypeConstraint SocketRemoteAddressPropertyInfo = IsSocket
type AttrGetType SocketRemoteAddressPropertyInfo = Soup.Address.Address
type AttrLabel SocketRemoteAddressPropertyInfo = "remote-address"
type AttrOrigin SocketRemoteAddressPropertyInfo = Socket
attrGet _ = getSocketRemoteAddress
attrSet _ = undefined
attrConstruct _ = constructSocketRemoteAddress
attrClear _ = undefined
#endif
getSocketSslCreds :: (MonadIO m, IsSocket o) => o -> m (Ptr ())
getSocketSslCreds obj = liftIO $ B.Properties.getObjectPropertyPtr obj "ssl-creds"
setSocketSslCreds :: (MonadIO m, IsSocket o) => o -> Ptr () -> m ()
setSocketSslCreds obj val = liftIO $ B.Properties.setObjectPropertyPtr obj "ssl-creds" val
constructSocketSslCreds :: (IsSocket o) => Ptr () -> IO (GValueConstruct o)
constructSocketSslCreds val = B.Properties.constructObjectPropertyPtr "ssl-creds" val
#if ENABLE_OVERLOADING
data SocketSslCredsPropertyInfo
instance AttrInfo SocketSslCredsPropertyInfo where
type AttrAllowedOps SocketSslCredsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketSslCredsPropertyInfo = (~) (Ptr ())
type AttrBaseTypeConstraint SocketSslCredsPropertyInfo = IsSocket
type AttrGetType SocketSslCredsPropertyInfo = (Ptr ())
type AttrLabel SocketSslCredsPropertyInfo = "ssl-creds"
type AttrOrigin SocketSslCredsPropertyInfo = Socket
attrGet _ = getSocketSslCreds
attrSet _ = setSocketSslCreds
attrConstruct _ = constructSocketSslCreds
attrClear _ = undefined
#endif
getSocketSslFallback :: (MonadIO m, IsSocket o) => o -> m Bool
getSocketSslFallback obj = liftIO $ B.Properties.getObjectPropertyBool obj "ssl-fallback"
constructSocketSslFallback :: (IsSocket o) => Bool -> IO (GValueConstruct o)
constructSocketSslFallback val = B.Properties.constructObjectPropertyBool "ssl-fallback" val
#if ENABLE_OVERLOADING
data SocketSslFallbackPropertyInfo
instance AttrInfo SocketSslFallbackPropertyInfo where
type AttrAllowedOps SocketSslFallbackPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketSslFallbackPropertyInfo = (~) Bool
type AttrBaseTypeConstraint SocketSslFallbackPropertyInfo = IsSocket
type AttrGetType SocketSslFallbackPropertyInfo = Bool
type AttrLabel SocketSslFallbackPropertyInfo = "ssl-fallback"
type AttrOrigin SocketSslFallbackPropertyInfo = Socket
attrGet _ = getSocketSslFallback
attrSet _ = undefined
attrConstruct _ = constructSocketSslFallback
attrClear _ = undefined
#endif
getSocketSslStrict :: (MonadIO m, IsSocket o) => o -> m Bool
getSocketSslStrict obj = liftIO $ B.Properties.getObjectPropertyBool obj "ssl-strict"
constructSocketSslStrict :: (IsSocket o) => Bool -> IO (GValueConstruct o)
constructSocketSslStrict val = B.Properties.constructObjectPropertyBool "ssl-strict" val
#if ENABLE_OVERLOADING
data SocketSslStrictPropertyInfo
instance AttrInfo SocketSslStrictPropertyInfo where
type AttrAllowedOps SocketSslStrictPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketSslStrictPropertyInfo = (~) Bool
type AttrBaseTypeConstraint SocketSslStrictPropertyInfo = IsSocket
type AttrGetType SocketSslStrictPropertyInfo = Bool
type AttrLabel SocketSslStrictPropertyInfo = "ssl-strict"
type AttrOrigin SocketSslStrictPropertyInfo = Socket
attrGet _ = getSocketSslStrict
attrSet _ = undefined
attrConstruct _ = constructSocketSslStrict
attrClear _ = undefined
#endif
getSocketTimeout :: (MonadIO m, IsSocket o) => o -> m Word32
getSocketTimeout obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "timeout"
setSocketTimeout :: (MonadIO m, IsSocket o) => o -> Word32 -> m ()
setSocketTimeout obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "timeout" val
constructSocketTimeout :: (IsSocket o) => Word32 -> IO (GValueConstruct o)
constructSocketTimeout val = B.Properties.constructObjectPropertyUInt32 "timeout" val
#if ENABLE_OVERLOADING
data SocketTimeoutPropertyInfo
instance AttrInfo SocketTimeoutPropertyInfo where
type AttrAllowedOps SocketTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketTimeoutPropertyInfo = (~) Word32
type AttrBaseTypeConstraint SocketTimeoutPropertyInfo = IsSocket
type AttrGetType SocketTimeoutPropertyInfo = Word32
type AttrLabel SocketTimeoutPropertyInfo = "timeout"
type AttrOrigin SocketTimeoutPropertyInfo = Socket
attrGet _ = getSocketTimeout
attrSet _ = setSocketTimeout
attrConstruct _ = constructSocketTimeout
attrClear _ = undefined
#endif
getSocketTlsCertificate :: (MonadIO m, IsSocket o) => o -> m (Maybe Gio.TlsCertificate.TlsCertificate)
getSocketTlsCertificate obj = liftIO $ B.Properties.getObjectPropertyObject obj "tls-certificate" Gio.TlsCertificate.TlsCertificate
#if ENABLE_OVERLOADING
data SocketTlsCertificatePropertyInfo
instance AttrInfo SocketTlsCertificatePropertyInfo where
type AttrAllowedOps SocketTlsCertificatePropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint SocketTlsCertificatePropertyInfo = (~) ()
type AttrBaseTypeConstraint SocketTlsCertificatePropertyInfo = IsSocket
type AttrGetType SocketTlsCertificatePropertyInfo = (Maybe Gio.TlsCertificate.TlsCertificate)
type AttrLabel SocketTlsCertificatePropertyInfo = "tls-certificate"
type AttrOrigin SocketTlsCertificatePropertyInfo = Socket
attrGet _ = getSocketTlsCertificate
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getSocketTlsErrors :: (MonadIO m, IsSocket o) => o -> m [Gio.Flags.TlsCertificateFlags]
getSocketTlsErrors obj = liftIO $ B.Properties.getObjectPropertyFlags obj "tls-errors"
#if ENABLE_OVERLOADING
data SocketTlsErrorsPropertyInfo
instance AttrInfo SocketTlsErrorsPropertyInfo where
type AttrAllowedOps SocketTlsErrorsPropertyInfo = '[ 'AttrGet]
type AttrSetTypeConstraint SocketTlsErrorsPropertyInfo = (~) ()
type AttrBaseTypeConstraint SocketTlsErrorsPropertyInfo = IsSocket
type AttrGetType SocketTlsErrorsPropertyInfo = [Gio.Flags.TlsCertificateFlags]
type AttrLabel SocketTlsErrorsPropertyInfo = "tls-errors"
type AttrOrigin SocketTlsErrorsPropertyInfo = Socket
attrGet _ = getSocketTlsErrors
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getSocketTrustedCertificate :: (MonadIO m, IsSocket o) => o -> m Bool
getSocketTrustedCertificate obj = liftIO $ B.Properties.getObjectPropertyBool obj "trusted-certificate"
#if ENABLE_OVERLOADING
data SocketTrustedCertificatePropertyInfo
instance AttrInfo SocketTrustedCertificatePropertyInfo where
type AttrAllowedOps SocketTrustedCertificatePropertyInfo = '[ 'AttrGet]
type AttrSetTypeConstraint SocketTrustedCertificatePropertyInfo = (~) ()
type AttrBaseTypeConstraint SocketTrustedCertificatePropertyInfo = IsSocket
type AttrGetType SocketTrustedCertificatePropertyInfo = Bool
type AttrLabel SocketTrustedCertificatePropertyInfo = "trusted-certificate"
type AttrOrigin SocketTrustedCertificatePropertyInfo = Socket
attrGet _ = getSocketTrustedCertificate
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getSocketUseThreadContext :: (MonadIO m, IsSocket o) => o -> m Bool
getSocketUseThreadContext obj = liftIO $ B.Properties.getObjectPropertyBool obj "use-thread-context"
constructSocketUseThreadContext :: (IsSocket o) => Bool -> IO (GValueConstruct o)
constructSocketUseThreadContext val = B.Properties.constructObjectPropertyBool "use-thread-context" val
#if ENABLE_OVERLOADING
data SocketUseThreadContextPropertyInfo
instance AttrInfo SocketUseThreadContextPropertyInfo where
type AttrAllowedOps SocketUseThreadContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SocketUseThreadContextPropertyInfo = (~) Bool
type AttrBaseTypeConstraint SocketUseThreadContextPropertyInfo = IsSocket
type AttrGetType SocketUseThreadContextPropertyInfo = Bool
type AttrLabel SocketUseThreadContextPropertyInfo = "use-thread-context"
type AttrOrigin SocketUseThreadContextPropertyInfo = Socket
attrGet _ = getSocketUseThreadContext
attrSet _ = undefined
attrConstruct _ = constructSocketUseThreadContext
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Socket
type instance O.AttributeList Socket = SocketAttributeList
type SocketAttributeList = ('[ '("asyncContext", SocketAsyncContextPropertyInfo), '("fd", SocketFdPropertyInfo), '("gsocket", SocketGsocketPropertyInfo), '("iostream", SocketIostreamPropertyInfo), '("ipv6Only", SocketIpv6OnlyPropertyInfo), '("isServer", SocketIsServerPropertyInfo), '("localAddress", SocketLocalAddressPropertyInfo), '("nonBlocking", SocketNonBlockingPropertyInfo), '("remoteAddress", SocketRemoteAddressPropertyInfo), '("sslCreds", SocketSslCredsPropertyInfo), '("sslFallback", SocketSslFallbackPropertyInfo), '("sslStrict", SocketSslStrictPropertyInfo), '("timeout", SocketTimeoutPropertyInfo), '("tlsCertificate", SocketTlsCertificatePropertyInfo), '("tlsErrors", SocketTlsErrorsPropertyInfo), '("trustedCertificate", SocketTrustedCertificatePropertyInfo), '("useThreadContext", SocketUseThreadContextPropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
socketAsyncContext :: AttrLabelProxy "asyncContext"
socketAsyncContext = AttrLabelProxy
socketFd :: AttrLabelProxy "fd"
socketFd = AttrLabelProxy
socketGsocket :: AttrLabelProxy "gsocket"
socketGsocket = AttrLabelProxy
socketIostream :: AttrLabelProxy "iostream"
socketIostream = AttrLabelProxy
socketIpv6Only :: AttrLabelProxy "ipv6Only"
socketIpv6Only = AttrLabelProxy
socketIsServer :: AttrLabelProxy "isServer"
socketIsServer = AttrLabelProxy
socketLocalAddress :: AttrLabelProxy "localAddress"
socketLocalAddress = AttrLabelProxy
socketNonBlocking :: AttrLabelProxy "nonBlocking"
socketNonBlocking = AttrLabelProxy
socketRemoteAddress :: AttrLabelProxy "remoteAddress"
socketRemoteAddress = AttrLabelProxy
socketSslCreds :: AttrLabelProxy "sslCreds"
socketSslCreds = AttrLabelProxy
socketSslFallback :: AttrLabelProxy "sslFallback"
socketSslFallback = AttrLabelProxy
socketSslStrict :: AttrLabelProxy "sslStrict"
socketSslStrict = AttrLabelProxy
socketTimeout :: AttrLabelProxy "timeout"
socketTimeout = AttrLabelProxy
socketTlsCertificate :: AttrLabelProxy "tlsCertificate"
socketTlsCertificate = AttrLabelProxy
socketTlsErrors :: AttrLabelProxy "tlsErrors"
socketTlsErrors = AttrLabelProxy
socketTrustedCertificate :: AttrLabelProxy "trustedCertificate"
socketTrustedCertificate = AttrLabelProxy
socketUseThreadContext :: AttrLabelProxy "useThreadContext"
socketUseThreadContext = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
data SocketDisconnectedSignalInfo
instance SignalInfo SocketDisconnectedSignalInfo where
type HaskellCallbackType SocketDisconnectedSignalInfo = SocketDisconnectedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_SocketDisconnectedCallback cb
cb'' <- mk_SocketDisconnectedCallback cb'
connectSignalFunPtr obj "disconnected" cb'' connectMode
data SocketEventSignalInfo
instance SignalInfo SocketEventSignalInfo where
type HaskellCallbackType SocketEventSignalInfo = SocketEventCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_SocketEventCallback cb
cb'' <- mk_SocketEventCallback cb'
connectSignalFunPtr obj "event" cb'' connectMode
data SocketNewConnectionSignalInfo
instance SignalInfo SocketNewConnectionSignalInfo where
type HaskellCallbackType SocketNewConnectionSignalInfo = SocketNewConnectionCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_SocketNewConnectionCallback cb
cb'' <- mk_SocketNewConnectionCallback cb'
connectSignalFunPtr obj "new-connection" cb'' connectMode
data SocketReadableSignalInfo
instance SignalInfo SocketReadableSignalInfo where
type HaskellCallbackType SocketReadableSignalInfo = SocketReadableCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_SocketReadableCallback cb
cb'' <- mk_SocketReadableCallback cb'
connectSignalFunPtr obj "readable" cb'' connectMode
data SocketWritableSignalInfo
instance SignalInfo SocketWritableSignalInfo where
type HaskellCallbackType SocketWritableSignalInfo = SocketWritableCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_SocketWritableCallback cb
cb'' <- mk_SocketWritableCallback cb'
connectSignalFunPtr obj "writable" cb'' connectMode
type instance O.SignalList Socket = SocketSignalList
type SocketSignalList = ('[ '("disconnected", SocketDisconnectedSignalInfo), '("event", SocketEventSignalInfo), '("newConnection", SocketNewConnectionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("readable", SocketReadableSignalInfo), '("writable", SocketWritableSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_socket_connect_async" soup_socket_connect_async ::
Ptr Socket ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Soup.Callbacks.C_SocketCallback ->
Ptr () ->
IO ()
socketConnectAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> Soup.Callbacks.SocketCallback
-> m ()
socketConnectAsync sock cancellable callback = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
ptrcallback <- callocMem :: IO (Ptr (FunPtr Soup.Callbacks.C_SocketCallback))
callback' <- Soup.Callbacks.mk_SocketCallback (Soup.Callbacks.wrap_SocketCallback (Just ptrcallback) (Soup.Callbacks.drop_closures_SocketCallback callback))
poke ptrcallback callback'
let userData = nullPtr
soup_socket_connect_async sock' maybeCancellable callback' userData
touchManagedPtr sock
whenJust cancellable touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data SocketConnectAsyncMethodInfo
instance (signature ~ (Maybe (b) -> Soup.Callbacks.SocketCallback -> m ()), MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketConnectAsyncMethodInfo a signature where
overloadedMethod _ = socketConnectAsync
#endif
foreign import ccall "soup_socket_connect_sync" soup_socket_connect_sync ::
Ptr Socket ->
Ptr Gio.Cancellable.Cancellable ->
IO Word32
socketConnectSync ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Word32
socketConnectSync sock cancellable = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
result <- soup_socket_connect_sync sock' maybeCancellable
touchManagedPtr sock
whenJust cancellable touchManagedPtr
return result
#if ENABLE_OVERLOADING
data SocketConnectSyncMethodInfo
instance (signature ~ (Maybe (b) -> m Word32), MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketConnectSyncMethodInfo a signature where
overloadedMethod _ = socketConnectSync
#endif
foreign import ccall "soup_socket_disconnect" soup_socket_disconnect ::
Ptr Socket ->
IO ()
socketDisconnect ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a) =>
a
-> m ()
socketDisconnect sock = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
soup_socket_disconnect sock'
touchManagedPtr sock
return ()
#if ENABLE_OVERLOADING
data SocketDisconnectMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSocket a) => O.MethodInfo SocketDisconnectMethodInfo a signature where
overloadedMethod _ = socketDisconnect
#endif
foreign import ccall "soup_socket_get_fd" soup_socket_get_fd ::
Ptr Socket ->
IO Int32
socketGetFd ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a) =>
a
-> m Int32
socketGetFd sock = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
result <- soup_socket_get_fd sock'
touchManagedPtr sock
return result
#if ENABLE_OVERLOADING
data SocketGetFdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsSocket a) => O.MethodInfo SocketGetFdMethodInfo a signature where
overloadedMethod _ = socketGetFd
#endif
foreign import ccall "soup_socket_get_local_address" soup_socket_get_local_address ::
Ptr Socket ->
IO (Ptr Soup.Address.Address)
socketGetLocalAddress ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a) =>
a
-> m Soup.Address.Address
socketGetLocalAddress sock = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
result <- soup_socket_get_local_address sock'
checkUnexpectedReturnNULL "socketGetLocalAddress" result
result' <- (newObject Soup.Address.Address) result
touchManagedPtr sock
return result'
#if ENABLE_OVERLOADING
data SocketGetLocalAddressMethodInfo
instance (signature ~ (m Soup.Address.Address), MonadIO m, IsSocket a) => O.MethodInfo SocketGetLocalAddressMethodInfo a signature where
overloadedMethod _ = socketGetLocalAddress
#endif
foreign import ccall "soup_socket_get_remote_address" soup_socket_get_remote_address ::
Ptr Socket ->
IO (Ptr Soup.Address.Address)
socketGetRemoteAddress ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a) =>
a
-> m Soup.Address.Address
socketGetRemoteAddress sock = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
result <- soup_socket_get_remote_address sock'
checkUnexpectedReturnNULL "socketGetRemoteAddress" result
result' <- (newObject Soup.Address.Address) result
touchManagedPtr sock
return result'
#if ENABLE_OVERLOADING
data SocketGetRemoteAddressMethodInfo
instance (signature ~ (m Soup.Address.Address), MonadIO m, IsSocket a) => O.MethodInfo SocketGetRemoteAddressMethodInfo a signature where
overloadedMethod _ = socketGetRemoteAddress
#endif
foreign import ccall "soup_socket_is_connected" soup_socket_is_connected ::
Ptr Socket ->
IO CInt
socketIsConnected ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a) =>
a
-> m Bool
socketIsConnected sock = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
result <- soup_socket_is_connected sock'
let result' = (/= 0) result
touchManagedPtr sock
return result'
#if ENABLE_OVERLOADING
data SocketIsConnectedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSocket a) => O.MethodInfo SocketIsConnectedMethodInfo a signature where
overloadedMethod _ = socketIsConnected
#endif
foreign import ccall "soup_socket_is_ssl" soup_socket_is_ssl ::
Ptr Socket ->
IO CInt
socketIsSsl ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a) =>
a
-> m Bool
socketIsSsl sock = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
result <- soup_socket_is_ssl sock'
let result' = (/= 0) result
touchManagedPtr sock
return result'
#if ENABLE_OVERLOADING
data SocketIsSslMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSocket a) => O.MethodInfo SocketIsSslMethodInfo a signature where
overloadedMethod _ = socketIsSsl
#endif
foreign import ccall "soup_socket_listen" soup_socket_listen ::
Ptr Socket ->
IO CInt
socketListen ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a) =>
a
-> m Bool
socketListen sock = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
result <- soup_socket_listen sock'
let result' = (/= 0) result
touchManagedPtr sock
return result'
#if ENABLE_OVERLOADING
data SocketListenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSocket a) => O.MethodInfo SocketListenMethodInfo a signature where
overloadedMethod _ = socketListen
#endif
foreign import ccall "soup_socket_read" soup_socket_read ::
Ptr Socket ->
Ptr Word8 ->
Word64 ->
Ptr Word64 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CUInt
socketRead ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) =>
a
-> ByteString
-> Maybe (b)
-> m ((Soup.Enums.SocketIOStatus, Word64))
socketRead sock buffer cancellable = liftIO $ do
let len = fromIntegral $ B.length buffer
sock' <- unsafeManagedPtrCastPtr sock
buffer' <- packByteString buffer
nread <- allocMem :: IO (Ptr Word64)
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
onException (do
result <- propagateGError $ soup_socket_read sock' buffer' len nread maybeCancellable
let result' = (toEnum . fromIntegral) result
nread' <- peek nread
touchManagedPtr sock
whenJust cancellable touchManagedPtr
freeMem buffer'
freeMem nread
return (result', nread')
) (do
freeMem buffer'
freeMem nread
)
#if ENABLE_OVERLOADING
data SocketReadMethodInfo
instance (signature ~ (ByteString -> Maybe (b) -> m ((Soup.Enums.SocketIOStatus, Word64))), MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketReadMethodInfo a signature where
overloadedMethod _ = socketRead
#endif
foreign import ccall "soup_socket_read_until" soup_socket_read_until ::
Ptr Socket ->
Ptr Word8 ->
Word64 ->
Ptr () ->
Word64 ->
Ptr Word64 ->
CInt ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CUInt
socketReadUntil ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) =>
a
-> ByteString
-> Ptr ()
-> Word64
-> Bool
-> Maybe (b)
-> m ((Soup.Enums.SocketIOStatus, Word64))
socketReadUntil sock buffer boundary boundaryLen gotBoundary cancellable = liftIO $ do
let len = fromIntegral $ B.length buffer
sock' <- unsafeManagedPtrCastPtr sock
buffer' <- packByteString buffer
nread <- allocMem :: IO (Ptr Word64)
let gotBoundary' = (fromIntegral . fromEnum) gotBoundary
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
onException (do
result <- propagateGError $ soup_socket_read_until sock' buffer' len boundary boundaryLen nread gotBoundary' maybeCancellable
let result' = (toEnum . fromIntegral) result
nread' <- peek nread
touchManagedPtr sock
whenJust cancellable touchManagedPtr
freeMem buffer'
freeMem nread
return (result', nread')
) (do
freeMem buffer'
freeMem nread
)
#if ENABLE_OVERLOADING
data SocketReadUntilMethodInfo
instance (signature ~ (ByteString -> Ptr () -> Word64 -> Bool -> Maybe (b) -> m ((Soup.Enums.SocketIOStatus, Word64))), MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketReadUntilMethodInfo a signature where
overloadedMethod _ = socketReadUntil
#endif
foreign import ccall "soup_socket_start_proxy_ssl" soup_socket_start_proxy_ssl ::
Ptr Socket ->
CString ->
Ptr Gio.Cancellable.Cancellable ->
IO CInt
socketStartProxySsl ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) =>
a
-> T.Text
-> Maybe (b)
-> m Bool
socketStartProxySsl sock sslHost cancellable = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
sslHost' <- textToCString sslHost
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
result <- soup_socket_start_proxy_ssl sock' sslHost' maybeCancellable
let result' = (/= 0) result
touchManagedPtr sock
whenJust cancellable touchManagedPtr
freeMem sslHost'
return result'
#if ENABLE_OVERLOADING
data SocketStartProxySslMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m Bool), MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketStartProxySslMethodInfo a signature where
overloadedMethod _ = socketStartProxySsl
#endif
foreign import ccall "soup_socket_start_ssl" soup_socket_start_ssl ::
Ptr Socket ->
Ptr Gio.Cancellable.Cancellable ->
IO CInt
socketStartSsl ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Bool
socketStartSsl sock cancellable = liftIO $ do
sock' <- unsafeManagedPtrCastPtr sock
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
result <- soup_socket_start_ssl sock' maybeCancellable
let result' = (/= 0) result
touchManagedPtr sock
whenJust cancellable touchManagedPtr
return result'
#if ENABLE_OVERLOADING
data SocketStartSslMethodInfo
instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketStartSslMethodInfo a signature where
overloadedMethod _ = socketStartSsl
#endif
foreign import ccall "soup_socket_write" soup_socket_write ::
Ptr Socket ->
Ptr Word8 ->
Word64 ->
Ptr Word64 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CUInt
socketWrite ::
(B.CallStack.HasCallStack, MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) =>
a
-> ByteString
-> Maybe (b)
-> m ((Soup.Enums.SocketIOStatus, Word64))
socketWrite sock buffer cancellable = liftIO $ do
let len = fromIntegral $ B.length buffer
sock' <- unsafeManagedPtrCastPtr sock
buffer' <- packByteString buffer
nwrote <- allocMem :: IO (Ptr Word64)
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
onException (do
result <- propagateGError $ soup_socket_write sock' buffer' len nwrote maybeCancellable
let result' = (toEnum . fromIntegral) result
nwrote' <- peek nwrote
touchManagedPtr sock
whenJust cancellable touchManagedPtr
freeMem buffer'
freeMem nwrote
return (result', nwrote')
) (do
freeMem buffer'
freeMem nwrote
)
#if ENABLE_OVERLOADING
data SocketWriteMethodInfo
instance (signature ~ (ByteString -> Maybe (b) -> m ((Soup.Enums.SocketIOStatus, Word64))), MonadIO m, IsSocket a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketWriteMethodInfo a signature where
overloadedMethod _ = socketWrite
#endif