Foreign.hs

-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "System/LibVirt/Foreign.chs" #-}{-# LANGUAGE ForeignFunctionInterface, StandaloneDeriving, DeriveDataTypeable, EmptyDataDecls #-}


{-# LINE 3 "System/LibVirt/Foreign.chs" #-}


module System.LibVirt.Foreign
  (-- * Types
   Connection, Domain, Network,
   DomainID,
   DomainInfo (..),
   DomainState (..),
   Stream,
   DomainCreateFlags (..),
   DomainXMLFlags (..),
   SecurityLabel (..),
   SecurityModel (..),
   NodeInfo (..),
   SchedParameterType (..),
   ConnectCredential (..),

   -- * Connection management functions
   initialize,
   openConnection, closeConnection,

   -- * Domains management functions
   runningDomainsCount, definedDomainsCount,
   runningDomainsIDs, definedDomainsNames,
   lookupDomainID, lookupDomainName,
   getDomainInfo, getDomainXML,
   defineDomainXML, undefineDomain,

   -- * Domains control
   createDomain, createDomainXML,
   destroyDomain, 
   shutdownDomain, rebootDomain,
   suspendDomain, resumeDomain,
   saveDomain, restoreDomain,
   refDomain, freeDomain,

   -- * Networks management
   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
{-# LINE 60 "System/LibVirt/Foreign.chs" #-}
import System.LibVirt.Errors
{-# LINE 61 "System/LibVirt/Foreign.chs" #-}

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)
{-# LINE 79 "System/LibVirt/Foreign.chs" #-}

data DomainState = DomainNostate
                 | DomainRunning
                 | DomainBlocked
                 | DomainPaused
                 | DomainShutdown
                 | DomainShutoff
                 | DomainCrashed
                 | DomainLast
                 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 DomainLast = 7

  toEnum 0 = DomainNostate
  toEnum 1 = DomainRunning
  toEnum 2 = DomainBlocked
  toEnum 3 = DomainPaused
  toEnum 4 = DomainShutdown
  toEnum 5 = DomainShutoff
  toEnum 6 = DomainCrashed
  toEnum 7 = DomainLast
  toEnum unmatched = error ("DomainState.toEnum: Cannot match " ++ show unmatched)

{-# LINE 81 "System/LibVirt/Foreign.chs" #-}
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)

{-# LINE 82 "System/LibVirt/Foreign.chs" #-}
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)

{-# LINE 83 "System/LibVirt/Foreign.chs" #-}

data NetworkXMLFlags = NetworkXML
  deriving (Eq, Show, Enum)

newtype Stream = Stream (Ptr (Stream))
{-# LINE 88 "System/LibVirt/Foreign.chs" #-}

data SecurityLabel = SecurityLabel {
  slLabel :: String,
  slEnforcing :: Int }
  deriving (Eq, Show)

type SecurityLabelPtr = Ptr (SecurityLabel)
{-# LINE 95 "System/LibVirt/Foreign.chs" #-}

data SecurityModel = SecurityModel {
  smModel :: String,
  smDOI :: String }
  deriving (Eq, Show)

type SecurityModelPtr = Ptr (SecurityModel)
{-# LINE 102 "System/LibVirt/Foreign.chs" #-}

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)
{-# LINE 115 "System/LibVirt/Foreign.chs" #-}

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)

{-# LINE 117 "System/LibVirt/Foreign.chs" #-}

data ConnectCredential = ConnectCredential {
  ccType :: Int,
  ccPrompt :: String,
  ccChallenge :: String,
  ccDefresult :: String,
  ccResult :: String,
  ccResultLen :: Integer }
  deriving (Eq, Show)

type ConnectCredentialPtr = Ptr (ConnectCredential)
{-# LINE 128 "System/LibVirt/Foreign.chs" #-}

initialize :: IO (Int)
initialize =
  initialize'_ >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 130 "System/LibVirt/Foreign.chs" #-}

openConnection :: String -> IO (Connection)
openConnection a1 =
  withCString a1 $ \a1' -> 
  openConnection'_ a1' >>= \res ->
  ptrToConnection res >>= \res' ->
  return (res')
{-# LINE 133 "System/LibVirt/Foreign.chs" #-}

closeConnection :: Connection -> IO (Int)
closeConnection a1 =
  let {a1' = connectionToPtr a1} in 
  closeConnection'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 136 "System/LibVirt/Foreign.chs" #-}

runningDomainsCount :: Connection -> IO (Int)
runningDomainsCount a1 =
  let {a1' = connectionToPtr a1} in 
  runningDomainsCount'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 139 "System/LibVirt/Foreign.chs" #-}

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
{-# LINE 148 "System/LibVirt/Foreign.chs" #-}
                  (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
{-# LINE 158 "System/LibVirt/Foreign.chs" #-}
        (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')
{-# LINE 164 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 168 "System/LibVirt/Foreign.chs" #-}

definedDomainsCount :: Connection -> IO (Int)
definedDomainsCount a1 =
  let {a1' = connectionToPtr a1} in 
  definedDomainsCount'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 171 "System/LibVirt/Foreign.chs" #-}

getDomainInfo :: Domain -> IO DomainInfo
getDomainInfo dptr = do
  allocaBytes 40 $ \iptr -> do
         i <- virDomainGetInfo (domainToPtr dptr) iptr
         state   <- (\ptr -> do {peekByteOff ptr 0 ::IO CUChar})     iptr
         maxmem  <- (\ptr -> do {peekByteOff ptr 8 ::IO CULong})    iptr
         memory  <- (\ptr -> do {peekByteOff ptr 16 ::IO CULong})    iptr
         ncpus   <- (\ptr -> do {peekByteOff ptr 24 ::IO CUShort}) iptr
         cputime <- (\ptr -> do {peekByteOff ptr 32 ::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')
{-# LINE 191 "System/LibVirt/Foreign.chs" #-}

undefineDomain :: Domain -> IO (Int)
undefineDomain a1 =
  let {a1' = domainToPtr a1} in 
  undefineDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 194 "System/LibVirt/Foreign.chs" #-}

createDomain :: Domain -> IO (Int)
createDomain a1 =
  let {a1' = domainToPtr a1} in 
  createDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 197 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 202 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 206 "System/LibVirt/Foreign.chs" #-}

shutdownDomain :: Domain -> IO (Int)
shutdownDomain a1 =
  let {a1' = domainToPtr a1} in 
  shutdownDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 209 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 213 "System/LibVirt/Foreign.chs" #-}

destroyDomain :: Domain -> IO (Int)
destroyDomain a1 =
  let {a1' = domainToPtr a1} in 
  destroyDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 216 "System/LibVirt/Foreign.chs" #-}

refDomain :: Domain -> IO (Int)
refDomain a1 =
  let {a1' = domainToPtr a1} in 
  refDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 219 "System/LibVirt/Foreign.chs" #-}

freeDomain :: Domain -> IO (Int)
freeDomain a1 =
  let {a1' = domainToPtr a1} in 
  freeDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 222 "System/LibVirt/Foreign.chs" #-}

suspendDomain :: Domain -> IO (Int)
suspendDomain a1 =
  let {a1' = domainToPtr a1} in 
  suspendDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 225 "System/LibVirt/Foreign.chs" #-}

resumeDomain :: Domain -> IO (Int)
resumeDomain a1 =
  let {a1' = domainToPtr a1} in 
  resumeDomain'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 228 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 232 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 236 "System/LibVirt/Foreign.chs" #-}

getNetworkConnection :: Network -> IO (Connection)
getNetworkConnection a1 =
  let {a1' = networkToPtr a1} in 
  getNetworkConnection'_ a1' >>= \res ->
  ptrToConnection res >>= \res' ->
  return (res')
{-# LINE 239 "System/LibVirt/Foreign.chs" #-}

runningNetworksCount :: Connection -> IO (Int)
runningNetworksCount a1 =
  let {a1' = connectionToPtr a1} in 
  runningNetworksCount'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 242 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 253 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 264 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 270 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 273 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 276 "System/LibVirt/Foreign.chs" #-}

undefineNetwork :: Network -> IO (Int)
undefineNetwork a1 =
  let {a1' = networkToPtr a1} in 
  undefineNetwork'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 279 "System/LibVirt/Foreign.chs" #-}

createNetwork :: Network -> IO (Int)
createNetwork a1 =
  let {a1' = networkToPtr a1} in 
  createNetwork'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 282 "System/LibVirt/Foreign.chs" #-}

destroyNetwork :: Network -> IO (Int)
destroyNetwork a1 =
  let {a1' = networkToPtr a1} in 
  destroyNetwork'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 285 "System/LibVirt/Foreign.chs" #-}

refNetwork :: Network -> IO (Int)
refNetwork a1 =
  let {a1' = networkToPtr a1} in 
  refNetwork'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 288 "System/LibVirt/Foreign.chs" #-}

freeNetwork :: Network -> IO (Int)
freeNetwork a1 =
  let {a1' = networkToPtr a1} in 
  freeNetwork'_ a1' >>= \res ->
  exceptionOnMinusOne res >>= \res' ->
  return (res')
{-# LINE 291 "System/LibVirt/Foreign.chs" #-}

getNetworkName :: Network -> IO (String)
getNetworkName a1 =
  let {a1' = networkToPtr a1} in 
  getNetworkName'_ a1' >>= \res ->
  peekCString res >>= \res' ->
  return (res')
{-# LINE 294 "System/LibVirt/Foreign.chs" #-}

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')
{-# LINE 298 "System/LibVirt/Foreign.chs" #-}


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 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))))