module System.LibVirt.Foreign
(
Connection, Domain, Network,
DomainID,
DomainInfo (..),
DomainState (..),
Stream,
DomainCreateFlags (..),
DomainXMLFlags (..),
SecurityLabel (..),
SecurityModel (..),
NodeInfo (..),
SchedParameterType (..),
ConnectCredential (..),
initialize,
openConnection, closeConnection,
runningDomainsCount, definedDomainsCount,
runningDomainsIDs, definedDomainsNames,
lookupDomainID, lookupDomainName,
getDomainInfo, getDomainXML,
defineDomainXML, undefineDomain,
getDomainID, getDomainName,
createDomain, createDomainXML,
destroyDomain,
shutdownDomain, rebootDomain,
suspendDomain, resumeDomain,
saveDomain, restoreDomain,
refDomain, freeDomain,
getNetworkConnection,
runningNetworksCount, definedNetworksCount,
runningNetworksNames, definedNetworksNames,
lookupNetworkName, lookupNetworkUUID,
createNetworkXML, defineNetworkXML,
undefineNetwork, destroyNetwork,
createNetwork,
refNetwork, freeNetwork,
getNetworkName,
getNetworkXML
) where
import Data.Bits
import Data.Generics
import Foreign
import Foreign.C.Types
import Foreign.C.String
import System.LibVirt.Internal
import System.LibVirt.Errors
cIntConv = fromIntegral
cuchar2state :: CUChar -> DomainState
cuchar2state c = toEnum (fromIntegral c)
flags2int :: (Enum f, Num a) => [f] -> a
flags2int list = fromIntegral $ foldr (.|.) 0 (map fromEnum list)
data DomainInfo = DomainInfo {
diState :: DomainState,
diMaxMem :: Integer,
diMemory :: Integer,
diNrVirtCPU :: Int,
diCPUTime :: Integer }
deriving (Eq, Show)
type DomainInfoPtr = Ptr (DomainInfo)
data DomainState = DomainNostate
| DomainRunning
| DomainBlocked
| DomainPaused
| DomainShutdown
| DomainShutoff
| DomainCrashed
| DomainPmsuspended
deriving (Eq,Show)
instance Enum DomainState where
fromEnum DomainNostate = 0
fromEnum DomainRunning = 1
fromEnum DomainBlocked = 2
fromEnum DomainPaused = 3
fromEnum DomainShutdown = 4
fromEnum DomainShutoff = 5
fromEnum DomainCrashed = 6
fromEnum DomainPmsuspended = 7
toEnum 0 = DomainNostate
toEnum 1 = DomainRunning
toEnum 2 = DomainBlocked
toEnum 3 = DomainPaused
toEnum 4 = DomainShutdown
toEnum 5 = DomainShutoff
toEnum 6 = DomainCrashed
toEnum 7 = DomainPmsuspended
toEnum unmatched = error ("DomainState.toEnum: Cannot match " ++ show unmatched)
data DomainCreateFlags = DomainNone
| DomainStartPaused
| DomainStartAutodestroy
| DomainStartBypassCache
| DomainStartForceBoot
deriving (Eq,Show)
instance Enum DomainCreateFlags where
fromEnum DomainNone = 0
fromEnum DomainStartPaused = 1
fromEnum DomainStartAutodestroy = 2
fromEnum DomainStartBypassCache = 4
fromEnum DomainStartForceBoot = 8
toEnum 0 = DomainNone
toEnum 1 = DomainStartPaused
toEnum 2 = DomainStartAutodestroy
toEnum 4 = DomainStartBypassCache
toEnum 8 = DomainStartForceBoot
toEnum unmatched = error ("DomainCreateFlags.toEnum: Cannot match " ++ show unmatched)
data DomainXMLFlags = DomainXmlSecure
| DomainXmlInactive
| DomainXmlUpdateCpu
deriving (Eq,Show)
instance Enum DomainXMLFlags where
fromEnum DomainXmlSecure = 1
fromEnum DomainXmlInactive = 2
fromEnum DomainXmlUpdateCpu = 4
toEnum 1 = DomainXmlSecure
toEnum 2 = DomainXmlInactive
toEnum 4 = DomainXmlUpdateCpu
toEnum unmatched = error ("DomainXMLFlags.toEnum: Cannot match " ++ show unmatched)
data NetworkXMLFlags = NetworkXML
deriving (Eq, Show, Enum)
newtype Stream = Stream (Ptr (Stream))
data SecurityLabel = SecurityLabel {
slLabel :: String,
slEnforcing :: Int }
deriving (Eq, Show)
type SecurityLabelPtr = Ptr (SecurityLabel)
data SecurityModel = SecurityModel {
smModel :: String,
smDOI :: String }
deriving (Eq, Show)
type SecurityModelPtr = Ptr (SecurityModel)
data NodeInfo = NodeInfo {
niModel :: String,
niMemory :: CULong,
niCPUs :: CUInt,
niMHz :: CUInt,
niNodes :: CUInt,
niSockets :: CUInt,
niCores :: CUInt,
niThreads :: CUInt }
deriving (Eq, Show)
type NodeInfoPtr = Ptr (NodeInfo)
data SchedParameterType = DomainSchedFieldInt
| DomainSchedFieldUint
| DomainSchedFieldLlong
| DomainSchedFieldUllong
| DomainSchedFieldDouble
| DomainSchedFieldBoolean
deriving (Eq,Show)
instance Enum SchedParameterType where
fromEnum DomainSchedFieldInt = 1
fromEnum DomainSchedFieldUint = 2
fromEnum DomainSchedFieldLlong = 3
fromEnum DomainSchedFieldUllong = 4
fromEnum DomainSchedFieldDouble = 5
fromEnum DomainSchedFieldBoolean = 6
toEnum 1 = DomainSchedFieldInt
toEnum 2 = DomainSchedFieldUint
toEnum 3 = DomainSchedFieldLlong
toEnum 4 = DomainSchedFieldUllong
toEnum 5 = DomainSchedFieldDouble
toEnum 6 = DomainSchedFieldBoolean
toEnum unmatched = error ("SchedParameterType.toEnum: Cannot match " ++ show unmatched)
data ConnectCredential = ConnectCredential {
ccType :: Int,
ccPrompt :: String,
ccChallenge :: String,
ccDefresult :: String,
ccResult :: String,
ccResultLen :: Integer }
deriving (Eq, Show)
type ConnectCredentialPtr = Ptr (ConnectCredential)
initialize :: IO (Int)
initialize =
initialize'_ >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
openConnection :: String -> IO (Connection)
openConnection a1 =
withCString a1 $ \a1' ->
openConnection'_ a1' >>= \res ->
ptrToConnection res >>= \res' ->
return (res')
closeConnection :: Connection -> IO (Int)
closeConnection a1 =
let {a1' = connectionToPtr a1} in
closeConnection'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
runningDomainsCount :: Connection -> IO (Int)
runningDomainsCount a1 =
let {a1' = connectionToPtr a1} in
runningDomainsCount'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
type DomainID = CInt
runningDomainsIDs :: Connection -> IO [DomainID]
runningDomainsIDs conn = do
cn <- virConnectNumOfDomains (connectionToPtr conn)
let n = fromIntegral cn
r <- allocaArray n $ \arr -> do
r <- virConnectListDomains
(connectionToPtr conn) arr cn
peekArray n arr
return r
definedDomainsNames :: Connection -> IO [String]
definedDomainsNames conn = do
cn <- virConnectNumOfDefinedDomains (connectionToPtr conn)
let n = fromIntegral cn
allocaArray n $ \nptr -> do
virConnectListDefinedDomains
(connectionToPtr conn) nptr cn
mapM peekCString =<< peekArray n nptr
lookupDomainID :: Connection -> DomainID -> IO (Domain)
lookupDomainID a1 a2 =
let {a1' = connectionToPtr a1} in
let {a2' = id a2} in
lookupDomainID'_ a1' a2' >>= \res ->
ptrToDomain res >>= \res' ->
return (res')
getDomainID :: Domain -> IO (DomainID)
getDomainID a1 =
let {a1' = domainToPtr a1} in
getDomainID'_ a1' >>= \res ->
let {res' = cIntConv res} in
return (res')
getDomainName :: Domain -> IO (String)
getDomainName a1 =
let {a1' = domainToPtr a1} in
getDomainName'_ a1' >>= \res ->
peekCString res >>= \res' ->
return (res')
lookupDomainName :: Connection -> String -> IO (Domain)
lookupDomainName a1 a2 =
let {a1' = connectionToPtr a1} in
withCString a2 $ \a2' ->
lookupDomainName'_ a1' a2' >>= \res ->
ptrToDomain res >>= \res' ->
return (res')
definedDomainsCount :: Connection -> IO (Int)
definedDomainsCount a1 =
let {a1' = connectionToPtr a1} in
definedDomainsCount'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
getDomainInfo :: Domain -> IO DomainInfo
getDomainInfo dptr = do
allocaBytes 24 $ \iptr -> do
i <- virDomainGetInfo (domainToPtr dptr) iptr
state <- (\ptr -> do {peekByteOff ptr 0 ::IO CUChar}) iptr
maxmem <- (\ptr -> do {peekByteOff ptr 4 ::IO CULong}) iptr
memory <- (\ptr -> do {peekByteOff ptr 8 ::IO CULong}) iptr
ncpus <- (\ptr -> do {peekByteOff ptr 12 ::IO CUShort}) iptr
cputime <- (\ptr -> do {peekByteOff ptr 16 ::IO CULLong}) iptr
return $ DomainInfo {
diState = cuchar2state state,
diMaxMem = fromIntegral maxmem,
diMemory = fromIntegral memory,
diNrVirtCPU = fromIntegral ncpus,
diCPUTime = fromIntegral cputime }
defineDomainXML :: Connection -> String -> IO (Domain)
defineDomainXML a1 a2 =
let {a1' = connectionToPtr a1} in
withCString a2 $ \a2' ->
defineDomainXML'_ a1' a2' >>= \res ->
ptrToDomain res >>= \res' ->
return (res')
undefineDomain :: Domain -> IO (Int)
undefineDomain a1 =
let {a1' = domainToPtr a1} in
undefineDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
createDomain :: Domain -> IO (Int)
createDomain a1 =
let {a1' = domainToPtr a1} in
createDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
createDomainXML :: Connection -> String -> [DomainCreateFlags] -> IO (Domain)
createDomainXML a1 a2 a3 =
let {a1' = connectionToPtr a1} in
withCString a2 $ \a2' ->
let {a3' = flags2int a3} in
createDomainXML'_ a1' a2' a3' >>= \res ->
ptrToDomain res >>= \res' ->
return (res')
getDomainXML :: Domain -> [DomainXMLFlags] -> IO (String)
getDomainXML a1 a2 =
let {a1' = domainToPtr a1} in
let {a2' = flags2int a2} in
getDomainXML'_ a1' a2' >>= \res ->
peekCString res >>= \res' ->
return (res')
shutdownDomain :: Domain -> IO (Int)
shutdownDomain a1 =
let {a1' = domainToPtr a1} in
shutdownDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
rebootDomain :: Domain -> CUInt -> IO (Int)
rebootDomain a1 a2 =
let {a1' = domainToPtr a1} in
let {a2' = id a2} in
rebootDomain'_ a1' a2' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
destroyDomain :: Domain -> IO (Int)
destroyDomain a1 =
let {a1' = domainToPtr a1} in
destroyDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
refDomain :: Domain -> IO (Int)
refDomain a1 =
let {a1' = domainToPtr a1} in
refDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
freeDomain :: Domain -> IO (Int)
freeDomain a1 =
let {a1' = domainToPtr a1} in
freeDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
suspendDomain :: Domain -> IO (Int)
suspendDomain a1 =
let {a1' = domainToPtr a1} in
suspendDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
resumeDomain :: Domain -> IO (Int)
resumeDomain a1 =
let {a1' = domainToPtr a1} in
resumeDomain'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
saveDomain :: Domain -> String -> IO (Int)
saveDomain a1 a2 =
let {a1' = domainToPtr a1} in
withCString a2 $ \a2' ->
saveDomain'_ a1' a2' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
restoreDomain :: Connection -> String -> IO (Int)
restoreDomain a1 a2 =
let {a1' = connectionToPtr a1} in
withCString a2 $ \a2' ->
restoreDomain'_ a1' a2' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
getNetworkConnection :: Network -> IO (Connection)
getNetworkConnection a1 =
let {a1' = networkToPtr a1} in
getNetworkConnection'_ a1' >>= \res ->
ptrToConnection res >>= \res' ->
return (res')
runningNetworksCount :: Connection -> IO (Int)
runningNetworksCount a1 =
let {a1' = connectionToPtr a1} in
runningNetworksCount'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
runningNetworksNames :: Connection -> IO [String]
runningNetworksNames conn = do
cn <- virConnectNumOfNetworks (connectionToPtr conn)
let n = fromIntegral cn
allocaArray n $ \nptr -> do
virConnectListNetworks (connectionToPtr conn) nptr cn
mapM peekCString =<< peekArray n nptr
definedNetworksCount :: Connection -> IO (Int)
definedNetworksCount a1 =
let {a1' = connectionToPtr a1} in
definedNetworksCount'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
definedNetworksNames :: Connection -> IO [String]
definedNetworksNames conn = do
cn <- virConnectNumOfDefinedNetworks (connectionToPtr conn)
let n = fromIntegral cn
allocaArray n $ \nptr -> do
virConnectListDefinedNetworks (connectionToPtr conn) nptr cn
mapM peekCString =<< peekArray n nptr
lookupNetworkName :: Connection -> String -> IO (Network)
lookupNetworkName a1 a2 =
let {a1' = connectionToPtr a1} in
withCString a2 $ \a2' ->
lookupNetworkName'_ a1' a2' >>= \res ->
ptrToNetwork res >>= \res' ->
return (res')
withCUString :: String -> (Ptr CUChar -> IO a) -> IO a
withCUString str fn = withCString str (fn . castPtr)
lookupNetworkUUID :: Connection -> String -> IO (Network)
lookupNetworkUUID a1 a2 =
let {a1' = connectionToPtr a1} in
withCUString a2 $ \a2' ->
lookupNetworkUUID'_ a1' a2' >>= \res ->
ptrToNetwork res >>= \res' ->
return (res')
createNetworkXML :: Connection -> String -> IO (Network)
createNetworkXML a1 a2 =
let {a1' = connectionToPtr a1} in
withCString a2 $ \a2' ->
createNetworkXML'_ a1' a2' >>= \res ->
ptrToNetwork res >>= \res' ->
return (res')
defineNetworkXML :: Connection -> String -> IO (Network)
defineNetworkXML a1 a2 =
let {a1' = connectionToPtr a1} in
withCString a2 $ \a2' ->
defineNetworkXML'_ a1' a2' >>= \res ->
ptrToNetwork res >>= \res' ->
return (res')
undefineNetwork :: Network -> IO (Int)
undefineNetwork a1 =
let {a1' = networkToPtr a1} in
undefineNetwork'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
createNetwork :: Network -> IO (Int)
createNetwork a1 =
let {a1' = networkToPtr a1} in
createNetwork'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
destroyNetwork :: Network -> IO (Int)
destroyNetwork a1 =
let {a1' = networkToPtr a1} in
destroyNetwork'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
refNetwork :: Network -> IO (Int)
refNetwork a1 =
let {a1' = networkToPtr a1} in
refNetwork'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
freeNetwork :: Network -> IO (Int)
freeNetwork a1 =
let {a1' = networkToPtr a1} in
freeNetwork'_ a1' >>= \res ->
exceptionOnMinusOne res >>= \res' ->
return (res')
getNetworkName :: Network -> IO (String)
getNetworkName a1 =
let {a1' = networkToPtr a1} in
getNetworkName'_ a1' >>= \res ->
peekCString res >>= \res' ->
return (res')
getNetworkXML :: Network -> [NetworkXMLFlags] -> IO (String)
getNetworkXML a1 a2 =
let {a1' = networkToPtr a1} in
let {a2' = flags2int a2} in
getNetworkXML'_ a1' a2' >>= \res ->
peekCString res >>= \res' ->
return (res')
foreign import ccall safe "System/LibVirt/Foreign.chs.h virInitialize"
initialize'_ :: (IO CInt)
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectOpen"
openConnection'_ :: ((Ptr CChar) -> (IO (Ptr ())))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectClose"
closeConnection'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfDomains"
runningDomainsCount'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfDomains"
virConnectNumOfDomains :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectListDomains"
virConnectListDomains :: ((Ptr ()) -> ((Ptr CInt) -> (CInt -> (IO CInt))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfDefinedDomains"
virConnectNumOfDefinedDomains :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectListDefinedDomains"
virConnectListDefinedDomains :: ((Ptr ()) -> ((Ptr (Ptr CChar)) -> (CInt -> (IO CInt))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainLookupByID"
lookupDomainID'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainGetID"
getDomainID'_ :: ((Ptr ()) -> (IO CUInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainGetName"
getDomainName'_ :: ((Ptr ()) -> (IO (Ptr CChar)))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainLookupByName"
lookupDomainName'_ :: ((Ptr ()) -> ((Ptr CChar) -> (IO (Ptr ()))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfDefinedDomains"
definedDomainsCount'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainGetInfo"
virDomainGetInfo :: ((Ptr ()) -> ((DomainInfoPtr) -> (IO CInt)))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainDefineXML"
defineDomainXML'_ :: ((Ptr ()) -> ((Ptr CChar) -> (IO (Ptr ()))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainUndefine"
undefineDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainCreate"
createDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainCreateXML"
createDomainXML'_ :: ((Ptr ()) -> ((Ptr CChar) -> (CUInt -> (IO (Ptr ())))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainGetXMLDesc"
getDomainXML'_ :: ((Ptr ()) -> (CUInt -> (IO (Ptr CChar))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainShutdown"
shutdownDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainReboot"
rebootDomain'_ :: ((Ptr ()) -> (CUInt -> (IO CInt)))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainDestroy"
destroyDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainRef"
refDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainFree"
freeDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainSuspend"
suspendDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainResume"
resumeDomain'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainSave"
saveDomain'_ :: ((Ptr ()) -> ((Ptr CChar) -> (IO CInt)))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virDomainRestore"
restoreDomain'_ :: ((Ptr ()) -> ((Ptr CChar) -> (IO CInt)))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkGetConnect"
getNetworkConnection'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfNetworks"
runningNetworksCount'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfNetworks"
virConnectNumOfNetworks :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectListNetworks"
virConnectListNetworks :: ((Ptr ()) -> ((Ptr (Ptr CChar)) -> (CInt -> (IO CInt))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfDefinedNetworks"
definedNetworksCount'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectNumOfDefinedNetworks"
virConnectNumOfDefinedNetworks :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virConnectListDefinedNetworks"
virConnectListDefinedNetworks :: ((Ptr ()) -> ((Ptr (Ptr CChar)) -> (CInt -> (IO CInt))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkLookupByName"
lookupNetworkName'_ :: ((Ptr ()) -> ((Ptr CChar) -> (IO (Ptr ()))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkLookupByUUID"
lookupNetworkUUID'_ :: ((Ptr ()) -> ((Ptr CUChar) -> (IO (Ptr ()))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkCreateXML"
createNetworkXML'_ :: ((Ptr ()) -> ((Ptr CChar) -> (IO (Ptr ()))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkDefineXML"
defineNetworkXML'_ :: ((Ptr ()) -> ((Ptr CChar) -> (IO (Ptr ()))))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkUndefine"
undefineNetwork'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkCreate"
createNetwork'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkDestroy"
destroyNetwork'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkRef"
refNetwork'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkFree"
freeNetwork'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkGetName"
getNetworkName'_ :: ((Ptr ()) -> (IO (Ptr CChar)))
foreign import ccall safe "System/LibVirt/Foreign.chs.h virNetworkGetXMLDesc"
getNetworkXML'_ :: ((Ptr ()) -> (CUInt -> (IO (Ptr CChar))))