#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.NM.Functions
(
connWireguardImport ,
ethtoolOptnameIsChannels ,
ethtoolOptnameIsCoalesce ,
ethtoolOptnameIsEee ,
ethtoolOptnameIsFeature ,
ethtoolOptnameIsPause ,
ethtoolOptnameIsRing ,
keyfileRead ,
keyfileWrite ,
utilsApModeSecurityValid ,
utilsBase64secretDecode ,
utilsBin2hexstr ,
utilsBondModeIntToString ,
utilsBondModeStringToInt ,
utilsCheckVirtualDeviceCompatibility ,
utilsEnsureGtypes ,
utilsEnumFromStr ,
utilsEnumGetValues ,
utilsEnumToStr ,
utilsEscapeSsid ,
utilsFileIsCertificate ,
utilsFileIsPkcs12 ,
utilsFileIsPrivateKey ,
utilsFileSearchInPaths ,
utilsGetTimestampMsec ,
utilsHexstr2bin ,
utilsHwaddrAtoba ,
utilsHwaddrAton ,
utilsHwaddrCanonical ,
utilsHwaddrLen ,
utilsHwaddrMatches ,
utilsHwaddrNtoa ,
utilsHwaddrValid ,
utilsIfaceValidName ,
utilsIp4AddressesFromVariant ,
utilsIp4AddressesToVariant ,
utilsIp4DnsFromVariant ,
utilsIp4DnsToVariant ,
utilsIp4GetDefaultPrefix ,
utilsIp4NetmaskToPrefix ,
utilsIp4PrefixToNetmask ,
utilsIp4RoutesFromVariant ,
utilsIp4RoutesToVariant ,
utilsIp6AddressesFromVariant ,
utilsIp6AddressesToVariant ,
utilsIp6DnsFromVariant ,
utilsIp6DnsToVariant ,
utilsIp6RoutesFromVariant ,
utilsIp6RoutesToVariant ,
utilsIpAddressesFromVariant ,
utilsIpAddressesToVariant ,
utilsIpRoutesFromVariant ,
utilsIpRoutesToVariant ,
utilsIpaddrValid ,
utilsIsEmptySsid ,
utilsIsJsonObject ,
utilsIsUuid ,
utilsIsValidIfaceName ,
utilsPrint ,
utilsSameSsid ,
utilsSecurityValid ,
utilsSriovVfFromStr ,
utilsSriovVfToStr ,
utilsSsidToUtf8 ,
utilsTcActionFromStr ,
utilsTcActionToStr ,
utilsTcQdiscFromStr ,
utilsTcQdiscToStr ,
utilsTcTfilterFromStr ,
utilsTcTfilterToStr ,
utilsUuidGenerate ,
utilsVersion ,
utilsWepKeyValid ,
utilsWifi2ghzFreqs ,
utilsWifi5ghzFreqs ,
utilsWifiChannelToFreq ,
utilsWifiFindNextChannel ,
utilsWifiFreqToChannel ,
utilsWifiIsChannelValid ,
utilsWifiStrengthBars ,
utilsWpaPskValid ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.KeyFile as GLib.KeyFile
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.NM.Callbacks as NM.Callbacks
import {-# SOURCE #-} qualified GI.NM.Enums as NM.Enums
import {-# SOURCE #-} qualified GI.NM.Flags as NM.Flags
import {-# SOURCE #-} qualified GI.NM.Interfaces.Connection as NM.Connection
import {-# SOURCE #-} qualified GI.NM.Objects.Setting as NM.Setting
import {-# SOURCE #-} qualified GI.NM.Objects.Setting8021x as NM.Setting8021x
import {-# SOURCE #-} qualified GI.NM.Objects.SettingAdsl as NM.SettingAdsl
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBluetooth as NM.SettingBluetooth
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBond as NM.SettingBond
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBridge as NM.SettingBridge
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBridgePort as NM.SettingBridgePort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingCdma as NM.SettingCdma
import {-# SOURCE #-} qualified GI.NM.Objects.SettingConnection as NM.SettingConnection
import {-# SOURCE #-} qualified GI.NM.Objects.SettingDcb as NM.SettingDcb
import {-# SOURCE #-} qualified GI.NM.Objects.SettingDummy as NM.SettingDummy
import {-# SOURCE #-} qualified GI.NM.Objects.SettingGeneric as NM.SettingGeneric
import {-# SOURCE #-} qualified GI.NM.Objects.SettingGsm as NM.SettingGsm
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIP4Config as NM.SettingIP4Config
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIP6Config as NM.SettingIP6Config
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIPConfig as NM.SettingIPConfig
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIPTunnel as NM.SettingIPTunnel
import {-# SOURCE #-} qualified GI.NM.Objects.SettingInfiniband as NM.SettingInfiniband
import {-# SOURCE #-} qualified GI.NM.Objects.SettingMacsec as NM.SettingMacsec
import {-# SOURCE #-} qualified GI.NM.Objects.SettingMacvlan as NM.SettingMacvlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOlpcMesh as NM.SettingOlpcMesh
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsBridge as NM.SettingOvsBridge
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsInterface as NM.SettingOvsInterface
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsPatch as NM.SettingOvsPatch
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsPort as NM.SettingOvsPort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingPpp as NM.SettingPpp
import {-# SOURCE #-} qualified GI.NM.Objects.SettingPppoe as NM.SettingPppoe
import {-# SOURCE #-} qualified GI.NM.Objects.SettingProxy as NM.SettingProxy
import {-# SOURCE #-} qualified GI.NM.Objects.SettingSerial as NM.SettingSerial
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTCConfig as NM.SettingTCConfig
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTeam as NM.SettingTeam
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTeamPort as NM.SettingTeamPort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTun as NM.SettingTun
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVlan as NM.SettingVlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVpn as NM.SettingVpn
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVxlan as NM.SettingVxlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWimax as NM.SettingWimax
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWired as NM.SettingWired
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWireless as NM.SettingWireless
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWirelessSecurity as NM.SettingWirelessSecurity
import {-# SOURCE #-} qualified GI.NM.Structs.BridgeVlan as NM.BridgeVlan
import {-# SOURCE #-} qualified GI.NM.Structs.IPAddress as NM.IPAddress
import {-# SOURCE #-} qualified GI.NM.Structs.IPRoute as NM.IPRoute
import {-# SOURCE #-} qualified GI.NM.Structs.IPRoutingRule as NM.IPRoutingRule
import {-# SOURCE #-} qualified GI.NM.Structs.Range as NM.Range
import {-# SOURCE #-} qualified GI.NM.Structs.SriovVF as NM.SriovVF
import {-# SOURCE #-} qualified GI.NM.Structs.TCAction as NM.TCAction
import {-# SOURCE #-} qualified GI.NM.Structs.TCQdisc as NM.TCQdisc
import {-# SOURCE #-} qualified GI.NM.Structs.TCTfilter as NM.TCTfilter
import {-# SOURCE #-} qualified GI.NM.Structs.TeamLinkWatcher as NM.TeamLinkWatcher
import {-# SOURCE #-} qualified GI.NM.Structs.VariantAttributeSpec as NM.VariantAttributeSpec
#else
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.KeyFile as GLib.KeyFile
import qualified GI.NM.Callbacks as NM.Callbacks
import {-# SOURCE #-} qualified GI.NM.Enums as NM.Enums
import {-# SOURCE #-} qualified GI.NM.Flags as NM.Flags
import {-# SOURCE #-} qualified GI.NM.Interfaces.Connection as NM.Connection
import {-# SOURCE #-} qualified GI.NM.Structs.IPAddress as NM.IPAddress
import {-# SOURCE #-} qualified GI.NM.Structs.IPRoute as NM.IPRoute
import {-# SOURCE #-} qualified GI.NM.Structs.SriovVF as NM.SriovVF
import {-# SOURCE #-} qualified GI.NM.Structs.TCAction as NM.TCAction
import {-# SOURCE #-} qualified GI.NM.Structs.TCQdisc as NM.TCQdisc
import {-# SOURCE #-} qualified GI.NM.Structs.TCTfilter as NM.TCTfilter
#endif
foreign import ccall "nm_utils_wpa_psk_valid" nm_utils_wpa_psk_valid ::
CString ->
IO CInt
utilsWpaPskValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
utilsWpaPskValid :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
utilsWpaPskValid Text
psk = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
psk' <- Text -> IO CString
textToCString Text
psk
CInt
result <- CString -> IO CInt
nm_utils_wpa_psk_valid CString
psk'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
psk'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_wifi_strength_bars" nm_utils_wifi_strength_bars ::
Word8 ->
IO CString
utilsWifiStrengthBars ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word8
-> m T.Text
utilsWifiStrengthBars :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Word8 -> m Text
utilsWifiStrengthBars Word8
strength = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- Word8 -> IO CString
nm_utils_wifi_strength_bars Word8
strength
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsWifiStrengthBars" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_wifi_is_channel_valid" nm_utils_wifi_is_channel_valid ::
Word32 ->
CString ->
IO CInt
utilsWifiIsChannelValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> T.Text
-> m Bool
utilsWifiIsChannelValid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> Text -> m Bool
utilsWifiIsChannelValid Word32
channel Text
band = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
band' <- Text -> IO CString
textToCString Text
band
CInt
result <- Word32 -> CString -> IO CInt
nm_utils_wifi_is_channel_valid Word32
channel CString
band'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
band'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_wifi_freq_to_channel" nm_utils_wifi_freq_to_channel ::
Word32 ->
IO Word32
utilsWifiFreqToChannel ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Word32
utilsWifiFreqToChannel :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m Word32
utilsWifiFreqToChannel Word32
freq = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- Word32 -> IO Word32
nm_utils_wifi_freq_to_channel Word32
freq
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_wifi_find_next_channel" nm_utils_wifi_find_next_channel ::
Word32 ->
Int32 ->
CString ->
IO Word32
utilsWifiFindNextChannel ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> Int32
-> T.Text
-> m Word32
utilsWifiFindNextChannel :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> Int32 -> Text -> m Word32
utilsWifiFindNextChannel Word32
channel Int32
direction Text
band = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
CString
band' <- Text -> IO CString
textToCString Text
band
Word32
result <- Word32 -> Int32 -> CString -> IO Word32
nm_utils_wifi_find_next_channel Word32
channel Int32
direction CString
band'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
band'
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_wifi_channel_to_freq" nm_utils_wifi_channel_to_freq ::
Word32 ->
CString ->
IO Word32
utilsWifiChannelToFreq ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> T.Text
-> m Word32
utilsWifiChannelToFreq :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> Text -> m Word32
utilsWifiChannelToFreq Word32
channel Text
band = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
CString
band' <- Text -> IO CString
textToCString Text
band
Word32
result <- Word32 -> CString -> IO Word32
nm_utils_wifi_channel_to_freq Word32
channel CString
band'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
band'
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_wifi_5ghz_freqs" nm_utils_wifi_5ghz_freqs ::
IO Word32
utilsWifi5ghzFreqs ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
utilsWifi5ghzFreqs :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
utilsWifi5ghzFreqs = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
nm_utils_wifi_5ghz_freqs
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_wifi_2ghz_freqs" nm_utils_wifi_2ghz_freqs ::
IO Word32
utilsWifi2ghzFreqs ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
utilsWifi2ghzFreqs :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
utilsWifi2ghzFreqs = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
nm_utils_wifi_2ghz_freqs
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_wep_key_valid" nm_utils_wep_key_valid ::
CString ->
CUInt ->
IO CInt
utilsWepKeyValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> NM.Enums.WepKeyType
-> m Bool
utilsWepKeyValid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> WepKeyType -> m Bool
utilsWepKeyValid Text
key WepKeyType
wepType = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
key' <- Text -> IO CString
textToCString Text
key
let wepType' :: CUInt
wepType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (WepKeyType -> Int) -> WepKeyType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WepKeyType -> Int
forall a. Enum a => a -> Int
fromEnum) WepKeyType
wepType
CInt
result <- CString -> CUInt -> IO CInt
nm_utils_wep_key_valid CString
key' CUInt
wepType'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_version" nm_utils_version ::
IO Word32
utilsVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
utilsVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
utilsVersion = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
nm_utils_version
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_uuid_generate" nm_utils_uuid_generate ::
IO CString
utilsUuidGenerate ::
(B.CallStack.HasCallStack, MonadIO m) =>
m T.Text
utilsUuidGenerate :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Text
utilsUuidGenerate = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- IO CString
nm_utils_uuid_generate
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsUuidGenerate" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_tc_tfilter_to_str" nm_utils_tc_tfilter_to_str ::
Ptr NM.TCTfilter.TCTfilter ->
Ptr (Ptr GError) ->
IO CString
utilsTcTfilterToStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
NM.TCTfilter.TCTfilter
-> m T.Text
utilsTcTfilterToStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TCTfilter -> m Text
utilsTcTfilterToStr TCTfilter
tfilter = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr TCTfilter
tfilter' <- TCTfilter -> IO (Ptr TCTfilter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TCTfilter
tfilter
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ Ptr TCTfilter -> Ptr (Ptr GError) -> IO CString
nm_utils_tc_tfilter_to_str Ptr TCTfilter
tfilter'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsTcTfilterToStr" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
TCTfilter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TCTfilter
tfilter
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "nm_utils_tc_tfilter_from_str" nm_utils_tc_tfilter_from_str ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr NM.TCTfilter.TCTfilter)
utilsTcTfilterFromStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m NM.TCTfilter.TCTfilter
utilsTcTfilterFromStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m TCTfilter
utilsTcTfilterFromStr Text
str = IO TCTfilter -> m TCTfilter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TCTfilter -> m TCTfilter) -> IO TCTfilter -> m TCTfilter
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
IO TCTfilter -> IO () -> IO TCTfilter
forall a b. IO a -> IO b -> IO a
onException (do
Ptr TCTfilter
result <- (Ptr (Ptr GError) -> IO (Ptr TCTfilter)) -> IO (Ptr TCTfilter)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr TCTfilter)) -> IO (Ptr TCTfilter))
-> (Ptr (Ptr GError) -> IO (Ptr TCTfilter)) -> IO (Ptr TCTfilter)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr TCTfilter)
nm_utils_tc_tfilter_from_str CString
str'
Text -> Ptr TCTfilter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsTcTfilterFromStr" Ptr TCTfilter
result
TCTfilter
result' <- ((ManagedPtr TCTfilter -> TCTfilter)
-> Ptr TCTfilter -> IO TCTfilter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TCTfilter -> TCTfilter
NM.TCTfilter.TCTfilter) Ptr TCTfilter
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
TCTfilter -> IO TCTfilter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TCTfilter
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
)
foreign import ccall "nm_utils_tc_qdisc_to_str" nm_utils_tc_qdisc_to_str ::
Ptr NM.TCQdisc.TCQdisc ->
Ptr (Ptr GError) ->
IO CString
utilsTcQdiscToStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
NM.TCQdisc.TCQdisc
-> m T.Text
utilsTcQdiscToStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TCQdisc -> m Text
utilsTcQdiscToStr TCQdisc
qdisc = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr TCQdisc
qdisc' <- TCQdisc -> IO (Ptr TCQdisc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TCQdisc
qdisc
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ Ptr TCQdisc -> Ptr (Ptr GError) -> IO CString
nm_utils_tc_qdisc_to_str Ptr TCQdisc
qdisc'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsTcQdiscToStr" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
TCQdisc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TCQdisc
qdisc
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "nm_utils_tc_qdisc_from_str" nm_utils_tc_qdisc_from_str ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr NM.TCQdisc.TCQdisc)
utilsTcQdiscFromStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m NM.TCQdisc.TCQdisc
utilsTcQdiscFromStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m TCQdisc
utilsTcQdiscFromStr Text
str = IO TCQdisc -> m TCQdisc
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TCQdisc -> m TCQdisc) -> IO TCQdisc -> m TCQdisc
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
IO TCQdisc -> IO () -> IO TCQdisc
forall a b. IO a -> IO b -> IO a
onException (do
Ptr TCQdisc
result <- (Ptr (Ptr GError) -> IO (Ptr TCQdisc)) -> IO (Ptr TCQdisc)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr TCQdisc)) -> IO (Ptr TCQdisc))
-> (Ptr (Ptr GError) -> IO (Ptr TCQdisc)) -> IO (Ptr TCQdisc)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr TCQdisc)
nm_utils_tc_qdisc_from_str CString
str'
Text -> Ptr TCQdisc -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsTcQdiscFromStr" Ptr TCQdisc
result
TCQdisc
result' <- ((ManagedPtr TCQdisc -> TCQdisc) -> Ptr TCQdisc -> IO TCQdisc
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TCQdisc -> TCQdisc
NM.TCQdisc.TCQdisc) Ptr TCQdisc
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
TCQdisc -> IO TCQdisc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TCQdisc
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
)
foreign import ccall "nm_utils_tc_action_to_str" nm_utils_tc_action_to_str ::
Ptr NM.TCAction.TCAction ->
Ptr (Ptr GError) ->
IO CString
utilsTcActionToStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
NM.TCAction.TCAction
-> m T.Text
utilsTcActionToStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TCAction -> m Text
utilsTcActionToStr TCAction
action = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr TCAction
action' <- TCAction -> IO (Ptr TCAction)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TCAction
action
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ Ptr TCAction -> Ptr (Ptr GError) -> IO CString
nm_utils_tc_action_to_str Ptr TCAction
action'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsTcActionToStr" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
TCAction -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TCAction
action
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "nm_utils_tc_action_from_str" nm_utils_tc_action_from_str ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr NM.TCAction.TCAction)
utilsTcActionFromStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m NM.TCAction.TCAction
utilsTcActionFromStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m TCAction
utilsTcActionFromStr Text
str = IO TCAction -> m TCAction
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TCAction -> m TCAction) -> IO TCAction -> m TCAction
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
IO TCAction -> IO () -> IO TCAction
forall a b. IO a -> IO b -> IO a
onException (do
Ptr TCAction
result <- (Ptr (Ptr GError) -> IO (Ptr TCAction)) -> IO (Ptr TCAction)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr TCAction)) -> IO (Ptr TCAction))
-> (Ptr (Ptr GError) -> IO (Ptr TCAction)) -> IO (Ptr TCAction)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr TCAction)
nm_utils_tc_action_from_str CString
str'
Text -> Ptr TCAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsTcActionFromStr" Ptr TCAction
result
TCAction
result' <- ((ManagedPtr TCAction -> TCAction) -> Ptr TCAction -> IO TCAction
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TCAction -> TCAction
NM.TCAction.TCAction) Ptr TCAction
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
TCAction -> IO TCAction
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TCAction
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
)
foreign import ccall "nm_utils_ssid_to_utf8" nm_utils_ssid_to_utf8 ::
Ptr Word8 ->
FCT.CSize ->
IO CString
utilsSsidToUtf8 ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m T.Text
utilsSsidToUtf8 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Text
utilsSsidToUtf8 ByteString
ssid = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let len :: CSize
len = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
ssid
Ptr Word8
ssid' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
ssid
CString
result <- Ptr Word8 -> CSize -> IO CString
nm_utils_ssid_to_utf8 Ptr Word8
ssid' CSize
len
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsSsidToUtf8" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
ssid'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_sriov_vf_to_str" nm_utils_sriov_vf_to_str ::
Ptr NM.SriovVF.SriovVF ->
CInt ->
Ptr (Ptr GError) ->
IO CString
utilsSriovVfToStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
NM.SriovVF.SriovVF
-> Bool
-> m T.Text
utilsSriovVfToStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SriovVF -> Bool -> m Text
utilsSriovVfToStr SriovVF
vf Bool
omitIndex = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr SriovVF
vf' <- SriovVF -> IO (Ptr SriovVF)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SriovVF
vf
let omitIndex' :: CInt
omitIndex' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
omitIndex
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ Ptr SriovVF -> CInt -> Ptr (Ptr GError) -> IO CString
nm_utils_sriov_vf_to_str Ptr SriovVF
vf' CInt
omitIndex'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsSriovVfToStr" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
SriovVF -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SriovVF
vf
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "nm_utils_sriov_vf_from_str" nm_utils_sriov_vf_from_str ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr NM.SriovVF.SriovVF)
utilsSriovVfFromStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m NM.SriovVF.SriovVF
utilsSriovVfFromStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m SriovVF
utilsSriovVfFromStr Text
str = IO SriovVF -> m SriovVF
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SriovVF -> m SriovVF) -> IO SriovVF -> m SriovVF
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
IO SriovVF -> IO () -> IO SriovVF
forall a b. IO a -> IO b -> IO a
onException (do
Ptr SriovVF
result <- (Ptr (Ptr GError) -> IO (Ptr SriovVF)) -> IO (Ptr SriovVF)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr SriovVF)) -> IO (Ptr SriovVF))
-> (Ptr (Ptr GError) -> IO (Ptr SriovVF)) -> IO (Ptr SriovVF)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr SriovVF)
nm_utils_sriov_vf_from_str CString
str'
Text -> Ptr SriovVF -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsSriovVfFromStr" Ptr SriovVF
result
SriovVF
result' <- ((ManagedPtr SriovVF -> SriovVF) -> Ptr SriovVF -> IO SriovVF
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SriovVF -> SriovVF
NM.SriovVF.SriovVF) Ptr SriovVF
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
SriovVF -> IO SriovVF
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SriovVF
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
)
foreign import ccall "nm_utils_security_valid" nm_utils_security_valid ::
CUInt ->
CUInt ->
CInt ->
CInt ->
CUInt ->
CUInt ->
CUInt ->
IO CInt
utilsSecurityValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
NM.Enums.UtilsSecurityType
-> [NM.Flags.DeviceWifiCapabilities]
-> Bool
-> Bool
-> [NM.Flags.NM80211ApFlags]
-> [NM.Flags.NM80211ApSecurityFlags]
-> [NM.Flags.NM80211ApSecurityFlags]
-> m Bool
utilsSecurityValid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
UtilsSecurityType
-> [DeviceWifiCapabilities]
-> Bool
-> Bool
-> [NM80211ApFlags]
-> [NM80211ApSecurityFlags]
-> [NM80211ApSecurityFlags]
-> m Bool
utilsSecurityValid UtilsSecurityType
type_ [DeviceWifiCapabilities]
wifiCaps Bool
haveAp Bool
adhoc [NM80211ApFlags]
apFlags [NM80211ApSecurityFlags]
apWpa [NM80211ApSecurityFlags]
apRsn = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (UtilsSecurityType -> Int) -> UtilsSecurityType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UtilsSecurityType -> Int
forall a. Enum a => a -> Int
fromEnum) UtilsSecurityType
type_
let wifiCaps' :: CUInt
wifiCaps' = [DeviceWifiCapabilities] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DeviceWifiCapabilities]
wifiCaps
let haveAp' :: CInt
haveAp' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
haveAp
let adhoc' :: CInt
adhoc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
adhoc
let apFlags' :: CUInt
apFlags' = [NM80211ApFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [NM80211ApFlags]
apFlags
let apWpa' :: CUInt
apWpa' = [NM80211ApSecurityFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [NM80211ApSecurityFlags]
apWpa
let apRsn' :: CUInt
apRsn' = [NM80211ApSecurityFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [NM80211ApSecurityFlags]
apRsn
CInt
result <- CUInt
-> CUInt -> CInt -> CInt -> CUInt -> CUInt -> CUInt -> IO CInt
nm_utils_security_valid CUInt
type_' CUInt
wifiCaps' CInt
haveAp' CInt
adhoc' CUInt
apFlags' CUInt
apWpa' CUInt
apRsn'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_same_ssid" nm_utils_same_ssid ::
Ptr Word8 ->
FCT.CSize ->
Ptr Word8 ->
FCT.CSize ->
CInt ->
IO CInt
utilsSameSsid ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> ByteString
-> Bool
-> m Bool
utilsSameSsid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> ByteString -> Bool -> m Bool
utilsSameSsid ByteString
ssid1 ByteString
ssid2 Bool
ignoreTrailingNull = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
let len2 :: CSize
len2 = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
ssid2
let len1 :: CSize
len1 = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
ssid1
Ptr Word8
ssid1' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
ssid1
Ptr Word8
ssid2' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
ssid2
let ignoreTrailingNull' :: CInt
ignoreTrailingNull' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
ignoreTrailingNull
CInt
result <- Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> CInt -> IO CInt
nm_utils_same_ssid Ptr Word8
ssid1' CSize
len1 Ptr Word8
ssid2' CSize
len2 CInt
ignoreTrailingNull'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
ssid1'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
ssid2'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_print" nm_utils_print ::
Int32 ->
CString ->
IO ()
utilsPrint ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> T.Text
-> m ()
utilsPrint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32 -> Text -> m ()
utilsPrint Int32
outputMode Text
msg = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
CString
msg' <- Text -> IO CString
textToCString Text
msg
Int32 -> CString -> IO ()
nm_utils_print Int32
outputMode CString
msg'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
msg'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "nm_utils_is_valid_iface_name" nm_utils_is_valid_iface_name ::
CString ->
Ptr (Ptr GError) ->
IO CInt
utilsIsValidIfaceName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m ()
utilsIsValidIfaceName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m ()
utilsIsValidIfaceName Maybe Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
CString
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jName -> do
CString
jName' <- Text -> IO CString
textToCString Text
jName
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jName'
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CInt
nm_utils_is_valid_iface_name CString
maybeName
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeName
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeName
)
foreign import ccall "nm_utils_is_uuid" nm_utils_is_uuid ::
CString ->
IO CInt
{-# DEPRECATED utilsIsUuid ["(Since version 1.32)","older versions of NetworkManager had a wrong"," understanding of what makes a valid UUID. This function can thus"," accept some inputs as valid, which in fact are not valid UUIDs."] #-}
utilsIsUuid ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
utilsIsUuid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
utilsIsUuid Maybe Text
str = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeStr <- case Maybe Text
str of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jStr -> do
CString
jStr' <- Text -> IO CString
textToCString Text
jStr
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jStr'
CInt
result <- CString -> IO CInt
nm_utils_is_uuid CString
maybeStr
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeStr
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_is_json_object" nm_utils_is_json_object ::
CString ->
Ptr (Ptr GError) ->
IO CInt
utilsIsJsonObject ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
utilsIsJsonObject :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m ()
utilsIsJsonObject Text
str = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CInt
nm_utils_is_json_object CString
str'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
)
foreign import ccall "nm_utils_is_empty_ssid" nm_utils_is_empty_ssid ::
Ptr Word8 ->
FCT.CSize ->
IO CInt
utilsIsEmptySsid ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m Bool
utilsIsEmptySsid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Bool
utilsIsEmptySsid ByteString
ssid = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
let len :: CSize
len = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
ssid
Ptr Word8
ssid' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
ssid
CInt
result <- Ptr Word8 -> CSize -> IO CInt
nm_utils_is_empty_ssid Ptr Word8
ssid' CSize
len
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
ssid'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_ipaddr_valid" nm_utils_ipaddr_valid ::
Int32 ->
CString ->
IO CInt
utilsIpaddrValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> T.Text
-> m Bool
utilsIpaddrValid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32 -> Text -> m Bool
utilsIpaddrValid Int32
family Text
ip = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
ip' <- Text -> IO CString
textToCString Text
ip
CInt
result <- Int32 -> CString -> IO CInt
nm_utils_ipaddr_valid Int32
family CString
ip'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
ip'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_ip_routes_to_variant" nm_utils_ip_routes_to_variant ::
Ptr (GPtrArray (Ptr NM.IPRoute.IPRoute)) ->
IO (Ptr GVariant)
utilsIpRoutesToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
[NM.IPRoute.IPRoute]
-> m GVariant
utilsIpRoutesToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[IPRoute] -> m GVariant
utilsIpRoutesToVariant [IPRoute]
routes = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
[Ptr IPRoute]
routes' <- (IPRoute -> IO (Ptr IPRoute)) -> [IPRoute] -> IO [Ptr IPRoute]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM IPRoute -> IO (Ptr IPRoute)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [IPRoute]
routes
Ptr (GPtrArray (Ptr IPRoute))
routes'' <- [Ptr IPRoute] -> IO (Ptr (GPtrArray (Ptr IPRoute)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr IPRoute]
routes'
Ptr GVariant
result <- Ptr (GPtrArray (Ptr IPRoute)) -> IO (Ptr GVariant)
nm_utils_ip_routes_to_variant Ptr (GPtrArray (Ptr IPRoute))
routes''
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIpRoutesToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
(IPRoute -> IO ()) -> [IPRoute] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ IPRoute -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [IPRoute]
routes
Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPRoute))
routes''
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip_routes_from_variant" nm_utils_ip_routes_from_variant ::
Ptr GVariant ->
Int32 ->
IO (Ptr (GPtrArray (Ptr NM.IPRoute.IPRoute)))
utilsIpRoutesFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> Int32
-> m [NM.IPRoute.IPRoute]
utilsIpRoutesFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> Int32 -> m [IPRoute]
utilsIpRoutesFromVariant GVariant
value Int32
family = IO [IPRoute] -> m [IPRoute]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [IPRoute] -> m [IPRoute]) -> IO [IPRoute] -> m [IPRoute]
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr (GPtrArray (Ptr IPRoute))
result <- Ptr GVariant -> Int32 -> IO (Ptr (GPtrArray (Ptr IPRoute)))
nm_utils_ip_routes_from_variant Ptr GVariant
value' Int32
family
Text -> Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIpRoutesFromVariant" Ptr (GPtrArray (Ptr IPRoute))
result
[Ptr IPRoute]
result' <- Ptr (GPtrArray (Ptr IPRoute)) -> IO [Ptr IPRoute]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr IPRoute))
result
[IPRoute]
result'' <- (Ptr IPRoute -> IO IPRoute) -> [Ptr IPRoute] -> IO [IPRoute]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr IPRoute -> IPRoute) -> Ptr IPRoute -> IO IPRoute
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IPRoute -> IPRoute
NM.IPRoute.IPRoute) [Ptr IPRoute]
result'
Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPRoute))
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
[IPRoute] -> IO [IPRoute]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [IPRoute]
result''
foreign import ccall "nm_utils_ip_addresses_to_variant" nm_utils_ip_addresses_to_variant ::
Ptr (GPtrArray (Ptr NM.IPAddress.IPAddress)) ->
IO (Ptr GVariant)
utilsIpAddressesToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
[NM.IPAddress.IPAddress]
-> m GVariant
utilsIpAddressesToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[IPAddress] -> m GVariant
utilsIpAddressesToVariant [IPAddress]
addresses = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
[Ptr IPAddress]
addresses' <- (IPAddress -> IO (Ptr IPAddress))
-> [IPAddress] -> IO [Ptr IPAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM IPAddress -> IO (Ptr IPAddress)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [IPAddress]
addresses
Ptr (GPtrArray (Ptr IPAddress))
addresses'' <- [Ptr IPAddress] -> IO (Ptr (GPtrArray (Ptr IPAddress)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr IPAddress]
addresses'
Ptr GVariant
result <- Ptr (GPtrArray (Ptr IPAddress)) -> IO (Ptr GVariant)
nm_utils_ip_addresses_to_variant Ptr (GPtrArray (Ptr IPAddress))
addresses''
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIpAddressesToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
(IPAddress -> IO ()) -> [IPAddress] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ IPAddress -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [IPAddress]
addresses
Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPAddress))
addresses''
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip_addresses_from_variant" nm_utils_ip_addresses_from_variant ::
Ptr GVariant ->
Int32 ->
IO (Ptr (GPtrArray (Ptr NM.IPAddress.IPAddress)))
utilsIpAddressesFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> Int32
-> m [NM.IPAddress.IPAddress]
utilsIpAddressesFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> Int32 -> m [IPAddress]
utilsIpAddressesFromVariant GVariant
value Int32
family = IO [IPAddress] -> m [IPAddress]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [IPAddress] -> m [IPAddress])
-> IO [IPAddress] -> m [IPAddress]
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr (GPtrArray (Ptr IPAddress))
result <- Ptr GVariant -> Int32 -> IO (Ptr (GPtrArray (Ptr IPAddress)))
nm_utils_ip_addresses_from_variant Ptr GVariant
value' Int32
family
Text -> Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIpAddressesFromVariant" Ptr (GPtrArray (Ptr IPAddress))
result
[Ptr IPAddress]
result' <- Ptr (GPtrArray (Ptr IPAddress)) -> IO [Ptr IPAddress]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr IPAddress))
result
[IPAddress]
result'' <- (Ptr IPAddress -> IO IPAddress)
-> [Ptr IPAddress] -> IO [IPAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr IPAddress -> IPAddress)
-> Ptr IPAddress -> IO IPAddress
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IPAddress -> IPAddress
NM.IPAddress.IPAddress) [Ptr IPAddress]
result'
Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPAddress))
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
[IPAddress] -> IO [IPAddress]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [IPAddress]
result''
foreign import ccall "nm_utils_ip6_routes_to_variant" nm_utils_ip6_routes_to_variant ::
Ptr (GPtrArray (Ptr NM.IPRoute.IPRoute)) ->
IO (Ptr GVariant)
utilsIp6RoutesToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
[NM.IPRoute.IPRoute]
-> m GVariant
utilsIp6RoutesToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[IPRoute] -> m GVariant
utilsIp6RoutesToVariant [IPRoute]
routes = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
[Ptr IPRoute]
routes' <- (IPRoute -> IO (Ptr IPRoute)) -> [IPRoute] -> IO [Ptr IPRoute]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM IPRoute -> IO (Ptr IPRoute)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [IPRoute]
routes
Ptr (GPtrArray (Ptr IPRoute))
routes'' <- [Ptr IPRoute] -> IO (Ptr (GPtrArray (Ptr IPRoute)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr IPRoute]
routes'
Ptr GVariant
result <- Ptr (GPtrArray (Ptr IPRoute)) -> IO (Ptr GVariant)
nm_utils_ip6_routes_to_variant Ptr (GPtrArray (Ptr IPRoute))
routes''
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp6RoutesToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
(IPRoute -> IO ()) -> [IPRoute] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ IPRoute -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [IPRoute]
routes
Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPRoute))
routes''
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip6_routes_from_variant" nm_utils_ip6_routes_from_variant ::
Ptr GVariant ->
IO (Ptr (GPtrArray (Ptr NM.IPRoute.IPRoute)))
utilsIp6RoutesFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m [NM.IPRoute.IPRoute]
utilsIp6RoutesFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m [IPRoute]
utilsIp6RoutesFromVariant GVariant
value = IO [IPRoute] -> m [IPRoute]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [IPRoute] -> m [IPRoute]) -> IO [IPRoute] -> m [IPRoute]
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr (GPtrArray (Ptr IPRoute))
result <- Ptr GVariant -> IO (Ptr (GPtrArray (Ptr IPRoute)))
nm_utils_ip6_routes_from_variant Ptr GVariant
value'
Text -> Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp6RoutesFromVariant" Ptr (GPtrArray (Ptr IPRoute))
result
[Ptr IPRoute]
result' <- Ptr (GPtrArray (Ptr IPRoute)) -> IO [Ptr IPRoute]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr IPRoute))
result
[IPRoute]
result'' <- (Ptr IPRoute -> IO IPRoute) -> [Ptr IPRoute] -> IO [IPRoute]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr IPRoute -> IPRoute) -> Ptr IPRoute -> IO IPRoute
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IPRoute -> IPRoute
NM.IPRoute.IPRoute) [Ptr IPRoute]
result'
Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPRoute))
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
[IPRoute] -> IO [IPRoute]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [IPRoute]
result''
foreign import ccall "nm_utils_ip6_dns_to_variant" nm_utils_ip6_dns_to_variant ::
CString ->
IO (Ptr GVariant)
utilsIp6DnsToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m GVariant
utilsIp6DnsToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m GVariant
utilsIp6DnsToVariant Text
dns = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
CString
dns' <- Text -> IO CString
textToCString Text
dns
Ptr GVariant
result <- CString -> IO (Ptr GVariant)
nm_utils_ip6_dns_to_variant CString
dns'
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp6DnsToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
dns'
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip6_dns_from_variant" nm_utils_ip6_dns_from_variant ::
Ptr GVariant ->
IO CString
utilsIp6DnsFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m T.Text
utilsIp6DnsFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m Text
utilsIp6DnsFromVariant GVariant
value = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
CString
result <- Ptr GVariant -> IO CString
nm_utils_ip6_dns_from_variant Ptr GVariant
value'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp6DnsFromVariant" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_ip6_addresses_to_variant" nm_utils_ip6_addresses_to_variant ::
Ptr (GPtrArray (Ptr NM.IPAddress.IPAddress)) ->
CString ->
IO (Ptr GVariant)
utilsIp6AddressesToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
[NM.IPAddress.IPAddress]
-> Maybe (T.Text)
-> m GVariant
utilsIp6AddressesToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[IPAddress] -> Maybe Text -> m GVariant
utilsIp6AddressesToVariant [IPAddress]
addresses Maybe Text
gateway = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
[Ptr IPAddress]
addresses' <- (IPAddress -> IO (Ptr IPAddress))
-> [IPAddress] -> IO [Ptr IPAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM IPAddress -> IO (Ptr IPAddress)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [IPAddress]
addresses
Ptr (GPtrArray (Ptr IPAddress))
addresses'' <- [Ptr IPAddress] -> IO (Ptr (GPtrArray (Ptr IPAddress)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr IPAddress]
addresses'
CString
maybeGateway <- case Maybe Text
gateway of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jGateway -> do
CString
jGateway' <- Text -> IO CString
textToCString Text
jGateway
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jGateway'
Ptr GVariant
result <- Ptr (GPtrArray (Ptr IPAddress)) -> CString -> IO (Ptr GVariant)
nm_utils_ip6_addresses_to_variant Ptr (GPtrArray (Ptr IPAddress))
addresses'' CString
maybeGateway
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp6AddressesToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
(IPAddress -> IO ()) -> [IPAddress] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ IPAddress -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [IPAddress]
addresses
Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPAddress))
addresses''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeGateway
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip6_addresses_from_variant" nm_utils_ip6_addresses_from_variant ::
Ptr GVariant ->
Ptr CString ->
IO (Ptr (GPtrArray (Ptr NM.IPAddress.IPAddress)))
utilsIp6AddressesFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m (([NM.IPAddress.IPAddress], Maybe T.Text))
utilsIp6AddressesFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m ([IPAddress], Maybe Text)
utilsIp6AddressesFromVariant GVariant
value = IO ([IPAddress], Maybe Text) -> m ([IPAddress], Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ([IPAddress], Maybe Text) -> m ([IPAddress], Maybe Text))
-> IO ([IPAddress], Maybe Text) -> m ([IPAddress], Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr CString
outGateway <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (GPtrArray (Ptr IPAddress))
result <- Ptr GVariant -> Ptr CString -> IO (Ptr (GPtrArray (Ptr IPAddress)))
nm_utils_ip6_addresses_from_variant Ptr GVariant
value' Ptr CString
outGateway
Text -> Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp6AddressesFromVariant" Ptr (GPtrArray (Ptr IPAddress))
result
[Ptr IPAddress]
result' <- Ptr (GPtrArray (Ptr IPAddress)) -> IO [Ptr IPAddress]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr IPAddress))
result
[IPAddress]
result'' <- (Ptr IPAddress -> IO IPAddress)
-> [Ptr IPAddress] -> IO [IPAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr IPAddress -> IPAddress)
-> Ptr IPAddress -> IO IPAddress
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IPAddress -> IPAddress
NM.IPAddress.IPAddress) [Ptr IPAddress]
result'
Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPAddress))
result
CString
outGateway' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outGateway
Maybe Text
maybeOutGateway' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outGateway' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
outGateway'' -> do
Text
outGateway''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outGateway''
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
outGateway'''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
outGateway'
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outGateway
([IPAddress], Maybe Text) -> IO ([IPAddress], Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ([IPAddress]
result'', Maybe Text
maybeOutGateway')
foreign import ccall "nm_utils_ip4_routes_to_variant" nm_utils_ip4_routes_to_variant ::
Ptr (GPtrArray (Ptr NM.IPRoute.IPRoute)) ->
IO (Ptr GVariant)
utilsIp4RoutesToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
[NM.IPRoute.IPRoute]
-> m GVariant
utilsIp4RoutesToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[IPRoute] -> m GVariant
utilsIp4RoutesToVariant [IPRoute]
routes = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
[Ptr IPRoute]
routes' <- (IPRoute -> IO (Ptr IPRoute)) -> [IPRoute] -> IO [Ptr IPRoute]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM IPRoute -> IO (Ptr IPRoute)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [IPRoute]
routes
Ptr (GPtrArray (Ptr IPRoute))
routes'' <- [Ptr IPRoute] -> IO (Ptr (GPtrArray (Ptr IPRoute)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr IPRoute]
routes'
Ptr GVariant
result <- Ptr (GPtrArray (Ptr IPRoute)) -> IO (Ptr GVariant)
nm_utils_ip4_routes_to_variant Ptr (GPtrArray (Ptr IPRoute))
routes''
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp4RoutesToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
(IPRoute -> IO ()) -> [IPRoute] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ IPRoute -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [IPRoute]
routes
Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPRoute))
routes''
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip4_routes_from_variant" nm_utils_ip4_routes_from_variant ::
Ptr GVariant ->
IO (Ptr (GPtrArray (Ptr NM.IPRoute.IPRoute)))
utilsIp4RoutesFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m [NM.IPRoute.IPRoute]
utilsIp4RoutesFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m [IPRoute]
utilsIp4RoutesFromVariant GVariant
value = IO [IPRoute] -> m [IPRoute]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [IPRoute] -> m [IPRoute]) -> IO [IPRoute] -> m [IPRoute]
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr (GPtrArray (Ptr IPRoute))
result <- Ptr GVariant -> IO (Ptr (GPtrArray (Ptr IPRoute)))
nm_utils_ip4_routes_from_variant Ptr GVariant
value'
Text -> Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp4RoutesFromVariant" Ptr (GPtrArray (Ptr IPRoute))
result
[Ptr IPRoute]
result' <- Ptr (GPtrArray (Ptr IPRoute)) -> IO [Ptr IPRoute]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr IPRoute))
result
[IPRoute]
result'' <- (Ptr IPRoute -> IO IPRoute) -> [Ptr IPRoute] -> IO [IPRoute]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr IPRoute -> IPRoute) -> Ptr IPRoute -> IO IPRoute
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IPRoute -> IPRoute
NM.IPRoute.IPRoute) [Ptr IPRoute]
result'
Ptr (GPtrArray (Ptr IPRoute)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPRoute))
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
[IPRoute] -> IO [IPRoute]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [IPRoute]
result''
foreign import ccall "nm_utils_ip4_prefix_to_netmask" nm_utils_ip4_prefix_to_netmask ::
Word32 ->
IO Word32
utilsIp4PrefixToNetmask ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Word32
utilsIp4PrefixToNetmask :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m Word32
utilsIp4PrefixToNetmask Word32
prefix = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- Word32 -> IO Word32
nm_utils_ip4_prefix_to_netmask Word32
prefix
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_ip4_netmask_to_prefix" nm_utils_ip4_netmask_to_prefix ::
Word32 ->
IO Word32
utilsIp4NetmaskToPrefix ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Word32
utilsIp4NetmaskToPrefix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m Word32
utilsIp4NetmaskToPrefix Word32
netmask = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- Word32 -> IO Word32
nm_utils_ip4_netmask_to_prefix Word32
netmask
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_ip4_get_default_prefix" nm_utils_ip4_get_default_prefix ::
Word32 ->
IO Word32
utilsIp4GetDefaultPrefix ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Word32
utilsIp4GetDefaultPrefix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m Word32
utilsIp4GetDefaultPrefix Word32
ip = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- Word32 -> IO Word32
nm_utils_ip4_get_default_prefix Word32
ip
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "nm_utils_ip4_dns_to_variant" nm_utils_ip4_dns_to_variant ::
CString ->
IO (Ptr GVariant)
utilsIp4DnsToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m GVariant
utilsIp4DnsToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m GVariant
utilsIp4DnsToVariant Text
dns = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
CString
dns' <- Text -> IO CString
textToCString Text
dns
Ptr GVariant
result <- CString -> IO (Ptr GVariant)
nm_utils_ip4_dns_to_variant CString
dns'
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp4DnsToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
dns'
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip4_dns_from_variant" nm_utils_ip4_dns_from_variant ::
Ptr GVariant ->
IO CString
utilsIp4DnsFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m T.Text
utilsIp4DnsFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m Text
utilsIp4DnsFromVariant GVariant
value = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
CString
result <- Ptr GVariant -> IO CString
nm_utils_ip4_dns_from_variant Ptr GVariant
value'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp4DnsFromVariant" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_ip4_addresses_to_variant" nm_utils_ip4_addresses_to_variant ::
Ptr (GPtrArray (Ptr NM.IPAddress.IPAddress)) ->
CString ->
IO (Ptr GVariant)
utilsIp4AddressesToVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
[NM.IPAddress.IPAddress]
-> Maybe (T.Text)
-> m GVariant
utilsIp4AddressesToVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[IPAddress] -> Maybe Text -> m GVariant
utilsIp4AddressesToVariant [IPAddress]
addresses Maybe Text
gateway = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
[Ptr IPAddress]
addresses' <- (IPAddress -> IO (Ptr IPAddress))
-> [IPAddress] -> IO [Ptr IPAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM IPAddress -> IO (Ptr IPAddress)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [IPAddress]
addresses
Ptr (GPtrArray (Ptr IPAddress))
addresses'' <- [Ptr IPAddress] -> IO (Ptr (GPtrArray (Ptr IPAddress)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr IPAddress]
addresses'
CString
maybeGateway <- case Maybe Text
gateway of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jGateway -> do
CString
jGateway' <- Text -> IO CString
textToCString Text
jGateway
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jGateway'
Ptr GVariant
result <- Ptr (GPtrArray (Ptr IPAddress)) -> CString -> IO (Ptr GVariant)
nm_utils_ip4_addresses_to_variant Ptr (GPtrArray (Ptr IPAddress))
addresses'' CString
maybeGateway
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp4AddressesToVariant" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
(IPAddress -> IO ()) -> [IPAddress] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ IPAddress -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [IPAddress]
addresses
Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPAddress))
addresses''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeGateway
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "nm_utils_ip4_addresses_from_variant" nm_utils_ip4_addresses_from_variant ::
Ptr GVariant ->
Ptr CString ->
IO (Ptr (GPtrArray (Ptr NM.IPAddress.IPAddress)))
utilsIp4AddressesFromVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m (([NM.IPAddress.IPAddress], Maybe T.Text))
utilsIp4AddressesFromVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m ([IPAddress], Maybe Text)
utilsIp4AddressesFromVariant GVariant
value = IO ([IPAddress], Maybe Text) -> m ([IPAddress], Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ([IPAddress], Maybe Text) -> m ([IPAddress], Maybe Text))
-> IO ([IPAddress], Maybe Text) -> m ([IPAddress], Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr CString
outGateway <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (GPtrArray (Ptr IPAddress))
result <- Ptr GVariant -> Ptr CString -> IO (Ptr (GPtrArray (Ptr IPAddress)))
nm_utils_ip4_addresses_from_variant Ptr GVariant
value' Ptr CString
outGateway
Text -> Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsIp4AddressesFromVariant" Ptr (GPtrArray (Ptr IPAddress))
result
[Ptr IPAddress]
result' <- Ptr (GPtrArray (Ptr IPAddress)) -> IO [Ptr IPAddress]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr IPAddress))
result
[IPAddress]
result'' <- (Ptr IPAddress -> IO IPAddress)
-> [Ptr IPAddress] -> IO [IPAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr IPAddress -> IPAddress)
-> Ptr IPAddress -> IO IPAddress
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IPAddress -> IPAddress
NM.IPAddress.IPAddress) [Ptr IPAddress]
result'
Ptr (GPtrArray (Ptr IPAddress)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr IPAddress))
result
CString
outGateway' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outGateway
Maybe Text
maybeOutGateway' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outGateway' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
outGateway'' -> do
Text
outGateway''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outGateway''
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
outGateway'''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
outGateway'
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outGateway
([IPAddress], Maybe Text) -> IO ([IPAddress], Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ([IPAddress]
result'', Maybe Text
maybeOutGateway')
foreign import ccall "nm_utils_iface_valid_name" nm_utils_iface_valid_name ::
CString ->
IO CInt
{-# DEPRECATED utilsIfaceValidName ["(Since version 1.6)","Use 'GI.NM.Functions.utilsIsValidIfaceName' instead, with better error reporting."] #-}
utilsIfaceValidName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
utilsIfaceValidName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
utilsIfaceValidName Maybe Text
name = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jName -> do
CString
jName' <- Text -> IO CString
textToCString Text
jName
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jName'
CInt
result <- CString -> IO CInt
nm_utils_iface_valid_name CString
maybeName
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeName
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_hwaddr_valid" nm_utils_hwaddr_valid ::
CString ->
DI.Int64 ->
IO CInt
utilsHwaddrValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> DI.Int64
-> m Bool
utilsHwaddrValid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Int64 -> m Bool
utilsHwaddrValid Text
asc Int64
length_ = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
asc' <- Text -> IO CString
textToCString Text
asc
CInt
result <- CString -> Int64 -> IO CInt
nm_utils_hwaddr_valid CString
asc' Int64
length_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
asc'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_hwaddr_ntoa" nm_utils_hwaddr_ntoa ::
Ptr Word8 ->
FCT.CSize ->
IO CString
utilsHwaddrNtoa ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m T.Text
utilsHwaddrNtoa :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Text
utilsHwaddrNtoa ByteString
addr = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let length_ :: CSize
length_ = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
addr
Ptr Word8
addr' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
addr
CString
result <- Ptr Word8 -> CSize -> IO CString
nm_utils_hwaddr_ntoa Ptr Word8
addr' CSize
length_
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsHwaddrNtoa" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
addr'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_hwaddr_matches" nm_utils_hwaddr_matches ::
Ptr () ->
DI.Int64 ->
Ptr () ->
DI.Int64 ->
IO CInt
utilsHwaddrMatches ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> DI.Int64
-> Ptr ()
-> DI.Int64
-> m Bool
utilsHwaddrMatches :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> Int64 -> Ptr () -> Int64 -> m Bool
utilsHwaddrMatches Ptr ()
hwaddr1 Int64
hwaddr1Len Ptr ()
hwaddr2 Int64
hwaddr2Len = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CInt
result <- Ptr () -> Int64 -> Ptr () -> Int64 -> IO CInt
nm_utils_hwaddr_matches Ptr ()
hwaddr1 Int64
hwaddr1Len Ptr ()
hwaddr2 Int64
hwaddr2Len
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_hwaddr_len" nm_utils_hwaddr_len ::
Int32 ->
IO FCT.CSize
utilsHwaddrLen ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> m FCT.CSize
utilsHwaddrLen :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Int32 -> m CSize
utilsHwaddrLen Int32
type_ = IO CSize -> m CSize
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ do
CSize
result <- Int32 -> IO CSize
nm_utils_hwaddr_len Int32
type_
CSize -> IO CSize
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CSize
result
foreign import ccall "nm_utils_hwaddr_canonical" nm_utils_hwaddr_canonical ::
CString ->
DI.Int64 ->
IO CString
utilsHwaddrCanonical ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> DI.Int64
-> m T.Text
utilsHwaddrCanonical :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Int64 -> m Text
utilsHwaddrCanonical Text
asc Int64
length_ = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
asc' <- Text -> IO CString
textToCString Text
asc
CString
result <- CString -> Int64 -> IO CString
nm_utils_hwaddr_canonical CString
asc' Int64
length_
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsHwaddrCanonical" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
asc'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_hwaddr_aton" nm_utils_hwaddr_aton ::
CString ->
Ptr Word8 ->
FCT.CSize ->
IO Word8
utilsHwaddrAton ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> ByteString
-> m Word8
utilsHwaddrAton :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> ByteString -> m Word8
utilsHwaddrAton Text
asc ByteString
buffer = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
let length_ :: CSize
length_ = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
buffer
CString
asc' <- Text -> IO CString
textToCString Text
asc
Ptr Word8
buffer' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
buffer
Word8
result <- CString -> Ptr Word8 -> CSize -> IO Word8
nm_utils_hwaddr_aton CString
asc' Ptr Word8
buffer' CSize
length_
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
asc'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
buffer'
Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
foreign import ccall "nm_utils_hwaddr_atoba" nm_utils_hwaddr_atoba ::
CString ->
FCT.CSize ->
IO (Ptr GByteArray)
utilsHwaddrAtoba ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> FCT.CSize
-> m ByteString
utilsHwaddrAtoba :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> CSize -> m ByteString
utilsHwaddrAtoba Text
asc CSize
length_ = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
CString
asc' <- Text -> IO CString
textToCString Text
asc
Ptr GByteArray
result <- CString -> CSize -> IO (Ptr GByteArray)
nm_utils_hwaddr_atoba CString
asc' CSize
length_
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsHwaddrAtoba" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
asc'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
foreign import ccall "nm_utils_hexstr2bin" nm_utils_hexstr2bin ::
CString ->
IO (Ptr GLib.Bytes.Bytes)
utilsHexstr2bin ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m GLib.Bytes.Bytes
utilsHexstr2bin :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bytes
utilsHexstr2bin Text
hex = IO Bytes -> m Bytes
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bytes -> m Bytes) -> IO Bytes -> m Bytes
forall a b. (a -> b) -> a -> b
$ do
CString
hex' <- Text -> IO CString
textToCString Text
hex
Ptr Bytes
result <- CString -> IO (Ptr Bytes)
nm_utils_hexstr2bin CString
hex'
Text -> Ptr Bytes -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsHexstr2bin" Ptr Bytes
result
Bytes
result' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
hex'
Bytes -> IO Bytes
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result'
foreign import ccall "nm_utils_get_timestamp_msec" nm_utils_get_timestamp_msec ::
IO Int64
utilsGetTimestampMsec ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Int64
utilsGetTimestampMsec :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Int64
utilsGetTimestampMsec = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Int64
result <- IO Int64
nm_utils_get_timestamp_msec
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
foreign import ccall "nm_utils_file_search_in_paths" nm_utils_file_search_in_paths ::
CString ->
CString ->
CString ->
CUInt ->
FunPtr NM.Callbacks.C_UtilsFileSearchInPathsPredicate ->
Ptr () ->
Ptr (Ptr GError) ->
IO CString
utilsFileSearchInPaths ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Maybe (T.Text)
-> Maybe (T.Text)
-> [GLib.Flags.FileTest]
-> NM.Callbacks.UtilsFileSearchInPathsPredicate
-> m T.Text
utilsFileSearchInPaths :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text
-> Maybe Text
-> Maybe Text
-> [FileTest]
-> UtilsFileSearchInPathsPredicate
-> m Text
utilsFileSearchInPaths Text
progname Maybe Text
tryFirst Maybe Text
paths [FileTest]
fileTestFlags UtilsFileSearchInPathsPredicate
predicate = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
progname' <- Text -> IO CString
textToCString Text
progname
CString
maybeTryFirst <- case Maybe Text
tryFirst of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jTryFirst -> do
CString
jTryFirst' <- Text -> IO CString
textToCString Text
jTryFirst
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jTryFirst'
CString
maybePaths <- case Maybe Text
paths of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jPaths -> do
CString
jPaths' <- Text -> IO CString
textToCString Text
jPaths
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jPaths'
let fileTestFlags' :: CUInt
fileTestFlags' = [FileTest] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [FileTest]
fileTestFlags
FunPtr C_UtilsFileSearchInPathsPredicate
predicate' <- C_UtilsFileSearchInPathsPredicate
-> IO (FunPtr C_UtilsFileSearchInPathsPredicate)
NM.Callbacks.mk_UtilsFileSearchInPathsPredicate (Maybe (Ptr (FunPtr C_UtilsFileSearchInPathsPredicate))
-> UtilsFileSearchInPathsPredicate_WithClosures
-> C_UtilsFileSearchInPathsPredicate
NM.Callbacks.wrap_UtilsFileSearchInPathsPredicate Maybe (Ptr (FunPtr C_UtilsFileSearchInPathsPredicate))
forall a. Maybe a
Nothing (UtilsFileSearchInPathsPredicate
-> UtilsFileSearchInPathsPredicate_WithClosures
NM.Callbacks.drop_closures_UtilsFileSearchInPathsPredicate UtilsFileSearchInPathsPredicate
predicate))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ CString
-> CString
-> CString
-> CUInt
-> FunPtr C_UtilsFileSearchInPathsPredicate
-> Ptr ()
-> Ptr (Ptr GError)
-> IO CString
nm_utils_file_search_in_paths CString
progname' CString
maybeTryFirst CString
maybePaths CUInt
fileTestFlags' FunPtr C_UtilsFileSearchInPathsPredicate
predicate' Ptr ()
forall a. Ptr a
userData
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsFileSearchInPaths" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_UtilsFileSearchInPathsPredicate -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_UtilsFileSearchInPathsPredicate
predicate'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
progname'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeTryFirst
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybePaths
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_UtilsFileSearchInPathsPredicate -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_UtilsFileSearchInPathsPredicate
predicate'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
progname'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeTryFirst
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybePaths
)
foreign import ccall "nm_utils_file_is_private_key" nm_utils_file_is_private_key ::
CString ->
Ptr CInt ->
IO CInt
utilsFileIsPrivateKey ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((Bool, Bool))
utilsFileIsPrivateKey :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Bool, Bool)
utilsFileIsPrivateKey Text
filename = IO (Bool, Bool) -> m (Bool, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
CString
filename' <- Text -> IO CString
textToCString Text
filename
Ptr CInt
outEncrypted <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
CInt
result <- CString -> Ptr CInt -> IO CInt
nm_utils_file_is_private_key CString
filename' Ptr CInt
outEncrypted
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CInt
outEncrypted' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
outEncrypted
let outEncrypted'' :: Bool
outEncrypted'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
outEncrypted'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
outEncrypted
(Bool, Bool) -> IO (Bool, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Bool
outEncrypted'')
foreign import ccall "nm_utils_file_is_pkcs12" nm_utils_file_is_pkcs12 ::
CString ->
IO CInt
utilsFileIsPkcs12 ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
utilsFileIsPkcs12 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
utilsFileIsPkcs12 Text
filename = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
filename' <- Text -> IO CString
textToCString Text
filename
CInt
result <- CString -> IO CInt
nm_utils_file_is_pkcs12 CString
filename'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_file_is_certificate" nm_utils_file_is_certificate ::
CString ->
IO CInt
utilsFileIsCertificate ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
utilsFileIsCertificate :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
utilsFileIsCertificate Text
filename = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
filename' <- Text -> IO CString
textToCString Text
filename
CInt
result <- CString -> IO CInt
nm_utils_file_is_certificate CString
filename'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_escape_ssid" nm_utils_escape_ssid ::
Ptr Word8 ->
FCT.CSize ->
IO CString
{-# DEPRECATED utilsEscapeSsid ["(Since version 1.46)","use 'GI.NM.Functions.utilsSsidToUtf8' or 'GI.NM.Functions.utilsBin2hexstr'."] #-}
utilsEscapeSsid ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m T.Text
utilsEscapeSsid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Text
utilsEscapeSsid ByteString
ssid = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let len :: CSize
len = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
ssid
Ptr Word8
ssid' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
ssid
CString
result <- Ptr Word8 -> CSize -> IO CString
nm_utils_escape_ssid Ptr Word8
ssid' CSize
len
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsEscapeSsid" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
ssid'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_enum_to_str" nm_utils_enum_to_str ::
CGType ->
Int32 ->
IO CString
utilsEnumToStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Int32
-> m T.Text
utilsEnumToStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Int32 -> m Text
utilsEnumToStr GType
type_ Int32
value = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
CString
result <- CGType -> Int32 -> IO CString
nm_utils_enum_to_str CGType
type_' Int32
value
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsEnumToStr" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_enum_get_values" nm_utils_enum_get_values ::
CGType ->
Int32 ->
Int32 ->
IO (Ptr CString)
utilsEnumGetValues ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Int32
-> Int32
-> m [T.Text]
utilsEnumGetValues :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Int32 -> Int32 -> m [Text]
utilsEnumGetValues GType
type_ Int32
from Int32
to = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
Ptr CString
result <- CGType -> Int32 -> Int32 -> IO (Ptr CString)
nm_utils_enum_get_values CGType
type_' Int32
from Int32
to
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsEnumGetValues" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
foreign import ccall "nm_utils_enum_from_str" nm_utils_enum_from_str ::
CGType ->
CString ->
Ptr Int32 ->
Ptr CString ->
IO CInt
utilsEnumFromStr ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> T.Text
-> m ((Bool, Int32, Maybe T.Text))
utilsEnumFromStr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Text -> m (Bool, Int32, Maybe Text)
utilsEnumFromStr GType
type_ Text
str = IO (Bool, Int32, Maybe Text) -> m (Bool, Int32, Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int32, Maybe Text) -> m (Bool, Int32, Maybe Text))
-> IO (Bool, Int32, Maybe Text) -> m (Bool, Int32, Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr Int32
outValue <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr CString
errToken <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- CGType -> CString -> Ptr Int32 -> Ptr CString -> IO CInt
nm_utils_enum_from_str CGType
type_' CString
str' Ptr Int32
outValue Ptr CString
errToken
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
outValue' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
outValue
CString
errToken' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
errToken
Maybe Text
maybeErrToken' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
errToken' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
errToken'' -> do
Text
errToken''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
errToken''
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
errToken'''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
errToken'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
outValue
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
errToken
(Bool, Int32, Maybe Text) -> IO (Bool, Int32, Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
outValue', Maybe Text
maybeErrToken')
foreign import ccall "nm_utils_ensure_gtypes" nm_utils_ensure_gtypes ::
IO ()
utilsEnsureGtypes ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
utilsEnsureGtypes :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ()
utilsEnsureGtypes = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
nm_utils_ensure_gtypes
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "nm_utils_check_virtual_device_compatibility" nm_utils_check_virtual_device_compatibility ::
CGType ->
CGType ->
IO CInt
utilsCheckVirtualDeviceCompatibility ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> GType
-> m Bool
utilsCheckVirtualDeviceCompatibility :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> GType -> m Bool
utilsCheckVirtualDeviceCompatibility GType
virtualType GType
otherType = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
let virtualType' :: CGType
virtualType' = GType -> CGType
gtypeToCGType GType
virtualType
let otherType' :: CGType
otherType' = GType -> CGType
gtypeToCGType GType
otherType
CInt
result <- CGType -> CGType -> IO CInt
nm_utils_check_virtual_device_compatibility CGType
virtualType' CGType
otherType'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_utils_bond_mode_string_to_int" nm_utils_bond_mode_string_to_int ::
CString ->
IO Int32
utilsBondModeStringToInt ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Int32
utilsBondModeStringToInt :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Int32
utilsBondModeStringToInt Text
mode = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
mode' <- Text -> IO CString
textToCString Text
mode
Int32
result <- CString -> IO Int32
nm_utils_bond_mode_string_to_int CString
mode'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
mode'
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "nm_utils_bond_mode_int_to_string" nm_utils_bond_mode_int_to_string ::
Int32 ->
IO CString
utilsBondModeIntToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> m T.Text
utilsBondModeIntToString :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Int32 -> m Text
utilsBondModeIntToString Int32
mode = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- Int32 -> IO CString
nm_utils_bond_mode_int_to_string Int32
mode
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsBondModeIntToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_bin2hexstr" nm_utils_bin2hexstr ::
Ptr Word8 ->
FCT.CSize ->
Int32 ->
IO CString
utilsBin2hexstr ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Int32
-> m T.Text
utilsBin2hexstr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Int32 -> m Text
utilsBin2hexstr ByteString
src Int32
finalLen = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let len :: CSize
len = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
src
Ptr Word8
src' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
src
CString
result <- Ptr Word8 -> CSize -> Int32 -> IO CString
nm_utils_bin2hexstr Ptr Word8
src' CSize
len Int32
finalLen
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"utilsBin2hexstr" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
src'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "nm_utils_base64secret_decode" nm_utils_base64secret_decode ::
CString ->
FCT.CSize ->
Ptr Word8 ->
IO CInt
utilsBase64secretDecode ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> FCT.CSize
-> m ((Bool, Word8))
utilsBase64secretDecode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> CSize -> m (Bool, Word8)
utilsBase64secretDecode Text
base64Key CSize
requiredKeyLen = IO (Bool, Word8) -> m (Bool, Word8)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word8) -> m (Bool, Word8))
-> IO (Bool, Word8) -> m (Bool, Word8)
forall a b. (a -> b) -> a -> b
$ do
CString
base64Key' <- Text -> IO CString
textToCString Text
base64Key
Ptr Word8
outKey <- IO (Ptr Word8)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word8)
CInt
result <- CString -> CSize -> Ptr Word8 -> IO CInt
nm_utils_base64secret_decode CString
base64Key' CSize
requiredKeyLen Ptr Word8
outKey
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word8
outKey' <- Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
outKey
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
base64Key'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
outKey
(Bool, Word8) -> IO (Bool, Word8)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word8
outKey')
foreign import ccall "nm_utils_ap_mode_security_valid" nm_utils_ap_mode_security_valid ::
CUInt ->
CUInt ->
IO CInt
utilsApModeSecurityValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
NM.Enums.UtilsSecurityType
-> [NM.Flags.DeviceWifiCapabilities]
-> m Bool
utilsApModeSecurityValid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
UtilsSecurityType -> [DeviceWifiCapabilities] -> m Bool
utilsApModeSecurityValid UtilsSecurityType
type_ [DeviceWifiCapabilities]
wifiCaps = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (UtilsSecurityType -> Int) -> UtilsSecurityType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UtilsSecurityType -> Int
forall a. Enum a => a -> Int
fromEnum) UtilsSecurityType
type_
let wifiCaps' :: CUInt
wifiCaps' = [DeviceWifiCapabilities] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DeviceWifiCapabilities]
wifiCaps
CInt
result <- CUInt -> CUInt -> IO CInt
nm_utils_ap_mode_security_valid CUInt
type_' CUInt
wifiCaps'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_keyfile_write" nm_keyfile_write ::
Ptr NM.Connection.Connection ->
CUInt ->
FunPtr NM.Callbacks.C_KeyfileWriteHandler ->
Ptr () ->
Ptr (Ptr GError) ->
IO (Ptr GLib.KeyFile.KeyFile)
keyfileWrite ::
(B.CallStack.HasCallStack, MonadIO m, NM.Connection.IsConnection a) =>
a
-> [NM.Flags.KeyfileHandlerFlags]
-> Maybe (NM.Callbacks.KeyfileWriteHandler)
-> m GLib.KeyFile.KeyFile
keyfileWrite :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsConnection a) =>
a
-> [KeyfileHandlerFlags] -> Maybe KeyfileWriteHandler -> m KeyFile
keyfileWrite a
connection [KeyfileHandlerFlags]
handlerFlags Maybe KeyfileWriteHandler
handler = IO KeyFile -> m KeyFile
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO KeyFile -> m KeyFile) -> IO KeyFile -> m KeyFile
forall a b. (a -> b) -> a -> b
$ do
Ptr Connection
connection' <- a -> IO (Ptr Connection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
let handlerFlags' :: CUInt
handlerFlags' = [KeyfileHandlerFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [KeyfileHandlerFlags]
handlerFlags
FunPtr C_KeyfileWriteHandler
maybeHandler <- case Maybe KeyfileWriteHandler
handler of
Maybe KeyfileWriteHandler
Nothing -> FunPtr C_KeyfileWriteHandler -> IO (FunPtr C_KeyfileWriteHandler)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_KeyfileWriteHandler
forall a. FunPtr a
FP.nullFunPtr
Just KeyfileWriteHandler
jHandler -> do
FunPtr C_KeyfileWriteHandler
jHandler' <- C_KeyfileWriteHandler -> IO (FunPtr C_KeyfileWriteHandler)
NM.Callbacks.mk_KeyfileWriteHandler (Maybe (Ptr (FunPtr C_KeyfileWriteHandler))
-> KeyfileWriteHandler_WithClosures -> C_KeyfileWriteHandler
NM.Callbacks.wrap_KeyfileWriteHandler Maybe (Ptr (FunPtr C_KeyfileWriteHandler))
forall a. Maybe a
Nothing (KeyfileWriteHandler -> KeyfileWriteHandler_WithClosures
NM.Callbacks.drop_closures_KeyfileWriteHandler KeyfileWriteHandler
jHandler))
FunPtr C_KeyfileWriteHandler -> IO (FunPtr C_KeyfileWriteHandler)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_KeyfileWriteHandler
jHandler'
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
IO KeyFile -> IO () -> IO KeyFile
forall a b. IO a -> IO b -> IO a
onException (do
Ptr KeyFile
result <- (Ptr (Ptr GError) -> IO (Ptr KeyFile)) -> IO (Ptr KeyFile)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr KeyFile)) -> IO (Ptr KeyFile))
-> (Ptr (Ptr GError) -> IO (Ptr KeyFile)) -> IO (Ptr KeyFile)
forall a b. (a -> b) -> a -> b
$ Ptr Connection
-> CUInt
-> FunPtr C_KeyfileWriteHandler
-> Ptr ()
-> Ptr (Ptr GError)
-> IO (Ptr KeyFile)
nm_keyfile_write Ptr Connection
connection' CUInt
handlerFlags' FunPtr C_KeyfileWriteHandler
maybeHandler Ptr ()
forall a. Ptr a
userData
Text -> Ptr KeyFile -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"keyfileWrite" Ptr KeyFile
result
KeyFile
result' <- ((ManagedPtr KeyFile -> KeyFile) -> Ptr KeyFile -> IO KeyFile
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr KeyFile -> KeyFile
GLib.KeyFile.KeyFile) Ptr KeyFile
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_KeyfileWriteHandler -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_KeyfileWriteHandler
maybeHandler
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
KeyFile -> IO KeyFile
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return KeyFile
result'
) (do
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_KeyfileWriteHandler -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_KeyfileWriteHandler
maybeHandler
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "nm_keyfile_read" nm_keyfile_read ::
Ptr GLib.KeyFile.KeyFile ->
CString ->
CUInt ->
FunPtr NM.Callbacks.C_KeyfileReadHandler ->
Ptr () ->
Ptr (Ptr GError) ->
IO (Ptr NM.Connection.Connection)
keyfileRead ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.KeyFile.KeyFile
-> T.Text
-> [NM.Flags.KeyfileHandlerFlags]
-> Maybe (NM.Callbacks.KeyfileReadHandler)
-> m NM.Connection.Connection
keyfileRead :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KeyFile
-> Text
-> [KeyfileHandlerFlags]
-> Maybe KeyfileReadHandler
-> m Connection
keyfileRead KeyFile
keyfile Text
baseDir [KeyfileHandlerFlags]
handlerFlags Maybe KeyfileReadHandler
handler = IO Connection -> m Connection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Connection -> m Connection) -> IO Connection -> m Connection
forall a b. (a -> b) -> a -> b
$ do
Ptr KeyFile
keyfile' <- KeyFile -> IO (Ptr KeyFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KeyFile
keyfile
CString
baseDir' <- Text -> IO CString
textToCString Text
baseDir
let handlerFlags' :: CUInt
handlerFlags' = [KeyfileHandlerFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [KeyfileHandlerFlags]
handlerFlags
FunPtr C_KeyfileReadHandler
maybeHandler <- case Maybe KeyfileReadHandler
handler of
Maybe KeyfileReadHandler
Nothing -> FunPtr C_KeyfileReadHandler -> IO (FunPtr C_KeyfileReadHandler)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_KeyfileReadHandler
forall a. FunPtr a
FP.nullFunPtr
Just KeyfileReadHandler
jHandler -> do
FunPtr C_KeyfileReadHandler
jHandler' <- C_KeyfileReadHandler -> IO (FunPtr C_KeyfileReadHandler)
NM.Callbacks.mk_KeyfileReadHandler (Maybe (Ptr (FunPtr C_KeyfileReadHandler))
-> KeyfileReadHandler_WithClosures -> C_KeyfileReadHandler
NM.Callbacks.wrap_KeyfileReadHandler Maybe (Ptr (FunPtr C_KeyfileReadHandler))
forall a. Maybe a
Nothing (KeyfileReadHandler -> KeyfileReadHandler_WithClosures
NM.Callbacks.drop_closures_KeyfileReadHandler KeyfileReadHandler
jHandler))
FunPtr C_KeyfileReadHandler -> IO (FunPtr C_KeyfileReadHandler)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_KeyfileReadHandler
jHandler'
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
IO Connection -> IO () -> IO Connection
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Connection
result <- (Ptr (Ptr GError) -> IO (Ptr Connection)) -> IO (Ptr Connection)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Connection)) -> IO (Ptr Connection))
-> (Ptr (Ptr GError) -> IO (Ptr Connection)) -> IO (Ptr Connection)
forall a b. (a -> b) -> a -> b
$ Ptr KeyFile
-> CString
-> CUInt
-> FunPtr C_KeyfileReadHandler
-> Ptr ()
-> Ptr (Ptr GError)
-> IO (Ptr Connection)
nm_keyfile_read Ptr KeyFile
keyfile' CString
baseDir' CUInt
handlerFlags' FunPtr C_KeyfileReadHandler
maybeHandler Ptr ()
forall a. Ptr a
userData
Text -> Ptr Connection -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"keyfileRead" Ptr Connection
result
Connection
result' <- ((ManagedPtr Connection -> Connection)
-> Ptr Connection -> IO Connection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Connection -> Connection
NM.Connection.Connection) Ptr Connection
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_KeyfileReadHandler -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_KeyfileReadHandler
maybeHandler
KeyFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KeyFile
keyfile
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
baseDir'
Connection -> IO Connection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Connection
result'
) (do
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_KeyfileReadHandler -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_KeyfileReadHandler
maybeHandler
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
baseDir'
)
foreign import ccall "nm_ethtool_optname_is_ring" nm_ethtool_optname_is_ring ::
CString ->
IO CInt
ethtoolOptnameIsRing ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
ethtoolOptnameIsRing :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
ethtoolOptnameIsRing Maybe Text
optname = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeOptname <- case Maybe Text
optname of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jOptname -> do
CString
jOptname' <- Text -> IO CString
textToCString Text
jOptname
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOptname'
CInt
result <- CString -> IO CInt
nm_ethtool_optname_is_ring CString
maybeOptname
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOptname
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_ethtool_optname_is_pause" nm_ethtool_optname_is_pause ::
CString ->
IO CInt
ethtoolOptnameIsPause ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
ethtoolOptnameIsPause :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
ethtoolOptnameIsPause Maybe Text
optname = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeOptname <- case Maybe Text
optname of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jOptname -> do
CString
jOptname' <- Text -> IO CString
textToCString Text
jOptname
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOptname'
CInt
result <- CString -> IO CInt
nm_ethtool_optname_is_pause CString
maybeOptname
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOptname
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_ethtool_optname_is_feature" nm_ethtool_optname_is_feature ::
CString ->
IO CInt
ethtoolOptnameIsFeature ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
ethtoolOptnameIsFeature :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
ethtoolOptnameIsFeature Maybe Text
optname = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeOptname <- case Maybe Text
optname of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jOptname -> do
CString
jOptname' <- Text -> IO CString
textToCString Text
jOptname
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOptname'
CInt
result <- CString -> IO CInt
nm_ethtool_optname_is_feature CString
maybeOptname
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOptname
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_ethtool_optname_is_eee" nm_ethtool_optname_is_eee ::
CString ->
IO CInt
ethtoolOptnameIsEee ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
ethtoolOptnameIsEee :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
ethtoolOptnameIsEee Maybe Text
optname = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeOptname <- case Maybe Text
optname of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jOptname -> do
CString
jOptname' <- Text -> IO CString
textToCString Text
jOptname
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOptname'
CInt
result <- CString -> IO CInt
nm_ethtool_optname_is_eee CString
maybeOptname
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOptname
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_ethtool_optname_is_coalesce" nm_ethtool_optname_is_coalesce ::
CString ->
IO CInt
ethtoolOptnameIsCoalesce ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
ethtoolOptnameIsCoalesce :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
ethtoolOptnameIsCoalesce Maybe Text
optname = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeOptname <- case Maybe Text
optname of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jOptname -> do
CString
jOptname' <- Text -> IO CString
textToCString Text
jOptname
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOptname'
CInt
result <- CString -> IO CInt
nm_ethtool_optname_is_coalesce CString
maybeOptname
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOptname
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_ethtool_optname_is_channels" nm_ethtool_optname_is_channels ::
CString ->
IO CInt
ethtoolOptnameIsChannels ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bool
ethtoolOptnameIsChannels :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Bool
ethtoolOptnameIsChannels Maybe Text
optname = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
maybeOptname <- case Maybe Text
optname of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jOptname -> do
CString
jOptname' <- Text -> IO CString
textToCString Text
jOptname
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOptname'
CInt
result <- CString -> IO CInt
nm_ethtool_optname_is_channels CString
maybeOptname
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOptname
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "nm_conn_wireguard_import" nm_conn_wireguard_import ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr NM.Connection.Connection)
connWireguardImport ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m NM.Connection.Connection
connWireguardImport :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m Connection
connWireguardImport Text
filename = IO Connection -> m Connection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Connection -> m Connection) -> IO Connection -> m Connection
forall a b. (a -> b) -> a -> b
$ do
CString
filename' <- Text -> IO CString
textToCString Text
filename
IO Connection -> IO () -> IO Connection
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Connection
result <- (Ptr (Ptr GError) -> IO (Ptr Connection)) -> IO (Ptr Connection)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Connection)) -> IO (Ptr Connection))
-> (Ptr (Ptr GError) -> IO (Ptr Connection)) -> IO (Ptr Connection)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr Connection)
nm_conn_wireguard_import CString
filename'
Text -> Ptr Connection -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"connWireguardImport" Ptr Connection
result
Connection
result' <- ((ManagedPtr Connection -> Connection)
-> Ptr Connection -> IO Connection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Connection -> Connection
NM.Connection.Connection) Ptr Connection
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Connection -> IO Connection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Connection
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
)