{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) Support for UNIX-domain (also known as local) sockets. UNIX domain sockets are generally visible in the filesystem. However, some systems support abstract socket names which are not visible in the filesystem and not affected by the filesystem permissions, visibility, etc. Currently this is only supported under Linux. If you attempt to use abstract sockets on other systems, function calls may return 'GI.Gio.Enums.IOErrorEnumNotSupported' errors. You can use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressAbstractNamesSupported' to see if abstract names are supported. Note that @\@ belongs to the UNIX-specific GIO interfaces, thus you have to use the @gio-unix-2.0.pc@ pkg-config file when using it. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.UnixSocketAddress ( -- * Exported types UnixSocketAddress(..) , IsUnixSocketAddress , toUnixSocketAddress , noUnixSocketAddress , -- * Methods -- ** abstractNamesSupported #method:abstractNamesSupported# unixSocketAddressAbstractNamesSupported , -- ** getAddressType #method:getAddressType# #if ENABLE_OVERLOADING UnixSocketAddressGetAddressTypeMethodInfo, #endif unixSocketAddressGetAddressType , -- ** getIsAbstract #method:getIsAbstract# #if ENABLE_OVERLOADING UnixSocketAddressGetIsAbstractMethodInfo, #endif unixSocketAddressGetIsAbstract , -- ** getPath #method:getPath# #if ENABLE_OVERLOADING UnixSocketAddressGetPathMethodInfo , #endif unixSocketAddressGetPath , -- ** getPathLen #method:getPathLen# #if ENABLE_OVERLOADING UnixSocketAddressGetPathLenMethodInfo , #endif unixSocketAddressGetPathLen , -- ** new #method:new# unixSocketAddressNew , -- ** newAbstract #method:newAbstract# unixSocketAddressNewAbstract , -- ** newWithType #method:newWithType# unixSocketAddressNewWithType , -- * Properties -- ** abstract #attr:abstract# {- | Whether or not this is an abstract address -} #if ENABLE_OVERLOADING UnixSocketAddressAbstractPropertyInfo , #endif constructUnixSocketAddressAbstract , getUnixSocketAddressAbstract , #if ENABLE_OVERLOADING unixSocketAddressAbstract , #endif -- ** addressType #attr:addressType# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING UnixSocketAddressAddressTypePropertyInfo, #endif constructUnixSocketAddressAddressType , getUnixSocketAddressAddressType , #if ENABLE_OVERLOADING unixSocketAddressAddressType , #endif -- ** path #attr:path# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING UnixSocketAddressPathPropertyInfo , #endif constructUnixSocketAddressPath , getUnixSocketAddressPath , #if ENABLE_OVERLOADING unixSocketAddressPath , #endif -- ** pathAsArray #attr:pathAsArray# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING UnixSocketAddressPathAsArrayPropertyInfo, #endif constructUnixSocketAddressPathAsArray , getUnixSocketAddressPathAsArray , #if ENABLE_OVERLOADING unixSocketAddressPathAsArray , #endif ) 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 {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums import {-# SOURCE #-} qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress -- | Memory-managed wrapper type. newtype UnixSocketAddress = UnixSocketAddress (ManagedPtr UnixSocketAddress) foreign import ccall "g_unix_socket_address_get_type" c_g_unix_socket_address_get_type :: IO GType instance GObject UnixSocketAddress where gobjectType = c_g_unix_socket_address_get_type -- | Type class for types which can be safely cast to `UnixSocketAddress`, for instance with `toUnixSocketAddress`. class (GObject o, O.IsDescendantOf UnixSocketAddress o) => IsUnixSocketAddress o instance (GObject o, O.IsDescendantOf UnixSocketAddress o) => IsUnixSocketAddress o instance O.HasParentTypes UnixSocketAddress type instance O.ParentTypes UnixSocketAddress = '[Gio.SocketAddress.SocketAddress, GObject.Object.Object, Gio.SocketConnectable.SocketConnectable] -- | Cast to `UnixSocketAddress`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toUnixSocketAddress :: (MonadIO m, IsUnixSocketAddress o) => o -> m UnixSocketAddress toUnixSocketAddress = liftIO . unsafeCastTo UnixSocketAddress -- | A convenience alias for `Nothing` :: `Maybe` `UnixSocketAddress`. noUnixSocketAddress :: Maybe UnixSocketAddress noUnixSocketAddress = Nothing #if ENABLE_OVERLOADING type family ResolveUnixSocketAddressMethod (t :: Symbol) (o :: *) :: * where ResolveUnixSocketAddressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveUnixSocketAddressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveUnixSocketAddressMethod "enumerate" o = Gio.SocketConnectable.SocketConnectableEnumerateMethodInfo ResolveUnixSocketAddressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveUnixSocketAddressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveUnixSocketAddressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveUnixSocketAddressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveUnixSocketAddressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveUnixSocketAddressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveUnixSocketAddressMethod "proxyEnumerate" o = Gio.SocketConnectable.SocketConnectableProxyEnumerateMethodInfo ResolveUnixSocketAddressMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveUnixSocketAddressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveUnixSocketAddressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveUnixSocketAddressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveUnixSocketAddressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveUnixSocketAddressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveUnixSocketAddressMethod "toNative" o = Gio.SocketAddress.SocketAddressToNativeMethodInfo ResolveUnixSocketAddressMethod "toString" o = Gio.SocketConnectable.SocketConnectableToStringMethodInfo ResolveUnixSocketAddressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveUnixSocketAddressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveUnixSocketAddressMethod "getAddressType" o = UnixSocketAddressGetAddressTypeMethodInfo ResolveUnixSocketAddressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveUnixSocketAddressMethod "getFamily" o = Gio.SocketAddress.SocketAddressGetFamilyMethodInfo ResolveUnixSocketAddressMethod "getIsAbstract" o = UnixSocketAddressGetIsAbstractMethodInfo ResolveUnixSocketAddressMethod "getNativeSize" o = Gio.SocketAddress.SocketAddressGetNativeSizeMethodInfo ResolveUnixSocketAddressMethod "getPath" o = UnixSocketAddressGetPathMethodInfo ResolveUnixSocketAddressMethod "getPathLen" o = UnixSocketAddressGetPathLenMethodInfo ResolveUnixSocketAddressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveUnixSocketAddressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveUnixSocketAddressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveUnixSocketAddressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveUnixSocketAddressMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveUnixSocketAddressMethod t UnixSocketAddress, O.MethodInfo info UnixSocketAddress p) => OL.IsLabel t (UnixSocketAddress -> 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 -- VVV Prop "abstract" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@abstract@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' unixSocketAddress #abstract @ -} getUnixSocketAddressAbstract :: (MonadIO m, IsUnixSocketAddress o) => o -> m Bool getUnixSocketAddressAbstract obj = liftIO $ B.Properties.getObjectPropertyBool obj "abstract" {- | Construct a `GValueConstruct` with valid value for the “@abstract@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructUnixSocketAddressAbstract :: (IsUnixSocketAddress o) => Bool -> IO (GValueConstruct o) constructUnixSocketAddressAbstract val = B.Properties.constructObjectPropertyBool "abstract" val #if ENABLE_OVERLOADING data UnixSocketAddressAbstractPropertyInfo instance AttrInfo UnixSocketAddressAbstractPropertyInfo where type AttrAllowedOps UnixSocketAddressAbstractPropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint UnixSocketAddressAbstractPropertyInfo = (~) Bool type AttrBaseTypeConstraint UnixSocketAddressAbstractPropertyInfo = IsUnixSocketAddress type AttrGetType UnixSocketAddressAbstractPropertyInfo = Bool type AttrLabel UnixSocketAddressAbstractPropertyInfo = "abstract" type AttrOrigin UnixSocketAddressAbstractPropertyInfo = UnixSocketAddress attrGet _ = getUnixSocketAddressAbstract attrSet _ = undefined attrConstruct _ = constructUnixSocketAddressAbstract attrClear _ = undefined #endif -- VVV Prop "address-type" -- Type: TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@address-type@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' unixSocketAddress #addressType @ -} getUnixSocketAddressAddressType :: (MonadIO m, IsUnixSocketAddress o) => o -> m Gio.Enums.UnixSocketAddressType getUnixSocketAddressAddressType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "address-type" {- | Construct a `GValueConstruct` with valid value for the “@address-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructUnixSocketAddressAddressType :: (IsUnixSocketAddress o) => Gio.Enums.UnixSocketAddressType -> IO (GValueConstruct o) constructUnixSocketAddressAddressType val = B.Properties.constructObjectPropertyEnum "address-type" val #if ENABLE_OVERLOADING data UnixSocketAddressAddressTypePropertyInfo instance AttrInfo UnixSocketAddressAddressTypePropertyInfo where type AttrAllowedOps UnixSocketAddressAddressTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint UnixSocketAddressAddressTypePropertyInfo = (~) Gio.Enums.UnixSocketAddressType type AttrBaseTypeConstraint UnixSocketAddressAddressTypePropertyInfo = IsUnixSocketAddress type AttrGetType UnixSocketAddressAddressTypePropertyInfo = Gio.Enums.UnixSocketAddressType type AttrLabel UnixSocketAddressAddressTypePropertyInfo = "address-type" type AttrOrigin UnixSocketAddressAddressTypePropertyInfo = UnixSocketAddress attrGet _ = getUnixSocketAddressAddressType attrSet _ = undefined attrConstruct _ = constructUnixSocketAddressAddressType attrClear _ = undefined #endif -- VVV Prop "path" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@path@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' unixSocketAddress #path @ -} getUnixSocketAddressPath :: (MonadIO m, IsUnixSocketAddress o) => o -> m T.Text getUnixSocketAddressPath obj = liftIO $ checkUnexpectedNothing "getUnixSocketAddressPath" $ B.Properties.getObjectPropertyString obj "path" {- | Construct a `GValueConstruct` with valid value for the “@path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructUnixSocketAddressPath :: (IsUnixSocketAddress o) => T.Text -> IO (GValueConstruct o) constructUnixSocketAddressPath val = B.Properties.constructObjectPropertyString "path" (Just val) #if ENABLE_OVERLOADING data UnixSocketAddressPathPropertyInfo instance AttrInfo UnixSocketAddressPathPropertyInfo where type AttrAllowedOps UnixSocketAddressPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint UnixSocketAddressPathPropertyInfo = (~) T.Text type AttrBaseTypeConstraint UnixSocketAddressPathPropertyInfo = IsUnixSocketAddress type AttrGetType UnixSocketAddressPathPropertyInfo = T.Text type AttrLabel UnixSocketAddressPathPropertyInfo = "path" type AttrOrigin UnixSocketAddressPathPropertyInfo = UnixSocketAddress attrGet _ = getUnixSocketAddressPath attrSet _ = undefined attrConstruct _ = constructUnixSocketAddressPath attrClear _ = undefined #endif -- VVV Prop "path-as-array" -- Type: TByteArray -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@path-as-array@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' unixSocketAddress #pathAsArray @ -} getUnixSocketAddressPathAsArray :: (MonadIO m, IsUnixSocketAddress o) => o -> m (Maybe ByteString) getUnixSocketAddressPathAsArray obj = liftIO $ B.Properties.getObjectPropertyByteArray obj "path-as-array" {- | Construct a `GValueConstruct` with valid value for the “@path-as-array@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructUnixSocketAddressPathAsArray :: (IsUnixSocketAddress o) => ByteString -> IO (GValueConstruct o) constructUnixSocketAddressPathAsArray val = B.Properties.constructObjectPropertyByteArray "path-as-array" (Just val) #if ENABLE_OVERLOADING data UnixSocketAddressPathAsArrayPropertyInfo instance AttrInfo UnixSocketAddressPathAsArrayPropertyInfo where type AttrAllowedOps UnixSocketAddressPathAsArrayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = (~) ByteString type AttrBaseTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = IsUnixSocketAddress type AttrGetType UnixSocketAddressPathAsArrayPropertyInfo = (Maybe ByteString) type AttrLabel UnixSocketAddressPathAsArrayPropertyInfo = "path-as-array" type AttrOrigin UnixSocketAddressPathAsArrayPropertyInfo = UnixSocketAddress attrGet _ = getUnixSocketAddressPathAsArray attrSet _ = undefined attrConstruct _ = constructUnixSocketAddressPathAsArray attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList UnixSocketAddress type instance O.AttributeList UnixSocketAddress = UnixSocketAddressAttributeList type UnixSocketAddressAttributeList = ('[ '("abstract", UnixSocketAddressAbstractPropertyInfo), '("addressType", UnixSocketAddressAddressTypePropertyInfo), '("family", Gio.SocketAddress.SocketAddressFamilyPropertyInfo), '("path", UnixSocketAddressPathPropertyInfo), '("pathAsArray", UnixSocketAddressPathAsArrayPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING unixSocketAddressAbstract :: AttrLabelProxy "abstract" unixSocketAddressAbstract = AttrLabelProxy unixSocketAddressAddressType :: AttrLabelProxy "addressType" unixSocketAddressAddressType = AttrLabelProxy unixSocketAddressPath :: AttrLabelProxy "path" unixSocketAddressPath = AttrLabelProxy unixSocketAddressPathAsArray :: AttrLabelProxy "pathAsArray" unixSocketAddressPathAsArray = AttrLabelProxy #endif #if ENABLE_OVERLOADING type instance O.SignalList UnixSocketAddress = UnixSocketAddressSignalList type UnixSocketAddressSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method UnixSocketAddress::new -- method type : Constructor -- Args : [Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the socket path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"})) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_new" g_unix_socket_address_new :: CString -> -- path : TBasicType TUTF8 IO (Ptr UnixSocketAddress) {- | Creates a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' for /@path@/. To create abstract socket addresses, on systems that support that, use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressNewAbstract'. /Since: 2.22/ -} unixSocketAddressNew :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@path@/: the socket path -} -> m UnixSocketAddress {- ^ __Returns:__ a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' -} unixSocketAddressNew path = liftIO $ do path' <- textToCString path result <- g_unix_socket_address_new path' checkUnexpectedReturnNULL "unixSocketAddressNew" result result' <- (wrapObject UnixSocketAddress) result freeMem path' return result' #if ENABLE_OVERLOADING #endif -- method UnixSocketAddress::new_abstract -- method type : Constructor -- Args : [Arg {argCName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the abstract name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"})) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_new_abstract" g_unix_socket_address_new_abstract :: Ptr Int8 -> -- path : TCArray False (-1) 1 (TBasicType TInt8) Int32 -> -- path_len : TBasicType TInt IO (Ptr UnixSocketAddress) {-# DEPRECATED unixSocketAddressNewAbstract ["Use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressNewWithType'."] #-} {- | Creates a new 'GI.Gio.Enums.UnixSocketAddressTypeAbstractPadded' 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' for /@path@/. -} unixSocketAddressNewAbstract :: (B.CallStack.HasCallStack, MonadIO m) => [Int8] {- ^ /@path@/: the abstract name -} -> m UnixSocketAddress {- ^ __Returns:__ a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' -} unixSocketAddressNewAbstract path = liftIO $ do let pathLen = fromIntegral $ length path path' <- packStorableArray path result <- g_unix_socket_address_new_abstract path' pathLen checkUnexpectedReturnNULL "unixSocketAddressNewAbstract" result result' <- (wrapObject UnixSocketAddress) result freeMem path' return result' #if ENABLE_OVERLOADING #endif -- method UnixSocketAddress::new_with_type -- method type : Constructor -- Args : [Arg {argCName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GUnixSocketAddressType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"})) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_new_with_type" g_unix_socket_address_new_with_type :: Ptr Int8 -> -- path : TCArray False (-1) 1 (TBasicType TInt8) Int32 -> -- path_len : TBasicType TInt CUInt -> -- type : TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"}) IO (Ptr UnixSocketAddress) {- | Creates a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' of type /@type@/ with name /@path@/. If /@type@/ is 'GI.Gio.Enums.UnixSocketAddressTypePath', this is equivalent to calling 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressNew'. If /@type@/ is 'GI.Gio.Enums.UnixSocketAddressTypeAnonymous', /@path@/ and /@pathLen@/ will be ignored. If /@pathType@/ is 'GI.Gio.Enums.UnixSocketAddressTypeAbstract', then /@pathLen@/ bytes of /@path@/ will be copied to the socket\'s path, and only those bytes will be considered part of the name. (If /@pathLen@/ is -1, then /@path@/ is assumed to be NUL-terminated.) For example, if /@path@/ was \"test\", then calling 'GI.Gio.Objects.SocketAddress.socketAddressGetNativeSize' on the returned socket would return 7 (2 bytes of overhead, 1 byte for the abstract-socket indicator byte, and 4 bytes for the name \"test\"). If /@pathType@/ is 'GI.Gio.Enums.UnixSocketAddressTypeAbstractPadded', then /@pathLen@/ bytes of /@path@/ will be copied to the socket\'s path, the rest of the path will be padded with 0 bytes, and the entire zero-padded buffer will be considered the name. (As above, if /@pathLen@/ is -1, then /@path@/ is assumed to be NUL-terminated.) In this case, 'GI.Gio.Objects.SocketAddress.socketAddressGetNativeSize' will always return the full size of a @struct sockaddr_un@, although 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetPathLen' will still return just the length of /@path@/. 'GI.Gio.Enums.UnixSocketAddressTypeAbstract' is preferred over 'GI.Gio.Enums.UnixSocketAddressTypeAbstractPadded' for new programs. Of course, when connecting to a server created by another process, you must use the appropriate type corresponding to how that process created its listening socket. /Since: 2.26/ -} unixSocketAddressNewWithType :: (B.CallStack.HasCallStack, MonadIO m) => [Int8] {- ^ /@path@/: the name -} -> Gio.Enums.UnixSocketAddressType {- ^ /@type@/: a 'GI.Gio.Enums.UnixSocketAddressType' -} -> m UnixSocketAddress {- ^ __Returns:__ a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' -} unixSocketAddressNewWithType path type_ = liftIO $ do let pathLen = fromIntegral $ length path path' <- packStorableArray path let type_' = (fromIntegral . fromEnum) type_ result <- g_unix_socket_address_new_with_type path' pathLen type_' checkUnexpectedReturnNULL "unixSocketAddressNewWithType" result result' <- (wrapObject UnixSocketAddress) result freeMem path' return result' #if ENABLE_OVERLOADING #endif -- method UnixSocketAddress::get_address_type -- method type : OrdinaryMethod -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"})) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_get_address_type" g_unix_socket_address_get_address_type :: Ptr UnixSocketAddress -> -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}) IO CUInt {- | Gets /@address@/\'s type. /Since: 2.26/ -} unixSocketAddressGetAddressType :: (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) => a {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -} -> m Gio.Enums.UnixSocketAddressType {- ^ __Returns:__ a 'GI.Gio.Enums.UnixSocketAddressType' -} unixSocketAddressGetAddressType address = liftIO $ do address' <- unsafeManagedPtrCastPtr address result <- g_unix_socket_address_get_address_type address' let result' = (toEnum . fromIntegral) result touchManagedPtr address return result' #if ENABLE_OVERLOADING data UnixSocketAddressGetAddressTypeMethodInfo instance (signature ~ (m Gio.Enums.UnixSocketAddressType), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetAddressTypeMethodInfo a signature where overloadedMethod _ = unixSocketAddressGetAddressType #endif -- method UnixSocketAddress::get_is_abstract -- method type : OrdinaryMethod -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_get_is_abstract" g_unix_socket_address_get_is_abstract :: Ptr UnixSocketAddress -> -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}) IO CInt {-# DEPRECATED unixSocketAddressGetIsAbstract ["Use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetAddressType'"] #-} {- | Tests if /@address@/ is abstract. /Since: 2.22/ -} unixSocketAddressGetIsAbstract :: (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) => a {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -} -> m Bool {- ^ __Returns:__ 'True' if the address is abstract, 'False' otherwise -} unixSocketAddressGetIsAbstract address = liftIO $ do address' <- unsafeManagedPtrCastPtr address result <- g_unix_socket_address_get_is_abstract address' let result' = (/= 0) result touchManagedPtr address return result' #if ENABLE_OVERLOADING data UnixSocketAddressGetIsAbstractMethodInfo instance (signature ~ (m Bool), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetIsAbstractMethodInfo a signature where overloadedMethod _ = unixSocketAddressGetIsAbstract #endif -- method UnixSocketAddress::get_path -- method type : OrdinaryMethod -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_get_path" g_unix_socket_address_get_path :: Ptr UnixSocketAddress -> -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}) IO CString {- | Gets /@address@/\'s path, or for abstract sockets the \"name\". Guaranteed to be zero-terminated, but an abstract socket may contain embedded zeros, and thus you should use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetPathLen' to get the true length of this string. /Since: 2.22/ -} unixSocketAddressGetPath :: (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) => a {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -} -> m T.Text {- ^ __Returns:__ the path for /@address@/ -} unixSocketAddressGetPath address = liftIO $ do address' <- unsafeManagedPtrCastPtr address result <- g_unix_socket_address_get_path address' checkUnexpectedReturnNULL "unixSocketAddressGetPath" result result' <- cstringToText result touchManagedPtr address return result' #if ENABLE_OVERLOADING data UnixSocketAddressGetPathMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetPathMethodInfo a signature where overloadedMethod _ = unixSocketAddressGetPath #endif -- method UnixSocketAddress::get_path_len -- method type : OrdinaryMethod -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt64) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_get_path_len" g_unix_socket_address_get_path_len :: Ptr UnixSocketAddress -> -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}) IO Word64 {- | Gets the length of /@address@/\'s path. For details, see 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetPath'. /Since: 2.22/ -} unixSocketAddressGetPathLen :: (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) => a {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -} -> m Word64 {- ^ __Returns:__ the length of the path -} unixSocketAddressGetPathLen address = liftIO $ do address' <- unsafeManagedPtrCastPtr address result <- g_unix_socket_address_get_path_len address' touchManagedPtr address return result #if ENABLE_OVERLOADING data UnixSocketAddressGetPathLenMethodInfo instance (signature ~ (m Word64), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetPathLenMethodInfo a signature where overloadedMethod _ = unixSocketAddressGetPathLen #endif -- method UnixSocketAddress::abstract_names_supported -- method type : MemberFunction -- Args : [] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "g_unix_socket_address_abstract_names_supported" g_unix_socket_address_abstract_names_supported :: IO CInt {- | Checks if abstract UNIX domain socket names are supported. /Since: 2.22/ -} unixSocketAddressAbstractNamesSupported :: (B.CallStack.HasCallStack, MonadIO m) => m Bool {- ^ __Returns:__ 'True' if supported, 'False' otherwise -} unixSocketAddressAbstractNamesSupported = liftIO $ do result <- g_unix_socket_address_abstract_names_supported let result' = (/= 0) result return result' #if ENABLE_OVERLOADING #endif